private async Task <PagerSlim> GetPagerSlimAsync(BuildPartDisplayContext context)
{
var settings = context.TypePartDefinition.GetSettings <ListPartSettings>();
var pagerParameters = new PagerSlimParameters();
await context.Updater.TryUpdateModelAsync(pagerParameters);
var pager = new PagerSlim(pagerParameters, settings.PageSize);
return(pager);
}
private async Task <PagerSlim> GetPagerAsync(IUpdateModel updater, ListPart part)
{
var settings = GetSettings(part);
PagerSlimParameters pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
PagerSlim pager = new PagerSlim(pagerParameters, settings.PageSize);
return(pager);
}
private async Task <PagerSlim> GetPagerAsync(IUpdateModel updater, CrossReferencePart part, string partName)
{
var settings = GetSettings(part, partName);
PagerSlimParameters pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
PagerSlim pager = new PagerSlim(pagerParameters, settings.PageSize);
return(pager);
}
private async Task <PagerSlim> GetPagerAsync(IUpdateModel updater, TaxonomyPart part)
{
//var settings = GetSettings(part);
PagerSlimParameters pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
PagerSlim pager = new PagerSlim(pagerParameters, 10);
return(pager);
}
private async Task <object> GetPagerObjectAsync(IUpdateModel updater, CrossReferencePart part, string partName)
{
var settings = GetSettings(part, partName);
// if (settings.PagerSlimDisabled)
// {
// var pagerParameters = new PagerParameters();
// await updater.TryUpdateModelAsync(pagerParameters);
//
// var pager = new Pager(pagerParameters, settings.PageSize);
//
// return pager;
// }
// else
// {
var pagerParameters = new PagerSlimParameters();
await updater.TryUpdateModelAsync(pagerParameters);
var pager = new PagerSlim(pagerParameters, settings.PageSize);
return(pager);
// }
}
private async Task <IEnumerable <ContentItem> > QueryListItemsAsync(ListPart listPart, PagerSlim pager)
{
if (pager.Before != null)
{
var beforeValue = new DateTime(long.Parse(pager.Before));
var query = _session.QueryAsync <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == listPart.ContentItem.ContentItemId)
.With <ContentItemIndex>(x => x.Published && x.CreatedUtc > beforeValue)
.OrderBy(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
var containedItems = await query.List();
if (containedItems.Count() == 0)
{
return(containedItems);
}
containedItems = containedItems.Reverse();
// There is always an After ras we clicked on Before
pager.Before = null;
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Skip(1);
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
return(containedItems);
}
else if (pager.After != null)
{
var afterValue = new DateTime(long.Parse(pager.After));
var query = _session.QueryAsync <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == listPart.ContentItem.ContentItemId)
.With <ContentItemIndex>(x => x.Published && x.CreatedUtc < afterValue)
.OrderByDescending(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
var containedItems = await query.List();
if (containedItems.Count() == 0)
{
return(containedItems);
}
// There is always a Before page as we clicked on After
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
return(containedItems);
}
else
{
var query = _session.QueryAsync <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == listPart.ContentItem.ContentItemId)
.With <ContentItemIndex>(x => x.Published)
.OrderByDescending(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
var containedItems = await query.List();
if (containedItems.Count() == 0)
{
return(containedItems);
}
pager.Before = null;
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
return(containedItems);
}
}
private async Task <IEnumerable <ContentItem> > QueryTermItemsAsync(TermPart termPart, PagerSlim pager)
{
if (pager.Before != null)
{
var beforeValue = new DateTime(long.Parse(pager.Before));
var query = _session.Query <ContentItem>()
.With <TaxonomyIndex>(x => x.TermContentItemId == termPart.ContentItem.ContentItemId)
.With <ContentItemIndex>(CreateContentIndexFilter(beforeValue, null))
.OrderBy(x => x.CreatedUtc)
.Take(pager.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
pager.Before = null;
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Skip(1);
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
return(await _contentManager.LoadAsync(containedItems));
}
else if (pager.After != null)
{
var afterValue = new DateTime(long.Parse(pager.After));
var query = _session.Query <ContentItem>()
.With <TaxonomyIndex>(x => x.TermContentItemId == termPart.ContentItem.ContentItemId)
.With <ContentItemIndex>(CreateContentIndexFilter(null, afterValue))
.OrderByDescending(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
// There is always a Before page as we clicked on After
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
return(await _contentManager.LoadAsync(containedItems));
}
else
{
var query = _session.Query <ContentItem>()
.With <TaxonomyIndex>(x => x.TermContentItemId == termPart.ContentItem.ContentItemId)
.With <ContentItemIndex>(CreateContentIndexFilter(null, null))
.OrderByDescending(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
pager.Before = null;
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
return(await _contentManager.LoadAsync(containedItems));
}
}
public async Task <IActionResult> Search(SearchIndexViewModel viewModel, PagerSlimParameters pagerParameters)
{
var permissionsProvider = _permissionProviders.FirstOrDefault(x => x.GetType().FullName == "OrchardCore.Lucene.Permissions");
var permissions = await permissionsProvider.GetPermissionsAsync();
var siteSettings = await _siteService.GetSiteSettingsAsync();
var searchSettings = siteSettings.As <LuceneSettings>();
if (permissions.FirstOrDefault(x => x.Name == "QueryLucene" + searchSettings.SearchIndex + "Index") != null)
{
if (!await _authorizationService.AuthorizeAsync(User, permissions.FirstOrDefault(x => x.Name == "QueryLucene" + searchSettings.SearchIndex + "Index")))
{
return(this.ChallengeOrForbid());
}
}
else
{
_logger.LogInformation("Couldn't execute search. The search index doesn't exist.");
return(BadRequest("Search is not configured."));
}
if (searchSettings.SearchIndex != null && !_luceneIndexProvider.Exists(searchSettings.SearchIndex))
{
_logger.LogInformation("Couldn't execute search. The search index doesn't exist.");
return(BadRequest("Search is not configured."));
}
var luceneSettings = await _luceneIndexingService.GetLuceneSettingsAsync();
if (luceneSettings == null || luceneSettings?.DefaultSearchFields == null)
{
_logger.LogInformation("Couldn't execute search. No Lucene settings was defined.");
return(BadRequest("Search is not configured."));
}
var luceneIndexSettings = await _luceneIndexSettingsService.GetSettingsAsync(searchSettings.SearchIndex);
if (luceneIndexSettings == null)
{
_logger.LogInformation($"Couldn't execute search. No Lucene index settings was defined for ({searchSettings.SearchIndex}) index.");
return(BadRequest($"Search index ({searchSettings.SearchIndex}) is not configured."));
}
if (string.IsNullOrWhiteSpace(viewModel.Terms))
{
return(View(new SearchIndexViewModel
{
SearchForm = new SearchFormViewModel("Search__Form")
{
},
}));
}
var pager = new PagerSlim(pagerParameters, siteSettings.PageSize);
// We Query Lucene index
var analyzer = _luceneAnalyzerManager.CreateAnalyzer(await _luceneIndexSettingsService.GetIndexAnalyzerAsync(luceneIndexSettings.IndexName));
var queryParser = new MultiFieldQueryParser(LuceneSettings.DefaultVersion, luceneSettings.DefaultSearchFields, analyzer);
var query = queryParser.Parse(QueryParser.Escape(viewModel.Terms));
// Fetch one more result than PageSize to generate "More" links
var start = 0;
var end = pager.PageSize + 1;
if (pagerParameters.Before != null)
{
start = Convert.ToInt32(pagerParameters.Before) - pager.PageSize - 1;
end = Convert.ToInt32(pagerParameters.Before);
}
else if (pagerParameters.After != null)
{
start = Convert.ToInt32(pagerParameters.After);
end = Convert.ToInt32(pagerParameters.After) + pager.PageSize + 1;
}
var contentItemIds = await _searchQueryService.ExecuteQueryAsync(query, searchSettings.SearchIndex, start, end);
// We Query database to retrieve content items.
IQuery <ContentItem> queryDb;
if (luceneIndexSettings.IndexLatest)
{
queryDb = _session.Query <ContentItem, ContentItemIndex>()
.Where(x => x.ContentItemId.IsIn(contentItemIds) && x.Latest == true)
.Take(pager.PageSize + 1);
}
else
{
queryDb = _session.Query <ContentItem, ContentItemIndex>()
.Where(x => x.ContentItemId.IsIn(contentItemIds) && x.Published == true)
.Take(pager.PageSize + 1);
}
var containedItems = await queryDb.ListAsync();
// We set the PagerSlim before and after links
if (pagerParameters.After != null || pagerParameters.Before != null)
{
if (start + 1 > 1)
{
pager.Before = (start + 1).ToString();
}
else
{
pager.Before = null;
}
}
if (containedItems.Count() == pager.PageSize + 1)
{
pager.After = (end - 1).ToString();
}
else
{
pager.After = null;
}
var model = new SearchIndexViewModel
{
Terms = viewModel.Terms,
SearchForm = new SearchFormViewModel("Search__Form")
{
Terms = viewModel.Terms
},
SearchResults = new SearchResultsViewModel("Search__Results")
{
ContentItems = containedItems.Take(pager.PageSize)
},
Pager = (await New.PagerSlim(pager)).UrlParams(new Dictionary <string, string>()
{
{ "Terms", viewModel.Terms }
})
};
return(View(model));
}
public async Task FilterAsync(IQuery <ContentItem> query, PagerSlim pager)
{
var updateModel = _updateModelAccessor.ModelUpdater;
var model = new ListPartContentOptions();
if (await updateModel.TryUpdateModelAsync(model, "ListPartOptions"))
{
if (!string.IsNullOrEmpty(model.DisplayText))
{
query = query.With <ContentItemIndex>(x => x.DisplayText.Contains(model.DisplayText));
pager.UrlParams.Add("ListPartOptions.DisplayText", model.DisplayText);
}
switch (model.ContentsStatus)
{
case ContentsStatus.Published:
query = query.With <ContentItemIndex>(x => x.Published);
pager.UrlParams.Add("ListPartOptions.ContentsStatus", "Published");
break;
case ContentsStatus.Draft:
query = query.With <ContentItemIndex>(x => x.Latest && !x.Published);
pager.UrlParams.Add("ListPartOptions.ContentsStatus", "Draft");
break;
case ContentsStatus.AllVersions:
query = query.With <ContentItemIndex>(x => x.Latest);
pager.UrlParams.Add("ListPartOptions.ContentsStatus", "AllVersions");
break;
case ContentsStatus.Latest:
query = query.With <ContentItemIndex>(x => x.Latest);
pager.UrlParams.Add("ListPartOptions.ContentsStatus", "Latest");
break;
}
if (model.ContentsStatus == ContentsStatus.Owner)
{
query = query.With <ContentItemIndex>(x => x.Owner == _httpContextAccessor.HttpContext.User.Identity.Name);
pager.UrlParams.Add("ListPartOptions.ContentsStatus", "Owner");
}
if (!String.IsNullOrEmpty(model.SelectedContentType))
{
query = query.With <ContentItemIndex>(x => x.ContentType == model.SelectedContentType);
pager.UrlParams.Add("ListPartOptions.SelectedContentType", model.SelectedContentType);
}
/*
* switch (model.OrderBy)
* {
* case ContentsOrder.Modified:
* query = query.With<ContentItemIndex>().OrderByDescending(x => x.ModifiedUtc);
* break;
* case ContentsOrder.Published:
* query = query.With<ContentItemIndex>().OrderByDescending(cr => cr.PublishedUtc);
* break;
* case ContentsOrder.Created:
* query = query.With<ContentItemIndex>().OrderByDescending(cr => cr.CreatedUtc);
* break;
* case ContentsOrder.Title:
* query = query.With<ContentItemIndex>().OrderByDescending(cr => cr.DisplayText);
* break;
* default:
* query = query.With<ContentItemIndex>().OrderByDescending(cr => cr.ModifiedUtc);
* break;
* }
*/
// 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 async Task <IEnumerable <ContentItem> > QueryContainedItemsAsync(string contentItemId, bool enableOrdering, PagerSlim pager, bool publishedOnly)
{
IQuery <ContentItem> query = null;
if (pager.Before != null)
{
if (enableOrdering)
{
var beforeValue = int.Parse(pager.Before);
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(CreateOrderedContainedPartIndexFilter(beforeValue, null, contentItemId))
.OrderByDescending(x => x.Order)
.With <ContentItemIndex>(CreateOrderedContentIndexFilter(publishedOnly))
.Take(pager.PageSize + 1);
}
else
{
var beforeValue = new DateTime(long.Parse(pager.Before));
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == contentItemId)
.With <ContentItemIndex>(CreateDefaultContentIndexFilter(beforeValue, null, publishedOnly))
.OrderBy(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
}
// Invoke any service that could alter the query
await _listPartcontentSearchFilters.InvokeAsync((filter, query, pagerParameters) => filter.FilterAsync(query, pager), query, pager, Logger);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
containedItems = containedItems.Reverse();
// There is always an After as we clicked on Before
pager.Before = null;
if (enableOrdering)
{
pager.After = containedItems.Last().As <ContainedPart>().Order.ToString();
}
else
{
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Skip(1);
if (enableOrdering)
{
pager.Before = containedItems.First().As <ContainedPart>().Order.ToString();
}
else
{
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
}
return(containedItems);
}
else if (pager.After != null)
{
if (enableOrdering)
{
var afterValue = int.Parse(pager.After);
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(CreateOrderedContainedPartIndexFilter(null, afterValue, contentItemId))
.OrderBy(x => x.Order)
.With <ContentItemIndex>(CreateOrderedContentIndexFilter(publishedOnly))
.Take(pager.PageSize + 1);
}
else
{
var afterValue = new DateTime(long.Parse(pager.After));
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(CreateOrderedContainedPartIndexFilter(null, null, contentItemId))
.With <ContentItemIndex>(CreateDefaultContentIndexFilter(null, afterValue, publishedOnly))
.OrderByDescending(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
}
// Invoke any service that could alter the query
await _listPartcontentSearchFilters.InvokeAsync((filter, query, pagerParameters) => filter.FilterAsync(query, pager), query, pager, Logger);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
// There is always a Before page as we clicked on After
if (enableOrdering)
{
pager.Before = containedItems.First().As <ContainedPart>().Order.ToString();
}
else
{
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
if (enableOrdering)
{
pager.After = containedItems.Last().As <ContainedPart>().Order.ToString();
}
else
{
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
}
return(containedItems);
}
else
{
if (enableOrdering)
{
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(CreateOrderedContainedPartIndexFilter(null, null, contentItemId))
.OrderBy(x => x.Order)
.With <ContentItemIndex>(CreateOrderedContentIndexFilter(publishedOnly))
.Take(pager.PageSize + 1);
}
else
{
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == contentItemId)
.With <ContentItemIndex>(CreateDefaultContentIndexFilter(null, null, publishedOnly))
.OrderByDescending(x => x.CreatedUtc)
.Take(pager.PageSize + 1);
}
// Invoke any service that could alter the query
await _listPartcontentSearchFilters.InvokeAsync((filter, query, pagerParameters) => filter.FilterAsync(query, pager), query, pager, Logger);
var containedItems = await query.ListAsync();
if (containedItems.Count() == 0)
{
return(containedItems);
}
pager.Before = null;
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
if (enableOrdering)
{
pager.After = containedItems.Last().As <ContainedPart>().Order.ToString();
}
else
{
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
}
return(containedItems);
}
}
public async Task <IEnumerable <ContentItem> > QueryContainedItemsAsync(
string contentItemId,
bool enableOrdering,
PagerSlim pager,
ContainedItemOptions containedItemOptions)
{
if (containedItemOptions == null)
{
throw new ArgumentNullException(nameof(containedItemOptions));
}
IQuery <ContentItem> query = null;
if (pager.Before != null)
{
if (enableOrdering)
{
var beforeValue = int.Parse(pager.Before);
query = _session.Query <ContentItem>()
.With(CreateOrderedContainedPartIndexFilter(beforeValue, null, contentItemId))
.OrderByDescending(x => x.Order);
}
else
{
var beforeValue = new DateTime(long.Parse(pager.Before));
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == contentItemId);
ApplyPagingContentIndexFilter(beforeValue, null, true, query);
}
ApplyContainedItemOptionsFilter(containedItemOptions, query);
// Take() needs to be the last expression in the query otherwise the ORDER BY clause will be
// syntactically incorrect.
query.Take(pager.PageSize + 1);
// Load items so that loading handlers are invoked.
var containedItems = await query.ListAsync(_contentManager);
if (!containedItems.Any())
{
return(containedItems);
}
containedItems = containedItems.Reverse();
// There is always an After as we clicked on Before
pager.Before = null;
if (enableOrdering)
{
pager.After = containedItems.Last().As <ContainedPart>().Order.ToString();
}
else
{
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Skip(1);
if (enableOrdering)
{
pager.Before = containedItems.First().As <ContainedPart>().Order.ToString();
}
else
{
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
}
return(containedItems);
}
else if (pager.After != null)
{
if (enableOrdering)
{
var afterValue = int.Parse(pager.After);
query = _session.Query <ContentItem>()
.With(CreateOrderedContainedPartIndexFilter(null, afterValue, contentItemId))
.OrderBy(x => x.Order);
}
else
{
var afterValue = new DateTime(long.Parse(pager.After));
query = _session.Query <ContentItem>()
.With(CreateOrderedContainedPartIndexFilter(null, null, contentItemId));
ApplyPagingContentIndexFilter(null, afterValue, false, query);
}
ApplyContainedItemOptionsFilter(containedItemOptions, query);
query.Take(pager.PageSize + 1);
// Load items so that loading handlers are invoked.
var containedItems = await query.ListAsync(_contentManager);
if (!containedItems.Any())
{
return(containedItems);
}
// There is always a Before page as we clicked on After
if (enableOrdering)
{
pager.Before = containedItems.First().As <ContainedPart>().Order.ToString();
}
else
{
pager.Before = containedItems.First().CreatedUtc.Value.Ticks.ToString();
}
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
if (enableOrdering)
{
pager.After = containedItems.Last().As <ContainedPart>().Order.ToString();
}
else
{
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
}
return(containedItems);
}
else
{
if (enableOrdering)
{
query = _session.Query <ContentItem>()
.With(CreateOrderedContainedPartIndexFilter(null, null, contentItemId))
.OrderBy(x => x.Order);
}
else
{
query = _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId == contentItemId);
ApplyPagingContentIndexFilter(null, null, false, query);
}
ApplyContainedItemOptionsFilter(containedItemOptions, query);
query.Take(pager.PageSize + 1);
// Load items so that loading handlers are invoked.
var containedItems = await query.ListAsync(_contentManager);
if (!containedItems.Any())
{
return(containedItems);
}
pager.Before = null;
pager.After = null;
if (containedItems.Count() == pager.PageSize + 1)
{
containedItems = containedItems.Take(pager.PageSize);
if (enableOrdering)
{
pager.After = containedItems.Last().As <ContainedPart>().Order.ToString();
}
else
{
pager.After = containedItems.Last().CreatedUtc.Value.Ticks.ToString();
}
}
return(containedItems);
}
}
