public ActionResult Create([Bind(Include = "Id,ProdId,UserId,Quantity,Date,Reason")] ProductOut productOut)
{
if (ModelState.IsValid)
{
int totalProducts = db.Products.
Where(p => p.Id == productOut.ProdId).
Select(p => p.Quantity).
FirstOrDefault();
int netQuantity = totalProducts - productOut.Quantity;
if (productOut.Quantity > 0)
{
if (productOut.Quantity <= totalProducts)
{
db.ProductOuts.Add(productOut);
db.SaveChanges();
UpdateProductQuantity(productOut.ProdId, netQuantity);
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Error: 'Quantity' cannot exceed available items!");
}
}
else
{
ModelState.AddModelError("", "Error: 'Quantity' cannot be 0 or less!");
}
}
ViewBag.ProdId = new SelectList(db.Products, "Id", "Name", productOut.ProdId);
ViewBag.UserId = new SelectList(db.Users, "Id", "Name", productOut.UserId);
return(View(productOut));
}
internal void Delete(ProductOut productOut)
{
command = database.GetStoredProcCommand("spProductOutDelete");
database.AddInParameter(command, "@ProductOutID", SqlDbType.Int, productOut.ProductOutID.Value);
database.ExecuteNonQuery(command);
}
public ActionResult DeleteConfirmed(int id)
{
ProductOut productOut = db.ProductOuts.Find(id);
db.ProductOuts.Remove(productOut);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ProductOutID,ProductCode,Qty,Notes")] ProductOut productOut)
{
if (ModelState.IsValid)
{
ProductOut obj = db.ProductsOut.Find(productOut.ProductOutID);
int qtyBefore = obj.Qty;
obj.Qty = productOut.Qty;
obj.ProductCode = productOut.ProductCode;
obj.Notes = productOut.Notes;
DateTime date = Date.getDate();
DateTime fromDate = new DateTime(2014, 01, 01);
string query = string.Format("EXEC [dbo].[sp_GetReportStock] @dateFrom = '{0}', @dateTo = '{1}'", fromDate.ToString("yyyy-MM-dd"), date.ToString("yyyy-MM-dd"));
IEnumerable <ReportStock> list = db.Database.SqlQuery <ReportStock>(query);
int stock = list.Where(o => o.ProductCode == productOut.ProductCode).FirstOrDefault().Stock + qtyBefore;
var oldobj = db.ProductsOut.Find(productOut.ProductOutID);
var productName = db.Products.Where(o => o.ProductCode == productOut.ProductCode).FirstOrDefault().ProductName;
if (productOut.Qty <= stock)
{
db.Entry(obj).State = EntityState.Modified;
db.SaveChanges();
Logger.AddLog(
User.Identity.Name,
productOut.ProductOutID,
Logger.ProductOut,
Logger.Edit,
Logger.DescriptionQty(productOut.ProductCode, productName, productOut.Qty, qtyBefore)
);
return(RedirectToAction("Index"));
}
else
{
ViewBag.msg = "Quantity can't be greater than stock (" + stock.ToString() + ")";
}
}
IEnumerable <Product> listProduct = db.Products;
foreach (var item in listProduct)
{
item.ProductName = item.ProductCode + " - " + item.ProductName;
}
ViewBag.ProductCode = new SelectList(listProduct, "ProductCode", "ProductName", productOut.ProductCode);
return(View(productOut));
}
public ActionResult Edit([Bind(Include = "ProductOutID,ProductCode,Qty,Notes")] ProductOut productOut)
{
if (ModelState.IsValid)
{
db.Entry(productOut).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProductID = new SelectList(db.Products, "ProductCode", "ProductCode", productOut.ProductCode);
return(View(productOut));
}
public ActionResult Edit([Bind(Include = "Id,ProdId,UserId,Quantity,Date,Reason")] ProductOut productOut)
{
if (ModelState.IsValid)
{
db.Entry(productOut).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProdId = new SelectList(db.Products, "Id", "Name", productOut.ProdId);
ViewBag.UserId = new SelectList(db.Users, "Id", "Name", productOut.UserId);
return(View(productOut));
}
public ActionResult Create([Bind(Include = "ProductOutID,Date,ProductCode,Qty,Notes")] ProductOut productOut)
{
productOut.Date = System.DateTime.Today;
if (ModelState.IsValid)
{
db.ProductsOut.Add(productOut);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProductCode = new SelectList(db.Products, "ProductCode", "ProductCode", productOut.ProductCode);
return(View(productOut));
}
public IActionResult GetProducts()
{
//return Ok(this.productRepository.GetAllWithInventory());
var simpleProductList = new List <ProductOut>();
var completeProductList = this.productRepository.GetAll()
.Include(p => p.Category)
.Include(p => p.Inventory)
.Include(p => p.Location)
.Include(p => p.ProductModel)
.Include(p => p.Status)
.Include(p => p.Category)
.Include(p => p.Supplier)
.Include(p => p.Color)
.Include(p => p.Size);
foreach (var product in completeProductList)
{
var newProd = new ProductOut()
{
ReferenceCode = product.ReferenceCode,
Value = product.Value,
ImageFullPath = product.ImageFullPath,
InventoryName = product.Inventory.Name,
InventoryManagerName = product.Inventory.UserName,
Location = product.Location.Name,
Status = product.Status.Name,
Category = product.Category.Name,
ProductModel = product.ProductModel.Name,
Supplier = product.Supplier.Name,
EntryDate = product.EntryDate,
LastChangeDate = product.LastChangeDate
};
//TO DELETE
if (product.Color != null)
{
newProd.Color = product.Color.Name;
}
if (product.Size != null)
{
newProd.Size = product.Size.Name;
}
simpleProductList.Add(newProd);
}
return(Ok(simpleProductList));
}
internal int Save(ProductOut productOut)
{
command = database.GetStoredProcCommand("spProductOutSave");
if (productOut.ProductOutID.HasValue)
{
database.AddInParameter(command, "@ProductOutID", SqlDbType.Int, productOut.ProductOutID.Value);
}
database.AddInParameter(command, "@ProductInID", SqlDbType.Int, productOut.ProductInID);
database.AddInParameter(command, "@Amount", SqlDbType.Float, productOut.Amount);
database.AddInParameter(command, "@Count", SqlDbType.Int, productOut.Count);
database.AddInParameter(command, "@UserID", SqlDbType.Int, productOut.UserID);
return((int)database.ExecuteScalar(command));
}
// GET: ProductOuts/Details/5
//[Authorize(Roles = "admin")]
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductOut productOut = db.ProductsOut.Find(id);
if (productOut == null)
{
return(HttpNotFound());
}
return(View(productOut));
}
public async Task <ProductOut> GetProducts()
{
return(await AsyncHelper.AsyncFunction <ProductOut>(() =>
{
ProductOut productOut = new ProductOut();
productOut.Products = _context.Products.Select(x => new ProductModel
{
ProductId = x.ProductId,
Name = x.Name,
}).ToList();
return productOut;
}));
}
// GET: ProductOuts/Edit/5
//[Authorize(Roles = "admin")]
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductOut productOut = db.ProductsOut.Find(id);
if (productOut == null)
{
return(HttpNotFound());
}
ViewBag.ProductCode = new SelectList(db.Products, "ProductCode", "ProductCode", productOut.ProductCode);
return(View(productOut));
}
public ActionResult Create([Bind(Include = "ProductOutID,Date,ProductCode,Qty,Notes")] ProductOut productOut)
{
DateTime date = Date.getDate();
productOut.Date = date;
if (ModelState.IsValid)
{
DateTime fromDate = new DateTime(2014, 01, 01);
string query = string.Format("EXEC [dbo].[sp_GetReportStock] @dateFrom = '{0}', @dateTo = '{1}'", fromDate.ToString("yyyy-MM-dd"), date.ToString("yyyy-MM-dd"));
IEnumerable <ReportStock> list = db.Database.SqlQuery <ReportStock>(query);
int stock = list.Where(o => o.ProductCode == productOut.ProductCode).FirstOrDefault().Stock;
//var obj = db.Products.Where(o => o.ProductCode == sale.ProductCode).FirstOrDefault();
//sale. = obj.ProductID;
//var oldobj = db.ProductsOut.Find(productOut.ProductOutID);
var productName = db.Products.Where(o => o.ProductCode == productOut.ProductCode).FirstOrDefault().ProductName;
if (productOut.Qty <= stock)
{
db.ProductsOut.Add(productOut);
db.SaveChanges();
Logger.AddLog(
User.Identity.Name,
productOut.ProductOutID,
Logger.ProductOut,
Logger.Add,
Logger.DescriptionQty(productOut.ProductCode, productName, productOut.Qty, productOut.Qty)
);
return(RedirectToAction("Index"));
}
else
{
ViewBag.msg = "Quantity can't be greater than stock (" + stock.ToString() + ")";
}
}
ViewBag.ProductCode = new SelectList(db.Products, "ProductCode", "ProductCode", productOut.ProductCode);
return(View(productOut));
}
public ActionResult DeleteConfirmed(int id)
{
ProductOut productOut = db.ProductsOut.Find(id);
var productName = db.Products.Where(o => o.ProductCode == productOut.ProductCode).FirstOrDefault().ProductName;
db.ProductsOut.Remove(productOut);
db.SaveChanges();
Logger.AddLog(
User.Identity.Name,
productOut.ProductOutID,
Logger.ProductOut,
Logger.Delete,
Logger.DescriptionQty(productOut.ProductCode, productName, productOut.Qty, productOut.Qty)
);
return(RedirectToAction("Index"));
}
public PurchaseOut(InventoryDBContext context, PurchaseDTO dto)
: base(dto)
{
this.ProductDetails = new List <ProductPurchaseDetails>();
// products
string[] productIDs = dto.ProductIDs.Split(',');
string[] productQuantities = dto.ProductQuantities.Split(',');
string[] productBuyingPrices = dto.ProductBuyingPrices.Split(',');
int numProducts = productIDs.Length;
for (int i = 0; i < numProducts; ++i)
{
int id = int.Parse(productIDs[i]);
ProductOut productOut = new ProductOut(context, context.GetProduct(id));
int Quantity = int.Parse(productQuantities[i]);
double BuyingPrice = double.Parse(productBuyingPrices[i]);
this.ProductDetails.Add(new ProductPurchaseDetails(productOut, Quantity, BuyingPrice));
}
}
// GET: ProductOuts/Edit/5
//[Authorize(Roles = "admin")]
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductOut productOut = db.ProductsOut.Find(id);
if (productOut == null)
{
return(HttpNotFound());
}
IEnumerable <Product> listProduct = db.Products;
foreach (var item in listProduct)
{
item.ProductName = item.ProductCode + " - " + item.ProductName;
}
ViewBag.ProductCode = new SelectList(listProduct, "ProductCode", "ProductName", productOut.ProductCode);
return(View(productOut));
}
public async Task <ProductOutVM> GetProducts()
{
ProductOut products = await _iProductRepository.GetProducts();
return(Mapper.Map <ProductOutVM>(products));
}
public ProductPurchaseDetails(ProductOut productOut, int quantity, double buyingPrice)
{
Product = productOut;
Quantity = quantity;
BuyingPrice = buyingPrice;
}
public async Task <IActionResult> PostProduct([FromBody] Common.Models.Product productOut)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(ModelState));
}
var user = await this.userManager.FindByEmailAsync(productOut.InventoryManagerName);
if (user == null)
{
return(this.BadRequest("Invalid user"));
}
var imageUrl = string.Empty;
if (productOut.ImageArray != null && productOut.ImageArray.Length > 0)
{
var stream = new MemoryStream(productOut.ImageArray);
var guid = Guid.NewGuid().ToString();
var file = $"{guid}.jpg";
var folder = "wwwroot\\images\\Products";
var fullPath = $"~/images/Products/{file}";
var response = FilesHelper.UploadPhoto(stream, folder, file);
if (response)
{
imageUrl = fullPath;
}
}
//Get the new index
var newIndex = 1;
var allProducts = await this.productRepository.GetAll().ToListAsync();
var contains = allProducts.Exists(p => p.ReferenceCode.Substring(0, 16) == productOut.ReferenceCode);
if (contains)
{
var lastProd = (await this.productRepository.GetAll().ToListAsync()).FindLast(p => p.ReferenceCode.Substring(0, 16) == productOut.ReferenceCode);
var lastIndex = Int32.Parse(lastProd.ReferenceCode.Substring(16));
newIndex = lastIndex + 1;
}
var entityProduct = new Product
{
ReferenceCode = productOut.ReferenceCode + newIndex,
Value = productOut.Value,
ImageUrl = imageUrl,
EntryDate = DateTime.Now,
InventoryId = (await this.context.Inventory.FirstOrDefaultAsync(i => i.Name == productOut.InventoryName)).Id,
LocationId = (await this.context.Locations.FirstOrDefaultAsync(l => l.Name == productOut.Location)).Id,
StatusId = (await this.context.Status.FirstOrDefaultAsync(st => st.Name == productOut.Status)).Id,
CategoryId = (await this.context.Categories.FirstOrDefaultAsync(ct => ct.Name == productOut.Category)).Id,
ProductModelId = (await this.context.ProductModel.FirstOrDefaultAsync(m => m.Name == productOut.ProductModel)).Id,
SupplierId = (await this.context.Suppliers.FirstOrDefaultAsync(sp => sp.Name == productOut.Supplier)).Id,
ColorId = (await this.context.Colors.FirstOrDefaultAsync(cl => cl.Name == productOut.Color)).Id,
SizeId = (await this.context.Sizes.FirstOrDefaultAsync(sz => sz.Name == productOut.Size)).Id,
LastChangeDate = DateTime.Now
};
await this.productRepository.CreateAsync(entityProduct);
var newProduct = await this.context.Products.FirstOrDefaultAsync(p => p.ReferenceCode == entityProduct.ReferenceCode);
var newProdOut = new ProductOut()
{
ReferenceCode = newProduct.ReferenceCode,
Value = newProduct.Value,
ImageFullPath = newProduct.ImageFullPath,
InventoryName = newProduct.Inventory.Name,
InventoryManagerName = newProduct.Inventory.UserName,
Location = newProduct.Location.Name,
Status = newProduct.Status.Name,
Category = newProduct.Category.Name,
ProductModel = newProduct.ProductModel.Name,
Supplier = newProduct.Supplier.Name,
Color = newProduct.Color.Name,
Size = newProduct.Size.Name,
EntryDate = newProduct.EntryDate,
LastChangeDate = newProduct.LastChangeDate
};
return(Ok(newProdOut));
}
public async Task <IActionResult> PutProduct([FromRoute] string referenceCode, [FromBody] ProductOut productOut)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(ModelState));
}
//var oldProduct = await this.productRepository.GetByIdAsync(id);
var oldProduct = await this.productRepository.GetAll().FirstOrDefaultAsync(p => p.ReferenceCode == referenceCode);
if (oldProduct == null)
{
return(this.BadRequest("Product ReferenceCode doesn't exists."));
}
//TODO: Upload images
//oldProduct.ReferenceCode = productOut.ReferenceCode;
oldProduct.Value = productOut.Value;
//oldProduct.ImageUrl = productOut.ImageFullPath.Substring(30);
oldProduct.LastChangeDate = DateTime.Now;
//oldProduct.InventoryId = (await this.context.Inventory.FirstOrDefaultAsync(i => i.Name == productOut.InventoryName)).Id;
var location = await this.context.Locations.FirstOrDefaultAsync(l => l.Name == productOut.Location);
oldProduct.LocationId = location.Id;
var status = await this.context.Status.FirstOrDefaultAsync(st => st.Name == productOut.Status);
oldProduct.StatusId = status.Id;
//oldProduct.CategoryId = (await this.context.Categories.FirstOrDefaultAsync(i => i.Name == productOut.Category)).Id;
//oldProduct.ProductModelId = (await this.context.ProductModel.FirstOrDefaultAsync(i => i.Name == productOut.ProductModel)).Id;
//oldProduct.SupplierId = (await this.context.Suppliers.FirstOrDefaultAsync(i => i.Name == productOut.Supplier)).Id;
//oldProduct.ColorId = (await this.context.Colors.FirstOrDefaultAsync(i => i.Name == productOut.Color)).Id;
//oldProduct.SizeId = (await this.context.Sizes.FirstOrDefaultAsync(i => i.Name == productOut.Size)).Id;
oldProduct.LastChangeDate = DateTime.Now;
await this.productRepository.UpdateAsync(oldProduct);
var updatedProduct = await this.context.Products.FirstOrDefaultAsync(p => p.ReferenceCode == oldProduct.ReferenceCode);
var updatedProdOut = new ProductOut()
{
ReferenceCode = updatedProduct.ReferenceCode,
Value = updatedProduct.Value,
ImageFullPath = updatedProduct.ImageFullPath,
InventoryName = productOut.InventoryName,
InventoryManagerName = productOut.InventoryManagerName,
Location = location.Name,
Status = status.Name,
Category = productOut.Category,
ProductModel = productOut.ProductModel,
Supplier = productOut.Supplier,
Color = productOut.Color,
Size = productOut.Size,
LastChangeDate = updatedProduct.LastChangeDate
};
return(Ok(updatedProdOut));
}
protected override void Execute(CodeActivityContext executionContext)
{
#region "Load CRM Service from context"
Common objCommon = new Common(executionContext);
objCommon.tracingService.Trace("Load CRM Service from context --- OK");
#endregion
#region "Read Parameters"
String _ProdEntityName = "product";
String _ProdLookupField1 = this.ProdLookupField1.Get(executionContext);
String _ProdLookupField2 = this.ProdLookupField2.Get(executionContext);
String _ProdFieldValue1 = this.ProdFieldValue1.Get(executionContext);
String _ProdFieldValue2 = this.ProdFieldValue2.Get(executionContext);
objCommon.tracingService.Trace(String.Format("ProdEntityName: {0} - ProdLookupField1:{1} - ProdLookupField2:{2} - ProdFieldValue1:{3} ProdFieldValue2:{4}",
_ProdEntityName, _ProdLookupField1, _ProdLookupField2, _ProdFieldValue1, _ProdFieldValue2));
#endregion
#region "QueryExpression Execution"
QueryExpression qe = new QueryExpression();
qe.EntityName = _ProdEntityName;
qe.ColumnSet = new ColumnSet("productid");
//prevent query from running forever with duplicate records
qe.PageInfo = new PagingInfo();
qe.PageInfo.Count = 2;
qe.PageInfo.PageNumber = 1;
FilterExpression filter = new FilterExpression(LogicalOperator.And);
if (_ProdLookupField1 != null && _ProdFieldValue1 != "")
{
ConditionExpression condition1 = new ConditionExpression();
condition1.AttributeName = _ProdLookupField1;
condition1.Values.Add(_ProdFieldValue1);
condition1.Operator = ConditionOperator.Equal;
filter.Conditions.Add(condition1);
}
if (_ProdLookupField2 != null && _ProdFieldValue2 != "")
{
ConditionExpression condition2 = new ConditionExpression();
condition2.AttributeName = _ProdLookupField2;
condition2.Values.Add(_ProdFieldValue2);
condition2.Operator = ConditionOperator.Equal;
filter.Conditions.Add(condition2);
}
ConditionExpression condition3 = new ConditionExpression();
condition3.AttributeName = "statecode";
condition3.Values.Add(0); //active records
condition3.Operator = ConditionOperator.Equal;
filter.Conditions.Add(condition3);
qe.Criteria = filter;
EntityCollection ProdResults = objCommon.service.RetrieveMultiple(qe);
if (ProdResults.Entities.Count > 0)
{
ProdFoundOne.Set(executionContext, true);
ProductOut.Set(executionContext, new EntityReference("product", ProdResults[0].Id));
}
if (ProdResults.Entities.Count > 1)
{
ProdFoundMultiple.Set(executionContext, true);
}
#endregion
}
