public OrdersProvider(OrdersDbContext context, ILogger <OrdersProvider> logger, IMapper mapper)
{
DataContext = context;
Mapper = mapper;
Logger = logger;
SeedData();
}
private void SeedData(OrdersDbContext dbContext)
{
if (!dbContext.Orders.Any())
{
for (var i = 100; i <= 110; i++)
{
dbContext.Add(new Db.Order()
{
Id = i,
CustomerId = i + 1,
OrderDate = DateTime.Now,
Items = new List <Db.OrderItem>()
{
new Db.OrderItem()
{
OrderId = 1, ProductId = 1, Quantity = 10, UnitPrice = 10
},
new Db.OrderItem()
{
OrderId = 2, ProductId = 2, Quantity = 10, UnitPrice = 10
},
new Db.OrderItem()
{
OrderId = 3, ProductId = 3, Quantity = 1, UnitPrice = 100
}
},
Total = i * 100
});;
}
}
}
private List <OrderItemsVM> GetImagingItems(OrdersDbContext orderDbContext)
{
var itemList = (from itm in orderDbContext.BillItemPrice
join servceDpt in orderDbContext.ServiceDepartment on itm.ServiceDepartmentId equals servceDpt.ServiceDepartmentId
where servceDpt.IntegrationName.ToLower() == "radiology"
select new OrderItemsVM
{
Type = servceDpt.ServiceDepartmentName,
PreferenceType = "Imaging",
ItemId = (int)itm.ItemId,
ItemName = itm.ItemName,
GenericId = null,
IsPreference = false,
IsGeneric = false
}).OrderBy(itm => itm.ItemName).ToList();
//var itemList = (from itm in orderDbContext.ImagingItems.Include("ImagingTypes")
// select new OrderItemsVM
// {
// Type = itm.ImagingTypes.ImagingTypeName,
// PreferenceType = "Imaging",
// ItemId = (int)itm.ImagingItemId,
// ItemName = itm.ImagingItemName,
// GenericId = null,
// IsPreference = false,
// IsGeneric = false
// }).OrderBy(itm => itm.ItemName).ToList();
return(itemList);
}
public OrdersService(OrdersDbContext dbContext, ILogger <OrdersService> logger, IMapper mapper)
{
this.dbContext = dbContext;
this.logger = logger;
this.mapper = mapper;
SeedData();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IWebHostEnvironment env,
IHostApplicationLifetime lifetime,
OrdersDbContext dbContext)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseCors("Cors Policy");
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
app.UseSwaggerCustom("Orders API V1");
app.UseMassTransitCustom(lifetime);
}
private List <OrderItemsVM> GetPhrmGenericItems(OrdersDbContext orderDbContext)
{
var phrmItems = (from gen in orderDbContext.PharmacyGenericItems
join map in orderDbContext.GenericDosageMaps on gen.GenericId equals map.GenericId into abc
from a in abc.DefaultIfEmpty()
select new OrderItemsVM
{
Type = "Medication",
PreferenceType = "Medication",
ItemId = gen.GenericId,
ItemName = gen.GenericName,
GenericId = gen.GenericId,
IsPreference = false,
IsGeneric = true,
Route = a.Route != null ? a.Route : "",
Frequency = a.Frequency != null ? a.Frequency : 0,
FreqInWords = a.FreqInWords != null ? a.FreqInWords : "",
Dosage = a.Dosage != null ? a.Dosage : ""
}).OrderBy(itm => itm.ItemName).ToList();
return(phrmItems);
//return itemListFromMap;
}
public ActionResult <Order> Get(long id)
{
using (var db = new OrdersDbContext())
{
return(db.Orders.Find(id));
}
}
public OrdersProvider(OrdersDbContext dbContext, ILogger <OrdersProvider> logger, IMapper mapper)
{
_dbContext = dbContext;
_logger = logger;
_mapper = mapper;
SeedData();
}
public SaveMineralPriceHandler(
ILoggerFactory loggerFactory,
OrdersDbContext orderDbContext)
{
_orderDbContext = orderDbContext;
_logger = loggerFactory.CreateLogger <SaveMineralPriceHandler>();
}
public OrdersProvider(OrdersDbContext dbContext, ILogger <OrdersProvider> logger, IMapper mapper)
{
this.dbContext = dbContext;
this.logger = logger;
this.mapper = mapper;
SeedData();
}
private OrderCheckpoint GetOrCreateOrderWithCheckpoint(Guid orderId, OrdersDbContext context)
{
var checkpoint = context.OrderCheckpoints
.Include(checkpoint => checkpoint.Order)
.FirstOrDefault(checkpoint => checkpoint.OrderId == orderId);
if (checkpoint != null)
{
return(checkpoint);
}
var order = new Order
{
Id = orderId
};
checkpoint = new OrderCheckpoint
{
Order = order,
OrderId = order.Id
};
context.OrderCheckpoints.Add(checkpoint);
return(checkpoint);
}
public OrdersController(
OrdersDbContext context,
IEventStoreConnection esConnection)
{
_context = context;
_esConnection = esConnection;
}
public ActionResult <IEnumerable <Order> > Get()
{
using (var db = new OrdersDbContext())
{
var orders = db.Orders.ToList();
return(orders);
}
}
public OrderItemQuery(OrdersDbContext dbContext, ILoggerServiceAdapter <OrderItemQuery> logger, IMapper mapper)
{
_dbContext = dbContext;
_logger = logger;
_mapper = mapper;
//orderCommand.SeedData();
//orderItemCommand.SeedData();
}
static void Main(string[] args)
{
var db = new OrdersDbContext();
var orders = db.Orders.Any();
Console.WriteLine(orders);
}
public OrdersProvider(OrdersDbContext dbContext, ILogger <OrdersProvider> logger, IMapper mapper,
IConfigurationProvider configurationProvider, IEventBus eventBus)
{
this.dbContext = dbContext;
this.logger = logger;
this.mapper = mapper;
this.configurationProvider = configurationProvider;
this.eventBus = eventBus;
}
public OrderDbSyncronizer(
IEventStoreConnection eventStoreConnection,
UserCredentials userCredentials,
OrdersDbContext context)
{
this.eventStoreConnection = eventStoreConnection;
this.userCredentials = userCredentials;
this.context = context;
}
public void Put(long id, [FromHeader] int invoce)
{
using (var db = new OrdersDbContext())
{
var order = db.Orders.Find(id);
order.InvoiceNumber = invoce;
db.Orders.Update(order);
db.SaveChanges();
}
}
public void Put(long id, [FromHeader] Byte status)
{
using (var db = new OrdersDbContext())
{
var order = db.Orders.Find(id);
order.OrderStatus = status;
db.Orders.Update(order);
db.SaveChanges();
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
OrdersDbContext db = new OrdersDbContext();
db.Dispose();
}
base.Dispose(disposing);
}
public static OrdersDbContext Build(DbConnection connection, DbTransaction transaction)
{
var contextOptions = new DbContextOptionsBuilder <OrdersDbContext>()
.UseSqlServer(connection)
.Options;
var context = new OrdersDbContext(contextOptions);
context.Database.UseTransaction(transaction);
return(context);
}
public static OrdersDbContext InitContextWithInMemoryDbSupport()
{
var options = new DbContextOptionsBuilder <OrdersDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var _dbContext = new OrdersDbContext(options);
_dbContext.Database.EnsureCreated();
return(_dbContext);
}
internal static OrdersDbContext ContextFactory(SqliteConnection conn)
{
var options = new DbContextOptionsBuilder <OrdersDbContext>()
.UseSqlite(conn)
.EnableSensitiveDataLogging()
.Options;
var context = new OrdersDbContext(options);
context.Database.EnsureCreated();
return(context);
}
/* I run migrations here. Database Is not currently initialized with any data so user
* has to wait for HttpClient to fill database. */
public static IApplicationBuilder PrepareDatabase(this IApplicationBuilder app)
{
using (var serviceScope = app.ApplicationServices
.GetService <IServiceScopeFactory>()
.CreateScope()) {
OrdersDbContext context = serviceScope
.ServiceProvider
.GetRequiredService <OrdersDbContext>();
context.Database.Migrate();
}
return(app);
}
public void PlaceOrder(CustomerDto customerDto, string supplierName, List <ProductDto> productDtos)
{
using (var ctx = new OrdersDbContext())
{
var supplier = ctx.Suppliers.FirstOrDefault(s => s.Name == supplierName);
if (supplier == null)
{
return;
}
var customer = ctx.Customers
.FirstOrDefault(c => c.Name == customerDto.Name && c.IdentificationNumber == customerDto.IdentificationNumber);
if (customer == null)
{
customer = new Customer
{
Name = customerDto.Name,
IdentificationNumber = customerDto.IdentificationNumber
};
}
customer.Address = customerDto.Address;
customer.PhoneNumber = customerDto.PhoneNumber;
var order = new Order
{
Customer = customer,
Supplier = supplier,
OrderedDate = DateTime.Now,
Status = OrderStatus.Opened,
ExpectedDate = DateTime.Now.AddDays(_random.Next(1, 10))
};
foreach (var productDto in productDtos)
{
var product = ctx.Products.Find(productDto.Id);
var orderDetails = new OrderDetails
{
Order = order,
Product = product,
ProductQuantity = productDto.Quantity
};
order.OrderDetails.Add(orderDetails);
}
ctx.Orders.Add(order);
ctx.SaveChanges();
}
}
public static OrdersDbContext GetOrdersDbContext(string dbName)
{
// Création des options pour l'instance DbContext
var options = new DbContextOptionsBuilder <OrdersDbContext>().UseInMemoryDatabase(databaseName: dbName).Options;
// Création de l'instance de DbContext
var dbContext = new OrdersDbContext(options);
// On ajoute les entités en mémoire ;)
dbContext.Seed();
return(dbContext);
}
public static void Seed(this OrdersDbContext dbContext)
{
/*dbContext.Orders.Add(new OrderDetails
* {
* ID_Order = 1,
* order = null,
* ID_Cocktail = 1,
* cocktail = { },
* Quantite = 2
* });*/
dbContext.SaveChanges();
}
internal static async Task SeedData(OrdersDbContext context, int amount)
{
using (context)
{
for (var i = 0; i < amount; i++)
{
var o = new Order((i + 1).ToString(), OrderStatus.Pending, OrderDetails.Empty());
context.Orders.Add(o);
}
await context.SaveChangesAsync();
}
}
public EmployeesViewModel()
{
using (OrdersDbContext context = new OrdersDbContext())
{
foreach (var item in context.Employees)
{
Employees.Add(new EmployeeModel {
Id = item.Id, EmployeeSurname = item.EmployeeSurname, EmployeeName = item.EmployeeName,
EmployeeMiddleName = item.EmployeeMiddleName, DepartmentId = item.DepartmentId, DepartmentName = item.Department.DepartmentName,
Gender = item.Gender, EmployeeBirthday = item.EmployeeBirthday
});
}
}
}
private void CreateOrders(OrdersDbContext dbContext)
{
for (int i = 21; i <= 30; i++)
{
dbContext.Orders.Add(new Order()
{
Id = i,
CustomerId = i,
Items = new List <OrderItem>(),
OrderDate = DateTime.Now,
Total = 7 * 7 + i
});
}
}
