public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("#admin");
var baseUrlConfig = new BaseUrlConfiguration();
builder.Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
builder.Services.AddScoped <BaseUrlConfiguration>(sp => baseUrlConfig);
builder.Services.AddScoped(sp => new HttpClient()
{
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
builder.Services.AddScoped <ToastService>();
builder.Services.AddScoped <HttpService>();
builder.Services.AddBlazoredLocalStorage();
builder.Services.AddAuthorizationCore();
builder.Services.AddScoped <AuthenticationStateProvider, CustomAuthStateProvider>();
builder.Services.AddScoped(sp => (CustomAuthStateProvider)sp.GetRequiredService <AuthenticationStateProvider>());
builder.Services.AddBlazorServices();
builder.Logging.AddConfiguration(builder.Configuration.GetSection("Logging"));
await ClearLocalStorageCache(builder.Services);
await builder.Build().RunAsync();
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("#app");
var baseUrlConfig = new BaseUrlConfiguration();
builder.Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
builder.Services.AddScoped(sp => baseUrlConfig);
// register the HttpClient and HttpService
builder.Services.AddScoped(sp => new HttpClient {
BaseAddress = new Uri(baseUrlConfig.ApiBase)
});
builder.Services.AddScoped <HttpService>();
// register the services
builder.Services.AddScoped <DoctorService>();
builder.Services.AddScoped <ClientService>();
builder.Services.AddScoped <PatientService>();
builder.Services.AddScoped <RoomService>();
builder.Services.AddScoped <AppointmentService>();
builder.Services.AddScoped <AppointmentTypeService>();
builder.Services.AddScoped <FileService>();
builder.Services.AddScoped <ConfigurationService>();
builder.Services.AddScoped <ToastService>();
builder.Services.AddScoped <SchedulerService>();
// register the Telerik services
builder.Services.AddTelerikBlazor();
await builder.Build().RunAsync();
}
public CatalogLookupDataService(HttpClient httpClient,
BaseUrlConfiguration baseUrlConfiguration,
ILogger <CatalogLookupDataService <TLookupData, TReponse> > logger)
{
_httpClient = httpClient;
_logger = logger;
_apiUrl = baseUrlConfiguration.ApiBase;
}
public CatalogTypeService(HttpClient httpClient,
BaseUrlConfiguration baseUrlConfiguration,
ILogger <CatalogTypeService> logger)
{
_httpClient = httpClient;
_logger = logger;
_apiUrl = baseUrlConfiguration.ApiBase;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSignalR();
services.AddMemoryCache();
services.AddSingleton(typeof(IApplicationSettings), typeof(OfficeSettings));
var baseUrlConfig = new BaseUrlConfiguration();
Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
services.AddCors(options =>
{
options.AddPolicy(name: CORS_POLICY,
builder =>
{
builder.WithOrigins(baseUrlConfig.WebBase.Replace("host.docker.internal", "localhost").TrimEnd('/'));
builder.SetIsOriginAllowed(origin => true);
//builder.SetIsOriginAllowed(origin => new Uri(origin).Host == "localhost");
builder.AllowAnyMethod();
builder.AllowAnyHeader();
});
});
services.AddControllers();
var assemblies = new Assembly[]
{
typeof(Startup).Assembly,
typeof(AppDbContext).Assembly,
typeof(Appointment).Assembly
};
services.AddMediatR(assemblies);
services.AddResponseCompression(opts =>
{
opts.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
new[] { "application/octet-stream" });
});
services.AddAutoMapper(typeof(Startup).Assembly);
services.AddSwaggerGenCustom();
// configure messaging
var messagingConfig = Configuration.GetSection("RabbitMq");
var messagingSettings = messagingConfig.Get <RabbitMqConfiguration>();
services.Configure <RabbitMqConfiguration>(messagingConfig);
if (messagingSettings.Enabled)
{
services.AddHostedService <ClinicManagementRabbitMqService>();
services.AddHostedService <VetClinicPublicRabbitMqService>();
}
services.AddSingleton <ObjectPoolProvider, DefaultObjectPoolProvider>();
services.AddSingleton <IPooledObjectPolicy <IModel>, RabbitModelPooledObjectPolicy>();
}
public CatalogItemService(ICatalogBrandService brandService,
ICatalogTypeService typeService,
HttpService httpService,
BaseUrlConfiguration baseUrlConfiguration,
ILogger <CatalogItemService> logger)
{
_brandService = brandService;
_typeService = typeService;
_httpService = httpService;
_logger = logger;
_apiUrl = baseUrlConfiguration.ApiBase;
}
public HttpService(HttpClient httpClient, BaseUrlConfiguration baseUrlConfiguration
, IApplicationInsights applicationInsights)
{
_httpClient = httpClient;
_applicationInsights = applicationInsights
?? throw new ArgumentNullException(nameof(applicationInsights));
_apiUrl = baseUrlConfiguration.ApiBase;
//Activity activity = new Activity("CallAPI");
//activity.Start();
//_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("traceparent", activity.Id);
//_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("tracestate", activity.TraceStateString);
}
public static async Task Main(string[] args)
{
Activity.DefaultIdFormat = ActivityIdFormat.W3C;
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("admin");
var baseUrlConfig = new BaseUrlConfiguration();
builder.Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
builder.Services.AddScoped <BaseUrlConfiguration>(sp => baseUrlConfig);
builder.Services.AddScoped(sp => new HttpClient()
{
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
//Application Insights
builder.Services.AddBlazorApplicationInsights(async applicationInsights =>
{
var telemetryItem = new TelemetryItem()
{
Tags = new Dictionary <string, object>()
{
{ "ai.cloud.role", "SPA" },
{ "ai.cloud.roleInstance", "Blazor Wasm" },
}
};
await applicationInsights.AddTelemetryInitializer(telemetryItem);
});
builder.Services.AddScoped <HttpService>();
builder.Services.AddScoped <ILocalStorageService, LocalStorageService>();
builder.Services.AddAuthorizationCore();
builder.Services.AddScoped <AuthenticationStateProvider, CustomAuthStateProvider>();
builder.Services.AddScoped(sp => (CustomAuthStateProvider)sp.GetRequiredService <AuthenticationStateProvider>());
builder.Services.AddBlazorServices();
builder.Logging.AddConfiguration(builder.Configuration.GetSection("Logging"));
await ClearLocalStorageCache(builder.Services);
builder.Build().RunAsync();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSignalR();
services.AddMemoryCache();
services.AddSingleton(typeof(IApplicationSettings), typeof(OfficeSettings));
var baseUrlConfig = new BaseUrlConfiguration();
Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
services.AddCors(options =>
{
options.AddPolicy(name: CORS_POLICY,
builder =>
{
builder.WithOrigins(baseUrlConfig.WebBase.Replace("host.docker.internal", "localhost").TrimEnd('/'));
builder.SetIsOriginAllowed(origin => new Uri(origin).Host == "localhost");
builder.AllowAnyMethod();
builder.AllowAnyHeader();
});
});
services.AddControllers();
services.AddMediatR(typeof(Startup).Assembly);
services.AddResponseCompression(opts =>
{
opts.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
new[] { "application/octet-stream" });
});
services.AddAutoMapper(typeof(Startup).Assembly);
services.AddSwaggerGenCustom();
// RabbitMQ service must be running on port 5673
//
services.AddHostedService <RabbitMQService>();
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Information()
.WriteTo.Console()
.WriteTo.File(new Serilog.Formatting.Compact.RenderedCompactJsonFormatter(), "../../logs/blazoradmin.log")
.CreateLogger();
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("admin");
var baseUrlConfig = new BaseUrlConfiguration();
builder.Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
builder.Services.AddScoped <BaseUrlConfiguration>(sp => baseUrlConfig);
builder.Services.AddScoped(sp => new HttpClient()
{
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
builder.Services.AddScoped <HttpService>();
builder.Services.AddScoped <ILocalStorageService, LocalStorageService>();
builder.Services.AddAuthorizationCore();
builder.Services.AddScoped <AuthenticationStateProvider, CustomAuthStateProvider>();
builder.Services.AddScoped(sp => (CustomAuthStateProvider)sp.GetRequiredService <AuthenticationStateProvider>());
builder.Services.AddBlazorServices();
builder.Logging.AddConfiguration(builder.Configuration.GetSection("Logging"));
await ClearLocalStorageCache(builder.Services);
builder.Build().RunAsync();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var baseUrlConfig = new BaseUrlConfiguration();
Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
GlobalConstants.ApiBase = baseUrlConfig.ApiBase;
GlobalConstants.IdentityServerBase = baseUrlConfig.IdentityServerBase;
services.AddWebServices(Configuration);
services.AddControllersWithViews();
JwtSecurityTokenHandler.DefaultMapInboundClaims = false;
services.AddAuthentication(options =>
{
options.DefaultScheme = "Cookies";
options.DefaultChallengeScheme = "oidc";
})
.AddCookie("Cookies")
.AddOpenIdConnect("oidc", options =>
{
options.Authority = "https://localhost:5001";
options.GetClaimsFromUserInfoEndpoint = true;
options.ClientId = "mvc";
options.ClientSecret = "secret";
options.ResponseType = "code";
options.SignedOutRedirectUri = "https://localhost:44368";
options.ClaimActions.MapJsonKey("role", "role", "role");
options.TokenValidationParameters.NameClaimType = "name";
options.TokenValidationParameters.RoleClaimType = "role";
options.Scope.Add("api1");
options.SaveTokens = true;
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <AppIdentityDbContext>()
.AddDefaultTokenProviders();
services.AddScoped(typeof(IAsyncRepository <>), typeof(EfRepository <>));
services.Configure <CatalogSettings>(Configuration);
services.AddSingleton <IUriComposer>(new UriComposer(Configuration.Get <CatalogSettings>()));
services.AddScoped(typeof(IAppLogger <>), typeof(LoggerAdapter <>));
services.AddScoped <ITokenClaimsService, IdentityTokenClaimService>();
var baseUrlConfig = new BaseUrlConfiguration();
Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
services.AddMemoryCache();
var key = Encoding.ASCII.GetBytes(AuthorizationConstants.JWT_SECRET_KEY);
services.AddAuthentication(config =>
{
config.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(config =>
{
config.RequireHttpsMetadata = false;
config.SaveToken = true;
config.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
});
services.AddCors(options =>
{
options.AddPolicy(name: CORS_POLICY,
builder =>
{
builder.WithOrigins(baseUrlConfig.WebBase.Replace("host.docker.internal", "localhost").TrimEnd('/'));
builder.AllowAnyMethod();
builder.AllowAnyHeader();
});
});
services.AddControllers();
services.AddMediatR(typeof(CatalogItem).Assembly);
services.AddAutoMapper(typeof(Startup).Assembly);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "My API", Version = "v1"
});
c.EnableAnnotations();
c.SchemaFilter <CustomSchemaFilters>();
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = @"JWT Authorization header using the Bearer scheme. \r\n\r\n
Enter 'Bearer' [space] and then your token in the text input below.
\r\n\r\nExample: 'Bearer 12345abcdef'",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
new List <string>()
}
});
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCookieSettings();
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie(options =>
{
options.Cookie.HttpOnly = true;
options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
options.Cookie.SameSite = SameSiteMode.Lax;
});
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddDefaultUI()
.AddEntityFrameworkStores <AppIdentityDbContext>()
.AddDefaultTokenProviders();
services.AddScoped <ITokenClaimsService, IdentityTokenClaimService>();
services.AddCoreServices(Configuration);
services.AddWebServices(Configuration);
// Add memory cache services
services.AddMemoryCache();
services.AddRouting(options =>
{
// Replace the type and the name used to refer to it with your own
// IOutboundParameterTransformer implementation
options.ConstraintMap["slugify"] = typeof(SlugifyParameterTransformer);
});
services.AddMvc(options =>
{
options.Conventions.Add(new RouteTokenTransformerConvention(
new SlugifyParameterTransformer()));
});
services.AddControllersWithViews();
services.AddRazorPages(options =>
{
options.Conventions.AuthorizePage("/Basket/Checkout");
});
services.AddHttpContextAccessor();
services.AddHealthChecks();
services.Configure <ServiceConfig>(config =>
{
config.Services = new List <ServiceDescriptor>(services);
config.Path = "/allservices";
});
var baseUrlConfig = new BaseUrlConfiguration();
Configuration.Bind(BaseUrlConfiguration.CONFIG_NAME, baseUrlConfig);
services.AddScoped <BaseUrlConfiguration>(sp => baseUrlConfig);
// Blazor Admin Required Services for Prerendering
services.AddScoped <HttpClient>(s => new HttpClient
{
BaseAddress = new Uri(baseUrlConfig.WebBase)
});
// add blazor services
services.AddBlazoredLocalStorage();
services.AddServerSideBlazor();
services.AddScoped <HttpService>();
services.AddBlazorServices();
_services = services; // used to debug registered services
}
public ApiHealthCheck(IOptions <BaseUrlConfiguration> baseUrlConfiguration)
{
_baseUrlConfiguration = baseUrlConfiguration.Value;
}
public HttpService(HttpClient httpClient, BaseUrlConfiguration baseUrlConfiguration, ToastService toastService)
{
_httpClient = httpClient;
_toastService = toastService;
_apiUrl = baseUrlConfiguration.ApiBase;
}
public ApiHealthCheck(BaseUrlConfiguration baseUrlConfiguration)
{
_baseUrlConfiguration = baseUrlConfiguration;
}
public HttpService(HttpClient httpClient, BaseUrlConfiguration baseUrlConfiguration)
{
_httpClient = httpClient;
_apiUrl = baseUrlConfiguration.ApiBase;
}
