How can I create a service that returns different JSON files based on the user's language?

[nikas-belogolov]

ASP.NET Core Get different JSON data from an injected service based on the user's language
Render nested JSON data to razor page based on the user language (asp.net core razor pages)

What I need is something like this:

public class JsonData { ... }

@inject JsonData jsonData // Get different JSON data based on the user's language

// If language is English
@jsonData["nested"]["Hello"] // Equals Hello

jsonData = {
  "nested": {
    "Hello": "Hello"
  }
}

// If language is Spanish
@jsonData["nested"]["Hello"] // Equals Hola

jsonData = {
  "nested": {
    "Hello": "Hola"
  }
}

The example above if I were using SharedLocalizer:

// Service
  public class CommonResources
{

}  

public class CommonLocalizationService
    {

        private readonly IStringLocalizer _localizer;
        public CommonLocalizationService(IStringLocalizerFactory factory)
        {
            var assemblyName = new AssemblyName(typeof(CommonResources).GetTypeInfo().Assembly.FullName);

            _localizer = factory.Create(nameof(CommonResources), assemblyName.Name);
        }

        public string Get(string key)
        {
            return _localizer.GetString(key);
        }
    }

services.AddSingleton<CommonLocalizationService>();

// Razor page
@inject CommonLocalizationService Localizer

@Localizer.Get("key") // This automatically gets the key in the localized file.

The second example works only with .resx files and doesn't work with nesting.

What I'm basically trying to achieve is to get localized JSON data from a service based on the user's language. (Something similar to the SharedLocalizationService)

This is my startup.cs configuration:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.Localization.Routing;
using Microsoft.AspNetCore.Mvc.ApplicationModels;
using Microsoft.AspNetCore.Rewrite;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Website.Middlewares;
using Website.Services;

using Microsoft.AspNetCore.Mvc.Razor;

namespace Website
{

    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();

            services.AddControllers();

            services.AddLocalization(options => options.ResourcesPath = "Resources");

            services
                .Configure<RequestLocalizationOptions>(options =>
                {
                    // var supportedCultures =
                    //     new List<CultureInfo> {
                    //         new CultureInfo("en"),
                    //         new CultureInfo("ru")
                    //     };

                    var supportedCultures = Services.CommonLocalizationService.SupportedCultures;

                    options.DefaultRequestCulture = new RequestCulture("en");
                    options.SupportedCultures = supportedCultures;
                    options.SupportedUICultures = supportedCultures;

                    options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(context =>
                    {
                        string defaultLang;

                        if (context.Request.Host.Host == "www.localhost")
                        {
                            return Task.FromResult(default(ProviderCultureResult));
                        }

                        var subdomain = Regex
                            .Replace(context.Request.Host.Host, @"www|" + "localhost", String.Empty)
                            .Split(".")
                            .Where(x => x != String.Empty).ToArray()[0];

                        if (supportedCultures.Contains(new CultureInfo(subdomain)))
                        {
                            defaultLang = subdomain;
                        }
                        else
                        {
                            // context.Response.Redirect("https://en.localhost:5001");

                            return Task.FromResult(default(ProviderCultureResult));
                        }

                        return Task.FromResult(new ProviderCultureResult(defaultLang, defaultLang));
                    }));
                });

            services.AddMvc().AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
            .AddDataAnnotationsLocalization();

            services.AddSingleton<Services.CommonLocalizationService>();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Error");

                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseWwwRedirection();

            app.UseStatusCodePages();
            app.UseStatusCodePagesWithReExecute("/StatusPages/Status{0}");

            app.UseStaticFiles();
            app.UseRouting();
            app.UseAuthorization();

            var localizationOptions = app.ApplicationServices.GetService<IOptions<RequestLocalizationOptions>>().Value;
            app.UseRequestLocalization(localizationOptions);

            app
                .UseEndpoints(endpoints =>
                {
                    endpoints.MapRazorPages();
                    endpoints.MapControllers();
                });
        }
    }
}

This is my JSON file:

// Data.en.json
[
    {
        "name": "Meteorology",
        "tools": [
            {
                "name": "Temperature Converter",
                "description": "Convert Between Celsius, Fahrenheit, Kelvin and Rankine"
            }
        ]
    }
]

// Data.ru.json
[ // Ignore the unlocalized srings
    {
        "name": "Meteorology - Russian",
        "tools": [
            {
                "name": "Temperature Converter - Russian",
                "description": "Convert Between Celsius, Fahrenheit, Kelvin and Rankine - Russian"
            }
        ]
    }
]