public override async Task<IDisplayResult> EditAsync(ContentItem model, IUpdateModel updater)
{
// This method can get called when a new content item is created, at that point
// the query string contains a ListPart.ContainerId value, or when an
// existing content item has ContainedPart value. In both cases the hidden field
// needs to be rendered in the edit form to maintain the relationship with the parent.
if (model.Is<ContainedPart>())
{
return BuildShape(model.As<ContainedPart>().ListContentItemId);
}
var viewModel = new EditContainedPartViewModel();
if ( await updater.TryUpdateModelAsync(viewModel, "ListPart"))
{
// We are editing a content item that needs to be added to a container
// so we render the container id as part of the form
return BuildShape(viewModel.ContainerId);
}
return null;
}
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> 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 async Task <IDisplayResult> UpdateAsync(AliasPart model, IUpdateModel updater)
{
var settings = GetAliasPartSettings(model);
await updater.TryUpdateModelAsync(model, Prefix, t => t.Alias);
await ValidateAsync(model, updater);
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(ValuesField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditValuesFieldViewModel();
await updater.TryUpdateModelAsync(model, Prefix, m => m.Data);
field.Data = JsonConvert.DeserializeObject <List <string> >(model.Data);
return(Edit(field, context));
}
public override async Task <IDisplayResult> UpdateAsync(PersonPart part, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new PersonPartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix);
part.BirthDateUtc = viewModel.BirthDateUtc;
part.Name = viewModel.Name;
part.Handedness = viewModel.Handedness;
return(Edit(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(MarkdownBodyPart model, IUpdateModel updater)
{
var viewModel = new MarkdownBodyPartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Source);
model.Markdown = viewModel.Source;
return(Edit(model));
}
private async Task <PagerSlim> GetPagerAsync(IUpdateModel updater, ListPart part)
{
var settings = GetSettings(part);
PagerSlimParameters pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
PagerSlim pager = new PagerSlim(pagerParameters, settings.PageSize);
return(pager);
}
private async Task <PagerSlim> GetPagerAsync(IUpdateModel updater, CrossReferencePart part, string partName)
{
var settings = GetSettings(part, partName);
PagerSlimParameters pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
PagerSlim pager = new PagerSlim(pagerParameters, settings.PageSize);
return(pager);
}
public override async Task <IDisplayResult> UpdateAsync(HtmlBodyPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new HtmlBodyPartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Source);
model.Html = viewModel.Source;
return(Edit(model, context));
}
public override async Task<bool> ValidateModelAsync(UserRegistration registration, IUpdateModel updater)
{
return await updater.TryUpdateModelAsync(new RegisterViewModel
{
UserName = registration.UserName,
Email = registration.Email,
Password = registration.Password,
ConfirmPassword = registration.ConfirmPassword
});
}
private async Task <PagerSlim> GetPagerAsync(IUpdateModel updater, TaxonomyPart part)
{
//var settings = GetSettings(part);
PagerSlimParameters pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
PagerSlim pager = new PagerSlim(pagerParameters, 10);
return(pager);
}
public override async Task <bool> ValidateModelAsync(EditProfileViewModel viewModel, IUpdateModel updater)
{
return(await updater.TryUpdateModelAsync(new EditProfileViewModel()
{
DisplayName = viewModel.DisplayName,
Location = viewModel.Location,
Biography = viewModel.Biography,
Url = viewModel.Url
}));
}
public override async Task <IDisplayResult> UpdateAsync(AliasPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
await updater.TryUpdateModelAsync(model, Prefix, t => t.Alias);
await foreach (var item in model.ValidateAsync(S, _session))
{
updater.ModelState.BindValidationResult(Prefix, item);
}
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(MultiSelectField field, IUpdateModel updater, UpdateFieldEditorContext context)
{
var model = new EditMultiSelectFieldViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix, m => m.SelectedValues))
{
field.SelectedValues = model.SelectedValues;
}
return(Edit(field, context));
}
public async override Task <IDisplayResult> UpdateAsync(DataTablePart part, IUpdateModel updater)
{
DataTablePartViewModel viewModel = new DataTablePartViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix))
{
part.JsonData = viewModel.JsonData;
}
return(Edit(part));
}
public override async Task <IDisplayResult> UpdateAsync(ISite model, PublishSetting section, IUpdateModel updater, BuildEditorContext context)
{
if (groupId == context.GroupId)
{
if (!await updater.TryUpdateModelAsync(section, Prefix))
{
return(null);
}
}
return(await EditAsync(section, context));
}
public async override Task <IDisplayResult> UpdateAsync(GalleryPart part, IUpdateModel updater)
{
var viewModel = new GalleryPartEditViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix))
{
part.MediaItems = JsonConvert.DeserializeObject <GalleryPartItem[]>(viewModel.MediaItems);
}
return(Edit(part));
}
public async override Task <IDisplayResult> UpdateAsync(SubscriptionAccessPart part, IUpdateModel updater)
{
var model = new SubscriptionAccessPartViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
part.SubscriptionSelection = model.SubscriptionSelection;
}
return(Edit(part));
}
public override async Task <IDisplayResult> UpdateAsync(LabelPart part, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new LabelPartEditViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix))
{
part.For = viewModel.For?.Trim();
}
return(Edit(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(TaxonomyTermPickerField field, IUpdateModel updater,
UpdateFieldEditorContext context)
{
//"#metadata_FaqWidget_TaxonomyTermPicker .4ffz2b0z1zwjqw0c7dz90k1fnm"
var vm = new TaxonomyTermPickerFieldViewModel();
if (await updater.TryUpdateModelAsync(vm, Prefix))
{
var termContentItemIds = new List <TaxonomyTermIdentifier>();
var selectedTerms = vm.ModelTermEntries.Where(x => x.Selected).ToList();
// var selectedTerms = vm.AvailableTaxonomies.SelectMany(x=> x.Terms).Where(x => x.Selected).ToList();
if (selectedTerms.Any())
{
// var taxonomy = await _contentManager.GetAsync(field.TaxonomyContentItemId, VersionOptions.Latest);
foreach (var selectedTerm in selectedTerms)
{
var boundtaxonomyId = selectedTerm.TermContentItemId; // selectedTerm.BoundTaxonomyId;
// var taxonomy = await _contentManager.GetAsync(boundtaxonomyId, VersionOptions.Latest);
//var termContentItem =GetTermContentItem(selectedTerm, taxonomy);
//if (termContentItem != null)
// {
termContentItemIds.Add(new TaxonomyTermIdentifier()
{
TaxonomyContentItemId = boundtaxonomyId,
TermContentItemId = selectedTerm.TermContentItemId
}
);
// }
}
}
field.TermContentItemEntries = termContentItemIds;
// 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 async override Task <IDisplayResult> UpdateAsync(FormInputElementPart part, IUpdateModel updater)
{
var viewModel = new FormInputElementPartEditViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix))
{
part.Name = viewModel.Name?.Trim();
}
return(Edit(part));
}
public override async Task <IDisplayResult> UpdateAsync(PoiPart part, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new PoiPartEditViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Latitude, t => t.Longitude);
part.Latitude = viewModel.Latitude;
part.Longitude = viewModel.Longitude;
return(Edit(part, context));
}
public async override Task <IDisplayResult> UpdateAsync(ValidationPart part, IUpdateModel updater)
{
var viewModel = new ValidationPartEditViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix))
{
part.For = viewModel.For?.Trim();
}
return(Edit(part));
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem model, IUpdateModel updater)
{
var viewModel = new EditContainedPartViewModel();
if (await updater.TryUpdateModelAsync(viewModel, nameof(ListPart)) && viewModel.ContainerId != null)
{
model.Alter <ContainedPart>(x => x.ListContentItemId = viewModel.ContainerId);
}
return(await base.UpdateAsync(model, updater));
}
//
public override async Task <IDisplayResult> UpdateAsync(BookMarkActionPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
//nothing to update. Only adding so favoritepart is added to json so that summary display type is called
// var settings = GetPartSettings(model);
//
// await updater.TryUpdateModelAsync(model, Prefix, t => t.IsFavorite);
await updater.TryUpdateModelAsync(model, Prefix, t => t.Title, t => t.Icon);
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(PricePart pricePart, IUpdateModel updater, UpdatePartEditorContext context)
{
var updateModel = new PricePartViewModel();
if (await updater.TryUpdateModelAsync(updateModel, Prefix, t => t.PriceValue, t => t.PriceCurrency))
{
pricePart.Price = _moneyService.Create(updateModel.PriceValue, updateModel.PriceCurrency);
}
return(Edit(pricePart, context));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPermissionsPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
await updater.TryUpdateModelAsync(model, Prefix, m => m.Enabled, m => m.Roles);
if (!model.Enabled)
{
model.Roles = Array.Empty <string>();
}
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(Query model, IUpdateModel updater)
{
await updater.TryUpdateModelAsync(model, Prefix, m => m.Name, m => m.Source);
if (String.IsNullOrEmpty(model.Name))
{
updater.ModelState.AddModelError(nameof(model.Name), S["Name is required"]);
}
return(await EditAsync(model, updater));
}
public async override Task <IDisplayResult> UpdateAsync(SubscriptionGroupPart part, IUpdateModel updater)
{
var model = new SubscriptionGroupPartEditViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
part.Identifier = model.Identifier;
}
return(Edit(part));
}
public override async Task <IDisplayResult> UpdateAsync(CodeField 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(SqlQuery model, IUpdateModel updater)
{
var viewModel = new SqlQueryViewModel();
if (await updater.TryUpdateModelAsync(viewModel, Prefix, m => m.Query, m => m.ReturnDocuments))
{
model.Template = viewModel.Query;
model.ReturnDocuments = viewModel.ReturnDocuments;
}
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(FacebookPluginPart model, IUpdateModel updater)
{
var viewModel = new FacebookPluginPartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Liquid);
model.Liquid = viewModel.Liquid;
await ValidateAsync(model, updater);
return(Edit(model));
}
public override async Task<IDisplayResult> UpdateAsync(ContentItem model, IUpdateModel updater)
{
var viewModel = new EditContainedPartViewModel();
if (await updater.TryUpdateModelAsync(viewModel, "ListPart"))
{
model.Weld<ContainedPart>();
model.Alter<ContainedPart>(x => x.ListContentItemId = viewModel.ContainerId);
}
return await base.UpdateAsync(model, updater);
}
public override IEnumerable<TemplateViewModel> TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel)
{
var model = new ContentTypeSettingsViewModel();
updateModel.TryUpdateModelAsync(model, "ContentTypeSettingsViewModel").Wait();
builder.Creatable(model.Creatable);
builder.Listable(model.Listable);
builder.Draftable(model.Draftable);
builder.Securable(model.Securable);
builder.WithSetting("Stereotype", model.Stereotype);
yield return DefinitionTemplate(model);
}
public override async Task<IDisplayResult> UpdateAsync(ContentItem contentItem, IUpdateModel updater)
{
var testContentPart = contentItem.As<TestContentPartA>();
if (testContentPart == null)
{
return null;
}
if (await updater.TryUpdateModelAsync(testContentPart, ""))
{
if (testContentPart.Line.EndsWith(" "))
{
updater.ModelState.AddModelError(nameof(testContentPart.Line), "Value cannot end with a space");
}
else
{
contentItem.Weld(testContentPart);
}
}
return Shape("TestContentPartA_Edit", testContentPart).Location("Content");
}
