private IInventoryTreatmentKey DeterminedOrderTreatment(MovementOrderDTO order, SerializableMove deserialized)
        {
            if (deserialized != null && deserialized.TreatmentOrder != null && deserialized.TreatmentOrder.TreatmentKey != null)
            {
                return(deserialized.TreatmentOrder.TreatmentKey);
            }

            int treatmentId;

            if (order.ToWHID == null || !_treatmentIdsByFacility.TryGetValue(order.ToWHID.Value, out treatmentId))
            {
                treatmentId = order.tblOutgoings.Where(o => o.TTypeID == (int)TransType.FrmTrmt)
                              .Select(o => o.TrtmtID)
                              .Distinct().FirstOrDefault(i => i != 0);
                if (treatmentId == 0)
                {
                    return(null);
                }
            }

            return(NewContextHelper.GetInventoryTreatment(treatmentId));
        }
        protected PickedInventory CreatePickedInventory(IPickedInventoryKey pickedInventoryKey, MovementOrderDTO order, ShipmentStatus shipmentStatus)
        {
            LoadCount.AddRead(EntityTypes.PickedInventory);

            int? employeeId = null;
            DateTime? timestamp = null;

            var latestMoveDetail = order.tblMoveDetails.OrderByDescending(d => d.MDetail).FirstOrDefault();
            if(latestMoveDetail != null)
            {
                employeeId = latestMoveDetail.EmployeeID;
                timestamp = latestMoveDetail.MDetail.ConvertLocalToUTC();
            }

            if(employeeId == null)
            {
                employeeId = employeeId ?? order.EmployeeID;
                timestamp = timestamp ?? order.EntryDate.ConvertLocalToUTC();

                if(employeeId == null || timestamp == null)
                {
                    var latestOutgoing = order.tblOutgoings.OrderByDescending(d => d.EntryDate).FirstOrDefault();
                    if(latestOutgoing != null)
                    {
                        employeeId = employeeId ?? latestOutgoing.EmployeeID;
                        timestamp = timestamp ?? latestOutgoing.EntryDate.ConvertLocalToUTC();
                    }
                }
            }
            
            if(timestamp == null)
            {
                Log(new CallbackParameters(CallbackReason.PickedInventoryNoTimestamp)
                    {
                        MovementOrder = order
                    });
                return null;
            }
            
            employeeId = employeeId ?? NewContextHelper.DefaultEmployee.EmployeeId;
            if(employeeId == NewContextHelper.DefaultEmployee.EmployeeId)
            {
                Log(new CallbackParameters(CallbackReason.PickedInventoryDefaultEmployee)
                    {
                        MovementOrder = order,
                        DefaultEmployeeId = employeeId.Value
                    });
            }
            
            return new PickedInventory
                {
                    EmployeeId = employeeId.Value,
                    TimeStamp = timestamp.Value,

                    DateCreated = pickedInventoryKey.PickedInventoryKey_DateCreated,
                    Sequence = pickedInventoryKey.PickedInventoryKey_Sequence,

                    PickedReason = ((TransType)order.TTypeID).ToPickedReason(),
                    Archived = order.Status > (int)tblOrderStatus.Staged,
                    Items = CreatePickedInventoryItemsFromMoveDetails(pickedInventoryKey, order, shipmentStatus).ToList()
                };
        }
        protected InventoryPickOrder CreateInventoryPickOrder(IInventoryPickOrderKey pickOrderKey, MovementOrderDTO order)
        {
            LoadCount.AddRead(EntityTypes.PickOrder);

            return new InventoryPickOrder
                {
                    DateCreated = pickOrderKey.InventoryPickOrderKey_DateCreated,
                    Sequence = pickOrderKey.InventoryPickOrderKey_Sequence,

                    Items = CreateInventoryPickOrderItems(pickOrderKey, order).ToList()
                };
        }
        protected InventoryShipmentOrder SetOrderProperties(InventoryShipmentOrder newOrder, MovementOrderDTO oldOrder)
        {
            newOrder.OrderType = GetOrderType(oldOrder.TTypeID);
            newOrder.MoveNum = oldOrder.MoveNum;
            newOrder.PurchaseOrderNumber = oldOrder.PONbr;
            newOrder.DateReceived = oldOrder.DateRecd;
            newOrder.RequestedBy = oldOrder.From;
            newOrder.TakenBy = oldOrder.TakenBy;
            newOrder.OrderStatus = GetOrderStatus(oldOrder.Status.ToTblOrderStatus());

            return newOrder;
        }
        private IEnumerable<PickedInventoryItem> CreatePickedInventoryItemsFromMoveDetails(IPickedInventoryKey pickedInventoryKey, MovementOrderDTO order, ShipmentStatus shipmentStatus)
        {
            var sequence = 0;

            var moveDetails = order.tblMoveDetails.ToList();
            foreach(var moveDetail in moveDetails)
            {
                LoadCount.AddRead(EntityTypes.PickedInventoryItem);

                var lotKey = LotNumberParser.ParseLotNumber(moveDetail.Lot);
                if(lotKey == null)
                {
                    Log(new CallbackParameters(CallbackReason.MoveDetailInvalidLotNumber)
                    {
                        MoveDetail = moveDetail
                    });
                    continue;
                }

                if(!NewContextHelper.LotLoaded(lotKey))
                {
                    Log(new CallbackParameters(CallbackReason.MoveDetailLotNotLoaded)
                    {
                        MoveDetail = moveDetail
                    });
                    continue;
                }

                var packaging = moveDetail.PType == (int?)LotTypeEnum.Packaging ? NewContextHelper.NoPackagingProduct : NewContextHelper.GetPackagingProduct(moveDetail.PkgID);
                if(packaging == null)
                {
                    Log(new CallbackParameters(CallbackReason.MoveDetailPackagingNotLoaded)
                    {
                        MoveDetail = moveDetail
                    });
                    continue;
                }

                var pickedLocation = NewContextHelper.GetLocation(moveDetail.LocID);
                if(pickedLocation == null)
                {
                    pickedLocation = NewContextHelper.UnknownFacilityLocation;
                    if(pickedLocation == null)
                    {
                        Log(new CallbackParameters(CallbackReason.MoveDetailUnknownWarehouseLocationNotLoaded)
                        {
                            MoveDetail = moveDetail
                        });
                        continue;
                    }

                    Log(new CallbackParameters(CallbackReason.MoveDetailDefaultUnknownWarehouseLocation)
                    {
                        MoveDetail = moveDetail,
                        Location = pickedLocation
                    });
                }

                var currentLocation = shipmentStatus == ShipmentStatus.Shipped ? NewContextHelper.GetLocation(moveDetail.Move2) ?? pickedLocation : pickedLocation;

                var treatment = NewContextHelper.GetInventoryTreatment(moveDetail.TrtmtID);
                if(treatment == null)
                {
                    Log(new CallbackParameters(CallbackReason.MoveDetailTreatmentNotLoaded)
                    {
                        MoveDetail = moveDetail
                    });
                    continue;
                }

                const string tote = "";

                yield return new PickedInventoryItem
                {
                    DateCreated = pickedInventoryKey.PickedInventoryKey_DateCreated,
                    Sequence = pickedInventoryKey.PickedInventoryKey_Sequence,
                    ItemSequence = ++sequence,
                    DetailID = moveDetail.MDetail,

                    LotDateCreated = lotKey.LotKey_DateCreated,
                    LotDateSequence = lotKey.LotKey_DateSequence,
                    LotTypeId = lotKey.LotKey_LotTypeId,
                    PackagingProductId = packaging.Id,
                    TreatmentId = treatment.Id,
                    ToteKey = tote,
                    Quantity = (int)moveDetail.Quantity,
                    FromLocationId = pickedLocation.Id,
                    CurrentLocationId = currentLocation.Id,
                    CustomerLotCode = moveDetail.CustLot,
                    CustomerProductCode = moveDetail.CustProductCode
                };
            }
        }
        private IEnumerable<InventoryPickOrderItem> CreateInventoryPickOrderItems(IInventoryPickOrderKey pickOrderKey, MovementOrderDTO order)
        {
            var sequence = 0;
            foreach(var orderDetail in order.tblMoveOrderDetails)
            {
                LoadCount.AddRead(EntityTypes.PickOrderItem);

                var product = NewContextHelper.GetProduct(orderDetail.ProdID);
                if(product == null)
                {
                    Log(new CallbackParameters(CallbackReason.OrderItemProductNotFound)
                        {
                            MovementOrder = order,
                            MoveOrderDetail = orderDetail
                        });
                    continue;
                }

                var packaging = NewContextHelper.GetPackagingProduct(orderDetail.PkgID);
                var treatment = NewContextHelper.GetInventoryTreatment(orderDetail.TrtmtID);

                Models.Company customer = null;
                if(!string.IsNullOrWhiteSpace(orderDetail.CustomerID))
                {
                    customer = NewContextHelper.GetCompany(orderDetail.CustomerID, CompanyType.Customer);
                    if(customer == null)
                    {
                        Log(new CallbackParameters(CallbackReason.OrderItemCustomerNotFound)
                            {
                                MovementOrder = order,
                                MoveOrderDetail = orderDetail
                            });
                        continue;
                    }
                }

                yield return new InventoryPickOrderItem
                    {
                        DateCreated = pickOrderKey.InventoryPickOrderKey_DateCreated,
                        OrderSequence = pickOrderKey.InventoryPickOrderKey_Sequence,
                        ItemSequence = ++sequence,

                        ProductId = product.ProductKey.ProductKey_ProductId,
                        PackagingProductId = packaging.Id,
                        TreatmentId = treatment.Id,
                        Quantity = (int)orderDetail.Quantity,
                        CustomerId = customer == null ? (int?)null : customer.Id,
                        CustomerLotCode = orderDetail.CustLot,
                        CustomerProductCode = orderDetail.CustProductCode
                    };
            }
        }
        protected ShipmentInformation CreateShipmentInformation(IShipmentInformationKey shipmentInformationKey, MovementOrderDTO order)
        {
            LoadCount.AddRead(EntityTypes.ShipmentInformation);

            var truncated = false;
            var shipmentInfo = new ShipmentInformation
                {
                    DateCreated = shipmentInformationKey.ShipmentInfoKey_DateCreated,
                    Sequence = shipmentInformationKey.ShipmentInfoKey_Sequence,
                    
                    Status = ShipmentStatusExtensions.FromOrderStatID(order.Status),
                    PalletWeight = (double?) order.PalletOR,
                    PalletQuantity = (int)(order.PalletQty ?? 0),
                    FreightBillType = order.FreightBillType.AnyTruncate(Constants.StringLengths.FreightBillType, ref truncated),
                    ShipmentMethod = order.ShipVia.AnyTruncate(Constants.StringLengths.ShipmentMethod, ref truncated),
                    DriverName = order.Driver.AnyTruncate(Constants.StringLengths.DriverName, ref truncated),
                    CarrierName = order.Carrier.AnyTruncate(Constants.StringLengths.CarrierName, ref truncated),
                    TrailerLicenseNumber = order.TrlNbr.AnyTruncate(Constants.StringLengths.TrailerLicenseNumber, ref truncated),
                    ContainerSeal = order.ContSeal.AnyTruncate(Constants.StringLengths.ContainerSeal, ref truncated),

                    RequiredDeliveryDate = order.DelDueDate,
                    ShipmentDate = order.Date ?? order.SchdShipDate,

                    InternalNotes = order.InternalNotes.AnyTruncate(Constants.StringLengths.ShipmentInformationNotes, ref truncated),
                    ExternalNotes = order.ExternalNotes.AnyTruncate(Constants.StringLengths.ShipmentInformationNotes, ref truncated),
                    SpecialInstructions = order.SpecialInstructions.AnyTruncate(Constants.StringLengths.ShipmentInformationNotes, ref truncated),

                    ShipFrom = new ShippingLabel
                        {
                            Name = order.CCompany.AnyTruncate(Constants.StringLengths.ShippingLabelName, ref truncated),
                            Address = new Address
                            {
                                AddressLine1 = order.CAddress1.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                AddressLine2 = order.CAddress2.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                AddressLine3 = order.CAddress3.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                City = order.CCity.AnyTruncate(Constants.StringLengths.AddressCity, ref truncated),
                                State = order.CState.AnyTruncate(Constants.StringLengths.AddressState, ref truncated),
                                PostalCode = order.CZip.AnyTruncate(Constants.StringLengths.AddressPostalCode, ref truncated),
                                Country = order.CCountry.AnyTruncate(Constants.StringLengths.AddressCountry, ref truncated)
                            }
                        },
                    ShipTo = new ShippingLabel
                        {
                            Name = order.SCompany.AnyTruncate(Constants.StringLengths.ShippingLabelName, ref truncated),
                            Phone = order.SPhone.AnyTruncate(Constants.StringLengths.PhoneNumber, ref truncated),
                            Address = new Address
                            {
                                AddressLine1 = order.SAddress1.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                AddressLine2 = order.SAddress2.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                AddressLine3 = order.SAddress3.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                City = order.SCity.AnyTruncate(Constants.StringLengths.AddressCity, ref truncated),
                                State = order.SState.AnyTruncate(Constants.StringLengths.AddressState, ref truncated),
                                PostalCode = order.SZip.AnyTruncate(Constants.StringLengths.AddressPostalCode, ref truncated),
                                Country = order.SCountry.AnyTruncate(Constants.StringLengths.AddressCountry, ref truncated)
                            }
                        },
                    FreightBill = new ShippingLabel
                        {
                            Name = order.Company.AnyTruncate(Constants.StringLengths.ShippingLabelName, ref truncated),
                            Phone = order.Phone.AnyTruncate(Constants.StringLengths.PhoneNumber, ref truncated),
                            EMail = order.Email.AnyTruncate(Constants.StringLengths.Email, ref truncated),
                            Fax = order.Fax.AnyTruncate(Constants.StringLengths.Fax, ref truncated),
                            Address = new Address
                            {
                                AddressLine1 = order.Address1.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                AddressLine2 = order.Address2.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                AddressLine3 = order.Address3.AnyTruncate(Constants.StringLengths.AddressLine, ref truncated),
                                City = order.City.AnyTruncate(Constants.StringLengths.AddressCity, ref truncated),
                                State = order.State.AnyTruncate(Constants.StringLengths.AddressState, ref truncated),
                                PostalCode = order.Zip.AnyTruncate(Constants.StringLengths.AddressPostalCode, ref truncated),
                                Country = order.Country.AnyTruncate(Constants.StringLengths.AddressCountry, ref truncated)
                            }
                        }
                };

            return shipmentInfo;
        }