// Token: 0x0600166C RID: 5740 RVA: 0x0007E508 File Offset: 0x0007C708
internal static List <ExDateRange> ConvertHoursToDateRanges(ExDateTime referenceTime, Hours hours, StorageWorkingHours workingHours, int days)
{
ExTraceGlobals.HeuristicsTracer.TraceFunction(0L, "WorkingHoursAwareReminderTimeCalculator.ConvertHoursToDateRanges");
ExTraceGlobals.HeuristicsTracer.TraceInformation <Hours, StorageWorkingHours, int>(0, 0L, "Hours: '{0}'; WorkingHours: '{1}'; Days: '{2}'", hours, workingHours, days);
List <ExDateRange> list = new List <ExDateRange>();
ExDateRange exDateRange = new ExDateRange(referenceTime.ToUtc(), referenceTime.AddDays((double)days).ToUtc());
if (workingHours == null)
{
ExTraceGlobals.HeuristicsTracer.TraceInformation(0, 0L, "User WorkingHours unavailable");
hours = Hours.Any;
}
switch (hours)
{
case Hours.Personal:
list = ExDateRange.SubtractRanges(exDateRange, WorkingHoursAwareReminderTimeCalculator.ConvertHoursToDateRanges(referenceTime, Hours.Working, workingHours, days));
break;
case Hours.Working:
for (int i = 0; i < days; i++)
{
ExDateTime date = referenceTime.AddDays((double)i).Date;
if (workingHours.IsWorkingDay(date.DayOfWeek))
{
list.Add(new ExDateRange(date.AddMinutes((double)workingHours.StartTimeInMinutes).ToUtc(), date.AddMinutes((double)workingHours.EndTimeInMinutes).ToUtc()));
}
}
break;
case Hours.Any:
list.Add(exDateRange);
break;
}
return(list);
}
// Token: 0x0600166B RID: 5739 RVA: 0x0007E45C File Offset: 0x0007C65C
internal static ExDateRange FindFirstIntersection(ExDateRange dateRange, List <ExDateRange> dateRanges)
{
ExTraceGlobals.HeuristicsTracer.TraceFunction(0L, "WorkingHoursAwareReminderTimeCalculator.FindIntersection");
dateRanges.Sort();
foreach (ExDateRange b in dateRanges)
{
if (ExDateRange.AreOverlapping(dateRange, b))
{
return(ExDateRange.Intersection(dateRange, b));
}
}
ExDateRange exDateRange = dateRanges.FirstOrDefault((ExDateRange x) => x.CompareTo(dateRange) > 0);
return(exDateRange ?? dateRanges.Last <ExDateRange>());
}
// Token: 0x0600166A RID: 5738 RVA: 0x0007E3A0 File Offset: 0x0007C5A0
public ExDateTime CalculateReminderTime(IModernReminder reminder, ExDateTime nowInUTC)
{
ExTraceGlobals.HeuristicsTracer.TraceFunction(0L, "WorkingHoursAwareReminderTimeCalculator.CalculateReminderTime");
if (reminder.ReminderTimeHint == ReminderTimeHint.Custom)
{
return(reminder.CustomReminderTime);
}
ExDateTime referenceTime = this.context.TimeZone.ConvertDateTime(reminder.ReferenceTime);
ExDateTime exDateTime;
if (reminder.ReminderTimeHint == ReminderTimeHint.Someday)
{
exDateTime = ExDateTime.MaxValue;
}
else
{
ExDateRange dateRange = WorkingHoursAwareReminderTimeCalculator.ConvertReminderTimeHintToExDateRange(reminder.ReminderTimeHint, referenceTime, this.context);
List <ExDateRange> dateRanges = WorkingHoursAwareReminderTimeCalculator.ConvertHoursToDateRanges(referenceTime, reminder.Hours, this.workingHours, 14);
exDateTime = WorkingHoursAwareReminderTimeCalculator.FindFirstIntersection(dateRange, dateRanges).Start;
}
ExTraceGlobals.HeuristicsTracer.TraceInformation <ExDateTime>(0, 0L, "WorkingHoursAwareReminderTimeCalculator calculated reminder time: {0}", exDateTime);
return(exDateTime);
}
// Token: 0x0600166D RID: 5741 RVA: 0x0007E618 File Offset: 0x0007C818
internal static ExDateRange ConvertReminderTimeHintToExDateRange(ReminderTimeHint hint, ExDateTime referenceTime, ReminderTimeCalculatorContext context)
{
ExTraceGlobals.HeuristicsTracer.TraceFunction(0L, "WorkingHoursAwareReminderTimeCalculator.ConvertReminderTimeHintToExDateRange");
ExTraceGlobals.HeuristicsTracer.TraceInformation <ReminderTimeHint, ExDateTime, DayOfWeek>(0, 0L, "ReminderTimeHint : '{0}'; ReferenceTime : '{1}'; StartOfWeek: '{2}'", hint, referenceTime, context.StartOfWeek);
ExDateRange exDateRange;
switch (hint)
{
case ReminderTimeHint.LaterToday:
exDateRange = new ExDateRange(referenceTime.Add(WorkingHoursAwareReminderTimeCalculator.RemindLaterMinOffsetTimeSpan).ToUtc(), referenceTime.Add(WorkingHoursAwareReminderTimeCalculator.RemindLaterMinOffsetTimeSpan).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc());
goto IL_496;
case ReminderTimeHint.Tomorrow:
exDateRange = new ExDateRange(referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayStartTimeSpan).ToUtc(), referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc());
goto IL_496;
case ReminderTimeHint.TomorrowMorning:
exDateRange = new ExDateRange(referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.MorningStartTimeSpan).ToUtc(), referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.MorningEndTimeSpan).ToUtc());
goto IL_496;
case ReminderTimeHint.TomorrowAfternoon:
exDateRange = new ExDateRange(referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.AfternoonStartTimeSpan).ToUtc(), referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.AfternoonEndTimeSpan).ToUtc());
goto IL_496;
case ReminderTimeHint.TomorrowEvening:
exDateRange = new ExDateRange(referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.EveningStartTimeSpan).ToUtc(), referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.EveningEndTimeSpan).ToUtc());
goto IL_496;
case ReminderTimeHint.ThisWeekend:
{
int num = WorkingHoursAwareReminderTimeCalculator.DaysTilNextOccurrence(referenceTime, DayOfWeek.Saturday);
if (num == 7)
{
return(new ExDateRange(referenceTime.ToUtc(), referenceTime.AddDays(1.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc()));
}
if (num == 6)
{
return(new ExDateRange(referenceTime.ToUtc(), referenceTime.Date.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc()));
}
return(new ExDateRange(referenceTime.AddDays((double)num).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayStartTimeSpan).ToUtc(), referenceTime.AddDays((double)(num + 1)).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc()));
}
case ReminderTimeHint.NextWeek:
{
ExDateTime date = referenceTime.AddDays((double)WorkingHoursAwareReminderTimeCalculator.DaysTilNextOccurrence(referenceTime, context.StartOfWeek)).Date;
exDateRange = new ExDateRange(date.ToUtc(), date.AddDays(6.0).Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc());
goto IL_496;
}
case ReminderTimeHint.NextMonth:
{
int num2 = ExDateTime.DaysInMonth(referenceTime.Year, referenceTime.Month) - referenceTime.Day + 1;
ExDateTime date2 = referenceTime.AddDays((double)num2).Date;
ExDateTime exDateTime = date2.AddDays((double)(ExDateTime.DaysInMonth(date2.Year, date2.Month) - 1));
exDateRange = new ExDateRange(date2.ToUtc(), exDateTime.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc());
goto IL_496;
}
case ReminderTimeHint.Now:
exDateRange = new ExDateRange(referenceTime.ToUtc(), referenceTime.ToUtc());
goto IL_496;
case ReminderTimeHint.InTwoDays:
exDateRange = new ExDateRange(referenceTime.AddDays(2.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayStartTimeSpan).ToUtc(), referenceTime.AddDays(2.0).Date.Add(WorkingHoursAwareReminderTimeCalculator.DayEndTimeSpan).ToUtc());
goto IL_496;
}
throw new InvalidOperationException("unsupported reminderTimeHint");
IL_496:
ExTraceGlobals.HeuristicsTracer.TraceInformation <ExDateTime, ExDateTime>(0, 0L, "Calculated reminder range : '{0}' - '{1}'", exDateRange.Start, exDateRange.End);
return(exDateRange);
}
// Token: 0x06000848 RID: 2120 RVA: 0x0003A2AC File Offset: 0x000384AC
private bool SyncFolder(MailboxSession mailboxSession, FolderRow folderRow, PublishingSubscriptionData subscriptionData, Deadline deadline, CalendarSyncPerformanceCountersInstance counters, CalendarSyncFolderOperationLogEntry folderOpLogEntry)
{
List <LocalizedString> list = new List <LocalizedString>();
bool result = true;
bool flag = false;
ExDateTime utcNow = ExDateTime.UtcNow;
using (CalendarFolder calendarFolder = CalendarFolder.Bind(mailboxSession, folderRow.FolderId))
{
ImportCalendarResults importCalendarResults = null;
try
{
TimeSpan timeLeft = deadline.TimeLeft;
if (timeLeft > TimeSpan.Zero)
{
calendarFolder.LastAttemptedSyncTime = utcNow;
TimeSpan timeout = (timeLeft > SynchronizableFolderType.MaxSyncTimePerFolder) ? SynchronizableFolderType.MaxSyncTimePerFolder : timeLeft;
HttpWebRequest httpWebRequest = this.CreateWebRequest(subscriptionData, timeout, mailboxSession, folderOpLogEntry);
if (httpWebRequest == null)
{
SynchronizableFolderType.Tracer.TraceWarning <Uri>((long)this.GetHashCode(), "Unable to get web request for subscription. {0}", subscriptionData.PublishingUrl);
return(true);
}
using (ImportCalendarStream importCalendarStream = new ImportCalendarStream())
{
int num = -1;
using (WebResponse response = httpWebRequest.GetResponse())
{
using (Stream responseStream = response.GetResponseStream())
{
num = importCalendarStream.CopyFrom(responseStream);
SynchronizableFolderType.Tracer.TraceDebug <object, int, PublishingSubscriptionData>((long)this.GetHashCode(), "{0}: Read data ({1} bytes ) into memory stream from subscription source {2}.", TraceContext.Get(), num, subscriptionData);
responseStream.Close();
}
response.Close();
}
if (num < 0)
{
folderOpLogEntry.AddErrorToLog("SubscriptionOverSizeLimit", null);
}
else
{
ExDateRange importWindow = InternetCalendarType.GetImportWindow(subscriptionData.PublishingUrl);
importCalendarResults = ICalSharingHelper.ImportCalendar(importCalendarStream, "utf-8", new InboundConversionOptions(mailboxSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), mailboxSession.ServerFullyQualifiedDomainName), mailboxSession, calendarFolder, deadline, importWindow.Start, importWindow.End);
if (importCalendarResults.Result != ImportCalendarResultType.Success)
{
list.AddRange(importCalendarResults.Errors);
foreach (LocalizedString value in importCalendarResults.Errors)
{
folderOpLogEntry.AddErrorToLog("ImportCalendarException", value);
}
}
flag = (importCalendarResults.Result != ImportCalendarResultType.Failed);
}
}
SynchronizableFolderType.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: iCal to folder {1} with id {2} for mailbox {3} with subscription {4}. Results: {5}", new object[]
{
TraceContext.Get(),
folderRow.DisplayName,
folderRow.FolderId,
mailboxSession.DisplayName,
subscriptionData,
(importCalendarResults != null) ? importCalendarResults.ToString() : "iCal over the size limit"
});
if (importCalendarResults == null)
{
folderOpLogEntry.AddErrorToLog("iCalOverSizeLimit", null);
}
}
result = (importCalendarResults != null && !importCalendarResults.TimedOut);
}
catch (WebException ex)
{
list.Add(new LocalizedString(ex.ToString()));
result = (ex.Status != WebExceptionStatus.Timeout);
folderOpLogEntry.AddExceptionToLog(ex);
}
catch (SystemException ex2)
{
list.Add(new LocalizedString(ex2.ToString()));
folderOpLogEntry.AddExceptionToLog(ex2);
}
catch (Exception ex3)
{
SynchronizableFolderType.Tracer.TraceError((long)this.GetHashCode(), "{0}: InternetCalendarType.SyncFolder for folder {1} with id {2} for mailbox {3} had the following exception: {4}. Subscription data: {5}", new object[]
{
TraceContext.Get(),
folderRow.DisplayName,
folderRow.FolderId,
mailboxSession.DisplayName,
ex3,
subscriptionData
});
this.SaveLocalFolder(mailboxSession, calendarFolder, subscriptionData, folderRow);
list.Add(new LocalizedString(ex3.ToString()));
folderOpLogEntry.AddExceptionToLog(ex3);
throw;
}
if (flag)
{
calendarFolder.LastSuccessfulSyncTime = utcNow;
}
this.SaveLocalFolder(mailboxSession, calendarFolder, subscriptionData, folderRow);
}
if (list != null)
{
foreach (LocalizedString localizedString in list)
{
SynchronizableFolderType.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: InternetCalendarType.SyncFolder for folder {1} with id {2} for mailbox {3} had the following error: {4}. Subscription data: {5}", new object[]
{
TraceContext.Get(),
folderRow.DisplayName,
folderRow.FolderId,
mailboxSession.DisplayName,
localizedString,
subscriptionData
});
}
}
return(result);
}
