/// <summary>
/// this method is used to update item quantity
/// </summary>
/// <param name="brachId"></param>
/// <param name="companyId"></param>
public void UpdateItemQuantity(int brachId, int companyId)
{
try
{
var brachDetails = _branchContext.Fetch(x => x.CompanyId == companyId).ToList().FirstOrDefault();
if (brachDetails != null)
{
foreach (var itemDetails in _itemQuantityContext.Fetch(x => x.BranchId == brachDetails.Id).ToList())
{
var itemQuantityDetail = new ItemQuantity
{
CreatedDateTime = DateTime.UtcNow,
ItemId = itemDetails.ItemId,
BranchId = brachId,
ActualQuantity = 0,
MaxQuantity = itemDetails.MaxQuantity,
MinQuantity = itemDetails.MinQuantity
};
_itemQuantityContext.Add(itemQuantityDetail);
_itemQuantityContext.SaveChanges();
}
}
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
public void QuantityUpdate(ItemQuantity item)
{
this.QuantityUpdate(new List <ItemQuantity>()
{
item
});
}
// buys object - changes wallet and adds item
public void CompleteTransaction(int cost, string itemName)
{
if (getItem(itemName) == Item.None)
{
return;
}
wallet -= cost;
// adds item to bough list
bool added = false;
//
for (int i = 0; i < bought.Count; i++)
{
if (bought[i].itemType == getItem(itemName))
{
bought[i].quantity++;
added = true;
}
}
if (!added)
{
ItemQuantity p = new ItemQuantity();
p.itemType = ShopData.getItem(itemName);
p.quantity = 1;
bought.Add(p);
}
}
public ActionResult Others(string sessionId)
{
if (sessionId != null && userServices.getUserCountBySessionId(sessionId) == true)
{
using (var db = new InventoryDbContext())
{
List <Requisition> rt = new List <Requisition>();
ItemQuantity iq = new ItemQuantity();
rt = db.requisitions.ToList();
foreach (var rts in rt)
{
foreach (var proReqs in rts.productReqs)
{
iq.add(proReqs.productitemnumber, proReqs.productDesc, proReqs.unitOfMeasure, proReqs.deliveredQuantity);
}
}
User user = db.users.Where(x => x.sessionId == sessionId).First();
ViewData["staffname"] = user.employee.empName;
ViewData["sessionId"] = sessionId;
return(View(iq));
}
}
else
{
return(RedirectToAction("Login", "Login"));
}
}
public bool UpdateItemQuantityForPOS(int itemId, int Quantity, int branchId, int currentUserId)
{
ItemQuantity itemQuantityObj = _itemQuantity.FirstOrDefault(x => x.ItemId == itemId && x.BranchId == branchId);
if (itemQuantityObj != null)
{
if ((itemQuantityObj.ActualQuantity - Quantity) <= 0)
{
itemQuantityObj.ActualQuantity = 0;
if (itemQuantityObj.ItemProfile.IsOfferItem)
{
itemQuantityObj.ItemProfile.IsActive = false;
itemQuantityObj.ItemProfile.ModifiedDateTime = DateTime.UtcNow;
}
}
else
{
itemQuantityObj.ActualQuantity = (itemQuantityObj.ActualQuantity - Quantity);
}
itemQuantityObj.ModifiedDateTime = DateTime.UtcNow;
_itemQuantity.Update(itemQuantityObj);
_itemQuantity.SaveChanges();
return(true);
}
return(false);
}
public async Task <IActionResult> PutItemQuantity(int id, ItemQuantity itemQuantity)
{
if (id != itemQuantity.ItemQuantityId)
{
return(BadRequest());
}
if (!itemQuantity.LastUpdated.HasValue)
{
itemQuantity.LastUpdated = DateTime.UtcNow;
}
_context.Entry(itemQuantity).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemQuantityExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> UpdateItemInfo(InventoryEntry ie)
{
if (ie.ItemId == 0 || ie.StoreId == 0)
{
return(BadRequest());
}
Item currentItem = await _context.Items.FindAsync(ie.ItemId);
List <ItemQuantity> currentIqs = await _context.ItemQuantities.Where(iq => iq.ItemId == ie.ItemId && iq.StoreId == ie.StoreId).ToListAsync();
if (currentItem == null || currentIqs.Count == 0)
{
return(NotFound());
}
Item postedItem = ie.ToItem();
postedItem.CompanyId = currentItem.CompanyId;
postedItem.ItemQuantities = currentItem.ItemQuantities;
_context.Entry(currentItem).State = EntityState.Detached;
_context.Entry(postedItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
ie.ItemQuantityId = currentIqs[0].ItemQuantityId;
ItemQuantity currentIq = currentIqs[0];
ItemQuantity postedQuantity = ie.ToItemQuantity();
postedQuantity.Amount = currentIq.Amount;
postedQuantity.LastUpdated = currentIq.LastUpdated;
postedQuantity.ItemId = currentIq.ItemId;
_context.Entry(currentIq).State = EntityState.Detached;
_context.Entry(postedQuantity).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
return(NoContent());
}
private void SpawnItem(ItemQuantity item)
{
for (var i = 0; i < item.Quantity; i++)
{
var spawnedItem = Instantiate(lootPrefab, transform.position + (transform.up * 2), Quaternion.identity);
spawnedItem.GetComponent <ItemEntity>().id = item.Id;
}
}
public void Add(string item, int quantity)
{
if (CheckCapacity(quantity))
{
if (item.Length == 3)
{
if (this.CashQuantity + quantity <= this.GemQuantity)
{
if (this.ItemQuantity.ContainsKey(item))
{
this.ItemQuantity[item] += quantity;
}
else
{
ItemQuantity.Add(item, quantity);
}
this.CashQuantity += quantity;
this.OverallQuantity += quantity;
}
}
else if (item.EndsWith("gem"))
{
if (this.GemQuantity + quantity <= this.GoldQuantity)
{
if (this.ItemQuantity.ContainsKey(item))
{
this.ItemQuantity[item] += quantity;
}
else
{
this.ItemQuantity.Add(item, quantity);
}
this.GemQuantity += quantity;
this.OverallQuantity += quantity;
}
}
else if (item.ToLower() == "gold")
{
if (this.ItemQuantity.ContainsKey(item))
{
this.ItemQuantity[item] += quantity;
}
else
{
this.ItemQuantity.Add(item, quantity);
}
this.GoldQuantity += quantity;
this.OverallQuantity += quantity;
}
}
}
private void ClearItemArea()
{
ItemId.Clear();
ItemTextBox.Clear();
ItemBoxName.Clear();
ItemQuantity.Clear();
ItemTargetQuantity.Clear();
ItemCanExpire.IsChecked = false;
}
/// <summary>
/// This method is used to update quantity. - JJ
/// </summary>
/// <param name="SupplierReturnId">Id of SupplierReturnDetail</param>
/// <param name="BranchId">Id of Returning Branch</param>
/// <param name="isAdd"></param>
/// <param name="companyDetails"></param>
/// <param name="user"></param>
/// <returns>status</returns>
public bool UpdateItemQuantity(int SupplierReturnId, int BranchId, bool isAdd, CompanyDetail companyDetails, UserDetail user)
{
try
{
var supplierReturnItems = _supplierReturnItemContext.Fetch(x => x.SupplierReturnId == SupplierReturnId).ToList();
foreach (var returnItem in supplierReturnItems)
{
if (returnItem.ItemProfile.IsParentItem)
{
if (_itemQuantityContext.Fetch(x => x.ItemId == returnItem.ItemProfile.Id && x.BranchId == BranchId).ToList().Any())
{
var itemQuantity = _itemQuantityContext.FirstOrDefault(x => x.ItemId == returnItem.ItemProfile.Id && x.BranchId == BranchId);
if (isAdd)
{
itemQuantity.ActualQuantity += (returnItem.ItemProfile.BaseUnit * returnItem.ReturnQuantity);
}
else
{
itemQuantity.ActualQuantity -= (returnItem.ItemProfile.BaseUnit * returnItem.ReturnQuantity);
}
itemQuantity.ModifiedDateTime = DateTime.UtcNow;
_itemQuantityContext.Update(itemQuantity);
_itemQuantityContext.SaveChanges();
GenrateAutomaticSpo(itemQuantity, companyDetails, user);
}
}
else if (_itemQuantityContext.Fetch(x => x.ItemId == returnItem.ItemProfile.ParentItemId && x.BranchId == BranchId).ToList().Any())
{
var itemQuantity = new ItemQuantity();
itemQuantity = _itemQuantityContext.FirstOrDefault(x => x.ItemId == returnItem.ItemProfile.ParentItemId && x.BranchId == BranchId);
if (isAdd)
{
itemQuantity.ActualQuantity += (returnItem.ItemProfile.BaseUnit * returnItem.ReturnQuantity);
}
else
{
itemQuantity.ActualQuantity -= (returnItem.ItemProfile.BaseUnit * returnItem.ReturnQuantity);
}
itemQuantity.ModifiedDateTime = DateTime.UtcNow;
_itemQuantityContext.Update(itemQuantity);
_itemQuantityContext.SaveChanges();
GenrateAutomaticSpo(itemQuantity, companyDetails, user);
}
}
return(true);
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
/// <summary>
/// Update the Item Profiles as per Purchase Order Items - JJ
/// </summary>
/// <param name="spoId"></param>
private void UpdateItem(int spoId)
{
SupplierPurchaseOrder spo = _supplierPOContext.Find(spoId);
List <PurchaseOrderBranch> spoBranches = _purchaseOrderBranchContext.Fetch(x => x.PurchaseOrderId == spoId).ToList();
List <PurchaseOrderItem> poItems = _purchaseOrderItemContext.Fetch(x => x.PurchaseOrderId == spoId).ToList();
foreach (PurchaseOrderItem item in poItems)
{
ItemProfile itemProfile = _itemProfileContext.Find(item.ItemId);
itemProfile.PreviousCostPrice = itemProfile.CostPrice;
itemProfile.CostPrice = GetItemPrice(item, itemProfile, spoBranches);
var icr = _icrDetailContext.FirstOrDefault(x => x.SPOItemId == item.Id && !x.IsDeleted);
if (icr != null)
{
var icrPrice = _icrPriceContext.FirstOrDefault(x => x.IcrId == icr.Id);
if (icrPrice != null)
{
itemProfile.SellPrice = icrPrice.ModifyingSellPrice;
itemProfile.SellPriceA = icrPrice.ModifyingSellPriceA;
itemProfile.SellPriceB = icrPrice.ModifyingSellPriceB;
itemProfile.SellPriceC = icrPrice.ModifyingSellPriceC;
itemProfile.SellPriceD = icrPrice.ModifyingSellPriceD;
}
}
_itemProfileContext.Update(itemProfile);
_itemProfileContext.SaveChanges();
foreach (PurchaseOrderBranch branch in spoBranches)
{
var itemQuantity = _itemQuantityContext.FirstOrDefault(x => x.ItemId == item.ItemId && x.BranchId == branch.BranchId);
if (itemQuantity != null)
{
itemQuantity.ActualQuantity += item.ReceivingQuantity;
_itemQuantityContext.Update(itemQuantity);
_itemQuantityContext.SaveChanges();
}
else
{
var newItemQuantity = new ItemQuantity
{
ActualQuantity = item.ReceivingQuantity,
BranchId = branch.BranchId,
CreatedDateTime = DateTime.UtcNow,
ItemId = item.ItemId,
//client asked to keep test data for the time being
MaxQuantity = item.ReceivingQuantity,
MinQuantity = item.ReceivingQuantity
};
_itemQuantityContext.Add(newItemQuantity);
_itemQuantityContext.SaveChanges();
}
}
}
}
private bool HasEnoughOfThisItem(ItemQuantity searchedItem)
{
var alreadyStoredItemQuantity = Items.SingleOrDefault(i => i.Id == searchedItem.Id);
if (alreadyStoredItemQuantity == null)
{
return(false);
}
return(alreadyStoredItemQuantity.Quantity >= searchedItem.Quantity);
}
public async Task <ActionResult <ItemQuantity> > PostItemQuantity(ItemQuantity itemQuantity)
{
if (!itemQuantity.LastUpdated.HasValue)
{
itemQuantity.LastUpdated = DateTime.UtcNow;
}
_context.ItemQuantities.Add(itemQuantity);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetItemQuantity", new { id = itemQuantity.ItemQuantityId }, itemQuantity));
}
/// <summary>
/// this method is used to genrate automatic spo.
/// </summary>
/// <param name="itemQuantityDetails"></param>
/// <param name="companyDetail"></param>
/// <param name="userDetail"></param>
private void GenrateAutomaticSpo(ItemQuantity itemQuantityDetails, CompanyDetail companyDetail, UserDetail userDetail)
{
try
{
_itemRepository.GenrateAutomaticSpo(itemQuantityDetails, companyDetail, userDetail);
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
public ActionResult Edit(int id, ItemQuantity list)
{
list = db.getAllMasterList.Single(i => i.ID == id);
try
{
UpdateModel(list);
db.paramQuery("edit_single_item", db.paramEditSingleItem(list, list.ID));
return RedirectToAction("List", new { id = list.itemID });
}
catch { return View(list); }
}
public void AddResource(ItemQuantity itemQuantity)
{
if (MissingResourceQuantities.Any(i => i.Id == itemQuantity.Id))
{
var alreadyAddedQuantity = MissingResourceQuantities.Single(s => s.Id == itemQuantity.Id);
alreadyAddedQuantity.Quantity += itemQuantity.Quantity;
}
else
{
MissingResourceQuantities.Add(itemQuantity);
}
UpdateText();
}
public void Store(ItemQuantity itemToStore)
{
_inventory.Add(itemToStore);
var inventoryDisplay = GetComponentInChildren <TextMeshPro>();
var builder = new StringBuilder();
foreach (var item in _inventory.Items)
{
builder.AppendLine(item.ToString());
}
inventoryDisplay.text = builder.ToString();
Events.Current.TriggerResourceStorageUpdated(itemToStore);
}
public void Add(ItemQuantity obtainedItems)
{
var alreadyStoredItemQuantity = Items.SingleOrDefault(i => i.Id == obtainedItems.Id);
if (alreadyStoredItemQuantity != null)
{
alreadyStoredItemQuantity.Quantity += obtainedItems.Quantity;
}
else
{
Items.Add(obtainedItems);
}
Events.Current.TriggerInventoryUpdate(Items);
}
private void UpdateResourceStorage(ItemQuantity item)
{
var resource = MissingResourceQuantities.SingleOrDefault(s => s.Id == item.Id);
if (resource == null)
{
return;
}
resource.Quantity -= item.Quantity;
if (resource.Quantity < 0)
{
resource.Quantity = 0;
}
UpdateText();
}
public bool TryAddItem(ItemQuantity itemQuantity)
{
ItemQuantity ownedItemQuantity;
if (itemQuantitiesByName.TryGetValue(itemQuantity.item.name, out ownedItemQuantity))
{
itemQuantitiesByName[ownedItemQuantity.item.name] = new ItemQuantity(ownedItemQuantity.item, ownedItemQuantity.quantity + itemQuantity.quantity);
}
else
{
itemQuantitiesByName[itemQuantity.item.name] = itemQuantity;
}
return(true);
}
/*
* Returns all of the random drops dropped by this enemy
*/
public List <ItemQuantity> GetDrops()
{
List <ItemQuantity> result = new List <ItemQuantity>();
int val;
foreach (ItemRarity itemRarity in rarityInfo)
{
if ((val = DetermineDropAmount(itemRarity)) != 0)
{
ItemQuantity quant = new ItemQuantity();
quant.item = itemRarity.item;
quant.quantity = val;
result.Add(quant);
}
}
return(result);
}
private void Sell_Click(object sender, RoutedEventArgs e)
{
if (!string.IsNullOrWhiteSpace(ItemQuantity.Text) && int.Parse(ItemQuantity.Text) <= int.Parse(oldQuan.Text) && int.Parse(ItemQuantity.Text) != 0)
{
int newQuan = int.Parse(oldQuan.Text) - int.Parse(ItemQuantity.Text);
try
{
connection.Open();
MySqlCommand cmd = new MySqlCommand();
cmd.CommandText = "update items set ITEM_NAME=@ItemName,ITEM_QUANTATY=@ItemQuantity where ITEM_ID=@ItemId";
cmd.Parameters.AddWithValue("@ItemName", ItemName.Text);
cmd.Parameters.AddWithValue("@ItemQuantity", newQuan);
cmd.Parameters.AddWithValue("@ItemId", ItemId.Text);
cmd.Connection = connection;
cmd.ExecuteNonQuery();
MySqlCommand Com = new MySqlCommand($"Select * from items where ITEM_QUANTATY>{0}", connection);
MySqlDataAdapter adp = new MySqlDataAdapter(Com);
DataSet ds = new DataSet();
adp.Fill(ds, "LoadDataBinding");
GridItemSell.DataContext = ds;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
finally
{
connection.Close();
string sts = ItemQuantity.Text + " " + ItemName.Text + " has been sold";
MessageBox.Show(sts, "Success");
// ItemName.Clear();
ItemQuantity.Clear();
ItemId.Clear();
}
}
else
{
MessageBox.Show("WRONG QUANTITY", "ERROR");
}
}
public ActionResult Index(List <CartItemQuantity> cartItems)
{
FoodCartRepository repository = new FoodCartRepository();
User user = Session["User"] as User;
List <ItemQuantity> items = new List <ItemQuantity>();
foreach (var cartItem in cartItems)
{
ItemQuantity item = new ItemQuantity();
item.FoodId = cartItem.FoodId;
item.Quantity = cartItem.Quantity;
item.UserId = user.Id;
items.Add(item);
}
repository.QuantityUpdate(items);
return(RedirectToAction("Index", "FoodCart"));
}
public bool CanRemoveItem(ItemQuantity itemQuantity)
{
ItemQuantity ownedItemQuantity;
if (itemQuantitiesByName.TryGetValue(itemQuantity.item.name, out ownedItemQuantity))
{
if (ownedItemQuantity.quantity >= itemQuantity.quantity)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public void Remove(ItemQuantity removedItems)
{
var alreadyStoredItemQuantity = Items.SingleOrDefault(i => i.Id == removedItems.Id);
if (alreadyStoredItemQuantity == null)
{
return;
}
if (alreadyStoredItemQuantity.Quantity < removedItems.Quantity)
{
Items.Remove(alreadyStoredItemQuantity);
}
else
{
alreadyStoredItemQuantity.Quantity -= removedItems.Quantity;
Items.Remove(alreadyStoredItemQuantity);
Items.Add(alreadyStoredItemQuantity);
}
}
public IHttpActionResult DeleteRetunrBillItem(string billNumber)
{
try
{
var returnBill = _iReturnBillRepository.GetPosReturnBillDataByReturnBillNo(billNumber);
if (returnBill != null)
{
if (!returnBill.IsProcessed)
{
returnBill.IsDeleted = true;
if (_iReturnBillRepository.UpdatePosReturnBillForPOs(returnBill))
{
var returnBillItemList = _iReturnBillRepository.GetListOfPOSReturnBillItemByReturnBillId(returnBill.Id);
if (returnBillItemList.Any())
{
foreach (var returnBillItem in returnBillItemList)
{
returnBillItem.IsDeleted = true;
_iReturnBillRepository.UpdatePosReturnBillItem(returnBillItem);
ItemQuantity itemQuantity = _iItemRepository.GetItemQunatityByBranchIdAndItemId(returnBillItem.POSBillItem.ItemID, Convert.ToInt32(MerchantContext.UserDetails.BranchId));
if (itemQuantity != null)
{
itemQuantity.ActualQuantity = (itemQuantity.ActualQuantity - returnBillItem.ReturnedQuantity);
_iItemRepository.UpdateItemQunatity(itemQuantity);
}
}
return(Ok(new { isResult = true }));
}
}
}
return(Ok(new { isResult = StringConstants.ReturnBillPaymentAlreadyDone }));
}
return(Ok(new { isResult = false }));
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
public ActionResult AddToCart(int id)
{
User user = Session["User"] as User;
if (user != null)
{
FoodCartRepository cartRespository = new FoodCartRepository();
int quantity = cartRespository.CheckProduct(user.Id, id);
if (quantity != 0)
{
ItemQuantity item = new ItemQuantity();
item.Quantity = quantity + 1;
item.FoodId = id;
item.UserId = user.Id;
cartRespository.QuantityUpdate(item);
}
else
{
cartRespository.AddToCart(id, user.Id);
}
}
return(RedirectToAction("Index", "FoodCart"));
}
private static Dictionary <ItemVariantInventoryDimension, ItemQuantity> GetSalesLineItemQuantities(IEnumerable <SalesLine> salesLines, Dictionary <string, decimal> salesLineInventoryQuantities)
{
Dictionary <ItemVariantInventoryDimension, ItemQuantity> itemQuantities = new Dictionary <ItemVariantInventoryDimension, ItemQuantity>();
foreach (SalesLine salesLine in salesLines)
{
ItemQuantity itemQuantity;
ItemVariantInventoryDimension item = salesLine.GetItemVariantInventoryDimension();
if (!itemQuantities.TryGetValue(item, out itemQuantity))
{
itemQuantity = new ItemQuantity()
{
ItemId = item.ItemId,
VariantInventoryDimensionId = item.VariantInventoryDimensionId,
};
itemQuantities.Add(item, itemQuantity);
}
itemQuantity.Quantity += salesLineInventoryQuantities[salesLine.LineId];
}
return(itemQuantities);
}
public void ChangeQuantity(int enumValue)
{
quantity = (ItemQuantity)enumValue;
}
/// <summary>
/// this method is used to update item details.
/// </summary>
/// <param name="itemDetails"></param>
/// <returns></returns>
public int UpdateItemDetails(ItemProfileAC itemDetails)
{
try
{
//used for update item profile
var itemProfileDetail = _itemProfileContext.FirstOrDefault(x => x.Id == itemDetails.ItemProfileId);
int posIncidentReportId = 0;
if (itemProfileDetail != null)
{
itemProfileDetail.ItemNameEn = itemDetails.ItemNameEn;
itemProfileDetail.ItemNameSl = itemDetails.ItemNameSl;
itemProfileDetail.FlavourEn = itemDetails.FlavourEn;
itemProfileDetail.FlavourSl = itemDetails.FlavourSl;
itemProfileDetail.Barcode = itemDetails.Barcode;
itemProfileDetail.UnitParamTypeId = itemDetails.UnitParamTypeId;
itemProfileDetail.Code = itemDetails.Code;
itemProfileDetail.BaseUnit = itemDetails.BaseUnit;
itemProfileDetail.CategoryId = itemDetails.CategoryId;
itemProfileDetail.IsOfferItem = itemDetails.IsOfferItem;
itemProfileDetail.IsActive = itemDetails.IsActive;
itemProfileDetail.IsAutomaticPO = itemDetails.IsAutomaticPO;
itemProfileDetail.ProfitMargin = itemDetails.ProfitMargin;
itemProfileDetail.SellPrice = itemDetails.SellPrice;
itemProfileDetail.SellPriceA = itemDetails.SellPriceA;
itemProfileDetail.SellPriceB = itemDetails.SellPriceB;
itemProfileDetail.SellPriceB = itemDetails.SellPriceB;
itemProfileDetail.SellPriceC = itemDetails.SellPriceC;
itemProfileDetail.SellPriceD = itemDetails.SellPriceD;
itemProfileDetail.CostPrice = itemDetails.CostPrice;
itemProfileDetail.ModifiedDateTime = DateTime.UtcNow;
_itemProfileContext.Update(itemProfileDetail);
_itemProfileContext.SaveChanges();
foreach (var itemQuantityObject in itemDetails.ListOfItemQuantityList)
{
var itemQuantityDetails =
_itemQuantityContext.FirstOrDefault(
x => x.ItemId == itemProfileDetail.Id && x.BranchId == itemQuantityObject.BranchId);
if (itemQuantityDetails != null)
{
if (itemQuantityDetails.BranchId != 0)
{
itemQuantityDetails.ActualQuantity = itemQuantityObject.ActualQuantity;
itemQuantityDetails.MaxQuantity = itemQuantityObject.MaximumQuantity;
itemQuantityDetails.MinQuantity = itemQuantityObject.MinimumQuantity;
itemQuantityDetails.ModifiedDateTime = DateTime.UtcNow;
_itemQuantityContext.Update(itemQuantityDetails);
_itemQuantityContext.SaveChanges();
}
}
else
{
var itemQuantity = new ItemQuantity
{
ActualQuantity = itemQuantityObject.ActualQuantity,
BranchId = itemDetails.BranchId,
CreatedDateTime = DateTime.UtcNow,
ItemId = itemProfileDetail.Id,
MaxQuantity = itemQuantityObject.MaximumQuantity,
MinQuantity = itemQuantityObject.MinimumQuantity
};
_itemQuantityContext.Add(itemQuantity);
_itemQuantityContext.SaveChanges();
}
}
}
return(posIncidentReportId = itemDetails.PosIncidentReportId);
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
/// <summary>
/// Creates a new instance of the GamePlayerLogicEventArgs class
/// </summary>
public GamePlayerLogicEventArgs(GamePlayer player, ItemQuantity item)
{
Player = player;
ItemQuantity = item;
}
/// <summary>
/// Removes an item from the player's inventory
/// </summary>
/// <param name="player"></param>
/// <param name="quantity"></param>
public void RemoveItem(GamePlayer player, int businessLocation, ItemQuantity itemQuantity)
{
BusinessLocation location = player.Locations[businessLocation];
LocationStorage storage = location.Storage;
storage.RemoveItem(itemQuantity);
if (ItemSubtracted != null)
{
OnItemSubtracted(new GamePlayerLogicEventArgs(player, itemQuantity));
}
}
