public override async Task <IDisplayResult> UpdateAsync(TextField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
await updater.TryUpdateModelAsync(field, Prefix, f => f.Text);
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(MultiTextField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditMultiTextFieldViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix))
{
field.Values = viewModel.Values;
var settings = context.PartFieldDefinition.GetSettings <MultiTextFieldSettings>();
if (settings.Required && !viewModel.Values.Any())
{
updater.ModelState.AddModelError(Prefix, nameof(field.Values), S["A value is required for {0}.", context.PartFieldDefinition.DisplayName()]);
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(Fields.MultiValueTextField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditMultiValueTextFieldViewModel();
var modelUpdated = await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.Values);
if (!modelUpdated)
{
return(Edit(field, context));
}
field.Values = viewModel.Values;
var settings = context.PartFieldDefinition.GetSettings <MultiValueTextFieldSettings>();
if (settings.Required && field.Values.Length == 0)
{
updater.ModelState.AddModelError(Prefix, nameof(field.Values), S["The {0} field is required.", context.PartFieldDefinition.DisplayName()]);
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(UserPickerField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditUserPickerFieldViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.UserIds))
{
field.UserIds = viewModel.UserIds == null
? Array.Empty <string>() : viewModel.UserIds.Split(',', StringSplitOptions.RemoveEmptyEntries);
var settings = context.PartFieldDefinition.GetSettings <UserPickerFieldSettings>();
if (settings.Required && field.UserIds.Length == 0)
{
updater.ModelState.AddModelError(Prefix, nameof(field.UserIds), S["The {0} field is required.", context.PartFieldDefinition.DisplayName()]);
}
if (!settings.Multiple && field.UserIds.Length > 1)
{
updater.ModelState.AddModelError(Prefix, nameof(field.UserIds), S["The {0} field cannot contain multiple items.", context.PartFieldDefinition.DisplayName()]);
}
var users = await _session.Query <User, UserIndex>().Where(x => x.UserId.IsIn(field.UserIds)).ListAsync();
field.SetUserNames(users.Select(t => t.UserName).ToArray());
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(NumericField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditNumericFieldViewModel();
bool modelUpdated = await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.Value);
if (modelUpdated)
{
decimal value;
var settings = context.PartFieldDefinition.Settings.ToObject <NumericFieldSettings>();
field.Value = null;
if (string.IsNullOrWhiteSpace(viewModel.Value))
{
if (settings.Required)
{
updater.ModelState.AddModelError(Prefix, T["The {0} field is required.", context.PartFieldDefinition.DisplayName()]);
}
}
else if (!decimal.TryParse(viewModel.Value, NumberStyles.Any, _cultureInfo, out value))
{
updater.ModelState.AddModelError(Prefix, T["{0} is an invalid number.", context.PartFieldDefinition.DisplayName()]);
}
else
{
field.Value = value;
if (settings.Minimum.HasValue && value < settings.Minimum.Value)
{
updater.ModelState.AddModelError(Prefix, T["The value must be greater than {0}.", settings.Minimum.Value]);
}
if (settings.Maximum.HasValue && value > settings.Maximum.Value)
{
updater.ModelState.AddModelError(Prefix, T["The value must be less than {0}.", settings.Maximum.Value]);
}
// checking the number of decimals
if (Math.Round(value, settings.Scale) != value)
{
if (settings.Scale == 0)
{
updater.ModelState.AddModelError(Prefix, T["The {0} field must be an integer.", context.PartFieldDefinition.DisplayName()]);
}
else
{
updater.ModelState.AddModelError(Prefix, T["Invalid number of digits for {0}, max allowed: {1}.", context.PartFieldDefinition.DisplayName(), settings.Scale]);
}
}
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(MarkdownField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditMarkdownFieldViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix, vm => vm.Markdown))
{
if (!string.IsNullOrEmpty(viewModel.Markdown) && !_liquidTemplateManager.Validate(viewModel.Markdown, out var errors))
{
var fieldName = context.PartFieldDefinition.DisplayName();
updater.ModelState.AddModelError(Prefix, nameof(viewModel.Markdown), S["{0} field doesn't contain a valid Liquid expression. Details: {1}", fieldName, string.Join(" ", errors)]);
}
else
{
field.Markdown = viewModel.Markdown;
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(TaxonomyField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditTaxonomyFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
var settings = context.PartFieldDefinition.GetSettings <TaxonomyFieldSettings>();
field.TaxonomyContentItemId = settings.TaxonomyContentItemId;
field.TermContentItemIds = model.TermEntries.Where(x => x.Selected).Select(x => x.ContentItemId).ToArray();
if (settings.Required && field.TermContentItemIds.Length == 0)
{
updater.ModelState.AddModelError(
nameof(EditTaxonomyFieldViewModel.TermEntries),
S["A value is required for '{0}'", context.PartFieldDefinition.DisplayName()]);
}
// Update display text for tags.
var taxonomy = await _contentManager.GetAsync(settings.TaxonomyContentItemId, VersionOptions.Latest);
if (taxonomy == null)
{
return(null);
}
var terms = new List <ContentItem>();
foreach (var termContentItemId in field.TermContentItemIds)
{
var term = TaxonomyOrchardHelperExtensions.FindTerm(taxonomy.Content.TaxonomyPart.Terms as JArray, termContentItemId);
terms.Add(term);
}
field.SetTagNames(terms.Select(t => t.DisplayText).ToArray());
}
return(Edit(field, context));
}
public virtual IDisplayResult Update(TField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
return(null);
}
public override async Task <IDisplayResult> UpdateAsync(MediaField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditMediaFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix, f => f.Paths))
{
field.Paths = JsonConvert.DeserializeObject <string[]>(model.Paths);
var settings = context.PartFieldDefinition.Settings.ToObject <MediaFieldSettings>();
if (settings.Required && field.Paths.Length < 1)
{
updater.ModelState.AddModelError(Prefix, S["{0}: A media is required.", context.PartFieldDefinition.DisplayName()]);
}
if (field.Paths.Length > 1 && !settings.Multiple)
{
updater.ModelState.AddModelError(Prefix, S["{0}: Selecting multiple media is forbidden.", context.PartFieldDefinition.DisplayName()]);
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(HtmlField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditHtmlFieldViewModel();
var settings = context.PartFieldDefinition.GetSettings <HtmlFieldSettings>();
if (await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.Html))
{
if (!string.IsNullOrEmpty(viewModel.Html) && !_liquidTemplateManager.Validate(viewModel.Html, out var errors))
{
var fieldName = context.PartFieldDefinition.DisplayName();
context.Updater.ModelState.AddModelError(Prefix, nameof(viewModel.Html), S["{0} doesn't contain a valid Liquid expression. Details: {1}", fieldName, string.Join(" ", errors)]);
}
else
{
field.Html = settings.SanitizeHtml ? _htmlSanitizerService.Sanitize(viewModel.Html) : viewModel.Html;
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(ColourField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditCodeFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix, m => m.Value))
{
field.Value = model.Value;
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(DateTimeField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditDateTimeFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix, f => f.LocalDateTime))
{
if (model.LocalDateTime == null)
{
field.Value = null;
}
else
{
field.Value = await _localClock.ConvertToUtcAsync(model.LocalDateTime.Value);
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPickerField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditContentPickerFieldViewModel();
var modelUpdated = await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.ContentItemIds);
if (!modelUpdated)
{
return(Edit(field, context));
}
field.ContentItemIds = viewModel.ContentItemIds == null
? new string[0] : viewModel.ContentItemIds.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var settings = context.PartFieldDefinition.Settings.ToObject <ContentPickerFieldSettings>();
if (settings.Required && field.ContentItemIds.Length == 0)
{
updater.ModelState.AddModelError(Prefix, T["The {0} field is required.", context.PartFieldDefinition.DisplayName()]);
}
if (!settings.Multiple && field.ContentItemIds.Length > 1)
{
updater.ModelState.AddModelError(Prefix, T["The {0} field cannot contain multiple items.", context.PartFieldDefinition.DisplayName()]);
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(LinkField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
bool modelUpdated = await updater.TryUpdateModelAsync(field, Prefix, f => f.Url, f => f.Text);
if (modelUpdated)
{
var settings = context.PartFieldDefinition.GetSettings <LinkFieldSettings>();
if (settings.Required && String.IsNullOrWhiteSpace(field.Url))
{
updater.ModelState.AddModelError(Prefix, T["The url is required for {0}.", context.PartFieldDefinition.DisplayName()]);
}
else if (!string.IsNullOrWhiteSpace(field.Url) && !Uri.IsWellFormedUriString(field.Url, UriKind.RelativeOrAbsolute))
{
updater.ModelState.AddModelError(Prefix, T["{0} is an invalid url.", field.Url]);
}
else if (settings.LinkTextMode == LinkTextMode.Required && string.IsNullOrWhiteSpace(field.Text))
{
updater.ModelState.AddModelError(Prefix, T["The link text is required for {0}.", context.PartFieldDefinition.DisplayName()]);
}
else if (settings.LinkTextMode == LinkTextMode.Static && string.IsNullOrWhiteSpace(settings.DefaultText))
{
updater.ModelState.AddModelError(Prefix, T["The text default value is required for {0}.", context.PartFieldDefinition.DisplayName()]);
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(YoutubeField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
EditYoutubeFieldViewModel model = new EditYoutubeFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
var settings = context.PartFieldDefinition.Settings.ToObject <YoutubeFieldSettings>();
if (settings.Required && String.IsNullOrWhiteSpace(model.RawAddress))
{
updater.ModelState.AddModelError(Prefix, T["A value is required for '{0}'.", context.PartFieldDefinition.DisplayName()]);
}
else
{
if (model.RawAddress != null)
{
var uri = new Uri(model.RawAddress);
// if it is a url with QueryString
if (!String.IsNullOrWhiteSpace(uri.Query))
{
var query = QueryHelpers.ParseQuery(uri.Query);
if (query.ContainsKey("v"))
{
model.EmbeddedAddress = $"{uri.GetLeftPart(UriPartial.Authority)}/embed/{query["v"]}";
}
else
{
updater.ModelState.AddModelError(Prefix + "." + nameof(model.RawAddress), T["The format of the url is invalid"]);
}
}
else
{
var path = uri.AbsolutePath.Split('?')[0];
model.EmbeddedAddress = $"{uri.GetLeftPart(UriPartial.Authority)}/embed/{path}";
}
field.RawAddress = model.RawAddress;
field.EmbeddedAddress = model.EmbeddedAddress;
}
}
}
return(Edit(field, context));
}
public virtual Task <IDisplayResult> UpdateAsync(TField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
return(Task.FromResult(Update(field, updater, context)));
}
public override async Task <IDisplayResult> UpdateAsync(TaxonomyField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
if (String.Equals(context.PartFieldDefinition.Editor(), "Contained", StringComparison.OrdinalIgnoreCase))
{
var model = new EditTaxonomyFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
var settings = context.PartFieldDefinition.GetSettings <TaxonomyFieldSettings>();
field.TaxonomyContentItemId = settings.TaxonomyContentItemId;
field.TermContentItemIds = model.TermEntries.Where(x => x.Selected).Select(x => x.ContentItemId).ToArray();
if (settings.Unique && !String.IsNullOrEmpty(model.UniqueValue))
{
field.TermContentItemIds = new[] { model.UniqueValue };
}
if (settings.Required && field.TermContentItemIds.Length == 0)
{
updater.ModelState.AddModelError(
nameof(EditTaxonomyFieldViewModel.TermEntries),
S["A value is required for '{0}'", context.PartFieldDefinition.Name]);
}
}
}
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(EnumerationField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
// var vm= new EditEnumerationFieldViewModel();
bool modelUpdated = await updater.TryUpdateModelAsync(field, Prefix, f => f.Value, f => f.SelectedValues);
if (modelUpdated)
{
var settings = context.PartFieldDefinition.GetSettings <EnumerationFieldSettings>();
switch (settings.ListMode)
{
case ListMode.Dropdown:
field.SelectedValues = new string[] {};
break;
case ListMode.Radiobutton:
field.SelectedValues = new string[] {};
break;
case ListMode.Listbox:
field.Value = string.Empty;
break;
case ListMode.Checkbox:
field.Value = string.Empty;
break;
}
if (settings.Required && field.SelectedValues.Length == 0)
{
updater.ModelState.AddModelError(Prefix, T["The field is required for {0}.", context.PartFieldDefinition.DisplayName()]);
}
// else if (!string.IsNullOrWhiteSpace(field.Url) && !Uri.IsWellFormedUriString(field.Url, UriKind.RelativeOrAbsolute))
// {
// updater.ModelState.AddModelError(Prefix, T["{0} is an invalid url.", field.Url]);
// }
// else if (settings.LinkTextMode == LinkTextMode.Required && string.IsNullOrWhiteSpace(field.Text))
// {
// updater.ModelState.AddModelError(Prefix, T["The link text is required for {0}.", context.PartFieldDefinition.DisplayName()]);
// }
// else if (settings.LinkTextMode == LinkTextMode.Static && string.IsNullOrWhiteSpace(settings.DefaultText))
// {
// updater.ModelState.AddModelError(Prefix, T["The text default value is required for {0}.", context.PartFieldDefinition.DisplayName()]);
// }
}
return(Edit(field, context));
}
// NEXT STATION: Settings/ColorFieldSettings
public override async Task <IDisplayResult> UpdateAsync(ColorField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var viewModel = new EditColorFieldViewModel();
// Using this overload of the model updater you can specifically say what properties need to be updated.
// This way you make sure no other properties will be bound to the view model. Instead of this you could put
// [BindNever] attributes to the properties to make the model binder to skip those, it's up to you.
if (await updater.TryUpdateModelAsync(viewModel, Prefix, f => f.Value, f => f.ColorName))
{
// Get the ColorFieldSettings to use it when validating the view model.
var settings = context.PartFieldDefinition.GetSettings <ColorFieldSettings>();
if (settings.Required && string.IsNullOrWhiteSpace(field.Value))
{
updater.ModelState.AddModelError(Prefix, T["A value is required for {0}.", context.PartFieldDefinition.DisplayName()]);
}
// Also some custom validation for our ColorField hex value. Could be done in the view model instead.
if (!string.IsNullOrWhiteSpace(field.Value) &&
!Regex.IsMatch(viewModel.Value, "^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$"))
{
updater.ModelState.AddModelError(Prefix, T["The given color is invalid."]);
}
field.ColorName = viewModel.ColorName;
field.Value = viewModel.Value;
}
return(Edit(field, context));
}
