save.go

// Copyright (c) 2020 MindStand Technologies, Inc
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package gogm

import (
	"errors"
	"fmt"
	dsl "github.com/mindstand/go-cypherdsl"
	"github.com/neo4j/neo4j-go-driver/v4/neo4j"
	"reflect"
)

// maximum supported depth
const maxSaveDepth = 10
const defaultSaveDepth = 1

// neoRunFunc typedefs function signature from neo4j driver
type neoRunFunc func(cypher string, params map[string]interface{}) (neo4j.Result, error)

// runWrap is used to wrap the session run function into a consistent function signature
func runWrap(sess neo4j.Session) neoRunFunc {
	return func(cypher string, params map[string]interface{}) (neo4j.Result, error) {
		if sess == nil {
			return nil, fmt.Errorf("session can not be nil, %w", ErrInternal)
		}
		return sess.Run(cypher, params)
	}
}

// nodeCreateConf holds configuration for creating new nodes
type nodeCreateConf struct {
	// params to save
	Params map[string]interface{}
	// type to save by
	Type reflect.Type
	// whether the node is new or not
	IsNew bool
}

// relCreateConf holds configuration for nodes to link together
type relCreateConf struct {
	// start uuid of relationship
	StartNodeUUID string
	// end uuid of relationship
	EndNodeUUID string
	// any data to store in edge
	Params map[string]interface{}
	// holds direction of the edge
	Direction dsl.Direction
}

// saves target node and connected node to specified depth
func saveDepth(runFunc neoRunFunc, obj interface{}, depth int) error {
	if runFunc == nil {
		return errors.New("session can not be nil")
	}

	if obj == nil {
		return errors.New("obj can not be nil")
	}

	if depth < 0 {
		return errors.New("cannot save a depth less than 0")
	}

	if depth > maxSaveDepth {
		return fmt.Errorf("saving depth of (%v) is currently not supported, maximum depth is (%v), %w", depth, maxSaveDepth, ErrConfiguration)
	}

	//validate that obj is a pointer
	rawType := reflect.TypeOf(obj)

	if rawType.Kind() != reflect.Ptr {
		return fmt.Errorf("obj must be of type pointer, not %T", obj)
	}

	//validate that the dereference type is a struct
	derefType := rawType.Elem()

	if derefType.Kind() != reflect.Struct {
		return fmt.Errorf("dereference type can not be of type %T", obj)
	}

	//signature is [LABEL][UUID]{config}
	nodes := map[string]map[string]nodeCreateConf{}

	//signature is [LABEL] []{config}
	relations := map[string][]relCreateConf{}

	// node id -- [field] config
	oldRels := map[string]map[string]*RelationConfig{}
	curRels := map[string]map[string]*RelationConfig{}

	// uuid -> reflect value
	nodeRef := map[string]*reflect.Value{}

	newNodes := []*string{}
	visited := []string{}

	rootVal := reflect.ValueOf(obj)

	err := parseStruct("", "", false, dsl.DirectionBoth, nil, &rootVal, 0, depth, &nodes, &relations, &oldRels, &newNodes, &nodeRef, &visited)
	if err != nil {
		return err
	}

	ids, err := createNodes(runFunc, nodes, &nodeRef)
	if err != nil {
		return err
	}

	err = generateCurRels("", &rootVal, 0, depth, &curRels)
	if err != nil {
		return err
	}

	dels := calculateDels(oldRels, curRels)

	//fix the cur rels and write them to their perspective nodes
	for uuid, val := range nodeRef {
		loadConf, ok := (curRels)[uuid]
		if !ok {
			return fmt.Errorf("load config not found for node [%s]", uuid)
		}

		//handle if its a pointer
		if val.Kind() == reflect.Ptr {
			*val = val.Elem()
		}

		reflect.Indirect(*val).FieldByName("LoadMap").Set(reflect.ValueOf(loadConf))
	}

	//execute concurrently
	//calculate dels

	if len(dels) != 0 {
		err := removeRelations(runFunc, dels)
		if err != nil {
			return err
		}
	}

	if len(relations) != 0 {
		err := relateNodes(runFunc, relations, ids)
		if err != nil {
			return err
		}
	}

	return nil
}

// calculates which relationships to delete
func calculateDels(oldRels, curRels map[string]map[string]*RelationConfig) map[string][]int64 {
	if len(oldRels) == 0 {
		return map[string][]int64{}
	}

	dels := map[string][]int64{}

	for uuid, oldRelConf := range oldRels {
		curRelConf, ok := curRels[uuid]
		deleteAllRels := false
		if !ok {
			//this means that the node is gone, remove all rels to this node
			deleteAllRels = true
		} else {
			for field, oldConf := range oldRelConf {
				curConf, ok := curRelConf[field]
				deleteAllRelsOnField := false
				if !ok {
					//this means that either the field has been removed or there are no more rels on this field,
					//either way delete anything left over
					deleteAllRelsOnField = true
				}
				for _, id := range oldConf.Ids {
					//check if this id is new rels in the same location
					if deleteAllRels || deleteAllRelsOnField {
						if _, ok := dels[uuid]; !ok {
							dels[uuid] = []int64{id}
						} else {
							dels[uuid] = append(dels[uuid], id)
						}
					} else {
						if !int64SliceContains(curConf.Ids, id) {
							if _, ok := dels[uuid]; !ok {
								dels[uuid] = []int64{id}
							} else {
								dels[uuid] = append(dels[uuid], id)
							}
						}
					}
				}
			}
		}
	}

	return dels
}

// removes relationships between specified nodes
func removeRelations(runFunc neoRunFunc, dels map[string][]int64) error {
	if dels == nil || len(dels) == 0 {
		return nil
	}

	if runFunc == nil {
		return fmt.Errorf("runFunc can not be nil, %w", ErrInternal)
	}

	var params []interface{}

	for uuid, ids := range dels {
		params = append(params, map[string]interface{}{
			"startNodeId": uuid,
			"endNodeIds":  ids,
		})
	}

	startParams, err := dsl.ParamsFromMap(map[string]interface{}{
		"uuid": dsl.ParamString("row.startNodeId"),
	})
	if err != nil {
		return fmt.Errorf("%s, %w", err.Error(), ErrInternal)
	}

	cyq, err := dsl.QB().
		Cypher("UNWIND $rows as row").
		Match(dsl.Path().
			V(dsl.V{
				Name:   "start",
				Params: startParams,
			}).E(dsl.E{
			Name: "e",
		}).V(dsl.V{
			Name: "end",
		}).Build()).
		Cypher("WHERE id(end) IN row.endNodeIds").
		Delete(false, "e").
		ToCypher()
	if err != nil {
		return err
	}

	res, err := runFunc(cyq, map[string]interface{}{
		"rows": params,
	})
	if err != nil {
		return fmt.Errorf("%s: %w", err.Error(), ErrInternal)
	} else if err = res.Err(); err != nil {
		return fmt.Errorf("%s: %w", err.Error(), ErrInternal)
	}
	//todo sanity check to make sure the affects worked

	return nil
}

// creates nodes
func createNodes(runFunc neoRunFunc, crNodes map[string]map[string]nodeCreateConf, nodeRef *map[string]*reflect.Value) (map[string]int64, error) {
	idMap := map[string]int64{}

	for label, nodes := range crNodes {
		var rows []interface{}
		for _, config := range nodes {
			rows = append(rows, config.Params)
		}

		params, err := dsl.ParamsFromMap(
			map[string]interface{}{
				"uuid": dsl.ParamString("row.uuid"),
			})
		if err != nil {
			return nil, err
		}

		path, err := dsl.Path().V(dsl.V{
			Name:   "n",
			Type:   "`" + label + "`",
			Params: params,
		}).ToCypher()
		if err != nil {
			return nil, err
		}

		//todo replace once unwind is fixed and path
		cyp, err := dsl.QB().
			Cypher("UNWIND $rows as row").
			Merge(&dsl.MergeConfig{
				Path: path,
			}).
			Cypher("SET n += row").
			Return(false, dsl.ReturnPart{
				Name:  "row.uuid",
				Alias: "uuid",
			}, dsl.ReturnPart{
				Function: &dsl.FunctionConfig{
					Name:   "ID",
					Params: []interface{}{dsl.ParamString("n")},
				},
				Alias: "id",
			}).
			ToCypher()

		res, err := runFunc(cyp, map[string]interface{}{
			"rows": rows,
		})
		if err != nil {
			return nil, err
		} else if res.Err() != nil {
			return nil, res.Err()
		}

		for res.Next() {
			row := res.Record().Values
			if len(row) != 2 {
				continue
			}

			uuid, ok := row[0].(string)
			if !ok {
				return nil, fmt.Errorf("cannot cast row[0] to string, %w", ErrInternal)
			}

			graphId, ok := row[1].(int64)
			if !ok {
				return nil, fmt.Errorf("cannot cast row[1] to int64, %w", ErrInternal)
			}

			idMap[uuid] = graphId
			//set the new id
			val, ok := (*nodeRef)[uuid]
			if !ok {
				return nil, fmt.Errorf("cannot find val for uuid [%s]", uuid)
			}

			reflect.Indirect(*val).FieldByName("Id").Set(reflect.ValueOf(graphId))
		}
	}

	return idMap, nil
}

// relateNodes connects nodes together using edge config
func relateNodes(runFunc neoRunFunc, relations map[string][]relCreateConf, ids map[string]int64) error {
	if relations == nil || len(relations) == 0 {
		return errors.New("relations can not be nil or empty")
	}

	if ids == nil || len(ids) == 0 {
		return errors.New("ids can not be nil or empty")
	}

	for label, rels := range relations {
		var params []interface{}

		if len(rels) == 0 {
			continue
		}

		for _, rel := range rels {
			startId, ok := ids[rel.StartNodeUUID]
			if !ok {
				return fmt.Errorf("can not find nodeId for uuid %s", rel.StartNodeUUID)
			}

			endId, ok := ids[rel.EndNodeUUID]
			if !ok {
				return fmt.Errorf("can not find nodeId for %T", rel)
			}

			//set map if its empty
			if rel.Params == nil {
				rel.Params = map[string]interface{}{}
			}

			params = append(params, map[string]interface{}{
				"startNodeId": startId,
				"endNodeId":   endId,
				"props":       rel.Params,
			})
		}

		mergePath, err := dsl.Path().
			V(dsl.V{
				Name: "startNode",
			}).
			E(dsl.E{
				Name: "rel",
				Types: []string{
					label,
				},
				Direction: dsl.DirectionOutgoing,
			}).
			V(dsl.V{
				Name: "endNode",
			}).
			ToCypher()
		if err != nil {
			return err
		}

		cyp, err := dsl.QB().
			Cypher("UNWIND $rows as row").
			Match(dsl.Path().V(dsl.V{Name: "startNode"}).Build()).
			Where(dsl.C(&dsl.ConditionConfig{
				FieldManipulationFunction: "ID",
				Name:                      "startNode",
				ConditionOperator:         dsl.EqualToOperator,
				Check:                     dsl.ParamString("row.startNodeId"),
			})).
			With(&dsl.WithConfig{
				Parts: []dsl.WithPart{
					{
						Name: "row",
					},
					{
						Name: "startNode",
					},
				},
			}).
			Match(dsl.Path().V(dsl.V{Name: "endNode"}).Build()).
			Where(dsl.C(&dsl.ConditionConfig{
				FieldManipulationFunction: "ID",
				Name:                      "endNode",
				ConditionOperator:         dsl.EqualToOperator,
				Check:                     dsl.ParamString("row.endNodeId"),
			})).
			Merge(&dsl.MergeConfig{
				Path: mergePath,
			}).
			Cypher("SET rel += row.props").
			ToCypher()

		res, err := runFunc(cyp, map[string]interface{}{
			"rows": params,
		})
		if err != nil {
			return err
		} else if err = res.Err(); err != nil {
			return err
		}
	}

	return nil
}

// validates data used by parse struct
func parseValidate(currentDepth, maxDepth int, current *reflect.Value, nodesPtr *map[string]map[string]nodeCreateConf, relationsPtr *map[string][]relCreateConf) error {
	if currentDepth > maxDepth {
		return nil
	}

	if nodesPtr == nil || relationsPtr == nil {
		return errors.New("nodesPtr and/or relationsPtr can not be nil")
	}

	if current == nil {
		return errors.New("current should never be nil")
	}

	return nil
}

// generates load map for updated structs
func generateCurRels(parentId string, current *reflect.Value, currentDepth, maxDepth int, curRels *map[string]map[string]*RelationConfig) error {
	if currentDepth > maxDepth {
		return nil
	}

	uuid := reflect.Indirect(*current).FieldByName("UUID").String()
	if uuid == "" {
		return errors.New("uuid not set")
	}

	if _, ok := (*curRels)[uuid]; ok {
		//this node has already been seen
		return nil
	} else {
		//create the record for it
		(*curRels)[uuid] = map[string]*RelationConfig{}
	}

	//get the type
	tString, err := getTypeName(current.Type())
	if err != nil {
		return err
	}

	//get the config
	actual, ok := mappedTypes.Get(tString)
	if !ok {
		return fmt.Errorf("struct config not found type (%s)", tString)
	}

	//cast the config
	currentConf, ok := actual.(structDecoratorConfig)
	if !ok {
		return errors.New("unable to cast into struct decorator config")
	}
	for _, conf := range currentConf.Fields {
		if conf.Relationship == "" {
			continue
		}

		relField := reflect.Indirect(*current).FieldByName(conf.FieldName)

		//if its nil, just skip it
		if relField.IsNil() {
			continue
		}

		if conf.ManyRelationship {
			slLen := relField.Len()
			if slLen == 0 {
				continue
			}

			for i := 0; i < slLen; i++ {
				relVal := relField.Index(i)

				newParentId, _, _, _, _, followVal, followId, _, err := processStruct(conf, &relVal, uuid, parentId)
				if err != nil {
					return err
				}

				//check the config is there for the specified field
				if _, ok = (*curRels)[uuid][conf.FieldName]; !ok {
					(*curRels)[uuid][conf.FieldName] = &RelationConfig{
						Ids:          []int64{},
						RelationType: Multi,
					}
				}

				(*curRels)[uuid][conf.FieldName].Ids = append((*curRels)[uuid][conf.FieldName].Ids, followId)

				err = generateCurRels(newParentId, followVal, currentDepth+1, maxDepth, curRels)
				if err != nil {
					return err
				}
			}
		} else {
			newParentId, _, _, _, _, followVal, followId, _, err := processStruct(conf, &relField, uuid, parentId)
			if err != nil {
				return err
			}

			//check the config is there for the specified field
			if _, ok = (*curRels)[uuid][conf.FieldName]; !ok {
				(*curRels)[uuid][conf.FieldName] = &RelationConfig{
					Ids:          []int64{},
					RelationType: Single,
				}
			}

			(*curRels)[uuid][conf.FieldName].Ids = append((*curRels)[uuid][conf.FieldName].Ids, followId)

			err = generateCurRels(newParentId, followVal, currentDepth+1, maxDepth, curRels)
			if err != nil {
				return err
			}

		}
	}

	return nil
}

// parses tree of structs
func parseStruct(parentId, edgeLabel string, parentIsStart bool, direction dsl.Direction, edgeParams map[string]interface{}, current *reflect.Value,
	currentDepth, maxDepth int, nodesPtr *map[string]map[string]nodeCreateConf, relationsPtr *map[string][]relCreateConf, oldRels *map[string]map[string]*RelationConfig,
	newNodes *[]*string, nodeRef *map[string]*reflect.Value, visited *[]string) error {
	//check if its done
	if currentDepth > maxDepth {
		return nil
	}

	log.Debugf("on cycle %v", currentDepth)

	//validate params
	err := parseValidate(currentDepth, maxDepth, current, nodesPtr, relationsPtr)
	if err != nil {
		return err
	}

	//get the type
	tString, err := getTypeName(current.Type())
	if err != nil {
		return err
	}

	//get the config
	actual, ok := mappedTypes.Get(tString)
	if !ok {
		return fmt.Errorf("struct config not found type (%s)", tString)
	}

	//cast the config
	currentConf, ok := actual.(structDecoratorConfig)
	if !ok {
		return errors.New("unable to cast into struct decorator config")
	}

	//set this to the actual field name later
	isNewNode, id, relConf, err := handleNodeState(current, "UUID")
	if err != nil {
		return err
	}

	//set edge
	if parentId != "" {
		if _, ok := (*relationsPtr)[edgeLabel]; !ok {
			(*relationsPtr)[edgeLabel] = []relCreateConf{}
		}

		start := ""
		end := ""
		curDir := direction

		if parentIsStart {
			start = parentId
			end = id
		} else {
			start = id
			end = parentId

			if curDir == dsl.DirectionIncoming {
				curDir = dsl.DirectionOutgoing
			} else if curDir == dsl.DirectionOutgoing {
				curDir = dsl.DirectionIncoming
			}
		}

		if edgeParams == nil {
			edgeParams = map[string]interface{}{}
		}

		found := false

		//check if this edge is already here
		if len((*relationsPtr)[edgeLabel]) != 0 {
			for _, conf := range (*relationsPtr)[edgeLabel] {
				if conf.StartNodeUUID == start && conf.EndNodeUUID == end {
					found = true
				}
			}
		}

		if !found {
			(*relationsPtr)[edgeLabel] = append((*relationsPtr)[edgeLabel], relCreateConf{
				Direction:     curDir,
				Params:        edgeParams,
				StartNodeUUID: start,
				EndNodeUUID:   end,
			})
		}

	}

	//check if this has been visited yet, do this after edge is intentional
	if stringSliceContains(*visited, id) {
		return nil
	} else {
		*visited = append(*visited, id)
	}

	if !isNewNode {
		if _, ok := (*oldRels)[id]; !ok {
			(*oldRels)[id] = relConf
		}
	} else {
		*newNodes = append(*newNodes, &id)
	}

	//set the reflect pointer so we can update the map later
	if _, ok := (*nodeRef)[id]; !ok {
		(*nodeRef)[id] = current
	}

	//convert params
	params, err := toCypherParamsMap(*current, currentConf)
	if err != nil {
		return err
	}

	//if its nil, just default it
	if params == nil {
		params = map[string]interface{}{}
	}

	//set the map
	if _, ok := (*nodesPtr)[currentConf.Label]; !ok {
		(*nodesPtr)[currentConf.Label] = map[string]nodeCreateConf{}
	}

	(*nodesPtr)[currentConf.Label][id] = nodeCreateConf{
		Type:   current.Type(),
		IsNew:  isNewNode,
		Params: params,
	}

	for _, conf := range currentConf.Fields {
		if conf.Relationship == "" {
			continue
		}

		relField := reflect.Indirect(*current).FieldByName(conf.FieldName)

		//if its nil, just skip it
		if relField.IsNil() {
			continue
		}

		if conf.ManyRelationship {
			slLen := relField.Len()
			if slLen == 0 {
				continue
			}

			for i := 0; i < slLen; i++ {
				relVal := relField.Index(i)

				newParentId, newEdgeLabel, newParentIdStart, newDirection, newEdgeParams, followVal, _, _, err := processStruct(conf, &relVal, id, parentId)
				if err != nil {
					return err
				}

				////makes us go backwards
				//if skip {
				//	continue
				//}

				err = parseStruct(newParentId, newEdgeLabel, newParentIdStart, newDirection, newEdgeParams, followVal, currentDepth+1, maxDepth, nodesPtr, relationsPtr, oldRels, newNodes, nodeRef, visited)
				if err != nil {
					return err
				}
			}
		} else {
			newParentId, newEdgeLabel, newParentIdStart, newDirection, newEdgeParams, followVal, _, _, err := processStruct(conf, &relField, id, parentId)
			if err != nil {
				return err
			}

			//if skip {
			//	continue
			//}

			err = parseStruct(newParentId, newEdgeLabel, newParentIdStart, newDirection, newEdgeParams, followVal, currentDepth+1, maxDepth, nodesPtr, relationsPtr, oldRels, newNodes, nodeRef, visited)
			if err != nil {
				return err
			}
		}
	}

	return nil
}

// processStruct generates configuration for individual struct for saving
func processStruct(fieldConf decoratorConfig, relVal *reflect.Value, id, oldParentId string) (parentId, edgeLabel string, parentIsStart bool, direction dsl.Direction, edgeParams map[string]interface{}, followVal *reflect.Value, followId int64, skip bool, err error) {
	edgeLabel = fieldConf.Relationship

	relValName, err := getTypeName(relVal.Type())
	if err != nil {
		return "", "", false, 0, nil, nil, -1, false, err
	}

	actual, ok := mappedTypes.Get(relValName)
	if !ok {
		return "", "", false, 0, nil, nil, -1, false, fmt.Errorf("cannot find config for %s", edgeLabel)
	}

	edgeConf, ok := actual.(structDecoratorConfig)
	if !ok {
		return "", "", false, 0, nil, nil, -1, false, errors.New("can not cast to structDecoratorConfig")
	}

	if relVal.Type().Implements(edgeType) {
		startValSlice := relVal.MethodByName("GetStartNode").Call(nil)
		endValSlice := relVal.MethodByName("GetEndNode").Call(nil)

		if len(startValSlice) == 0 || len(endValSlice) == 0 {
			return "", "", false, 0, nil, nil, -1, false, errors.New("edge is invalid, sides are not set")
		}

		startId := reflect.Indirect(startValSlice[0].Elem()).FieldByName("UUID").String()
		endId := reflect.Indirect(endValSlice[0].Elem()).FieldByName("UUID").String()

		params, err := toCypherParamsMap(*relVal, edgeConf)
		if err != nil {
			return "", "", false, 0, nil, nil, -1, false, err
		}

		//if its nil, just default it
		if params == nil {
			params = map[string]interface{}{}
		}

		if startId == id {

			//follow the end
			retVal := endValSlice[0].Elem()

			Iid := reflect.Indirect(retVal).FieldByName("Id").Interface()

			followId, ok := Iid.(int64)
			if !ok {
				followId = 0
			}

			//check that we're not going in circles
			if oldParentId != "" {
				if endId == oldParentId {
					return startId, edgeLabel, true, fieldConf.Direction, params, &retVal, followId, true, nil
				}
			}

			return startId, edgeLabel, true, fieldConf.Direction, params, &retVal, followId, false, nil
		} else if endId == id {
			///follow the start
			retVal := startValSlice[0].Elem()

			Iid := reflect.Indirect(retVal).FieldByName("Id").Interface()

			followId, ok := Iid.(int64)
			if !ok {
				followId = 0
			}

			if oldParentId != "" {
				if startId == oldParentId {
					return endId, edgeLabel, false, fieldConf.Direction, params, &retVal, followId, true, nil
				}
			}

			return endId, edgeLabel, false, fieldConf.Direction, params, &retVal, followId, false, nil
		} else {
			return "", "", false, 0, nil, nil, -1, false, errors.New("edge is invalid, doesn't point to parent vertex")
		}
	} else {
		var followId int64

		if oldParentId != "" {
			if relVal.Kind() == reflect.Ptr {
				*relVal = relVal.Elem()
			}

			Iid := reflect.Indirect(*relVal).FieldByName("Id").Interface()

			followId, ok = Iid.(int64)
			if !ok {
				followId = 0
			}

			if relVal.FieldByName("UUID").String() == oldParentId {
				return id, edgeLabel, fieldConf.Direction == dsl.DirectionOutgoing, fieldConf.Direction, map[string]interface{}{}, relVal, followId, true, nil
			}
		} else {
			Iid := reflect.Indirect(*relVal).FieldByName("Id").Interface()

			followId, ok = Iid.(int64)
			if !ok {
				followId = 0
			}
		}

		return id, edgeLabel, fieldConf.Direction == dsl.DirectionOutgoing, fieldConf.Direction, map[string]interface{}{}, relVal, followId, false, nil
	}
}