コード例 #1
0
        public frmGetSalesInvoices(DataTable salesInvoiceRecords, CustomerOrderTransaction originalTransaction)
            : this()
        {
            if (salesInvoiceRecords == null)
            {
                throw new ArgumentNullException("salesInvoiceRecords");
            }
            if (originalTransaction == null)
            {
                throw new ArgumentNullException("originalTransaction");
            }

            Invoices = salesInvoiceRecords;

            // Copy the original order and clear all the items/charges.
            CustomerOrderTransaction returnTransaction = new CustomerOrderTransaction(originalTransaction, originalTransaction.ISalesOrder);

            SalesOrderActions.SetCustomerOrderDefaults(returnTransaction);
            returnTransaction.DeliveryMode          = originalTransaction.DeliveryMode;
            returnTransaction.RequestedDeliveryDate = originalTransaction.RequestedDeliveryDate;
            returnTransaction.SaleItems.Clear();
            returnTransaction.MiscellaneousCharges.Clear();
            returnTransaction.Mode       = CustomerOrderMode.Return;
            returnTransaction.LockPrices = true;

            // Clear deposit details from the Return because we simply return the full invoiced amount (deposit + payments) for the items,
            // and there is no way to allocate the actual deposit paid for individual lines on the transaction in the case of a partial return.
            returnTransaction.PrepaymentAmountOverridden = true;
            returnTransaction.PrepaymentAmountRequired   = 0.0m;

            this.Transaction = returnTransaction;
        }
コード例 #2
0
        /// <summary>
        /// Prompt for return reason code and add to transaction.
        /// </summary>
        /// <param name="customerOrderTransaction">Transaction to update.</param>
        private static void ProcessReturnReasonCodes(CustomerOrderTransaction customerOrderTransaction)
        {
            if (customerOrderTransaction == null)
            {
                NetTracer.Warning("customerOrderTransaction parameter is null");
                throw new ArgumentNullException("customerOrderTransaction");
            }

            // Process codes only if it is a return order and has items selected.
            if (customerOrderTransaction.Mode == CustomerOrderMode.Return &&
                customerOrderTransaction.SaleItems != null &&
                customerOrderTransaction.SaleItems.Count > 0)
            {
                string       selectedValue;
                DialogResult dialogResult = SalesOrder.InternalApplication.Services.Dialog.GenericLookup(
                    SalesOrder.GetReturnReasonCodes() as IList,
                    "Description",
                    ApplicationLocalizer.Language.Translate(99524), // Return Reason
                    "ReasonCodeId",
                    out selectedValue, null);

                if (dialogResult == DialogResult.OK)
                {
                    customerOrderTransaction.ReturnReasonCodeId = selectedValue;
                }
            }
        }
コード例 #3
0
        public OrderDetailsViewModel(
            CustomerOrderTransaction customerOrderTransaction,
            OrderDetailsSelection selectedMode)
        {
            this.SetTransaction(customerOrderTransaction);

            this.mode = selectedMode;

            DM.StoreDataManager storeDataManager = new DM.StoreDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            DM.EmployeeDataManager employeeDataManager = new DM.EmployeeDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            // Collection of all employees
            employees = new ReadOnlyCollection <DataEntity.Employee>(employeeDataManager.GetEmployees(ApplicationSettings.Terminal.StoreId));

            // Set the default minimum expiration date to tomorrow (but do not overwrite the current expiration date already set on the transaction)
            this.MinimumOrderExpirationDate = DateTime.Today.AddDays(1);

            // Use the actual, recalled, expiration date if it is older.
            // This is needed to prevent the UI from forcing the older date to snap to the minimum.
            if (this.MinimumOrderExpirationDate > this.OrderExpirationDate)
            {
                this.MinimumOrderExpirationDate = this.OrderExpirationDate;
            }

            // Set the default sales person to the currently logged in operator
            if (string.IsNullOrWhiteSpace(this.SalesPersonId))
            {
                this.SalesPersonId = LSRetailPosis.Settings.ApplicationSettings.Terminal.TerminalOperator.OperatorId;
            }
        }
コード例 #4
0
        public frmGetSalesInvoices(DataTable salesInvoiceRecords, CustomerOrderTransaction originalTransaction)
            : this()
        {
            if (salesInvoiceRecords == null)
            {
                throw new ArgumentNullException("salesInvoiceRecords");
            }
            if (originalTransaction == null)
            {
                throw new ArgumentNullException("originalTransaction");
            }

            Invoices = salesInvoiceRecords;

            // Copy the original order and clear all the items/charges.
            CustomerOrderTransaction returnTransaction = new CustomerOrderTransaction(originalTransaction, originalTransaction.ISalesOrder);

            SalesOrderActions.SetCustomerOrderDefaults(returnTransaction);
            returnTransaction.DeliveryMode          = originalTransaction.DeliveryMode;
            returnTransaction.RequestedDeliveryDate = originalTransaction.RequestedDeliveryDate;
            returnTransaction.SaleItems.Clear();
            returnTransaction.MiscellaneousCharges.Clear();
            returnTransaction.Mode       = CustomerOrderMode.Return;
            returnTransaction.LockPrices = true;

            this.Transaction = returnTransaction;
        }
コード例 #5
0
        /// <summary>
        /// Creates a <see cref="LineLevelInformationViewModel" object/>
        /// </summary>
        /// <param name="saleLineItem">Reference to the line item. It will be modified on Commit.</param>
        public LineLevelInformationViewModel(SaleLineItem saleLineItem, CustomerOrderTransaction custTransaction)
        {
            this.transaction = custTransaction;

            StoreDataManager storeDataManager = new StoreDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            this.deliveryStore = storeDataManager.GetStore(saleLineItem.DeliveryStoreNumber);

            this.saleLineItem       = saleLineItem;
            this.LineItemId         = saleLineItem.ItemId;
            this.Description        = saleLineItem.Description;
            this.Quantity           = saleLineItem.Quantity;
            this.DeliveryDate       = saleLineItem.DeliveryDate;
            this.ShippingAddress    = saleLineItem.ShippingAddress;
            this.ShippingMethodCode = saleLineItem.DeliveryMode != null ? saleLineItem.DeliveryMode.Code : string.Empty;

            // Since there is a difference between no shipping charge and a shipping charge of zero, we need to see if we have any shipping charges before summing them
            IEnumerable <Tax.MiscellaneousCharge> shippingCharges = saleLineItem.MiscellaneousCharges.Where(c => c.ChargeCode == ApplicationSettings.Terminal.ShippingChargeCode);

            if (shippingCharges.Any())
            {
                this.ShippingCharge = shippingCharges.Sum(c => c.Price);
            }

            // Check for delivery mode on line first, then header
            IDeliveryMode deliveryMode    = saleLineItem.DeliveryMode ?? custTransaction.DeliveryMode;
            bool          hasPickupCode   = deliveryMode != null && string.Equals(deliveryMode.Code, ApplicationSettings.Terminal.PickupDeliveryModeCode, StringComparison.OrdinalIgnoreCase);
            bool          hasDeliveryDate = saleLineItem.DeliveryDate.HasValue;

            // we have to do this because if hasPickupCode == false, that does not mean that IsShipping will be set to true
            this.IsPickup   = hasPickupCode && hasDeliveryDate;
            this.IsShipping = !hasPickupCode && hasDeliveryDate;
        }
コード例 #6
0
        public PickupInformationViewModel(CustomerOrderTransaction custTransaction)
        {
            this.transaction = custTransaction;

            // Get list of addresses
            storeDataManager = new DM.StoreDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            customerDataManager = new DM.CustomerDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            // Create a read-only collection
            stores = new ReadOnlyCollection <DataEntity.Store>(storeDataManager.GetStoresForPickup(SalesOrder.InternalApplication.Settings.Database.DataAreaID));

            // Load date
            if (custTransaction.RequestedDeliveryDate > DateTime.MinValue)
            {
                this.pickUpDate = custTransaction.RequestedDeliveryDate;
            }

            // Load store
            if (!string.IsNullOrWhiteSpace(custTransaction.WarehouseId))
            {
                this.selectedStore = storeDataManager.GetWarehouseStore(custTransaction.WarehouseId);
            }
            else
            {
                this.selectedStore = storeDataManager.GetStore(LSRetailPosis.Settings.ApplicationSettings.Terminal.StoreId);
            }
        }
コード例 #7
0
        private void btnEdit_Click(object sender, EventArgs e)
        {
            //Get order
            CustomerOrderTransaction cot = SalesOrderActions.GetCustomerOrder(this.SelectedSalesOrderId, this.SelectedOrderType, LSRetailPosis.Transaction.CustomerOrderMode.Edit);

            SalesOrderActions.ShowOrderDetails(cot, OrderDetailsSelection.ViewDetails);
            SetSelectedOrderAndClose(cot);
        }
コード例 #8
0
        private void btnReturn_Click(object sender, EventArgs e)
        {
            //Get the order from the grid
            CustomerOrderTransaction cot = SalesOrderActions.GetCustomerOrder(this.SelectedSalesOrderId, this.SelectedOrderType, LSRetailPosis.Transaction.CustomerOrderMode.Edit);

            //Now get an invoice from the order
            cot = SalesOrderActions.ReturnOrderInvoices(cot);
            SetSelectedOrderAndClose(cot);
        }
コード例 #9
0
        private void btnPickUp_Click(object sender, EventArgs e)
        {
            //Get order
            //set Mode = Pickup
            CustomerOrderTransaction cot = SalesOrderActions.GetCustomerOrder(this.SelectedSalesOrderId, this.SelectedOrderType, LSRetailPosis.Transaction.CustomerOrderMode.Pickup);

            SalesOrderActions.ShowOrderDetails(cot, OrderDetailsSelection.PickupOrder);
            SetSelectedOrderAndClose(cot);
        }
コード例 #10
0
 private void SetSelectedOrderAndClose(CustomerOrderTransaction transaction)
 {
     if (transaction != null)
     {
         this.SelectedOrder = transaction;
         this.DialogResult  = System.Windows.Forms.DialogResult.OK;
         Close();
     }
 }
コード例 #11
0
        public ItemDetailsViewModel(CustomerOrderTransaction customerOrderTransaction)
        {
            this.SetTransaction(customerOrderTransaction);

            // Create a collection of LineItemViewModels from each SaleLineItem
            viewModels = (from lineItem in this.Transaction.SaleItems.Where(i => !i.Voided)
                          select new LineItemViewModel(lineItem)).ToList <LineItemViewModel>();

            this.lineItems = new ReadOnlyCollection <LineItemViewModel>(viewModels);
        }
コード例 #12
0
        public PaymentHistoryViewModel(CustomerOrderTransaction customerOrderTransaction)
        {
            this.SetTransaction(customerOrderTransaction);

            // Create a collection of PaymentHistoryLineViewModels from each CustomerOrderPaymentHistory
            List <PaymentHistoryLineViewModel> viewModels = (from lineItem in this.Transaction.PaymentHistory
                                                             select new PaymentHistoryLineViewModel(lineItem, this.Transaction.OrderId)).ToList <PaymentHistoryLineViewModel>();

            payments = new ReadOnlyCollection <PaymentHistoryLineViewModel>(viewModels);
        }
コード例 #13
0
        private static void AddSalesItemToTransaction(string invoiceId, CustomerOrderTransaction transaction, StoreDataManager storeDataManager, InvoiceItem item)
        {
            // add item
            SaleLineItem lineItem = (SaleLineItem)
                                    SalesOrder.InternalApplication.BusinessLogic.Utility.CreateSaleLineItem(
                ApplicationSettings.Terminal.StoreCurrency,
                SalesOrder.InternalApplication.Services.Rounding,
                transaction);

            lineItem.Found                      = true;
            lineItem.ItemId                     = item.ItemId;
            lineItem.Description                = item.ProductName;
            lineItem.Quantity                   = item.Quantity;
            lineItem.ReturnQtyAllowed           = item.Quantity;
            lineItem.SalesOrderUnitOfMeasure    = item.Unit;
            lineItem.Price                      = item.Price;
            lineItem.NetAmount                  = item.NetAmount;
            lineItem.SalesTaxGroupId            = item.SalesTaxGroup;
            lineItem.TaxGroupId                 = item.ItemTaxGroup;
            lineItem.SalesMarkup                = item.SalesMarkup;
            lineItem.QuantityOrdered            = item.Quantity;
            lineItem.DeliveryMode               = storeDataManager.GetDeliveryMode(item.DeliveryMode);
            lineItem.DeliveryDate               = DateTime.Today;
            lineItem.DeliveryStoreNumber        = transaction.StoreId;
            lineItem.DeliveryWarehouse          = item.Warehouse;
            lineItem.SerialId                   = item.SerialId;
            lineItem.BatchId                    = item.BatchId;
            lineItem.ReturnInvoiceInventTransId = item.InventTransId;
            lineItem.ReturnInvoiceId            = invoiceId;
            // When we get price from a sales invoice in AX; this is THE price that we will use
            lineItem.ReceiptReturnItem = true;

            lineItem.Dimension.ColorId    = item.ColorId;
            lineItem.Dimension.SizeId     = item.SizeId;
            lineItem.Dimension.StyleId    = item.StyleId;
            lineItem.Dimension.ConfigId   = item.ConfigId;
            lineItem.Dimension.ColorName  = item.ColorName;
            lineItem.Dimension.SizeName   = item.SizeName;
            lineItem.Dimension.StyleName  = item.StyleName;
            lineItem.Dimension.ConfigName = item.ConfigName;

            // set discount, everything is converted into a LineDiscount
            if ((item.DiscountAmount != decimal.Zero) && (item.Quantity != decimal.Zero))
            {
                ILineDiscountItem lineDiscountItem = SalesOrder.InternalApplication
                                                     .BusinessLogic.Utility.CreateLineDiscountItem();
                lineDiscountItem.Amount = item.DiscountAmount;

                // this method takes the per item discount amount
                SalesOrder.InternalApplication.Services.Discount.AddLineDiscountAmount(lineItem, lineDiscountItem);
            }

            SalesOrder.InternalApplication.Services.Item.ProcessItem(lineItem);
            transaction.Add(lineItem);
        }
コード例 #14
0
        /// <summary>
        /// Get a sales order or quote by id
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="orderType"></param>
        /// <returns></returns>
        internal static CustomerOrderTransaction GetCustomerOrder(string orderId, CustomerOrderType orderType, CustomerOrderMode forMode)
        {
            CustomerOrderTransaction result = null;
            IRetailTransaction       order;
            bool   retValue = false;
            string comment;

            //Verify that the user has rights to EDIT an order, and prompt for access.
            if (!SalesOrder.InternalApplication.Services.LogOn.VerifyOperationAccess(SalesOrder.InternalApplication.Shift.StaffId, PosisOperations.CustomerOrderDetails))
            {
                return(null);
            }

            switch (orderType)
            {
            case CustomerOrderType.SalesOrder:
                SalesOrder.InternalApplication.Services.SalesOrder.GetCustomerOrder(
                    ref retValue, orderId, out comment, out order);
                break;

            case CustomerOrderType.Quote:
                SalesOrder.InternalApplication.Services.SalesOrder.GetCustomerQuote(
                    ref retValue, orderId, out comment, out order);
                break;

            default:
                throw new InvalidOperationException("Unsupported CustomerOrderType");
            }

            if (retValue)
            {
                // Cache the order
                CustomerOrderTransaction customerOrder = (CustomerOrderTransaction)order;
                customerOrder.Mode = forMode;

                if (forMode == CustomerOrderMode.Cancel)
                {
                    AddDefaultCancellationCharge(customerOrder);
                }

                customerOrder.CalcTotals();

                result = customerOrder;
            }
            else
            {
                // The sales order was not found in AX
                ApplicationLog.Log(SalesOrderActions.LogSource,
                                   string.Format("{0}\n{1}", ApplicationLocalizer.Language.Translate(56124), comment),
                                   LogTraceLevel.Error);
                SalesOrder.InternalApplication.Services.Dialog.ShowMessage(56124, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            return(result);
        }
コード例 #15
0
        internal static void WarnAndFlagForRecalculation(CustomerOrderTransaction trans)
        {
            if (trans.ExpirationDate.Date < DateTime.Now.Date)
            {
                // show warning
                SalesOrder.InternalApplication.Services.Dialog.ShowMessage(56300, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);

                // unlock prices so that they will recalculate
                RecalculatePrices(trans);
            }
        }
コード例 #16
0
        private void SetSelectedOrderAndClose(CustomerOrderTransaction transaction)
        {
            if (transaction == null)
            {
                return;
            }

            this.UpdateSerialNumbers(transaction);
            this.SelectedOrder = transaction;
            this.DialogResult  = DialogResult.OK;
            this.Close();
        }
コード例 #17
0
        internal static CustomerOrderTransaction GetTransactionFromInvoice(InvoiceJournal invoice)
        {
            CustomerOrderTransaction transaction = (CustomerOrderTransaction)
                                                   SalesOrder.InternalApplication.BusinessLogic.Utility.CreateCustomerOrderTransaction(
                ApplicationSettings.Terminal.StoreId,
                ApplicationSettings.Terminal.StoreCurrency,
                ApplicationSettings.Terminal.TaxIncludedInPrice,
                SalesOrder.InternalApplication.Services.Rounding,
                SalesOrder.InternalApplication.Services.SalesOrder);

            // Get all the defaults
            SalesOrder.InternalApplication.BusinessLogic.TransactionSystem.LoadTransactionStatus(transaction);

            //General header properties
            transaction.OrderId           = invoice.SalesId;
            transaction.OrderType         = CustomerOrderType.SalesOrder;
            transaction.QuotationId       = invoice.SalesId;
            transaction.OriginalOrderType = CustomerOrderType.SalesOrder;

            transaction.OrderStatus = SalesStatus.Created;
            transaction.LockPrices  = true;

            transaction.ExpirationDate        = DateTime.Today;
            transaction.RequestedDeliveryDate = DateTime.Today;
            transaction.BeginDateTime         = DateTime.Now;
            transaction.Comment = string.Empty;

            StoreDataManager storeDataManager = new StoreDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            // Customer info
            ICustomer customer = SalesOrder.InternalApplication.BusinessLogic.CustomerSystem
                                 .GetCustomerInfo(invoice.InvoiceAccount);

            SalesOrder.InternalApplication.BusinessLogic.CustomerSystem
            .SetCustomer(transaction, customer, customer);

            // Items
            foreach (InvoiceItem item in invoice.Items)
            {
                AddSalesItemToTransaction(
                    invoice.InvoiceId,
                    transaction,
                    storeDataManager,
                    item);
            }

            SalesOrder.InternalApplication.BusinessLogic.ItemSystem.CalculatePriceTaxDiscount(transaction);
            transaction.CalculateAmountDue();

            return(transaction);
        }
コード例 #18
0
        private static void CloseOrder(ICustomerOrderTransaction transaction)
        {
            CustomerOrderTransaction cot = transaction as CustomerOrderTransaction;

            if (cot == null)
            {
                NetTracer.Warning("CustomerOrderTransaction is null");
                throw new ArgumentNullException("CustomerOrderTransaction");
            }

            cot.EntryStatus = PosTransaction.TransactionStatus.Cancelled;
        }
コード例 #19
0
        /// <summary>
        /// Add the default cancellation charge configured for this store
        /// </summary>
        /// <param name="transaction"></param>
        private static void AddDefaultCancellationCharge(CustomerOrderTransaction transaction)
        {
            Contracts.IApplication app = SalesOrder.InternalApplication;

            Tax.MiscellaneousCharge charge = transaction.MiscellaneousCharges.SingleOrDefault(
                m => string.Equals(m.ChargeCode, ApplicationSettings.Terminal.CancellationChargeCode, StringComparison.OrdinalIgnoreCase));

            // if there is not already a charge on this order, then attempt to add the default charge
            if (charge == null && transaction.OrderType == CustomerOrderType.SalesOrder)
            {
                // Get Cancellation charge properties from DB
                StoreDataManager store = new StoreDataManager(
                    app.Settings.Database.Connection,
                    app.Settings.Database.DataAreaID);

                DataEntity.MiscellaneousCharge chargeProperties = store.GetMiscellaneousCharge(
                    ApplicationSettings.Terminal.CancellationChargeCode);

                if (chargeProperties != null)
                {
                    // Compute the default charge rate
                    decimal chargePercent = ApplicationSettings.Terminal.CancellationCharge;
                    decimal chargeAmount  = decimal.Zero;

                    if (chargePercent >= decimal.Zero)
                    {
                        chargeAmount = (transaction.NetAmountWithTaxAndCharges * chargePercent) / 100m;
                        chargeAmount = app.Services.Rounding.Round(chargeAmount, transaction.StoreCurrencyCode);
                    }

                    // construct and add the new charge
                    charge = (Tax.MiscellaneousCharge)app.BusinessLogic.Utility.CreateMiscellaneousCharge(
                        chargeAmount,
                        transaction.Customer.SalesTaxGroup,
                        chargeProperties.TaxItemGroup,
                        chargeProperties.MarkupCode,
                        string.Empty,
                        transaction);

                    // Set the proper SalesTaxGroup based on the store/customer settings
                    SalesOrder.InternalApplication.BusinessLogic.CustomerSystem.ResetCustomerTaxGroup(charge);
                    transaction.MiscellaneousCharges.Add(charge);
                }
                else
                {
                    NetTracer.Information("chargeProperties is null");
                }
            }
        }
コード例 #20
0
        private void btnCancelOrder_Click(object sender, EventArgs e)
        {
            //Get order
            //set Mode = Cancel
            CustomerOrderTransaction cot = SalesOrderActions.GetCustomerOrder(this.SelectedSalesOrderId, this.SelectedOrderType, LSRetailPosis.Transaction.CustomerOrderMode.Cancel);

            if (cot.OrderStatus == SalesStatus.Processing)
            {
                //Order cannot be cancelled at this time from POS
                SalesOrder.InternalApplication.Services.Dialog.ShowMessage(56237, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            SalesOrderActions.ShowOrderDetails(cot, OrderDetailsSelection.CancelOrder);
            SetSelectedOrderAndClose(cot);
        }
コード例 #21
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="custTransaction">Transaction for this view model</param>
        /// <param name="saleLineItem">Sale line item for this view model if applicable</param>
        /// <remarks>If saleLineItem is not null then view model wraps line not transaction</remarks>
        public ShippingInformationViewModel(CustomerOrderTransaction custTransaction, SaleLineItem saleLineItem)
        {
            this.transaction     = custTransaction;
            this.lineItem        = saleLineItem;
            this.ShippingAddress = (saleLineItem == null) ? custTransaction.ShippingAddress : saleLineItem.ShippingAddress;

            // Load delivery date and set DeliveryDate property so validation is checked
            if (saleLineItem == null)
            {
                if (custTransaction.RequestedDeliveryDate > DateTime.MinValue)
                {
                    this.DeliveryDate = custTransaction.RequestedDeliveryDate;
                }
            }
            else
            {
                if (saleLineItem.DeliveryDate.HasValue && saleLineItem.DeliveryDate.Value > DateTime.MinValue)
                {
                    this.DeliveryDate = saleLineItem.DeliveryDate.Value;
                }
            }

            // Load delivery charge
            string shippingChargeCode = LSRetailPosis.Settings.ApplicationSettings.Terminal.ShippingChargeCode;

            Tax.MiscellaneousCharge mc = (saleLineItem == null)
                ? custTransaction.MiscellaneousCharges.SingleOrDefault(m => m.ChargeCode == shippingChargeCode)
                : lineItem.MiscellaneousCharges.SingleOrDefault(m => m.ChargeCode == shippingChargeCode);

            if (mc != null)
            {
                this.shippingCharge = mc.Price;
            }

            // Get list of addresses
            storeDataManager = new DM.StoreDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            // Create a read-only collection
            GetValidDeliveryModes();
            //deliveryModes = new ReadOnlyCollection<DeliveryModeExploded>(storeDataManager.GetDeliveryModes());

            // Load delivery method and set ShippingMethod property so validation is checked
            //this.ShippingMethod = (DeliveryMode)((saleLineItem == null) ? custTransaction.DeliveryMode : saleLineItem.DeliveryMode);
            this.ShippingMethod = new DeliveryModeExploded((DeliveryMode)((saleLineItem == null) ? custTransaction.DeliveryMode : saleLineItem.DeliveryMode));
        }
コード例 #22
0
        /// <summary>
        /// Updates serial numbers for items in transaction.
        /// </summary>
        /// <remarks>This function will ask user to confirm serial numbers for every sales line to be picked up in transaction.</remarks>
        /// <param name="transaction">The customer order transaction.</param>
        private void UpdateSerialNumbers(CustomerOrderTransaction transaction)
        {
            if (transaction == null)
            {
                return;
            }

            if (transaction.Mode == CustomerOrderMode.Pickup)
            {
                IEnumerable <SaleLineItem> pickupSaleItems = transaction.SaleItems.Where(
                    item => item.Quantity != 0 &&
                    ApplicationSettings.Terminal.PickupDeliveryModeCode.Equals(item.DeliveryMode.Code));

                foreach (var saleLineItem in pickupSaleItems)
                {
                    SalesOrder.InternalApplication.Services.Item.UpdateSerialNumberInfo(saleLineItem);
                }
            }
        }
コード例 #23
0
        private static void RecalculatePrices(ICustomerOrderTransaction transaction)
        {
            CustomerOrderTransaction cot = transaction as CustomerOrderTransaction;

            if (cot != null)
            {
                if (cot.OrderStatus == SalesStatus.Created || cot.OrderStatus == SalesStatus.Unknown)
                {
                    cot.LockPrices = false;
                    // discounts which already exist on the transaction could have been recalled from AX,
                    //  but we don't know which ones, so to avoid over-discounting, we remove all before recalculating the order
                    cot.ClearAllDiscounts();
                    SalesOrder.InternalApplication.BusinessLogic.ItemSystem.CalculatePriceTaxDiscount(transaction);
                }
                else
                {
                    //Operation is not allowed for the current order status.
                    SalesOrder.InternalApplication.Services.Dialog.ShowMessage(56246);
                }
            }
        }
コード例 #24
0
        internal static ICustomerOrderTransaction ShowOrderDetailsOptions(ICustomerOrderTransaction transaction)
        {
            using (formOrderDetailsSelection frm = new formOrderDetailsSelection())
            {
                ICustomerOrderTransaction result = transaction;
                POSFormsManager.ShowPOSForm(frm);
                if (frm.DialogResult == DialogResult.OK)
                {
                    // when in cancel mode, we only allow to enter view details, cancel or close order modes.
                    bool allowedOnCancelMode     = IsSelectionAllowedOnCancelOrderMode(frm.Selection);
                    CustomerOrderTransaction cot = transaction as CustomerOrderTransaction;

                    if (cot != null && cot.Mode == CustomerOrderMode.Cancel && !allowedOnCancelMode)
                    {
                        SalesOrder.InternalApplication.Services.Dialog.ShowMessage(4543);
                        return(result);
                    }

                    switch (frm.Selection)
                    {
                    case OrderDetailsSelection.ViewDetails:
                        SalesOrderActions.ShowOrderDetails(transaction, frm.Selection);
                        break;

                    case OrderDetailsSelection.CloseOrder:
                        CloseOrder(transaction);
                        break;

                    case OrderDetailsSelection.Recalculate:
                        RecalculatePrices(transaction);
                        break;

                    default:
                        break;
                    }
                }

                return(result);
            }
        }
コード例 #25
0
        internal static void ShowOrderDetails(ICustomerOrderTransaction transaction, OrderDetailsSelection selectionMode)
        {
            CustomerOrderTransaction cot = (CustomerOrderTransaction)transaction;

            using (formOrderDetails frm = new formOrderDetails(cot, selectionMode))
            {
                POSFormsManager.ShowPOSForm(frm);
                DialogResult result = frm.DialogResult;

                // Get updated transaction since nested operations might have been run
                transaction = frm.Transaction;

                if (result == DialogResult.OK)
                {
                    // Update the editing mode of the order.
                    UpdateCustomerOrderMode(cot, selectionMode);

                    // Refresh prices/totals
                    SalesOrder.InternalApplication.BusinessLogic.ItemSystem.CalculatePriceTaxDiscount(transaction);

                    // call CalcTotal to roll up misc charge taxes
                    transaction.CalcTotals();

                    // Reminder prompt for Deposit Override w/ Zero deposit applied
                    if (selectionMode == OrderDetailsSelection.PickupOrder &&
                        cot.PrepaymentAmountOverridden &&
                        cot.PrepaymentAmountApplied == decimal.Zero)
                    {
                        SalesOrder.InternalApplication.Services.Dialog.ShowMessage(56139, MessageBoxButtons.OK, MessageBoxIcon.Information);    //"No deposit has been applied to this pickup. To apply a deposit, use the ""Deposit override"" operation."
                    }
                }
                else
                {
                    // Set cancel on the transaction so the original is not updated
                    transaction.OperationCancelled = true;
                }
            }
        }
コード例 #26
0
        private static void UpdateCustomerOrderMode(CustomerOrderTransaction cot, OrderDetailsSelection selectionMode)
        {
            switch (selectionMode)
            {
            case OrderDetailsSelection.CancelOrder:
            {
                cot.Mode = CustomerOrderMode.Cancel;
            }
            break;

            case OrderDetailsSelection.ViewDetails:
            {
                // if the order was cancelled before, we shouldn't change this mode when just viewing the order.
                if (cot.Mode != CustomerOrderMode.Cancel)
                {
                    if (cot.OriginalOrderType == CustomerOrderType.Quote &&
                        cot.OrderType == CustomerOrderType.SalesOrder &&
                        !string.IsNullOrWhiteSpace(cot.QuotationId))
                    {
                        // Change mode to 'Convert', if user is converting a Quote to a SalesOrder
                        cot.Mode = CustomerOrderMode.Convert;
                    }
                    else if (cot.Mode == CustomerOrderMode.Convert)
                    {
                        // Change mode to 'Edit', if user converted from Quote to SalesOrder and then back to Quote.
                        cot.Mode = CustomerOrderMode.Edit;
                    }
                }
            }
            break;

            case OrderDetailsSelection.PickupOrder:     //Pickup mode has already been handled by the ItemDetailsPage on frmOrderDetails
            default:
                break;
            }
        }
コード例 #27
0
 public CustomerInformationViewModel(CustomerOrderTransaction customerTransaction)
 {
     this.SetTransaction(customerTransaction);
 }
コード例 #28
0
 public OrderSummaryViewModel(CustomerOrderTransaction customerOrderTransaction)
 {
     this.SetTransaction(customerOrderTransaction);
 }
コード例 #29
0
        internal static CustomerOrderInfo GetInfoFromTransaction(CustomerOrderTransaction customerOrder)
        {
            CustomerOrderInfo parameters = new CustomerOrderInfo();
            //GRW
            DAC       odac = new DAC(SalesOrder.InternalApplication.Settings.Database.Connection);
            DataTable dt   = odac.GetContactData(customerOrder.TransactionId, customerOrder.TerminalId, customerOrder.StoreId);

            if (dt.Rows.Count > 0)
            {
                parameters.CustName  = dt.Rows[0]["NAME"].ToString();
                parameters.CustPhone = dt.Rows[0]["PHONE"].ToString();
                parameters.Email     = dt.Rows[0]["EMAIL"].ToString();
            }
            //GRW
            parameters.OrderType      = customerOrder.OrderType;
            parameters.Id             = customerOrder.OrderId;
            parameters.TransactionId  = customerOrder.TransactionId;
            parameters.QuotationId    = customerOrder.OrderId;
            parameters.AutoPickOrder  = false;
            parameters.WarehouseId    = customerOrder.WarehouseId;
            parameters.CurrencyCode   = customerOrder.StoreCurrencyCode;
            parameters.StoreId        = customerOrder.StoreId;
            parameters.TerminalId     = customerOrder.TerminalId;
            parameters.LocalHourOfDay = customerOrder.LocalHourOfDay;

            parameters.AddressRecordId    = (customerOrder.ShippingAddress != null) ? customerOrder.ShippingAddress.AddressRecId : string.Empty;
            parameters.CustomerAccount    = (customerOrder.Customer != null) ? customerOrder.Customer.CustomerId : string.Empty;
            parameters.SalespersonStaffId = (customerOrder.SalesPersonId) ?? string.Empty;

            // The format must match the expected format in AX RetailTransactionService.CreateCustomerOrder: "dd/MM/yyyy"
            parameters.ExpiryDateString            = customerOrder.ExpirationDate.ToString(FixedDateFormat);
            parameters.RequestedDeliveryDateString = customerOrder.RequestedDeliveryDate.ToString(FixedDateFormat);
            parameters.DeliveryMode = customerOrder.DeliveryMode != null ? customerOrder.DeliveryMode.Code : string.Empty;
            parameters.PrepaymentAmountOverridden = customerOrder.PrepaymentAmountOverridden;
            parameters.PrepaymentAmountApplied    = customerOrder.NetAmountWithTaxAndCharges - customerOrder.AmountDue;

            parameters.TotalManualDiscountAmount     = customerOrder.TotalManualDiscountAmount;
            parameters.TotalManualDiscountPercentage = customerOrder.TotalManualPctDiscount;

            //parameters.Email = customerOrder.ReceiptEmailAddress;
            parameters.Comment            = ((IPosTransactionV1)customerOrder).Comment;
            parameters.ReturnReasonCodeId = customerOrder.ReturnReasonCodeId;
            parameters.LoyaltyCardId      = (customerOrder.LoyaltyItem != null) ?
                                            customerOrder.LoyaltyItem.LoyaltyCardNumber : string.Empty;

            // If we do not have the channel reference identifier, we create a new receipt identifier instead.
            parameters.ChannelReferenceId = customerOrder.ChannelReferenceId;

            parameters.CreditCardToken = customerOrder.CreditCardToken;

            // Discount codes
            parameters.DiscountCodes = new Collection <string>();
            foreach (string code in customerOrder.DiscountCodes)
            {
                parameters.DiscountCodes.Add(code);
            }

            // Line Items
            parameters.Items = new Collection <ItemInfo>();
            foreach (SaleLineItem item in customerOrder.SaleItems)
            {
                if (!item.Voided)
                {
                    string deliveryMode = parameters.DeliveryMode;
                    if (item.DeliveryMode != null)
                    {
                        deliveryMode = item.DeliveryMode.Code;
                    }

                    string deliveryDateString = parameters.RequestedDeliveryDateString;
                    if (item.DeliveryDate.HasValue)
                    {
                        deliveryDateString = item.DeliveryDate.Value.ToString(FixedDateFormat);
                    }

                    Collection <ChargeInfo> lineChargeInfo = new Collection <ChargeInfo>();
                    foreach (Tax.MiscellaneousCharge charge in item.MiscellaneousCharges)
                    {
                        lineChargeInfo.Add(new ChargeInfo()
                        {
                            Amount        = charge.Amount,
                            Code          = charge.ChargeCode,
                            SalesTaxGroup = charge.SalesTaxGroupId,
                            TaxGroup      = charge.TaxGroupId
                        });
                    }

                    // If no line-level warehouse is specified, fall back to the header warehouse
                    string inventLocationId = string.IsNullOrWhiteSpace(item.DeliveryWarehouse) ? customerOrder.WarehouseId : item.DeliveryWarehouse;

                    // AX SO line stores discount amount per item, POS stores for whole line, calculate per item discount amount
                    decimal lineDiscount = (item.Quantity == 0M ? 0M : (item.TotalDiscount + item.LineDiscount + item.PeriodicDiscount) / (item.Quantity));

                    // Save all discount lines per sales line
                    Collection <DiscountInfo> lineDiscountInfo = new Collection <DiscountInfo>();
                    foreach (DiscountItem discountLine in item.DiscountLines)
                    {
                        DiscountInfo discountInfo = new DiscountInfo();
                        discountInfo.DiscountCode            = string.Empty;
                        discountInfo.PeriodicDiscountOfferId = string.Empty;

                        discountInfo.EffectiveAmount = discountLine.EffectiveAmount;
                        discountInfo.DealPrice       = discountLine.DealPrice;
                        discountInfo.Percentage      = discountLine.Percentage;
                        discountInfo.DiscountAmount  = discountLine.Amount;

                        LineDiscountItem     lineDiscountItem;
                        PeriodicDiscountItem periodicDiscountItem;
                        CustomerDiscountItem customerDiscountItem;

                        if ((lineDiscountItem = discountLine as LineDiscountItem) != null)
                        {
                            discountInfo.DiscountOriginType = (int)lineDiscountItem.LineDiscountType;

                            if ((periodicDiscountItem = discountLine as PeriodicDiscountItem) != null)
                            {
                                discountInfo.PeriodicDiscountOfferId = periodicDiscountItem.OfferId;
                                discountInfo.DiscountCode            = periodicDiscountItem.DiscountCode;
                            }
                            else if ((customerDiscountItem = discountLine as CustomerDiscountItem) != null)
                            {
                                discountInfo.CustomerDiscountType = (int)customerDiscountItem.CustomerDiscountType;
                            }
                            else
                            {
                                discountInfo.DiscountOriginType = (int)LineDiscountItem.DiscountTypes.Manual;
                                discountInfo.ManualDiscountType = (int)discountLine.GetManualDiscountType();
                            }
                        }

                        if (discountLine is TotalDiscountItem)
                        {
                            discountInfo.DiscountOriginType = (int)LineDiscountItem.DiscountTypes.Manual;
                            discountInfo.ManualDiscountType = (int)discountLine.GetManualDiscountType();
                        }

                        lineDiscountInfo.Add(discountInfo);
                    }

                    parameters.Items.Add(new ItemInfo()
                    {
                        RecId = item.OrderLineRecordId,

                        //quantity
                        ItemId   = item.ItemId,
                        Quantity = item.Quantity,
                        Unit     = item.SalesOrderUnitOfMeasure,

                        //pricing
                        Price         = item.Price,
                        Discount      = lineDiscount,
                        NetAmount     = item.NetAmount,
                        ItemTaxGroup  = item.TaxGroupId,
                        SalesTaxGroup = item.SalesTaxGroupId,
                        SalesMarkup   = item.SalesMarkup,

                        PeriodicDiscount             = item.PeriodicDiscount,
                        LineDscAmount                = item.LineDiscount,
                        LineManualDiscountAmount     = item.LineManualDiscountAmount,
                        LineManualDiscountPercentage = item.LineManualDiscountPercentage,
                        TotalDiscount                = item.TotalDiscount,
                        TotalPctDiscount             = item.TotalPctDiscount,
                        PeriodicPercentageDiscount   = item.PeriodicPctDiscount,

                        //Comment
                        Comment = item.Comment,

                        //delivery
                        WarehouseId                 = inventLocationId,
                        AddressRecordId             = item.ShippingAddress != null ? item.ShippingAddress.AddressRecId : null,
                        DeliveryMode                = deliveryMode,
                        RequestedDeliveryDateString = deliveryDateString,

                        //inventDim
                        BatchId   = item.BatchId,
                        SerialId  = item.SerialId,
                        VariantId = item.Dimension.VariantId,
                        ColorId   = item.Dimension.ColorId,
                        SizeId    = item.Dimension.SizeId,
                        StyleId   = item.Dimension.StyleId,
                        ConfigId  = item.Dimension.ConfigId,

                        //Return
                        InvoiceId     = item.ReturnInvoiceId,
                        InventTransId = item.ReturnInvoiceInventTransId,

                        //line-level misc. charges
                        Charges = lineChargeInfo,

                        //line-level discounts
                        Discounts = lineDiscountInfo,
                    });
                }
            }

            // Header level Misc Charges
            parameters.Charges = new Collection <ChargeInfo>();
            foreach (Tax.MiscellaneousCharge charge in customerOrder.MiscellaneousCharges)
            {
                parameters.Charges.Add(new ChargeInfo()
                {
                    Code          = charge.ChargeCode,
                    Amount        = charge.Amount,
                    SalesTaxGroup = charge.SalesTaxGroupId,
                    TaxGroup      = charge.TaxGroupId
                });
            }
            string CardType = "";

            // Payments
            parameters.Payments = new Collection <PaymentInfo>();
            foreach (ITenderLineItem tender in customerOrder.TenderLines)
            {
                CardType = "";
                if (!tender.Voided)
                {
                    ICardTenderLineItem cardTender = tender as ICardTenderLineItem;
                    if (cardTender != null && cardTender.EFTInfo.IsAuthOnly)
                    {
                        // This is a Pre-Authorization record.
                        IEFTInfo eft = cardTender.EFTInfo;
                        parameters.Preauthorization = new Preauthorization()
                        {
                            PaymentPropertiesBlob = eft.PaymentProviderPropertiesXML
                        };
                    }
                    else if (tender.Amount != decimal.Zero)
                    {
                        // This is an actual payment record.
                        DAC odac2 = new DAC(ApplicationSettings.Database.LocalConnection);
                        CardType = odac2.getCardType(customerOrder.TransactionId, customerOrder.TerminalId, customerOrder.StoreId, tender.LineId, tender.TenderTypeId);

                        parameters.Payments.Add(new PaymentInfo()
                        {
                            PaymentType = tender.TenderTypeId,
                            Amount      = string.IsNullOrEmpty(tender.CurrencyCode) ? tender.Amount : tender.ForeignCurrencyAmount,
                            Currency    = (tender.CurrencyCode) ?? string.Empty,
                            CardType    = string.IsNullOrEmpty(CardType) ? "":CardType
                        });
                    }
                }
            }

            // Affiliations
            parameters.Affiliations = new Collection <AffiliationInfo>();
            foreach (IAffiliation affiliation in customerOrder.AffiliationLines)
            {
                parameters.Affiliations.Add(new AffiliationInfo()
                {
                    AffiliationId = affiliation.RecId,
                    LoyaltyTierId = affiliation.LoyaltyTier
                });
            }

            return(parameters);
        }
コード例 #30
0
        internal static CustomerOrderTransaction GetTransactionFromInfo(CustomerOrderInfo orderInfo, SalesOrder salesOrderService)
        {
            CustomerOrderTransaction transaction = (CustomerOrderTransaction)SalesOrder.InternalApplication.BusinessLogic.Utility.CreateCustomerOrderTransaction(
                ApplicationSettings.Terminal.StoreId,
                ApplicationSettings.Terminal.StoreCurrency,
                ApplicationSettings.Terminal.TaxIncludedInPrice,
                SalesOrder.InternalApplication.Services.Rounding,
                salesOrderService);

            // Get all the defaults
            SalesOrder.InternalApplication.BusinessLogic.TransactionSystem.LoadTransactionStatus(transaction);

            // General header properties
            transaction.OrderId   = orderInfo.Id;
            transaction.OrderType = orderInfo.OrderType;

            if (orderInfo.OrderType == CustomerOrderType.Quote)
            {
                transaction.QuotationId = orderInfo.Id;
            }

            transaction.OriginalOrderType = orderInfo.OrderType;

            switch (orderInfo.OrderType)
            {
            case CustomerOrderType.Quote:
                transaction.OrderStatus = GetSalesStatus((SalesQuotationStatus)orderInfo.Status);
                break;

            case CustomerOrderType.SalesOrder:
                transaction.OrderStatus = GetSalesStatus((SalesOrderStatus)orderInfo.Status, (DocumentStatus)orderInfo.DocumentStatus);
                break;

            default:
                transaction.OrderStatus = SalesStatus.Unknown;
                NetTracer.Information("SalesOrder::CustomerOrderTransaction: CustomerOrderInfo OrderType is unknown: {0}", orderInfo.OrderType);
                break;
            }

            transaction.LockPrices = true;

            transaction.ExpirationDate = ParseDateString(orderInfo.ExpiryDateString, DateTime.Today);

            // RequestedDeliveryDate is directly input from user. It is stored in the local timezone
            transaction.RequestedDeliveryDate = ParseDateString(orderInfo.RequestedDeliveryDateString, DateTime.Today);

            // CreationDate is stored in UTC. It needs to be converted to local time zone where order is accessed.
            ((IPosTransactionV2)transaction).BeginDateTime = ParseDateString(orderInfo.CreationDateString, DateTime.UtcNow, DateTimeStyles.AdjustToUniversal).ToLocalTime();
            transaction.LocalHourOfDay = orderInfo.LocalHourOfDay;

            ((IPosTransactionV2)transaction).Comment = orderInfo.Comment;

            // Header delivery
            DM.StoreDataManager storeDataManager = new DM.StoreDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            transaction.WarehouseId  = orderInfo.WarehouseId;
            transaction.DeliveryMode = storeDataManager.GetDeliveryMode(orderInfo.DeliveryMode);
            transaction.CurrencyCode = orderInfo.CurrencyCode;

            foreach (var code in orderInfo.DiscountCodes)
            {
                transaction.DiscountCodes.AddLast(code);
            }

            // Header affiliation
            DM.AffiliationDataManager affiliationDataManager = new DM.AffiliationDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            if (orderInfo.Affiliations != null && orderInfo.Affiliations.Any())
            {
                foreach (AffiliationInfo affiliationInfo in orderInfo.Affiliations)
                {
                    transaction.AffiliationLines.AddLast(
                        new AffiliationItem()
                    {
                        RecId           = affiliationInfo.AffiliationId,
                        LoyaltyTier     = affiliationInfo.LoyaltyTierId,
                        AffiliationType = affiliationInfo.AffiliationType
                    });
                }
            }

            // Customer info
            ICustomerSystem customerSystem = SalesOrder.InternalApplication.BusinessLogic.CustomerSystem;

            DM.CustomerDataManager customerDataManager = new DM.CustomerDataManager(
                SalesOrder.InternalApplication.Settings.Database.Connection,
                SalesOrder.InternalApplication.Settings.Database.DataAreaID);

            DE.ICustomer customer = customerSystem.GetCustomerInfo(orderInfo.CustomerAccount);

            // try to get the customer from transaction service
            if (customer == null || customer.IsEmptyCustomer())
            {
                DE.ICustomer tempCustomer = SalesOrder.GetCustomerFromAX(orderInfo.CustomerAccount, customerSystem, customerDataManager);
                if (tempCustomer != null)
                {
                    customer = tempCustomer;
                }
            }

            DE.ICustomer invoicedCustomer = customerSystem.GetCustomerInfo(customer.InvoiceAccount);

            // try to get the invoicedCustomer from transaction service
            if (invoicedCustomer == null || invoicedCustomer.IsEmptyCustomer())
            {
                DE.ICustomer tempinvoicedCustomer = SalesOrder.GetCustomerFromAX(customer.InvoiceAccount, customerSystem, customerDataManager);
                if (tempinvoicedCustomer != null)
                {
                    invoicedCustomer = tempinvoicedCustomer;
                }
            }

            // If InvoiceCustomer is *still* blank/empty then fallback to Customer so that the UI fields are populated.
            if (invoicedCustomer == null || invoicedCustomer.IsEmptyCustomer())
            {
                invoicedCustomer = customer;
            }

            customerSystem.SetCustomer(transaction, customer, invoicedCustomer);

            if (transaction.DeliveryMode != null && !string.IsNullOrWhiteSpace(orderInfo.AddressRecordId))
            {
                DE.IAddress shippingAddress = customerDataManager.GetAddress(Int64.Parse(orderInfo.AddressRecordId));
                customerSystem.SetShippingAddress(transaction, shippingAddress);
            }

            if (!string.IsNullOrEmpty(orderInfo.SalespersonStaffId))
            {
                // Sets the sales person id and name according to AX values
                // This is done because we do not know whether the sales person information is available on this store
                transaction.SalesPersonId   = orderInfo.SalespersonStaffId;
                transaction.SalesPersonName = orderInfo.SalespersonName;

                DM.EmployeeDataManager employees = new DM.EmployeeDataManager(
                    SalesOrder.InternalApplication.Settings.Database.Connection,
                    SalesOrder.InternalApplication.Settings.Database.DataAreaID);

                Employee employee = employees.GetEmployee(ApplicationSettings.Terminal.StoreId, orderInfo.SalespersonStaffId);
                if (employee != null)
                {
                    transaction.SalesPersonId            = employee.StaffId;
                    transaction.SalesPersonName          = employee.Name;
                    transaction.SalesPersonNameOnReceipt = employee.NameOnReceipt;
                }
            }

            transaction.ChannelReferenceId = orderInfo.ChannelReferenceId;
            if (transaction.LoyaltyItem != null && !string.IsNullOrEmpty(orderInfo.LoyaltyCardId))
            {
                transaction.LoyaltyItem.LoyaltyCardNumber = orderInfo.LoyaltyCardId;
            }

            transaction.ReceiptEmailAddress = orderInfo.Email;

            transaction.TotalManualDiscountAmount = orderInfo.TotalManualDiscountAmount;
            transaction.TotalManualPctDiscount    = orderInfo.TotalManualDiscountPercentage;

            DateTime earliestDeliveryDate = DateTime.MaxValue;

            // Items
            foreach (ItemInfo item in orderInfo.Items)
            {
                Collection <Tax.MiscellaneousCharge> lineCharges = new Collection <Tax.MiscellaneousCharge>();
                foreach (ChargeInfo charge in item.Charges)
                {
                    Tax.MiscellaneousCharge lineCharge = (Tax.MiscellaneousCharge)SalesOrder.InternalApplication.BusinessLogic.Utility.CreateMiscellaneousCharge(
                        charge.Amount, charge.SalesTaxGroup, charge.TaxGroup, charge.Code, string.Empty, transaction);
                    lineCharges.Add(lineCharge);
                }

                // add item
                SaleLineItem lineItem = (SaleLineItem)SalesOrder.InternalApplication.BusinessLogic.Utility.CreateSaleLineItem(
                    ApplicationSettings.Terminal.StoreCurrency,
                    SalesOrder.InternalApplication.Services.Rounding,
                    transaction);

                lineItem.Found                        = true;
                lineItem.OrderLineRecordId            = item.RecId;
                lineItem.ItemId                       = item.ItemId;
                lineItem.Quantity                     = item.Quantity;
                lineItem.ReturnQtyAllowed             = item.Quantity;
                lineItem.SalesOrderUnitOfMeasure      = item.Unit;
                lineItem.Price                        = item.Price;
                lineItem.NetAmount                    = item.NetAmount;
                lineItem.QuantityOrdered              = item.Quantity;
                lineItem.QuantityPickedUp             = item.QuantityPicked;
                lineItem.DeliveryMode                 = storeDataManager.GetDeliveryMode(item.DeliveryMode);
                lineItem.DeliveryDate                 = ParseDateString(item.RequestedDeliveryDateString, DateTime.Today);
                lineItem.DeliveryStoreNumber          = item.StoreId;
                lineItem.DeliveryWarehouse            = item.WarehouseId;
                lineItem.SerialId                     = item.SerialId;
                lineItem.BatchId                      = item.BatchId;
                lineItem.HasBeenRecalled              = true;
                lineItem.SalesMarkup                  = item.SalesMarkup;
                lineItem.Comment                      = string.IsNullOrEmpty(item.Comment) ? string.Empty : item.Comment;
                lineItem.LineStatus                   = GetSalesStatus((SalesOrderStatus)item.Status);
                lineItem.LineDiscount                 = item.LineDscAmount;
                lineItem.PeriodicDiscount             = item.PeriodicDiscount;
                lineItem.PeriodicPctDiscount          = item.PeriodicPercentageDiscount;
                lineItem.LineManualDiscountAmount     = item.LineManualDiscountAmount;
                lineItem.LineManualDiscountPercentage = item.LineManualDiscountPercentage;
                lineItem.TotalDiscount                = item.TotalDiscount;
                lineItem.TotalPctDiscount             = item.TotalPctDiscount;

                foreach (Tax.MiscellaneousCharge charge in lineCharges)
                {
                    lineItem.MiscellaneousCharges.Add(charge);
                }

                if (lineItem.DeliveryMode != null && !string.IsNullOrWhiteSpace(item.AddressRecordId))
                {
                    lineItem.ShippingAddress = customerDataManager.GetAddress(Int64.Parse(item.AddressRecordId));
                }

                lineItem.Dimension.VariantId  = item.VariantId;
                lineItem.Dimension.ColorId    = item.ColorId;
                lineItem.Dimension.StyleId    = item.StyleId;
                lineItem.Dimension.SizeId     = item.SizeId;
                lineItem.Dimension.ConfigId   = item.ConfigId;
                lineItem.Dimension.ColorName  = item.ColorName;
                lineItem.Dimension.StyleName  = item.StyleName;
                lineItem.Dimension.SizeName   = item.SizeName;
                lineItem.Dimension.ConfigName = item.ConfigName;

                if (!string.IsNullOrEmpty(lineItem.Dimension.VariantId))
                {
                    Dimensions dimension = (Dimensions)SalesOrder.InternalApplication.BusinessLogic.Utility.CreateDimension();
                    dimension.VariantId = lineItem.Dimension.VariantId;
                    SalesOrder.InternalApplication.Services.Dimension.GetDimensionForVariant(dimension);
                    lineItem.Dimension = dimension;
                }

                if (item.Discounts.Count > 0)
                {
                    lineItem.QuantityDiscounted = item.Quantity;
                    lineItem.LinePctDiscount    = lineItem.CalculateLinePercentDiscount();
                }

                // create discount line from discount info object
                foreach (DiscountInfo discountInfo in item.Discounts)
                {
                    DiscountItem discountItem = ConvertToDiscountItem(
                        discountInfo.DiscountOriginType,
                        discountInfo.ManualDiscountType,
                        discountInfo.CustomerDiscountType,
                        discountInfo.EffectiveAmount,
                        discountInfo.DealPrice,
                        discountInfo.DiscountAmount,
                        discountInfo.Percentage,
                        discountInfo.PeriodicDiscountOfferId,
                        discountInfo.OfferName,
                        discountInfo.DiscountCode);

                    SalesOrder.InternalApplication.Services.Discount.AddDiscountLine(lineItem, discountItem);
                }

                // Set other default properties for this item
                SalesOrder.InternalApplication.Services.Item.ProcessItem(lineItem, bypassSerialNumberEntry: true);

                // Set tax info after defaults, as it may have been overridden.
                lineItem.SalesTaxGroupId         = item.SalesTaxGroup;
                lineItem.SalesTaxGroupIdOriginal = item.SalesTaxGroup;
                lineItem.TaxGroupId         = item.ItemTaxGroup;
                lineItem.TaxGroupIdOriginal = item.ItemTaxGroup;

                // Add it to the transaction
                transaction.Add(lineItem);

                if (lineItem.DeliveryDate < earliestDeliveryDate)
                {
                    earliestDeliveryDate = lineItem.DeliveryDate.HasValue ? lineItem.DeliveryDate.Value : earliestDeliveryDate;
                }
            }

            // Once Items are populated - Reset Customer Tax Group
            //GRW Linea comentada para poder recoger la orden de venta en una tienda distinta a la configurada en AX
            //customerSystem.ResetCustomerTaxGroup(transaction);

            // The order can be created through some other channel other than POS which has set header delivery date as NoDate.
            // This must not be interpreted as a valid date. Instead the earliestDeliveryDate is used.
            if (transaction.RequestedDeliveryDate == NoDate)
            {
                transaction.RequestedDeliveryDate = earliestDeliveryDate;
            }

            // Charges
            foreach (ChargeInfo charge in orderInfo.Charges)
            {
                // add charges
                Tax.MiscellaneousCharge newCharge = (Tax.MiscellaneousCharge)SalesOrder.InternalApplication.BusinessLogic.Utility.CreateMiscellaneousCharge(
                    charge.Amount, charge.SalesTaxGroup, charge.TaxGroup, charge.Code, string.Empty, transaction);
                transaction.Add(newCharge);
            }

            SalesOrder.InternalApplication.BusinessLogic.ItemSystem.CalculatePriceTaxDiscount(transaction);
            transaction.CalculateAmountDue();

            // Payments
            // - total up amounts
            // - add history entries
            transaction.PrepaymentAmountPaid     = decimal.Zero;
            transaction.PrepaymentAmountInvoiced = decimal.Zero;
            decimal nonPrepayments = decimal.Zero;

            PaymentInfo pinfo = new PaymentInfo();

            pinfo.Amount   = -111;
            pinfo.Currency = "MXN";
            orderInfo.Payments.Add(pinfo);

            foreach (PaymentInfo payment in orderInfo.Payments)
            {
                // sum up payments
                decimal amount = (string.IsNullOrWhiteSpace(payment.Currency))
                    ? payment.Amount
                    : (SalesOrder.InternalApplication.Services.Currency.CurrencyToCurrency(
                           payment.Currency,
                           ApplicationSettings.Terminal.StoreCurrency,
                           payment.Amount));

                if (payment.Prepayment)
                {
                    // Sum prepayments to track total deposits paid
                    transaction.PrepaymentAmountPaid += amount;
                }
                else
                {
                    // Sum non-prepayments as base for calculating deposits applied to pickups
                    nonPrepayments += amount;
                }

                CustomerOrderPaymentHistory paymentHistory = (CustomerOrderPaymentHistory)SalesOrder.InternalApplication.BusinessLogic.Utility.CreateCustomerOrderPaymentHistory();
                paymentHistory.Amount   = payment.Amount;
                paymentHistory.Currency = payment.Currency;
                paymentHistory.Date     = ParseDateString(payment.DateString, DateTime.MinValue);
                paymentHistory.Balance  = transaction.NetAmountWithTaxAndCharges - transaction.PrepaymentAmountPaid;

                transaction.PaymentHistory.Add(paymentHistory);
            }

            // Prepayment/Deposit override info
            transaction.PrepaymentAmountOverridden = orderInfo.PrepaymentAmountOverridden;
            if (transaction.PrepaymentAmountOverridden)
            {
                transaction.PrepaymentAmountRequired = transaction.PrepaymentAmountPaid;
            }

            // Amount that has been previously invoiced (picked-up)
            transaction.PreviouslyInvoicedAmount = orderInfo.PreviouslyInvoicedAmount;

            // Portion of the prepayment that has been applied to invoices.
            // If .PrepaymentAmountApplied is non-NULL then use the explicit amount, otherwise fall back to computing the amount based on payment history.
            transaction.PrepaymentAmountInvoiced = orderInfo.PrepaymentAmountApplied
                                                   ?? (transaction.PreviouslyInvoicedAmount - nonPrepayments);

            transaction.HasLoyaltyPayment = orderInfo.HasLoyaltyPayment;

            return(transaction);
        }