private void AuditLog(smART.ViewModel.Scale businessEntity, smART.Model.smARTDBContext dbContext)
{
try
{
smART.Model.AuditLog newModObject = new Model.AuditLog()
{
Entity_Name = "Scale",
Entity_ID = businessEntity.ID,
Field_Name = "Scale_Reading",
Old_Value = businessEntity.Scale_Reading.ToString(),
New_Value = businessEntity.Scale_Reading.ToString(),
Active_Ind = true,
Created_By = businessEntity.Updated_By,
Updated_By = businessEntity.Updated_By,
Created_Date = businessEntity.Last_Updated_Date,
Last_Updated_Date = businessEntity.Last_Updated_Date
};
dbContext.T_Audit_Log.Add(newModObject);
dbContext.SaveChanges();
}
catch (Exception ex)
{
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, businessEntity.Updated_By, businessEntity.GetType().Name, businessEntity.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
public void UpdateScaleDetailNetWeight(smART.Model.Scale modelScale, smART.Model.smARTDBContext dbContext)
{
try
{
IEnumerable <smART.Model.ScaleDetails> scaleDetails = from scaledetail in dbContext.T_Scale_Details
where scaledetail.Scale.ID == modelScale.ID
select scaledetail;
if (scaleDetails != null)
{
foreach (var modelEntity in scaleDetails)
{
modelEntity.GrossWeight = modelScale.Gross_Weight * (modelEntity.Split_Value / 100);
modelEntity.TareWeight = modelScale.Tare_Weight * (modelEntity.Split_Value / 100);
modelEntity.NetWeight = modelEntity.GrossWeight - modelEntity.TareWeight - modelEntity.Contamination_Weight + modelEntity.Settlement_Diff_NetWeight;
}
dbContext.SaveChanges();
}
}
catch (Exception ex)
{
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, modelScale.Updated_By, modelScale.GetType().Name, modelScale.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
public void AddNewLocation(smART.Model.AssetAudit assetAudit, smART.Model.smARTDBContext dbContext)
{
smART.Model.AssetAudit modelAssetAudit = dbContext.T_Asset_Audit.Where(o => o.Asset.ID == assetAudit.Asset.ID && o.Party.ID == assetAudit.Party.ID && o.Location.ID == assetAudit.Location.ID && o.Dispatcher_Request.ID == assetAudit.Dispatcher_Request.ID && o.Asset_Current_Location_Flg == true).FirstOrDefault();
if (modelAssetAudit == null)
{
UpdatePreviousLocation(assetAudit, dbContext);
dbContext.T_Asset_Audit.Add(assetAudit);
dbContext.SaveChanges();
}
}
/// <summary>
/// Update Asset_Current_Location_Flg to false for all previous location records.
/// </summary>
/// <param name="businessEntity"></param>
/// <param name="dbContext"></param>
public void UpdatePreviousLocation(smART.Model.AssetAudit modelEntity, smART.Model.smARTDBContext dbContext)
{
try {
IEnumerable <Model.AssetAudit> results = dbContext.T_Asset_Audit.Where(o => o.Asset.ID == modelEntity.Asset.ID && o.Asset.Asset_Type == "Bin");
if (results != null && results.Count() > 0)
{
foreach (var item in results)
{
item.Asset_Current_Location_Flg = false;
}
dbContext.SaveChanges();
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, modelEntity.Updated_By, modelEntity.GetType().Name, "0");
if (rethrow)
{
throw ex;
}
}
}
public void Inventory(smART.Model.Scale modelScale, smART.Model.smARTDBContext dbContext)
{
try
{
IQueryable <smART.Model.ScaleDetails> scaleDetails = dbContext.Set <smART.Model.ScaleDetails>().AsQueryable().Where(o => o.Scale.ID == modelScale.ID);
if (scaleDetails != null)
{
scaleDetails = scaleDetails.Include("Apply_To_Item");
foreach (var modelEntity in scaleDetails)
{
modelEntity.Old_Net_Weight = modelEntity.NetWeight;
modelEntity.GrossWeight = modelScale.Gross_Weight * (modelEntity.Split_Value / 100);
modelEntity.TareWeight = modelScale.Tare_Weight * (modelEntity.Split_Value / 100);
modelEntity.NetWeight = modelEntity.GrossWeight - modelEntity.TareWeight - modelEntity.Contamination_Weight + modelEntity.Settlement_Diff_NetWeight;
if (modelEntity.Scale != null && modelEntity.Scale.Ticket_Status.ToLower().Equals("close") && modelEntity.Apply_To_Item != null)
{
AddInventory(modelEntity, dbContext);
}
}
dbContext.SaveChanges();
}
}
catch (Exception ex)
{
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, modelScale.Updated_By, modelScale.GetType().Name, modelScale.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
internal virtual void DeleteInventory(smART.Model.ScaleDetails modelScaleDetails, smART.Model.smARTDBContext dbContext)
{
try {
//If status is close then add inventory record
if (modelScaleDetails.Scale != null && modelScaleDetails.Scale.Ticket_Status.ToLower().Equals("close") && modelScaleDetails.Apply_To_Item != null)
{
//Get all scale inventory item by ticket id & item id
IQueryable <smART.Model.Inventory> inventories = dbContext.Set <smART.Model.Inventory>().AsQueryable().Where(i => i.Scale_Ticket_ID.ID == modelScaleDetails.Scale.ID &&
i.Item_ID.ID == modelScaleDetails.Apply_To_Item.ID &&
i.Trans_Type == "Scale ticket" &&
i.Active_Ind == true);
//Get current balance from Item Master
smART.Model.Item item = dbContext.M_Item.FirstOrDefault(i => i.ID == modelScaleDetails.Apply_To_Item.ID);
if (item != null && inventories != null && inventories.Count() > 0)
{
foreach (var inventory in inventories)
{
// Update Invetory Active_Ind to false.
inventory.Updated_By = modelScaleDetails.Updated_By;
inventory.Last_Updated_Date = modelScaleDetails.Last_Updated_Date;
inventory.Active_Ind = false;
dbContext.Entry <smART.Model.Inventory>(inventory);
}
decimal itemCurrentBalance = item.Current_Balance;
decimal scaleItemCurrentBalance = modelScaleDetails.NetWeight;
if (modelScaleDetails.Scale.Ticket_Type.ToLower().Equals("receiving ticket"))
{
itemCurrentBalance -= scaleItemCurrentBalance;
}
else
{
itemCurrentBalance += scaleItemCurrentBalance;
}
//Update Item current balance in Item Master
item.Current_Balance = itemCurrentBalance;
item.Last_Updated_Date = DateTime.Now;
item.Updated_By = modelScaleDetails.Updated_By;
dbContext.Entry <smART.Model.Item>(item);
dbContext.SaveChanges();
}
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, modelScaleDetails.Updated_By, modelScaleDetails.GetType().Name, modelScaleDetails.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
private void UpdateDefault(smART.ViewModel.PriceList businessEntity, smART.Model.PriceList modelEntity, smART.Model.smARTDBContext dbContext)
{
if (businessEntity.IsDefault == true)
{
smART.Model.PriceList price = dbContext.T_PriceList.FirstOrDefault(i => i.IsDefault == true);
if (price != null)
{
price.IsDefault = false;
price.Last_Updated_Date = modelEntity.Last_Updated_Date;
dbContext.SaveChanges();
}
}
}
private void UpdateBalance(smART.ViewModel.Cash businessEntity, smART.Model.Cash modelEntity, smART.Model.smARTDBContext dbContext)
{
if (businessEntity.Transaction_Type.Equals("add cash", StringComparison.InvariantCultureIgnoreCase))
{
modelEntity.Amount_Received = businessEntity.Amount;
}
if (businessEntity.Transaction_Type.Equals("payment", StringComparison.InvariantCultureIgnoreCase))
{
modelEntity.Amount_Paid = businessEntity.Amount;
}
if (businessEntity.Transaction_Type.Equals("update balance", StringComparison.InvariantCultureIgnoreCase))
{
modelEntity.Balance = businessEntity.Amount;
}
if (!businessEntity.Transaction_Type.Equals("update balance", StringComparison.InvariantCultureIgnoreCase))
{
Model.Cash prevEntity = dbContext.Set <smART.Model.Cash>().AsQueryable().OrderByDescending(s => s.Created_Date).FirstOrDefault();
modelEntity.Balance = (prevEntity == null ? 0 : prevEntity.Balance) + modelEntity.Amount_Received - modelEntity.Amount_Paid;
}
}
public void Modifying(smART.ViewModel.Cash businessEntity, smART.Model.Cash modelEntity, smART.Model.smARTDBContext dbContext, out bool cancel)
{
UpdateBalance(businessEntity, modelEntity, dbContext);
cancel = false;
}
public void Added(smART.ViewModel.Settlement businessEntity, smART.Model.Settlement modelEntity, smART.Model.smARTDBContext dbContext)
{
UpdateScale(businessEntity, modelEntity, dbContext);
}
public void Deleted(smART.ViewModel.Settlement businessEntity, smART.Model.Settlement modelEntity, smART.Model.smARTDBContext dbContext)
{
DeleteSettlementScale(businessEntity, modelEntity, dbContext);
}
public void UpdateAssetAuditLog(smART.ViewModel.DispatcherRequest businessEntity, smART.Model.DispatcherRequest modelEntity, smART.Model.smARTDBContext dbContext)
{
if (businessEntity.RequestCategory.ToLower().Equals("bin") && businessEntity.RequestStatus.ToLower() == "close")
{
smART.Model.AssetAudit modelAssetAudit = new Model.AssetAudit();
modelAssetAudit.Dispatcher_Request = dbContext.T_Dispatcher.First(o => o.ID == modelEntity.ID);
modelAssetAudit.Asset_Current_Location_Flg = true;
modelAssetAudit.Asset = modelEntity.Asset;
modelAssetAudit.Active_Ind = true;
modelAssetAudit.Created_By = modelEntity.Updated_By;
modelAssetAudit.Updated_By = modelEntity.Updated_By;
modelAssetAudit.Created_Date = modelEntity.Last_Updated_Date;
modelAssetAudit.Last_Updated_Date = modelEntity.Last_Updated_Date;
modelAssetAudit.Date = modelEntity.Time;
if (businessEntity.RequestType.ToLower() == "drop off only")
{
modelAssetAudit.Party = dbContext.M_Party.FirstOrDefault(o => o.ID == modelEntity.Party.ID);
modelAssetAudit.Location = dbContext.M_Address.FirstOrDefault(o => o.ID == modelEntity.Location.ID);
new smART.Business.Rules.AssetAudit().AddNewLocation(modelAssetAudit, dbContext);
}
else if (businessEntity.RequestType.ToLower() == "pickup only")
{
Model.Party modelParty = dbContext.M_Party.Where(o => o.Party_Type.ToLower() == "organization").FirstOrDefault();
Model.AddressBook modelAddress = dbContext.M_Address.Where(o => o.Party.ID == modelParty.ID && o.Primary_Flag == true).FirstOrDefault();
modelAssetAudit.Party = modelParty;
modelAssetAudit.Location = modelAddress;
new smART.Business.Rules.AssetAudit().AddNewLocation(modelAssetAudit, dbContext);
}
}
}
public void GotSingle(smART.ViewModel.Scale businessEntity, smART.Model.Scale modelEntity, smART.Model.smARTDBContext dbContext)
{
if (businessEntity != null)
{
if (businessEntity.Ticket_Type.Equals("Brokerage", StringComparison.InvariantCultureIgnoreCase))
{
businessEntity.Brokerage_Party = businessEntity.Party_ID;
businessEntity.Brokerage_Purchase_Order = businessEntity.Purchase_Order;
}
if (businessEntity.QScale)
{
IEnumerable <smART.Model.ScaleDetails> details = dbContext.T_Scale_Details.Where(s => s.Scale.ID == businessEntity.ID);
if (details != null)
{
businessEntity.Item_Amount = details.Sum(s => s.NetWeight * s.Rate);
}
}
}
}
public void Modified(smART.ViewModel.Scale businessEntity, smART.Model.Scale modelEntity, smART.Model.smARTDBContext dbContext)
{
UpdateContainer(businessEntity, modelEntity, dbContext);
if (!businessEntity.QScale)
{
UpdateScaleDetailNetWeight(modelEntity, dbContext);
}
//Inventory(modelEntity, dbContext);
//AuditLog(businessEntity, dbContext);
//dbContext.SaveChanges();
}
public void Added(smART.ViewModel.Scale businessEntity, smART.Model.Scale modelEntity, smART.Model.smARTDBContext dbContext)
{
UpdateContainer(businessEntity, modelEntity, dbContext);
//AuditLog(businessEntity, dbContext);
//dbContext.SaveChanges();
}
public void Deleted(smART.ViewModel.SettlementDetails businessEntity, smART.Model.SettlementDetails modelEntity, smART.Model.smARTDBContext dbContext)
{
DeleteScaleDetails(businessEntity, modelEntity, dbContext);
}
public void DeleteScaleDetails(smART.ViewModel.SettlementDetails businessEntity, smART.Model.SettlementDetails modelEntity, smART.Model.smARTDBContext dbContext)
{
try {
smART.Model.ScaleDetails scaleDetails = dbContext.T_Scale_Details.FirstOrDefault(i => i.ID == modelEntity.Scale_Details_ID.ID);
if (scaleDetails != null)
{
if (scaleDetails.Settlement_Diff_NetWeight != 0)
{
AddInventory(scaleDetails, dbContext);
}
scaleDetails.NetWeight = scaleDetails.NetWeight - scaleDetails.Settlement_Diff_NetWeight;
scaleDetails.Updated_By = modelEntity.Updated_By;
scaleDetails.Last_Updated_Date = modelEntity.Last_Updated_Date;
scaleDetails.Settlement_Diff_NetWeight = 0;
dbContext.SaveChanges();
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, businessEntity.Updated_By, businessEntity.GetType().Name, businessEntity.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
public void Modifying(smART.ViewModel.DispatcherRequest businessEntity, smART.Model.DispatcherRequest modelEntity, smART.Model.smARTDBContext dbContext, out bool cancel)
{
UpdateContainer(businessEntity, modelEntity, dbContext);
cancel = false;
}
public void UpdateScale(smART.ViewModel.Settlement businessEntity, smART.Model.Settlement modelEntity, smART.Model.smARTDBContext dbContext)
{
try {
smART.Model.Scale scale = dbContext.T_Scale.FirstOrDefault(i => i.ID == modelEntity.Scale.ID);
if (scale != null)
{
scale.Updated_By = modelEntity.Updated_By;
scale.Last_Updated_Date = modelEntity.Last_Updated_Date;
scale.Ticket_Settled = true;
scale.Settlement_Diff_NetWeight = businessEntity.Actual_Net_Weight - scale.Net_Weight;
scale.Net_Weight = businessEntity.Actual_Net_Weight;
dbContext.SaveChanges();
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, businessEntity.Updated_By, businessEntity.GetType().Name, businessEntity.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
public void GotSingle(smART.ViewModel.DispatcherRequest businessEntity, smART.Model.DispatcherRequest modelEntity, smART.Model.smARTDBContext dbContext)
{
if (businessEntity.Booking_Ref_No != null)
{
businessEntity.Sales_Order_No = businessEntity.Booking_Ref_No.Sales_Order_No;
businessEntity.Shipper = businessEntity.Booking_Ref_No.Shipping_Company;
businessEntity.Container_No = businessEntity.Container != null ? businessEntity.Container.Container_No : businessEntity.Container_No;
}
}
public static double Convert(string UnitFrom, string UnitTo, double UnitValue, smART.Model.smARTDBContext dbContext)
{
if (UnitFrom.Equals(UnitTo, StringComparison.OrdinalIgnoreCase))
{
return(UnitValue);
}
smART.Model.UOMConversion uomConversion = dbContext.M_UOM_Conversion.Where(o => o.Conversion_UOM.Equals(UnitFrom, StringComparison.OrdinalIgnoreCase) &&
o.Base_UOM.Equals(UnitFrom, StringComparison.OrdinalIgnoreCase) &&
o.Is_Base_UOM == true
).SingleOrDefault();
double factor = uomConversion.Factor;
return(UnitValue * factor);
}
public void UpdateContainer(smART.ViewModel.DispatcherRequest businessEntity, smART.Model.DispatcherRequest modelEntity, smART.Model.smARTDBContext dbContext)
{
try {
if (modelEntity.RequestCategory.ToLower() == "container" && !string.IsNullOrEmpty(businessEntity.Container_No))
{
Model.Booking modBooking = dbContext.T_Booking_Ref.FirstOrDefault(o => o.ID.Equals(modelEntity.Booking_Ref_No.ID));
if (modBooking != null)
{
Model.Container modContainer = dbContext.T_Container_Ref.Include("Booking").FirstOrDefault(o => o.Container_No == businessEntity.Container_No && o.Active_Ind == true);
if (modContainer == null)
{
smART.Model.Container modNewcontainer = new smART.Model.Container();
modNewcontainer.Booking = modBooking;
modNewcontainer.Container_No = businessEntity.Container_No;
modNewcontainer.Created_Date = modelEntity.Time;
modNewcontainer.Last_Updated_Date = modelEntity.Time;
modNewcontainer.Created_By = modelEntity.Created_By;
modNewcontainer.Updated_By = modelEntity.Updated_By;
modNewcontainer.Date_In = DateTime.Now;
modNewcontainer.Status = GetContainerStatus(modBooking, modelEntity, dbContext);
modNewcontainer.Active_Ind = true;
Model.Container insertedObject = dbContext.T_Container_Ref.Add(modNewcontainer);
modContainer = insertedObject;
dbContext.SaveChanges();
modelEntity.Container = modContainer;
}
else
{
modContainer.Last_Updated_Date = DateTime.Now;
modContainer.Updated_By = modelEntity.Updated_By;
modelEntity.Container = modContainer;
modelEntity.Booking_Ref_No = dbContext.T_Booking_Ref.FirstOrDefault(o => o.ID == modContainer.Booking.ID);
modContainer.Status = GetContainerStatus(modelEntity.Booking_Ref_No, modelEntity, dbContext);
dbContext.SaveChanges();
}
}
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, businessEntity.Updated_By, businessEntity.GetType().Name, businessEntity.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
public void GotSingle(smART.ViewModel.Cash businessEntity, smART.Model.Cash modelEntity, smART.Model.smARTDBContext dbContext)
{
if (businessEntity.Transaction_Type.Equals("add cash", StringComparison.InvariantCultureIgnoreCase))
{
businessEntity.Amount = modelEntity.Amount_Received;
}
else if (businessEntity.Transaction_Type.Equals("update balance", StringComparison.InvariantCultureIgnoreCase))
{
businessEntity.Amount = modelEntity.Balance;
}
else if (businessEntity.Transaction_Type.Equals("payment", StringComparison.InvariantCultureIgnoreCase))
{
businessEntity.Amount = modelEntity.Amount_Paid;
}
}
public void Added(smART.ViewModel.DispatcherRequest businessEntity, smART.Model.DispatcherRequest modelEntity, smART.Model.smARTDBContext dbContext)
{
//UpdateContainer(businessEntity, modelEntity, dbContext);
UpdateAssetAuditLog(businessEntity, modelEntity, dbContext);
}
public void Adding(smART.ViewModel.SalesOrder businessEntity, smART.Model.SalesOrder modelEntity, smART.Model.smARTDBContext dbContext, out bool cancel)
{
if (string.IsNullOrWhiteSpace(modelEntity.Order_Status))
{
modelEntity.Order_Status = "Open";
}
cancel = false;
}
public string GetContainerStatus(smART.Model.Booking modBooking, smART.Model.DispatcherRequest modelEntity, smART.Model.smARTDBContext dbContext)
{
string status = string.Empty;
try {
smART.Model.Scale modScale = modelEntity.Container != null?dbContext.T_Scale.FirstOrDefault(s => s.Container_No.ID == modelEntity.Container.ID && s.Container_No.Active_Ind == true) : null;
if (modBooking.Invoice_Generated_Flag == true)
{
status = "Closed";
}
else if (modScale != null && modScale.Ticket_Status.ToLower() == "open")
{
status = "WIP";
}
else if (modScale != null && modScale.Ticket_Status.ToLower() == "close")
{
if (modelEntity.RequestType.ToLower() == "drop off only")
{
status = "Shipped";
}
else
{
status = "Open-Loaded";
}
}
else if (string.IsNullOrWhiteSpace(modelEntity.RequestType) || modelEntity.RequestType.ToLower() == "pickup only")
{
status = "Open-Empty";
}
else if (modelEntity.RequestType.ToLower() == "drop off only")
{
if (modScale != null)
{
status = "Shipped";
}
else
{
status = "Open-Empty";
}
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, modelEntity.Updated_By, modelEntity.GetType().Name, modelEntity.ID.ToString());
if (rethrow)
{
throw ex;
}
}
return(status);
}
public void Adding(smART.ViewModel.PriceList businessEntity, smART.Model.PriceList modelEntity, smART.Model.smARTDBContext dbContext, out bool cancel)
{
UpdateDefault(businessEntity, modelEntity, dbContext);
cancel = false;
}
public void Adding(smART.ViewModel.Booking businessEntity, smART.Model.Booking modelEntity, smART.Model.smARTDBContext dbContext, out bool cancel)
{
// If Booking Status is null set default status to "Open"
if (string.IsNullOrEmpty(modelEntity.Booking_Status))
{
modelEntity.Booking_Status = "Open";
}
cancel = false;
}
internal virtual void AddInventory(smART.Model.ScaleDetails modelScaleDetails, smART.Model.smARTDBContext dbContext)
{
try {
//If status is close then add inventory record
if (modelScaleDetails.Scale != null && modelScaleDetails.Scale.Ticket_Status.ToLower().Equals("close") && modelScaleDetails.Apply_To_Item != null)
{
decimal qty = 0;
decimal oldNetWeight = 0;
decimal newCurrentBalance = 0;
//Get all scale inventory item by ticket id & item id
IQueryable <smART.Model.Inventory> inventories = dbContext.Set <smART.Model.Inventory>().AsQueryable().Where(i => i.Scale_Ticket_ID.ID == modelScaleDetails.Scale.ID &&
i.Item_ID.ID == modelScaleDetails.Apply_To_Item.ID &&
i.Trans_Type == "Scale ticket" &&
i.Active_Ind == true);
//Get current balance from Item Master
smART.Model.Item item = dbContext.M_Item.FirstOrDefault(i => i.ID == modelScaleDetails.Apply_To_Item.ID);
oldNetWeight = modelScaleDetails.Old_Net_Weight;
if (item != null)
{
newCurrentBalance = item.Current_Balance;
smART.Model.Inventory newInventory = new Model.Inventory();
//If item inventory exists then add diffrence inventory entry
if (inventories != null && inventories.Count() >= 1)
{
//Check item inventory already exist with same scale ticket.
smART.Model.Inventory inventory = inventories.FirstOrDefault();
//Same item update with same qty.
if (modelScaleDetails.NetWeight == oldNetWeight)
{
return;
}
if (modelScaleDetails.NetWeight > oldNetWeight)
{
newInventory.Impact = "Add";
qty = modelScaleDetails.NetWeight - oldNetWeight;
newCurrentBalance += qty;
}
else
{
newInventory.Impact = "Subtract";
qty = oldNetWeight - modelScaleDetails.NetWeight;
newCurrentBalance -= qty;
}
}
//If item inventory not exists then add item inventory entry
else
{
qty = modelScaleDetails.NetWeight;
if (modelScaleDetails.Scale.Ticket_Type.ToLower().Equals("receiving ticket"))
{
newInventory.Impact = "Add";
newCurrentBalance += qty;
}
else
{
newInventory.Impact = "Subtract";
newCurrentBalance -= qty;
}
}
newInventory.Created_By = modelScaleDetails.Created_By;
newInventory.Created_Date = modelScaleDetails.Created_Date;
newInventory.Item_ID = modelScaleDetails.Apply_To_Item;
newInventory.Party_ID = modelScaleDetails.Scale.Party_ID;
newInventory.Quantity = qty;
newInventory.Scale_Ticket_ID = modelScaleDetails.Scale;
newInventory.Trans_Date = DateTime.Now;
newInventory.Trans_Type = "Scale ticket";
newInventory.Active_Ind = true;
newInventory.Balance = newCurrentBalance;
dbContext.T_Inventory.Add(newInventory);
//Update Item current balance in Item Master
item.Current_Balance = newCurrentBalance;
item.Last_Updated_Date = DateTime.Now;
item.Updated_By = modelScaleDetails.Updated_By;
dbContext.Entry <smART.Model.Item>(item);
}
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, modelScaleDetails.Updated_By, modelScaleDetails.GetType().Name, modelScaleDetails.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
public void GotSingle(smART.ViewModel.Booking businessEntity, smART.Model.Booking modelEntity, smART.Model.smARTDBContext dbContext)
{
try {
// Calculate assigned and due container and container netweight.
IEnumerable <smART.Model.Container> containers = from c in dbContext.T_Container_Ref
where c.Booking.ID == modelEntity.ID && c.Active_Ind == true
select c;
if (containers != null)
{
businessEntity.Containers_Assigned = containers.Count();
businessEntity.Total_Weight = containers.Sum(od => od.Net_Weight);
businessEntity.Containers_Due = businessEntity.No_Of_Containers - businessEntity.Containers_Assigned;
}
}
catch (Exception ex) {
bool rethrow;
rethrow = BusinessRuleExceptionHandler.HandleException(ref ex, businessEntity.Updated_By, businessEntity.GetType().Name, businessEntity.ID.ToString());
if (rethrow)
{
throw ex;
}
}
}
