/// <summary>
/// Creates the specified pattern.
/// </summary>
/// <param name="pattern">The pattern.</param>
/// <param name="windowStart">The window start.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">pattern.Frequency</exception>
public static IRecurrence Create(IRecurrencePattern pattern, DateTime windowStart)
{
AsyncServiceException.ThrowIfNull(pattern, "pattern");
switch (pattern.Frequency)
{
case RecurrenceFrequency.Minutely:
return new ConstantPeriodRecurrence(TimeSpan.FromMinutes(1.0), pattern.Interval,
pattern.PatternStart, windowStart);
case RecurrenceFrequency.Hourly:
return new ConstantPeriodRecurrence(TimeSpan.FromHours(1.0), pattern.Interval, pattern.PatternStart,
windowStart);
case RecurrenceFrequency.Daily:
return new ConstantPeriodRecurrence(TimeSpan.FromDays(1.0), pattern.Interval, pattern.PatternStart,
windowStart);
case RecurrenceFrequency.Weekly:
if (pattern.ByDay.Length == 0)
{
return new ConstantPeriodRecurrence(TimeSpan.FromDays(7.0), pattern.Interval,
pattern.PatternStart, windowStart);
}
IModifier modifier = new ByDayWeeklyModifier(pattern.ByDay, pattern.WeekStartDay);
IRecurrence recurrence = new WeeklyRecurrence(pattern.Interval, pattern.PatternStart,
pattern.WeekStartDay, windowStart);
return new ModifiedRecurrence(recurrence, modifier, windowStart);
case RecurrenceFrequency.Yearly:
return new YearlyRecurrence(pattern.Interval, pattern.ByMonth, pattern.ByMonthDay, pattern.PatternStart, windowStart);
case RecurrenceFrequency.Secondly:
return new ConstantPeriodRecurrence(TimeSpan.FromSeconds(1.0), pattern.Interval,
pattern.PatternStart, windowStart);
default:
throw new ArgumentException(string.Format("不合法的重复频率{0}。", pattern.Frequency), "pattern.Frequency");
}
}
public void GetOccurrences_Weekends_Until()
{
var recurrence = new WeeklyRecurrence(DaysOfWeek.Weekends, 1, new DateTime(2017, 2, 25));
var occurrences = recurrence.GetOccurrences(from).ToList();
CollectionAssert.AreEqual(new[]
{
from.AddDays(3),
from.AddDays(4),
from.AddDays(10),
}, occurrences);
}
public void GetOccurrences_NoneDaysOfWeek()
{
var recurrence = new WeeklyRecurrence(DaysOfWeek.None, 2, null);
var occurrences = recurrence.GetOccurrences(from).Take(4).ToList();
CollectionAssert.AreEqual(new[]
{
from.AddDays(0),
from.AddDays(14),
from.AddDays(28),
from.AddDays(42),
}, occurrences);
}
public void GetOccurrences_Weekends_EverySecond()
{
var recurrence = new WeeklyRecurrence(DaysOfWeek.Weekends, 2, null);
var occurrences = recurrence.GetOccurrences(from).Take(5).ToList();
CollectionAssert.AreEqual(new[]
{
from.AddDays(3),
from.AddDays(4),
from.AddDays(17),
from.AddDays(18),
from.AddDays(31),
}, occurrences);
}
public void GetOccurrences_EveryDay_EverySecond()
{
var recurrence = new WeeklyRecurrence(DaysOfWeek.EveryDay, 2, null);
var occurrences = recurrence.GetOccurrences(from).Take(9).ToList();
CollectionAssert.AreEqual(new[]
{
from.AddDays(0),
from.AddDays(1),
from.AddDays(2),
from.AddDays(3),
from.AddDays(4),
from.AddDays(5),
from.AddDays(6),
from.AddDays(14),
from.AddDays(15),
}, occurrences);
}
public void CanCalculateRecurrenceSet()
{
#region Arrange
var validStartDateTime = new DateTime(2014, 2, 17);
const int validWeeksBetweenOccurrences = 1;
var validIncludedWeekDays = new List<DayOfWeek>
{
DayOfWeek.Monday,
DayOfWeek.Wednesday,
DayOfWeek.Saturday
};
// end on Saturday two weeks from the start date
DateTime validEndDateTime =
validStartDateTime.AddDays((DayOfWeek.Saturday - DayOfWeek.Monday)).AddDays(7*2);
var validWeeklyRecurrence = new WeeklyRecurrence(validStartDateTime, validWeeksBetweenOccurrences,
validIncludedWeekDays, validEndDateTime);
var expectedRecurrenceSet = new List<DateTime>
{
// DateTimes from first occurrence
validStartDateTime,
validStartDateTime.AddDays(DayOfWeek.Wednesday - DayOfWeek.Monday),
validStartDateTime.AddDays(DayOfWeek.Saturday - DayOfWeek.Monday),
// DateTimes from second occurrence
validStartDateTime.AddDays(7*2),
validStartDateTime.AddDays(DayOfWeek.Wednesday - DayOfWeek.Monday).AddDays(7*2),
validStartDateTime.AddDays(DayOfWeek.Saturday - DayOfWeek.Monday).AddDays(7*2)
};
#endregion
#region Act
IEnumerable<DateTime> recurrenceSet = validWeeklyRecurrence.CalculateRecurrenceSet();
#endregion
#region Assert
Assert.IsTrue(expectedRecurrenceSet.SequenceEqual(recurrenceSet));
#endregion
}
/// Function: Convert PWRecurrenceInfo... to WeeklyRecurrence
/// Author : Jerry Xu
/// Date : 2008-12-6
/// </summary>
/// <param name="recurrence">PWRecurrenceInfo</param>
/// <returns>WeeklyRecurrence</returns>
private WeeklyRecurrence ConvertWeeklyPattern(PWRecurrenceInfo recurrence)
{
WeeklyRecurrence item = new WeeklyRecurrence();
//if(recurrence.w
int target = 0;
if ((recurrence.WeekDays & PWWeekDays.Monday) == PWWeekDays.Monday)
{
target = (int)WeeklyChoiceType.M;
}
if ((recurrence.WeekDays & PWWeekDays.Tuesday) == PWWeekDays.Tuesday)
{
target = target | (int)WeeklyChoiceType.T;
}
if ((recurrence.WeekDays & PWWeekDays.Wednesday) == PWWeekDays.Wednesday)
{
target = target | (int)WeeklyChoiceType.W;
}
if ((recurrence.WeekDays & PWWeekDays.Thursday) == PWWeekDays.Thursday)
{
target = target | (int)WeeklyChoiceType.TH;
}
if ((recurrence.WeekDays & PWWeekDays.Friday) == PWWeekDays.Friday)
{
target = target | (int)WeeklyChoiceType.F;
}
if ((recurrence.WeekDays & PWWeekDays.Saturday) == PWWeekDays.Saturday)
{
target = target | (int)WeeklyChoiceType.S;
}
if ((recurrence.WeekDays & PWWeekDays.Sunday) == PWWeekDays.Sunday)
{
target = target | (int)WeeklyChoiceType.SU;
}
if (target != 0)
{
item.DaysChoice = (WeeklyChoiceType)target;
}
//item.DaysChoice = (WeeklyChoiceType)Enum.Parse(typeof(WeeklyChoiceType), ((int)recurrence.WeekDays).ToString());
item.RecurCycle = recurrence.Periodicity;
return(item);
}
public void GetOccurrences_EveryDay_Until()
{
var recurrence = new WeeklyRecurrence(DaysOfWeek.EveryDay, 1, new DateTime(2017, 2, 25));
var occurrences = recurrence.GetOccurrences(from).ToList();
CollectionAssert.AreEqual(new[]
{
from.AddDays(0),
from.AddDays(1),
from.AddDays(2),
from.AddDays(3),
from.AddDays(4),
from.AddDays(5),
from.AddDays(6),
from.AddDays(7),
from.AddDays(8),
from.AddDays(9),
from.AddDays(10),
}, occurrences);
}
private static ScheduleDefinition ScheduleDefinitionFromReportSchedulerModel(ReportSchedulerModel model)
{
var startDate = DateTime.Parse(model.StartDate, CultureInfo.CurrentCulture);
var runtTime = DateTime.Parse(model.ScheduledTime, CultureInfo.CurrentCulture);
var startDateTime = new DateTime(startDate.Year, startDate.Month, startDate.Day,
runtTime.Hour, runtTime.Minute, runtTime.Second, DateTimeKind.Local);
var recurrencePattern = new WeeklyRecurrence
{
WeeksIntervalSpecified = true,
WeeksInterval = 1,
DaysOfWeek =
model.ReportFrequency == ReportFrequency.Daily
? DailyDaysOfWeek
: WeeklyDayOfWeek(model.Weekday)
};
var scheduleDefinition = new ScheduleDefinition
{
StartDateTime = startDateTime,
EndDateSpecified = model.EndDateSpecified,
Item = recurrencePattern
};
if (model.EndDateSpecified)
{
scheduleDefinition.EndDate = DateTime.Parse(model.EndDate, CultureInfo.CurrentCulture);
}
return scheduleDefinition;
}
/// <summary>
/// Create the recurrence pattern according to the schedule Type
/// </summary>
/// <param name="scheduleTypeParam"></param>
/// <returns></returns>
private RecurrencePattern GetPattern(string scheduleTypeParam, int scheduleDay)
{
SchedulePeriod scheduleType = (SchedulePeriod)Enum.Parse(typeof(SchedulePeriod), scheduleTypeParam, true);
switch (scheduleType)
{
case SchedulePeriod.Daily:
DailyRecurrence dailyPattern = new DailyRecurrence();
dailyPattern.DaysInterval = 1;
return(dailyPattern);
case SchedulePeriod.Monthly:
MonthlyDOWRecurrence monthlyPattern = new MonthlyDOWRecurrence();
monthlyPattern.WhichWeekSpecified = true;
monthlyPattern.WhichWeek = WeekNumberEnum.LastWeek;
MonthsOfYearSelector months = new MonthsOfYearSelector();
months.January = true;
months.February = true;
months.March = true;
months.April = true;
months.May = true;
months.June = true;
months.July = true;
months.August = true;
months.September = true;
months.October = true;
months.November = true;
months.December = true;
monthlyPattern.MonthsOfYear = months;
DaysOfWeekSelector days = GetExecutionDay(scheduleDay);
monthlyPattern.DaysOfWeek = days;
return(monthlyPattern);
case SchedulePeriod.Weekdays:
WeeklyRecurrence weekdaysRecurrence = new WeeklyRecurrence();
DaysOfWeekSelector Weekdays = new DaysOfWeekSelector();
Weekdays.Monday = true;
Weekdays.Tuesday = true;
Weekdays.Wednesday = true;
Weekdays.Thursday = true;
Weekdays.Friday = true;
weekdaysRecurrence.DaysOfWeek = Weekdays;
weekdaysRecurrence.WeeksIntervalSpecified = true;
weekdaysRecurrence.WeeksInterval = 1;
return(weekdaysRecurrence);
case SchedulePeriod.Weekly:
WeeklyRecurrence weeklyRecurrence = new WeeklyRecurrence();
DaysOfWeekSelector weeklydays = GetExecutionDay(scheduleDay);
weeklyRecurrence.DaysOfWeek = weeklydays;
weeklyRecurrence.WeeksIntervalSpecified = true;
weeklyRecurrence.WeeksInterval = 1;
return(weeklyRecurrence);
default:
return(null);
}
}
