Example: nails

Per product price precision

1. Model price precision per product per unit of measure
2. Model price precision per product for the default unit of measure, and convert the precision when converting the unit of measure. (There may be some rounding of precision.)

Best price within priority and compound across

Individual discount design

Sample and tests in SDK

Example: wine

Dual unit of measure analysis

Variant-specific

Not the same as common case of unit of measure conversion.

Two models of dual unit of measures

Per product (or variant) unit of measure conversion

Per barcode unit of measure conversion

Setup

• One qualifying group with amount threshold
• One application group with fixed quantity

Preliminary analysis

How to apply the mix and match when it is (or as if it were) the only discount for the checkout cart?

• If the price of an item >= the minimal amount threshold, then it itself can make a qualifying group. We can single them out and work on the rest. From now on, we will assume all item prices < minimal amount threshold.
• First, we can get maximum number of discount applications possible, by dividing total price by the minimal amount threshold. During the evaluation, if we reach it, then we can quit.
• In addition, we may adjust maximum number of discount applications possible by checking number of application groups

1. Satisfying: for each group, sum(number) > = threshold number
2. Maximizing the number of groups, up to the possible maximum number of groups.

Qualifying group and application group overlap

Multiple mix and match discounts with amount threshold

    public interface IDiscountPackage
    {
        PeriodicDiscountOfferType DiscountOfferType { get; }

        DiscountBase CreateDiscount(PeriodicDiscount discountAndLine);

        void LoadDiscountDetails(
            Dictionary<string, DiscountBase> offerIdToDiscountMap,
            IPricingDataAccessor pricingDataManager,
            SalesTransaction transaction);
    }

    public class DiscountPackageAmountCap : IDiscountPackage
    {
        private IDataAccessorAmountCap amountCapDataAccessor;

        public DiscountPackageAmountCap(IDataAccessorAmountCap amountCapDataAccessor)
        {
            this.amountCapDataAccessor = amountCapDataAccessor;
        }

        public PeriodicDiscountOfferType DiscountOfferType
        {
            get { return (PeriodicDiscountOfferType)AmountCapDiscount.PeriodicDiscountOfferTypeAmountCap; }
        }

        public DiscountBase CreateDiscount(PeriodicDiscount discountAndLine)
        {
            ThrowIf.Null(discountAndLine, "discountAndLine");
            return new AmountCapDiscount(discountAndLine.ValidationPeriod);
        }

        public void LoadDiscountDetails(
            Dictionary<string, DiscountBase> offerIdToDiscountMap,
            IPricingDataAccessor pricingDataManager,
            SalesTransaction transaction)
        {
            ThrowIf.Null(offerIdToDiscountMap, "offerIdToDiscountMap");

            IEnumerable amountCapOfferIds = offerIdToDiscountMap.Where(p => (int)p.Value.PeriodicDiscountType == AmountCapDiscount.PeriodicDiscountOfferTypeAmountCap).Select(p => p.Key);
            if (amountCapOfferIds.Any())
            {
                IEnumerable caps = this.amountCapDataAccessor.GetDiscountAmountCapsByOfferIds(amountCapOfferIds) as IEnumerable;

                foreach (DiscountAmountCap cap in caps)
                {
                    AmountCapDiscount discount = offerIdToDiscountMap[cap.OfferId] as AmountCapDiscount;
                    if (discount != null)
                    {
                        discount.DiscountAmountCap = cap.AmountCap;
                        discount.ApplyBaseReduction = cap.ApplyBaseReduction;
                    }
                }
            }
        }
    }

    IDiscountPackage package = new DiscountPackageAmountCap(new ChannelDataAccessorAmountCap(requestContext));
    PricingEngineExtensionRepository.RegisterDiscountPackage(package);

Mock your new discount type

1. (Folder TestDataManager) Extends PeriodicDisocuntData and PeriodicDiscountLineData from test foundation. See ExtensionDiscountData and ExtensionDiscountLineData.
2. (Folder TestDataManager\SampleData) Add xml file for your discount data. See DiscountOffersAmountCap.xml or DiscountOffersLineFilter.xml. If a price group is associated with a non-zero priority, add it to ExtensionPriceGroups.xml
3. (Folder TestDataManager) PricingSampleRepository: read extension discount data from xml
4. (Folder TestDataManager) GlobalTestSampleDataCache: your sample data global cache.
5. (Folder TestDataManager) ExtensionTestPricingDataManager. You can override ReadRetailDiscounts and GetRetailDiscountPriceGroups. In addition, it needs to support your own extension data access interface.

Now you can have fun with your new discount type and your tests.

Test Foundation Core Data

Introduce the test foundation for Dynamics retail pricing engine.

1. Mock pricing data accessor with XML. If you remember, we have IPricingDataAccessor to bridge the difference between AX and channel data access.
2. Automatic validation of data integrity.
3. Miscellaneous utilities.

Now, technical details.

Test data interface ITransactionSetupAndDataManager

1. Test configurations: concurrency control model, compound behavior, and hold-or-split-for-rounding, etc.
2. AddPriceGroupToTransaction and AddPriceGroupsToTransaction: this sets up the (mock) discounts for the discount calculation.

Default mock implementation of ITransactionSetupAndDataManager

Data integration verification

Mock (main) discount data types.

Helpers

Test Foundation Core Data

One pricing engine serves all retail channels

1. Retail server calls pricing services via commence runtime framework, which in turn calls pricing engine.
2. AX calls pricing engine directly, as AX does not understand commerce runtime.

Now onto extensibility.

First, the schema, the form and CDX

1. [AX schema extension (5)] new table(s)
2. [AX form extension (6)] RetailPeriodicDiscount form extension
3. [Channel database schema (8)] new table(s), view(s) and/or stored procedure(s).
4. [CDX extension (7)] manual setup.

Secondly, core pricing engine

1. [pricing engine extension (1)] Create a new discount type.
2. [pricing engine extension (1)] Register the discount type in retail discount store that loads discount data from database and instantiates discount types
3. [pricing data accessor interface extension (3)]

Thirdly, channel stack

1. [pricing services extension (2)] Register the retail discount store extension at the top of commerce runtime pricing services extension. Instantiate the extension data accessor and pass it to the pricing engine.
2. [pricing data accessor channel extension (4)] Derive from PricingDataServiceManager and implement the extension interface.

Lastly, the AX stack

1. [pricing data accessor AX extension (9)] derive from RetailPricingDataManager and RetailPricingDataManagerSimulator
2. [AX pricing proxy (10)] Equivalent to channel side commerce runtime pricing services extension: register the retail discount store extension. Instantiate the extension AX data accessor and pass it to the pricing engine.

1. Smallest amount: $0.01
2. Unit amount not-rounded is $1.42857143 (10 / 7)
3. Take the floor: $1.42
4. Remainder: $0.06 ($10 – 7 * $1.42)
5. Remainder / smallest amount: 6 ($0.06/0.01)
6. Split the sales line with quantity 7 into two:
7. Quantity 1 (7 – 6) with discount amount $1.42
8. Quantity 6 with discount amount $1.43 ($1.42 + $0.01)

     decimal smallestAmount = PriceContextHelper.GetSmallestNonNegativeAmount(
         priceContext,
         Math.Min(discountAmount, price));
     if (smallestAmount > decimal.Zero && quantityToApply > decimal.Zero)
     {
         int totalDiscountAmountInSmallestAmount = (int)(discountAmount / smallestAmount);
         int averageDiscountAmountRoundingDownInSmallestAmount =
             totalDiscountAmountInSmallestAmount / (int)quantityToApply;
         decimal quantityForHigherDiscountAmount = totalDiscountAmountInSmallestAmount -
                                   (averageDiscountAmountRoundingDownInSmallestAmount * (int)quantityToApply);
         decimal quantityForLowerDiscountAmount = quantityToApply - quantityForHigherDiscountAmount;
         decimal unitDiscountAmountForLowerDiscountAmount =
                 averageDiscountAmountRoundingDownInSmallestAmount * smallestAmount;

         if (quantityForHigherDiscountAmount > decimal.Zero)
         {             
             DiscountLine discountLine = this.NewDiscountLine(
                 appliedDiscountApplication.DiscountApplication.DiscountCode,
                 discountableItemGroups[itemIndex].ItemId);
             discountLine.DiscountAmount = unitDiscountAmountForLowerDiscountAmount + smallestAmount;
             appliedDiscountApplication.AddDiscountLine(
                 itemGroupIndex,
                 new DiscountLineQuantity(discountLine, quantityForHigherDiscountAmount));
         }

         if (quantityForLowerDiscountAmount > decimal.Zero
             && unitDiscountAmountForLowerDiscountAmount > decimal.Zero)
         {
             DiscountLine discountLine = this.NewDiscountLine(
                 appliedDiscountApplication.DiscountApplication.DiscountCode,
                 discountableItemGroups[itemIndex].ItemId);
             discountLine.DiscountAmount = unitDiscountAmountForLowerDiscountAmount;
             appliedDiscountApplication.AddDiscountLine(
                 itemGroupIndex,
                 new DiscountLineQuantity(discountLine, quantityForLowerDiscountAmount));
         }
     }

    AppliedDiscountApplication appliedDiscountApplication;
    discountLine.DiscountAmount = totalAmount / quantity; 
    appliedDiscountApplication.AddDiscountLine(
        itemGroupIndex,
        new DiscountLineQuantity(discountLine, quantity, requiresFurtherRounding: true));