public static List <StockTransactionModel> GetStockTransactionModels(List <string> datas)
{
int count = 8;
List <StockTransactionModel> result = new List <StockTransactionModel>();
try
{
datas.ForEach(data =>
{
var arrs = data.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (arrs.Count() == count)
{
StockTransactionModel model = new StockTransactionModel();
model.Time = arrs[0];
model.Price = double.Parse(arrs[1]);
model.DealHands = double.Parse(arrs[2]);
model.DealType = (BuyOrSale)int.Parse(arrs[3]);
//model.SX = double.Parse(arrs[4]);
//model.XX = double.Parse(arrs[5]);
model.Status = (StockStatus)int.Parse(arrs[4]);
model.DealHands2 = double.Parse(arrs[5]);
model.Unknow2 = int.Parse(arrs[6]);
model.Unknow3 = int.Parse(arrs[7]);
result.Add(model);
}
});
}
catch
{
}
return(result.OrderBy(item => item.Time).ToList());
}
private void SetData(StockTransactionModel model)
{
if (model != null)
{
this.Code = model.Code;
this.Name = model.Name;
this.CurrentPercent = model.CurrentPercent;
this.Time = model.Time;
this.Price = model.Price;
this.DealHands = model.DealHands;
this.DealType = model.DealType;
this.Status = model.Status;
this.DealHands2 = model.DealHands2;
this.Unknow2 = model.Unknow2;
this.Unknow3 = model.Unknow3;
this.CurrentTime = DateTime.Now.ToString("HH:mm:ss");
if (!string.IsNullOrEmpty(model.Topic))
{
var topics = model.Topic.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
foreach (var topic in topics)
{
var url = CommonStockDataManager.Instance.GetStorageSectionUrl(topic);
TopicModel temp = new TopicModel();
temp.Topic = topic;
temp.UrlStr = url;
this.TopicModels.Add(temp);
}
}
}
}
public (bool isUpdateExist, QuantityBalanceModel balance) Calculating(StockTransactionModel transaction,
IEnumerable <QuantityBalanceModel> quantityBalanceModels)
{
var qtyBalanceByProduct = quantityBalanceModels
.FirstOrDefault(p =>
p.ProductCode == transaction.ProductCode &&
p.TimeToStock == transaction.TimeToStock &&
p.LocationId == transaction.LocationId);
if (qtyBalanceByProduct is default(QuantityBalanceModel))
{
return(false, TranDataToQtyBalanceModel(transaction.Io == StockIo.In, transaction));
}
if (transaction.Io == StockIo.In)
{
qtyBalanceByProduct.Quantity += transaction.Quantity;
}
else
{
qtyBalanceByProduct.Quantity -= transaction.Quantity;
}
return(true, qtyBalanceByProduct);
}
protected override (bool isDataExist, CostsBalanceModel balance) GetOutCalculateResult(
StockTransactionModel transaction,
CostsBalanceModel currentBalanceData, string targetLocationId)
{
return(currentBalanceData is default(CostsBalanceModel)
? (false, TranDataToValueBalanceModel(true, targetLocationId, transaction))
: (true, currentBalanceData));
}
protected CostsBalanceModel TranDataToValueBalanceModel(bool isIntoStock, string locationId,
StockTransactionModel transactionItem)
{
return(new CostsBalanceModel
{
LocationId = locationId,
ProductCode = transactionItem.ProductCode,
Quantity = transactionItem.Quantity * (isIntoStock ? 1 : -1),
TimeToStock = transactionItem.TimeToStock,
Values = transactionItem.UnitPrice * transactionItem.Quantity,
UnitValues = transactionItem.UnitPrice
});
}
protected override (bool isDataExist, CostsBalanceModel balance) GetInCalculateResult(
StockTransactionModel transaction,
CostsBalanceModel currentBalanceData, string targetLocationId)
{
if (currentBalanceData is default(CostsBalanceModel))
{
return(false, TranDataToValueBalanceModel(true, targetLocationId, transaction));
}
currentBalanceData.Quantity += transaction.Quantity;
currentBalanceData.Values += transaction.UnitPrice * transaction.Quantity;
currentBalanceData.UnitValues = currentBalanceData.Values / currentBalanceData.Quantity;
return(true, currentBalanceData);
}
public (bool isUpdateExist, CostsBalanceModel balance) Calculating(StockTransactionModel transaction,
IEnumerable <CostsBalanceModel> costsBalanceModels,
bool byLocationId)
{
var orderResult = GetOrderResult(costsBalanceModels);
var currentBalanceData = GetCurrentBalanceData(orderResult, transaction.ProductCode,
transaction.TimeToStock, transaction.LocationId);
switch (transaction.Io)
{
case StockIo.Out:
return(GetOutCalculateResult(transaction, currentBalanceData));
case StockIo.In:
return(GetInCalculateResult(transaction, currentBalanceData));
default:
throw new ArgumentOutOfRangeException();
}
}
//This is complete transaction for ReturnToVendorTransaction
//1. Add ReturnToVendorItems
//2. Add StockTransaction
//3. Update StockUpdate (AvailableQuantity)
public static Boolean ReturnToVendorTransaction(List <ReturnToVendorItemsModel> retrnToVendorItemsFromClient, InventoryDbContext inventoryDbContext)
{
//Transaction Begin
//We first Need to make Stock, Stock_Transaction Object with WriteOff data (which has client data)
using (var dbContextTransaction = inventoryDbContext.Database.BeginTransaction())
{
try
{
//This is updated list of stock records after write off items
List <StockModel> stockListForUpdate = new List <StockModel>();
//This is transaction list of write off items
List <StockTransactionModel> stockTxnListForInsert = new List <StockTransactionModel>();
//This is WriteOff List for insert into writeOff table
List <ReturnToVendorItemsModel> retrnToVndrListForInsert = new List <ReturnToVendorItemsModel>();
//Stock data
foreach (var rtvItm in retrnToVendorItemsFromClient)
{
StockModel curStock = new StockModel();
curStock = GetStockbyStockId(rtvItm.StockId, inventoryDbContext);
//curStock.StockId = rtvItm.StockId;
curStock.AvailableQuantity = curStock.AvailableQuantity - rtvItm.Quantity;
stockListForUpdate.Add(curStock);
}
//ReturnToVendorItems data
foreach (var retItm in retrnToVendorItemsFromClient)
{
ReturnToVendorItemsModel retVendor = new ReturnToVendorItemsModel();
retVendor = rtvClone(retItm);
retrnToVndrListForInsert.Add(retVendor);
}
//Save ReturnToVendorItems in database
AddretrnToVndrItems(inventoryDbContext, retrnToVndrListForInsert);
//stocktxn data
foreach (var rtvItem in retrnToVndrListForInsert)
{
StockTransactionModel stkTxnItem = new StockTransactionModel();
stkTxnItem.StockId = rtvItem.StockId;
stkTxnItem.Quantity = (int)rtvItem.Quantity;
stkTxnItem.InOut = "out";
stkTxnItem.ReferenceNo = rtvItem.ReturnToVendorItemId;
stkTxnItem.CreatedBy = rtvItem.CreatedBy;
stkTxnItem.TransactionType = "returntovendor";
stockTxnListForInsert.Add(stkTxnItem);
}
//Save Stock Transaction record
AddStockTransaction(inventoryDbContext, stockTxnListForInsert);
//Update Stock records
UpdateStockAvailQty(inventoryDbContext, stockListForUpdate);
//Commit Transaction
dbContextTransaction.Commit();
return(true);
}
catch (Exception ex)
{
//Rollback all transaction if exception occured i.e. WriteOff Insertion, Stock_Transaction Insertion, Stock Updation
dbContextTransaction.Rollback();
throw ex;
}
}
}
//This function is Transaction and do followig things
//1) Save WriteOff Items entry in WriteOff Table 2) WriteOff Items Entry in Stock_Transaction table
//3) Update Stock Table Quantity
public static Boolean WriteOffItemsTransaction(List <WriteOffItemsModel> writeOffItemsFromClient, InventoryDbContext inventoryDbContext)
{
//Transaction Begin
//We first Need to make Stock, Stock_Transaction Object with WriteOff data (which has client data)
using (var dbContextTransaction = inventoryDbContext.Database.BeginTransaction())
{
try
{
//This is updated list of stock records after write off items
List <StockModel> stockListForUpdate = new List <StockModel>();
//This is transaction list of write off items
List <StockTransactionModel> stockTxnListForInsert = new List <StockTransactionModel>();
//This is WriteOff List for insert into writeOff table
List <WriteOffItemsModel> writeOffListForInsert = new List <WriteOffItemsModel>();
var createdOn = DateTime.Now;
for (int i = 0; i < writeOffItemsFromClient.Count; i++)
{
List <StockModel> currStockList = new List <StockModel>();
currStockList = GetStockItemsByItemIdBatchNO(writeOffItemsFromClient[i].ItemId, writeOffItemsFromClient[i].BatchNO, inventoryDbContext);
if (currStockList.Count > 0)
{
foreach (var currStkItm in currStockList)
{
if (writeOffItemsFromClient[i].WriteOffQuantity > 0)
{
//When stockItem availableQuantity is > WriteOffQuantity
if (currStkItm.AvailableQuantity > writeOffItemsFromClient[i].WriteOffQuantity)
{
WriteOffItemsModel woItemsClone = new WriteOffItemsModel();
//Clone WriteList item
woItemsClone = Clone(writeOffItemsFromClient[i]);
currStkItm.AvailableQuantity = currStkItm.AvailableQuantity - woItemsClone.WriteOffQuantity.Value;
//Push Updated StockItem into StockList for Update Stock
stockListForUpdate.Add(currStkItm);
woItemsClone.StockId = currStkItm.StockId;
woItemsClone.GoodsReceiptItemId = currStkItm.GoodsReceiptItemId;
woItemsClone.WriteOffQuantity = woItemsClone.WriteOffQuantity.Value;
woItemsClone.Remark = woItemsClone.Remark.ToString();
woItemsClone.CreatedOn = createdOn;
//Push Updated WriteOff Item Into WriteOffItemList for Save
writeOffListForInsert.Add(woItemsClone);
//updated Current WriteOff Item Quantity as 0
writeOffItemsFromClient[i].WriteOffQuantity = 0;
}
else if (currStkItm.AvailableQuantity < writeOffItemsFromClient[i].WriteOffQuantity)
{
//when curStkItm.AvailableQuantity< woitm.WriteOffQuantity
WriteOffItemsModel woItemsClone = new WriteOffItemsModel();
woItemsClone = Clone(writeOffItemsFromClient[i]);
woItemsClone.StockId = currStkItm.StockId;
woItemsClone.WriteOffQuantity = currStkItm.AvailableQuantity;
//double and decimal can't multiply so, need explicitly typecasting
woItemsClone.TotalAmount = (decimal)currStkItm.AvailableQuantity * woItemsClone.ItemRate.Value;
woItemsClone.GoodsReceiptItemId = currStkItm.GoodsReceiptItemId;
//Push Updated WriteOff Item Into WriteOffItemList for Save
writeOffListForInsert.Add(woItemsClone);
currStkItm.AvailableQuantity = 0;
//Push Updated StockItem into StockList for Update Stock
stockListForUpdate.Add(currStkItm);
writeOffItemsFromClient[i].WriteOffQuantity = writeOffItemsFromClient[i].WriteOffQuantity - currStkItm.AvailableQuantity;
}
}
}
}
}
//Save WriteOffItems in database
AddWriteOffItems(inventoryDbContext, writeOffListForInsert);
//Make Fill data into Stock_transaction object for save into INV_TXN_StockTransaction table
foreach (var woItem in writeOffListForInsert)
{
StockTransactionModel stkTxnItem = new StockTransactionModel();
//StockTxnId,StockId,Quantity,InOut, ReferenceNo CreatedBy ,CreatedOn,TransactionType
stkTxnItem.StockId = woItem.StockId;
stkTxnItem.Quantity = (int)woItem.WriteOffQuantity;
stkTxnItem.InOut = "out";
stkTxnItem.ReferenceNo = woItem.WriteOffId;
stkTxnItem.CreatedBy = woItem.CreatedBy;
stkTxnItem.TransactionType = "writeoff";
//Push current StkTxnItem into StkTxnItemList for Save to database
stockTxnListForInsert.Add(stkTxnItem);
}
//Save Stock Transaction record
AddStockTransaction(inventoryDbContext, stockTxnListForInsert);
//Update Stock records
UpdateStock(inventoryDbContext, stockListForUpdate);
//Commit Transaction
dbContextTransaction.Commit();
return(true);
}
catch (Exception ex)
{
//Rollback all transaction if exception occured i.e. WriteOff Insertion, Stock_Transaction Insertion, Stock Updation
dbContextTransaction.Rollback();
throw ex;
}
}
}
protected abstract (bool isDataExist, CostsBalanceModel balance) GetOutCalculateResult(StockTransactionModel transaction,
CostsBalanceModel currentBalanceData, string targetLocationId);
public StockModel(StockTransactionModel model) : this()
{
SetData(model);
this.TypeString = ResourceHelper.FindKey("Monitor_TypeString_BigDeal");
}
public static Boolean BackToInventoryTransfer(WARDStockModel stkTransferfromClient, WardSupplyDbContext wardSupplyDbContext, RbacUser currentUser)
{
//Transaction Begin
using (var dbContextTransaction = wardSupplyDbContext.Database.BeginTransaction())
{
try
{
List <Boolean> flag = new List <bool>(); //for checking all transaction status
var AvailableQuantity = (int)(Convert.ToDecimal(stkTransferfromClient.AvailableQuantity)) - (int)(Convert.ToDecimal(stkTransferfromClient.DispachedQuantity));
WARDStockModel stockDetail = (from stock in wardSupplyDbContext.WARDStockModel
where stock.StockId == stkTransferfromClient.StockId && stock.ItemId == stkTransferfromClient.ItemId && stock.DepartmentId == stkTransferfromClient.DepartmentId && stock.StockType == "inventory"
select stock
).FirstOrDefault();
stockDetail.AvailableQuantity = AvailableQuantity;
wardSupplyDbContext.Entry(stockDetail).Property(a => a.AvailableQuantity).IsModified = true;
//add to transaction table
var selectedstockTxnItm = new WARDTransactionModel();
selectedstockTxnItm.WardId = stkTransferfromClient.DepartmentId;
selectedstockTxnItm.newWardId = stkTransferfromClient.newWardId;
selectedstockTxnItm.ItemId = stkTransferfromClient.ItemId;
selectedstockTxnItm.StockId = stkTransferfromClient.StockId;
selectedstockTxnItm.TransactionId = 0;
selectedstockTxnItm.Quantity = (int)(Convert.ToDecimal(stkTransferfromClient.DispachedQuantity));
selectedstockTxnItm.TransactionType = "BackToInventory";
selectedstockTxnItm.Remarks = stkTransferfromClient.Remarks;
selectedstockTxnItm.CreatedBy = currentUser.UserName;
selectedstockTxnItm.CreatedOn = DateTime.Now;
selectedstockTxnItm.IsWard = false;
wardSupplyDbContext.TransactionModel.Add(selectedstockTxnItm);
wardSupplyDbContext.SaveChanges();
//add stock to inventory
var inventoryStock = new StockModel();
inventoryStock = (from stock in wardSupplyDbContext.INVStockMaster
where stock.ItemId == stkTransferfromClient.ItemId && stock.BatchNO == stkTransferfromClient.BatchNo
select stock).FirstOrDefault();
if (inventoryStock != null)
{
inventoryStock.AvailableQuantity = inventoryStock.AvailableQuantity + (int)(Convert.ToDecimal(stkTransferfromClient.DispachedQuantity));
wardSupplyDbContext.Entry(inventoryStock).Property(a => a.AvailableQuantity).IsModified = true;
wardSupplyDbContext.SaveChanges();
var stockTransaction = new StockTransactionModel();
stockTransaction.StockId = inventoryStock.StockId;
stockTransaction.Quantity = (int)(Convert.ToDecimal(stkTransferfromClient.DispachedQuantity));
stockTransaction.InOut = "in";
stockTransaction.ReferenceNo = inventoryStock.GoodsReceiptItemId;
stockTransaction.CreatedBy = currentUser.EmployeeId;
stockTransaction.CreatedOn = DateTime.Now;
stockTransaction.TransactionType = "Sent From WardSupply";
wardSupplyDbContext.INVStockTransaction.Add(stockTransaction);
wardSupplyDbContext.SaveChanges();
}
//add to stock transaction in inventory
dbContextTransaction.Commit();//Commit Transaction
return(true);
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw ex;
}
//return false;
}
}
public QuantityBalanceModel TranDataToQtyBalanceModel(bool isIntoStock,
StockTransactionModel transactionItem)
{
return(new QuantityBalanceModel
{
ExpiryDate = default,
public (bool isUpdateExist, QuantityBalanceModel balance) Calculating(StockTransactionModel transaction,
IEnumerable <QuantityBalanceModel> quantityBalanceModels)
{
throw new System.NotImplementedException();
}
