private static void ConfigureRequestLocalization(IApplicationBuilder app)
{
using (var languageManager = app.ApplicationServices.GetRequiredService<IIocResolver>().ResolveAsDisposable<ILanguageManager>())
{
var defaultLanguage = languageManager.Object
.GetLanguages()
.FirstOrDefault(l => l.IsDefault);
if (defaultLanguage == null)
{
return;
}
var supportedCultures = languageManager.Object
.GetLanguages()
.Select(l => new CultureInfo(l.Name))
.ToArray();
var defaultCulture = new RequestCulture(defaultLanguage.Name);
var options = new RequestLocalizationOptions
{
DefaultRequestCulture = defaultCulture,
SupportedCultures = supportedCultures,
SupportedUICultures = supportedCultures
};
app.UseRequestLocalization(options);
}
}
public void Can_Resolve_Path_To_Page_To_Specified_Culture()
{
// Arrange
var trie = CreateTrie();
var currentRequestCulture = new Mock<RequestCulture>("en");
var trieResolver = new Mock<IRouteResolverTrie>(MockBehavior.Strict);
trieResolver.Setup(t => t.LoadTrieAsync(It.IsAny<RequestCulture>()))
.ReturnsAsync(trie);
var mapper = new Mock<IControllerMapper>(MockBehavior.Strict);
var page = new Page
{
Id = "articles/1"
};
var virtualPathResolver = new DefaultVirtualPathResolver(trieResolver.Object, mapper.Object);
var virtualPathContext = CreateVirtualPathContext(new { page, culture = "sv" });
var defaultRequestCulture = new RequestCulture("en");
// Act
var result = virtualPathResolver.Resolve(virtualPathContext, defaultRequestCulture, currentRequestCulture.Object);
// Assert
Assert.NotNull(result);
Assert.True(result.HasValue);
Assert.Equal("/sv/article", result.Value);
}
public DefaultRouter(IRouter defaultHandler, IRouteResolver routeResolver, IVirtualPathResolver virtualPathResolver, RequestCulture defaultRequestCulture)
{
if (defaultHandler == null)
{
throw new ArgumentNullException(nameof(defaultHandler));
}
if (routeResolver == null)
{
throw new ArgumentNullException(nameof(routeResolver));
}
if (virtualPathResolver == null)
{
throw new ArgumentNullException(nameof(virtualPathResolver));
}
if (defaultRequestCulture == null)
{
throw new ArgumentNullException(nameof(defaultRequestCulture));
}
_defaultHandler = defaultHandler;
_routeResolver = routeResolver;
_virtualPathResolver = virtualPathResolver;
_defaultRequestCulture = defaultRequestCulture;
}
protected virtual void ConfigureRequestLocalization(IApplicationBuilder app)
{
using (var languageManager = AbpBootstrapper.IocManager.ResolveAsDisposable<ILanguageManager>())
{
var supportedCultures = languageManager.Object
.GetLanguages()
.Select(l => new CultureInfo(l.Name))
.ToArray();
var defaultCulture = new RequestCulture(
languageManager.Object
.GetLanguages()
.FirstOrDefault(l => l.IsDefault)
?.Name
);
var options = new RequestLocalizationOptions
{
DefaultRequestCulture = defaultCulture,
SupportedCultures = supportedCultures,
SupportedUICultures = supportedCultures
};
app.UseRequestLocalization(options);
}
}
public async Task<Trie> LoadTrieAsync(RequestCulture requestCulture)
{
using (var session = _documentStore.OpenAsyncSession())
{
using (session.Advanced.DocumentStore.AggressivelyCacheFor(TimeSpan.FromMinutes(60)))
{
var site = await session.LoadAsync<Site>("sites/" + requestCulture.Culture.TwoLetterISOLanguageName);
return site.Trie;
}
}
}
/// <summary>
/// Creates a string representation of a <see cref="RequestCulture"/> for placement in a cookie.
/// </summary>
/// <param name="requestCulture">The <see cref="RequestCulture"/>.</param>
/// <returns>The cookie value.</returns>
public static string MakeCookieValue(RequestCulture requestCulture)
{
if (requestCulture == null)
{
throw new ArgumentNullException(nameof(requestCulture));
}
return(string.Join(_cookieSeparator,
$"{_culturePrefix}{requestCulture.Culture.Name}",
$"{_uiCulturePrefix}{requestCulture.UICulture.Name}"));
}
// Pass the requestCultureFeature and requestCulture objects to the view
// so we can get Culture/UICulture information.
public IActionResult About()
{
IRequestCultureFeature requestCultureFeature = HttpContext.Features.Get <IRequestCultureFeature>();
RequestCulture requestCulture = requestCultureFeature.RequestCulture;
ViewData["requestCultureFeature"] = requestCultureFeature;
ViewData["requestCulture"] = requestCulture;
ViewData["Message"] = _localizer["Your application description page."];
return(View());
}
public async Task <Trie> LoadTrieAsync(RequestCulture requestCulture)
{
using (var session = _documentStore.OpenAsyncSession())
{
using (session.Advanced.DocumentStore.AggressivelyCacheFor(TimeSpan.FromMinutes(60)))
{
var site = await session.LoadAsync <Site>("sites/" + requestCulture.Culture.TwoLetterISOLanguageName);
return(site.Trie);
}
}
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
SupportedCultures = new CultureInfo[]
{
new CultureInfo("pt-BR"),
new CultureInfo("en-US")
};
DefaultRequestCulture = new RequestCulture("en-US", "en-US");
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
//app.UseHsts();
app.UseHttpsRedirection();
}
app.UseSession();
app.UseStaticFiles();
app.UseCookiePolicy();
// Add Documentation (MkDocs) Support
app.UseFileServer(new FileServerOptions
{
FileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), "Documentation/site/")),
RequestPath = "/documentation",
EnableDirectoryBrowsing = false,
EnableDefaultFiles = true,
DefaultFilesOptions = { DefaultFileNames = { "index.html" } }
});
// Add Culture Detection Support
var allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures).ToList(); //.Where(x => !x.IsNeutralCulture)
var defaultCulture = new RequestCulture("en-US");
defaultCulture.UICulture.NumberFormat.CurrencySymbol = "$";
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = defaultCulture,
SupportedCultures = allCultures,
SupportedUICultures = allCultures
});
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapHub <UpdateHub>("/update");
});
}
public async Task GetCultureInfoFromPersistentCookie()
{
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-SA")
},
SupportedUICultures = new List <CultureInfo>
{
new CultureInfo("ar-SA")
}
};
var provider = new CookieRequestCultureProvider
{
CookieName = "Preferences"
};
options.RequestCultureProviders.Insert(0, provider);
app.UseRequestLocalization(options);
app.Run(context =>
{
var requestCultureFeature = context.Features.Get <IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
return(Task.FromResult(0));
});
});
}).Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var culture = new CultureInfo("ar-SA");
var requestCulture = new RequestCulture(culture);
var value = CookieRequestCultureProvider.MakeCookieValue(requestCulture);
client.DefaultRequestHeaders.Add("Cookie", new CookieHeaderValue("Preferences", value).ToString());
var response = await client.GetAsync(string.Empty);
Assert.Equal("c=ar-SA|uic=ar-SA", value);
}
}
/// <summary>
/// Creates a string representation of a <see cref="RequestCulture"/> for placement in a cookie.
/// </summary>
/// <param name="requestCulture">The <see cref="RequestCulture"/>.</param>
/// <returns>The cookie value.</returns>
public static string MakeCookieValue(RequestCulture requestCulture)
{
if (requestCulture == null)
{
throw new ArgumentNullException("requestCulture");
}
var seperator = _cookieSeparator[0].ToString();
return string.Join(seperator,
string.Format("{0}{1}", _culturePrefix, requestCulture.Culture.Name),
string.Format("{0}{1}", _uiCulturePrefix, requestCulture.UICulture.Name));
}
public static void SetCultureCookie(
HttpContext httpContext,
RequestCulture requestCulture)
{
httpContext.Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(requestCulture),
new CookieOptions
{
Expires = DateTime.Now.AddYears(2)
}
);
}
public IActionResult Set(string uiCulture, string returnUrl)
{
IRequestCultureFeature feature = HttpContext.Features.Get <IRequestCultureFeature>();
RequestCulture request = new RequestCulture(feature.RequestCulture.Culture, new CultureInfo(uiCulture));
string cookieValue = CookieRequestCultureProvider.MakeCookieValue(request);
string cookieName = CookieRequestCultureProvider.DefaultCookieName;
Response.Cookies.Append(cookieName, cookieValue);
return(LocalRedirect(returnUrl));
}
public static RequestCulture AppendCookie(HttpResponse response, string culture)
{
RequestCulture requestCulture = new RequestCulture(culture);
response.Cookies.Delete(CookieRequestCultureProvider.DefaultCookieName);
response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(requestCulture),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1), Secure = true, IsEssential = true
});
return(requestCulture);
}
public override Task <RequestCulture> DetermineRequestCulture(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
if (!httpContext.User.Identity.IsAuthenticated)
{
return(Task.FromResult((RequestCulture)null));
}
string userCulture = null;
string userUICulture = null;
string cultureClaim = httpContext.User.GetCulture();
if (!string.IsNullOrWhiteSpace(cultureClaim))
{
userCulture = cultureClaim;
}
string uicultureClaim = httpContext.User.GetUICulture();
if (!string.IsNullOrWhiteSpace(uicultureClaim))
{
userUICulture = uicultureClaim;
}
if (userCulture == null && userUICulture == null)
{
// No values specified for either so no match
return(Task.FromResult((RequestCulture)null));
}
if (userCulture != null && userUICulture == null)
{
// Value for culture but not for UI culture so default to culture value for both
userUICulture = userCulture;
}
if (userCulture == null && userUICulture != null)
{
// Value for UI culture but not for culture so default to UI culture value for both
userCulture = userUICulture;
}
var requestCulture = new RequestCulture(new CultureInfo(userCulture), new CultureInfo(userUICulture));
return(Task.FromResult(requestCulture));
}
public void SetCulture(string culture)
{
var requestCulture = new RequestCulture(culture);
var response = m_httpContextAccessor.HttpContext.Response;
response.Cookies.Append(
CultureCookieName,
requestCulture.Culture.Name,
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
}
public static void SetCultureCookie(HttpContext context
, string cookieName
, string culture)
{
var requestCulture = new RequestCulture(culture);
context.Response.Cookies.Append(
cookieName
, CookieRequestCultureProvider.MakeCookieValue(requestCulture)
, new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
}
private void SetApplicationCultures(RequestLocalizationOptions options)
{
var defaultCulture = new RequestCulture("en");
var supportedCultures = new[]
{
new CultureInfo("ro"),
new CultureInfo("en"),
new CultureInfo("fr")
};
options.DefaultRequestCulture = defaultCulture;
options.SupportedCultures = supportedCultures;
options.SupportedUICultures = supportedCultures;
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
var requestCulture = new RequestCulture(culture);
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(requestCulture),
new CookieOptions {
IsEssential = true
}
);
return(LocalRedirect(returnUrl));
}
private void SetCookieValues(string culture = null)
{
var localizationCookie = GetCookieValue();
if (culture != null)
{
var requestCulture = new RequestCulture(culture);
localizationCookie.CurrentCulture = requestCulture.Culture.Name;
}
localizationCookie.DefaultCulture = m_autoLocalizationManager.GetDefaultCulture().Name;
SetCookieValue(localizationCookie);
}
public void Create_ReturnsRequestLocalizationOptions(RequestLocalizationOptions options)
{
var requestCulture = new RequestCulture("pt-BR");
var supportedCultures = new List <CultureInfo> {
new CultureInfo("pt-BR")
};
var action = RequestLocalizationOptionsFactory.Create();
action.Invoke(options);
// Asserts
options.DefaultRequestCulture.Should().BeEquivalentTo(requestCulture);
options.SupportedCultures.Should().BeEquivalentTo(supportedCultures);
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
var requestCulture = new RequestCulture(culture);
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(requestCulture),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
return(LocalRedirect(returnUrl));
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
var requestCulture = new RequestCulture(culture); //TODO validation of unsupported culture name
HttpContext.Request.HttpContext.Response.Cookies.Append(
"Localization.Culture",
requestCulture.Culture.Name,
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
return(LocalRedirect(returnUrl));
}
private void SetPreferences(ApplicationUser user)
{
UserPreferencesViewModel preferences = UserPreferencesAppService.GetByUserId(new Guid(user.Id));
if (preferences == null || preferences.Id == Guid.Empty)
{
RequestCulture requestLanguage = Request.HttpContext.Features.Get <IRequestCultureFeature>().RequestCulture;
SupportedLanguage lang = base.SetLanguageFromCulture(requestLanguage.UICulture.Name);
SetCookieValue(SessionValues.PostLanguage, lang.ToString(), 7);
}
else
{
SetCookieValue(SessionValues.PostLanguage, preferences.UiLanguage.ToString(), 7);
SetSessionValue(SessionValues.JobProfile, preferences.JobProfile.ToString());
}
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var userId = await _userManager.GetUserIdAsync(user);
var email = await _userManager.GetEmailAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId, code },
protocol: Request.Scheme);
string culture = "";
RequestCulture requestCulture = new RequestCulture("en-US");
if (!_options.Value.DefaultRequestCulture.Equals(requestCulture))
{
culture = ".ru-RU";
}
string webRootPath = _hostingEnvironment.WebRootPath;
string contentRootPath = _hostingEnvironment.ContentRootPath;
var file = Path.Combine(contentRootPath, "wwwroot", "lib", "mtd-ordermaker", "emailform", $"userEmail{culture}.html");
var htmlArray = System.IO.File.ReadAllText(file);
string htmlText = htmlArray.ToString();
htmlText = htmlText.Replace("{link}", $"<a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>{_localizer["Verify Email Address"]}</a>");
await _emailSender.SendEmailAsync(email, _localizer["Email Verification"], htmlText);
StatusMessage = "Verification email sent. Please check your email.";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostAdminConfimEmailAsync()
{
IFormCollection requestForm = await Request.ReadFormAsync();
string userName = requestForm["UserName"];
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(NotFound());
}
var userId = await _userManager.GetUserIdAsync(user);
var email = await _userManager.GetEmailAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId, code },
protocol: Request.Scheme);
string culture = "";
RequestCulture requestCulture = new RequestCulture("en-US");
if (!_options.Value.DefaultRequestCulture.Equals(requestCulture))
{
culture = ".ru-RU";
}
string webRootPath = _hostingEnvironment.WebRootPath;
string contentRootPath = _hostingEnvironment.ContentRootPath;
var file = Path.Combine(contentRootPath, "wwwroot", "lib", "mtd-ordermaker", "emailform", $"userEmail{culture}.html");
var htmlArray = System.IO.File.ReadAllText(file);
string htmlText = htmlArray.ToString();
htmlText = htmlText.Replace("{link}", $"<a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>{_localizer["Verify Email Address"]}</a>");
await _emailSender.SendEmailAsync(email, _localizer["Email Verification"], htmlText);
user.EmailConfirmed = false;
await _userManager.UpdateAsync(user);
return(Ok());
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { code },
protocol: Request.Scheme);
string culture = "";
RequestCulture requestCulture = new RequestCulture("en-US");
if (!_options.Value.DefaultRequestCulture.Equals(requestCulture))
{
culture = ".ru-RU";
}
string webRootPath = _hostingEnvironment.WebRootPath;
string contentRootPath = _hostingEnvironment.ContentRootPath;
var file = Path.Combine(contentRootPath, "wwwroot", "lib", "mtd-ordermaker", "emailform", $"userPassword{culture}.html");
var htmlArray = System.IO.File.ReadAllText(file);
string htmlText = htmlArray.ToString();
htmlText = htmlText.Replace("{link}", $"<a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>{_localizer["Create account password"]}</a>");
htmlText = htmlText.Replace("{login}", user.UserName);
await _emailSender.SendEmailAsync(Input.Email, _localizer["Password reset"], htmlText);
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
/// <summary>
/// Adds the <see cref="RequestLocalizationMiddleware"/> to automatically set culture information for
/// requests based on information provided by the client using the default options.
/// </summary>
/// <param name="app">The <see cref="IApplicationBuilder"/>.</param>
/// <param name="defaultRequestCulture">The default <see cref="RequestCulture"/> to use if none of the
/// requested cultures match supported cultures.</param>
/// <returns>The <see cref="IApplicationBuilder"/>.</returns>
public static IApplicationBuilder UseRequestLocalization(
this IApplicationBuilder app,
RequestCulture defaultRequestCulture)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (defaultRequestCulture == null)
{
throw new ArgumentNullException(nameof(defaultRequestCulture));
}
var options = new RequestLocalizationOptions();
return(UseRequestLocalization(app, options, defaultRequestCulture));
}
public IActionResult Set(string uiCulture, string returnUrl)
{
var languages = Request.GetTypedHeaders()
.AcceptLanguage
?.OrderByDescending(x => x.Quality ?? 1) // Quality defines priority from 0 to 1, where 1 is the highest.
.Select(x => x.Value.ToString())
.ToArray() ?? Array.Empty <string>();
IRequestCultureFeature feature = HttpContext.Features.Get <IRequestCultureFeature>();
RequestCulture requestCulture = new RequestCulture(feature.RequestCulture.Culture, new CultureInfo(uiCulture));
string cookieValue = CookieRequestCultureProvider.MakeCookieValue(requestCulture);
string cookieName = CookieRequestCultureProvider.DefaultCookieName;
Response.Cookies.Append(cookieName, cookieValue);
return(LocalRedirect(returnUrl));
}
// 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();
services.AddControllers();
services.AddSingleton <WeatherForecastService>();
Language[] languages =
{
new Language
{
LangId = "en-US",
Title = "English"
},
new Language
{
LangId = "it-IT",
Title = "Italiano"
}
};
CultureInfo[] supportedCultures = new CultureInfo[languages.Length];
for (int i = 0; i < languages.Length; i++)
{
supportedCultures[i] = new CultureInfo(languages[i].LangId);
}
RequestCulture requestCulture = new RequestCulture("en-US");
IRequestCultureProvider[] requestCultureProvider = new IRequestCultureProvider[]
{
new CookieRequestCultureProvider()
};
services.Configure <RequestLocalizationOptions>(options =>
{
options.RequestCultureProviders = requestCultureProvider;
options.DefaultRequestCulture = requestCulture;
options.SupportedCultures = supportedCultures;
options.SupportedUICultures = supportedCultures;
});
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
var cultures = new List <CultureInfo>
{
new CultureInfo("en-GB"),
new CultureInfo("th-TH")
};
var requestCulture = new RequestCulture("en-GB", "en-GB");
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = requestCulture,
SupportedCultures = cultures,
SupportedUICultures = cultures,
RequestCultureProviders = new List <IRequestCultureProvider>
{
new CookieRequestCultureProvider
{
CookieName = "Web.Language"
}
}
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IStringLocalizer <Startup> sr)
{
app.UseIISPlatformHandler();
var options = new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture(new CultureInfo("en-US")),
SupportedCultures = new CultureInfo[]
{
new CultureInfo("en-US"),
new CultureInfo("de-AT"),
new CultureInfo("de")
},
SupportedUICultures = new CultureInfo[]
{
new CultureInfo("en-US"),
new CultureInfo("de-AT"),
new CultureInfo("de")
}
};
app.UseRequestLocalization(options);
app.Run(async context =>
{
IRequestCultureFeature requestCultureFeature = context.Features.Get <IRequestCultureFeature>();
RequestCulture requestCulture = requestCultureFeature.RequestCulture;
var today = DateTime.Today;
context.Response.StatusCode = 200;
await context.Response.WriteAsync("<h1>Sample Localization</h1>");
await context.Response.WriteAsync(
$"<div>{requestCulture.Culture} {requestCulture.UICulture}</div>");
await context.Response.WriteAsync($"<div>{today:D}</div>");
await context.Response.WriteAsync($"<div>{sr["message1"]}</div>");
await context.Response.WriteAsync($"<div>{sr.WithCulture(new CultureInfo("de-DE")).GetString("message1")}</div>");
await context.Response.WriteAsync($"<div>{WebUtility.HtmlEncode(sr.GetString("message1"))}</div>");
await context.Response.WriteAsync(
$"<div>{sr.GetString("message2", requestCulture.Culture, requestCulture.UICulture)}</div>");
});
}
private void SetLanguage()
{
PostFromHomeViewModel postModel = new PostFromHomeViewModel();
RequestCulture requestLanguage = Request.HttpContext.Features.Get <IRequestCultureFeature>().RequestCulture;
string lang = GetCookieValue(SessionValues.PostLanguage);
if (lang != null)
{
SupportedLanguage langEnum = (SupportedLanguage)Enum.Parse(typeof(SupportedLanguage), lang);
postModel.DefaultLanguage = langEnum;
}
else
{
if (!User.Identity.IsAuthenticated)
{
SetAspNetCultureCookie(requestLanguage);
postModel.DefaultLanguage = base.SetLanguageFromCulture(requestLanguage.UICulture.Name);
}
else
{
UserPreferencesViewModel userPrefs = userPreferencesAppService.GetByUserId(CurrentUserId);
if (userPrefs != null && userPrefs.Id != Guid.Empty)
{
SetAspNetCultureCookie(userPrefs.UiLanguage);
SetCookieValue(SessionValues.PostLanguage, postModel.DefaultLanguage.ToString(), 7);
postModel.DefaultLanguage = userPrefs.UiLanguage;
}
else
{
SetAspNetCultureCookie(requestLanguage);
postModel.DefaultLanguage = base.SetLanguageFromCulture(requestLanguage.UICulture.Name);
}
}
}
ViewBag.PostFromHome = postModel;
}
public JsonStringLocalizerFactory(
IHostingEnvironment hostingEnvironment,
IOptions <JsonLocalizationOptions> options,
IOptions <RequestLocalizationOptions> requestLocalizationOptions,
IActionContextAccessor actionContextAccessor,
ILoggerFactory loggerFactory)
{
_options = options.Value;
_env = hostingEnvironment ?? throw new ArgumentNullException(nameof(hostingEnvironment));
_defaultCulture = requestLocalizationOptions.Value.DefaultRequestCulture;
_actionContextAccessor = actionContextAccessor ?? throw new ArgumentNullException(nameof(actionContextAccessor));
_loggerFactory = loggerFactory;
_resourcesRelativePath = _options.ResourcesPath ?? string.Empty;
if (!string.IsNullOrEmpty(_resourcesRelativePath))
{
_resourcesRelativePath = _resourcesRelativePath.Replace(Path.AltDirectorySeparatorChar, '.').Replace(Path.DirectorySeparatorChar, '.');
}
_globalResources = new JsonGlobalResources(hostingEnvironment, options, _defaultCulture, _loggerFactory);
}
public static IApplicationBuilder UseRequestLocalization(
this IApplicationBuilder app,
RequestCulture defaultCulture,
params RequestCulture[] supportedCultures)
{
if (app is null)
{
throw new ArgumentNullException(nameof(app));
}
return(app.UseRequestLocalization(options =>
{
options.DefaultRequestCulture = defaultCulture ?? throw new ArgumentNullException(nameof(defaultCulture));
if (supportedCultures.IsNotNullOrEmpty())
{
options.SupportedCultures = supportedCultures.Select(rc => rc.Culture).ToList();
options.SupportedUICultures = supportedCultures.Select(rc => rc.UICulture).ToList();
}
}));
}
public void Can_Resolve(string path)
{
// Arrange
var context = CreateRouteContext(path);
var virtualPathContext = CreateVirtualPathContext(new { });
var virtualPathResolver = new Mock<IVirtualPathResolver>(MockBehavior.Strict);
var defaultRequestCulture = new RequestCulture("en");
var requestCulture = new RequestCulture("en");
virtualPathResolver.Setup(v => v.Resolve(virtualPathContext, defaultRequestCulture, requestCulture))
.Returns("/about");
var route = CreateDefaultRouter(context, new RequestCulture("en"), virtualPathResolver.Object);
// Act
VirtualPathData data = route.GetVirtualPath(virtualPathContext);
// Assert
Assert.NotNull(data);
Assert.Equal("/about", data.VirtualPath);
}
public async Task Can_Resolve_Home_Page_With_Custom_Action(string path)
{
// Arrange
var context = CreateRouteContext(path);
var trie = CreateTrie();
var requestCulture = new RequestCulture("en");
var trieResolver = new Mock<IRouteResolverTrie>(MockBehavior.Strict);
trieResolver.Setup(t => t.LoadTrieAsync(requestCulture)).ReturnsAsync(trie);
var mapper = new Mock<IControllerMapper>(MockBehavior.Strict);
mapper.Setup(x => x.ControllerHasAction("Home", "about")).Returns(true);
var routeResolver = new DefaultRouteResolver(trieResolver.Object, mapper.Object);
// Act
IResolveResult result = await routeResolver.Resolve(context, requestCulture);
// Assert
Assert.NotNull(result);
Assert.Equal("Home", result.Controller);
Assert.Equal("about", result.Action);
}
public PathString Resolve(VirtualPathContext virtualPathContext, RequestCulture defaultRequestCulture, RequestCulture requestCulture)
{
// Handle when the page is added as a route parameter
object value;
if (virtualPathContext.Values.TryGetValue("page", out value))
{
var page = value as Page;
if (page == null) return null;
object culture;
if (virtualPathContext.Values.TryGetValue("culture", out culture))
{
string cultureValue = culture as string;
if (cultureValue != null)
{
requestCulture = new RequestCulture(cultureValue);
}
}
var trie = _routeResolverTrie.LoadTrieAsync(requestCulture);
trie.Wait();
var node = trie.Result.FirstOrDefault(n => n.Value.PageId == page.Id);
PathString path = new PathString();
if (defaultRequestCulture.Culture.Name != requestCulture.Culture.Name)
{
path = path.Add("/" + requestCulture.Culture.TwoLetterISOLanguageName);
}
return path.Add(node.Key);
}
if (virtualPathContext.Values.TryGetValue("id", out value))
{
var id = value as string;
if (id == null) return null;
object culture;
if (virtualPathContext.Values.TryGetValue("culture", out culture))
{
string cultureValue = culture as string;
if (cultureValue != null)
{
requestCulture = new RequestCulture(cultureValue);
}
}
var trie = _routeResolverTrie.LoadTrieAsync(requestCulture);
trie.Wait();
var node = trie.Result.FirstOrDefault(n => n.Value.PageId == id);
PathString path = new PathString();
if (defaultRequestCulture.Culture.Name != requestCulture.Culture.Name)
{
path = path.Add("/" + requestCulture.Culture.TwoLetterISOLanguageName);
}
return path.Add(node.Key);
}
return null;
}
private static DefaultRouter CreateDefaultRouter(RouteContext context, RequestCulture culture, IVirtualPathResolver virtualPathResolver)
{
var result = new Mock<IResolveResult>(MockBehavior.Strict);
result.SetupGet(x => x.Controller).Returns("Home");
result.SetupGet(x => x.Action).Returns("Index");
var routeResolver = new Mock<IRouteResolver>(MockBehavior.Strict);
routeResolver.Setup(x => x.Resolve(context, culture))
.ReturnsAsync(result.Object);
return new DefaultRouter(
CreateTarget(),
routeResolver.Object,
virtualPathResolver,
new RequestCulture("en"));
}
public async Task<IResolveResult> Resolve(RouteContext context, RequestCulture requestCulture)
{
var trie = await _routeResolverTrie.LoadTrieAsync(requestCulture);
if (trie == null || !trie.Any()) return null;
// Set the default action to index
var action = DefaultRouter.DefaultAction;
PathString remaining = context.HttpContext.Request.Path;
if (context.HttpContext.Request.Path.Value.StartsWith("/" + requestCulture.Culture.TwoLetterISOLanguageName))
{
remaining = remaining.Value.Substring(3);
}
var segments = remaining.Value.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
TrieNode currentNode;
// The requested url is for the start page with no action
// so just return the start page
if (!segments.Any())
{
trie.TryGetNode("/", out currentNode);
}
else
{
var requestPath = NormalizeRequestPath(remaining);
// The normal behaviour is to load the page based on the incoming url
trie.TryGetNode(requestPath, out currentNode);
// Try to find the node without the last segment of the url and set the last segment as action
if (currentNode == null)
{
action = segments.Last();
requestPath = string.Join("/", segments, 0, (segments.Length - 1));
trie.TryGetNode("/" + requestPath, out currentNode);
}
}
if (currentNode == null)
{
return null;
}
if(segments.Any()) {
// We always need to check if the last segment is a valid action on the controller for the node we found
string possibleAction = segments.Last();
if (_controllerMapper.ControllerHasAction(currentNode.ControllerName, possibleAction))
{
action = possibleAction;
}
}
if (!_controllerMapper.ControllerHasAction(currentNode.ControllerName, action))
{
return null;
}
return new ResolveResult(currentNode, currentNode.ControllerName, action);
}
