protected override void HandleSuccess(WWW webRequest)
{
Debug.Log(webRequest.text);
InventoryServiceResponseModel response = JsonMapper.ToObject<InventoryServiceResponseModel>(webRequest.text);
this.inventory = response.inventory;
if (response.success)
{
Debug.Log("Got inventory.");
base.HandleSuccess(webRequest);
}
else
{
this.failureResponseHandler(webRequest);
}
}
internal void LoadDispensedItems()
{
try
{
var disSheet = new List <DispenseSheetViewModel2>();
using (var ctx = new InventoryModel())
{
disSheet = ctx.Dispenses
.OrderByDescending(x => x.Identifier)
.ToViewModels()
.ToList();
}
View.SetDispenseBindingSource(disSheet);
}
catch (Exception ex)
{
View.ShowError(ex);
}
}
public void InsertProductInventory(ProductModel product, InventoryModel inventory)
{
//using (SqlDataAccess sql = new SqlDataAccess())
//{
try
{
_sqlDataAccess.StartTransaction("TulipData");
int newProductId = _sqlDataAccess.CreateProductTransaction("dbo.spProduct_Insert", product);
inventory.ProductId = newProductId;
_sqlDataAccess.SaveDataInTransaction("dbo.spInventory_Insert", inventory);
_sqlDataAccess.CommitTransaction();
}
catch
{
_sqlDataAccess.RollbackTransaction();
throw;
}
//}
}
public void GetInventory(string type, int entityId)
{
if (PlayerPrefs.GetInt("offline") == 1)
{
TextAsset jsonAsset = (TextAsset) Resources.Load("ExampleData/ExampleInventoryData", typeof(TextAsset));
InventoryServiceResponseModel response = JsonMapper.ToObject<InventoryServiceResponseModel>(jsonAsset.text);
this.inventory = response.inventory;
if (this.successResponseHandler != null)
{
this.successResponseHandler(null);
}
}
else
{
Debug.Log("Getting inventory for entity type: " + type + ", ID: " + entityId);
this.MakeRequest(server + "drpg/data/inventory/" + type + "/" + entityId);
}
}
public async Task <bool> PostProductInventory(ProductModel product, InventoryModel inventory)
{
//object[] productInventory = { product, inventory };
List <object> productInventory = new List <object>
{
product,
inventory
};
using (HttpResponseMessage response = await _apiHelper.ApiClient.PostAsJsonAsync("/api/Product", productInventory))
{
if (response.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
}
public void GetInventory(string type, int entityId)
{
if (PlayerPrefs.GetInt("offline") == 1)
{
TextAsset jsonAsset = (TextAsset)Resources.Load("ExampleData/ExampleInventoryData", typeof(TextAsset));
InventoryServiceResponseModel response = JsonMapper.ToObject <InventoryServiceResponseModel>(jsonAsset.text);
this.inventory = response.inventory;
if (this.successResponseHandler != null)
{
this.successResponseHandler(null);
}
}
else
{
Debug.Log("Getting inventory for entity type: " + type + ", ID: " + entityId);
this.MakeRequest(server + "drpg/data/inventory/" + type + "/" + entityId);
}
}
public async Task <object> UpdateInventory(InventoryModel request)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
_context.Update(request);
var result = await _context.SaveChangesAsync();
await transaction.CommitAsync();
return(result > 0 ? request : null);
}
catch (Exception ex)
{
await transaction.RollbackAsync();
return(ex.InnerException != null?ex.InnerException.Message.ToString() : ex.Message.ToString());
}
}
}
internal void SaveDispensedItems(DispenseCartSaveEventArgs e)
{
try
{
var ds = new DispenseSummary();
ds.DateDispensed = DateTime.Now;
ds.Discount = (float)e.Discount;
ds.SubAmount = (float)e.SubTotal;
ds.Total = (float)e.Total;
ds.UserDispensed = Environment.UserName;
ds.Vat = (float)e.Vat;
ds.GroupId = string.Empty;
ds.GroupDate = DateTime.Now;
using (var ctx = new InventoryModel())
{
foreach (var item in e.Items)
{
var aItem = ctx
.Items
.Single(x => x.Identifier == item.ItemId);
aItem.StockLevel -= item.Quantity;
}
ctx.DispenseSummaries.Add(ds);
ctx.SaveChanges();
}
using (var db = new InventoryDocumentStorage())
{
db.DispenseSummaries.Insert(ds);
}
}
catch (Exception ex)
{
View.ShowError(ex);
}
}
public void RemoveItem(int id)
{
InventoryModel itemToRemove = database.FetchItemByID(id);
if (itemToRemove.Stackable && CheckItemInInventory(itemToRemove))
{
for (int j = 0; j < inv.items.Count; j++)
{
if (inv.items[j].ID == id)
{
ItemData data = inv.slots[j].transform.GetChild(0).GetComponent <ItemData>();
data.amount--;
data.transform.GetChild(0).GetComponent <Text>().text = data.amount.ToString();
if (data.amount == 0)
{
Destroy(inv.slots[j].transform.GetChild(0).gameObject);
inv.items[j] = new InventoryModel();
break;
}
if (data.amount == 1)
{
inv.slots[j].transform.GetChild(0).transform.GetChild(0).GetComponent <Text>().text = "";
break;
}
break;
}
}
}
else
{
for (int i = 0; i < inv.items.Count; i++)
{
if (inv.items[i].Title == null && inv.items[i].ID == id)
{
Destroy(inv.slots[i].transform.GetChild(0).gameObject); inv.items[i] = new InventoryModel();
break;
}
}
}
}
private void PaintInventoryList()
{
foreach (Transform t in ScrollContent)
{
Destroy(t.gameObject);
}
ScrollContent.DetachChildren();
List <InventoryItemInstance> itemList = GameState.Instance.PlayerRpgState.Inventory.GetItemsListActual();
ItemLookupTable = new InventoryItemInstance[itemList.Count];
for (int i = 0; i < itemList.Count; i++)
{
var item = itemList[i];
if (item.ItemModel.Hidden)
{
continue;
}
GameObject itemGO = Instantiate <GameObject>(ItemTemplatePrefab, ScrollContent);
if (!item.ItemModel.Stackable)
{
itemGO.GetComponentInChildren <Text>().text = InventoryModel.GetNiceName(item.ItemModel) + (item.Equipped ? " [Equipped]" : string.Empty); //for now
}
else
{
itemGO.GetComponentInChildren <Text>().text = string.Format("{0} ({1})", InventoryModel.GetNiceName(item.ItemModel), item.Quantity); //for now
}
Button b = itemGO.GetComponent <Button>();
int lexI = i;
b.onClick.AddListener(delegate { OnItemSelected(lexI); }); //scoping is weird here
ItemLookupTable[i] = item;
if (ApplyTheme)
{
ApplyThemeToElements(b.transform);
}
}
}
// save single item dispensary
private void Save_Dispensary()
{
try
{
var level = int.Parse(txtStockLevel.Text);
var qty = (int)nudDispenseQty.Value;
var bal = int.Parse(txtStockBalance.Text);
bal = level - qty;
txtStockBalance.Text = bal.ToString();
var dis = new Dispense();
dis.ItemId = txtItemid.Text;
dis.GroupId = txtRandom.Text;
dis.GroupDate = DateTime.Parse(txtgroupDate.Text);
dis.ItemCode = txtItemCode.Text;
dis.ItemName = txtItemName.Text;
dis.StockLevel = int.Parse(txtStockLevel.Text);
dis.UnitPrice = (float)nudUnitPrice.Value;
dis.DispenseQuantity = (int)nudDispenseQty.Value;
dis.SubAmount = float.Parse(txtAmountSub.Text);
dis.StockBalance = int.Parse(txtStockBalance.Text);
dis.DateDispensed = DateTime.Parse(txtDateAmend.Text);
dis.UserDispensed = Environment.UserName;
using (var ctx = new InventoryModel())
{
ctx.Dispenses.Add(dis);
ctx.SaveChanges();
}
MessageBox.Show("Item successfully dispensed");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Dispense Item");
}
}
public void UpdateInventory(InventoryModel inventoryModel)
{
string connectionString = CreateDatabase();
DataTable dt = new DataTable();
using (SqlCeCommand comm = new SqlCeCommand())
{
comm.Connection = new SqlCeConnection(connectionString);
comm.CommandType = CommandType.Text;
comm.CommandText = "UPDATE Inventory SET Description = @Description, Size = @Size, " +
"Quantity = @Quantity Where InventoryId = @InventoryId";
comm.Parameters.AddWithValue("@InventoryId", inventoryModel.InventoryId);
comm.Parameters.AddWithValue("@Description", inventoryModel.Description);
comm.Parameters.AddWithValue("@Size", inventoryModel.Size);
comm.Parameters.AddWithValue("@Quantity", inventoryModel.Quantity);
comm.Connection.Open();
comm.ExecuteNonQuery();
comm.Connection.Close();
}
}
public List <RepairCheck> RepairCheckList(InventoryModel inventoryModel)
{
string query = "SELECT * FROM RepairCheck WHERE InventoryRefId = '" + inventoryModel.InventoryId + "'";
SqlCommand queryCommand = new SqlCommand(query, DBConnection);
SqlDataReader queryCommandReader = queryCommand.ExecuteReader();
List <RepairCheck> repairCheckList = new List <RepairCheck>();
if (queryCommandReader.HasRows)
{
while (queryCommandReader.Read())
{
repairCheckList.Add(new RepairCheck()
{
SugesstionPrice = (int)queryCommandReader["SugesstionPrice"],
VisitDate = (DateTime)queryCommandReader["VisitDate"],
});
}
}
DBConnection.Close();
return(repairCheckList);
}
private void Load_Users()
{
var users = new List <ViewUserViewModel>();
try
{
using (var ctx = new InventoryModel())
{
users = ctx.Users
.Select(x => new ViewUserViewModel {
FirstName = x.FirstName, LastName = x.LastName, UserName = x.UserName, Role = x.Role, Phone = x.Phone, Email = x.Email
})
.ToList();
}
}
catch (Exception err)
{
MessageBox.Show(this, err.Message, "ViewUser", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
bsViewUser.DataSource = users;
}
public void SaveItem(InventoryModel updatedModel)
{
this.newModel = updatedModel;
if (RecordExists() && IsItemUpdated())
{
updatedModel.ItemCode = thisModel.ItemCode;
Update.Inventory(updatedModel);
helper.MessageDialog("Employee data has been updated successfully!",
updatedModel.Description);
}
else if (RecordExists() == true && IsItemUpdated() == false)
{
helper.MessageDialog("Save failed! There are no changes identified.",
updatedModel.Description);
}
else
{
Create.Inventory(updatedModel);
helper.MessageDialog("Employee data has been added successfully!",
updatedModel.Description);
}
}
public async Task <IHttpActionResult> GetSingleInventory(InventoryModel inventory)
{
CommonResponse validatedResponse = await AuthService.ValidateUserAndToken();
if (!validatedResponse.IsError)
{
var InventoryItem = await InventoryService.GetSingleInventory(inventory);
if (InventoryItem.Count > 0)
{
return(Ok(InventoryItem));
}
else
{
return(BadRequest("No Inventory record Exists!"));
}
}
else
{
return(Unauthorized());
}
}//end of get
public virtual async Task <InventoryModel> updateInventoryAsync(InventoryModel inventoryModel)
{
var inventoryData = _inventoryRepository.Read(inventoryModel.Id);
inventoryData.AvailableQuantity = inventoryModel.AvailableQuantity;
inventoryData.Barcode = inventoryModel.Barcode;
inventoryData.Height = inventoryModel.Height;
inventoryData.InventoryName = inventoryModel.InventoryName;
inventoryData.Stock_Keeping_Unit = inventoryModel.Stock_Keeping_Unit;
inventoryData.Weight = inventoryModel.Weight;
inventoryData.Price = inventoryModel.Price;
inventoryData.ImageInventoryId = inventoryModel.ImageInventoryId;
inventoryData.isActive = inventoryModel.isActive;
inventoryData.ModifiedBy = 1;
inventoryData.ModificationDate = DateTime.Now;
_inventoryRepository.Update(inventoryData);
await _inventoryRepository.SaveAsync();
InventoryModel inventoryModelData = Mapper.Map <Inventory, InventoryModel>(inventoryData);
return(inventoryModelData);
}
public async Task <IHttpActionResult> AddInventory(InventoryModel inventory)
{
if (inventory == null)
{
return(BadRequest("Please provide valid inputs!"));
}
CommonResponse validatedResponse = await AuthService.ValidateUserAndToken();
if (!validatedResponse.IsError)
{
if (await ProductService.ProductExist(inventory.ProductID))
{
InventoryModel inventoryToAdd = new InventoryModel()
{
ProductID = inventory.ProductID,
Quantity = inventory.Quantity,
Description = inventory.Description
};
if (await InventoryService.AddInventory(inventoryToAdd))
{
return(Ok("Inventory record Added Successfully!"));
}
else
{
return(BadRequest("Inventory record Adding Failed!"));
}
}
else
{
return(BadRequest("No SUch Item Exists"));
}
}
else
{
return(Unauthorized());
}
}//end of add
public override void Execute(ActionInvokerData data)
{
if (Locked || (!AllowInvokeWhenDisabled && !isActiveAndEnabled))
{
return;
}
if (data.Activator != null && WorldUtils.IsPlayer(data.Activator.gameObject))
{
InventoryModel inventory = GameState.Instance.PlayerRpgState.Inventory;
if (inventory.CountItem(InventoryItem) > 0)
{
Special.Invoke(data);
if (Consume)
{
inventory.RemoveItem(InventoryItem, 1);
}
}
if (!Repeatable)
{
Locked = true;
}
}
else if (PassthroughNonPlayerAction)
{
Special.Invoke(data);
if (!Repeatable) //should we do this?
{
Locked = true;
}
}
if (!Repeatable && LockEvenOnFail)
{
Locked = true;
}
}
//public int FreeSlot
//{
// get
// {
// return freeSlot;
// }
// set
// {
// freeSlot = value;
// }
//}
void Awake()
{
database = ItemDatabase.Instance(itemJSON);
inventoryName = null;
switch (inventory)
{
case Inventory.Ship:
inventoryName = "ShipInventory";
break;
case Inventory.Base:
inventoryName = "BaseInventory";
break;
default:
Debug.LogError("No inventory selected !", this);
break;
}
inventoryModel = GameObject.Find(inventoryName).GetComponent <InventoryModel>();
inventoryView = this.gameObject.GetComponent <InventoryView>();
//FreeSlot = inventoryView.slotsAmount;
}
public ActionResult Add()
{
InventoryModel inv = new InventoryModel();
List <Category> temp = new List <Category>();
CategoriesRepository repo = new CategoriesRepository();
temp = repo.GetList();
if (temp.Count() > 0)
{
inv.categories = new List <SelectListItem>();
foreach (Category c in temp)
{
inv.categories.Add(new SelectListItem {
Text = c.CategoryName, Value = c.ID.ToString()
});
}
return(View(inv));
}
return(View());
}
public ActionResult Warehousing(InventoryModel model)
{
if (!permissionService.Authorize(StandardPermissionProvider.InventoryProduct))
{
return(AccessDeniedView());
}
if (ModelState.IsValid)
{
var inventory = new Inventory
{
StoreId = model.StoreId,
ProductId = model.ProductId,
Quantity = model.Quantity,
Notes = model.Note
};
inventory.InStockTime = DateTime.Now;
var payment = new Payment
{
DueDateTime = model.DueDateTime,
TotalAmount = model.TotalAmount
};
if (model.Paid > 0)
{
payment.Items.Add(
new PayItem
{
Paid = model.Paid,
PayDataTime = DateTime.Now
});
}
inventory.Payment = payment;
inventoryService.InsertInventory(inventory);
}
return(RedirectToAction("Inventory"));
}
private static InventoryInformation CreateInventoryInformation(InventoryModel inventory, string inventoryId,
string friendlyId, string inventorySetId)
{
// Create an InventoryInformationObject
var inventoryInformation = new InventoryInformation();
inventoryInformation.Id = inventoryId;
inventoryInformation.FriendlyId = friendlyId;
inventoryInformation.SellableItem = new EntityReference(inventory.SellableItemId);
inventoryInformation.InventorySet = new EntityReference(inventorySetId);
inventoryInformation.Quantity = inventory.Quantity;
inventoryInformation.InvoiceUnitPrice = inventory.InvoiceUnitPrice;
if (inventory.Backorderable)
{
var backorderableComponent = inventoryInformation.GetComponent<BackorderableComponent>();
backorderableComponent.Backorderable = inventory.Backorderable;
backorderableComponent.BackorderAvailabilityDate = inventory.BackorderAvailabilityDate;
backorderableComponent.BackorderedQuantity = inventory.BackorderedQuantity;
backorderableComponent.BackorderLimit = inventory.BackorderLimit;
}
if (inventory.Preorderable)
{
var preorderableComponent = inventoryInformation.GetComponent<PreorderableComponent>();
preorderableComponent.Preorderable = inventory.Preorderable;
preorderableComponent.PreorderAvailabilityDate = inventory.PreorderAvailabilityDate;
preorderableComponent.PreorderedQuantity = inventory.PreorderedQuantity;
preorderableComponent.PreorderLimit = inventory.PreorderLimit;
}
// Add to list of Inventory Informations
inventoryInformation.GetComponent<TransientListMembershipsComponent>().Memberships.Add(
CommerceEntity.ListName<InventoryInformation>());
return inventoryInformation;
}
public void AddItem(int id)
{
InventoryModel itemToAdd = database.FetchItemByID(id);
if (itemToAdd.Stackable && CheckItemInInventory(itemToAdd))
{
for (int i = 0; i < inv.items.Count; i++)
{
if (inv.items[i].ID == id)
{
ItemData data = inv.slots[i].transform.GetChild(0).GetComponent <ItemData>();
data.amount++;
data.transform.GetChild(0).GetComponent <Text>().text = data.amount.ToString();
break;
}
}
}
else
{
for (int i = 0; i < inv.items.Count; i++)
{
if (inv.items[i].ID == -1)
{
inv.items[i] = itemToAdd;
GameObject itemObj = Instantiate(inv.inventoryItem);
itemObj.GetComponent <ItemData>().inventoryModel = itemToAdd;
itemObj.GetComponent <ItemData>().amount = 1;
itemObj.GetComponent <ItemData>().slot = i;
itemObj.transform.SetParent(inv.slots[i].transform);
itemObj.transform.position = Vector2.zero;
itemObj.GetComponent <Image>().sprite = itemToAdd.Sprite;
itemObj.name = itemToAdd.Title;
break;
}
}
}
}
public override void Start()
{
base.Start();
if (string.IsNullOrEmpty(ItemId) || ItemQuantity == 0)
{
Debug.LogWarning(string.Format("ItemController on {0} has invalid values (id {1}, qty {2})", name, ItemId, ItemQuantity));
}
if (!UseInteractPickup)
{
//disable interactable (the whole thing is hacky)
var iobj = transform.GetComponentInChildren <InteractableComponent>().Ref()?.gameObject;
if (iobj != null)
{
iobj.gameObject.SetActive(false);
}
}
else
{
//set tooltip
var iobj = transform.GetComponentInChildren <InteractableComponent>().Ref()?.gameObject;
string itemName = null;
var itemDef = InventoryModel.GetDef(ItemId);
if (itemDef != null)
{
itemName = itemDef.NiceName;
}
else
{
itemName = ItemId;
}
iobj.GetComponent <InteractableComponent>().Tooltip = ItemQuantity > 1 ? string.Format("{0} [{1}]", itemName, ItemQuantity) : itemName;
}
TryExecuteOnComponents(component => component.Init(this));
Initialized = true;
}
public async Task <IActionResult> Edit(int id, [Bind("ItemId,CoffeeId,VendorId,RoastId,PricePerLbs,LbsOnHand")] InventoryViewModel ivm)
{
if (id != ivm.ItemId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var updated = new InventoryModel
{
Id = ivm.ItemId,
Coffee = _context.Coffees.Find(ivm.CoffeeId),
Vendor = _context.Vendors.Find(ivm.VendorId),
Roast = _context.Roasts.Find(ivm.RoastId),
LbsOnHand = ivm.LbsOnHand,
PricePerLbs = ivm.PricePerLbs
};
_context.Update(updated);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InventoryModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(ivm));
}
public ActionResult AddInventory(InventoryModel model)
{
ViewBag.Products = LoadProductModels();
ViewBag.Bins = LoadBinModels();
if (ModelState.IsValid)
{
try
{
CreateInventory(model.InventoryID,
model.ProductID,
model.BinID,
model.QTY);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ViewBag.ErrorMessage = "That operation could not be completed. Please update the information and try again, or contact your system administrator.";
return(View(model));
}
}
return(View(model));
}
public async Task <IActionResult> getProduct([FromQuery][Required] int id)
{
InventoryModel model = new InventoryModel();
try
{
model = await(from item in appDbContext.Inventories
where (item.Id == id)
select new InventoryModel
{
Id = item.Id,
Name = item.Name,
Price = item.Price,
Quantity = item.Quantity,
CreatedDate = item.CreatedDate.ToString("MM/dd/yyyy hh:mm tt")
}).FirstOrDefaultAsync();
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok(model));
}
public void Inventory_Update_Default_Should_Pass()
{
// Arrange
var myBackend = InventoryRepositoryMock.Instance;
var myData = myBackend.Index().FirstOrDefault();
// Make a Copy of the Data and update an aspect of it
var myDataCopy = new InventoryModel(myData);
myDataCopy.ID = myData.ID; // Force the ID to match for this test.
myDataCopy.TestStripStock = 101;
myDataCopy.ClinicID = "Clinic";
// Act
var result = myBackend.Update(myDataCopy);
// Reset
myBackend.Reset();
// Assert
Assert.AreEqual(101, result.TestStripStock);
Assert.AreEqual("Clinic", result.ClinicID);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
if (Item != null)
{
if (Item.Contract == "Consignment")
{
uxConsignment.IsChecked = true;
}
else
{
uxPurchased.IsChecked = true;
}
uxSubmit.Content = "Update";
uxPrice.Text = string.Format("{0:C}", Item.Price.ToString());
}
else
{
Item = new InventoryModel();
Item.CreatedDate = DateTime.Now;
}
uxGrid.DataContext = Item;
}
public InventoryWindowViewModel(InventoryModel inventory)
: this()
{
this.Inventory = inventory;
this.Name = this.Inventory.Name;
this.DefaultItemMaxAmount = this.Inventory.DefaultMaxAmount;
foreach (InventoryItemModel item in this.Inventory.Items.Values)
{
this.Items.Add(item);
}
this.ShopEnabled = this.Inventory.ShopEnabled;
this.ShopCommandText = this.Inventory.ShopCommand;
this.SelectedShopCurrency = this.Currencies.FirstOrDefault(c => c.ID.Equals(this.Inventory.ShopCurrencyID));
this.ShopBuyCommand = this.Inventory.ItemsBoughtCommand;
this.ShopSellCommand = this.Inventory.ItemsSoldCommand;
this.TradeEnabled = this.Inventory.TradeEnabled;
this.TradeCommandText = this.Inventory.TradeCommand;
this.TradeCommand = this.Inventory.ItemsTradedCommand;
}
public void AddItemToInventoryShouldAddItemToInventory()
{
var options = new DbContextOptionsBuilder <TeaContext>().UseInMemoryDatabase("AddItemToInventoryShouldAddItemToInventory").Options;
using var testContext = new TeaContext(options);
repo = new DBRepo()
{
context = testContext,
mapper = mapper
};
InventoryModel inventory = new InventoryModel()
{
locationId = 1,
productId = 1,
stock = 1
};
//Act
repo.AddItemToInventory(inventory);
//Assert
using var assertContext = new TeaContext(options);
Assert.NotNull(assertContext.Inventory.First(i => i.Locationid == 1));
}
