// 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);
}
public ExDateTime GetLastScheduledTime()
{
if (this.Mode == ScheduleMode.Never)
{
return(Schedule.MinimumValidDateTime);
}
if (this.Mode == ScheduleMode.Always)
{
return(ExDateTime.Now);
}
ExDateTime now = ExDateTime.Now;
TimeSpan value = TimeSpan.MaxValue;
foreach (ScheduleInterval scheduleInterval in this.Intervals)
{
ExDateTime value2 = new ExDateTime(ExTimeZone.CurrentTimeZone, now.Year, now.Month, now.Day, scheduleInterval.StartHour, scheduleInterval.StartMinute, 0);
int num = scheduleInterval.StartDay - now.DayOfWeek;
if (num > 0 || (num == 0 && scheduleInterval.StartHour > now.Hour) || (num == 0 && scheduleInterval.StartHour == now.Hour && scheduleInterval.StartMinute >= now.Minute))
{
num -= 7;
}
value2 = value2.AddDays((double)num);
TimeSpan timeSpan = now.Subtract(value2);
if (timeSpan.Ticks < value.Ticks)
{
value = timeSpan;
}
}
return(now.Subtract(value));
}
internal string GetFreeBusyByDay(Duration timeWindow, ExTimeZone timeZone)
{
ExDateTime windowStart = new ExDateTime(timeZone, timeWindow.StartTime);
ExDateTime exDateTime = new ExDateTime(timeZone, timeWindow.EndTime);
int num = (int)(exDateTime.Date - windowStart.Date).TotalDays + 1;
char[] array = new char[num];
char c = (base.ExceptionInfo != null) ? '5' : '0';
for (int i = 0; i < num; i++)
{
array[i] = c;
}
if (this.CalendarEventArray != null)
{
for (int j = 0; j < this.CalendarEventArray.Length; j++)
{
CalendarEvent calendarEvent = this.CalendarEventArray[j];
ExDateTime exDateTime2 = new ExDateTime(timeZone, calendarEvent.StartTime.Date);
ExDateTime t = new ExDateTime(timeZone, calendarEvent.EndTime.Date);
while (exDateTime2 < t)
{
this.AddEventTime(array, windowStart, exDateTime2, calendarEvent.BusyType);
exDateTime2 = exDateTime2.AddDays(1.0);
}
if (calendarEvent.EndTime.TimeOfDay != TimeSpan.Zero)
{
this.AddEventTime(array, windowStart, new ExDateTime(timeZone, calendarEvent.EndTime), calendarEvent.BusyType);
}
}
}
return(new string(array));
}
public SuggestionDayResult[] GetSuggestionsByDateRange(ExDateTime startDate, ExDateTime endDate, ExTimeZone timeZone, int inputMeetingDuration, AttendeeData[] attendees)
{
this.meetingDuration = inputMeetingDuration;
MeetingSuggester.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Entering MeetingSuggester.GetSuggestionsByDateRange()", new object[]
{
TraceContext.Get()
});
MeetingSuggester.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: startDate={1}, endDate={2}, inputMeetingDuration={3}", new object[]
{
TraceContext.Get(),
startDate,
endDate,
inputMeetingDuration
});
this.ValidateAndProcessInput(startDate, endDate, inputMeetingDuration, attendees);
List <SuggestionDayResult> list = new List <SuggestionDayResult>();
ExDateTime exDateTime = startDate;
while (exDateTime < endDate)
{
list.Add(new SuggestionDayResult(exDateTime, this.meetingDuration, this.requiredAttendeeCount, this.optionalAttendeeCount, attendees, this.options, this.currentMeetingTime));
exDateTime = exDateTime.AddDays(1.0);
}
return(list.ToArray());
}
internal SuggestionDayResult(ExDateTime currentDate, int inputMeetingDuration, int requiredAttendeeCount, int optionalAttendeeCount, AttendeeData[] attendees, ConfigOptions options, ExDateTime currentMeetingTime)
{
this.date = currentDate.LocalTime;
ExDateTime t = ExDateTime.Now.ToUtc();
List <Suggestion> list = new List <Suggestion>();
ExDateTime t2 = currentDate.AddDays(1.0);
ExDateTime exDateTime = currentDate.ToUtc();
while (exDateTime < t2)
{
if (exDateTime >= t || exDateTime == currentMeetingTime)
{
list.Add(new Suggestion(currentDate.TimeZone.ConvertDateTime(exDateTime), inputMeetingDuration, requiredAttendeeCount, optionalAttendeeCount, attendees, options));
}
exDateTime = exDateTime.AddMinutes((double)options.SuggestionInterval);
}
this.rawSuggestionsList = list.ToArray();
this.FilterSuggestions(list, options, currentMeetingTime);
foreach (Suggestion suggestion in list)
{
if (suggestion.SuggestionQuality < this.quality)
{
this.quality = suggestion.SuggestionQuality;
}
}
this.meetingSuggestions = list.ToArray();
}
private void GetStartEndDateForReportingPeriod(ReportingPeriod reportingPeriod, out ExDateTime startDateTime, out ExDateTime endDateTime)
{
startDateTime = ExDateTime.MinValue;
endDateTime = ExDateTime.MaxValue;
ExDateTime date = ExDateTime.UtcNow.Date;
switch (reportingPeriod)
{
case ReportingPeriod.Today:
startDateTime = date;
endDateTime = startDateTime.Add(TimeSpan.FromDays(1.0)).Subtract(TimeSpan.FromMinutes(1.0));
return;
case ReportingPeriod.Yesterday:
startDateTime = date.Subtract(TimeSpan.FromDays(1.0));
endDateTime = startDateTime.AddDays(1.0).Subtract(TimeSpan.FromMinutes(1.0));
return;
case ReportingPeriod.LastWeek:
startDateTime = date.Subtract(TimeSpan.FromDays((double)(7 + date.DayOfWeek)));
endDateTime = date.Subtract(TimeSpan.FromDays((double)date.DayOfWeek)).Subtract(TimeSpan.FromMinutes(1.0));
return;
case ReportingPeriod.LastMonth:
startDateTime = GetAvailabilityReport <TIdentity> .SubtractMonths(date, 1);
endDateTime = GetAvailabilityReport <TIdentity> .GetLastMonthLastDate(date);
return;
case ReportingPeriod.Last3Months:
startDateTime = GetAvailabilityReport <TIdentity> .SubtractMonths(date, 3);
endDateTime = GetAvailabilityReport <TIdentity> .GetLastMonthLastDate(date);
return;
case ReportingPeriod.Last6Months:
startDateTime = GetAvailabilityReport <TIdentity> .SubtractMonths(date, 6);
endDateTime = GetAvailabilityReport <TIdentity> .GetLastMonthLastDate(date);
return;
case ReportingPeriod.Last12Months:
startDateTime = GetAvailabilityReport <TIdentity> .SubtractMonths(date, 12);
endDateTime = GetAvailabilityReport <TIdentity> .GetLastMonthLastDate(date);
return;
default:
base.WriteError(new ArgumentException(Strings.InvalidReportingPeriod), (ErrorCategory)1000, null);
return;
}
}
public static ExDateTime GetFutureTimestamp(ExDateTime startTime, int afterMinimumDays, DayOfWeek onDayOfWeek, TimeSpan atTimeOfDay, ExTimeZone localTimeZone)
{
ExDateTime exDateTime = localTimeZone.ConvertDateTime(startTime);
int num = (exDateTime.TimeOfDay > atTimeOfDay) ? 1 : 0;
ExDateTime exDateTime2 = exDateTime.AddDays((double)(afterMinimumDays + num));
int num2 = onDayOfWeek - exDateTime2.DayOfWeek;
if (num2 < 0)
{
num2 += 7;
}
return(exDateTime2.AddDays((double)num2).Date.Add(atTimeOfDay).ToUtc());
}
public static void GetStartEndDateForReportingPeriod(ReportingPeriod reportingPeriod, out ExDateTime startDateTime, out ExDateTime endDateTime)
{
ExDateTime date = ExDateTime.UtcNow.Date;
switch (reportingPeriod)
{
case ReportingPeriod.Today:
startDateTime = date;
endDateTime = startDateTime.Add(TimeSpan.FromDays(1.0)).Subtract(TimeSpan.FromSeconds(1.0));
return;
case ReportingPeriod.Yesterday:
startDateTime = date.Subtract(TimeSpan.FromDays(1.0));
endDateTime = startDateTime.AddDays(1.0).Subtract(TimeSpan.FromSeconds(1.0));
return;
case ReportingPeriod.LastWeek:
startDateTime = date.Subtract(TimeSpan.FromDays((double)(7 + date.DayOfWeek)));
endDateTime = date.Subtract(TimeSpan.FromDays((double)date.DayOfWeek)).Subtract(TimeSpan.FromSeconds(1.0));
return;
case ReportingPeriod.LastMonth:
startDateTime = Utils.SubtractMonths(date, 1);
endDateTime = Utils.GetLastMonthLastDate(date);
return;
case ReportingPeriod.Last3Months:
startDateTime = Utils.SubtractMonths(date, 3);
endDateTime = Utils.GetLastMonthLastDate(date);
return;
case ReportingPeriod.Last6Months:
startDateTime = Utils.SubtractMonths(date, 6);
endDateTime = Utils.GetLastMonthLastDate(date);
return;
case ReportingPeriod.Last12Months:
startDateTime = Utils.SubtractMonths(date, 12);
endDateTime = Utils.GetLastMonthLastDate(date);
return;
default:
throw new ArgumentException(Strings.InvalidReportingPeriod);
}
}
public static IEnumerable <StartEndDateTimePair> GetAllDaysInGivenRange(ExDateTime startDate, ExDateTime endDate)
{
List <StartEndDateTimePair> list = new List <StartEndDateTimePair>();
if (endDate.Date < startDate.Date)
{
throw new ArgumentException(Strings.InvalidTimeRange, "StartDate");
}
if (endDate.Date == startDate.Date)
{
list.Add(new StartEndDateTimePair(startDate.Date, startDate.Date.AddDays(1.0).Subtract(TimeSpan.FromSeconds(1.0))));
}
else if (endDate.Date > startDate.Date)
{
ExDateTime t = startDate.Date;
while (t <= endDate.Date)
{
list.Add(new StartEndDateTimePair(t.Date, t.Date.AddDays(1.0).Subtract(TimeSpan.FromSeconds(1.0))));
t = t.AddDays(1.0);
}
}
return(list);
}
internal static void ApplyPolicy(MailboxSession mailboxSession, object policy, object flags, object period, object archivePolicy, object archivePeriod, object compactDefaultPolicy, MessageItem messageItem, bool keepRetentionTag)
{
if (policy == null && compactDefaultPolicy == null)
{
using (Folder folder = Folder.Bind(mailboxSession, messageItem.ParentId, new PropertyDefinition[]
{
StoreObjectSchema.PolicyTag,
StoreObjectSchema.RetentionPeriod,
StoreObjectSchema.RetentionFlags,
StoreObjectSchema.ArchiveTag,
StoreObjectSchema.ArchivePeriod,
FolderSchema.RetentionTagEntryId
}))
{
RetentionTagHelper.ReadPolicyFromFolder(folder, out policy, out flags, out period, out archivePolicy, out archivePeriod, out compactDefaultPolicy);
}
}
bool flag = false;
bool flag2 = false;
ExDateTime d = messageItem.ReceivedTime;
if (d == ExDateTime.MinValue)
{
d = messageItem.SentTime;
if (d == ExDateTime.MinValue)
{
d = ExDateTime.Now;
}
}
if (archivePolicy != null && archivePolicy is byte[] && archivePeriod != null && archivePeriod is int)
{
flag2 = true;
}
if (policy != null && policy is byte[] && period != null && period is int)
{
flag = true;
}
if (flag2)
{
try
{
messageItem[ItemSchema.ArchiveDate] = d.AddDays((double)((int)archivePeriod));
}
catch (ArgumentOutOfRangeException)
{
messageItem[ItemSchema.ArchiveDate] = DateTime.MaxValue;
}
messageItem[StoreObjectSchema.ArchiveTag] = (archivePolicy as byte[]);
}
else
{
messageItem.DeleteProperties(new PropertyDefinition[]
{
StoreObjectSchema.ArchiveTag
});
messageItem.DeleteProperties(new PropertyDefinition[]
{
ItemSchema.ArchiveDate
});
}
Guid guid;
int num;
RetentionTagHelper.GetDefaultPolicyInfo(mailboxSession, messageItem, compactDefaultPolicy, out guid, out num);
if (!keepRetentionTag)
{
if (flag)
{
try
{
messageItem[ItemSchema.RetentionDate] = d.AddDays((double)((int)period));
}
catch (ArgumentOutOfRangeException)
{
messageItem[ItemSchema.RetentionDate] = DateTime.MaxValue;
}
messageItem[StoreObjectSchema.PolicyTag] = (policy as byte[]);
}
else
{
if (num > 0)
{
try
{
messageItem[ItemSchema.RetentionDate] = d.AddDays((double)num);
goto IL_223;
}
catch (ArgumentOutOfRangeException)
{
messageItem[ItemSchema.RetentionDate] = DateTime.MaxValue;
goto IL_223;
}
}
messageItem.DeleteProperties(new PropertyDefinition[]
{
ItemSchema.RetentionDate
});
IL_223:
if (!guid.Equals(Guid.Empty))
{
messageItem[StoreObjectSchema.PolicyTag] = guid.ToByteArray();
}
else
{
messageItem.DeleteProperties(new PropertyDefinition[]
{
StoreObjectSchema.PolicyTag
});
if (!flag2)
{
return;
}
}
}
}
else if (!flag2)
{
return;
}
CompositeProperty compositeProperty = new CompositeProperty(num, d.UniversalTime);
messageItem[ItemSchema.StartDateEtc] = compositeProperty.GetBytes(true);
messageItem[StoreObjectSchema.RetentionFlags] = 0;
}
// Token: 0x06000E0C RID: 3596 RVA: 0x00054E78 File Offset: 0x00053078
protected override void InvokeInternal(InvokeArgs invokeArgs, List <KeyValuePair <string, object> > customDataToLog)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
MailboxSession mailboxSession = invokeArgs.StoreSession as MailboxSession;
if (mailboxSession == null)
{
return;
}
if (mailboxSession.MailboxOwner.RecipientTypeDetails != RecipientTypeDetails.UserMailbox && mailboxSession.MailboxOwner.RecipientTypeDetails != RecipientTypeDetails.LinkedMailbox && mailboxSession.MailboxOwner.RecipientTypeDetails != RecipientTypeDetails.GroupMailbox)
{
CalendarRepairAssistant.CachedStateTracer.TraceDebug <Guid, string, string>((long)this.GetHashCode(), "Skipping mailbox with guid {0} and display name {1} since this is a {2} and not a UserMailbox or a LinkedMailbox", mailboxSession.MailboxGuid, mailboxSession.MailboxOwner.MailboxInfo.DisplayName, mailboxSession.MailboxOwner.RecipientTypeDetails.ToString());
return;
}
ExDateTime now = ExDateTime.Now;
ExDateTime rangeStart = now.AddDays((double)(-(double)this.RepairPolicy.DaysInWindowBackward));
ExDateTime rangeEnd = now.AddDays((double)this.RepairPolicy.DaysInWindowForward);
CachedState cachedState = AssistantsService.CachedObjectsList.GetCachedState(mailboxSession.MailboxGuid);
bool flag = ResourceCheck.DetailedCheckForAutomatedBooking(mailboxSession, cachedState);
if (flag)
{
CalendarRepairAssistant.CachedStateTracer.TraceDebug((long)this.GetHashCode(), "{0}: Calendar Repair Assistant is skipping resource mailbox.", new object[]
{
TraceContext.Get()
});
return;
}
CalendarRepairAssistantLogEntry calendarRepairAssistantLogEntry = new CalendarRepairAssistantLogEntry
{
DatabaseGuid = mailboxSession.MailboxOwner.MailboxInfo.GetDatabaseGuid(),
MailboxGuid = mailboxSession.MailboxGuid,
TenantGuid = mailboxSession.MailboxOwner.MailboxInfo.OrganizationId.GetTenantGuid(),
RepairMode = this.RepairPolicy.RepairMode.ToString(),
RangeStartTime = string.Format("{0:O}", rangeStart.ToUtc()),
RangeEndTime = string.Format("{0:O}", rangeEnd.ToUtc())
};
this.MarkMailboxForUpgrade(mailboxSession, calendarRepairAssistantLogEntry);
try
{
CalendarRepairAssistant.CachedStateTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Calendar Repair Assistant starting to validate mailbox: {1}.", TraceContext.Get(), mailboxSession.MailboxOwner.MailboxInfo.DisplayName);
CalendarValidator calendarValidator = CalendarValidator.CreateRepairingInstance(mailboxSession, rangeStart, rangeEnd, this.RepairPolicy, CalendarRepairAssistant.cvsPopulationTimeout);
calendarValidator.OnItemInspected += this.incrementTotalItemsInspected;
calendarValidator.OnItemRepaired += this.incrementTotalItemsRepaired;
List <MeetingValidationResult> validationResults = calendarValidator.Run();
calendarValidator.OnItemInspected -= this.incrementTotalItemsInspected;
calendarValidator.OnItemRepaired -= this.incrementTotalItemsRepaired;
calendarRepairAssistantLogEntry.AddValidationResults(validationResults);
CalendarRepairLogger.Instance.Log(validationResults, mailboxSession.MailboxOwner, rangeStart, rangeEnd);
if (CalendarRepairAssistant.IsCRAReliabilityLoggerEnabled(mailboxSession))
{
CalendarReliabilityInsigntLogger.Instance.Log(calendarRepairAssistantLogEntry, validationResults);
}
CalendarRepairAssistant.CachedStateTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Calendar Repair Assistant completed validating mailbox: {1}.", TraceContext.Get(), mailboxSession.MailboxOwner.MailboxInfo.DisplayName);
}
catch (WrongServerException ex)
{
string message = string.Format("Could not access the mailbox (ExchangePrincipal:'{0}'). Exception: {1}.", mailboxSession.MailboxOwner, ex);
CalendarRepairAssistant.Tracer.TraceDebug((long)this.GetHashCode(), message);
calendarRepairAssistantLogEntry.AddExceptionToLog(ex);
}
catch (MailboxUserNotFoundException ex2)
{
CalendarRepairAssistant.Tracer.TraceDebug <MailboxUserNotFoundException>((long)this.GetHashCode(), "MailboxUserNotFoundException:{0}", ex2);
calendarRepairAssistantLogEntry.AddExceptionToLog(ex2);
}
catch (CorruptDataException ex3)
{
CalendarRepairAssistant.Tracer.TraceDebug <CorruptDataException>((long)this.GetHashCode(), "CorruptDataException:{0}", ex3);
calendarRepairAssistantLogEntry.AddExceptionToLog(ex3);
}
catch (SubmissionQuotaExceededException ex4)
{
CalendarRepairAssistant.Tracer.TraceDebug <SubmissionQuotaExceededException>((long)this.GetHashCode(), "SubmissionQuotaExceededException:{0}", ex4);
calendarRepairAssistantLogEntry.AddExceptionToLog(ex4);
}
catch (StoragePermanentException ex5)
{
CalendarRepairAssistant.Tracer.TraceDebug <StoragePermanentException>((long)this.GetHashCode(), "StoragePermanentException:{0}", ex5);
calendarRepairAssistantLogEntry.AddExceptionToLog(ex5);
}
catch (Exception ex6)
{
CalendarRepairAssistant.Tracer.TraceDebug <Exception>((long)this.GetHashCode(), "Exception:{0}", ex6);
calendarRepairAssistantLogEntry.AddExceptionToLog(ex6);
throw ex6;
}
finally
{
stopwatch.Stop();
calendarRepairAssistantLogEntry.TotalProcessingTime = stopwatch.Elapsed.TotalMilliseconds.ToString();
customDataToLog.AddRange(calendarRepairAssistantLogEntry.FormatCustomData());
}
}
protected override void ProcessMailbox()
{
try
{
ExDateTime exDateTime = this.Date.ToUtc();
ExDateTime startDateTime = new ExDateTime(ExTimeZone.UtcTimeZone, exDateTime.Year, exDateTime.Month, exDateTime.Day);
ExDateTime endDateTime = startDateTime.AddDays(1.0);
StreamWriter streamWriter = new StreamWriter(this.ClientStream, Encoding.UTF8);
streamWriter.WriteCsvLine(this.csvRow.Keys);
using (IUMCallDataRecordStorage umcallDataRecordsAcessor = InterServerMailboxAccessor.GetUMCallDataRecordsAcessor(this.DataObject))
{
int num = 0;
int numberOfRecordsToRead = 5000;
if (Utils.RunningInTestMode)
{
numberOfRecordsToRead = 1;
}
bool flag;
do
{
flag = false;
CDRData[] umcallDataRecords = umcallDataRecordsAcessor.GetUMCallDataRecords(startDateTime.Subtract(this.TimeDelta), endDateTime.Add(this.TimeDelta), num, numberOfRecordsToRead);
if (umcallDataRecords != null && umcallDataRecords.Length > 0)
{
num += umcallDataRecords.Length;
this.WriteToStream(umcallDataRecords, streamWriter, startDateTime, endDateTime);
flag = true;
}
streamWriter.Flush();
}while (flag);
}
}
catch (ArgumentException exception)
{
base.WriteError(exception, ErrorCategory.InvalidArgument, null);
}
catch (ObjectDisposedException exception2)
{
base.WriteError(exception2, ErrorCategory.InvalidArgument, null);
}
catch (IOException exception3)
{
base.WriteError(exception3, ErrorCategory.WriteError, null);
}
catch (UnableToFindUMReportDataException exception4)
{
base.WriteError(exception4, ErrorCategory.ReadError, null);
}
catch (StorageTransientException exception5)
{
base.WriteError(exception5, ErrorCategory.ReadError, null);
}
catch (StoragePermanentException exception6)
{
base.WriteError(exception6, ErrorCategory.ReadError, null);
}
catch (HttpException exception7)
{
base.WriteError(exception7, ErrorCategory.WriteError, null);
}
catch (CDROperationException exception8)
{
base.WriteError(exception8, ErrorCategory.ReadError, null);
}
catch (EWSUMMailboxAccessException exception9)
{
base.WriteError(exception9, ErrorCategory.ReadError, null);
}
}
// 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);
}
