public async Task Task_changes_note_recurring()
{
// reporter, Kamil Gozdek [mailto:[email protected]]
// updating the note of a recurring task in Exchange creates a duplicate
var folder = this.CreateFolder("folder");
var task = this.CreateTask("task", folder);
task.Note = "task note content";
var originalDue = DateSunday17Aug;
var originalFrequency = new WeeklyFrequency();
task.Due = originalDue;
task.FrequencyType = FrequencyType.Weekly;
task.CustomFrequency = originalFrequency;
task.UseFixedDate = true;
await this.SyncDelta();
AssertEx.ContainsTasks(this.Workbook, "task");
AssertEx.IsDue(this.Workbook, 0, task.Due);
AssertEx.IsRecurringWithFrequency(task, originalFrequency);
AssertEx.IsWithNote(this.Workbook, 0, task.Note);
task.Note = "new note";
await this.SyncFull();
AssertEx.ContainsTasks(this.Workbook, "task");
AssertEx.IsDue(this.Workbook, 0, task.Due);
AssertEx.IsRecurringWithFrequency(task, originalFrequency);
AssertEx.IsWithNote(this.Workbook, 0, task.Note);
}
public async Task Task_complete_recurring()
{
var folder = this.CreateFolder("folder");
var task = this.CreateTask("task", folder);
var originalDue = DateSunday17Aug;
var originalFrequency = new WeeklyFrequency();
task.Due = originalDue;
task.FrequencyType = FrequencyType.Weekly;
task.CustomFrequency = originalFrequency;
task.UseFixedDate = true;
// add recurring task
await this.SyncDelta();
// complete recurring task
task.IsCompleted = true;
await this.SyncFull();
Assert.AreEqual(2, this.Workbook.Tasks.Count);
var task1 = AssertEx.ContainsTask(this.Workbook, "task", DateSunday17Aug.Day);
AssertEx.IsDue(task1, task.Due);
AssertEx.IsCompleted(task);
AssertEx.IsRecurringWithFrequencyType(task, FrequencyType.Once);
var task2 = AssertEx.ContainsTask(this.Workbook, "task", DateSunday17Aug.Day + 7);
AssertEx.IsDue(task2, originalDue.AddDays(7));
AssertEx.IsRecurringWithFrequency(task2, originalFrequency);
}
private IEnumerable <string> AddWeeklyAddIns(WeeklyFrequency weeklyFrequency)
{
var addIns = new List <string>
{
weeklyFrequency.Period == 1
? @"каждую" //every_w
: string.Format(DescriptionFormattingString, @"каждые", weeklyFrequency.Period), //@"every(s)"
DeclinableForDates(weeklyFrequency.Occurs, weeklyFrequency.Period)
};
List <DayOfWeek> recuringDays = weeklyFrequency.RecuringDays;
CultureInfo russi = new CultureInfo("ru-RU");
if (recuringDays.Count > 0)
{
const string declinable = @"{0}";
addIns.Add("в");
addIns.AddRange(
recuringDays.Select(
(t, i) =>
i == (recuringDays.Count - 1)
? string.Format(declinable, russi.DateTimeFormat.DayNames[(int)t])
: string.Format(DescriptionFormattingString, string.Format(declinable, russi.DateTimeFormat.DayNames[(int)t]),
i == (recuringDays.Count - 2)
? @"и"// "and" //_resourceStore.GetValueForKey(ResourceType.PageContent, "and")
: ",")));
}
return(addIns);
}
public void ScheduleOnDays(bool sunday, bool monday, bool tuesday, bool wednesday, bool thrusday, bool friday, bool saturday)
{
if (sunday)
WeeklyFrequency |= WeeklyFrequency.Sunday;
if (monday)
WeeklyFrequency |= WeeklyFrequency.Monday;
if (tuesday)
WeeklyFrequency |= WeeklyFrequency.Tuesday;
if (wednesday)
WeeklyFrequency |= WeeklyFrequency.Wednesday;
if (thrusday)
WeeklyFrequency |= WeeklyFrequency.Thrusday;
if (friday)
WeeklyFrequency |= WeeklyFrequency.Friday;
if (saturday)
WeeklyFrequency |= WeeklyFrequency.Saturday;
}
public WeeklySchedule(TimeSpan timeOfTheDay, DateTime startDate, DateTime endDate, WeeklyFrequency weeklyFrequency)
: base(timeOfTheDay, startDate, endDate)
{
WeeklyFrequency = weeklyFrequency;
SetNextDueDateTime();
}
/// <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();
}
}
public void ScheduleWeekendsOnly()
{
WeeklyFrequency = WeeklyFrequency.Sunday | WeeklyFrequency.Saturday;
}
public void ScheduleWeekdaysOnly()
{
WeeklyFrequency = WeeklyFrequency.Monday | WeeklyFrequency.Tuesday | WeeklyFrequency.Wednesday | WeeklyFrequency.Thrusday | WeeklyFrequency.Friday;
}
public void ScheduleEveryDayOfTheWeek()
{
WeeklyFrequency = WeeklyFrequency.Sunday | WeeklyFrequency.Monday | WeeklyFrequency.Tuesday | WeeklyFrequency.Wednesday | WeeklyFrequency.Thrusday | WeeklyFrequency.Friday | WeeklyFrequency.Saturday;
}
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);
}
