Add struct handling

Author: henrmota

request.go

@@ -247,15 +247,27 @@ func unmarshalNode(data *Node, model reflect.Value, included *map[string]*Node)
 			}
 
 			structField := fieldType
-			value, err := unmarshalAttribute(attribute, args, structField, fieldValue)
-			if err != nil {
-				er = err
-				break
-			}
 
-			assign(fieldValue, value)
-			continue
+			if structField.Type.Kind() != reflect.Struct ||
+				fieldValue.Type() == reflect.TypeOf(new(time.Time)) ||
+				fieldValue.Type() == reflect.TypeOf(time.Time{})  {
+				value, err := unmarshalAttribute(attribute, args, structField, fieldValue)
+				if err != nil {
+					er = err
+					break
+				}
+				assign(fieldValue, value)
+				continue
 
+			} else {
+				structModel, err := unmarshalFromAttribute(attribute, fieldValue)
+				if err != nil {
+					er = err
+					break
+				}
+				fieldValue.Set((*structModel).Elem())
+				continue
+			}
 		} else if annotation == annotationRelation {
 			isSlice := fieldValue.Type().Kind() == reflect.Slice
 
@@ -334,6 +346,23 @@ func unmarshalNode(data *Node, model reflect.Value, included *map[string]*Node)
 	return er
 }
 
+func unmarshalFromAttribute(attribute interface{}, fieldValue reflect.Value) (*reflect.Value, error) {
+	structData, err := json.Marshal(attribute)
+	if err != nil {
+		return nil, err
+	}
+	structNode := new(Node)
+	if err := json.Unmarshal(structData, &structNode.Attributes); err != nil {
+		return nil, err
+	}
+	structModel := reflect.New(fieldValue.Type())
+	if err := unmarshalNode(structNode, structModel, nil); err != nil {
+		return nil, err
+	}
+
+	return &structModel, nil
+}
+
 func fullNode(n *Node, included *map[string]*Node) *Node {
 	includedKey := fmt.Sprintf("%s,%s", n.Type, n.ID)
 
@@ -347,7 +376,7 @@ func fullNode(n *Node, included *map[string]*Node) *Node {
 // assign will take the value specified and assign it to the field; if
 // field is expecting a ptr assign will assign a ptr.
 func assign(field, value reflect.Value) {
-	if field.Kind() == reflect.Ptr {
+	if field.Kind() == reflect.Ptr || field.Kind() == reflect.Struct{
 		field.Set(value)
 	} else {
 		field.Set(reflect.Indirect(value))
@@ -362,6 +391,7 @@ func unmarshalAttribute(
 	value = reflect.ValueOf(attribute)
 	fieldType := structField.Type
 
+
 	// Handle field of type []string
 	if fieldValue.Type() == reflect.TypeOf([]string{}) {
 		value, err = handleStringSlice(attribute)
@@ -566,7 +596,6 @@ func handlePointer(
 func handleStruct(
 	attribute interface{},
 	fieldValue reflect.Value) (reflect.Value, error) {
-
 	data, err := json.Marshal(attribute)
 	if err != nil {
 		return reflect.Value{}, err

response.go

@@ -207,7 +207,13 @@ func visitModelNode(model interface{}, included *map[string]*Node,
 	node := new(Node)
 
 	var er error
-	value := reflect.ValueOf(model)
+	var value reflect.Value
+	if modelValue, ok := model.(reflect.Value); ok {
+		value = modelValue.Addr()
+	} else {
+		value = reflect.ValueOf(model)
+	}
+
 	if value.IsNil() {
 		return nil, nil
 	}
@@ -340,6 +346,28 @@ func visitModelNode(model interface{}, included *map[string]*Node,
 						node.Attributes[args[1]] = tm.Unix()
 					}
 				}
+			} else if fieldValue.Kind() == reflect.Slice && fieldValue.Type().Elem().Kind() == reflect.Struct {
+				newSlice := make([]map[string]interface{}, fieldValue.Len())
+				for i:=0; i < fieldValue.Len(); i++ {
+					included := make(map[string]*Node)
+					nested, err := visitModelNode(fieldValue.Index(i), &included, true)
+					if err != nil {
+						er = err
+						break
+					}
+
+					newSlice[i] = nested.Attributes
+				}
+				node.Attributes[args[1]] = newSlice
+			} else if fieldValue.Kind() == reflect.Struct {
+				included := make(map[string]*Node)
+				nested, err := visitModelNode(fieldValue, &included, true)
+				if err != nil {
+					er = err
+					break
+				}
+
+				node.Attributes[args[1]] = nested.Attributes
 			} else {
 				// Dealing with a fieldValue that is not a time
 				emptyValue := reflect.Zero(fieldValue.Type())