public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var container = model.ContainerId.HasValue ? _contentManager.GetLatest((int)model.ContainerId) : null;
if (container == null || !container.Has <ContainerPart>())
{
return(HttpNotFound());
}
var restrictedContentType = container.As <ContainerPart>().Record.ItemContentType;
var hasRestriction = !string.IsNullOrEmpty(restrictedContentType);
if (hasRestriction)
{
model.FilterByContentType = restrictedContentType;
}
model.Options.SelectedFilter = model.FilterByContentType;
model.ContainerDisplayName = container.ContentManager.GetItemMetadata(container).DisplayText;
if (string.IsNullOrEmpty(model.ContainerDisplayName))
{
model.ContainerDisplayName = container.ContentType;
}
var query = GetListContentItemQuery(model.ContainerId.Value, model.FilterByContentType, model.Options.OrderBy);
if (query == null)
{
return(HttpNotFound());
}
model.Options.FilterOptions = GetContainableTypes()
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Key);
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
dynamic viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.ContainerId(model.ContainerId)
.Options(model.Options)
.ContainerDisplayName(model.ContainerDisplayName)
.HasRestriction(hasRestriction)
.ContainerContentType(container.ContentType)
.ContainerItemContentType(hasRestriction ? restrictedContentType : (model.FilterByContentType ?? ""))
.OtherLists(_contentManager.Query <ContainerPart>(VersionOptions.Latest).List()
.Select(part => part.ContentItem)
.Where(item => item != container)
.OrderBy(item => item.As <CommonPart>().VersionPublishedUtc));
// Casting to avoid invalid (under medium trust) reflection over the protected View method and force a static invocation.
return(View((object)viewModel));
}
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 != null)
{
query.With <ContainedPartIndex>(x => x.ListContentItemId == viewModel.ListContentItemId);
}
}
}
public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = _contentManager.Query <ProductPart, ProductPartRecord>(VersionOptions.Latest);
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
dynamic viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options);
// Casting to avoid invalid (under medium trust) reflection over the protected View method and force a static invocation.
return(View((object)viewModel));
}
public ActionResult Index(ListContentsViewModel model, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = Services.ContentManager.Query(VersionOptions.Latest, GetCreatableTypes(false).Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.Options.SelectedFilter))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedFilter);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.Options.SelectedFilter);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord, DateTime?>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord, DateTime?>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord, DateTime?>(cr => cr.CreatedUtc);
break;
}
model.Options.FilterOptions = GetCreatableTypes(false)
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
var pagerShape = Services.New.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Services.New.List();
list.AddRange(pageOfContentItems.Select(ci => Services.ContentManager.BuildDisplay(ci, "SummaryAdmin")));
foreach (IShape item in list.Items)
{
item.Metadata.Type = "ContentPicker";
}
dynamic tab = Services.New.RecentContentTab()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(new ShapeResult(this, Services.New.ContentPicker().Tab(tab)));
}
public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
Pager pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = _contentManager.Query(VersionOptions.Latest, GetCreatableTypes(false).Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.TypeName))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.TypeName);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
//query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.ContentItemRecord.Versions.Single(civr => civr.Latest).Id);
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
//query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.Id);
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = GetCreatableTypes(false)
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
dynamic viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
// Casting to avoid invalid (under medium trust) reflection over the protected View method and force a static invocation.
return(View((object)viewModel));
}
public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(Permissions.ManageTemplates, T("Not authorized to manage templates")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = _contentManager.Query(VersionOptions.Latest, GetShapeTypes().Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.TypeName))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.TypeName);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = GetShapeTypes()
.Select(x => new KeyValuePair <string, string>(x.Name, x.DisplayName))
.ToList().OrderBy(x => x.Value);
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
var viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(View(viewModel));
}
public ActionResult ListFilterPOST(ListContentsViewModel model)
{
return(RedirectToAction("List", new RouteValueDictionary {
{ "Options.OrderBy", model.Options.OrderBy },
{ "Options.ContentsStatus", model.Options.ContentsStatus },
{ "Options.SelectedContentType", model.Options.SelectedContentType },
{ "Options.DisplayText", model.Options.DisplayText }
}));
}
public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
Pager pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = _contentManager.Query();
//if (!string.IsNullOrEmpty(model.TypeName))
//{
// var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
// if (contentTypeDefinition == null)
// return HttpNotFound();
// model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
// ? contentTypeDefinition.DisplayName
// : contentTypeDefinition.Name;
// query = query.ForType(model.TypeName);
//}
//query=query.OrderByDescending<ContentItemRecord>()
//switch (model.Options.OrderBy)
//{
// case ContentsOrder.Modified:
// //query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.ContentItemRecord.Versions.Single(civr => civr.Latest).Id);
// query = query.OrderByDescending<CommonPartRecord>(cr => cr.ModifiedUtc);
// break;
// case ContentsOrder.Published:
// query = query.OrderByDescending<CommonPartRecord>(cr => cr.PublishedUtc);
// break;
// case ContentsOrder.Created:
// //query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.Id);
// query = query.OrderByDescending<CommonPartRecord>(cr => cr.CreatedUtc);
// break;
//}
var maxPagedCount = _siteService.GetSiteSettings().MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
pager.Total = query.Count();
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
model.Pager = pager;
model.Items = pageOfContentItems;
return(View(model));
}
public async Task <IActionResult> ListContainerWorkBookTemplates(ListContentsViewModel model, PagerParameters pagerParameters)
{
//get types based on the unique alias name
var siteSettings = await _siteService.GetSiteSettingsAsync();
var contentItemAliasSettings = siteSettings.As <ContainerItemAliasSettings>();
IEnumerable <string> contentItemAliases = new List <string>();
if (!String.IsNullOrEmpty(contentItemAliasSettings?.ContentTypes))
{
contentItemAliases = contentItemAliasSettings.ContentTypes
.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
//get content itemids by alias name
List <String> contentItemIds = new List <string>();
foreach (var contentItemAliase in contentItemAliases)
{
string contentItemId = !string.IsNullOrEmpty(contentItemAliase) ? await _contentAliasManager.GetContentItemIdAsync("alias:" + contentItemAliase) : "NotFound";
if (contentItemId != "NotFound")
{
contentItemIds.Add(contentItemId);
}
}
var query = _session.Query <ContentItem, ContentItemIndex>().Where(x => x.ContentItemId.IsIn(contentItemIds) && x.Latest);
var contentItemsBag = await PrepareQuery(query, model, pagerParameters);
dynamic pagerShape = contentItemsBag.PageShape;
var viewModel = (await New.ViewModel())
.ContentItems(contentItemsBag.ContentItemSummaries)
.Pager(pagerShape)
.Options(model.Options)
// .TypeDisplayName(model.TypeDisplayName ?? "")
;
return(View(viewModel));
}
public async Task <IActionResult> Index(PagerParameters pagerParameters) //ListContentsViewModel model,
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var query = _session.Query <ContentItem, ContentItemIndex>();
query = query.With <ContentItemIndex>(x => x.ContentType == contentType);
query = query.With <ContentItemIndex>(x => x.Published);
query = query.OrderByDescending(x => x.PublishedUtc);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var routeData = new RouteData();
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
IEnumerable <ContentItem> model = await query.ListAsync();
// Prepare the content items Summary Admin shape
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "Summary"));
}
var viewModel = new ListContentsViewModel
{
ContentItems = contentItemSummaries,
Pager = pagerShape
//Options = model.Options
};
return(View(viewModel));
}
public ActionResult List(ListContentsViewModel model)
{
if (!Services.Authorizer.Authorize(Permissions.ManageTemplates, T("Not allowed to manage templates.")))
{
return(new HttpUnauthorizedResult());
}
var contentItems = _templateService.GetTemplates(model.Options.OrderBy);
var list = Shape.List();
list.AddRange(contentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
dynamic viewModel = Shape.ViewModel(
ContentItems: list,
Options: model.Options);
// Casting to avoid invalid (under medium trust) reflection over the protected View method and force a static invocation.
return(View((object)viewModel));
}
public ActionResult Index(ListContentsViewModel model, PagerParameters pagerParameters)
{
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = Services.ContentManager.Query(VersionOptions.Latest, GetBlogPostTypes().Select(ctd => ctd.Name).ToArray( ));
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord, DateTime?>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord, DateTime?>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord, DateTime?>(cr => cr.CreatedUtc);
break;
}
var pagerShape = Services.New.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Services.New.List();
list.AddRange(pageOfContentItems.Select(ci => Services.ContentManager.BuildDisplay(ci, "SummaryAdmin")));
foreach (IShape item in list.Items)
{
item.Metadata.Type = "BlogPostPicker";
}
dynamic tab = Services.New.RecentBlogPostTab()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(new ShapeResult(this, Services.New.BlogPostPicker().Tab(tab)));
}
public ActionResult Rates(ListContentsViewModel model, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(OShopPermissions.ManageShopSettings, T("Not allowed to manage VAT rates")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = _contentManager.Query <VatRatePart, VatRatePartRecord>(VersionOptions.Latest);
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
var viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options);
// Casting to avoid invalid (under medium trust) reflection over the protected View method and force a static invocation.
return(View(viewModel));
}
public async Task <ActionResult <IEnumerable <object> > > GetContentItemsList(string contentTypes,
string contentType = "")
{
//todo need to incorporate pager and sort settings
var query = _session.Query <ContentItem, ContentItemIndex>();
var model = new ListContentsViewModel();
if (!string.IsNullOrEmpty(contentType))
{
model.Options.SelectedContentType = contentType;
}
if (!string.IsNullOrEmpty(model.Options.SelectedContentType))
{
var contentTypeDefinition =
_contentDefinitionManager.GetTypeDefinition(model.Options.SelectedContentType);
if (contentTypeDefinition == null)
{
return(NotFound());
}
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = query.With <ContentItemIndex>(x => x.ContentType == model.Options.SelectedContentType);
}
else
{
var validContentTypes = contentTypes.Split(',').ToList();
if (validContentTypes.Any())
{
query = query.With <ContentItemIndex>(x => x.ContentType.IsIn(validContentTypes));
}
}
var pageOfContentItems = await query.Skip(0).Take(100).ListAsync();
return(pageOfContentItems?.Select(CreateContentItemResult).ToArray());
}
public ActionResult Index(ListContentsViewModel model, PagerParameters pagerParameters)
{
if (!Services.Authorizer.Authorize(Permissions.OShopPermissions.AccessShopPanel, T("Not allowed to manage products")))
{
return(new HttpUnauthorizedResult());
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var versionOptions = VersionOptions.Latest;
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
versionOptions = VersionOptions.Published;
break;
case ContentsStatus.Draft:
versionOptions = VersionOptions.Draft;
break;
case ContentsStatus.AllVersions:
versionOptions = VersionOptions.AllVersions;
break;
default:
versionOptions = VersionOptions.Latest;
break;
}
var productTypes = GetProductTypes();
if (productTypes.Count() == 0)
{
Services.Notifier.Information(T("There is no product enabled content type. Please create one."));
return(RedirectToAction("Index", "Admin", new { Area = "Orchard.ContentTypes" }));
}
var query = _contentManager.Query(versionOptions, productTypes.Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.TypeName))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.TypeName);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = GetProductTypes()
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
var pagerShape = Shape.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
var viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options);
return(View(viewModel));
}
public async Task <ActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters, string contentTypeId = "")
{
if (model.PageCount == 0)
{
model.PageCount = 999;
}
List <ContentItem> contentItems;
var siteSettings = await siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, model.PageCount);
var query = await session.Query <ContentItem, ContentItemIndex>()
.Where(x => x.ContentType == "CommentPost" && x.Latest == true && x.Published == true)
.ListAsync();
/* Get all comments for Document */
contentItems = query.Where(x => BelongsToDocument(x, contentTypeId)).ToList();
/* Group By */
switch (model.Options.GroupBy)
{
case ContentsGrouping.Thread:
/* Update Child Count */
foreach (var contentItem in contentItems)
{
string parentId = contentItem.ContentItemId;
contentItem.Content.CommentPost.ChildCount.Value = contentItems.Count(comment => IsChildOf(parentId, comment));
}
if (!model.OnlySubComments)
{
contentItems = contentItems.Where(x => IsParentComment(x)).ToList();
}
break;
case ContentsGrouping.Single:
contentItems = contentItems.ToList();
break;
default:
contentItems = contentItems.ToList();
break;
}
/* Get Only Sub Comments */
if (model.OnlySubComments && !string.IsNullOrEmpty(model.ParentId))
{
contentItems = contentItems.Where(x => IsChildOf(model.ParentId, x)).ToList();
}
/* Order By */
switch (model.Options.OrderBy)
{
case ContentsOrder.Date:
logger.LogInformation("Order By Date");
contentItems = contentItems.OrderByDescending(x => x.PublishedUtc).ToList();
break;
case ContentsOrder.Rank:
logger.LogInformation("Order By Rank");
break;
default:
logger.LogInformation("No Order");
contentItems = contentItems.OrderByDescending(x => x.PublishedUtc).ToList();
break;
}
for (int i = 0; i < contentItems.Count; i++)
{
contentItems[i] = await contentManager.LoadAsync(contentItems[i]);
}
/* Prepare Pager */
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : contentItems.Count());
var pageOfContentItems = contentItems.Skip(pager.GetStartIndex()).Take(model.PageCount);
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await contentItemDisplayManager.BuildDisplayAsync(contentItem, updateModelAccessor.ModelUpdater));
}
var viewModel = new ListContentsViewModel
{
ContentItems = contentItemSummaries,
Options = model.Options,
PageCount = model.PageCount,
Pager = pagerShape,
OnlySubComments = model.OnlySubComments
};
return(PartialView(viewModel));
}
public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
Pager pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var versionOptions = VersionOptions.Latest;
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
versionOptions = VersionOptions.Published;
break;
case ContentsStatus.Draft:
versionOptions = VersionOptions.Draft;
break;
case ContentsStatus.AllVersions:
versionOptions = VersionOptions.AllVersions;
break;
default:
versionOptions = VersionOptions.Latest;
break;
}
var query = _contentManager.Query(versionOptions, GetListableTypes(false).Select(ctd => ctd.Name).ToArray());
ContentTypeDefinition contentTypeDefinition = null;
if (!string.IsNullOrEmpty(model.TypeName))
{
contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = _contentManager.Query(versionOptions, model.TypeName);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
//query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.ContentItemRecord.Versions.Single(civr => civr.Latest).Id);
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
//query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.Id);
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
if (!String.IsNullOrWhiteSpace(model.Options.SelectedCulture))
{
query = _cultureFilter.FilterCulture(query, model.Options.SelectedCulture);
}
if (model.Options.ContentsStatus == ContentsStatus.Owner)
{
query = query.Where <CommonPartRecord>(cr => cr.OwnerId == Services.WorkContext.CurrentUser.Id);
}
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = GetListableTypes(false)
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
model.Options.Cultures = _cultureManager.ListCultures();
var maxPagedCount = _siteService.GetSiteSettings().MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var pagerShape = Shape.Pager(pager).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
var viewModel = Shape.ViewModel(ContentType: contentTypeDefinition)
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(View(viewModel));
}
public ActionResult Index(ListContentsViewModel model, PagerParameters pagerParameters, string part, string field, string types)
{
var menuItems = _navigationManager.BuildMenu("content-picker").ToList();
var contentPickerMenuItem = menuItems.FirstOrDefault();
if (contentPickerMenuItem == null)
{
return(HttpNotFound());
}
if (contentPickerMenuItem.Items.All(x => x.Text.TextHint != "Recent Content"))
{
// the default tab should not be displayed, redirect to the next one
var root = menuItems.FirstOrDefault();
if (root == null)
{
return(HttpNotFound());
}
var firstChild = root.Items.First();
if (firstChild == null)
{
return(HttpNotFound());
}
var routeData = new RouteValueDictionary(firstChild.RouteValues);
var queryString = Request.QueryString;
foreach (var key in queryString.AllKeys)
{
if (!String.IsNullOrEmpty(key))
{
routeData[key] = queryString[key];
}
}
return(RedirectToRoute(routeData));
}
ContentPickerFieldSettings settings = null;
// if the picker is loaded for a specific field, apply custom settings
if (!String.IsNullOrEmpty(part) && !String.IsNullOrEmpty(field))
{
var definition = _contentDefinitionManager.GetPartDefinition(part).Fields.FirstOrDefault(x => x.Name == field);
if (definition != null)
{
settings = definition.Settings.GetModel <ContentPickerFieldSettings>();
}
}
if (settings != null && !String.IsNullOrEmpty(settings.DisplayedContentTypes))
{
types = settings.DisplayedContentTypes;
}
IEnumerable <ContentTypeDefinition> contentTypes;
if (!String.IsNullOrEmpty(types))
{
var rawTypes = types.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
contentTypes = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x => x.Parts.Any(p => rawTypes.Contains(p.PartDefinition.Name)) || rawTypes.Contains(x.Name))
.ToArray();
}
else
{
contentTypes = GetCreatableTypes(false).ToList();
}
var pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var query = Services.ContentManager.Query(VersionOptions.Latest, contentTypes.Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.Options.SelectedFilter))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedFilter);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.Options.SelectedFilter);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
model.Options.FilterOptions = contentTypes
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
var pagerShape = Services.New.Pager(pager).TotalItemCount(query.Count());
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Services.New.List();
list.AddRange(pageOfContentItems.Select(ci => Services.ContentManager.BuildDisplay(ci, "SummaryAdmin")));
foreach (IShape item in list.Items)
{
item.Metadata.Type = "ContentPicker";
}
var tab = Services.New.RecentContentTab()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
// retain the parameter in the pager links
RouteData.Values["Options.SelectedFilter"] = model.Options.SelectedFilter;
RouteData.Values["Options.OrderBy"] = model.Options.OrderBy.ToString();
RouteData.Values["Options.ContentsStatus"] = model.Options.ContentsStatus.ToString();
return(new ShapeResult(this, Services.New.ContentPicker().Tab(tab)));
}
public ActionResult List(ListContentsViewModel model, PagerParameters pagerParameters)
{
Pager pager = new Pager(_siteService.GetSiteSettings(), pagerParameters);
var versionOptions = VersionOptions.Latest;
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
versionOptions = VersionOptions.Published;
break;
case ContentsStatus.Draft:
versionOptions = VersionOptions.Draft;
break;
case ContentsStatus.AllVersions:
versionOptions = VersionOptions.AllVersions;
break;
default:
versionOptions = VersionOptions.Latest;
break;
}
var query = _contentManager.Query(versionOptions, GetCreatableTypes(false).Select(ctd => ctd.Name).ToArray());
if (!string.IsNullOrEmpty(model.TypeName))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(HttpNotFound());
}
model.TypeDisplayName = !string.IsNullOrWhiteSpace(contentTypeDefinition.DisplayName)
? contentTypeDefinition.DisplayName
: contentTypeDefinition.Name;
query = query.ForType(model.TypeName);
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
//query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.ContentItemRecord.Versions.Single(civr => civr.Latest).Id);
query = query.OrderByDescending <CommonPartRecord>(cr => cr.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending <CommonPartRecord>(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
//query = query.OrderByDescending<ContentPartRecord, int>(ci => ci.Id);
query = query.OrderByDescending <CommonPartRecord>(cr => cr.CreatedUtc);
break;
}
//query.Where(p => Authorizer.Authorize(Authorizer.Permissions.EditContent, p));
//if (!Services.Authorizer.Authorize(Permissions.EditContent, T("Not authorized to list users")))
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = GetCreatableTypes(false)
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
var pagerShape = Shape.Pager(pager).TotalItemCount(query.List().Count(p => Services.Authorizer.Authorize(Permissions.EditContent, p)));
var pageOfContentItems = query.Slice(pager.GetStartIndex(), pager.PageSize).ToList();
var list = Shape.List();
list.AddRange(pageOfContentItems.Select(ci => _contentManager.BuildDisplay(ci, "SummaryAdmin")));
var viewModel = Shape.ViewModel()
.ContentItems(list)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(View(viewModel));
}
public async Task <IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters, string contentTypeId = "")
{
var context = _httpContextAccessor.HttpContext;
var contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.GetSettings <ContentTypeSettings>().Creatable&& ctd.GetSettings <ContentTypeSettings>().Enabled)
.OrderBy(ctd => ctd.DisplayName);
if (!await _authorizationService.AuthorizeContentTypeDefinitionsAsync(User, CommonPermissions.EditContent, contentTypeDefinitions, _contentManager))
{
return(Forbid());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
// This is used by the AdminMenus so needs to be passed into the options.
if (!String.IsNullOrEmpty(contentTypeId))
{
model.Options.SelectedContentType = contentTypeId;
}
// Populate the creatable types.
if (!String.IsNullOrEmpty(model.Options.SelectedContentType))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedContentType);
if (contentTypeDefinition == null)
{
return(NotFound());
}
var creatableList = new List <SelectListItem>();
// Allows non creatable types to be created by another admin page.
if (contentTypeDefinition.GetSettings <ContentTypeSettings>().Creatable || model.Options.CanCreateSelectedContentType)
{
creatableList.Add(new SelectListItem(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name));
}
model.Options.CreatableTypes = creatableList;
}
if (model.Options.CreatableTypes == null)
{
var creatableList = new List <SelectListItem>();
if (contentTypeDefinitions.Any())
{
foreach (var contentTypeDefinition in contentTypeDefinitions)
{
var contentItem = await _contentManager.NewAsync(contentTypeDefinition.Name);
contentItem.Owner = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
if (await _authorizationService.AuthorizeAsync(context.User, CommonPermissions.EditContent, contentItem))
{
creatableList.Add(new SelectListItem(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name));
}
}
}
model.Options.CreatableTypes = creatableList;
}
// We populate the remaining SelectLists.
model.Options.ContentStatuses = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Latest"], Value = nameof(ContentsStatus.Latest)
},
new SelectListItem()
{
Text = S["Published"], Value = nameof(ContentsStatus.Published)
},
new SelectListItem()
{
Text = S["Unpublished"], Value = nameof(ContentsStatus.Draft)
},
new SelectListItem()
{
Text = S["All versions"], Value = nameof(ContentsStatus.AllVersions)
}
};
if (await _authorizationService.AuthorizeAsync(context.User, Permissions.ListContent))
{
model.Options.ContentStatuses.Insert(1, new SelectListItem()
{
Text = S["Owned by me"], Value = nameof(ContentsStatus.Owner)
});
}
model.Options.ContentSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Recently created"], Value = nameof(ContentsOrder.Created)
},
new SelectListItem()
{
Text = S["Recently modified"], Value = nameof(ContentsOrder.Modified)
},
new SelectListItem()
{
Text = S["Recently published"], Value = nameof(ContentsOrder.Published)
},
new SelectListItem()
{
Text = S["Title"], Value = nameof(ContentsOrder.Title)
}
};
model.Options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Publish Now"], Value = nameof(ContentsBulkAction.PublishNow)
},
new SelectListItem()
{
Text = S["Unpublish"], Value = nameof(ContentsBulkAction.Unpublish)
},
new SelectListItem()
{
Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove)
}
};
if ((String.IsNullOrEmpty(model.Options.SelectedContentType) || String.IsNullOrEmpty(contentTypeId)) && model.Options.ContentTypeOptions == null)
{
var listableTypes = new List <ContentTypeDefinition>();
foreach (var ctd in _contentDefinitionManager.ListTypeDefinitions())
{
if (ctd.GetSettings <ContentTypeSettings>().Listable)
{
var contentItem = await _contentManager.NewAsync(ctd.Name);
contentItem.Owner = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
var authorized = await _authorizationService.AuthorizeAsync(User, CommonPermissions.EditContent, contentItem);
if (authorized)
{
listableTypes.Add(ctd);
}
}
}
var contentTypeOptions = listableTypes
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
model.Options.ContentTypeOptions = new List <SelectListItem>
{
new SelectListItem()
{
Text = S["All content types"], Value = ""
}
};
foreach (var option in contentTypeOptions)
{
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = option.Value, Value = option.Key, Selected = (option.Value == model.Options.SelectedContentType)
});
}
}
// If ContentTypeOptions is not initialized by query string or by the code above, initialize it
if (model.Options.ContentTypeOptions == null)
{
model.Options.ContentTypeOptions = new List <SelectListItem>();
}
// With the model populated we filter the query, allowing the filters to alter the model.
var query = await _contentsAdminListQueryService.QueryAsync(model.Options, _updateModelAccessor.ModelUpdater);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
// We prepare the pager
var routeData = new RouteData();
routeData.Values.Add("DisplayText", model.Options.DisplayText);
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
// We prepare the content items SummaryAdmin shape
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "SummaryAdmin"));
}
// Populate options pager summary values.
var startIndex = (pagerShape.Page - 1) * (pagerShape.PageSize) + 1;
model.Options.StartIndex = startIndex;
model.Options.EndIndex = startIndex + contentItemSummaries.Count - 1;
model.Options.ContentItemsCount = contentItemSummaries.Count;
model.Options.TotalItemCount = pagerShape.TotalItemCount;
var header = await _contentOptionsDisplayManager.BuildEditorAsync(model.Options, _updateModelAccessor.ModelUpdater, false);
var shapeViewModel = await _shapeFactory.CreateAsync <ListContentsViewModel>("ContentsAdminList", viewModel =>
{
viewModel.ContentItems = contentItemSummaries;
viewModel.Pager = pagerShape;
viewModel.Options = model.Options;
viewModel.Header = header;
});
return(View(shapeViewModel));
}
private async Task <ContentItemsBag> PrepareQuery(IQuery <ContentItem, ContentItemIndex> query, ListContentsViewModel model, PagerParameters pagerParameters)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
Pager pager = new Pager(pagerParameters, siteSettings.PageSize);
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
query = query.With <ContentItemIndex>(x => x.Published);
break;
case ContentsStatus.Draft:
query = query.With <ContentItemIndex>(x => x.Latest && !x.Published);
break;
case ContentsStatus.AllVersions:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
default:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending(x => x.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending(cr => cr.CreatedUtc);
break;
default:
query = query.OrderByDescending(cr => cr.ModifiedUtc);
break;
}
// Invoke any service that could alter the query
//await _contentAdminFilters.InvokeAsync(x => x.FilterAsync(query, model, pagerParameters, this), Logger);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync());
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, "SummaryAdmin"));
}
return(new ContentItemsBag
{
PageShape = pagerShape,
ContentItemSummaries = contentItemSummaries// pageOfContentItems
});
}
public async Task <IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters, string contentTypeId = "")
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var query = _session.Query <ContentItem, ContentItemIndex>();
if (!string.IsNullOrEmpty(model.Options.DisplayText))
{
query = query.With <ContentItemIndex>(x => x.DisplayText.Contains(model.Options.DisplayText));
}
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
query = query.With <ContentItemIndex>(x => x.Published);
break;
case ContentsStatus.Draft:
query = query.With <ContentItemIndex>(x => x.Latest && !x.Published);
break;
case ContentsStatus.AllVersions:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
default:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
}
if (model.Options.ContentsStatus == ContentsStatus.Owner)
{
query = query.With <ContentItemIndex>(x => x.Owner == HttpContext.User.Identity.Name);
}
if (!string.IsNullOrEmpty(contentTypeId))
{
model.Options.SelectedContentType = contentTypeId;
}
IEnumerable <ContentTypeDefinition> contentTypeDefinitions = new List <ContentTypeDefinition>();
if (!string.IsNullOrEmpty(model.Options.SelectedContentType))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedContentType);
if (contentTypeDefinition == null)
{
return(NotFound());
}
contentTypeDefinitions = contentTypeDefinitions.Append(contentTypeDefinition);
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = query.With <ContentItemIndex>(x => x.ContentType == model.Options.SelectedContentType);
// Allows non creatable types to be created by another admin page.
if (model.Options.CanCreateSelectedContentType)
{
model.Options.CreatableTypes = new List <SelectListItem>
{
new SelectListItem(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name)
};
}
}
else
{
contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions();
var listableTypes = (await GetListableTypesAsync()).Select(t => t.Name).ToArray();
if (listableTypes.Any())
{
query = query.With <ContentItemIndex>(x => x.ContentType.IsIn(listableTypes));
}
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending(x => x.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending(cr => cr.CreatedUtc);
break;
case ContentsOrder.Title:
query = query.OrderBy(cr => cr.DisplayText);
break;
default:
query = query.OrderByDescending(cr => cr.ModifiedUtc);
break;
}
// Allow parameters to define creatable types.
if (model.Options.CreatableTypes == null)
{
var contentTypes = contentTypeDefinitions.Where(ctd => ctd.GetSettings <ContentTypeSettings>().Creatable).OrderBy(ctd => ctd.DisplayName);
var creatableList = new List <SelectListItem>();
if (contentTypes.Any())
{
foreach (var contentTypeDefinition in contentTypes)
{
creatableList.Add(new SelectListItem(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name));
}
}
model.Options.CreatableTypes = creatableList;
}
// Invoke any service that could alter the query
await _contentAdminFilters.InvokeAsync((filter, query, model, pagerParameters, updateModel) => filter.FilterAsync(query, model, pagerParameters, updateModel), query, model, pagerParameters, _updateModelAccessor.ModelUpdater, _logger);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
//We prepare the pager
var routeData = new RouteData();
routeData.Values.Add("DisplayText", model.Options.DisplayText);
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
//We prepare the content items SummaryAdmin shape
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater, "SummaryAdmin"));
}
//We populate the SelectLists
model.Options.ContentStatuses = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Latest"], Value = nameof(ContentsStatus.Latest)
},
new SelectListItem()
{
Text = S["Owned by me"], Value = nameof(ContentsStatus.Owner)
},
new SelectListItem()
{
Text = S["Published"], Value = nameof(ContentsStatus.Published)
},
new SelectListItem()
{
Text = S["Unpublished"], Value = nameof(ContentsStatus.Draft)
},
new SelectListItem()
{
Text = S["All versions"], Value = nameof(ContentsStatus.AllVersions)
}
};
model.Options.ContentSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Recently created"], Value = nameof(ContentsOrder.Created)
},
new SelectListItem()
{
Text = S["Recently modified"], Value = nameof(ContentsOrder.Modified)
},
new SelectListItem()
{
Text = S["Recently published"], Value = nameof(ContentsOrder.Published)
},
new SelectListItem()
{
Text = S["Title"], Value = nameof(ContentsOrder.Title)
}
};
model.Options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Publish Now"], Value = nameof(ContentsBulkAction.PublishNow)
},
new SelectListItem()
{
Text = S["Unpublish"], Value = nameof(ContentsBulkAction.Unpublish)
},
new SelectListItem()
{
Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove)
}
};
var ContentTypeOptions = (await GetListableTypesAsync())
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
model.Options.ContentTypeOptions = new List <SelectListItem>();
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = S["All content types"], Value = ""
});
foreach (var option in ContentTypeOptions)
{
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = option.Value, Value = option.Key
});
}
var viewModel = new ListContentsViewModel
{
ContentItems = contentItemSummaries,
Pager = pagerShape,
Options = model.Options
};
return(View(viewModel));
}
public async Task <IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
Pager pager = new Pager(pagerParameters, siteSettings.PageSize);
var query = _session.Query <ContentItem, ContentItemIndex>();
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
query = query.With <ContentItemIndex>(x => x.Published);
break;
case ContentsStatus.Draft:
query = query.With <ContentItemIndex>(x => x.Latest && !x.Published);
break;
case ContentsStatus.AllVersions:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
default:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
}
if (!string.IsNullOrEmpty(model.TypeName))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.TypeName);
if (contentTypeDefinition == null)
{
return(NotFound());
}
model.TypeDisplayName = contentTypeDefinition.ToString();
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = query.With <ContentItemIndex>(x => x.ContentType == model.TypeName);
}
else
{
var listableTypes = (await GetListableTypesAsync()).Select(t => t.Name).ToArray();
if (listableTypes.Any())
{
query = query.With <ContentItemIndex>(x => x.ContentType.IsIn(listableTypes));
}
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending(x => x.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending(cr => cr.CreatedUtc);
break;
default:
query = query.OrderByDescending(cr => cr.ModifiedUtc);
break;
}
//if (!String.IsNullOrWhiteSpace(model.Options.SelectedCulture))
//{
// query = _cultureFilter.FilterCulture(query, model.Options.SelectedCulture);
//}
//if (model.Options.ContentsStatus == ContentsStatus.Owner)
//{
// query = query.Where<CommonPartRecord>(cr => cr.OwnerId == Services.WorkContext.CurrentUser.Id);
//}
model.Options.SelectedFilter = model.TypeName;
model.Options.FilterOptions = (await GetListableTypesAsync())
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
//model.Options.Cultures = _cultureManager.ListCultures();
// Invoke any service that could alter the query
await _contentAdminFilters.InvokeAsync(x => x.FilterAsync(query, model, pagerParameters, this), Logger);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync());
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, "SummaryAdmin"));
}
var viewModel = (await New.ViewModel())
.ContentItems(contentItemSummaries)
.Pager(pagerShape)
.Options(model.Options)
.TypeDisplayName(model.TypeDisplayName ?? "");
return(View(viewModel));
}
public async Task <ActionResult> ListFilterPOST(ListContentsViewModel model)
{
await _contentOptionsDisplayManager.UpdateEditorAsync(model.Options, _updateModelAccessor.ModelUpdater, false);
return(RedirectToAction("List", model.Options.RouteValues));
}
public async Task <IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters, string containedContentItemId)
{
var containedContentItem = await _contentManager.GetAsync(containedContentItemId, VersionOptions.Published);
// var hascontainedPart = containedContentItem.Has("ContainedPart");
// if (hascontainedPart == false)
// return NotFound("Content Item does have attached contained Part");
if (containedContentItem == null)
{
return(NotFound());
}
//1 Candidates are all content types that have a list part and list part settings has the current content type as eligible
//get
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
/*
* var query = _session.Query<ContentItem, ContentItemIndex>();
*
* if (!string.IsNullOrEmpty(model.Options.DisplayText))
* {
* query = query.With<ContentItemIndex>(x => x.DisplayText.Contains(model.Options.DisplayText));
* }
*
* switch (model.Options.ContentsStatus)
* {
* case ContentsStatus.Published:
* query = query.With<ContentItemIndex>(x => x.Published);
* break;
* case ContentsStatus.Draft:
* query = query.With<ContentItemIndex>(x => x.Latest && !x.Published);
* break;
* case ContentsStatus.AllVersions:
* query = query.With<ContentItemIndex>(x => x.Latest);
* break;
* default:
* query = query.With<ContentItemIndex>(x => x.Latest);
* break;
* }
*
* if (model.Options.ContentsStatus == ContentsStatus.Owner)
* {
* query = query.With<ContentItemIndex>(x => x.Owner == HttpContext.User.Identity.Name);
* }
*
*
*/
/*if (!string.IsNullOrEmpty(contentTypeId))
* {
* model.Options.SelectedContentType = contentTypeId;
* }*/
/*
* switch (model.Options.OrderBy)
* {
* case ContentsOrder.Modified:
* query = query.OrderByDescending(x => x.ModifiedUtc);
* break;
* case ContentsOrder.Published:
* query = query.OrderByDescending(cr => cr.PublishedUtc);
* break;
* case ContentsOrder.Created:
* query = query.OrderByDescending(cr => cr.CreatedUtc);
* break;
* case ContentsOrder.Title:
* query = query.OrderBy(cr => cr.DisplayText);
* break;
* default:
* query = query.OrderByDescending(cr => cr.ModifiedUtc);
* break;
* }
*/
// Allow parameters to define creatable types.
/*if (model.Options.CreatableTypes == null)
* {
* var contentTypes = contentTypeDefinitions
* .Where(ctd =>
* ctd.GetSettings<ContentTypeSettings>().Creatable &&
* ctd.GetSettings<ContentTypeSettings>().Enabled).OrderBy(ctd => ctd.DisplayName);
* var creatableList = new List<SelectListItem>();
* if (contentTypes.Any())
* {
* foreach (var contentTypeDefinition in contentTypes)
* {
* creatableList.Add(new SelectListItem(
* new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName)
* .Value, contentTypeDefinition.Name));
* }
* }
*
* model.Options.CreatableTypes = creatableList;
* }*/
// We populate the remaining SelectLists.
model.Options.ContentStatuses = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Latest"], Value = nameof(ContentsStatus.Latest)
},
new SelectListItem()
{
Text = S["Owned by me"], Value = nameof(ContentsStatus.Owner)
},
new SelectListItem()
{
Text = S["Published"], Value = nameof(ContentsStatus.Published)
},
new SelectListItem()
{
Text = S["Unpublished"], Value = nameof(ContentsStatus.Draft)
},
new SelectListItem()
{
Text = S["All versions"], Value = nameof(ContentsStatus.AllVersions)
}
};
model.Options.ContentSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Recently created"], Value = nameof(ContentsOrder.Created)
},
new SelectListItem()
{
Text = S["Recently modified"], Value = nameof(ContentsOrder.Modified)
},
new SelectListItem()
{
Text = S["Recently published"], Value = nameof(ContentsOrder.Published)
},
new SelectListItem()
{
Text = S["Title"], Value = nameof(ContentsOrder.Title)
}
};
model.Options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Publish Now"], Value = nameof(ContentsBulkAction.PublishNow)
},
new SelectListItem()
{
Text = S["Unpublish"], Value = nameof(ContentsBulkAction.Unpublish)
},
new SelectListItem()
{
Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove)
}
};
// Invoke any service that could alter the query
// await _contentAdminFilters.InvokeAsync(
// (filter, query, model, pagerParameters, updateModel) =>
// filter.FilterAsync(query, model, pagerParameters, updateModel), query, model, pagerParameters,
// _updateModelAccessor.ModelUpdater, _logger);
// With the model populated we filter the query, allowing the filters to alter the model.
var query = await _contentsAdminListQueryService.QueryAsync(model.Options, _updateModelAccessor.ModelUpdater);
IEnumerable <ContentTypeDefinition> contentTypeDefinitions = new List <ContentTypeDefinition>();
var eligibleContentTypes = new List <string>();
if (!string.IsNullOrEmpty(model.Options.SelectedContentType))
{
var contentTypeDefinition =
_contentDefinitionManager.GetTypeDefinition(model.Options.SelectedContentType);
if (contentTypeDefinition == null)
{
return(NotFound());
}
contentTypeDefinitions = contentTypeDefinitions.Append(contentTypeDefinition);
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = query.With <ContentItemIndex>(x => x.ContentType == model.Options.SelectedContentType);
// Allows non creatable types to be created by another admin page.
/*if (model.Options.CanCreateSelectedContentType)
* {
* model.Options.CreatableTypes = new List<SelectListItem>
* {
* new SelectListItem(
* new LocalizedString(contentTypeDefinition.DisplayName,
* contentTypeDefinition.DisplayName).Value, contentTypeDefinition.Name)
* };
* }*/
}
else
{
//eligible content types
//Get ContentTypes with ListPart
//and that can accept as child element the current contained content item type
contentTypeDefinitions = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x =>
x.Parts.Any(p =>
p.PartDefinition.Name == "ListPart"))
;
foreach (var contentTypeDefintion in contentTypeDefinitions)
{
var containedContentTypes =
_contentAssignParentContainerFilter
.GetContainedContentTypeDefinitions(contentTypeDefintion.Name).ToList();
if (containedContentTypes.Any())
{
if (containedContentTypes.Any(x => x.Name == containedContentItem.ContentType))
{
//is eligible
eligibleContentTypes.Add(contentTypeDefintion.Name);
}
}
else
{
//if zero this means that all content types are valid , so add it
eligibleContentTypes.Add(contentTypeDefintion.Name);
}
}
query.With <ContentItemIndex>(x => x.ContentType.IsIn(eligibleContentTypes));
/*contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions();
*
* var listableTypes = (await GetListableTypesAsync()).Select(t => t.Name).ToArray();
* if (listableTypes.Any())
* {
* query = query.With<ContentItemIndex>(x => x.ContentType.IsIn(listableTypes));
* }*/
}
var contentTypeOptions = contentTypeDefinitions.Where(x => eligibleContentTypes.Any(s => s == x.Name)) //(await GetListableTypesAsync())
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
model.Options.ContentTypeOptions = new List <SelectListItem>();
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = S["All content types"], Value = ""
});
foreach (var option in contentTypeOptions)
{
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = option.Value, Value = option.Key
});
}
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
//We prepare the pager
var routeData = new RouteData();
routeData.Values.Add("DisplayText", model.Options.DisplayText);
var pagerShape = (await New.Pager(pager))
.TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
//We prepare the content items SummaryAdmin shape
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem,
_updateModelAccessor.ModelUpdater, "SummaryAdmin"));
}
var viewModel = new ListContentsViewModel
{
ContentItems = contentItemSummaries, Pager = pagerShape, Options = model.Options
};
ViewData["ContainedContentItem"] = containedContentItem;
return(View(viewModel));
}
public async Task <IActionResult> List(ListContentsViewModel model, PagerParameters pagerParameters, string contentTypeName = "")
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var query = _session.Query <ContentItem, ContentItemIndex>();
if (!string.IsNullOrEmpty(model.Options.DisplayText))
{
query = query.With <ContentItemIndex>(x => x.DisplayText.Contains(model.Options.DisplayText));
}
switch (model.Options.ContentsStatus)
{
case ContentsStatus.Published:
query = query.With <ContentItemIndex>(x => x.Published);
break;
case ContentsStatus.Draft:
query = query.With <ContentItemIndex>(x => x.Latest && !x.Published);
break;
case ContentsStatus.AllVersions:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
default:
query = query.With <ContentItemIndex>(x => x.Latest);
break;
}
if (contentTypeName != "")
{
model.Options.SelectedContentType = contentTypeName;
}
if (!string.IsNullOrEmpty(model.Options.SelectedContentType))
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(model.Options.SelectedContentType);
if (contentTypeDefinition == null)
{
return(NotFound());
}
// We display a specific type even if it's not listable so that admin pages
// can reuse the Content list page for specific types.
query = query.With <ContentItemIndex>(x => x.ContentType == model.Options.SelectedContentType);
}
else
{
var listableTypes = (await GetListableTypesAsync()).Select(t => t.Name).ToArray();
if (listableTypes.Any())
{
query = query.With <ContentItemIndex>(x => x.ContentType.IsIn(listableTypes));
}
}
switch (model.Options.OrderBy)
{
case ContentsOrder.Modified:
query = query.OrderByDescending(x => x.ModifiedUtc);
break;
case ContentsOrder.Published:
query = query.OrderByDescending(cr => cr.PublishedUtc);
break;
case ContentsOrder.Created:
query = query.OrderByDescending(cr => cr.CreatedUtc);
break;
case ContentsOrder.Title:
query = query.OrderBy(cr => cr.DisplayText);
break;
default:
query = query.OrderByDescending(cr => cr.ModifiedUtc);
break;
}
//if (!String.IsNullOrWhiteSpace(model.Options.SelectedCulture))
//{
// query = _cultureFilter.FilterCulture(query, model.Options.SelectedCulture);
//}
//if (model.Options.ContentsStatus == ContentsStatus.Owner)
//{
// query = query.Where<CommonPartRecord>(cr => cr.OwnerId == Services.WorkContext.CurrentUser.Id);
//}
//model.Options.Cultures = _cultureManager.ListCultures();
// Invoke any service that could alter the query
await _contentAdminFilters.InvokeAsync(x => x.FilterAsync(query, model, pagerParameters, this), Logger);
var maxPagedCount = siteSettings.MaxPagedCount;
if (maxPagedCount > 0 && pager.PageSize > maxPagedCount)
{
pager.PageSize = maxPagedCount;
}
//We prepare the pager
var routeData = new RouteData();
routeData.Values.Add("DisplayText", model.Options.DisplayText);
var pagerShape = (await New.Pager(pager)).TotalItemCount(maxPagedCount > 0 ? maxPagedCount : await query.CountAsync()).RouteData(routeData);
var pageOfContentItems = await query.Skip(pager.GetStartIndex()).Take(pager.PageSize).ListAsync();
//We prepare the content items SummaryAdmin shape
var contentItemSummaries = new List <dynamic>();
foreach (var contentItem in pageOfContentItems)
{
contentItemSummaries.Add(await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, "SummaryAdmin"));
}
//We populate the SelectLists
model.Options.ContentStatuses = new List <SelectListItem>()
{
new SelectListItem()
{
Text = T["latest"].Value, Value = ContentsStatus.Latest.ToString()
},
new SelectListItem()
{
Text = T["owned by me"].Value, Value = ContentsStatus.Owner.ToString()
},
new SelectListItem()
{
Text = T["published"].Value, Value = ContentsStatus.Published.ToString()
},
new SelectListItem()
{
Text = T["unpublished"].Value, Value = ContentsStatus.Draft.ToString()
},
new SelectListItem()
{
Text = T["all versions"].Value, Value = ContentsStatus.AllVersions.ToString()
}
};
model.Options.ContentSorts = new List <SelectListItem>()
{
new SelectListItem()
{
Text = T["recently created"].Value, Value = ContentsOrder.Created.ToString()
},
new SelectListItem()
{
Text = T["recently modified"].Value, Value = ContentsOrder.Modified.ToString()
},
new SelectListItem()
{
Text = T["recently published"].Value, Value = ContentsOrder.Published.ToString()
},
new SelectListItem()
{
Text = T["title"].Value, Value = ContentsOrder.Title.ToString()
}
};
model.Options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = T["Publish Now"].Value, Value = ContentsBulkAction.PublishNow.ToString()
},
new SelectListItem()
{
Text = T["Unpublish"].Value, Value = ContentsBulkAction.Unpublish.ToString()
},
new SelectListItem()
{
Text = T["Delete"].Value, Value = ContentsBulkAction.Remove.ToString()
}
};
var ContentTypeOptions = (await GetListableTypesAsync())
.Select(ctd => new KeyValuePair <string, string>(ctd.Name, ctd.DisplayName))
.ToList().OrderBy(kvp => kvp.Value);
model.Options.ContentTypeOptions = new List <SelectListItem>();
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = T["All content types"].Value, Value = ""
});
foreach (var option in ContentTypeOptions)
{
model.Options.ContentTypeOptions.Add(new SelectListItem()
{
Text = option.Value, Value = option.Key
});
}
var viewModel = new ListContentsViewModel
{
ContentItems = contentItemSummaries,
Pager = pagerShape,
Options = model.Options
};
return(View(viewModel));
}
