/// <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)); } }