public override async Task <IDisplayResult> UpdateAsync(FlowPart part, UpdatePartEditorContext context)
{
var contentItemDisplayManager = _serviceProvider.GetRequiredService <IContentItemDisplayManager>();
var model = new FlowPartEditViewModel {
FlowPart = part
};
await context.Updater.TryUpdateModelAsync(model, Prefix);
part.Widgets.Clear();
for (var i = 0; i < model.Prefixes.Length; i++)
{
var contentItem = await _contentManager.NewAsync(model.ContentTypes[i]);
contentItem.Weld(new FlowMetadata());
var widgetModel = await contentItemDisplayManager.UpdateEditorAsync(contentItem, context.Updater, context.IsNew, htmlFieldPrefix : model.Prefixes[i]);
part.Widgets.Add(contentItem);
}
return(Edit(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(BagPart part, UpdatePartEditorContext context)
{
var contentItemDisplayManager = _serviceProvider.GetRequiredService <IContentItemDisplayManager>();
var model = new BagPartEditViewModel {
BagPart = part
};
await context.Updater.TryUpdateModelAsync(model, Prefix);
var contentItems = new List <ContentItem>();
for (var i = 0; i < model.Prefixes.Length; i++)
{
var contentItem = await _contentManager.NewAsync(model.ContentTypes[i]);
var existingContentItem = part.ContentItems.FirstOrDefault(x => String.Equals(x.ContentItemId, model.Prefixes[i], StringComparison.OrdinalIgnoreCase));
// When the content item already exists merge its elements to preverse nested content item ids.
// All of the data for these merged items is then replaced by the model values on update, while a nested content item id is maintained.
// This prevents nested items which rely on the content item id, i.e. the media attached field, losing their reference point.
if (existingContentItem != null)
{
contentItem.ContentItemId = model.Prefixes[i];
contentItem.Merge(existingContentItem);
}
var widgetModel = await contentItemDisplayManager.UpdateEditorAsync(contentItem, context.Updater, context.IsNew, htmlFieldPrefix : model.Prefixes[i]);
contentItems.Add(contentItem);
}
part.ContentItems = contentItems;
return(Edit(part, context));
}
Task <IDisplayResult> IContentPartDisplayDriver.UpdateEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, UpdateEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(Task.FromResult <IDisplayResult>(null));
}
var updateEditorContext = new UpdatePartEditorContext(typePartDefinition, context);
var result = UpdateAsync(part, context.Updater, updateEditorContext);
if (result == null)
{
return(Task.FromResult <IDisplayResult>(null));
}
if (context.Updater.ModelState.IsValid)
{
part.ContentItem.Weld(typePartDefinition.Name, part);
}
return(result);
}
public override async Task <IDisplayResult> UpdateAsync(BagPart part, UpdatePartEditorContext context)
{
var contentItemDisplayManager = _serviceProvider.GetRequiredService <IContentItemDisplayManager>();
var model = new BagPartEditViewModel {
BagPart = part
};
await context.Updater.TryUpdateModelAsync(model, Prefix);
var contentItems = new List <ContentItem>();
for (var i = 0; i < model.Prefixes.Length; i++)
{
var contentItem = await _contentManager.NewAsync(model.ContentTypes[i]);
var existing = part.ContentItems.FirstOrDefault(x => String.Equals(x.ContentItemId, model.Prefixes[i], StringComparison.OrdinalIgnoreCase));
if (existing != null)
{
contentItem.ContentItemId = model.Prefixes[i];
}
var widgetModel = await contentItemDisplayManager.UpdateEditorAsync(contentItem, context.Updater, context.IsNew, htmlFieldPrefix : model.Prefixes[i]);
contentItems.Add(contentItem);
}
part.ContentItems = contentItems;
return(Edit(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(EditActionPart model, IUpdateModel updater,
UpdatePartEditorContext context)
{
await updater.TryUpdateModelAsync(model, Prefix, t => t.Title, t => t.Icon, t => t.OpenInModal);
return(Edit(model, context));
}
public Task UpdatePartEditorAsync(ContentPartDefinition model, UpdatePartEditorContext context)
{
return _partDisplayDrivers.InvokeAsync(async contentDisplay =>
{
var result = await contentDisplay.UpdateEditorAsync(model, context);
if (result != null)
result.Apply(context);
}, Logger);
}
public override async Task<IDisplayResult> UpdateAsync(ContentPartDefinition contentPartDefinition, UpdatePartEditorContext context)
{
var model = new ContentPartSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
context.Builder.Attachable(model.Attachable);
context.Builder.WithDescription(model.Description);
}
return Edit(contentPartDefinition, context.Updater);
}
public override async Task <IDisplayResult> UpdateAsync(CommonPart part, UpdatePartEditorContext context)
{
var currentUser = _httpContextAccessor.HttpContext?.User;
if (!await _authorizationService.AuthorizeAsync(currentUser, StandardPermissions.SiteOwner, part))
{
return(null);
}
var settings = context.TypePartDefinition.GetSettings <CommonPartSettings>();
if (!settings.DisplayOwnerEditor)
{
if (part.ContentItem.Owner == null)
{
part.ContentItem.Owner = currentUser.FindFirstValue(ClaimTypes.NameIdentifier);
}
}
else
{
var model = new OwnerEditorViewModel();
if (part.ContentItem.Owner != null)
{
var user = await _userManager.FindByIdAsync(part.ContentItem.Owner);
model.OwnerName = user.UserName;
}
var priorOwnerName = model.OwnerName;
await context.Updater.TryUpdateModelAsync(model, Prefix);
if (model.OwnerName != priorOwnerName)
{
var newOwner = (await _userManager.FindByNameAsync(model.OwnerName));
if (newOwner == null)
{
context.Updater.ModelState.AddModelError("CommonPart.OwnerName", S["Invalid user name"]);
}
else
{
part.ContentItem.Owner = await _userManager.GetUserIdAsync(newOwner);
}
}
}
return(await EditAsync(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(CommonPart part, UpdatePartEditorContext context)
{
var currentUser = _httpContextAccessor.HttpContext?.User;
if (currentUser == null || !(await _authorizationService.AuthorizeAsync(currentUser, StandardPermissions.SiteOwner, part)))
{
return(null);
}
var settings = context.TypePartDefinition.GetSettings <CommonPartSettings>();
if (!settings.DisplayOwnerEditor)
{
if (part.ContentItem.Owner == null)
{
part.ContentItem.Owner = currentUser.Identity.Name;
}
}
else
{
var model = new OwnerEditorViewModel();
if (part.ContentItem.Owner != null)
{
model.Owner = part.ContentItem.Owner;
}
var priorOwner = model.Owner;
await context.Updater.TryUpdateModelAsync(model, Prefix);
if (!string.IsNullOrEmpty(part.ContentItem.Owner) && model.Owner != priorOwner)
{
var newOwner = await _userService.GetUserAsync(model.Owner);
if (newOwner == null)
{
context.Updater.ModelState.AddModelError("CommonPart.Owner", S["Invalid user name"]);
}
else
{
part.ContentItem.Owner = newOwner.UserName;
}
}
}
return(await EditAsync(part, context));
}
Task <IDisplayResult> IContentPartDisplayDriver.UpdateEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, UpdateEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(Task.FromResult <IDisplayResult>(null));
}
var updateEditorContext = new UpdatePartEditorContext(typePartDefinition, context);
var result = UpdateAsync(part, context.Updater, updateEditorContext);
part.ContentItem.Apply(part);
return(result);
}
public override async Task <IDisplayResult> UpdateAsync(ListPart listPart, IUpdateModel updater,
UpdatePartEditorContext context)
{
var isAdminMode = AdminAttribute.IsApplied(_httpContextAccessor.HttpContext);
if (isAdminMode)
{
var settings = context.TypePartDefinition.GetSettings <ListPartSettings>();
if (settings.AllowOverrideDataFillModePerInstance)
{
await updater.TryUpdateModelAsync(listPart, Prefix, m => m.ContainedContentTypes,
m => m.DataFillMode, m => m.SelectedWorkMapContentItemIds);
}
}
return(Edit(listPart, context));
}
async Task <IDisplayResult> IContentPartDisplayDriver.UpdateEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, UpdateEditorContext context)
{
var part = contentPart as TPart;
if (part == null)
{
return(null);
}
BuildPrefix(typePartDefinition, context.HtmlFieldPrefix);
var updateEditorContext = new UpdatePartEditorContext(typePartDefinition, context);
var result = await UpdateAsync(part, context.Updater, updateEditorContext);
part.ContentItem.Apply(typePartDefinition.Name, part);
return(result);
}
public override async Task <IDisplayResult> UpdateAsync(TransformalizeFormPart part, IUpdateModel updater, UpdatePartEditorContext context)
{
var model = new EditTransformalizeFormPartViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
part.Arrangement.Text = model.Arrangement.Text;
part.LocationEnableHighAccuracy.Value = model.LocationEnableHighAccuracy.Value;
part.LocationMaximumAge.Value = model.LocationMaximumAge.Value;
part.LocationTimeout.Value = model.LocationTimeout.Value;
}
try {
var logger = new MemoryLogger(LogLevel.Error);
var process = _configurationContainer.CreateScope(model.Arrangement.Text, part.ContentItem, new Dictionary <string, string>(), false).Resolve <Process>();
if (process.Errors().Any())
{
foreach (var error in process.Errors())
{
updater.ModelState.AddModelError(Prefix, S[error]);
}
}
if (process.Warnings().Any())
{
foreach (var warning in process.Warnings())
{
_notifier.Warning(H[warning]);
}
}
if (!process.Connections.Any(c => c.Table != "[default]" && !string.IsNullOrEmpty(c.Table)))
{
updater.ModelState.AddModelError(Prefix, S["A form requires one connection to have a table defined. The submissions are stored in this table."]);
}
if (process.Parameters.Where(p => p.PrimaryKey).Count() != 1)
{
updater.ModelState.AddModelError(Prefix, S["A form requires one parameter to be marked as the primary key."]);
}
} catch (Exception ex) {
updater.ModelState.AddModelError(Prefix, S[ex.Message]);
}
if (updater.ModelState.IsValid)
{
_signal.SignalToken(Common.GetCacheKey(part.ContentItem.Id));
}
return(Edit(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(ProfilePart part, IUpdateModel updater, UpdatePartEditorContext context)
{
var model = new ProfilePartViewModel();
if (!await context.Updater.TryUpdateModelAsync(model, Prefix))
{
return(await EditAsync(part, context));
}
var user = await _userService.GetUserAsync(model.UserName);
if (user == null)
{
user = await _userService.CreateUserAsync(new User { UserName = model.UserName, Email = model.UserName }, null, (key, message) =>
{
context.Updater.ModelState.AddModelError("UserName", $"{message}");
}) as User;
}
part.UserIdentifier = await _userManager.GetUserIdAsync(user);
return(await EditAsync(part, context));
}
public override async Task <IDisplayResult> UpdateAsync(ContentPartDefinition contentPartDefinition, UpdatePartEditorContext context)
{
if (!String.Equals(nameof(TestPartPart), contentPartDefinition.Name, StringComparison.Ordinal))
{
return(null);
}
var model = new TestPartPartSettingsViewModel();
if (await context.Updater.TryUpdateModelAsync(model, Prefix, m => m.MySetting))
{
context.Builder.WithSettings(new TestPartPartSettings {
MySetting = model.MySetting
});
}
return(Edit(contentPartDefinition, context.Updater));
}
public override async Task <IDisplayResult> UpdateAsync(LocalizationPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new LocalizationPartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Culture);
// Invariant culture name is empty so a null value is bound.
model.Culture = viewModel.Culture ?? "";
// Need to do this here to support displaying the message to save before localizing when the item has not been saved yet.
if (String.IsNullOrEmpty(model.LocalizationSet))
{
model.LocalizationSet = _iidGenerator.GenerateUniqueId();
}
return(Edit(model));
}
public override async Task <IDisplayResult> UpdateAsync(ProfileGroupOwnershipPart part, IUpdateModel updater, UpdatePartEditorContext context)
{
var model = new EditProfileGroupOwnershipPartViewModel();
if (await context.Updater.TryUpdateModelAsync(model, Prefix, m => m.RestrictAccess))
{
part.RestrictAccess = model.RestrictAccess;
}
return(Edit(part, context));
}
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 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 virtual Task <IDisplayResult> UpdateAsync(TPart part, UpdatePartEditorContext context)
{
return(UpdateAsync(part, context.Updater));
}
public override async Task <IDisplayResult> UpdateAsync(WidgetsListPart part, UpdatePartEditorContext context)
{
var contentItemDisplayManager = _serviceProvider.GetRequiredService <IContentItemDisplayManager>();
var model = new WidgetsListPartEditViewModel {
WidgetsListPart = part
};
await context.Updater.TryUpdateModelAsync(model, Prefix);
var zonedContentItems = new Dictionary <string, List <ContentItem> >();
// Remove any content or the zones would be merged and not be cleared
part.Content.Widgets.RemoveAll();
for (var i = 0; i < model.Prefixes.Length; i++)
{
var contentType = model.ContentTypes[i];
var zone = model.Zones[i];
var prefix = model.Prefixes[i];
var contentItem = await _contentManager.NewAsync(contentType);
if (part.Widgets.ContainsKey(zone))
{
var existingContentItem = part.Widgets[zone].FirstOrDefault(x => String.Equals(x.ContentItemId, model.Prefixes[i], StringComparison.OrdinalIgnoreCase));
// When the content item already exists merge its elements to preverse nested content item ids.
// All of the data for these merged items is then replaced by the model values on update, while a nested content item id is maintained.
// This prevents nested items which rely on the content item id, i.e. the media attached field, losing their reference point.
if (existingContentItem != null)
{
contentItem.ContentItemId = model.Prefixes[i];
contentItem.Merge(existingContentItem);
}
}
contentItem.Weld(new WidgetMetadata());
var widgetModel = await contentItemDisplayManager.UpdateEditorAsync(contentItem, context.Updater, context.IsNew, htmlFieldPrefix : prefix);
if (!zonedContentItems.ContainsKey(zone))
{
zonedContentItems.Add(zone, new List <ContentItem>());
}
zonedContentItems[zone].Add(contentItem);
}
part.Widgets = zonedContentItems;
return(Edit(part, context));
}
//
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(AutoroutePart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new AutoroutePartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Path, t => t.UpdatePath, t => t.RouteContainedItems, t => t.Absolute, t => t.Disabled);
var settings = context.TypePartDefinition.GetSettings <AutoroutePartSettings>();
model.Disabled = viewModel.Disabled;
model.Absolute = viewModel.Absolute;
model.RouteContainedItems = viewModel.RouteContainedItems;
// When disabled these values are not updated.
if (!model.Disabled)
{
if (settings.AllowCustomPath)
{
model.Path = viewModel.Path;
}
if (settings.AllowUpdatePath && viewModel.UpdatePath)
{
// Make it empty to force a regeneration
model.Path = "";
}
var httpContext = _httpContextAccessor.HttpContext;
if (httpContext != null && await _authorizationService.AuthorizeAsync(httpContext.User, Permissions.SetHomepage))
{
await updater.TryUpdateModelAsync(model, Prefix, t => t.SetHomepage);
}
await ValidateAsync(model, updater, settings);
}
return(Edit(model, context));
}
public async override Task <IDisplayResult> UpdateAsync(SiteSearch part, IUpdateModel updater, UpdatePartEditorContext context)
{
var model = new SiteSearchEditViewModel();
if (await updater.TryUpdateModelAsync(model, Prefix))
{
part.ContentTypeSettings = CleanSettings(JsonConvert.DeserializeObject <SiteSearchContentTypeSettings[]>(model.ContentTypeSettings));
part.DisplayType = model.DisplayType;
part.EmptyResultsContent = model.EmptyResultsContent;
part.FilterInputPlaceholder = model.FilterInputPlaceholder;
part.ItemsDisplayType = string.IsNullOrWhiteSpace(model.ItemsDisplayType) ? DefaultItemsDisplayType : model.ItemsDisplayType;
part.PageSize = model.PageSize;
part.Query = model.Query;
part.SubmitButtonLabel = model.SubmitButtonLabel;
}
return(await EditAsync(part, context));
}
public async Task<dynamic> UpdatePartEditorAsync(ContentPartDefinition contentPartDefinition, IUpdateModel updater, string groupId)
{
if (contentPartDefinition == null)
{
throw new ArgumentNullException(nameof(contentPartDefinition));
}
var contentPartDefinitionShape = CreateContentShape("ContentPartDefinition_Edit");
UpdatePartEditorContext partContext = null;
_contentDefinitionManager.AlterPartDefinition(contentPartDefinition.Name, partBuilder =>
{
partContext = new UpdatePartEditorContext(
partBuilder,
contentPartDefinitionShape,
groupId,
_shapeFactory,
_layoutAccessor.GetLayout(),
updater
);
});
await BindPlacementAsync(partContext);
await _handlers.InvokeAsync(handler => handler.UpdatePartEditorAsync(contentPartDefinition, partContext), Logger);
return contentPartDefinitionShape;
}
public override async Task <IDisplayResult> UpdateAsync(TitlePart model, IUpdateModel updater, UpdatePartEditorContext context)
{
if (await updater.TryUpdateModelAsync(model, Prefix, t => t.Title))
{
var settings = context.TypePartDefinition.GetSettings <TitlePartSettings>();
if (settings.Options == TitlePartOptions.EditableRequired && String.IsNullOrWhiteSpace(model.Title))
{
updater.ModelState.AddModelError(Prefix, S["A value is required for Title."]);
}
}
model.ContentItem.DisplayText = model.Title;
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(DependencyTreePart model, IUpdateModel updater, UpdatePartEditorContext context)
{
//copied from ContainedPartDisplayDriver.cs
var viewModel = new EditContainedPartViewModel();
if (await updater.TryUpdateModelAsync(viewModel, "ListPart") && viewModel.ContainerId != null)
{
//add the containers rootid as this items rootid as well (cascade update)
//need to find document id d
//using documentid get record ContainedPartIndex
var contentItemIndex = await _session.QueryIndex <ContentItemIndex>(x => x.ContentItemId == viewModel.ContainerId).FirstOrDefaultAsync();
if (contentItemIndex != null)
{
var docid = contentItemIndex.DocumentId;
var index = await _session.QueryIndex <ContainedPartIndex>(x => x.DocumentId == docid).FirstOrDefaultAsync();
if (index == null)
{
//this is a node at first level below root so set rootid to contentitemid
model.RootContentItemId = viewModel.ContainerId;
model.IsRoot = false;
}
else
{ //otherwise use the same RootContentItemId
model.RootContentItemId = index.RootContentItemId;
model.IsRoot = false;
}
}
}
else
{
//this means this is root content item
model.RootContentItemId = null;
model.IsRoot = true;
}
// await updater.TryUpdateModelAsync(model, Prefix, t => t.IsRoot, t=> t.RootContentItemId);
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(AutoroutePart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new AutoroutePartViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix, t => t.Path, t => t.UpdatePath, t => t.RouteContainedItems, t => t.Absolute, t => t.Disabled);
var settings = context.TypePartDefinition.GetSettings <AutoroutePartSettings>();
model.Disabled = viewModel.Disabled;
model.Absolute = viewModel.Absolute;
model.RouteContainedItems = viewModel.RouteContainedItems;
// When disabled these values are not updated.
if (!model.Disabled)
{
if (settings.AllowCustomPath)
{
model.Path = viewModel.Path;
}
if (settings.AllowUpdatePath && viewModel.UpdatePath)
{
// Make it empty to force a regeneration
model.Path = "";
}
var httpContext = _httpContextAccessor.HttpContext;
if (httpContext != null && await _authorizationService.AuthorizeAsync(httpContext.User, Permissions.SetHomepage))
{
await updater.TryUpdateModelAsync(model, Prefix, t => t.SetHomepage);
}
updater.ModelState.BindValidationResults(Prefix, model.ValidatePathFieldValue(S));
// This can only validate the path if the Autoroute is not managing content item routes or the path is absolute.
if (!String.IsNullOrEmpty(model.Path) && (!settings.ManageContainedItemRoutes || (settings.ManageContainedItemRoutes && model.Absolute)))
{
var possibleConflicts = await _session.QueryIndex <AutoroutePartIndex>(o => o.Path == model.Path).ListAsync();
if (possibleConflicts.Any())
{
var hasConflict = false;
if (possibleConflicts.Any(x => x.ContentItemId != model.ContentItem.ContentItemId) ||
possibleConflicts.Any(x => !string.IsNullOrEmpty(x.ContainedContentItemId) && x.ContainedContentItemId != model.ContentItem.ContentItemId))
{
hasConflict = true;
}
if (hasConflict)
{
updater.ModelState.AddModelError(Prefix, nameof(model.Path), S["Your permalink is already in use."]);
}
}
}
}
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(MarkdownBodyPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new MarkdownBodyPartViewModel();
if (await context.Updater.TryUpdateModelAsync(viewModel, Prefix, vm => vm.Markdown))
{
if (!string.IsNullOrEmpty(viewModel.Markdown) && !_liquidTemplateManager.Validate(viewModel.Markdown, out var errors))
{
var partName = context.TypePartDefinition.DisplayName();
updater.ModelState.AddModelError(Prefix, nameof(viewModel.Markdown), S["{0} doesn't contain a valid Liquid expression. Details: {1}", partName, string.Join(" ", errors)]);
}
else
{
model.Markdown = viewModel.Markdown;
}
}
return(Edit(model, context));
}
public override async Task <IDisplayResult> UpdateAsync(RssFeed part, IUpdateModel updater, UpdatePartEditorContext context)
{
var viewModel = new EditRssFeedViewModel();
await updater.TryUpdateModelAsync(viewModel, Prefix);
return(Edit(part, context));
}
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(CrudActionPart model, IUpdateModel updater, UpdatePartEditorContext context)
{
await updater.TryUpdateModelAsync(model, Prefix, t => t.CreateContentType, t => t.ListUrl, t => t.ShowCreate, t => t.ShowView, t => t.ShowEdit, t => t.ShowRemove, t => t.ShowList);// t=> t.Title,t=> t.Icon );
return(Edit(model, context));
}
