/// <summary>
/// Used to get the next
/// </summary>
/// <param name="businessId">Business so we can see colour id correctly</param>
/// <param name="cultureCode">culture for names</param>
/// <param name="periodType">type to get colour for</param>
/// <returns>Period colour of type specified</returns>
public PeriodColor GetNextPeriodColorForPeriodType(long businessId, PeriodTypeEnum periodType, string cultureCode)
{
// Count % max of sequence is done so that it will keep going through the colours
// as more seasons are added
const string SQL_STATEMENT = SQL_GET_STATEMENT + @"
-- Get next colour id for the period type
WHERE pc.Sequence =
(SELECT COUNT(PC.Id) %
(SELECT MAX(Sequence) FROM Pricing.PeriodColor WHERE PeriodTypeCode = @PeriodTypeCode)
+ 1
AS nextSeq
FROM Pricing.Period AS P
INNER JOIN Pricing.PeriodColor AS PC ON P.PeriodColorId = PC.Id
WHERE P.BusinessId = @BusinessId AND PC.PeriodTypeCode = @PeriodTypeCode)
AND pc.PeriodTypeCode = @PeriodTypeCode";
var parameters = new List<SqlParameter>
{
DbHelper.CreateParameter(PeriodColorMapper.Parameters.PeriodTypeCode, periodType.GetCode()),
DbHelper.CreateParameter(CultureMapper.Parameters.CultureCode, cultureCode),
DbHelper.CreateParameter(PeriodMapper.Parameters.BusinessId, businessId)
};
return DbHelper.CreateInstance(SQL_STATEMENT, PeriodColorMapper.MapReader, parameters: parameters);
}
public bool Equals(PeriodTypeEnum obj)
{
if ((object)obj == null)
{
return(false);
}
return(StringComparer.OrdinalIgnoreCase.Equals(this.Value, obj.Value));
}
public static PeriodType FromTypeEnum(PeriodTypeEnum typeEnum)
{
switch (typeEnum)
{
case PeriodTypeEnum.Day: return(DailySummary);
case PeriodTypeEnum.Week: return(WeeklySummary);
case PeriodTypeEnum.Month: return(MonthlySummary);
default: throw new ArgumentOutOfRangeException(nameof(typeEnum), typeEnum, "Invalid period type enum value");
}
}
/// <summary>
/// Set up a period with one date range and values sent in, only id is required
/// </summary>
/// <param name="id">period id</param>
/// <param name="businessId">business id</param>
/// <param name="name">name of period</param>
/// <param name="periodType">type of period default of season</param>
/// <param name="setPeriodDateRangePeriodIdToZero">true will set period date range period id to 0</param>
/// <param name="periodDateRangeId">id for date range created</param>
/// <returns>Period of your desires</returns>
private static Period CreateValidPeriod(int id, long businessId = 500, string name = "Name",
PeriodTypeEnum periodType = PeriodTypeEnum.Season,
bool setPeriodDateRangePeriodIdToZero = true,
int periodDateRangeId = default(int))
{
return new Period
{
Id = id,
BusinessId = businessId,
Name = name,
PeriodColor = new PeriodColor(),
PeriodType = new PeriodType { PeriodTypeEnum = periodType, Name = Enum.GetName(typeof(PeriodTypeEnum), periodType) },
PeriodDateRanges = new List<PeriodDateRange>
{
new PeriodDateRange
{
Id = periodDateRangeId,
PeriodId = setPeriodDateRangePeriodIdToZero ? 0 : id,
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(50)
}
}
};
}
/// <summary>
/// Get overlap error type
/// </summary>
/// <remarks>
/// This will need fixing if overlap rules get more complex
/// </remarks>
/// <param name="periodTypeEnum">type that had error</param>
/// <returns>overlap type needed</returns>
private PricingPeriodError? GetOverlapError(PeriodTypeEnum periodTypeEnum)
{
switch (periodTypeEnum)
{
case PeriodTypeEnum.Season:
return PricingPeriodError.SeasonOverSeason;
case PeriodTypeEnum.Event:
return PricingPeriodError.EventOverEvent;
case PeriodTypeEnum.Closure:
return PricingPeriodError.ClosureOverClosure;
default:
return PricingPeriodError.Unknown;
}
}
/// <summary>
/// Get the business event for the period type and action
/// </summary>
/// <param name="periodTypeEnum">period type</param>
/// <param name="isCreate">true to get added event, default to false</param>
/// <param name="isEdit">true to get edit event, default to false</param>
/// <param name="isDelete">true to get delete event, default to false</param>
/// <returns>business event to fetch</returns>
private BusinessEventTypesEnum GetBusinessEventForPeriodType(PeriodTypeEnum periodTypeEnum, bool isCreate = false, bool isEdit = false, bool isDelete = false)
{
switch (periodTypeEnum)
{
case PeriodTypeEnum.Season:
{
if (isCreate)
{
return BusinessEventTypesEnum.SeasonPeriodAdded;
}
if (isEdit)
{
return BusinessEventTypesEnum.SeasonPeriodModified;
}
if (isDelete)
{
return BusinessEventTypesEnum.SeasonPeriodDeleted;
}
// if they sent all bools as false, return this
return BusinessEventTypesEnum.SeasonPeriodAdded;
}
case PeriodTypeEnum.Event:
{
if (isCreate)
{
return BusinessEventTypesEnum.EventPeriodAdded;
}
if (isEdit)
{
return BusinessEventTypesEnum.EventPeriodModified;
}
if (isDelete)
{
return BusinessEventTypesEnum.EventPeriodDeleted;
}
// if they sent all bools as false, return this
return BusinessEventTypesEnum.EventPeriodAdded;
}
case PeriodTypeEnum.Closure:
{
if (isCreate)
{
return BusinessEventTypesEnum.ClosurePeriodAdded;
}
if (isEdit)
{
return BusinessEventTypesEnum.ClosurePeriodModified;
}
if (isDelete)
{
return BusinessEventTypesEnum.ClosurePeriodDeleted;
}
// if they sent all bools as false, return this
return BusinessEventTypesEnum.ClosurePeriodAdded;
}
default: // Which should never happen, but just in case
{
return BusinessEventTypesEnum.SeasonPeriodAdded;
}
}
}
/// <summary>
/// Delete a period date range, if no date ranges after, delete the period
/// </summary>
/// <param name="businessId">business to delete period from</param>
/// <param name="periodType">type of period being deleted</param>
/// <param name="periodId">period to potentially delete</param>
/// <param name="periodDateRangeId">date range id to delete</param>
public void DeletePeriod(long businessId, PeriodTypeEnum periodType, int periodId, int periodDateRangeId)
{
// Add tracked event for date range removal
BusinessEventTypesEnum businessEventType = GetBusinessEventForPeriodType(periodType, isDelete: true);
PeriodDateRange pdrDeleted = null;
string reference = string.Empty;
using (var bex = new BusinessTransaction())
{
// Actual delete time
List<PeriodDateRange> dateRangesLeft = periodDateRangeDao.GetAllByPeriodId(periodId);
if (dateRangesLeft.Any(d => d.Id == periodDateRangeId))
{
pdrDeleted = dateRangesLeft.First(d => d.Id == periodDateRangeId);
}
periodDateRangeDao.Remove(periodDateRangeId);
if (dateRangesLeft == null ||
dateRangesLeft.Count == 1) // last one deleted
{
// this is where rates are killed since period is actually killed
// Delete all rates associated with the period
variantRatePlanDao.DeleteRatePlanRatesAssociatedWithPeriod(periodId);
// Delete the period when no date ranges left
periodDao.Remove(periodId);
}
bex.Commit();
}
if (pdrDeleted != null)
{
reference = reference + pdrDeleted.StartDate.ToString(StandardDateTimeFormatProvider.GetShortDBFormat()) + ",";
reference = reference + pdrDeleted.EndDate.ToString(StandardDateTimeFormatProvider.GetShortDBFormat()) + ",";
}
// event for modify of period / date range here
eventTrackingManager.CreateBusinessEventAsync(businessId, businessEventType, reference.TrimEnd(','));
}
private PeriodType(string name, PeriodTypeEnum type, Func <DateRange, string> dateFormat)
{
Type = type;
Name = name;
DateFormat = dateFormat;
}
/// <summary>
/// Returns true if the date range in question overlaps any other date ranges for the business
/// </summary>
/// <param name="periodType">type of event to look in</param>
/// <param name="businessId">business Id</param>
/// <param name="periodDateRange">date range to check</param>
/// <returns>true if it overlaps, false if it doesn't</returns>
public bool IsDateRangeForPeriodTypeOverlapping(PeriodTypeEnum periodType, long businessId, PeriodDateRange periodDateRange)
{
const string SQL_SELECT = @"
SELECT @doesItOverlap =
CASE WHEN (COUNT(pdr.id) > 0)
THEN 1
ELSE 0
END
FROM Pricing.PeriodDateRange pdr
JOIN Pricing.Period p on p.Id = pdr.PeriodId
WHERE p.PeriodTypeCode = @PeriodTypeCode
AND p.BusinessId = @BusinessId
AND ((@StartDate between pdr.StartDate AND pdr.EndDate) OR
(@EndDate between pdr.StartDate AND pdr.EndDate) OR
(pdr.StartDate between @StartDate AND @EndDate) OR
(pdr.EndDate between @StartDate AND @EndDate))
AND (@Id = 0 OR pdr.id <> @Id)
";
var parameters = new List<SqlParameter>
{
DbHelper.CreateParameter(PeriodDateRangeMapper.Parameters.StartDate, periodDateRange.StartDate.Date),
DbHelper.CreateParameter(PeriodDateRangeMapper.Parameters.EndDate, periodDateRange.EndDate.Date),
DbHelper.CreateParameter(PeriodDateRangeMapper.Parameters.Id, periodDateRange.Id),
DbHelper.CreateParameter(PeriodMapper.Parameters.PeriodTypeCode, periodType.GetCode()),
DbHelper.CreateParameter(PeriodMapper.Parameters.BusinessId, businessId)
};
SqlParameter outputKey;
parameters.Add(outputKey = DbHelper.CreateParameterOut<bool>(PeriodDateRangeMapper.Parameters.DoesItOverlap, SqlDbType.Bit));
DbHelper.ExecuteNonQueryCommand(SQL_SELECT, CommandType.Text, parameters);
return DbHelper.ParameterValue<bool>(outputKey);
}
