public ProductStockModel UpdateProductStock(ProductStockModel _productStockModel)
{
try
{
using (_context = new HSSNInventoryEntities())
{
var data =
_context.ProductStocks.FirstOrDefault(a => a.ProductId == _productStockModel.ProductId &&
a.OrganisationId == _productStockModel.OrganisationId &&
a.WareHouseId == _productStockModel.WareHouseId);
if (_productStockModel.InOutMode == "IN")
{
if (data != null)
{
data.CurrentStock += _productStockModel.CurrentStock;
}
}
else
{
if (data != null)
{
data.CurrentStock -= _productStockModel.CurrentStock;
}
}
_context.Entry(data).State = EntityState.Modified;
_context.SaveChanges();
return(_productStockModel);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// Validates the product stock model.
/// </summary>
/// <param name="model">The model.</param>
/// <exception cref="Exception">User Not Found</exception>
private async Task ValidateProductStockModel(ProductStockModel model)
{
if (!await IsUserExists(model.UserId))
{
throw new Exception("User Not Found");
}
if (!await IsProductExists(model.ProductId))
{
throw new Exception("Product Not Found");
}
if (!await IsPeriodTypeExists(model.PeriodTypeId))
{
throw new Exception("Period Type Not Found");
}
if (!await IsUnitTypeExists(model.UnitTypeId))
{
throw new Exception("Unit Type Not Found");
}
if (await IsProductAlreadyExists(model))
{
throw new Exception("The product already exists");
}
}
/// <summary>
/// Creates stock for the selected product, and removes from stock the ingredient quantities used
/// </summary>
private void CreateProductStockButton_Click(object sender, EventArgs e)
{
int quantityToCreate = int.Parse(QuantityToCreateTextBox.Text);
if (ValidateIngredientsAvailability(SelectedProduct_RecipeIngredients, quantityToCreate))
{
ProductModel selectedProduct = (ProductModel)ProductListBox.SelectedItem;
ProductStockModel selectedProductStock = new ProductStockModel
{
ProductId = selectedProduct.Id,
Quantity = quantityToCreate
};
RMS_Logic.PurchasingLogic.AddProductToStock(selectedProductStock);
List <OrderProductModel> productsToRemoveFromStock = new List <OrderProductModel>();
foreach (RecipeAndContentModel ingredient in SelectedProduct_RecipeIngredients)
{
productsToRemoveFromStock.Add(new OrderProductModel
{
OrderedQuantity = ingredient.ProductQuantity * quantityToCreate,
ProductId = ingredient.ProductId
});
}
RMS_Logic.SalesLogic.UnBookProducts(productsToRemoveFromStock);
RMS_Logic.SalesLogic.RemoveProductsFromStock(productsToRemoveFromStock);
Clear();
//TODO - Record Journal transation for exceptional stoc creation/deletion
}
}
/// <summary>
/// Saves the product stock.
/// </summary>
/// <param name="model">The model.</param>
private async Task SaveProductStock(ProductStockModel model)
{
await ValidateProductStockModel(model);
ProductStock productStock;
if (model.Id.HasValue)
{
productStock = await GetProductStockById(model.Id.Value);
productStock.ProductId = model.ProductId;
productStock.UserId = model.UserId;
productStock.PeriodId = model.PeriodTypeId;
productStock.UnitId = model.UnitTypeId;
productStock.UnitAmount = model.UnitAmount;
productStock.ProductAmountExist = model.ProductAmountExist.HasValue ? model.ProductAmountExist.Value : productStock.ProductAmountExist; // TODO: check!!
}
else
{
productStock = new ProductStock
{
UserId = model.UserId,
ProductId = model.ProductId,
PeriodId = model.PeriodTypeId,
UnitId = model.UnitTypeId,
UnitAmount = model.UnitAmount,
ProductAmountExist = model.ProductAmountExist
};
await _context.ProductsStock.AddAsync(productStock);
}
await _context.SaveChangesAsync();
}
public async Task SetProductStocksAsync(ProductStockModel stock)
{
var expire = GetNextDay() - DateTime.Now;
var setKey = AddKeyPrefix <ProductStockModel>("Set");
await Database.SetAddAsync(setKey, stock.ProductId);
await Database.KeyExpireAsync(setKey, expire);
var entityKey = AddKeyPrefix <ProductStockModel>(stock.ProductId.ToString());
await Database.StringSetAsync(entityKey, stock.ToJson(), expire);
}
public async Task <IActionResult> updateData([FromBody] ProductStockModel objData)
{
try
{
return(Ok(_objModule.UpdateAsync(objData)));
}
catch (Exception e)
{
return(BadRequest(e.Message.ConvertExceptionToErrorInfo()));
}
}
/// <summary>
/// UpdateAsync Product to database
/// </summary>
/// <param name="id">The id of Product</param>
/// <param name="Product">The object of Product</param>
/// <returns>null</returns>
public async Task <ProductStockModel> UpdateAsync(ProductStockModel Product)
{
var ent = UnitOfWork.Context.Entry <ProductStockModel>(Product);
ent.State = EntityState.Modified;
int re = await UnitOfWork.Context.SaveChangesAsync();
//await UnitOfWork.ProductRepository.UpdateAsync(Product);
//await SaveAsync();
return(Product);
}
public async Task <IActionResult> AddNewProductStock([FromBody] ProductStockModel model)
{
try
{
await _productStockRepository.CreateProductStock(model);
return(Ok());
}
catch (Exception ex)
{
return(Ok(ex));
}
}
public async Task <IActionResult> GatProductStock(int productStockId)
{
try
{
ProductStockModel productStock = await _productStockRepository.GetProductStock(productStockId);
return(Ok(productStock));
}
catch (Exception ex)
{
return(Ok(ex));
}
}
/// <summary>
/// Removes / frees booked products
/// </summary>
/// <param name="productsToUnbook"> Products to be removed from the booked section abd be made available to be sold</param>
public void UnBookProducts(List <OrderProductModel> productsToUnbook)
{
foreach (OrderProductModel product in productsToUnbook)
{
ProductStockModel selectedProductStock = GlobalConfig.Connection.GetProductStock_Single(product.ProductId);
if (CanUnBookProduct(product, selectedProductStock))
{
selectedProductStock.BookedQuantity -= product.OrderedQuantity;
selectedProductStock.AvailableQuantity += product.OrderedQuantity;
GlobalConfig.Connection.UpdateProductStockModel(selectedProductStock);
}
}
}
public async Task <IActionResult> UpdateProductStock(int productStockId, [FromBody] ProductStockModel model)
{
try
{
model.Id = productStockId;
await _productStockRepository.UpdateProductStock(model);
return(Ok());
}
catch (Exception ex)
{
return(Ok(ex));
}
}
/// <summary>
/// Adds a product to stock as a new entry or updating an existing one
/// </summary>
public void AddProductToStock(ProductStockModel product)
{
ProductStockModel existingProductStock = GlobalConfig.Connection.GetProductStock_Single(product.ProductId);
if (existingProductStock != null)
{
existingProductStock.Quantity += product.Quantity;
existingProductStock.AvailableQuantity += product.AvailableQuantity;
GlobalConfig.Connection.UpdateProductStockModel(existingProductStock);
}
else
{
GlobalConfig.Connection.CreateProductStock(product);
}
}
/// <summary>
/// Removes / frees booked products
/// </summary>
/// <param name="productsToRemove"> Products to be removed from the booked section abd be made available to be sold</param>
public void RemoveProductsFromStock(List <OrderProductModel> productsToRemove)
{
foreach (OrderProductModel product in productsToRemove)
{
ProductStockModel selectedProductStock = GlobalConfig.Connection.GetProductStock_Single(product.ProductId);
if (selectedProductStock != null)
{
selectedProductStock.Quantity -= product.OrderedQuantity;
selectedProductStock.AvailableQuantity -= product.OrderedQuantity;
GlobalConfig.Connection.UpdateProductStockModel(selectedProductStock);
}
}
}
/// <summary>
/// Add the product quantities on the purchase invoice in stock making them available to be sold
/// </summary>
public void AddInvoicedProductsToStock(List <PurchaseOrderDetails_Join> PurchaseOrderContentList)
{
foreach (var row in PurchaseOrderContentList)
{
if (row.ProductId != 0 && row.ProductName != "" && row.Quantity != 0)
{
ProductStockModel productStock = new ProductStockModel()
{
ProductId = row.ProductId,
Quantity = row.Quantity,
AvailableQuantity = row.Quantity,
};
AddProductToStock(productStock);
}
}
}
//Post([FromBody] ClassType classType)
public async Task <IActionResult> insertData([FromBody] ProductStockModel objData)
{
try
{
//ProductStockModel objData = new ProductStockModel();
//objData.product_id = id;
//objData.item_amt = amt;
return(Ok(_objModule.InsertAsync(objData)));
}
catch (Exception e)
{
return(BadRequest(e.Message.ConvertExceptionToErrorInfo()));
throw;
}
}
public void Test()
{
var pub = new Publisher();
Subscriber sb = new Subscriber(1, pub);
Subscriber sb2 = new Subscriber(2, pub);
// Subscriber sb3 = new Subscriber(3, pub);
// Subscriber sb4 = new Subscriber(4, pub);
var product = new ProductStockModel(1, 2, "Product A"); // get from Catalog context
pub.RemoveStock(product, 2);
//pub.AddToStock(product, 10);
var product2 = new ProductStockModel(1, 2, "Product B"); // get from Catalog context
pub.RemoveStock(product2, 4);
// pub.AddToStock(product, 10);
}
/// <summary>
/// Initializes fields in the "Product Stock " groupBox asociated with the selected product
/// </summary>
private void InitializeProductStockDetails_GroupBox(int productId)
{
if (productId > 0)
{
ProductStockModel selectedProductStock = GlobalConfig.Connection.GetProductStock_Single(productId);
if (selectedProductStock != null)
{
ProductTotalStockQuantityLabel.Text = selectedProductStock.Quantity == 0 ? "0" : selectedProductStock.Quantity.ToString();
ProductBookedQuantityLabel.Text = selectedProductStock.BookedQuantity == 0 ? "0" : selectedProductStock.BookedQuantity.ToString();
ProductAvailableQuantityLabel.Text = (selectedProductStock.Quantity - selectedProductStock.BookedQuantity).ToString();
}
else
{
ProductTotalStockQuantityLabel.Text = "0";
ProductBookedQuantityLabel.Text = "0";
ProductAvailableQuantityLabel.Text = "0";
}
}
}
private List <ProductStockModel> datafunc()
{
var listdata = new List <ProductStockModel>();
foreach (var row in grdOpeningstock.Rows)
{
var tempdata = new ProductStockModel()
{
ProductId = Convert.ToInt32(row.Cells["ProductId"].Value),
OrganisationId = 1,
WareHouseId = Convert.ToInt32(cmbWarehouse.SelectedValue),
OpeningStock = Convert.ToInt32(row.Cells["OpeningStock"].Value),
CurrentStock = Convert.ToInt32(row.Cells["OpeningStock"].Value),
InOutMode = "IN",
};
listdata.Add(tempdata);
}
_commonservice.SaveProductStock(listdata);
return(listdata);
}
public async Task <IActionResult> Create(int productId, [FromBody] ProductStockModel model)
{
if (!ModelState.IsValid)
{
_logger.LogInformation($"Invalid data submitted for product ID {model.ProductId}");
return(BadRequest(ModelState));
}
var product = await _productService.GetProduct(model.ProductId);
if (product == null)
{
_logger.LogInformation($"Product ID {model.ProductId} not found");
return(NotFound());
}
try
{
var stock = new ProductStock
{
Product = product,
PurchaseDate = model.PurchaseDate,
PurchaseQuantity = model.PurchaseQuantity,
PurchasePrice = model.PurchasePrice,
UserId = GetUserId()
};
await _productService.RestockProduct(stock);
return(Ok(model)); // Not sure if this is what _should_ be returned here or not...
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error re-stocking product ID {model.ProductId}");
return(StatusCode(500, "Error re-stocking product"));
}
}
/// <summary>
/// Insert new Product to database
/// </summary>
/// <param name="blackList">The object of Product</param>
/// <returns>The Product object</returns>
public async Task <ProductStockModel> InsertAsync(ProductStockModel objData)
{
//if (UnitOfWork.ProductStockRepository.Get(p => p.stock_trn_id == Product.stock_trn_id /*&& p.Status == StatusOfProduct.Enabled*/).Count() > 0)
// throw new Exception(new ErrorInfo
// {
// Message = $"Can not insert Product code : {Product.stock_trn_id} duplicate data",
// MessageLocal = $"ไม่สามารถเพิ่มข้อมูลนี้ได้ เนื่องจาก : {Product.stock_trn_id} มีในระบบแล้ว",
// Data = Product.stock_trn_id
// }.ConvertErrorInfoToException());
//return await UnitOfWork.ProductStockRepository.InsertAsync(Product);
using (var cmd = UnitOfWork.Context.Database.GetDbConnection().CreateCommand())
{
cmd.CommandText = "stk_trn_insert";
cmd.CommandType = CommandType.StoredProcedure;
// InPut param
cmd.Parameters.Add(new SqlParameter("@product_id", SqlDbType.BigInt)
{
Value = objData.product_id
});
cmd.Parameters.Add(new SqlParameter("@item_amt", SqlDbType.BigInt)
{
Value = objData.item_amt
});
cmd.Parameters.Add(new SqlParameter("@from_action", SqlDbType.NChar)
{
Value = objData.from_action
});
cmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.BigInt)
{
Value = objData.CreateByUserId
});
cmd.Parameters.Add(new SqlParameter("@relate_doc_id", SqlDbType.BigInt)
{
Value = objData.relate_doc_id
});
// OutPut return
cmd.Parameters.Add(new SqlParameter("@retrunID", SqlDbType.BigInt)
{
Direction = ParameterDirection.Output
});
cmd.Parameters.Add(new SqlParameter("@returnRemainAmt", SqlDbType.BigInt)
{
Direction = ParameterDirection.Output
});
//cmd.Parameters.Add(new SqlParameter("@id", SqlDbType.BigInt) { Direction = ParameterDirection.Output });
if (UnitOfWork.Context.Database.GetDbConnection().State == ConnectionState.Closed)
{
UnitOfWork.Context.Database.OpenConnection();
}
if (cmd.ExecuteNonQuery() == 0)
{
throw new Exception(new ErrorInfo
{
Message = $"Can not insert Product code : {objData.product_id} duplicate data",
MessageLocal = $"ไม่สามารถเพิ่มข้อมูลนี้ได้ เนื่องจาก : {objData.product_id} มีในระบบแล้ว",
Data = objData.product_id
}.ConvertErrorInfoToException());
}
//return await Task.Factory.StartNew(() =>
//{
objData.stock_trn_id = Convert.ToInt32(cmd.Parameters["@retrunID"].Value.ToString());;
objData.remain_amt = Convert.ToInt32(cmd.Parameters["@returnRemainAmt"].Value.ToString());
int i = Convert.ToInt32(objData.remain_amt);
return(objData);
//});
}
}
/// <summary>
/// Insert new Product to database
/// </summary>
/// <param name="blackList">The object of Product</param>
/// <returns>The Product object</returns>
public async Task <ReturnRequisitionDataModel> SaveReturnRequisitionData(ReturnRequisitionDataModel objData)
{
try
{
//ReturnRequisitionModel objMast = new ReturnRequisitionModel();
//List<ProductModel> lstProRemain = new List<ProductModel>();
//if (objData._master.description == "APR")
//{
// foreach (var item in objData._lstProducts)
// {
// var objChk = UnitOfWork.Context.Set<ProductModel>().Where(w => w.product_id.Equals(item.product_id) && w.remain_amt < item.quantity).FirstOrDefault();
// if (objChk != null)
// lstProRemain.Add(objChk);
// }
// if (lstProRemain.Count > 0)
// {
// var lstMsg = lstProRemain.Select(s => string.Format("รายการสินค้า {0} ยอดคงเหลือ {1} น้อยกว่า ยอดเบิกจ่าย", s.product_name, s.remain_amt));
// throw new Exception(new ErrorInfo
// {
// Message = string.Join("\n", lstMsg),
// MessageLocal = string.Join("\n", lstMsg),
// Data = -1
// }.ConvertErrorInfoToException());
// }
//}
objData._master.ModifyDate = DateTime.Today;
objData._master.ModifyByUserId = 1;
if (objData._master.retrun_requisition_id <= 0)
{
//objData._master.document_no = "abc";
objData._master.CreateDate = DateTime.Today;
objData._master.CreateByUserId = 1;
UnitOfWork.Context.Set <ReturnRequisitionModel>().Add(objData._master);
}
else
{
UnitOfWork.Context.Set <ReturnRequisitionModel>().Update(objData._master);
}
int i = UnitOfWork.Context.SaveChanges();
foreach (var item in objData._lstProducts)
{
item.ModifyDate = DateTime.Today;
item.ModifyByUserId = 1;
if (item.return_product_id <= 0)
{
item.retrun_requisition_id = objData._master.retrun_requisition_id;
//item.document_no = objData._master.document_no;
item.status = "Y";
item.CreateDate = DateTime.Today;
item.CreateByUserId = 1;
UnitOfWork.Context.Set <ReturnRequisitionProductModel>().Add(item);
}
else
{
UnitOfWork.Context.Set <ReturnRequisitionProductModel>().Update(item);
}
UnitOfWork.Context.SaveChanges();
if (item.return_quantity > 0)
{
ProductStockModel objStock = new ProductStockModel();
objStock.CreateByUserId = 1;
objStock.CreateDate = DateTime.Today;
objStock.ModifyByUserId = item.ModifyByUserId;
objStock.ModifyDate = item.ModifyDate;
objStock.product_id = item.product_id;
objStock.relate_doc_id = item.return_product_id;
objStock.item_amt = item.return_quantity ?? 0;
objStock.from_action = "RTN";
ProductStockModule processStock = new ProductStockModule(UnitOfWork);
await processStock.InsertAsync(objStock);
}
}
foreach (var item in objData._lstPackages)
{
//item.ModifyDate = DateTime.Today;
//item.ModifyByUserId = 1;
if (item.return_requisition_package_id <= 0)
{
item.retrun_requisition_id = objData._master.retrun_requisition_id;
//item.document_no = objData._master.document_no;
item.status = "Y";
//item.CreateDate = DateTime.Today;
//item.CreateByUserId = 1;
UnitOfWork.Context.Set <ReturnRequisitionPackageModel>().Add(item);
}
else
{
UnitOfWork.Context.Set <ReturnRequisitionPackageModel>().Update(item);
}
UnitOfWork.Context.SaveChanges();
}
foreach (var item in objData._lstItems)
{
//item.ModifyDate = DateTime.Today;
//item.ModifyByUserId = 1;
if (item.return_requisition_item_id <= 0)
{
item.retrun_requisition_id = objData._master.retrun_requisition_id;
//item.document_no = objData._master.document_no;
item.status = "Y";
//item.CreateDate = DateTime.Today;
//item.CreateByUserId = 1;
UnitOfWork.Context.Set <ReturnRequisitionItemModel>().Add(item);
}
else
{
UnitOfWork.Context.Set <ReturnRequisitionItemModel>().Update(item);
}
UnitOfWork.Context.SaveChanges();
}
return(objData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private Task <bool> IsProductAlreadyExists(ProductStockModel model)
{
return(_context.ProductsStock.AsNoTracking()
.AnyAsync(product => product.ProductId == model.ProductId && product.UserId == model.UserId));
}
/// <summary>
/// Creates the product stock.
/// </summary>
/// <param name="model">The model.</param>
public async Task CreateProductStock(ProductStockModel model)
{
await SaveProductStock(model);
}
/// <summary>
/// Insert new Product to database
/// </summary>
/// <param name="blackList">The object of Product</param>
/// <returns>The Product object</returns>
public async Task <RequisitionDataModel> SaveRequisitionData(RequisitionDataModel objData)
{
try
{
//RequisitionModel objMast = new RequisitionModel();
List <ProductModel> lstProRemain = new List <ProductModel>();
if ("APR,POS,DLV".Contains(objData._master.requisition_type))
{
foreach (var item in objData._lstProducts)
{
var objChk = UnitOfWork.Context.Set <ProductModel>()
.Where(w => w.product_id.Equals(item.product_id) && w.remain_amt < item.quantity)
.FirstOrDefault();
if (objChk != null)
{
lstProRemain.Add(objChk);
}
}
if (lstProRemain.Count > 0)
{
var lstMsg = lstProRemain.Select(s =>
string.Format("รายการสินค้า {0} ยอดคงเหลือ {1} น้อยกว่า ยอดเบิกจ่าย", s.product_name,
s.remain_amt));
throw new Exception(new ErrorInfo
{
Message = string.Join("\n", lstMsg),
MessageLocal = string.Join("\n", lstMsg),
Data = -1
}.ConvertErrorInfoToException());
}
}
objData._master.ModifyDate = DateTime.Now;
objData._master.ModifyByUserId = 1;
if (objData._master.requisition_id <= 0)
{
objData._master.document_no = "abc";
objData._master.CreateDate = DateTime.Now;
objData._master.CreateByUserId = 1;
UnitOfWork.Context.Set <RequisitionModel>().Add(objData._master);
}
else
{
UnitOfWork.Context.Set <RequisitionModel>().Update(objData._master);
}
int i = UnitOfWork.Context.SaveChanges();
foreach (var item in objData._lstProducts)
{
item.ModifyDate = DateTime.Now;
item.ModifyByUserId = 1;
if (item.id <= 0)
{
item.requisition_id = objData._master.requisition_id;
item.document_no = objData._master.document_no;
item.status = "Y";
item.CreateDate = DateTime.Now;
item.CreateByUserId = 1;
UnitOfWork.Context.Set <RequisitionProductModel>().Add(item);
}
else
{
UnitOfWork.Context.Set <RequisitionProductModel>().Update(item);
}
await UnitOfWork.Context.SaveChangesAsync();
if ("APR,POS,DLV".Contains(objData._master.requisition_type))
{
ProductStockModel objStock = new ProductStockModel();
objStock.CreateByUserId = 1;
objStock.CreateDate = DateTime.Now;
objStock.ModifyByUserId = item.ModifyByUserId;
objStock.ModifyDate = item.ModifyDate;
objStock.product_id = item.product_id;
objStock.relate_doc_id = item.requisition_id;
objStock.item_amt = item.quantity;
objStock.from_action = objData._master.requisition_type;
ProductStockModule processStock = new ProductStockModule(UnitOfWork);
await processStock.InsertAsync(objStock);
}
}
if (objData._lstPackages != null)
{
foreach (var item in objData._lstPackages)
{
item.ModifyDate = DateTime.Now;
item.ModifyByUserId = 1;
if (item.id <= 0)
{
item.requisition_id = objData._master.requisition_id;
item.document_no = objData._master.document_no;
item.status = "Y";
item.CreateDate = DateTime.Now;
item.CreateByUserId = 1;
UnitOfWork.Context.Set <RequisitionPackageModel>().Add(item);
}
else
{
UnitOfWork.Context.Set <RequisitionPackageModel>().Update(item);
}
await UnitOfWork.Context.SaveChangesAsync();
}
}
return(objData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Checks if the product stock model is not null, and there is enough booked quantity that we can also
/// un-book the requested quantity from the sales order
/// </summary>
public static bool CanUnBookProduct(OrderProductModel product, ProductStockModel selectedProductStock)
{
return(selectedProductStock != null &&
selectedProductStock.BookedQuantity >= product.OrderedQuantity &&
selectedProductStock.Quantity >= product.OrderedQuantity);
}
/// <summary>
/// Validates if the selected product is not null and has a quantity >= than the quantity we want to sell
/// </summary>
public bool CheckProductToSellAvailability(ProductStockModel selectedProductStock, int productQtyToAdd)
{
return(selectedProductStock != null && selectedProductStock.AvailableQuantity >= productQtyToAdd);
}
/// <summary>
/// Adds the selected product to the selected sales order in the selected quantities and
/// updates the product stock available quantity
/// </summary>
public void AddProductToSalesOrder(SalesOrderModel selectedOrder, ProductModel selectedProduct, ProductStockModel selectedProductStock, TaxModel taxToUse, int productQtyToAdd)
{
OrderProductModel productToSell = CheckIfProductExistsInSalesOrder(selectedProduct, selectedOrder);
if (productToSell == null)
{
AddNewProductToSalesOrderContent(selectedOrder, selectedProduct, taxToUse, productQtyToAdd);
}
else
{
IncrementExistingProductInSalesOrderContent(productToSell, productQtyToAdd);
}
UpdateProductStock_OnAddToSalesOrder(selectedProductStock, productQtyToAdd);
}
/// <summary>
/// Increment booked quantity/decrement available quantity, according to the quantity added to the sales order
/// Update the ProductStockModel in the database
/// </summary>
public void UpdateProductStock_OnAddToSalesOrder(ProductStockModel selectedProductStock, int productQtyToAdd)
{
selectedProductStock.BookedQuantity += productQtyToAdd;
selectedProductStock.AvailableQuantity -= productQtyToAdd;
GlobalConfig.Connection.UpdateProductStockModel(selectedProductStock);
}
/// <summary>
/// Decrement booked quantity/inccrement available quantity for the selected ProductStockModel item
/// </summary>
public void UnBookSalesOrderProduct(ProductStockModel selectedProductStock)
{
selectedProductStock.BookedQuantity--;
selectedProductStock.AvailableQuantity++;
GlobalConfig.Connection.UpdateProductStockModel(selectedProductStock);
}
