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