// ColorFieldSettings.Edit.cshtml file will contain the editor inputs.
public override async Task <IDisplayResult> UpdateAsync(
ContentPartFieldDefinition partFieldDefinition,
UpdatePartFieldEditorContext context)
{
var model = new ColorFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
// A content field or a content part can have multiple settings. These settings are stored in a single JSON
// object. This helper will merge our settings to this JSON object so these will be stored.
context.Builder.MergeSettings <ColorFieldSettings>(settings => settings = model);
return(Edit(partFieldDefinition));
}
public override async Task<IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (!String.Equals("TextField", partFieldDefinition.FieldDefinition.Name, StringComparison.Ordinal))
{
return null;
}
var model = new TextFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.Hint(model.Hint);
return Edit(partFieldDefinition);
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new BooleanFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.Hint(model.Hint);
context.Builder.WithSetting(nameof(model.Label), model.Label);
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new LinkFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.MergeSettings(model);
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new HtmlSettingsViewModel();
var settings = new HtmlFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
settings.SanitizeHtml = model.SanitizeHtml;
settings.Hint = model.Hint;
context.Builder.WithSettings(settings);
return(Edit(partFieldDefinition));
}
public Task UpdatePartFieldEditorAsync(ContentPartFieldDefinition model, UpdatePartFieldEditorContext context)
{
return _partFieldDisplayDrivers.InvokeAsync(async contentDisplay =>
{
var result = await contentDisplay.UpdateEditorAsync(model, context);
if (result != null)
result.Apply(context);
}, Logger);
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.Editor() == "PredefinedList")
{
var model = new PredefinedListSettingsViewModel();
var settings = new TextFieldPredefinedListEditorSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
try
{
settings.DefaultValue = model.DefaultValue;
settings.Editor = model.Editor;
settings.Options = string.IsNullOrWhiteSpace(model.Options)
? new ListValueOption[0]
: JsonConvert.DeserializeObject <ListValueOption[]>(model.Options);
}
catch
{
context.Updater.ModelState.AddModelError(Prefix, S["The options are written in an incorrect format."]);
return(Edit(partFieldDefinition));
}
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (!String.Equals(nameof(TextField), partFieldDefinition.FieldDefinition.Name, StringComparison.Ordinal))
{
return(null);
}
var model = new TextFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.Hint(model.Hint);
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new UpdateResponsiveMediaFieldSettingsViewModel();
await context.Updater.TryUpdateModelAsync(model, Prefix);
var settings = new ResponsiveMediaFieldSettings
{
Hint = model.Hint,
Required = model.Required
};
try
{
settings.Breakpoints = model.Breakpoints;
settings.GetBreakpoints();
} catch
{
context.Updater.ModelState.AddModelError(Prefix, T["Failed to parse breakpoints, make sure it only contains numeric values."]);
}
context.Builder.MergeSettings(settings);
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new ContentPickerFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.MergeSettings(model);
context.Builder.WithSetting(nameof(ContentPickerFieldSettings.DisplayedContentTypes), model.DisplayedContentTypes);
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.DisplayMode() == "Header")
{
var model = new HeaderSettingsViewModel();
var settings = new TextFieldHeaderDisplaySettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
settings.Level = model.Level;
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new UserPickerFieldSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
var settings = new UserPickerFieldSettings
{
Hint = model.Hint,
Required = model.Required,
Multiple = model.Multiple
};
var selectedRoles = model.Roles.Where(x => x.IsSelected).Select(x => x.Role).ToArray();
if (model.DisplayAllUsers || selectedRoles.Length == 0)
{
// No selected role should have the same effect as display all users
settings.DisplayedRoles = Array.Empty <string>();
settings.DisplayAllUsers = true;
}
else
{
settings.DisplayedRoles = selectedRoles;
settings.DisplayAllUsers = false;
}
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition, context.Updater));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new ContentPickerFieldSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
if (model.DisplayAllContentTypes)
{
model.DisplayedContentTypes = Array.Empty <String>();
}
context.Builder.WithSettings(model);
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new UserPickerFieldSettingsViewModel();
var settings = new UserPickerFieldSettings();
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
settings.Hint = model.Hint;
settings.Required = model.Required;
settings.Multiple = model.Multiple;
settings.DisplayAllUsers = model.DisplayAllUsers;
if (settings.DisplayAllUsers)
{
settings.DisplayedRoles = Array.Empty <String>();
}
else
{
settings.DisplayedRoles = model.Roles.Where(x => x.IsSelected).Select(x => x.Role).ToArray();
}
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var settings = new ValuesFieldSettings();
if (await context.Updater.TryUpdateModelAsync(settings, Prefix))
{
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public Task<dynamic> UpdatePartFieldEditorAsync(ContentPartFieldDefinition contentPartFieldDefinition, IUpdateModel updater, string groupId = "")
{
if (contentPartFieldDefinition == null)
{
throw new ArgumentNullException(nameof(contentPartFieldDefinition));
}
var contentPartDefinition = contentPartFieldDefinition.PartDefinition;
dynamic partFieldDefinitionShape = CreateContentShape("ContentPartFieldDefinition_Edit");
_contentDefinitionManager.AlterPartDefinition(contentPartDefinition.Name, partBuilder =>
{
partBuilder.WithField(contentPartFieldDefinition.Name, async partFieldBuilder =>
{
partFieldDefinitionShape.ContentField = contentPartFieldDefinition;
var fieldContext = new UpdatePartFieldEditorContext(
partFieldBuilder,
partFieldDefinitionShape,
groupId,
_shapeFactory,
_layoutAccessor.GetLayout(),
updater
);
await BindPlacementAsync(fieldContext);
await _handlers.InvokeAsync(handler => handler.UpdatePartFieldEditorAsync(contentPartFieldDefinition, fieldContext), Logger);
});
});
return Task.FromResult<dynamic>(partFieldDefinitionShape);
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new TextProductAttributeSettingsViewModel();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder
.WithSettings(new TextProductAttributeFieldSettings
{
Hint = model.Hint,
DefaultValue = model.DefaultValue,
Required = model.Required,
Placeholder = model.Placeholder,
RestrictToPredefinedValues = model.RestrictToPredefinedValues,
MultipleValues = model.MultipleValues,
PredefinedValues = (model.PredefinedValues ?? "")
.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
.Select(v => v.Trim())
.Where(v => !String.IsNullOrWhiteSpace(v))
.ToArray()
});
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.Editor() == "CKEditorClassic")
{
var model = new HtmlFieldCKEditorClassicSettingsViewModel();
var settings = new HtmlFieldCKEditorClassicSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix, m => m.SelectedConfigurationName);
settings.ConfigurationName = model.SelectedConfigurationName;
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition model, UpdatePartFieldEditorContext context)
{
var viewModel = new EditCodeFieldSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(viewModel, Prefix))
{
context.Builder.WithSettings(new CodeFieldSettings
{
Language = viewModel.Language
});
}
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.Editor() == "Elastic")
{
var model = new ContentPickerFieldElasticEditorSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.WithSettings(model);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.Editor() == "Trumbowyg")
{
var model = new TrumbowygSettingsViewModel();
var settings = new HtmlFieldTrumbowygEditorSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
settings.InsertMediaWithUrl = model.InsertMediaWithUrl;
try
{
settings.Options = model.Options;
JObject.Parse(settings.Options);
}
catch
{
context.Updater.ModelState.AddModelError(Prefix, S["The options are written in an incorrect format."]);
return(Edit(partFieldDefinition));
}
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition model, UpdatePartFieldEditorContext context)
{
var viewModel = new EditMultiSelectFieldSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(viewModel, Prefix))
{
context.Builder.WithSettings(new MultiSelectFieldSettings
{
Hint = viewModel.Hint,
Options = string.IsNullOrWhiteSpace(viewModel.OptionsJson) ? Array.Empty <string>() : JsonConvert.DeserializeObject <string[]>(viewModel.OptionsJson)
});
}
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new EditAccordionFieldSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
context.Builder.WithSettings(new AccordionFieldSettings());
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition contentPartFieldDefinition, UpdatePartFieldEditorContext context)
{
if (!await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User, Permissions.ManageIndexes))
{
return(null);
}
var model = new ContentIndexSettingsViewModel();
await context.Updater.TryUpdateModelAsync(model, Prefix);
context.Builder.WithSettings(model.ContentIndexSettings);
return(await EditAsync(contentPartFieldDefinition, context.Updater));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var settings = new DictionaryFieldSettings();
if (await context.Updater.TryUpdateModelAsync(settings, Prefix))
{
// This makes sure the JSON is correctly formatted as it comes from the front end
// with incorrect casing
try
{
settings.DefaultData = JsonConvert.SerializeObject(JsonConvert.DeserializeObject <IList <DictionaryItem> >(settings.DefaultData));
}
catch (Exception e)
{
_logger.LogError(e, "Error parsing DefaultData for DictionaryFieldSettings");
}
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.DisplayMode() == "Prism")
{
var model = new PrismSettingsViewModel();
var settings = new HtmlFieldPrismDisplaySettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
settings.Theme = model.Theme;
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
if (partFieldDefinition.Editor() == "Monaco")
{
var model = new MonacoSettingsViewModel();
var settings = new TextFieldMonacoEditorSettings();
await context.Updater.TryUpdateModelAsync(model, Prefix);
if (!model.Options.IsJson())
{
context.Updater.ModelState.AddModelError(Prefix + "." + nameof(MonacoSettingsViewModel.Options), S["The options are written in an incorrect format."]);
}
else
{
settings.Options = model.Options;
context.Builder.WithSettings(settings);
}
}
return(Edit(partFieldDefinition, context.Updater));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition model, UpdatePartFieldEditorContext context)
{
var viewModel = new EditColourFieldSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(viewModel, Prefix))
{
context.Builder.WithSettings(new ColourFieldSettings
{
AllowCustom = viewModel.AllowCustom,
AllowTransparent = viewModel.AllowTransparent,
Colours = JsonConvert.DeserializeObject <ColourItem[]>(viewModel.Colours),
DefaultValue = viewModel.DefaultValue,
Hint = viewModel.Hint,
UseGlobalColours = viewModel.UseGlobalColours
});
}
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition model, UpdatePartFieldEditorContext context)
{
var viewModel = new UpdateResponsiveMediaFieldSettingsViewModel();
await context.Updater.TryUpdateModelAsync(viewModel, Prefix);
var settings = new ResponsiveMediaFieldSettings
{
AllowMediaText = viewModel.AllowMediaText,
Hint = viewModel.Hint,
Multiple = viewModel.Multiple,
Required = viewModel.Required,
FallbackData = JsonConvert.SerializeObject(ResponsiveMediaUtils.ParseMedia(_mediaFileStore, viewModel.FallbackData))
};
try
{
settings.Breakpoints = viewModel.Breakpoints;
settings.GetBreakpoints();
} catch
{
context.Updater.ModelState.AddModelError(Prefix, T["Failed to parse breakpoints, make sure it only contains numeric values."]);
}
context.Builder.WithSettings(settings);
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartFieldDefinition partFieldDefinition, UpdatePartFieldEditorContext context)
{
var model = new MultiTextFieldSettingsViewModel();
var settings = new MultiTextFieldSettings();
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
settings.Required = model.Required;
settings.Hint = model.Hint;
try
{
settings.Options = JsonConvert.DeserializeObject <MultiTextFieldValueOption[]>(model.Options);
}
catch
{
context.Updater.ModelState.AddModelError(Prefix, S["The options are written in an incorrect format."]);
return(Edit(partFieldDefinition));
}
context.Builder.WithSettings(settings);
}
return(Edit(partFieldDefinition));
}
