/// <summary>
/// Create a new DiscountParameters object and initialize from database if possible.
/// </summary>
/// <param name="pricingDataManager">Data manager to access pricing data.</param>
/// <returns>Newly fetched and initialized DiscountParameters object.</returns>
public static DiscountParameters CreateAndInitialize(IPricingDataAccessor pricingDataManager)
{
DiscountParameters parameters = new DiscountParameters();
parameters.GetDiscountParameters(pricingDataManager);
return(parameters);
}
/// <summary>
/// Gets category to product or variant identifiers lookup for all items applicable of price on the transaction.
/// </summary>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="productOrVariantIdsInTransaction">Product or variant identifiers in transaction.</param>
/// <returns>A dictionary of category to product categories.</returns>
private static Dictionary <long, IList <RetailCategoryMember> > GetCategoryToProductOrVariantIdsMapForTransaction(
IPricingDataAccessor pricingDataManager,
ISet <long> productOrVariantIdsInTransaction)
{
Dictionary <long, IList <RetailCategoryMember> > result = new Dictionary <long, IList <RetailCategoryMember> >();
IEnumerable <RetailCategoryMember> allProductCategories = pricingDataManager.GetRetailCategoryMembersForItems(productOrVariantIdsInTransaction) as IEnumerable <RetailCategoryMember>;
if (allProductCategories != null)
{
foreach (RetailCategoryMember productCategory in allProductCategories)
{
IList <RetailCategoryMember> productCategories = null;
if (result.TryGetValue(productCategory.CategoryId, out productCategories))
{
productCategories.Add(productCategory);
}
else
{
productCategories = new List <RetailCategoryMember>()
{
productCategory
};
result.Add(productCategory.CategoryId, productCategories);
}
}
}
return(result);
}
/// <summary>
/// Returns variant from sales line (if not null), otherwise, retrieves from the database.
/// </summary>
/// <param name="pricingDataManager">Instance of data manager to look up the data.</param>
/// <param name="salesLine">SalesLine to retrieve Variant from, or fetch from DB if missing.</param>
/// <returns>
/// Variant if found. If no variant found or the line doesn't have a variant, returns null.
/// </returns>
private static ProductVariant GetVariantFromLineOrDatabase(IPricingDataAccessor pricingDataManager, SalesLine salesLine)
{
string itemId = salesLine.ItemId;
string inventDimId = salesLine.InventoryDimensionId;
ProductVariant variant = null;
if (!string.IsNullOrWhiteSpace(inventDimId))
{
if (salesLine.Variant == null || salesLine.Variant.DistinctProductVariantId == 0)
{
HashSet <ItemVariantInventoryDimension> itemVariantIds = new HashSet <ItemVariantInventoryDimension>();
itemVariantIds.Add(new ItemVariantInventoryDimension(itemId, inventDimId));
ReadOnlyCollection <ProductVariant> variants = pricingDataManager.GetVariants(itemVariantIds) as ReadOnlyCollection <ProductVariant>;
variant = variants.Count > 0 ? variants[0] : new ProductVariant();
}
else
{
variant = salesLine.Variant;
}
}
return(variant);
}
/// <summary>
/// Create a new instance of the <see cref="PriceContext"/> class for price calculation.
/// </summary>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="priceCalculationMode">Price calculation mode.</param>
/// <param name="discountCalculationMode">Discount calculation mode.</param>
/// <param name="itemIds">Item Ids.</param>
/// <param name="catalogIds">Catalog identifiers.</param>
/// <param name="affiliationLoyaltyTiers">Affiliation or loyalty tier identifiers.</param>
/// <param name="customerId">Customer Id.</param>
/// <param name="customerPriceGroup">Customer price group.</param>
/// <param name="priceIncludesTax">Price includes tax.</param>
/// <param name="currencyCode">Currency code.</param>
/// <param name="activeDate">Active date.</param>
/// <returns>A new instance of the <see cref="PriceContext"/> class.</returns>
public static PriceContext CreatePriceContext(
IPricingDataAccessor pricingDataManager,
ICurrencyOperations currencyAndRoundingHelper,
PricingCalculationMode priceCalculationMode,
DiscountCalculationMode discountCalculationMode,
ISet <string> itemIds,
ISet <long> catalogIds,
IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers,
string customerId,
string customerPriceGroup,
bool priceIncludesTax,
string currencyCode,
DateTimeOffset activeDate)
{
PriceContext priceContext = CreatePriceContext(
pricingDataManager,
currencyAndRoundingHelper,
priceCalculationMode,
discountCalculationMode,
itemIds,
catalogIds,
affiliationLoyaltyTiers,
customerId,
customerPriceGroup,
string.Empty,
string.Empty,
string.Empty,
priceIncludesTax,
currencyCode,
activeDate);
return(priceContext);
}
/// <summary>
/// Create a new instance of the <see cref="PriceContext"/> class.
/// </summary>
/// <param name="requestContext">Request context.</param>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="priceParameters">Price parameters.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="itemIds">Item Ids.</param>
/// <param name="catalogIds">Catalog identifiers.</param>
/// <param name="activeDate">Active date.</param>
/// <param name="priceCalculationMode">Price calculation mode.</param>
/// <param name="discountCalculationMode">Discount calculation mode.</param>
/// <returns>A new instance of the <see cref="PriceContext"/> class.</returns>
public static PriceContext CreatePriceContext(
RequestContext requestContext,
IPricingDataAccessor pricingDataManager,
PriceParameters priceParameters,
ICurrencyOperations currencyAndRoundingHelper,
ISet <string> itemIds,
ISet <long> catalogIds,
DateTimeOffset activeDate,
PricingCalculationMode priceCalculationMode,
DiscountCalculationMode discountCalculationMode)
{
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
PriceContext priceContext = new PriceContext
{
CurrencyAndRoundingHelper = currencyAndRoundingHelper,
ActiveDate = activeDate,
PriceParameters = priceParameters,
PriceCalculationMode = priceCalculationMode,
DiscountCalculationMode = discountCalculationMode,
};
PriceContextHelper.InitializePriceContextOfInferredProperties(priceContext, pricingDataManager, requestContext, itemIds, catalogIds, null);
return(priceContext);
}
private static ReadOnlyCollection <PeriodicDiscount> GetRetailDiscounts(
IEnumerable <SalesLine> salesLines,
PriceContext priceContext,
IPricingDataAccessor pricingDataManager,
QueryResultSettings settings)
{
// don't do lookup if there aren't any price groups to search by
HashSet <string> allPriceGroups = PriceContextHelper.GetAllPriceGroupsForDiscount(priceContext);
if (allPriceGroups.Count == 0)
{
return(new ReadOnlyCollection <PeriodicDiscount>(new PeriodicDiscount[0]));
}
var items = salesLines.Select(l => new ItemUnit
{
ItemId = l.ItemId,
VariantInventoryDimensionId = l.InventoryDimensionId ?? string.Empty,
UnitOfMeasure = Discount.GetUnitOfMeasure(l),
});
ReadOnlyCollection <PeriodicDiscount> discounts =
pricingDataManager.ReadRetailDiscounts(items, allPriceGroups, priceContext.ActiveDate, priceContext.ActiveDate, priceContext.CurrencyCode, settings) as ReadOnlyCollection <PeriodicDiscount>;
ReadOnlyCollection <PeriodicDiscount> validDiscounts =
discounts.Where(d => InternalValidationPeriod.ValidateDateAgainstValidationPeriod((DateValidationType)d.DateValidationType, d.ValidationPeriod, d.ValidFromDate, d.ValidToDate, priceContext.ActiveDate)).AsReadOnly();
return(validDiscounts);
}
private static Discount InitializeDiscountEngine(IPricingDataAccessor pricingDataManager)
{
Discount discountEngine = Discount.Create();
discountEngine.Initialize(pricingDataManager);
return(discountEngine);
}
/// <summary>
/// This method will calculate the prices for the whole sales transaction.
/// </summary>
/// <param name="salesTransaction">Sales transaction.</param>
/// <param name="pricingDataManager">Provides access to the pricing data to the pricing calculation.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="customerPriceGroup">Customer price group.</param>
/// <param name="currencyCode">Current code.</param>
/// <param name="activeDate">Active date time offset for price.</param>
/// <remarks>Parallel processing has been disabled, but we leave parameter here for backward compatibility.</remarks>
public static void CalculatePricesForTransaction(
SalesTransaction salesTransaction,
IPricingDataAccessor pricingDataManager,
ICurrencyOperations currencyAndRoundingHelper,
string customerPriceGroup,
string currencyCode,
DateTimeOffset activeDate)
{
if (salesTransaction == null)
{
throw new ArgumentNullException("salesTransaction");
}
if (pricingDataManager == null)
{
throw new ArgumentNullException("pricingDataManager");
}
if (currencyAndRoundingHelper == null)
{
throw new ArgumentNullException("currencyAndRoundingHelper");
}
ISet <long> catalogIds = PriceContextHelper.GetCatalogIds(salesTransaction);
IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers = PriceContextHelper.GetAffiliationLoyalTierIds(salesTransaction);
ISet <string> itemIds = PriceContextHelper.GetItemIds(salesTransaction);
PriceContext priceContext = PriceContextHelper.CreatePriceContext(
pricingDataManager,
currencyAndRoundingHelper,
PricingCalculationMode.Transaction,
DiscountCalculationMode.None,
itemIds,
catalogIds,
affiliationLoyaltyTiers,
salesTransaction.CustomerId,
customerPriceGroup,
salesTransaction.IsTaxIncludedInPrice,
currencyCode,
activeDate);
bool isDiagnosticsCollected = GetCollectDiagnostics(salesTransaction);
if (isDiagnosticsCollected)
{
priceContext.IsDiagnosticsCollected = true;
priceContext.PricingEngineDiagnosticsObject = new PricingEngineDiagnosticsObject();
}
PricingEngine.CalculatePricesForSalesLines(salesTransaction.PriceCalculableSalesLines, priceContext, pricingDataManager);
if (isDiagnosticsCollected)
{
SetPricingEngineDiagnosticsObject(salesTransaction, priceContext.PricingEngineDiagnosticsObject);
}
}
/// <summary>
/// For all sales lines on the transaction, retrieve the product rec id if it's not already set.
/// </summary>
/// <param name="pricingDataManager">Provides data access to the calculation.</param>
/// <param name="priceContext">Price context.</param>
/// <param name="salesLines">Sales lines.</param>
private static void PopulateProductIds(IPricingDataAccessor pricingDataManager, PriceContext priceContext, IEnumerable <SalesLine> salesLines)
{
var itemVariantIds = new HashSet <ItemVariantInventoryDimension>();
foreach (var line in salesLines)
{
if ((line.Variant == null || line.Variant.DistinctProductVariantId == 0) && !string.IsNullOrWhiteSpace(line.InventoryDimensionId))
{
var itemVariantId = new ItemVariantInventoryDimension(line.ItemId, line.InventoryDimensionId);
itemVariantIds.Add(itemVariantId);
}
}
// We make a single database call to retrieve all variant identifiers that we need
// and create a map using the ItemVariantInventoryDimension as its key.
var variantsMap = new Dictionary <ItemVariantInventoryDimension, ProductVariant>();
if (itemVariantIds.Any())
{
variantsMap = ((IEnumerable <ProductVariant>)pricingDataManager.GetVariants(itemVariantIds)).ToDictionary(key => new ItemVariantInventoryDimension(key.ItemId, key.InventoryDimensionId));
}
// Consider calculable lines only. Ignore voided or return-by-receipt lines.
foreach (var line in salesLines)
{
if (line.MasterProductId == 0)
{
Item item = PriceContextHelper.GetItem(priceContext, line.ItemId);
line.MasterProductId = (item != null) ? item.Product : 0L;
if (item != null && string.IsNullOrWhiteSpace(line.OriginalSalesOrderUnitOfMeasure))
{
line.OriginalSalesOrderUnitOfMeasure = item.SalesUnitOfMeasure;
}
}
if ((line.Variant == null || line.Variant.DistinctProductVariantId == 0) && !string.IsNullOrWhiteSpace(line.InventoryDimensionId))
{
ProductVariant variant;
var itemVariant = new ItemVariantInventoryDimension(line.ItemId, line.InventoryDimensionId);
if (variantsMap.TryGetValue(itemVariant, out variant))
{
line.Variant = variant;
}
}
if (line.ProductId == 0)
{
line.ProductId = line.Variant != null ? line.Variant.DistinctProductVariantId : line.MasterProductId;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IndiaPriceHelper"/> class.
/// </summary>
/// <param name="channelConfiguration">The channel configuration.</param>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="transaction">Current transaction.</param>
/// /// <param name="priceGroup">Customer price group.</param>
/// <returns>The instance of IndiaPriceHelper.</returns>
public IndiaPriceHelper(ChannelConfiguration channelConfiguration, IPricingDataAccessor pricingDataManager, SalesTransaction transaction, string priceGroup)
{
ThrowIf.Null(channelConfiguration, "channelConfiguration");
ThrowIf.Null(pricingDataManager, "pricingDataManager");
ThrowIf.Null(transaction, "transaction");
this.channelConfiguration = channelConfiguration;
this.pricingDataManager = pricingDataManager;
this.salesTransaction = transaction;
this.customerId = transaction.CustomerId;
this.priceGroup = priceGroup;
}
/// <summary>
/// Implements the IPricingCalculator interface to calculate item price trade agreement prices.
/// </summary>
/// <param name="salesLines">The item lines which need prices.</param>
/// <param name="priceContext">The configuration of the overall pricing context for the calculation.</param>
/// <param name="pricingDataManager">Instance of pricing data manager to access pricing data.</param>
/// <returns>Sets of possible price lines keyed by item line Id.</returns>
public Dictionary <string, IEnumerable <PriceLine> > CalculatePriceLines(
IEnumerable <SalesLine> salesLines,
PriceContext priceContext,
IPricingDataAccessor pricingDataManager)
{
Tuple <DateTimeOffset, DateTimeOffset> dateRange = PricingEngine.GetMinAndMaxActiveDates(salesLines, priceContext.ActiveDate);
// look up all trade agreements for given items and context
HashSet <string> itemIds = new HashSet <string>(salesLines.Select(s => s.ItemId).Distinct(), StringComparer.OrdinalIgnoreCase);
ReadOnlyCollection <TradeAgreement> tradeAgreements = pricingDataManager.ReadPriceTradeAgreements(
itemIds,
PriceContextHelper.GetAllPriceGroupsForPrice(priceContext),
priceContext.CustomerAccount,
dateRange.Item1,
dateRange.Item2,
priceContext.CurrencyCode,
QueryResultSettings.AllRecords) as ReadOnlyCollection <TradeAgreement>;
if (priceContext.IsDiagnosticsCollected && tradeAgreements.Any())
{
priceContext.PricingEngineDiagnosticsObject.AddTradeAgreementsConsidered(tradeAgreements.ToList());
}
var agreementsByItemId = IndexAgreementsByItemId(tradeAgreements);
var discountParameters = DiscountParameters.CreateAndInitialize(priceContext.PriceParameters);
Dictionary <string, IEnumerable <PriceLine> > itemPriceLines;
Dictionary <string, decimal> itemQuantites = null;
if (priceContext.PriceCalculationMode == PricingCalculationMode.Transaction)
{
itemQuantites = GetItemQuantities(salesLines);
}
itemPriceLines = new Dictionary <string, IEnumerable <PriceLine> >(StringComparer.OrdinalIgnoreCase);
foreach (SalesLine salesLine in salesLines)
{
Tuple <decimal, string> priceCustPriceGroup = CalculateAgreementPriceLine(salesLines, salesLine, priceContext, agreementsByItemId, discountParameters, itemQuantites);
if (priceCustPriceGroup.Item1 != decimal.Zero)
{
itemPriceLines.Add(salesLine.LineId, new List <PriceLine>(1)
{
ConstructTradeAgreementPriceLine(priceCustPriceGroup)
});
}
}
return(itemPriceLines);
}
private static void InitializeItemCache(
PriceContext priceContext,
IPricingDataAccessor pricingDataManager,
ISet <string> itemIds)
{
if (itemIds != null && itemIds.Count > 0)
{
ReadOnlyCollection <Item> items = pricingDataManager.GetItems(itemIds) as ReadOnlyCollection <Item>;
foreach (Item item in items)
{
priceContext.ItemCache.Add(item.ItemId, item);
}
}
}
/// <summary>
/// Create a new instance of the <see cref="PriceContext"/> class.
/// </summary>
/// <param name="requestContext">Request context.</param>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="transaction">Current transaction.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="activeDate">Active date.</param>
/// <param name="customerId">Customer Id.</param>
/// <param name="customerPriceGroup">Customer price group.</param>
/// <param name="customerLinePriceGroup">Customer line discount price group.</param>
/// <param name="customerMultipleLinePriceGroup">Customer multiple line discount price group.</param>
/// <param name="customerTotalPriceGroup">Customer total discount price group.</param>
/// <param name="priceIncludesTax">Price includes tax.</param>
/// <param name="priceCalculationMode">Price calculation mode.</param>
/// <param name="discountCalculationMode">Discount calculation mode.</param>
/// <param name="calculateForNewSalesLinesOnly">A flag indicating whether to calculate for new sales lines only.</param>
/// <param name="newSalesLineIdSet">New sales line id set.</param>
/// <returns>A new instance of the <see cref="PriceContext"/> class.</returns>
public static PriceContext CreatePriceContext(
RequestContext requestContext,
IPricingDataAccessor pricingDataManager,
SalesTransaction transaction,
ICurrencyOperations currencyAndRoundingHelper,
DateTimeOffset activeDate,
string customerId,
string customerPriceGroup,
string customerLinePriceGroup,
string customerMultipleLinePriceGroup,
string customerTotalPriceGroup,
bool priceIncludesTax,
PricingCalculationMode priceCalculationMode,
DiscountCalculationMode discountCalculationMode,
bool calculateForNewSalesLinesOnly,
HashSet <string> newSalesLineIdSet)
{
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
PriceContext priceContext = new PriceContext
{
CurrencyAndRoundingHelper = currencyAndRoundingHelper,
ActiveDate = activeDate,
CustomerAccount = customerId,
CustomerPriceGroup = customerPriceGroup,
CustomerLinePriceGroup = customerLinePriceGroup,
CustomerMultipleLinePriceGroup = customerMultipleLinePriceGroup,
CustomerTotalPriceGroup = customerTotalPriceGroup,
IsTaxInclusive = priceIncludesTax,
PriceCalculationMode = priceCalculationMode,
DiscountCalculationMode = discountCalculationMode,
CalculateForNewSalesLinesOnly = calculateForNewSalesLinesOnly,
};
if (newSalesLineIdSet != null && newSalesLineIdSet.Count > 0)
{
priceContext.NewSalesLineIdSet.AddRange(newSalesLineIdSet);
}
ISet <long> catalogIds = GetCatalogIds(transaction);
IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers = GetAffiliationLoyalTierIds(transaction);
ISet <string> itemIds = GetItemIds(transaction);
PriceContextHelper.InitializePriceContextOfInferredProperties(priceContext, pricingDataManager, requestContext, itemIds, catalogIds, affiliationLoyaltyTiers);
return(priceContext);
}
internal static PriceResult GetActiveTradeAgreement(IPricingDataAccessor pricingDataManager, DiscountParameters priceParameters, string currencyCode, SalesLine saleItem, decimal quantity, string customerId, string customerPriceGroup, DateTimeOffset dateToCheck)
{
dateToCheck = saleItem.SalesDate ?? dateToCheck;
IEnumerable <PriceGroup> priceGroups = pricingDataManager.GetChannelPriceGroups() as IEnumerable <PriceGroup>;
HashSet <string> priceGroupIds = new HashSet <string>(priceGroups.Select(pg => pg.GroupId).Distinct(StringComparer.OrdinalIgnoreCase));
PriceResult result;
ProductVariant variantLine = GetVariantFromLineOrDatabase(pricingDataManager, saleItem);
variantLine = variantLine ?? new ProductVariant();
Tuple <DateTimeOffset, DateTimeOffset> dateRange = GetMinAndMaxActiveDates(new SalesLine[] { saleItem }, dateToCheck);
ReadOnlyCollection <TradeAgreement> agreements = pricingDataManager.ReadPriceTradeAgreements(
new HashSet <string> {
saleItem.ItemId
},
priceGroupIds,
customerId,
dateRange.Item1,
dateRange.Item2,
currencyCode,
QueryResultSettings.AllRecords) as ReadOnlyCollection <TradeAgreement>;
var agreementDict = new Dictionary <string, IList <TradeAgreement> >(StringComparer.OrdinalIgnoreCase);
agreementDict.Add(saleItem.ItemId, agreements);
result = TradeAgreementCalculator.GetPriceResultOfActiveTradeAgreement(
agreementDict,
priceParameters,
currencyCode,
saleItem.ItemId,
saleItem.OriginalSalesOrderUnitOfMeasure,
Discount.GetUnitOfMeasure(saleItem),
variantLine,
saleItem.UnitOfMeasureConversion,
quantity,
customerId,
customerPriceGroup,
priceGroupIds,
new List <SalesLine> {
saleItem
},
new PriceContext(),
dateToCheck);
return(result);
}
/// <summary>
/// Calculate the periodic discounts for the transaction.
/// </summary>
/// <param name="pricingDataManager">Provides data access to the calculation.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="transaction">The sales transaction.</param>
/// <param name="customer">Customer for the transaction containing customer discount groups.</param>
/// <param name="doesPriceIncludeTax">Does the channel have tax-inclusive prices.</param>
/// <param name="currencyCode">Currency code to filter discounts by.</param>
/// <param name="channelDateTime">Channel time.</param>
internal static void GetAllPeriodicDisc(
IPricingDataAccessor pricingDataManager,
ICurrencyOperations currencyAndRoundingHelper,
SalesTransaction transaction,
Customer customer,
bool doesPriceIncludeTax,
string currencyCode,
DateTimeOffset channelDateTime)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
// Clear all periodic, customer, standard, total discounts
ClearDiscountLinesOfType(transaction, null);
PriceContext priceContext = BuildPriceContext(pricingDataManager, currencyAndRoundingHelper, customer, transaction, currencyCode, channelDateTime, doesPriceIncludeTax, DiscountCalculationMode.CalculateAll);
PricingEngine.PopulateProductIds(pricingDataManager, priceContext, transaction);
ReadOnlyCollection <PeriodicDiscount> periodicDiscountData = GetRetailDiscounts(transaction.ActiveSalesLines, priceContext, pricingDataManager, QueryResultSettings.AllRecords);
foreach (SalesLine salesLine in transaction.PriceCalculableSalesLines)
{
ReadOnlyCollection <PeriodicDiscount> applicablePeriodicDiscounts = Discount.GetPeriodicDiscountData(periodicDiscountData, salesLine.ItemId, salesLine.InventoryDimensionId);
foreach (PeriodicDiscount periodicDiscount in applicablePeriodicDiscounts)
{
var discountLine = new DiscountLine
{
OfferId = periodicDiscount.OfferId,
OfferName = periodicDiscount.Name,
Percentage = periodicDiscount.DiscountPercent,
Amount = periodicDiscount.DiscountAmount,
ConcurrencyMode = periodicDiscount.ConcurrencyMode,
ConcurrencyModeValue = (int)periodicDiscount.ConcurrencyMode,
DiscountLineType = DiscountLineType.PeriodicDiscount,
DiscountLineTypeValue = (int)DiscountLineType.PeriodicDiscount,
PeriodicDiscountType = periodicDiscount.PeriodicDiscountType,
PeriodicDiscountTypeValue = (int)periodicDiscount.PeriodicDiscountType,
DiscountApplicationGroup = salesLine.ItemId,
IsDiscountCodeRequired = periodicDiscount.IsDiscountCodeRequired
};
salesLine.DiscountLines.Add(discountLine);
}
}
}
private static void FixCustomerPriceGroupPriority(IPricingDataAccessor pricingDataManager, PriceContext priceContext)
{
if (!string.IsNullOrEmpty(priceContext.CustomerPriceGroup))
{
// Customer price group may have already been covered by price groups from channel, affiliation, loyalty or catalog.
if (!priceContext.PriceGroupIdToPriorityDictionary.ContainsKey(priceContext.CustomerPriceGroup))
{
PriceGroup customerPriceGroup = pricingDataManager.GetCustomerPriceGroup(priceContext.CustomerPriceGroup);
if (customerPriceGroup != null && customerPriceGroup.PriceGroupId > 0)
{
priceContext.PriceGroupIdToPriorityDictionary.Add(priceContext.CustomerPriceGroup, customerPriceGroup.PricingPriorityNumber);
}
}
}
}
/// <summary>
/// Calculate the customer discount.
/// </summary>
/// <param name="pricingDataManager">Provides data access to the calculation.</param>
/// <param name="salesTransaction">The sales transaction.</param>
/// <param name="priceContext">Context for the pricing calculation.</param>
public void CalcCustomerDiscount(
IPricingDataAccessor pricingDataManager,
SalesTransaction salesTransaction,
PriceContext priceContext)
{
// Fetch all discount trade agreements if the data manager supports it
List <TradeAgreement> lineTradeAgreements = null;
List <TradeAgreement> multiLineTradeAgreements = null;
List <TradeAgreement> totalTradeAgreements = null;
HashSet <string> items = new HashSet <string>(salesTransaction.PriceCalculableSalesLines.Select(sl => sl.ItemId).Distinct(), StringComparer.OrdinalIgnoreCase);
IEnumerable <TradeAgreement> tradeAgreements = pricingDataManager.ReadDiscountTradeAgreements(items, priceContext.CustomerAccount, priceContext.ActiveDate, priceContext.ActiveDate, priceContext.CurrencyCode, QueryResultSettings.AllRecords) as IEnumerable <TradeAgreement>;
lineTradeAgreements = new List <TradeAgreement>();
multiLineTradeAgreements = new List <TradeAgreement>();
totalTradeAgreements = new List <TradeAgreement>();
foreach (var agreement in tradeAgreements)
{
if (agreement.Relation == PriceDiscountType.LineDiscountSales)
{
lineTradeAgreements.Add(agreement);
}
else if (agreement.Relation == PriceDiscountType.MultilineDiscountSales)
{
multiLineTradeAgreements.Add(agreement);
}
else if (agreement.Relation == PriceDiscountType.EndDiscountSales)
{
totalTradeAgreements.Add(agreement);
}
}
// Calculate line discount
var lineDiscountCalculator = new LineDiscountCalculator(this.DiscountParameters, priceContext);
salesTransaction = lineDiscountCalculator.CalcLineDiscount(lineTradeAgreements, salesTransaction);
// Calculate multiline discount
var multilineDiscountCalculator = new MultilineDiscountCalculator(this.DiscountParameters, priceContext);
salesTransaction = multilineDiscountCalculator.CalcMultiLineDiscount(multiLineTradeAgreements, salesTransaction);
// Calculate total discount
var totalDiscountCalculator = new TotalDiscountCalculator(this.DiscountParameters, priceContext);
salesTransaction = totalDiscountCalculator.CalcTotalCustomerDiscount(totalTradeAgreements, salesTransaction);
}
/// <summary>
/// Gets all of the periodic discount lines for the items in the transaction.
/// </summary>
/// <param name="pricingDataManager">Provides data access to the calculation.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="transaction">The sales transaction.</param>
/// <param name="currencyCode">Currency code to filter discounts by.</param>
/// <param name="activeDate">Active date in channel date time to apply discount for.</param>
/// <param name="doesPriceIncludeTax">Does the channel have tax-inclusive prices.</param>
/// <remarks>Each sales line will have a collection of periodic discount lines.</remarks>
public static void GetAllPeriodicDiscountsForLines(
IPricingDataAccessor pricingDataManager,
ICurrencyOperations currencyAndRoundingHelper,
SalesTransaction transaction,
string currencyCode,
DateTimeOffset activeDate,
bool doesPriceIncludeTax)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
Customer customer = new Customer();
customer.SetAccountNumber(transaction.CustomerId);
Discount.GetAllPeriodicDisc(pricingDataManager, currencyAndRoundingHelper, transaction, customer, doesPriceIncludeTax, currencyCode, activeDate);
}
/// <summary>
/// Create a new instance of the <see cref="PriceContext"/> class for price or discount calculation.
/// </summary>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="priceCalculationMode">Price calculation mode.</param>
/// <param name="discountCalculationMode">Discount calculation mode.</param>
/// <param name="itemIds">Item Ids.</param>
/// <param name="catalogIds">Catalog identifiers.</param>
/// <param name="affiliationLoyaltyTiers">Affiliation or loyalty tier identifiers.</param>
/// <param name="customerId">Customer Id.</param>
/// <param name="customerPriceGroup">Customer price group.</param>
/// <param name="customerLinePriceGroup">Customer line discount price group.</param>
/// <param name="customerMultipleLinePriceGroup">Customer multiple line discount price group.</param>
/// <param name="customerTotalPriceGroup">Customer total discount price group.</param>
/// <param name="priceIncludesTax">Price includes tax.</param>
/// <param name="currencyCode">Currency code.</param>
/// <param name="activeDate">Active date.</param>
/// <returns>A new instance of the <see cref="PriceContext"/> class.</returns>
public static PriceContext CreatePriceContext(
IPricingDataAccessor pricingDataManager,
ICurrencyOperations currencyAndRoundingHelper,
PricingCalculationMode priceCalculationMode,
DiscountCalculationMode discountCalculationMode,
ISet <string> itemIds,
ISet <long> catalogIds,
IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers,
string customerId,
string customerPriceGroup,
string customerLinePriceGroup,
string customerMultipleLinePriceGroup,
string customerTotalPriceGroup,
bool priceIncludesTax,
string currencyCode,
DateTimeOffset activeDate)
{
if (pricingDataManager == null)
{
throw new ArgumentNullException("pricingDataManager");
}
PriceContext priceContext = new PriceContext
{
CurrencyAndRoundingHelper = currencyAndRoundingHelper,
ActiveDate = activeDate,
CurrencyCode = currencyCode,
CustomerAccount = customerId,
CustomerPriceGroup = customerPriceGroup,
CustomerLinePriceGroup = customerLinePriceGroup,
CustomerMultipleLinePriceGroup = customerMultipleLinePriceGroup,
CustomerTotalPriceGroup = customerTotalPriceGroup,
PriceParameters = pricingDataManager.GetPriceParameters(),
IsTaxInclusive = priceIncludesTax,
PriceCalculationMode = priceCalculationMode,
DiscountCalculationMode = discountCalculationMode,
};
PriceContextHelper.InitializePriceContexOfAlgorithmMode(priceContext, pricingDataManager);
PriceContextHelper.InitializePriceContexOfPriceGroups(priceContext, pricingDataManager, catalogIds, affiliationLoyaltyTiers);
PriceContextHelper.InitializeItemCache(priceContext, pricingDataManager, itemIds);
return(priceContext);
}
internal static Dictionary <long, List <DiscountBase> > GetProductOrVarintToDiscountMapFromCache(
IPricingDataAccessor pricingDataManager,
PriceContext priceContext,
SalesTransaction transaction)
{
ISet <long> productVariantMasterIdsInTransaction = GetProductVariantMasterIdsForTransaction(transaction);
Dictionary <long, IList <RetailCategoryMember> > categorytoProductOrVariantIdsMap = GetCategoryToProductOrVariantIdsMapForTransaction(pricingDataManager, productVariantMasterIdsInTransaction);
IEnumerable <RetailDiscount> allDiscounts = pricingDataManager.GetAllRetailDiscounts() as IEnumerable <RetailDiscount>;
Dictionary <long, List <DiscountBase> > allApplicableDiscounts = new Dictionary <long, List <DiscountBase> >();
foreach (RetailDiscount retailDiscount in allDiscounts)
{
if (!PriceContextHelper.MatchCalculationMode(priceContext, retailDiscount.PeriodicDiscountType))
{
continue;
}
DiscountBase discount = ConvertRetailDiscountToDiscountBase(retailDiscount, priceContext);
discount.ProductOrVariantIdsInTransaction = productVariantMasterIdsInTransaction;
// Product or variant id to categories map is needed to filter which discount lines are applicable for the transaction. See DiscountBase class.
discount.CategoryToProductOrVariantIdsMap = categorytoProductOrVariantIdsMap;
IDictionary <long, IList <RetailDiscountLine> > itemDiscounts = discount.GetProductOrVariantIdToRetailDiscountLinesMap();
foreach (long productOrVariantId in itemDiscounts.Keys)
{
if (allApplicableDiscounts.ContainsKey(productOrVariantId))
{
allApplicableDiscounts[productOrVariantId].Add(discount);
}
else
{
allApplicableDiscounts.Add(productOrVariantId, new List <DiscountBase>()
{
discount
});
}
}
}
return(allApplicableDiscounts);
}
private static PriceContext BuildPriceContext(
IPricingDataAccessor pricingDataManager,
ICurrencyOperations currencyAndRoundingHelper,
Customer customer,
SalesTransaction transaction,
string currencyCode,
DateTimeOffset channelDateTime,
bool doesPriceIncludeTax,
DiscountCalculationMode discountCalculationMode)
{
return(BuildPriceContext(
pricingDataManager,
currencyAndRoundingHelper,
customer,
transaction,
currencyCode,
doesPriceIncludeTax,
discountCalculationMode,
channelDateTime));
}
/// <summary>
/// Calculates all of the discounts for the transactions.
/// </summary>
/// <param name="pricingDataManager">Provides data access to the calculation.</param>
/// <param name="transaction">The sales transaction.</param>
/// <param name="priceContext">The price context.</param>
internal void CalculateDiscount(
IPricingDataAccessor pricingDataManager,
SalesTransaction transaction,
PriceContext priceContext)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
bool priceLock = false;
PricingEngine.PopulateProductIds(pricingDataManager, priceContext, transaction);
// if prices aren't locked on transaction, compute automatic discounts
if (!priceLock)
{
// Clear all the periodic discounts
ClearDiscountLinesOfType(transaction, null);
// Now calculate the discounts.
DiscountCalculator calculator = new DiscountCalculator(transaction, priceContext, pricingDataManager);
calculator.CalculateDiscounts(transaction);
// Calculation of customer discount
// should pass in "sales rounding" rule
if (!string.IsNullOrEmpty(transaction.CustomerId))
{
// Calculation of customer discount
this.CalcCustomerDiscount(pricingDataManager, transaction, priceContext); // should pass in "sales rounding" rule
}
}
// this is manual total discount, it should always be calculated
// technically, this should be a different rounding rule for sales rounding
this.CalculateLineManualDiscount(transaction, priceContext);
this.CalculateTotalManualDiscount(transaction, priceContext);
Discount.CalculateLoyaltyManualDiscount(transaction, priceContext);
}
/// <summary>
/// Gets list of discount lines corresponding to products.
/// </summary>
/// <param name="items">The collection of products.</param>
/// <param name="priceContext">The pricing context.</param>
/// <param name="pricingDataManager">The Pricing data manager.</param>
/// <param name="settings">Query Settings.</param>
/// <returns>List of discounts.</returns>
/// <remarks>The method returns flattened list of discounts which roughly speaking means: it returns 1 line per each possible discount for every product.</remarks>
private static ReadOnlyCollection <PeriodicDiscount> GetRetailDiscountsAndLines(
IEnumerable <ItemUnit> items,
PriceContext priceContext,
IPricingDataAccessor pricingDataManager,
QueryResultSettings settings)
{
// don't do lookup if there aren't any price groups to search by
HashSet <string> allPriceGroups = PriceContextHelper.GetAllPriceGroupsForDiscount(priceContext);
if (allPriceGroups.Count == 0)
{
return(new ReadOnlyCollection <PeriodicDiscount>(new PeriodicDiscount[0]));
}
ReadOnlyCollection <PeriodicDiscount> discounts =
pricingDataManager.ReadRetailDiscounts(items, allPriceGroups, priceContext.ActiveDate, priceContext.ActiveDate, priceContext.CurrencyCode, settings) as ReadOnlyCollection <PeriodicDiscount>;
ReadOnlyCollection <PeriodicDiscount> validDiscounts = discounts.Where(p => InternalValidationPeriod.ValidateDateAgainstValidationPeriod((DateValidationType)p.DateValidationType, p.ValidationPeriod, p.ValidFromDate, p.ValidToDate, priceContext.ActiveDate)).AsReadOnly();
return(validDiscounts);
}
/// <summary>
/// Calculates all of the discount lines for the transactions.
/// </summary>
/// <param name="pricingDataManager">Provides data access to the calculation.</param>
/// <param name="transaction">The sales transaction.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="currencyCode">Currency code to filter discounts by.</param>
/// <param name="lineDiscountGroup">Optional. Line discount group Id for the customer.</param>
/// <param name="multilineDiscountGroup">Optional. Multiline discount group Id for the customer.</param>
/// <param name="totalDiscountGroup">Optional. Total discount group Id for the customer.</param>
/// <param name="shouldTotalLines">True if discount lines should be totaled for each line. False if they should be left as raw discount lines.</param>
/// <param name="calculationMode">Pricing calculation mode.</param>
/// <param name="activeDate">Optional. Active, channel date/time to apply discount for.</param>
/// <remarks>Each sales line will have a collection of DiscountLines and a net discount total in DiscountAmount property (if totaling is enabled).</remarks>
public static void CalculateDiscountsForLines(
IPricingDataAccessor pricingDataManager,
SalesTransaction transaction,
ICurrencyOperations currencyAndRoundingHelper,
string currencyCode,
string lineDiscountGroup,
string multilineDiscountGroup,
string totalDiscountGroup,
bool shouldTotalLines,
DiscountCalculationMode calculationMode,
DateTimeOffset activeDate)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
Customer customer = InitializeCustomer(transaction, lineDiscountGroup, multilineDiscountGroup, totalDiscountGroup);
PriceContext priceContext = Discount.BuildPriceContext(pricingDataManager, currencyAndRoundingHelper, customer, transaction, currencyCode, transaction.IsTaxIncludedInPrice, calculationMode, activeDate);
bool isDiagnosticsCollected = GetCollectDiagnostics(transaction);
if (isDiagnosticsCollected)
{
priceContext.IsDiagnosticsCollected = true;
priceContext.PricingEngineDiagnosticsObject = new PricingEngineDiagnosticsObject();
}
CalculateDiscountsForLines(
pricingDataManager,
transaction,
shouldTotalLines,
priceContext);
if (isDiagnosticsCollected)
{
SetPricingEngineDiagnosticsObject(transaction, priceContext.PricingEngineDiagnosticsObject);
}
}
private static void InitializePriceContextOfInferredProperties(
PriceContext priceContext,
IPricingDataAccessor pricingDataManager,
RequestContext requestContext,
ISet <string> itemIds,
ISet <long> catalogIds,
IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers)
{
if (priceContext == null)
{
throw new ArgumentNullException("priceContext");
}
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
if (pricingDataManager == null)
{
throw new ArgumentNullException("pricingDataManager");
}
if (string.IsNullOrWhiteSpace(priceContext.CurrencyCode))
{
string currencyCode = requestContext.GetChannelConfiguration().Currency;
priceContext.CurrencyCode = currencyCode;
}
if (priceContext.PriceParameters == null)
{
priceContext.PriceParameters = pricingDataManager.GetPriceParameters();
}
InitializePriceContexOfAlgorithmMode(priceContext, pricingDataManager);
InitializePriceContexOfPriceGroups(priceContext, pricingDataManager, catalogIds, affiliationLoyaltyTiers);
InitializeItemCache(priceContext, pricingDataManager, itemIds);
}
public static IDictionary <string, IList <PriceGroup> > GetRetailDiscountPriceGroupDictionaryFilteredByTransaction(
IPricingDataAccessor pricingDataManager,
ISet <string> offerIds,
ISet <string> transactionPriceGroups)
{
if (pricingDataManager == null)
{
throw new ArgumentNullException("pricingDataManager");
}
Dictionary <string, IList <PriceGroup> > ret = new Dictionary <string, IList <PriceGroup> >(StringComparer.OrdinalIgnoreCase);
if (offerIds != null && offerIds.Count > 0 && transactionPriceGroups != null && transactionPriceGroups.Any())
{
IEnumerable <RetailDiscountPriceGroup> discountPriceGroups = pricingDataManager.GetRetailDiscountPriceGroups(offerIds) as IEnumerable <RetailDiscountPriceGroup>;
if (discountPriceGroups != null)
{
foreach (RetailDiscountPriceGroup discountPriceGroup in discountPriceGroups)
{
if (transactionPriceGroups.Contains(discountPriceGroup.GroupId))
{
IList <PriceGroup> priceGroups = null;
if (!ret.TryGetValue(discountPriceGroup.OfferId, out priceGroups))
{
priceGroups = new List <PriceGroup>();
ret.Add(discountPriceGroup.OfferId, priceGroups);
}
priceGroups.Add(discountPriceGroup);
}
}
}
}
return(ret);
}
/// <summary>
/// Create a new instance of the <see cref="PriceContext"/> class.
/// </summary>
/// <param name="requestContext">Request context.</param>
/// <param name="pricingDataManager">Pricing data manager.</param>
/// <param name="transaction">Current transaction.</param>
/// <param name="priceParameters">Price parameters.</param>
/// <param name="currencyAndRoundingHelper">Currency and rounding helper.</param>
/// <param name="activeDate">Active date.</param>
/// <param name="customerId">Customer Id.</param>
/// <param name="customerPriceGroup">Customer price group.</param>
/// <param name="priceIncludesTax">Price includes tax.</param>
/// <param name="priceCalculationMode">Price calculation mode.</param>
/// <param name="discountCalculationMode">Discount calculation mode.</param>
/// <returns>A new instance of the <see cref="PriceContext"/> class.</returns>
public static PriceContext CreatePriceContext(
RequestContext requestContext,
IPricingDataAccessor pricingDataManager,
SalesTransaction transaction,
PriceParameters priceParameters,
ICurrencyOperations currencyAndRoundingHelper,
DateTimeOffset activeDate,
string customerId,
string customerPriceGroup,
bool priceIncludesTax,
PricingCalculationMode priceCalculationMode,
DiscountCalculationMode discountCalculationMode)
{
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
PriceContext priceContext = new PriceContext
{
CurrencyAndRoundingHelper = currencyAndRoundingHelper,
ActiveDate = activeDate,
CustomerAccount = customerId,
CustomerPriceGroup = customerPriceGroup,
IsTaxInclusive = priceIncludesTax,
PriceParameters = priceParameters,
PriceCalculationMode = priceCalculationMode,
DiscountCalculationMode = discountCalculationMode,
};
ISet <long> catalogIds = GetCatalogIds(transaction);
IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers = GetAffiliationLoyalTierIds(transaction);
ISet <string> itemIds = GetItemIds(transaction);
PriceContextHelper.InitializePriceContextOfInferredProperties(priceContext, pricingDataManager, requestContext, itemIds, catalogIds, affiliationLoyaltyTiers);
return(priceContext);
}
private static void InitializePriceContexOfPriceGroups(PriceContext priceContext, IPricingDataAccessor pricingDataManager, ISet <long> catalogIds, IEnumerable <AffiliationLoyaltyTier> affiliationLoyaltyTiers)
{
if (priceContext == null)
{
throw new ArgumentNullException("priceContext");
}
if (pricingDataManager == null)
{
throw new ArgumentNullException("pricingDataManager");
}
IEnumerable <PriceGroup> channelPriceGroups = pricingDataManager.GetChannelPriceGroups() as IEnumerable <PriceGroup>;
AddPriceGroupsToCollections(
channelPriceGroups,
priceContext.ChannelPriceGroups,
priceContext.PriceGroupIdsToRecordIdsDictionary,
priceContext.RecordIdsToPriceGroupIdsDictionary,
priceContext.PriceGroupIdToPriorityDictionary);
IEnumerable <CatalogPriceGroup> catalogPriceGroups = catalogIds != null && catalogIds.Count > 0 ? pricingDataManager.GetCatalogPriceGroups(catalogIds) as IEnumerable <CatalogPriceGroup> : new List <CatalogPriceGroup>().AsReadOnly();
IEnumerable <PriceGroup> affiliationPriceGroups = affiliationLoyaltyTiers != null && affiliationLoyaltyTiers.Any() ? pricingDataManager.GetAffiliationPriceGroups(affiliationLoyaltyTiers) as IEnumerable <PriceGroup> : new List <PriceGroup>().AsReadOnly();
foreach (CatalogPriceGroup catalogPriceGroup in catalogPriceGroups)
{
if (!priceContext.CatalogPriceGroups.ContainsKey(catalogPriceGroup.CatalogId))
{
priceContext.CatalogPriceGroups.Add(catalogPriceGroup.CatalogId, new HashSet <string>(StringComparer.OrdinalIgnoreCase));
}
priceContext.CatalogPriceGroups[catalogPriceGroup.CatalogId].Add(catalogPriceGroup.GroupId);
}
priceContext.PriceGroupIdsToRecordIdsDictionary.Merge(catalogPriceGroups.Select(p => new KeyValuePair <string, long>(p.GroupId, p.PriceGroupId)));
priceContext.RecordIdsToPriceGroupIdsDictionary.Merge(catalogPriceGroups.Select(p => new KeyValuePair <long, string>(p.PriceGroupId, p.GroupId)));
priceContext.PriceGroupIdToPriorityDictionary.Merge(catalogPriceGroups.Select(p => new KeyValuePair <string, int>(p.GroupId, p.PricingPriorityNumber)));
AddPriceGroupsToCollections(
affiliationPriceGroups,
priceContext.AffiliationPriceGroups,
priceContext.PriceGroupIdsToRecordIdsDictionary,
priceContext.RecordIdsToPriceGroupIdsDictionary,
priceContext.PriceGroupIdToPriorityDictionary);
FixCustomerPriceGroupPriority(pricingDataManager, priceContext);
}
private static void InitializePriceContexOfAlgorithmMode(PriceContext priceContext, IPricingDataAccessor pricingDataManager)
{
ChannelPriceConfiguration channelPriceConfig = pricingDataManager.GetChannelPriceConfiguration();
priceContext.DiscountAlgorithmMode = channelPriceConfig.DiscountAlgorithmMode;
priceContext.MaxBestDealAlgorithmStepCount = channelPriceConfig.MaxBestDealStepCount;
}
/// <summary>
/// Get discount parameters from the database. These parameters tell what search possibilities are active.
/// Populate the internal set of enabled trade agreement combinations based on fetched values.
/// </summary>
/// <param name="pricingDataManager">The data manager which returns pricing data.</param>
private void GetDiscountParameters(IPricingDataAccessor pricingDataManager)
{
var priceParameters = pricingDataManager.GetPriceParameters();
this.GetDiscountParameters(priceParameters);
}
