public bool CreateReceiveItem(FrunutStockEntities db, ReceiveItem receiveItem)
{
bool result = false;
using (var dbContextTransaction = db.Database.BeginTransaction())
{
var itemWarehouse = db.ItemWarehouses.Where(i => i.ItemID == receiveItem.ItemID && i.WarehouseID == receiveItem.WarehouseID).FirstOrDefault();
var item = db.Items.Where(i => i.ID == receiveItem.ItemID).FirstOrDefault();
try
{
if (itemWarehouse == null)
{
ItemWarehouse iw = AddItemWarehouse(receiveItem, item);
db.ItemWarehouses.Add(iw);
}
else
{
UpdateItemWarehouse(itemWarehouse, receiveItem, item, 1);
db.Entry(itemWarehouse).State = EntityState.Modified;
}
db.ReceiveItems.Add(receiveItem);
db.SaveChanges();
dbContextTransaction.Commit();
result = true;
}
catch (Exception err)
{
dbContextTransaction.Rollback();
result = false;
}
}
return(result);
}
//JQuery Ajax calls go
public JsonResult SaveOrderdetailsRow(OrderDetail orderDetail)
{
bool status = false;
OrderDetail savedOrderRow = null;
try
{
ItemWarehouse itemWareHouse = itemWarehouseService.GetItemWarehouse(orderDetail.WarehouseID);
Order order = orderService.GetOrder(orderDetail.OrderID);
if (order != null)
{
orderDetail.WarehouseID = itemWareHouse.WarehouseID;
orderDetailService.CreateOrderDetail(orderDetail);
order.TotalPrice += orderDetail.Extended_Price;
orderService.UpdateOrder(order);
orderDetailService.SaveOrderDetail();
orderService.SaveOrder();
savedOrderRow = orderDetailService.GetSavedOrderDetail(orderDetail);
if (savedOrderRow != null)
{
status = true;
}
}
}
catch (Exception e)
{
}
return(new JsonResult
{
Data = new { status = status }
});
}
private static ItemWarehouse getEntityByModel(ItemWarehouseModel model, int count)
{
if (model == null)
{
return(null);
}
ItemWarehouse entity = new ItemWarehouse();
if (count == 0)
{
entity.CreateBy = AuthenticationHelper.UserId;
entity.CreateDate = DateTime.Now;
}
else
{
entity.CreateBy = model.CreateBy;
entity.CreateDate = model.CreateDate;
}
entity.EndDate = model.EndDate;
entity.Id = model.Id;
entity.ItemId = model.ItemId;
entity.SOBId = model.SOBId;
entity.StartDate = model.StartDate;
entity.UpdateBy = AuthenticationHelper.UserId;
entity.UpdateDate = DateTime.Now;
entity.WarehouseId = model.WarehouseId;
return(entity);
}
/// <summary>
/// Get availability of items for specified stores.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="stores">The collection of store locations.</param>
/// <param name="itemUnits">The collection of items.</param>
/// <returns>
/// The collection of store availability information.
/// </returns>
internal static Collection <OrgUnitAvailability> GetChannelAvailabiltiy(RequestContext context, IEnumerable <OrgUnitLocation> stores, IEnumerable <ItemUnit> itemUnits)
{
HashSet <ItemWarehouse> itemWarehouses = new HashSet <ItemWarehouse>();
foreach (OrgUnitLocation storeLocation in stores)
{
foreach (var itemUnit in itemUnits)
{
ItemWarehouse itemWarehouse = new ItemWarehouse
{
ItemId = itemUnit.ItemId,
VariantInventoryDimensionId = itemUnit.VariantInventoryDimensionId,
InventoryLocationId = storeLocation.InventoryLocationId
};
itemWarehouses.Add(itemWarehouse);
}
}
var request = new GetItemAvailabilitiesByItemWarehousesServiceRequest(QueryResultSettings.AllRecords, itemWarehouses);
var response = context.Execute <GetItemAvailabilitiesByItemWarehousesServiceResponse>(request);
ChannelAvailabilityHelper.ConvertUnitOfMeasure(context, response.ItemAvailabilities.Results, itemUnits);
Collection <OrgUnitAvailability> storeAvailabilities = new Collection <OrgUnitAvailability>();
foreach (OrgUnitLocation storeLocation in stores)
{
List <ItemAvailability> itemAvailabilities = response.ItemAvailabilities.Results.Where(item => item.InventoryLocationId.Equals(storeLocation.InventoryLocationId, StringComparison.OrdinalIgnoreCase)).ToList();
storeAvailabilities.Add(new OrgUnitAvailability(storeLocation, itemAvailabilities));
}
return(storeAvailabilities);
}
public long Update(ItemWarehouse entity)
{
var originalEntity = this.Context.ItemWarehouses.Find(entity.Id);
this.Context.Entry(originalEntity).CurrentValues.SetValues(entity);
this.Context.Entry(originalEntity).State = EntityState.Modified;
this.Commit();
return(entity.Id);
}
public void UpdateItemWarehouse(ItemWarehouse itemWarehouse, ReceiveItem receiveItem, Item item, int factor)
{
itemWarehouse.QtyBoxesIn += receiveItem.QtyBoxes * factor;
itemWarehouse.QtyKgIn += receiveItem.QtyKg * factor;
itemWarehouse.QtyBoxesOnhand += receiveItem.QtyBoxes * factor;
itemWarehouse.QtyKgOnhand += receiveItem.QtyKg * factor;
itemWarehouse.QtyTotalWeightIn += (receiveItem.QtyKg * factor) + (receiveItem.QtyBoxes * item.BoxWeight) * factor;
itemWarehouse.QtyTotalWeightOnhand += (receiveItem.QtyKg * factor) + (receiveItem.QtyBoxes * item.BoxWeight) * factor;
}
/// <summary>
/// Size Packet 28 bytes
/// </summary>
/// <returns></returns>
public byte[] GetClubData()
{
var ClubInfo = ItemWarehouse.GetItem(this.ClubSetIndex);
if ((ClubInfo == null))
{
return(new byte[28]);
}
return(ClubInfo.GetClubInfo());
}
public bool SetBallTypeID(uint TypeID)
{
var Ball = ItemWarehouse.GetItem(TypeID, 1);
if ((Ball == null) || (!(Ball.ItemTypeID.GetItemGroup() == IffGroupFlag.ITEM_TYPE_BALL)))
{
return(false);
}
this.BallTypeID = TypeID;
return(true);
}
// club system
public bool SetClubSetIndex(uint Index)
{
var Club = ItemWarehouse.GetItem(Index);
if ((Club == null) || (!(Club.ItemTypeID.GetItemGroup() == IffGroupFlag.ITEM_TYPE_CLUB)))
{
return(false);
}
this.ClubSetIndex = Index;
return(true);
}
public override byte[] GetClubData()
{
PlayerItemData ClubInfo;
ClubInfo = ItemWarehouse.GetItem(this.ClubSetIndex);
if ((ClubInfo == null))
{
return(new byte[28]);
}
return(ClubInfo.GetClubInfo());
}
public bool SetBackgroudIndex(uint typeID)
{
var Get = ItemWarehouse.GetItem(typeID, 1);
if (Get == null)
{
return(false);
}
ItemDecoration.BackGroundTypeID = typeID;
BackGroundIndex = Get.ItemIndex;
return(true);
}
public bool SetFrameIndex(uint typeID)
{
var Get = ItemWarehouse.GetItem(typeID, 1);
if (Get == null)
{
return(false);
}
ItemDecoration.FrameTypeID = typeID;
FrameIndex = Get.ItemIndex;
return(true);
}
public override bool SetSlotIndex(uint typeID)
{
var Get = ItemWarehouse.GetItem(typeID, 1);
if (Get == null)
{
return(false);
}
ItemDecoration.SlotTypeID = typeID;
SlotIndex = Get.ItemIndex;
return(true);
}
public bool EditReceiveItem(FrunutStockEntities db, ReceiveItem receiveItem)
{
bool result = false;
using (var dbContextTransaction = db.Database.BeginTransaction())
{
var oldReceiveItem = db.ReceiveItems.Find(receiveItem.ID);
try
{
if (oldReceiveItem == null)
{
throw new System.InvalidOperationException("Could't find old values.");
}
var oldItemWarehouse = db.ItemWarehouses.Where(i => i.ItemID == oldReceiveItem.ItemID && i.WarehouseID == oldReceiveItem.WarehouseID).FirstOrDefault();
var oldItem = db.Items.Where(i => i.ID == oldReceiveItem.ItemID).FirstOrDefault();
if (oldItemWarehouse == null)
{
throw new System.InvalidOperationException("Could't find old values.");
}
UpdateItemWarehouse(oldItemWarehouse, oldReceiveItem, oldItem, -1);
db.Entry(oldItemWarehouse).State = EntityState.Modified;
db.SaveChanges();
var itemWarehouse = db.ItemWarehouses.Where(i => i.ItemID == receiveItem.ItemID && i.WarehouseID == receiveItem.WarehouseID).FirstOrDefault();
var item = db.Items.Where(i => i.ID == receiveItem.ItemID).FirstOrDefault();
if (itemWarehouse == null)
{
ItemWarehouse iw = AddItemWarehouse(receiveItem, item);
db.ItemWarehouses.Add(iw);
}
else
{
UpdateItemWarehouse(itemWarehouse, receiveItem, item, 1);
}
db.Entry(oldReceiveItem).State = EntityState.Detached;
db.Entry(receiveItem).State = EntityState.Modified;
db.SaveChanges();
dbContextTransaction.Commit();
result = true;
}
catch (Exception err)
{
// UpdateItemWarehouse(itemWarehouse, receiveItem, -1);
dbContextTransaction.Rollback();
result = false;
}
}
return(result);
}
public bool SetTitleIndex(uint ID)
{
var Get = ItemWarehouse.GetItem(ID);
if (Get == null)
{
return(false);
}
ItemDecoration.TitleTypeID = Get.ItemTypeID;
TitleIndex = Get.ItemIndex;
return(true);
}
// club system
public bool SetClubSetIndex(uint Index)
{
PlayerItemData Club;
Club = ItemWarehouse.GetItem(Index);
if ((Club == null) || (!(GetItemGroup(Club.ItemTypeID) == 0x4)))
{
return(false);
}
this.ClubSetIndex = Index;
return(true);
}
public bool SetBallTypeID(uint TypeID)
{
PlayerItemData Ball;
Ball = ItemWarehouse.GetItem(TypeID, 1);
if ((Ball == null) || (!(GetItemGroup(Ball.ItemTypeID) == 0x5)))
{
return(false);
}
this.BallTypeID = TypeID;
return(true);
}
public uint GetQuantity(uint TypeId)
{
switch ((byte)TypeId.GetItemGroup())
{
case 5:
case 6:
// Ball And Normal
return(ItemWarehouse.GetQuantity(TypeId));
default:
return(0);
}
}
public ItemWarehouseModel(ItemWarehouse entity)
{
this.CreateBy = entity.CreateBy;
this.CreateDate = entity.CreateDate;
this.EndDate = entity.EndDate;
this.Id = entity.Id;
this.ItemId = entity.ItemId;
this.SOBId = entity.SOBId;
this.StartDate = entity.StartDate;
this.UpdateBy = entity.UpdateBy;
this.UpdateDate = entity.UpdateDate;
this.WarehouseId = entity.WarehouseId;
}
public override uint GetQuantity(uint TypeId)
{
switch (GetPartGroup(TypeId))
{
case 5:
case 6:
// Ball And Normal
return(ItemWarehouse.GetQuantity(TypeId));
default:
return(0);
}
}
public static void Save(ItemModel itemModel)
{
Item entity = getEntityByModel(itemModel);
string result = string.Empty;
if (entity.IsValid())
{
if (itemModel.Id > 0)
{
result = service.Update(entity);
}
else
{
result = service.Insert(entity);
}
if (!string.IsNullOrEmpty(result))
{
var savedDetail = GetItemWarehouses(result);
if (savedDetail.Count() > itemModel.ItemWarehouses.Count())
{
var tobeDeleted = savedDetail.Take(savedDetail.Count() - itemModel.ItemWarehouses.Count());
foreach (var item in tobeDeleted)
{
service.DeleteItemWarehouse(item.Id);
}
savedDetail = GetItemWarehouses(result);
}
foreach (var detail in itemModel.ItemWarehouses)
{
ItemWarehouse detailEntity = getEntityByModel(detail, savedDetail.Count());
if (detailEntity.IsValid())
{
detailEntity.ItemId = Convert.ToInt64(result);
if (savedDetail.Count() > 0)
{
detailEntity.Id = savedDetail.FirstOrDefault().Id;
savedDetail.Remove(savedDetail.FirstOrDefault(rec => rec.Id == detailEntity.Id));
service.Update(detailEntity);
}
else
{
service.Insert(detailEntity);
}
}
}
}
}
}
// GET: Stock/ItemWarehouses/Details/5
public ActionResult Details(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ItemWarehouse itemWarehouse = db.ItemWarehouses.Find(id);
if (itemWarehouse == null)
{
return(HttpNotFound());
}
return(View(itemWarehouse));
}
public ItemWarehouse AddItemWarehouse(ReceiveItem receiveItem, Item item)
{
ItemWarehouse iw = new ItemWarehouse();
iw.ItemID = receiveItem.ItemID;
iw.WarehouseID = receiveItem.WarehouseID;
iw.QtyBoxesIn = receiveItem.QtyBoxes;
iw.QtyKgIn = receiveItem.QtyKg;
iw.QtyBoxesOnhand = receiveItem.QtyBoxes;
iw.QtyKgOnhand = receiveItem.QtyKg;
iw.QtyTotalWeightIn = receiveItem.QtyKg + (receiveItem.QtyBoxes * item.BoxWeight);
iw.QtyTotalWeightOnhand = receiveItem.QtyKg + (receiveItem.QtyBoxes * item.BoxWeight);
iw.QtyTotalWeightReserved = 0;
return(iw);
}
public AddItemData AddRent(uint TypeID, ushort Day = 7)
{
object PRent;
AddItemData Result;
Result = new AddItemData()
{
Status = false
};
if (!(TypeID.GetItemGroup() == IffGroupFlag.ITEM_TYPE_PART))
{
return(Result);
}
var _db = new PangyaEntities();
var Add = _db.ProcAddRent((int)UID, (int)TypeID, Day).ToList();
if (Add.Count <= 0)
{
return(Result);
}
foreach (var data in Add)
{
PRent = new WarehouseData();
((WarehouseData)(PRent)).ItemIndex = (uint)data.ITEM_INDEX;
((WarehouseData)(PRent)).ItemTypeID = (uint)data.ITEM_TYPEID;
((WarehouseData)(PRent)).ItemC0 = 0;
((WarehouseData)(PRent)).ItemUCCUnique = string.Empty;
((WarehouseData)(PRent)).CreateNewItem();
((WarehouseData)(PRent)).ItemFlag = (byte)data.ITEM_FLAG;
((WarehouseData)(PRent)).ItemEndDate = data.ITEM_DATE_END;
ItemWarehouse.ItemAdd((WarehouseData)(PRent));
Result.Status = true;
Result.ItemIndex = ((WarehouseData)(PRent)).ItemIndex;
Result.ItemTypeID = ((WarehouseData)(PRent)).ItemTypeID;
Result.ItemOldQty = 0;
Result.ItemNewQty = 1;
Result.ItemUCCKey = ((WarehouseData)(PRent)).ItemUCCUnique;
Result.ItemFlag = (byte)((WarehouseData)(PRent)).ItemFlag;
Result.ItemEndDate = ((WarehouseData)(PRent)).ItemEndDate;
}
return(Result);
}
public bool IsExist(uint TypeID, uint Index, uint Quantity)
{
switch ((byte)TypeID.GetItemGroup())
{
case 5:
case 6:
// ## normal and ball
return(ItemWarehouse.IsNormalExist(TypeID, Index, Quantity));
case 2:
// ## part
return(ItemWarehouse.IsPartExist(TypeID, Index, Quantity));
case 0x1:
// ## card
return(ItemCard.IsExist(TypeID, Index, Quantity));
}
return(false);
}
// poster
public override bool SetCutInIndex(uint CharIndex, uint CutinIndex)
{
if (CutinIndex == 0)
{
return(true);
}
var Item = ItemWarehouse.GetItem(CutinIndex, TGET_ITEM.gcIndex);
var CharType = ItemCharacter.GetChar(CharIndex, Defines.CharType.bIndex);
if (Item == null)
{
return(false);
}
if (CharType == null)
{
return(false);
}
CharType.FCutinIndex = Item.ItemIndex;
ItemCharacter.UpdateCharacter(CharType);
return(true);
}
// poster
public bool SetCutInIndex(uint CharIndex, uint CutinIndex)
{
if (CutinIndex == 0)
{
return(true);
}
var Item = ItemWarehouse.GetItem(CutinIndex, 0);
var CharType = ItemCharacter.GetChar(CharIndex, 0);
if (Item == null)
{
return(false);
}
if (CharType == null)
{
return(false);
}
CharType.CutinIndex = Item.ItemIndex;
ItemCharacter.UpdateCharacter(CharType);
return(true);
}
// item exists?
public bool IsExist(uint TypeId)
{
List <Dictionary <uint, uint> > ListSet;
switch ((byte)TypeId.GetItemGroup())
{
case 2:
return(ItemWarehouse.IsPartExist(TypeId));
case 5:
case 6:
return(ItemWarehouse.IsNormalExist(TypeId));
case 9:
ListSet = IFFEntry.GetIff.SetItem.SetList(TypeId);
try
{
if (ListSet.Count <= 0)
{
return(false);
}
foreach (var __Enum in ListSet)
{
if (this.IsExist(__Enum.First().Key))
{
return(true);
}
}
return(false);
}
finally
{
ListSet.Clear();
}
case 14:
return(ItemWarehouse.IsSkinExist(TypeId));
}
return(false);
}
public void AddToItemWarehouses(ItemWarehouse itemWarehouse)
{
base.AddObject("ItemWarehouses", itemWarehouse);
}
public AddItemData AddItemToDB(AddItem ItemAddItemData)
{
Object PlayerObjectData;
TransactionData Tran;
AddItemData Result;
Result = new AddItemData()
{
Status = false
};
var _db = new PangyaEntities();
var additem = _db.ProcAddItem((int)UID, (int)ItemAddItemData.ItemIffId, (int)ItemAddItemData.Quantity, Compare.IfCompare <byte>(IFFEntry.GetIff.IsSelfDesign(ItemAddItemData.ItemIffId), 1, 0), IFFEntry.GetIff.GetItemTimeFlag(ItemAddItemData.ItemIffId, ItemAddItemData.Day), (int)ItemAddItemData.Day).ToList();
if (additem.Count > 0)
{
var dbdata = additem.FirstOrDefault();
Tran = new TransactionData()
{
Types = 2, Index = (uint)dbdata.IDX, TypeID = (uint)dbdata.iffTypeId, PreviousQuan = 0, NewQuan = (uint)dbdata.Quantity, UCC = dbdata.UCC_KEY
};
ItemTransaction.Add(Tran);
try
{
switch (ItemAddItemData.ItemIffId.GetItemGroup())
{
case IffGroupFlag.ITEM_TYPE_CHARACTER:
{
PlayerObjectData = new CharacterData();
((CharacterData)(PlayerObjectData)).Index = (uint)dbdata.IDX;
((CharacterData)(PlayerObjectData)).TypeID = (uint)dbdata.iffTypeId;
((CharacterData)(PlayerObjectData)).HairColour = 0;
((CharacterData)(PlayerObjectData)).GiftFlag = 0;
ItemCharacter.CharacterAdd((CharacterData)(PlayerObjectData));
CharacterIndex = (uint)dbdata.IDX;
Result = new AddItemData()
{
Status = true,
ItemIndex = ((CharacterData)(PlayerObjectData)).Index,
ItemTypeID = ((CharacterData)(PlayerObjectData)).TypeID,
ItemOldQty = 1,
ItemNewQty = 1,
ItemUCCKey = string.Empty,
ItemFlag = 0,
ItemEndDate = DateTime.MinValue,
};
}
break;
case IffGroupFlag.ITEM_TYPE_AUX:
case IffGroupFlag.ITEM_TYPE_PART:
case IffGroupFlag.ITEM_TYPE_CLUB:
case IffGroupFlag.ITEM_TYPE_BALL:
case IffGroupFlag.ITEM_TYPE_USE:
case IffGroupFlag.ITEM_TYPE_SKIN:
{
PlayerObjectData = new WarehouseData();
((WarehouseData)(PlayerObjectData)).ItemIndex = (uint)dbdata.IDX;
((WarehouseData)(PlayerObjectData)).ItemTypeID = (uint)dbdata.iffTypeId;
((WarehouseData)(PlayerObjectData)).ItemC0 = (ushort)dbdata.Quantity;
((WarehouseData)(PlayerObjectData)).ItemUCCUnique = dbdata.UCC_KEY;
((WarehouseData)(PlayerObjectData)).CreateNewItem();
// Add to inventory list
ItemWarehouse.ItemAdd((WarehouseData)(PlayerObjectData));
// Set the result data
Result = new AddItemData()
{
Status = true,
ItemIndex = ((WarehouseData)(PlayerObjectData)).ItemIndex,
ItemTypeID = ((WarehouseData)(PlayerObjectData)).ItemTypeID,
ItemOldQty = 0,
ItemNewQty = ItemAddItemData.Quantity,
ItemUCCKey = ((WarehouseData)(PlayerObjectData)).ItemUCCUnique,
ItemFlag = 0,
ItemEndDate = null,
};
}
break;
case IffGroupFlag.ITEM_TYPE_CADDIE:
{
PlayerObjectData = new CaddieData();
((CaddieData)(PlayerObjectData)).CaddieIdx = (uint)dbdata.IDX;
((CaddieData)(PlayerObjectData)).CaddieTypeId = (uint)dbdata.iffTypeId;
((CaddieData)(PlayerObjectData)).CaddieDateEnd = (DateTime)dbdata.END_DATE;
((CaddieData)(PlayerObjectData)).CaddieAutoPay = 0;
((CaddieData)(PlayerObjectData)).CaddieType = (byte)dbdata.Flag;
// Add caddie to inventory list
ItemCaddie.CadieAdd((CaddieData)(PlayerObjectData));
// set the result data
Result = new AddItemData()
{
Status = true,
ItemIndex = ((CaddieData)(PlayerObjectData)).CaddieIdx,
ItemTypeID = ((CaddieData)(PlayerObjectData)).CaddieTypeId,
ItemOldQty = 0,
ItemNewQty = 1,
ItemUCCKey = string.Empty,
ItemFlag = ((CaddieData)(PlayerObjectData)).CaddieType,
ItemEndDate = null,
};
}
break;
case IffGroupFlag.ITEM_TYPE_CARD:
{
PlayerObjectData = new CardData();
((CardData)(PlayerObjectData)).CardIndex = (uint)dbdata.IDX;
((CardData)(PlayerObjectData)).CardTypeID = (uint)dbdata.iffTypeId;
((CardData)(PlayerObjectData)).CardQuantity = ItemAddItemData.Quantity;
((CardData)(PlayerObjectData)).CardIsValid = 1;
((CardData)(PlayerObjectData)).CardNeedUpdate = false;
// ## add to card
ItemCard.CardAdd((CardData)(PlayerObjectData));
// set the result data
Result = new AddItemData()
{
Status = true,
ItemIndex = ((CardData)(PlayerObjectData)).CardIndex,
ItemTypeID = ((CardData)(PlayerObjectData)).CardTypeID,
ItemOldQty = 0,
ItemNewQty = ((CardData)(PlayerObjectData)).CardQuantity,
ItemUCCKey = string.Empty,
ItemFlag = 0,
ItemEndDate = null,
};
}
break;
case IffGroupFlag.ITEM_TYPE_MASCOT:
{
PlayerObjectData = new MascotData();
((MascotData)(PlayerObjectData)).MascotIndex = (uint)dbdata.IDX;
((MascotData)(PlayerObjectData)).MascotTypeID = (uint)dbdata.iffTypeId;
((MascotData)(PlayerObjectData)).MascotMessage = "Pangya !";
((MascotData)(PlayerObjectData)).MascotIsValid = 1;
((MascotData)(PlayerObjectData)).MascotNeedUpdate = false;
((MascotData)(PlayerObjectData)).MascotEndDate = (DateTime)dbdata.END_DATE;
((MascotData)(PlayerObjectData)).MascotDayToEnd = (ushort)dbdata.END_DATE.DaysBetween(DateTime.Now);
// ## add to card
ItemMascot.MascotAdd((MascotData)(PlayerObjectData));
// set the result data
Result = new AddItemData()
{
Status = true,
ItemIndex = ((MascotData)(PlayerObjectData)).MascotIndex,
ItemTypeID = ((MascotData)(PlayerObjectData)).MascotTypeID,
ItemOldQty = 0,
ItemNewQty = 1,
ItemUCCKey = string.Empty,
ItemFlag = 4,
ItemEndDate = DateTime.Now.AddDays(ItemAddItemData.Day + 1),
};
}
break;
}
}
catch
{
}
}
// ## resulted
return(Result);
}
public AddItemData AddItem(AddItem ItemAddItemData)
{
Object WareHouseData;
AddItemData Result;
Result = new AddItemData()
{
Status = false
};
if (UID == 0)
{
return(Result);
}
switch (ItemAddItemData.ItemIffId.GetItemGroup())
{
case IffGroupFlag.ITEM_TYPE_CHARACTER:
{
WareHouseData = ItemCharacter.GetChar(ItemAddItemData.ItemIffId, 1);
if (WareHouseData == null)
{
return(AddItemToDB(ItemAddItemData));
}
else if (!(WareHouseData != null))
{
Result.Status = true;
Result.ItemIndex = ((CharacterData)(WareHouseData)).Index;
Result.ItemTypeID = ((CharacterData)(WareHouseData)).TypeID;
Result.ItemOldQty = 1;
Result.ItemNewQty = 1;
Result.ItemUCCKey = string.Empty;
Result.ItemFlag = 0;
Result.ItemEndDate = null;
if (ItemAddItemData.Transaction)
{
ItemTransaction.AddChar(2, (CharacterData)WareHouseData);
}
}
}
break;
case IffGroupFlag.ITEM_TYPE_HAIR_STYLE:
{
var IffHair = IFFEntry.GetIff.GetByHairColor(ItemAddItemData.ItemIffId);
var character = ItemCharacter.GetCharByType((byte)IffHair.CharType);
if (character != null)
{
character.HairColour = IffHair.HairColor;
character.Update(character);
Result.Status = true;
Result.ItemIndex = character.Index;
Result.ItemTypeID = ItemAddItemData.ItemIffId;
Result.ItemOldQty = 0;
Result.ItemNewQty = 1;
Result.ItemUCCKey = null;
Result.ItemFlag = 0;
Result.ItemEndDate = null;
}
}
break;
case IffGroupFlag.ITEM_TYPE_PART:
{
return(AddItemToDB(ItemAddItemData));
}
case IffGroupFlag.ITEM_TYPE_CLUB:
{
return(AddItemToDB(ItemAddItemData));
}
case IffGroupFlag.ITEM_TYPE_AUX:
case IffGroupFlag.ITEM_TYPE_BALL:
case IffGroupFlag.ITEM_TYPE_USE:
{
WareHouseData = ItemWarehouse.GetItem(ItemAddItemData.ItemIffId, 1);
if (WareHouseData != null)
{
Result.Status = true;
Result.ItemIndex = ((WarehouseData)(WareHouseData)).ItemIndex;
Result.ItemTypeID = ((WarehouseData)(WareHouseData)).ItemTypeID;
Result.ItemOldQty = ((WarehouseData)(WareHouseData)).ItemC0;
Result.ItemNewQty = ((WarehouseData)(WareHouseData)).ItemC0 + ItemAddItemData.Quantity;
Result.ItemUCCKey = ((WarehouseData)(WareHouseData)).ItemUCCUnique;
Result.ItemFlag = (byte)((WarehouseData)(WareHouseData)).ItemFlag;
Result.ItemEndDate = null;
//Add
((WarehouseData)(WareHouseData)).AddQuantity(ItemAddItemData.Quantity);
if (ItemAddItemData.Transaction)
{
ItemTransaction.AddItem(0x02, (WarehouseData)WareHouseData, ItemAddItemData.Quantity);
}
}
else if (WareHouseData == null)
{
return(AddItemToDB(ItemAddItemData));
}
}
break;
case IffGroupFlag.ITEM_TYPE_CADDIE:
{
return(AddItemToDB(ItemAddItemData));
}
case IffGroupFlag.ITEM_TYPE_CADDIE_ITEM:
{
WareHouseData = ItemCaddie.GetCaddieBySkinId(ItemAddItemData.ItemIffId);
if (!(WareHouseData == null))
{
((CaddieData)(WareHouseData)).Update();
((CaddieData)(WareHouseData)).UpdateCaddieSkin(ItemAddItemData.ItemIffId, ItemAddItemData.Day);
Result.Status = true;
Result.ItemIndex = ((CaddieData)(WareHouseData)).CaddieIdx;
Result.ItemTypeID = ((CaddieData)(WareHouseData)).CaddieSkin;
Result.ItemOldQty = 1;
Result.ItemNewQty = 1;
Result.ItemUCCKey = string.Empty;
Result.ItemFlag = 0;
Result.ItemEndDate = DateTime.Now.AddDays(ItemAddItemData.Day);
}
}
break;
case IffGroupFlag.ITEM_TYPE_SKIN:
{
return(AddItemToDB(ItemAddItemData));
}
case IffGroupFlag.ITEM_TYPE_MASCOT:
{
WareHouseData = ItemMascot.GetMascotByTypeId(ItemAddItemData.ItemIffId);
if (WareHouseData != null)
{
((MascotData)(WareHouseData)).AddDay(ItemAddItemData.Day);
Result.Status = true;
Result.ItemIndex = ((MascotData)(WareHouseData)).MascotIndex;
Result.ItemTypeID = ((MascotData)(WareHouseData)).MascotTypeID;
Result.ItemOldQty = 1;
Result.ItemNewQty = 1;
Result.ItemUCCKey = "";
Result.ItemFlag = 0;
Result.ItemEndDate = ((MascotData)(WareHouseData)).MascotEndDate;
}
else if (WareHouseData == null)
{
return(AddItemToDB(ItemAddItemData));
}
}
break;
case IffGroupFlag.ITEM_TYPE_CARD:
{
WareHouseData = ItemCard.GetCard(ItemAddItemData.ItemIffId, 1);
if (WareHouseData == null)
{
AddItemToDB(ItemAddItemData);
}
else if (WareHouseData != null)
{
Result.Status = true;
Result.ItemIndex = ((CardData)(WareHouseData)).CardIndex;
Result.ItemTypeID = ((CardData)(WareHouseData)).CardTypeID;
Result.ItemOldQty = ((CardData)(WareHouseData)).CardQuantity;
Result.ItemNewQty = ((CardData)(WareHouseData)).CardQuantity + ItemAddItemData.Quantity;
Result.ItemUCCKey = string.Empty;
Result.ItemFlag = 0;
Result.ItemEndDate = null;
((CardData)(WareHouseData)).AddQuantity(ItemAddItemData.Quantity);
if (ItemAddItemData.Transaction)
{
ItemTransaction.AddCard(0x02, (CardData)WareHouseData, ItemAddItemData.Quantity);
}
}
}
break;
}
return(Result);
}
public static ItemWarehouse CreateItemWarehouse(int itemID, int warehouseID, int maxAllowedOnOrder)
{
ItemWarehouse itemWarehouse = new ItemWarehouse();
itemWarehouse.ItemID = itemID;
itemWarehouse.WarehouseID = warehouseID;
itemWarehouse.MaxAllowedOnOrder = maxAllowedOnOrder;
return itemWarehouse;
}
