Пример #1
0
        public ActionResult FieldEdit(int IdField = 0)
        {
            CustomFieldsField data = null;

            if (IdField > 0)
            {
                using (var db = this.CreateUnitOfWork())
                {
                    data = db.CustomFieldsFields.Where(x => x.IdField == IdField).Include(x => x.data).FirstOrDefault();
                    if (data == null)
                    {
                        throw new Exception("Такое поле не найдено в базе данных!");
                    }
                    if (data.IdModule != this.Module.ID)
                    {
                        var module = AppCore.GetModulesManager().GetModule(data.IdModule);
                        if (module == null)
                        {
                            throw new Exception("Это поле относится к другому модулю.");
                        }
                        else
                        {
                            throw new Exception(string.Format("Это поле относится к модулю '{0}'.", module.Caption));
                        }
                    }
                }
            }
            else
            {
                data = new DB.CustomFieldsField()
                {
                    IdFieldType = 0, IdModule = this.Module.ID
                };
            }

            return(Controller.display("ModuleExtensions/CustomFields/Design/FieldEdit.cshtml", new Model.FieldEdit(data)));
        }
Пример #2
0
        public JsonResult FieldSave(Model.FieldEdit model = null)
        {
            var result = Controller.JsonAnswer();

            try
            {
                using (var db = this.CreateUnitOfWork())
                {
                    CustomFieldsField data = null;
                    if (model.IdField > 0)
                    {
                        data = db.CustomFieldsFields.Where(x => x.IdField == model.IdField).Include(x => x.data).FirstOrDefault();
                        if (data == null)
                        {
                            throw new Exception("Такое поле не найдено в базе данных!");
                        }
                        if (data.IdModule != this.Module.ID)
                        {
                            var module = AppCore.GetModulesManager().GetModule(data.IdModule);
                            if (module == null)
                            {
                                throw new Exception("Это поле относится к другому модулю.");
                            }
                            else
                            {
                                throw new Exception(string.Format("Это поле относится к модулю '{0}'.", module.Caption));
                            }
                        }
                    }
                    else
                    {
                        data = new DB.CustomFieldsField()
                        {
                            IdFieldType = 0, IdModule = this.Module.ID
                        };
                        db.CustomFieldsFields.Add(data);
                    }

                    if (ModelState.ContainsKeyCorrect(nameof(model.name)))
                    {
                        data.name = model.name;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.nameAlt)))
                    {
                        data.nameAlt = model.nameAlt;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.alias)))
                    {
                        data.alias = model.alias;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.formatCheck)))
                    {
                        data.formatCheck = model.formatCheck;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.IdFieldType)))
                    {
                        data.IdFieldType = model.IdFieldType;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.IsValueRequired)))
                    {
                        data.IsValueRequired = model.IsValueRequired;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.IdValueType)))
                    {
                        data.IdValueType = model.IdValueType;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.size)))
                    {
                        data.size = model.size;
                    }
                    if (ModelState.ContainsKeyCorrect(nameof(model.nameEnding)))
                    {
                        data.nameEnding = model.nameEnding;
                    }

                    using (var scope = db.CreateScope())
                    {
                        var entry = db.GetState(data);
                        if (entry == ItemState.Detached)
                        {
                            throw new Exception("Невозможно найти поле для сохранения.");
                        }
                        else if (entry.In(ItemState.Modified, ItemState.Added))
                        {
                            data.DateChange = DateTime.Now.Timestamp();
                            data.Block      = 0;

                            if (db.SaveChanges <CustomFieldsField>() == 0)
                            {
                                throw new Exception("Сохранение поля провалилось!");
                            }
                        }

                        if (Request.Form.HasKey("values"))
                        {
                            var t    = DateTime.Now.Timestamp();
                            var vals = Request.Form.TryGetValue <CustomFieldsValue[]>("values");

                            if (vals != null)
                            {
                                foreach (var d in vals)
                                {
                                    d.IdField = data.IdField;
                                    //d.Field = data;
                                    d.DateChange = t;
                                }

                                db.CustomFieldsValues.AddOrUpdate(vals);
                            }
                            else
                            {
                                vals = new CustomFieldsValue[0];
                            }

                            var values = vals.ToList();

                            if (values.Count > 0)
                            {
                                if (db.SaveChanges <CustomFieldsValue>() == 0)
                                {
                                    throw new Exception("Не удалось сохранить варианты значений поля");
                                }
                            }

                            data.data = data.FieldType.CreateValuesCollection(data, values);

                            var keys = values.Select(x => x.IdFieldValue);

                            var removeExistsValue   = new Dictionary <int, string>();
                            var removeExistsObjects = new Dictionary <int, List <int> >();

                            var sql = (from p in db.CustomFieldsValues
                                       join d in db.CustomFieldsDatas on p.IdFieldValue equals d.IdFieldValue
                                       where p.IdField == data.IdField && !keys.Contains(p.IdFieldValue)
                                       select new { p, d });

                            foreach (var res in sql)
                            {
                                removeExistsValue[res.p.IdFieldValue] = res.p.FieldValue;
                                if (!removeExistsObjects.ContainsKey(res.p.IdFieldValue))
                                {
                                    removeExistsObjects[res.p.IdFieldValue] = new List <int>();
                                }
                                if (!removeExistsObjects[res.p.IdFieldValue].Contains(res.d.IdItem))
                                {
                                    removeExistsObjects[res.p.IdFieldValue].Add(res.d.IdItem);
                                }
                            }

                            if (removeExistsValue.Count > 0)
                            {
                                var removeTexts = new Dictionary <int, string>();
                                foreach (var pair in removeExistsValue)
                                {
                                    removeTexts[pair.Key] = " - №" + pair.Key + " \"" + pair.Value + "\" у объектов №" + string.Join(", №", removeExistsObjects[pair.Key]);
                                }

                                throw new Exception("Некоторые значения, которые вы пытаетесь удалить, указаны у следующих объектов:\r\n" + string.Join(", \r\n", removeTexts.Values));
                            }

                            //todo подозрение, что неправильный запрос, может очистить всю таблицу.
                            //DB.CustomFieldsValues.Where(x => !keys.Contains(x.IdFieldValue)).Delete();
                        }

                        result.Message = "Сохранение поля прошло успешно!";
                        result.Success = true;
                        result.Data    = data;

                        scope.Commit();
                    }

                    result.Success = true;
                }
            }
            catch (OnUtils.Data.Validation.EntityValidationException ex) { result.Message = ex.CreateComplexMessage(); }
            catch (Exception ex) { result.Message = ex.Message; }

            return(Controller.ReturnJson(result));
        }