Example #1
0
        public ActionResult New(string tabId, int parentId, int?fieldId)
        {
            var field = FieldService.New(parentId, fieldId);
            var model = FieldViewModel.Create(field, tabId, parentId);

            return(JsonHtml("Properties", model));
        }
Example #2
0
        public ActionResult Properties(string tabId, int parentId, int id, string backendActionCode, FormCollection collection)
        {
            var field         = FieldService.ReadForUpdate(id);
            var model         = FieldViewModel.Create(field, tabId, parentId);
            var oldOrder      = model.Data.Order;
            var oldViewInList = model.Data.ViewInList;
            var oldLinkId     = model.Data.LinkId;
            var oldBackward   = model.Data.BackwardField;

            TryUpdateModel(model);
            model.Validate(ModelState);
            if (ModelState.IsValid)
            {
                try
                {
                    model.Data = FieldService.Update(model.Data);
                    PersistLinkId(oldLinkId, model.Data.LinkId);
                    PersistBackwardId(oldBackward, model.Data.BackwardField);
                    PersistVirtualFieldIds(model.Data.NewVirtualFieldIds);
                    AppendFormGuidsFromIds("DefaultArticleIds", "DefaultArticleUniqueIds");
                    AppendFormGuidsFromIds("Data.O2MDefaultValue", "Data.O2MUniqueIdDefaultValue");
                }
                catch (UserQueryContentCreateViewException uqEx)
                {
                    if (HttpContext.IsXmlDbUpdateReplayAction())
                    {
                        throw;
                    }

                    ModelState.AddModelError("UserQueryContentCreateViewException", uqEx.Message);
                    return(JsonHtml("Properties", model));
                }
                catch (VirtualContentProcessingException vcpEx)
                {
                    if (HttpContext.IsXmlDbUpdateReplayAction())
                    {
                        throw;
                    }

                    ModelState.AddModelError("VirtualContentProcessingException", vcpEx.Message);
                    return(JsonHtml("Properties", model));
                }

                var newOrder      = model.Data.Order;
                var newViewInList = model.Data.ViewInList;
                return(Redirect("Properties", new
                {
                    tabId,
                    parentId,
                    id = model.Data.Id,
                    successfulActionCode = backendActionCode,
                    orderChanged = newOrder != oldOrder,
                    viewInListAffected = newViewInList != oldViewInList
                }));
            }

            return(JsonHtml("Properties", model));
        }
Example #3
0
        public ActionResult VirtualProperties(string tabId, int parentId, int id, string successfulActionCode, bool?orderChanged, bool?viewInListAffected)
        {
            var content = FieldService.VirtualRead(id);
            var model   = FieldViewModel.Create(content, tabId, parentId);

            model.SuccesfulActionCode = successfulActionCode;
            model.OrderChanged        = orderChanged ?? false;
            model.ViewInListAffected  = viewInListAffected ?? false;
            return(JsonHtml("VirtualProperties", model));
        }
Example #4
0
        public ActionResult VirtualProperties(string tabId, int parentId, int id, FormCollection collection)
        {
            var field         = FieldService.ReadForUpdate(id);
            var model         = FieldViewModel.Create(field, tabId, parentId);
            var oldOrder      = model.Data.Order;
            var oldViewInList = model.Data.ViewInList;

            TryUpdateModel(model);
            model.Validate(ModelState);
            if (ModelState.IsValid)
            {
                try
                {
                    model.Data = VirtualFieldService.Update(model.Data);
                    PersistVirtualFieldIds(model.Data.NewVirtualFieldIds);
                }
                catch (UserQueryContentCreateViewException uqe)
                {
                    if (HttpContext.IsXmlDbUpdateReplayAction())
                    {
                        throw;
                    }

                    ModelState.AddModelError("UserQueryContentCreateViewException", uqe.Message);
                    return(JsonHtml("VirtualProperties", model));
                }
                catch (VirtualContentProcessingException vcpe)
                {
                    if (HttpContext.IsXmlDbUpdateReplayAction())
                    {
                        throw;
                    }

                    ModelState.AddModelError("VirtualContentProcessingException", vcpe.Message);
                    return(JsonHtml("Properties", model));
                }

                var newViewInList = model.Data.ViewInList;
                return(Redirect("VirtualProperties", new
                {
                    tabId,
                    parentId,
                    id = model.Data.Id,
                    successfulActionCode = ActionCode.UpdateField,
                    orderChanged = oldOrder != model.Data.Order,
                    viewInListAffected = newViewInList != oldViewInList
                }));
            }

            return(JsonHtml("VirtualProperties", model));
        }
Example #5
0
        public ActionResult New(string tabId, int parentId, string backendActionCode, FormCollection collection)
        {
            var content     = FieldService.New(parentId, null);
            var model       = FieldViewModel.Create(content, tabId, parentId);
            var oldLinkId   = model.Data.LinkId;
            var oldBackward = model.Data.BackwardField;

            TryUpdateModel(model);
            model.Validate(ModelState);
            if (ModelState.IsValid)
            {
                try
                {
                    model.Data = FieldService.Save(model.Data);
                    PersistResultId(model.Data.Id);
                    PersistLinkId(oldLinkId, model.Data.LinkId);
                    PersistBackwardId(oldBackward, model.Data.BackwardField);
                    PersistVirtualFieldIds(model.Data.NewVirtualFieldIds);
                    PersistChildFieldIds(model.Data.ResultChildFieldIds);
                    PersistChildLinkIds(model.Data.ResultChildLinkIds);
                    AppendFormGuidsFromIds("DefaultArticleIds", "DefaultArticleUniqueIds");
                    AppendFormGuidsFromIds("Data.O2MDefaultValue", "Data.O2MUniqueIdDefaultValue");
                }
                catch (VirtualContentProcessingException vcpe)
                {
                    if (HttpContext.IsXmlDbUpdateReplayAction())
                    {
                        throw;
                    }

                    ModelState.AddModelError("VirtualContentProcessingException", vcpe.Message);
                    return(JsonHtml("Properties", model));
                }

                return(Redirect("Properties", new
                {
                    tabId,
                    parentId,
                    id = model.Data.Id,
                    successfulActionCode = backendActionCode,
                    viewInListAffected = model.Data.ViewInList
                }));
            }

            return(JsonHtml("Properties", model));
        }
Example #6
0
        public Mapper(INavigationService navigationService)
        {
            _navigationService = navigationService ?? throw new ArgumentNullException(nameof(navigationService));

            var config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap <Settings, Configuration>()
                .ForMember(c => c.Salt, act => {
                    act.MapFrom(s => Encoding.ASCII.GetBytes(s.Salt));
                });
                cfg.CreateMap <IConfiguration, Settings>()
                .ForMember(s => s.Salt, act => {
                    act.MapFrom(c => Encoding.ASCII.GetString(c.Salt));
                });

                cfg.CreateMap <Item, ItemViewModel>()
                .ForMember(vm => vm.Tags, act => {
                    act.MapFrom(i => string.Join(", ", i.Tags));
                })
                .ForMember(vm => vm.Fields, act => {
                    act.MapFrom((i, vm) =>
                    {
                        return(i.Fields
                               .Select(f => FieldViewModel.Create(f, vm, this, _navigationService))
                               .ToArray());
                    });
                });
                cfg.CreateMap <ItemViewModel, Item>()
                .ForMember(i => i.Tags, act => {
                    act.MapFrom((vm, i) =>
                    {
                        if (string.IsNullOrWhiteSpace(vm.Tags))
                        {
                            return(new string[0]);
                        }

                        return(vm.Tags.Split(',', StringSplitOptions.RemoveEmptyEntries)
                               .Where(t => !string.IsNullOrWhiteSpace(t))
                               .Select(t => t.Trim())
                               .ToArray());
                    });
                })
                .ForMember(i => i.Fields, act => {
                    act.MapFrom((vm, i) =>
                    {
                        return(vm.Fields.Select(f => f.Model).ToArray());
                    });
                });

                cfg.CreateMap <SingleLineTextField, SingleLineTextFieldViewModel>();
                cfg.CreateMap <SingleLineTextFieldViewModel, SingleLineTextField>();
                cfg.CreateMap <MultiLineTextField, MultiLineTextFieldViewModel>();
                cfg.CreateMap <MultiLineTextFieldViewModel, MultiLineTextField>();
                cfg.CreateMap <PasswordField, PasswordFieldViewModel>();
                cfg.CreateMap <PasswordFieldViewModel, PasswordField>();

                cfg.CreateMap <IConfiguration, SettingsViewModel>();
                cfg.CreateMap <IConfiguration, Configuration>();
                cfg.CreateMap <SettingsViewModel, Configuration>();
            }
                                                 );

            _mapper = new AutoMapper.Mapper(config);
        }