public JsonStringLocalizerFactory(
IWebAssemblyHostEnvironment env,
IOptions <JsonLocalizationOptions> localizationOptions = null)
{
_env = env;
_localizationOptions = localizationOptions ?? throw new ArgumentNullException(nameof(localizationOptions));
}
private static void ConfigureHttpClient(ServiceConfigurationContext context, IWebAssemblyHostEnvironment environment)
{
context.Services.AddTransient(sp => new HttpClient
{
BaseAddress = new Uri(environment.BaseAddress)
});
}
public Startup(IConfiguration configuration, Uri baseAddress, IWebAssemblyHostEnvironment hostEnvironment, BlazorWasmPrerenderingOptions prerenderingOptions)
{
this.Configuration = configuration;
this.BaseAddress = baseAddress;
this.HostEnvironment = hostEnvironment;
this.PrerenderingOptions = prerenderingOptions;
}
public StaticWebAppsAuthenticationStateProvider(IConfiguration config, IWebAssemblyHostEnvironment environment)
{
this.config = config;
this.http = new HttpClient {
BaseAddress = new Uri(environment.BaseAddress)
};
}
public static void ConfigureServices(IServiceCollection services, IWebAssemblyHostEnvironment environment)
{
services.AddHttpClient("CrazyFramework.API", (sp, client) =>
{
client.BaseAddress = new Uri(environment.BaseAddress);
client.EnableIntercept(sp);
})
.AddHttpMessageHandler <BaseAddressAuthorizationMessageHandler>();
// Supply HttpClient instances that include access tokens when making requests to the server project
services.AddTransient(sp => sp.GetRequiredService <IHttpClientFactory>().CreateClient("CrazyFramework.API"));
services.AddTransient <IProductService, ProductService>();
services.AddTransient <IJobTitleService, JobTitleService>();
services.AddApiAuthorization()
.AddAccountClaimsPrincipalFactory <CustomUserFactory>();
services.AddSingleton <AppState>();
services.AddSingleton <NotificationService>();
services.AddLoadingBar();
services.AddValidatorsFromAssemblyContaining <Program>();
services
.AddBlazorise(options =>
{
options.ChangeTextOnKeyPress = true;
})
.AddBootstrapProviders()
.AddFontAwesomeIcons();
}
public ConfigurationService(HttpClient httpClient, IWebAssemblyHostEnvironment webAssemblyHostEnvironment)
{
HttpClient = httpClient;
WebAssemblyHostEnvironment = webAssemblyHostEnvironment;
//GetConfiguration();
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
IConfiguration config = builder.Configuration;
IWebAssemblyHostEnvironment env = builder.HostEnvironment;
builder.Logging.Services.AddLogging(logger => {
logger.SetMinimumLevel(LogLevel.Trace);
});
builder.Services.AddSingleton <AppState>();
builder.Services.AddTransient <HttpClient>();
builder.Services.AddTransient <WeatherForcastService>();
builder.Services.AddTransient <StarWarsPeopleService>();
builder.RootComponents.Add <App>("app");
var host = builder.Build();
var logger = host.Services.GetRequiredService <ILogger <Program> >();
logger.LogInformation("Starting Program...");
await builder.Build().RunAsync();
}
public CustomAuthenticationStateProvider(IConfiguration config, IWebAssemblyHostEnvironment environment)
{
_config = config;
http = new HttpClient {
BaseAddress = new Uri(environment.BaseAddress)
};
}
public static void ConfigureServices(IServiceCollection services, IWebAssemblyHostEnvironment environment)
{
services.AddHttpClient("CrazyFramework.API", (sp, client) =>
{
client.BaseAddress = new Uri(environment.BaseAddress);
client.EnableIntercept(sp);
})
.AddHttpMessageHandler <BaseAddressAuthorizationMessageHandler>();
// Supply HttpClient instances that include access tokens when making requests to the server project
services.AddTransient(sp => sp.GetRequiredService <IHttpClientFactory>().CreateClient("CrazyFramework.API"));
services.AddTransient <IProductService, ProductService>();
services.AddApiAuthorization()
.AddAccountClaimsPrincipalFactory <CustomUserFactory>();
services.AddSingleton <AppState>();
services.AddLoadingBar();
services.AddMatToaster(config =>
{
config.Position = MatToastPosition.BottomRight;
config.PreventDuplicates = true;
config.NewestOnTop = true;
config.ShowCloseButton = true;
config.MaximumOpacity = 95;
config.VisibleStateDuration = 3000;
});
services.AddValidatorsFromAssemblyContaining <Program>();
}
private static void ConfigureServices(IServiceCollection services, IWebAssemblyHostEnvironment hostEnvironment)
{
services.AddTransient(provider =>
{
return(provider.GetRequiredService <IConfiguration>().Get <AppConfiguration>());
});
services.AddApiService <ITasksService, ApiTaskService>();
}
public ProductionOnlyAnalytics(GoogleAnalyticsStrategy analytics,
IWebAssemblyHostEnvironment hostEnvironment, string trackingId)
{
this.analytics = analytics;
this.hostEnvironment = hostEnvironment;
this.analytics.Configure(trackingId);
}
public WeatherForcastService(IConfiguration config, IWebAssemblyHostEnvironment env, ILogger <WeatherForcastService> logger, HttpClient http)
{
_config = config;
_logger = logger;
_http = http;
_http.BaseAddress = new Uri(env.BaseAddress);
_logger.LogInformation("Create StarWarsPeopleService");
}
public StarshipApi(HttpClient client, IWebAssemblyHostEnvironment hostEnvironment)
{
// Note Blazor environment. For more details see
// https://docs.microsoft.com/en-us/aspnet/core/blazor/fundamentals/environments?view=aspnetcore-5.0
var apiUrl = hostEnvironment.IsDevelopment() ? "http://localhost:5000/api/" : "https://starshipapi.azurewebsites.net/api/";
client.BaseAddress = new Uri(apiUrl);
Client = client;
}
/// <summary>
/// Checks if the current hosting environment name is <c>Production</c>.
/// </summary>
/// <param name="hostingEnvironment">An instance of <see cref="IWebAssemblyHostEnvironment"/>.</param>
/// <returns>True if the environment name is <c>Production</c>, otherwise false.</returns>
public static bool IsProduction(this IWebAssemblyHostEnvironment hostingEnvironment)
{
if (hostingEnvironment == null)
{
throw new ArgumentNullException(nameof(hostingEnvironment));
}
return(hostingEnvironment.IsEnvironment("Production"));
}
public static void AddServices(this IServiceCollection services, IWebAssemblyHostEnvironment HostEnvironment)
{
services.AddScoped(sp => new HttpClient {
BaseAddress = new Uri(HostEnvironment.BaseAddress)
});
services.AddFluxor(options =>
{
options.ScanAssemblies(Assembly.GetExecutingAssembly());
options.UseReduxDevTools();
});
}
public SecurityService(NavigationManager navigationManager,
AuthenticationStateProvider authenticationStateProvider,
HttpClient httpClient, GlobalsService globals,
IWebAssemblyHostEnvironment env)
{
this.httpClient = httpClient;
this.baseUri = new Uri($"{navigationManager.BaseUri}auth/");
this.navigationManager = navigationManager;
this.authenticationStateProvider = authenticationStateProvider;
this.globals = globals;
this.env = env;
}
public SamDataServiceRemote(HttpClient httpClient, IWebAssemblyHostEnvironment env)
{
hc = httpClient;
if (env.IsProduction())
{
baseUrl = baseProdUrl;
}
else
{
baseUrl = baseDevUrl;
}
}
/// <summary>
/// Compares the current hosting environment name against the specified value.
/// </summary>
/// <param name="hostingEnvironment">An instance of <see cref="IWebAssemblyHostEnvironment"/>.</param>
/// <param name="environmentName">Environment name to validate against.</param>
/// <returns>True if the specified name is the same as the current environment, otherwise false.</returns>
public static bool IsEnvironment(
this IWebAssemblyHostEnvironment hostingEnvironment,
string environmentName)
{
if (hostingEnvironment == null)
{
throw new ArgumentNullException(nameof(hostingEnvironment));
}
return(string.Equals(
hostingEnvironment.Environment,
environmentName,
StringComparison.OrdinalIgnoreCase));
}
public void ConfigureServices(IServiceCollection services, IWebAssemblyHostEnvironment hostEnvironment)
{
services.AddAuthGrpcClient <Account.AccountClient>();
services.AddAuthGrpcClient <ChatRoom.ChatRoomClient>();
services.AddScoped <AuthenticationStateProvider, IdentityAuthenticationStateProvider>();
services.AddBlazoredLocalStorage();
services.AddAuthorizationCore();
services.AddScoped <AuthorizeApi>();
services.AddLocalization(options => options.ResourcesPath = "Resources");
}
public AppAuthenticationStateProvider(HttpClient hostClient,
NavigationManager navigationManager,
AppSettings appSettings,
IJSRuntime jsRuntime,
IWebAssemblyHostEnvironment hostEnvironment,
ISecurityClientService securityClientService)
{
_hostClient = hostClient;
_navigationManager = navigationManager;
_appSettings = appSettings;
_jsRuntime = jsRuntime;
_hostEnvironment = hostEnvironment;
_securityClientService = securityClientService;
}
public static async Task Main(string[] args)
{
WebAssemblyHostBuilder builder = WebAssemblyHostBuilder.CreateDefault(args);
WebAssemblyHostConfiguration configuration = builder.Configuration;
IWebAssemblyHostEnvironment hostEnvironment = builder.HostEnvironment;
builder.RootComponents.Add <App>("app");
AddSerilog(hostEnvironment);
builder.Services.ConfigureServices(configuration, hostEnvironment)
.ConfigureApplicationServices(configuration);
await builder.Build().RunAsync();
}
public static void ConfigureServices(IServiceCollection services, IWebAssemblyHostEnvironment hostEnvironment)
{
services.AddSingleton(provider =>
{
var config = provider.GetService <IConfiguration>();
return(config.GetSection("App").Get <AppConfiguration>());
});
// Temporary cache
services.AddMemoryCache();
// More permanent cache
services.AddBlazoredLocalStorage();
services.AddTransient <PersonGroupsViewModel>();
services.AddTransient <PersonGroupsPersonViewModel>();
services.AddTransient <PersonViewModel>();
services.AddTransient <DetectViewModel>();
services.AddTransient <TextViewModel>();
services.AddTransient <CustomFormsViewModel>();
// Repos
services.AddTransient <IProfilesRepository, ProfilesRepository>();
services.AddTransient <IProfileMigrations, ProfileMigrations>();
services.AddMediatR(typeof(ExecuteCognitiveServicesCommand));
// MatBlazor
services.AddScoped <AppState>();
services.AddLoadingBar();
services.AddMatToaster(config =>
{
config.Position = MatToastPosition.BottomRight;
config.PreventDuplicates = true;
config.NewestOnTop = true;
config.ShowCloseButton = true;
config.MaximumOpacity = 95;
config.VisibleStateDuration = 3000;
});
services.AddHttpClient();
services.AddSingleton(new HttpClient {
BaseAddress = new Uri(hostEnvironment.BaseAddress)
});;
services.AddFileReaderService(options => options.UseWasmSharedBuffer = true);
}
public static void AddServices(this IServiceCollection services, IWebAssemblyHostEnvironment env)
{
services.AddSingleton(sp => new HttpClient {
BaseAddress = new Uri(env.IsDevelopment() ? "http://localhost:5000/" : env.BaseAddress)
});
// services.AddSingleton(sp => new UowService());
services.AddSingleton <UowService>();
services.AddSingleton <MyConsole>();
services.AddMatToaster(config =>
{
config.Position = MatToastPosition.TopRight;
config.PreventDuplicates = true;
config.NewestOnTop = true;
config.ShowCloseButton = true;
// config.MaximumOpacity = 95;
config.VisibleStateDuration = 3000;
});
}
private static void AddSerilog(IWebAssemblyHostEnvironment hostEnvironment)
{
var loggerConfiguration = new LoggerConfiguration()
.WriteTo.BrowserConsole()
.Enrich.FromLogContext()
.Enrich.WithExceptionDetails();
if (hostEnvironment.IsDevelopment())
{
loggerConfiguration.MinimumLevel.Override("Microsoft", LogEventLevel.Verbose)
.MinimumLevel.Verbose();
}
else
{
loggerConfiguration.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.MinimumLevel.Information();
}
Log.Logger = loggerConfiguration.CreateLogger();
Log.Logger.Information("Initializing {Program} (env: {Environment})", typeof(Program).FullName, hostEnvironment.Environment);
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("app");
IConfiguration config = builder.Configuration;
IWebAssemblyHostEnvironment env = builder.HostEnvironment;
builder.Logging.SetMinimumLevel(LogLevel.Trace).AddFilter("Microsoft", LogLevel.Warning);
builder.Logging.Services.AddLogging();
var host = builder.Build();
var logger = host.Services.GetRequiredService <ILogger <Program> >();
logger.LogInformation("Starting Program...");
builder.Services.AddTransient(sp => new HttpClient {
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
//----------------------------------------------------------------------
// Added for Custom Authentication
//----------------------------------------------------------------------
builder.Services.AddBlazoredLocalStorage();
builder.Services.AddAuthorizationCore();
builder.Services.AddScoped <AuthenticationStateProvider, ApiAuthenticationStateProvider>();
builder.Services.AddScoped <IAuthService, AuthService>();
//----------------------------------------------------------------------
builder.Services.AddBrowserLibraryExtensions();
await builder.Build().RunAsync();
}
public HubConnectionService(IWebAssemblyHostEnvironment hostEnvironment)
{
this.hostEnvironment = hostEnvironment;
}
public AuthorizedHttpClientFactory(IWebAssemblyHostEnvironment env, IAuthService authService)
{
this.env = env;
this.authService = authService;
}
public OidcService(IConfiguration configuration, IWebAssemblyHostEnvironment environment, NavigationManager navigation)
{
this.configuration = configuration.GetSection("AzureB2C");
this.environment = environment;
this.navigation = navigation;
}
public EnvironmentNameAccessor(IWebAssemblyHostEnvironment webHostEnvironment)
{
EnvironmentName = webHostEnvironment.Environment;
}
public HttpService(IWebAssemblyHostEnvironment hostEnvironment)
{
_baseAddress = hostEnvironment.BaseAddress;
}
