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)); }