// Token: 0x0600079C RID: 1948 RVA: 0x000364A4 File Offset: 0x000346A4
private static void AutoAcceptEvents(MailboxSession session, CalendarItemBase originalCalItem)
{
if (originalCalItem != null && !originalCalItem.IsCancelled)
{
bool flag;
if (session.IsGroupMailbox())
{
CalendarProcessing.ProcessingRequestTracer.TraceDebug <IExchangePrincipal>(0L, "Processing meeting request for group mailbox {0}", session.MailboxOwner);
originalCalItem.Reminder.IsSet = false;
flag = false;
}
else
{
CalendarProcessing.ProcessingRequestTracer.TraceDebug <IExchangePrincipal>(0L, "Processing sent to self meeting request. Mailbox owner: {0}", session.MailboxOwner);
flag = originalCalItem.ResponseRequested;
}
using (MeetingResponse meetingResponse = originalCalItem.RespondToMeetingRequest(ResponseType.Accept, true, flag, null, null))
{
if (flag)
{
meetingResponse.Send();
}
}
originalCalItem.Load();
}
}
private bool ShouldProcessMessage(MailboxSession session, StoreDriverDeliveryEventArgsImpl argsImpl)
{
MessageItem messageItem = argsImpl.MessageItem;
if (!StoreDriverConfig.Instance.IsGroupEscalationAgentEnabled)
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: skipping group message escalation as the feature is disabled via app config.");
return(false);
}
if (!GroupEscalation.IsEscalationEnabled())
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: skipping group message escalation as the feature is disabled.");
return(false);
}
if (session == null || !session.IsGroupMailbox())
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: skipping group message escalation as the session is not for a group mailbox.");
return(false);
}
if (this.processedMessages.IsAlreadyProcessedForStage(messageItem.InternetMessageId, messageItem.SentTime, session.MailboxGuid, DeliveryStage.CreatedMessageEventHandled))
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: skipping group message escalation as it was already processed earlier.");
return(false);
}
if (!ObjectClass.IsMessage(argsImpl.MessageClass, false) && !ObjectClass.IsMeetingMessage(argsImpl.MessageClass) && !ObjectClass.IsMeetingMessageSeries(argsImpl.MessageClass))
{
GroupEscalationAgent.Tracer.TraceDebug <string>((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: ignoring messages that are not messages nor meeting messages. Message class {0}", argsImpl.MessageClass);
return(false);
}
if (ObjectClass.IsMeetingForwardNotification(argsImpl.MessageClass) || ObjectClass.IsMeetingForwardNotificationSeries(argsImpl.MessageClass))
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: item class is meeting forward notification. Do not process.");
return(false);
}
if (ObjectClass.IsMeetingResponse(argsImpl.MessageClass) || ObjectClass.IsMeetingResponseSeries(argsImpl.MessageClass))
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: item class is meeting response. Do not process.");
return(false);
}
if (GroupEscalationAgent.IsEHAMigrationMeetingMessage(argsImpl.MailItem))
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: ignoring EHA migration messages.");
return(false);
}
if (GroupEscalationAgent.IsRepairUpdateMessage(argsImpl.MessageItem))
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: ignoring RUM messages.");
return(false);
}
if (GroupEscalationAgent.IsOofOrDsnMessage(argsImpl.MessageClass))
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.ShouldProcessMessage: ignoring OOF or DSN messages.");
return(false);
}
return(true);
}
internal void Enforce(Func <ICollection <MapiAclTableRestriction.ExternalUserPermission> > getExternalUserPermissions)
{
if ((this.session == null || !this.session.IsMoveUser) && this.coreFolder.IsPermissionChangeBlocked())
{
ExTraceGlobals.StorageTracer.TraceDebug <string>((long)this.GetHashCode(), "{0}: Cannot change permissions on permission-change-blocked folder.", this.session.DisplayAddress);
throw new CannotChangePermissionsOnFolderException();
}
MailboxSession mailboxSession = this.session as MailboxSession;
if (mailboxSession == null || mailboxSession.IsGroupMailbox())
{
return;
}
this.EnforceSharingPolicy(mailboxSession, getExternalUserPermissions());
}
public void OnDeliveredMessageHandler(StoreDriverEventSource source, StoreDriverDeliveryEventArgs args)
{
StoreDriverDeliveryEventArgsImpl storeDriverDeliveryEventArgsImpl = (StoreDriverDeliveryEventArgsImpl)args;
MailboxSession mailboxSession = storeDriverDeliveryEventArgsImpl.MailboxSession;
if (mailboxSession == null || !mailboxSession.IsGroupMailbox())
{
GroupEscalationAgent.Tracer.TraceDebug((long)this.GetHashCode(), "GroupEscalationAgent.OnDeliveredMessageHandler: Session null or not a group mailbox.");
return;
}
MessageItem messageItem = storeDriverDeliveryEventArgsImpl.MessageItem;
messageItem.Load(new PropertyDefinition[]
{
ItemSchema.InternetMessageId,
ItemSchema.SentTime
});
this.processedMessages.ClearMessageFromProcessedList(messageItem.InternetMessageId, messageItem.SentTime, mailboxSession.MailboxGuid);
}
// Token: 0x0600077A RID: 1914 RVA: 0x00034F74 File Offset: 0x00033174
private void HandlePermissionChange(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item, List <KeyValuePair <string, object> > customDataToLog)
{
if (mapiEvent.ItemEntryId == null || itemStore.IsGroupMailbox())
{
return;
}
StoreObjectId storeObjectId = StoreObjectId.FromProviderSpecificId(mapiEvent.ItemEntryId, StoreObjectType.Folder);
StoreObjectId defaultFolderId = itemStore.GetDefaultFolderId(DefaultFolderType.Root);
if (storeObjectId != null && defaultFolderId != null)
{
if (!storeObjectId.Equals(defaultFolderId) && !ObjectClass.IsCalendarFolder(mapiEvent.ObjectClass))
{
return;
}
using (Folder folder = Folder.Bind(itemStore, storeObjectId))
{
string text = CalendarLoggingHelper.GetCalendarPermissionsLog(itemStore, folder);
if (!string.IsNullOrEmpty(text))
{
text = string.Format("Client Type: {0} New Permission Table:\n{1}", mapiEvent.ClientType, text);
}
else
{
text = string.Format("Client Type: {0} Mailbox session or folder was null", mapiEvent.ClientType);
}
CalendarPermissionsLog.LogEntry(itemStore, text, new object[0]);
return;
}
}
if (storeObjectId == null)
{
CalendarAssistant.GeneralTracer.TraceError <object, byte[]>((long)this.GetHashCode(), "{0}: Unable to bind to a calendar folder with FolderId {1}", TraceContext.Get(), mapiEvent.ItemEntryId);
return;
}
CalendarAssistant.GeneralTracer.TraceError <object, Guid>((long)this.GetHashCode(), "{0}: Unable to bind to the root folder for Mailbox {1}", TraceContext.Get(), mapiEvent.MailboxGuid);
}
private bool ShouldGenerateMfn()
{
MessageItem messageItem = this.item.Item;
MailboxSession mailboxSession = messageItem.Session as MailboxSession;
if (mailboxSession == null)
{
TraceHelper.MeetingForwardNotificationTracer.TracePass(TraceHelper.MessageProbeActivityId, 0L, "Skipping MFN generation as the session is not a mailboxsession.");
return(false);
}
if (!ObjectClass.IsMeetingRequest(messageItem.ClassName) && !ObjectClass.IsMeetingRequestSeries(messageItem.ClassName))
{
TraceHelper.MeetingForwardNotificationTracer.TracePass <string>(TraceHelper.MessageProbeActivityId, 0L, "Not a meeting request {0} - skipping MFN generation.", messageItem.ClassName);
return(false);
}
string text = null;
bool result;
try
{
string text2 = MfnSubmitter.SafeGetProperty <string>(messageItem, MessageItemSchema.ReceivedRepresentingEmailAddress, string.Empty);
if (!string.IsNullOrEmpty(text2))
{
text = string.Format("Skipping MFN generation as the update/forward was made by a delegate {0}. From: {1}, Sender {2}, Subject: {3}", new object[]
{
text2,
messageItem.From,
messageItem.Sender,
messageItem.Subject ?? "<No subject found>"
});
result = false;
}
else
{
int num = MfnSubmitter.SafeGetProperty <int>(messageItem, MeetingMessageSchema.AppointmentAuxiliaryFlags, 0);
if ((num & 32) != 0)
{
text = string.Format("Skipping MFN generation for RUMs. From: {0}, Sender {1} , Subject: {2}", messageItem.From, messageItem.Sender, messageItem.Subject ?? "<No subject found>");
result = false;
}
else if (messageItem.IsResponseRequested && (num & 256) != 0)
{
text = string.Format("Skipping MFN generation for events added from group calendar. From: {0}, Sender {1} , Subject: {2}", messageItem.From, messageItem.Sender, messageItem.Subject ?? "<No subject found>");
result = false;
}
else
{
if ((num & 4) == 0)
{
if (mailboxSession.IsGroupMailbox())
{
TraceHelper.MeetingForwardNotificationTracer.TracePass(TraceHelper.MessageProbeActivityId, 0L, "Skipping MFN generation as the meeting was created/updated on the group calendar. From: {0}, Sender {1}, Auxilliary Flags {2}, Subject {3}", new object[]
{
messageItem.From,
messageItem.Sender,
num,
messageItem.Subject ?? "<No subject found>"
});
return(false);
}
if (Participant.HasSameEmail(messageItem.From, messageItem.Sender, mailboxSession, true))
{
TraceHelper.MeetingForwardNotificationTracer.TracePass(TraceHelper.MessageProbeActivityId, 0L, "Skipping MFN generation as the update was made by the organizer. From: {0}, Sender {1}, Auxilliary Flags {2}, Subject {3}", new object[]
{
messageItem.From,
messageItem.Sender,
num,
messageItem.Subject ?? "<No subject found>"
});
return(false);
}
bool?flag = this.IsDelegateOfOrganizer();
if (flag != null && flag.Value)
{
text = string.Format("Skipping MFN generation as the update was made by a delegate. From: {0}, Sender {1}. Auxilliary Flags {2}, Subject {3}", new object[]
{
messageItem.From,
messageItem.Sender,
num,
messageItem.Subject ?? "<No subject found>"
});
return(false);
}
}
if (MeetingMessage.IsFromExternalParticipant(messageItem.From.RoutingType))
{
text = string.Format("Skipping MFN generation as the organizer is external. From: {0}, RoutingType {1}, Sender {2}, Auxilliary Flags {3} Subject : {4}", new object[]
{
messageItem.From,
messageItem.From.RoutingType,
messageItem.Sender,
num,
messageItem.Subject ?? "<No subject found>"
});
result = false;
}
else
{
text = string.Format("Generating MFN as the meeting was forwarded. From: {0}, RoutingType {1}, Sender {2}, Auxilliary Flags {3}, Subject {4}", new object[]
{
messageItem.From,
messageItem.From.RoutingType,
messageItem.Sender,
num,
messageItem.Subject ?? "<No subject found>"
});
result = true;
}
}
}
}
finally
{
if (text != null)
{
TraceHelper.MeetingForwardNotificationTracer.TracePass(TraceHelper.MessageProbeActivityId, 0L, text);
MfnLog.LogEntry(mailboxSession, text);
}
}
return(result);
}
// Token: 0x06000793 RID: 1939 RVA: 0x00035B83 File Offset: 0x00033D83
private static bool IsAutoAcceptanceProcessingRequired(MailboxSession session, MeetingMessage mtgMessage, CalendarItemBase calendarItem)
{
return(calendarItem != null && mtgMessage is MeetingRequest && !calendarItem.IsOrganizer() && calendarItem.ResponseType != ResponseType.Accept && (session.IsGroupMailbox() || OldMessageDeletion.IsSelfForwardedEvent(mtgMessage, session)));
}
// Token: 0x0600077C RID: 1916 RVA: 0x00035104 File Offset: 0x00033304
private bool GetDelegatesRuleLoggerStatus(MailboxSession session)
{
return(session != null && session.MailboxOwner != null && !session.IsGroupMailbox() && this.IsDelegateRulesLoggerEnabled(session.MailboxOwner));
}
// Token: 0x060007B4 RID: 1972 RVA: 0x000371A0 File Offset: 0x000353A0
private List <VersionedId> QueryMatchingItems(MailboxSession itemStore, MeetingMessage item, byte[] itemGlobalObjId, string sentRepresenting, int itemSequenceNumber, ref OldMessageDeletion.LatestItemInfo latestInfo)
{
ExDateTime utcNow = ExDateTime.UtcNow;
List <VersionedId> list = new List <VersionedId>();
bool flag = true;
bool flag2 = (bool)Utils.SafeGetProperty(item, MessageItemSchema.MapiHasAttachment, false);
bool flag3 = item.Body != null && item.Body.Size > 0L;
bool flag4 = item is MeetingRequest;
bool flag5 = item is MeetingResponse;
bool flag6 = item is MeetingCancellation;
SortBy[] sortColumns = new SortBy[]
{
new SortBy(CalendarItemBaseSchema.GlobalObjectId, SortOrder.Ascending),
new SortBy(StoreObjectSchema.ItemClass, SortOrder.Descending)
};
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.Equal, CalendarItemBaseSchema.GlobalObjectId, itemGlobalObjId);
using (Folder folder = Folder.Bind(itemStore, item.ParentId))
{
using (QueryResult queryResult = folder.ItemQuery(ItemQueryType.None, null, sortColumns, OldMessageDeletion.OMDColumnsToQuery))
{
queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter);
while (flag)
{
object[][] rows = queryResult.GetRows(25);
if (rows.Length < 1)
{
break;
}
ExDateTime itemOwnerChangeTime = (ExDateTime)Utils.SafeGetProperty(item, CalendarItemBaseSchema.OwnerCriticalChangeTime, utcNow);
foreach (object[] array in rows)
{
string text = array[0] as string;
if (!string.IsNullOrEmpty(text))
{
if (!itemStore.IsGroupMailbox())
{
if ((flag4 || flag6) && !ObjectClass.IsMeetingRequest(text) && !ObjectClass.IsMeetingCancellation(text))
{
flag = false;
break;
}
if (flag5 && !ObjectClass.IsMeetingResponse(text))
{
goto IL_186;
}
}
byte[] rowGlobalObjectId = (array[2] is byte[]) ? (array[2] as byte[]) : null;
if (!OldMessageDeletion.GlobalObjectIdMatches(itemGlobalObjId, rowGlobalObjectId))
{
flag = false;
break;
}
this.DetermineIfWeDelete(list, item, array, itemOwnerChangeTime, sentRepresenting, itemSequenceNumber, ref latestInfo, ref flag2, ref flag3);
}
IL_186 :;
}
}
}
}
return(list);
}
// Token: 0x060007AC RID: 1964 RVA: 0x00036880 File Offset: 0x00034A80
public void PerformCleanUp(MailboxSession itemStore, StoreObject item, CalendarConfiguration mailboxConfig, CalendarItemBase originalCalItem, IEnumerable <VersionedId> duplicates)
{
bool flag = false;
if (mailboxConfig.RemoveOldMeetingMessages && !(item is MeetingForwardNotification))
{
this.DeleteOldMessages(itemStore, (MeetingMessage)item, originalCalItem, out flag);
}
if (item is MeetingMessage)
{
bool flag2 = false;
MeetingMessage meetingMessage = (MeetingMessage)item;
if (meetingMessage.IsRepairUpdateMessage)
{
flag2 = (!flag || (!(meetingMessage is MeetingRequest) && !(meetingMessage is MeetingCancellation)));
if (flag2)
{
meetingMessage.MarkAsOutOfDate();
meetingMessage.IsRead = true;
try
{
int num = 3;
ConflictResolutionResult saveResults;
do
{
saveResults = meetingMessage.Save(SaveMode.ResolveConflicts);
meetingMessage.Load();
num--;
}while (num > 0 && !CalendarProcessing.CheckSaveResults(meetingMessage, saveResults, meetingMessage.InternetMessageId));
}
catch (ObjectNotFoundException arg)
{
flag2 = false;
OldMessageDeletion.Tracer.TraceWarning <object, ObjectNotFoundException>((long)this.GetHashCode(), "{0}: Tried to mark a RUM as Outdated, which does not exist anymore. Exception: {1}", TraceContext.Get(), arg);
}
}
}
if (!flag2 && item is MeetingForwardNotification)
{
bool flag3 = itemStore.IsGroupMailbox();
string text = null;
flag2 = (mailboxConfig.RemoveForwardedMeetingNotifications || !meetingMessage.IsResponseRequested || flag3);
if (!flag2)
{
Participant participant = null;
flag2 = OldMessageDeletion.IsSenderSame(meetingMessage.From, itemStore, out participant);
if (participant != null)
{
text = participant.EmailAddress;
}
}
string text2;
if (flag2)
{
text2 = string.Format("Deleting MFN message as it was forwarded by the organizer. ParticipantFromEmail: {0}, Message From: {1}, From RoutingType: {2}, Mailbox owner : {3}, Mailboxconfig.RemoveMFN setting {4}, IsResponseRequested {5}, Subject: {6}, IsGroupMailbox: {7} ", new object[]
{
text ?? "unspecified",
meetingMessage.From,
(meetingMessage.From != null) ? meetingMessage.From.RoutingType : "unspecified",
itemStore.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(),
mailboxConfig.RemoveForwardedMeetingNotifications,
meetingMessage.IsResponseRequested,
meetingMessage.Subject,
flag3
});
}
else
{
text2 = string.Format("Not deleting MFN message as it was forwarded by someone other than the organizer. ParticipantFromEmail {0}, Message From: {1}, From RoutingType: {2}, Mailbox owner : {3}, Mailboxconfig.RemoveMFN setting {4}, IsResponseRequested {5}, Subject: {6} ", new object[]
{
text ?? "unspecified",
meetingMessage.From,
(meetingMessage.From != null) ? meetingMessage.From.RoutingType : "unspecified",
itemStore.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(),
mailboxConfig.RemoveForwardedMeetingNotifications,
meetingMessage.IsResponseRequested,
meetingMessage.Subject
});
}
OldMessageDeletion.Tracer.TraceDebug((long)this.GetHashCode(), text2);
MfnLog.LogEntry(itemStore, text2);
}
if (!flag2 && OldMessageDeletion.IsSelfForwardedEventAndAccepted(meetingMessage, itemStore, originalCalItem))
{
flag2 = true;
OldMessageDeletion.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Marked the meeting request for deletion as sent to self", new object[]
{
TraceContext.Get()
});
}
if (flag2)
{
this.DeleteMessage(itemStore, item);
}
}
if (duplicates != null)
{
foreach (VersionedId versionedId in duplicates)
{
itemStore.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
versionedId
});
OldMessageDeletion.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: Deleted a duplicate item ID: {1}.", TraceContext.Get(), versionedId);
}
}
}
// Token: 0x060007AE RID: 1966 RVA: 0x00036C68 File Offset: 0x00034E68
private void DeleteOldMessages(MailboxSession itemStore, MeetingMessage item, CalendarItemBase originalCalItem, out bool fullUpdateDeleted)
{
fullUpdateDeleted = false;
string text = (string)Utils.SafeGetProperty(item, ItemSchema.InternetMessageId, "<null>");
if (item is MeetingRequest || item is MeetingCancellation)
{
bool flag = (bool)Utils.SafeGetProperty(item, MeetingMessageSchema.HijackedMeeting, false);
if (flag)
{
CalendarAssistantLog.LogEntry(itemStore, "Message {0} has been hijacked, skipping deletion of old messages.", new object[]
{
text
});
return;
}
}
int num = (int)Utils.SafeGetProperty(item, CalendarItemBaseSchema.AppointmentSequenceNumber, -1);
if (num < 0)
{
OldMessageDeletion.Tracer.TraceError <object, string>((long)this.GetHashCode(), "{0}: Message does not have a sequence number, skipping {1}", TraceContext.Get(), text);
CalendarAssistantLog.LogEntry(itemStore, "Message does not have a sequence number, skipping {0}", new object[]
{
text
});
return;
}
if (OldMessageDeletion.ShouldIgnoreFolder(itemStore, item.ParentId))
{
return;
}
string text2 = (string)Utils.SafeGetProperty(item, MessageItemSchema.ReceivedRepresentingEmailAddress, string.Empty);
string text3 = (string)Utils.SafeGetProperty(item, CalendarItemBaseSchema.OrganizerEmailAddress, string.Empty);
byte[] array = (byte[])Utils.SafeGetProperty(item, CalendarItemBaseSchema.GlobalObjectId, null);
if (array == null)
{
OldMessageDeletion.Tracer.TraceError <object, string>((long)this.GetHashCode(), "{0}: Message {1} does not have a globalObjectId, skipping the message.", TraceContext.Get(), text);
CalendarAssistantLog.LogEntry(itemStore, "Message {0} does not have a globalObjectId, skipping the message.", new object[]
{
text
});
return;
}
OldMessageDeletion.Tracer.TraceDebug <object, string, string>((long)item.GetHashCode(), "{0}: Received representing={1} sent representing={2}", TraceContext.Get(), text2, text3);
CalendarAssistant.TracerPfd.TracePfd((long)item.GetHashCode(), "PFD IWC {0} {1}: Received representing={2} sent representing={3}", new object[]
{
22679,
TraceContext.Get(),
text2,
text3
});
if (!itemStore.IsGroupMailbox() && string.Compare(text2, text3, true) == 0)
{
Participant participant = null;
if (!OldMessageDeletion.IsSenderSame(item.Sender, itemStore, out participant))
{
return;
}
AggregateOperationResult aggregateOperationResult = itemStore.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
item.Id
});
OldMessageDeletion.Tracer.TraceDebug <object, string, OperationResult>((long)this.GetHashCode(), "{0}: Moving the item {1} to the Deleted Items folder returned:{2}", TraceContext.Get(), text, aggregateOperationResult.OperationResult);
return;
}
else
{
if (item.IsRepairUpdateMessage)
{
RUMOldMessageDeletion.CleanUp(itemStore, item, originalCalItem, OldMessageDeletion.Tracer, out fullUpdateDeleted);
return;
}
OldMessageDeletion.LatestItemInfo latestItemInfo;
latestItemInfo.FullUpdateDeleted = fullUpdateDeleted;
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);
this.QueryAndDeleteMatchingItems(itemStore, item, originalCalItem, array, text, text3, num, ref latestItemInfo);
fullUpdateDeleted = latestItemInfo.FullUpdateDeleted;
return;
}
}
private void OnPromotedMessageHandler(StoreDriverEventSource source, StoreDriverDeliveryEventArgs args)
{
if (StoreDriverConfig.Instance.IsAutoAcceptForGroupAndSelfForwardedEventEnabled)
{
StoreDriverDeliveryEventArgsImpl storeDriverDeliveryEventArgsImpl = (StoreDriverDeliveryEventArgsImpl)args;
if ((ObjectClass.IsMeetingRequest(storeDriverDeliveryEventArgsImpl.MessageClass) || ObjectClass.IsMeetingResponse(storeDriverDeliveryEventArgsImpl.MessageClass)) && !this.IsEHAMigrationMeetingMessage(storeDriverDeliveryEventArgsImpl.MailItem))
{
MailboxSession mailboxSession = storeDriverDeliveryEventArgsImpl.MailboxSession;
if (mailboxSession == null || storeDriverDeliveryEventArgsImpl.ReplayItem == null)
{
MeetingMessageProcessingAgent.tracer.TraceError((long)this.GetHashCode(), "MeetingMessageProcessingAgent::OnPromotedMessageHandler() MailboxSession or StoreDriverDeliveryEventArgsImpl.ReplayItem is null");
return;
}
if (ObjectClass.IsMeetingRequest(storeDriverDeliveryEventArgsImpl.MessageClass) && !mailboxSession.IsGroupMailbox())
{
MeetingRequest meetingRequest = null;
try
{
meetingRequest = (Item.ConvertFrom(storeDriverDeliveryEventArgsImpl.ReplayItem, mailboxSession) as MeetingRequest);
if (meetingRequest != null && MeetingMessageProcessing.IsSentToSelf(meetingRequest, mailboxSession))
{
MeetingMessageProcessingAgent.tracer.TraceDebug <string, IExchangePrincipal>((long)this.GetHashCode(), "Attempting to deliver self forwarded message {0} to mailbox {1} to Deleted Items", meetingRequest.InternetMessageId, mailboxSession.MailboxOwner);
this.DeliverToDeletedItems(mailboxSession, meetingRequest, storeDriverDeliveryEventArgsImpl);
}
}
finally
{
if (meetingRequest != null)
{
Item.SafeDisposeConvertedItem(storeDriverDeliveryEventArgsImpl.ReplayItem, meetingRequest);
}
}
}
if (ObjectClass.IsMeetingResponse(storeDriverDeliveryEventArgsImpl.MessageClass) && mailboxSession.IsGroupMailbox())
{
MeetingResponse meetingResponse = Item.ConvertFrom(storeDriverDeliveryEventArgsImpl.ReplayItem, mailboxSession) as MeetingResponse;
if (meetingResponse != null && meetingResponse.IsSilent)
{
ADRecipient adrecipient = null;
if (meetingResponse.From.TryGetADRecipient(mailboxSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), out adrecipient) && adrecipient != null && adrecipient.RecipientDisplayType != RecipientDisplayType.ConferenceRoomMailbox && adrecipient.RecipientDisplayType != RecipientDisplayType.SyncedConferenceRoomMailbox && adrecipient.RecipientDisplayType != RecipientDisplayType.EquipmentMailbox && adrecipient.RecipientDisplayType != RecipientDisplayType.SyncedEquipmentMailbox && !meetingResponse.IsCounterProposal)
{
MeetingMessageProcessingAgent.tracer.TraceDebug <string, IExchangePrincipal>((long)this.GetHashCode(), "Attempting to deliver empty response {0} to mailbox {1} to Deleted Items", meetingResponse.InternetMessageId, mailboxSession.MailboxOwner);
this.DeliverToDeletedItems(mailboxSession, meetingResponse, storeDriverDeliveryEventArgsImpl);
}
}
}
}
}
}
private static bool ShouldBlockMessageForGroup(MailboxSession session, string messageClass)
{
return(session != null && session.IsGroupMailbox() && GroupEscalationAgent.IsOofOrDsnMessage(messageClass));
}
private static bool ShouldGenerateIrmNdr(MailboxSession session, MessageItem messageItem, MiniRecipient mailboxOwner)
{
return(session != null && session.IsGroupMailbox() && messageItem.IsRestricted && !GroupEscalationAgent.IsIrmEnabledGroup(mailboxOwner));
}
