Esempio n. 1
0
        public void PopulateWithNonDefaultValues(object to, object from)
        {
            var nonDefaultPredicate = (Func <object, Type, bool>)((x, t) =>
                                                                  x != null && !Equals(x, AutoMappingUtils.GetDefaultValue(t))
                                                                  );

            Populate(to, from, null, nonDefaultPredicate);
        }
        private Dictionary <string, object> ResolveDtoValues(object dto, bool skipDefaults = false)
        {
            var dtoValues = dto.ToObjectDictionary();

            var meta = AutoCrudMetadata.Create(dto.GetType());

            if (meta.MapAttrs != null)
            {
                foreach (var entry in meta.MapAttrs)
                {
                    if (dtoValues.TryRemove(entry.Key, out var value))
                    {
                        dtoValues[entry.Value.To] = value;
                    }
                }
            }

            var appHost = HostContext.AppHost;

            if (skipDefaults || meta.UpdateAttrs != null || meta.DefaultAttrs != null)
            {
                List <string> removeKeys = null;
                Dictionary <string, object> replaceValues = null;

                foreach (var entry in dtoValues)
                {
                    var isNullable     = meta.NullableProps?.Contains(entry.Key) == true;
                    var isDefaultValue = entry.Value == null || (!isNullable && AutoMappingUtils.IsDefaultValue(entry.Value));
                    if (isDefaultValue)
                    {
                        var handled = false;
                        if (meta.DefaultAttrs != null && meta.DefaultAttrs.TryGetValue(entry.Key, out var defaultAttr))
                        {
                            handled = true;
                            replaceValues ??= new Dictionary <string, object>();
                            replaceValues[entry.Key] = appHost.EvalScriptValue(defaultAttr, Request);
                        }
                        if (!handled)
                        {
                            if (skipDefaults ||
                                (meta.UpdateAttrs != null && meta.UpdateAttrs.TryGetValue(entry.Key, out var attr) &&
                                 attr.Style == AutoUpdateStyle.NonDefaults))
                            {
                                removeKeys ??= new List <string>();
                                removeKeys.Add(entry.Key);
                            }
                        }
                    }
                }

                if (removeKeys != null)
                {
                    foreach (var key in removeKeys)
                    {
                        dtoValues.RemoveKey(key);
                    }
                }

                if (replaceValues != null)
                {
                    foreach (var entry in replaceValues)
                    {
                        dtoValues[entry.Key] = entry.Value;
                    }
                }
            }

            if (meta.PopulateAttrs != null)
            {
                foreach (var populateAttr in meta.PopulateAttrs)
                {
                    dtoValues[populateAttr.Field] = appHost.EvalScriptValue(populateAttr, Request);
                }
            }

            var populatorFn = AutoMappingUtils.GetPopulator(
                typeof(Dictionary <string, object>), meta.DtoType);

            populatorFn?.Invoke(dtoValues, dto);

            // Ensure RowVersion is always populated if defined on Request DTO
            if (meta.RowVersionGetter != null && !dtoValues.ContainsKey(Keywords.RowVersion))
            {
                dtoValues[Keywords.RowVersion] = default(uint);
            }

            return(dtoValues);
        }