public bool SendThings(User user, Dictionary <List <Thing>, int> chosenThings)
{
if (!CheckCanStartTransaction(user))
{
return(false);
}
List <KeyValuePair <RealmThing, int> > realmThings = new List <KeyValuePair <RealmThing, int> >();
foreach (KeyValuePair <List <Thing>, int> entry in chosenThings)
{
RealmThing realmThing = realmData.ToRealmThing(entry.Key[0]);
realmThings.Add(new KeyValuePair <RealmThing, int>(realmThing, entry.Value));
}
int id = ++this.currentUser.lastTransactionId;
ItemTransaction transaction = new ItemTransaction(id, currentUser, user, chosenThings, realmThings);
realmData.transactions.Add(transaction);
this.SendPacket(new StartTransactionPacket {
transaction = transaction
});
Messages.Message("Offer sent, waiting for confirmation", MessageSound.Silent);
return(true);
}
private void HeaderEvents_OnNew(object Sender, ExtenderEventArgs e)
{
_transaction = (ItemTransaction)e.get_data();
//Se cliente da última venda diferente de 0
if (lastCustomerId != 0)
{
double customerPoints = GetCustomerPoints(lastCustomerId); //verifica os pontos que o cliente tem
if (customerPoints >= 200) //se cliente com mais de 200 pontos
{
//retira 200 pontos ao cliente
Discount200Points(lastCustomerId);
//criar um TDE no valor de 10€ para o cliente, referência POINTS (se não existir, é criada automaticamente)
var transactionTDE = CreateNewDocumentTDE(bsoItemTrans.Transaction.TransSerial, bsoItemTrans.Transaction.DefaultWarehouse, "TDE", 10, lastCustomerId, bsoItemTrans.Transaction.Salesman.SalesmanID, true);
//Imprime o TDE (tem de estar configurado na Conf. postos para impressão)
BSOItemTransaction bsoItemTransaction = null;
bsoItemTransaction = new BSOItemTransaction();
bsoItemTransaction.UserPermissions = MyApp.SystemSettings.User;
bsoItemTransaction.PrintTransaction(transactionTDE.TransSerial, transactionTDE.TransDocument, transactionTDE.TransDocNumber, RTLPrint16.PrintJobEnum.jobPrint, 1);
bsoItemTransaction = null;
}
}
lastCustomerId = 0;
}
public HttpResponseMessage AddItem([FromBody] ItemTransaction item, string api)
{
try
{
item.name = Core.gameItems[item.itemId].name;
item.url = Core.gameItems[item.itemId].url;
Core.items[item.itemId].Insert(0, item);
if (Core.items[item.itemId].Count > 10)
{
Core.items[item.itemId].RemoveAt(Core.items[item.itemId].Count - 1);
}
Core.lastItems.Insert(0, item);
if (Core.lastItems.Count >= 100)
{
Core.lastItems.RemoveAt(Core.lastItems.Count - 1);
}
Task.Run(() => APIBackend.Database.Insert(string.Format("INSERT INTO transactions (itemid, price, time, amount, enchantment) VALUES('{0}', '{1}', '{2}', '{3}', '{4}')", item.itemId, item.price, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), item.amount, item.enchantment)));
return(new HttpResponseMessage(HttpStatusCode.OK));
} catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError));
}
}
public async Task <GetListTransactionResponse> GetListTransactionAsync()
{
var response = new GetListTransactionResponse();
try
{
var listTransaction = await _context.Transactions.Take(20).OrderByDescending(t => t.TransDate).ToListAsync();
foreach (var transaction in listTransaction)
{
var acountItem = new ItemTransaction()
{
TransType = transaction.TransType,
Amount = transaction.Amount,
TransactionDate = transaction.TransDate,
Status = transaction.Status,
Fee = transaction.Fee
};
response.Data.ListTransaction.Add(acountItem);
}
}
catch (Exception ex)
{
response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key;
response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value;
Logger.Error(ex);
}
return(await Task.FromResult(response));
}
public Transaction CreateDefaultTransaction(ITransaction tx, Product product, Service service)
{
var transaction = new Transaction();
transaction.TransactionId = TransactionId;
transaction.Name = "TRS-0001";
var productTransaction = new ItemTransaction(transaction);
productTransaction.IndexNo = 0;
productTransaction.Item = product;
transaction.ItemTransactions.Add(productTransaction);
var productTransactionCharge = new ItemTransactionCharge(productTransaction);
productTransactionCharge.ChargeCode = "Product-Sell-Code";
productTransaction.ItemTransactionCharges.Add(productTransactionCharge);
var serviceTransaction = new ItemTransaction(transaction);
serviceTransaction.IndexNo = 1;
serviceTransaction.Item = service;
transaction.ItemTransactions.Add(serviceTransaction);
var serviceTransactionCharge = new ItemTransactionCharge(serviceTransaction);
serviceTransactionCharge.ChargeCode = "Service-Sell-Code";
serviceTransaction.ItemTransactionCharges.Add(serviceTransactionCharge);
transaction.Persist(tx);
return(transaction);
}
// Token: 0x0600001A RID: 26 RVA: 0x00002690 File Offset: 0x00000890
public bool SendThings(User user, Dictionary <List <Thing>, int> chosenThings)
{
if (!CheckCanStartTransaction(user))
{
return(false);
}
var list = new List <KeyValuePair <RealmThing, int> >();
foreach (var keyValuePair in chosenThings)
{
var key = realmData.ToRealmThing(keyValuePair.Key[0]);
list.Add(new KeyValuePair <RealmThing, int>(key, keyValuePair.Value));
}
var user2 = currentUser;
var num = user2.lastTransactionId + 1;
user2.lastTransactionId = num;
var itemTransaction = new ItemTransaction(num, currentUser, user, chosenThings, list);
realmData.transactions.Add(itemTransaction);
SendPacket(new StartTransactionPacket
{
transaction = itemTransaction
});
Messages.Message("Offer sent, waiting for confirmation", MessageTypeDefOf.SilentInput);
return(true);
}
public ActionResult StoreRequest(string[] counts, string[] items, string text, string to)
{
var order = new Order()
{
From = db.Employees.FirstOrDefault(i => i.Login == User.Identity.Name),
To = db.Employees.FirstOrDefault(i => i.Name == db.Employees.FirstOrDefault(j => j.Name == to).Name),
Text = text,
Date = DateTime.Now,
Status = db.Statuses.FirstOrDefault(i => i.Name == "Sent to the warehouse"),
// Employee = null
};
db.Orders.Add(order);
for (var i = 0; i < items.Length; i++)
{
var item = new ItemTransaction()
{
Name = items[i],
Count = int.Parse(counts[i]),
Order = order
};
db.ItemTransactions.Add(item);
}
db.SaveChanges();
ViewBag.Message = "Успешно добавлено!";
Writer.Write(order, User.Identity.Name, Server.MapPath("~/Files/"));
return(View(db));
}
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);
}
public ActionResult IssueReplenishments()
{
ItemTransaction itemTransaction = new ItemTransaction();
Item item = new Item();
int factoryId = Convert.ToInt32(Session["factoryId"].ToString());
foreach (var itemsForSale in AddedReplenishments.Where(f => f.FactoryId == factoryId))
{
var CompareItemFactory = db.Items.Where(i => i.ID == itemsForSale.ItemId).FirstOrDefault();
if (CompareItemFactory.FactoryId == itemsForSale.FactoryId)
{
itemTransaction.ItemID = itemsForSale.ItemId;
itemTransaction.Quantity = itemsForSale.Quantity;
itemTransaction.TransactionTypeId = 1;
itemTransaction.EffectiveDate = DateTime.Now;
db.ItemTransactions.Add(itemTransaction);
db.SaveChanges();
var changedRec = db.Items.Where(i => i.ID == itemsForSale.ItemId).FirstOrDefault();
changedRec.DaySellingQty = changedRec.DaySellingQty + itemsForSale.Quantity;
db.Entry(changedRec).State = EntityState.Modified;
db.SaveChanges();
}
}
AddedReplenishments.RemoveAll(f => f.FactoryId == factoryId);
return(RedirectToAction("Replenishments"));
}
public ActionResult DeleteConfirmed(int id)
{
ItemTransaction itemTransaction = db.ItemTransactions.Find(id);
db.ItemTransactions.Remove(itemTransaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <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>
/// Adiciona um detalhe (linha) à transação
/// </summary>
/// <param name="trans"></param>
/// <param name="itemId"></param>
/// <param name="qty"></param>
/// <param name="unitOfMeasureId"></param>
/// <param name="unitPrice"></param>
/// <param name="taxPercent"></param>
/// <param name="whareHouseId"></param>
private ItemTransactionDetail TransAddDetail(ItemTransaction trans, Item item, double qty, string unitOfMeasureId, double unitPrice, double taxPercent, short whareHouseId,
short colorId, short sizeId,
string serialNumberPropId, string serialNumberPropValue,
string lotId, string lotDescription, DateTime lotExpDate, short lotReturnWeek, short lotReturnYear, short lotEditionId)
{
var doc = MyApp.SystemSettings.WorkstationInfo.Document[trans.TransDocument];
ItemTransactionDetail transDetail = new ItemTransactionDetail();
transDetail.BaseCurrency = MyApp.SystemSettings.BaseCurrency;
transDetail.ItemID = item.ItemID;
transDetail.CreateDate = trans.CreateDate;
transDetail.CreateTime = trans.CreateTime;
transDetail.ActualDeliveryDate = trans.CreateDate;
//Utilizar a descrição do artigo, ou uma descrição personalizada
transDetail.Description = item.Description;
// definir a quantidade
transDetail.Quantity = qty;
// Preço unitário. NOTA: Ver a diferença se o documento for com impostos incluidos!
if (trans.TransactionTaxIncluded)
transDetail.TaxIncludedPrice = unitPrice;
else
transDetail.UnitPrice = unitPrice;
// Definir a lista de unidades
transDetail.UnitList = item.UnitList;
// Definir a unidade de venda/compra
transDetail.SetUnitOfSaleID(unitOfMeasureId);
//Definir os impostos
short TaxGroupId = MyApp.DSOCache.TaxesProvider.GetTaxableGroupIDFromTaxRate(taxPercent, MyApp.SystemSettings.SystemInfo.DefaultCountryID, MyApp.SystemSettings.SystemInfo.TaxRegionID);
transDetail.TaxableGroupID = TaxGroupId;
//*** Uncomment for discout
//transDetail.DiscountPercent = 10
//
// Se o Armazém não existir, utilizar o default que se encontra no documento.
if (MyApp.DSOCache.WarehouseProvider.WarehouseExists(whareHouseId))
transDetail.WarehouseID = whareHouseId;
else
transDetail.WarehouseID = doc.Defaults.Warehouse;
// Identificador da linha
transDetail.LineItemID = trans.Details.Count + 1;
//
//*** Uncomment to provide line totals
//.TotalGrossAmount = 'Line Gross amount
//.TotalNetAmount = 'Net Gross amount
//
//Definir o último preço de compra
if (doc.TransDocType == DocumentTypeEnum.dcTypePurchase)
{
transDetail.ItemExtraInfo.ItemLastCostTaxIncludedPrice = item.SalePrice[0].TaxIncludedPrice;
transDetail.ItemExtraInfo.ItemLastCostUnitPrice = item.SalePrice[0].UnitPrice;
}
item = null;
return transDetail;
}
/// <summary>
/// Assumes quantity already validated
/// </summary>
/// <param name="itemsToQuantity"></param>
public void AddNewTransaction(Dictionary <Item, int> itemsToQuantity)
{
var now = DateTime.Now;
//creating transaction
var newTransaction = new Transaction()
{
TimeOfTransaction = now
};
using (var dbContext = new InventoryContext())
{
dbContext.Transactions.Add(newTransaction);
dbContext.SaveChanges();
}
using (var dbContext = new InventoryContext())
{
foreach (KeyValuePair <Item, int> i_q in itemsToQuantity)
{
var newi_t = new ItemTransaction()
{
Item = dbContext.Items.Where(i => i.ItemID == i_q.Key.ItemID).First(),
Transaction = dbContext.Transactions
.Where(t => t.TransactionID == newTransaction.TransactionID)
.First(),
Quantity = i_q.Value
};
dbContext.ItemTransactions.Add(newi_t);
}
dbContext.SaveChanges();
}
//setting totalValue
decimal totalValue = 0m;
foreach (KeyValuePair <Item, int> i_q in itemsToQuantity)
{
//totalValue += item.RRP * itemTransaction.Quantity
totalValue += i_q.Key.RRP * i_q.Value;
}
//setting new total value
using (var dbContext = new InventoryContext())
{
var targetTransaction = dbContext.Transactions
.Where(t => t.TransactionID == newTransaction.TransactionID)
.First();
targetTransaction.TotalValue = totalValue;
dbContext.SaveChanges();
}
//Reduce QuantityStockLevel of items by itemsToQuantity.value
ReduceItemQuantity(itemsToQuantity);
}
/// <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));
}
/// <summary>
/// Needs dictionary that
/// Maps Item to its quntity needed
/// </summary>
/// <param name="itemToQuantity"></param>
/// <returns></returns>
public static Transaction CreateNewTransaction(Dictionary <Item, int> itemToQuantity)
{
using (var dbContext = new InventoryContext())
{
//converting items to item obj from dbContext
//otherwise it will create new item in db
Dictionary <Item, int> fixedItemToQuantity = new Dictionary <Item, int>();
IQueryable <Item> allItemsFromDB = from item in dbContext.Items
select item;
foreach (KeyValuePair <Item, int> itemQuantity in itemToQuantity)
{
//searches all items (from above)
//matches the current keyvaluepairs item(key) to one from all items
//then add this to fixedItemToQuantity with quanity from itemToQuantity
Item itemFromDB = (from item in allItemsFromDB
where item.ItemID == itemQuantity.Key.ItemID
select item).First();
fixedItemToQuantity.Add(itemFromDB, itemQuantity.Value);
}
//sets current dataTime as transactions TimeOfTransaction
var newTransaction = new Transaction()
{
TimeOfTransaction = DateTime.Now
};
decimal itemTotValue = 0;
//create many instances of itemTransaction and adds to db
foreach (KeyValuePair <Item, int> itemQuantity in fixedItemToQuantity)
{
//remove this item from stock
//add new I_T to ItemTransaction(tbl) and to the new transaction obj
ItemTransaction tempItemTransaction = new ItemTransaction
{
Transaction = newTransaction,
Item = itemQuantity.Key,
Quantity = itemQuantity.Value
};
dbContext.ItemTransactions.Add(tempItemTransaction);
//adding value of each Item * Quantity of item
itemTotValue += (itemQuantity.Key.RRP * itemQuantity.Value);
}
newTransaction.TotalValue = itemTotValue;
dbContext.SaveChanges();
return(newTransaction);
}
}
public ActionResult Edit([Bind(Include = "ID,ItemID,Quantity,TransactionTypeId,EffectiveDate")] ItemTransaction itemTransaction)
{
if (ModelState.IsValid)
{
db.Entry(itemTransaction).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ItemID = new SelectList(db.Items, "ID", "ItemName", itemTransaction.ItemID);
ViewBag.TransactionTypeId = new SelectList(db.TransactionTypes, "ID", "TransactionType1", itemTransaction.TransactionTypeId);
return(View(itemTransaction));
}
protected void btnUpdateBalance_Click(object sender, EventArgs e)
{
try
{
int hfId = CurrentEnvironment.LoggedUser.HealthFacilityId;
string _hfId = (string)Request.QueryString["hfId"];
if (!String.IsNullOrEmpty(_hfId))
{
int.TryParse(_hfId, out hfId);
}
foreach (GridViewRow gr in gvHealthFacilityBalance.Rows)
{
if (gr.RowType == DataControlRowType.DataRow)
{
TextBox txtQty = (TextBox)gr.FindControl("txtQty");
if (!string.IsNullOrEmpty(txtQty.Text))
{
UInt32 qty = UInt32.Parse(txtQty.Text.Trim());
string gtin = gr.Cells[1].Text;
string lotno = gr.Cells[3].Text;
DateTime date = DateTime.ParseExact(txtDate.Text, ConfigurationDate.GetConfigurationDateById(int.Parse(Configuration.GetConfigurationByName("DateFormat").Value)).DateFormat.ToString(), CultureInfo.CurrentCulture);
HealthFacility hf = HealthFacility.GetHealthFacilityById(hfId);
StockManagementLogic sml = new StockManagementLogic();
ItemTransaction st = sml.StockCount(hf, gtin, lotno, qty, CurrentEnvironment.LoggedUser.Id, date);
int i = st.Id;
if (i > 0)
{
lblSuccess.Visible = true;
lblError.Visible = false;
}
else
{
lblSuccess.Visible = false;
lblError.Visible = true;
}
}
}
}
odsHealthFacilityBalance.SelectParameters.Clear();
odsHealthFacilityBalance.SelectParameters.Add("id", hfId.ToString());
odsHealthFacilityBalance.DataBind();
}
catch (Exception ex)
{
lblSuccess.Visible = false;
lblError.Visible = true;
}
}
// GET: Common/Item/Delete/5
public ActionResult Delete(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Item item = new ItemTransaction().GetById(id);
if (item == null)
{
return HttpNotFound();
}
return View(item);
}
/// <summary>
/// Updates Vaccination Event with given id <paramref name="id"/> with all the other parameters.
/// </summary>
/// <param name="id">The id of the vaccination event that is being updated </param>
/// <param name="lotId">The vaccine lot used for this vaccination event</param>
/// <param name="vaccinationdate">The vaccination date for this vaccination event</param>
/// <param name="hfId">The health facility where this vaccination event happened</param>
/// <param name="done">Status of the vaccination event</param>
/// <param name="nonvaccreasonId">The reason for not vaccinating for this vaccination event</param>
/// <returns></returns>
public VaccinationEvent UpdateVaccinationEvent(int id, int lotId, DateTime vaccinationdate, int hfId, bool done, int nonvaccreasonId, int userId, DateTime modifiedOn)
{
if (id <= 0)
{
throw new ArgumentException("id");
}
if (hfId <= 0)
{
throw new ArgumentException("hfId");
}
if (userId <= 0)
{
throw new ArgumentException("userId");
}
VaccinationEvent o = VaccinationEvent.GetVaccinationEventById(id);
o.VaccineLotId = lotId;
o.VaccinationDate = vaccinationdate;
o.HealthFacilityId = hfId;
o.VaccinationStatus = done;
if (done)
{
o.NonvaccinationReasonId = 0;
}
else
{
o.NonvaccinationReasonId = nonvaccreasonId;
o.VaccineLotId = 0;
}
o.ModifiedOn = modifiedOn;
o.ModifiedBy = userId;
int i = VaccinationEvent.Update(o);
if (i > 0)
{
if (done || o.NonVaccinationReason.KeepChildDue == false)
{
RescheduleNextDose(o, false);
}
if (o.VaccineLotId > 0)
{
StockManagementLogic sml = new StockManagementLogic();
ItemTransaction it = sml.Vaccinate(o.HealthFacility, o);
}
}
return(o);
}
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);
}
// GET: ItemTransactions/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ItemTransaction itemTransaction = db.ItemTransactions.Find(id);
if (itemTransaction == null)
{
return(HttpNotFound());
}
return(View(itemTransaction));
}
// GET: ItemTransactions/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ItemTransaction itemTransaction = db.ItemTransactions.Find(id);
if (itemTransaction == null)
{
return(HttpNotFound());
}
ViewBag.ItemID = new SelectList(db.Items, "ID", "ItemName", itemTransaction.ItemID);
ViewBag.TransactionTypeId = new SelectList(db.TransactionTypes, "ID", "TransactionType1", itemTransaction.TransactionTypeId);
return(View(itemTransaction));
}
public static void updateItemTransReceived(InventorySysDBEntities cntx, string deptID, DisbursementDetail d)
{
var q = from x in cntx.ItemTransactions where x.Item_ID == d.Item_ID select x;
var p = from x in cntx.Items where x.Item_ID == d.Item_ID select x;
List <ItemTransaction> ItList = q.ToList();
ItemTransaction it = new ItemTransaction();
Item i = p.First();
it.Item_ID = d.Item_ID;
it.Quantity = 0 - d.Quantity;
it.Balance = ItList.Last().Balance - d.Quantity;
it.Reason = "Sent to " + deptID;
it.Update_Date = DateTime.Now;
cntx.ItemTransactions.Add(it);
i.Inventory = ItList.Last().Balance - d.Quantity;
cntx.SaveChanges();
}
protected void btnAdd_Click(object sender, EventArgs e)
{
try
{
if (Page.IsValid)
{
int userId = CurrentEnvironment.LoggedUser.Id;
//check for duplicates
// ItemTransaction st = StockManagementLogic.StockCount(CurrentEnvironment.LoggedUser.HealthFacility.Code, ddlGtin.SelectedValue, ddlItemLot.SelectedValue, txtQuantity.Text, CurrentEnvironment.LoggedUser.Id);
StockManagementLogic sml = new StockManagementLogic();
UInt32 qty = UInt32.Parse(txtQuantity.Text);
DateTime date = DateTime.ParseExact(txtStockCountDate.Text, ConfigurationDate.GetConfigurationDateById(int.Parse(Configuration.GetConfigurationByName("DateFormat").Value)).DateFormat.ToString(), CultureInfo.CurrentCulture);
ItemTransaction st = sml.StockCount(CurrentEnvironment.LoggedUser.HealthFacility, ddlGtin.SelectedValue, ddlItemLot.SelectedValue, qty, CurrentEnvironment.LoggedUser.Id, date);
int i = st.Id; // ItemTransaction.Insert(o);
if (i > 0)
{
lblSuccess.Visible = true;
lblWarning.Visible = false;
lblError.Visible = false;
odsTransactionLines.SelectParameters.Clear();
odsTransactionLines.SelectParameters.Add("i", i.ToString());
odsTransactionLines.DataBind();
ClearControls(this);
}
else
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
}
catch (Exception ex)
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
private void CreateTransaction(Company company)
{
var transType = (ItemTransaction.TransactionType)TransactionType.SelectedIndex;
NewTransaction = new ItemTransaction
{
Company = company,
Price = Price,
ItemTransactionType = transType,
TransactionDate = TransactionDate.DisplayDate,
Quantity = Quantity
};
if (transType == ItemTransaction.TransactionType.Buy)
{
company.IsSourceCompany = true;
company.Items.Add(_item);
}
}
public RedirectToRouteResult Reject(string requestid, string itemcode)
{
StockAdjustmentDetail stockadjdet = repo.GetStockAdjustmentDetailById(requestid, itemcode);
using (IItemTransactionRepository itemRepo = new ItemTransactionRepositoryImpl(new SSISdbEntities()))
{
ItemTransaction itemTrans = new ItemTransaction
{
DocumentRefNo = requestid,
TransDateTime = DateTime.Now,
ItemCode = itemcode,
TransactionType = "Reject Stock Adjustment",
Quantity = stockadjdet.ItemQuantity,
Amount = stockadjdet.Amount,
UnitCost = stockadjdet.Amount / stockadjdet.ItemQuantity
};
itemRepo.InsertItemTransaction(itemTrans);
itemRepo.Save();
}
stockadjdet.Status = "Rejected";
stockadjdet.NotificationStatus = "Unread";
repo.UpdateStockAdjustmentDetail(stockadjdet);
repo.Save();
using (SSISdbEntities m = new SSISdbEntities())
{
StockAdjustmentHeader sjh = m.StockAdjustmentHeaders.Where(x => x.RequestId == requestid).FirstOrDefault();
Employee emp = m.Employees.Where(x => x.EmployeeID == sjh.Requestor).FirstOrDefault();
// Send to Employee
string title = "[LogicUniversity] Stock Adjustment Rejected: " + requestid;
string message = "Item Code: " + itemcode + " has been rejected.";
// Send to Employee
CommonLogic.Email.sendEmail("*****@*****.**", emp.EmployeeEmail, title, message);
}
Session["StoreInventoryTabIndex"] = "1";
Session["StockAdjPage"] = 2;
return(RedirectToAction("Inventory", "Store", new { area = "" }));
}
private void WastageTransaction(ItemTransaction o, int diff)
{
ItemTransaction it = new ItemTransaction();
it.TransactionDate = o.TransactionDate;
it.Gtin = o.Gtin;
it.GtinLot = o.GtinLot;
it.HealthFacilityCode = o.HealthFacilityCode;
it.TransactionTypeId = 4; //Adjustment
it.RefId = o.Id.ToString();
it.TransactionQtyInBaseUom = diff;
it.Notes = o.Notes;
it.ModifiedOn = DateTime.Now;
it.ModifiedBy = CurrentEnvironment.LoggedUser.Id;
it.AdjustmentId = 99; //From stock count - open vial wastage
int i = ItemTransaction.Insert(it);
//do we need to update used column?
}
public bool ReceivePurchaseOrder(string orderid, List <int> recNumberList, string remark, string recStaff)
{
try
{
var q = from x in context.OrderLists where x.Order_ID == orderid select x;
OrderList ol = q.First();
var p = from x in context.OrderListDetails where x.Order_ID == orderid select x;
List <OrderListDetail> old = p.ToList();
for (int i = 0; i < old.Count; i++)
{
string ItemID = old[i].Item_ID;
old[i].Received_Qty = recNumberList[i];
ItemTransaction it = new ItemTransaction();
it.Item_ID = old[i].Item_ID;
it.Update_Date = DateTime.Now;
it.Reason = "Received from " + ol.Supplier_ID;
it.Quantity = recNumberList[i];
var r = from x in context.ItemTransactions where x.Item_ID == ItemID select x;
List <ItemTransaction> itList = r.ToList();
it.Balance = itList.Last().Balance;
it.Balance = it.Balance + recNumberList[i];
var o = from x in context.Items where x.Item_ID == ItemID select x;
o.First().Inventory = it.Balance;
context.ItemTransactions.Add(it);
}
ol.Status = "Received";
if (remark != null)
{
ol.Remark = remark;
}
ol.Finish_Date = DateTime.Now;
ol.RecStaff_ID = recStaff;
context.SaveChanges();
return(true);
}
catch (Exception e)
{
return(false);
}
}
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);
}
private void TransAddDetail(ItemTransaction trans, Item item, double qty, string unitOfMeasureId, double unitPrice, double taxPercent, short whareHouseId)
{
ItemTransactionDetail transDetail = new ItemTransactionDetail();
transDetail.BaseCurrency = systemSettings.BaseCurrency;
transDetail.ItemID = item.ItemID;
transDetail.CreateDate = trans.CreateDate;
transDetail.CreateTime = trans.CreateTime;
transDetail.ActualDeliveryDate = trans.CreateDate;
//Utilizar a descrição do artigo, ou uma descrição personalizada
transDetail.Description = item.Description;
// definir a quantidade
transDetail.Quantity = qty;
// Preço unitário. NOTA: Ver a diferença se o documento for com impostos incluidos!
if (trans.TransactionTaxIncluded)
{
transDetail.TaxIncludedPrice = unitPrice;
}
else
{
transDetail.UnitPrice = unitPrice;
}
// Definir a lista de unidades
transDetail.UnitList = item.UnitList;
// Definir a unidade de venda/compra
transDetail.SetUnitOfSaleID(unitOfMeasureId);
//Definir os impostos
short TaxGroupId = dsoCache.TaxesProvider.GetTaxableGroupIDFromTaxRate(taxPercent, systemSettings.SystemInfo.DefaultCountryID, systemSettings.SystemInfo.TaxRegionID);
transDetail.TaxableGroupID = TaxGroupId;
//armazém
transDetail.WarehouseID = whareHouseId;
// Identificador da linha
transDetail.LineItemID = trans.Details.Count + 1;
item = null;
trans.Details.Add(transDetail);
}
public ActionResult StockTakeUpdate(StockTakeList[] arr, string[] arr1)
{
try
{
int count = 0;
string transType = "Stock Take";
List <StockTakeList> list = new List <StockTakeList>();
for (int i = 0; i < arr.Length; i++)
{
list.Add(arr[i]);
}
using (SSISdbEntities m = new SSISdbEntities())
{
int itemTransCount = m.StockTakeHeaders.Count() + 1;
string itemTransactionId = CommonLogic.SerialNo(itemTransCount, "ST");
// Update StockTakeHeader Table
StockTakeHeader stockTakeHeader = new StockTakeHeader();
stockTakeHeader.StockTakeID = itemTransactionId;
stockTakeHeader.Date = DateTime.Now;
stockTakeHeader.TransactionType = transType;
m.StockTakeHeaders.Add(stockTakeHeader);
m.SaveChanges();
foreach (StockTakeList l in list)
{
Item item = m.Items.Where(x => x.ItemCode == l.ItemCode).FirstOrDefault();
int itemQty = Convert.ToInt32(arr1[count]);
float avgCost = item.AvgUnitCost;
int qtyOnHand = item.Quantity;
int qtyAdjusted = itemQty - qtyOnHand;
float totalAmt = avgCost * (float)qtyAdjusted;
string itemcode = l.ItemCode;
if (qtyAdjusted != 0)
{
// Update Item Table
item.Quantity = itemQty;
// Update ItemTransaction Table
ItemTransaction itemTransaction = new ItemTransaction();
itemTransaction.TransDateTime = DateTime.Now;
itemTransaction.DocumentRefNo = itemTransactionId;
itemTransaction.ItemCode = itemcode;
itemTransaction.TransactionType = transType;
itemTransaction.Quantity = qtyAdjusted;
itemTransaction.UnitCost = avgCost;
itemTransaction.Amount = totalAmt;
m.ItemTransactions.Add(itemTransaction);
m.SaveChanges();
}
// Update StockTakeDetails Table
StockTakeDetail stockTakeDetail = new StockTakeDetail();
stockTakeDetail.StockTakeID = itemTransactionId;
stockTakeDetail.ItemCode = itemcode;
stockTakeDetail.QuantityOnHand = qtyOnHand;
stockTakeDetail.QuantityCounted = itemQty;
stockTakeDetail.QuantityAdjusted = qtyAdjusted;
m.StockTakeDetails.Add(stockTakeDetail);
m.SaveChanges();
count++;
}
}
}
catch (FormatException fe)
{
Debug.WriteLine(fe.Message);
}catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(View());
}