/// <summary>
/// On yearly frequency build an anniversary temporal expression
/// </summary>
/// <returns></returns>
public UnionTE Create()
{
var union = new UnionTE();
if (_event.FrequencyTypeOptions == FrequencyTypeEnum.Yearly)
{
if (_event.Anniversary == null)
{
throw new ApplicationException("Events with a yearly frequency requires an anniversary.");
}
if (_event.Anniversary.Day < 1 || _event.Anniversary.Day > 31 ||
_event.Anniversary.Month < 1 || _event.Anniversary.Month > 12)
throw new ApplicationException("The anniversary month and day are invalid.");
if (_event.RepeatInterval > 1 && _event.StartDateTime == null)
throw new ApplicationException("Events with a yearly repeat interval greater than one, require a start date.");
// Find the proper start year for the year temporal event, based on the event start date.
int year = DateTime.Now.Year;
if (_event.StartDateTime != null)
{
DateTime startDate = (DateTime)_event.StartDateTime;
if (startDate.Month == _event.Anniversary.Month &&
startDate.Day > _event.Anniversary.Day)
startDate = startDate.AddMonths(1);
year = (startDate.Month > _event.Anniversary.Month) ?
startDate.Year + 1 : startDate.Year;
}
union.Add(new YearTE(_event.RepeatInterval, year, _event.Anniversary.Month, _event.Anniversary.Day));
}
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
var quarters = EnumExtensions.GetFlags(_event.QuarterlyOptions);
var quarterlyIntervals = EnumExtensions.GetFlags(_event.QuarterlyIntervalOptions);
var monthlyIntervals = EnumExtensions.GetFlags(_event.MonthlyIntervalOptions);
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
foreach (QuarterEnum quarter in quarters)
{
foreach (QuarterlyIntervalEnum qInt in quarterlyIntervals)
{
foreach (MonthlyIntervalEnum mInt in monthlyIntervals)
{
foreach (DayOfWeekEnum day in daysOfWeek)
{
var dayInQuarter = new DayInQuarterTE(quarter, qInt, mInt, day);
union.Add(dayInQuarter);
}
}
}
}
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
var firstDayOfWeek = EnumExtensions.GetDayOfWeek(_event.FirstDayOfWeek);
var weeklyIntervals = _event.RepeatInterval;
if (weeklyIntervals > 0 && _event.StartDateTime != null)
{
foreach (DayOfWeekEnum day in daysOfWeek.Cast<DayOfWeekEnum>().OrderBy(e => e, new DayOfWeekEnumComparer(_event.FirstDayOfWeek)))
{
var dayOfWeek = new DayInWeekTE(day, firstDayOfWeek, (DateTime)_event.StartDateTime, weeklyIntervals);
union.Add(dayOfWeek);
}
}
else
{
foreach (DayOfWeekEnum day in daysOfWeek.Cast<DayOfWeekEnum>().OrderBy(e => e, new DayOfWeekEnumComparer(_event.FirstDayOfWeek)))
{
var dayOfWeek = new DayOfWeekTE(day);
union.Add(dayOfWeek);
}
}
return union;
}
private static UnionTE GetHolidays()
{
var union = new UnionTE();
union.Add(new FixedHolidayTE(7, 4));
union.Add(new FloatingHolidayTE(9, DayOfWeekEnum.Mon, MonthlyIntervalEnum.First));
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
foreach(DayOfWeekEnum day in Enum.GetValues(typeof(DayOfWeekEnum)))
{
union.Add(new DayOfWeekTE(day));
}
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
foreach (DayOfWeekEnum day in daysOfWeek)
{
var dayOfWeek = new DayOfWeekTE(day);
union.Add(dayOfWeek);
}
return union;
}
/// <summary>
/// No frequency means a one-time only event
/// </summary>
/// <returns></returns>
public UnionTE Create()
{
var union = new UnionTE();
if (_event.FrequencyTypeOptions == FrequencyTypeEnum.None)
{
if (_event.OneTimeOnlyEventDate.HasValue)
{
union.Add(new DateTE(_event.OneTimeOnlyEventDate.Value));
}
}
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
var firstDateTime = _event.FirstDateTime ?? DateTime.Now;
foreach (DayOfWeekEnum day in Enum.GetValues(typeof(DayOfWeekEnum)))
{
union.Add(new DayIntervalTE(_event.DayInterval, firstDateTime));
}
return union;
}
/// <summary>
/// On yearly frequency build an anniversary temporal expression
/// </summary>
/// <returns></returns>
public UnionTE Create()
{
var union = new UnionTE();
if (_event.FrequencyTypeOptions == FrequencyTypeEnum.Yearly)
{
if (_event.Anniversary == null)
{
throw new ApplicationException("Events with a yearly frequency requires an anniversary.");
}
union.Add(new AnniversaryTE(_event.Anniversary.Month, _event.Anniversary.Day));
}
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
var monthlyIntervals = EnumExtensions.GetFlags(_event.MonthlyIntervalOptions);
foreach (MonthlyIntervalEnum monthlyInterval in monthlyIntervals)
{
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
foreach (DayOfWeekEnum dayOfWeek in daysOfWeek)
{
var dayInMonth = new DayInMonthTE(dayOfWeek, monthlyInterval);
union.Add(dayInMonth);
}
}
return union;
}
public void DailyEventTest4()
{
var holidays = new UnionTE();
holidays.Add(new FixedHolidayTE(2, 4));
var aEvent = new Event()
{
ID = 1,
Title = "Event 4",
FrequencyTypeOptions = FrequencyTypeEnum.Daily,
RepeatInterval = 4,
StartDateTime = new DateTime(2013, 1, 3)
};
var schedule = new Schedule(aEvent, holidays);
Assert.IsTrue(schedule.IsOccurring(new DateTime(2013, 1, 7)));
Assert.IsFalse(schedule.IsOccurring(new DateTime(2013, 1, 13)));
Assert.IsFalse(schedule.IsOccurring(new DateTime(2013, 2, 4)));
}
public UnionTE Create()
{
var union = new UnionTE();
var firstDateTime = _event.StartDateTime ?? DateTime.Now;
if (_event.DayOfMonth == 0 && (int)_event.MonthlyIntervalOptions == 0)
_event.MonthlyIntervalOptions = MonthlyIntervalEnum.EveryWeek;
if (_event.DayOfMonth > 0)
{
var dayInMonth = new MonthTE(_event.RepeatInterval, firstDateTime, _event.DayOfMonth);
union.Add(dayInMonth);
}
else if (_event.MonthlyInterval == (int)MonthlyIntervalEnum.EveryWeek)
{
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
foreach (DayOfWeekEnum dayOfWeek in daysOfWeek)
{
var dayInMonth = new MonthTE(_event.RepeatInterval, firstDateTime, dayOfWeek);
union.Add(dayInMonth);
}
}
else
{
var monthlyIntervals = EnumExtensions.GetFlags(_event.MonthlyIntervalOptions);
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
foreach (MonthlyIntervalEnum monthlyInterval in monthlyIntervals)
{
foreach (DayOfWeekEnum dayOfWeek in daysOfWeek)
{
var dayInMonth = new MonthTE(_event.RepeatInterval, firstDateTime, dayOfWeek, monthlyInterval);
union.Add(dayInMonth);
}
}
}
return union;
}
public UnionTE Create()
{
var union = new UnionTE();
var daysOfWeek = EnumExtensions.GetFlags(_event.DaysOfWeekOptions);
var weeklyIntervals = _event.WeeklyIntervalOptions;
if (weeklyIntervals > 1 && _event.FirstDateTime != null)
{
foreach (DayOfWeekEnum day in daysOfWeek)
{
var dayOfWeek = new DayInWeekTE(day, (DateTime)_event.FirstDateTime, weeklyIntervals);
union.Add(dayOfWeek);
}
}
else
{
foreach (DayOfWeekEnum day in daysOfWeek)
{
var dayOfWeek = new DayOfWeekTE(day);
union.Add(dayOfWeek);
}
}
return union;
}
/// <summary>
/// Create and return a base schedule with no exclusions.
/// </summary>
/// <returns></returns>
private TemporalExpression Create()
{
var union = new UnionTE();
return Create(union);
}
/// <summary>
/// Street cleaning occurs from April to October on the first and third Monday of the
/// month, excluding holidays. In this test there are two holidays: July 4 and Labor
/// Day (first Monday in Sep). The street cleaning example is taken directly from
/// Martin Fowler's white paper "Recurring Events for Calendars".
/// </summary>
private static TemporalExpression BuildStreetCleaningTemporalExpression()
{
var maHolidays = new UnionTE();
var independenceDay = new FixedHolidayTE(7, 4);
var laborDay = new FloatingHolidayTE(9, 1, 1);
maHolidays.Add(independenceDay);
maHolidays.Add(laborDay);
var firstMondayFirstWeek = new DayInMonthTE(1, 1);
var firstMondayThirdWeek = new DayInMonthTE(1, 3);
var firstAndThirdMonday = new UnionTE();
firstAndThirdMonday.Add(firstMondayThirdWeek);
firstAndThirdMonday.Add(firstMondayFirstWeek);
var streetCleaningMonths = new IntersectionTE();
streetCleaningMonths.Add(firstAndThirdMonday);
streetCleaningMonths.Add(new RangeEachYearTE(3, 9));
var diff = new DifferenceTE(streetCleaningMonths, maHolidays);
return diff;
}
/// <summary>
/// The witching hour prep is every Saturday night at midnight in October
/// except on Halloween when the main event occurs (separate event).
/// </summary>
/// <returns></returns>
private static TemporalExpression BuildWitchingHourPrepTemporalExpression()
{
var halloween = new FixedHolidayTE(10, 31);
var holidays = new UnionTE();
holidays.Add(halloween);
var everySaturdayNight = new DayOfMonthTE(6);
var october = new RangeEachYearTE(10);
var saturdays = new UnionTE();
saturdays.Add(everySaturdayNight);
var intersection = new IntersectionTE();
intersection.Add(october);
intersection.Add(saturdays);
var diff = new DifferenceTE(intersection, holidays);
return diff;
}
public void MonthTest5()
{
var holidays = new UnionTE();
holidays.Add(new FixedHolidayTE(1, 25));
holidays.Add(new FloatingHolidayTE(3, DayOfWeekEnum.Mon, MonthlyIntervalEnum.First));
var aEvent = new Event()
{
ID = 1,
Title = "Event 5",
FrequencyTypeOptions = FrequencyTypeEnum.Monthly,
MonthlyIntervalOptions = MonthlyIntervalEnum.EveryWeek,
DaysOfWeekOptions = DayOfWeekEnum.Mon | DayOfWeekEnum.Fri
};
var range = new DateRange()
{
StartDateTime = new DateTime(2013, 1, 15),
EndDateTime = new DateTime(2013, 4, 30)
};
var occurringDate = new DateTime(2013, 1, 21);
var schedule = new Schedule(aEvent, holidays);
Assert.IsTrue(schedule.IsOccurring(occurringDate));
Assert.IsFalse(schedule.IsOccurring(new DateTime(2013, 3, 4)));
var previousOccurrence = schedule.PreviousOccurrence(occurringDate, range);
Assert.AreEqual(new DateTime(2013, 1, 18), previousOccurrence.Value);
var nextOccurrence = schedule.NextOccurrence(occurringDate, range);
Assert.AreEqual(new DateTime(2013, 1, 28), nextOccurrence.Value);
var occurrences = schedule.Occurrences(range);
Assert.AreEqual(28, occurrences.Count());
Assert.AreEqual(new DateTime(2013, 1, 18), occurrences.First());
Assert.AreEqual(new DateTime(2013, 4, 29), occurrences.Last());
}
/// <summary>
/// Create and return a base schedule including exclusions if applicable.
/// </summary>
/// <param name="excludedDates"></param>
/// <returns></returns>
private TemporalExpression Create(IEnumerable<DateTime> excludedDates)
{
var union = new UnionTE();
if (excludedDates != null)
{
foreach (var date in excludedDates)
{
union.Add(new DateTE(date));
}
}
return Create(union);
}
public Schedule(Event aEvent, UnionTE excludedDates)
{
_event = aEvent;
TemporalExpression = Create(excludedDates);
}
