V13: Set request culture for VirtualPageController

src/Umbraco.Core/Routing/IPublishedRouter.cs

@@ -47,4 +47,37 @@ public interface IPublishedRouter
     ///     </para>
     /// </remarks>
     Task<IPublishedRequest> UpdateRequestAsync(IPublishedRequest request, IPublishedContent? publishedContent);
+
+    /// <summary>
+    /// Finds the site root (if any) matching the http request, and updates the PublishedRequest and VariationContext accordingly.
+    /// <remarks>
+    /// <para>
+    /// This method is used for VirtualPage routing.
+    /// </para>
+    /// <para>
+    /// In this case we do not want to run the entire routing pipeline since ContentFinders are not needed here.
+    /// However, we do want to set the culture on VariationContext and PublishedRequest to the values specified by the domains.
+    /// </para>
+    /// </remarks>
+    /// </summary>
+    /// <param name="request">The request to update the culture on domain on</param>
+    /// <returns>True if a domain was found otherwise false.</returns>
+    bool RouteDomain(IPublishedRequestBuilder request) => false;
+
+    /// <summary>
+    /// Finds the site root (if any) matching the http request, and updates the VariationContext accordingly.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This is used for VirtualPage routing.
+    /// </para>
+    /// <para>
+    /// This is required to set the culture on VariationContext to the values specified by the domains, before the FindContent method is called.
+    /// In order to allow the FindContent implementer to correctly find content based off the culture. Before the PublishedRequest is built.
+    /// </para>
+    /// </remarks>
+    /// <param name="uri">The URI to resolve the domain from.</param>
+    /// <returns>True if a domain was found, otherwise false.</returns>
+    bool UpdateVariationContext(Uri uri) => false;
+
 }

src/Umbraco.Core/Routing/PublishedRouter.cs

@@ -1,4 +1,4 @@
 using System.Globalization;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Configuration.Models;
@@ -108,7 +108,7 @@
         // find domain
         if (builder.Domain == null)
         {
-            FindDomain(builder);
+            FindAndSetDomain(builder);
         }
 
         await RouteRequestInternalAsync(builder);
@@ -185,7 +185,7 @@
 
     private async Task<IPublishedRequest> TryRouteRequest(IPublishedRequestBuilder request)
     {
-        FindDomain(request);
+        FindAndSetDomain(request);
 
         if (request.IsRedirect())
         {
@@ -270,55 +270,78 @@
         // to find out the appropriate template
     }
 
-    /// <summary>
-    ///     Finds the site root (if any) matching the http request, and updates the PublishedRequest accordingly.
-    /// </summary>
-    /// <returns>A value indicating whether a domain was found.</returns>
-    internal bool FindDomain(IPublishedRequestBuilder request)
+    /// <inheritdoc />
+    public bool RouteDomain(IPublishedRequestBuilder request)
+    {
+        var found = FindAndSetDomain(request);
+        HandleWildcardDomains(request);
+        SetVariationContext(request.Culture);
+        return found;
+    }
+
+    /// <inheritdoc />
+    public bool UpdateVariationContext(Uri uri)
+    {
+        DomainAndUri? domain = FindDomain(uri, out _);
+        SetVariationContext(domain?.Culture);
+        return domain?.Culture is not null;
+    }
+
+    private DomainAndUri? FindDomain(Uri uri, out string? defaultCulture)
     {
         const string tracePrefix = "FindDomain: ";
 
         // note - we are not handling schemes nor ports here.
         if (_logger.IsEnabled(LogLevel.Debug))
         {
-            _logger.LogDebug("{TracePrefix}Uri={RequestUri}", tracePrefix, request.Uri);
+            _logger.LogDebug("{TracePrefix}Uri={RequestUri}", tracePrefix, uri);
         }
 
         IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
         IDomainCache? domainsCache = umbracoContext.PublishedSnapshot.Domains;
         var domains = domainsCache?.GetAll(false).ToList();
 
         // determines whether a domain corresponds to a published document, since some
         // domains may exist but on a document that has been unpublished - as a whole - or
         // that is not published for the domain's culture - in which case the domain does
         // not apply
         bool IsPublishedContentDomain(Domain domain)
         {
             // just get it from content cache - optimize there, not here
             IPublishedContent? domainDocument = umbracoContext.PublishedSnapshot.Content?.GetById(domain.ContentId);
 
             // not published - at all
             if (domainDocument == null)
             {
                 return false;
             }
 
             // invariant - always published
             if (!domainDocument.ContentType.VariesByCulture())
             {
                 return true;
             }
 
             // variant, ensure that the culture corresponding to the domain's language is published
             return domain.Culture is not null && domainDocument.Cultures.ContainsKey(domain.Culture);
         }
 
         domains = domains?.Where(IsPublishedContentDomain).ToList();
 
-        var defaultCulture = domainsCache?.DefaultCulture;
+        defaultCulture = domainsCache?.DefaultCulture;
 
+        return DomainUtilities.SelectDomain(domains, uri, defaultCulture: defaultCulture);
+    }
+
+    /// <summary>
+    ///     Finds the site root (if any) matching the http request, and updates the PublishedRequest accordingly.
+    /// </summary>
+    /// <returns>A value indicating whether a domain was found.</returns>
+    internal bool FindAndSetDomain(IPublishedRequestBuilder request)
+    {
+        const string tracePrefix = "FindDomain: ";
         // try to find a domain matching the current request
-        DomainAndUri? domainAndUri = DomainUtilities.SelectDomain(domains, request.Uri, defaultCulture: defaultCulture);
+        DomainAndUri? domainAndUri = FindDomain(request.Uri, out var defaultCulture);
 
         // handle domain - always has a contentId and a culture
         if (domainAndUri != null)

src/Umbraco.Web.Common/Filters/UmbracoVirtualPageFilterAttribute.cs

@@ -1,9 +1,11 @@
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.DependencyInjection;
 using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Cms.Core.Routing;
 using Umbraco.Cms.Web.Common.Controllers;
 using Umbraco.Cms.Web.Common.Routing;
 
@@ -40,6 +42,12 @@ public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionE
             if (endpoint != null)
             {
                 IUmbracoVirtualPageRoute umbracoVirtualPageRoute = context.HttpContext.RequestServices.GetRequiredService<IUmbracoVirtualPageRoute>();
+                IPublishedRouter publishedRouter = context.HttpContext.RequestServices.GetRequiredService<IPublishedRouter>();
+                UriUtility uriUtility = context.HttpContext.RequestServices.GetRequiredService<UriUtility>();
+
+                var originalRequestUrl = new Uri(context.HttpContext.Request.GetEncodedUrl());
+                Uri cleanedUri = uriUtility.UriToUmbraco(originalRequestUrl);
+                publishedRouter.UpdateVariationContext(cleanedUri);
 
                 IPublishedContent? publishedContent = umbracoVirtualPageRoute.FindContent(endpoint, context);
 

src/Umbraco.Web.Common/Routing/UmbracoVirtualPageRoute.cs

@@ -155,6 +155,7 @@ public async Task<IPublishedRequest> CreatePublishedRequest(HttpContext httpCont
 
         IPublishedRequestBuilder requestBuilder = await _publishedRouter.CreateRequestAsync(cleanedUrl);
         requestBuilder.SetPublishedContent(publishedContent);
+        _publishedRouter.RouteDomain(requestBuilder);
 
         return requestBuilder.Build();
     }

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/ContentFinderByAliasWithDomainsTests.cs

@@ -31,7 +31,7 @@ public async Task Lookup_By_Url_Alias_And_Domain(string inputUrl, string expecte
         var request = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
         // must lookup domain
-        publishedRouter.FindDomain(request);
+        publishedRouter.FindAndSetDomain(request);
 
         if (expectedNode > 0)
         {

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/ContentFinderByUrlWithDomainsTests.cs

@@ -207,7 +207,7 @@ public async Task Lookup_SingleDomain(string url, int expectedId)
         var frequest = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
         // must lookup domain else lookup by URL fails
-        publishedRouter.FindDomain(frequest);
+        publishedRouter.FindAndSetDomain(frequest);
 
         var lookup = new ContentFinderByUrl(Mock.Of<ILogger<ContentFinderByUrl>>(), umbracoContextAccessor);
         var result = await lookup.TryFindContent(frequest);
@@ -245,7 +245,7 @@ public async Task Lookup_NestedDomains(string url, int expectedId, string expect
         var frequest = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
         // must lookup domain else lookup by URL fails
-        publishedRouter.FindDomain(frequest);
+        publishedRouter.FindAndSetDomain(frequest);
         Assert.AreEqual(expectedCulture, frequest.Culture);
 
         var lookup = new ContentFinderByUrl(Mock.Of<ILogger<ContentFinderByUrl>>(), umbracoContextAccessor);

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/DomainsAndCulturesTests.cs

@@ -261,7 +261,7 @@ public async Task DomainAndCulture(string inputUrl, string expectedCulture, int
         var frequest = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
         // lookup domain
-        publishedRouter.FindDomain(frequest);
+        publishedRouter.FindAndSetDomain(frequest);
 
         Assert.AreEqual(expectedCulture, frequest.Culture);
 
@@ -310,7 +310,7 @@ public async Task DomainAndCultureWithWildcards(string inputUrl, string expected
         var frequest = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
         // lookup domain
-        publishedRouter.FindDomain(frequest);
+        publishedRouter.FindAndSetDomain(frequest);
 
         // find document
         var finder = new ContentFinderByUrl(Mock.Of<ILogger<ContentFinderByUrl>>(), umbracoContextAccessor);
@@ -345,7 +345,7 @@ public async Task DomainGeneric(string inputUrl, string expectedCulture, int exp
         var frequest = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
         // lookup domain
-        publishedRouter.FindDomain(frequest);
+        publishedRouter.FindAndSetDomain(frequest);
         Assert.IsNotNull(frequest.Domain);
 
         Assert.AreEqual(expectedCulture, frequest.Culture);

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/UrlsWithNestedDomains.cs

@@ -62,7 +62,7 @@ public async Task DoNotPolluteCache()
         var publishedRouter = CreatePublishedRouter(umbracoContextAccessor);
         var frequest = await publishedRouter.CreateRequestAsync(umbracoContext.CleanedUmbracoUrl);
 
-        publishedRouter.FindDomain(frequest);
+        publishedRouter.FindAndSetDomain(frequest);
         Assert.IsTrue(frequest.HasDomain());
 
         // check that it's been routed