Ejemplo n.º 1
0
        public static List <PurchaseOrder> RetrievalRequestFromNAV()
        {
            NAVRMARetrievalRoot  myNAVRMAOrderRetrievalRoot = new NAVRMARetrievalRoot();
            List <PurchaseOrder> myWMSRMAOrders             = new List <PurchaseOrder>();

            String myResult = String.Empty;

            try
            {
                PurchaseOrder myWMSRMAOrder;

                // Call NAV Web Service | ExportPurchaseOrder
                myResult = CompanyConfig.Instance.NavWebServiceInstance.RetrieveRMAOrder(ref myNAVRMAOrderRetrievalRoot);
                CompanyConfig.Instance.NavWebServiceInstance.Dispose();

                //NAV Business Object | Code = RH
                NAVBusinessObjectRMAR myNAVBusinessObjectRMAR = new NAVBusinessObjectRMAR();
                myNAVBusinessObjectRMAR = myNAVRMAOrderRetrievalRoot.NAVBusinessObjectRMAR;

                //NAV RMA Headers | Processed = Ready to Send
                NAVRMARetrievals myNAVRMARetrievals = new NAVRMARetrievals();
                myNAVRMARetrievals = myNAVBusinessObjectRMAR.NAVRMARetrievals;

                try
                {
                    // For each RMA Retrieval record in the queue
                    foreach (NAVRMARetrieval myNAVOrder in myNAVRMARetrievals.NAVRMARetrieval)
                    {
                        myWMSRMAOrder = new PurchaseOrder();

                        // Parse RMA Header
                        myWMSRMAOrder.SVAStagingID        = myNAVOrder.StagingID.ToString();
                        myWMSRMAOrder.ClientName          = NAVAdapterUtils.getClientName();
                        myWMSRMAOrder.PurchaseOrderNumber = NAVAdapterUtils.NAVFormatString(myNAVOrder.OrderNumber.ToString(), 40);

                        //Add RMA to List of RMAs
                        if (myNAVOrder.OrderNumber.ToString() != "")
                        {
                            myWMSRMAOrders.Add(myWMSRMAOrder);
                            EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrderRetrieval", CompanyConfig.InstanceId, "A1I -> Status Update -> NAV", new Variable("Status", "Sent to WMS"), new Variable("Purchase Order Number", NAVAdapterUtils.NAVFormatString(myNAVOrder.OrderNumber.ToString(), 40)), new Variable("Entry No", NAVAdapterUtils.NAVFormatString(myNAVOrder.StagingID.ToString(), 40)));
                            try
                            {
                                // Call NAV Web Service | SentStatus
                                CompanyConfig.Instance.NavWebServiceInstance.SentStatus(NAVAdapterUtils.NAVFormatString(myNAVOrder.StagingID.ToString(), 40), "RH");
                                CompanyConfig.Instance.NavWebServiceInstance.Dispose();
                            }
                            catch (Exception ex1)
                            {
                                EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrderRetrieval.Error", CompanyConfig.InstanceId, "Error: A1I Entry No -> NAV", new Variable("Error Sending to WMS", ex1));
                            }
                        }
                    }
                }
                catch (Exception exceptionPOLvl)
                {
                    //Error at RMA Order Level
                    EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrderRetrieval.Error", CompanyConfig.InstanceId, "Error: RMA Order Level", new Variable("Error Sending to WMS", exceptionPOLvl));
                }
            }
            catch (Exception exceptionPORetRootLvl)
            {
                //Error at RMA Order Retrieval Root Level
                EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrderRetrieval.Error", CompanyConfig.InstanceId, "Error: RMA Order Retrieval Root Level", new Variable("Error Sending to WMS", exceptionPORetRootLvl));
            }

            return(myWMSRMAOrders);
        }
Ejemplo n.º 2
0
        public static List <PurchaseOrder> RetrieveFromNAV()
        {
            NAVRMARoot           myNAVRMARoot   = new NAVRMARoot();
            List <PurchaseOrder> myWMSRMAOrders = new List <PurchaseOrder>();
            bool didFailureOccur;

            String myResult = String.Empty;

            try
            {
                PurchaseOrder     myWMSRMAOrder;
                PurchaseOrderLine myWMSPurchaseOrderLine;

                // Call NAV Web Service | ExportRMA
                myResult = CompanyConfig.Instance.NavWebServiceInstance.ExportRMAOrder(ref myNAVRMARoot);
                CompanyConfig.Instance.NavWebServiceInstance.Dispose();
                EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrders", CompanyConfig.InstanceId, "Exported NAV Data",
                                                             new Variable("data", Utils.SerializeToString(myNAVRMARoot)));

                //NAV Business Object | Code = RH
                NAVBusinessObjectRMA myNAVBusinessObjectRMA = new NAVBusinessObjectRMA();
                myNAVBusinessObjectRMA = myNAVRMARoot.NAVBusinessObjectRMA;

                //NAV Customer Returns | Processed = Ready to Send
                NAVCustomerReturns myNAVCustomerReturns = new NAVCustomerReturns();
                myNAVCustomerReturns = myNAVBusinessObjectRMA.NAVCustomerReturns;

                try
                {
                    if (myNAVCustomerReturns.NAVCustomerReturn == null)
                    {
                        //There aren't any orders to process
                        myWMSRMAOrders = new List <PurchaseOrder>();
                        return(myWMSRMAOrders);
                    }

                    // For each Customer Return record in the queue
                    foreach (NAVCustomerReturn myNAVCustomerReturn in myNAVCustomerReturns.NAVCustomerReturn)
                    {
                        NAVRmaOrders myNAVRMAOrders = new NAVRmaOrders();
                        myNAVRMAOrders = myNAVCustomerReturn.NAVRmaOrders;

                        NAVRmaOrder myNAVOrder = new NAVRmaOrder();
                        myNAVOrder = myNAVRMAOrders.NAVRmaOrder;

                        myWMSRMAOrder = new PurchaseOrder();

                        // Parse Purchase Order Header
                        myWMSRMAOrder.AllowBackOrder            = NAVAdapterUtils.NAVFormatBoolean(myNAVOrder.AllowBackOrder.ToString());
                        myWMSRMAOrder.BackOrder                 = NAVAdapterUtils.NAVFormatString(myNAVOrder.BackOrder.ToString(), 40);
                        myWMSRMAOrder.BuyerName                 = NAVAdapterUtils.NAVFormatString(myNAVOrder.BuyerName.ToString(), 40);
                        myWMSRMAOrder.ClientName                = NAVAdapterUtils.getClientName();
                        myWMSRMAOrder.ContainerBatchRef         = NAVAdapterUtils.NAVFormatString(myNAVOrder.ContainerBatchRef.ToString(), 40);
                        myWMSRMAOrder.DueDate                   = NAVAdapterUtils.NAVFormatDateTime(myNAVOrder.DueDate.ToString());
                        myWMSRMAOrder.Email                     = NAVAdapterUtils.NAVFormatString(myNAVOrder.Email.ToString(), 40);
                        myWMSRMAOrder.Extra1                    = NAVAdapterUtils.NAVFormatString(myNAVOrder.Extra1.ToString(), 40);
                        myWMSRMAOrder.Extra2                    = NAVAdapterUtils.NAVFormatString(myNAVOrder.Extra2.ToString(), 40);
                        myWMSRMAOrder.Extra3                    = NAVAdapterUtils.NAVFormatString(myNAVOrder.Extra3.ToString(), 40);
                        myWMSRMAOrder.Extra4                    = NAVAdapterUtils.NAVFormatString(myNAVOrder.Extra4.ToString(), 40);
                        myWMSRMAOrder.Extra5                    = NAVAdapterUtils.NAVFormatString(myNAVOrder.Extra5.ToString(), 40);
                        myWMSRMAOrder.IsRMA                     = NAVAdapterUtils.NAVFormatBoolean(myNAVOrder.IsRMA.ToString());
                        myWMSRMAOrder.NoSHReship                = NAVAdapterUtils.NAVFormatString(myNAVOrder.NoSHReship.ToString(), 40);
                        myWMSRMAOrder.OrderSource               = NAVAdapterUtils.NAVFormatString(myNAVOrder.OrderSource.ToString(), 40);
                        myWMSRMAOrder.Packslip                  = NAVAdapterUtils.NAVFormatString(myNAVOrder.Packslip.ToString(), 40);
                        myWMSRMAOrder.PoType                    = NAVAdapterUtils.NAVFormatPOType(myNAVOrder.PoType.ToString());
                        myWMSRMAOrder.PurchaseOrderNumber       = NAVAdapterUtils.NAVFormatString(myNAVOrder.PurchaseOrderNumber.ToString(), 40);
                        myWMSRMAOrder.RequestPOD                = NAVAdapterUtils.NAVFormatString(myNAVOrder.RequestPOD.ToString(), 40);
                        myWMSRMAOrder.RequestSH                 = NAVAdapterUtils.NAVFormatString(myNAVOrder.CreditSH.ToString(), 40);
                        myWMSRMAOrder.RequisitionNumber         = NAVAdapterUtils.NAVFormatString(myNAVOrder.RequisitionNumber.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions1      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions1.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions2      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions2.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions3      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions3.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions4      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions4.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions5      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions5.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions6      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions6.ToString(), 40);
                        myWMSRMAOrder.SpecialInstructions7      = NAVAdapterUtils.NAVFormatString(myNAVOrder.SpecialIntructions7.ToString(), 40);
                        myWMSRMAOrder.SVAStagingID              = myNAVOrder.StagingID.ToString();
                        myWMSRMAOrder.VendorName                = NAVAdapterUtils.NAVFormatString(myNAVOrder.VendorName.ToString(), 40);
                        myWMSRMAOrder.VendorNumber              = NAVAdapterUtils.NAVFormatString(myNAVOrder.VendorNumber.ToString(), 40);
                        myWMSRMAOrder.WarehouseTransferLocation = NAVAdapterUtils.NAVFormatString(myNAVOrder.WarehouseTransferLocation.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF1           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF1.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF2           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF2.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF3           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF3.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF4           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF4.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF5           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF5.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF6           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF6.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF7           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF7.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF8           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF8.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF9           = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF9.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF10          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF10.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF11          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF11.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF12          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF12.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF13          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF13.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF14          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF14.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF15          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF15.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF16          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF16.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF17          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF17.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF18          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF18.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF19          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF19.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF20          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF20.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF21          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF21.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF22          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF22.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF23          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF23.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF24          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF24.ToString(), 40);
                        myWMSRMAOrder.IntegrationUDF25          = NAVAdapterUtils.NAVFormatString(myNAVOrder.IntegrationUDF25.ToString(), 40);

                        didFailureOccur = false;

                        try
                        {
                            NAVRmaLines myNAVRMALines = myNAVOrder.NAVRmaLines;

                            foreach (NAVRmaLine myNAVLine in myNAVRMALines.NAVRmaLine)
                            {
                                myWMSPurchaseOrderLine = new PurchaseOrderLine();

                                // Parse Purchase Order Lines
                                NAV.BusinessObjects.AttributeSet mySet = new NAV.BusinessObjects.AttributeSet();
                                mySet.Attribute1  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute1.ToString(), 40);
                                mySet.Attribute2  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute2.ToString(), 40);
                                mySet.Attribute3  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute3.ToString(), 40);
                                mySet.Attribute4  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute4.ToString(), 40);
                                mySet.Attribute5  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute5.ToString(), 40);
                                mySet.Attribute6  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute6.ToString(), 40);
                                mySet.Attribute7  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute7.ToString(), 40);
                                mySet.Attribute8  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute8.ToString(), 40);
                                mySet.Attribute9  = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute9.ToString(), 40);
                                mySet.Attribute10 = NAVAdapterUtils.NAVFormatString(myNAVLine.Attribute10.ToString(), 40);
                                myWMSPurchaseOrderLine.Attributes.Add(mySet);

                                myWMSPurchaseOrderLine.ContainerBatchRef    = NAVAdapterUtils.NAVFormatString(myNAVLine.ContainerBatchRef.ToString(), 40);
                                myWMSPurchaseOrderLine.ContainerStatus      = NAVAdapterUtils.NAVFormatString(myNAVLine.ContainerStatus.ToString(), 40);
                                myWMSPurchaseOrderLine.CostPrice            = NAVAdapterUtils.NAVFormatDecimal(myNAVLine.CostPrice.ToString());
                                myWMSPurchaseOrderLine.CountryOfOrigin      = NAVAdapterUtils.NAVFormatString(myNAVLine.CountryOfOrigin.ToString(), 40);
                                myWMSPurchaseOrderLine.CreditNow            = NAVAdapterUtils.NAVFormatBoolean(myNAVLine.CreditNow.ToString());
                                myWMSPurchaseOrderLine.CustomerName         = NAVAdapterUtils.NAVFormatString(myNAVLine.CustomerName.ToString(), 40);
                                myWMSPurchaseOrderLine.CustomerNumber       = NAVAdapterUtils.NAVFormatString(myNAVLine.CustomerNumber.ToString(), 40);
                                myWMSPurchaseOrderLine.Description          = NAVAdapterUtils.NAVFormatString(myNAVLine.Description.ToString(), 100); // Changed to 100 characters for A1W 64 - iCepts 10/6/15
                                myWMSPurchaseOrderLine.Discount             = NAVAdapterUtils.NAVFormatDecimal(myNAVLine.Discount.ToString());
                                myWMSPurchaseOrderLine.ExpectedRequiredDate = NAVAdapterUtils.NAVFormatDateTime(myNAVLine.ExpectedRequiredDate.ToString());
                                myWMSPurchaseOrderLine.ExpiryDate           = NAVAdapterUtils.NAVFormatDateTime(myNAVLine.ExpiryDate.ToString());
                                myWMSPurchaseOrderLine.Extra1                = NAVAdapterUtils.NAVFormatString(myNAVLine.Extra1.ToString(), 40);
                                myWMSPurchaseOrderLine.Extra2                = NAVAdapterUtils.NAVFormatString(myNAVLine.Extra2.ToString(), 40);
                                myWMSPurchaseOrderLine.Extra3                = NAVAdapterUtils.NAVFormatString(myNAVLine.Extra3.ToString(), 40);
                                myWMSPurchaseOrderLine.Extra4                = NAVAdapterUtils.NAVFormatString(myNAVLine.Extra4.ToString(), 40);
                                myWMSPurchaseOrderLine.Extra5                = NAVAdapterUtils.NAVFormatString(myNAVLine.Extra5.ToString(), 40);
                                myWMSPurchaseOrderLine.HostLineReference     = NAVAdapterUtils.NAVFormatString(myNAVLine.HostLineReference.ToString(), 40);
                                myWMSPurchaseOrderLine.IsSpecial             = NAVAdapterUtils.NAVFormatBoolean(myNAVLine.IsSpecial.ToString());
                                myWMSPurchaseOrderLine.LineNumber            = NAVAdapterUtils.NAVFormatString(myNAVLine.LineNumber.ToString(), 40);
                                myWMSPurchaseOrderLine.Location              = NAVAdapterUtils.NAVFormatString(myNAVLine.Location.ToString(), 40);
                                myWMSPurchaseOrderLine.OverReceiptPercentage = NAVAdapterUtils.NAVFormatString(myNAVLine.OverReceivePercent.ToString(), 40);
                                myWMSPurchaseOrderLine.PrimaryLocation       = NAVAdapterUtils.NAVFormatString(myNAVLine.PrimaryBin.ToString(), 40);
                                myWMSPurchaseOrderLine.ProductClass          = NAVAdapterUtils.NAVFormatString(myNAVLine.ProductClass.ToString(), 40);
                                myWMSPurchaseOrderLine.ProductCode           = NAVAdapterUtils.NAVFormatString(myNAVLine.ProductCode.ToString(), 40);
                                myWMSPurchaseOrderLine.PurchaseOrderNumber   = NAVAdapterUtils.NAVFormatString(myNAVLine.PurchaseOrderNumber.ToString(), 40);
                                myWMSPurchaseOrderLine.QuantityExpected      = NAVAdapterUtils.NAVFormatDecimal(myNAVLine.QuantityExpected.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute1Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute1Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute2Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute2Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute3Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute3Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute4Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute4Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute5Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute5Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute6Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute6Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute7Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute7Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute8Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute8Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute9Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute9Tracking.ToString());
                                myWMSPurchaseOrderLine.ReceiveAttributeTracking.Attribute10Tracking = NAVAdapterUtils.NAVFormatTrackingType(myNAVLine.Attribute10Tracking.ToString());
                                myWMSPurchaseOrderLine.ReInvoice               = NAVAdapterUtils.NAVFormatBoolean(myNAVLine.ReInvoice.ToString());
                                myWMSPurchaseOrderLine.Reship                  = NAVAdapterUtils.NAVFormatInt(myNAVLine.Reship.ToString());
                                myWMSPurchaseOrderLine.RMAReason               = NAVAdapterUtils.NAVFormatString(myNAVLine.RMAReason.ToString(), 40);
                                myWMSPurchaseOrderLine.RMARestockCharge        = NAVAdapterUtils.NAVFormatString(myNAVLine.RMARestockCharge.ToString(), 40);                        //myWMSPurchaseOrderLine = NAVAdapterUtils.NAVFormatString(myNAVLine
                                myWMSPurchaseOrderLine.SalesOrderLineNumber    = NAVAdapterUtils.NAVFormatString(myNAVLine.SalesOrderLineNumber.ToString(), 40);
                                myWMSPurchaseOrderLine.SalesOrderNumber        = NAVAdapterUtils.NAVFormatString(myNAVLine.SalesOrderNumber.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions1    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions1.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions2    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions2.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions3    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions3.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions4    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions4.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions5    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions5.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions6    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions6.ToString(), 40);
                                myWMSPurchaseOrderLine.SpecialInstructions7    = NAVAdapterUtils.NAVFormatString(myNAVLine.SpecialInstructions7.ToString(), 40);
                                myWMSPurchaseOrderLine.StockItemIndicator      = NAVAdapterUtils.NAVFormatStockItemIndicatorType(myNAVLine.StockItemIndicator.ToString());
                                myWMSPurchaseOrderLine.UnitOfMeasureMultiplier = NAVAdapterUtils.NAVFormatString(myNAVLine.UnitOfMeasureMultiplier.ToString(), 40);
                                myWMSPurchaseOrderLine.UnitOfMeasureText       = NAVAdapterUtils.NAVFormatString(myNAVLine.UnitOfMeasureText.ToString(), 40);
                                myWMSPurchaseOrderLine.UnitPrice               = NAVAdapterUtils.NAVFormatDecimal(myNAVLine.UnitPrice.ToString());
                                myWMSPurchaseOrderLine.UPC = NAVAdapterUtils.NAVFormatString(myNAVLine.UPC.ToString(), 40);
                                myWMSPurchaseOrderLine.VendorProductNumber = NAVAdapterUtils.NAVFormatString(myNAVLine.VendorProductNumber.ToString(), 40);
                                myWMSPurchaseOrderLine.Warehouse           = NAVAdapterUtils.NAVFormatString(myNAVLine.Warehouse.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF1     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF1.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF2     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF2.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF3     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF3.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF4     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF4.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF5     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF5.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF6     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF6.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF7     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF7.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF8     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF8.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF9     = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF9.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF10    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF10.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF11    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF11.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF12    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF12.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF13    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF13.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF14    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF14.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF15    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF15.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF16    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF16.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF17    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF17.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF18    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF18.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF19    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF19.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF20    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF20.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF21    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF21.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF22    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF22.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF23    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF23.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF24    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF24.ToString(), 40);
                                myWMSPurchaseOrderLine.IntegrationUDF25    = NAVAdapterUtils.NAVFormatString(myNAVLine.IntegrationUDF25.ToString(), 40);


                                myWMSRMAOrder.Lines.Add(myWMSPurchaseOrderLine);
                            }
                        }
                        catch (Exception exceptionRMALinesLvl)
                        {
                            //Error at RMA Lines Level
                            EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrders.Error", CompanyConfig.InstanceId, "Error: RMA Order Lines Level", new Variable("Error Sending to WMS", exceptionRMALinesLvl));
                            didFailureOccur = true;
                        }

                        //Add RMA (if succeeded) to List of RMAs
                        if (!didFailureOccur)
                        {
                            myWMSRMAOrders.Add(myWMSRMAOrder);
                            EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrders", CompanyConfig.InstanceId, "A1I -> Status Update -> NAV", new Variable("Status", "Sent to WMS"), new Variable("Purchase Order Number", NAVAdapterUtils.NAVFormatString(myNAVOrder.PurchaseOrderNumber.ToString(), 40)), new Variable("Entry No", NAVAdapterUtils.NAVFormatString(myNAVOrder.StagingID.ToString(), 40)));
                            //try
                            //{
                            //    // Call NAV Web Service | SentStatus
                            //    CompanyConfig.Instance.NavWebServiceInstance.SentStatus(NAVAdapterUtils.NAVFormatString(myNAVOrder.StagingID.ToString(), 40), "RH");
                            //    CompanyConfig.Instance.NavWebServiceInstance.Dispose();
                            //}
                            //catch (Exception ex1)
                            //{
                            //    EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrders.Error", CompanyConfig.InstanceId, "Error: A1I Entry No -> NAV", new Variable("Error Sending to WMS", ex1));
                            //}
                        }
                    }
                }
                catch (Exception exceptionCRLvl)
                {
                    //Error at Customer Return Level
                    EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrders.Error", CompanyConfig.InstanceId, "Error: Customer Return Level", new Variable("Error Sending to WMS", exceptionCRLvl));
                }
            }
            catch (Exception exceptionRMARootLvl)
            {
                //Error at RMA Root Level
                EventNotificationClient.Instance.PostMessage("NAV.Download.RMAOrders.Error", CompanyConfig.InstanceId, "Error: RMA Root Level", new Variable("Error Sending to WMS", exceptionRMARootLvl));
            }

            return(myWMSRMAOrders);
        }
Ejemplo n.º 3
0
        public static List <AdjustmentsCA> RetrieveFromNAV()
        {
            NAVComputerAdjustmentRoot myNAVComputerAdjustmentRoot = new NAVComputerAdjustmentRoot();
            List <AdjustmentsCA>      myWMSComputerAdjustments    = new List <AdjustmentsCA>();

            String myResult = String.Empty;

            try
            {
                AdjustmentsCA myWMSComputerAdjustment;

                // Call NAV Web Service | ExportComputerAdjustment
                myResult = CompanyConfig.Instance.NavWebServiceInstance.ExportComputerAdjustment(ref myNAVComputerAdjustmentRoot);
                EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Exported NAV Data",
                                                             new Variable("data", Utils.SerializeToString(myNAVComputerAdjustmentRoot)));

                //NAV Business Object | Code = CA
                NAVBusinessObjectCA myNAVBusinessObjectCA = myNAVComputerAdjustmentRoot.NAVBusinessObjectCA;

                //NAV Computer Adjustments | Processed = Ready to Send
                NAVComputerAdjustments myNAVComputerAdjustments = myNAVBusinessObjectCA.NAVComputerAdjustments;

                try
                {
                    if (myNAVComputerAdjustments.NAVCAInventory == null)
                    {
                        //There aren't any orders to process
                        myWMSComputerAdjustments = new List <AdjustmentsCA>();
                        return(myWMSComputerAdjustments);
                    }

                    // For each Receipt Header record in the queue
                    foreach (NAVCAInventory iNavCAInventory in myNAVComputerAdjustments.NAVCAInventory)
                    {
                        NAVCAItem iItem = new NAVCAItem();
                        iItem = iNavCAInventory.NAVCAItems.NAVCAItem;

                        myWMSComputerAdjustment = new AdjustmentsCA();

                        // Parse Computer Adjustment
                        myWMSComputerAdjustment.SVAStagingID = iItem.StagingID.ToString();
                        myWMSComputerAdjustment.Attribute1   = NAVAdapterUtils.NAVFormatString(iItem.Attribute1, 40);
                        myWMSComputerAdjustment.Attribute2   = NAVAdapterUtils.NAVFormatString(iItem.Attribute2, 40);
                        myWMSComputerAdjustment.Attribute3   = NAVAdapterUtils.NAVFormatString(iItem.Attribute3, 40);
                        myWMSComputerAdjustment.Attribute4   = NAVAdapterUtils.NAVFormatString(iItem.Attribute4, 40);
                        myWMSComputerAdjustment.Attribute5   = NAVAdapterUtils.NAVFormatString(iItem.Attribute5, 40);
                        myWMSComputerAdjustment.Attribute6   = NAVAdapterUtils.NAVFormatString(iItem.Attribute6, 40);
                        myWMSComputerAdjustment.Attribute7   = NAVAdapterUtils.NAVFormatString(iItem.Attribute7, 40);
                        myWMSComputerAdjustment.Attribute8   = NAVAdapterUtils.NAVFormatString(iItem.Attribute8, 40);
                        myWMSComputerAdjustment.Attribute9   = NAVAdapterUtils.NAVFormatString(iItem.Attribute9, 40);
                        myWMSComputerAdjustment.Attribute10  = NAVAdapterUtils.NAVFormatString(iItem.Attribute10, 40);

                        myWMSComputerAdjustment.BinLocation = NAVAdapterUtils.NAVFormatString(iItem.BinLocation, 40);
                        myWMSComputerAdjustment.ClientName  = NAVAdapterUtils.NAVFormatString(iItem.Clientname, 40);
                        myWMSComputerAdjustment.Comment     = NAVAdapterUtils.NAVFormatString(iItem.Comment, 40);
                        myWMSComputerAdjustment.Description = NAVAdapterUtils.NAVFormatString(iItem.Description, 100); // Changed to 100 characters for A1W 64 - iCepts 10/6/15
                        //    myWMSComputerAdjustment.FIFODate = NAVAdapterUtils.NAVFormatDateTime(iItem.FIFODate);
                        myWMSComputerAdjustment.Packsize     = NAVAdapterUtils.NAVFormatInt(iItem.Innerpack);
                        myWMSComputerAdjustment.PlusMinus    = (NAVAdapterUtils.NAVFormatDecimal(iItem.Quantity) < 0 ? "-" : "+");
                        myWMSComputerAdjustment.LicensePlate = NAVAdapterUtils.NAVFormatString(iItem.LicensePlate, 40);
                        myWMSComputerAdjustment.MaximumLevelOfReplenishment = NAVAdapterUtils.NAVFormatInt(iItem.MaximumLevelOfReplenishment);
                        myWMSComputerAdjustment.MinimumLevelOfReplenishment = NAVAdapterUtils.NAVFormatInt(iItem.MinimumLevelOfReplenishment);
                        myWMSComputerAdjustment.Packsize     = NAVAdapterUtils.NAVFormatInt(iItem.Packsize);
                        myWMSComputerAdjustment.PONumber     = NAVAdapterUtils.NAVFormatString(iItem.PONumber, 40);
                        myWMSComputerAdjustment.ProductClass = NAVAdapterUtils.NAVFormatString(iItem.ProductClass, 40);
                        myWMSComputerAdjustment.ProductCode  = NAVAdapterUtils.NAVFormatString(iItem.ProductCode, 40);
                        myWMSComputerAdjustment.Quantity     = Math.Abs(NAVAdapterUtils.NAVFormatDecimal(iItem.Quantity));
                        myWMSComputerAdjustment.ReceivingAttributeControl = NAVAdapterUtils.NAVFormatString(iItem.ReceivingAttributeControl, 40);
                        myWMSComputerAdjustment.ReservedStockFlag         = NAVAdapterUtils.NAVFormatString(iItem.ReservedStockFlag, 40);
                        //    myWMSComputerAdjustment.Subcode = NAVAdapterUtils.NAVFormatString(iItem.Subcode, 40);
                        myWMSComputerAdjustment.UnitOfMeasure = NAVAdapterUtils.NAVFormatString(iItem.UnitOfMeasure, 40);
                        myWMSComputerAdjustment.UPC           = NAVAdapterUtils.NAVFormatString(iItem.UPC, 40);

                        //Add Computer Adjustment (if succeeded) to List of Computer Adjustments
                        myWMSComputerAdjustments.Add(myWMSComputerAdjustment);
                        EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId,
                                                                     "A1I -> Status Update -> NAV", new Variable("Status", "Sent to WMS"),
                                                                     new Variable("Product Code", myWMSComputerAdjustment.ProductCode));
                        //try
                        //{
                        //    // Call NAV Web Service | SentStatus
                        //    CompanyConfig.Instance.NavWebServiceInstance.SentStatus(NAVAdapterUtils.NAVFormatString(iItem.StagingID.ToString(), 40), "CA");
                        //    CompanyConfig.Instance.NavWebServiceInstance.Dispose();
                        //}
                        //catch (Exception ex1)
                        //{
                        //    EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems.Error", CompanyConfig.InstanceId, "Error: A1I Entry No -> NAV", new Variable("Error Updating Status to NAV", ex1));
                        //}
                    }
                }
                catch (Exception exceptionCALvl)
                {
                    //Error with Computer Adjustment
                    EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments.Error", CompanyConfig.InstanceId,
                                                                 "Error: Computer Adjustment Level", new Variable("Error Sending to WMS", exceptionCALvl));
                }
            }
            catch (Exception exceptionCARootLvl)
            {
                //Error at Computer Adjustment Root Level
                EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments.Error", CompanyConfig.InstanceId,
                                                             "Error: Computer Adjustment Root Level", new Variable("Error Sending to WMS", exceptionCARootLvl),
                                                             new Variable("NAV Return Data", myNAVComputerAdjustmentRoot), new Variable("My Result", myResult));
            }

            return(myWMSComputerAdjustments);
        }
        public static List <InventoryItem> RetrieveFromNAV()
        {
            List <InventoryItem> myWMSItems = new List <InventoryItem>();
            String myResult = String.Empty;

            try
            {
                NAVInventoryItemRoot myNAVInventoryItemRoot = new NAVInventoryItemRoot();
                InventoryItem        myWMSItem;
                myWMSItem = new InventoryItem();

                // Call NAV Web Service | ExportInventoryItem
                myResult = CompanyConfig.Instance.NavWebServiceInstance.ExportInventoryItem(ref myNAVInventoryItemRoot);
                CompanyConfig.Instance.NavWebServiceInstance.Dispose();
                EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems", CompanyConfig.InstanceId, "Exported NAV Data",
                                                             new Variable("data", Utils.SerializeToString(myNAVInventoryItemRoot)));


                //NAV Business Object | Code = VA
                NAVBusinessObjectVA myNAVBusinessObjectVA = new NAVBusinessObjectVA();
                myNAVBusinessObjectVA = myNAVInventoryItemRoot.NAVBusinessObjectVA;

                //NAV Vendor Adjustments | Processed = Ready to Send
                NAVVendorAdjustments myNAVVendorAdjustments = new NAVVendorAdjustments();
                myNAVVendorAdjustments = myNAVBusinessObjectVA.NAVVendorAdjustments;

                if (myNAVVendorAdjustments.NAVVendorAdjustment == null)
                {
                    //There aren't any items to process
                    myWMSItems = new List <InventoryItem>();
                    return(myWMSItems);
                }

                // For each Vendor Adjustment record in the queue
                foreach (NAVVendorAdjustment myNAVVendorAdjustment in myNAVVendorAdjustments.NAVVendorAdjustment)
                {
                    NAVInventoryItems myNAVInventoryItems = new NAVInventoryItems();
                    myNAVInventoryItems = myNAVVendorAdjustment.NAVInventoryItems;

                    NAVInventoryItem myNAVItem = new NAVInventoryItem();
                    myNAVItem = myNAVInventoryItems.NAVInventoryItem;

                    EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems", CompanyConfig.InstanceId, "NAVVendorAdjustment",
                                                                 new Variable("data", Utils.SerializeToString(myNAVItem)), new Variable("desc", myNAVItem.Description.ToString()));

                    myWMSItem = new InventoryItem();

                    if (myNAVItem.ProductCode.Length > 0)
                    {
                        NAV.BusinessObjects.AttributeSet mySet = new NAV.BusinessObjects.AttributeSet();
                        mySet.Attribute1  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute1.ToString(), 40);
                        mySet.Attribute2  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute2.ToString(), 40);
                        mySet.Attribute3  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute3.ToString(), 40);
                        mySet.Attribute4  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute4.ToString(), 40);
                        mySet.Attribute5  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute5.ToString(), 40);
                        mySet.Attribute6  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute6.ToString(), 40);
                        mySet.Attribute7  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute7.ToString(), 40);
                        mySet.Attribute8  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute8.ToString(), 40);
                        mySet.Attribute9  = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute9.ToString(), 40);
                        mySet.Attribute10 = NAVAdapterUtils.NAVFormatString(myNAVItem.Attributes.Attribute10.ToString(), 40);
                        myWMSItem.Attributes.Add(mySet);

                        myWMSItem.AverageUnits               = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.AverageUnits.ToString());
                        myWMSItem.BeeLine                    = NAVAdapterUtils.NAVFormatString(myNAVItem.BeeLine.ToString(), 40);
                        myWMSItem.BinLocation                = NAVAdapterUtils.NAVFormatString(myNAVItem.Bin.ToString(), 40);
                        myWMSItem.Buyer                      = NAVAdapterUtils.NAVFormatString(myNAVItem.Buyer.ToString(), 40);
                        myWMSItem.BypassQuantity             = NAVAdapterUtils.NAVFormatInt(myNAVItem.BypassQuantity.ToString());
                        myWMSItem.CartonDef                  = NAVAdapterUtils.NAVFormatInt(myNAVItem.CartonDef.ToString());
                        myWMSItem.CartonSize                 = NAVAdapterUtils.NAVFormatString(myNAVItem.CartonSize.ToString(), 40);
                        myWMSItem.ClientName                 = NAVAdapterUtils.getClientName();
                        myWMSItem.CommodityCode              = NAVAdapterUtils.NAVFormatString(myNAVItem.CommodityCode.ToString(), 6);
                        myWMSItem.CountryofOrigin            = NAVAdapterUtils.NAVFormatString(myNAVItem.CountryOfOrigin.ToString(), 6);
                        myWMSItem.Cost                       = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.Cost.ToString());
                        myWMSItem.Cubage                     = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.Cubage.ToString());
                        myWMSItem.Description                = NAVAdapterUtils.NAVFormatString(myNAVItem.Description.ToString(), 100); // Changed to 100 characters for A1W 64 - iCepts 10/6/15
                        myWMSItem.EDPNum                     = NAVAdapterUtils.NAVFormatString(myNAVItem.EDPNum.ToString(), 40);
                        myWMSItem.ExpiryDateRequired         = NAVAdapterUtils.NAVFormatBoolean(myNAVItem.ExpiryDateRequired.ToString());
                        myWMSItem.FormalSize1.Height         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize1.Height.ToString());
                        myWMSItem.FormalSize1.Length         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize1.Length.ToString());
                        myWMSItem.FormalSize1.Weight         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize1.Weight.ToString());
                        myWMSItem.FormalSize1.Width          = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize1.Width.ToString());
                        myWMSItem.FormalSize2.Height         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize2.Height.ToString());
                        myWMSItem.FormalSize2.Length         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize2.Length.ToString());
                        myWMSItem.FormalSize2.Weight         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize2.Weight.ToString());
                        myWMSItem.FormalSize2.Width          = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize2.Width.ToString());
                        myWMSItem.FormalSize3.Height         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize3.Height.ToString());
                        myWMSItem.FormalSize3.Length         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize3.Length.ToString());
                        myWMSItem.FormalSize3.Weight         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize3.Weight.ToString());
                        myWMSItem.FormalSize3.Width          = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize3.Width.ToString());
                        myWMSItem.FormalSize4.Height         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize4.Height.ToString());
                        myWMSItem.FormalSize4.Length         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize4.Length.ToString());
                        myWMSItem.FormalSize4.Weight         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize4.Weight.ToString());
                        myWMSItem.FormalSize4.Width          = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize4.Width.ToString());
                        myWMSItem.FormalSize5.Height         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize5.Height.ToString());
                        myWMSItem.FormalSize5.Length         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize5.Length.ToString());
                        myWMSItem.FormalSize5.Weight         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize5.Weight.ToString());
                        myWMSItem.FormalSize5.Width          = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.FormalSize5.Width.ToString());
                        myWMSItem.GlobalCoreReservation      = NAVAdapterUtils.NAVFormatInt(myNAVItem.GlobalCoreReservation.ToString());
                        myWMSItem.HandleCode                 = NAVAdapterUtils.NAVFormatString(myNAVItem.HandleCode.ToString(), 40);
                        myWMSItem.Height                     = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.Height.ToString());
                        myWMSItem.Length                     = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.Length.ToString());
                        myWMSItem.LicensePlate               = NAVAdapterUtils.NAVFormatString(myNAVItem.LicensePlate.ToString(), 40);
                        myWMSItem.MaximumReplenishmentLevel1 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MaximumReplenishmentLevel1.ToString());
                        myWMSItem.MaximumReplenishmentLevel2 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MaximumReplenishmentLevel2.ToString());
                        myWMSItem.MaximumReplenishmentLevel3 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MaximumReplenishmentLevel3.ToString());
                        myWMSItem.MaximumReplenishmentLevel4 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MaximumReplenishmentLevel4.ToString());
                        myWMSItem.MaximumReplenishmentLevel5 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MaximumReplenishmentLevel5.ToString());
                        myWMSItem.MinimumDaysToExpiry        = NAVAdapterUtils.NAVFormatString(myNAVItem.MinimumDaysToExpiry.ToString(), 40);
                        myWMSItem.MinimumReplenishmentLevel1 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MinimumReplenishmentLevel1.ToString());
                        myWMSItem.MinimumReplenishmentLevel2 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MinimumReplenishmentLevel2.ToString());
                        myWMSItem.MinimumReplenishmentLevel3 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MinimumReplenishmentLevel3.ToString());
                        myWMSItem.MinimumReplenishmentLevel4 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MinimumReplenishmentLevel4.ToString());
                        myWMSItem.MinimumReplenishmentLevel5 = NAVAdapterUtils.NAVFormatInt(myNAVItem.MinimumReplenishmentLevel5.ToString());
                        myWMSItem.OrderGroup                 = NAVAdapterUtils.NAVFormatString(myNAVItem.OrderGroup.ToString(), 40);
                        myWMSItem.OverReceiptPercentage      = NAVAdapterUtils.NAVFormatString(myNAVItem.OverReceivePercent.ToString(), 40);
                        myWMSItem.PackClass                  = NAVAdapterUtils.NAVFormatString(myNAVItem.PackClass.ToString(), 40);
                        myWMSItem.PacksizePrecision          = NAVAdapterUtils.NAVFormatInt(myNAVItem.DecimalPacksizePrecision.ToString());
                        myWMSItem.PickAttributeTracking.Attribute1Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute1Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute2Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute2Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute3Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute3Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute4Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute4Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute5Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute5Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute6Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute6Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute7Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute7Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute8Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute8Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute9Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute9Tracking.ToString());
                        myWMSItem.PickAttributeTracking.Attribute10Tracking = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.PickAttributeTracking.Attribute10Tracking.ToString());
                        myWMSItem.ProductClass      = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductClass.ToString(), 40);
                        myWMSItem.ProductCode       = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductCode.ToString(), 40);
                        myWMSItem.ProductUDF1       = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductUDF1.ToString(), 40);
                        myWMSItem.ProductUDF2       = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductUDF2.ToString(), 40);
                        myWMSItem.ProductUDF3       = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductUDF3.ToString(), 40);
                        myWMSItem.ProductUDF4       = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductUDF4.ToString(), 40);
                        myWMSItem.ProductUDF5       = NAVAdapterUtils.NAVFormatString(myNAVItem.ProductUDF5.ToString(), 40);
                        myWMSItem.QuantityAvailable = NAVAdapterUtils.NAVFormatInt(myNAVItem.QuantityAvailable.ToString());
                        myWMSItem.QuantityPrecision = NAVAdapterUtils.NAVFormatInt(myNAVItem.DecimalQtyPrecision.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute1Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute1Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute2Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute2Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute3Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute3Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute4Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute4Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute5Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute5Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute6Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute6Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute7Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute7Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute8Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute8Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute9Tracking  = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute9Tracking.ToString());
                        myWMSItem.ReceiveAttributeTracking.Attribute10Tracking = NAVAdapterUtils.NAVFormatTrackingType(myNAVItem.ReceiveAttributeTracking.Attribute10Tracking.ToString());
                        myWMSItem.ReorderPoint        = NAVAdapterUtils.NAVFormatInt(myNAVItem.ReorderPoint.ToString());
                        myWMSItem.RetailPrice         = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.RetailPrice.ToString());
                        myWMSItem.Size1               = NAVAdapterUtils.NAVFormatInt(myNAVItem.Size1.ToString());
                        myWMSItem.Size1ItemType       = NAVAdapterUtils.NAVFormatString(myNAVItem.Size1ItemType.ToString(), 40);
                        myWMSItem.Size2               = NAVAdapterUtils.NAVFormatInt(myNAVItem.Size2.ToString());
                        myWMSItem.Size2ItemType       = NAVAdapterUtils.NAVFormatString(myNAVItem.Size2ItemType.ToString(), 40);
                        myWMSItem.Size3               = NAVAdapterUtils.NAVFormatInt(myNAVItem.Size3.ToString());
                        myWMSItem.Size3ItemType       = NAVAdapterUtils.NAVFormatString(myNAVItem.Size3ItemType.ToString(), 40);
                        myWMSItem.Size4               = NAVAdapterUtils.NAVFormatInt(myNAVItem.Size4.ToString());
                        myWMSItem.Size4ItemType       = NAVAdapterUtils.NAVFormatString(myNAVItem.Size4ItemType.ToString(), 40);
                        myWMSItem.Size5               = NAVAdapterUtils.NAVFormatInt(myNAVItem.Size5.ToString());
                        myWMSItem.Size5ItemType       = NAVAdapterUtils.NAVFormatString(myNAVItem.Size5ItemType.ToString(), 40);
                        myWMSItem.SVAStagingID        = myNAVItem.StagingID.ToString();
                        myWMSItem.SupplierType        = NAVAdapterUtils.NAVFormatString(myNAVItem.SupplierType.ToString(), 40);
                        myWMSItem.TariffCode          = NAVAdapterUtils.NAVFormatString(myNAVItem.TariffCode.ToString(), 10);
                        myWMSItem.UPC                 = NAVAdapterUtils.NAVFormatString(myNAVItem.UPC.ToString(), 40);
                        myWMSItem.VendorNumber        = NAVAdapterUtils.NAVFormatString(myNAVItem.VendorNumber.ToString(), 40);
                        myWMSItem.VendorProductNumber = NAVAdapterUtils.NAVFormatString(myNAVItem.VendorProductCode.ToString(), 40);
                        myWMSItem.Weight              = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.Weight.ToString());
                        myWMSItem.WholesalePacksize   = NAVAdapterUtils.NAVFormatInt(myNAVItem.WholesalePackSize.ToString());
                        myWMSItem.Width               = NAVAdapterUtils.NAVFormatDecimal(myNAVItem.Width.ToString());

                        myWMSItems.Add(myWMSItem);
                        EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems", CompanyConfig.InstanceId, "A1I -> Status Update -> NAV", new Variable("Status", "Sent to WMS"), new Variable("Product Code", NAVAdapterUtils.NAVFormatString(myNAVItem.ProductCode.ToString(), 40)), new Variable("Entry No", NAVAdapterUtils.NAVFormatString(myNAVItem.StagingID.ToString(), 40)));
                        try
                        {
                            // Call NAV Web Service | SentStatus
                            CompanyConfig.Instance.NavWebServiceInstance.SentStatus(NAVAdapterUtils.NAVFormatString(myNAVItem.StagingID.ToString(), 40), "VA");
                            CompanyConfig.Instance.NavWebServiceInstance.Dispose();
                        }
                        catch (Exception ex1)
                        {
                            EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems.Error", CompanyConfig.InstanceId, "Error: A1I Entry No -> NAV", new Variable("Error Sending to WMS", ex1));
                        }
                    }
                }
            }
            catch (Exception ex1)
            {
                EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems.Error", CompanyConfig.InstanceId, "Error", new Variable("Error Message", ex1));

                try
                {
                    if (myWMSItems.Count == 0)
                    {
                        myWMSItems = new List <InventoryItem>();
                    }
                }
                catch (Exception ex)
                {
                    EventNotificationClient.Instance.PostMessage("NAV.Download.InventoryItems.Error", CompanyConfig.InstanceId, "Error", new Variable("XMLPort Result Message", myResult), new Variable("Error Message", ex));
                    myWMSItems = new List <InventoryItem>();
                }
                return(myWMSItems);
            }
            return(myWMSItems);
        }
Ejemplo n.º 5
0
        public static List <AdjustmentsCA> RetrieveFromFile(string filepath)
        {
            List <AdjustmentsCA> myWMSComputerAdjustments = new List <AdjustmentsCA>();
            AdjustmentsCA        myWMSComputerAdjustment;

            XmlTextReader xmlReadCA = new XmlTextReader(filepath);

            xmlReadCA.WhitespaceHandling = WhitespaceHandling.None;

            try
            {
                xmlReadCA.Read();
                //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                if (xmlReadCA.NodeType != XmlNodeType.XmlDeclaration)
                {
                    throw new Exception("Xml Declaration Node Missing!");
                }

                xmlReadCA.Read();
                //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                if (xmlReadCA.Name != "NAVComputerAdjustmentRoot")
                {
                    throw new Exception("NAVComputerAdjustmentRoot Node Missing!");
                }

                xmlReadCA.Read();
                //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                if (xmlReadCA.Name != "NAVBusinessObjectCA")
                {
                    throw new Exception("NAVBusinessObjectCA Node Missing!");
                }

                xmlReadCA.Read();
                //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                if (xmlReadCA.Name != "NAVComputerAdjustments")
                {
                    throw new Exception("NAVComputerAdjustments Node Missing!");
                }

                if (xmlReadCA.IsEmptyElement)
                {
                    //There aren't any orders to process
                    xmlReadCA.Close();

                    myWMSComputerAdjustments = new List <AdjustmentsCA>();
                    return(myWMSComputerAdjustments);
                }

                xmlReadCA.Read();
                //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                if (xmlReadCA.Name != "NAVCAInventory")
                {
                    throw new Exception("NAVCAInventory Node Missing!");
                }

                while (xmlReadCA.Name == "NAVCAInventory")
                {
                    xmlReadCA.Read();
                    //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                    //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                    if (xmlReadCA.Name != "NAVCAItems")
                    {
                        throw new Exception("NAVCAItems Node Missing!");
                    }

                    xmlReadCA.Read();
                    //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node Information",
                    //        new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                    if (xmlReadCA.Name != "NAVCAItem")
                    {
                        throw new Exception("NAVCAItem Node Missing!");
                    }

                    myWMSComputerAdjustment = new AdjustmentsCA();

                    xmlReadCA.Read();
                    //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Element Node Info",
                    //    new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));

                    while (xmlReadCA.Name != "NAVCAItem")
                    {
                        if (xmlReadCA.NodeType == XmlNodeType.Element)
                        {
                            string elementName = xmlReadCA.Name;

                            xmlReadCA.Read();
                            //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Text Node Info",
                            //    new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));

                            if (xmlReadCA.NodeType == XmlNodeType.Text)
                            {
                                switch (elementName.ToLower())                                                                        //6.4 Added ToLower
                                {
                                case "adjustmentsubcode":                                                                             //6.4 Subcode --> adjustmentsubcode
                                    myWMSComputerAdjustment.AdjustmentSubcode = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40); //6.4 Subcode --> AdjustmentSubcode
                                    break;

                                case "attribute1":      //6.4 Attribute1 --> attribute1
                                    myWMSComputerAdjustment.Attribute1 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute2":      //6.4 Attribute2 --> attribute2
                                    myWMSComputerAdjustment.Attribute2 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute3":      //6.4 Attribute3 --> attribute3
                                    myWMSComputerAdjustment.Attribute3 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute4":      //6.4 Attribute4 --> attribute4
                                    myWMSComputerAdjustment.Attribute4 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute5":      //6.4 Attribute5 --> attribute5
                                    myWMSComputerAdjustment.Attribute5 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute6":      //6.4 Attribute6 --> attribute6
                                    myWMSComputerAdjustment.Attribute6 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute7":      //6.4 Attribute7 --> attribute7
                                    myWMSComputerAdjustment.Attribute7 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute8":      //6.4 Attribute8 --> attribute8
                                    myWMSComputerAdjustment.Attribute8 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute9":      //6.4 Attribute9 --> attribute9
                                    myWMSComputerAdjustment.Attribute9 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "attribute10":     //6.4 Attribute10 --> attribute10
                                    myWMSComputerAdjustment.Attribute10 = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "bin":     //6.4 BinLocation --> bin
                                    myWMSComputerAdjustment.BinLocation = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "clientname":                                                        //6.4 Clientname --> clientname
                                    myWMSComputerAdjustment.ClientName = NAVAdapterUtils.getClientName(); //6.4 Clientname --> ClientName, NAVFormatString --> NAVAdapterUtils.getClientName()
                                    break;

                                case "comment":     //6.4 Comment --> comment
                                    myWMSComputerAdjustment.Comment = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "description":     //6.4 Description --> description
                                    myWMSComputerAdjustment.Description = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "fifodate":        //6.4 FIFODate --> fifodate
                                    myWMSComputerAdjustment.FIFODate = NAVAdapterUtils.NAVFormatDateTime(xmlReadCA.Value);
                                    break;

                                case "innerpack":                                                                      //6.4 Innerpack --> innerpack
                                    myWMSComputerAdjustment.InnerPack = NAVAdapterUtils.NAVFormatInt(xmlReadCA.Value); //6.4 Innerpack --> InnerPack
                                    break;

                                case "licenseplate":        //6.4 LicensePlate --> licenseplate
                                    myWMSComputerAdjustment.LicensePlate = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "maximumlevelofreplenishment":     //6.4 MaximumLevelOfReplenishment --> maximumlevelofreplenishment
                                    myWMSComputerAdjustment.MaximumLevelOfReplenishment = NAVAdapterUtils.NAVFormatInt(xmlReadCA.Value);
                                    break;

                                case "minimumlevelofreplenishment":     //6.4 MinimumLevelOfReplenishment --> minimumlevelofreplenishment
                                    myWMSComputerAdjustment.MinimumLevelOfReplenishment = NAVAdapterUtils.NAVFormatInt(xmlReadCA.Value);
                                    break;

                                case "packsize":        //6.4 Packsize --> packsize
                                    myWMSComputerAdjustment.Packsize = NAVAdapterUtils.NAVFormatInt(xmlReadCA.Value);
                                    break;

                                case "ponumber":        //6.4 PONumber --> ponumber
                                    myWMSComputerAdjustment.PONumber = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "productclass":        //6.4 ProductClass --> productclass
                                    myWMSComputerAdjustment.ProductClass = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "productcode":     //6.4 ProductCode --> productcode
                                    myWMSComputerAdjustment.ProductCode = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "quantity":        //6.4 Quantity --> quantity
                                    myWMSComputerAdjustment.Quantity = NAVAdapterUtils.NAVFormatDecimal(xmlReadCA.Value);
                                    //   myWMSComputerAdjustment.PlusMinus = (myWMSComputerAdjustment.Quantity < 0 ? '-' : '+'); //6.4 InOrOut --> PlusMinus, "-" --> '-', "+" --> '+'
                                    myWMSComputerAdjustment.Quantity = Math.Abs(myWMSComputerAdjustment.Quantity);
                                    break;

                                case "receivingattributecontrol":       //6.4 ReceivingAttributeControl --> receivingattributecontrol
                                    myWMSComputerAdjustment.ReceivingAttributeControl = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "reservedstockflag":       //6.4 ReservedStockFlag --> reservedstockflag
                                    // myWMSComputerAdjustment.ReservedStockFlag = NAVAdapterUtils.NAVFormatChar(xmlReadCA.Value); //6.4 NAVFormatString --> NAVFormatChar
                                    break;

                                case "unitofmeasure":       //6.4 UnitOfMeasure --> unitofmeasure
                                    myWMSComputerAdjustment.UnitOfMeasure = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                case "upc":     //6.4 UPC --> upc
                                    myWMSComputerAdjustment.UPC = NAVAdapterUtils.NAVFormatString(xmlReadCA.Value, 40);
                                    break;

                                default:
                                    throw new Exception("Not a supported tag type!");
                                }
                            }
                            else
                            {
                                //Continue the loop because the data we have may be the next element
                                //and we don't want to read the next line of data till we test the
                                //current element
                                continue;
                            }
                        }

                        //Get next value (if there is one)
                        xmlReadCA.Read();
                        //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node information",
                        //    new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                    }

                    if (myWMSComputerAdjustment.Quantity != 0)  //If no quantity to adjust, ignore. (NAV doesn't handle this filter well)
                    {
                        //Add Computer Adjustment to List of Computer Adjustments
                        myWMSComputerAdjustments.Add(myWMSComputerAdjustment);
                        EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId,
                                                                     "A1I -> Status Update -> NAV", new Variable("Status", "Sent to WMS"),
                                                                     new Variable("Product Code", myWMSComputerAdjustment.ProductCode));
                    }
                    else
                    {
                        EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId,
                                                                     "Quantity 0, adjustment omitted.", new Variable("Bin", myWMSComputerAdjustment.BinLocation),
                                                                     new Variable("Product Code", myWMSComputerAdjustment.ProductCode));
                    }

                    //Get next item (if there is one)
                    while ((!(xmlReadCA.EOF)) && (xmlReadCA.NodeType == XmlNodeType.EndElement))
                    {
                        xmlReadCA.Read();
                        //EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments", CompanyConfig.InstanceId, "Node information",
                        //    new Variable("Name", xmlReadCA.Name), new Variable("Value", xmlReadCA.Value), new Variable("Type", xmlReadCA.NodeType));
                    }
                }
            }
            catch (Exception exception)
            {
                //Error with Computer Adjustment
                EventNotificationClient.Instance.PostMessage("NAV.Download.ComputerAdjustments.Error", CompanyConfig.InstanceId,
                                                             exception.Message, new Variable("Error Sending to WMS", exception));
            }

            xmlReadCA.Close();

            return(myWMSComputerAdjustments);
        }