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 bool IsAdjustmentActiveOnSalesLine(
SalesLine line,
PriceAdjustment adjustment,
DateTimeOffset defaultDate)
{
var activeDate = line.SalesDate ?? defaultDate;
return(InternalValidationPeriod.ValidateDateAgainstValidationPeriod(
(DateValidationType)adjustment.DateValidationType,
adjustment.ValidationPeriod,
adjustment.ValidFromDate,
adjustment.ValidToDate,
activeDate));
}
/// <summary>
/// Validate date against validation period.
/// </summary>
/// <param name="validationType">Validation type.</param>
/// <param name="validationPeriod">Validation period.</param>
/// <param name="startDate">Pricing start date.</param>
/// <param name="endDate">Pricing end date.</param>
/// <param name="dateToCheck">Date to check.</param>
/// <returns>True if it's valid.</returns>
public static bool ValidateDateAgainstValidationPeriod(DateValidationType validationType, ValidationPeriod validationPeriod, DateTimeOffset startDate, DateTimeOffset endDate, DateTimeOffset dateToCheck)
{
InternalValidationPeriod validation;
bool promoPeriodValid = false;
switch (validationType)
{
case DateValidationType.Advanced:
validation = InternalValidationPeriod.CreateAdvanced(validationPeriod);
promoPeriodValid = validation.IsActive(dateToCheck);
break;
case DateValidationType.Standard:
validation = InternalValidationPeriod.CreateStandard(startDate: startDate, endDate: endDate);
promoPeriodValid = validation.IsActive(dateToCheck);
break;
default:
throw new ArgumentOutOfRangeException("validationType", "Invalid Discount Validation Type: " + validationType);
}
return(promoPeriodValid);
}
/// <summary>
/// For the given date/time is the validation period instance active.
/// </summary>
/// <param name="currentTime">Date/time to check for activity.</param>
/// <returns>True is validation period instance is active for date/time; False otherwise.</returns>
public bool IsActive(DateTimeOffset currentTime)
{
bool promoPeriodValid = false;
if (this.ValidationType == DateValidationType.Advanced)
{
if (this.Period != null)
{
promoPeriodValid = IsValidationPeriodActive(this.Period, currentTime);
}
}
else if (this.ValidationType == DateValidationType.Standard)
{
promoPeriodValid = InternalValidationPeriod.IsDateWithinStartEndDate(currentTime.Date, this.StartDate, this.EndDate);
}
else
{
string error = string.Format(CultureInfo.InvariantCulture, "The validation type '{0}' is not supported.", this.ValidationType);
throw new NotSupportedException(error);
}
return(promoPeriodValid);
}
private static bool IsValidationPeriodActive(ValidationPeriod validationPeriod, DateTimeOffset transDateTime)
{
if (validationPeriod == null || string.IsNullOrEmpty(validationPeriod.PeriodId))
{
// If no period Id given, then it is always a valid period
return(true);
}
DateTime transDate = transDateTime.Date;
TimeSpan transTime = transDateTime.TimeOfDay;
// Is the discount valid within the start and end date period?
if (InternalValidationPeriod.IsDateWithinStartEndDate(transDate, validationPeriod.ValidFrom.Date, validationPeriod.ValidTo.Date))
{
bool answerFound = false;
bool isActive = false;
// does today's configuration tell if period is active?
if (IsRangeDefinedForDay(validationPeriod, transDate.DayOfWeek))
{
isActive = IsPeriodActiveForDayAndTime(validationPeriod, transDate.DayOfWeek, transTime, false);
answerFound = true;
}
// if we don't know or got negative result, see if yesterday will activate it (if its range ends after midnight)
DayOfWeek yesterday = transDate.AddDays(-1).DayOfWeek;
bool lastRangeDefinedAfterMidnight =
IsRangeDefinedForDay(validationPeriod, yesterday) && validationPeriod.IsEndTimeAfterMidnightForDay(yesterday);
if ((!answerFound || isActive == false) && lastRangeDefinedAfterMidnight)
{
// if yesterday makes it active, set isActive = true
isActive = IsPeriodActiveForDayAndTime(validationPeriod, yesterday, transTime, true);
answerFound = true;
}
// if we still don't know, try using general configuration
if (!answerFound)
{
var configuration = new PeriodRangeConfiguration
{
StartTime = validationPeriod.StartingTime,
EndTime = validationPeriod.EndingTime,
IsActiveOnlyWithinBounds = validationPeriod.IsTimeBounded != 0,
EndsTomorrow = validationPeriod.IsEndTimeAfterMidnight != 0
};
if ((validationPeriod.StartingTime != 0) && (validationPeriod.EndingTime != 0))
{
int currentTime = Convert.ToInt32(transTime.TotalSeconds);
isActive = IsTimeActiveForConfiguration(currentTime, configuration, false);
answerFound = true;
}
}
return(answerFound ? isActive : (validationPeriod.IsTimeBounded == 1));
}
// not within date range, so active if not set to be within date range
return(validationPeriod.IsTimeBounded != 1);
}
/// <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);
}
