Skip to content
Snippets Groups Projects
Select Git revision
  • 9d31d87553b4d903a51085ebef28561b1d7dbcac
  • master default protected
  • fix/PRXS-3401-ValidateValidationOpts
  • feature/PRXS-3383-CollectionsRankSortAPI
  • feature/3149-LocaleCodeAsID-Feature
  • feature/PRXS-3383-CollectionsSort
  • feature/3109-SerializeFeature
  • release/0.33
  • feature/3109-RecoverySchema
  • feature/3109-feature
  • fix/PRXS-3369-ValidateFields
  • refactor/PRXS-3306-MovePkgGroup1
  • refactor/6-pkg-refactor-expr
  • fix/PRXS-3360-TemplateBuilderPatch
  • feature/3293-MongoV2
  • feature/3272-GoVersionUp
  • feature/PRXS-3218-HideTemplateActions
  • feature/PRXS-3234-PruneIdents
  • feature/3146-UpdateItemStorageInterface
  • feature/3274-ObjectIndexesFixes
  • feature/PRXS-3143-3235-ReferenceOptions
  • v0.33.1
  • v0.32.0
  • v0.31.1
  • v0.31.0
  • v0.30.0
  • v0.29.0
  • v0.28.0
  • v0.27.0-alpha.1+16
  • v0.27.0-alpha.1+15
  • v0.27.0-alpha.1+14
  • v0.27.0-alpha.1+13
  • v0.27.0-alpha.1+12
  • v0.27.0-alpha.1+11
  • v0.27.0-alpha.1+10
  • v0.27.0-alpha.1+9
  • v0.27.0-alpha.1+8
  • v0.27.0-alpha.1+7
  • v0.27.0-alpha.1+6
  • v0.27.0-alpha.1+5
  • v0.27.0-alpha.1+4
41 results

file.go

Blame
  • schema.go 4.72 KiB
    package schema
    
    import (
    	"context"
    
    	"git.perx.ru/perxis/perxis-go/pkg/errors"
    	"git.perx.ru/perxis/perxis-go/pkg/expr"
    	"git.perx.ru/perxis/perxis-go/pkg/schema/field"
    	"git.perx.ru/perxis/perxis-go/pkg/schema/modify"
    	"git.perx.ru/perxis/perxis-go/pkg/schema/validate"
    )
    
    type Schema struct {
    	field.Field
    	Loaded   bool              `json:"loaded"`
    	Metadata map[string]string `json:"metadata"`
    }
    
    func New(kv ...interface{}) *Schema {
    	return &Schema{Field: *field.Object(kv...)}
    }
    
    func NewFromField(f *field.Field) *Schema {
    	return &Schema{Field: *f}
    }
    
    var (
    	Encode   = field.Encode
    	Decode   = field.Decode
    	Modify   = modify.Modify
    	Validate = validate.Validate
    	Evaluate = field.Evaluate
    )
    
    func (s *Schema) Clone(reset bool) *Schema {
    	return &Schema{
    		Field:    *s.Field.Clone(reset),
    		Loaded:   s.Loaded,
    		Metadata: s.Metadata,
    	}
    }
    
    func (s Schema) WithIncludes(includes ...interface{}) *Schema {
    	s.Field.SetIncludes(includes...)
    	return &s
    }
    
    func (s *Schema) WithMetadata(kv ...string) *Schema {
    	if s.Metadata == nil {
    		s.Metadata = make(map[string]string)
    	}
    	for i := 0; i < len(kv); i += 2 {
    		s.Metadata[kv[i]] = kv[i+1]
    	}
    	return s
    }
    
    func (s Schema) SetMetadata(md map[string]string) *Schema {
    	s.Metadata = md
    	return &s
    }
    
    func (s *Schema) Load(ctx context.Context) error {
    	if s.Loaded {
    		return nil
    	}
    	return s.LoadIncludes(ctx, nil)
    }
    
    func (s *Schema) LoadIncludes(ctx context.Context, loader field.Loader) (err error) {
    	if loader == nil {
    		loader = GetLoader()
    	}
    	err = s.Field.LoadIncludes(ctx, loader)
    	if err == nil {
    		s.Loaded = true
    	}
    	return
    }
    
    func (s *Schema) Modify(ctx context.Context, data map[string]interface{}) (res map[string]interface{}, err error) {
    	if err = s.Load(ctx); err != nil {
    		return nil, err
    	}
    
    	v, _, err := Modify(ctx, s, data)
    	if err != nil || v == nil {
    		return
    	}
    
    	res, _ = v.(map[string]interface{})
    	return
    }
    
    func (s *Schema) Validate(ctx context.Context, data map[string]interface{}) (err error) {
    	if err = s.Load(ctx); err != nil {
    		return err
    	}
    
    	return Validate(ctx, s, data)
    }
    
    func (s *Schema) Evaluate(ctx context.Context, data map[string]interface{}) (res map[string]interface{}, err error) {
    	if err = s.Load(ctx); err != nil {
    		return nil, err
    	}
    
    	v, err := Evaluate(ctx, s, data)
    	if err != nil || v == nil {
    		return
    	}
    	res, _ = v.(map[string]interface{})
    	return
    }
    
    func (s *Schema) Decode(ctx context.Context, v interface{}) (res map[string]interface{}, err error) {
    	if err = s.Load(ctx); err != nil {
    		return nil, err
    	}
    
    	if v, err = Decode(ctx, s, v); err != nil {
    		return nil, err
    	}
    	res, _ = v.(map[string]interface{})
    	return
    }
    
    func (s *Schema) Encode(ctx context.Context, v interface{}) (interface{}, error) {
    	if err := s.Load(ctx); err != nil {
    		return nil, err
    	}
    
    	var res interface{}
    	var err error
    
    	if res, err = Encode(ctx, s, v); err != nil {
    		return nil, err
    	}
    
    	return res, nil
    }
    
    func (s *Schema) ToValue(ctx context.Context, data map[string]interface{}) (res map[string]interface{}, err error) {
    	if err = s.Load(ctx); err != nil {
    		return nil, err
    	}
    
    	if data, err = s.Decode(ctx, data); err != nil {
    		return nil, err
    	}
    	if data, err = s.Modify(ctx, data); err != nil {
    		return nil, err
    	}
    	if data, err = s.Evaluate(ctx, data); err != nil {
    		return nil, err
    	}
    	if err = s.Validate(ctx, data); err != nil {
    		return nil, err
    	}
    	return data, err
    }
    
    type parentFieldCtxKey struct{}
    
    func (s *Schema) Introspect(ctx context.Context, data map[string]interface{}) (map[string]interface{}, *Schema, error) {
    	if err := s.Load(ctx); err != nil {
    		return nil, nil, err
    	}
    
    	var err error
    
    	chg := true
    	val := data
    	i := 0
    
    	var mutatedSchema *Schema
    
    	for chg {
    		mutatedSchema = nil
    
    		var res interface{}
    		res, chg, err = s.Walk(expr.WithEnv(ctx, val), val, func(ctx context.Context, f *field.Field, v interface{}) (res field.WalkFuncResult, err error) {
    			parent, _ := ctx.Value(parentFieldCtxKey{}).(*field.Field)
    			name, _ := ctx.Value(field.FieldName).(string)
    			enabled, err := f.IsEnabled(ctx)
    			if err != nil {
    				return
    			}
    
    			if !enabled {
    				res.Stop = true
    				if v != nil {
    					res.Changed = true
    				}
    				return
    			}
    
    			fld := f.Clone(true)
    			if mutatedSchema == nil {
    				mutatedSchema = &Schema{Field: *fld}
    				fld = &mutatedSchema.Field
    			}
    
    			if parent != nil && name != "" {
    				field.AddField(parent, name, fld)
    			}
    
    			ctx = context.WithValue(ctx, parentFieldCtxKey{}, fld)
    			res.Context = ctx
    
    			return
    		}, field.WalkSchema())
    
    		if err != nil {
    			return nil, nil, errors.Wrap(err, "evaluation error")
    		}
    
    		if res != nil {
    			val = res.(map[string]interface{})
    		} else {
    			val = nil
    		}
    
    		i += 1
    
    		if i > field.EvaluatePassesLimit {
    			return nil, nil, errors.New("fail to evaluate data conditions")
    		}
    	}
    
    	return val, mutatedSchema, nil
    }