Example #1
0
            /// <summary>
            /// Get single item non-overlapped discount result.
            /// </summary>
            /// <param name="itemGroupIndex">Item group index.</param>
            /// <param name="price">Item price.</param>
            /// <param name="quantity">Item quantity.</param>
            /// <returns>Single item non-overlapped discount result.</returns>
            protected internal override SingleItemNonOverlappedDiscountResult GetSingleItemNonOverlappedDiscountResult(
                int itemGroupIndex,
                decimal price,
                decimal quantity)
            {
                SingleItemNonOverlappedDiscountResult result = SingleItemNonOverlappedDiscountResult.NotApplicable;
                HashSet <decimal> discountLineNumberSet      = null;

                if (this.ItemGroupIndexToDiscountLineNumberSetMap.TryGetValue(itemGroupIndex, out discountLineNumberSet))
                {
                    if (discountLineNumberSet.Count == 1)
                    {
                        RetailDiscountLine discountLineDefinition = this.DiscountLines[discountLineNumberSet.First()];

                        result = new SingleItemNonOverlappedDiscountResult(
                            (DiscountOfferMethod)discountLineDefinition.DiscountMethod,
                            discountLineDefinition.DiscountAmount,
                            discountLineDefinition.DiscountPercent,
                            discountLineDefinition.OfferPrice,
                            GetUnitDiscountAmount(discountLineDefinition, price),
                            this.ConcurrencyMode);
                    }
                }

                return(result);
            }
            /// <summary>
            /// Compare two compounded results by application sequence.
            /// </summary>
            /// <param name="x">First single item non-overlapped discount result.</param>
            /// <param name="y">Second single item non-overlapped discount result.</param>
            /// <returns>Comparison result.</returns>
            public static int CompareCompoundedApplicationSequence(SingleItemNonOverlappedDiscountResult x, SingleItemNonOverlappedDiscountResult y)
            {
                int result = 0;

                if (x != null && y != null)
                {
                    if (x.IsApplicable && x.CanCompound && y.IsApplicable && y.CanCompound)
                    {
                        // The sort would put OfferPrice first, then DiscountAmount, and finally Percentage
                        result = Math.Sign(((int)y.DiscountMethod) - ((int)x.DiscountMethod));

                        if (result == 0)
                        {
                            switch (x.DiscountMethod)
                            {
                            case DiscountOfferMethod.OfferPrice:
                                result = x.OfferPrice.CompareTo(y.OfferPrice);
                                break;

                            case DiscountOfferMethod.DiscountAmount:
                                result = y.DiscountAmount.CompareTo(x.DiscountAmount);
                                break;

                            case DiscountOfferMethod.DiscountPercent:
                                result = y.DiscountPercentage.CompareTo(x.DiscountPercentage);
                                break;
                            }
                        }
                    }
                }
                else if (y == null)
                {
                    result = 1;
                }
                else
                {
                    result = -1;
                }

                return(result);
            }