private async Task SetUmbracoRouteValues(ActionExecutingContext context, IPublishedContent content) { if (content != null) { IUmbracoContextAccessor umbracoContextAccessor = context.HttpContext.RequestServices.GetRequiredService <IUmbracoContextAccessor>(); IPublishedRouter router = context.HttpContext.RequestServices.GetRequiredService <IPublishedRouter>(); var umbracoContext = umbracoContextAccessor.GetRequiredUmbracoContext(); IPublishedRequestBuilder requestBuilder = await router.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl); requestBuilder.SetPublishedContent(content); IPublishedRequest publishedRequest = requestBuilder.Build(); var routeValues = new UmbracoRouteValues( publishedRequest, (ControllerActionDescriptor)context.ActionDescriptor); context.HttpContext.Features.Set(routeValues); } else { // if there is no content then it should be a not found context.Result = new NotFoundResult(); } }
private async Task SetUmbracoRouteValues(ActionExecutingContext context, IPublishedContent?content) { if (content != null) { UriUtility uriUtility = context.HttpContext.RequestServices.GetRequiredService <UriUtility>(); var originalRequestUrl = new Uri(context.HttpContext.Request.GetEncodedUrl()); Uri cleanedUrl = uriUtility.UriToUmbraco(originalRequestUrl); IPublishedRouter router = context.HttpContext.RequestServices.GetRequiredService <IPublishedRouter>(); IPublishedRequestBuilder requestBuilder = await router.CreateRequestAsync(cleanedUrl); requestBuilder.SetPublishedContent(content); IPublishedRequest publishedRequest = requestBuilder.Build(); var routeValues = new UmbracoRouteValues( publishedRequest, (ControllerActionDescriptor)context.ActionDescriptor); context.HttpContext.Features.Set(routeValues); } else { // if there is no content then it should be a not found context.Result = new NotFoundResult(); } }
private async Task <IPublishedRequest> TryRouteRequest(IPublishedRequestBuilder request) { FindDomain(request); if (request.IsRedirect()) { return(request.Build()); } if (request.HasPublishedContent()) { return(request.Build()); } await FindPublishedContent(request); return(request.Build()); }
private IPublishedRequest TryRouteRequest(IPublishedRequestBuilder request) { FindDomain(request); if (request.IsRedirect()) { return(request.Build()); } if (request.HasPublishedContent()) { return(request.Build()); } FindPublishedContent(request); return(request.Build()); }
/// <summary> /// This method finalizes/builds the PCR with the values assigned. /// </summary> /// <returns> /// Returns false if the request was not successfully configured /// </returns> /// <remarks> /// This method logic has been put into it's own method in case developers have created a custom PCR or are assigning /// their own values /// but need to finalize it themselves. /// </remarks> internal IPublishedRequest BuildRequest(IPublishedRequestBuilder builder) { IPublishedRequest result = builder.Build(); if (!builder.HasPublishedContent()) { return(result); } // set the culture -- again, 'cos it might have changed in the event handler SetVariationContext(result.Culture); return(result); }
public void Builds_All_Values() { IPublishedRequestBuilder sut = GetBuilder(); IPublishedContent content = Mock.Of <IPublishedContent>(x => x.Id == 1); ITemplate template = Mock.Of <ITemplate>(x => x.Id == 1); string[] cacheExt = new[] { "must-revalidate" }; var auCulture = "en-AU"; var usCulture = "en-US"; var domain = new DomainAndUri( new Domain(1, "test", 2, auCulture, false), new Uri("https://example.com/en-au")); IReadOnlyDictionary <string, string> headers = new Dictionary <string, string> { ["Hello"] = "world" }; var redirect = "https://test.com"; sut .SetNoCacheHeader(true) .SetCacheExtensions(cacheExt) .SetDomain(domain) .SetCulture(usCulture) .SetHeaders(headers) .SetInternalRedirect(content) .SetRedirect(redirect) .SetTemplate(template); IPublishedRequest request = sut.Build(); Assert.AreEqual(true, request.SetNoCacheHeader); Assert.AreEqual(cacheExt, request.CacheExtensions); Assert.AreEqual(usCulture, request.Culture); Assert.AreEqual(domain, request.Domain); Assert.AreEqual(headers, request.Headers); Assert.AreEqual(true, request.IsInternalRedirect); Assert.AreEqual(content, request.PublishedContent); Assert.AreEqual(redirect, request.RedirectUrl); Assert.AreEqual(302, request.ResponseStatusCode); Assert.AreEqual(template, request.Template); Assert.AreEqual(_baseUri, request.Uri); }
public async Task RenderAsync(int pageId, int?altTemplateId, StringWriter writer) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext(); // instantiate a request and process // important to use CleanedUmbracoUrl - lowercase path-only version of the current URL, though this isn't going to matter // terribly much for this implementation since we are just creating a doc content request to modify it's properties manually. IPublishedRequestBuilder requestBuilder = await _publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl); IPublishedContent?doc = umbracoContext.Content?.GetById(pageId); if (doc == null) { writer.Write("<!-- Could not render template for Id {0}, the document was not found -->", pageId); return; } // in some cases the UmbracoContext will not have a PublishedRequest assigned to it if we are not in the // execution of a front-end rendered page. In this case set the culture to the default. // set the culture to the same as is currently rendering if (umbracoContext.PublishedRequest == null) { ILanguage?defaultLanguage = _languageService.GetAllLanguages().FirstOrDefault(); requestBuilder.SetCulture(defaultLanguage == null ? CultureInfo.CurrentUICulture.Name : defaultLanguage.IsoCode); } else { requestBuilder.SetCulture(umbracoContext.PublishedRequest.Culture); } // set the doc that was found by id requestBuilder.SetPublishedContent(doc); // set the template, either based on the AltTemplate found or the standard template of the doc var templateId = _webRoutingSettings.DisableAlternativeTemplates || !altTemplateId.HasValue ? doc.TemplateId : altTemplateId.Value; if (templateId.HasValue) { requestBuilder.SetTemplate(_fileService.GetTemplate(templateId.Value)); } // if there is not template then exit if (requestBuilder.HasTemplate() == false) { if (altTemplateId.HasValue == false) { writer.Write( "<!-- Could not render template for Id {0}, the document's template was not found with id {0}-->", doc.TemplateId); } else { writer.Write( "<!-- Could not render template for Id {0}, the altTemplate was not found with id {0}-->", altTemplateId); } return; } // First, save all of the items locally that we know are used in the chain of execution, we'll need to restore these // after this page has rendered. SaveExistingItems(out IPublishedRequest? oldPublishedRequest); IPublishedRequest contentRequest = requestBuilder.Build(); try { // set the new items on context objects for this templates execution SetNewItemsOnContextObjects(contentRequest); // Render the template ExecuteTemplateRendering(writer, contentRequest); } finally { // restore items on context objects to continuing rendering the parent template RestoreItems(oldPublishedRequest); } }