public override IEnumerable<TemplateViewModel> PartEditorUpdate(ContentPartDefinitionBuilder builder, IUpdateModel updateModel) { var model = new ContentPartSettings(); updateModel.TryUpdateModel(model, "ContentPartSettings", null, null); builder.Attachable(model.Attachable); yield return DefinitionTemplate(model); }
public async Task FilterAsync(IQuery<ContentItem> query, ListContentsViewModel model, PagerParameters pagerParameters, IUpdateModel updateModel) { var viewModel = new ListPartContentAdminFilterModel(); if(await updateModel.TryUpdateModelAsync(viewModel, "")) { // Show list content items if (viewModel.ShowListContentTypes) { var listableTypes = _contentDefinitionManager .ListTypeDefinitions() .Where(x => x.Parts.Any(p => p.PartDefinition.Name == nameof(ListPart))) .Select(x => x.Name); query.With<ContentItemIndex>(x => x.ContentType.IsIn(listableTypes)); } // Show contained elements for the specified list else if(viewModel.ListContentItemId != 0) { query.With<ContainedPartIndex>(x => x.ListContentItemId == viewModel.ListContentItemId); } } }
public override IEnumerable<TemplateViewModel> PartFieldEditorUpdate(ContentPartFieldDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.FieldType != "ReferenceField") { yield break; } var model = new ReferenceFieldSettings(); if (updateModel.TryUpdateModel(model, "ReferenceFieldSettings", null, null)) { UpdateSettings(model, builder, "ReferenceFieldSettings"); if (model.QueryId <= 0) { model.QueryId = CreateQuery(model.ContentTypeName.ToString(CultureInfo.InvariantCulture)); } if (model.RelationshipId <= 0) { var httpContext = _httpContextAccessor.Current(); var routeValues = httpContext.Request.RequestContext.RouteData.Values; var entityName = routeValues["id"].ToString(); model.RelationshipId = _relationshipService.CreateOneToManyRelationship(builder.Name, model.RelationshipName, model.ContentTypeName, entityName); } if (model.QueryId <= 0 || model.RelationshipId <= 0) { updateModel.AddModelError("QueryOrRelation", T("Invalid Query or Relationship Id")); yield break; } UpdateSettings(model, builder, "ReferenceFieldSettings"); builder.WithSetting("ReferenceFieldSettings.DisplayAsLink", model.DisplayAsLink.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("ReferenceFieldSettings.ContentTypeName", model.ContentTypeName.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("ReferenceFieldSettings.RelationshipName", model.RelationshipName.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("ReferenceFieldSettings.RelationshipId", model.RelationshipId.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("ReferenceFieldSettings.QueryId", model.QueryId.ToString(CultureInfo.InvariantCulture)); } yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> PartFieldEditorUpdate(ContentPartFieldDefinitionBuilder builder, IUpdateModel updateModel) { if (!builder.FieldType.Equals(typeof(MoneyField).Name)) yield break; var model = new MoneyFieldSettings(); if (updateModel.TryUpdateModel(model, typeof(MoneyFieldSettings).Name, null, null)) { if (string.IsNullOrEmpty(model.DefaultCurrency)) { builder.WithSetting("MoneyFieldSettings.DefaultCurrency", Currency.FromCurrentCulture().Iso3LetterCode); } else { Currency parsedCurrency; if (Currency.TryParse(model.DefaultCurrency, out parsedCurrency)) { builder.WithSetting("MoneyFieldSettings.DefaultCurrency", model.DefaultCurrency); } else { updateModel.AddModelError("InvalidCurrencyIsoCode", T("MoneyField - Invalid currency iso code was given.")); } } builder.WithSetting("MoneyFieldSettings.IsCurrencyReadOnly", model.IsCurrencyReadOnly.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("MoneyFieldSettings.Hint", model.Hint); builder.WithSetting("MoneyFieldSettings.Required", model.Required.ToString(CultureInfo.InvariantCulture)); } yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != typeof (TermPart).Name) yield break; var settings = new ExtraTermPartSettings(); updateModel.TryUpdateModel(settings, typeof (ExtraTermPartSettings).Name, null, null); builder.WithSetting("ExtraTermPartSettings.OnlyDirectChildren", settings.OnlyDirectChildren.ToString()); }
public Task<dynamic> UpdateTypeEditorAsync(ContentTypeDefinition contentTypeDefinition, IUpdateModel updater, string groupId) { if (contentTypeDefinition == null) { throw new ArgumentNullException(nameof(contentTypeDefinition)); } dynamic contentTypeDefinitionShape = CreateContentShape("ContentTypeDefinition_Edit"); contentTypeDefinitionShape.ContentTypeDefinition = contentTypeDefinition; _contentDefinitionManager.AlterTypeDefinition(contentTypeDefinition.Name, typeBuilder => { var typeContext = new UpdateTypeEditorContext( typeBuilder, contentTypeDefinitionShape, groupId, _shapeFactory, _layoutAccessor.GetLayout(), updater ); BindPlacementAsync(typeContext).Wait(); _handlers.InvokeAsync(handler => handler.UpdateTypeEditorAsync(contentTypeDefinition, typeContext), Logger).Wait(); }); return Task.FromResult<dynamic>(contentTypeDefinitionShape); }
public dynamic UpdateSettings(IUpdateModel updater) { var settings = _contentManager.Get<SeoGlobalSettingsPart>(GetGlobalSettings().ContentItem.Id, VersionOptions.DraftRequired); var editor = _contentManager.UpdateEditor(settings, updater); _contentManager.Publish(settings.ContentItem); return editor; }
public UpdateEditorContext(IShape model, IContent content, IUpdateModel updater, string groupInfoId, IShapeFactory shapeFactory, ShapeTable shapeTable, string path) : base(model, content, groupInfoId, shapeFactory) { ShapeTable = shapeTable; Updater = updater; Path = path; }
public override IDisplayResult Display(ContentItem contentItem, IUpdateModel updater) { var testContentPart = contentItem.As<TestContentPartA>(); if (testContentPart == null) { return null; } return Combine( // A new shape is created and the properties of the object are bound to it when rendered Shape("TestContentPartA", testContentPart).Location("Detail", "Content"), // New shape, no initialization, custom location Shape("LowerDoll").Location("Detail", "Footer"), // New shape Shape("TestContentPartA", ctx => ctx.New.TestContentPartA().Creating(_creating++), shape => { shape.Processing = _processing++; return Task.CompletedTask; }) .Location("Detail", "Content") .Cache("lowerdoll2", cache => cache.During(TimeSpan.FromSeconds(5))), // A strongly typed shape model is used and initialized when rendered Shape<TestContentPartAShape>(shape => { shape.Line = "Strongly typed shape"; return Task.CompletedTask; }) .Location("Detail", "Content:2"), // Cached shape Shape("LowerDoll") .Location("Detail", "/Footer") .Cache("lowerdoll", cache => cache.During(TimeSpan.FromSeconds(5))) ); }
public override IEnumerable<TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != "RelatedContentPart") yield break; var viewModel = new PropertyFieldsViewModel(); updateModel.TryUpdateModel(viewModel, "PropertyFieldsViewModel", null, null); var settings = new RelatedContentRelationshipSettings(); foreach (var relationshipFieldsModel in viewModel.Fields) { settings.DisplayName += String.Format("<field>{0}</field>", relationshipFieldsModel.DisplayName); settings.RelatedContentFields += String.Format("<field>{0}</field>", relationshipFieldsModel.RelatedContentFields); settings.RelatedcontentType += String.Format("<field>{0}</field>", relationshipFieldsModel.RelatedcontentType); } builder.WithSetting("RelatedContentRelationshipSettings.RelatedcontentType", settings.RelatedcontentType); builder.WithSetting("RelatedContentRelationshipSettings.RelatedContentFields", settings.RelatedContentFields); builder.WithSetting("RelatedContentRelationshipSettings.DisplayName", settings.DisplayName); var model = GetModel(settings); yield return DefinitionTemplate(model); }
public dynamic UpdateEditor(IContent content, IUpdateModel updater, string groupInfoId) { var contentKey = "ContentUpdate:" + content.Id.ToString(); _profiler.StepStart(contentKey, String.Format("Content Update: {0}", content.Id)); var result = _innerContentDisplay.UpdateEditor(content, updater, groupInfoId); _profiler.StepStop(contentKey); return result; }
public dynamic UpdateEditor(IContent content, IUpdateModel updater, string groupId = "") { var shape = _origami.ContentShape(content, "", true); var builder = _origami.ContentBuilder(content).WithMode("Editor").WithUpdater(updater, ""); if (!String.IsNullOrWhiteSpace(groupId)) builder.WithGroup(groupId); _origami.Build(builder, shape); return shape; }
public override IEnumerable<TemplateViewModel> PartEditorUpdate(ContentPartDefinitionBuilder builder, IUpdateModel updateModel) { var model = new ContentPartSettings(); updateModel.TryUpdateModelAsync(model, "ContentPartSettings").Wait(); builder.Attachable(model.Attachable); builder.WithDescription(model.Description); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var model = new ExperimentalSettings(); updateModel.TryUpdateModel(model, "ExperimentalSettings", null, null); builder .WithSetting("ExperimentalSettings.ShowDebugLinks", model.ShowDebugLinks ? true.ToString() : null); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var model = new SecurableContentItemsSettingsViewModel(); updateModel.TryUpdateModel(model, "SecurableContentItemsSettingsViewModel", null, null); builder.WithSetting("ContentPermissionsTypeSettings.SecurableContentItems", model.SecurableContentItems.ToString()); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var model = new ContentTypeSettings(); updateModel.TryUpdateModel(model, "ContentTypeSettings", null, null); builder.Creatable(model.Creatable); builder.Draftable(model.Draftable); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var model = new AssociativyTaxonomiesAdapterTypeSettings(); updateModel.TryUpdateModel(model, "AssociativyTaxonomiesAdapterTypeSettings", null, null); builder.WithSetting("AssociativyTaxonomiesAdapterTypeSettings.GraphNamesSerialized", model.GraphNamesSerialized); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> PartFieldEditorUpdate(ContentPartFieldDefinitionBuilder builder, IUpdateModel updateModel) { var model = new DateTimeFieldSettings(); if(updateModel.TryUpdateModel(model, "DateTimeFieldSettings", null, null)) { builder.WithSetting("DateTimeFieldSettings.Display", model.Display.ToString()); } yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var model = new DynamicTypeSettingsViewModel(); updateModel.TryUpdateModel(model, "DynamicTypeSettingsViewModel", null, null); builder.WithSetting("DynamicTypeSettings.IsDeployed", model.IsDeployed.ToString()); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> PartFieldEditorUpdate(ContentPartFieldDefinitionBuilder builder, IUpdateModel updateModel) { var model = new HtmlFieldSettings(); if (updateModel.TryUpdateModel(model, "HtmlFieldSettings", null, null)) { builder.WithSetting("HtmlFieldSettings.FlavorDefault", model.FlavorDefault); } yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != typeof(AuthorablePart).Name) yield break; var model = new AuthorablePartSettings(); updateModel.TryUpdateModel(model, typeof (AuthorablePartSettings).Name, null, null); builder.WithSetting(string.Format("{0}.{1}", typeof(AuthorablePartSettings).Name, model.AutomaticallyAssignEditorToAuthors.GetType().Name), model.AutomaticallyAssignEditorToAuthors.ToString()); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name == "CommonPart") { var model = new DateEditorSettings(); if (updateModel.TryUpdateModel(model, "DateEditorSettings", null, null)) { builder.WithSetting("DateEditorSettings.ShowDateEditor", model.ShowDateEditor.ToString()); } yield return DefinitionTemplate(model); } }
public override IEnumerable<TemplateViewModel> PartFieldEditorUpdate(ContentPartFieldDefinitionBuilder builder, IUpdateModel updateModel) { var model = new FieldIndexing(); updateModel.TryUpdateModel(model, "FieldIndexing", null, null); builder.WithSetting("FieldIndexing.Included", model.Included ? true.ToString() : null); CreateIndexingTasks(); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var model = new TypeIndexing(); updateModel.TryUpdateModel(model, "TypeIndexing", null, null); builder.WithSetting("TypeIndexing.Indexes", model.Indexes); CreateIndexingTasks(); yield return DefinitionTemplate(model); }
public dynamic DisplayElement( Element element, IContent content, string displayType = null, IUpdateModel updater = null, string renderEventName = null, string renderEventArgs = null) { var createShapeContext = new ElementCreatingDisplayShapeContext { Element = element, DisplayType = displayType, Content = content, }; element.Descriptor.CreatingDisplay(createShapeContext); var typeName = element.GetType().Name; var category = element.Category.ToSafeName(); var drivers = element.Descriptor.GetDrivers(); var elementShapeArguments = CreateArguments(element, content); var elementShape = (dynamic)_shapeFactory.Create("Element", elementShapeArguments, () => new ZoneHolding(() => _shapeFactory.Create("ElementZone"))); elementShape.Metadata.DisplayType = displayType; elementShape.Metadata.Alternates.Add(String.Format("Elements_{0}", typeName)); elementShape.Metadata.Alternates.Add(String.Format("Elements_{0}_{1}", typeName, displayType)); elementShape.Metadata.Alternates.Add(String.Format("Elements_{0}__{1}", typeName, category)); elementShape.Metadata.Alternates.Add(String.Format("Elements_{0}_{1}__{2}", typeName, displayType, category)); var displayContext = new ElementDisplayContext { Element = element, ElementShape = elementShape, DisplayType = displayType, Content = content, Updater = updater, RenderEventName = renderEventName, RenderEventArgs = renderEventArgs }; _elementEventHandlerHandler.Displaying(displayContext); InvokeDrivers(drivers, driver => driver.Displaying(displayContext)); element.Descriptor.Display(displayContext); var container = element as Container; if (container != null) { if (container.Elements.Any()) { foreach (var child in container.Elements) { var childShape = DisplayElement(child, content, displayType: displayType, updater: updater); childShape.Parent = elementShape; elementShape.Add(childShape); } } } return elementShape; }
public override IEnumerable<TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != "ElementWrapperPart") yield break; var model = new ElementWrapperPartSettings(); updateModel.TryUpdateModel(model, "ElementWrapperPartSettings", null, null); builder.WithSetting("ElementWrapperPartSettings.ElementTypeName", model.ElementTypeName); yield return DefinitionTemplate(model); }
public override IEnumerable<TemplateViewModel> PartEditorUpdate(ContentPartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != "BodyPart") yield break; var model = new BodyPartSettings(); updateModel.TryUpdateModel(model, "BodyPartSettings", null, null); builder.WithSetting("BodyPartSettings.FlavorDefault", !string.IsNullOrWhiteSpace(model.FlavorDefault) ? model.FlavorDefault : null); yield return DefinitionTemplate(model); }
protected BuildShapeContext(IShape shape, string groupId, IShapeFactory shapeFactory, IShape layout, IUpdateModel updater) { Shape = shape; ShapeFactory = shapeFactory; GroupId = groupId; Layout = layout; FindPlacement = FindDefaultPlacement; Updater = updater; }
public override IDisplayResult Edit(ContentTypePartDefinition model, IUpdateModel updater) { if (!String.Equals("BodyPart", model.PartDefinition.Name, StringComparison.Ordinal)) { return null; } return Shape("BodyPartSettings_Edit", new { ContentPart = model }).Location("Content"); }
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var settings = builder.Current.Settings; if (settings.ContainsKey("Stereotype") && settings["Stereotype"] == "Media") { var model = new MediaFileNameEditorSettings(); if (updateModel.TryUpdateModel(model, "MediaFileNameEditorSettings", null, null)) { builder.WithSetting("MediaFileNameEditorSettings.ShowFileNameEditor", model.ShowFileNameEditor.ToString()); } } return base.TypeEditorUpdate(builder, updateModel); }
public override async Task <IDisplayResult> UpdateAsync(BooleanField field, IUpdateModel updater, UpdateFieldEditorContext context) { await updater.TryUpdateModelAsync(field, Prefix, f => f.Value); return(Edit(field, context)); }
public override async Task <IDisplayResult> UpdateAsync(LayerSettings settings, IUpdateModel updater, string groupId) { if (groupId == GroupId) { var model = new LayerSettingsViewModel(); await updater.TryUpdateModelAsync(model, Prefix); settings.Zones = model.Zones.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries); } return(Edit(settings)); }
public override IDisplayResult Edit(ContentTypePartDefinition contentTypePartDefinition, IUpdateModel updater) { if (!String.Equals(nameof(MarkdownBodyPart), contentTypePartDefinition.PartDefinition.Name, StringComparison.Ordinal)) { return(null); } return(Initialize <MarkdownBodyPartSettingsViewModel>("MarkdownBodyPartSettings_Edit", model => { var settings = contentTypePartDefinition.GetSettings <MarkdownBodyPartSettings>(); model.Editor = settings.Editor; model.MarkdownBodyPartSettings = settings; }).Location("Content")); }
public override async Task <IDisplayResult> UpdateAsync(ResponsiveMediaField field, IUpdateModel updater, UpdateFieldEditorContext context) { if (await updater.TryUpdateModelAsync(field, Prefix, f => f.Data)) { var settings = context.PartFieldDefinition.GetSettings <ResponsiveMediaFieldSettings>(); if (settings.Required && !JsonConvert.DeserializeObject <IList <ResponsiveMediaItem> >(field.Data).Any()) { updater.ModelState.AddModelError(Prefix, S["{0}: Media is required.", context.PartFieldDefinition.DisplayName()]); } } return(Edit(field, context)); }
public virtual Task <IDisplayResult> UpdateAsync(TModel model, IUpdateModel updater) { return(EditAsync(model, updater)); }
public static async Task <IHtmlContent> DisplayAsync(this OrchardRazorHelper razorHelper, ContentItem content, string displayType = "", string groupId = "", IUpdateModel updater = null) { var displayManager = razorHelper.HttpContext.RequestServices.GetService <IContentItemDisplayManager>(); var shape = await displayManager.BuildDisplayAsync(content, updater, displayType, groupId); return(await razorHelper.DisplayHelper(shape)); }
public virtual IDisplayResult Edit(TModel model, IUpdateModel updater) { return(Edit(model)); }
public override Task <bool> ValidateModelAsync(DocComment comment, IUpdateModel updater) { // ensure tags are optional return(Task.FromResult(true)); }
protected override DriverResult Editor(ContentPart part, Fields.DbFilesField field, IUpdateModel updater, dynamic shapeHelper) { var viewModel = new DbFilesFieldEditViewModel(); if (updater.TryUpdateModel(viewModel, GetPrefix(field, part), null, null)) { if (!string.IsNullOrEmpty(viewModel.DeleteIds)) { var idsToDelete = viewModel.DeleteIds.Split(','); foreach (var id in idsToDelete) { _dbFilesService.DeleteFile(id); } } var request = ((Controller)updater).Request; var settings = field.PartFieldDefinition.Settings.GetModel <DbFilesFieldSettings>(); var keyName = "DbFiles-" + field.Name; var postedFiles = new List <HttpPostedFileBase>(); for (var i = 0; i < request.Files.Count; i++) { if (request.Files.GetKey(i).Equals(keyName)) { var postedFile = request.Files[i]; if (postedFile != null && postedFile.InputStream.Length > 0) { postedFiles.Add(postedFile); } } } if (settings.Required) { var existingFiles = _dbFilesService.GetFilesForField(field.Name, part.ContentItem.Id); if (!existingFiles.Any() && !postedFiles.Any()) { updater.AddModelError(GetPrefix(field, part), T("{0} is required.", field.DisplayName)); return(Editor(part, field, shapeHelper)); } } try { foreach (var postedFile in postedFiles) { if (postedFile.ContentLength / 1000 > settings.MaxKb) { updater.AddModelError(GetPrefix(field, part), T("{0} is too large.", postedFile.FileName)); } else { var document = new byte[postedFile.ContentLength]; postedFile.InputStream.Read(document, 0, postedFile.ContentLength); var record = new FileUploadRecord { FileData = document, IdContent = part.ContentItem.Id, FieldName = field.Name, FileName = Path.GetFileName(postedFile.FileName), ContentType = postedFile.ContentType }; _fileUploadRepository.Create(record); } } } catch (Exception ex) { updater.AddModelError(GetPrefix(field, part), T("Failed to save {0} - {1}.", field.DisplayName, ex.Message)); } } return(Editor(part, field, shapeHelper)); }
public override IEnumerable <TemplateViewModel> PartFieldEditorUpdate(ContentPartFieldDefinitionBuilder builder, IUpdateModel updateModel) { var previous = builder.Current.Settings.GetModel <FieldIndexing>(); var model = new FieldIndexing(); updateModel.TryUpdateModel(model, "FieldIndexing", null, null); builder.WithSetting("FieldIndexing.Included", model.Included ? true.ToString() : null); // create indexing tasks only if settings have changed if (model.Included != previous.Included) { // if a field setting has changed, all existing content items need to be re-indexed CreateIndexingTasks(); } yield return(DefinitionTemplate(model)); }
// POST protected override DriverResult Editor(AvatarsSettingsPart part, IUpdateModel updater, dynamic shapeHelper) { updater.TryUpdateModel(part, Prefix, null, null); return(Editor(part, shapeHelper)); }
public override IEnumerable <TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { var previous = builder.Current.Settings.GetModel <TypeIndexing>(); var model = new TypeIndexing(); updateModel.TryUpdateModel(model, "TypeIndexing", null, null); builder.WithSetting("TypeIndexing.Indexes", model.Indexes); // create indexing tasks only if settings have changed if (Clean(model.Indexes) != Clean(previous.Indexes)) { // if a an index is added, all existing content items need to be re-indexed CreateIndexingTasks(); } yield return(DefinitionTemplate(model)); }
public override async Task <IDisplayResult> UpdateAsync(HttpsSettings settings, IUpdateModel updater, string groupId) { if (groupId == SettingsGroupId) { var model = new HttpsSettingsViewModel(); await updater.TryUpdateModelAsync(model, Prefix); settings.RequireHttps = model.RequireHttps; settings.RequireHttpsPermanent = model.RequireHttpsPermanent; settings.SslPort = model.SslPort; } if (_memoryCache.Get(RestartPendingCacheKey) == null) { var entry = _memoryCache.CreateEntry(RestartPendingCacheKey); _memoryCache.Set(entry.Key, entry, new MemoryCacheEntryOptions { Priority = CacheItemPriority.NeverRemove }); } return(Edit(settings)); }
public void AlterType(EditTypeViewModel typeViewModel, IUpdateModel updateModel) { var updater = new PrefixedModelUpdater(updateModel); _contentDefinitionManager.AlterTypeDefinition(typeViewModel.Name, typeBuilder => { typeBuilder.DisplayedAs(typeViewModel.DisplayName); // allow extensions to alter type configuration _contentDefinitionEditorEvents.Invoke(x => x.TypeEditorUpdating(typeBuilder), Logger); typeViewModel.Templates = _contentDefinitionEditorEvents.Invoke(x => x.TypeEditorUpdate(typeBuilder, updater), Logger); _contentDefinitionEditorEvents.Invoke(x => x.TypeEditorUpdated(typeBuilder), Logger); foreach (var part in typeViewModel.Parts) { var partViewModel = part; // enable updater to be aware of changing part prefix updater.Prefix = secondHalf => String.Format("{0}.{1}", partViewModel.Prefix, secondHalf); // allow extensions to alter typePart configuration typeBuilder.WithPart(partViewModel.PartDefinition.Name, typePartBuilder => { _contentDefinitionEditorEvents.Invoke(x => x.TypePartEditorUpdating(typePartBuilder), Logger); partViewModel.Templates = _contentDefinitionEditorEvents.Invoke(x => x.TypePartEditorUpdate(typePartBuilder, updater), Logger); _contentDefinitionEditorEvents.Invoke(x => x.TypePartEditorUpdated(typePartBuilder), Logger); }); if (!partViewModel.PartDefinition.Fields.Any()) { continue; } _contentDefinitionManager.AlterPartDefinition(partViewModel.PartDefinition.Name, partBuilder => { var fieldFirstHalf = String.Format("{0}.{1}", partViewModel.Prefix, partViewModel.PartDefinition.Prefix); foreach (var field in partViewModel.PartDefinition.Fields) { var fieldViewModel = field; // enable updater to be aware of changing field prefix updater.Prefix = secondHalf => String.Format("{0}.{1}.{2}", fieldFirstHalf, fieldViewModel.Prefix, secondHalf); // allow extensions to alter partField configuration partBuilder.WithField(fieldViewModel.Name, partFieldBuilder => { _contentDefinitionEditorEvents.Invoke(x => x.PartFieldEditorUpdating(partFieldBuilder), Logger); fieldViewModel.Templates = _contentDefinitionEditorEvents.Invoke(x => x.PartFieldEditorUpdate(partFieldBuilder, updater), Logger); _contentDefinitionEditorEvents.Invoke(x => x.PartFieldEditorUpdated(partFieldBuilder), Logger); }); } }); } if (typeViewModel.Fields.Any()) { _contentDefinitionManager.AlterPartDefinition(typeViewModel.Name, partBuilder => { foreach (var field in typeViewModel.Fields) { var fieldViewModel = field; // enable updater to be aware of changing field prefix updater.Prefix = secondHalf => string.Format("{0}.{1}", fieldViewModel.Prefix, secondHalf); // allow extensions to alter partField configuration partBuilder.WithField(fieldViewModel.Name, partFieldBuilder => { _contentDefinitionEditorEvents.Invoke(x => x.PartFieldEditorUpdating(partFieldBuilder), Logger); fieldViewModel.Templates = _contentDefinitionEditorEvents.Invoke(x => x.PartFieldEditorUpdate(partFieldBuilder, updater), Logger); _contentDefinitionEditorEvents.Invoke(x => x.PartFieldEditorUpdated(partFieldBuilder), Logger); }); } }); } }); }
public override async Task <IDisplayResult> UpdateAsync(FacebookPluginPart model, IUpdateModel updater) { var viewModel = new FacebookPluginPartViewModel(); if (await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Liquid)) { if (!string.IsNullOrEmpty(viewModel.Liquid) && !_liquidTemplatemanager.Validate(viewModel.Liquid, out var errors)) { updater.ModelState.AddModelError(nameof(model.Liquid), T["The FaceBook Body doesn't contain a valid Liquid expression. Details: {0}", string.Join(" ", errors)]); } else { model.Liquid = viewModel.Liquid; } } return(Edit(model)); }
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != "DataRestrictionsPart") { yield break; } var model = new DataRestrictionsPartSettings(); updateModel.TryUpdateModel(model, "DataRestrictionsPartSettings", null, null); builder.WithSetting("DataRestrictionsPartSettings.RestrictionsDefault", model.RestricitonsDefault); builder.WithSetting("DataRestrictionsPartSettings.ForceDefault", ((bool)model.ForceDefault).ToString()); yield return(DefinitionTemplate(model)); }
public override void UpdateFieldSettings(string fieldType, string fieldName, SettingsDictionary settingsDictionary, IUpdateModel updateModel) { if (fieldType != "CurrencyField") { return; } var model = new CurrencyFieldSettings(); if (updateModel.TryUpdateModel(model, "CurrencyFieldSettings", null, null)) { UpdateSettings(model, settingsDictionary, "CurrencyFieldSettings"); settingsDictionary["CurrencyFieldSettings.Length"] = model.Length.ToString("D"); settingsDictionary["CurrencyFieldSettings.DecimalPlaces"] = model.DecimalPlaces.ToString("D"); settingsDictionary["CurrencyFieldSettings.DefaultValue"] = model.DefaultValue.ToString(); } }
public override async Task <IDisplayResult> UpdateAsync(CommentatorPart model, IUpdateModel updater) { var settings = GetCommentatorPartSettings(model); await updater.TryUpdateModelAsync(model, Prefix, t => t.AllowComments); return(Edit(model)); }
public override async Task <IDisplayResult> UpdateAsync(JavascriptCondition condition, IUpdateModel updater) { var model = new JavascriptConditionViewModel(); if (await updater.TryUpdateModelAsync(model, Prefix)) { // TODO is empty. condition.Script = model.Script; } return(Edit(condition)); }
public virtual Task <IDisplayResult> EditAsync(TModel model, IUpdateModel updater) { return(Task.FromResult(Edit(model, updater))); }
public virtual IDisplayResult Display(TModel model, IUpdateModel updater) { return(Display(model)); }
public override async Task <IDisplayResult> UpdateAsync(LocalizationSetContentPickerField field, IUpdateModel updater, UpdateFieldEditorContext context) { var viewModel = new EditLocalizationSetContentPickerFieldViewModel(); var modelUpdated = await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.LocalizationSets); if (!modelUpdated) { return(Edit(field, context)); } field.LocalizationSets = viewModel.LocalizationSets == null ? new string[0] : viewModel.LocalizationSets.Split(',', StringSplitOptions.RemoveEmptyEntries); var settings = context.PartFieldDefinition.GetSettings <LocalizationSetContentPickerFieldSettings>(); if (settings.Required && field.LocalizationSets.Length == 0) { updater.ModelState.AddModelError(Prefix, nameof(field.LocalizationSets), S["The {0} field is required.", context.PartFieldDefinition.DisplayName()]); } if (!settings.Multiple && field.LocalizationSets.Length > 1) { updater.ModelState.AddModelError(Prefix, nameof(field.LocalizationSets), S["The {0} field cannot contain multiple items.", context.PartFieldDefinition.DisplayName()]); } return(Edit(field, context)); }
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != "SeoPart") { yield break; } var settings = new SeoPartSettings(); if (updateModel.TryUpdateModel(settings, "SeoPartSettings", null, null)) { builder.WithSetting("SeoPartSettings.AddCanonicalLink", settings.AddCanonicalLink.ToString()); builder.WithSetting("SeoPartSettings.DefaultDescriptionPattern", settings.DefaultDescriptionPattern); builder.WithSetting("SeoPartSettings.DefaultKeywordsPattern", settings.DefaultKeywordsPattern); builder.WithSetting("SeoPartSettings.DefaultRobotsMeta", settings.DefaultRobotsMeta.ToString()); } yield return(DefinitionTemplate(settings)); }
public override IEnumerable <TemplateViewModel> TypePartEditorUpdate(ContentTypePartDefinitionBuilder builder, IUpdateModel updateModel) { if (builder.Name != "ContentPermissionsPart") { yield break; } if (!_authorizer.Authorize(Permissions.GrantPermission)) { yield break; } var allRoles = _roleService.GetRoles().Select(x => x.Name).OrderBy(x => x).ToList(); var model = new ContentPermissionsPartViewModel(); updateModel.TryUpdateModel(model, "ContentPermissionsPartViewModel", null, null); // update permissions only for those the current user is granted if (_authorizer.Authorize(Core.Contents.Permissions.ViewContent)) { builder.WithSetting("ContentPermissionsPartSettings.View", ContentPermissionsPartViewModel.SerializePermissions(model.ViewRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.ViewOwnContent)) { builder.WithSetting("ContentPermissionsPartSettings.ViewOwn", ContentPermissionsPartViewModel.SerializePermissions(model.ViewOwnRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.PublishContent)) { builder.WithSetting("ContentPermissionsPartSettings.Publish", ContentPermissionsPartViewModel.SerializePermissions(model.PublishRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.PublishOwnContent)) { builder.WithSetting("ContentPermissionsPartSettings.PublishOwn", ContentPermissionsPartViewModel.SerializePermissions(model.PublishOwnRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.EditContent)) { builder.WithSetting("ContentPermissionsPartSettings.Edit", ContentPermissionsPartViewModel.SerializePermissions(model.EditRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.EditOwnContent)) { builder.WithSetting("ContentPermissionsPartSettings.EditOwn", ContentPermissionsPartViewModel.SerializePermissions(model.EditOwnRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.DeleteContent)) { builder.WithSetting("ContentPermissionsPartSettings.Delete", ContentPermissionsPartViewModel.SerializePermissions(model.DeleteRoles)); } if (_authorizer.Authorize(Core.Contents.Permissions.DeleteOwnContent)) { builder.WithSetting("ContentPermissionsPartSettings.DeleteOwn", ContentPermissionsPartViewModel.SerializePermissions(model.DeleteOwnRoles)); } builder.WithSetting("ContentPermissionsPartSettings.DisplayedRoles", ContentPermissionsPartViewModel.SerializePermissions(model.AllRoles)); // disable permissions the current user doesn't have model.ViewRoles = model.ViewRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.ViewContent) }).ToList(); model.ViewOwnRoles = model.ViewOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.ViewOwnContent) }).ToList(); model.PublishRoles = model.PublishRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.PublishContent) }).ToList(); model.PublishOwnRoles = model.PublishOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.PublishOwnContent) }).ToList(); model.EditRoles = model.EditRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.EditContent) }).ToList(); model.EditOwnRoles = model.EditOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.EditOwnContent) }).ToList(); model.DeleteRoles = model.DeleteRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.DeleteContent) }).ToList(); model.DeleteOwnRoles = model.DeleteOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.DeleteOwnContent) }).ToList(); // initialize default value model.ViewRoles = model.ViewRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewContent, UserSimulation.Create(x.Role), null) }).ToList(); model.ViewOwnRoles = model.ViewOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewOwnContent, UserSimulation.Create(x.Role), null) }).ToList(); model.PublishRoles = model.PublishRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishContent, UserSimulation.Create(x.Role), null) }).ToList(); model.PublishOwnRoles = model.PublishOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishOwnContent, UserSimulation.Create(x.Role), null) }).ToList(); model.EditRoles = model.EditRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditContent, UserSimulation.Create(x.Role), null) }).ToList(); model.EditOwnRoles = model.EditOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditOwnContent, UserSimulation.Create(x.Role), null) }).ToList(); model.DeleteRoles = model.DeleteRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteContent, UserSimulation.Create(x.Role), null) }).ToList(); model.DeleteOwnRoles = model.DeleteOwnRoles.Select(x => new RoleEntry { Role = x.Role, Checked = x.Checked, Enabled = x.Enabled, Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteOwnContent, UserSimulation.Create(x.Role), null) }).ToList(); yield return(DefinitionTemplate(model)); }
public override async Task <IDisplayResult> UpdateAsync(PlaceholderAdminNode treeNode, IUpdateModel updater) { var model = new PlaceholderAdminNodeViewModel(); if (await updater.TryUpdateModelAsync(model, Prefix, x => x.LinkText, x => x.IconClass, x => x.PermissionIds)) { treeNode.LinkText = model.LinkText; treeNode.IconClass = model.IconClass; var modifiedPermissions = (model.PermissionIds == null ? new string[0] : model.PermissionIds.Split(',', StringSplitOptions.RemoveEmptyEntries)); //clear the old permissions to insert all every time treeNode.Permissions.Clear(); //change permissions only if one is inserted if (modifiedPermissions.Length > 0) { var permissions = await _permissionService.GetInstalledPermissionsAsync(); foreach (var permissionName in modifiedPermissions) { var perm = permissions.Where(p => p.Name == permissionName).FirstOrDefault(); if (perm != null) { treeNode.Permissions.Add(perm); } } } treeNode.RenderIfEmpty = model.RenderIfEmpty; } ; return(Edit(treeNode)); }
public override async Task <IDisplayResult> UpdateAsync(MarkdownPart model, IUpdateModel updater) { await updater.TryUpdateModelAsync(model, Prefix, t => t.Markdown); return(Edit(model)); }
private ElementEditorContext CreateEditorContext(IContent content, Element element, ElementDataDictionary elementData, IUpdateModel updater, dynamic shapeFactory) { var context = new ElementEditorContext { Content = content, Element = element, Updater = updater, ValueProvider = elementData.ToValueProvider(_cultureAccessor.CurrentCulture), ElementData = elementData, ShapeFactory = shapeFactory, Prefix = Prefix }; return(context); }
public override async Task <IDisplayResult> UpdateAsync(LinkAdminNode treeNode, IUpdateModel updater) { var model = new LinkAdminNodeViewModel(); if (await updater.TryUpdateModelAsync(model, Prefix, x => x.LinkUrl, x => x.LinkText, x => x.IconClass)) { treeNode.LinkText = model.LinkText; treeNode.LinkUrl = model.LinkUrl; treeNode.IconClass = model.IconClass; } ; return(Edit(treeNode)); }
public override IDisplayResult Edit(ContentTypePartDefinition contentTypePartDefinition, IUpdateModel updater) { if (!String.Equals(nameof(ListPart), contentTypePartDefinition.PartDefinition.Name, StringComparison.Ordinal)) { return(null); } return(Shape <ListPartSettingsViewModel>("ListPartSettings_Edit", model => { model.ListPartSettings = contentTypePartDefinition.Settings.ToObject <ListPartSettings>(); model.PageSize = model.ListPartSettings.PageSize; model.ContainedContentTypes = model.ListPartSettings.ContainedContentTypes; model.ContentTypes = new NameValueCollection(); foreach (var contentTypeDefinition in _contentDefinitionManager.ListTypeDefinitions()) { model.ContentTypes.Add(contentTypeDefinition.Name, contentTypeDefinition.DisplayName); } }).Location("Content")); }
protected override DriverResult Editor(ContentPart part, Fields.ContentPickerField field, IUpdateModel updater, dynamic shapeHelper) { var model = new ContentPickerFieldViewModel { SelectedIds = string.Join(",", field.Ids) }; updater.TryUpdateModel(model, GetPrefix(field, part), null, null); var settings = field.PartFieldDefinition.Settings.GetModel <ContentPickerFieldSettings>(); if (String.IsNullOrEmpty(model.SelectedIds)) { field.Ids = new int[0]; } else { field.Ids = model.SelectedIds.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray(); } if (settings.Required && field.Ids.Length == 0) { updater.AddModelError("Id", T("The {0} field is required.", field.Name.CamelFriendly())); } return(Editor(part, field, shapeHelper)); }