public ActionResult Index(SalesVM salesVM)
{
_salesManager.Add(salesVM.SalesProducts);
salesVM.Customers = _customerManager.GetAll();
salesVM.Products = _productManager.GetAll();
return(View(salesVM));
}
public async Task <ActionResult <IEnumerable <SalesVM> > > GetSales()
{
List <SalesVM> salesVM = new List <SalesVM>();
var sales = await _context.Sales
.Include(sale => sale.Product)
.Include(sale => sale.SalesPerson)
.Include(sale => sale.Customer)
.ToListAsync();
foreach (Sales sale in sales)
{
SalesVM saleVM = new SalesVM
{
Id = sale.Id,
ProductName = sale.Product.Name,
SalesPersonName = $"{sale.SalesPerson.FirstName} {sale.SalesPerson.LastName}",
CustomerName = $"{sale.Customer.FirstName} {sale.Customer.LastName}",
SalesDate = sale.SalesDate
};
salesVM.Add(saleVM);
}
return(salesVM);
}
public IActionResult Index()
{
SalesVM salesVM = new SalesVM();
salesVM.Category = categoryService.GetActive();
salesVM.Customers = customerService.GetActive();
salesVM.Orders = orderService.GetActive();
salesVM.Product = productService.GetActive();
salesVM.AppUser = appUserService.GetActive();
return(View(salesVM));
}
public IActionResult Sum(SalesVM model)
{
if (ModelState.IsValid)
{
decimal getCost = (from c in _context.SalesMgmt
where (c.PurchaseDate.Date >= model.Start.Date && c.PurchaseDate.Date <= model.End.Date)
select c.Cost).Sum();
ViewBag.Cost = getCost;
}
return(View());
}
public ActionResult YeniSatis(SalesVM p1)
{
TBLSATISLAR sat = new TBLSATISLAR()
{
KATEGORI = p1.CategoryID,
URUN = p1.ProductID,
MUSTERI = p1.CustomerID,
FIYAT = p1.price,
ADET = (byte)p1.ProductPiece,
};
service.salesRepository.Insert(sat);
var urun = service.productRepository.Find((int)sat.URUN);
urun.STOK = Convert.ToByte(Convert.ToInt32(urun.STOK) - Convert.ToInt32(sat.ADET));
service.productRepository.Guncelle(urun);
return(RedirectToAction("Index", "Urun"));
}
public async Task <IActionResult> SalesHistory(long id)
{
try
{
SalesVM vm = new SalesVM();
User seller = await db.Users.FindAsync(id);
List <Sale> salesList = await db.SalesHistory.ToListAsync();
salesList = salesList.Where(item => item.FarmerID == seller.ID).ToList();
vm.SaleList = salesList;
vm.SaleList = vm.SaleList.OrderByDescending(p => p.Date).ToList();
vm.farmerID = seller.ID;
return(View(vm));
}
catch (Exception e)
{
return(Content(e.Message));
}
}
public ActionResult MonthlySalesByDate()
{
int year = Convert.ToInt32(DateTime.Today.ToString("yyyy"));
int month = Convert.ToInt32(DateTime.Today.ToString("MM"));
int daysInMonth = DateTime.DaysInMonth(year, month);
var days = Enumerable.Range(1, daysInMonth);
var query = db.Sales.Where(x => x.Date.Year == year && x.Date.Month == month).OrderBy(x => x.Date).Select(g => new
{
Day = g.Date.Day,
Total = g.GrandTotal
});
var model = new SalesVM
{
Date = new DateTime(year, month, 1),
Days = days.GroupJoin(query, d => d, q => q.Day, (d, q) => new DayTotalVM
{
Day = d,
Total = q.Sum(x => x.Total)
}).ToList()
};
return(View(model));
}
public List <DayTotalVM> MonthlySalesByDate_forCharts(int yr, int mnt)
{
int year = yr;
int month = mnt;
int daysInMonth = DateTime.DaysInMonth(year, month);
var days = Enumerable.Range(1, daysInMonth);
var query = db.Sales.Where(x => x.Date.Year == year && x.Date.Month == month).Select(g => new
{
Day = g.Date.Day,
Total = g.GrandTotal
});
SalesVM model = new SalesVM
{
Date = new DateTime(year, month, 1),
Days = days.GroupJoin(query, d => d, q => q.Day, (d, q) => new DayTotalVM
{
Day = d,
Total = q.Sum(x => x.Total)
}).ToList()
};
return(model.Days.ToList());
}
public ActionResult MonthlySalesByDate(string _year, string _month)
{
//assign incoming values to the variables
int year = 0, month = 0;
//check if year is null
if (string.IsNullOrWhiteSpace(_year) && _month != null)
{
year = DateTime.Now.Date.Year;
month = Convert.ToInt32(_month.Trim());
}
else
{
year = Convert.ToInt32(_year.Trim());
month = Convert.ToInt32(_month.Trim());
}
//calculate ttal number of days in a particular month for a that year
int daysInMonth = DateTime.DaysInMonth(year, month);
var days = Enumerable.Range(1, daysInMonth);
var query = db.Sales.Where(x => x.Date.Year == year && x.Date.Month == month).OrderBy(x => x.Date.Day).Select(g => new
{
Day = g.Date.Day,
Total = g.GrandTotal
});
var model = new SalesVM
{
Date = new DateTime(year, month, 1),
Days = days.GroupJoin(query, d => d, q => q.Day, (d, q) => new DayTotalVM
{
Day = d,
Total = q.Sum(x => x.Total)
}).ToList()
};
return(View(model));
}
public async Task <WrapperSalesListVM> AddSales([FromBody] SalesVM sales)
{
return(await _serviceWrapper.SalesService.AddSalesAsync(sales));
}
// Invoice
// Income
// Recievable
// Sales
// Stock
// StockOut
// Transaction
public async Task <WrapperSalesListVM> AddSalesAsync(SalesVM salesVM)
{
// Invoice
Invoice invoiceToAdd = new Invoice();
invoiceToAdd = _utilService.Mapper.Map <SalesVM, Invoice>(salesVM);
_repositoryWrapper.Invoice.Create(invoiceToAdd);
// Setting Up Invoice Id
salesVM.InvoiceId = invoiceToAdd.Id;
foreach (var item in salesVM.ItemList)
{
item.InvoiceId = invoiceToAdd.Id;
}
// Income
Income incomeToAdd = new Income();
incomeToAdd = this._utilService.Mapper.Map <SalesVM, Income>(salesVM);
_repositoryWrapper.Income.Create(incomeToAdd);
// Recievable
Recievable recievableToAdd = new Recievable();
recievableToAdd = _utilService.Mapper.Map <SalesVM, Recievable>(salesVM);
_repositoryWrapper.Recievable.Create(recievableToAdd);
// Sales
List <Sales> listOfSalesToAdd = new List <Sales>();
listOfSalesToAdd = _utilService.Mapper.Map <List <SalesItemVM>, List <Sales> >(salesVM.ItemList);
_repositoryWrapper.Sales.CreateAll(listOfSalesToAdd);
// Stock
Stock stockToAdd = new Stock();
IEnumerable <Stock> stockList = await _repositoryWrapper.Stock.FindByConditionAsync(x => x.FactoryId == salesVM.FactoryId);
for (int i = 0; i < salesVM.ItemList.Count; i++)
{
Stock existingStock = stockList.ToList().Where(x => x.ItemId == salesVM.ItemList[i].Item.Id && x.ItemStatusId == salesVM.ItemList[i].ItemStatus.Id).FirstOrDefault();
if (existingStock == null)
{
var getDatalistVM2 = new GetDataListVM()
{
FactoryId = salesVM.FactoryId,
PageNumber = 1,
PageSize = 10
};
WrapperSalesListVM dataToReturn = await GetAllSalesAsync(getDatalistVM2);
dataToReturn.HasMessage = true;
dataToReturn.Message = "Stock Is Empty";
return(dataToReturn);
// _utilService.Log("Stock Is Empty. Not Enough Stock available");
// throw new StockEmptyException();
}
else
{
if (existingStock.Quantity >= salesVM.ItemList[i].Quantity)
{
existingStock.Quantity -= salesVM.ItemList[i].Quantity;
_repositoryWrapper.Stock.Update(existingStock);
}
else
{
_utilService.Log("Stock Is Empty");
return(new WrapperSalesListVM());
}
}
}
// StockOut
List <StockOut> stockOutsToAdd = new List <StockOut>();
stockOutsToAdd = _utilService.Mapper.Map <List <SalesItemVM>, List <StockOut> >(salesVM.ItemList);
_repositoryWrapper.StockOut.CreateAll(stockOutsToAdd);
// Transaction
TblTransaction transactionRecieved = new TblTransaction();
transactionRecieved = _utilService.Mapper.Map <SalesVM, TblTransaction>(salesVM);
transactionRecieved.Amount = salesVM.PaidAmount;
transactionRecieved.PaymentStatus = PAYMENT_STATUS.CASH_RECIEVED.ToString();
transactionRecieved.TransactionType = TRANSACTION_TYPE.CREDIT.ToString();
_repositoryWrapper.Transaction.Create(transactionRecieved);
//TblTransaction transactionRecievable = new TblTransaction();
//transactionRecievable = _utilService.Mapper.Map<SalesVM, TblTransaction>(salesVM);
//transactionRecievable.Amount = salesVM.DueAmount;
//transactionRecievable.PaymentStatus = PAYMENT_STATUS.CASH_RECIEVABLE.ToString();
//transactionRecievable.TransactionType = TRANSACTION_TYPE.NOT_YET_EXECUTED.ToString();
//transactionRecievable.TransactionId = transactionRecieved.TransactionId;
//_repositoryWrapper.Transaction.Create(transactionRecievable);
Task <int> Invoice = _repositoryWrapper.Invoice.SaveChangesAsync();
Task <int> Income = _repositoryWrapper.Income.SaveChangesAsync();
Task <int> Recievable = _repositoryWrapper.Recievable.SaveChangesAsync();
Task <int> Sales = _repositoryWrapper.Sales.SaveChangesAsync();
Task <int> Stock = _repositoryWrapper.Stock.SaveChangesAsync();
Task <int> StockOut = _repositoryWrapper.StockOut.SaveChangesAsync();
Task <int> Transaction = _repositoryWrapper.Transaction.SaveChangesAsync();
await Task.WhenAll(Invoice, Income, Recievable, Sales, Stock, StockOut, Transaction);
var getDatalistVM = new GetDataListVM()
{
FactoryId = salesVM.FactoryId,
PageNumber = 1,
PageSize = 10
};
return(await GetAllSalesAsync(getDatalistVM));
}
// Invoice
// Income
// Recievable
// Sales
// Stock
// StockOut
// Transaction
public async Task <WrapperSalesListVM> DeleteSalesAsync(SalesVM vm)
{
Task <List <Invoice> > invoiceToDelete = _repositoryWrapper
.Invoice
.FindAll()
.Where(x => x.Id == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <Income> > incomeToDelete = _repositoryWrapper
.Income
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <Recievable> > recievableToDelete = _repositoryWrapper
.Recievable
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
Task <List <Sales> > salesToDelete = _repositoryWrapper
.Sales
.FindAll()
.Where(x => x.InvoiceId == vm.InvoiceId && x.FactoryId == vm.FactoryId)
.ToListAsync();
await Task.WhenAll(invoiceToDelete, incomeToDelete, recievableToDelete, salesToDelete);
// Stock
IEnumerable <Stock> stockList = await _repositoryWrapper
.Stock
.FindByConditionAsync(
x => x.FactoryId == vm.FactoryId);
//&& salesToDelete
//.Result
//.ToList()
//.FirstOrDefault(d => d.ItemId == x.ItemId) != null);
for (int i = 0; i < salesToDelete.Result.Count(); i++)
{
Sales sales = salesToDelete.Result.ElementAt(i);
Stock existingStock = stockList.Where(x => x.ItemId == sales.ItemId).FirstOrDefault();
if (existingStock == null)
{
// _utilService.Log("Stock Is Empty. Not Enough Stock available");
// throw new StockEmptyException();
}
else
{
existingStock.Quantity += sales.Quantity;
_repositoryWrapper.Stock.Update(existingStock);
}
}
Task <List <StockOut> > stockOutToDelete = _repositoryWrapper
.StockOut
.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.Income.DeleteAll(incomeToDelete.Result.ToList());
_repositoryWrapper.Recievable.DeleteAll(recievableToDelete.Result.ToList());
_repositoryWrapper.Sales.DeleteAll(salesToDelete.Result.ToList());
_repositoryWrapper.StockOut.DeleteAll(stockOutToDelete.Result.ToList());
_repositoryWrapper.Transaction.DeleteAll(transactionToDelete.Result.ToList());
Task <int> Invoice = _repositoryWrapper.Invoice.SaveChangesAsync();
Task <int> Income = _repositoryWrapper.Income.SaveChangesAsync();
Task <int> Recievable = _repositoryWrapper.Recievable.SaveChangesAsync();
Task <int> Sales = _repositoryWrapper.Sales.SaveChangesAsync();
Task <int> StockOut = _repositoryWrapper.StockOut.SaveChangesAsync();
Task <int> TblTransaction = _repositoryWrapper.Transaction.SaveChangesAsync();
Task <int> Stock = _repositoryWrapper.Stock.SaveChangesAsync();
await Task.WhenAll(Invoice, Income, Recievable, Sales, StockOut, TblTransaction, Stock);
var getDatalistVM = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10
};
return(await GetAllSalesAsync(getDatalistVM));
}
