public async void GetCultureInfoFromPersistentCookie()
{
using (var server = TestServer.Create(app =>
{
var options = new RequestLocalizationOptions()
{
SupportedCultures = new List <CultureInfo>
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List <CultureInfo>
{
new CultureInfo("ar-SA")
}
};
var provider = new CookieRequestCultureProvider();
provider.CookieName = "Preferences";
options.RequestCultureProviders.Insert(0, provider);
app.UseRequestLocalization(options, defaultRequestCulture: new RequestCulture("en-US"));
app.Run(context =>
{
var requestCultureFeature = context.Features.Get <IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
return(Task.FromResult(0));
});
}))
{
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);
}
}
public async Task GetDefaultCultureInfoIfCookieDoesNotExist()
{
var builder = new WebHostBuilder()
.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("en-US", requestCulture.Culture.Name);
return(Task.FromResult(0));
});
});
using (var server = new TestServer(builder))
{
var client = server.CreateClient();
var response = await client.GetAsync(string.Empty);
}
}
public IActionResult SetLanguage(int id)
{
//RU
if (id == 1)
{
string lang = "ru-RU";
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(lang)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddMonths(12)
});
return(LocalRedirect("/Home/Index"));
}//LV
else if (id == 2)
{
string lang = "lv-LV";
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(lang)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddMonths(12)
});
return(LocalRedirect("/Home/Index"));
}
//English
else
{
string lang = "en-EN";
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(lang)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddMonths(12)
});
return(LocalRedirect("/Home/Index"));
}
}
public virtual ActionResult ChangeCulture(string cultureName, string returnUrl = "")
{
if (!GlobalizationHelper.IsValidCultureCode(cultureName))
{
throw new AbpException("Unknown language: " + cultureName + ". It must be a valid culture!");
}
var cookieValue = CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(cultureName, cultureName));
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
cookieValue,
new CookieOptions {
Expires = Clock.Now.AddYears(2)
}
);
if (AbpSession.UserId.HasValue)
{
SettingManager.ChangeSettingForUser(
AbpSession.ToUserIdentifier(),
LocalizationSettingNames.DefaultLanguage,
cultureName
);
}
if (Request.IsAjaxRequest())
{
return(Json(new AjaxResponse()));
}
if (!string.IsNullOrWhiteSpace(returnUrl) && AbpUrlHelper.IsLocalUrl(Request, returnUrl))
{
return(Redirect(returnUrl));
}
return(Redirect("/")); //TODO: Go to app root
}
public Task Invoke(HttpContext context)
{
var cultureQuery = context.Request.Cookies[".AspNetCore.Culture"];
if (!string.IsNullOrWhiteSpace(cultureQuery))
{
//var result = new CookieRequestCultureProvider().DetermineProviderCultureResult(context).Result;
//result.Cultures
//var culture = new CultureInfo(result.Cultures);
//CultureInfo.CurrentCulture = ;
//CultureInfo.CurrentUICulture = result.UICultures.First();
//var culture = new CultureInfo(cultureQuery);
//CultureInfo.CurrentCulture = culture;
//CultureInfo.CurrentUICulture = culture;
//
}
else
{
var culture = new CultureInfo("zh");
CultureInfo.CurrentCulture = culture;
CultureInfo.CurrentUICulture = CultureInfo.CreateSpecificCulture(culture.Name);
context.Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
}
// Call the next delegate/middleware in the pipeline
return(this._next(context));
}
public async Task <IActionResult> ChangeLanguageAsync([FromBody] ChangeCultureRequest model, CancellationToken token)
{
var culture = model.Culture;
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(culture),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
if (!User.Identity.IsAuthenticated)
{
return(Ok());
}
var userId = _userManager.GetLongUserId(User);
var command = new UpdateUserCultureCommand(userId, culture.Culture.Name);
await _commandBus.DispatchAsync(command, token);
return(Ok());
}
public void UpdateCultureCookie_ShouldCallCorrectMethod_WithCorrectArgument(string culture)
{
//Arrange
string keyPassedAsArgument = null, valuePassedAsArgument = null;
_mockCookies.Setup(x => x.Append(It.IsAny <string>(), It.IsAny <string>()))
.Callback <string, string>((string key, string value) =>
{
keyPassedAsArgument = key;
valuePassedAsArgument = value;
});
var sut = new LanguageService();
var expectedArgumentToAppendMethod = CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture));
//Act
sut.UpdateCultureCookie(_mockHttpContext.Object, culture);
//Assert
_mockCookies.Verify(x => x.Append(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
Assert.Equal(expectedArgumentToAppendMethod, valuePassedAsArgument);
Assert.Equal(CookieRequestCultureProvider.DefaultCookieName, keyPassedAsArgument);
}
public virtual async Task <IActionResult> SetLanguage([FromQuery][FromHeader(Name = "Accept-Language")][Required] string code, string returnUrl, CancellationToken cancellationToken = new CancellationToken())
{
await Task.Factory
.StartNew(x =>
{
this.Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(
new RequestCulture(code)),
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
}, null, cancellationToken);
if (returnUrl != null)
{
return(LocalRedirect(returnUrl));
}
return(Ok());
}
public IActionResult SetLanguage(string language, string returnUrl)
{
var defaultFormattingCulture = _localizationOptions.DefaultRequestCulture.Culture.Name;
var formattingCulture = defaultFormattingCulture;
if (HttpContext.Request.Cookies.TryGetValue(CookieRequestCultureProvider.DefaultCookieName, out var value))
{
formattingCulture = CookieRequestCultureProvider.ParseCookieValue(value).Cultures.FirstOrDefault().Value;
if (string.IsNullOrEmpty(formattingCulture))
{
formattingCulture = defaultFormattingCulture;
}
}
value = CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(formattingCulture, language));
var expiration = new CookieOptions {
Expires = DateTime.UtcNow.AddYears(4)
};
HttpContext.Response.Cookies.Delete(CookieRequestCultureProvider.DefaultCookieName);
HttpContext.Response.Cookies.Append(CookieRequestCultureProvider.DefaultCookieName, value, expiration);
return(LocalRedirect(returnUrl));
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
var currentCulture = _localizationOptions.Value.DefaultRequestCulture.Culture.Name;
if (RouteData.Values.ContainsKey("culture"))
{
currentCulture = (string)RouteData.Values["culture"];
}
returnUrl = ReplaceFirst(returnUrl, currentCulture, culture);
return(LocalRedirect(returnUrl));
}
public IActionResult SetLanguage(
[FromServices] LocalizationSettings settings,
string culture,
string returnUrl = null)
{
if (string.IsNullOrWhiteSpace(culture))
{
throw new ArgumentException("Invalid culture argument value provided.", nameof(culture));
}
Response.Cookies.Append(
settings.LocalizationCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(1),
HttpOnly = true,
Secure = Request.IsHttps
}
);
return(LocalRedirect(returnUrl ?? "~/"));
}
public IActionResult SetLanguage(string locale, string returnUrl)
{
Response.Cookies.Append(CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(locale)));
var headers = Request.GetTypedHeaders();
if (string.IsNullOrEmpty(returnUrl) && headers.Referer != null)
{
returnUrl = headers.Referer.PathAndQuery + "?locale=" + locale;
}
else
{
returnUrl = returnUrl + "?locale=" + locale;
}
if (Url.IsLocalUrl(returnUrl) && !string.IsNullOrEmpty(returnUrl))
{
ViewBag.ReturnURL = returnUrl;
}
return(Redirect(returnUrl));
}
public async void GetDefaultCultureInfoIfCultureKeysAreMissingOrInvalid()
{
using (var server = TestServer.Create(app =>
{
var options = new RequestLocalizationOptions();
var provider = new CookieRequestCultureProvider();
provider.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(options.DefaultRequestCulture.Culture.Name, requestCulture.Culture.Name);
return(Task.FromResult(0));
});
}))
{
var client = server.CreateClient();
client.DefaultRequestHeaders.Add("Cookie", new CookieHeaderValue("Preferences", "uic=ar-SA").ToString());
var response = await client.GetAsync(string.Empty);
}
}
protected string GetAspNetCultureCookie()
{
RequestCulture requestLanguage = Request.HttpContext.Features.Get <IRequestCultureFeature>().RequestCulture;
string cookieValue = GetCookieValue(CookieRequestCultureProvider.DefaultCookieName);
ProviderCultureResult cookie = CookieRequestCultureProvider.ParseCookieValue(cookieValue);
if (!User.Identity.IsAuthenticated)
{
SetAspNetCultureCookie(requestLanguage);
return(requestLanguage.UICulture.Name);
}
else
{
if (cookie == null || !cookie.Cultures.Any())
{
UserPreferencesViewModel userPrefs = UserPreferencesAppService.GetByUserId(CurrentUserId);
if (userPrefs != null && userPrefs.Id != Guid.Empty)
{
SetAspNetCultureCookie(userPrefs.UiLanguage);
}
else
{
SetAspNetCultureCookie(requestLanguage);
}
return(requestLanguage != null ? requestLanguage.UICulture.Name : "en-US");
}
else
{
return(cookie.Cultures.First().Value);
}
}
}
public virtual ActionResult ChangeCulture(string cultureName)
{
if (!Localization.GlobalizationHelper.IsValidCultureCode(cultureName))
{
throw new Exception("Unknown language: " + cultureName + ". It must be a valid culture!");
}
string queryString = Request.QueryString.Value;
string returnUrl = queryString.Split("returnUrl=")[1];
string cookieValue = CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(cultureName, cultureName));
Response.Cookies.Append(
HybridConsts.CultureCookieName,
cookieValue,
new CookieOptions
{
Expires = DateTime.UtcNow.AddYears(2),
HttpOnly = true
}
);
//LocalizationIocManager.CultureName = cultureName;
if (Request.IsAjaxRequest())
{
return(Json(new AjaxResult()));
}
if (!string.IsNullOrWhiteSpace(returnUrl) && returnUrl.IsLocalUrl(Request))
{
return(Redirect(returnUrl));
}
return(Redirect("/")); //: Go to app root
}
public async Task InvokeAsync(HttpContext context)
{
var opts = (IOptions <SimpleIdServerCommonOptions>)context.RequestServices.GetService(typeof(IOptions <SimpleIdServerCommonOptions>));
if (context.Request.Query.ContainsKey(AuthorizationRequestParameters.UILocales) && context.Request.Query[AuthorizationRequestParameters.UILocales].Count == 1)
{
var uiLocales = context.Request.Query[AuthorizationRequestParameters.UILocales][0];
if (await UpdateLanguage(uiLocales, opts.Value, context))
{
return;
}
}
if (context.Request.Headers.ContainsKey(TranslationHelper.AcceptLanguage))
{
var acceptLanguages = context.Request.Headers[TranslationHelper.AcceptLanguage].FirstOrDefault();
if (await UpdateLanguage(acceptLanguages, opts.Value, context))
{
return;
}
}
if (context.Request.Cookies.ContainsKey(CookieRequestCultureProvider.DefaultCookieName))
{
var str = context.Request.Cookies[CookieRequestCultureProvider.DefaultCookieName];
var value = CookieRequestCultureProvider.ParseCookieValue(str);
if (TranslationHelper.TrySwitchCulture(value.UICultures.Select(_ => _.ToString()), opts.Value.SupportedUICultures))
{
await _next(context);
return;
}
}
TranslationHelper.SwitchCulture(opts.Value.DefaultCulture);
await _next(context);
}
public IActionResult SetLanguage([FromForm] string culture, [FromForm] string returnUrl)
{
if (string.IsNullOrEmpty(culture))
{
throw new ArgumentException("culture cannot be empty", culture);
}
if (string.IsNullOrEmpty(returnUrl))
{
throw new ArgumentException("return url must be specified", returnUrl);
}
var cookieName = CookieRequestCultureProvider.DefaultCookieName;
var cookieValue = CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture));
Response.Cookies.Append(
cookieName,
cookieValue,
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
return(LocalRedirect(returnUrl));
}
public virtual async Task <IActionResult> Save(SaveCultureCookieForm form)
{
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
var options = this.Facade.RequestLocalization.CurrentValue;
var comparison = StringComparison.OrdinalIgnoreCase;
if (options.SupportedCultures.Any(culture => string.Equals(culture.Name, form.Culture, comparison)) && options.SupportedUICultures.Any(uiCulture => string.Equals(uiCulture.Name, form.UiCulture, comparison)))
{
this.HttpContext.Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(form.Culture, form.UiCulture)),
new CookieOptions {
MaxAge = TimeSpan.FromDays(365)
}
);
}
return(this.Redirect(await this.GetResolvedReturnUrlAsync(form.ReturnUrl)));
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
if (culture == "en")
{
//IT-ORVAL=>Test-aje-jg->Aje group Paris ENGLISH
_credentials.workspaceID = "f4462a3c-709b-4dbb-993c-7dc4d59b5f4d";
}
else
{
_credentials.workspaceID = "ac6889fe-7f09-4f71-ac0e-4d8850b72d2f";
}
HttpContext.Session.SetObjectAsJson("Watson", _credentials);
return(LocalRedirect(returnUrl));
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
if (_env.IsDevelopment())
{
Response.Cookies.Append(
Constants.LanguageCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
}
else
{
Response.Cookies.Append(
Constants.LanguageCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1), Domain = "." + Constants.AppRootDomain
}
);
}
return(Redirect(returnUrl));
}
public IActionResult ChangeLanguage(string returnUrl)
{
var otherLanguage = CultureInfo.CurrentCulture.Name == "en-US" ? "mk-MK" : "en-US";
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(otherLanguage)),
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(3),
IsEssential = true,
Path = "/",
HttpOnly = false,
SameSite = SameSiteMode.Strict
}
);
Response.Cookies.Append(
"LanguagePrompt",
"false",
new CookieOptions
{
Expires = DateTimeOffset.UtcNow.AddYears(3),
IsEssential = true,
Path = "/",
HttpOnly = false,
SameSite = SameSiteMode.Strict
}
);
if (returnUrl != null)
{
return(RedirectToLocal(returnUrl));
}
return(RedirectToAction(nameof(HomeController.Index)));
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
if (_signInManager.IsSignedIn(User))
{
if (culture == null)
{
culture = UserLogin();
}
else
{
var task = ChangeCulture(culture);
task.Wait();
}
}
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
return(LocalRedirect(returnUrl));
}
/*
* Login page
* **/
public IActionResult Login()
{
if (HttpContext.Session.GetInt32("UserType") != null)
{
return(RedirectToAction("Index", "Home"));
}
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture("ja-JP")),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddDays(1)
}
);
//Load list infomation
var list_info = _db.Infomations.OrderByDescending(p => p.InfomationId);
var langRequest = Request.HttpContext.Features.Get <IRequestCultureFeature>();
var culture = langRequest.RequestCulture.Culture;
ViewBag.Lang = culture.ToString();
ViewBag.Lang = "ja-JP";
return(View(list_info));
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
int lcid;
Int32.TryParse(culture, out lcid);
if (lcid > 0)
{
var cultureInfo = new CultureInfo(lcid);
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(cultureInfo.Name)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
return(LocalRedirect(returnUrl).WithSuccess(LOCALIZATION_SUCCESS_DEFAULT));
}
else
{
return(LocalRedirect(ERROR_URL).WithError(LOCALIZATION_ERROR_DEFAULT));
}
}
public ActionResult RedirectToDefaultLanguage()
{
var culture = CurrentLanguage;
var returnUrl = _returnUrl;
if (culture != "es")
{
culture = "es";
}
if (returnUrl == "")
{
returnUrl = "Index";
}
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
return(RedirectToAction(returnUrl, new { culture }));
}
public async Task <IActionResult> SetCulture(string culture)
{
if (string.IsNullOrEmpty(culture))
{
return(BadRequest(_errorLocalizer[ErrorMessages.MissingDataError]));
}
var user = await _userManager.FindByIdAsync(HttpContext.User.FindFirstValue(JwtClaimTypes.Subject));
if (user == null)
{
return(BadRequest(_errorLocalizer[ErrorMessages.InvalidUserError]));
}
if (user.AdminLocked)
{
return(StatusCode(403, _errorLocalizer[ErrorMessages.LockedAccount, _adminOptions.AdminEmailAddress]));
}
if (culture == "<default>")
{
user.Culture = _localizationOptions.DefaultRequestCulture.Culture.Name;
}
else
{
user.Culture = culture;
}
await _userManager.UpdateAsync(user);
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
});
return(Ok());
}
public IActionResult SetLanguage(string culture, string returnUrl)
{
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions {
Expires = DateTimeOffset.UtcNow.AddYears(1)
}
);
string ReturnUrlReplaced = "";
//return LocalRedirect(returnUrl);
if (returnUrl == "/")
{
ReturnUrlReplaced = "/" + culture;
}
else
{
string[] ArrReturnUrlSplit = returnUrl.Split("/");
ReturnUrlReplaced = returnUrl.Replace(ArrReturnUrlSplit[1], culture);
//var cultureItems = LocOptions.Value.SupportedUICultures;
//foreach (CultureInfo ci in cultureItems)
// {
// // returnUrl.Replace()
// //if (returnUrl.Contains("/" + ci.DisplayName + "/"))
// //{
// //}
//}
}
//return LocalRedirect("~/" +culture + @"/" + returnUrl);
return(LocalRedirect("~" + ReturnUrlReplaced));
}
[HttpPost, AllowAnonymous]
public IActionResult SetLanguage(string culture, string returnUrl)
{
Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
new CookieOptions { Expires = DateTimeOffset.UtcNow.AddYears(1) }
);
return(LocalRedirect(returnUrl));
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("app");
HttpClient httpClient = new HttpClient {
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
};
builder.Services.AddSingleton(httpClient);
builder.Services.AddOptions();
// Register localization services
builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");
// register auth services
builder.Services.AddAuthorizationCore();
builder.Services.AddScoped <IdentityAuthenticationStateProvider>();
builder.Services.AddScoped <AuthenticationStateProvider>(s => s.GetRequiredService <IdentityAuthenticationStateProvider>());
// register scoped core services
builder.Services.AddScoped <SiteState>();
builder.Services.AddScoped <IInstallationService, InstallationService>();
builder.Services.AddScoped <IModuleDefinitionService, ModuleDefinitionService>();
builder.Services.AddScoped <IThemeService, ThemeService>();
builder.Services.AddScoped <IAliasService, AliasService>();
builder.Services.AddScoped <ITenantService, TenantService>();
builder.Services.AddScoped <ISiteService, SiteService>();
builder.Services.AddScoped <IPageService, PageService>();
builder.Services.AddScoped <IModuleService, ModuleService>();
builder.Services.AddScoped <IPageModuleService, PageModuleService>();
builder.Services.AddScoped <IUserService, UserService>();
builder.Services.AddScoped <IProfileService, ProfileService>();
builder.Services.AddScoped <IRoleService, RoleService>();
builder.Services.AddScoped <IUserRoleService, UserRoleService>();
builder.Services.AddScoped <ISettingService, SettingService>();
builder.Services.AddScoped <IPackageService, PackageService>();
builder.Services.AddScoped <ILogService, LogService>();
builder.Services.AddScoped <IJobService, JobService>();
builder.Services.AddScoped <IJobLogService, JobLogService>();
builder.Services.AddScoped <INotificationService, NotificationService>();
builder.Services.AddScoped <IFolderService, FolderService>();
builder.Services.AddScoped <IFileService, FileService>();
builder.Services.AddScoped <ISiteTemplateService, SiteTemplateService>();
builder.Services.AddScoped <ISqlService, SqlService>();
builder.Services.AddScoped <ISystemService, SystemService>();
builder.Services.AddScoped <ILocalizationService, LocalizationService>();
builder.Services.AddScoped <ILanguageService, LanguageService>();
await LoadClientAssemblies(httpClient);
var assemblies = AppDomain.CurrentDomain.GetOqtaneAssemblies();
foreach (var assembly in assemblies)
{
// dynamically register module services
var implementationTypes = assembly.GetInterfaces <IService>();
foreach (var implementationType in implementationTypes)
{
if (implementationType.AssemblyQualifiedName != null)
{
var serviceType = Type.GetType(implementationType.AssemblyQualifiedName.Replace(implementationType.Name, $"I{implementationType.Name}"));
builder.Services.AddScoped(serviceType ?? implementationType, implementationType);
}
}
// register client startup services
var startUps = assembly.GetInstances <IClientStartup>();
foreach (var startup in startUps)
{
startup.ConfigureServices(builder.Services);
}
}
var host = builder.Build();
var jsRuntime = host.Services.GetRequiredService <IJSRuntime>();
var interop = new Interop(jsRuntime);
var localizationCookie = await interop.GetCookie(CookieRequestCultureProvider.DefaultCookieName);
var culture = CookieRequestCultureProvider.ParseCookieValue(localizationCookie).UICultures[0].Value;
var localizationService = host.Services.GetRequiredService <ILocalizationService>();
var cultures = await localizationService.GetCulturesAsync();
if (culture == null || !cultures.Any(c => c.Name.Equals(culture, StringComparison.OrdinalIgnoreCase)))
{
culture = cultures.Single(c => c.IsDefault).Name;
}
SetCulture(culture);
ServiceActivator.Configure(host.Services);
await host.RunAsync();
}
private void SetLocalizationCookie(string culture)
{
HttpContext.Response.Cookies.Append(
CookieRequestCultureProvider.DefaultCookieName,
CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)));
}
