示例#1
0
        internal static void AssertEqual(this SalesOrderItem expected, ISalesOrderItem result)
        {
            if (expected == null)
            {
                throw new ArgumentNullException("expected");
            }
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (expected.ContractItem == null)
            {
                Assert.IsNull(result.ContractItemKey);
            }
            else
            {
                Assert.AreEqual(expected.ContractItem.ToContractItemKey().KeyValue, result.ContractItemKey);
            }

            Assert.AreEqual(expected.InventoryPickOrderItem.ToProductKey().KeyValue, result.ProductKey);
            Assert.AreEqual(expected.InventoryPickOrderItem.ToPackagingProductKey().KeyValue, result.PackagingKey);
            Assert.AreEqual(expected.InventoryPickOrderItem.ToInventoryTreatmentKey().KeyValue, result.TreatmentKey);
            Assert.AreEqual(expected.InventoryPickOrderItem.Quantity, result.Quantity);
            Assert.AreEqual(expected.PriceBase, result.PriceBase);
            Assert.AreEqual(expected.PriceFreight, result.PriceFreight);
            Assert.AreEqual(expected.PriceTreatment, result.PriceTreatment);
            Assert.AreEqual(expected.PriceWarehouse, result.PriceWarehouse);
            Assert.AreEqual(expected.PriceRebate, result.PriceRebate);
            Assert.AreEqual(expected.InventoryPickOrderItem.CustomerLotCode, result.CustomerLotCode);
            Assert.AreEqual(expected.InventoryPickOrderItem.CustomerProductCode, result.CustomerProductCode);
        }
        public static decimal CalculateAdjustedPrice(ISalesOrderItem salesOrderItem)
        {
            if (salesOrderItem.SalesOrder.OrderType == "Return Order") {

                //Adjusted Price  is calculated differently for return orders
                //Adjusted Price = (original price - (original price * original discount) - (price - (price * discount)))
                decimal price = 0M;
                decimal discount = salesOrderItem.Discount.HasValue ? Convert.ToDecimal(salesOrderItem.Discount.Value) : 0M;

                decimal origPrice = 0M;
                decimal origDiscount = salesOrderItem.OrigProductDiscount.HasValue ? Convert.ToDecimal(salesOrderItem.OrigProductDiscount.Value) : 0M;

                price = (salesOrderItem.Price == 0.0) ? (salesOrderItem.CalculatedPrice.HasValue ? salesOrderItem.CalculatedPrice.Value : 0M) : (salesOrderItem.Price.HasValue ? ((decimal)salesOrderItem.Price.Value) : ((decimal)0.0));
                origPrice = salesOrderItem.OrigProductPrice.HasValue ? (decimal)salesOrderItem.OrigProductPrice.Value : 0M;

                return new decimal?(Math.Round((decimal)(origPrice - (origPrice * origDiscount)) - (price - (price * discount)), 2, MidpointRounding.AwayFromZero)) ?? 0M;

            } else {

                //Adjusted Price = price - (price * discount)
                decimal price = 0M;
                decimal discount = salesOrderItem.Discount.HasValue ? Convert.ToDecimal(salesOrderItem.Discount.Value) : 0M;
                price = (salesOrderItem.Price == 0.0) ? (salesOrderItem.CalculatedPrice.HasValue ? salesOrderItem.CalculatedPrice.Value : 0M) : (salesOrderItem.Price.HasValue ? ((decimal)salesOrderItem.Price.Value) : ((decimal)0.0));
                //price = (decimal)salesOrderItem.Price;
                return new decimal?(Math.Round((decimal)(price - (price * discount)), 2, MidpointRounding.AwayFromZero)) ?? 0M;

            }
        }
        private static ISalesOrderItem GetSalesOrderItem(string original_Id, object original_InstanceId)
        {
            ISalesOrderItem salesOrderItem = null;

            if (CurrentSalesOrder != null)
            {
                foreach (ISalesOrderItem item in CurrentSalesOrder.SalesOrderItems)
                {
                    if (item.Id != null)
                    {
                        if (String.Equals(item.Id.ToString(), original_Id))
                        {
                            salesOrderItem = item;
                            break;
                        }
                    }
                    else
                    {
                        if (String.Equals(item.InstanceId.ToString(), original_InstanceId.ToString()))
                        {
                            salesOrderItem = item;
                            break;
                        }
                    }
                }
            }
            else
            {
                salesOrderItem = EntityFactory.GetRepository <ISalesOrderItem>().Get(original_Id);
            }
            return(salesOrderItem);
        }
        public static void CalculatePriceChangeStep( ISalesOrderItem salesOrderItem)
        {
            decimal num = 0M;
            decimal num2 = salesOrderItem.Discount.HasValue ? Convert.ToDecimal(salesOrderItem.Discount.Value) : 0M;
            num = (salesOrderItem.Price == 0.0) ? (salesOrderItem.CalculatedPrice.HasValue ? salesOrderItem.CalculatedPrice.Value : 0M) : (salesOrderItem.Price.HasValue ? ((decimal) salesOrderItem.Price.Value) : ((decimal) 0.0));
            salesOrderItem.CalculatedPrice = new decimal?(num - (num * num2));

            salesOrderItem.CalculateExtendedPrice();
        }
 public static void GetServiceNameStep( ISalesOrderItem salesorderitem, out System.String result)
 {
     // TODO: Complete business rule implementation
     using (ISession session = new SessionScopeWrapper())
     {
         string sql = "select description from product where productid='"+salesorderitem.Product.Id+"'";
         string prodname = session.CreateSQLQuery(sql).UniqueResult<string>();
         result=prodname;
     }
 }
 public static void GetProductInfoStep( ISalesOrderItem salesorderitem, out System.String result)
 {
     result = salesorderitem.ProductName;
     if(salesorderitem.Product != null)
     {
       if(string.IsNullOrEmpty(salesorderitem.ProductName))
       {
          result = salesorderitem.Product.Name;
       }
     }
 }
 public static void GetProductInfoStep(ISalesOrderItem salesorderitem, out String result)
 {
     result = salesorderitem.ProductName;
     if (salesorderitem.Product != null)
     {
         if (string.IsNullOrEmpty(salesorderitem.ProductName))
         {
             result = salesorderitem.Product.Name;
         }
     }
 }
示例#8
0
        /// <summary>
        /// Initializes the view.
        /// </summary>
        /// <param name="form">The Edit Sales Order Item form.</param>
        /// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        public static void OnFormLoadStep(IEditSalesOrderItem form, EventArgs args)
        {
            ISalesOrderItem   salesOrderItem = form.CurrentEntity as ISalesOrderItem;
            IWebDialogService dialogService  = form.Services.Get <IWebDialogService>();

            if (dialogService != null && dialogService.DialogParameters.ContainsKey("CustomProductSalesOrder"))
            {
                ISalesOrder salesOrder = dialogService.DialogParameters["CustomProductSalesOrder"] as ISalesOrder;
                salesOrderItem.SalesOrder      = salesOrder;
                salesOrderItem.Quantity        = 1;
                salesOrderItem.CalculatedPrice = 0;
                salesOrderItem.Discount        = 0;
                salesOrderItem.ExtendedPrice   = 0;
                salesOrderItem.Price           = 0;
                dialogService.DialogParameters.Remove("CustomProductSalesOrder");
            }
            if (salesOrderItem.SalesOrder.IsMultiCurrencyEnabled())
            {
                form.curMCCalcPrice.ExchangeRate     = salesOrderItem.SalesOrder.ExchangeRate.GetValueOrDefault(1);
                form.curMCCalcPrice.CurrentCode      = salesOrderItem.SalesOrder.CurrencyCode;
                form.curMCCalcPrice.ExchangeRateType = Sage.Platform.Controls.ExchangeRateTypeEnum.EntityRate;
                form.curMCCalcPrice.Text             = salesOrderItem.CalculatedPrice.ToString();
            }
            else
            {
                form.ctrlstMCPrice.Visible = false;
            }

            if (salesOrderItem.Product == null)              // AdHocProduct
            {
                salesOrderItem.LineType        = "FreeText"; // Use as literal; represents adhoc product.
                form.ctrlstLineNumber.Visible  = false;
                form.ctrlstPriceLevel.Visible  = false;
                form.curPrice.IsReadOnly       = false;
                form.txtSKU.IsReadOnly         = false;
                form.pklFamily.IsReadOnly      = false;
                form.txtDescription.IsReadOnly = false;
                form.txtProductName.IsReadOnly = false;
            }

            bool closed = (salesOrderItem.SalesOrder.Status.ToUpper().Equals(form.GetResource("SalesOrderStatus_Closed").ToString().ToUpper()));

            form.txtDescription.Enabled     = !closed;
            form.txtSKU.Enabled             = !closed;
            form.pklFamily.Enabled          = !closed;
            form.txtDiscount.Enabled        = !closed;
            form.curCalculatedPrice.Enabled = !closed;
            form.curMCCalcPrice.Enabled     = !closed;
            form.numQuantity.Enabled        = !closed;
            form.btnOK.Visible     = !closed;
            form.btnCancel.Caption = form.GetResource("Closed_Caption").ToString();
        }
示例#9
0
        private static IResult <SetSalesOrderItemParameters> ToParsedParameters(this ISalesOrderItem orderItem)
        {
            if (orderItem == null)
            {
                throw new ArgumentNullException("orderItem");
            }

            IContractItemKey contractItemKey = null;

            if (!string.IsNullOrWhiteSpace(orderItem.ContractItemKey))
            {
                var contractItemKeyResult = KeyParserHelper.ParseResult <IContractItemKey>(orderItem.ContractItemKey);
                if (!contractItemKeyResult.Success)
                {
                    return(contractItemKeyResult.ConvertTo <SetSalesOrderItemParameters>());
                }

                contractItemKey = contractItemKeyResult.ResultingObject;
            }

            var productKeyResult = KeyParserHelper.ParseResult <IProductKey>(orderItem.ProductKey);

            if (!productKeyResult.Success)
            {
                return(productKeyResult.ConvertTo <SetSalesOrderItemParameters>());
            }

            var packagingProductKeyResult = KeyParserHelper.ParseResult <IPackagingProductKey>(orderItem.PackagingKey);

            if (!packagingProductKeyResult.Success)
            {
                return(packagingProductKeyResult.ConvertTo <SetSalesOrderItemParameters>());
            }

            var treatmentKeyResult = KeyParserHelper.ParseResult <IInventoryTreatmentKey>(orderItem.TreatmentKey);

            if (!treatmentKeyResult.Success)
            {
                return(treatmentKeyResult.ConvertTo <SetSalesOrderItemParameters>());
            }

            return(new SuccessResult <SetSalesOrderItemParameters>(new SetSalesOrderItemParameters
            {
                SalesOrderItem = orderItem,
                ContractItemKey = contractItemKey == null ? null : contractItemKey.ToContractItemKey(),
                ProductKey = productKeyResult.ResultingObject.ToProductKey(),
                PackagingProductKey = packagingProductKeyResult.ResultingObject.ToPackagingProductKey(),
                InventoryTreatmentKey = treatmentKeyResult.ResultingObject.ToInventoryTreatmentKey()
            }));
        }
        /// <summary>
        /// Updates the sales order products price based on a change of the multi currency pricing value.
        /// The updated is based on the value changed divided by the exchange rate. This event is only
        /// called when multi-currency is enabled.
        /// </summary>
        /// <param name="form">the instance of the ICEditSalesOrderItem dialog</param>
        /// <param name="args">empty</param>
        public static void curMCCalcPrice_OnChangeStep(IICEditSalesOrderItem form, EventArgs args)
        {
            ISalesOrderItem salesOrderItem = form.CurrentEntity as ISalesOrderItem;

            if (salesOrderItem != null)
            {
                double exchangeRate = salesOrderItem.SalesOrder.ExchangeRate.HasValue
                                                                                ? salesOrderItem.SalesOrder.ExchangeRate.Value
                                                                                : 1;
                form.curMCCalcPrice.CurrentCode = salesOrderItem.SalesOrder.CurrencyCode;
                string price = String.IsNullOrEmpty(form.curMCCalcPrice.Text) ? "0" : form.curMCCalcPrice.Text;
                salesOrderItem.CalculatedPrice = (decimal?)(Convert.ToDouble(price) / exchangeRate);
                salesOrderItem.CalculateCalcPrice();
            }
        }
        //Overrides the built in business rules function
        public static void CalculateExtendedPrice(ISalesOrderItem salesOrderItem)
        {
            if (salesOrderItem.SalesOrder.OrderType == "Return Order") {

                //Extended Price is calculated differently for return orders
                //Extended price = (original price - (original price * original discount) - (price - (price * discount))) * quantity

                //decimal calcPrice = salesOrderItem.CalculatedPrice.HasValue ? salesOrderItem.CalculatedPrice.Value : 0M;
                decimal calcPrice = CalculateAdjustedPrice(salesOrderItem);
                decimal qty = salesOrderItem.Quantity.HasValue ? Convert.ToDecimal(salesOrderItem.Quantity.Value) : 0M;
                salesOrderItem.ExtendedPrice = (double)(calcPrice * qty);

            } else {
                //Extended price = price - (price * discount) * quantity

                //decimal num3 = salesOrderItem.CalculatedPrice.HasValue ? salesOrderItem.CalculatedPrice.Value : 0M;
                decimal calcPrice = CalculateAdjustedPrice(salesOrderItem);
                decimal qty = salesOrderItem.Quantity.HasValue ? Convert.ToDecimal(salesOrderItem.Quantity.Value) : 0M;
                salesOrderItem.ExtendedPrice = (double)(calcPrice * qty);

            }
        }
示例#12
0
 public void RemoveSalesOrderItem(ISalesOrderItem salesOrderItem)
 {
     throw new System.NotImplementedException();
 }
        public static void TACOnAfterUpdate(ISalesOrderItem salesorderitem)
        {
            //Find the Matching StockCard Item
            // Update The LastOrder Fields
            Sage.Platform.RepositoryHelper<IStockCardItems> rep1 = Sage.Platform.EntityFactory.GetRepositoryHelper<IStockCardItems>();
            Sage.Platform.Repository.ICriteria crit1 = rep1.CreateCriteria();

            if (salesorderitem.SalesOrder != null) {
                if (salesorderitem.SalesOrder.Account != null) {
                    crit1.Add(rep1.EF.Eq("Accountid", salesorderitem.SalesOrder.Account.Id));

                    if (salesorderitem.Product != null) {
                        crit1.Add(rep1.EF.Eq("Productid", salesorderitem.Product.Id));

                        foreach (IStockCardItems scard in crit1.List<IStockCardItems>()) {
                            scard.LastOrder = scard.GetLastOrderX(1);
                            scard.LastOrder2 = scard.GetLastOrderX(2);
                            scard.LastOrder3 = scard.GetLastOrderX(3);
                            scard.LastOrder4 = scard.GetLastOrderX(4);
                            scard.LastOrder5 = scard.GetLastOrderX(5);
                            scard.LastOrder6 = scard.GetLastOrderX(6);
                            scard.LastOrder7 = scard.GetLastOrderX(7);
                            scard.LastOrder8 = scard.GetLastOrderX(8);
                            scard.LastOrder9 = scard.GetLastOrderX(9);
                            scard.LastOrder10 = scard.GetLastOrderX(10);
                            scard.LastOrder11 = scard.GetLastOrderX(11);
                            scard.LastOrder12 = scard.GetLastOrderX(12);
                            scard.Save();
                            break;
                        }

                    }
                }
            }
        }
 public static void CalculateCalcPriceStep( ISalesOrderItem salesorderitem)
 {
     salesorderitem.CalculateExtendedPrice();
 }
示例#15
0
        /// <summary>
        /// Sets view state of the Add Custom Product view based on a set of rules.
        /// </summary>
        /// <param name="form">The Edit Sales Order Item form.</param>
        /// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        public static void OnLoad1Step(IICEditSalesOrderItem form, EventArgs args)
        {
            ISalesOrderItem   salesOrderItem = form.CurrentEntity as ISalesOrderItem;
            ISalesOrder       salesOrder     = salesOrderItem.SalesOrder;
            IWebDialogService dialogService  = form.Services.Get <IWebDialogService>();

            if (dialogService != null && dialogService.DialogParameters.ContainsKey("CustomProductSalesOrder"))
            {
                salesOrder = dialogService.DialogParameters["CustomProductSalesOrder"] as ISalesOrder;
                salesOrderItem.SalesOrder      = salesOrder;
                salesOrderItem.Quantity        = 1;
                salesOrderItem.CalculatedPrice = 0;
                salesOrderItem.Discount        = 0;
                salesOrderItem.ExtendedPrice   = 0;
                salesOrderItem.Price           = 0;
                dialogService.DialogParameters.Remove("CustomProductSalesOrder");
            }

            if (salesOrder != null && salesOrder.IsMultiCurrencyEnabled())
            {
                form.curMCCalcPrice.ExchangeRate     = salesOrder.ExchangeRate.GetValueOrDefault(1);
                form.curMCCalcPrice.CurrentCode      = salesOrder.CurrencyCode;
                form.curMCCalcPrice.ExchangeRateType = Sage.Platform.Controls.ExchangeRateTypeEnum.EntityRate;
                form.curMCCalcPrice.Text             = salesOrderItem.CalculatedPrice.ToString();
            }
            else
            {
                form.ctrlstMCPrice.Visible = false;
            }

            form.ctrlstLineNumber.Visible = (salesOrderItem.Id != null);

            if (salesOrderItem.Product == null) // AdHocProduct
            {
                if (String.IsNullOrEmpty(salesOrderItem.LineType))
                {
                    salesOrderItem.LineType = "FreeText"; // Use as literal; represents adhoc product.
                }
                form.curPrice.IsReadOnly       = false;
                form.txtSKU.IsReadOnly         = false;
                form.txtFamily.IsReadOnly      = false;
                form.txtDescription.IsReadOnly = false;
                form.txtProduct.IsReadOnly     = false;
                form.ctrlstWarehouse.Visible   = false;
                form.ctrlstWarehouses.Visible  = false;
            }
            IAppIdMappingService mappingService = Sage.Platform.Application.ApplicationContext.Current.Services.Get <IAppIdMappingService>(true);
            //if this is a Sales Order that synced from the accounting system or the Sales Order has been submitted then we disable it
            bool isOpen = false;

            if (!String.IsNullOrEmpty(salesOrder.ERPSalesOrder.ERPStatus))
            {
                isOpen = (salesOrder.ERPSalesOrder.ERPStatus.Equals(
                              form.GetResource("erpStatus_Open").ToString()) ||
                          salesOrder.ERPSalesOrder.ERPStatus.Equals(form.GetResource("erpStatus_Rejected").ToString()));
            }
            bool erpSalesOrder = (mappingService.IsIntegrationEnabled() && (salesOrder.GlobalSyncId.HasValue && !isOpen));

            form.txtDescription.Enabled      = !erpSalesOrder;
            form.txtFamily.Enabled           = !erpSalesOrder;
            form.lueLocation.Enabled         = !erpSalesOrder;
            form.numDiscount.Enabled         = !erpSalesOrder;
            form.currCalculatedPrice.Enabled = !erpSalesOrder;
            form.numQuantity.Enabled         = !erpSalesOrder;
            form.lueUnitOfMeasure.Enabled    = !erpSalesOrder;
            form.chkPriceLocked.Enabled      = !erpSalesOrder;
            form.btnOk.Visible       = !erpSalesOrder;
            form.txtComments.Enabled = !erpSalesOrder;
            form.btnCancel.Caption   = form.GetResource("Closed_Caption").ToString();

            IRoleSecurityService roleSecurityService = form.Services.Get <IRoleSecurityService>(true);

            form.chkPriceLocked.Enabled = roleSecurityService.HasAccess("IntegrationContract/LockPricing");
        }
 public static void LastOrderStep(ISalesOrderItem salesorderitem, out System.String result)
 {
     // TODO: Complete business rule implementation
     result = GetSalesHistoryByIndex(1, salesorderitem.SalesOrder.Account.Id.ToString(), salesorderitem.Product.Id.ToString());
 }
示例#17
0
 /// <summary>
 /// Removes the sales order item.
 /// </summary>
 /// <param name="salesOrderItem">The sales order item.</param>
 public void RemoveSalesOrderItem(ISalesOrderItem salesOrderItem)
 {
     SalesOrderItem concreteSalesOrderItem = (SalesOrderItem)salesOrderItem;
     this.SalesOrderItems.Remove(concreteSalesOrderItem);
 }
示例#18
0
    /// <summary>
    /// Handles the Click event of the btnAdd control.
    /// </summary>
    /// <param name="sender">The source of the event.</param>
    /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
    protected void btnAdd_Click(object sender, EventArgs e)
    {
        List <string> selectedProductIDs = new List <string>(selectedNodes.Value.Split(','));
        ISalesOrder   salesOrder         = BindingSource.Current as ISalesOrder;

        foreach (string productID in selectedProductIDs)
        {
            IProduct product = EntityFactory.GetRepository <IProduct>().Get(productID);
            if (product != null)
            {
                ISalesOrderItem salesOrderItem = EntityFactory.Create <ISalesOrderItem>();
                salesOrderItem.Product     = EntityFactory.GetRepository <IProduct>().Get(productID);
                salesOrderItem.ProductName = salesOrderItem.Product.Name;
                salesOrderItem.SalesOrder  = salesOrder;
                salesOrderItem.Family      = product.Family;
                salesOrderItem.ActualID    = product.ActualId;
                salesOrderItem.Description = product.Description;

                bool isInList = false;
                if (salesOrder != null)
                {
                    foreach (ISalesOrderItem so in salesOrder.SalesOrderItems)
                    {
                        if (so.Product != null)
                        {
                            if (string.Compare(Convert.ToString(so.Product.Id), Convert.ToString(salesOrderItem.Product.Id)) == 0)
                            {
                                so.Quantity++;
                                isInList = true;
                                break;
                            }
                        }
                    }

                    if (!isInList)
                    {
                        salesOrderItem.Quantity = 1;
                        salesOrderItem.Discount = 0;

                        if (salesOrderItem.Product.ProductProgram.Count != 0)
                        {
                            foreach (IProductProgram prodProgram in salesOrderItem.Product.ProductProgram)
                            {
                                if (prodProgram.DefaultProgram == true)
                                {
                                    salesOrderItem.CalculatedPrice = prodProgram.Price;
                                    salesOrderItem.Program         = prodProgram.Program;
                                    salesOrderItem.Price           = (double?)prodProgram.Price;
                                }
                            }
                        }
                        else
                        {
                            salesOrderItem.CalculatedPrice = Convert.ToDecimal(salesOrderItem.Product.Price);
                            salesOrderItem.Price           = (double?)salesOrderItem.Product.Price;
                        }

                        salesOrderItem.ExtendedPrice = (double?)(salesOrderItem.CalculatedPrice * Convert.ToDecimal(salesOrderItem.Quantity));
                        salesOrder.SalesOrderItems.Add(salesOrderItem);
                    }
                }
            }
        }
    }
        public static void GetStockCardPricing(ISalesOrderItem salesorderitem)
        {
            try {
                // Set the pricing from stock card
                double listPrice = 0;
                try {
                    if (salesorderitem.Product != null) {
                        if (salesorderitem.Product.Vproductpricesheet != null) {
                            listPrice = (double)salesorderitem.Product.Vproductpricesheet.Listprice;
                        } else {
                            //price not found
                        }
                    }
                } catch (Exception ex) {
                    //vproductpricesheet record not found
                    Sage.Platform.Application.Exceptions.EventLogExceptionHandler eh = new Sage.Platform.Application.Exceptions.EventLogExceptionHandler();
                    eh.HandleException(new Exception("Order (" + salesorderitem.SalesOrder.SalesOrderNumber + "): " + ex.Message, ex), false);
                }

                Sage.Platform.RepositoryHelper<IStockCardItems> rep1 = Sage.Platform.EntityFactory.GetRepositoryHelper<IStockCardItems>();
                Sage.Platform.Repository.ICriteria crit1 = rep1.CreateCriteria();

                if (salesorderitem.SalesOrder != null) {
                    if (salesorderitem.SalesOrder.Account != null) {
                        crit1.Add(rep1.EF.Eq("Accountid", salesorderitem.SalesOrder.Account.Id));

                        if (salesorderitem.Product != null) {
                            crit1.Add(rep1.EF.Eq("Productid", salesorderitem.Product.Id));

                            double margin = 0;
                            foreach (IStockCardItems scard in crit1.List<IStockCardItems>()) {
                                margin = scard.Margin ?? 0;
                                break;
                            }

                            salesorderitem.Price = Math.Round(listPrice, 2);
                            salesorderitem.Discount = margin;
                            salesorderitem.CalculatedPrice = Math.Round((Decimal)listPrice - ((Decimal)listPrice * (Decimal)margin), 2, MidpointRounding.AwayFromZero);
                            salesorderitem.ExtendedPrice = Math.Round((Double)salesorderitem.CalculatedPrice * (Double)salesorderitem.Quantity, 2, MidpointRounding.AwayFromZero);
                            salesorderitem.UPC = salesorderitem.Product.UPC;

                            //Set a value on salesorder to recalculate totals on save
                            salesorderitem.SalesOrder.Tick = salesorderitem.SalesOrder.Tick + 1 ?? 1;
                        }
                    }
                }
            } catch (Exception e) {
                throw new Exception("Order (" + salesorderitem.SalesOrder.SalesOrderNumber + "): " + e.Message, e);
            }
        }
 public static void CalculateDiscountStep( ISalesOrderItem salesorderitem)
 {
     // TODO: Complete business rule implementation
 }
        public static void OnBeforeQuantityChanged(ISalesOrderItem salesorderitem, ExtendedPropertyChangedEventArgs args)
        {
            if (args.NewValue == null) {
                args.NewValue = 0d;
            }
            //Quantity check does not apply to return orders
            if (salesorderitem.SalesOrder.OrderType.ToUpper() != "RETURN ORDER") {

                if (salesorderitem.SalesOrder.OrderType.ToUpper() == "SALES ORDER") {
                    //Set the quantity to no more than available, allow negatives
                    if ((double)args.NewValue > 0) {
                        if (args.NewValue != args.OldValue) {
                            if (salesorderitem.Product != null) {
                                if ((double)args.NewValue > salesorderitem.Product.QtyAvailable) {
                                    //quantity not valid
                                    if (args.OldValue == null) {
                                        args.NewValue = 0;
                                    } else {
                                        args.NewValue = args.OldValue;
                                    }
                                    string errormsg = "You cannot order more than the available " + Math.Round((double)salesorderitem.Product.QtyAvailable);
                                    errormsg += " of the item " + salesorderitem.ActualID.ToString();
                                    throw new ArgumentOutOfRangeException("Quantity", errormsg);
                                }
                            }
                        }
                    }
                } else {
                    //For all other types, the quantity cannot be more than the quantity available, no negatives
                    if ((double)args.NewValue != 0) {
                        if (args.NewValue != args.OldValue) {
                            if (salesorderitem.Product != null) {
                                if ((double)args.NewValue < 0 || (double)args.NewValue > salesorderitem.Product.QtyAvailable) {
                                    //quantity not valid
                                    if (args.OldValue == null) {
                                        args.NewValue = 0;
                                    } else {
                                        args.NewValue = args.OldValue;
                                    }
                                    string errormsg = "You cannot order more than the available " + Math.Round((double)salesorderitem.Product.QtyAvailable);
                                    errormsg += " of the item " + salesorderitem.ActualID.ToString();
                                    errormsg += "\nOr less than 0 of any item.";
                                    throw new ArgumentOutOfRangeException("Quantity", errormsg);
                                }
                            }
                        }
                    }
                }
            }
            //Update the extended Price
            if (args.NewValue != args.OldValue) {
                salesorderitem.CalculateExtendedPrice();
            }
        }
 public static void CalcPriceFromProgramPriceStep( ISalesOrderItem salesorderitem)
 {
     // TODO: Complete business rule implementation
 }
        public static void UPCSearch(ISalesOrderItem salesorderitem, out object result)
        {
            result = null;
            if (!String.IsNullOrEmpty(salesorderitem.UPC)) {
                //Clear the current product
                salesorderitem.Product = null;

                //Lookup UPC from products
                Sage.Platform.RepositoryHelper<Sage.Entity.Interfaces.IProduct> f = Sage.Platform.EntityFactory.GetRepositoryHelper<Sage.Entity.Interfaces.IProduct>();
                Sage.Platform.Repository.ICriteria crit = f.CreateCriteria();

                if (salesorderitem.SalesOrder.UserWareHouse != null) {
                    crit.Add(f.EF.Eq("WarehouseID", salesorderitem.SalesOrder.UserWareHouse.SiteCodeId));
                    crit.Add(f.EF.Ne("Status", "Deleted"));
                    crit.Add(f.EF.Eq("UPC", salesorderitem.UPC));

                    //For returns on show return items. for all others do not show returns or bulk
                    if (salesorderitem.SalesOrder.OrderType == "Return Order") {
                        crit.Add(f.EF.Eq("Family", "Exchange Returns"));
                    } else {
                        crit.Add(f.EF.And(f.EF.Ne("Family", "Exchange Returns"), f.EF.Ne("Family", "Bulk Products")));
                    }

                    foreach (Sage.Entity.Interfaces.IProduct product in crit.List<Sage.Entity.Interfaces.IProduct>()) {
                        salesorderitem.Product = product;
                        salesorderitem.ActualID = product.ActualId;

                        //Modified 2014-1-10 PG
                        //products that are already in the order, return the existing product
                        var existsInOrder = from p in salesorderitem.SalesOrder.SalesOrderItems
                                            where p.ActualID.Equals(salesorderitem.Product.ActualId)
                                            select p;

                        if (existsInOrder.Count() > 0) {
                            //throw new Exception("Order already contains this product, use the edit function instead.");
                            //If an existing item is requested, load values from salesorder

                            foreach (ISalesOrderItem item in existsInOrder) {
                                item.Product = product;
                                item.ActualID = product.ActualId;

                                //save the product found to salesorder
                                SaveProductToSalesOrderItem(item);
                                result = item;
                            }

                        } else {

                            //save the product found to salesorder
                            SaveProductToSalesOrderItem(salesorderitem);
                            result = salesorderitem;
                        }
                        break;
                    }
                }
                if (salesorderitem.Product == null) {
                    throw new Exception("UPC not found.             ");
                }
            }
        }
示例#24
0
 /// <summary>
 /// Adds the sales order item.
 /// </summary>
 /// <param name="salesOrderItem">The sales order item.</param>
 public void AddSalesOrderItem(ISalesOrderItem salesOrderItem)
 {
     // IMPORTANT!! 
     // in Sales order item list, there has to be only 1 records per menu. So, you can't have sales order
     // item list containing 2 records with same menu.
     // for now, if user enter a sales item recors in which menu already exist in the list, 
     // add the quantity to existing record
     SalesOrderItem existingSalesOrderItem = this.SalesOrderItems.SingleOrDefault(s => s.MenuCode == salesOrderItem.MenuCode);
     if (existingSalesOrderItem != null)
     {
         existingSalesOrderItem.QtyOrdered += salesOrderItem.QtyOrdered;
     }
     else
     {
         SalesOrderItem concreteSalesOrderItem = (SalesOrderItem)salesOrderItem;
         concreteSalesOrderItem.OrderItemStatus = BMResto.BO.SalesOrder.Constant.ORDER_STATUS_NEW;
         concreteSalesOrderItem.OrderNo = this.OrderNo;
         this.SalesOrderItems.Add(concreteSalesOrderItem);
     }
 }
        public static void SaveProductToSalesOrderItem(ISalesOrderItem salesorderitem)
        {
            try {
                if (salesorderitem.Product != null) {

                    //exclude products that are already in the order, this is used for add only
                    var existsInOrder = from p in salesorderitem.SalesOrder.SalesOrderItems
                                        where p.ActualID.Equals(salesorderitem.Product.ActualId)
                                        select p;
                    if (existsInOrder.Count() > 0) {
                        //    //throw new Exception("Order already contains this product, use the edit function instead.");
                        //    //Modified 2014-1-10 PG
                        //    //If an existing item is requested, load values from salesorder

                        //salesorderitem.Quantity = 0; //don't change quantity
                    } else {
                        salesorderitem.Quantity = 0; //set to 0 initially
                    }

                    //item.SalesOrder = salesorder;
                    salesorderitem.ActualID = salesorderitem.Product.ActualId;
                    salesorderitem.Description = salesorderitem.Product.Description;
                    salesorderitem.Family = salesorderitem.Product.Family;
                    salesorderitem.UPC = salesorderitem.Product.UPC;

                    salesorderitem.ProductName = salesorderitem.Product.Name;
                    salesorderitem.Program = salesorderitem.Product.Program;
                    salesorderitem.UnitOfMeasureId = salesorderitem.Product.UnitOfMeasureId.Trim();
                    salesorderitem.Case = salesorderitem.Product.Unit;

                    ////get margin from category
                    //salesorderitem.Discount = 0;
                    //if (salesorderitem.SalesOrder != null) {
                    //    if (salesorderitem.SalesOrder.Account != null) {

                    //        String sql = "SELECT ACCOUNTPRODUCTCATEGORY.MARGIN";
                    //        sql += " FROM PRODUCT";
                    //        sql += " INNER JOIN TIMPRODCATITEM ON PRODUCT.MASITEMKEY = TIMPRODCATITEM.ITEMKEY";
                    //        sql += " INNER JOIN TIMPRODCATEGORY ON TIMPRODCATITEM.PRODCATEGORYKEY = TIMPRODCATEGORY.PRODCATEGORYKEY";
                    //        sql += " INNER JOIN ACCOUNTPRODUCTCATEGORY ON TIMPRODCATEGORY.TIMPRODCATEGORYID = ACCOUNTPRODUCTCATEGORY.PRODUCTCATEGORYID";
                    //        sql += " Where ProductId = '" + salesorderitem.Product.Id.ToString() + "'";
                    //        sql += " And AccountId = '" + salesorderitem.SalesOrder.Account.Id.ToString() + "'";

                    //        Sage.Platform.Data.IDataService datasvc = Sage.Platform.Application.ApplicationContext.Current.Services.Get<Sage.Platform.Data.IDataService>();
                    //        using (System.Data.OleDb.OleDbConnection conn = new System.Data.OleDb.OleDbConnection(datasvc.GetConnectionString())) {
                    //            conn.Open();
                    //            using (System.Data.OleDb.OleDbCommand cmd = new System.Data.OleDb.OleDbCommand(sql, conn)) {
                    //                OleDbDataReader reader = cmd.ExecuteReader();
                    //                //loop through the reader
                    //                while (reader.Read()) {
                    //                    try {
                    //                        salesorderitem.Discount = (Double)reader["MARGIN"];
                    //                    } catch (Exception) {
                    //                        //no catch?
                    //                        salesorderitem.Discount = 0;
                    //                    }
                    //                }
                    //                reader.Close();
                    //            }
                    //        }
                    //    }
                    //}

                    //Get margin from extension method
                    double margin = 0;
                    if (salesorderitem.Product.Timprodpricegroup != null
                        && salesorderitem.SalesOrder != null
                        && salesorderitem.SalesOrder.Account != null) {

                        Extentions.GetDefaultMargin(null,
                                                salesorderitem.Product.Timprodpricegroup.Id.ToString(),
                                                salesorderitem.SalesOrder.Account,
                                                out margin);
                    }
                    salesorderitem.Discount = margin;

                    //get msrp price
                    double listPrice = 0;
                    try {
                        if (salesorderitem.Product != null) {
                            if (salesorderitem.Product.Vproductpricesheet != null) {
                                listPrice = (double)salesorderitem.Product.Vproductpricesheet.Listprice;
                            } else {
                                //price not found
                            }
                        }
                    } catch (Exception ex) {
                        //vproductpricesheet record not found
                        Sage.Platform.Application.Exceptions.EventLogExceptionHandler eh = new Sage.Platform.Application.Exceptions.EventLogExceptionHandler();
                        eh.HandleException(new Exception("Order (" + salesorderitem.SalesOrder.SalesOrderNumber + "): " + ex.Message, ex), false);
                    }
                    salesorderitem.Price = Math.Round(listPrice, 2);

                    if (salesorderitem.SalesOrder.OrderType == "Return Order") {

                        if (salesorderitem.SalesOrder.Account != null) {

                            //find the new item, id is the same as return except last char
                            double newProductPrice = 0;
                            double returnmargin = 0;
                            try {
                                IProduct newProduct = FindProductByReturnProduct(salesorderitem.Product, salesorderitem.SalesOrder.Account);

                                if (newProduct.Vproductpricesheet != null) {
                                    newProductPrice = (double)newProduct.Vproductpricesheet.Listprice;
                                } else {
                                    //price not found
                                }

                                if (newProduct.Timprodpricegroup != null
                                && salesorderitem.SalesOrder != null
                                && salesorderitem.SalesOrder.Account != null) {

                                    Extentions.GetDefaultMargin(null,
                                                            newProduct.Timprodpricegroup.Id.ToString(),
                                                            salesorderitem.SalesOrder.Account,
                                                            out returnmargin);
                                }

                            } catch (Exception ex) {
                                //vproductpricesheet record not found
                                Sage.Platform.Application.Exceptions.EventLogExceptionHandler eh = new Sage.Platform.Application.Exceptions.EventLogExceptionHandler();
                                eh.HandleException(new Exception("Order (" + salesorderitem.SalesOrder.SalesOrderNumber + "): " + ex.Message, ex), false);
                            }
                            //return item price is new item price - return item price
                            salesorderitem.OrigProductPrice = Math.Round(newProductPrice, 2);

                            //Get return margin from extension method
                            salesorderitem.OrigProductDiscount = returnmargin;

                        }
                    }

                    //calculate the adjusted and extended prices
                    salesorderitem.CalculatedPrice = CalculateAdjustedPrice(salesorderitem);
                    CalculateExtendedPrice(salesorderitem);

                }
                //}
            } catch (Exception e) {
                throw new Exception("Order (" + salesorderitem.SalesOrder.SalesOrderNumber + "): " + e.Message, e);
            }
        }