private void Create(OrderHistoryFile currentFile, bool isSpecialOrder)
{
EF.OrderHistoryHeader header = GetHeaderAndMergeCurrentFile(currentFile, isSpecialOrder);
if (Configuration.DiagnosticsAuditOrderHistoryHeaderChanges)
{
ChangeAuditor.AuditChanges(_unitOfWork.Context, header, _log);
}
bool hasSpecialItems = false;
foreach (OrderHistoryDetail currentDetail in currentFile.Details.ToList())
{
if (string.IsNullOrWhiteSpace(currentDetail.SpecialOrderHeaderId))
{
hasSpecialItems = true;
}
DetermineDetailOnOrder(isSpecialOrder, header, currentDetail);
}
RecalcOrderSubtotal(currentFile, header);
_headerRepo.CreateOrUpdate(header);
if (hasSpecialItems)
{
RemoveSpecialOrderItemsFromHistory(header);
}
}
private static void FillEtaInformation(EF.OrderHistoryHeader orderHistory, Order order)
{
order.ScheduledDeliveryTime = orderHistory.ScheduledDeliveryTime;
order.EstimatedDeliveryTime = orderHistory.EstimatedDeliveryTime;
order.ActualDeliveryTime = orderHistory.ActualDeliveryTime;
order.DeliveryOutOfSequence = orderHistory.DeliveryOutOfSequence;
}
private void GetSubtotal(EF.OrderHistoryHeader header)
{
Order newOrder = header.ToOrder();
LookupProductDetails(header.BranchId, newOrder);
header.OrderSubtotal = (decimal)newOrder.Items.Sum(i => i.LineTotal);
}
private EF.OrderHistoryHeader FindHeader(OrderHistoryFile currentFile)
{
// first attempt to find the order, look by confirmation number
EF.OrderHistoryHeader header = null;
if (!String.IsNullOrEmpty(currentFile.Header.ControlNumber) && !String.IsNullOrEmpty(currentFile.Header.OrderSystem.ToShortString()))
{
header = _headerRepo.ReadByConfirmationNumber(currentFile.Header.ControlNumber, currentFile.Header.OrderSystem.ToShortString()).FirstOrDefault();
}
// second attempt to find the order, look by invioce number
if (header == null && !currentFile.Header.InvoiceNumber.Equals("Processing"))
{
header = _headerRepo.ReadForInvoice(currentFile.Header.BranchId, currentFile.Header.InvoiceNumber).FirstOrDefault();
}
// last ditch effort is to create a new header
if (header == null)
{
header = new EF.OrderHistoryHeader();
header.OrderDetails = new List <EF.OrderHistoryDetail>();
}
return(header);
}
/// <summary>
/// Method to check for a cart/changeorder being submitted
/// </summary>
public static bool CheckOrderBlock(UserProfile user, UserSelectedContext catalogInfo, Guid?cartId, string orderNumber,
IPurchaseOrderRepository pORepository, IOrderHistoryHeaderRepsitory hHRepository, ICacheRepository cache)
{
if (cartId != null && orderNumber == null) // if we are given cartId but not orderNumber, check for cross-reference
{
string cachekey = string.Format("Cart2OrderId_{0}", cartId);
orderNumber = cache.GetItem <string>(CACHE_GROUPNAME, CACHE_PREFIX, CACHE_NAME, cachekey);
}
if (orderNumber != null && cartId == null) // if we are given an orderNumber but not cartId, we could be in changeorder, check for cross-reference
{
string cachekey = string.Format("ChangeOrder_Order2NewOrderId_{0}", orderNumber);
string newOrderNumber = cache.GetItem <string>(CACHE_GROUPNAME, CACHE_PREFIX, CACHE_NAME, cachekey);
if (newOrderNumber != null)
{
orderNumber = newOrderNumber;
}
}
EF.OrderHistoryHeader theEFOrder = null;
Order theOrder = null;
// to check, we need to build the order and look at its status.
if (catalogInfo != null && orderNumber != null && hHRepository != null)
{
// We just get the header not the details for performance
theEFOrder = hHRepository.Read(h => h.BranchId.Equals(catalogInfo.BranchId, StringComparison.InvariantCultureIgnoreCase) &&
(h.ControlNumber.Equals(orderNumber))).FirstOrDefault();
}
if (theEFOrder == null && pORepository != null && orderNumber != null) // if we don't find a header, try and construct the order from the purchaseOrder
{
CS.PurchaseOrder po = pORepository.ReadPurchaseOrderByTrackingNumber(orderNumber);
theOrder = po.ToOrder();
}
else
{
if (theEFOrder != null)
{
theOrder = theEFOrder.ToOrder();
}
}
// we provide for no block for sysadmin
// block a pending or submitted order otherwise
//if (user.RoleName.Equals("beksysadmin", StringComparison.CurrentCultureIgnoreCase) == false &&
// theOrder != null && ((theOrder.Status.Equals("Pending")) | (theOrder.Status.Equals("Submitted"))))
if (theOrder != null)
{
if ((theOrder.Status.Equals("Pending")) | (theOrder.Status.Equals("Submitted")))
{
return(true);
}
}
return(false);
}
public static void MergeWithEntity(this OrderHistoryHeader header, ref EF.OrderHistoryHeader entity)
{
entity.OrderSystem = header.OrderSystem.ToShortString();
entity.BranchId = header.BranchId;
entity.CustomerNumber = header.CustomerNumber;
entity.InvoiceNumber = header.InvoiceNumber;
entity.OrderDateTime = header.OrderDateTime;
entity.DeliveryDate = header.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
entity.PONumber = header.PONumber ?? entity.PONumber;
//entity.ControlNumber = header.ControlNumber.Trim();
// the original control number is actually set from the entity already
// and because the order history header is actually a converted confirmation
// it does not know the original control number so it is seeing it as null
// and screwing up the original control number
//entity.OriginalControlNumber = string.IsNullOrEmpty(header.OriginalControlNumber) ? header.ControlNumber.Trim() : header.OriginalControlNumber.Trim();
entity.OrderStatus = header.OrderStatus;
entity.FutureItems = header.FutureItems;
entity.ErrorStatus = header.ErrorStatus;
entity.RouteNumber = header.RouteNumber;
entity.StopNumber = header.StopNumber;
//entity.IsSpecialOrder =
if (string.IsNullOrEmpty(entity.ControlNumber))
{
entity.ControlNumber = header.ControlNumber.Trim();
if (string.IsNullOrEmpty(entity.OriginalControlNumber))
{
entity.OriginalControlNumber = header.ControlNumber.Trim();
}
}
else
{
// update the history file with EF data
int valueControlNumber;
if (!int.TryParse(header.ControlNumber, out valueControlNumber))
{
valueControlNumber = 0;
}
int entityControlNumber;
if (!int.TryParse(entity.ControlNumber, out entityControlNumber))
{
entityControlNumber = 0;
}
if (entityControlNumber > valueControlNumber)
{
header.ControlNumber = entity.ControlNumber;
}
else
{
entity.ControlNumber = header.ControlNumber;
}
//value.ControlNumber = entityControlNumber >= valueControlNumber? entity.ControlNumber : value.ControlNumber;
header.OriginalControlNumber = entity.OriginalControlNumber ?? entity.ControlNumber;
}
}
private EF.OrderHistoryDetail SeekMatchingDetail(EF.OrderHistoryHeader header, OrderHistoryDetail currentDetail)
{
EF.OrderHistoryDetail detail = null;
if (header.OrderDetails != null && header.OrderDetails.Count > 0)
{
detail = header.OrderDetails.Where(d => (d.LineNumber == currentDetail.LineNumber)).FirstOrDefault();
}
return(detail);
}
private void UpdateOrder(SpecialOrderResponseModel specialorder, EF.OrderHistoryDetail detail)
{
EF.OrderHistoryHeader header = _headerRepo.ReadById(detail.OrderHistoryHeader.Id);
header.DeliveryDate = specialorder.Item.EstimatedArrival;
_headerRepo.Update(header);
detail.ItemStatus = Constants.CONFIRMATION_DETAIL_FILLED_CODE;
_detailRepo.Update(detail);
_unitOfWork.SaveChanges();
}
private EF.OrderHistoryDetail MergeWithCurrentOrderDetail
(bool isSpecialOrder, EF.OrderHistoryHeader header, OrderHistoryDetail currentDetail, EF.OrderHistoryDetail detail)
{
currentDetail.MergeWithEntityFrameworkModel(ref detail);
detail.BranchId = header.BranchId;
detail.InvoiceNumber = header.InvoiceNumber;
if (isSpecialOrder)
{
detail.ItemStatus = KeithLink.Svc.Core.Constants.SPECIALORDERITEM_REQ_STATUS_TRANSLATED_CODE;
}
return(detail);
}
private EF.OrderHistoryDetail AddNewDetailToOrder(bool isSpecialOrder, EF.OrderHistoryHeader header, OrderHistoryDetail currentDetail)
{
EF.OrderHistoryDetail tempDetail = currentDetail.ToEntityFrameworkModel();
tempDetail.BranchId = header.BranchId;
tempDetail.InvoiceNumber = header.InvoiceNumber;
tempDetail.OrderHistoryHeader = header;
if (isSpecialOrder)
{
tempDetail.ItemStatus = KeithLink.Svc.Core.Constants.SPECIALORDERITEM_REQ_STATUS_TRANSLATED_CODE;
}
header.OrderDetails.Add(tempDetail);
return(tempDetail);
}
private void SaveRejectedConfirmationAsOrderHistory(ConfirmationFile confFile)
{
//Assume we will only get rejections for Entree Orders
Core.Enumerations.Order.OrderSource orderSource = Core.Enumerations.Order.OrderSource.Entree;
EF.OrderHistoryHeader header = _historyRepo.ReadByConfirmationNumber(confFile.Header.ConfirmationNumber, orderSource.ToShortString()).FirstOrDefault();
if (header != null)
{
header.OrderStatus = Constants.CONFIRMATION_HEADER_REJECTED_CODE;
header.InvoiceNumber = Constants.CONFIRMATION_HEADER_REJECTED_STATUS;
_historyRepo.CreateOrUpdate(header);
_uow.SaveChanges();
}
}
private void DetermineDetailOnOrder(bool isSpecialOrder, EF.OrderHistoryHeader header, OrderHistoryDetail currentDetail)
{
EF.OrderHistoryDetail detail = SeekMatchingDetail(header, currentDetail);
if (detail == null)
{
detail = AddNewDetailToOrder(isSpecialOrder, header, currentDetail);
}
else
{
detail = MergeWithCurrentOrderDetail(isSpecialOrder, header, currentDetail, detail);
}
if (Configuration.DiagnosticsAuditOrderHistoryDetailChanges)
{
ChangeAuditor.AuditChanges(_unitOfWork.Context, detail, _log);
}
}
public static OrderHistoryHeader ToOrderHistoryHeader(this EF.OrderHistoryHeader entity)
{
OrderHistoryHeader header = new OrderHistoryHeader();
header.OrderSystem = OrderSource.Entree; // TODO: entity.OrderSystem.ToShortString();
header.BranchId = entity.BranchId;
header.CustomerNumber = entity.CustomerNumber;
header.InvoiceNumber = entity.InvoiceNumber;
header.DeliveryDate = entity.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
header.PONumber = entity.PONumber;
header.ControlNumber = entity.ControlNumber;
header.OriginalControlNumber = string.IsNullOrEmpty(entity.OriginalControlNumber) ? entity.ControlNumber.Trim() : entity.OriginalControlNumber.Trim();
header.OrderStatus = entity.OrderStatus;
header.FutureItems = entity.FutureItems;
header.ErrorStatus = entity.ErrorStatus;
header.RouteNumber = entity.RouteNumber;
header.StopNumber = entity.StopNumber;
return(header);
}
public static EF.OrderHistoryHeader ToEntityFrameworkModel(this OrderHistoryHeader header)
{
EF.OrderHistoryHeader entity = new EF.OrderHistoryHeader();
entity.OrderSystem = header.OrderSystem.ToShortString();
entity.BranchId = header.BranchId;
entity.CustomerNumber = header.CustomerNumber;
entity.InvoiceNumber = header.InvoiceNumber;
entity.OrderDateTime = header.OrderDateTime;
entity.DeliveryDate = header.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
entity.PONumber = header.PONumber;
entity.ControlNumber = header.ControlNumber;
entity.OriginalControlNumber = string.IsNullOrEmpty(header.OriginalControlNumber) ? header.ControlNumber.Trim() : header.OriginalControlNumber.Trim();
entity.OrderStatus = header.OrderStatus;
entity.FutureItems = header.FutureItems;
entity.ErrorStatus = header.ErrorStatus;
entity.RouteNumber = header.RouteNumber;
entity.StopNumber = header.StopNumber;
return(entity);
}
private void ProcessOrderHistoryDetailOnDeletedOrPurgedStatusUpdate(EF.OrderHistoryDetail detail)
{
EF.OrderHistoryHeader header = detail.OrderHistoryHeader;
if (header != null)
{
if (header.OrderDetails.Count > 1)
{
_detailRepo.Delete(detail);
}
else
{
_headerRepo.Delete(header);
}
_unitOfWork.SaveChanges();
}
else
{
_detailRepo.Delete(detail);
_unitOfWork.SaveChanges();
}
}
private EF.OrderHistoryHeader GetHeaderAndMergeCurrentFile(OrderHistoryFile currentFile, bool isSpecialOrder)
{
// add retry helper logic to attempt to resolve race conflict
EF.OrderHistoryHeader header = KeithLink.Svc.Impl.Helpers.Retry.Do <EF.OrderHistoryHeader>
(() => FindHeader(currentFile),
TimeSpan.FromSeconds(1), 3);
currentFile.Header.MergeWithEntity(ref header);
// set isSpecialOrder if that is true; but don't set otherwise (used from two places)
if (isSpecialOrder)
{
header.IsSpecialOrder = true;
}
if (string.IsNullOrEmpty(header.OriginalControlNumber))
{
header.OriginalControlNumber = currentFile.Header.ControlNumber;
}
return(header);
}
private void DetermineCatalogNotesSpecialOrder(PurchaseOrder po, ref EF.OrderHistoryHeader header)
{
//_log.WriteInformationLog("InternalOrderHistoryLogic.PullCatalogFromPurchaseOrderItemsToOrder() LineItems=" +
// ((CommerceServer.Foundation.CommerceRelationshipList)po.Properties["LineItems"]).Count);
string catalogId = null;
string catalogType;
if (po.Properties["LineItems"] != null)
{
foreach (var lineItem in ((CommerceServer.Foundation.CommerceRelationshipList)po.Properties["LineItems"]))
{
var item = (CS.LineItem)lineItem.Target;
catalogId = item.CatalogName;
catalogType = _catalogLogic.GetCatalogTypeFromCatalogId(item.CatalogName);
}
}
// Look for certain catalogs names or at least the start to be one of the special catalogs
if (catalogId.IndexOf("unfi") > -1)
{
header.IsSpecialOrder = true;
}
}
public static Order ToOrderHeaderOnly(this EF.OrderHistoryHeader entity)
{
Order order = new Order();
order.OrderNumber = entity.InvoiceNumber;
switch (entity.OrderStatus.Trim())
{
case "":
order.Status = "Ordered";
break;
case "I":
order.Status = "Invoiced";
break;
case "P":
order.Status = "Processing";
break;
default:
order.Status = "Unknown";
break;
}
order.CreatedDate = DateTime.SpecifyKind(entity.CreatedUtc.ToLocalTime(), DateTimeKind.Unspecified);
order.DeliveryDate = entity.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
order.InvoiceNumber = entity.InvoiceNumber.Trim();
order.InvoiceStatus = "N/A";
order.ItemCount = entity.OrderDetails == null ? 0 : entity.OrderDetails.Count;
order.OrderTotal = (double)entity.OrderDetails.Sum(d => d.ShippedQuantity * d.SellPrice);
order.RequestedShipDate = entity.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
order.IsChangeOrderAllowed = false;
order.CommerceId = Guid.Empty;
FillEtaInformation(entity, order);
return(order);
}
private void RemoveSpecialOrderItemsFromHistory(EF.OrderHistoryHeader order)
{
// clean up any previous orders where the special order item existed
var specialOrderInfo = order.OrderDetails.Where(currentDetail => !String.IsNullOrEmpty(currentDetail.SpecialOrderHeaderId))
.Select(d => new { HeaderId = d.SpecialOrderHeaderId, LineNumber = d.SpecialOrderLineNumber })
.Distinct()
.ToList();
// loop through each special order item in the current order
foreach (var specialOrderItem in specialOrderInfo)
{
// find all detail records with the current line's special order info that is not the current order
var specialLines = _detailRepo.Read(d => d.BranchId.Equals(order.BranchId) &&
d.SpecialOrderHeaderId.Equals(specialOrderItem.HeaderId) &&
d.SpecialOrderLineNumber.Equals(specialOrderItem.LineNumber) &&
!d.InvoiceNumber.Equals(order.InvoiceNumber))
.ToList();
// loop through each found detail record
foreach (var line in specialLines)
{
_detailRepo.Delete(line);
// check to see if there are any more records on the detail's header record
if (_detailRepo.Read(d => d.BranchId.Equals(line.BranchId) &&
d.InvoiceNumber.Equals(line.InvoiceNumber))
.Any() == false)
{
_headerRepo.Delete(h => h.BranchId.Equals(line.BranchId) &&
h.InvoiceNumber.Equals(line.InvoiceNumber));
}
}
}
// this is commented out so that all updates to EF happen in one transaction for the current order
//_unitOfWork.SaveChanges();
}
public void SaveConfirmationAsOrderHistory(ConfirmationFile confFile)
{
if (confFile.Header.ConfirmationStatus.Equals(Constants.CONFIRMATION_HEADER_REJECTED_CODE, StringComparison.InvariantCultureIgnoreCase))
{
SaveRejectedConfirmationAsOrderHistory(confFile);
}
else
{
OrderHistoryFile currentFile = confFile.ToOrderHistoryFile();
EF.OrderHistoryHeader header = _historyRepo.ReadForInvoice(currentFile.Header.BranchId, currentFile.Header.InvoiceNumber).FirstOrDefault();
// second attempt to find the order, look by confirmation number
if (header == null)
{
header = _historyRepo.ReadByConfirmationNumber(currentFile.Header.ControlNumber, currentFile.Header.OrderSystem.ToShortString()).FirstOrDefault();
if (header != null)
{
header.InvoiceNumber = confFile.Header.InvoiceNumber;
}
}
// last ditch effort is to create a new header
if (header == null)
{
header = new EF.OrderHistoryHeader();
header.OrderDetails = new List <EF.OrderHistoryDetail>();
}
currentFile.Header.MergeWithEntity(ref header);
foreach (OrderHistoryDetail currentDetail in currentFile.Details)
{
EF.OrderHistoryDetail detail = null;
if (header.OrderDetails != null && header.OrderDetails.Count > 0)
{
detail = header.OrderDetails.Where(d => (d.LineNumber == currentDetail.LineNumber)).FirstOrDefault();
}
if (detail == null)
{
EF.OrderHistoryDetail tempDetail = currentDetail.ToEntityFrameworkModel();
tempDetail.BranchId = header.BranchId;
tempDetail.InvoiceNumber = header.InvoiceNumber;
header.OrderDetails.Add(currentDetail.ToEntityFrameworkModel());
}
else
{
currentDetail.MergeWithEntityFrameworkModel(ref detail);
detail.BranchId = header.BranchId;
detail.InvoiceNumber = header.InvoiceNumber;
}
}
//Mark missing items as deleted
foreach (var deletedItem in header.OrderDetails.Where(d => !currentFile.Details.Any(c => c.LineNumber.Equals(d.LineNumber))).ToList())
{
deletedItem.ItemDeleted = true;
deletedItem.OrderQuantity = 0;
deletedItem.ShippedQuantity = 0;
}
GetSubtotal(header);
_historyRepo.CreateOrUpdate(header);
_uow.SaveChangesAndClearContext();
}
}
public static Order ToOrder(this EF.OrderHistoryHeader entity)
{
Order order = new Order();
//retVal.OrderNumber = value.InvoiceNumber;
order.OrderNumber = entity.ControlNumber;
switch (entity.OrderStatus.Trim())
{
case "":
order.Status = "Ordered";
break;
case "I":
order.Status = "Invoiced";
break;
case "P":
order.Status = "Processing";
break;
case "D":
order.Status = "Deleted";
break;
default:
break;
}
order.CreatedDate = DateTime.SpecifyKind(entity.CreatedUtc.ToLocalTime(), DateTimeKind.Unspecified);
if (string.IsNullOrWhiteSpace(entity.OrderDateTime) == false)
{
var orderDateTime = entity.OrderDateTime.ToDateTime();
if (orderDateTime.HasValue)
{
order.CreatedDate = orderDateTime.Value;
}
}
order.DeliveryDate = entity.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
order.InvoiceNumber = entity.InvoiceNumber.Trim();
order.InvoiceStatus = "N/A";
order.ItemCount = entity.OrderDetails == null ? 0 : entity.OrderDetails.Count;
order.RequestedShipDate = entity.DeliveryDate.ToDateTime().Value.ToLongDateFormat();
order.IsChangeOrderAllowed = false;
order.CommerceId = Guid.Empty;
FillEtaInformation(entity, order);
order.PONumber = entity.PONumber;
order.IsSpecialOrder = entity.IsSpecialOrder;
order.OrderTotal = (double)entity.OrderSubtotal;
order.OrderSystem = new OrderSource().Parse(entity.OrderSystem).ToString();
if (entity.OrderDetails != null && entity.OrderDetails.Count > 0)
{
var lineItems = new BlockingCollection <OrderLine>();
Parallel.ForEach(entity.OrderDetails, d =>
{
lineItems.Add(d.ToOrderLine(entity.OrderStatus));
});
order.Items = lineItems.OrderBy(i => i.LineNumber).ToList();
}
return(order);
}
private void RecalcOrderSubtotal(OrderHistoryFile currentFile, EF.OrderHistoryHeader header)
{
// since we keep an ordersubtotal in the header, we need to recalibrate it (especially for catchweight items) when processing order updates
LookupAverageWeightOnDetails(currentFile);
header.OrderSubtotal = (decimal)currentFile.Details.Sum(i => i.LineTotal);
}