/// <summary>
/// Determines the provider culture result.
/// </summary>
/// <param name="httpContext">The HTTP context.</param>
/// <returns>Task<ProviderCultureResult>.</returns>
/// <exception cref="ArgumentNullException">httpContext</exception>
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
Argument.IsNotNull(httpContext);
// Test if length of result complies with ISO2 country code,
// else return ZeroResultTask.
var pathTest = httpContext.Request.Path.Value.Split('/')[1]?.ToString();
if (pathTest is null || pathTest.Length != 2)
{
return(ZeroResultTask);
}
string culture;
var uiCulture = culture = pathTest;
try
{
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
catch (Exception)
{
return(ZeroResultTask);
}
}
/// <summary>
/// Determining custom culture result.
/// </summary>
/// <param name="httpContext">Inject HttpContext.</param>
/// <returns>Task ProviderCultureResult</returns>
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var configuration = EngineContext.Current.Resolve <CultureInfo>();
string defaultCulture = configuration.Default;
string defaultUICulture = configuration.DefaultUI;
if (defaultCulture == null && defaultUICulture == null)
{
return(Task.FromResult((ProviderCultureResult)null));
}
if (defaultCulture != null && defaultUICulture == null)
{
defaultUICulture = defaultCulture;
}
if (defaultCulture == null && defaultUICulture != null)
{
defaultCulture = defaultUICulture;
}
var requestCulture = new ProviderCultureResult(defaultCulture, defaultUICulture);
return(Task.FromResult(requestCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var routeParts = httpContext.Request.Path.Value.Split('/');
var culture = routeParts[IndexOfCulture]?.ToString();
var uiCulture = routeParts[IndexOfUiCulture]?.ToString();
if (culture == null && uiCulture == null)
{
culture = uiCulture = LocalizationUtils.DefaultCultureCode;
}
else if (culture != null && uiCulture == null)
{
uiCulture = culture;
}
else if (culture == null && uiCulture != null)
{
culture = uiCulture;
}
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
string cultureCode = null;
if (httpContext.Request.Path.HasValue && httpContext.Request.Path.Value == "/")
{
cultureCode = this.GetDefaultCultureCode();
}
else if (httpContext.Request.Path.HasValue && httpContext.Request.Path.Value.Length >= 2 && httpContext.Request.Path.Value[0] == '/' && httpContext.Request.Path.Value[3] == '/')
{
cultureCode = httpContext.Request.Path.Value.Substring(1, 2);
if (!this.CheckCultureCode(cultureCode))
{
cultureCode = this.GetDefaultCultureCode(); //throw new HttpException(HttpStatusCode.NotFound);
}
}
else
{
cultureCode = this.GetDefaultCultureCode(); //throw new HttpException(HttpStatusCode.NotFound);
}
ProviderCultureResult requestCulture = new ProviderCultureResult(cultureCode);
return(Task.FromResult(requestCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
string cultureCode = null;
if (httpContext.Request.Path.HasValue && httpContext.Request.Path.Value == "/")
{
cultureCode = this.GetDefaultCultureCode();
}
// TODO: make it look more beautiful
else if (httpContext.Request.Path.HasValue && httpContext.Request.Path.Value.Length >= 6 && httpContext.Request.Path.Value[0] == '/')
{
cultureCode = httpContext.Request.Path.Value.Substring(1, 5);
if (!this.CheckCultureCode(cultureCode))
{
cultureCode = this.GetDefaultCultureCode(); //throw new HttpException(HttpStatusCode.NotFound);
}
}
else
{
cultureCode = this.GetDefaultCultureCode(); //throw new HttpException(HttpStatusCode.NotFound);
}
// TODO: from the SEO point of view, we should return 404 error code for unknown cultures
ProviderCultureResult requestCulture = new ProviderCultureResult(cultureCode);
return(Task.FromResult(requestCulture));
}
/// <summary>
/// Get the culture of the current request.
/// </summary>
/// <param name="httpContext">The current request.</param>
/// <returns>A Task resolving to the culture info if found, null otherwise.</returns>
#pragma warning disable UseAsyncSuffix // Interface method doesn't have Async suffix.
public async Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
#pragma warning restore UseAsyncSuffix
{
if (httpContext?.Request?.Body?.CanRead != true)
{
return(null);
}
try
{
// Wrap the request stream so that we can rewind it back to the start for regular request processing.
httpContext.Request.EnableBuffering();
// Read the request headers and set the parsed culture information.
var locale = httpContext.Request.Headers["Accept-Language"].First()?.Split(',').First();
var result = new ProviderCultureResult(locale);
return(result);
}
#pragma warning disable CA1031 // part of the middle ware pipeline, better to use default local then fail the request.
catch (Exception)
#pragma warning restore CA1031
{
return(null);
}
finally
{
httpContext.Request.Body.Seek(0, SeekOrigin.Begin);
}
}
/// <inheritdoc />
/// <summary>
/// Copied from here:
/// https://stackoverflow.com/a/42536548/5500609
/// </summary>
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
// /en/Substances > en
// /Substances > Substances
var culture = httpContext.Request.Path.Value.Split('/')[1];
try
{
Options.SupportedCultures.Contains(new CultureInfo(culture));
}
catch (CultureNotFoundException e)
{
culture = Options.DefaultRequestCulture.Culture.DisplayName;
}
var uiCulture = culture;
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddServerSideBlazor().AddCircuitOptions(options => { options.DetailedErrors = true; });
#region Localization
services.AddControllers();
services.AddLocalization(option => option.ResourcesPath = "Resources");
services.Configure <RequestLocalizationOptions>(options =>
{
var supportedCultures = new List <CultureInfo>()
{
new CultureInfo("en"),
new CultureInfo("fr")
};
options.DefaultRequestCulture = new RequestCulture("en");
options.SupportedCultures = supportedCultures;
options.SupportedUICultures = supportedCultures;
options.AddInitialRequestCultureProvider(new CustomRequestCultureProvider(async context =>
{
var segments = context.Request.Path.Value.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length > 1 && segments[0].Length == 2)
{
_currentCulture = segments[0].Equals("en", StringComparison.OrdinalIgnoreCase) ? "en" : "fr";
}
var requestCulture = new ProviderCultureResult(_currentCulture, _currentCulture);
return(await Task.FromResult(requestCulture));
}));
});
}
public void GetUserClientCultureHeaderValueTest()
{
var haeders = "ru-RU,ru;q=0.8,en-US;q=0.6,en;q=0.4";
var requestHeaderController = new TestRequestHeaderController(HeaderNames.AcceptLanguage, haeders);
var headerValue =
requestHeaderController.HttpContext._getRequestHeaderValue(HeaderNames.AcceptLanguage,
out var hasValue);
Assert.IsTrue(hasValue);
Console.WriteLine($"realHeaders: {headerValue}");
var httpContext = requestHeaderController.HttpContext;
var acceptLanguage = httpContext.Request.GetTypedHeaders().AcceptLanguage;
Assert.IsTrue(acceptLanguage.Count > 0);
var list = acceptLanguage.AsEnumerable()
.OrderByDescending(h => h, StringWithQualityHeaderValueComparer.QualityComparer).Select(x => x.Value)
.ToList();
Assert.AreEqual(list[0].Buffer, haeders);
Assert.AreEqual(list[0].Value, "ru-RU");
var providerCultureResult = new ProviderCultureResult(list);
var supCultures = L10N.SupportedCulture;
var cultures = providerCultureResult.Cultures;
var resultCulture =
cultures.FirstOrDefault(i => i.HasValue && i.Length == 2 && supCultures.Contains(i.Value));
Assert.AreEqual(resultCulture.Value, "ru");
}
public async void CustomRequestCultureProviderThatGetsCultureInfoFromUrl()
{
using (var server = TestServer.Create(app =>
{
var options = new RequestLocalizationOptions()
{
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("ar")
},
SupportedUICultures = new List <CultureInfo>
{
new CultureInfo("ar")
}
};
options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(context =>
{
var culture = GetCultureInfoFromUrl(context, options.SupportedCultures);
var requestCulture = new ProviderCultureResult(culture);
return(Task.FromResult(requestCulture));
}));
app.UseRequestLocalization(options, defaultRequestCulture: new RequestCulture("en-US"));
app.Run(context =>
{
var requestCultureFeature = context.Features.Get <IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar", requestCulture.Culture.Name);
return(Task.FromResult(0));
});
}))
{
var client = server.CreateClient();
var response = await client.GetAsync("/ar/page");
}
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
string cultureCode = null;
// TODO: get rid of these hardcoded strings
if (httpContext.Request.Path.HasValue && (httpContext.Request.Path.Value == "/" || httpContext.Request.Path.Value.Contains("/img") || httpContext.Request.Path.Value.Contains("/api/v1/")))
{
cultureCode = this.GetDefaultCultureCode();
}
else if (httpContext.Request.Path.HasValue && httpContext.Request.Path.Value.Length >= 4 && httpContext.Request.Path.Value[0] == '/' && httpContext.Request.Path.Value[3] == '/')
{
cultureCode = httpContext.Request.Path.Value.Substring(1, 2);
if (!this.CheckCulture(cultureCode))
{
throw new HttpException(HttpStatusCode.NotFound);
}
}
else
{
throw new HttpException(HttpStatusCode.NotFound);
}
ProviderCultureResult requestCulture = new ProviderCultureResult(cultureCode);
return(Task.FromResult(requestCulture));
}
public override async Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
// Accès à la culture par défaut de la requête
// IRequestCultureFeature cultureFeature = httpContext.Features.Get<IRequestCultureFeature>();
CookieRequestCultureProvider cookieCulture = new CookieRequestCultureProvider();
AcceptLanguageHeaderRequestCultureProvider headerCulture = new AcceptLanguageHeaderRequestCultureProvider();
// 1 - On teste les cookies
ProviderCultureResult res = await cookieCulture.DetermineProviderCultureResult(httpContext);
if (res != null)
{
if ((Options == null) || Options.SupportedUICultures.Any(c => res.UICultures.Contains(c.TwoLetterISOLanguageName)))
{
return(res);
}
}
// 2 - On teste l'entête http
res = await headerCulture.DetermineProviderCultureResult(httpContext);
if (res != null)
{
if ((Options == null) || Options.SupportedUICultures.Any(c => res.UICultures.Contains(c.TwoLetterISOLanguageName)))
{
return(res);
}
}
// 3 - Valeur par défaut...
// Par défaut en dur, à améliorer.
return(new ProviderCultureResult("en-US"));
}
public override async Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
var currentUiCulture = await FindCurrentUiCulture(httpContext); // You need to implement this method to find the UI culture
var result = new ProviderCultureResult(culture: (StringSegment)"en-US", uiCulture: (StringSegment)currentUiCulture);
return(await Task.FromResult(result));
}
/// <summary>
/// Get the culture of current request.
/// </summary>
/// <param name="httpContext">The current HTTP request.</param>
/// <returns>A Task resolving to the culture info if found, null otherwise.</returns>
#pragma warning disable UseAsyncSuffix // Interface method doesn't have Async suffix.
public async Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
#pragma warning restore UseAsyncSuffix
{
if (httpContext?.Request?.Body?.CanRead != true)
{
return(null);
}
string locale = string.Empty;
var isBotFrameworkUserAgent =
httpContext.Request.Headers["User-Agent"]
.Any(userAgent => userAgent.Contains("Microsoft-BotFramework", StringComparison.OrdinalIgnoreCase));
if (!isBotFrameworkUserAgent)
{
locale = httpContext.Request.Headers["Accept-Language"].FirstOrDefault();
locale = locale?.Split(",")?.FirstOrDefault();
if (string.IsNullOrEmpty(locale))
{
return(null);
}
}
try
{
if (isBotFrameworkUserAgent)
{
// Wrap the request stream so that we can rewind it back to the start for regular request processing.
httpContext.Request.EnableBuffering();
// Read the request body, parse out the activity object, and set the parsed culture information.
var streamReader = new StreamReader(httpContext.Request.Body, Encoding.UTF8, true, 1024, leaveOpen: true);
using (var jsonReader = new JsonTextReader(streamReader))
{
var obj = await JObject.LoadAsync(jsonReader);
var activity = obj.ToObject <Activity>();
var result = new ProviderCultureResult(activity.Locale);
httpContext.Request.Body.Seek(0, SeekOrigin.Begin);
return(result);
}
}
else
{
var result = new ProviderCultureResult(locale);
return(result);
}
}
#pragma warning disable CA1031 // part of the middle ware pipeline, better to use default local then fail the request.
catch (Exception)
#pragma warning restore CA1031
{
return(null);
}
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
string culture = null;
string uiCulture = null;
var twoLetterCultureName = httpContext.Request.Path.Value.Split('/')[IndexOfCulture]?.ToString();
var twoLetterUICultureName = httpContext.Request.Path.Value.Split('/')[IndexofUICulture]?.ToString();
if (twoLetterUICultureName == "th")
{
culture = "th-TH";
}
else if (twoLetterUICultureName == "en")
{
culture = uiCulture = "en-US";
}
if (twoLetterCultureName == "th")
{
culture = "th-TH";
}
else if (twoLetterCultureName == "en")
{
culture = uiCulture = "en-US";
}
if (culture == null && uiCulture == null)
{
return(NullProviderCultureResult);
}
if (culture != null && uiCulture == null)
{
uiCulture = culture;
}
if (culture == null && uiCulture != null)
{
culture = uiCulture;
}
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(uiCulture);
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(culture);
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
public async override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
ProviderCultureResult providerCultureResult = null;
providerCultureResult = await new HeaderRequestCultureProvider()
.DetermineProviderCultureResult(httpContext) ?? await new QueryStringRequestCultureProvider()
.DetermineProviderCultureResult(httpContext) ?? await new RouteRequestCultureProvider()
.DetermineProviderCultureResult(httpContext);
return(providerCultureResult);
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var request = httpContext.Request;
if (!request.Path.HasValue)
{
return(Task.FromResult((ProviderCultureResult)null));
}
var cultureValue = Regex.Match(
request.Path.Value,
@"^/([a-z]{2})(?:$|/)",
RegexOptions.IgnoreCase);
if (cultureValue.Success)
{
var culture = CultureInfo.CurrentCulture;
var uiCulture = CultureInfo.CurrentUICulture;
if (culture == null || uiCulture == null)
{
return(Task.FromResult((ProviderCultureResult)null));
}
if (culture.Name == Options.DefaultRequestCulture.Culture.TwoLetterISOLanguageName)
{
if (httpContext.Request.Path.Equals(new PathString("/" + culture.TwoLetterISOLanguageName)))
{
httpContext.Response.Redirect("/", true);
}
else
{
var remaining = httpContext.Request.Path.Value.Substring(3);
httpContext.Response.Redirect(remaining, true);
}
}
var requestCulture = new ProviderCultureResult(culture.Name, uiCulture.Name);
return(Task.FromResult(requestCulture));
}
else
{
var requestCulture = new ProviderCultureResult(Options.DefaultRequestCulture.Culture.TwoLetterISOLanguageName, Options.DefaultRequestCulture.UICulture.TwoLetterISOLanguageName);
return(Task.FromResult(requestCulture));
}
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
string culture = null;
string uiCulture = null;
//var twoLetterCultureName = httpContext.Request.Path.Value.Split('/')[IndexOfCulture]?.ToString();
//var twoLetterUICultureName = httpContext.Request.Path.Value.Split('/')[IndexofUICulture]?.ToString();
var twoLetterCultureName = httpContext.Request.Cookies["lang"];
var twoLetterUICultureName = httpContext.Request.Cookies["lang"];
if (twoLetterCultureName == "tr")
{
culture = "tr-TR";
}
else if (twoLetterCultureName == "en")
{
culture = uiCulture = "en-US";
}
if (twoLetterUICultureName == "tr")
{
culture = "tr-TR";
}
else if (twoLetterUICultureName == "en")
{
culture = uiCulture = "en-US";
}
if (culture == null && uiCulture == null)
{
return(NullProviderCultureResult);
}
if (culture != null && uiCulture == null)
{
uiCulture = culture;
}
if (culture == null && uiCulture != null)
{
culture = uiCulture;
}
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
public Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
var culture = httpContext.Request.Path.Value.Split('/')[1]?.ToString();
if (culture == null)
{
return(null);
}
var providerResultCulture = new ProviderCultureResult(culture);
return(Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
var defaultLanguage = _settingManager.GetSettingValue(LocalizationSettingNames.DefaultLanguage);
if (defaultLanguage.IsNullOrEmpty() || !GlobalizationHelper.IsValidCultureCode(defaultLanguage))
{
return(Task.FromResult((ProviderCultureResult)null));
}
var providerResultCulture = new ProviderCultureResult(defaultLanguage, defaultLanguage);
return(Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
string uiCulture;
string culture = uiCulture = httpContext.Request.Path.Value.Split('/')[IndexOfCulture]?.ToString();
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
string culture = null;
var host = httpContext.Request.Host.Host.Split('.');
if ((IsDevelopment() && host.Length != 2) ||
(!IsDevelopment() && host.Length != 3))
{
var cookieRequestCultureProvider = new CookieRequestCultureProvider();
return(cookieRequestCultureProvider.DetermineProviderCultureResult(httpContext));
}
var twoLetterCultureName = host[0]?.ToString();
if (twoLetterCultureName == "tr")
{
culture = "tr-TR";
}
else if (twoLetterCultureName == "en")
{
culture = "en-US";
}
if (culture == null)
{
return(NullProviderCultureResult);
}
//Set Culture Cookie
httpContext.Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(1),
Domain = "." + domain
}
);
var providerResultCulture = new ProviderCultureResult(culture, culture);
return(Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var hostFragments = httpContext.Request.Host.Host.Split('.');
var culture = hostFragments.Last();
var result = new ProviderCultureResult(culture);
return(Task.FromResult(result));
}
public Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
var languageRouteValue = httpContext.Request.RouteValues.Where(r => r.Key == "language").ToList();
CultureInfo selectedCulture = null;
if (languageRouteValue.Any())
{
var selectedLanguage = languageRouteValue.First().Value as string;
selectedCulture = supportedCultures.FirstOrDefault(culture => culture.TwoLetterISOLanguageName.Equals(selectedLanguage, StringComparison.InvariantCultureIgnoreCase));
}
selectedCulture = selectedCulture ?? supportedCultures.First();
var result = new ProviderCultureResult(selectedCulture.TwoLetterISOLanguageName);
return(Task.FromResult(result));
}
/// <inheritdoc />
public override Task <ProviderCultureResult?> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var request = httpContext.Request;
if (!request.QueryString.HasValue)
{
return(NullProviderCultureResult);
}
string?queryCulture = null;
string?queryUICulture = null;
if (!string.IsNullOrWhiteSpace(QueryStringKey))
{
queryCulture = request.Query[QueryStringKey];
}
if (!string.IsNullOrWhiteSpace(UIQueryStringKey))
{
queryUICulture = request.Query[UIQueryStringKey];
}
if (queryCulture == null && queryUICulture == null)
{
// No values specified for either so no match
return(NullProviderCultureResult);
}
if (queryCulture != null && queryUICulture == null)
{
// Value for culture but not for UI culture so default to culture value for both
queryUICulture = queryCulture;
}
else if (queryCulture == null && queryUICulture != null)
{
// Value for UI culture but not for culture so default to UI culture value for both
queryCulture = queryUICulture;
}
var providerResultCulture = new ProviderCultureResult(queryCulture, queryUICulture);
return(Task.FromResult <ProviderCultureResult?>(providerResultCulture));
}
public Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
ProviderCultureResult result = null;
var map = new Dictionary <string, string>()
{
{ "en", "en" },
{ "de", "de" }
};
string domain = httpContext.Request.Host.Host.Split('.').Last();
if (map.ContainsKey(domain))
{
result = new ProviderCultureResult(map[domain]);
}
return(Task.FromResult(result));
}
public override async Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
var workContext = httpContext.RequestServices.GetRequiredService <IWorkContext>();
var user = await workContext.GetCurrentUser();
var culture = user.Culture;
if (culture == null)
{
return(await Task.FromResult((ProviderCultureResult)null));
}
var providerResultCulture = new ProviderCultureResult(culture);
return(await Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException();
}
var env = httpContext.RequestServices.GetService <IHostingEnvironment>();
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile(JsonFileName);
Configuration = builder.Build();
string culture = null;
string uiCulture = null;
var localizationSection = Configuration.GetSection(LocalizationSection);
if (!string.IsNullOrEmpty(CultureKey))
{
culture = localizationSection[CultureKey];
}
if (!string.IsNullOrEmpty(UICultureKey))
{
uiCulture = localizationSection[UICultureKey];
}
if (culture == null && uiCulture == null)
{
return(Task.FromResult((ProviderCultureResult)null));
}
if (culture != null && uiCulture == null)
{
uiCulture = culture;
}
if (culture == null && uiCulture != null)
{
culture = uiCulture;
}
var providerResultCulture = new ProviderCultureResult(culture, uiCulture);
return(Task.FromResult(providerResultCulture));
}
public override Task <ProviderCultureResult> DetermineProviderCultureResult(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
string culture = httpContext.Request.Path.Value.Split('/')[Segment];
if (string.IsNullOrEmpty(culture))
{
return(NullProviderCultureResult);
}
var providerResultCulture = new ProviderCultureResult(culture, culture);
return(Task.FromResult(providerResultCulture));
}
public async Task CustomRequestCultureProviderThatGetsCultureInfoFromUrl()
{
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
var options = new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("ar")
},
SupportedUICultures = new List <CultureInfo>
{
new CultureInfo("ar")
}
};
options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(context =>
{
var culture = GetCultureInfoFromUrl(context, options.SupportedCultures);
var requestCulture = new ProviderCultureResult(culture);
return(Task.FromResult(requestCulture));
}));
app.UseRequestLocalization(options);
app.Run(context =>
{
var requestCultureFeature = context.Features.Get <IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar", requestCulture.Culture.Name);
return(Task.FromResult(0));
});
});
}).Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync("/ar/page");
}
}
