public async Task <WrapperStockListVM> Delete(StockVM Temp)
{
var Task = await _repositoryWrapper.Stock.FindByConditionAsync(x => x.Id == Temp.Id && x.FactoryId == Temp.FactoryId);
var datarow = Task.ToList().FirstOrDefault();
if (datarow == null)
{
return(new WrapperStockListVM());
}
_repositoryWrapper.Stock.Delete(datarow);
await _repositoryWrapper.Stock.SaveChangesAsync();
this._utilService.Log("Successful In Deleting Data");
var dataParam = new GetDataListVM()
{
FactoryId = Temp.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperStockListVM data = await GetListPaged(dataParam);
return(data);
}
/// <summary>
/// Insert Purchases
/// </summary>
/// <param name="entity"></param>
/// <returns>Message</returns>
public async Task <string> InsertPurchases(Purchases entity)
{
var result = string.Empty;
StockVM stockdata = new StockVM();
using (TransactionScope txScope = new TransactionScope())
{
try
{
foreach (var data in entity.PurcheaseDetails)
{
data.ProReturn = true;
result = await new PurcheaseDetailsRepository(logger).Update(data);
stockdata = new StocksRepository(logger).GetAll().Result.FirstOrDefault(c => c.ProductId == data.ProductId);
if (stockdata != null)
{
stockdata.Quantity = decimal.Subtract(stockdata.Quantity, data.Quantity);
result = await new StocksRepository(logger).Update(stockdata);
}
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
result = "Fail~" + ex.Message.ToString();
throw ex;
}
finally {
txScope.Complete();
txScope.Dispose();
}
}
return(result);
}
public IHttpActionResult Getstock(StockVM stockVMVM)
{
List <StockVM> stockVMs = new List <StockVM>();
var StockObj = (from a in db.stocks
join b in db.stores
on a.store_id equals b.store_id
join c in db.products
on a.product_id equals c.product_id
where stockVMVM.product_id == a.product_id && stockVMVM.store_id == a.store_id
select new { b.store_name, c.product_name, a.quantity }).ToList();
foreach (var item in StockObj)
{
StockVM stockVMObj = new StockVM();
stockVMObj.quantity = item.quantity;
stockVMObj.store_name = item.store_name;
stockVMObj.product_name = item.product_name;
stockVMs.Add(stockVMObj);
}
if (StockObj == null)
{
return(NotFound());
}
return(Ok(stockVMs));
}
public async Task <WrapperStockListVM> Update(string id, StockVM ViewModel)
{
if (id != ViewModel.Id)
{
new WrapperStockListVM();
}
Task <IEnumerable <Stock> > itemsDB = _repositoryWrapper.Stock.FindByConditionAsync(x => x.Id == id && x.FactoryId == ViewModel.FactoryId);
await Task.WhenAll(itemsDB);
var itemUpdated = _utilService.GetMapper().Map <StockVM, Stock>(ViewModel, itemsDB.Result.ToList().FirstOrDefault());
_repositoryWrapper.Stock.Update(itemUpdated);
Task <int> t1 = _repositoryWrapper.Stock.SaveChangesAsync();
await Task.WhenAll(t1);
this._utilService.Log("Successful In Updating Data");
var dataParam = new GetDataListVM()
{
FactoryId = ViewModel.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperStockListVM data = await GetListPaged(dataParam);
return(data);
}
public IHttpActionResult Putstock(int id, StockVM stock)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != stock.store_id)
{
return(BadRequest());
}
db.Entry(stock).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!stockExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Index(StockVM model)
{
//model.Purchases = _manager.purchases();
if (model.Reordercheck == null && model.Expirecheck == null)
{
model.Sales = (Db.sales.Where(c => c.Purchase.product.Name == model.productName).ToList()).Where(c => c.Purchase.Date >= model.sDate && c.Purchase.Date <= model.eDate).ToList();
}
else if (model.Reordercheck == "true" && model.Expirecheck == null)
{
model.Sales = ((Db.sales.Where(c => c.Purchase.product.Name == model.productName).ToList()).Where(c => c.Purchase.expireDate >= model.sDate && c.Purchase.expireDate <= model.eDate).ToList()).Where(c => c.quantity <= c.Purchase.product.ReorderLevel).ToList();
}
else if (model.Reordercheck == "true" && model.Expirecheck == "true")
{
model.Sales = ((Db.sales.Where(c => c.Purchase.product.Name == model.productName).ToList()).Where(c => c.Purchase.expireDate >= model.sDate && c.Purchase.expireDate <= model.eDate).ToList()).Where(c => c.quantity <= c.Purchase.product.ReorderLevel && c.Purchase.expireDate <= model.eDate).ToList();
}
else if (model.Reordercheck == null && model.Expirecheck == "true")
{
model.Sales = ((Db.sales.Where(c => c.Purchase.product.Name == model.productName).ToList()).Where(c => c.Purchase.expireDate >= model.sDate && c.Purchase.expireDate <= model.eDate).ToList()).Where(c => c.Purchase.expireDate <= model.eDate).ToList();
}
//model.stockoutBlance=model.Purchases.Where(c=>c.).
return(RedirectToAction("index"));
}
/// <summary>
/// Insert Stocks
/// </summary>
/// <param name="entity"></param>
/// <returns>Message</returns>
public async Task <string> InsertStocks(StockVM entity)
{
var result = string.Empty;
try
{
StockDetails stockdetail = new StockDetails();
var dataProduct = new StocksRepository(logger).GetAll().Result.FirstOrDefault(c => c.ProductId.Equals(entity.ProductId));
stockdetail.StockQuantity = dataProduct.Quantity;
stockdetail.TransQuantity = decimal.Subtract(dataProduct.Quantity, entity.Quantity);
stockdetail.TotalQuantity = entity.Quantity;
stockdetail.Date = entity.Date;
stockdetail.PurcheaseId = entity.PurcheaseId;
stockdetail.SalesId = entity.SalesId;
stockdetail.PurcheaseReturnId = entity.PurcheaseReturnId;
stockdetail.SalesReturnId = entity.SalesReturnId;
stockdetail.StockStutes = entity.StockStutes;
result = await new StockDetailsBL(logger).InsertStockDetails(stockdetail);
result = await new StocksRepository(logger).Insert(entity);
return(result);
}
catch (Exception ex)
{
logger.Error(ex.Message);
throw ex;
}
}
public ActionResult SearchByReorderLevel(StockVM stockVM)
{
_product.ProductName = stockVM.ProductName;
_product.CategoryName = stockVM.CategoryName;
List <StockVM> products = _productManager.GetProductsWithCatagory(_product).Select(c => new StockVM
{
ProductName = c.ProductName,
CategoryName = c.Category.CategoryName,
ReorderLevel = c.ReorderLevel,
Code = c.ProductCode,
}).ToList();
foreach (var product in products)
{
Product pro = new Product();
pro.ProductName = product.ProductName;
pro.ProductCode = product.Code;
pro.CategoryName = product.CategoryName;
pro.ReorderLevel = product.ReorderLevel;
var availableQuantity = _productManager.AvailableQuantity(pro);
foreach (var item in products)
{
if (item.ProductName == pro.ProductName)
{
item.Code = pro.ProductCode;
item.ProductName = pro.ProductName;
item.CategoryName = pro.CategoryName;
item.ReorderLevel = pro.ReorderLevel;
item.Quantity = availableQuantity.Quantity;
}
}
}
return(View(stockVM));
}
/// <summary>
/// Update Purchases
/// </summary>
/// <param name="entity"></param>
/// <returns>Message</returns>
public async Task <string> UpdatePurchases(Purchases entity)
{
var result = string.Empty;
try
{
using (TransactionScope txScope = new TransactionScope())
{
//Insert in Purchease
result = await new PurchasesRepository(logger).Update(entity);
var purd = new PurcheaseDetailsRepository(logger).GetAll().Result.Where(c => c.PurchaseId.Equals(entity.Id));
//Delete in PurcheaseDetail
foreach (var data in purd)
{
var stockdata = new StocksRepository(logger).GetAll().Result.FirstOrDefault(c => c.ProductId.Equals(data.ProductId));
if (stockdata != null)
{
stockdata.Quantity = stockdata.Quantity - data.Quantity;
result = await new StocksRepository(logger).Update(stockdata);
}
result = await new PurcheaseDetailsRepository(logger).Delete(data.Id);
}
foreach (PurcheaseDetails datas in entity.PurcheaseDetails.ToList())
{
var stockdata = new StocksRepository(logger).GetAll().Result.FirstOrDefault(c => c.ProductId.Equals(datas.ProductId));
if (stockdata != null)
{
if (stockdata.Quantity < datas.Quantity)
{
var Quantity = decimal.Add(stockdata.Quantity, datas.Quantity);
stockdata.Quantity = Quantity;
}
else if (stockdata.Quantity > datas.Quantity)
{
stockdata.Quantity = decimal.Subtract(stockdata.Quantity, datas.Quantity);
}
stockdata.UnitPrice = datas.UnitePrice;
result = await new StocksRepository(logger).Update(stockdata);
}
else
{
StockVM svm = new StockVM {
ProductId = datas.ProductId, UnitPrice = datas.UnitePrice, Quantity = datas.Quantity
};
result = await new StocksRepository(logger).Insert(svm);
}
datas.PurchaseId = entity.Id;
result = await new PurcheaseDetailsRepository(logger).Insert(datas);
}
txScope.Complete();
}
return(result);
}
catch (Exception ex)
{
logger.Error(ex.Message);
throw ex;
}
}
public ActionResult GetByProductDetails(int productName)
{
StockVM stockVM = new StockVM();
var productList = _stockManager.GetByProductDetails(productName);
ViewBag.ExpiredList = productList;
return(PartialView("Shared/ProductDetails"));
}
public ActionResult SearchByExpiredDate(DateTime StartDate, DateTime EndDate, Product product)
{
StockVM stockVM = new StockVM();
var productList = _stockManager.SearchByExpiredDate(StartDate, EndDate, product);
ViewBag.ExpiredList = productList;
return(PartialView("Shared/ProductList"));
}
public async Task <ActionResult <WrapperStockListVM> > DeleteStock([FromBody] StockVM Temp)
{
WrapperStockListVM vb = new WrapperStockListVM();
vb = await _serviceWrapper.StockService.Delete(Temp);
_utilService.Log("Stock Successfully Deleted");
return(vb);
}
public async Task <ActionResult <WrapperStockListVM> > AddStock([FromBody] StockVM VM)
{
WrapperStockListVM result = new WrapperStockListVM();
VM.ExpiryDate = VM.ExpiryDate.ToLocalTime();
result = await _serviceWrapper.StockService.Add(VM);
_utilService.Log("Stock Successfully Added");
return(Ok(result));
}
public ActionResult Index()
{
StockVM model = new StockVM();
model.ProductList = _manager.ShowProduct().Select(c => new SelectListItem {
Value = c.ID.ToString(), Text = c.Name
}).ToList();
model.Sales = _manager.sales();
return(View(model));
}
public IActionResult StockProductDetail(int ProductId)
{
Product product = dbContext.Products
.Include(p => p.ProductType)
.Include(p => p.Stocks)
.FirstOrDefault(p => p.ProductId == ProductId);
StockVM model = new StockVM();
model.Product = product;
return(View(model));
}
public IActionResult AddNewStock([FromBody] StockVM stock)
{
if (!ModelState.IsValid)
{
return(Json(new JSONResponseVM {
success = false, message = "Model state isn't valid"
}));
}
//get the portfolioId
var port = httpContext?.HttpContext?.User?.FindFirst(JwtRegisteredClaimNames.Azp).Value;
Guid portId;
//is this portId legit?
if (!Guid.TryParse(port, out portId))
{
return(Json(new JSONResponseVM {
success = false, message = "Model state isn't valid"
}));
}
Stock exists = context.Stocks.Where(s => s.symbol == stock.symbol).FirstOrDefault();
if (exists != null)
{
//if the stock exists just add to the stocks quantity owned
//as in our system assets are never truely deleted from the system
//just the quantity owned gets set to zero
exists.quantityOwned += stock.quantityOwned;
context.SaveChanges();
return(Json(new JSONResponseVM {
success = true, message = "The stocks quantity has been added to"
}));
}
else
{
Stock newStock = new Stock
{
stockId = Guid.NewGuid(),
name = stock.name,
symbol = stock.symbol,
quantityOwned = stock.quantityOwned,
portfolioId = portId,
Portfolio = context.Portfolios.Where(p => p.portfolioId == portId).FirstOrDefault()
};
context.Stocks.Add(newStock);
context.SaveChanges();
return(Json(new JSONResponseVM {
success = true, message = newStock.symbol + " has been added!"
}));
}
}
/// <summary>
/// Update Stocks
/// </summary>
/// <param name="entity"></param>
/// <returns>Message</returns>
public async Task <string> UpdateStocks(StockVM entity)
{
try
{
var result = await new StocksRepository(logger).Update(entity);
return(result);
}
catch (Exception ex)
{
logger.Error(ex.Message);
throw ex;
}
}
async public Task <ActionResult> ViewAll()
{
var equipments = await Db.Equipments.ToListAsync();
var cables = await Db.CableRolls.ToListAsync();
var stockVm = new StockVM()
{
Cables = cables,
Equipments = equipments
};
return(View(stockVm));
}
public async Task <ActionResult> Edit(StockVM data)
{
string result = string.Empty;
try
{
result = await repo.UpdateStocks(data);
}
catch (Exception ex)
{
throw;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public JsonResult SaveStock(StockVM stock)
{
bool status = false;
if (stock.ItemDetails != null)
{
foreach (var value in stock.ItemDetails)
{
var data = dc.Stocks.Where(x => x.ItemID == value.ItemID).ToList();
if (data.Count != 0)
{
status = true;
}
else
{
Stock S = new Stock();
S.ItemID = value.ItemID;
S.CategoryID = value.CategoryID;
S.VendorID = value.VendorID;
S.ItemName = value.ItemName;
S.Quantity = 0;
S.ExpDate = value.ExpDate;
S.MfgDate = value.MfgDate;
S.PurchasePrice = value.PurchasePrice;
S.UnitPrice = value.UnitPrice;
S.LeadTime = value.LeadTime;
S.Unit_of_Measure = value.Unit_of_Measure;
string Day = DateTime.Now.Day.ToString();
string Month = DateTime.Now.Month.ToString();
string Year = DateTime.Now.Year.ToString();
S.AddedDay = Day;
S.AddedMonth = Month;
S.AddedYear = Year;
dc.Stocks.InsertOnSubmit(S);
}
}
dc.SubmitChanges();
status = true;
}
else
{
status = false;
}
return(new JsonResult {
Data = new { status = status }
});
}
public async Task <JsonResult> Delete(string ids)
{
string result = string.Empty;
string[] IdList = ids.Split('~');
StockVM vm = new StockVM();
try
{
result = await repo.IsDeleteStocks(IdList, vm);
}
catch (Exception ex)
{
throw;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public ActionResult Delete(int id, StockVM stockk)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://localhost:54964/api/StocksApi");
//HTTP DELETE
var deleteTask = client.DeleteAsync("StocksApi/" + id.ToString());
deleteTask.Wait();
var result = deleteTask.Result;
if (result.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
}
return(RedirectToAction("Index"));
}
public List <StockVM> GetOnlyStock()
{
List <StockVM> stockvm = new List <StockVM>();
var stk = _stockService.GetStocks();
foreach (var item in stk)
{
StockVM stockVM = new StockVM()
{
StockId = item.StockId,
ProductId = item.ProductName,
SupplierId = item.SupplierName,
Quatity = item.Quantity,
};
stockvm.Add(stockVM);
}
return(stockvm);
}
public List <StockVM> UpdateStock(int stockId, int quantity)
{
List <StockVM> stockvm = new List <StockVM>();
var stk = _stockService.Update(stockId, quantity);
foreach (var item in stk)
{
StockVM stockVM = new StockVM()
{
StockId = item.StockId,
ProductId = item.ProductName,
SupplierId = item.SupplierName,
Quatity = item.Quantity,
};
stockvm.Add(stockVM);
}
return(stockvm);
}
public void AddStock(StockVM stockVM)
{
try
{
var stock = _mapper.Map <Stock>(stockVM);
_unitOfWork.Repository <Stock>().Add(stock);
_unitOfWork.CommitSync();
}
catch (CustomException exc)
{
throw exc;
}
catch (Exception ex)
{
throw CustomException.Create <ProductApplicationService>("Unexpected error fetching add stock", nameof(this.AddStock), ex);
}
}
/// <summary>
/// Delete Stocks
/// </summary>
/// <param name="Id"></param>
/// <returns>Message</returns>
public async Task <string> IsDeleteStocks(string[] IdList, StockVM entity)
{
string result = string.Empty;
try
{
for (int i = 0; i < IdList.Length - 1; i++)
{
result = await new StocksRepository(logger).IsDelete(Convert.ToInt32(IdList[i]), entity);
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
throw ex;
}
return(result);
}
public ActionResult Search(StockVM stockVM, DateTime startDate, DateTime endDate)
{
_product.ProductName = stockVM.ProductName;
_product.CategoryName = stockVM.CategoryName;
try
{
List <StockVM> products = _productManager.GetProductsWithCatagory(_product).Select(c => new StockVM
{
ProductId = c.ProductId,
ProductName = c.ProductName,
CategoryName = c.Category.CategoryName,
ReorderLevel = c.ReorderLevel,
Code = c.ProductCode,
}).ToList();
foreach (var product in products)
{
Product pro = new Product();
pro.ProductId = product.ProductId;
pro.ProductName = product.ProductName;
var aProduct = _stockManager.GetProductAvailableQuantity(pro);
var expireDate = _productManager.PurchaseDetails(pro, startDate, endDate);
foreach (var item in products)
{
if (item.ProductName == pro.ProductName)
{
item.Quantity = aProduct;
item.ProductId = pro.ProductId;
item.ExpireDate = expireDate.ExpireDate;
TempData["SuccessMessage"] = "Search Successfully";
}
}
}
ViewBag.Products = products;
}
catch (Exception ex)
{
TempData["SuccessMessage"] = "Search data not found";
}
return(View());
}
public async Task <int> AddStock(StockVM stock)
{
if (ModelState.IsValid)
{
try
{
ProductColor newPColor = new ProductColor();
ProductSize newPSize = new ProductSize();
newPColor.Color = stock.color;
newPColor.ProductId = stock.Id;
await _db.ProductColors.AddAsync(newPColor);
newPSize.Size = stock.size;
newPSize.ProductId = stock.Id;
await _db.ProductSizes.AddAsync(newPSize);
var Stock = new Stock {
ProductColorId = newPColor.Id,
ProductSizeId = newPSize.Id,
Quantity = stock.count,
};
await _db.Stocks.AddAsync(Stock);
await _db.SaveChangesAsync();
return(Response.StatusCode = StatusCodes.Status200OK);
}
catch (System.Exception)
{
return(Response.StatusCode = StatusCodes.Status200OK);
}
}
else
{
return(Response.StatusCode = StatusCodes.Status400BadRequest);
};
}
public ActionResult Index()
{
var stoctVlue = _IRelativeProfitService.GetStockNameList();
List <StockName> RadioItemList = new List <StockName>();
foreach (var item in stoctVlue)
{
StockName stockName = new StockName();
stockName.StockCode = item.StockCode;
stockName.Name = item.Name;
RadioItemList.Add(stockName);
}
StockVM stoctVM = new StockVM();
stoctVM.RadioItemList = RadioItemList;
return(View(stoctVM));
}
// GET: api/StocksApi
public IQueryable <StockVM> Getstocks()
{
List <StockVM> stockVMs = new List <StockVM>();
var StockObj = (from a in db.stocks
join b in db.stores
on a.store_id equals b.store_id
join c in db.products
on a.product_id equals c.product_id
select new { b.store_name, c.product_name, a.quantity }).ToList();
foreach (var item in StockObj)
{
StockVM stockVMObj = new StockVM();
stockVMObj.quantity = item.quantity;
stockVMObj.store_name = item.store_name;
stockVMObj.product_name = item.product_name;
stockVMs.Add(stockVMObj);
}
return(stockVMs.AsQueryable());
}
