public ActionResult Edit(EditSiloModel model)
{
if (ModelState.IsValid)
{
using (var db = new WarehouseDbContext())
{
var silo = db.Silos.Find(model.Id);
if (silo == null)
{
return(HttpNotFound());
}
silo.Name = model.Name;
silo.SiloNumber = model.Number;
silo.MaxCapacity = model.MaxCapacity;
db.SaveChanges();
}
return(RedirectToAction("AllSilos"));
}
return(View(model));
}
public ActionResult Delete(int id)
{
var db = new WarehouseDbContext();
var siloQuery = db.Silos.AsQueryable();
var silo = siloQuery
.Where(a => a.Id == id)
.Select(a => new DeleteSiloModel
{
Id = a.Id,
Name = a.Name,
MaxCapacity = a.MaxCapacity,
Number = a.SiloNumber,
CapacityLeft = a.MaxCapacity - a.CurrentLoad,
CurrentCommodity = a.CurrentCommodity,
CurrentLoad = a.CurrentLoad
})
.FirstOrDefault();
if (silo == null)
{
return(HttpNotFound());
}
return(View(silo));
}
public ActionResult AddFertilizer(int id)
{
var db = new WarehouseDbContext();
var tank = db.Tanks
.Where(t => t.Id == id)
.Select(t => new TankViewModel
{
Number = t.Number,
Name = t.Name,
CurrentLoad = t.CurrentLoad,
MaxCapacity = t.MaxCapacity,
CapacityLeft = t.MaxCapacity - t.CurrentLoad,
Fertilizer = new Fertilizer(),
CurrentFertilizer = t.CurrentFertilizer
})
.FirstOrDefault();
if (tank.CurrentFertilizer == null)
{
tank.CurrentFertilizer = "empty";
}
if (tank == null)
{
return(HttpNotFound());
}
return(View(tank));
}
private void Delete()
{
if (SelectedDetail == null)
{
MessageBox.Show(CurrentWindows, "Please select a user before deleting.");
return;
}
MessageBoxResult result = MessageBox.Show(CurrentWindows, "Are you sure you want to delete:\n" +
SelectedDetail.ProductId, "Confirm delete", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
if (result == MessageBoxResult.OK)
{
try
{
if (Order.ID != 0)
{
WarehouseDbContext ctx = new WarehouseDbContext();
var detail = ctx.Details.Single(u => u.ID == SelectedDetail.ID);
ctx.Details.Remove(detail);
ctx.SaveChanges();
}
Details.Remove(SelectedDetail);
}
catch (SqlException ex)
{
MessageBox.Show(CurrentWindows, ex.Message, "Database error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
/* Update Database */
using (var serviceScope = app.ApplicationServices.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
WarehouseDbContext context = serviceScope.ServiceProvider.GetService <WarehouseDbContext>();
context.Database.SetCommandTimeout(10 * 60 * 1000);
if (context.Database.ProviderName != "Microsoft.EntityFrameworkCore.InMemory")
{
context.Database.Migrate();
}
}
app.UseAuthentication();
app.UseCors(PURCHASING_POLICITY);
app.UseMvc();
// 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 V1");
});
JobManager.Initialize(new MasterRegistry(app.ApplicationServices));
}
private void Delete()
{
if (SelectedOrder == null)
{
MessageBox.Show(CurrentWindows, "Please select on order before deleting!");
return;
}
MessageBoxResult result = MessageBox.Show(CurrentWindows, "Are you sure you want to delete:\n"
, "Confirm delete", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
if (result == MessageBoxResult.OK)
{
try
{
WarehouseDbContext ctx = new WarehouseDbContext();
var order = ctx.Orders.Single(u => u.ID == SelectedOrder.ID);
ctx.Orders.Remove(order);
ctx.SaveChanges();
OrderList = new List <Order>(ctx.Orders.ToList());
}
catch (SqlException ex)
{
MessageBox.Show(CurrentWindows, ex.Message, "Database error", MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (DbUpdateException ex)
{
MessageBox.Show(CurrentWindows, "Please delete the products before deleting the order.");
}
}
}
private void AddProduct()
{
if (SelectedCustomer == null)
{
MessageBox.Show(CurrentWindows, "Please select a user before adding products.");
return;
}
Order order;
if (SelectedOrder.ID == 0)
{
order = new Order
{
OrderType = SelectedOrder.OrderType,
Date = SelectedOrder.Date,
UserId = Int32.Parse(App.Current.Properties["CurrentUserID"].ToString()),
CustomerId = SelectedCustomer.ID,
};
}
else
{
order = SelectedOrder;
}
AddProductsWindow myWindow = new AddProductsWindow(order);
if (myWindow.ShowDialog() == true)
{
WarehouseDbContext ctx = new WarehouseDbContext();
OrderList = new List <Order>(ctx.Orders.ToList());
}
}
public ActionResult Edit(EditTankModel model)
{
if (ModelState.IsValid)
{
using (var db = new WarehouseDbContext())
{
var tank = db.Tanks.Find(model.Id);
if (tank == null)
{
return(HttpNotFound());
}
tank.Name = model.Name;
tank.Number = model.Number;
tank.MaxCapacity = model.MaxCapacity;
db.SaveChanges();
}
return(RedirectToAction("AllTanks"));
}
return(View(model));
}
public ActionResult Delete(int id)
{
var db = new WarehouseDbContext();
var tankQuery = db.Tanks.AsQueryable();
var tank = tankQuery
.Where(t => t.Id == id)
.Select(t => new DeleteTankModel
{
Id = t.Id,
Name = t.Name,
MaxCapacity = t.MaxCapacity,
Number = t.Number,
CapacityLeft = t.MaxCapacity - t.CurrentLoad,
CurrentFertilizer = t.CurrentFertilizer,
CurrentLoad = t.CurrentLoad
})
.FirstOrDefault();
if (tank == null)
{
return(HttpNotFound());
}
return(View(tank));
}
public InventoryDataUtil(InventoryFacade facade, WarehouseDbContext dbContext)
{
this.inventoryFacade = facade;
this.dbContext = dbContext;
this.dbSetInventory = dbContext.Set <Inventory>();
//this.garmentPurchaseOrderDataUtil = garmentPurchaseOrderDataUtil;
}
public ActionResult All()
{
var db = new WarehouseDbContext();
var silos = db.Silos
.OrderBy(s => s.SiloNumber)
.Select(s => new AllSilosViewModel
{
Id = s.Id,
Number = s.SiloNumber,
Name = s.Name,
MaxCapacity = s.MaxCapacity,
CapacityLeft = s.MaxCapacity - s.CurrentLoad,
CurrentCommodity = s.CurrentCommodity
})
.ToList();
foreach (var silo in silos)
{
if (silo.CurrentCommodity == null)
{
silo.CurrentCommodity = "empty";
}
}
return(View(silos));
}
public ActionResult AddCommodity(int id)
{
var db = new WarehouseDbContext();
var silo = db.Silos
.Where(s => s.Id == id)
.Select(s => new SiloViewModel
{
Number = s.SiloNumber,
Name = s.Name,
CurrentLoad = s.CurrentLoad,
MaxCapacity = s.MaxCapacity,
CapacityLeft = s.MaxCapacity - s.CurrentLoad,
Commodity = new Commodity(),
CurrentCommodity = s.CurrentCommodity
})
.FirstOrDefault();
if (silo.CurrentCommodity == null)
{
silo.CurrentCommodity = "empty";
}
if (silo == null)
{
return(HttpNotFound());
}
return(View(silo));
}
private void Delete()
{
if (SelectedUser == null)
{
MessageBox.Show(CurrentWindows, "Please select a user before deleting.");
return;
}
MessageBoxResult result = MessageBox.Show(CurrentWindows, "Are you sure you want to delete:\n" +
SelectedUser.Name, "Confirm delete", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
if (result == MessageBoxResult.OK)
{
try
{
WarehouseDbContext ctx = new WarehouseDbContext();
var user = ctx.Users.Single(u => u.ID == SelectedUser.ID);
ctx.Users.Remove(user);
ctx.SaveChanges();
//Reload data from databse
UserList = new List <User>(ctx.Users.ToList());
}
catch (SqlException ex)
{
MessageBox.Show(CurrentWindows, ex.Message, "Database error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
public ActionResult Create(CreateSiloModel model)
{
if (ModelState.IsValid)
{
var db = new WarehouseDbContext();
var creatorId = this.User.Identity.GetUserId();
var silo = new Silo(model.Name, model.MaxCapacity, model.SiloNumber);
silo.SiloCreatorId = creatorId;
if (model.CurrentCommodity == null)
{
silo.CurrentCommodity = null;
}
else
{
silo.CurrentCommodity = model.CurrentCommodity;
}
db.Silos.Add(silo);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public ActionResult AllTanks()
{
var db = new WarehouseDbContext();
var tanks = db.Tanks
.OrderBy(t => t.Number)
.Select(t => new AllTanksViewModel
{
Id = t.Id,
Number = t.Number,
Name = t.Name,
CurrentFertilizer = t.CurrentFertilizer,
MaxCapacity = t.MaxCapacity,
CapacityLeft = t.MaxCapacity - t.CurrentLoad
})
.ToList();
foreach (var tank in tanks)
{
if (tank.CurrentFertilizer == null)
{
tank.CurrentFertilizer = "empty";
}
}
return(View(tanks));
}
public ActionResult Create(CreateTankModel model)
{
if (ModelState.IsValid)
{
var db = new WarehouseDbContext();
var creatorId = this.User.Identity.GetUserId();
var tank = new Tank(model.Name, model.TankNumber, model.MaxCapacity);
tank.TankCreatorId = creatorId;
if (model.CurrentFertilizer == null)
{
tank.CurrentFertilizer = null;
}
else
{
tank.CurrentFertilizer = model.CurrentFertilizer.ToLower();
}
db.Tanks.Add(tank);
db.SaveChanges();
return(RedirectToAction("All", "Tanks"));
}
return(View(model));
}
public TransferFacade(IServiceProvider serviceProvider, WarehouseDbContext dbContext)
{
this.serviceProvider = serviceProvider;
this.dbContext = dbContext;
this.dbSet = dbContext.Set <TransferInDoc>();
this.dbSetInventory = dbContext.Set <Inventory>();
this.dbSetInventoryMovement = dbContext.Set <InventoryMovement>();
}
public CancelOrderCommandHandler(IItemsRepository itemsRepository, IOrdersRepository ordersRepository,
WarehouseDbContext warehouseDbContext, IWarrantyService warrantyService)
{
_itemsRepository = itemsRepository ?? throw new ArgumentNullException(nameof(itemsRepository));
_ordersRepository = ordersRepository ?? throw new ArgumentNullException(nameof(ordersRepository));
_warehouseDbContext = warehouseDbContext ?? throw new ArgumentNullException(nameof(warehouseDbContext));
_warrantyService = warrantyService ?? throw new ArgumentNullException(nameof(warrantyService));
}
public void Setup()
{
var dbContextOptions = new DbContextOptionsBuilder().UseInMemoryDatabase("test_db").Options;
_mockDbContext = new WarehouseDbContext(dbContextOptions);
ordersRepository = new OrdersRepository(_mockDbContext);
itemsRepository = new ItemsRepository(_mockDbContext);
}
public AddStockEventHandler(WarehouseDbContext dbContext,
IMapper mapper,
IMediator mediator)
{
_dbContext = dbContext;
_mapper = mapper;
_mediator = mediator;
}
public ReturnToCenterFacade(IServiceProvider serviceProvider, WarehouseDbContext dbContext)
{
this.serviceProvider = serviceProvider;
this.dbContext = dbContext;
this.dbSet = dbContext.Set <TransferOutDoc>();
this.dbSetSPKDocs = dbContext.Set <SPKDocs>();
this.dbSetInventoryMovement = dbContext.Set <InventoryMovement>();
this.dbSetExpedition = dbContext.Set <Expedition>();
}
private InventoryDataUtil dataUtil(InventoryFacade facade, string testName, WarehouseDbContext dbContext)
{
var pkbbjfacade = new InventoryFacade(ServiceProvider, _dbContext(testName));
//var sPKDocDataUtil = new SPKDocDataUtil(pkbbjfacade);
//var transferFacade = new TransferFacade(ServiceProvider, _dbContext(testName));
//var transferDataUtil = new TransferDataUtil(transferFacade, sPKDocDataUtil);
return(new InventoryDataUtil(facade, dbContext));
}
public AdjustmentFacade(IServiceProvider serviceProvider, WarehouseDbContext dbContext)
{
this.serviceProvider = serviceProvider;
this.dbContext = dbContext;
this.dbSetTransferIn = dbContext.Set <TransferInDoc>();
this.dbSetInventory = dbContext.Set <Inventory>();
this.dbSetAdjustment = dbContext.Set <AdjustmentDocs>();
this.dbSetInventoryMovement = dbContext.Set <InventoryMovement>();
this.dbSetTransferOut = dbContext.Set <TransferOutDoc>();
}
private void Save()
{
WarehouseDbContext ctx = new WarehouseDbContext();
if (!IsNew)
{
if (SelectedProduct == null)
{
MessageBox.Show(CurrentWindows, "Please select a user before editting.");
return;
}
var cat = ctx.Categories.SingleOrDefault(x => x.Name == SelectedCategory);
if (cat == null)
{
cat = ctx.Categories.Add(new Category {
Name = SelectedCategory
});
ctx.SaveChanges();
}
var product = ctx.Products.Single(u => u.ID == SelectedProduct.ID);
product.Name = SelectedProduct.Name;
product.Category = cat;
product.Price = SelectedProduct.Price;
product.Description = SelectedProduct.Description;
product.Image = SelectedProduct.Image;
ctx.SaveChanges();
}
else
{
var cat = ctx.Categories.SingleOrDefault(x => x.Name == SelectedCategory);
if (cat == null)
{
cat = ctx.Categories.Add(new Category {
Name = SelectedCategory
});
ctx.SaveChanges();
}
SelectedProduct.Category = cat;
ctx.Products.Add(SelectedProduct);
ctx.SaveChanges();
}
//Reload data from database
ProductList = new List <Product>(ctx.Products.ToList());
Categories = new List <Category>(ctx.Categories.ToList());
IsNew = false;
MessageBox.Show(CurrentWindows, "Updated successfully !");
}
public ExpeditionFacade(IServiceProvider serviceProvider, WarehouseDbContext dbContext)
{
this.serviceProvider = serviceProvider;
this.dbContext = dbContext;
this.dbSet = dbContext.Set <Expedition>();
this.dbSetInventory = dbContext.Set <Inventory>();
this.dbSetInventoryMovement = dbContext.Set <InventoryMovement>();
this.dbSetTransfer = dbContext.Set <TransferOutDoc>();
mapper = serviceProvider == null ? null : (IMapper)serviceProvider.GetService(typeof(IMapper));
}
public TransferStockFacade(IServiceProvider serviceProvider, WarehouseDbContext dbContext)
{
this.serviceProvider = serviceProvider;
this.dbContext = dbContext;
this.dbSetTransferIn = dbContext.Set <TransferInDoc>();
this.dbSetInventory = dbContext.Set <Inventory>();
this.dbSetSpk = dbContext.Set <SPKDocs>();
this.dbSetInventoryMovement = dbContext.Set <InventoryMovement>();
this.dbSetExpedition = dbContext.Set <Expedition>();
this.dbSet = dbContext.Set <TransferOutDoc>();
}
public ActionResult AllOperations(int id, int page = 1)
{
var pageSize = 12;
double size = 12;
var db = new WarehouseDbContext();
var siloQuery = db.Operations.AsQueryable();
var totalActions = siloQuery
.Where(a => a.SiloId == id)
.Select(a => new AllOperationsModel
{
Id = a.Id,
ActionDate = a.ActionDate,
AmountBeforeAction = a.AmountBeforeAction,
OperationName = a.OperationName,
ActionAmount = a.ActionAmount,
AmountAfterAction = a.AmountAfterAction,
SiloId = a.SiloId,
Operator = a.OperationName,
CommodityName = a.CommodityName
})
.ToList();
var actions = siloQuery
.Where(a => a.SiloId == id)
.OrderByDescending(a => a.ActionDate)
.Skip((page - 1) * pageSize)
.Take(pageSize)
.Select(a => new AllOperationsModel
{
Id = a.Id,
ActionDate = a.ActionDate,
AmountBeforeAction = a.AmountBeforeAction,
OperationName = a.OperationName,
ActionAmount = a.ActionAmount,
AmountAfterAction = a.AmountAfterAction,
SiloId = a.SiloId,
Operator = a.OperatorName,
CommodityName = a.CommodityName
})
.ToList();
var totalPages = Math.Ceiling(totalActions.Count / size);
ViewBag.CurrentPage = page;
ViewBag.CurrentSilo = id;
ViewBag.TotalPages = totalPages;
return(View(actions));
}
private WarehouseDbContext _dbContext(string testName)
{
DbContextOptionsBuilder <WarehouseDbContext> optionsBuilder = new DbContextOptionsBuilder <WarehouseDbContext>();
optionsBuilder
.UseInMemoryDatabase(testName)
.ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning));
WarehouseDbContext dbContext = new WarehouseDbContext(optionsBuilder.Options);
return(dbContext);
}
public bool RemoveProduct(int ProductId)
{
using (WarehouseDbContext _db = new WarehouseDbContext())
{
var _warehouseItem = _db.Warehouse.Where(x => x.ProductId == ProductId).FirstOrDefault();
if (_warehouseItem != null)
{
_db.Warehouse.Remove(_warehouseItem);
}
return(_db.SaveChanges() > 0);
}
}
public bool RemoveProducts(IEnumerable <int> producIds)
{
using (WarehouseDbContext _db = new WarehouseDbContext())
{
foreach (var id in producIds)
{
var _removeItem = _db.Warehouse.FirstOrDefault(x => x.ProductId == id);
_db.Warehouse.Attach(_removeItem);
_db.Entry <Warehouse>(_removeItem).State = EntityState.Deleted;
}
return(_db.SaveChanges() > 0);
}
}
