예제 #1
0
            private static DiscountBase ConvertDiscountAndLineToDiscountBase(PeriodicDiscount discountAndLine)
            {
                DiscountBase        discount    = null;
                OfferDiscount       offer       = null;
                MixAndMatchDiscount mixAndMatch = null;
                MultipleBuyDiscount multipleBuy = null;
                ThresholdDiscount   threshold   = null;

                switch (discountAndLine.PeriodicDiscountType)
                {
                case PeriodicDiscountOfferType.Offer:
                    offer    = new OfferDiscount(discountAndLine.ValidationPeriod);
                    discount = offer;
                    break;

                case PeriodicDiscountOfferType.MixAndMatch:
                    mixAndMatch = new MixAndMatchDiscount(discountAndLine.ValidationPeriod);
                    mixAndMatch.DealPriceValue              = discountAndLine.MixAndMatchDealPrice;
                    mixAndMatch.DiscountAmountValue         = discountAndLine.MixAndMatchDiscountAmount;
                    mixAndMatch.DiscountPercentValue        = discountAndLine.MixAndMatchDiscountPercent;
                    mixAndMatch.NumberOfLeastExpensiveLines = discountAndLine.MixAndMatchNumberOfLeastExpensiveLines;
                    mixAndMatch.NumberOfTimesApplicable     = discountAndLine.MixAndMatchNumberOfTimeApplicable;
                    mixAndMatch.LeastExpensiveMode          = discountAndLine.LeastExpensiveMode;
                    discount = mixAndMatch;
                    break;

                case PeriodicDiscountOfferType.MultipleBuy:
                    multipleBuy = new MultipleBuyDiscount(discountAndLine.ValidationPeriod);
                    discount    = multipleBuy;
                    break;

                case PeriodicDiscountOfferType.Threshold:
                    threshold = new ThresholdDiscount(discountAndLine.ValidationPeriod);
                    threshold.ShouldCountNonDiscountItems = discountAndLine.ShouldCountNonDiscountItems != 0;
                    discount = threshold;
                    break;
                }

                if (discount != null)
                {
                    discount.IsCategoryToProductOrVariantIdsMapSet = true;

                    discount.OfferId                = discountAndLine.OfferId;
                    discount.OfferName              = discountAndLine.Name;
                    discount.PeriodicDiscountType   = discountAndLine.PeriodicDiscountType;
                    discount.IsDiscountCodeRequired = discountAndLine.IsDiscountCodeRequired;
                    discount.ConcurrencyMode        = discountAndLine.ConcurrencyMode;
                    discount.PricingPriorityNumber  = discountAndLine.PricingPriorityNumber;
                    discount.CurrencyCode           = discountAndLine.CurrencyCode;
                    discount.DateValidationPeriodId = discountAndLine.ValidationPeriodId;
                    discount.DateValidationType     = (DateValidationType)discountAndLine.DateValidationType;
                    discount.DiscountType           = GetDiscountMethodType(discount.PeriodicDiscountType, discountAndLine.DiscountType);
                    discount.ValidFrom              = discountAndLine.ValidFromDate;
                    discount.ValidTo                = discountAndLine.ValidToDate;
                }

                return(discount);
            }
예제 #2
0
            internal static Dictionary <long, List <DiscountBase> > GetProductOrVariantToDiscountMapLive(
                SalesTransaction transaction,
                PriceContext priceContext,
                IPricingDataAccessor pricingDataManager)
            {
                List <ItemUnit>           items = new List <ItemUnit>();
                Dictionary <string, long> itemIdInventDimIdToProductOrVariantIdMap = new Dictionary <string, long>(StringComparer.OrdinalIgnoreCase);

                foreach (SalesLine salesLine in transaction.PriceCalculableSalesLines)
                {
                    // The map is to look up product or variant id, but not master id if variant id is present.
                    itemIdInventDimIdToProductOrVariantIdMap[GetItemIdInventDimIdKey(salesLine.ItemId, salesLine.InventoryDimensionId)] = salesLine.ProductId;

                    items.Add(new ItemUnit()
                    {
                        ItemId = salesLine.ItemId, VariantInventoryDimensionId = salesLine.InventoryDimensionId, Product = salesLine.MasterProductId == 0 ? salesLine.ProductId : salesLine.MasterProductId, DistinctProductVariant = salesLine.Variant != null ? salesLine.Variant.DistinctProductVariantId : 0, UnitOfMeasure = Discount.GetUnitOfMeasure(salesLine)
                    });
                }

                ReadOnlyCollection <PeriodicDiscount> discountAndLines = GetRetailDiscountsAndLines(items, priceContext, pricingDataManager, QueryResultSettings.AllRecords);
                ISet <long> productVariantMasterIdsInTransaction       = GetProductVariantMasterIdsForTransaction(transaction);

                Dictionary <long, List <DiscountBase> > productDiscountMap   = new Dictionary <long, List <DiscountBase> >();
                Dictionary <string, DiscountBase>       offerIdToDiscountMap = new Dictionary <string, DiscountBase>(StringComparer.OrdinalIgnoreCase);

                foreach (PeriodicDiscount discountAndLine in discountAndLines)
                {
                    if (!PriceContextHelper.MatchCalculationMode(priceContext, discountAndLine.PeriodicDiscountType))
                    {
                        continue;
                    }

                    string key = GetItemIdInventDimIdKey(discountAndLine.ItemId, discountAndLine.InventoryDimensionId);
                    long   productOrVariantId = 0;
                    if (itemIdInventDimIdToProductOrVariantIdMap.TryGetValue(key, out productOrVariantId))
                    {
                        DiscountBase discount = null;

                        if (offerIdToDiscountMap.TryGetValue(discountAndLine.OfferId, out discount))
                        {
                            RetailDiscountLine discountLine = null;
                            if (!discount.DiscountLines.TryGetValue(discountAndLine.DiscountLineNumber, out discountLine))
                            {
                                discountLine = ConvertDiscountAndLineToDiscountLine(discountAndLine, discount);
                                discount.DiscountLines.Add(discountLine.DiscountLineNumber, discountLine);
                            }

                            IList <RetailDiscountLine> discountLines = null;
                            if (discount.ProductOfVariantToDiscountLinesMap.TryGetValue(productOrVariantId, out discountLines))
                            {
                                discountLines.Add(discountLine);
                            }
                            else
                            {
                                discount.ProductOfVariantToDiscountLinesMap[productOrVariantId] = new List <RetailDiscountLine> {
                                    discountLine
                                };
                            }
                        }
                        else
                        {
                            discount = ConvertDiscountAndLineToDiscountBase(discountAndLine);
                            discount.ProductOrVariantIdsInTransaction = productVariantMasterIdsInTransaction;
                            RetailDiscountLine discountLine = ConvertDiscountAndLineToDiscountLine(discountAndLine, discount);
                            discount.DiscountLines.Add(discountLine.DiscountLineNumber, discountLine);
                            offerIdToDiscountMap.Add(discount.OfferId, discount);
                            discount.ProductOfVariantToDiscountLinesMap[productOrVariantId] = new List <RetailDiscountLine> {
                                discountLine
                            };
                        }

                        List <DiscountBase> discounts;
                        if (productDiscountMap.TryGetValue(productOrVariantId, out discounts))
                        {
                            if (!discounts.Where(p => p.OfferId == discount.OfferId).Any())
                            {
                                discounts.Add(discount);
                            }
                        }
                        else
                        {
                            productDiscountMap[productOrVariantId] = new List <DiscountBase>()
                            {
                                discount
                            };
                        }
                    }
                }

                IEnumerable <string> offerIds = offerIdToDiscountMap.Select(p => p.Key);

                if (offerIds.Any())
                {
                    IEnumerable <DiscountCode> discountCodes = pricingDataManager.GetDiscountCodesByOfferIds(offerIds) as IEnumerable <DiscountCode>;

                    foreach (DiscountCode discountCode in discountCodes)
                    {
                        DiscountBase discountBase;
                        if (offerIdToDiscountMap.TryGetValue(discountCode.OfferId, out discountBase))
                        {
                            // Accept both discount code and barcode in retail channel.
                            discountBase.DiscountCodes.Add(discountCode.Code);
                            discountBase.DiscountCodes.Add(discountCode.Barcode);
                        }
                    }

                    IEnumerable <RetailDiscountPriceGroup> discountPriceGroups = pricingDataManager.GetRetailDiscountPriceGroups(new HashSet <string>(offerIds)) as IEnumerable <RetailDiscountPriceGroup>;

                    foreach (RetailDiscountPriceGroup discountPriceGroup in discountPriceGroups)
                    {
                        offerIdToDiscountMap[discountPriceGroup.OfferId].PriceDiscountGroupIds.Add(discountPriceGroup.PriceGroupId);
                    }

                    SetEffectiveDiscountPriorityFromPriceGroups(offerIdToDiscountMap, priceContext);

                    IEnumerable <string> quantityOfferIds = offerIdToDiscountMap.Where(p => p.Value.PeriodicDiscountType == PeriodicDiscountOfferType.MultipleBuy).Select(p => p.Key);

                    if (quantityOfferIds.Any())
                    {
                        IEnumerable <QuantityDiscountLevel> quantityLevels = pricingDataManager.GetMultipleBuyDiscountLinesByOfferIds(quantityOfferIds) as IEnumerable <QuantityDiscountLevel>;

                        foreach (QuantityDiscountLevel quantityLevel in quantityLevels)
                        {
                            DiscountBase discountBase;
                            if (offerIdToDiscountMap.TryGetValue(quantityLevel.OfferId, out discountBase))
                            {
                                MultipleBuyDiscount multipleBuy = discountBase as MultipleBuyDiscount;

                                if (multipleBuy != null)
                                {
                                    multipleBuy.QuantityDiscountLevels.Add(quantityLevel);
                                }
                            }
                        }
                    }

                    IEnumerable <string> mixMatchOfferIds = offerIdToDiscountMap.Where(p => p.Value.PeriodicDiscountType == PeriodicDiscountOfferType.MixAndMatch).Select(p => p.Key);

                    if (mixMatchOfferIds.Any())
                    {
                        IEnumerable <MixAndMatchLineGroup> mixMatchLineGroups = pricingDataManager.GetMixAndMatchLineGroupsByOfferIds(mixMatchOfferIds) as IEnumerable <MixAndMatchLineGroup>;

                        foreach (MixAndMatchLineGroup lineGroup in mixMatchLineGroups)
                        {
                            DiscountBase discountBase;
                            if (offerIdToDiscountMap.TryGetValue(lineGroup.OfferId, out discountBase))
                            {
                                MixAndMatchDiscount mixMatch = discountBase as MixAndMatchDiscount;

                                if (mixMatch != null)
                                {
                                    mixMatch.LineGroupToNumberOfItemsMap.Add(lineGroup.LineGroup, lineGroup.NumberOfItemsNeeded);
                                }
                            }
                        }
                    }

                    IEnumerable <string> thresholdOfferIds = offerIdToDiscountMap.Where(p => p.Value.PeriodicDiscountType == PeriodicDiscountOfferType.Threshold).Select(p => p.Key);

                    if (thresholdOfferIds.Any())
                    {
                        IEnumerable <ThresholdDiscountTier> thresholdTiers = pricingDataManager.GetThresholdTiersByOfferIds(thresholdOfferIds) as IEnumerable <ThresholdDiscountTier>;

                        foreach (ThresholdDiscountTier tier in thresholdTiers)
                        {
                            DiscountBase discountBase;
                            if (offerIdToDiscountMap.TryGetValue(tier.OfferId, out discountBase))
                            {
                                ThresholdDiscount threshold = discountBase as ThresholdDiscount;

                                if (threshold != null)
                                {
                                    threshold.ThresholdDiscountTiers.Add(tier);
                                }
                            }
                        }
                    }
                }

                return(productDiscountMap);
            }
예제 #3
0
            /// <summary>
            /// Converts retail discount data from database to discount object.
            /// </summary>
            /// <param name="retailDiscount">Retail discount data from database.</param>
            /// <returns>Discount object.</returns>
            /// <remarks>This is private. Exposed as internal for test.</remarks>
            internal static DiscountBase ConvertRetailDiscountToDiscountBase(RetailDiscount retailDiscount)
            {
                DiscountBase        discount    = null;
                OfferDiscount       offer       = null;
                MixAndMatchDiscount mixAndMatch = null;
                MultipleBuyDiscount multipleBuy = null;
                ThresholdDiscount   threshold   = null;

                switch (retailDiscount.PeriodicDiscountType)
                {
                case PeriodicDiscountOfferType.Offer:
                    offer    = new OfferDiscount(retailDiscount.ValidationPeriod);
                    discount = offer;
                    break;

                case PeriodicDiscountOfferType.MixAndMatch:
                    mixAndMatch = new MixAndMatchDiscount(retailDiscount.ValidationPeriod);
                    mixAndMatch.DealPriceValue              = retailDiscount.MixAndMatchDealPrice;
                    mixAndMatch.DiscountAmountValue         = retailDiscount.MixAndMatchDiscountAmount;
                    mixAndMatch.DiscountPercentValue        = retailDiscount.MixAndMatchDiscountPercent;
                    mixAndMatch.NumberOfLeastExpensiveLines = retailDiscount.MixAndMatchNumberOfLeastExpensiveLines;
                    mixAndMatch.LeastExpensiveMode          = retailDiscount.LeastExpensiveMode;
                    mixAndMatch.NumberOfTimesApplicable     = retailDiscount.MixAndMatchNumberOfTimeApplicable;
                    foreach (RetailDiscountLine mixMatchLine in retailDiscount.DiscountLines)
                    {
                        if (!mixAndMatch.LineGroupToNumberOfItemsMap.ContainsKey(mixMatchLine.MixAndMatchLineGroup))
                        {
                            mixAndMatch.LineGroupToNumberOfItemsMap.Add(mixMatchLine.MixAndMatchLineGroup, mixMatchLine.MixAndMatchLineNumberOfItemsNeeded);
                        }
                    }

                    discount = mixAndMatch;
                    break;

                case PeriodicDiscountOfferType.MultipleBuy:
                    multipleBuy = new MultipleBuyDiscount(retailDiscount.ValidationPeriod);
                    multipleBuy.QuantityDiscountLevels.AddRange(retailDiscount.MultibuyQuantityTiers);
                    discount = multipleBuy;
                    break;

                case PeriodicDiscountOfferType.Threshold:
                    threshold = new ThresholdDiscount(retailDiscount.ValidationPeriod);
                    threshold.ShouldCountNonDiscountItems = retailDiscount.ShouldCountNonDiscountItems != 0;
                    threshold.ThresholdDiscountTiers.AddRange(retailDiscount.ThresholdDiscountTiers);
                    discount = threshold;
                    break;
                }

                if (discount != null)
                {
                    discount.IsCategoryToProductOrVariantIdsMapSet = false;

                    discount.OfferId                = retailDiscount.OfferId;
                    discount.OfferName              = retailDiscount.Name;
                    discount.PeriodicDiscountType   = retailDiscount.PeriodicDiscountType;
                    discount.IsDiscountCodeRequired = retailDiscount.IsDiscountCodeRequired;
                    discount.ConcurrencyMode        = retailDiscount.ConcurrencyMode;
                    discount.PricingPriorityNumber  = retailDiscount.PricingPriorityNumber;
                    discount.CurrencyCode           = retailDiscount.CurrencyCode;
                    discount.DateValidationPeriodId = retailDiscount.ValidationPeriodId;
                    discount.DateValidationType     = (DateValidationType)retailDiscount.DateValidationType;
                    discount.DiscountType           = GetDiscountMethodType(discount.PeriodicDiscountType, retailDiscount.DiscountType);
                    discount.ValidFrom              = retailDiscount.ValidFromDate;
                    discount.ValidTo                = retailDiscount.ValidToDate;

                    foreach (RetailDiscountLine discountLine in retailDiscount.DiscountLines)
                    {
                        discountLine.DiscountMethod = (int)GetLineDiscountOfferMethod(discount.PeriodicDiscountType, discount.DiscountType, discountLine.DiscountMethod, discountLine.MixAndMatchLineSpecificDiscountType);
                        discount.DiscountLines.Add(discountLine.DiscountLineNumber, discountLine);
                    }

                    foreach (RetailDiscountPriceGroup priceGroup in retailDiscount.PriceGroups)
                    {
                        discount.PriceDiscountGroupIds.Add(priceGroup.PriceGroupId);
                    }

                    foreach (DiscountCode discountCode in retailDiscount.DiscountCodes)
                    {
                        discount.DiscountCodes.Add(discountCode.Code);
                        discount.DiscountCodes.Add(discountCode.Barcode);
                    }
                }

                return(discount);
            }