示例#1
0
        public Entity GetEntityWithData(Entity entity, params string[] key)
        {
            var keys = new object[key.Length];

            for (int i = 0; i < key.Length; i++)
            {
                keys[i] = entity.Key[i].Value.ToObject(key[i]);
            }
            var item = GetRecord(entity, keys);

            if (item == null)
            {
                _notificator.Error(IlaroAdminResources.EntityNotExist);
                return(null);
            }

            foreach (var property in entity.CreateProperties(false))
            {
                property.Value.Raw =
                    item.ContainsKey(property.ColumnName.Undecorate()) ?
                    item[property.ColumnName.Undecorate()] :
                    null;
            }

            return(entity);
        }
示例#2
0
        private void FileHandle(Entity entity)
        {
            foreach (var property in entity.CreateProperties(getForeignCollection: false).Where(x => x.DataType == DataType.File))
            {
                if (property.PropertyType == typeof(string))
                {
                    // we must save file to disk and save file path in db
                    var file     = (HttpPostedFile)property.Value;
                    var fileName = String.Empty;
                    if (property.ImageOptions.NameCreation == NameCreation.UserInput)
                    {
                        fileName = "test.jpg";
                    }
                    fileName = FileUpload.FileUpload.SaveImage(file, fileName, property.ImageOptions.NameCreation, property.ImageOptions.Settings.ToArray());

                    property.Value = fileName;
                }
                else
                {
                    // we must save file in db as byte array

                    var file  = (HttpPostedFile)property.Value;
                    var bytes = FileUpload.FileUpload.GetImageByte(file, property.ImageOptions.Settings.ToArray());
                    property.Value = bytes;
                }
            }
        }
        private EntityHierarchy GetEntityHierarchy(
            EntityHierarchy parent,
            Entity entity,
            ref int index)
        {
            var hierarchy = new EntityHierarchy
            {
                Entity          = entity,
                Alias           = "[t" + index + "]",
                SubHierarchies  = new List <EntityHierarchy>(),
                ParentHierarchy = parent
            };

            foreach (var property in entity.CreateProperties()
                     .Where(x => x.IsForeignKey && x.TypeInfo.IsCollection)
                     .Where(property =>
                            parent == null ||
                            parent.Entity != property.ForeignEntity))
            {
                index++;
                var subHierarchy =
                    GetEntityHierarchy(hierarchy, property.ForeignEntity, ref index);
                hierarchy.SubHierarchies.Add(subHierarchy);
            }

            return(hierarchy);
        }
示例#4
0
        public bool Delete(Entity entity, string key, IEnumerable <PropertyDeleteOption> options)
        {
            var existingRecord = _source.GetRecord(entity, key);

            if (existingRecord == null)
            {
                _notificator.Error(IlaroAdminResources.EntityNotExist);
                return(false);
            }
            entity.SetKeyValue(key);

            options = options ?? new List <PropertyDeleteOption>();
            var deleteOptions = options.ToDictionary(x => x.PropertyName, x => x.DeleteOption);

            foreach (var property in entity.GetForeignsForUpdate())
            {
                if (!deleteOptions.ContainsKey(property.ForeignEntity.Name))
                {
                    deleteOptions[property.ForeignEntity.Name] = property.DeleteOption;
                }
            }

            var result = _deleter.Delete(entity, deleteOptions, () => _changeDescriber.DeleteChanges(entity, existingRecord));

            if (result)
            {
                var propertiesWithFilesToDelete = entity
                                                  .CreateProperties(getForeignCollection: false)
                                                  .Where(x => x.TypeInfo.IsFile && x.TypeInfo.IsFileStoredInDb == false);
                _filesHandler.Delete(propertiesWithFilesToDelete);
            }

            return(result);
        }
        public string UpdateChanges(Entity entity, IDictionary <string, object> existingRecord)
        {
            var updateProperties = entity.CreateProperties(getForeignCollection: false)
                                   .Where(x => x.IsKey == false)
                                   .WhereIsNotSkipped().ToList();

            if (updateProperties.Any() == false)
            {
                return("No changes");
            }

            var changeBuilder = new StringBuilder();

            foreach (var property in updateProperties)
            {
                var columnName = property.ColumnName.Undecorate();
                if (existingRecord.ContainsKey(columnName))
                {
                    var oldValue = existingRecord[columnName];
                    changeBuilder.AppendFormat("{0} ({1} => {2})", property.Name, oldValue.ToStringSafe(), property.Value.AsString);
                    changeBuilder.AppendLine();
                }
            }

            return(changeBuilder.ToString());
        }
示例#6
0
        private DbCommand CreateBaseCommand(Entity entity)
        {
            var sbKeys = new StringBuilder();
            var sbVals = new StringBuilder();

            var cmd     = DB.CreateCommand();
            var counter = 0;

            foreach (var property in entity.CreateProperties(getForeignCollection: false))
            {
                sbKeys.AppendFormat("{0},", property.ColumnName);
                sbVals.AppendFormat("@{0},", counter);
                AddParam(cmd, property);
                counter++;
            }
            var keys       = sbKeys.ToString().Substring(0, sbKeys.Length - 1);
            var vals       = sbVals.ToString().Substring(0, sbVals.Length - 1);
            var idType     = "int";
            var insertedId = "SCOPE_IDENTITY()";

            if (entity.Key.TypeInfo.IsString)
            {
                idType     = "nvarchar(max)";
                insertedId = "@" + counter;
                cmd.AddParam(entity.Key.Value.Raw);
            }
            var sql = SqlFormat.Fill(entity.TableName, keys, vals, idType, insertedId);

            cmd.CommandText = sql;

            return(cmd);
        }
示例#7
0
        protected virtual DbCommand CreateBaseCommand(Entity entity)
        {
            var sbKeys = new StringBuilder();

            var cmd              = DB.CreateCommand();
            var counter          = 0;
            var updateProperties = entity.CreateProperties(getForeignCollection: false)
                                   .Where(x => x.IsKey == false)
                                   .WhereIsNotSkipped().ToList();

            if (updateProperties.Any())
            {
                foreach (var property in updateProperties)
                {
                    AddParam(cmd, property);
                    sbKeys.AppendFormat("\t{0} = @{1}, \r\n", property.ColumnName, counter++);
                }
                cmd.AddParams(entity.Key.Select(x => x.Value.Raw).ToArray());
                var keys       = sbKeys.ToString().Substring(0, sbKeys.Length - 4);
                var whereParts = new List <string>();
                foreach (var key in entity.Key)
                {
                    whereParts.Add("{0} = @{1}".Fill(key.ColumnName, counter++));
                }
                var wherePart = string.Join(" AND ", whereParts);
                cmd.CommandText = SqlFormat.Fill(entity.TableName, keys, wherePart);
            }
            cmd.AddParam(entity.JoinedKeyValue);
            cmd.CommandText += SqlReturnRecordIdPart.Fill(counter);

            return(cmd);
        }
示例#8
0
        private void FixParamsSqlType(Entity entity, DbCommand cmd, IDictionary <string, object> values)
        {
            foreach (var property in entity.CreateProperties(getForeignCollection: false).Where(x => x.DataType == DataType.File))
            {
                if (property.PropertyType != typeof(string))
                {
                    var index = GetIndex(values, property.ColumnName);

                    var parameter = cmd.Parameters.OfType <SqlParameter>().FirstOrDefault(x => x.ParameterName == "@" + index);
                    parameter.SqlDbType = SqlDbType.Image;
                }
            }
        }
示例#9
0
        public int Edit(Entity entity)
        {
            if (entity.Key.Value == null)
            {
                Error(IlaroAdminResources.EntityKeyIsNull);
                return(0);
            }

            var existingItem = GetEntity(entity, entity.Key.Value);

            if (existingItem == null)
            {
                Error(IlaroAdminResources.EntityNotExist);
                return(0);
            }

            var table = new DynamicModel(AdminInitialise.ConnectionString, tableName: entity.TableName, primaryKeyField: entity.Key.ColumnName);

            var expando = new ExpandoObject();
            var filler  = expando as IDictionary <String, object>;

            foreach (var property in entity.CreateProperties(getForeignCollection: false))
            {
                filler[property.ColumnName] = property.Value;
            }
            var cmd = table.CreateUpdateCommand(expando, entity.Key.Value);

            foreach (var property in entity.Properties.Where(x => x.IsForeignKey && x.IsCollection))
            {
                var actualRecords = GetRecords(property.ForeignEntity, new List <IEntityFilter> {
                    new ForeignEntityFilter(entity.Key, entity.Key.Value.ToStringSafe())
                });
                var idsToRemoveRelation = actualRecords.Select(x => x.KeyValue);
                idsToRemoveRelation = idsToRemoveRelation.Except(property.Values.OfType <string>());
                // UPDATE {TableName} SET {ForeignKey} = {FKValue} WHERE {PrimaryKey} In ({PKValues});
                var updateFormat = Environment.NewLine + ";UPDATE {0} SET {1} = {2} WHERE {3} In ({4})";
                if (idsToRemoveRelation.Any())
                {
                    cmd.CommandText += Environment.NewLine + string.Format(updateFormat, property.ForeignEntity.TableName, entity.Key.ColumnName, "NULL", property.ForeignEntity.Key.ColumnName, DecorateSqlValue(idsToRemoveRelation.OfType <object>().ToList(), property.ForeignEntity.Key));
                }
                cmd.CommandText += Environment.NewLine + string.Format(updateFormat, property.ForeignEntity.TableName, entity.Key.ColumnName, DecorateSqlValue(entity.Key.Value, entity.Key), property.ForeignEntity.Key.ColumnName, DecorateSqlValue(property.Values, property.ForeignEntity.Key));
            }
            var savedItems = table.Execute(cmd);

            // TODO: get info about changed properties
            AddEntityChange(entity.Name, entity.Key.StringValue, EntityChangeType.Update);

            ClearProperties(entity);

            return(savedItems);
        }
示例#10
0
        public IList <GroupPropertiesViewModel> PrepareGroups(Entity entity, bool getKey = true, string key = null)
        {
            var properties = entity.CreateProperties(getKey);

            foreach (var foreign in properties.Where(x => x.IsForeignKey))
            {
                var records = GetRecords(foreign.ForeignEntity, determineDisplayValue: true);
                foreign.PossibleValues = records.ToDictionary(x => x.KeyValue, x => x.DisplayName);
                if (foreign.IsCollection)
                {
                    foreign.Values = records.Where(x => x.Values.Any(y => y.Property.ForeignEntity == entity && y.Value == key)).Select(x => x.KeyValue).OfType <object>().ToList();
                }
            }

            return(entity.Groups);
        }
示例#11
0
        public void SkipNotChangedProperties(Entity entity, IDictionary<string, object> existingRecord)
        {
            foreach (var property in entity
                .CreateProperties(getForeignCollection: false)
                .Where(x => x.IsKey == false)
                .WhereIsNotSkipped())
            {
                if (existingRecord.ContainsKey(property.ColumnName.Undecorate()))
                {
                    var oldValue = existingRecord[property.ColumnName.Undecorate()];
                    var equals = Equals(property.Value.Raw, oldValue);

                    if (equals)
                        property.Value.Raw = DataBehavior.Skip;
                }
            }
        }
示例#12
0
        public void FillEntity(Entity entity, string key)
        {
            var item = GetEntity(entity, key);

            if (item == null)
            {
                Error(IlaroAdminResources.EntityNotExist);
                return;
            }

            var propertiesDict = item as IDictionary <string, object>;

            foreach (var property in entity.CreateProperties(false))
            {
                property.Value = propertiesDict.ContainsKey(property.ColumnName) ? propertiesDict[property.ColumnName] : null;
            }

            entity.Key.Value = key;
        }
示例#13
0
        public void SkipNotChangedProperties(Entity entity, IDictionary <string, object> existingRecord)
        {
            foreach (var property in entity
                     .CreateProperties(getForeignCollection: false)
                     .Where(x => x.IsKey == false)
                     .WhereIsNotSkipped())
            {
                if (existingRecord.ContainsKey(property.ColumnName.Undecorate()))
                {
                    var oldValue = existingRecord[property.ColumnName.Undecorate()];
                    var equals   = Equals(property.Value.Raw, oldValue);

                    if (equals)
                    {
                        property.Value.Raw = DataBehavior.Skip;
                    }
                }
            }
        }
示例#14
0
        public object Create(Entity entity)
        {
            var existingItem = GetEntity(entity, entity.Key.Value);

            if (existingItem != null)
            {
                Error(IlaroAdminResources.EntityAlreadyExist);
                return(null);
            }

            FileHandle(entity);

            var table = new DynamicModel(AdminInitialise.ConnectionString, tableName: entity.TableName, primaryKeyField: entity.Key.ColumnName);

            var expando = new ExpandoObject();
            var filler  = expando as IDictionary <String, object>;

            foreach (var property in entity.CreateProperties(getForeignCollection: false))
            {
                filler[property.ColumnName] = property.Value;
            }
            var cmd = table.CreateInsertCommand(expando);

            cmd.CommandText += Environment.NewLine + ";DECLARE @newID int; SELECT @newID = SCOPE_IDENTITY()";
            foreach (var property in entity.Properties.Where(x => x.IsForeignKey && x.IsCollection && !x.Values.IsNullOrEmpty()))
            {
                // UPDATE {TableName} SET {ForeignKey} = {FKValue} WHERE {PrimaryKey} In ({PKValues});
                var updateFormat = Environment.NewLine + ";UPDATE {0} SET {1} = @newID WHERE {2} In ({3})";
                cmd.CommandText += string.Format(updateFormat, property.ForeignEntity.TableName, entity.Key.ColumnName, property.ForeignEntity.Key.ColumnName, DecorateSqlValue(property.Values, property.ForeignEntity.Key));
            }
            cmd.CommandText += Environment.NewLine + ";SELECT @newID";

            FixParamsSqlType(entity, cmd, filler);

            var item = table.Execute(cmd);

            AddEntityChange(entity.Name, item.ToString(), EntityChangeType.Insert);

            ClearProperties(entity);

            return(item);
        }
示例#15
0
        protected virtual DbCommand CreateBaseCommand(Entity entity)
        {
            var sbKeys = new StringBuilder();

            var cmd     = DB.CreateCommand();
            var counter = 0;

            foreach (var property in
                     entity.CreateProperties(getForeignCollection: false).Where(x => x.IsKey == false))
            {
                AddParam(cmd, property);
                sbKeys.AppendFormat("\t{0} = @{1}, \r\n", property.ColumnName, counter);
                counter++;
            }
            cmd.AddParam(entity.Key.Value.Raw);
            var keys = sbKeys.ToString().Substring(0, sbKeys.Length - 4);

            cmd.CommandText = SqlFormat.Fill(entity.TableName, keys, entity.Key.ColumnName, counter);

            return(cmd);
        }
示例#16
0
        private void FillEntity(object item, Entity entity)
        {
            var request = HttpContext.Current.Request;

            foreach (var property in entity.CreateProperties(false))
            {
                if (property.DataType == DataType.File)
                {
                    var file     = request.Files[property.Name];
                    var fileName = String.Empty;
                    if (property.ImageOptions.NameCreation == NameCreation.UserInput)
                    {
                        fileName = "test.jpg";
                    }
                    fileName = FileUpload.FileUpload.SaveImage(file, fileName, property.ImageOptions.NameCreation, property.ImageOptions.Settings.ToArray());

                    property.Value = fileName;
                }

                var propertyInfo = entity.Type.GetProperty(property.Name);
                propertyInfo.SetValue(item, property.Value, null);
            }
        }
        public string UpdateChanges(Entity entity, IDictionary<string, object> existingRecord)
        {
            var updateProperties = entity.CreateProperties(getForeignCollection: false)
                .Where(x => x.IsKey == false)
                .WhereIsNotSkipped().ToList();

            if (updateProperties.Any() == false)
                return "No changes";

            var changeBuilder = new StringBuilder();
            foreach (var property in updateProperties)
            {
                var columnName = property.ColumnName.Undecorate();
                if (existingRecord.ContainsKey(columnName))
                {
                    var oldValue = existingRecord[columnName];
                    changeBuilder.AppendFormat("{0} ({1} => {2})", property.Name, oldValue.ToStringSafe(), property.Value.AsString);
                    changeBuilder.AppendLine();
                }
            }

            return changeBuilder.ToString();
        }
示例#18
0
        /// <summary>
        /// Upload files to temp location, or save file byte array to property value
        /// </summary>
        public IList <Property> Upload(Entity entity)
        {
            var proccessedProperties = new List <Property>();

            foreach (var property in entity
                     .CreateProperties(getForeignCollection: false)
                     .Where(x => x.TypeInfo.IsFile))
            {
                if (property.Value.Raw.IsBehavior(DataBehavior.Clear))
                {
                    property.Value.Raw = property.Value.DefaultValue;
                    proccessedProperties.Add(property);
                    continue;
                }
                var file = (HttpPostedFileWrapper)property.Value.Raw;
                if (file == null || file.ContentLength == 0)
                {
                    property.Value.Raw = DataBehavior.Skip;
                    continue;
                }

                if (property.TypeInfo.IsFileStoredInDb)
                {
                    var setting         = property.FileOptions.Settings.FirstOrDefault();
                    var fileInputStream = property.TypeInfo.IsImage ?
                                          _resizer.Resize(file.InputStream, setting.Width, setting.Height) :
                                          file.InputStream;

                    var bytes = _saver.GetFileByteArray(fileInputStream);
                    property.Value.Raw = bytes;
                }
                else
                {
                    var fileName = _fileNameCreator.GetFileName(property, file);
                    property.Value.Raw = fileName;

                    if (property.TypeInfo.IsImage)
                    {
                        foreach (var setting in property.FileOptions.Settings)
                        {
                            var resizedStream = _resizer.Resize(
                                file.InputStream,
                                setting.Width,
                                setting.Height);

                            var subPath =
                                setting.SubPath.TrimEnd('/', '\\') +
                                _configuration.UploadFilesTempFolderSufix;
                            var path = Path.Combine(BasePath, property.FileOptions.Path, subPath, fileName);

                            _saver.SaveFile(resizedStream, path);
                            resizedStream.Dispose();
                        }
                    }
                    else
                    {
                        var subPath =
                            property.FileOptions.Path.TrimEnd('/', '\\') +
                            _configuration.UploadFilesTempFolderSufix;
                        var path = Path.Combine(BasePath, subPath, fileName);

                        _saver.SaveFile(file.InputStream, path);
                    }

                    proccessedProperties.Add(property);
                }

                file.InputStream.Dispose();
            }

            return(proccessedProperties);
        }