private ExDateTime GetNextHalfHour()
{
ExDateTime d = ExDateTime.GetNow(base.PropertyBag.ExTimeZone);
if (d.Minute < 30)
{
d = d.AddMinutes((double)(30 - d.Minute));
}
else
{
d = d.AddMinutes((double)(60 - d.Minute));
}
return(d - TimeSpan.FromMilliseconds((double)(d.Second * 1000 + d.Millisecond)));
}
// Token: 0x06000B9D RID: 2973 RVA: 0x0004D360 File Offset: 0x0004B560
internal void GenerateOutOfPolicyOutOfWorkingHours(WorkingHours wh)
{
WorkingPeriod workingPeriod = wh.WorkingPeriodArray[0];
StringCollection stringCollection = new StringCollection();
string[] dayNames = this.CultureInfo.DateTimeFormat.DayNames;
for (int i = 0; i < 7; i++)
{
DaysOfWeek daysOfWeek = WorkingHours.DayToDays((DayOfWeek)i);
if ((workingPeriod.DayOfWeek & daysOfWeek) != (DaysOfWeek)0)
{
stringCollection.Add(dayNames[i]);
}
}
ExDateTime now = ExDateTime.GetNow(this.CalendarItemTz);
ExDateTime exDateTime = new ExDateTime(this.CalendarItemTz, now.Year, now.Month, now.Day, this.CultureInfo.Calendar);
ExDateTime exDateTime2 = exDateTime.AddMinutes((double)workingPeriod.StartTimeInMinutes);
ExDateTime exDateTime3 = exDateTime.AddMinutes((double)workingPeriod.EndTimeInMinutes);
string startDisplay = exDateTime2.ToString(this.CultureInfo.DateTimeFormat.ShortTimePattern);
string endDisplay = exDateTime3.ToString(this.CultureInfo.DateTimeFormat.ShortTimePattern);
string daysString;
if (stringCollection.Count == 0)
{
daysString = string.Empty;
}
else
{
daysString = " " + Strings.descOn(stringCollection[0]).ToString(this.CultureInfo);
if (stringCollection.Count > 1)
{
for (int j = 1; j < stringCollection.Count - 1; j++)
{
daysString = Strings.descCommaList(daysString, stringCollection[j]).ToString(this.CultureInfo);
}
daysString = Strings.descAndList(daysString, stringCollection[stringCollection.Count - 1]).ToString(this.CultureInfo);
}
}
this.GetResponseBody = (() => this.GenerateResponseWithTimeZoneInfo(Strings.descWorkingHours(startDisplay, endDisplay, daysString).ToString(this.CultureInfo)));
this.GetResponseSubjectPrefix = delegate()
{
if (!this.IsRecurrence)
{
return(Strings.descDeclined.ToString(this.CultureInfo));
}
return(Strings.descDeclinedAll.ToString(this.CultureInfo));
};
this.GetDelegateBody = (() => this.GenerateOutOfPolicyDelegateResponse(Strings.descDelegateWorkHours(Strings.descWorkingHours(startDisplay, endDisplay, daysString).ToString(this.DelegateCultureInfo))));
}
public static int CalculateReminderMinutesBeforeStart(VAlarm valarm, ExDateTime startTime, ExDateTime endTime)
{
int result;
if (valarm.ValueType == CalendarValueType.Duration)
{
if (valarm.TriggerRelationship == TriggerRelationship.Start || valarm.TriggerRelationship == TriggerRelationship.None)
{
result = ((valarm.TimeSpan != TimeSpan.MinValue) ? ((int)valarm.TimeSpan.Negate().TotalMinutes) : 15);
}
else if (valarm.TriggerRelationship == TriggerRelationship.End)
{
int num = (int)valarm.TimeSpan.TotalMinutes;
ExDateTime dt = endTime.AddMinutes((double)num);
result = (int)(startTime - dt).TotalMinutes;
}
else
{
result = 15;
}
}
else
{
result = (int)(startTime - valarm.ExDateTime).TotalMinutes;
}
return(result);
}
private void BuildScriptDescriptor(ScriptComponentDescriptor descriptor)
{
descriptor.AddElementProperty("SearchButton", this.searchButton.ClientID, true);
descriptor.AddElementProperty("ClearButton", this.clearButton.ClientID, true);
descriptor.AddComponentProperty("FromEditor", this.senderMatches.ClientID, true);
descriptor.AddComponentProperty("ToEditor", this.recipientMatches.ClientID, true);
descriptor.AddElementProperty("MessageIDTextBox", this.messageIDTextBox.ClientID, true);
descriptor.AddComponentProperty("ListView", this.listViewSearchResults.ClientID, true);
descriptor.AddComponentProperty("ListViewDataSource", this.messageTraceDataSource.ClientID, true);
descriptor.AddComponentProperty("ListViewRefreshMethod", this.messageTraceDataSource.RefreshWebServiceMethod.ClientID, true);
descriptor.AddElementProperty("DdMessageTimeFrame", this.ddMessageTimeframe.ClientID, true);
descriptor.AddElementProperty("DdDeliveryStatus", this.ddDeliveryStatus.ClientID, true);
descriptor.AddElementProperty("CustomLink", this.customLink.ClientID, true);
ExDateTime dateTimeValue = ExDateTime.UtcNow.ToUserExDateTime();
dateTimeValue = dateTimeValue.AddMinutes((double)((60 - dateTimeValue.Minute) % 30));
descriptor.AddProperty("StartDate", dateTimeValue.AddHours(-48.0).ToUserDateTimeGeneralFormatString(), true);
descriptor.AddProperty("EndDate", dateTimeValue.ToUserDateTimeGeneralFormatString(), true);
ExTimeZone exTimeZone;
if (RbacPrincipal.Current.UserTimeZone != null)
{
exTimeZone = RbacPrincipal.Current.UserTimeZone;
}
else if (!ExTimeZoneEnumerator.Instance.TryGetTimeZoneByName("UTC", out exTimeZone))
{
exTimeZone = ExTimeZone.UtcTimeZone;
}
descriptor.AddProperty("TimeZone", exTimeZone.Id, true);
descriptor.AddUrlProperty("PickerFormUrl", "~/Pickers/CustomDateRangePicker.aspx", this);
}
// 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);
}
private static bool ParseDateTimeRange(HttpRequest request, CalendarItemBase calendarItem, bool isAllDayEvent, bool autoFixEndDate, out string errorMessage, out EditCalendarItemHelper.CalendarItemUpdateFlags updateFlags, UserContext userContext)
{
updateFlags = EditCalendarItemHelper.CalendarItemUpdateFlags.None;
errorMessage = null;
if (!string.IsNullOrEmpty(Utilities.GetFormParameter(request, "selSM", false)))
{
ExDateTime exDateTime = CalendarUtilities.ParseDateTimeFromForm(request, "selSY", "selSM", "selSD", isAllDayEvent ? null : "selST", userContext);
ExDateTime exDateTime2 = CalendarUtilities.ParseDateTimeFromForm(request, "selEY", "selEM", "selED", isAllDayEvent ? null : "selET", userContext);
if (isAllDayEvent)
{
exDateTime2 = exDateTime2.IncrementDays(1);
}
if (exDateTime > exDateTime2)
{
if (!autoFixEndDate)
{
errorMessage = LocalizedStrings.GetNonEncoded(107113300);
return(false);
}
exDateTime2 = exDateTime.AddMinutes(60.0);
}
if (!exDateTime.Equals(calendarItem.StartTime))
{
updateFlags |= EditCalendarItemHelper.CalendarItemUpdateFlags.TimeChanged;
calendarItem.StartTime = exDateTime;
}
if (!exDateTime2.Equals(calendarItem.EndTime))
{
updateFlags |= EditCalendarItemHelper.CalendarItemUpdateFlags.TimeChanged;
calendarItem.EndTime = exDateTime2;
}
}
return(true);
}
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();
}
// Token: 0x06003125 RID: 12581 RVA: 0x001217A0 File Offset: 0x0011F9A0
public static void RenderReminderTimeDropDownList(UserContext userContext, TextWriter output, Item item, bool isEnabled)
{
ExDateTime today = ExDateTime.Today;
if (item == null)
{
TimeDropDownList.RenderTimePicker(output, today.AddMinutes((double)userContext.WorkingHours.WorkDayStartTimeInWorkingHoursTimeZone), "divRemindTime", isEnabled);
return;
}
object obj = item.TryGetProperty(ItemSchema.ReminderDueBy);
if (obj is ExDateTime)
{
TimeDropDownList.RenderTimePicker(output, (ExDateTime)obj, "divRemindTime", isEnabled);
return;
}
TimeDropDownList.RenderTimePicker(output, today.AddMinutes((double)userContext.WorkingHours.WorkDayStartTimeInWorkingHoursTimeZone), "divRemindTime", isEnabled);
}
// Token: 0x06001972 RID: 6514 RVA: 0x000949BC File Offset: 0x00092BBC
private void AddWorkingPeriodForDay(List <WorkingHours.WorkingPeriod> workingPeriods, ExDateTime day, int offset)
{
ExDateTime day2 = day.IncrementDays(offset);
if (!this.IsWorkDay(day2.DayOfWeek))
{
return;
}
int val = this.GetWorkDayStartTime(day2) + offset * 1440;
int val2 = this.GetWorkDayEndTime(day2) + offset * 1440;
WorkingHours.WorkingPeriod workingPeriod = new WorkingHours.WorkingPeriod();
workingPeriod.Start = day.AddMinutes((double)Math.Max(0, Math.Min(1440, val)));
workingPeriod.End = day.AddMinutes((double)Math.Max(0, Math.Min(1440, val2)));
if (workingPeriod.Start < workingPeriod.End)
{
workingPeriods.Add(workingPeriod);
}
}
private void SetRequiredAttendeeAvailability(AttendeeData attendee, IndividualAttendeeConflictData attendeeConflict)
{
BusyType busyType = attendeeConflict.BusyType;
if (busyType == BusyType.NoData)
{
this.requiredAttendeeCount--;
return;
}
if (this.strongestReqConflict < busyType)
{
this.strongestReqConflict = busyType;
}
if (busyType != BusyType.Free)
{
this.requiredAttendeeConflictCount++;
}
this.SetConvenience(attendee);
int num = this.meetingDuration / this.options.FreeBusyInterval;
int num2 = 0;
int num3 = 0;
double num4 = 0.0;
if (num > 0)
{
BusyType[] busyTypeRange = attendee.GetBusyTypeRange(this.meetingStartTime, this.meetingDuration);
ExDateTime startUtc = this.meetingStartTime.ToUtc();
foreach (BusyType busyType2 in busyTypeRange)
{
ExDateTime exDateTime = startUtc.AddMinutes((double)this.options.FreeBusyInterval);
if (busyType2 != BusyType.Free)
{
num4 += this.GetConflictValue(busyType2);
num3++;
}
else if (!attendee.WorkingHours.IsWorkTime(startUtc, exDateTime))
{
num4 += 0.25;
num3++;
}
else if (num3 == 0)
{
num2++;
}
startUtc = exDateTime;
}
this.sumReqFrontTime += (double)num2 / (double)num;
double num5 = (double)num2 / (double)num;
if (num5 < this.minPctReqFrontTime)
{
this.minPctReqFrontTime = num5;
}
this.weightedReqConflicts += num4 / (double)num;
}
}
internal override void Initialize(bool newItem)
{
base.Initialize(newItem);
this[InternalSchema.ItemClass] = "IPM.Appointment";
ExDateTime nextHalfHour = this.GetNextHalfHour();
this[InternalSchema.StartTime] = nextHalfHour;
this[InternalSchema.EndTime] = nextHalfHour.AddMinutes(30.0);
this[InternalSchema.AppointmentRecurring] = false;
this[InternalSchema.IsRecurring] = false;
this[InternalSchema.IsException] = false;
this[InternalSchema.ConversationIndexTracking] = true;
this[InternalSchema.SideEffects] = (SideEffects.OpenToDelete | SideEffects.CoerceToInbox | SideEffects.OpenToCopy | SideEffects.OpenToMove | SideEffects.OpenForCtxMenu);
}
public static IEnumerable <PublicFolderFreeBusyAppointment> FromBinary(byte[][] binaryData, ExDateTime[] publishMonths, BusyType busyType)
{
List <PublicFolderFreeBusyAppointment> list = new List <PublicFolderFreeBusyAppointment>();
for (int i = 0; i < binaryData.Length; i++)
{
ExDateTime exDateTime = publishMonths[i];
using (MemoryStream memoryStream = new MemoryStream(binaryData[i]))
{
using (BinaryReader binaryReader = new BinaryReader(memoryStream))
{
while (memoryStream.Position + 4L <= memoryStream.Length)
{
ushort num = binaryReader.ReadUInt16();
ushort num2 = binaryReader.ReadUInt16();
list.Add(new PublicFolderFreeBusyAppointment(exDateTime.AddMinutes((double)num), exDateTime.AddMinutes((double)num2), busyType));
}
}
}
}
return(list);
}
private bool PromoteReminders()
{
if (base.Context.Method == CalendarMethod.Request || base.Context.Method == CalendarMethod.Publish)
{
ExDateTime valueOrDefault = base.GetValueOrDefault <ExDateTime>(InternalSchema.DueDate, ExDateTime.MinValue);
bool flag = false;
if (this.item != null && this.item.Session != null && this.item.Session.IsOlcMoveDestination)
{
InternalRecurrence recurrenceFromItem = CalendarItem.GetRecurrenceFromItem(this.item);
ExDateTime exDateTime;
if (recurrenceFromItem != null)
{
exDateTime = recurrenceFromItem.EndDate + recurrenceFromItem.EndOffset;
}
else
{
exDateTime = valueOrDefault;
}
flag = (exDateTime.CompareTo(ExDateTime.UtcNow) < 0);
}
if (this.displayVAlarm != null && this.displayVAlarm.Validate() && !flag && (this.dueTime != null || this.displayVAlarm.ValueType == CalendarValueType.DateTime))
{
int num = VAlarm.CalculateReminderMinutesBeforeStart(this.displayVAlarm, valueOrDefault, valueOrDefault);
base.SetProperty(InternalSchema.ReminderIsSetInternal, true);
base.SetProperty(InternalSchema.ReminderDueBy, valueOrDefault.AddMinutes((double)(-(double)num)));
}
else
{
base.SetProperty(InternalSchema.ReminderMinutesBeforeStart, 0);
base.SetProperty(InternalSchema.ReminderIsSetInternal, false);
}
if (!flag)
{
VAlarm.PromoteEmailReminders(this.item, this.emailVAlarms, valueOrDefault, valueOrDefault, false);
}
}
return(true);
}
internal Suggestion(ExDateTime meetingStartTime, int inputMeetingDuration, int inputRequiredAttendeeCount, int inputOptionalAttendeeCount, AttendeeData[] inputAttendees, ConfigOptions inputOptions)
{
this.options = inputOptions;
Suggestion.Tracer.TraceDebug <object, ExDateTime>((long)this.GetHashCode(), "{0}: Suggestion.Suggestion() entered, inputStartDateTime: {1}", TraceContext.Get(), meetingStartTime);
this.meetingStartTime = meetingStartTime;
this.startDateTime = meetingStartTime.LocalTime;
this.meetingDuration = inputMeetingDuration;
this.requiredAttendeeCount = inputRequiredAttendeeCount;
this.optionalAttendeeCount = inputOptionalAttendeeCount;
ExDateTime endUtc = meetingStartTime.AddMinutes((double)inputMeetingDuration);
bool flag = true;
int num = 0;
this.attendeeConflictDataArray = new AttendeeConflictData[inputAttendees.Length];
foreach (AttendeeData attendeeData in inputAttendees)
{
BusyType busyType = attendeeData.GetBusyType(this.meetingStartTime, this.meetingDuration);
IndividualAttendeeConflictData individualAttendeeConflictData = IndividualAttendeeConflictData.Create(attendeeData, busyType);
if (attendeeData.AttendeeType == MeetingAttendeeType.Required || attendeeData.AttendeeType == MeetingAttendeeType.Organizer)
{
this.SetRequiredAttendeeAvailability(attendeeData, individualAttendeeConflictData);
if (individualAttendeeConflictData.BusyType != BusyType.NoData)
{
this.excludeConflict |= attendeeData.ExcludeConflict;
}
}
else if (attendeeData.AttendeeType == MeetingAttendeeType.Optional)
{
this.SetOptionalAttendeeAvailability(attendeeData, individualAttendeeConflictData);
}
else if (attendeeData.AttendeeType == MeetingAttendeeType.Room)
{
this.SetRoomAttendeeAvailability(attendeeData, individualAttendeeConflictData);
if (individualAttendeeConflictData.BusyType != BusyType.NoData)
{
flag &= attendeeData.ExcludeConflict;
}
}
else if (attendeeData.AttendeeType == MeetingAttendeeType.Resource)
{
this.SetResourceAttendeeAvailability(attendeeData, individualAttendeeConflictData);
}
else
{
Suggestion.Tracer.TraceError <object, MeetingAttendeeType>((long)this.GetHashCode(), "{0}: unknown attendee type: {1}", TraceContext.Get(), attendeeData.AttendeeType);
}
if (attendeeData.AttendeeType == MeetingAttendeeType.Organizer)
{
this.isWorkTime = attendeeData.WorkingHours.IsWorkTime(this.meetingStartTime, endUtc);
}
this.attendeeConflictDataArray[num] = individualAttendeeConflictData;
num++;
}
if (this.roomsRequested)
{
this.excludeConflict = (this.excludeConflict || flag);
}
Suggestion.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: required: {1}, optional: {2}, worktime?: {3}", new object[]
{
TraceContext.Get(),
this.requiredAttendeeCount,
this.optionalAttendeeCount,
this.isWorkTime
});
if (this.requiredAttendeeCount != 0)
{
this.sumPctReqFrontTime = this.sumReqFrontTime / (double)this.requiredAttendeeCount;
this.weightedPctReqConflicts = this.weightedReqConflicts / (double)this.requiredAttendeeCount;
}
else
{
this.weightedPctReqConflicts = 1.0;
}
if (this.optionalAttendeeCount != 0)
{
this.pctOptConflicts = (double)this.optionalAttendeeConflictCount / (double)this.optionalAttendeeCount;
this.pctOptOverlap = this.optOverlap / (double)this.optionalAttendeeCount;
}
this.timeSlotRating = this.GetRating();
if (this.weightedPctReqConflicts == 0.0)
{
this.bucket = SuggestionQuality.Excellent;
}
else if (this.weightedPctReqConflicts * 100.0 >= 50.0)
{
this.bucket = SuggestionQuality.Poor;
}
else if (this.weightedPctReqConflicts * 100.0 <= (double)this.options.GoodThreshold)
{
this.bucket = SuggestionQuality.Good;
}
else
{
this.bucket = SuggestionQuality.Fair;
}
Suggestion.Tracer.TraceDebug <object, long, SuggestionQuality>((long)this.GetHashCode(), "{0}: final suggestion results, timeSlotRating: {1}, bucket: {2}", TraceContext.Get(), this.timeSlotRating, this.bucket);
}
private void MatchCrossPremiseMessages(MapiFolder responseFolder, MapiFolder probeFolder, SmtpAddress source, List <SmtpAddress> targets)
{
using (MapiTable contentsTable = responseFolder.GetContentsTable())
{
using (MapiTable contentsTable2 = probeFolder.GetContentsTable())
{
contentsTable.SetColumns(new PropTag[]
{
PropTag.EntryId,
PropTag.Subject,
PropTag.ClientSubmitTime
});
contentsTable2.SetColumns(new PropTag[]
{
PropTag.EntryId,
PropTag.Subject,
PropTag.ClientSubmitTime
});
PropValue[][] array = contentsTable.QueryRows(1000, QueryRowsFlags.None);
PropValue[][] array2 = contentsTable2.QueryRows(1000, QueryRowsFlags.None);
List <byte[]> list = new List <byte[]>();
List <byte[]> list2 = new List <byte[]>();
Dictionary <SmtpAddress, CrossPremiseTestMailFlowHelper.HealthData> dictionary = new Dictionary <SmtpAddress, CrossPremiseTestMailFlowHelper.HealthData>(targets.Count);
for (int i = 0; i <= array2.GetUpperBound(0); i++)
{
if (TestMailFlowHelper.IsValidPropData(array2, i, 3))
{
string text = (string)array2[i][1].Value;
if (text.StartsWith("CrossPremiseMailFlowMonitoring-", StringComparison.OrdinalIgnoreCase))
{
byte[] bytes = array2[i][0].GetBytes();
using (MapiMessage mapiMessage = (MapiMessage)probeFolder.OpenEntry(bytes))
{
SmtpAddress key = SmtpAddress.Parse((string)mapiMessage.GetProp(PropTag.ReceivedByEmailAddress).Value);
if (!dictionary.ContainsKey(key))
{
dictionary.Add(key, new CrossPremiseTestMailFlowHelper.HealthData(EnhancedTimeSpan.Zero, EnhancedTimeSpan.Zero, 0, 0, 0, 0));
}
ExDateTime exDateTime = (ExDateTime)array2[i][2].GetDateTime();
if (exDateTime.Add(base.Task.CrossPremisesExpirationTimeout) < ExDateTime.UtcNow)
{
dictionary[key].ExpiredNumber++;
list.Add(bytes);
}
else
{
for (int j = 0; j <= array.GetUpperBound(0); j++)
{
if (TestMailFlowHelper.IsValidPropData(array, j, 3))
{
string text2 = (string)array[j][1].Value;
if (text2.EndsWith(text, StringComparison.OrdinalIgnoreCase))
{
byte[] bytes2 = array[j][0].GetBytes();
if (((ExDateTime)array[j][2].GetDateTime()).Add(base.Task.CrossPremisesExpirationTimeout) < ExDateTime.UtcNow)
{
list2.Add(bytes2);
}
else
{
using (MapiMessage mapiMessage2 = (MapiMessage)responseFolder.OpenEntry(bytes2))
{
EnhancedTimeSpan t;
EnhancedTimeSpan t2;
if (this.ProcessCrossPremiseMessagePair(mapiMessage, mapiMessage2, source.ToString(), key.ToString(), out t, out t2))
{
dictionary[key].ProbeLatency += t;
dictionary[key].ResponseLatency += t2;
dictionary[key].SuccessNumber++;
}
else
{
dictionary[key].FailedNumber++;
}
}
list2.Add(bytes2);
list.Add(bytes);
}
}
}
}
if (!list.Contains(bytes) && exDateTime.AddMinutes(10.0) < ExDateTime.UtcNow)
{
dictionary[key].PendingNumber++;
}
}
}
}
}
}
this.SaveHealthData(source, dictionary);
if (list2.Count > 0)
{
responseFolder.DeleteMessages(DeleteMessagesFlags.ForceHardDelete, list2.ToArray());
}
if (list.Count > 0)
{
probeFolder.DeleteMessages(DeleteMessagesFlags.ForceHardDelete, list.ToArray());
}
}
}
}
public void GetFlagDialog()
{
ExDateTime date = DateTimeUtilities.GetLocalTime().Date;
ExDateTime exDateTime = ExDateTime.MinValue;
ExDateTime exDateTime2 = ExDateTime.MinValue;
ExDateTime exDateTime3 = ExDateTime.MinValue;
bool flag = false;
FlagStatus flagStatus = FlagStatus.NotFlagged;
bool flag2 = true;
OwaStoreObjectId owaStoreObjectId = base.GetParameter("fldrId") as OwaStoreObjectId;
OwaStoreObjectId latestFlaggedOrNormalItem = this.GetLatestFlaggedOrNormalItem();
if (latestFlaggedOrNormalItem != null)
{
using (Item item = Utilities.GetItem <Item>(base.UserContext, latestFlaggedOrNormalItem, FlagEventHandler.prefetchProperties))
{
flag2 = (!Utilities.IsPublic(item) && !(item is MeetingMessage));
flagStatus = FlagEventHandler.GetFlagStatus(item);
exDateTime = ItemUtility.GetProperty <ExDateTime>(item, TaskSchema.StartDate, ExDateTime.MinValue);
if (exDateTime.Year <= 1601)
{
exDateTime = ExDateTime.MinValue;
}
exDateTime2 = ItemUtility.GetProperty <ExDateTime>(item, TaskSchema.DueDate, ExDateTime.MinValue);
if (exDateTime2.Year <= 1601)
{
exDateTime2 = ExDateTime.MinValue;
}
flag = ItemUtility.GetProperty <bool>(item, ItemSchema.ReminderIsSet, false);
if (flag)
{
exDateTime3 = ItemUtility.GetProperty <ExDateTime>(item, ItemSchema.ReminderDueBy, ExDateTime.MinValue);
if (exDateTime3.Year <= 1601)
{
exDateTime3 = ExDateTime.MinValue;
}
}
}
}
if (owaStoreObjectId != null)
{
flag2 = !owaStoreObjectId.IsPublic;
}
if (flagStatus == FlagStatus.NotFlagged)
{
if (exDateTime2 == ExDateTime.MinValue)
{
exDateTime2 = DateTimeUtilities.GetLocalTime().Date;
}
if (exDateTime == ExDateTime.MinValue || exDateTime > exDateTime2)
{
exDateTime = exDateTime2;
}
}
if (exDateTime3 == ExDateTime.MinValue)
{
if (exDateTime == ExDateTime.MinValue || exDateTime == date)
{
exDateTime3 = date;
int num = base.UserContext.WorkingHours.GetWorkDayEndTime(exDateTime3) - 60;
exDateTime3 = exDateTime3.AddMinutes((double)num);
}
else
{
exDateTime3 = exDateTime;
exDateTime3 = exDateTime3.AddMinutes((double)base.UserContext.WorkingHours.GetWorkDayStartTime(exDateTime3));
}
}
RenderingUtilities.RenderStringVariable(this.Writer, "sDT", LocalizedStrings.GetNonEncoded(-941242639));
StringBuilder stringBuilder = new StringBuilder();
StringWriter stringWriter = new StringWriter(stringBuilder);
stringWriter.Write("<table class=flgDtRm><col><col class=pkr><tr><td nowrap>");
stringWriter.Write(LocalizedStrings.GetHtmlEncoded(1089701318));
stringWriter.Write("</td><td nowrap>");
DatePickerDropDownCombo.RenderDatePicker(stringWriter, "tblFlgSD", exDateTime, date, DatePicker.Features.TodayButton | DatePicker.Features.NoneButton);
stringWriter.Write("</td></tr>");
stringWriter.Write("<tr><td>");
stringWriter.Write(LocalizedStrings.GetHtmlEncoded(1012104992));
stringWriter.Write("</td><td>");
DatePickerDropDownCombo.RenderDatePicker(stringWriter, "tblFlgDD", exDateTime2, date, DatePicker.Features.TodayButton | DatePicker.Features.NoneButton);
stringWriter.Write("</td></tr>");
if (flag2)
{
stringWriter.Write("<tr><td colspan=2 nowrap><input type=checkbox id=chkRM");
if (flag)
{
stringWriter.Write(" checked");
}
stringWriter.Write("><label for=chkRM> ");
stringWriter.Write(LocalizedStrings.GetHtmlEncoded(-1024614879));
stringWriter.Write("</label></td></tr>");
stringWriter.Write("<tr><td nowrap class=rmd>");
stringWriter.Write(LocalizedStrings.GetHtmlEncoded(-1966747526));
stringWriter.Write("</td><td>");
DatePickerDropDownCombo.RenderDatePicker(stringWriter, "tblFlgRD", exDateTime3);
stringWriter.Write("</td></tr>");
stringWriter.Write("<tr><td nowrap class=rmd>");
stringWriter.Write(LocalizedStrings.GetHtmlEncoded(-837446999));
stringWriter.Write("</td><td>");
TimeDropDownList.RenderTimePicker(stringWriter, exDateTime3, "divFlgRT");
stringWriter.Write("</td></tr>");
}
stringWriter.Write("</table>");
stringWriter.Close();
RenderingUtilities.RenderStringVariable(this.Writer, "sD", stringBuilder.ToString());
}