//public static void Main(string[] args)
//{
// CreateHostBuilder(args).Build().Run();
//}
//public static IHostBuilder CreateHostBuilder(string[] args) =>
// Host.CreateDefaultBuilder(args)
// .ConfigureWebHostDefaults(webBuilder =>
// {
// webBuilder.UseStartup<Startup>();
// });
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
context.Database.Migrate();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedAsync(userManager);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var identityContext = services.GetRequiredService <ApplicationDbContext>();
identityContext.Database.Migrate();
//Populate Data
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var RolManager = services.GetRequiredService <RoleManager <ApplicationRol> >();
await ApplicationDbContextSeed.SeedAsync(userManager, RolManager);
await ApplicationDbContextSeed.SeedMainDataAsync(identityContext);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or initializing the database.");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// This will create a new scope for the logger factory and the store context objects.
using (var scope = host.Services.CreateScope())
{
// This will get the necessary services from the scope.
var services = scope.ServiceProvider;
// This will create a new instance of the logger factory service.
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
// This will create a new instance of the application db context service.
var applicationDbContext = services.GetRequiredService <ApplicationDbContext>();
// This will update the database with the latest code first migration of the dw_morgan database.
await applicationDbContext.Database.MigrateAsync();
// This will seed the database with initial data.
await ApplicationDbContextSeed.SeedAsync(applicationDbContext, loggerFactory);
}
catch (Exception ex)
{
// This will create a new logger instance for the program class.
var logger = loggerFactory.CreateLogger <Program>();
// This will log the details of the exception thrown during the database migration.
logger.LogError(ex, "An error occurred during database migration.");
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
await ApplicationDbContextSeed.SeedScoresAsync(context);
await ApplicationDbContextSeed.SeedStarshipsAsync(context);
await ApplicationDbContextSeed.SeedCrewMembersAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var env = services.GetService <IWebHostEnvironment>();
var context = services.GetRequiredService <ClubsContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
await ApplicationDbContextSeed.SeedAsync(context);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
//Seed Default Users
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedEssentialsAsync(userManager, roleManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IApiVersionDescriptionProvider provider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseSwagger();
app.UseSwaggerUI(options => {
foreach (var desc in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint($"/swagger/{desc.GroupName}/swagger.json", desc.GroupName.ToUpperInvariant());
}
options.RoutePrefix = "";
});
app.UseRouting();
app.UseCors(x => x.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
ApplicationDbContextSeed.SeedAsync(app).Wait();
}
/// <summary>
/// Starts the system and seeds the database
/// Runs first when the system launches
/// </summary>
/// <param name="args"></param>
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
// Checking environments
var env = services.GetRequiredService <IWebHostEnvironment>();
if (!env.IsDevelopment() && !env.IsStaging() && !env.IsProduction())
{
// Not any of the supported environments
Environment.Exit(1);
}
// TODO: Make enviroment specific database seeding
// Database seeding
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.MinimumLevel.Override("SerilogDemo", LogEventLevel.Information)
.WriteTo.File("Logs/Example.txt",
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}")
.CreateLogger();
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
//Seed Default Users
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedEssentialsAsync(userManager, roleManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ApplicationDbContextSeed seeder)
{
var swaggerOptions = new SwaggerOptions();
Configuration.GetSection(nameof(SwaggerOptions)).Bind(swaggerOptions);
if (env.IsDevelopment())
{
seeder.Seed();
app.UseDeveloperExceptionPage();
app.UseSwagger(option => { option.RouteTemplate = swaggerOptions.JsonRoute; });
app.UseSwaggerUI(option => option.SwaggerEndpoint(swaggerOptions.UiEndpoint, swaggerOptions.Description));
}
app.UseMiddleware <CustomExceptionHandlerMiddleware>();
app.UseCustomHealthChecks();
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseRouting();
app.UseCors("Open");
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
private static async Task SeedDatabase(IWebHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogInformation("Seeding database...");
try
{
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
if (userManager.Users.Any() || roleManager.Roles.Any())
{
logger.LogDebug("User/Role data already exists.");
}
else
{
await ApplicationDbContextSeed.SeedAsync(userManager, roleManager);
logger.LogDebug("Populated AppIdentityDbContext test data.");
}
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
await context.Database.MigrateAsync();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "Ocorreu um erro durante a migração ou propagação do banco de dados.");
throw;
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
try
{
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultRolesAsync(roleManager);
await ApplicationDbContextSeed.SeedDefaultAdministratorAsync(userManager);
}
catch (Exception exception)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(exception, "an error occurred while seeding the database");
throw;
}
await host.RunAsync();
}
protected async override void OnStartup(StartupEventArgs e)
{
IServiceProvider provider = CreateServiceProvider();
try
{
ApplicationDbContext context = provider.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
await ApplicationDbContextSeed.SeedDefaultData(context);
}
catch (Exception ex)
{
MessageBox.Show($"An error occurred while migrating or seeding the database.\n{ex.Message}", "Error");
throw;
}
MainWindow window = new MainWindow();
window.DataContext = provider.GetRequiredService <MainWindowViewModel>();
window.Show();
base.OnStartup(e);
}
public async static Task Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var config = services.GetRequiredService <IConfiguration>();
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(config)
.CreateLogger();
try
{
var dbContext = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
dbContext.Database.Migrate();
await ApplicationDbContextSeed.SeedDataAsync(dbContext);
await ApplicationDbContextSeed.SeedIdentityAsync(userManager);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured while migrating or seeding the database");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var logger = NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
// var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
//logger.LogError(ex, "An error occurred while migrating or seeding the database.");
logger.Error(ex, "An error occurred while migrating or seeding the database.");
throw;
}
}
await host.RunAsync();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database." + ex.Message + ex.StackTrace);
throw;
}
}
await host.RunAsync();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var identityContext = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <ApplicationRole> >();
identityContext.Database.Migrate();
var financialOrganizerContext = services.GetRequiredService <FODbContext>();
financialOrganizerContext.Database.Migrate();
ApplicationDbContextSeed.SeedAsync(userManager, roleManager).Wait();
FODbContextSeed.SeedAsync(financialOrganizerContext).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
await context.Database.MigrateAsync();
await ApplicationDbContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
/// <summary>
/// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
/// </summary>
/// <param name="app"></param>
/// <param name="env"></param>
/// <param name="context"></param>
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ApplicationDbContext context)
{
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Api Clean Code");
});
if (env.IsDevelopment())
{
ApplicationDbContextSeed.Seed(context);
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
// UserManager
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
// // Adding Roles
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
context.Database.Migrate();
// Apply Seed
await ApplicationDbContextSeed.SeedData(context, userManager, roleManager);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error ocurring during migration");
}
}
await host.RunAsync();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
context.Database.Migrate();
ApplicationDbContextSeed.Seed(context);
}
catch (Exception ex)
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
catch (Exception ex)
{
throw;
}
}
await host.RunAsync();
}
/// <summary>
/// Seed data
/// </summary>
/// <returns></returns>
public override Task InvokeSeedAsync(IServiceProvider services)
{
var seeder = new ApplicationDbContextSeed();
seeder.SeedAsync(this, services).Wait();
return(Task.CompletedTask);
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var serivces = scope.ServiceProvider;
try
{
var dbContext = serivces.GetRequiredService <ApplicationDbContext>();
dbContext.Database.Migrate();
var userManager = serivces.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = serivces.GetRequiredService <RoleManager <IdentityRole> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager, roleManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(dbContext);
}
catch (Exception ex)
{
var logger = serivces.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "Error seeding the database");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args)
.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var appContext = services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.SeedAsync(appContext, loggerFactory)
.Wait();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
AppIdentityDbContextSeed.SeedAsync(userManager).Wait();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public static async Task <bool> MigrateDB(IHost host)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var logger = scope.ServiceProvider.GetRequiredService <ILogger <Program> >();
try
{
var context = services.GetRequiredService <ApplicationDbContext>();
var env = services.GetRequiredService <IWebHostEnvironment>();
context.Database.Migrate();
await ApplicationDbContextSeed.SeedDbAsync(context);
logger.LogInformation("Migrating db");
return(true);
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred while migrating or seeding the database.");
return(false);
}
}
public static async Task Main(string[] args)
{
var host = BuildWebHost(args);
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var config = builder.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <ApplicationDbContext>();
if (context.Database.IsSqlServer())
{
context.Database.Migrate();
}
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
await ApplicationDbContextSeed.SeedDefaultUserAsync(userManager);
await ApplicationDbContextSeed.SeedSampleDataAsync(context);
}
host.Run();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseSession();
app.UseAuthentication();
var supportedCultures = new List <CultureInfo>
{
new CultureInfo("en-US")
{
NumberFormat = { CurrencySymbol = CultureInfo.CurrentCulture.NumberFormat.CurrencySymbol + " " }
}
};
var supportedCultures2 = new List <CultureInfo>
{
new CultureInfo("tr-TR")
{
NumberFormat = { CurrencySymbol = CultureInfo.CurrentCulture.NumberFormat.CurrencySymbol + " " }
}
};
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("en-US"),
// Formatting numbers, dates, etc.
SupportedCultures = supportedCultures,
// UI strings that we have localized.
SupportedUICultures = supportedCultures2
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "areaRoute",
template: "{area:exists}/{controller=Home}/{action=Index}"
);
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
ApplicationDbContextSeed.Seed(app); // Test verileri oluşturmak için kullanılır.
ApplicationDbContextSeed.CreateRootAdmin(app.ApplicationServices, Configuration, app).Wait(); // User yaratmak için kullanılır
}
public App()
{
_host = CreateHostBuilder().Build();
var loggerFactory = _host.Services.GetRequiredService <ILoggerFactory>();
var catalogContext = _host.Services.GetRequiredService <ApplicationDbContext>();
ApplicationDbContextSeed.Seed(catalogContext, loggerFactory);
}
