public async Task <ActionResult> Detail(int versionNumber, string auditTrailEventId)
{
var auditTrailEvent = await _session.Query <AuditTrailEvent, AuditTrailEventIndex>()
.Where(auditTrailEventIndex => auditTrailEventIndex.AuditTrailEventId == auditTrailEventId)
.FirstOrDefaultAsync();
var contentItem = auditTrailEvent.Get(auditTrailEvent.EventName).ToObject <ContentItem>();
if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.ViewContent, contentItem))
{
return(Forbid());
}
contentItem = await _contentManager.LoadAsync(contentItem);
var auditTrailPart = contentItem.As <AuditTrailPart>();
if (auditTrailPart != null)
{
auditTrailPart.ShowComment = true;
}
dynamic contentItemEditor =
await _contentItemDisplayManager.BuildEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, false);
contentItemEditor.VersionNumber = versionNumber;
return(View(contentItemEditor));
}
private async Task <Dictionary <string, DeploymentPlan> > GetDeploymentPlans()
{
if (_deploymentPlans == null)
{
var deploymentPlanQuery = _session.Query <DeploymentPlan, DeploymentPlanIndex>();
var deploymentPlans = await deploymentPlanQuery.ListAsync();
_deploymentPlans = deploymentPlans.ToDictionary(x => x.Name);
}
return(_deploymentPlans);
}
public async Task <IActionResult> GetAdminComments(string id)
{
var query = _session.Query <ContentItem, ContentItemIndex>();
var comments = await query.Where(o => o.ContentType == "AdminComment" && o.DisplayText == id && (o.Latest || o.Published)).ListAsync();
return(Ok(comments));
}
private async Task <IShape> BuildEventShapeAsync(string shapeType, AuditTrailEvent auditTrailEvent, string displayType)
{
dynamic auditTrailEventActionsShape = await _shapeFactory.CreateAsync(shapeType, Arguments.From(new Dictionary <string, object>
{
{ "AuditTrailEvent", auditTrailEvent },
{ "Descriptor", _auditTrailManager.DescribeEvent(auditTrailEvent) },
{ "EventData", auditTrailEvent.Get(auditTrailEvent.EventName) }
}));
if (auditTrailEvent.Category == "Content")
{
var contentItem = auditTrailEvent.Get(auditTrailEvent.EventName).ToObject <ContentItem>();
var availableVersionsCount = await _session.Query <ContentItem, ContentItemIndex>()
.Where(index => index.ContentItemId == contentItem.ContentItemId).CountAsync();
auditTrailEventActionsShape.AvailableVersionsCount = availableVersionsCount;
}
var metaData = auditTrailEventActionsShape.Metadata;
metaData.DisplayType = displayType;
metaData.Alternates.Add($"{shapeType}_{displayType}");
metaData.Alternates.Add($"{shapeType}__{auditTrailEvent.Category}");
metaData.Alternates.Add($"{shapeType}_{displayType}__{auditTrailEvent.Category}");
metaData.Alternates.Add($"{shapeType}__{auditTrailEvent.Category}__{auditTrailEvent.EventName}");
metaData.Alternates.Add($"{shapeType}_{displayType}__{auditTrailEvent.Category}__{auditTrailEvent.EventName}");
return(auditTrailEventActionsShape);
}
private async Task RecordAuditTrailEventAsync(string eventName, IContent content)
{
var buildingAuditTrailEventContext = new BuildingAuditTrailEventContext(content.ContentItem, eventName);
await _auditTrailEvents.InvokeAsync((provider, context) =>
provider.BuildingAuditTrailEventAsync(context), buildingAuditTrailEventContext, Logger);
// -1 is a unique contentItem.Id that only Preview is using such that another stored document can't have
// the same one in the IContentManagerSession index.
if (buildingAuditTrailEventContext.IsCanceled || content.ContentItem.Id == -1)
{
return;
}
var versionNumber = await _session.Query <ContentItem, ContentItemIndex>()
.Where(contentItemIndex => contentItemIndex.ContentItemId == content.ContentItem.ContentItemId)
.CountAsync();
var eventData = new Dictionary <string, object>
{
{ "ContentItem", content.ContentItem },
{ "VersionNumber", versionNumber }
};
await _auditTrailManager.AddAuditTrailEventAsync <ContentAuditTrailEventProvider>(
new AuditTrailContext(eventName, _hca.GetCurrentUserName(), eventData, "content", content.ContentItem.ContentItemId));
}
public override IDisplayResult Edit(ListPart listPart, BuildPartEditorContext context)
{
var settings = context.TypePartDefinition.GetSettings <ListPartSettings>();
if (settings.AllowOverrideDataFillModePerInstance == true)
{
return(Initialize <ListPartViewModel>("ListPart_Edit", m =>
{
m.ContainedContentTypes = listPart.ContainedContentTypes;
m.DataFillMode = listPart.DataFillMode;
m.SelectedWorkMapContentItemIds = listPart.SelectedWorkMapContentItemIds;
if (m.DataFillMode == DataFillMode.WorkMaps)
{
//var contentmanager = _serviceProvider.GetService<IContentManager>();
var query = _session.Query <ContentItem, ContentItemIndex>();
query = query.With <ContentItemIndex>(x => x.Published);
query = query.With <ContentItemIndex>(x => x.ContentType == "WorkMap");
query = query.OrderBy(cr => cr.DisplayText);
m.AvailableWorkMapContentItems = query.ListAsync().GetAwaiter().GetResult();
}
}));
}
return(null);
}
public async Task <int> TrimAsync(TimeSpan retentionPeriod)
{
var dateThreshold = _clock.UtcNow.AddDays(1) - retentionPeriod;
var auditTrailEvents = await _session.Query <AuditTrailEvent, AuditTrailEventIndex>()
.Where(index => index.CreatedUtc <= dateThreshold).ListAsync();
var deletedEvents = 0;
// Related Orchard Core issue to be able to delete items without a foreach:
// https://github.com/OrchardCMS/OrchardCore/issues/5821
foreach (var auditTrailEvent in auditTrailEvents)
{
_session.Delete(auditTrailEvent);
deletedEvents++;
}
return(deletedEvents);
}
private async Task <IEnumerable <ContentItem> > GetTaxonomyContentItems()
{
string contentType = "Taxonomy";
var query = _session.Query <ContentItem, ContentItemIndex>();
if (!string.IsNullOrEmpty(contentType))
{
query = query.With <ContentItemIndex>(x => x.ContentType == contentType && x.Latest == true);
}
query = query.OrderBy(cr => cr.DisplayText);
return(await query.ListAsync());
}
public override async Task <IDisplayResult> DisplayAsync(PostcodeSearch part, BuildPartDisplayContext context)
{
var contents = new List <PostcodeSearchViewModel>();
var results = Enumerable.Empty <ContentItem>();
ContentItem[] list = null;
var postcode = GetQuerystringValue(QueryStringPostcode);
var postcodesApi = new PostcodesApi();
var response = await postcodesApi.GetGameData(postcode);
if (response != null && !string.IsNullOrEmpty(postcode))
{
var coord = new GeoCoordinate(Convert.ToDouble(response.FirstResult.Latitude), Convert.ToDouble(response.FirstResult.Longitude));
results = await _session.Query <ContentItem>()
.With <ContentItemIndex>()
.Where(x => x.Published)
.With <PostcodeIndex>()
.ListAsync();
foreach (var result in results)
{
contents.Add(new PostcodeSearchViewModel
{
ContentItem = result,
Latitude = Convert.ToDouble(result?.ContentItem?.As <PostcodePart>()?.Latitude ?? null),
Longitude = Convert.ToDouble(result?.ContentItem?.As <PostcodePart>()?.Longitude ?? null),
Postcode = result?.ContentItem?.As <PostcodePart>()?.Postcode
});
}
list = contents.OrderBy(x => x.GeoCoordinate.GetDistanceTo(coord)).ToList().Select(x => x.ContentItem).ToArray();
}
return(Initialize <PostcodeSearchListViewModel>("PostcodeSearch_List", model =>
{
model.EmptyResultsContent = part.EmptyResultsContent;
model.Postcode = postcode;
model.PostcodeInputPlaceholder = part.PostcodeInputPlaceholder;
model.Results = list;
model.SubmitButtonLabel = part.SubmitButtonLabel;
})
.Location("Detail", "Content:5"));
}
public override async Task <IDisplayResult> EditAsync(TaxonomyContentsAdminListSettings settings, BuildEditorContext context)
{
var user = _httpContextAccessor.HttpContext?.User;
if (user == null || !await _authorizationService.AuthorizeAsync(user, Permissions.ManageTaxonomies))
{
return(null);
}
var taxonomies = await _session.Query <ContentItem, ContentItemIndex>(q => q.ContentType == "Taxonomy" && q.Published).ListAsync();
var entries = taxonomies.Select(x => new TaxonomyEntry
{
DisplayText = x.DisplayText,
ContentItemId = x.ContentItemId,
IsChecked = settings.TaxonomyContentItemIds.Any(id => String.Equals(x.ContentItemId, id, StringComparison.OrdinalIgnoreCase))
}).ToArray();
return(Initialize <TaxonomyContentsAdminListSettingsViewModel>("TaxonomyContentsAdminListSettings_Edit", model =>
{
model.TaxonomyEntries = entries;
}).Location("Content:2").OnGroup(GroupId));
}
public async Task <IActionResult> AdvancedForms()
{
List <AdvFormsDisplayViewModel> model = new List <AdvFormsDisplayViewModel>();
AdvFormsDisplayViewModel displayModel;
var query = _session.Query <ContentItem, ContentItemIndex>();
var allAdvancedForms = await query.Where(o => o.ContentType == "AdvancedForm" && o.Published).ListAsync();
query = _session.Query <ContentItem, ContentItemIndex>();
var allAdvancedFormTypes = await query.Where(o => o.ContentType == "AdvancedFormTypes" && o.Published).ListAsync();
allAdvancedFormTypes = allAdvancedFormTypes.Where(o => !Boolean.Parse(o.Content.AdvancedFormTypes.HideFromListing.Value.ToString()));
foreach (var item in allAdvancedFormTypes)
{
displayModel = new AdvFormsDisplayViewModel();
var filteredForms = allAdvancedForms.Where(o => o.Content.AdvancedForm.Type.Text.ToString() == item.ContentItemId && !Boolean.Parse(o.Content.AdvancedForm.HideFromListing.Value.ToString())).ToList();
displayModel.Items = GetAFDisplayList(filteredForms, true);
if (displayModel.Items.Count > 0)
{
displayModel.Type = item.DisplayText;
model.Add(displayModel);
}
}
return(View(model));
}
public async Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable <IAdminNodeNavigationBuilder> treeNodeBuilders)
{
var node = menuItem as UrlTreeAdminNode;
if ((node == null) || (!node.Enabled))
{
return;
}
//TODO cache (actually cache the levels.)
var contentItems = (await _session
.Query <ContentItem>()
.With <AutoroutePartIndex>(o => o.Published)
.ListAsync()).ToList();
var homeRoute = (await _siteService.GetSiteSettingsAsync()).HomeRoute;
// Return on no homeroute.
if (homeRoute == null)
{
return;
}
var homeRouteContentItemId = homeRoute[_options.ContentItemIdKey]?.ToString();
if (String.IsNullOrEmpty(homeRouteContentItemId))
{
return;
}
var homeRouteContentItem = await _contentManager.GetAsync(homeRouteContentItemId);
if (homeRouteContentItem == null)
{
return;
}
var homeRouteMetadata = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(homeRouteContentItem);
if (!homeRouteMetadata.AdminRouteValues.Any())
{
return;
}
// In case of lists, which use display
homeRouteMetadata.AdminRouteValues["Action"] = "Edit";
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", homeRouteContentItem);
var rootMenuDisplayText = await _liquidTemplatemanager.RenderAsync(node.TreeRootDisplayPattern, NullEncoder.Default, templateContext);
// In case of bad liquid.
if (String.IsNullOrEmpty(rootMenuDisplayText))
{
_logger.LogError("Bad liquid root menu display text");
}
var segments = new List <ContentItemSegment2>();
foreach (var ci in contentItems)
{
var part = ci.As <AutoroutePart>();
var contentItemSegment = new ContentItemSegment2
{
Segments = part.Path.Contains("/") ? part.Path.Split('/') : new string[] { part.Path },
Path = part.Path,
ContentItem = ci
};
segments.Add(contentItemSegment);
}
var levels = new List <Level>();
await BuildLevels(levels, segments, node, 0);
//TODO Dynamic string localization not supported yet.
await builder.AddAsync(new LocalizedString(rootMenuDisplayText, rootMenuDisplayText), async urlTreeRoot =>
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(homeRouteContentItem.ContentType);
urlTreeRoot.Action(homeRouteMetadata.AdminRouteValues["Action"] as string, homeRouteMetadata.AdminRouteValues["Controller"] as string, homeRouteMetadata.AdminRouteValues);
urlTreeRoot.Resource(homeRouteContentItem);
urlTreeRoot.Priority(node.Priority);
urlTreeRoot.Position(node.Position);
urlTreeRoot.LocalNav();
AddPrefixToClasses(node.IconForTree).ToList().ForEach(c => urlTreeRoot.AddClass(c));
urlTreeRoot.Permission(ContentTypePermissions.CreateDynamicPermission(
ContentTypePermissions.PermissionTemplates[global::OrchardCore.Contents.Permissions.EditContent.Name], contentTypeDefinition));
await BuildMenuLevels(urlTreeRoot, levels);
});
}
private async Task <bool> ImportRowAsync(ImportRedirectRow row)
{
if (!ValidateRow(row))
{
return(false);
}
var existing = await _session.Query <ContentItem>()
.With <RedirectPartIndex>(x => x.Url == row.FromUrl)
.ListAsync();
ContentItem redirectItem = null;
var newItem = false;
if (existing.Any())
{
redirectItem = existing.FirstOrDefault(x => x.Published);
}
if (redirectItem == null)
{
redirectItem = await _contentManager.NewAsync(Constants.RedirectContentType);
redirectItem.Owner = _httpContextAccessor.HttpContext.User.Identity.Name;
redirectItem.CreatedUtc = DateTime.UtcNow;
newItem = true;
}
if (redirectItem == null)
{
return(false);
}
var redirectPart = redirectItem.Get <RedirectPart>(nameof(RedirectPart));
if (redirectPart == null)
{
return(false);
}
redirectItem.Author = _httpContextAccessor.HttpContext.User.Identity.Name;
redirectItem.DisplayText = row.Title;
redirectPart.FromUrl = row.FromUrl?.Trim();
redirectPart.ToUrl = row.ToUrl?.Trim();
redirectPart.IsPermanent = true;
redirectPart.Apply();
redirectItem.Apply(nameof(RedirectPart), redirectPart);
ContentExtensions.Apply(redirectItem, redirectItem);
if (newItem)
{
await _contentManager.CreateAsync(redirectItem);
}
else
{
await _contentManager.UpdateAsync(redirectItem);
}
await _contentManager.PublishAsync(redirectItem);
return(true);
}
public async Task SetInitialOrder(string contentType)
{
// Set initial order for published and drafts if they have never been published.
var contanerContentItemsQuery = _session.QueryIndex <ContentItemIndex>(x => x.ContentType == contentType && (x.Published || x.Latest));
var containerContentItems = await contanerContentItemsQuery.ListAsync();
if (!containerContentItems.Any())
{
return;
}
// Reduce duplicates to only set order for the published container item and the draft item if it has not been published.
var containerContentItemIds = containerContentItems.Select(x => x.ContentItemId).Distinct();
var containedItemsQuery = _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId.IsIn(containerContentItemIds))
.With <ContentItemIndex>(ci => ci.Latest || ci.Published)
.OrderByDescending(x => x.CreatedUtc);
// Load items so that loading handlers are invoked.
var contentItemGroups = (await containedItemsQuery.ListAsync(_contentManager)).ToLookup(l => l.As <ContainedPart>()?.ListContentItemId);
foreach (var contentItemGroup in contentItemGroups)
{
var i = 0;
foreach (var contentItem in contentItemGroup)
{
var containedPart = contentItem.As <ContainedPart>();
if (containedPart != null)
{
if (contentItem.Published && contentItem.Latest)
{
containedPart.Order = i;
containedPart.Apply();
}
else if (contentItem.Latest && !contentItem.Published)
{
// Update the latest order.
containedPart.Order = i;
containedPart.Apply();
// If a published version exists, find it, and set it to the same order as the draft.
var publishedItem = contentItemGroup.FirstOrDefault(p => p.Published == true && p.ContentItemId == contentItem.ContentItemId);
var publishedContainedPart = publishedItem?.As <ContainedPart>();
if (publishedContainedPart != null)
{
publishedContainedPart.Order = i;
publishedContainedPart.Apply();
}
}
else if (contentItem.Published && !contentItem.Latest)
{
// If a latest version exists, it will handle updating the order.
var latestItem = contentItemGroup.FirstOrDefault(l => l.Latest == true && l.ContentItemId == contentItem.ContentItemId);
if (latestItem == null)
{
// Apply order to the published item.
containedPart.Order = i;
containedPart.Apply();
}
else
{
// Order of this item will be updated when latest is iterated.
continue;
}
}
_session.Save(contentItem);
}
i++;
}
}
}
private async Task <IEnumerable <ContentItem> > QueryListItemsAsync(CrossReferencePart listPart, object pager, bool publishedOnly, string relation)
{
// if (pagerSlimDisabled)
// {
// var realPager = (Pager)pager;
// var query = _session.Query<ContentItem>()
// .With<CrossReferencedPartIndex>(x => x.SourceContentItemId == listPart.ContentItem.ContentItemId && x.Relation==relation)
// .With<ContentItemIndex>(CreateContentIndexFilter(null, null, publishedOnly))
// .OrderByDescending(x => x.CreatedUtc)
// .Skip((realPager.Page - 1) * realPager.PageSize)
// .Take(realPager.PageSize + 1);
//
// var containedItems = await query.ListAsync();
//
// if (containedItems.Count() == 0)
// {
// return containedItems;
// }
//
// //pager.Before = null;
// //pager.After = null;
//
// if (containedItems.Count() == realPager.PageSize + 1)
// {
// containedItems = containedItems.Take(realPager.PageSize);
// }
//
// return containedItems;
// }
// else
// {
var realPager = (PagerSlim)pager;
if (realPager.Before != null)
{
var beforeValue = new DateTime(long.Parse(realPager.Before));
var query = _session.Query <ContentItem>()
.With <CrossReferencedPartIndex>(x => x.SourceContentItemId == listPart.ContentItem.ContentItemId && x.Relation == relation)
.With <ContentItemIndex>(CreateContentIndexFilter(beforeValue, null, publishedOnly))
.OrderBy(x => x.CreatedUtc)
.Take(realPager.PageSize + 1);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
containedItems = containedItems.Reverse();
// There is always an After as we clicked on Before
realPager.Before = null;
realPager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
if (containedItems.Count() == realPager.PageSize + 1)
{
containedItems = containedItems.Skip(1);
realPager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
return(containedItems);
}
else if (realPager.After != null)
{
var afterValue = new DateTime(long.Parse(realPager.After));
var query = _session.Query <ContentItem>()
.With <CrossReferencedPartIndex>(x => x.SourceContentItemId == listPart.ContentItem.ContentItemId && x.Relation == relation)
.With <ContentItemIndex>(CreateContentIndexFilter(null, afterValue, publishedOnly))
.OrderByDescending(x => x.CreatedUtc)
.Take(realPager.PageSize + 1);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
// There is always a Before page as we clicked on After
realPager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
realPager.After = null;
if (containedItems.Count() == realPager.PageSize + 1)
{
containedItems = containedItems.Take(realPager.PageSize);
realPager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
return(containedItems);
}
else
{
var query = _session.Query <ContentItem>()
.With <CrossReferencedPartIndex>(x => x.SourceContentItemId == listPart.ContentItem.ContentItemId && x.Relation == relation)
.With <ContentItemIndex>(CreateContentIndexFilter(null, null, publishedOnly))
.OrderByDescending(x => x.CreatedUtc)
.Take(realPager.PageSize + 1);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
realPager.Before = null;
realPager.After = null;
if (containedItems.Count() == realPager.PageSize + 1)
{
containedItems = containedItems.Take(realPager.PageSize);
realPager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
return(containedItems);
}
//}
}
public async Task <ActionResult> ListPOST(ContentOptionsViewModel options, IEnumerable <int> itemIds)
{
if (itemIds?.Count() > 0)
{
var checkedContentItems = await _session.Query <ContentItem, ContentItemIndex>().Where(x => x.DocumentId.IsIn(itemIds) && x.Latest).ListAsync();
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.PublishNow:
foreach (var item in checkedContentItems)
{
if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.PublishContent, item))
{
_notifier.Warning(H["Couldn't publish selected content."]);
_session.Cancel();
return(Forbid());
}
await _contentManager.PublishAsync(item);
}
_notifier.Success(H["Content successfully published."]);
break;
case ContentsBulkAction.Unpublish:
foreach (var item in checkedContentItems)
{
if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.PublishContent, item))
{
_notifier.Warning(H["Couldn't unpublish selected content."]);
_session.Cancel();
return(Forbid());
}
await _contentManager.UnpublishAsync(item);
}
_notifier.Success(H["Content successfully unpublished."]);
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.DeleteContent, item))
{
_notifier.Warning(H["Couldn't remove selected content."]);
_session.Cancel();
return(Forbid());
}
await _contentManager.RemoveAsync(item);
}
_notifier.Success(H["Content successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction("List"));
}
public Task <User> GetParticipantAsync()
{
var user = _httpContextAccessor.HttpContext.User;
if (!user.Identity.IsAuthenticated)
{
return(Task.FromResult <User>(null));
}
return(_session.Query <User, HackathonUsersIndex>(x => x.UserId == user.FindFirst(ClaimTypes.NameIdentifier).Value).FirstOrDefaultAsync());
}
public Task <AuditTrailEvent> GetEventAsync(string eventId) => _session.Query <AuditTrailEvent, AuditTrailEventIndex>(collection: AuditTrailEvent.Collection) .Where(index => index.EventId == eventId) .FirstOrDefaultAsync();
// public async Task<ActionResult> ListPOST(ViewModels.ContentOptions options, IEnumerable<int> itemIds)
public async Task <ActionResult> ListPOST(string containedContentItem, IEnumerable <int> itemIds)
{
if (itemIds?.Count() != 1)
{
_notifier.Warning(H["Only one parent container element can be selected."]);
return(Forbid());
}
else
{
var parentContentItem = await _session.Query <ContentItem, ContentItemIndex>()
.Where(x => x.DocumentId.IsIn(itemIds) && x.Latest).FirstOrDefaultAsync();
if (parentContentItem != null)
{
// Invoke any service that could alter the query
await _contentAssignParentContainerFilter.AssignContainerAsync(containedContentItem,
parentContentItem.ContentItemId, _updateModelAccessor.ModelUpdater);
}
if (!ModelState.IsValid)
{
return(RedirectToAction("List"));
}
_notifier.Success(H["Content item moved successfully."]);
return(RedirectToAction("Display", "Admin", new { contentItemId = parentContentItem?.ContentItemId }));
//redirect to new parent content item container in detailadmin displaytype
/*switch (options.BulkAction)
* {
* case ContentsBulkAction.None:
* break;
* case ContentsBulkAction.PublishNow:
* foreach (var item in checkedContentItems)
* {
* if (!await _authorizationService.AuthorizeAsync(User, Permissions.PublishContent, item))
* {
* _notifier.Warning(H["Couldn't publish selected content."]);
* _session.Cancel();
* return Forbid();
* }
*
* await _contentManager.PublishAsync(item);
* }
* _notifier.Success(H["Content successfully published."]);
* break;
* case ContentsBulkAction.Unpublish:
* foreach (var item in checkedContentItems)
* {
* if (!await _authorizationService.AuthorizeAsync(User, Permissions.PublishContent, item))
* {
* _notifier.Warning(H["Couldn't unpublish selected content."]);
* _session.Cancel();
* return Forbid();
* }
*
* await _contentManager.UnpublishAsync(item);
* }
* _notifier.Success(H["Content successfully unpublished."]);
* break;
* case ContentsBulkAction.Remove:
* foreach (var item in checkedContentItems)
* {
* if (!await _authorizationService.AuthorizeAsync(User, Permissions.DeleteContent, item))
* {
* _notifier.Warning(H["Couldn't remove selected content."]);
* _session.Cancel();
* return Forbid();
* }
*
* await _contentManager.RemoveAsync(item);
* }
* _notifier.Success(H["Content successfully removed."]);
* break;
* default:
* throw new ArgumentOutOfRangeException();
* }*/
}
//return RedirectToAction("List");
}
