private GetByUriResult GetHtmlRedirect(string url)
        {
            if (url.IsBlank())
            {
                return(null);
            }

            var baseUrl =
                HttpContext
                .Current
                .Request
                .ActualUrl()
                .GetLeftPart(UriPartial.Authority);
            var getByUriResult =
                this
                .htmlRedirectPipeline
                .GetByUri(
                    new GetByUriParameter {
                Uri = new Uri($"{baseUrl}{url}")
            });

            PipelineHelper.VerifyResults(getByUriResult);

            return(getByUriResult);
        }
示例#2
0
        private void ProcessSubscription(IUnitOfWork unitOfWork, CustomerOrder customerOrder, OrderLine orderLine)
        {
            ProductSubscriptionDto productSubscriptionDto = this.GetProductSubscriptionDto(orderLine);
            Subscription           subscription           = this.GetSubscription(customerOrder, orderLine, productSubscriptionDto);

            unitOfWork.GetRepository <Subscription>().Insert(subscription);
            Dictionary <Guid, PricingServiceParameter> dictionary = new Dictionary <Guid, PricingServiceParameter>();

            foreach (SubscriptionProduct subscriptionProduct in (IEnumerable <SubscriptionProduct>)orderLine.Product.SubscriptionProducts)
            {
                PricingServiceParameter serviceParameter = new PricingServiceParameter(subscriptionProduct.Product.Id)
                {
                    Product    = subscriptionProduct.Product,
                    QtyOrdered = subscriptionProduct.QtyOrdered * orderLine.QtyOrdered
                };
                dictionary.Add(subscriptionProduct.Product.Id, serviceParameter);
            }
            GetProductPricingResult productPricing = this.pricingPipeline.GetProductPricing(new GetProductPricingParameter(true)
            {
                PricingServiceParameters = (IDictionary <Guid, PricingServiceParameter>)dictionary
            });

            PipelineHelper.VerifyResults((PipeResultBase)productPricing);
            foreach (SubscriptionProduct subscriptionProduct1 in (IEnumerable <SubscriptionProduct>)orderLine.Product.SubscriptionProducts)
            {
                SubscriptionProduct subscriptionProduct = subscriptionProduct1;
                SubscriptionLine    subscriptionLine    = new SubscriptionLine()
                {
                    Product    = unitOfWork.GetRepository <Product>().Get(subscriptionProduct.Product.Id),
                    QtyOrdered = subscriptionProduct.QtyOrdered * orderLine.QtyOrdered
                };
                ProductPriceDto productPriceDto = productPricing.ProductPriceDtos.First <KeyValuePair <Guid, ProductPriceDto> >((Func <KeyValuePair <Guid, ProductPriceDto>, bool>)(o => o.Key == subscriptionProduct.Product.Id)).Value;
                subscriptionLine.Price = productPriceDto.UnitRegularPrice;
                subscription.SubscriptionLines.Add(subscriptionLine);
                //if (subscription.IncludeInInitialOrder)
                //{
                //    OrderLine orderLine1 = new OrderLine()
                //    {
                //        Description = subscriptionLine.Product.ErpDescription,
                //        UnitListPrice = productPriceDto.UnitListPrice,
                //        UnitRegularPrice = productPriceDto.UnitRegularPrice,
                //        UnitNetPrice = subscription.FixedPrice ? subscriptionLine.Price : productPriceDto.UnitNetPrice
                //    };
                //    this.orderLineUtilities.SetProduct(orderLine1, subscriptionLine.Product);
                //    this.orderLineUtilities.SetQtyOrdered(orderLine1, subscriptionLine.QtyOrdered);
                //    PipelineHelper.VerifyResults((PipeResultBase)this.cartPipeline.AddCartLine(new Insite.Cart.Services.Pipelines.Parameters.AddCartLineParameter()
                //    {
                //        Cart = customerOrder,
                //        CartLine = orderLine1
                //    }));
                //}
            }
            if (!subscription.IncludeInInitialOrder)
            {
                return;
            }
            subscription.CustomerOrders.Add(customerOrder);
        }
        public virtual IDictionary <Guid, ProductPriceDto> GetPricingServiceResult(IEnumerable <OrderLine> orderLines)
        {
            GetProductPricingResult productPricing = this.pricingPipeline.GetProductPricing(new GetProductPricingParameter(true)
            {
                PricingServiceParameters = orderLines.ToDictionary(o => o.Id, o => new PricingServiceParameter(o.ProductId)
                {
                    OrderLine       = o,
                    CustomerOrderId = o.CustomerOrderId
                })
            });

            PipelineHelper.VerifyResults((PipeResultBase)productPricing);
            return(productPricing.ProductPriceDtos);
        }
        public override void ClearPromotionResult(CustomerOrder customerOrder)
        {
            //4.2 Code
            //customerOrder.OrderLines.Where<OrderLine>((Func<OrderLine, bool>)(o =>
            //{
            //    PromotionResult promotionResult = o.PromotionResult;
            //    Guid? nullable = promotionResult != null ? new Guid?(promotionResult.Id) : new Guid?();
            //    Guid id = this.PromotionResult.Id;
            //    if (!nullable.HasValue)
            //        return false;
            //    if (!nullable.HasValue)
            //        return true;
            //    return nullable.GetValueOrDefault() == id;
            //})).ToList<OrderLine>().ForEach((Action<OrderLine>)(orderLine =>
            //{
            //    // BUSA-683 : Volume Discount Promotion - Issue when user cart qualifies add free product promotion &volume discount group.
            //    this.UnitOfWork.Save();
            //    var id = this.UnitOfWork.GetRepository<OrderLine>().GetTable().Where(x => x.Id == orderLine.Id).Count();
            //    if (id > 0)
            //    {
            //        this.CustomerOrderUtilities.RemoveOrderLine(customerOrder, orderLine);
            //    }
            //}));

            foreach (OrderLine orderLine in customerOrder.OrderLines.Where <OrderLine>((Func <OrderLine, bool>)(o =>
            {
                PromotionResult promotionResult = o.PromotionResult;
                Guid?nullable = promotionResult != null ? new Guid?(promotionResult.Id) : new Guid?();
                Guid id = this.PromotionResult.Id;
                if (!nullable.HasValue)
                {
                    return(false);
                }
                if (!nullable.HasValue)
                {
                    return(true);
                }
                return(nullable.GetValueOrDefault() == id);
            })).ToList <OrderLine>())
            {
                PipelineHelper.VerifyResults((PipeResultBase)this.CartPipeline.RemoveCartLine(new Insite.Cart.Services.Pipelines.Parameters.RemoveCartLineParameter()
                {
                    Cart     = customerOrder,
                    CartLine = orderLine
                }));
            }
        }
        protected void GetPricingServiceResult(IEnumerable <OrderLine> orderLines)
        {
            GetProductPricingResult productPricing = this.pricingPipeline.GetProductPricing(new GetProductPricingParameter(true)
            {
                PricingServiceParameters = orderLines.ToDictionary(o => o.Id, o => new PricingServiceParameter(o.ProductId)
                {
                    OrderLine       = o,
                    CustomerOrderId = o.CustomerOrderId
                })
            });

            PipelineHelper.VerifyResults((PipeResultBase)productPricing);

            foreach (OrderLine ol in orderLines)
            {
                ProductPriceDto productPriceDto = productPricing.ProductPriceDtos.First(o => o.Key == ol.Id).Value;
                ol.UnitListPrice    = productPriceDto.UnitListPrice;
                ol.UnitRegularPrice = productPriceDto.UnitRegularPrice;
                ol.UnitNetPrice     = productPriceDto.UnitNetPrice;
                //ol.CustomerOrder.ConversionRate =
            }
        }
        //public override Decimal ProductDiscount(CustomerOrder customerOrder)
        //{
        //    return Decimal.Zero;
        //}

        public override void ApplyPromotionResult(CustomerOrder customerOrder)
        {
            //BUSA- 463 Subscrition- Not include promotional product in subscrition order
            if (!customerOrder.Status.EqualsIgnoreCase("Saved") && !customerOrder.Status.EqualsIgnoreCase("SubscriptionOrder") && !customerOrder.Status.EqualsIgnoreCase("Return Requested"))
            {
                if (!this.PromotionResult.Amount.HasValue)
                {
                    throw new ArgumentNullException("Amount");
                }
                if (this.PromotionResult.Amount.Value <= Decimal.Zero)
                {
                    throw new ArgumentOutOfRangeException("Amount");
                }
                if (this.PromotionResult.Product == null)
                {
                    throw new ArgumentNullException("Product");
                }
                if (this.PromotionResult.Product.TrackInventory && (!this.InventorySettings.AllowBackOrder || this.PromotionResult.Product.IsDiscontinued))
                {
                    ProductInventory inventory = this.InventoryPipeline.Value.GetQtyOnHand(new GetQtyOnHandParameter(true)
                    {
                        GetInventoryParameter = new GetInventoryParameter()
                        {
                            ProductIds = new List <Guid>()
                            {
                                this.PromotionResult.Product.Id
                            },
                            Products = new List <Product>()
                            {
                                this.PromotionResult.Product
                            }
                        }
                    }).Inventories[this.PromotionResult.Product.Id];
                    if ((inventory != null ? inventory.QtyOnHand : Decimal.Zero) < this.PromotionResult.Amount.Value)
                    {
                        return;
                    }
                }
                IProductUtilities productUtilities = this.ProductUtilities;
                List <Product>    products         = new List <Product>();
                products.Add(this.PromotionResult.Product);
                Customer billTo = SiteContext.Current.BillTo;
                Customer shipTo = SiteContext.Current.ShipTo;
                if (productUtilities.GetRestrictedProductIds(products, billTo, shipTo).Any <Guid>())
                {
                    return;
                }
                OrderLine orderLine1 = new OrderLine();
                orderLine1.UnitOfMeasure = this.PromotionResult.Product.UnitOfMeasure;
                orderLine1.Id            = Guid.NewGuid();
                // BUSA-1319: Limit Qty Per Product
                var maxProductQty = this.PromotionResult.Product.CustomProperties.Where(x => x.Name == "maxProductQty").Select(s => s.Value).FirstOrDefault() ?? "0";

                if (!string.IsNullOrEmpty(maxProductQty) && Convert.ToInt32(maxProductQty) != 0 && this.PromotionResult.Amount.Value > Convert.ToDecimal(maxProductQty))
                {
                    orderLine1.QtyOrdered = Convert.ToDecimal(maxProductQty);
                }
                else
                {
                    orderLine1.QtyOrdered = this.PromotionResult.Amount.Value;
                } // BUSA-1319: END
                OrderLine orderLine2 = orderLine1;
                this.OrderLineUtilities.SetProduct(orderLine2, this.PromotionResult.Product);
                PipelineHelper.VerifyResults((PipeResultBase)this.CartPipeline.AddCartLine(new Insite.Cart.Services.Pipelines.Parameters.AddCartLineParameter()
                {
                    Cart     = customerOrder,
                    CartLine = orderLine2
                }));
                CustomerOrderPromotion customerOrderPromotion = customerOrder.CustomerOrderPromotions.FirstOrDefault <CustomerOrderPromotion>((Func <CustomerOrderPromotion, bool>)(p => p.PromotionId == this.PromotionResult.PromotionId));
                if (customerOrderPromotion != null)
                {
                    customerOrderPromotion.OrderLineId = new Guid?(orderLine2.Id);
                    customerOrderPromotion.Amount      = new Decimal?(new Decimal());
                }
                orderLine2.PromotionResult  = this.PromotionResult;
                orderLine2.IsPromotionItem  = true;
                orderLine2.UnitNetPrice     = Decimal.Zero;
                orderLine2.UnitRegularPrice = this.PromotionResult.Product.BasicListPrice;

                // BUSA-683 : Volume Discount Promotion -Issue when user cart qualifies add free product promotion & volume discount group.
                var orderLineCount = customerOrder.OrderLines.Where(x => x.Id == new Guid()).Count();

                //start BUSA-683 Volume Discount Promotion -Issue when user's cart qualifies add free product promotion & volume discount group
                if (this.PromotionResult.Promotion.RuleManager.RuleClauses.Where(x => x.CriteriaType == "OverideVolumeDiscount").Count() > 0)
                {
                    var vdgOverride = this.PromotionResult.Promotion.RuleManager.RuleClauses.Where(x => x.CriteriaType == "OverideVolumeDiscount").FirstOrDefault().CriteriaValue;
                    //check if override VDG
                    if (vdgOverride == "Yes")
                    {
                        var ruleProductId = this.PromotionResult.Promotion.RuleManager.RuleClauses.Where(x => x.CriteriaType == "OrderedProduct").Count() > 0 ? this.PromotionResult.Promotion.RuleManager.RuleClauses.Where(x => x.CriteriaType == "OrderedProduct").FirstOrDefault().SimpleValue : string.Empty;

                        var ruleOrderLine = customerOrder.OrderLines.Where(x => x.ProductId.ToString() == ruleProductId.ToString()).FirstOrDefault();
                        if (ruleOrderLine != null && !string.IsNullOrEmpty(ruleOrderLine.ConfigurationViewModel))
                        {
                            ruleOrderLine.UnitNetPrice = ruleOrderLine.UnitListPrice;
                            ruleOrderLine.SmartPart    = string.Empty;

                            ruleOrderLine.ConfigurationViewModel = "false";
                            var grpDescription = ruleOrderLine.GetProperty("GrpDescription", "");

                            if (!string.IsNullOrEmpty(grpDescription))
                            {
                                ruleOrderLine.SetProperty("GrpDescription", " ");
                            }

                            CartHelper_Brasseler helper = new CartHelper_Brasseler(this.pricingPipeline);
                            helper.UpdateVolumeGrpPricing(customerOrder, ruleOrderLine.Product.PriceBasis, UnitOfWork);
                            if (orderLineCount == 0)
                            {
                                PipelineHelper.VerifyResults((PipeResultBase)this.CartPipeline.AddCartLine(new Insite.Cart.Services.Pipelines.Parameters.AddCartLineParameter()
                                {
                                    Cart     = customerOrder,
                                    CartLine = orderLine1
                                }));
                                orderLine1.PromotionResult = this.PromotionResult;

                                orderLine1.IsPromotionItem  = true;
                                orderLine1.UnitNetPrice     = Decimal.Zero;
                                orderLine1.UnitRegularPrice = this.PromotionResult.Product.BasicListPrice;
                            }
                        }
                        else
                        {
                            if (orderLineCount == 0)
                            {
                                PipelineHelper.VerifyResults((PipeResultBase)this.CartPipeline.AddCartLine(new Insite.Cart.Services.Pipelines.Parameters.AddCartLineParameter()
                                {
                                    Cart     = customerOrder,
                                    CartLine = orderLine1
                                }));
                                orderLine1.PromotionResult = this.PromotionResult;

                                orderLine1.IsPromotionItem  = true;
                                orderLine1.UnitNetPrice     = Decimal.Zero;
                                orderLine1.UnitRegularPrice = this.PromotionResult.Product.BasicListPrice;
                            }
                        }
                    }
                    else
                    {
                        //Do nothing
                    }
                }
                //end BUSA-683 Volume Discount Promotion -Issue when user's cart qualifies add free product promotion & volume discount group
                else
                {
                    PipelineHelper.VerifyResults((PipeResultBase)this.CartPipeline.AddCartLine(new Insite.Cart.Services.Pipelines.Parameters.AddCartLineParameter()
                    {
                        Cart     = customerOrder,
                        CartLine = orderLine1
                    }));
                    orderLine1.PromotionResult = this.PromotionResult;

                    orderLine1.IsPromotionItem  = true;
                    orderLine1.UnitNetPrice     = Decimal.Zero;
                    orderLine1.UnitRegularPrice = this.PromotionResult.Product.BasicListPrice;
                }
            }
        }