Merge pull request #1922 from riganti/fix/localizable-routes

tomasherceg · web-flow · commit 779b2f9281c3 · 2025-04-26T16:01:12.000+02:00
Enhancements of localizable routes
diff --git a/src/Framework/Framework/Hosting/Middlewares/DotvvmRoutingMiddleware.cs b/src/Framework/Framework/Hosting/Middlewares/DotvvmRoutingMiddleware.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 using DotVVM.Framework.Runtime.Tracing;
@@ -40,9 +41,14 @@ private static bool TryParseGooglebotHashbangEscapedFragment(string queryString,
 
         public static string GetRouteMatchUrl(IDotvvmRequestContext context)
         {
-            if (!TryParseGooglebotHashbangEscapedFragment(context.HttpContext.Request.Url.Query, out var url))
+            return GetRouteMatchUrl(context.HttpContext.Request.Path.Value!, context.HttpContext.Request.Url.Query);
+        }
+
+        public static string GetRouteMatchUrl(string requestPath, string queryString)
+        {
+            if (!TryParseGooglebotHashbangEscapedFragment(queryString, out var url))
             {
-                url = context.HttpContext.Request.Path.Value;
+                url = requestPath;
             }
             url = url?.Trim('/') ?? "";
 
diff --git a/src/Framework/Framework/Routing/DotvvmRouteTable.cs b/src/Framework/Framework/Routing/DotvvmRouteTable.cs
@@ -64,7 +64,8 @@ public void AddGroup(string groupName,
             string urlPrefix,
             string virtualPathPrefix,
             Action<DotvvmRouteTable> content,
-            Func<IServiceProvider, IDotvvmPresenter>? presenterFactory = null)
+            Func<IServiceProvider, IDotvvmPresenter>? presenterFactory = null,
+            LocalizedRouteUrl[]? localizedUrls = null)
         {
             ThrowIfFrozen();
             if (string.IsNullOrEmpty(groupName))
@@ -77,6 +78,7 @@ public void AddGroup(string groupName,
             }
             urlPrefix = CombinePath(group?.UrlPrefix, urlPrefix);
             virtualPathPrefix = CombinePath(group?.VirtualPathPrefix, virtualPathPrefix);
+            localizedUrls = CombineLocalizedUrls(group, urlPrefix, localizedUrls);
 
             var newGroup = new DotvvmRouteTable(configuration);
             newGroup.group = new RouteTableGroup(
@@ -85,7 +87,8 @@ public void AddGroup(string groupName,
                 urlPrefix,
                 virtualPathPrefix,
                 addToParentRouteTable: Add,
-                presenterFactory);
+                presenterFactory,
+                localizedUrls);
 
             content(newGroup);
             routeTableGroups.Add(groupName, newGroup);
@@ -180,6 +183,8 @@ private void AddCore(string routeName, string url, string? virtualPath, object?
 
             if (url == null)
                 throw new ArgumentNullException(nameof(url));
+
+            localizedUrls = CombineLocalizedUrls(group, url, localizedUrls);
             url = CombinePath(group?.UrlPrefix, url);
 
             virtualPath = CombinePath(group?.VirtualPathPrefix, virtualPath);
@@ -194,7 +199,7 @@ private void AddCore(string routeName, string url, string? virtualPath, object?
             RouteBase route = localizedUrls == null
                 ? new DotvvmRoute(url, virtualPath, routeName, defaultValues, presenterFactory, configuration)
                 : new LocalizedDotvvmRoute(url,
-                    localizedUrls.Select(l => new LocalizedRouteUrl(l.CultureIdentifier, CombinePath(group?.UrlPrefix, l.RouteUrl))).ToArray(),
+                    localizedUrls.Select(l => new LocalizedRouteUrl(l.CultureIdentifier, l.RouteUrl)).ToArray(),
                     virtualPath, routeName, defaultValues, presenterFactory, configuration);
             Add(route);
         }
@@ -330,6 +335,29 @@ IEnumerator IEnumerable.GetEnumerator()
             return $"{prefix}/{appendedPath}";
         }
 
+        private LocalizedRouteUrl[]? CombineLocalizedUrls(RouteTableGroup? group, string routeUrl, LocalizedRouteUrl[]? localizedUrls)
+        {
+            if (group == null)
+            {
+                return localizedUrls;
+            }
+            if (group.LocalizedUrls == null && localizedUrls == null)
+            {
+                return null;
+            }
+
+            var groupCultures = group.LocalizedUrls?.ToDictionary(u => u.CultureIdentifier, u => u.RouteUrl) ?? new();
+            var routeCultures = localizedUrls?.ToDictionary(u => u.CultureIdentifier, u => u.RouteUrl) ?? new();
+
+            return groupCultures.Keys.Union(routeCultures.Keys)
+                .Select(c =>
+                    new LocalizedRouteUrl(c, CombinePath(
+                        groupCultures.TryGetValue(c, out var localizedGroupUrl) ? localizedGroupUrl : group.UrlPrefix,
+                        routeCultures.TryGetValue(c, out var localizedRouteUrl) ? localizedRouteUrl : routeUrl)
+                    ))
+                .ToArray();
+        }
+
         private bool isFrozen = false;
 
         private void ThrowIfFrozen()
diff --git a/src/Framework/Framework/Routing/LocalizedDotvvmRoute.cs b/src/Framework/Framework/Routing/LocalizedDotvvmRoute.cs
@@ -98,9 +98,15 @@ public static void ValidateCultureName(string cultureIdentifier)
         public override bool IsMatch(string url, [MaybeNullWhen(false)] out IDictionary<string, object?> values) => GetRouteForCulture(CultureInfo.CurrentCulture).IsMatch(url, out values);
 
         public bool IsPartialMatch(string url, [MaybeNullWhen(false)] out RouteBase matchedRoute, [MaybeNullWhen(false)] out IDictionary<string, object?> values)
+        {
+            return IsPartialMatch(url, out matchedRoute, out values, out _);
+        }
+
+        public bool IsPartialMatch(string url, [MaybeNullWhen(false)] out RouteBase matchedRoute, [MaybeNullWhen(false)] out IDictionary<string, object?> values, [MaybeNullWhen(false)] out string? matchedCulture)
         {
             RouteBase? twoLetterCultureMatch = null;
             IDictionary<string, object?>? twoLetterCultureMatchValues = null;
+            matchedCulture = null;
 
             foreach (var route in localizedRoutes)
             {
@@ -110,13 +116,15 @@ public bool IsPartialMatch(string url, [MaybeNullWhen(false)] out RouteBase matc
                     {
                         // exact culture match - return immediately
                         matchedRoute = route.Value;
+                        matchedCulture = route.Key;
                         return true;
                     }
                     else if (route.Key.Length > 0 && twoLetterCultureMatch == null)
                     {
                         // match for two-letter culture - continue searching if there is a better match
                         twoLetterCultureMatch = route.Value;
                         twoLetterCultureMatchValues = values;
+                        matchedCulture = route.Key;
                     }
                     else
                     {
diff --git a/src/Framework/Framework/Routing/RouteTableGroup.cs b/src/Framework/Framework/Routing/RouteTableGroup.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Text;
 using DotVVM.Framework.Hosting;
 
@@ -15,15 +16,17 @@ public class RouteTableGroup
         public string RouteNamePrefix { get; private set; }
         public string UrlPrefix { get; private set; }
         public string VirtualPathPrefix { get; private set; }
+        public ImmutableArray<LocalizedRouteUrl>? LocalizedUrls { get; private set; }
 
-        public RouteTableGroup(string groupName, string routeNamePrefix, string urlPrefix, string virtualPathPrefix, Action<RouteBase> addToParentRouteTable, Func<IServiceProvider, IDotvvmPresenter>? presenterFactory)
+        public RouteTableGroup(string groupName, string routeNamePrefix, string urlPrefix, string virtualPathPrefix, Action<RouteBase> addToParentRouteTable, Func<IServiceProvider, IDotvvmPresenter>? presenterFactory, LocalizedRouteUrl[]? localizedUrls = null)
         {
             GroupName = groupName;
             RouteNamePrefix = routeNamePrefix;
             UrlPrefix = urlPrefix;
             VirtualPathPrefix = virtualPathPrefix;
             AddToParentRouteTable = addToParentRouteTable;
             PresenterFactory = presenterFactory;
+            LocalizedUrls = localizedUrls?.ToImmutableArray();
         }
     }
 }
diff --git a/src/Framework/Hosting.AspNetCore/DotVVM.Framework.Hosting.AspNetCore.csproj b/src/Framework/Hosting.AspNetCore/DotVVM.Framework.Hosting.AspNetCore.csproj
@@ -21,15 +21,4 @@
     <ProjectReference Include="../Framework/DotVVM.Framework.csproj" />
     <ProjectReference Include="../Core/DotVVM.Core.csproj" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.1'">
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.Cookies" Version="2.2.0" />
-    <PackageReference Include="Microsoft.AspNetCore.DataProtection" Version="2.2.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Http.Extensions" Version="2.2.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Authorization" Version="2.2.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Localization" Version="2.2.0" />
-    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="2.2.0" />
-    <PackageReference Include="Microsoft.Extensions.Localization" Version="2.2.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.HealthChecks" Version="2.2.0" />
-    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions" Version="2.2.0" />
-  </ItemGroup>
 </Project>
diff --git a/src/Framework/Hosting.AspNetCore/Localization/DotvvmRoutingRequestCultureProvider.cs b/src/Framework/Hosting.AspNetCore/Localization/DotvvmRoutingRequestCultureProvider.cs
@@ -0,0 +1,60 @@
+﻿#nullable enable
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using DotVVM.Framework.Configuration;
+using DotVVM.Framework.Hosting.Middlewares;
+using DotVVM.Framework.Routing;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Localization;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace DotVVM.Framework.Hosting.AspNetCore.Localization;
+
+public class DotvvmRoutingRequestCultureProvider : IRequestCultureProvider
+{
+    private static readonly object locker = new();
+    private static IReadOnlyList<LocalizedDotvvmRoute>? cachedRoutes;
+
+    public Task<ProviderCultureResult?> DetermineProviderCultureResult(HttpContext httpContext)
+    {
+        EnsureCachedRoutes(httpContext);
+
+        // find matching localizable route and extract culture from it
+        var url = DotvvmRoutingMiddleware.GetRouteMatchUrl(httpContext.Request.Path.Value!, httpContext.Request.QueryString.Value!);
+        foreach (var route in cachedRoutes!)
+        {
+            if (route.IsPartialMatch(url, out _, out var values, out var matchedCulture))
+            {
+                return Task.FromResult<ProviderCultureResult?>(new ProviderCultureResult(matchedCulture));
+            }
+        }
+
+        return Task.FromResult<ProviderCultureResult?>(null);
+    }
+
+    private void EnsureCachedRoutes(HttpContext httpContext)
+    {
+        if (cachedRoutes == null)
+        {
+            lock (locker)
+            {
+                if (cachedRoutes == null)
+                {
+                    // try to obtain DotVVM configuration
+                    if (httpContext.RequestServices.GetService<DotvvmConfiguration>() is not { } config)
+                    {
+                        throw new InvalidOperationException("DotVVM configuration not found in the service provider.");
+                    }
+
+                    // try to obtain DotVVM routes
+                    cachedRoutes = config.RouteTable
+                        .OfType<LocalizedDotvvmRoute>()
+                        .ToArray();
+                }
+            }
+        }
+    }
+}
diff --git a/src/Tests/Routing/RouteTableGroupTests.cs b/src/Tests/Routing/RouteTableGroupTests.cs
@@ -186,6 +186,62 @@ public void RouteTableGroup_DefaultPresenterFactory()
             Assert.IsInstanceOfType(table.First().GetPresenter(configuration.ServiceProvider), typeof(TestPresenter));
         }
 
+        [TestMethod]
+        public void RouteTableGroup_LocalizedUrls_RouteOnly()
+        {
+            var table = new DotvvmRouteTable(configuration);
+            table.AddGroup("Group", "group", "", opt => {
+                opt.Add("Route", "route", "route.dothtml", null, null, [
+                    new LocalizedRouteUrl("cs-CZ", "cesta")
+                ]);
+            });
+
+            var route = table["Group_Route"];
+            Assert.IsInstanceOfType(route, typeof(LocalizedDotvvmRoute));
+            var csCzRoute = ((LocalizedDotvvmRoute)route).GetRouteForCulture("cs-CZ");
+
+            Assert.AreEqual("group/route", route.Url);
+            Assert.AreEqual("group/cesta", csCzRoute.Url);
+        }
+
+        [TestMethod]
+        public void RouteTableGroup_LocalizedUrls_GroupOnly()
+        {
+            var table = new DotvvmRouteTable(configuration);
+            table.AddGroup("Group", "group", "", opt => {
+                opt.Add("Route", "route", "route.dothtml", null, null, null);
+            }, localizedUrls: [
+                new LocalizedRouteUrl("cs-CZ", "skupina")
+            ]);
+
+            var route = table["Group_Route"];
+            Assert.IsInstanceOfType(route, typeof(LocalizedDotvvmRoute));
+            var csCzRoute = ((LocalizedDotvvmRoute)route).GetRouteForCulture("cs-CZ");
+
+            Assert.AreEqual("group/route", route.Url);
+            Assert.AreEqual("skupina/route", csCzRoute.Url);
+        }
+
+        [TestMethod]
+        public void RouteTableGroup_LocalizedUrls()
+        {
+            var table = new DotvvmRouteTable(configuration);
+            table.AddGroup("Group", "group", "", opt => {
+                opt.Add("Route", "route", "route.dothtml", null, null, [
+                    new LocalizedRouteUrl("cs-CZ", "cesta")
+                ]);
+            }, localizedUrls: [
+                new LocalizedRouteUrl("cs-CZ", "skupina")
+            ]);
+
+            var route = table["Group_Route"];
+            Assert.IsInstanceOfType(route, typeof(LocalizedDotvvmRoute));
+            var csCzRoute = ((LocalizedDotvvmRoute)route).GetRouteForCulture("cs-CZ");
+
+            Assert.AreEqual("group/route", route.Url);
+            Assert.AreEqual("skupina/cesta", csCzRoute.Url);
+        }
+
         [TestMethod]
         public void RouteTableGroup_Redirections()
         {

Original file line number	Diff line number	Diff line change
`@@ -98,9 +98,15 @@ public static void ValidateCultureName(string cultureIdentifier)`
`98`	`98`	`public override bool IsMatch(string url, [MaybeNullWhen(false)] out IDictionary<string, object?> values) => GetRouteForCulture(CultureInfo.CurrentCulture).IsMatch(url, out values);`
`99`	`99`
`100`	`100`	`public bool IsPartialMatch(string url, [MaybeNullWhen(false)] out RouteBase matchedRoute, [MaybeNullWhen(false)] out IDictionary<string, object?> values)`
	`101`	`+ {`
	`102`	`+ return IsPartialMatch(url, out matchedRoute, out values, out _);`
	`103`	`+ }`
	`104`	`+`
	`105`	`+ public bool IsPartialMatch(string url, [MaybeNullWhen(false)] out RouteBase matchedRoute, [MaybeNullWhen(false)] out IDictionary<string, object?> values, [MaybeNullWhen(false)] out string? matchedCulture)`
`101`	`106`	`{`
`102`	`107`	`RouteBase? twoLetterCultureMatch = null;`
`103`	`108`	`IDictionary<string, object?>? twoLetterCultureMatchValues = null;`
	`109`	`+ matchedCulture = null;`
`104`	`110`
`105`	`111`	`foreach (var route in localizedRoutes)`
`106`	`112`	`{`
`@@ -110,13 +116,15 @@ public bool IsPartialMatch(string url, [MaybeNullWhen(false)] out RouteBase matc`
`110`	`116`	`{`
`111`	`117`	`// exact culture match - return immediately`
`112`	`118`	`matchedRoute = route.Value;`
	`119`	`+ matchedCulture = route.Key;`
`113`	`120`	`return true;`
`114`	`121`	`}`
`115`	`122`	`else if (route.Key.Length > 0 && twoLetterCultureMatch == null)`
`116`	`123`	`{`
`117`	`124`	`// match for two-letter culture - continue searching if there is a better match`
`118`	`125`	`twoLetterCultureMatch = route.Value;`
`119`	`126`	`twoLetterCultureMatchValues = values;`
	`127`	`+ matchedCulture = route.Key;`
`120`	`128`	`}`
`121`	`129`	`else`
`122`	`130`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Collections.Immutable;`
`3`	`4`	`using System.Text;`
`4`	`5`	`using DotVVM.Framework.Hosting;`
`5`	`6`
`@@ -15,15 +16,17 @@ public class RouteTableGroup`
`15`	`16`	`public string RouteNamePrefix { get; private set; }`
`16`	`17`	`public string UrlPrefix { get; private set; }`
`17`	`18`	`public string VirtualPathPrefix { get; private set; }`
	`19`	`+ public ImmutableArray<LocalizedRouteUrl>? LocalizedUrls { get; private set; }`
`18`	`20`
`19`		`- public RouteTableGroup(string groupName, string routeNamePrefix, string urlPrefix, string virtualPathPrefix, Action<RouteBase> addToParentRouteTable, Func<IServiceProvider, IDotvvmPresenter>? presenterFactory)`
	`21`	`+ public RouteTableGroup(string groupName, string routeNamePrefix, string urlPrefix, string virtualPathPrefix, Action<RouteBase> addToParentRouteTable, Func<IServiceProvider, IDotvvmPresenter>? presenterFactory, LocalizedRouteUrl[]? localizedUrls = null)`
`20`	`22`	`{`
`21`	`23`	`GroupName = groupName;`
`22`	`24`	`RouteNamePrefix = routeNamePrefix;`
`23`	`25`	`UrlPrefix = urlPrefix;`
`24`	`26`	`VirtualPathPrefix = virtualPathPrefix;`
`25`	`27`	`AddToParentRouteTable = addToParentRouteTable;`
`26`	`28`	`PresenterFactory = presenterFactory;`
	`29`	`+ LocalizedUrls = localizedUrls?.ToImmutableArray();`
`27`	`30`	`}`
`28`	`31`	`}`
`29`	`32`	`}`