public static void Main(string[] args)
{
/*
* var host = CreateHostBuilder(args).Build();
* host.MigrateDatabase<OrderContext>((context, services) =>
* {
* var logger = services.GetService<ILogger<OrderContextSeed>>();
* OrderContextSeed
* .SeedAsync(context, logger)
* .Wait();
* });
* host.Run();
*/
CreateHostBuilder(args)
.Build()
.MigrateDatabase <OrderContext>((context, services) =>
{
var logger = services.GetService <ILogger <OrderContextSeed> >();
OrderContextSeed
.SeedAsync(context, logger)
.Wait();
})
.Run();
}
private static async Task Execute(IServiceProvider provider)
{
using (var scope = provider.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var aspnetRunContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(aspnetRunContext).Wait();
}
catch (Exception exception)
{
LogHelper.Error("An error occurred seeding the DB.", exception);
}
}
var client = provider.GetRequiredService <IBusClient>();
await client.ReceiveAsync <BasketCheckoutEvent>(ContextNames.Queue.OrderCheckout, ContextNames.Exchange.BasketCheckout,
async message =>
{
using var scope = provider.CreateScope();
var consumer = scope.ServiceProvider.GetRequiredService <BasketCheckoutConsumer>();
await consumer.Execute(message);
});
}
public static void MigrateDB(this IServiceProvider svcProvider)
{
var services = svcProvider.CreateScope().ServiceProvider;
var dbContext = services.GetRequiredService <OrderContext>();
dbContext.Database.Migrate();
OrderContextSeed.SeedAsync(dbContext);
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
host.MigrateDataase <OrderContext>((context, service) =>
{
var logger = service.GetService <ILogger <OrderContextSeed> >();
OrderContextSeed.SeedAsync(context, logger).Wait();
});
host.Run();
}
public static void Main(string[] args)
{
CreateHostBuilder(args)
.Build()
.MigrateDatabase <OrderContext>((context, services) =>
{
var logger = services.GetRequiredService <ILogger <OrderContextSeed> >();
OrderContextSeed.SeedAsync(context, logger).Wait();
})
.Run();
}
private static async void SeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var ordersContext = services.GetRequiredService <OrdersContext>();
await OrderContextSeed.SeedAsync(ordersContext, loggerFactory);
}
catch (System.Exception ex)
{
loggerFactory.CreateLogger <Program>().LogError(ex.Message);
}
}
}
private static void CreateAndSeedDatabase(IHost host)
{
using IServiceScope scope = host.Services.CreateScope();
IServiceProvider services = scope.ServiceProvider;
ILoggerFactory loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
OrderContext orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory).GetAwaiter().GetResult();
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e.Message);
}
}
private static void CreateAndSeedDb(IHost host)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory).Wait();
}
catch (Exception exception)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(exception, "An error occurred seeding the DB.");
}
}
private static async Task CreateAndSeedDatabase(IHost host)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
await OrderContextSeed.SeedAsync(orderContext, loggerFactory);
}
catch (Exception exception)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(exception.Message);
}
}
private static void CreateOrderDb(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedDataAsync(orderContext, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError($"Exception Occured in API: {ex.Message}");
}
}
}
private static void CreateAndSeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
using (var appContext = scope.ServiceProvider.GetRequiredService <OrderContext>())
{
try
{
OrderContextSeed.SeedAsync(appContext).Wait();
}
catch (Exception ex)
{
//Log errors or do anything you think it's needed
throw;
}
}
}
}
private async static Task CreateAndSeedDatabase(IHost host)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <OrderContext>();
await OrderContextSeed.SeedAsync(context, loggerFactory);
}catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e, "Failed to seed order data");
throw e;
}
}
private static void CreateAndSeedDatabase(IHost host)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
var logerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
OrderContextSeed.SeedAsync(orderContext, logerFactory);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
catch (Exception ex)
{
var logger = logerFactory.CreateLogger <Program>();
logger.LogError(ex.Message);
}
}
private static void CreateAndSeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(string.Format("{0} - {1}", ex.Message, ex.StackTrace));
}
}
}
private static void CreateAndSeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
//Get logger factory so that we can use it.
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory);
}
catch (Exception exception)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(exception.Message);
throw;
}
}
}
private static void CreateAndSeedDatabase(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory).Wait(); // Wait here is important
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e.Message);
throw e;
}
}
}
private static void CreateAndSeedDatabase(IHost host)
{
// scope - get all services
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex.Message);
}
}
}
private static void CreateAndSeedDatabase(IHost host)
{
// Create scope from host to get service provider
using var scope = host.Services.CreateScope();
IServiceProvider services = scope.ServiceProvider;
// create logger factory
ILoggerFactory loggerFactory = new LoggerFactory();
// ILogger<Program> loggerFactory = services.GetRequiredService<ILogger<Program>>();
try
{
OrderContext orderContext = services.GetRequiredService <OrderContext>();
OrderContextSeed.SeedAsync(orderContext, loggerFactory);
}
catch (Exception e)
{
ILogger <Program> logger = loggerFactory.CreateLogger <Program>();
logger.LogError(e.Message);
}
}
public static IHost MigrateDatabase(this IHost host)
{
using (var scope = host.Services.CreateScope())
{
try
{
var orderContext = scope.ServiceProvider.GetRequiredService <OrderContext>();
if (orderContext.Database.ProviderName != "Microsoft.EntityFrameworkCore.InMemory")
{
orderContext.Database.Migrate();
}
OrderContextSeed.SeedAsync(orderContext).Wait();
}
catch (Exception ex)
{
throw;
}
}
return(host);
}
public static async Task Main(string[] args)
{
//Get the IWebHost which will host this application.
var host = CreateWebHostBuilder(args).Build();
//Find the service layer within our scope.
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <OrderContext>();
await OrderContextSeed.SeedAsync(context);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
//Continue to run the application
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)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/error");
}
app.UseSwagger();
app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "OrderSercice v1"));
app.UseHealthChecks("/Health", new HealthCheckOptions()
{
Predicate = _ => true,
ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});
app.UseHealthChecksUI();
app.UseHttpsRedirection();
app.UseSession();
app.UseRouting();
app.UseAuthorization();
app.UseAuthentication();
//AddAuthentication();
app.UseHttpContextItemsMiddleware();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapGet("/ping", async context => {
await context.Response.WriteAsync("pong!!!");
});
endpoints.Map("/ui", context => {
context.Response.Redirect("/HealthChecks-UI");
return(Task.CompletedTask);
});
endpoints.MapGet("/", async context =>
{
await context.Response.WriteAsync("Hello from order One");
});
endpoints.MapGet("/InitDb", async(c) => {
var orderContext = c.RequestServices.GetService <OrderContext>();
var loggerfactory = c.RequestServices.GetService <ILoggerFactory>();
await OrderContextSeed.SeedAsync(orderContext, loggerfactory, 3);
await c.Response.WriteAsync(Guid.NewGuid().ToString("N"));
});
});
}
