public async Task <ActionResult> IndexPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManagePlacements))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in itemIds)
{
await _placementsManager.RemoveShapePlacementsAsync(item);
}
_notifier.Success(H["Placements successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> IndexPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageMediaProfiles))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var mediaProfilesDocument = await _mediaProfilesManager.LoadMediaProfilesDocumentAsync();
var checkedContentItems = mediaProfilesDocument.MediaProfiles.Where(x => itemIds.Contains(x.Key));
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
await _mediaProfilesManager.RemoveMediaProfileAsync(item.Key);
}
_notifier.Success(H["Media profiles successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> ListPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageSitemaps))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var sitemapsList = await _sitemapManager.LoadSitemapsAsync();
var checkedContentItems = sitemapsList.Where(x => itemIds.Contains(x.SitemapId));
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
await _sitemapManager.DeleteSitemapAsync(item.SitemapId);
}
await _notifier.SuccessAsync(H["Sitemaps successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction(nameof(List)));
}
public async Task <ActionResult> IndexPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdminMenu))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var adminMenuList = (await _adminMenuService.GetAdminMenuListAsync()).AdminMenu;
var checkedContentItems = adminMenuList.Where(x => itemIds.Contains(x.Id));
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
var adminMenu = adminMenuList.FirstOrDefault(x => String.Equals(x.Id, item.Id, StringComparison.OrdinalIgnoreCase));
await _adminMenuService.DeleteAsync(adminMenu);
}
_notifier.Success(H["Admin menus successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction(nameof(List)));
}
public async Task <ActionResult> IndexPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageRemoteInstances))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var remoteClients = (await _remoteClientService.GetRemoteClientListAsync()).RemoteClients;
var checkedContentItems = remoteClients.Where(x => itemIds.Contains(x.Id)).ToList();
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
await _remoteClientService.DeleteRemoteClientAsync(item.Id);
}
await _notifier.SuccessAsync(H["Remote clients successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> IndexPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageQueries))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var queriesList = await _queryManager.ListQueriesAsync();
var checkedContentItems = queriesList.Where(x => itemIds.Contains(x.Name));
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
await _queryManager.DeleteQueryAsync(item.Name);
}
_notifier.Success(H["Queries successfully removed."]);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Index(ViewModels.ContentOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageEmailTemplates))
{
return(Forbid());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var templatesDocument = await _templatesManager.GetEmailTemplatesDocumentAsync();
var templates = templatesDocument.Templates.ToList();
if (!string.IsNullOrWhiteSpace(options.Search))
{
templates = templates.Where(x => x.Value.Name.Contains(options.Search, StringComparison.OrdinalIgnoreCase)).ToList();
}
var count = templates.Count;
templates = templates.OrderBy(x => x.Value.Name)
.Skip(pager.GetStartIndex())
.Take(pager.PageSize).ToList();
var pagerShape = (await New.Pager(pager)).TotalItemCount(count);
var model = new EmailTemplateIndexViewModel
{
Templates = templates.ConvertAll(x => new TemplateEntry {
Id = x.Key, Template = x.Value
}),
Options = options,
Pager = pagerShape
};
model.Options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove)
}
};
return(View("Index", model));
}
public async Task <ActionResult> IndexPost(ViewModels.ContentOptions options, IEnumerable <string> itemIds)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageIndexes))
{
return(Forbid());
}
if (itemIds?.Count() > 0)
{
var luceneIndexSettings = await _luceneIndexSettingsService.GetSettingsAsync();
var checkedContentItems = luceneIndexSettings.Where(x => itemIds.Contains(x.IndexName));
switch (options.BulkAction)
{
case ContentsBulkAction.None:
break;
case ContentsBulkAction.Remove:
foreach (var item in checkedContentItems)
{
await _luceneIndexingService.DeleteIndexAsync(item.IndexName);
}
_notifier.Success(H["Indices successfully removed."]);
break;
case ContentsBulkAction.Reset:
foreach (var item in checkedContentItems)
{
if (!_luceneIndexManager.Exists(item.IndexName))
{
return(NotFound());
}
_luceneIndexingService.ResetIndex(item.IndexName);
await _luceneIndexingService.ProcessContentItemsAsync(item.IndexName);
_notifier.Success(H["Index <em>{0}</em> reset successfully.", item.IndexName]);
}
break;
case ContentsBulkAction.Rebuild:
foreach (var item in checkedContentItems)
{
if (!_luceneIndexManager.Exists(item.IndexName))
{
return(NotFound());
}
await _luceneIndexingService.RebuildIndexAsync(item.IndexName);
await _luceneIndexingService.ProcessContentItemsAsync(item.IndexName);
_notifier.Success(H["Index <em>{0}</em> rebuilt successfully.", item.IndexName]);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> ListPOST(ViewModels.ContentOptions 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, 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"));
}
