private static IEnumerable <string> AddDailyAddIns(DailyFrequency dailyFrequency)
{
return(new List <string>
{
dailyFrequency.Period == 1
?@"каждый" // @"every"
: string.Format(DescriptionFormattingString, @"каждые", dailyFrequency.Period), //@"every(s)"
DeclinableForDates(dailyFrequency.Occurs, dailyFrequency.Period)
});
}
/// <summary>
/// Returns the next time this schedule should run given the last run date.
/// </summary>
/// <returns></returns>
public DateTime GetScheduledDate(DateTime lastRunDate)
{
lastRunDate = lastRunDate.StartOfMillisecond();
DateTime currentDate = SystemTime.Now();
if (ScheduledFrequencyDate is DailyFrequency)
{
DailyFrequency frequency = (DailyFrequency)ScheduledFrequencyDate;
#region DailyFrequencyCalculation
//The minimum date is a minimum of either todays date or the next run date
//whichever is greater.
DateTime nextRunDate = lastRunDate;
DateTime todaysDate = SystemTime.Now();
DateTime minDate = nextRunDate > todaysDate ? nextRunDate : todaysDate;
minDate = minDate.StartOfMillisecond().AddSeconds(1);
if (nextRunDate.Date < minDate.Date)
{
nextRunDate = frequency.GetNextDay(nextRunDate, minDate);
}
bool setDateTime = false;
while (setDateTime == false)
{
DateTime?nextValidTime = ScheduledFrequencyTime.CalculateNextIntervalTime(nextRunDate, minDate, true);
if (nextValidTime != null)
{
nextRunDate = nextValidTime.Value;
setDateTime = true;
}
if (setDateTime == false)
{
nextRunDate = frequency.GetNextDay(nextRunDate, minDate);
}
}
return(nextRunDate);
#endregion DailyFrequencyCalculation
}
else if (ScheduledFrequencyDate is WeeklyFrequency)
{
WeeklyFrequency frequency = (WeeklyFrequency)ScheduledFrequencyDate;
#region WeeklyFrequencyCalculation
//Increment last run date until date >= today's date.
DateTime nextRunDate = lastRunDate;
DateTime lastRunWeek = lastRunDate.StartOfWeek(DayOfWeek.Monday);
DateTime thisWeek = currentDate.StartOfWeek(DayOfWeek.Monday);
DateTime minDate = nextRunDate > currentDate ? nextRunDate : currentDate;
minDate = minDate.StartOfMillisecond().AddSeconds(1);
DateTime currentValidDay = frequency.GetNextDay(minDate.AddDays(-1));
minDate = currentValidDay > minDate ? currentValidDay : minDate;
DateTime minWeek = minDate.StartOfWeek(DayOfWeek.Monday);
//Ignore any weeks less than the week we want to check
if (nextRunDate.Date.StartOfWeek(DayOfWeek.Monday) < minWeek.Date)
{
nextRunDate = frequency.GetNextDay(nextRunDate, minDate);
}
bool setDateTime = false;
while (setDateTime == false)
{
DateTime?nextValidTime = ScheduledFrequencyTime.CalculateNextIntervalTime(nextRunDate, minDate, true);
if (nextValidTime != null)
{
nextRunDate = nextValidTime.Value;
setDateTime = true;
}
if (setDateTime == false)
{
nextRunDate = frequency.GetNextDay(nextRunDate, minDate);
}
}
return(nextRunDate);
#endregion WeeklyFrequencyCalculation
}
else if (ScheduledFrequencyDate is MonthlyFrequency)
{
MonthlyFrequency frequency = (MonthlyFrequency)ScheduledFrequencyDate;
#region MonthlyFrequencyCalculation
//Increment last run date until date >= today's date.
DateTime nextRunDate = lastRunDate;
DateTime lastRunMonth = lastRunDate.StartOfMonth();
DateTime thisMonth = SystemTime.Now().StartOfMonth();
DateTime minDate = lastRunDate > currentDate ? lastRunDate : currentDate;
DateTime currentValidDay = frequency.GetNextDay(minDate.AddDays(-1));
minDate = minDate.StartOfMillisecond().AddSeconds(1);
minDate = currentValidDay > minDate ? currentValidDay : minDate;
DateTime minMonth = minDate.StartOfMonth();
//Ignore any months less than the month we want to check
if (nextRunDate.Date.StartOfMonth() < minMonth)
{
nextRunDate = frequency.GetNextDay(nextRunDate, minDate);
}
bool setDateTime = false;
while (setDateTime == false)
{
DateTime?nextValidTime = ScheduledFrequencyTime.CalculateNextIntervalTime(nextRunDate, minDate, true);
if (nextValidTime != null)
{
nextRunDate = nextValidTime.Value;
setDateTime = true;
}
if (setDateTime == false)
{
nextRunDate = frequency.GetNextDay(nextRunDate, minDate);
}
}
return(nextRunDate);
#endregion MonthlyFrequencyCalculation
}
else
{
throw new NotImplementedException();
}
}
private SheduleFrequencyProperty ApplySheduling(Sofia.WebSite.Models.SchedulerModel model)
{
SheduleFrequencyProperty frequencyProperty = null;
if (model.FrequencyType == 0)
{
return(new SingleLanchFrequency(model.cDate));
}
var periodType =
(RhythmByDate)Enum.Parse(typeof(RhythmByDate), (model.ddlDateRhythm).ToString());
switch (periodType)
{
case RhythmByDate.Daily:
frequencyProperty = new DailyFrequency {
Period = model.DailyPeriod
};
break;
case RhythmByDate.Weekly:
frequencyProperty = new WeeklyFrequency {
Period = model.WeeklyPeriod
};
var daysOfWeek = new HashSet <DayOfWeek>();
if (model.Monday)
{
daysOfWeek.Add(DayOfWeek.Monday);
}
if (model.Tuesday)
{
daysOfWeek.Add(DayOfWeek.Tuesday);
}
if (model.Wednesday)
{
daysOfWeek.Add(DayOfWeek.Wednesday);
}
if (model.Thursday)
{
daysOfWeek.Add(DayOfWeek.Thursday);
}
if (model.Friday)
{
daysOfWeek.Add(DayOfWeek.Friday);
}
if (model.Saturday)
{
daysOfWeek.Add(DayOfWeek.Saturday);
}
if (model.Sunday)
{
daysOfWeek.Add(DayOfWeek.Sunday);
}
((WeeklyFrequency)frequencyProperty).SetDays(daysOfWeek);
break;
case RhythmByDate.Monthly:
frequencyProperty = new MonthlyFrequency(model.RblMonthDetail);
if (model.RblMonthDetail == false)
{
frequencyProperty.Period = model.MonthlyPeriod;
((MonthlyFrequency)frequencyProperty).DayOffset = model.DayOffset;
}
else
{
frequencyProperty.Period = model.tbxMonthNumFor;
((MonthlyFrequency)frequencyProperty).DayOfWeek =
new KeyValuePair <RhythmByWeek, DayOfWeek>(
(RhythmByWeek)
Enum.Parse(typeof(RhythmByWeek), model.ddlWeekPart.ToString()),
(DayOfWeek)
Enum.Parse(typeof(DayOfWeek), model.ddlWeeks.ToString()));
}
break;
}
if (frequencyProperty == null)
{
return(null);
}
frequencyProperty.DurationFrom = model.DurationFrom.Date;
if (model.IsInfinite == false)
{
frequencyProperty.DurationTo = model.DurationTo.Date;
}
frequencyProperty.DailyFrequency = ApplyTimeRange(model);
return(frequencyProperty);
}
