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