Esempio n. 1
0
 public PropertyMapping(IPropertyValidator pv)
 {
     this.PropertyValidator = pv;
     GetValue = ReflectionTools.CreateGetter <T, P>(pv.PropertyInfo);
     SetValue = ReflectionTools.CreateSetter <T, P>(pv.PropertyInfo);
     Mapping  = Signum.Web.Mapping.New <P>();
 }
Esempio n. 2
0
        internal PropertyValidator(PropertyInfo pi)
        {
            this.PropertyInfo = pi;

            this.Validators = pi.GetCustomAttributes(typeof(ValidatorAttribute), false).OfType <ValidatorAttribute>().OrderBy(va => va.Order).ThenBy(va => va.GetType().Name).ToList();

            this.GetValue = ReflectionTools.CreateGetter <T>(pi);
            this.SetValue = ReflectionTools.CreateSetter <T>(pi);
        }
Esempio n. 3
0
        public static Action <L, Lite <T> >?CreateSetter <T, L>(Expression <Func <L, Lite <T>?> > getBackReference)
            where T : Entity
            where L : Entity
        {
            var body = getBackReference.Body;

            if (body.NodeType == ExpressionType.Convert)
            {
                body = ((UnaryExpression)body).Operand;
            }

            return(ReflectionTools.CreateSetter <L, Lite <T> >(((MemberExpression)body).Member));
        }
Esempio n. 4
0
        internal PropertyValidator(PropertyInfo pi)
        {
            this.PropertyInfo = pi;

            this.Validators = pi.GetCustomAttributes(typeof(ValidatorAttribute), false).OfType <ValidatorAttribute>().OrderBy(va => va.Order).ThenBy(va => va.GetType().Name).ToList();

            var nullable = pi.IsNullable();

            if (nullable == false && !this.Validators.Any(v => v is NotNullValidatorAttribute))
            {
                this.Validators.Add(new NotNullValidatorAttribute());
            }

            this.GetValue = ReflectionTools.CreateGetter <T, object?>(pi) !;
            this.SetValue = ReflectionTools.CreateSetter <T, object?>(pi) !;
        }
Esempio n. 5
0
        Action <T, M, IRetriever> CreateSetter()
        {
            if (PropertyRoute.Type.IsMList())
            {
                var partGetter = PropertyRoute.GetLambdaExpression <T, M>(true).Compile();

                return((e, value, retriever) =>
                {
                    var mlist = partGetter(e);

                    if (mlist == null)
                    {
                        return;
                    }

                    ((IMListPrivate)mlist).AssignAndPostRetrieving((IMListPrivate)value);

                    retriever.ModifiablePostRetrieving((Modifiable)(object)mlist);
                });
            }
            else if (PropertyRoute.Parent.PropertyRouteType == PropertyRouteType.Root)
            {
                var setter = ReflectionTools.CreateSetter <T, M>(PropertyRoute.PropertyInfo);

                return((e, value, retriever) => setter(e, value));
            }
            else
            {
                var partGetter = PropertyRoute.Parent.GetLambdaExpression <T, ModifiableEntity>(true).Compile();

                var setter = ReflectionTools.CreateSetter <ModifiableEntity, M>(PropertyRoute.PropertyInfo);

                return((e, value, retriever) =>
                {
                    var part = partGetter(e);
                    if (part == null)
                    {
                        return;
                    }

                    setter(part, value);
                });
            }
        }
Esempio n. 6
0
    public static List <MemberEntry <T> > GenerateList <T>(MemberOptions options, Type?type = null)
    {
        if (type != null && !typeof(T).IsAssignableFrom(type))
        {
            throw new InvalidOperationException($"Type {type} is assignable {typeof(T)}");
        }

        var finalType = type ?? typeof(T);

        PropertyInfo[] properties = (options & MemberOptions.Properties) == 0 ? new PropertyInfo[0] : typeof(T).GetProperties(bf);
        FieldInfo[]    fields     = (options & MemberOptions.Fields) == 0 ? new FieldInfo[0] : typeof(T).GetFields(bf);

        var members = properties.Where(p => p.GetIndexParameters().Length == 0).Cast <MemberInfo>()
                      .Concat(fields.Cast <MemberInfo>()).OrderBy(e => e.MetadataToken).ToArray();

        var result = members.Select(m => new MemberEntry <T>(
                                        m.Name, m,
                                        options.IsSet(MemberOptions.Getter) ? ReflectionTools.CreateGetter <T, object?>(m) : null,
                                        options.IsSet(MemberOptions.Setters) ? ReflectionTools.CreateSetter <T, object?>(m) : null
                                        )).ToList();

        return(result);
    }
Esempio n. 7
0
 public PropertyConverter(Type type, IPropertyValidator pv)
 {
     this.PropertyValidator = pv;
     GetValue = ReflectionTools.CreateGetter <ModifiableEntity, object?>(pv.PropertyInfo);
     SetValue = ReflectionTools.CreateSetter <ModifiableEntity, object?>(pv.PropertyInfo);
 }
Esempio n. 8
0
 internal static Action <T, V> Setter <V>(PropertyInfo pi)
 {
     return((Action <T, V>)cache.GetOrAdd(pi.Name, s => ReflectionTools.CreateSetter <T, V>(Reflector.FindFieldInfo(typeof(T), pi))));
 }
Esempio n. 9
0
        public static FluentInclude <T> WithVirtualMList <T, L>(this FluentInclude <T> fi,
                                                                Func <T, MList <L> > getMList,
                                                                Expression <Func <L, Lite <T> > > getBackReference,
                                                                Action <L, T> onSave   = null,
                                                                Action <L, T> onRemove = null)
            where T : Entity
            where L : Entity
        {
            Action <L, Lite <T> > setter = null;
            var sb = fi.SchemaBuilder;

            sb.Schema.EntityEvents <T>().Retrieved += (T e) =>
            {
                var mlist = getMList(e);

                var rowIdElements = Database.Query <L>()
                                    .Where(line => getBackReference.Evaluate(line) == e.ToLite())
                                    .ToList()
                                    .Select(line => new MList <L> .RowIdElement(line, line.Id, null));

                ((IMListPrivate <L>)mlist).InnerList.AddRange(rowIdElements);
            };

            sb.Schema.EntityEvents <T>().Saving += (T e) =>
            {
                if (getMList(e).IsGraphModified)
                {
                    e.SetModified();
                }
            };
            sb.Schema.EntityEvents <T>().Saved += (T e, SavedEventArgs args) =>
            {
                var mlist = getMList(e);
                if (!args.WasNew)
                {
                    var oldElements = mlist.Where(line => !line.IsNew);
                    var query       = Database.Query <L>()
                                      .Where(p => getBackReference.Evaluate(p) == e.ToLite());

                    if (onRemove == null)
                    {
                        query.Where(p => !oldElements.Contains(p)).UnsafeDelete();
                    }
                    else
                    {
                        query.ToList().ForEach(line => onRemove(line, e));
                    }
                }

                if (setter == null)
                {
                    setter = ReflectionTools.CreateSetter <L, Lite <T> >(((MemberExpression)getBackReference.Body).Member);
                }

                mlist.ForEach(line => setter(line, e.ToLite()));
                if (onSave == null)
                {
                    mlist.SaveList();
                }
                else
                {
                    mlist.ForEach(line => onSave(line, e));
                }
                var priv = (IMListPrivate)mlist;
                for (int i = 0; i < mlist.Count; i++)
                {
                    if (priv.GetRowId(i) == null)
                    {
                        priv.SetRowId(i, mlist[i].Id);
                    }
                }
            };

            return(fi);
        }