private void SaveChangedPropertiesForDelegateForward(StoreDriverDeliveryEventArgsImpl argsImpl)
{
if (argsImpl.PropertiesForDelegateForward == null)
{
argsImpl.PropertiesForDelegateForward = new Dictionary <PropertyDefinition, object>(MeetingMessageProcessingAgent.propertyChangingByProcessing.Length);
}
foreach (PropertyDefinition propertyDefinition in MeetingMessageProcessingAgent.propertyChangingByProcessing)
{
try
{
object obj = argsImpl.MessageItem.TryGetProperty(propertyDefinition);
if (obj != null && !(obj is PropertyError))
{
if (propertyDefinition == CalendarItemBaseSchema.MeetingRequestType && obj is int && (MeetingMessageType)obj == MeetingMessageType.PrincipalWantsCopy)
{
MeetingMessageType valueOrDefault = argsImpl.MessageItem.GetValueOrDefault <MeetingMessageType>(MeetingMessageInstanceSchema.OriginalMeetingType, MeetingMessageType.FullUpdate);
argsImpl.PropertiesForDelegateForward[propertyDefinition] = valueOrDefault;
}
else
{
argsImpl.PropertiesForDelegateForward[propertyDefinition] = obj;
}
}
}
catch (NotInBagPropertyErrorException)
{
}
}
}
internal static bool MeetingCancellationIsOutOfDate(MeetingCancellation meetingCancellation)
{
if (meetingCancellation == null)
{
throw new ArgumentNullException("meetingCancellation");
}
MeetingMessageType property = ItemUtility.GetProperty <MeetingMessageType>(meetingCancellation, CalendarItemBaseSchema.MeetingRequestType, MeetingMessageType.None);
return(property == MeetingMessageType.Outdated);
}
public override void RenderToolbar(TextWriter writer)
{
Toolbar toolbar = new Toolbar(writer, true);
MeetingMessageType meetingMessageType = this.meetingMessageType;
if (meetingMessageType > MeetingMessageType.FullUpdate)
{
if (meetingMessageType != MeetingMessageType.InformationalUpdate)
{
if (meetingMessageType == MeetingMessageType.Outdated)
{
toolbar.RenderStartForSubToolbar();
toolbar.RenderButton(ToolbarButtons.MeetingOutOfDate);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.ShowCalendar);
toolbar.RenderFill();
toolbar.RenderEndForSubToolbar();
return;
}
if (meetingMessageType != MeetingMessageType.PrincipalWantsCopy)
{
return;
}
}
toolbar.RenderStartForSubToolbar();
toolbar.RenderButton(ToolbarButtons.MeetingNoResponseRequired);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.ShowCalendar);
toolbar.RenderFill();
toolbar.RenderEndForSubToolbar();
return;
}
if (meetingMessageType != MeetingMessageType.NewMeetingRequest && meetingMessageType != MeetingMessageType.FullUpdate)
{
return;
}
toolbar.RenderStartForSubToolbar();
toolbar.RenderButton(ToolbarButtons.MeetingAccept);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.MeetingTentative);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.MeetingDecline);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.ShowCalendar);
toolbar.RenderFill();
toolbar.RenderEndForSubToolbar();
if (this.meetingRequest.IsResponseRequested)
{
MeetingPageWriter.RenderResponseEditTypeSelectToolbar(writer);
return;
}
}
private void ProcessChangeHighlights(CalendarItemBase calendarItem, long meetingRequestBodySize, long calendarItemBodySize)
{
int num = base.GetValueOrDefault <int>(InternalSchema.ChangeHighlight, -1);
if (calendarItem.IsNew && !(calendarItem is CalendarItemOccurrence))
{
num = 0;
base.LocationIdentifierHelperInstance.SetLocationIdentifier(47221U);
this[InternalSchema.ChangeHighlight] = num;
}
else
{
ChangeHighlightHelper changeHighlightHelper = MeetingRequest.CompareForChangeHighlightOnUpdatedItems(base.PropertyBag, meetingRequestBodySize, calendarItem.PropertyBag, calendarItemBodySize);
if (this.ShouldPreserveAttendeesChanges(calendarItem))
{
PreservablePropertyContext context = new PreservablePropertyContext(this, calendarItem, (ChangeHighlightProperties)num);
foreach (StorePropertyDefinition storePropertyDefinition in ChangeHighlightHelper.HighlightProperties)
{
if (changeHighlightHelper[storePropertyDefinition])
{
PreservableMeetingMessageProperty preservableMeetingMessageProperty = null;
if (PreservableMeetingMessageProperty.InstanceFromPropertyDefinition.TryGetValue(storePropertyDefinition, out preservableMeetingMessageProperty))
{
changeHighlightHelper[storePropertyDefinition] = !preservableMeetingMessageProperty.ShouldPreserve(context);
}
}
}
}
num = changeHighlightHelper.HighlightFlags;
MeetingMessageType meetingMessageType = changeHighlightHelper.SuggestedMeetingType;
if (meetingMessageType == MeetingMessageType.InformationalUpdate && calendarItem.IsCancelled)
{
meetingMessageType = MeetingMessageType.FullUpdate;
}
if (this.MeetingRequestType != MeetingMessageType.PrincipalWantsCopy)
{
this.MeetingRequestType = meetingMessageType;
}
else
{
base.LocationIdentifierHelperInstance.SetLocationIdentifier(35701U);
this[InternalSchema.OriginalMeetingType] = meetingMessageType;
}
base.LocationIdentifierHelperInstance.SetLocationIdentifier(52085U);
this[InternalSchema.ChangeHighlight] = num;
}
calendarItem.SetChangeHighlight(num);
}
// Token: 0x060020EE RID: 8430 RVA: 0x000BDA3C File Offset: 0x000BBC3C
protected override void RenderButtons()
{
if (!this.isOrganizer)
{
MeetingMessageType meetingMessageType = this.meetingMessageType;
if (meetingMessageType > MeetingMessageType.FullUpdate)
{
if (meetingMessageType != MeetingMessageType.InformationalUpdate)
{
if (meetingMessageType == MeetingMessageType.Outdated)
{
base.RenderButton(ToolbarButtons.MeetingOutOfDate);
return;
}
if (meetingMessageType != MeetingMessageType.PrincipalWantsCopy)
{
return;
}
}
base.RenderButton(ToolbarButtons.MeetingNoResponseRequired);
return;
}
if (meetingMessageType != MeetingMessageType.NewMeetingRequest && meetingMessageType != MeetingMessageType.FullUpdate)
{
return;
}
ToolbarButtonFlags toolbarButtonFlags = ToolbarButtonFlags.None;
if (this.isInArchiveMailbox)
{
toolbarButtonFlags |= ToolbarButtonFlags.Disabled;
}
if (!this.isResponseRequested)
{
base.RenderButton(ToolbarButtons.MeetingAccept, toolbarButtonFlags);
base.RenderButton(ToolbarButtons.MeetingTentative, toolbarButtonFlags);
base.RenderButton(ToolbarButtons.MeetingDecline, toolbarButtonFlags);
return;
}
base.RenderButton(ToolbarButtons.MeetingAcceptMenu, toolbarButtonFlags, new Toolbar.RenderMenuItems(this.RenderMeetingResponseMenuItems));
base.RenderButton(ToolbarButtons.MeetingTentativeMenu, toolbarButtonFlags, new Toolbar.RenderMenuItems(this.RenderMeetingResponseMenuItems));
base.RenderButton(ToolbarButtons.MeetingDeclineMenu, toolbarButtonFlags, new Toolbar.RenderMenuItems(this.RenderMeetingResponseMenuItems));
return;
}
}
// Token: 0x0600079B RID: 1947 RVA: 0x00036360 File Offset: 0x00034560
private void ProcessMeetingRequest(MailboxSession itemStore, MeetingRequest mtgMessage, ref CalendarItemBase originalCalItem, string internetMessageId, int defaultReminderInMinutes)
{
try
{
if (mtgMessage.TryUpdateCalendarItem(ref originalCalItem, false))
{
MeetingMessageType meetingRequestType = mtgMessage.MeetingRequestType;
if (originalCalItem != null)
{
if (originalCalItem.Id == null && MeetingMessageType.NewMeetingRequest == meetingRequestType)
{
int num = (int)Utils.SafeGetProperty(mtgMessage, ItemSchema.ReminderMinutesBeforeStart, defaultReminderInMinutes);
if (num == 1525252321)
{
num = defaultReminderInMinutes;
originalCalItem[ItemSchema.ReminderMinutesBeforeStart] = num;
}
if (num < 0 || num > 2629800)
{
originalCalItem[ItemSchema.ReminderMinutesBeforeStart] = defaultReminderInMinutes;
}
if (!originalCalItem.Reminder.IsSet)
{
originalCalItem.Reminder.MinutesBeforeStart = defaultReminderInMinutes;
originalCalItem.Reminder.IsSet = true;
}
}
originalCalItem.Validate();
ConflictResolutionResult conflictResolutionResult = originalCalItem.Save(SaveMode.ResolveConflicts);
originalCalItem.Load();
if (conflictResolutionResult.SaveStatus == SaveResult.IrresolvableConflict)
{
throw new SaveConflictException(ServerStrings.ExSaveFailedBecauseOfConflicts(originalCalItem.Id), conflictResolutionResult);
}
}
}
CalendarAssistantPerformanceCounters.MeetingRequests.Increment();
CalendarProcessing.TracerPfd.TracePfd <int, object, string>((long)mtgMessage.GetHashCode(), "PFD IWC {0} {1}:completed Processing Meeting Request for {2}", 24727, TraceContext.Get(), internetMessageId);
}
catch (ObjectNotFoundException innerException)
{
throw new TransientException(Strings.descTransientErrorInRequest, innerException);
}
}
// Token: 0x06000920 RID: 2336 RVA: 0x0003D85C File Offset: 0x0003BA5C
private static CalendarNotificationType AnalyzeEvent(MapiEvent mapiEvent, MeetingMessage meeting)
{
CalendarNotificationType result = CalendarNotificationType.Uninteresting;
if (meeting is MeetingRequest)
{
MeetingRequest meetingRequest = (MeetingRequest)meeting;
MeetingMessageType meetingRequestType = meetingRequest.MeetingRequestType;
if (meetingRequestType <= MeetingMessageType.FullUpdate)
{
if (meetingRequestType != MeetingMessageType.NewMeetingRequest)
{
if (meetingRequestType != MeetingMessageType.FullUpdate)
{
return(result);
}
goto IL_4A;
}
}
else
{
if (meetingRequestType == MeetingMessageType.InformationalUpdate || meetingRequestType == MeetingMessageType.SilentUpdate)
{
goto IL_4A;
}
if (meetingRequestType != MeetingMessageType.PrincipalWantsCopy)
{
return(result);
}
}
return(CalendarNotificationType.NewUpdate);
IL_4A:
if (CalendarChangeProcessor.InterestingFlagsExists(meetingRequest.ChangeHighlight, MapiExtendedEventFlags.NoReminderPropertyModified))
{
result = CalendarNotificationType.ChangedUpdate;
}
}
else if (meeting is MeetingCancellation)
{
result = CalendarNotificationType.DeletedUpdate;
}
return(result);
}
// Token: 0x060000E3 RID: 227 RVA: 0x00007A4C File Offset: 0x00005C4C
public override void RenderToolbar(TextWriter writer)
{
Toolbar toolbar = new Toolbar(writer, true);
toolbar.RenderStartForSubToolbar();
if (base.CalendarItemBase.IsCancelled)
{
toolbar.RenderButton(ToolbarButtons.RemoveFromCalendar);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.ShowCalendar);
toolbar.RenderFill();
toolbar.RenderEndForSubToolbar();
return;
}
MeetingMessageType meetingMessageType = this.meetingMessageType;
if (meetingMessageType != MeetingMessageType.NewMeetingRequest && meetingMessageType != MeetingMessageType.FullUpdate)
{
if (meetingMessageType != MeetingMessageType.Outdated)
{
return;
}
toolbar.RenderButton(ToolbarButtons.MeetingOutOfDate);
toolbar.RenderFill();
toolbar.RenderEndForSubToolbar();
}
else
{
toolbar.RenderButton(ToolbarButtons.MeetingAccept);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.MeetingTentative);
toolbar.RenderDivider();
toolbar.RenderButton(ToolbarButtons.MeetingDecline);
toolbar.RenderDivider();
toolbar.RenderFill();
toolbar.RenderEndForSubToolbar();
if (this.IsResponseRequested)
{
MeetingPageWriter.RenderResponseEditTypeSelectToolbar(writer);
return;
}
}
}
public static void ProcessMeetingMessage(IStoreSession session, MeetingMessage message, Event @event, IXSOFactory xsoFactory = null)
{
try
{
MeetingMessageType type = message.Type;
if (type != MeetingMessageType.SeriesRequest)
{
throw new NotSupportedException(string.Format("Not supported meeting message type: {0}", message.Type));
}
ProcessMeetingMessageCommand processMeetingMessageCommand = new ProcessSeriesMeetingRequest
{
MeetingMessage = message,
Event = @event
};
CalendaringContainer calendaringContainer = new CalendaringContainer(session, xsoFactory);
processMeetingMessageCommand.Scope = (calendaringContainer.Calendars.Default.Events as Events);
processMeetingMessageCommand.Execute(null);
}
catch (Exception arg)
{
ExTraceGlobals.MeetingMessageProcessingTracer.TraceError <string, Exception>(0L, "Error processing meeting message for message '{0}'. Error {1}", message.Id ?? string.Empty, arg);
throw;
}
}
private void SetDefaultMeetingRequestTypeIfNeeded(CalendarItemBase calendarItem)
{
object valueOrDefault = base.GetValueOrDefault <object>(InternalSchema.MeetingRequestType);
MeetingMessageType meetingRequestType = MeetingMessageType.FullUpdate;
bool flag = false;
if (valueOrDefault == null)
{
flag = true;
}
if (calendarItem.IsNew && this.MeetingRequestType != MeetingMessageType.PrincipalWantsCopy)
{
if (!(calendarItem is CalendarItemOccurrence))
{
meetingRequestType = MeetingMessageType.NewMeetingRequest;
}
flag = true;
}
if (flag)
{
base.LocationIdentifierHelperInstance.SetLocationIdentifier(48245U, LastChangeAction.SetDefaultMeetingRequestType);
this.MeetingRequestType = meetingRequestType;
}
}
// Token: 0x060020EC RID: 8428 RVA: 0x000BDA0B File Offset: 0x000BBC0B
internal EditMeetingInviteToolbar(string id, bool isResponseRequested, bool isInArchiveMailbox, MeetingMessageType meetingMessageType) : base(id, ToolbarType.Form)
{
this.isResponseRequested = isResponseRequested;
this.isInArchiveMailbox = isInArchiveMailbox;
this.meetingMessageType = meetingMessageType;
}
// Token: 0x060007B5 RID: 1973 RVA: 0x0003739C File Offset: 0x0003559C
private void DetermineIfWeDelete(List <VersionedId> itemsToDelete, MeetingMessage item, object[] rowProperties, ExDateTime itemOwnerChangeTime, string sentRepresenting, int itemSequenceNumber, ref OldMessageDeletion.LatestItemInfo latestInfo, ref bool hasAttachments, ref bool hasBody)
{
bool flag = item is MeetingRequest;
bool flag2 = item is MeetingResponse;
object obj = rowProperties[0];
MailboxSession itemStore = item.Session as MailboxSession;
if (rowProperties[1] != null && !(rowProperties[1] is PropertyError))
{
VersionedId versionedId = (VersionedId)rowProperties[1];
if (versionedId.Equals(latestInfo.LatestItemId))
{
return;
}
int num = 0;
bool flag3 = false;
if (!(rowProperties[3] is PropertyError) && rowProperties[3] is int)
{
num = (int)rowProperties[3];
flag3 = true;
if (latestInfo.LatestSequenceNumber < num)
{
if (rowProperties[9] is ExDateTime)
{
latestInfo.LatestOldStartTime = (ExDateTime)rowProperties[9];
latestInfo.LatestSequenceNumber = num;
}
if (rowProperties[10] is ExDateTime)
{
latestInfo.LatestOldEndTime = (ExDateTime)rowProperties[10];
latestInfo.LatestSequenceNumber = num;
}
if (rowProperties[11] is string && !string.IsNullOrEmpty((string)rowProperties[11]))
{
latestInfo.LatestOldLocationStr = (string)rowProperties[11];
latestInfo.LatestSequenceNumber = num;
}
}
}
bool flag4 = false;
bool flag5 = false;
bool flag6 = false;
if (flag3)
{
flag4 = (num == itemSequenceNumber);
flag5 = (num < itemSequenceNumber);
}
else if (!(rowProperties[6] is PropertyError) && rowProperties[6] is ExDateTime && latestInfo.LatestClientSubmitTime >= (ExDateTime)rowProperties[6])
{
flag6 = true;
}
if (flag5 || flag6)
{
if (!flag2)
{
if (flag && !(rowProperties[4] is PropertyError) && rowProperties[4] is int)
{
latestInfo.RollingHighlight |= (int)rowProperties[4];
}
object obj2 = rowProperties[13];
if (obj2 is int)
{
MeetingMessageType meetingMessageType = (MeetingMessageType)obj2;
latestInfo.FullUpdateDeleted |= (meetingMessageType == MeetingMessageType.FullUpdate || meetingMessageType == MeetingMessageType.NewMeetingRequest);
}
itemsToDelete.Add(versionedId);
return;
}
if (!this.SentRepresentingMatches(sentRepresenting, rowProperties[5]))
{
return;
}
itemsToDelete.Add(versionedId);
return;
}
else if (flag4)
{
if (flag2)
{
this.HandleResponsesWithSameSequenceNumber(itemStore, item, versionedId, rowProperties, sentRepresenting, ref latestInfo, itemsToDelete, ref hasAttachments, ref hasBody);
return;
}
if (flag && !(rowProperties[4] is PropertyError) && rowProperties[4] is int)
{
latestInfo.RollingHighlight |= (int)rowProperties[4];
}
if (!(rowProperties[8] is PropertyError) && rowProperties[8] is ExDateTime)
{
ExDateTime t = (ExDateTime)rowProperties[8];
if (t < itemOwnerChangeTime)
{
if (!(rowProperties[4] is PropertyError) && rowProperties[4] is int)
{
latestInfo.RollingHighlight |= (int)rowProperties[4];
}
object obj3 = rowProperties[13];
if (obj3 is int)
{
MeetingMessageType meetingMessageType2 = (MeetingMessageType)obj3;
latestInfo.FullUpdateDeleted |= (meetingMessageType2 == MeetingMessageType.FullUpdate || meetingMessageType2 == MeetingMessageType.NewMeetingRequest);
}
itemsToDelete.Add(versionedId);
}
}
}
}
}
private void CopyMeetingRequestProperties(CalendarItemBase calendarItem, bool preserveLocalExceptions)
{
long size = calendarItem.Body.Size;
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(42101U);
if (!base.IsRepairUpdateMessage || (this.ChangeHighlight & ChangeHighlightProperties.BodyProps) == ChangeHighlightProperties.BodyProps)
{
Body.CopyBody(this, calendarItem, false);
this.CopyNlgPropertiesTo(calendarItem);
}
ChangeHighlightProperties changeHighlight = this.ChangeHighlight;
this.ProcessChangeHighlights(calendarItem, calendarItem.Body.Size, size);
MeetingMessageType meetingMessageType = base.GetValueOrDefault <MeetingMessageType>(InternalSchema.MeetingRequestType, MeetingMessageType.NewMeetingRequest);
if (meetingMessageType == MeetingMessageType.PrincipalWantsCopy)
{
if (calendarItem.IsNew)
{
meetingMessageType = MeetingMessageType.NewMeetingRequest;
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; Meeting type is PrincipalWantsCopy and calendar item just created.", this.GlobalObjectId);
}
else
{
meetingMessageType = base.GetValueOrDefault <MeetingMessageType>(InternalSchema.OriginalMeetingType, MeetingMessageType.NewMeetingRequest);
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, MeetingMessageType>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; Meeting type is PrincipalWantsCopy. Will use OriginalMeetingType {1}", this.GlobalObjectId, meetingMessageType);
}
}
base.LocationIdentifierHelperInstance.SetLocationIdentifier(60533U, LastChangeAction.CopyMeetingRequestProperties);
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(35957U, LastChangeAction.CopyMeetingRequestProperties);
if (MeetingMessageType.NewMeetingRequest == meetingMessageType || calendarItem.IsNew)
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, string>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; {1}", this.GlobalObjectId, "Copying WriteOnCreate properties onto calendar item.");
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(52341U);
CalendarItemBase.CopyPropertiesTo(this, calendarItem, MeetingMessage.WriteOnCreateProperties);
if (base.IsSeriesMessage)
{
CalendarItemBase.CopyPropertiesTo(this, calendarItem, MeetingMessage.WriteOnCreateSeriesProperties);
}
Reminder.EnsureMinutesBeforeStartIsInRange(calendarItem, this.consumerDefaultMinutesBeforeStart);
if (base.IsRepairUpdateMessage)
{
int?valueAsNullable = base.GetValueAsNullable <int>(CalendarItemBaseSchema.ItemVersion);
if (valueAsNullable != null)
{
calendarItem[CalendarItemBaseSchema.ItemVersion] = valueAsNullable;
}
}
}
if (meetingMessageType == MeetingMessageType.NewMeetingRequest || (!base.IsRepairUpdateMessage && meetingMessageType == MeetingMessageType.FullUpdate))
{
calendarItem.ResponseType = ResponseType.NotResponded;
BusyType valueOrDefault = base.GetValueOrDefault <BusyType>(InternalSchema.IntendedFreeBusyStatus, BusyType.Busy);
BusyType valueOrDefault2 = base.GetValueOrDefault <BusyType>(InternalSchema.FreeBusyStatus, BusyType.Tentative);
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(58485U);
calendarItem[InternalSchema.IntendedFreeBusyStatus] = valueOrDefault;
calendarItem[InternalSchema.FreeBusyStatus] = ((valueOrDefault != BusyType.Free) ? valueOrDefault2 : BusyType.Free);
}
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, string>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; {1}", this.GlobalObjectId, "Copying properties onto calendar item.");
byte[] largeBinaryProperty = base.PropertyBag.GetLargeBinaryProperty(InternalSchema.AppointmentRecurrenceBlob);
CalendarItem calendarItem2 = calendarItem as CalendarItem;
bool flag = false;
if (largeBinaryProperty != null && calendarItem2 != null)
{
calendarItem2.SuppressUpdateRecurrenceTimeOffset = true;
this.CopyRecurrenceBlob(calendarItem2, largeBinaryProperty, preserveLocalExceptions);
flag = true;
}
else if (calendarItem.CalendarItemType == CalendarItemType.RecurringMaster)
{
CalendarItem calendarItem3 = calendarItem as CalendarItem;
if (calendarItem3 != null)
{
calendarItem3.Recurrence = null;
}
}
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(62581U);
if (calendarItem is CalendarItem)
{
PropertyChangeMetadataProcessingFlags propertyChangeMetadataProcessingFlags = calendarItem.GetValueOrDefault <PropertyChangeMetadataProcessingFlags>(CalendarItemSchema.PropertyChangeMetadataProcessingFlags, PropertyChangeMetadataProcessingFlags.None);
propertyChangeMetadataProcessingFlags |= PropertyChangeMetadataProcessingFlags.OverrideMetadata;
calendarItem[CalendarItemSchema.PropertyChangeMetadataProcessingFlags] = propertyChangeMetadataProcessingFlags;
}
if (this.ShouldPreserveAttendeesChanges(calendarItem))
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, string>((long)this.GetHashCode(), "Storage.MeetingRequest.CopyMeetingRequestProperties: GOID={0}; {1}", this.GlobalObjectId, "Will copy properties trying to preserve attendee's changes.");
CalendarItemBase.CopyPropertiesTo(this, calendarItem, CalendarItemProperties.NonPreservableMeetingMessageProperties);
PreservableMeetingMessageProperty.CopyPreserving(new PreservablePropertyContext(this, calendarItem, changeHighlight));
if (calendarItem is CalendarItem)
{
PropertyChangeMetadata valueOrDefault3 = calendarItem.GetValueOrDefault <PropertyChangeMetadata>(InternalSchema.PropertyChangeMetadata);
PropertyChangeMetadata valueOrDefault4 = base.GetValueOrDefault <PropertyChangeMetadata>(InternalSchema.PropertyChangeMetadata);
PropertyChangeMetadata propertyChangeMetadata = PropertyChangeMetadata.Merge(valueOrDefault3, valueOrDefault4);
if (propertyChangeMetadata != null)
{
calendarItem[InternalSchema.PropertyChangeMetadata] = propertyChangeMetadata;
}
}
}
else
{
if (calendarItem.CalendarItemType == CalendarItemType.RecurringMaster || calendarItem.CalendarItemType == CalendarItemType.Single)
{
calendarItem.DeleteProperties(MeetingMessage.DisplayTimeZoneProperties);
}
if (calendarItem is CalendarItem)
{
CalendarItemBase.CopyPropertiesTo(this, calendarItem, new PropertyDefinition[]
{
InternalSchema.PropertyChangeMetadataRaw
});
}
CalendarItemBase.CopyPropertiesTo(this, calendarItem, MeetingMessage.MeetingMessageProperties);
}
string valueOrDefault5 = base.GetValueOrDefault <string>(InternalSchema.AppointmentClass);
if (valueOrDefault5 != null && ObjectClass.IsDerivedClass(valueOrDefault5, "IPM.Appointment"))
{
calendarItem.ClassName = valueOrDefault5;
}
Microsoft.Exchange.Data.Storage.Item.CopyCustomPublicStrings(this, calendarItem);
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(54389U);
CalendarItemBase.CopyPropertiesTo(this, calendarItem, new PropertyDefinition[]
{
InternalSchema.TimeZoneDefinitionRecurring
});
if (meetingMessageType == MeetingMessageType.InformationalUpdate && !calendarItem.IsCalendarItemTypeOccurrenceOrException)
{
Sensitivity?valueAsNullable2 = base.GetValueAsNullable <Sensitivity>(InternalSchema.Sensitivity);
if (valueAsNullable2 != null && calendarItem.Sensitivity != Sensitivity.Private && Enum.IsDefined(typeof(Sensitivity), valueAsNullable2.Value))
{
calendarItem.Sensitivity = valueAsNullable2.Value;
}
}
calendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(50293U);
calendarItem.Reminder.Adjust();
if (flag && calendarItem2 != null)
{
calendarItem2.ReloadRecurrence();
}
}
// Token: 0x060007BD RID: 1981 RVA: 0x00037EC4 File Offset: 0x000360C4
private static List <VersionedId> GetOldMeetingMessages(MailboxSession mailboxSession, MeetingMessage item, byte[] globalObjectId, int rumSequenceNumber, out OldMessageDeletion.LatestItemInfo latestItemInfo)
{
SortBy[] array = new SortBy[2];
latestItemInfo.FullUpdateDeleted = false;
latestItemInfo.RollingHighlight = (int)Utils.SafeGetProperty(item, CalendarItemBaseSchema.ChangeHighlight, 0);
latestItemInfo.LatestOldStartTime = ExDateTime.MinValue;
latestItemInfo.LatestOldEndTime = ExDateTime.MinValue;
latestItemInfo.LatestOldLocationStr = string.Empty;
latestItemInfo.LatestSequenceNumber = -1;
latestItemInfo.LatestItemId = item.Id;
latestItemInfo.LatestClientSubmitTime = (ExDateTime)Utils.SafeGetProperty(item, ItemSchema.SentTime, ExDateTime.MinValue);
ExDateTime valueOrDefault = item.GetValueOrDefault <ExDateTime>(CalendarItemBaseSchema.OwnerCriticalChangeTime, ExDateTime.MinValue);
VersionedId id = item.Id;
array[0] = new SortBy(CalendarItemBaseSchema.GlobalObjectId, SortOrder.Ascending);
array[1] = new SortBy(CalendarItemBaseSchema.AppointmentSequenceNumber, SortOrder.Descending);
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.Equal, CalendarItemBaseSchema.GlobalObjectId, globalObjectId);
List <VersionedId> list = new List <VersionedId>();
using (Folder folder = Folder.Bind(mailboxSession, item.ParentId))
{
using (QueryResult queryResult = folder.ItemQuery(ItemQueryType.None, null, array, OldMessageDeletion.OMDColumnsToQuery))
{
queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter);
bool flag = true;
while (flag)
{
IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(25);
if (propertyBags.Length <= 1)
{
break;
}
foreach (IStorePropertyBag storePropertyBag in propertyBags)
{
string valueOrDefault2 = storePropertyBag.GetValueOrDefault <string>(OldMessageDeletion.OMDColumnsToQuery[0], null);
if (!string.IsNullOrEmpty(valueOrDefault2) && (ObjectClass.IsMeetingRequest(valueOrDefault2) || ObjectClass.IsMeetingCancellation(valueOrDefault2)))
{
byte[] valueOrDefault3 = storePropertyBag.GetValueOrDefault <byte[]>(OldMessageDeletion.OMDColumnsToQuery[2], null);
if (!OldMessageDeletion.GlobalObjectIdMatches(globalObjectId, valueOrDefault3))
{
flag = false;
break;
}
VersionedId valueOrDefault4 = storePropertyBag.GetValueOrDefault <VersionedId>(OldMessageDeletion.OMDColumnsToQuery[1], null);
if (valueOrDefault4 != null && !id.Equals(valueOrDefault4))
{
int valueOrDefault5 = storePropertyBag.GetValueOrDefault <int>(OldMessageDeletion.OMDColumnsToQuery[3], -1);
if (valueOrDefault5 != -1)
{
if (valueOrDefault5 > rumSequenceNumber)
{
latestItemInfo.LatestSequenceNumber = valueOrDefault5;
return(null);
}
if (valueOrDefault5 == rumSequenceNumber)
{
ExDateTime valueOrDefault6 = storePropertyBag.GetValueOrDefault <ExDateTime>(OldMessageDeletion.OMDColumnsToQuery[8], ExDateTime.MinValue);
if (valueOrDefault6 > valueOrDefault)
{
latestItemInfo.LatestSequenceNumber = valueOrDefault5;
return(null);
}
}
if (latestItemInfo.LatestSequenceNumber == -1)
{
ExDateTime valueOrDefault7 = storePropertyBag.GetValueOrDefault <ExDateTime>(OldMessageDeletion.OMDColumnsToQuery[9], ExDateTime.MinValue);
if (valueOrDefault7 != ExDateTime.MinValue)
{
latestItemInfo.LatestOldStartTime = valueOrDefault7;
}
ExDateTime valueOrDefault8 = storePropertyBag.GetValueOrDefault <ExDateTime>(OldMessageDeletion.OMDColumnsToQuery[10], ExDateTime.MinValue);
if (valueOrDefault7 != ExDateTime.MinValue)
{
latestItemInfo.LatestOldEndTime = valueOrDefault8;
}
string valueOrDefault9 = storePropertyBag.GetValueOrDefault <string>(OldMessageDeletion.OMDColumnsToQuery[11], null);
if (!string.IsNullOrEmpty(valueOrDefault9))
{
latestItemInfo.LatestOldLocationStr = valueOrDefault9;
}
}
latestItemInfo.RollingHighlight |= storePropertyBag.GetValueOrDefault <int>(OldMessageDeletion.OMDColumnsToQuery[4], 0);
MeetingMessageType valueOrDefault10 = storePropertyBag.GetValueOrDefault <MeetingMessageType>(OldMessageDeletion.OMDColumnsToQuery[13], MeetingMessageType.None);
latestItemInfo.FullUpdateDeleted |= (valueOrDefault10 == MeetingMessageType.FullUpdate || valueOrDefault10 == MeetingMessageType.NewMeetingRequest);
list.Add(valueOrDefault4);
}
}
}
}
}
}
}
return(list);
}
// Token: 0x060007B6 RID: 1974 RVA: 0x0003766C File Offset: 0x0003586C
internal static void ApplyRollingHighlight(MeetingRequest meetingRequest, string internetMessageId, CalendarItemBase originalCalItem, OldMessageDeletion.LatestItemInfo latestInfo)
{
int i = 3;
MeetingRequest meetingRequest2 = meetingRequest;
CalendarAssistant.TracerPfd.TracePfd <int, object, string>(0L, "PFD IWC {0} {1} Applying the rolling highlight to the item{2}", 18583, TraceContext.Get(), internetMessageId);
if (meetingRequest2 != null)
{
int hashCode = meetingRequest.GetHashCode();
PropertyDefinition changeHighlight = CalendarItemBaseSchema.ChangeHighlight;
while (i > 0)
{
try
{
if (meetingRequest2 == null)
{
meetingRequest2 = MeetingRequest.Bind(meetingRequest.Session, meetingRequest.Id);
meetingRequest2.OpenAsReadWrite();
}
if (latestInfo.RollingHighlight != 0)
{
int num = (int)Utils.SafeGetProperty(meetingRequest2, changeHighlight, 0);
if ((num & 8) == 0 && (latestInfo.RollingHighlight & 8) != 0)
{
if (!string.IsNullOrEmpty(latestInfo.LatestOldLocationStr))
{
meetingRequest2[CalendarItemBaseSchema.OldLocation] = latestInfo.LatestOldLocationStr;
}
else
{
latestInfo.RollingHighlight &= -9;
}
}
if ((num & 3) == 0 && (latestInfo.RollingHighlight & 3) != 0)
{
if (latestInfo.LatestOldStartTime != ExDateTime.MinValue && latestInfo.LatestOldEndTime != ExDateTime.MinValue)
{
meetingRequest2[MeetingRequestSchema.OldStartWhole] = latestInfo.LatestOldStartTime;
meetingRequest2[MeetingRequestSchema.OldEndWhole] = latestInfo.LatestOldEndTime;
}
else
{
latestInfo.RollingHighlight &= -4;
}
}
num |= latestInfo.RollingHighlight;
meetingRequest2[changeHighlight] = num;
if (meetingRequest2.MeetingRequestType != MeetingMessageType.PrincipalWantsCopy)
{
ChangeHighlightHelper changeHighlightHelper = new ChangeHighlightHelper(num);
MeetingMessageType suggestedMeetingType = changeHighlightHelper.SuggestedMeetingType;
meetingRequest2.MeetingRequestType = suggestedMeetingType;
}
}
if (originalCalItem != null && meetingRequest2.MeetingRequestType != MeetingMessageType.NewMeetingRequest && meetingRequest2.MeetingRequestType != MeetingMessageType.PrincipalWantsCopy)
{
ResponseType responseType = originalCalItem.ResponseType;
if (responseType == ResponseType.NotResponded || responseType == ResponseType.None)
{
meetingRequest2.MeetingRequestType = MeetingMessageType.FullUpdate;
meetingRequest2[ItemSchema.IconIndex] = CalendarItemBase.CalculateMeetingRequestIcon(meetingRequest2);
}
}
if (!meetingRequest2.IsDirty)
{
break;
}
ConflictResolutionResult saveResults = meetingRequest2.Save(SaveMode.ResolveConflicts);
meetingRequest2.Load();
if (CalendarProcessing.CheckSaveResults(meetingRequest2, saveResults, internetMessageId))
{
break;
}
i--;
if (meetingRequest2 != meetingRequest && meetingRequest2 != null)
{
meetingRequest2.Dispose();
}
meetingRequest2 = null;
}
catch (ObjectExistedException ex)
{
MailboxSession session = meetingRequest.Session as MailboxSession;
OldMessageDeletion.Tracer.TraceError((long)hashCode, "{0}: Exception thrown when rolling forward the change highlight on item: {1}, attempt: {2}, exception = {3}", new object[]
{
TraceContext.Get(),
internetMessageId,
4 - i,
ex
});
CalendarAssistantLog.LogEntry(session, ex, false, "Exception thrown when rolling forward the change highlight on item: {0}, attempt: {1}", new object[]
{
internetMessageId,
4 - i
});
i--;
if (meetingRequest2 != meetingRequest && meetingRequest2 != null)
{
meetingRequest2.Dispose();
meetingRequest2 = null;
}
}
catch (SaveConflictException ex2)
{
MailboxSession session2 = meetingRequest.Session as MailboxSession;
OldMessageDeletion.Tracer.TraceError((long)hashCode, "{0}: Exception thrown when rolling forward the change highlight on item: {1}, attempt: {2}, exception = {3}", new object[]
{
TraceContext.Get(),
internetMessageId,
4 - i,
ex2
});
CalendarAssistantLog.LogEntry(session2, ex2, false, "Exception thrown when rolling forward the change highlight on item: {0}, attempt: {1}", new object[]
{
internetMessageId,
4 - i
});
i--;
if (meetingRequest2 != meetingRequest && meetingRequest2 != null)
{
meetingRequest2.Dispose();
meetingRequest2 = null;
}
}
catch (ObjectNotFoundException ex3)
{
MailboxSession session3 = meetingRequest.Session as MailboxSession;
OldMessageDeletion.Tracer.TraceError((long)hashCode, "{0}: Exception thrown when rolling forward the change highlight on item: {1}, attempt: {2}, exception = {3}", new object[]
{
TraceContext.Get(),
internetMessageId,
4 - i,
ex3
});
CalendarAssistantLog.LogEntry(session3, ex3, false, "Exception thrown when rolling forward the change highlight on item: {0}, attempt: {1}", new object[]
{
internetMessageId,
4 - i
});
break;
}
finally
{
if (meetingRequest2 != meetingRequest && meetingRequest2 != null)
{
meetingRequest2.Dispose();
}
}
}
}
}
private bool TryUpdateCalendarItemInternal(ref CalendarItemBase originalCalendarItem, bool shouldThrow, bool canUpdatePrincipalCalendar)
{
this.CheckDisposed("MeetingRequest::TryUpdateCalendarItem");
bool flag = originalCalendarItem == null;
CalendarProcessingSteps calendarProcessingSteps = CalendarProcessingSteps.None;
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.TryUpdateCalendarItemInternal: GOID={0}", this.GlobalObjectId);
base.CheckPreConditionForDelegatedMeeting(canUpdatePrincipalCalendar);
if (originalCalendarItem != this.externalCorrelatedCalendarItem)
{
throw new CalendarProcessingException(ServerStrings.ExInvalidCallToTryUpdateCalendarItem);
}
if (!this.CheckPreConditions(originalCalendarItem, shouldThrow, canUpdatePrincipalCalendar))
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.TryUpdateCalendarItemInternal: GOID={0}; failed pre-conditions", this.GlobalObjectId);
return(false);
}
if (originalCalendarItem != null)
{
originalCalendarItem.IsCorrelated = false;
}
calendarProcessingSteps |= CalendarProcessingSteps.PropsCheck;
DelegateRuleType?delegateRuleType;
if (MeetingMessage.TryGetDelegateRuleTypeFromSession(base.Session as MailboxSession, out delegateRuleType))
{
if (delegateRuleType == DelegateRuleType.ForwardAndSetAsInformationalUpdate)
{
ExTraceGlobals.MeetingMessageTracer.Information((long)this.GetHashCode(), "Storage.MeetingMessage.TryUpdateCalendarItemInternal: Setting PrincipalWantsCopy on meetingmessage.");
MeetingMessageType valueOrDefault = base.GetValueOrDefault <MeetingMessageType>(InternalSchema.MeetingRequestType, MeetingMessageType.NewMeetingRequest);
base.LocationIdentifierHelperInstance.SetLocationIdentifier(53365U);
this[InternalSchema.OriginalMeetingType] = valueOrDefault;
this[InternalSchema.MeetingRequestType] = MeetingMessageType.PrincipalWantsCopy;
}
calendarProcessingSteps |= CalendarProcessingSteps.PrincipalWantsCopyChecked;
}
int num = flag ? 1 : this.CompareToCalendarItem(originalCalendarItem);
calendarProcessingSteps |= CalendarProcessingSteps.LookedForOutOfDate;
if ((!base.CalendarProcessed && num == 0) || num > 0)
{
base.LocationIdentifierHelperInstance.SetLocationIdentifier(57461U, LastChangeAction.UpdateCalendarItem);
this.UpdateCalendarItemInternal(ref originalCalendarItem);
base.CalendarProcessed = true;
if (originalCalendarItem != null)
{
originalCalendarItem.LocationIdentifierHelperInstance.SetLocationIdentifier(32885U, LastChangeAction.UpdateCalendarItem);
}
MeetingMessageInstance.SetVersionInfo(originalCalendarItem);
calendarProcessingSteps |= CalendarProcessingSteps.UpdatedCalItem;
}
else
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, bool, int>((long)this.GetHashCode(), "Storage.MeetingMessage.TryUpdateCalendarItemInternal: GOID={0}; NOOP: calendarprocessed = {1}, originalCalendarItem={2}", this.GlobalObjectId, base.CalendarProcessed, (originalCalendarItem == null) ? -1 : originalCalendarItem.GetHashCode());
}
if (flag && originalCalendarItem != null)
{
this.externalCorrelatedCalendarItem = originalCalendarItem;
calendarProcessingSteps |= CalendarProcessingSteps.CreatedOnPrincipal;
}
if (originalCalendarItem != null)
{
originalCalendarItem.CharsetDetector.DetectionOptions = base.CharsetDetector.DetectionOptions;
}
this.SetCalendarProcessingSteps(calendarProcessingSteps);
return(true);
}
private bool ShouldPreserveAttendeesChanges(CalendarItemBase calItem)
{
MeetingMessageType valueOrDefault = base.GetValueOrDefault <MeetingMessageType>(InternalSchema.MeetingRequestType, MeetingMessageType.NewMeetingRequest);
return(valueOrDefault == MeetingMessageType.InformationalUpdate || valueOrDefault == MeetingMessageType.FullUpdate);
}
