Add better handling of values with decimal64 schema type

Author: karimra

pkg/datastore/data_rpc.go

@@ -781,11 +781,22 @@ func validateLeafTypeValue(lt *sdcpb.SchemaLeafType, v any) error {
 			return fmt.Errorf("value %q does not match identityRef type %q, must be one of [%s]", v, lt.TypeName, strings.Join(lt.Values, ", "))
 		}
 		return nil
+	case "decimal64":
+		switch v := v.(type) {
+		case float64: // if it's a float64 then it's a valid decimal64
+		case string:
+			if c := strings.Count(v, "."); c == 0 || c > 1 {
+				return fmt.Errorf("value %q is not a valid Decimal64", v)
+			}
+		default:
+			return fmt.Errorf("unexpected type for a Decimal64 value %q: %T", v, v)
+		}
+		return nil
 	case "leafref":
 		// TODO: does this need extra validation?
 		return nil
 	default:
-		return fmt.Errorf("unhandled type %v", lt.GetType())
+		return fmt.Errorf("unhandled type %v for value %q", lt.GetType(), v)
 	}
 }
 
@@ -1391,6 +1402,16 @@ func convertTypedValueToYANGType(schemaElem *sdcpb.SchemaElem, tv *sdcpb.TypedVa
 				return nil, err
 			}
 			return &sdcpb.TypedValue{Value: &sdcpb.TypedValue_BoolVal{BoolVal: v}}, nil
+		case "decimal64":
+			d64, err := utils.ParseDecimal64(utils.TypedValueToString(tv))
+			if err != nil {
+				return nil, err
+			}
+			return &sdcpb.TypedValue{
+				Value: &sdcpb.TypedValue_DecimalVal{
+					DecimalVal: d64,
+				},
+			}, nil
 		case "float":
 			v, err := strconv.ParseFloat(utils.TypedValueToString(tv), 32)
 			if err != nil {

pkg/datastore/target/netconf/conversion/leaf_convert.go

@@ -20,6 +20,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/sdcio/data-server/pkg/utils"
 	sdcpb "github.com/sdcio/sdc-protos/sdcpb"
 	log "github.com/sirupsen/logrus"
 )
@@ -71,6 +72,8 @@ func Convert(value string, lst *sdcpb.SchemaLeafType) (*sdcpb.TypedValue, error)
 		return ConvertIdentityRef(value, lst)
 	case "instance-identifier": //TODO: https://www.rfc-editor.org/rfc/rfc6020.html#section-9.13
 		return ConvertInstanceIdentifier(value, lst)
+	case "decimal64":
+		return ConvertDecimal64(value, lst)
 	}
 	log.Warnf("type %q not implemented", lst.Type)
 	return ConvertString(value, lst)
@@ -280,6 +283,19 @@ func ConvertString(value string, lst *sdcpb.SchemaLeafType) (*sdcpb.TypedValue,
 
 }
 
+func ConvertDecimal64(value string, lst *sdcpb.SchemaLeafType) (*sdcpb.TypedValue, error) {
+	d64, err := utils.ParseDecimal64(value)
+	if err != nil {
+		return nil, err
+	}
+
+	return &sdcpb.TypedValue{
+		Value: &sdcpb.TypedValue_DecimalVal{
+			DecimalVal: d64,
+		},
+	}, nil
+}
+
 func ConvertUnion(value string, slts []*sdcpb.SchemaLeafType) (*sdcpb.TypedValue, error) {
 	// iterate over the union types try to convert without error
 	for _, slt := range slts {

pkg/utils/value.go

@@ -85,12 +85,12 @@ func GetSchemaValue(updValue *sdcpb.TypedValue) (interface{}, error) {
 		value = updValue.GetBoolVal()
 	case *sdcpb.TypedValue_BytesVal:
 		value = updValue.GetBytesVal()
-	// case *sdcpb.TypedValue_DecimalVal:
-	// 	value = updValue.GetDecimalVal()
+	case *sdcpb.TypedValue_DecimalVal:
+		value = updValue.GetDecimalVal()
 	case *sdcpb.TypedValue_FloatVal:
 		value = updValue.GetFloatVal()
-	// case *sdcpb.TypedValue_DoubleVal:
-	// 	value = updValue.GetDoubleVal()
+	case *sdcpb.TypedValue_DoubleVal:
+		value = updValue.GetDoubleVal()
 	case *sdcpb.TypedValue_IntVal:
 		value = updValue.GetIntVal()
 	case *sdcpb.TypedValue_StringVal:
@@ -536,3 +536,34 @@ func TypedValueToString(tv *sdcpb.TypedValue) string {
 	}
 	return ""
 }
+
+func ParseDecimal64(v string) (*sdcpb.Decimal64, error) {
+	// Remove any leading or trailing spaces.
+	trimmed := strings.TrimSpace(v)
+
+	// Split the string into integer and fractional parts.
+	parts := strings.SplitN(trimmed, ".", 2)
+	intPart := parts[0]
+	var fracPart string
+	if len(parts) > 1 {
+		fracPart = parts[1]
+	}
+
+	// Combine integer and fractional parts into one number.
+	combined := intPart + fracPart
+
+	// Parse combined parts into a uint64.
+	digits, err := strconv.ParseInt(combined, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	// Calculate precision as the length of the fractional part.
+	precision := uint32(len(fracPart))
+
+	// Return the Decimal64 representation.
+	return &sdcpb.Decimal64{
+		Digits:    digits,
+		Precision: precision,
+	}, nil
+}