public async Task <WrapperPurchaseListVM> GetAllPurchaseAsync(GetDataListVM getDataListVM)
{
WrapperPurchaseListVM vm = new WrapperPurchaseListVM();
List <PurchaseVM> vmList = new List <PurchaseVM>();
Task <List <Invoice> > invoicesT = _repositoryWrapper
.Invoice
.FindAll()
.Include(x => x.Supplier)
.Include(x => x.InvoiceType)
.Where(x => x.FactoryId == getDataListVM.FactoryId &&
x.InvoiceType.Name == TypeInvoice.Purchase.ToString())
.Skip((getDataListVM.PageNumber - 1) * (getDataListVM.PageSize))
.Take(getDataListVM.PageSize)
.ToListAsync();
Task <List <Purchase> > purchasesT = _repositoryWrapper
.Purchase
.FindAll()
.Where(x => x.FactoryId == getDataListVM.FactoryId)
.Include(x => x.Item)
.ThenInclude(s => s.ItemCategory)
.ToListAsync();
await Task.WhenAll(invoicesT, purchasesT);
List <Purchase> dbListPurchase = purchasesT.Result.ToList();
vmList = _utilService.Mapper.Map <List <Invoice>, List <PurchaseVM> >(invoicesT.Result.ToList());
List <Purchase> temp = new List <Purchase>();
for (int i = 0; i < vmList.Count; i++)
{
temp = dbListPurchase.Where(x => x.InvoiceId == vmList.ElementAt(i).InvoiceId).ToList();
vmList.ElementAt(i).ItemList = _utilService.Mapper.Map <List <Purchase>, List <PurchaseItemVM> >(temp);
}
vm.ListOfData = vmList;
vm.TotalRecords = invoicesT.Result.ToList().Count;
return(vm);
}
// Invoice
// Expense
// Payable
// Purchase
// Stock
// StockIn
// Transaction
public async Task <WrapperPurchaseListVM> DeletePurchaseAsync(PurchaseVM vm)
{
Task <List <Invoice> > invoiceToDelete = _repositoryWrapper
.Invoice
.FindAll()
.Where(x => x.Id == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <Expense> > expenseToDelete = _repositoryWrapper
.Expense
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <Payable> > payableToDelete = _repositoryWrapper
.Payable
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <Purchase> > purchaseToDelete = _repositoryWrapper
.Purchase
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
await Task.WhenAll(invoiceToDelete, expenseToDelete, payableToDelete, purchaseToDelete);
// Stock
IEnumerable <Stock> stockList = await _repositoryWrapper
.Stock
.FindByConditionAsync(
x => x.FactoryId == vm.FactoryId);
//&& purchaseToDelete
//.Result
//.ToList()
//.FirstOrDefault(d => d.ItemId == x.ItemId) != null);
for (int i = 0; i < purchaseToDelete.Result.Count(); i++)
{
Purchase purchaseItem = purchaseToDelete.Result.ElementAt(i);
Stock existingStock = stockList.ToList().Where(x => x.ItemId == purchaseItem.ItemId).FirstOrDefault();
if (existingStock == null)
{
// _utilService.Log("Stock Is Empty. Not Enough Stock available");
// throw new StockEmptyException();
}
else
{
if (existingStock.Quantity < purchaseItem.Quantity)
{
var getDatalistVM2 = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10
};
WrapperPurchaseListVM vm2 = await GetAllPurchaseAsync(getDatalistVM2);
vm2.HasMessage = true;
vm2.Message = "Stock hasn't enough item";
return(vm2);
}
else
{
existingStock.Quantity -= purchaseItem.Quantity;
_repositoryWrapper.Stock.Update(existingStock);
}
}
}
Task <List <StockIn> > stockInToDelete = _repositoryWrapper
.StockIn
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <TblTransaction> > transactionToDelete = _repositoryWrapper
.Transaction
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
_repositoryWrapper.Invoice.DeleteAll(invoiceToDelete.Result.ToList());
_repositoryWrapper.Expense.DeleteAll(expenseToDelete.Result.ToList());
_repositoryWrapper.Payable.DeleteAll(payableToDelete.Result.ToList());
_repositoryWrapper.Purchase.DeleteAll(purchaseToDelete.Result.ToList());
_repositoryWrapper.StockIn.DeleteAll(stockInToDelete.Result.ToList());
_repositoryWrapper.Transaction.DeleteAll(transactionToDelete.Result.ToList());
Task <int> Invoice = _repositoryWrapper.Invoice.SaveChangesAsync();
Task <int> Expense = _repositoryWrapper.Expense.SaveChangesAsync();
Task <int> Payable = _repositoryWrapper.Payable.SaveChangesAsync();
Task <int> Purchase = _repositoryWrapper.Purchase.SaveChangesAsync();
Task <int> StockIn = _repositoryWrapper.StockIn.SaveChangesAsync();
Task <int> TblTransaction = _repositoryWrapper.Transaction.SaveChangesAsync();
Task <int> Stock = _repositoryWrapper.Stock.SaveChangesAsync();
await Task.WhenAll(Invoice, Expense, Payable, Purchase, StockIn, TblTransaction, Stock);
var getDatalistVM = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10
};
return(await GetAllPurchaseAsync(getDatalistVM));
}