基于不同域的Razor页面路由

Question

I'm trying to setup a single ASP.NET Core Razor Web app localized for use on multi domains. I have the localization working, with one different language for each domain. But right now I want to have the .com domain accepting a routing parameter, to make the URL path decide with language to show.

Something like:

• www.mysite.pt - no custom routing - www.mysite.pt/PageA works, localized in Portuguese.
• www.mysite.com - custom routing - www.mysite.com/us/PageA goes to PageA, localized in en-US. But www.mysite.com/PageA should return a 404, as for this domain every page needs the country parameter.

For MVC this could be achieved by using the MapRoute with a custom IRouteConstraint to filter by domain. However with Razor pages, I only see the option to go with the conventions and add a class derived from IPageRouteModelConvention.

But I don't see a way on the IPageRouteModelConvention methodology to use a IRouteConstraint. Is there a way to do this?

Answer 1

Not exactly the best solution... but worked this out:

On ConfigureServices added a custom convention that takes a country parameter only with two country codes US and CA:

  options.Conventions.Add(new CountryTemplateRouteModelConvention());

wethe this class being:

public class CountryTemplateRouteModelConvention : IPageRouteModelConvention
{
    public void Apply(PageRouteModel model)
    {

        var selectorCount = model.Selectors.Count;
        for (var i = 0; i < selectorCount; i++)
        {
            var selector = model.Selectors[i];
            // selector.AttributeRouteModel.SuppressLinkGeneration = false;

            //we are not adding the selector, but replacing the existing one
            model.Selectors.Add(new SelectorModel
            {

                AttributeRouteModel = new AttributeRouteModel
                {
                    Order = -1,

                    Template = AttributeRouteModel.CombineTemplates(@"{country:length(2):regex(^(us|ca)$)}", selector.AttributeRouteModel.Template),
                }
            });
        }
    }
}

Then, before the UseMvc on Configure, I used two types of Rewrite rules:

var options = new RewriteOptions();
options.Add(new CountryBasedOnDomainRewriteRule(domains: GetDomainsWhereCountryComesFromDomain(Configuration)));
options.Add(new CountryBasedOnPathRewriteRule(domains: GetDomainsWhereCountryComesFromPath(Configuration)));
app.UseRewriter(options);

The methods GetDomainsWhereCountryComesFromDomain and GetDomainsWhereCountryComesFromPath just read from the appsettings the domains where I want to have a single language, and the domains where I want the language to be obtained from the URL path.

Now, the two IRule classes:

public class CountryBasedOnPathRewriteRule : IRule
{
    private readonly string[] domains;

    public CountryBasedOnPathRewriteRule(string[] domains)
    {
        this.domains = domains;
    }

    public void ApplyRule(RewriteContext context)
    {
        string hostname = context.HttpContext.Request.Host.Host.ToLower();
        if (!domains.Contains(hostname)) return;

        //only traffic that has the country on the path is valid. examples:
        // www.mysite.com/ -> www.mysite.com/US/
        // www.mysite.com/Cart -> www.mysite.com/US/Cart

        var path = context.HttpContext.Request.Path.ToString().ToLower();

        /* let's exclude the error page, as method UseExceptionHandler doesn't accept the country parameter */
        if (path == "/" || path == "/error")
        {
            //redirect to language default

            var response = context.HttpContext.Response;
            response.StatusCode = (int)HttpStatusCode.Moved;
            response.Headers[HeaderNames.Location] = "/us/"; //default language/country
            context.Result = RuleResult.EndResponse;
        }

        string pathFirst = path.Split('/')?[1];

        if (pathFirst.Length != 2) /* US and CA country parameter is already enforced by the routing */
        {
            var response = context.HttpContext.Response;
            response.StatusCode = (int)HttpStatusCode.NotFound;
            context.Result = RuleResult.EndResponse;
        }
    }
}

public class CountryBasedOnDomainRewriteRule : IRule
{
    private readonly string[] domains;

    public CountryBasedOnDomainRewriteRule(string[] domains)
    {
        this.domains = domains;
    }

    public void ApplyRule(RewriteContext context)
    {
        string hostname = context.HttpContext.Request.Host.Host.ToLower();
        if (!domains.Contains(hostname)) return;

        var path = context.HttpContext.Request.Path.ToString().ToLower();

        string pathFirst = path.Split('/')?[1];

        if (pathFirst.Length == 2) //we are trying to use www.mysite.co.uk/us which is not allowed 
        {
            var response = context.HttpContext.Response;
            response.StatusCode = (int)HttpStatusCode.NotFound;
            context.Result = RuleResult.EndResponse;
        }
    }
}

And that's it.