public async Task <ActiveLocale> ExecuteAsync(GetByIdQuery <ActiveLocale> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <ActiveLocale>())
.SingleOrDefault(l => l.LocaleId == query.Id);
return(result);
}
public async Task <WebDirectoryRoute> ExecuteAsync(GetByIdQuery <WebDirectoryRoute> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <WebDirectoryRoute>())
.SingleOrDefault(l => l.WebDirectoryId == query.Id);
return(result);
}
public async Task <PageRoute> ExecuteAsync(GetByIdQuery <PageRoute> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <PageRoute>(executionContext))
.SingleOrDefault(p => p.PageId == query.Id);
return(result);
}
private async Task <PageModuleTypeDetails> GetPageModuleTypeById(int id)
{
var allModuleTypes = await _queryExecutor.GetAllAsync <PageModuleTypeSummary>();
var moduleTypeSummary = allModuleTypes
.SingleOrDefault(t => t.PageModuleTypeId == id);
return(Mapper.Map <PageModuleTypeDetails>(moduleTypeSummary));
}
public async Task <IDictionary <int, PageRoute> > ExecuteAsync(GetByIdRangeQuery <PageRoute> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <PageRoute>(executionContext))
.Where(r => query.Ids.Contains(r.PageId))
.ToDictionary(r => r.PageId);
return(result);
}
public async Task <PageRoutingInfo> ExecuteAsync(GetPageRoutingInfoByPathQuery query, IExecutionContext executionContext)
{
// Deal with malformed query
if (!string.IsNullOrWhiteSpace(query.Path) && !Uri.IsWellFormedUriString(query.Path, UriKind.Relative))
{
return(null);
}
var path = _pathHelper.StandardisePath(query.Path);
var allRoutes = await _queryExecutor.GetAllAsync <PageRoute>(executionContext);
// Rather than starts with, do a regex replacement here with the path
// E.g. /styuff/{slug} is not matching /styff/winterlude
var pageRoutes = allRoutes
.Where(r => r.FullPath.Equals(path) || (r.PageType == PageType.CustomEntityDetails && IsCustomRoutingMatch(path, r.FullPath)))
.Where(r => query.IncludeUnpublished || r.IsPublished)
.Where(r => r.Locale == null || MatchesLocale(r.Locale, query.LocaleId))
.OrderByDescending(r => r.FullPath.Equals(path))
.ThenByDescending(r => MatchesLocale(r.Locale, query.LocaleId))
.ToList();
PageRoutingInfo result = null;
// Exact match
if (pageRoutes.Any() && pageRoutes[0].PageType != PageType.CustomEntityDetails)
{
result = ToRoutingInfo(pageRoutes[0]);
}
else
{
var allRules = _queryExecutor.GetAll <ICustomEntityRoutingRule>(executionContext);
// I'm only anticipating a single rule to match at the moment, but eventually there might be multiple rules to match e.g. categories page
foreach (var pageRoute in pageRoutes)
{
// Find a routing rule, matching higher priorities first
var rule = allRules
.Where(r => r.MatchesRule(query.Path, pageRoute))
.OrderBy(r => r.Priority)
.ThenBy(r => r.RouteFormat.Length)
.FirstOrDefault();
if (rule != null)
{
var customEntityRouteQuery = rule.ExtractRoutingQuery(query.Path, pageRoute);
var customEntityRoute = await _queryExecutor.ExecuteAsync(customEntityRouteQuery, executionContext);
if (customEntityRoute != null && (query.IncludeUnpublished || customEntityRoute.Versions.HasPublishedVersion()))
{
return(ToRoutingInfo(pageRoute, customEntityRoute, rule));
}
}
}
}
return(result);
}
public async Task <IEnumerable <PageRoute> > ExecuteAsync(GetPageRoutesByCustomEntityDefinitionCodeQuery query, IExecutionContext executionContext)
{
var allRoutes = await _queryExecutor.GetAllAsync <PageRoute>(executionContext);
var customEntityRoutes = allRoutes
.Where(p => p.CustomEntityDefinitionCode == query.CustomEntityDefinitionCode)
.OrderBy(p => p.Locale != null)
.ThenBy(p => p.Title)
.ToList();
return(customEntityRoutes);
}
public async Task <IEnumerable <CustomEntityRenderSummary> > MapSummariesAsync(
ICollection <CustomEntityVersion> dbResults,
IExecutionContext executionContext
)
{
var routingsQuery = GetPageRoutingQuery(dbResults);
var allRoutings = await _queryExecutor.ExecuteAsync(routingsQuery, executionContext);
var allLocales = await _queryExecutor.GetAllAsync <ActiveLocale>(executionContext);
return(Map(dbResults, allRoutings, allLocales));
}
public async Task <IEnumerable <PageSectionDetails> > ExecuteAsync(GetPageSectionDetailsByPageVersionIdQuery query, IExecutionContext executionContext)
{
var sections = await GetSections(query).ToListAsync();
var dbModules = await QueryModules(query).ToListAsync();
var allModuleTypes = await _queryExecutor.GetAllAsync <PageModuleTypeSummary>(executionContext);
MapSections(sections, dbModules, allModuleTypes);
return(sections);
}
public async Task <ActiveLocale> ExecuteAsync(GetActiveLocaleByIETFLanguageTagQuery query, IExecutionContext executionContext)
{
if (!IsTagValid(query.IETFLanguageTag))
{
return(null);
}
var result = (await _queryExecutor
.GetAllAsync <ActiveLocale>())
.SingleOrDefault(l => l.IETFLanguageTag.Equals(query.IETFLanguageTag, StringComparison.OrdinalIgnoreCase));
return(result);
}
public async Task <PagedQueryResult <CustomEntitySummary> > ExecuteAsync(SearchCustomEntitySummariesQuery query, IExecutionContext executionContext)
{
var definition = _queryExecutor.GetById <CustomEntityDefinitionSummary>(query.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, query.CustomEntityDefinitionCode);
// Get Query
var dbQuery = GetQuery(query, definition);
// Execute Query
var dbPagedResult = dbQuery.ToPagedResult(query);
var routingsQuery = new GetPageRoutingInfoByCustomEntityIdRangeQuery(dbPagedResult.Items.Select(e => e.CustomEntityId));
var routings = await _queryExecutor.ExecuteAsync(routingsQuery);
var allLocales = (await _queryExecutor.GetAllAsync <ActiveLocale>()).ToDictionary(l => l.LocaleId);
// Map Items
var entities = new List <CustomEntitySummary>(dbPagedResult.Items.Length);
foreach (var dbVersion in dbPagedResult.Items)
{
PageRoutingInfo detailsRouting = null;
if (routings.ContainsKey(dbVersion.CustomEntityId))
{
detailsRouting = routings[dbVersion.CustomEntityId].FirstOrDefault(r => r.CustomEntityRouteRule != null);
}
var entity = Mapper.Map <CustomEntitySummary>(dbVersion);
if (dbVersion.LocaleId.HasValue)
{
entity.Locale = allLocales.GetOrDefault(dbVersion.LocaleId.Value);
EntityNotFoundException.ThrowIfNull(entity.Locale, dbVersion.LocaleId.Value);
}
if (detailsRouting != null)
{
entity.FullPath = detailsRouting.CustomEntityRouteRule.MakeUrl(detailsRouting.PageRoute, detailsRouting.CustomEntityRoute);
}
entity.Model = (ICustomEntityVersionDataModel)_dbUnstructuredDataSerializer.Deserialize(dbVersion.SerializedData, definition.DataModelType);
entity.AuditData.UpdateDate = dbVersion.VersionAuditData.CreateDate;
entity.AuditData.Updater = dbVersion.VersionAuditData.Creator;
entities.Add(entity);
}
return(dbPagedResult.ChangeType(entities));
}
public async Task <PageRoute> ExecuteAsync(GetNotFoundPageRouteByPathQuery query, IExecutionContext executionContext)
{
if (!string.IsNullOrWhiteSpace(query.Path) && !Uri.IsWellFormedUriString(query.Path, UriKind.Relative))
{
return(null);
}
var path = _pathHelper.StandardisePath(query.Path);
var allRoutes = (await _queryExecutor
.GetAllAsync <PageRoute>())
.Where(r => r.IsPublished || query.IncludeUnpublished)
.Where(r => r.PageType == PageType.NotFound);
var paths = path
.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
PageRoute notFoundRoute = null;
// Work backwards through the path to find a 404 page
while (notFoundRoute == null)
{
var pathToTest = string.Join("/", paths);
if (string.IsNullOrEmpty(pathToTest))
{
pathToTest = "/";
}
// Prefer the specified locale, but fall back to a non-specific locale page
notFoundRoute = allRoutes
.Where(r => r.IsInDirectory(pathToTest) && r.Locale == null || MatchesLocale(r.Locale, query.LocaleId))
.OrderByDescending(r => MatchesLocale(r.Locale, query.LocaleId))
.FirstOrDefault();
// After we've checked the root directory, break and return null
if (paths.Count <= 0)
{
break;
}
// Move backwards down the path
paths.Remove(paths.Last());
}
return(notFoundRoute);
}
public async Task <IDictionary <int, PageRenderDetails> > ExecuteAsync(GetPageRenderDetailsByIdRangeQuery query, IExecutionContext executionContext)
{
var dbPages = await QueryPages(query).FirstOrDefaultAsync();
var pages = Mapper.Map <List <PageRenderDetails> >(dbPages);
var pageRoutes = await _queryExecutor.GetByIdRangeAsync <PageRoute>(GetAllPageIds(pages), executionContext);
MapPageRoutes(pages, pageRoutes);
var dbModules = await QueryModules(pages).ToListAsync();
var allModuleTypes = await _queryExecutor.GetAllAsync <PageModuleTypeSummary>(executionContext);
_entityVersionPageModuleMapper.MapSections(dbModules, pages.SelectMany(p => p.Sections), allModuleTypes, query.WorkFlowStatus);
return(pages.ToDictionary(d => d.PageId));
}
public async Task MapSectionsAsync <TModuleRenderDetails>(IEnumerable <IEntityVersionPageModule> dbModules, IEnumerable <IEntitySectionRenderDetails <TModuleRenderDetails> > sections, WorkFlowStatusQuery workflowStatus, IExecutionContext executionContext)
where TModuleRenderDetails : IEntityVersionPageModuleRenderDetails, new()
{
var allModuleTypes = await _queryExecutor.GetAllAsync <PageModuleTypeSummary>(executionContext);
var mappedModules = ToModuleMappingData(dbModules, allModuleTypes, workflowStatus);
// Map Sections
foreach (var section in sections)
{
var sectionMappedModules = mappedModules
.Where(m => m.PageModule.PageTemplateSectionId == section.PageTemplateSectionId)
.OrderBy(m => m.PageModule.Ordering);
section.Modules = ToModuleRenderDetails <TModuleRenderDetails>(sectionMappedModules).ToArray();
}
}
public async Task <PageRenderDetails> ExecuteAsync(GetPageRenderDetailsByIdQuery query, IExecutionContext executionContext)
{
var dbPage = await QueryPage(query).FirstOrDefaultAsync();
if (dbPage == null)
{
return(null);
}
var page = Mapper.Map <PageRenderDetails>(dbPage);
page.PageRoute = await _queryExecutor.GetByIdAsync <PageRoute>(page.PageId, executionContext);
var dbModules = await QueryModules(page).ToListAsync();
var allModuleTypes = await _queryExecutor.GetAllAsync <PageModuleTypeSummary>(executionContext);
_entityVersionPageModuleMapper.MapSections(dbModules, page.Sections, allModuleTypes, query.WorkFlowStatus);
return(page);
}
public async Task <IHttpActionResult> Get()
{
var results = await _queryExecutor.GetAllAsync <CustomEntityDefinitionSummary>();
return(_apiResponseHelper.SimpleQueryResponse(this, results));
}
/// <summary>
/// Returns all IPermission instances registered with Cofoundry.
/// </summary>
/// <param name="executionContext">Optional execution context to use when executing the query. Useful if you need to temporarily elevate your permission level.</param>
public Task <IEnumerable <IPermission> > GetAllPermissionsAsync(IExecutionContext executionContext = null)
{
return(_queryExecutor.GetAllAsync <IPermission>(executionContext));
}
public Task <IEnumerable <PageModuleTypeSummary> > GetAllPageModuleTypeSummariesAsync(IExecutionContext executionContext = null)
{
return(_queryExecutor.GetAllAsync <PageModuleTypeSummary>(executionContext));
}
public async Task <IHttpActionResult> Get()
{
var results = await _queryExecutor.GetAllAsync <WebDirectoryRoute>();
return(_apiResponseHelper.SimpleQueryResponse(this, results));
}
public async Task <IHttpActionResult> Get()
{
var results = await _queryExecutor.GetAllAsync <UserAreaMicroSummary>();
return(_apiResponseHelper.SimpleQueryResponse(this, results));
}
public async Task <RewriteRuleSummary> ExecuteAsync(GetRewriteRuleByPathQuery query, IExecutionContext executionContext)
{
var rules = await _queryExecutor.GetAllAsync <RewriteRuleSummary>();
return(FindRule(query, rules));
}
public Task <IEnumerable <PageRoute> > GetAllPageRoutesAsync(IExecutionContext executionContext = null)
{
return(_queryExecutor.GetAllAsync <PageRoute>(executionContext));
}
public Task <IEnumerable <RewriteRuleSummary> > GetAllRewriteRuleSummariesAsync(IExecutionContext executionContext = null)
{
return(_queryExecutor.GetAllAsync <RewriteRuleSummary>(executionContext));
}
public Task <IEnumerable <CustomEntityDefinitionMicroSummary> > GetAllCustomEntityDefinitionMicroSummariesAsync(IExecutionContext executionContext = null)
{
return(_queryExecutor.GetAllAsync <CustomEntityDefinitionMicroSummary>(executionContext));
}
/// <summary>
/// Returns all web directories as WebDirectoryRoute instances. The results of this query are cached.
/// </summary>
/// <param name="executionContext">Optional execution context to use when executing the query. Useful if you need to temporarily elevate your permission level.</param>
public Task <IEnumerable <WebDirectoryRoute> > GetAllWebDirectoryRoutesAsync(IExecutionContext executionContext = null)
{
return(_queryExecutor.GetAllAsync <WebDirectoryRoute>(executionContext));
}
private async Task MapPages(CustomEntityVersion dbVersion, CustomEntityDetails entity, IExecutionContext executionContext)
{
var pages = new List <CustomEntityDetailsPage>();
entity.LatestVersion.Pages = pages;
var routingsQuery = new GetPageRoutingInfoByCustomEntityIdQuery(dbVersion.CustomEntityId);
var routings = (await _queryExecutor.ExecuteAsync(routingsQuery, executionContext))
.Where(r => r.CustomEntityRouteRule != null);
if (!routings.Any())
{
return;
}
// Map templates
var pageTemplateIds = routings
.Select(r => new
{
PageId = r.PageRoute.PageId,
VersionRoute = r.PageRoute.Versions.GetVersionRouting(WorkFlowStatusQuery.Latest)
})
.Where(r => r.VersionRoute != null && r.VersionRoute.HasCustomEntityModuleSections)
.ToDictionary(k => k.PageId, v => v.VersionRoute.PageTemplateId);
var allTemplateIds = pageTemplateIds
.Select(r => r.Value)
.ToArray();
var allTemplateSections = await _dbContext
.PageTemplateSections
.AsNoTracking()
.Where(s => allTemplateIds.Contains(s.PageTemplateId) && s.IsCustomEntitySection)
.ToListAsync();
var allModuleTypes = await _queryExecutor.GetAllAsync <PageModuleTypeSummary>(executionContext);
foreach (var routing in routings)
{
var page = new CustomEntityDetailsPage();
pages.Add(page);
page.FullPath = routing.CustomEntityRouteRule.MakeUrl(routing.PageRoute, routing.CustomEntityRoute);
page.PageRoute = routing.PageRoute;
// Map Sections
var templateId = pageTemplateIds.GetOrDefault(routing.PageRoute.PageId);
page.Sections = allTemplateSections
.Where(s => s.PageTemplateId == templateId)
.OrderBy(s => s.UpdateDate)
.Select(s => new CustomEntityPageSectionDetails()
{
Name = s.Name,
PageTemplateSectionId = s.PageTemplateSectionId
})
.ToList();
// Map Modules
foreach (var section in page.Sections)
{
section.Modules = dbVersion
.CustomEntityVersionPageModules
.Where(m => m.PageTemplateSectionId == section.PageTemplateSectionId)
.OrderBy(m => m.Ordering)
.Select(m => MapModule(m, allModuleTypes))
.ToArray();
}
}
// Map default full path
entity.FullPath = pages
.OrderByDescending(p => p.PageRoute.Locale == null)
.Select(p => p.FullPath)
.First();
}
public async Task <IHttpActionResult> Get()
{
var results = await _queryExecutor.GetAllAsync <ICustomEntityRoutingRule>();
return(_apiResponseHelper.SimpleQueryResponse(this, results));
}
public async Task <IHttpActionResult> Get()
{
var results = await _queryExecutor.GetAllAsync <DocumentAssetFileType>();
return(_apiResponseHelper.SimpleQueryResponse(this, results));
}
