public IReceiptBuilder WithPurchasedItem(string itemDescription, bool isItemImported, decimal purchasePrice)
{
var purchasedItem = new PurchasedItem { ItemDescription = itemDescription, IsItemImported = isItemImported, PurchasePrice = purchasePrice };
_purchasedItems.Add(purchasedItem);
return this;
}
private void SavePurchasedItem(int id, PurchasedItem item)
{
using (DBClass = new MSSQLDatabase())
{
using (DbTransaction txn = DBClass.BeginTransaction())
{
try
{
var cmd = DBClass.GetStoredProcedureCommand("APP_SAVE_NEW_PURCHASE_ORDER_ITEM") as SqlCommand;
DBClass.AddSimpleParameter(cmd, "@PurchaseOrderId", id);
DBClass.AddSimpleParameter(cmd, "@ProductId", item.ProductID);
DBClass.AddSimpleParameter(cmd, "@Qty", item.Qty);
DBClass.AddSimpleParameter(cmd, "@EstimatedDate", item.EstimatedDate);
DBClass.AddSimpleParameter(cmd, "@DeliveredStatus", 1);
DBClass.ExecuteNonQuery(cmd, txn);
txn.Commit();
}
catch (Exception)
{
txn.Rollback();
throw;
}
}
}
}
public IEnumerable <PurchasedItem> GetPurchasedItems(int purchaseOrderId)
{
var result = new List <PurchasedItem>();
using (DBClass = new MSSQLDatabase())
{
var cmd = DBClass.GetStoredProcedureCommand("APP_GET_PURCHASE_ORDER_ITEM") as SqlCommand;
DBClass.AddSimpleParameter(cmd, "@PurchaseOrderId", purchaseOrderId);
var reader = DBClass.ExecuteReader(cmd);
while (reader.Read())
{
var item = new PurchasedItem
{
ProductID = int.Parse(reader[0].ToString()),
PurchaseOrderID = int.Parse(reader[1].ToString()),
ProductCode = reader[2].ToString(),
ProductName = reader[3].ToString(),
Qty = decimal.Parse(reader[4].ToString()),
DeliveredQty = decimal.Parse(reader[5].ToString()),
EstimatedDate = DateTime.Parse(reader[6].ToString()),
UnitID = int.Parse(reader[7].ToString()),
UnitName = reader[8].ToString(),
Status = reader[9].ToString()
};
result.Add(item);
}
}
return(result);
}
public PurchasedItem GetNumOfExistingPurchasedItems(PurchasedItem item)
{
PurchasedItem defaultItem = new PurchasedItem();
defaultItem = _connection.Table <PurchasedItem>().Where(x => x.Name == item.Name).Where(x => x.Color == item.Color).Where(x => x.Level == item.Level).FirstOrDefault();
return(defaultItem);
}
public async Task <IActionResult> PutPurchasedItem(double id, PurchasedItem purchasedItem)
{
if (id != purchasedItem.PurchasedItemId)
{
return(BadRequest());
}
_context.Entry(purchasedItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchasedItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void AddToCart()
{
if (string.IsNullOrEmpty(InputData))
{
Message = "値が正しく取得できませんでした";
return;
}
//
string pattern = @"^(?<producerCode>\d{1,4})\-(?<productCode>\d{1,4})\-(?<price>\d{1,6})$";
Regex r = new Regex(pattern, RegexOptions.None, TimeSpan.FromMilliseconds(150));
Match m = r.Match(InputData.Trim());
if (m.Success)
{
PurchasedItem item = new PurchasedItem();
item.Price = decimal.Parse(m.Result("${price}"));
item.Quantity = 1;
item.ProducerCode = m.Result("${producerCode}");
item.ProductCode = m.Result("${productCode}");
AddPurchasedItem(item);
InputData = string.Empty;
Message = string.Empty;
}
else
{
Message = "値が正しく取得できませんでした";
}
}
public void CreateReceipt_TwoItemsDifferentDescription_TwoDetail()
{
//Setup
var firstItemDescription = "a very good book";
var secondItemDescription = "A very good book";
var firstImportBook = new PurchasedItem()
{
Description = firstItemDescription,
FinalPrice = 12.49m,
SaleTax = 0.6m
};
var sevondImportBook = new PurchasedItem()
{
Description = secondItemDescription,
FinalPrice = 12.49m,
SaleTax = 0.6m
};
var cart = new PurchasedItem[] { firstImportBook, sevondImportBook };
//SUT Call
var receipt = receiptBuilder.CreateReceipt(cart);
//Assertiom
Assert.AreEqual(2, receipt.Details.Length);
Assert.AreEqual(1, receipt.Details[0].Quantity);
Assert.AreEqual(1, receipt.Details[1].Quantity);
Assert.AreEqual(firstItemDescription, receipt.Details[0].Description);
Assert.AreEqual(secondItemDescription, receipt.Details[1].Description);
Assert.AreEqual(12.49m, receipt.Details[0].Price);
Assert.AreEqual(12.49m, receipt.Details[0].Price);
Assert.AreEqual(2, receipt.PurchasedItems.Length);
}
public static PurchasedItem Create(int userId, Money unitPrice, int quantity, string description, PurchasedItemType itemType, decimal tax = 0)
{
var item = new PurchasedItem(userId, unitPrice, quantity, description, itemType, tax);
item.Save();
return(item);
}
public static int GetItemPrice(PurchasedItem item)
{
if (item == PurchasedItem.None)
{
return(0);
}
return(ItemPriceArray[(int)item]);
}
public void boughtItem(int cost, PurchasedItem item)
{
if (item == PurchasedItem.PROTECTION)
{
protection += 3;
}
GameState.Instance.money -= cost;
updateMoney();
}
public void AddItem(PurchasedItem item)
{
if (item is null)
{
throw new ArgumentNullException();
}
_items.Add(item);
}
public void RemoveItem(PurchasedItem item)
{
if (item is null)
{
throw new ArgumentNullException();
}
_items.Remove(item);
}
public async Task <DataAccessResponse <string> > Update(string friendId, Guid purchasedItemId, PurchasedItem purchasedItem)
{
DataAccessResponse <string> response = new DataAccessResponse <string>();
if (friendId == null)
{
return(response.NotFound());
}
if (purchasedItemId == null)
{
return(response.NotFound());
}
DataAccessResponse <Friend> friendResponse = await _friendRepo.Get(friendId);
if (friendResponse.Status != HttpStatusCode.OK)
{
return(response.NotFound());
}
Friend friend = friendResponse.Payload;
if (friend.PurchasedItems == null)
{
return(response.BadRequest());
}
PurchasedItem purchasedItemToUpdate = friend.PurchasedItems.FirstOrDefault(p => p.Id == purchasedItemId);
if (purchasedItemToUpdate == null)
{
return(response.NotFound());
}
purchasedItem.Id = purchasedItemId;
friend.PurchasedItems.Remove(purchasedItemToUpdate);
friend.PurchasedItems.Add(purchasedItem);
IUpdateResponse <Friend> updateResponse = await _esClient.UpdateAsync <Friend>(friendId,
d => d
.Index(FriendRepository.Index)
.Type(FriendRepository.Type)
.Doc(friend));
if (!updateResponse.IsValid)
{
return(response.InternalServerError());
}
if (updateResponse.Id == null)
{
return(response.InternalServerError());
}
return(response.NoContent(updateResponse.Id));
}
private static PurchasedItem create_purchase_item_entry(decimal price, POSItems item, TransactionRequest request)
{
PurchasedItem item_entry = new PurchasedItem();
item_entry.Id = item.Id;
item_entry.item_name = item.Name;
item_entry.Quantity = request.Quantity;
item_entry.price = price;
return(item_entry);
}
private void PerformPurchaseCancel()
{
if (PurchasedItem != null && PurchaseInfo != null)
{
PurchaseInfo.Delete();
PurchasedItem.AdjustQuantityByAmount(PurchaseInfo.QuantitySold);
PurchaseInfoIsVisible = false;
BarcodeNumber = "";
ItemPurchaseStatusMessage = "";
}
}
//Function creates a new order from given values input by user and updates quantities
private void btnOrder_Click(object sender, EventArgs e)
{
//Creates new purchased item
PurchasedItem order = new PurchasedItem(formItem, formSize, cmbQuant.SelectedIndex + 1);
//Updates total cost of orders
formCharge += order.Cost;
//Adds order description to the text box of total orders
lblTotal.Text = formCharge.ToString("C");
lstOrder.Items.Add(order.ToString());
}
public Task <PurchasedItem> AddPuchase(PurchaseOrder order)
{
var item = new PurchasedItem
{
Date = DateTime.Now,
ProductId = order.ProductId,
ProductName = Products.Where(x => x.Id == order.ProductId).Single().Name,
TotalPrice = order.Size.TotalPrice
};
Purchases.Add(item);
return(Task.FromResult(item));
}
protected void HistoryGridView_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "download")
{
int index = Convert.ToInt32(e.CommandArgument) % HistoryGridView.PageSize;
GridViewRow row = HistoryGridView.Rows[index];
int itemId = Convert.ToInt32((row.Cells[0].Text));
var item = new PurchasedItem(itemId);
HtmlInvoiceGenerator generator = new HtmlInvoiceGenerator(item);
generator.DownloadPdf();
}
}
private PurchasedItem addGetItemFromList(string key, string keyUpToNumber, PayPalIPNRequest ret)
{
int itemIndex = getItemNumber(key, keyUpToNumber);
PurchasedItem itm = ret.purchased_items.Find(item => item.index == itemIndex);
if (itm == null)
{
itm = new PurchasedItem();
itm.index = itemIndex;
ret.purchased_items.Add(itm);
}
return(itm);
}
public List <PurchasedItem> purchaseHistory(string userID)
{
//get conn string
string DBConnect;
DBConnect = ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString;
//make adapter
SqlDataAdapter da;
//make dataset to store results (ResultSet equivalent in Java)
DataSet ds = new DataSet();
StringBuilder sqlCommand = new StringBuilder();
sqlCommand.AppendLine("Select * from [CartHistory] where");
sqlCommand.AppendLine("UserId = @paraUserId");
List <PurchasedItem> objList = new List <PurchasedItem>();
SqlConnection myConn = new SqlConnection(DBConnect);
da = new SqlDataAdapter(sqlCommand.ToString(), myConn);
da.SelectCommand.Parameters.AddWithValue("paraUserId", userID);
da.Fill(ds, "itemTable"); //Executes command and fills data set with the results
int rec_cnt = ds.Tables["itemTable"].Rows.Count; //recordcount
if (rec_cnt == 0) //no record has been found
{
//return a null object
objList = null;
}
else if (rec_cnt > 0)
{
for (int i = 0; i < rec_cnt; i++)
{
DataRow row = ds.Tables["itemTable"].Rows[i]; //First record
PurchasedItem obj = new PurchasedItem();
obj.historyID = int.Parse(row["historyID"].ToString());
obj.UserID = row["UserId"].ToString();
obj.items = row["Items"].ToString();
obj.ReceiptId = int.Parse(row["ReceiptId"].ToString());
obj.price = double.Parse(row["Price"].ToString());
obj.purchaseDate = row["PurchaseDate"].ToString();
objList.Add(obj);
}
}
return(objList);
}
public void RemoveItem_ShouldRemove()
{
var banana = new PurchasedItem(ItemType.Banana, 0.7);
_purchase.AddItem(new PurchasedItem(ItemType.Apple, 0.5));
_purchase.AddItem(banana);
_purchase.AddItem(banana);
_purchase.RemoveItem(banana);
var items = _purchase.GetAllItems();
Assert.AreEqual(2, items.Count);
Assert.AreEqual(1, items.Count(i => i.ItemType == ItemType.Apple));
Assert.AreEqual(1, items.Count(i => i.ItemType == ItemType.Banana));
}
void UserOrBuyItem(PurchasedItem item)
{
if (GameLogic.Singleton.GetGameFlow() != TGameFlow.EGameState_Playing)
{
return;
}
if (GlobalVars.PurchasedItemArray[(int)item] == 0)
{
UIPurchase purchaseWindow = UIWindowManager.Singleton.GetUIWindow<UIPurchase>();
purchaseWindow.ShowWindow();
purchaseWindow.OnPurchase = delegate()
{
if (item == PurchasedItem.Item_PlusStep)
{
if (GlobalVars.Coins > 0)
{
--GlobalVars.Coins;
GA.API.Business.NewEvent("BuyStep", "RMB", 1);
PlayerPrefs.SetInt("Coins", GlobalVars.Coins);
GameLogic.Singleton.PlayingStageData.StepLimit += 5; //步数加5
}
}
else if (item == PurchasedItem.Item_Hammer)
{
GameLogic.Singleton.UsingItem = item; //进入使用道具状态，等着选目标
}
};
return;
}
UIUseItem useItemWindow = UIWindowManager.Singleton.GetUIWindow<UIUseItem>();
useItemWindow.ShowWindow();
useItemWindow.OnUse = delegate()
{
if (item == PurchasedItem.Item_Hammer)
{
GameLogic.Singleton.UsingItem = item;
}
else if (item == PurchasedItem.Item_PlusStep)
{
GameLogic.Singleton.PlayingStageData.StepLimit += 5; //步数加5
--GlobalVars.PurchasedItemArray[(int)item]; //减少道具数量
RefreshItemCount();
PlayerPrefsExtend.SetIntArray("PurchasedItemArray", GlobalVars.PurchasedItemArray);
}
};
}
public HttpResponseMessage Purchase([FromBody] PurchasedItem item)
{
using (SQLiteConnection sqliteConnection = DBConnecter.DBConnect())
{
using (SQLiteCommand sqliteInsertCommand = new SQLiteCommand("INSERT INTO ShopPurchases (UserEmail, ShopProductID, Quantity, Cost, DatePurchased) VALUES (@email, @productID, @quantity, @cost, @date)", sqliteConnection))
{
sqliteInsertCommand.Parameters.Add(new SQLiteParameter("@email", item.Email));
sqliteInsertCommand.Parameters.Add(new SQLiteParameter("@productID", item.ProductID));
sqliteInsertCommand.Parameters.Add(new SQLiteParameter("@quantity", item.Quantity));
sqliteInsertCommand.Parameters.Add(new SQLiteParameter("@cost", item.Price));
sqliteInsertCommand.Parameters.Add(new SQLiteParameter("@date", DateTime.Now));
try
{
sqliteInsertCommand.ExecuteNonQuery();
}
catch (Exception ex)
{
sqliteConnection.Close();
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Internal Server Error: DB Insert fail - " + ex.ToString()));
}
}
using (SQLiteCommand sqliteUpdateCommand = new SQLiteCommand("UPDATE ShopItems SET Stock = (SELECT Stock FROM ShopItems WHERE ProductID = @productID) - @quantity WHERE ProductID = @productID", sqliteConnection))
{
sqliteUpdateCommand.Parameters.Add(new SQLiteParameter("@productID", item.ProductID));
sqliteUpdateCommand.Parameters.Add(new SQLiteParameter("@productID", item.ProductID));
sqliteUpdateCommand.Parameters.Add(new SQLiteParameter("@quantity", item.Quantity));
try
{
sqliteUpdateCommand.ExecuteNonQuery();
sqliteConnection.Close();
return(Request.CreateResponse(HttpStatusCode.OK, "Items purchased"));
}
catch (Exception ex)
{
sqliteConnection.Close();
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Internal Server Error: DB Update fail - " + ex.ToString()));
}
}
}
}
/**
* handles purchasing items.
*/
public bool PurchaseItems(Guid userId)
{
// try to get the user's cart
List <CartItem> cartItems = GetUsersCart(userId);
if (cartItems.Count == 0)
{
return(false);
}
// create a new purchase model to add to the database
PurchaseModel purchaseModel = new PurchaseModel
{
UserId = userId,
PurchasedAt = DateTime.Now
};
_context.Purchases.Add(purchaseModel);
_context.SaveChanges();
// add the user's cart items as purchased items
List <PurchasedItem> purchasedItems = new List <PurchasedItem>();
cartItems.ForEach(item =>
{
PurchasedItem newItem = new PurchasedItem
{
PurchaseId = purchaseModel.ID,
Product = item.Product,
PurchasePrice = _productService.GetProductPrice(item.Product.ID),
Quantity = item.Quantity
};
purchasedItems.Add(newItem);
});
_context.PurchasedItems.AddRange(purchasedItems);
// empty the user's cart
_context.CartItems.RemoveRange(cartItems);
_context.SaveChanges();
return(true);
}
public async Task <DataAccessResponse <string> > Add(string friendId, PurchasedItem item)
{
DataAccessResponse <string> response = new DataAccessResponse <string>();
if (friendId == null)
{
return(response.NotFound());
}
if (item == null)
{
return(response.NotFound());
}
DataAccessResponse <Friend> friendResponse = await _friendRepo.Get(friendId);
if (friendResponse.Status != HttpStatusCode.OK)
{
return(response.NotFound());
}
Friend friend = friendResponse.Payload;
item.Id = Guid.NewGuid();
friend.PurchasedItems = friend.PurchasedItems == null ? new List <PurchasedItem>() : friend.PurchasedItems;
friend.PurchasedItems.Add(item);
IUpdateResponse <Friend> updateResponse = await _esClient.UpdateAsync <Friend>(friendId,
d => d
.Index(FriendRepository.Index)
.Type(FriendRepository.Type)
.Doc(friend));
if (!updateResponse.IsValid)
{
return(response.InternalServerError());
}
if (updateResponse.Id == null)
{
return(response.InternalServerError());
}
return(response.Created(item.Id.ToString()));
}
public Guid CreateInvoice(InvoiceViewModel order)
{
try
{
if (order != null)
{
Invoice = new Invoice();
Invoice.Id = Guid.NewGuid();
var dateTimeNow = DateTime.Now.ToString("yyMMddHHmmssfff");
Invoice.InvoiceNumber = dateTimeNow + DateTime.Now.Day;
Invoice.CustomerFk = order.CustomerFk;
foreach (var item in order.PurchasedItems)
{
PurchasedItem purchasedItem = new PurchasedItem();
purchasedItem.Id = Guid.NewGuid();
purchasedItem.InvoiceFk = Invoice.Id;
purchasedItem.MedicineFk = item.MedicineFk;
purchasedItem.Quantity = item.Quantity;
purchasedItem.UnitPrice = item.UnitPrice;
purchasedItem.MRP = item.MRP;
unitOfWork.PurchasedItemRepository.Add(purchasedItem);
// update stock level of medicine
Medicine medicine = new Medicine();
medicine = unitOfWork.MedicineRepository.FirstOrDefault(m => m.Id == item.MedicineFk);
if (medicine != null)
{
medicine.StockLevel = medicine.StockLevel - item.Quantity;
unitOfWork.MedicineRepository.Update(medicine);
}
}
unitOfWork.InvoiceRepository.Add(Invoice);
unitOfWork.SaveChanges();
return(Invoice.Id);
}
}
catch (Exception ex)
{
logger.Error(ex, "Something bad happened");
}
return(Guid.Empty);
}
private UserPurchase createUserPurchaseByPurchasedItem(PurchasedItem purchasedItem)
{
var salt = GenerateSequenceOfChars(20);
// TODO: check facility name length
var password = GeneratePassword(purchasedItem.Facility);
var userPurchase = new UserPurchase();
userPurchase.Email = purchasedItem.Email;
userPurchase.Name = purchasedItem.Name;
userPurchase.PasswordSalt = salt;
userPurchase.Password = HashPassword(password, salt);
userPurchase.FacilityName = purchasedItem.Facility;
userPurchase.DateOfPurchase = purchasedItem.DateOfPurchase;
userPurchase.UserRegistrationDate = DateTime.Now;
userPurchase.UserExpirationDate = DateTime.Now.AddMonths(6);
return(userPurchase);
}
public void ReadFile(string filename)
{
string line = "";
StreamReader reader = new StreamReader(filename);
while ((line = reader.ReadLine()) != null)
{
line = line.Trim();
if (line.Length > 0)
{
string[] splitArray = line.Split(new char[] { ',' });
//regular item cost calculator
_type = splitArray[0];
name = splitArray[1];
PurchasedItem purchasedItem = new PurchasedItem(splitArray); //testing to return value to print into the write out file
items.Add(purchasedItem);
}
}
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var Item = await _context.Products.SingleOrDefaultAsync(x => x.Id == Guid.Parse(request.ItemId));
if (Item == null)
{
throw new RestException(HttpStatusCode.NotFound, new { Product = "Item not found" });
}
if (!Item.IsAvailable)
{
throw new RestException(HttpStatusCode.NotFound, new { Product = "Out of stock" });
}
if (Item.Points > _userAccessor.GetTotalPoints())
{
throw new RestException(HttpStatusCode.BadRequest, new { Purchase = "Purchase failed, not enough points" });
}
Item.IsAvailable = false;
var pItem = new PurchasedItem
{
Product = Item,
DatePurchased = DateTime.Now,
ShippingAddress = string.IsNullOrWhiteSpace(request.ShippingAddress) ? user.Person.Address : request.ShippingAddress,
isDelivered = false
};
user.PurchasedItems.Add(pItem);
var saved = await _context.SaveChangesAsync() > 0;
if (saved)
{
return(Unit.Value);
}
throw new Exception("Error Saving Purchased");
}
public void Buy()
{
if (MainViewModel.CurrentNinja.Gold < SelectedEquipment.Value)
{
MessageBox.Show("You don't have that much money!", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
PurchasedItem item = new PurchasedItem();
item.Ninja = MainViewModel.CurrentNinja.Id;
item.Equipment = SelectedEquipment.Id;
_database.PurchasedItems.Add(item);
MainViewModel.CurrentNinja.Gold -= SelectedEquipment.Value;
_database.SaveChanges();
UpdateEquipment();
}
public Item(PurchasedItem textItem)
{
this.ResourceId = textItem.ResourceId;
this.Path = textItem.Path;
this.Color = StringToColor(textItem.Color);
this.Type = textItem.Type;
this.HealthPower = textItem.HealthPower;
this.EnergyPower = textItem.EnergyPower;
this.FoodPower = textItem.FoodPower;
this.FunPower = textItem.FunPower;
this.SlotPlace = textItem.SlotPlace;
this.RoomId = textItem.RoomId;
this.Price = textItem.Price;
this.IsPurchased = textItem.IsPurchased;
this.Count = textItem.Count;
this.Parent = textItem.Parent;
this.Name = textItem.Name;
this.Level = textItem.Level;
this.Experience = textItem.Experience;
}
public override bool Purshase(ShopDefItem item, int quantity)
{
bool ret = true;
Fields.currentShopOwner = RelatedFaction;
if (!Fields.shopItemsSold.ContainsKey(item.ID))
{
PurchasedItem pItem = new PurchasedItem();
pItem.ID = item.ID;
pItem.Count = quantity;
pItem.Cost = UIControler.GetPrice(item) * quantity;
pItem.TransactionId = PersistentMapClient.getBMarketId();
pItem.remainingFunds = PersistentMapClient.companyStats.GetValue <int>("Funds");
Fields.shopItemsSold.Add(item.ID, pItem);
}
else
{
Fields.shopItemsSold[item.ID].Count += quantity;
Fields.shopItemsSold[item.ID].Cost += UIControler.GetPrice(item) * quantity;
Fields.shopItemsSold[item.ID].remainingFunds = PersistentMapClient.companyStats.GetValue <int>("Funds");
}
try
{
if (Web.PostBuyItems(Fields.shopItemsSold, RelatedFaction, isBlackMarket))
{
UIControler.DefaultPurshase(this, item, quantity);
}
else
{
ret = false;
}
}
catch (Exception e)
{
PersistentMapClient.Logger.LogError(e);
ret = false;
}
Fields.shopItemsSold = new Dictionary <string, Objects.PurchasedItem>();
needsRefresh = true;
return(ret);
}
partial void InsertPurchasedItem(PurchasedItem instance);
partial void UpdatePurchasedItem(PurchasedItem instance);
partial void DeletePurchasedItem(PurchasedItem instance);
void UserOrBuyItem(PurchasedItem item)
{
if (GameLogic.Singleton.GetGameFlow() != TGameFlow.EGameState_Playing || !GameLogic.Singleton.IsMoveAble())
{
return;
}
GlobalVars.UsingItem = item;
//先判断是否够钱
if (Unibiller.GetCurrencyBalance("gold") < CapsConfig.GetItemPrice(item)) //若钱不够，购买窗口
{
UIPurchaseNotEnoughMoney uiWindow = UIWindowManager.Singleton.GetUIWindow<UIPurchaseNotEnoughMoney>();
uiWindow.ShowWindow();
GlobalVars.OnPurchaseFunc = delegate()
{
UserOrBuyItem(item);
};
GlobalVars.OnCancelFunc = delegate()
{
GlobalVars.UsingItem = PurchasedItem.None;
};
return;
}
if (item == PurchasedItem.ItemInGame_Hammer)
{
UIWindow uiWindow = UIWindowManager.Singleton.GetUIWindow<UIPurchaseTarget>();
uiWindow.ShowWindow();
}
else
{
UIWindow uiWindow = UIWindowManager.Singleton.GetUIWindow<UIPurchaseNoTarget>();
uiWindow.ShowWindow();
}
}
public static int GetItemPrice(PurchasedItem item)
{
if (item == PurchasedItem.None)
{
return 0;
}
return ItemPriceArray[(int)item];
}
