/// <summary>
/// Updates all prices.
/// </summary>
/// <param name="context">The request context.</param>
/// <param name="transaction">The sales transaction.</param>
/// <param name="dateToCheck">The date to check.</param>
public void UpdateAllPrices(RequestContext context, SalesTransaction transaction, DateTime dateToCheck)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
var linesToCalculate = transaction.PriceCalculableSalesLines.ToList();
// build price calculation context
string customerAccount = string.IsNullOrWhiteSpace(transaction.CustomerId) ? string.Empty : transaction.CustomerId;
string customerPriceGroup = GetCustomerPriceGroup(context, customerAccount);
PricingDataServiceManager pricingDataManager = new PricingDataServiceManager(context);
var priceContext = PE.PriceContextHelper.CreatePriceContext(context, pricingDataManager, transaction, this.priceParameters, new ChannelCurrencyOperations(context), dateToCheck, customerAccount, customerPriceGroup, transaction.IsTaxIncludedInPrice, PricingCalculationMode.Transaction, DiscountCalculationMode.None);
priceContext.IsTaxInclusive = transaction.IsTaxIncludedInPrice;
// store old line prices
var oldPrices = linesToCalculate.ToDictionary(l => l.LineId, l => l.Price, StringComparer.OrdinalIgnoreCase);
// calculate the prices on the transaction
PE.PricingEngine.CalculatePricesForSalesLines(linesToCalculate, priceContext, pricingDataManager);
// Check if any prices were changed/invalid
foreach (var salesLine in linesToCalculate)
{
if (salesLine.PriceInBarcode && !salesLine.IsPriceOverridden)
{
if (salesLine.Price != 0 && salesLine.Price != salesLine.BarcodeEmbeddedPrice)
{
decimal quantity = salesLine.BarcodeEmbeddedPrice / salesLine.Price;
var roundingRequest = new GetRoundQuantityServiceRequest(quantity, salesLine.UnitOfMeasureSymbol);
var response = context.Execute <GetRoundQuantityServiceResponse>(roundingRequest);
quantity = response.RoundedValue;
salesLine.Quantity = quantity;
salesLine.BarcodeCalculatedQuantity = quantity;
}
else
{
salesLine.Price = salesLine.BarcodeEmbeddedPrice;
salesLine.BarcodeCalculatedQuantity = 1;
}
}
decimal oldPrice = oldPrices[salesLine.LineId];
if (salesLine.Price != oldPrice)
{
salesLine.WasChanged = true;
}
// if price change, raise Price changed notification
RaiseNotificationIfPriceIsChanged(context, oldPrice, salesLine);
// if price is invalid, raise Price invalid notification
RaiseNotificationIfPriceIsInvalid(context, salesLine);
}
}
private static Price GetPriceService(RequestContext context)
{
var pricingDataManager = new PricingDataServiceManager(context);
var salesParameters = pricingDataManager.GetPriceParameters();
return(Price.Create(salesParameters));
}
/// <summary>
/// Calculates price and discount independently for each item.
/// </summary>
/// <param name="request">The pricing request.</param>
/// <returns>The response object.</returns>
private static GetPriceServiceResponse CalculateIndependentPriceAndDiscount(GetIndependentPriceDiscountServiceRequest request)
{
PricingDataServiceManager pricingDataManager = new PricingDataServiceManager(request.RequestContext);
DateTimeOffset today = request.RequestContext.GetNowInChannelTimeZone();
Customer customer = Discount.GetCustomer(request.RequestContext, request.Transaction.CustomerId);
PE.PriceContext priceContext = PE.PriceContextHelper.CreatePriceContext(
request.RequestContext,
pricingDataManager,
request.Transaction,
new ChannelCurrencyOperations(request.RequestContext),
today,
request.Transaction.CustomerId,
customer != null ? customer.PriceGroup : string.Empty,
customer != null ? customer.LineDiscountGroup : string.Empty,
customer != null ? customer.MultilineDiscountGroup : string.Empty,
customer != null ? customer.TotalDiscountGroup : string.Empty,
request.Transaction.IsTaxIncludedInPrice,
PricingCalculationMode.Independent,
DiscountCalculationMode.CalculateOffer,
request.CalculateForNewSalesLinesOnly,
request.NewSalesLineIdSet);
PE.PricingEngine.CalculatePricesForSalesLines(request.Transaction.PriceCalculableSalesLines, priceContext, pricingDataManager);
PE.PricingEngine.CalculateDiscountsForLines(pricingDataManager, request.Transaction, true, priceContext);
return(new GetPriceServiceResponse(request.Transaction));
}
/// <summary>
/// Get independent prices.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="transaction">The transaction.</param>
public void GetIndependentPrices(RequestContext context, SalesTransaction transaction)
{
PricingDataServiceManager pricingDataManager = new PricingDataServiceManager(context);
DateTimeOffset today = context.GetNowInChannelTimeZone();
string customerPriceGroup = GetCustomerPriceGroup(context, transaction.CustomerId);
PE.PriceContext priceContext = PE.PriceContextHelper.CreatePriceContext(context, pricingDataManager, transaction, this.priceParameters, new ChannelCurrencyOperations(context), today, transaction.CustomerId, customerPriceGroup, transaction.IsTaxIncludedInPrice, PricingCalculationMode.Independent, DiscountCalculationMode.None);
PE.PricingEngine.CalculatePricesForSalesLines(transaction.PriceCalculableSalesLines, priceContext, pricingDataManager);
}
/// <summary>
/// Puts prices on the given sales lines according to the PriceContext.
/// </summary>
/// <param name="pricingRequest">The request context.</param>
/// <returns>Response containing updated lines and original context.</returns>
public static GetPricesServiceResponse GetLinePrices(GetPricesServiceRequest pricingRequest)
{
PE.IPricingDataAccessor pricingDataManager = new PricingDataServiceManager(pricingRequest.RequestContext);
PE.PriceContext priceContext = PE.PriceContextHelper.CreatePriceContext(
pricingRequest.RequestContext,
pricingDataManager,
new ChannelCurrencyOperations(pricingRequest.RequestContext),
PE.PriceContextHelper.GetItemIds(pricingRequest.SalesLines),
PE.PriceContextHelper.GetCatalogIds(pricingRequest.SalesLines),
pricingRequest.AffiliationLoyaltyTiers,
pricingRequest.ActiveDate,
pricingRequest.CustomerAccount,
pricingRequest.CustomerPriceGroup,
pricingRequest.PriceCalculationMode,
DiscountCalculationMode.None);
PE.PricingEngine.CalculatePricesForSalesLines(pricingRequest.SalesLines, priceContext, pricingDataManager);
return(new GetPricesServiceResponse(pricingRequest.SalesLines.AsPagedResult(), priceContext.CurrencyCode));
}
private IList <ProductPrice> CalculateProductPrices(RequestContext requestContext, IEnumerable <Product> products)
{
// use truncated date for comparison and price search
DateTimeOffset today = requestContext.GetNowInChannelTimeZone();
// create sales lines for calculation
var salesLines = new List <SalesLine>();
foreach (var product in products)
{
SalesLine salesLine = new SalesLine
{
ItemId = product.ItemId,
InventoryDimensionId = string.Empty,
LineId = System.Guid.NewGuid().ToString("N"),
SalesOrderUnitOfMeasure = product.Rules.DefaultUnitOfMeasure,
Quantity = 1,
ProductId = product.RecordId,
SalesDate = today,
};
salesLines.Add(salesLine);
if (product.IsMasterProduct)
{
foreach (var variant in product.GetVariants())
{
salesLine = new SalesLine
{
ItemId = product.ItemId,
InventoryDimensionId = variant.InventoryDimensionId,
LineId = System.Guid.NewGuid().ToString("N"),
SalesOrderUnitOfMeasure = product.Rules.DefaultUnitOfMeasure,
Quantity = 1,
ProductId = variant.DistinctProductVariantId,
SalesDate = today,
};
salesLines.Add(salesLine);
}
}
}
// set the catalogIds on the sales lines
var productCatalogAssociationRequest = new GetProductCatalogAssociationsDataRequest(salesLines.Select(p => p.ProductId));
productCatalogAssociationRequest.QueryResultSettings = QueryResultSettings.AllRecords;
var productCatalogs = requestContext.Runtime.Execute <GetProductCatalogAssociationsDataResponse>(
productCatalogAssociationRequest,
requestContext).CatalogAssociations;
foreach (var sl in salesLines)
{
sl.CatalogIds.UnionWith(productCatalogs.Where(pc => pc.ProductRecordId == sl.ProductId).Select(pc => pc.CatalogRecordId));
}
// create price context for calculation
ISet <string> itemIds = PE.PriceContextHelper.GetItemIds(salesLines);
var pricingDataManager = new PricingDataServiceManager(requestContext);
var priceContext = PE.PriceContextHelper.CreatePriceContext(requestContext, pricingDataManager, this.priceParameters, new ChannelCurrencyOperations(requestContext), itemIds, PE.PriceContextHelper.GetCatalogIds(salesLines), today, PricingCalculationMode.Independent, DiscountCalculationMode.None);
// calculate product prices
PE.PricingEngine.CalculatePricesForSalesLines(salesLines, priceContext, pricingDataManager);
IList <ProductPrice> prices = new List <ProductPrice>(salesLines.Count);
foreach (var salesLine in salesLines)
{
prices.Add(new ProductPrice
{
ItemId = salesLine.ItemId,
InventoryDimensionId = salesLine.InventoryDimensionId,
ProductId = salesLine.ProductId,
BasePrice = salesLine.BasePrice,
AdjustedPrice = salesLine.AdjustedPrice,
TradeAgreementPrice = salesLine.AgreementPrice
});
}
// return updated product prices
return(prices);
}
/// <summary>
/// Initializes a new instance of the <see cref="Discount"/> class.
/// </summary>
/// <param name="context">The request context.</param>
private Discount(RequestContext context)
{
this.pricingDataManager = new PricingDataServiceManager(context);
}
