private int UpdateBalance(ItemTransaction it)
{
HealthFacilityBalance hb = HealthFacilityBalance.GetHealthFacilityBalance(it.HealthFacilityCode, it.Gtin, it.GtinLot);
int i = -1;
if (hb != null)
{
hb.StockCount = it.TransactionQtyInBaseUom;
int qty = (int)(hb.Balance - it.TransactionQtyInBaseUom);
if (qty > 0)
{
WastageTransaction(it, qty);
}
hb.Balance = it.TransactionQtyInBaseUom;
i = HealthFacilityBalance.Update(hb);
}
else
{
HealthFacilityBalance hbnew = new HealthFacilityBalance();
hbnew.HealthFacilityCode = it.HealthFacilityCode;
hbnew.Gtin = it.Gtin;
hbnew.LotNumber = it.GtinLot;
hbnew.StockCount = it.TransactionQtyInBaseUom;
hbnew.Balance = it.TransactionQtyInBaseUom;
i = HealthFacilityBalance.Insert(hbnew);
}
return(i);
}
/// <summary>
/// Gets the current health facility balance for <paramref name="facility"/> of item with <paramref name="gtin"/> or creates if necessary
/// </summary>
/// <param name="facility">The facility to query for current balance</param>
/// <param name="gtin">The GTIN of the item to retrieve the balance for</param>
/// <param name="lot">The lot number to retrieve the balance</param>
/// <returns></returns>
private HealthFacilityBalance GetCurrentBalance(HealthFacility facility, String gtin, String lot)
{
if (facility == null)
{
throw new ArgumentNullException("facility");
}
else if (String.IsNullOrEmpty(gtin))
{
throw new ArgumentNullException("gtin");
}
else if (String.IsNullOrEmpty(lot))
{
throw new ArgumentNullException("lot");
}
// Current balance
HealthFacilityBalance balance = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode(facility.Code).Find(o => o.Gtin == gtin && o.LotNumber == lot);
if (balance == null)
{
balance = new HealthFacilityBalance()
{
Balance = 0,
Gtin = gtin,
HealthFacilityCode = facility.Code,
LotNumber = lot
};
HealthFacilityBalance.Insert(balance);
}
return(balance);
}
/// <summary>
/// Allocate stock
/// </summary>
/// <param name="facility">The facility in which to allocate stock</param>
/// <param name="gtin">The GTIN of the stock to be allocated</param>
/// <param name="lot">The lot number of stock to be allocated</param>
/// <param name="qty">The amount of stock to be allocated</param>
/// <returns>The <see cref="T:GIIS.DataLayer.ItemTransaction"/> representing the allocation</returns>
public ItemTransaction Allocate(HealthFacility facility, String gtin, String lot, Int32 qty, TransferOrderDetail orderLine, Int32 modifiedBy)
{
// Sanity check
if (facility == null)
{
throw new ArgumentNullException("facility");
}
else if (String.IsNullOrEmpty(gtin))
{
throw new ArgumentNullException("gtin");
}
else if (String.IsNullOrEmpty(lot))
{
throw new ArgumentNullException("lot");
}
// Adjustment type
TransactionType allocationType = TransactionType.GetTransactionTypeList().FirstOrDefault(o => o.Name == "Allocation");
if (allocationType == null)
{
throw new InvalidOperationException("Cannot find transaction type 'Allocation'");
}
// Get current balance and ensure we have enough to do the balance
var balance = this.GetCurrentBalance(facility, gtin, lot);
//if (qty > 0 && balance.Balance < qty)
// throw new InvalidOperationException(String.Format("Cannot de-allocate more stock than is available (Request: {0}, Available:{1}, GTIN: {2})", qty, balance, ItemLot.GetItemLotByGtin(gtin).ItemObject.Name));
//else if (qty < 0 && balance.Allocated < -qty)
// throw new InvalidOperationException("Cannot de-allocate more stock than is currently allocated");
// Create an item transaction
ItemTransaction retVal = new ItemTransaction()
{
Gtin = gtin,
GtinLot = lot,
HealthFacilityCode = facility.Code,
ModifiedBy = modifiedBy,
ModifiedOn = DateTime.Now,
RefId = orderLine != null?orderLine.OrderNum.ToString() : null,
RefIdNum = orderLine != null ? orderLine.OrderDetailNum : 0,
TransactionDate = DateTime.Now,
TransactionQtyInBaseUom = qty,
TransactionTypeId = allocationType.Id
};
// Update the balance
//balance.Balance -= qty;
balance.Allocated += qty;
// Save
HealthFacilityBalance.Update(balance);
retVal.Id = ItemTransaction.Insert(retVal);
return(retVal);
}
/// <summary>
/// Performs a stock count for the specified <paramref name="gtin"/> at <paramref name="facility"/>
/// </summary>
/// <param name="facility">The facility in which the count occurred</param>
/// <param name="gtin">The GTIN of the item being counted</param>
/// <param name="lot">The lot number of the item being counted</param>
/// <param name="count">The count of items</param>
/// <returns>The <see cref="T:GIIS.DataLayer.ItemTransaction"/> representing the count</returns>
public ItemTransaction StockCount(HealthFacility facility, String gtin, String lot, UInt32 count, Int32 modifiedBy, DateTime date)
{
// Validate
if (facility == null)
{
throw new ArgumentNullException("facility");
}
else if (String.IsNullOrEmpty(gtin))
{
throw new ArgumentNullException("gtin");
}
else if (String.IsNullOrEmpty(lot))
{
throw new ArgumentNullException("lot");
}
// Stock Count
TransactionType stockCountType = TransactionType.GetTransactionTypeList().FirstOrDefault(o => o.Name == "Stock Count");
if (stockCountType == null)
{
throw new InvalidOperationException("Cannot find transaction type 'Stock Count'");
}
// Balance
var balance = this.GetCurrentBalance(facility, gtin, lot);
// Now we want to create transaction for count operation
ItemTransaction retVal = new ItemTransaction()
{
Gtin = gtin,
GtinLot = lot,
HealthFacilityCode = facility.Code,
ModifiedBy = modifiedBy,
ModifiedOn = DateTime.Now,
TransactionDate = date,
TransactionQtyInBaseUom = count,
TransactionTypeId = stockCountType.Id
};
// Overwrite the values
int qty = (int)(balance.Balance - count);
if (qty > 0)
{
Adjust(facility, gtin, lot, qty, AdjustmentReason.GetAdjustmentReasonById(99), modifiedBy, date);
}
balance.StockCount = balance.Balance = count;
// Save
HealthFacilityBalance.Update(balance);
int i = ItemTransaction.Insert(retVal);
return(ItemTransaction.GetItemTransactionById(i));
}
public void AllocationTest()
{
StockManagementLogic stockLogic = new StockManagementLogic();
// Assertion of initial stock balances
HealthFacilityBalance balance = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF888").Find(o => o.Gtin == TestData.GTIN_UNDER_TEST);
int preBalance = (int)balance.Allocated;
stockLogic.Allocate(HealthFacility.GetHealthFacilityByCode("HF888"), TestData.GTIN_UNDER_TEST, balance.LotNumber, 100, null, 1);
// Get the new balance
balance = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF888").Find(o => o.Gtin == TestData.GTIN_UNDER_TEST);
Assert.AreEqual(preBalance + 100, balance.Allocated);
}
private int UpdateBalance(ItemTransaction it, int qty)
{
HealthFacilityBalance hb = HealthFacilityBalance.GetHealthFacilityBalance(it.HealthFacilityCode, it.Gtin, it.GtinLot);
int i = -1;
if (hb != null)
{
hb.StockCount += qty; //??
hb.Balance += qty;
WastageTransaction(it, qty);
i = HealthFacilityBalance.Update(hb);
}
return(i);
}
/// <summary>
/// Performs rollback of stock transaction for a vaccination event
/// </summary>
/// <param name="facility">The healthfacility where the vaccination event happened</param>
/// <param name="vaccineLotId">The vaccine lot that was used in the vaccination event</param>
public int ClearBalance(HealthFacility facility, int vaccineLotId)
{
if (vaccineLotId > 0)
{
ItemLot il = ItemLot.GetItemLotById(vaccineLotId);
HealthFacilityBalance hb = HealthFacilityBalance.GetHealthFacilityBalance(facility.Code, il.Gtin, il.LotNumber);
if (hb != null)
{
hb.Used -= 1;
hb.Balance += 1;
int i = HealthFacilityBalance.Update(hb);
return(i);
}
}
return(-1);
}
/// <summary>
/// Gets the oldest lot in a facility of the specified <paramref name="gtin"/>
/// </summary>
/// <param name="facility">The facility in which the oldest lot should be found</param>
/// <param name="gtin">The GTIN of the item to be found</param>
/// <returns>The <see cref="T:GIIS.DataLayer.ItemLot"/> with the earliest expiry date</returns>
public ItemLot GetOldestLot(HealthFacility facility, String gtin)
{
var oldestLot = from l in
(from v in HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode(facility.Code)
where gtin == v.Gtin
select new { il = ItemLot.GetItemLotByGtinAndLotNo(gtin, v.LotNumber), hfb = v })
where l.il != null
orderby l.il.ExpireDate
select l;
var candidateLot = (oldestLot.FirstOrDefault(o => o.hfb.Balance > 0) ?? oldestLot.FirstOrDefault());
// Candidate lot is null when there is demand (from a kit item) with no lot available!
if (candidateLot == null)
{
// Is it becaues there is no lot in existence?
var itemLot = ItemLot.GetItemLotByGtin(gtin);
if (itemLot == null)
{
itemLot = new ItemLot()
{
Gtin = gtin,
LotNumber = String.Format("N/A-{0}", gtin),
Notes = "Automatically inserted by order system",
ItemId = ItemManufacturer.GetItemManufacturerByGtin(gtin).ItemId
};
itemLot.Id = ItemLot.Insert(itemLot);
}
// Is there no balance?
var balanceLot = HealthFacilityBalance.GetHealthFacilityBalanceByLotNumber(itemLot.LotNumber);
if (balanceLot == null)
{
HealthFacilityBalance.Insert(new HealthFacilityBalance()
{
Gtin = gtin,
HealthFacilityCode = facility.Code,
LotNumber = itemLot.LotNumber
});
}
return(itemLot);
}
else
{
return(candidateLot.il);
}
}
public void TransferTest()
{
StockManagementLogic stockLogic = new StockManagementLogic();
// Assertion of initial stock balances
HealthFacilityBalance balanceHf888 = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF888").Find(o => o.Gtin == TestData.GTIN_UNDER_TEST),
balanceHf999 = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF999").Find(o => o.Gtin == TestData.GTIN_UNDER_TEST);
int preBalance888 = (int)balanceHf888.Balance,
preBalance999 = (int)balanceHf999.Balance;
stockLogic.Transfer(HealthFacility.GetHealthFacilityByCode("HF888"), HealthFacility.GetHealthFacilityByCode("HF999"), TestData.GTIN_UNDER_TEST, balanceHf888.LotNumber, null, 100, 1);
// Get the new balance
balanceHf888 = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF888").Find(o => o.Gtin == TestData.GTIN_UNDER_TEST);
balanceHf999 = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF999").Find(o => o.Gtin == TestData.GTIN_UNDER_TEST);
Assert.AreEqual(preBalance888 - 100, balanceHf888.Balance);
Assert.AreEqual(preBalance999 + 100, balanceHf999.Balance);
}
protected void Page_Load(object sender, EventArgs e)
{
if (CurrentEnvironment.LoggedUser == null)
{
Response.Redirect("../Default.aspx", false);
}
else if (!Page.IsPostBack)
{
GetStockStatusinDosesChart();
int hfid = CurrentEnvironment.LoggedUser.HealthFacilityId;
DataTable originalData = new HealthFacilityBalance().GetCoverageChart(hfid);
DataTable dt = Pivot(originalData, "Name", "Month", "Percentage");
GetVaccinationCoverageChart(dt);
}
}
private int UpdateBalance(ItemTransaction it, int qty)
{
HealthFacilityBalance hb = HealthFacilityBalance.GetHealthFacilityBalance(it.HealthFacilityCode, it.Gtin, it.GtinLot);
int i = -1;
if (hb != null)
{
if (it.AdjustmentObject.Positive)
{
hb.Balance += qty;
}
else
{
hb.Balance -= qty;
hb.Wasted += qty;
}
i = HealthFacilityBalance.Update(hb);
}
return(i);
}
protected void btnAdd_Click(object sender, EventArgs e)
{
try
{
if (Page.IsValid)
{
string orderNumber = "";
if (Request.QueryString["orderNum"] != null)
{
orderNumber = Request.QueryString["orderNum"].ToString();
}
int index = 0;
for (int rowIndex = 0; rowIndex < gvCreateTOD.Rows.Count; rowIndex++)
{
//extract the TextBox values
Label lblOrderGtin = (Label)gvCreateTOD.Rows[rowIndex].Cells[0].FindControl("lblGtin");
TextBox txtValue = (TextBox)gvCreateTOD.Rows[rowIndex].Cells[2].FindControl("txtQty");
Label lblItem = (Label)gvCreateTOD.Rows[rowIndex].Cells[1].FindControl("lblGtinItem");
DropDownList ddlUom = (DropDownList)gvCreateTOD.Rows[rowIndex].Cells[3].FindControl("ddlUom2");
if (!String.IsNullOrEmpty(txtValue.Text))
{
string gtin = lblOrderGtin.Text;
string uom = ddlUom.SelectedValue;
double qty = double.Parse(txtValue.Text);
string item = lblItem.Text;
index = NewOrderDetail(orderNumber, gtin, qty, uom, item);
if (index > 0)
{
List <ItemManufacturer> imlist = ItemManufacturer.GetItemManufacturerByParentGtin(gtin);
if (imlist.Count > 0)
{
foreach (ItemManufacturer imo in imlist)
{
index = NewOrderDetail(orderNumber, imo.Gtin, qty, uom, imo.ItemObject.Code);
}
}
}
}
}
if (index > 0)
{
lblSuccess.Visible = true;
lblWarning.Visible = false;
lblError.Visible = false;
gvCreateTOD.Visible = false;
gvGtinValue.Visible = true;
odsGtinValue.SelectParameters.Clear();
odsGtinValue.SelectParameters.Add("orderNumber", orderNumber);
odsGtinValue.SelectParameters.Add("healthFacilityCode", CurrentEnvironment.LoggedUser.HealthFacility.Code);
gvGtinValue.DataSourceID = "odsGtinValue";
gvGtinValue.DataBind();
tbl.Visible = true;
ddlGtin.Visible = true;
ddlUom.Visible = true;
txtQuantity.Visible = true;
btnAdd.Visible = false;
btnEdit.Visible = true;
btnAddDetail.Visible = true;
btnRelease.Visible = true;
btnCancel.Visible = true;
////bind ddl
//List<Uom> uomList = Uom.GetUomList();
//ddlUom.DataSource = uomList;
//ddlUom.DataBind();
DataTable dt = HealthFacilityBalance.GetItemManufacturerBalanceForDropDown(CurrentEnvironment.LoggedUser.HealthFacilityId);
ddlGtin.DataSource = dt;
ddlGtin.DataBind();
}
else
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
}
catch (Exception ex)
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
/// <summary>
/// Performs stock transaction for a vaccination event
/// </summary>
/// <param name="facility">The facility in which the vaccination event occurred</param>
/// <param name="vaccination">The vaccination event</param>
/// <returns>The <see cref="T:GIIS.DataLayer.ItemTransaction"/> representing the transfer</returns>
public ItemTransaction Vaccinate(HealthFacility facility, VaccinationEvent vaccination)
{
// Vaccination not given = no transaction
if (!vaccination.VaccinationStatus)
{
return(null);
}
List <ItemLot> lots = new List <ItemLot>();
// Verify
if (facility == null)
{
throw new ArgumentNullException("facility");
}
else if (vaccination == null)
{
throw new ArgumentNullException("vaccination");
}
else if (String.IsNullOrEmpty(vaccination.VaccineLot))
{
ItemManufacturer gtin = ItemManufacturer.GetItemManufacturerByItem(vaccination.Dose.ScheduledVaccination.ItemId);
OrderManagementLogic oml = new OrderManagementLogic();
lots.Add(oml.GetOldestLot(facility, gtin.Gtin));
}
//throw new ArgumentException("Vaccination event missing lot#", "vaccination");
// Item lot that was used
if (lots.Count == 0)
{
lots.Add(ItemLot.GetItemLotById(vaccination.VaccineLotId));
}
//lots.Add(ItemLot.GetItemLotByLotNumber(vaccination.VaccineLot));
if (lots.Count == 0)
{
return(null);
}
// throw new InvalidOperationException("Cannot find the specified ItemLot relation (GTIN)");
// Transaction type
TransactionType vaccinationType = TransactionType.GetTransactionTypeList().FirstOrDefault(o => o.Name == "Vaccination");
if (vaccinationType == null)
{
throw new InvalidOperationException("Cannot find transaction type 'Vaccination'");
}
// Return value
ItemTransaction retVal = null;
// Iterate through lots
for (int i = 0; i < lots.Count; i++)
{
var lot = lots[i];
// Get balance
HealthFacilityBalance balance = this.GetCurrentBalance(facility, lot.Gtin, lot.LotNumber);
//if (balance.Balance < 1)
// throw new InvalidOperationException("Insufficient doses to register vaccination event");
// Create a transaction
#if XAMARIN
#else
#endif
ItemTransaction itl = new ItemTransaction()
{
Gtin = lot.Gtin,
GtinLot = lot.LotNumber,
HealthFacilityCode = facility.Code,
ModifiedBy = vaccination.ModifiedBy,
ModifiedOn = vaccination.ModifiedOn,
RefIdNum = vaccination.Id,
TransactionDate = vaccination.VaccinationDate,
TransactionQtyInBaseUom = -1,
TransactionTypeId = vaccinationType.Id
};
if (String.IsNullOrEmpty(vaccination.VaccineLot))
{
vaccination.VaccineLotId = lot.Id;
VaccinationEvent.Update(vaccination);
}
// Update facility balances
balance.Balance -= 1;
balance.Used += 1;
// Now save
HealthFacilityBalance.Update(balance);
itl.Id = ItemTransaction.Insert(itl);
if (retVal == null)
{
retVal = itl;
}
// Linked or kitted items
var lotGtinItem = ItemManufacturer.GetItemManufacturerByGtin(lot.Gtin);
foreach (var im in lotGtinItem.KitItems)
{
lots.Add(new OrderManagementLogic().GetOldestLot(facility, im.Gtin));
}
}
return(retVal);
}
/// <summary>
/// Transfers stock from facility <paramref name="from"/> to facility <paramref name="to"/>
/// </summary>
/// <param name="from">The facility from which stock is being transferred</param>
/// <param name="to">The facility to which stock is being transferred</param>
/// <param name="gtin">The GTIN of the stock being transfered</param>
/// <param name="lot">The lot of the stock being transferred</param>
/// <param name="orderDetail">The order detail which informed this transfer</param>
/// <param name="qty">The quantity of stock to be transferred</param>
/// <returns>The <see cref="T:GIIS.DataLayer.ItemTransaction"/> representing the transfers </returns>
public List <ItemTransaction> Transfer(HealthFacility from, HealthFacility to, String gtin, String lot, TransferOrderDetail orderDetail, Int32 qty, Int32 modifiedBy)
{
// Validate parameters
if (from == null)
{
throw new ArgumentNullException("from");
}
else if (to == null)
{
throw new ArgumentNullException("to");
}
else if (String.IsNullOrEmpty(gtin))
{
throw new ArgumentNullException("gtin");
}
else if (String.IsNullOrEmpty(lot))
{
throw new ArgumentNullException("lot");
}
// Transfer type
TransactionType transferType = TransactionType.GetTransactionTypeList().FirstOrDefault(o => o.Name == "Transfer");
if (transferType == null)
{
throw new InvalidOperationException("Cannot find transaction type 'Transfer'");
}
// Lookup the current balances in both facilities
HealthFacilityBalance fromBalance = this.GetCurrentBalance(from, gtin, lot),
toBalance = this.GetCurrentBalance(to, gtin, lot);
// Validate the fromBalance has sufficient quantity to transfer
//if (fromBalance.Balance < qty)
// throw new InvalidOperationException("Insufficient quantity in the 'from' facility to perform transfer");
// Two ItemTransactions
ItemTransaction fromTransaction = new ItemTransaction()
{
Gtin = gtin,
GtinLot = lot,
HealthFacilityCode = from.Code,
ModifiedBy = modifiedBy,
ModifiedOn = DateTime.Now,
RefId = orderDetail != null?orderDetail.OrderNum.ToString() : null,
RefIdNum = orderDetail != null ? orderDetail.OrderDetailNum : 0,
TransactionDate = DateTime.Now,
TransactionQtyInBaseUom = -qty, // transfer out
TransactionTypeId = transferType.Id
},
toTrasnaction = new ItemTransaction()
{
Gtin = gtin,
GtinLot = lot,
HealthFacilityCode = to.Code,
ModifiedBy = modifiedBy,
ModifiedOn = DateTime.Now,
RefId = orderDetail != null?orderDetail.OrderNum.ToString() : null,
RefIdNum = orderDetail != null ? orderDetail.OrderDetailNum : 0,
TransactionDate = DateTime.Now,
TransactionQtyInBaseUom = qty, // transfer in
TransactionTypeId = transferType.Id
};
// Update balances
fromBalance.Balance -= qty;
toBalance.Balance += qty;
toBalance.Received += qty;
fromBalance.Distributed += qty;
// Save
HealthFacilityBalance.Update(fromBalance);
HealthFacilityBalance.Update(toBalance);
fromTransaction.Id = ItemTransaction.Insert(fromTransaction);
toTrasnaction.Id = ItemTransaction.Insert(toTrasnaction);
// Return
return(new List <ItemTransaction>()
{
fromTransaction, toTrasnaction
});
}
/// <summary>
/// Initialize the test data
/// </summary>
public static void InitializeTestDataset()
{
/// Transaction type 999 = ID
var transactionTypes = TransactionType.GetTransactionTypeList();
if (!transactionTypes.Exists(o => o.Name == "Allocation"))
{
TransactionType.Insert(new TransactionType()
{
Name = "Allocation"
});
}
if (!transactionTypes.Exists(o => o.Name == "Transfer"))
{
TransactionType.Insert(new TransactionType()
{
Name = "Transfer"
});
}
// GTIN 12345 - PHARMACO OPV
if (ItemManufacturer.GetItemManufacturerByGtin(GTIN_UNDER_TEST) == null)
{
// Item Category 999 = Vaccine
if (ItemCategory.GetItemCategoryById(VACCINE_CATEGORY_ID) == null)
{
VACCINE_CATEGORY_ID = ItemCategory.Insert(new ItemCategory()
{
Id = VACCINE_CATEGORY_ID,
Code = "VACCINE",
IsActive = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Name = "Vaccine"
});
}
// Item 999 - OPV
if (Item.GetItemById(OPV_ITEM_ID) == null)
{
OPV_ITEM_ID = Item.Insert(new Item()
{
Code = "OPV",
EntryDate = DateTime.Now,
Id = OPV_ITEM_ID,
ItemCategoryId = VACCINE_CATEGORY_ID,
IsActive = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Name = "OPV"
});
}
// Unit of Measure
if (Uom.GetUomById(DOSE_UOM_ID) == null)
{
DOSE_UOM_ID = Uom.Insert(new Uom()
{
Id = DOSE_UOM_ID,
Name = "DOSE"
});
}
// Manufacturer 999 - PHARMACO
if (Manufacturer.GetManufacturerById(PHARMACO_MANUFACTURER_ID) == null)
{
PHARMACO_MANUFACTURER_ID = Manufacturer.Insert(new Manufacturer()
{
Id = PHARMACO_MANUFACTURER_ID,
Code = "PHX",
IsActive = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Name = "PHARMACO INC."
});
}
ItemManufacturer.Insert(new ItemManufacturer()
{
Alt1QtyPer = 20,
BaseUom = "DOSE",
BaseUomChildPerBaseUomParent = 10,
Gtin = GTIN_UNDER_TEST,
IsActive = true,
ItemId = OPV_ITEM_ID,
ManufacturerId = PHARMACO_MANUFACTURER_ID,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Price = 9.99,
StorageSpace = 1,
Alt1Uom = "DOSE",
Alt2QtyPer = 30,
Alt2Uom = "DOSE"
});
}
if (ItemLot.GetItemLotByGtin(GTIN_UNDER_TEST) == null)
{
// Item 999 - OPV
if (Item.GetItemById(OPV_ITEM_ID) == null)
{
OPV_ITEM_ID = Item.Insert(new Item()
{
Code = "OPV",
EntryDate = DateTime.Now,
Id = OPV_ITEM_ID,
ItemCategoryId = VACCINE_CATEGORY_ID,
IsActive = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Name = "OPV"
});
}
ItemLot.Insert(new ItemLot()
{
ExpireDate = DateTime.Now.AddDays(10),
Gtin = GTIN_UNDER_TEST,
ItemId = OPV_ITEM_ID,
LotNumber = GTIN_LOT_USE_FIRST
});
// Item Lot 2 - Will be more stock and expires later
ItemLot.Insert(new ItemLot()
{
ExpireDate = DateTime.Now.AddDays(40),
Gtin = GTIN_UNDER_TEST,
ItemId = OPV_ITEM_ID,
LotNumber = GTIN_LOT_USE_LAST
});
// Item Lot 3 - Will trigger low stock
ItemLot.Insert(new ItemLot()
{
ExpireDate = DateTime.Now.AddDays(80),
Gtin = GTIN_UNDER_TEST,
ItemId = OPV_ITEM_ID,
LotNumber = GTIN_LOT_LOW_BAL
});
}
// Type 3 = DISTRICT
if (HealthFacilityType.GetHealthFacilityTypeById(6) == null)
{
HealthFacilityType.Insert(new HealthFacilityType()
{
Id = 3,
Code = "DISTRICT",
IsActive = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Name = "DISTRICT LEVEL"
});
}
// Type 6 = SDP
if (HealthFacilityType.GetHealthFacilityTypeById(6) == null)
{
HealthFacilityType.Insert(new HealthFacilityType()
{
Id = 6,
Code = "SDP",
IsActive = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now,
Name = "SDP"
});
}
// HF888 = DISTRICT
if (HealthFacility.GetHealthFacilityByCode("HF888") == null)
{
HealthFacility.Insert(new HealthFacility()
{
Id = 888,
Code = "HF888",
ColdStorageCapacity = 1000,
IsActive = true,
Leaf = false,
ParentId = HealthFacility.GetHealthFacilityByParentId(0)[0].Id,
TopLevel = false,
TypeId = 3,
VaccinationPoint = false,
VaccineStore = true,
ModifiedBy = 1,
ModifiedOn = DateTime.Now
});
}
// GIVE HEALTH FACILITY SOME BALANCE
var hf888Balances = HealthFacilityBalance.GetHealthFacilityBalanceByHealthFacilityCode("HF888");
HealthFacilityBalance useFirst = hf888Balances.Find(o => o.Gtin == GTIN_UNDER_TEST && o.LotNumber == GTIN_LOT_USE_FIRST),
useLast = hf888Balances.Find(o => o.Gtin == GTIN_UNDER_TEST && o.LotNumber == GTIN_LOT_USE_LAST),
lowStock = hf888Balances.Find(o => o.Gtin == GTIN_UNDER_TEST && o.LotNumber == GTIN_LOT_LOW_BAL);
if (useFirst == null)
{
useFirst = new HealthFacilityBalance()
{
Allocated = 0,
Balance = 500,
Distributed = 0,
Gtin = GTIN_UNDER_TEST,
HealthFacilityCode = "HF888",
LotNumber = GTIN_LOT_USE_FIRST,
Received = 0,
StockCount = 500,
Used = 0,
Wasted = 0
};
hf888Balances.Add(useFirst);
HealthFacilityBalance.Insert(useFirst);
}
else
{
useFirst.Balance = 500;
useFirst.StockCount = 500;
HealthFacilityBalance.Update(useFirst);
}
if (useLast == null)
{
useLast = new HealthFacilityBalance()
{
Allocated = 0,
Balance = 1000,
Distributed = 0,
Gtin = GTIN_UNDER_TEST,
HealthFacilityCode = "HF888",
LotNumber = GTIN_LOT_USE_LAST,
Received = 0,
StockCount = 1000,
Used = 0,
Wasted = 0
};
hf888Balances.Add(useLast);
HealthFacilityBalance.Insert(useLast);
}
else
{
useLast.Balance = 1000;
useLast.StockCount = 1000;
HealthFacilityBalance.Update(useLast);
}
if (lowStock == null)
{
lowStock = new HealthFacilityBalance()
{
Allocated = 0,
Balance = 10,
Distributed = 0,
Gtin = GTIN_UNDER_TEST,
HealthFacilityCode = "HF888",
LotNumber = GTIN_LOT_LOW_BAL,
Received = 0,
StockCount = 10,
Used = 0,
Wasted = 0
};
hf888Balances.Add(lowStock);
HealthFacilityBalance.Insert(lowStock);
}
else
{
useLast.Balance = 10;
useLast.StockCount = 10;
HealthFacilityBalance.Update(lowStock);
}
// HF999 = SDP
if (HealthFacility.GetHealthFacilityByCode("HF999") == null)
{
HealthFacility.Insert(new HealthFacility()
{
Id = 999,
Code = "HF999",
ColdStorageCapacity = 100,
IsActive = true,
Leaf = true,
ParentId = HealthFacility.GetHealthFacilityByCode("HF888").Id,
TopLevel = false,
TypeId = 6,
VaccinationPoint = true,
VaccineStore = true,
ModifiedOn = DateTime.Now,
ModifiedBy = 1
});
}
}
/// <summary>
/// Make an adjustment
/// </summary>
/// <param name="facility">The facility in which the adjustment is being made</param>
/// <param name="gtin">The GTIN of the stock item being adjusted</param>
/// <param name="lot">The lot number of the stock being adjusted</param>
/// <param name="qty">The amount of the adjustment</param>
/// <param name="reason">The reason for the adjustment</param>
/// <returns>The <see cref="T:GIIS.DataLayer.ItemTransaction"/> representing the transaction created</returns>
/// <remarks>This method updates the ItemTransaction and HealthFacility Balances</remarks>
public ItemTransaction Adjust(HealthFacility facility, String gtin, String lot, Int32 qty, AdjustmentReason reason, Int32 modifiedBy, DateTime date)
{
if (facility == null)
{
throw new ArgumentNullException("facility");
}
else if (String.IsNullOrEmpty(gtin))
{
throw new ArgumentNullException("gtin");
}
// Adjustment type
TransactionType adjustmentType = TransactionType.GetTransactionTypeList().FirstOrDefault(o => o.Name == "Adjustment");
if (adjustmentType == null)
{
throw new InvalidOperationException("Cannot find transaction type 'Adjustment'");
}
var balance = this.GetCurrentBalance(facility, gtin, lot);
// Sanity check, is there a balance of this?
//if (qty < 0 && -qty > balance.Balance)
// throw new InvalidOperationException("Quantity is a negative adjustment on a balance which exceeds the current balance");
int quantity;
if (reason.Positive)
{
quantity = qty;
}
else
{
quantity = -qty;
}
// Create the item transaction
ItemTransaction retVal = new ItemTransaction()
{
ModifiedBy = modifiedBy,
AdjustmentId = reason.Id,
Gtin = gtin,
GtinLot = lot,
HealthFacilityCode = facility.Code,
ModifiedOn = DateTime.Now,
TransactionDate = date,
TransactionQtyInBaseUom = quantity,
TransactionTypeId = adjustmentType.Id
};
// Adjust the balance
// An adjustment reason can be positive - results in increased balance
if (reason.Id != 99)
{
if (reason.Positive)
{
balance.Balance += qty;
}
else
{
balance.Balance -= qty;
balance.Wasted += qty;
}
}
// Adjust the balances of other reasons
//if(adjustmentType != null)
//{
// switch(adjustmentType.Name)
// {
// case "Adjustments":
// balance.Wasted += -qty;
// break;
// }
//}
// Save the balances
HealthFacilityBalance.Update(balance);
int i = ItemTransaction.Insert(retVal);
return(ItemTransaction.GetItemTransactionById(i));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!this.Page.IsPostBack)
{
List <string> actionList = null;
string sessionNameAction = "";
if (CurrentEnvironment.LoggedUser != null)
{
sessionNameAction = "__GIS_actionList_" + CurrentEnvironment.LoggedUser.Id;
actionList = (List <string>)Session[sessionNameAction];
}
if ((actionList != null) && actionList.Contains("ViewTransferOrderDetails") && (CurrentEnvironment.LoggedUser != null))
{
int userId = CurrentEnvironment.LoggedUser.Id;
string language = CurrentEnvironment.Language;
int languageId = int.Parse(language);
Dictionary <string, string> wtList = (Dictionary <string, string>)HttpContext.Current.Cache["TransferOrderDetail-dictionary" + language];
if (wtList == null)
{
List <WordTranslate> wordTranslateList = WordTranslate.GetWordByLanguage(languageId, "TransferOrderDetail");
wtList = new Dictionary <string, string>();
foreach (WordTranslate vwt in wordTranslateList)
{
wtList.Add(vwt.Code, vwt.Name);
}
HttpContext.Current.Cache.Insert("TransferOrderDetail-dictionary" + language, wtList);
}
this.lblOrderNum.Text = wtList["TransferOrderDetailOrderNum"];
//this.lblOrderDetailNum.Text = wtList["TransferOrderDetailOrderDetailNum"];
//this.lblOrderGtin.Text = wtList["TransferOrderDetailOrderGtin"];
//this.lblOrderGtinLotnum.Text = wtList["TransferOrderDetailOrderGtinLotnum"];
//this.lblOrderCustomItem.Text = wtList["TransferOrderDetailOrderCustomItem"];
//this.lblOrderDetailDescription.Text = wtList["TransferOrderDetailOrderDetailDescription"];
//this.lblOrderUom.Text = wtList["TransferOrderDetailOrderUom"];
//this.lblOrderQtyInBaseUom.Text = wtList["TransferOrderDetailOrderQtyInBaseUom"];
//this.lblOrderDetailStatus.Text = wtList["TransferOrderDetailOrderDetailStatus"];
//this.lblRevNum.Text = wtList["TransferOrderDetailRevNum"];
//gvGtinValue.Columns[2].HeaderText = wtList["TransferOrderDetailOrderItem"];
gvGtinValue.Columns[4].HeaderText = wtList["TransferOrderDetailOrderGtin"];
gvGtinValue.Columns[5].HeaderText = wtList["TransferOrderDetailOrderGtinLotnum"];
gvGtinValue.Columns[6].HeaderText = wtList["TransferOrderDetailOrderQtyInBaseUom"];
gvGtinValue.Columns[7].HeaderText = wtList["TransferOrderDetailOrderUom"];
// this.btnAdd.Visible = actionList.Contains("AddTransferOrderDetail");
// this.btnAdd.Text = wtList["TransferOrderDetailAddButton"];
btnRelease.Visible = false;
btnPack.Visible = false;
btnShip.Visible = false;
btnCancel.Visible = false;
if (Request.QueryString["orderNum"] != null)
{
string orderNumber = Request.QueryString["orderNum"].ToString();
//Requested = 0,
//Released = 1,
//Packed = 2,
//Shipped = 3,
//Cancelled = -1
TransferOrderHeader orderheader = TransferOrderHeader.GetTransferOrderHeaderByOrderNum(int.Parse(orderNumber));
txtOrderNum.Text = orderheader.OrderNum.ToString();
txtOrderSchedReplenishDate.Text = orderheader.OrderSchedReplenishDate.ToString("dd-MMM-yyyy");
txtOrderFacilityFrom.Text = orderheader.OrderFacilityFromObject.Name;
txtOrderFacilityTo.Text = orderheader.OrderFacilityToObject.Name;
int ostatus = orderheader.OrderStatus;
switch (ostatus)
{
case 0:
txtOrderStatus.Text = "Requested";
break;
case 1:
txtOrderStatus.Text = "Released";
break;
case 2:
txtOrderStatus.Text = "Packed";
break;
case 3:
txtOrderStatus.Text = "Shipped";
break;
case -1:
txtOrderStatus.Text = "Canceled";
break;
}
txtOrderCarrier.Text = orderheader.OrderCarrier;
List <TransferOrderDetail> orderDetailList = TransferOrderDetail.GetTransferOrderDetailByOrderNumAsList(int.Parse(orderNumber), CurrentEnvironment.LoggedUser.HealthFacility.Code);
if (orderDetailList.Count >= 1)
{
if (orderheader.OrderStatus == 0)
{
btnRelease.Visible = true;
btnCancel.Visible = true;
gvCreateTOD.Visible = false;
gvGtinValue.Visible = true;
ddlItemLot.Visible = false;
}
else if (orderheader.OrderStatus == 1)
{
btnPack.Visible = true;
btnCancel.Visible = true;
gvCreateTOD.Visible = false;
gvGtinValue.Visible = true;
}
else if (orderheader.OrderStatus == 2)
{
btnShip.Visible = true;
btnCancel.Visible = true;
gvCreateTOD.Visible = false;
gvGtinValue.Visible = true;
}
else if (orderheader.OrderStatus == 3)
{
btnAdd.Visible = false;
ddlGtin.Visible = false;
ddlItemLot.Visible = false;
ddlUom.Visible = false;
txtQuantity.Visible = false;
btnEdit.Visible = false;
btnAddDetail.Visible = false;
tbl.Visible = false;
}
else if (orderheader.OrderStatus == -1)
{
btnAdd.Visible = false;
ddlGtin.Visible = false;
ddlItemLot.Visible = false;
ddlUom.Visible = false;
txtQuantity.Visible = false;
btnEdit.Visible = false;
btnAddDetail.Visible = false;
tbl.Visible = false;
}
hlPrintPackingSlip.Visible = orderheader.OrderStatus > 0;
hlPrintPackingSlip.NavigateUrl = String.Format("{0}/Pack_Order_Report.pdf?j_username={1}&j_password={2}&OrderNum={3}",
ConfigurationManager.AppSettings["JasperServer"],
ConfigurationManager.AppSettings["JasperUser"],
ConfigurationManager.AppSettings["JasperPassword"],
orderheader.OrderNum);
odsGtinValue.SelectParameters.Clear();
odsGtinValue.SelectParameters.Add("orderNumber", orderNumber);
odsGtinValue.SelectParameters.Add("healthFacilityCode", CurrentEnvironment.LoggedUser.HealthFacility.Code);
gvGtinValue.DataSourceID = "odsGtinValue";
gvGtinValue.DataBind();
//List<Uom> uomList = Uom.GetUomList();
//ddlUom.DataSource = uomList;
//ddlUom.DataBind();
DataTable dt = HealthFacilityBalance.GetItemManufacturerBalanceForDropDown(CurrentEnvironment.LoggedUser.HealthFacilityId);
ddlGtin.DataSource = dt;
ddlGtin.DataBind();
}
else
{
gvCreateTOD.Visible = true;
gvGtinValue.Visible = false;
odsCreateTOD.SelectParameters.Clear();
odsCreateTOD.SelectParameters.Add("healthFacilityCode", CurrentEnvironment.LoggedUser.HealthFacility.Code);
gvCreateTOD.DataSourceID = "odsCreateTOD";
gvCreateTOD.DataBind();
btnAdd.Visible = true;
//hide cotrols
tbl.Visible = false;
ddlGtin.Visible = false;
ddlItemLot.Visible = false;
ddlUom.Visible = false;
txtQuantity.Visible = false;
btnEdit.Visible = false;
btnAddDetail.Visible = false;
}
}
}
}
}
