public override CalendarItemBase TryGetCorrelatedItemFromHintId(MailboxSession session, StoreObjectId hintId)
{
if (hintId != null)
{
try
{
CalendarItemBase calendarItemBase = CalendarItemBase.Bind(session, hintId);
if (!this.ValidateCorrelatedItem(calendarItemBase))
{
calendarItemBase.Dispose();
throw new CorrelationFailedException(ServerStrings.ExCorrelationFailedForOccurrence(this.Subject));
}
calendarItemBase.OpenAsReadWrite();
calendarItemBase.IsCorrelated = true;
this.correlatedItemId = calendarItemBase.Id;
calendarItemBase.AssociatedItemId = base.Id;
this.externalCorrelatedCalendarItem = calendarItemBase;
this.getCorrelatedItemCalled = true;
return(calendarItemBase);
}
catch (Exception arg)
{
ExTraceGlobals.MeetingMessageTracer.TraceError <string, Exception>((long)this.GetHashCode(), "Exception thrown when trying to bind to calendar item id hint passed from meeting series message ordering agent. Mailbox = {0}, exception = {1}.", session.MailboxOwnerLegacyDN, arg);
}
}
return(null);
}
public override CalendarItemBase UpdateCalendarItem(bool canUpdatePrincipalCalendar)
{
this.CheckDisposed("UpdateCalendarItem");
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.UpdateCalendarItem: GOID={0}", this.GlobalObjectId);
object obj = base.TryGetProperty(InternalSchema.OriginalMeetingType);
if (obj is int)
{
base.LocationIdentifierHelperInstance.SetLocationIdentifier(36981U);
this[InternalSchema.MeetingRequestType] = (MeetingMessageType)obj;
}
base.CheckPreConditionForDelegatedMeeting(canUpdatePrincipalCalendar);
CalendarItemBase calendarItemBase = this.GetCorrelatedItem();
bool flag = calendarItemBase == null;
bool flag2 = false;
try
{
this.TryUpdateCalendarItemInternal(ref calendarItemBase, true, canUpdatePrincipalCalendar);
flag2 = true;
}
finally
{
if (!flag2 && calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
if (flag && calendarItemBase != null)
{
calendarItemBase.AssociatedItemId = base.Id;
}
return(calendarItemBase);
}
protected override void UpdateCalendarItemInternal(ref CalendarItemBase correlatedCalendarItem)
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingRequest.UpdateCalendarItemInternal: GOID={0}", this.GlobalObjectId);
CalendarItemBase calendarItemBase = null;
try
{
calendarItemBase = base.GetCalendarItemToUpdate(correlatedCalendarItem);
this.UpdateMeetingRequest(calendarItemBase);
this.UpdateCalendarItemProperties(calendarItemBase);
this.UpdateAttachmentsOnCalendarItem(calendarItemBase);
this.UpdateParticipantsOnCalendarItem(calendarItemBase, false);
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Leaving Storage.MeetingRequest.UpdateCalendarItemInternal: GOID={0}", this.GlobalObjectId);
if (correlatedCalendarItem == null)
{
correlatedCalendarItem = calendarItemBase;
}
}
finally
{
if (calendarItemBase != null && calendarItemBase != correlatedCalendarItem)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
public void EditResponseCalendarItem()
{
ExTraceGlobals.CalendarCallTracer.TraceDebug((long)this.GetHashCode(), "EditMeetingInviteEventHandler.EditResponseCalendarItem");
ResponseType responseType = (ResponseType)base.GetParameter("Rsp");
CalendarItemBase calendarItemBase = null;
try
{
calendarItemBase = base.GetRequestItem <CalendarItemBase>(new PropertyDefinition[0]);
if (calendarItemBase != null)
{
this.EditResponseInternal(responseType, calendarItemBase);
calendarItemBase.Load();
this.Writer.Write("<div id=nid>");
if (calendarItemBase.Id != null && calendarItemBase.Id.ObjectId != null)
{
this.Writer.Write(OwaStoreObjectId.CreateFromStoreObject(calendarItemBase).ToBase64String());
}
this.Writer.Write("</div>");
}
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
public override CalendarItemBase GetEmbeddedItem()
{
this.CheckDisposed("GetEmbeddedItem");
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.GetEmbeddedItem: GOID={0}", this.GlobalObjectId);
CalendarItemBase calendarItemBase = null;
bool flag = false;
CalendarItemBase result;
try
{
ItemCreateInfo calendarItemInfo = ItemCreateInfo.CalendarItemInfo;
calendarItemBase = ItemBuilder.ConstructItem <CalendarItem>(base.Session, base.StoreObjectId, (base.StoreObjectId != null) ? base.Id.ChangeKeyAsByteArray() : null, calendarItemInfo.Schema.AutoloadProperties, delegate
{
AcrPropertyBag acrPropertyBag = null;
PersistablePropertyBag persistablePropertyBag = null;
bool flag2 = false;
StoreObjectId storeObjectId = base.StoreObjectId;
PersistablePropertyBag result2;
try
{
if (storeObjectId != null && !storeObjectId.IsFakeId)
{
persistablePropertyBag = StoreObjectPropertyBag.CreatePropertyBag(base.Session, storeObjectId, InternalSchema.ContentConversionProperties);
acrPropertyBag = new AcrPropertyBag(persistablePropertyBag, AcrProfile.AppointmentProfile, storeObjectId, new ItemBagFactory(base.Session, base.StoreObjectId), null);
flag2 = true;
result2 = acrPropertyBag;
}
else
{
persistablePropertyBag = new StoreObjectPropertyBag(base.Session, base.MapiProp, InternalSchema.ContentConversionProperties, false);
flag2 = true;
result2 = persistablePropertyBag;
}
}
finally
{
if (!flag2)
{
Util.DisposeIfPresent(persistablePropertyBag);
Util.DisposeIfPresent(acrPropertyBag);
}
}
return(result2);
}, calendarItemInfo.Creator, base.CoreObject.Origin, base.CoreObject.ItemLevel);
flag = true;
result = calendarItemBase;
}
finally
{
if (!flag && calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
return(result);
}
public void EditResponseInvite()
{
ExTraceGlobals.CalendarCallTracer.TraceDebug((long)this.GetHashCode(), "EditMeetingInviteEventHandler.EditResponseInvite");
ResponseType responseType = (ResponseType)base.GetParameter("Rsp");
this.properties = new PropertyDefinition[]
{
MeetingMessageSchema.CalendarProcessed,
StoreObjectSchema.ParentItemId
};
CalendarItemBase calendarItemBase = null;
MeetingRequest meetingRequest = null;
try
{
meetingRequest = this.GetMeetingRequest(this.properties);
calendarItemBase = MeetingUtilities.UpdateCalendarItem(meetingRequest);
if (calendarItemBase == null)
{
throw new OwaInvalidRequestException(string.Format("calendarItemBase associated with meeting request with Id {0} is null.", base.GetParameter("Id")));
}
this.EditResponseInternal(responseType, calendarItemBase);
this.UpdateItem(meetingRequest);
Utilities.SaveItem(meetingRequest);
meetingRequest.Load();
this.Writer.Write("<div id=ck>");
this.Writer.Write(meetingRequest.Id.ChangeKeyAsBase64String());
this.Writer.Write("</div>");
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
if (meetingRequest != null)
{
meetingRequest.Dispose();
meetingRequest = null;
}
}
}
protected virtual StoreId CreateCorrelatedEvent(IMeetingRequest meetingRequest)
{
CalendarItemBase calendarItemBase = null;
StoreId result = null;
try
{
if (meetingRequest.TryUpdateCalendarItem(ref calendarItemBase, meetingRequest.IsDelegated()))
{
calendarItemBase.Save(SaveMode.NoConflictResolution);
this.Scope.MeetingRequestMessageDataProvider.SaveMeetingRequest(meetingRequest, this.Context);
result = calendarItemBase.Id;
}
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
}
}
return(result);
}
public void SaveCalendarItem()
{
ExTraceGlobals.CalendarCallTracer.TraceDebug((long)this.GetHashCode(), "EditMeetingInviteEventHandler.SaveCalendarItem");
CalendarItemBase calendarItemBase = null;
try
{
calendarItemBase = base.GetRequestItem <CalendarItemBase>(new PropertyDefinition[0]);
this.UpdateItem(calendarItemBase);
Utilities.SaveItem(calendarItemBase);
calendarItemBase.Load();
this.Writer.Write("<div id=ck>");
this.Writer.Write(calendarItemBase.Id.ChangeKeyAsBase64String());
this.Writer.Write("</div>");
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
public override CalendarItemBase PreProcess(bool createNewItem, bool processExternal, int defaultReminderMinutes)
{
this.CheckDisposed("PreProcess");
base.LocationIdentifierHelperInstance.SetLocationIdentifier(44661U, LastChangeAction.PreProcessMeetingMessage);
bool canUpdatePrincipalCalendar = true;
CalendarItemBase calendarItemBase = null;
bool flag = false;
if (base.GetValueOrDefault <MeetingMessageType>(InternalSchema.MeetingRequestType) == MeetingMessageType.Outdated)
{
return(null);
}
try
{
calendarItemBase = this.GetCorrelatedItem();
if (base.IsOutOfDate(calendarItemBase))
{
base.MarkAsOutOfDate();
base.LocationIdentifierHelperInstance.SetLocationIdentifier(59381U, LastChangeAction.MeetingMessageOutdated);
return(null);
}
if (base.SkipMessage(processExternal, calendarItemBase))
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId, bool, bool>((long)this.GetHashCode(), "Storage.MeetingMessage.PreProcess: GOID={0}. Skipping meeting message processing. (ProcessExternal: {1}; IsRepairUpdateMessage: {2})", this.GlobalObjectId, processExternal, base.IsRepairUpdateMessage);
return(null);
}
CalendarProcessingSteps valueOrDefault = base.GetValueOrDefault <CalendarProcessingSteps>(InternalSchema.CalendarProcessingSteps);
bool flag2 = (valueOrDefault & CalendarProcessingSteps.CreatedOnPrincipal) == CalendarProcessingSteps.CreatedOnPrincipal;
bool flag3 = (valueOrDefault & CalendarProcessingSteps.UpdatedCalItem) == CalendarProcessingSteps.UpdatedCalItem;
flag = (flag2 || flag3);
if (flag)
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.PreProcess: GOID={0}. Skipping meeting message processing because it was already created.", this.GlobalObjectId);
}
else if (createNewItem || calendarItemBase != null)
{
MeetingRequest meetingRequest = this as MeetingRequest;
if (meetingRequest != null)
{
flag = meetingRequest.TryUpdateCalendarItem(ref calendarItemBase, defaultReminderMinutes, canUpdatePrincipalCalendar);
}
else
{
MeetingCancellation meetingCancellation = this as MeetingCancellation;
if (meetingCancellation != null)
{
flag = meetingCancellation.TryUpdateCalendarItem(ref calendarItemBase, canUpdatePrincipalCalendar);
}
}
}
else
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.PreProcess: GOID={0}. Skipping new meeting request.", this.GlobalObjectId);
}
}
finally
{
if (!flag && calendarItemBase != null)
{
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.PreProcess: GOID={0}. Disposing calendar item; preconditions failed.", this.GlobalObjectId);
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
return(calendarItemBase);
}
// Token: 0x06000927 RID: 2343 RVA: 0x0003DEC0 File Offset: 0x0003C0C0
private static void HandleMeetingEvent(ExDateTime eventTime, MailboxData mailboxData, MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item)
{
if (item == null || !NotificationFactories.Instance.IsInterestedInCalendarMeetingEvent(mailboxData.Settings))
{
ExTraceGlobals.AssistantTracer.TraceDebug <MailboxData, MapiEvent>((long)typeof(CalendarChangeProcessor).GetHashCode(), "Ignore event because update is disabled for user {0}, event: {1}", mailboxData, mapiEvent);
return;
}
if (object.Equals(item.Id.ObjectId, mailboxData.DefaultDeletedItemsFolderId) || object.Equals(item.Id.ObjectId, mailboxData.DefaultJunkEmailFolderId))
{
ExTraceGlobals.AssistantTracer.TraceDebug <MailboxData, MapiEvent>((long)typeof(CalendarChangeProcessor).GetHashCode(), "Ignore event because item has been deleted for user {0}, event: {1}", mailboxData, mapiEvent);
return;
}
MeetingMessage meetingMessage = item as MeetingMessage;
if (meetingMessage == null)
{
ExTraceGlobals.AssistantTracer.TraceDebug <MailboxData, MapiEvent>((long)typeof(CalendarChangeProcessor).GetHashCode(), "Meeting event handler could do nothing because the item is not meeting message for user {0}, event: {1}", mailboxData, mapiEvent);
return;
}
if (meetingMessage.IsDelegated() || meetingMessage.IsMailboxOwnerTheSender() || meetingMessage.IsOutOfDate())
{
ExTraceGlobals.AssistantTracer.TraceDebug <MailboxData, MapiEvent>((long)typeof(CalendarChangeProcessor).GetHashCode(), "Ignore event because mtg is delegated or out of data or is ornizer for user {0}, event: {1}", mailboxData, mapiEvent);
return;
}
CalendarNotificationType calendarNotificationType = CalendarChangeProcessor.AnalyzeEvent(mapiEvent, meetingMessage);
if (calendarNotificationType == CalendarNotificationType.Uninteresting)
{
ExTraceGlobals.AssistantTracer.TraceDebug <MailboxData, MapiEvent>((long)typeof(CalendarChangeProcessor).GetHashCode(), "Ignore mtg event due to uninteresting for user {0}, event: {1}", mailboxData, mapiEvent);
return;
}
List <CalendarInfo> list = null;
Interval <ExDateTime> interval = new Interval <ExDateTime>(eventTime, false, eventTime + TimeSpan.FromDays((double)mailboxData.Settings.Text.TextNotification.NextDays), true);
CalendarItemBase calendarItemBase = null;
try
{
calendarItemBase = meetingMessage.GetCorrelatedItem();
if (!meetingMessage.TryUpdateCalendarItem(ref calendarItemBase, false))
{
ExTraceGlobals.AssistantTracer.TraceDebug <MailboxData, MapiEvent>((long)typeof(CalendarChangeProcessor).GetHashCode(), "Ignore mtg event because TryUpdateCalendarItem failed for user {0}, event: {1}", mailboxData, mapiEvent);
return;
}
list = OccurrenceLoader.Load(eventTime, mailboxData.Settings.TimeZone.ExTimeZone, itemStore, meetingMessage as MeetingRequest, calendarItemBase, mailboxData.Settings.Text.TextNotification.CalendarNotificationSettings.UpdateSettings.Duration.NonWorkHoursExcluded ? mailboxData.Settings.Text.WorkingHours : null, interval.Minimum, interval.Maximum);
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
int num = 0;
foreach (CalendarInfo calendarInfo in list)
{
if (calendarInfo.IsInteresting(calendarNotificationType))
{
CalendarNotificationInitiator.ScheduleAction(new UpdateEmitting(mailboxData, calendarInfo, calendarNotificationType), "HandleMeetingEvent");
num++;
}
}
ExTraceGlobals.AssistantTracer.TraceDebug((long)typeof(CalendarChangeProcessor).GetHashCode(), "{0} updates has been sent according to mtg msg {1} for user {2}, type: {3}, event: {4}", new object[]
{
num,
meetingMessage.Id.ObjectId,
mailboxData,
calendarNotificationType,
mapiEvent
});
}
public void MoveAppointment()
{
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("Id");
string changeKey = (string)base.GetParameter("CK");
OwaStoreObjectId owaStoreObjectId2 = (OwaStoreObjectId)base.GetParameter("fId");
CalendarItemBase calendarItemBase = null;
bool flag = false;
if (base.IsParameterSet("chkms"))
{
flag = (bool)base.GetParameter("chkms");
}
try
{
calendarItemBase = Utilities.GetItem <CalendarItemBase>(base.UserContext, owaStoreObjectId, changeKey, new PropertyDefinition[]
{
CalendarItemBaseSchema.IsMeeting,
CalendarItemBaseSchema.MeetingRequestWasSent,
StoreObjectSchema.EffectiveRights
});
if (!ItemUtility.UserCanEditItem(calendarItemBase) || Utilities.IsItemInExternalSharedInFolder(base.UserContext, calendarItemBase))
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=np></div>");
}
else if (flag && calendarItemBase.IsMeeting && calendarItemBase.MeetingRequestWasSent)
{
base.ResponseContentType = OwaEventContentType.Html;
if (owaStoreObjectId2.IsOtherMailbox)
{
this.Writer.Write("<div id=divOp _sOp=sfsu></div>");
}
else
{
this.Writer.Write("<div id=divOp _sOp=su></div>");
}
}
else if (flag && (owaStoreObjectId2.IsOtherMailbox || owaStoreObjectId2.IsGSCalendar))
{
this.Writer.Write("<div id=divOp _sOp=sfma></div>");
}
else
{
ExDateTime exDateTime = (ExDateTime)base.GetParameter("ST");
ExDateTime exDateTime2 = (ExDateTime)base.GetParameter("ET");
if (exDateTime > exDateTime2)
{
exDateTime2 = exDateTime;
}
calendarItemBase.LocationIdentifierHelperInstance.SetLocationIdentifier(43167U, LastChangeAction.MoveAppointmentTime);
calendarItemBase.StartTime = exDateTime;
calendarItemBase.EndTime = exDateTime2;
calendarItemBase.SetClientIntentBasedOnModifiedProperties(new ClientIntentFlags?(ClientIntentFlags.ModifiedTime));
if (!Utilities.IsPublic(calendarItemBase) && calendarItemBase.IsMeeting && calendarItemBase.MeetingRequestWasSent)
{
ExTraceGlobals.CalendarTracer.TraceDebug(0L, "Sending meeting update");
if (!calendarItemBase.IsOrganizer())
{
throw new OwaEventHandlerException(LocalizedStrings.GetNonEncoded(1360823576));
}
calendarItemBase.SendMeetingMessages(true, null, false, true, null, null);
}
else
{
ConflictResolutionResult conflictResolutionResult = calendarItemBase.Save(SaveMode.ResolveConflicts);
if (conflictResolutionResult.SaveStatus == SaveResult.IrresolvableConflict)
{
throw new OwaEventHandlerException("Could not save calendar item due to conflict resolution failure", LocalizedStrings.GetNonEncoded(-482397486), OwaEventHandlerErrorCode.ConflictResolution);
}
}
bool flag2 = false;
if (base.IsParameterSet("Ntfy"))
{
flag2 = (bool)base.GetParameter("Ntfy");
}
if (flag2)
{
calendarItemBase.Load();
PrincipalNotificationMessage principalNotificationMessage = new PrincipalNotificationMessage(owaStoreObjectId.ToBase64String(), owaStoreObjectId2, base.UserContext, this.HttpContext, PrincipalNotificationMessage.ActionType.Move, false, calendarItemBase.IsMeeting);
principalNotificationMessage.SendNotificationMessage();
}
this.RenderPayload(new OwaStoreObjectId[]
{
owaStoreObjectId2
});
}
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug((long)this.GetHashCode(), "Calendar item could not be found");
throw;
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
public static CalendarItemBase UpdateCalendarItem(MeetingRequest meetingRequest)
{
if (meetingRequest == null)
{
throw new ArgumentNullException("meetingRequest");
}
MeetingUtilities.ThrowIfMeetingResponseInvalid(meetingRequest);
CalendarItemBase calendarItemBase = null;
try
{
try
{
ExTraceGlobals.CalendarTracer.TraceDebug <string>(0L, "Retreiving calendar item associated with meeting request. Value = '{0}'", (meetingRequest.Id != null && meetingRequest.Id.ObjectId != null) ? meetingRequest.Id.ObjectId.ToBase64String() : "null");
if (meetingRequest.IsOutOfDate())
{
throw new OwaOperationNotSupportedException(LocalizedStrings.GetNonEncoded(-1085726012));
}
calendarItemBase = meetingRequest.UpdateCalendarItem(true);
if (calendarItemBase == null)
{
throw new OwaInvalidOperationException("meetingRequest.UpdateCalendarItem returns null.");
}
calendarItemBase.Load();
}
catch (CorrelationFailedException ex)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug <string>(0L, "Calendar item associated with meeting request could not be found. Exception: {0}", ex.Message);
throw;
}
catch (StoragePermanentException ex2)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug <string>(0L, "Calendar item associated with meeting request could not be found. Exception: {0}", ex2.Message);
throw;
}
catch (InvalidOperationException ex3)
{
if (ex3.Message == ServerStrings.ExOrganizerCannotCallUpdateCalendarItem)
{
throw new OwaOperationNotSupportedException(LocalizedStrings.GetNonEncoded(679811893));
}
throw;
}
try
{
MeetingUtilities.SaveItem(meetingRequest, new PropertyDefinition[]
{
MeetingMessageSchema.CalendarProcessed,
StoreObjectSchema.ParentItemId
});
}
catch (OwaSaveConflictException ex4)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug <string>(0L, "Calendar item associated with meeting request could not be saved. Exception: {0}", ex4.Message);
throw;
}
}
catch
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
throw;
}
if (Globals.ArePerfCountersEnabled)
{
OwaSingleCounters.ItemsCreated.Increment();
}
return(calendarItemBase);
}
public static void DeleteMeetingMessageCalendarItem(StoreObjectId meetingMessageId)
{
if (meetingMessageId == null)
{
throw new ArgumentNullException("meetingRequestId");
}
MeetingMessage meetingMessage = null;
CalendarItemBase calendarItemBase = null;
UserContext userContext = UserContextManager.GetUserContext();
try
{
try
{
meetingMessage = (MeetingMessage)Item.Bind(userContext.MailboxSession, meetingMessageId, ItemBindOption.LoadRequiredPropertiesOnly);
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug(0L, "Meeting request could not be found.");
throw;
}
calendarItemBase = MeetingUtilities.TryGetCorrelatedItem(meetingMessage);
if (calendarItemBase != null)
{
if (!calendarItemBase.IsOrganizer())
{
MeetingRequest meetingRequest = meetingMessage as MeetingRequest;
if (meetingRequest != null)
{
if (meetingRequest.MeetingRequestType == MeetingMessageType.InformationalUpdate || meetingRequest.MeetingRequestType == MeetingMessageType.Outdated || calendarItemBase.ResponseType == ResponseType.Accept || calendarItemBase.ResponseType == ResponseType.Tentative)
{
return;
}
}
else
{
if (!(meetingMessage is MeetingCancellation))
{
throw new OwaInvalidRequestException("Meeting message must be either a meeting invite or meeting cancellation");
}
if (meetingMessage.IsOutOfDate(calendarItemBase))
{
return;
}
}
calendarItemBase.DeleteMeeting(DeleteItemFlags.MoveToDeletedItems);
}
}
}
finally
{
if (meetingMessage != null)
{
meetingMessage.Dispose();
meetingMessage = null;
}
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
// Token: 0x06000CEA RID: 3306 RVA: 0x00045C70 File Offset: 0x00043E70
private bool LegacyRespond(StoreObjectId itemId, string requestId, string userResponse, bool usingLongId)
{
MeetingRequest meetingRequest = null;
CalendarItemBase calendarItemBase = null;
StoreObjectId storeObjectId = null;
StoreObjectId storeObjectId2 = null;
Item item = null;
try
{
base.ProtocolLogger.IncrementValue(ProtocolLoggerData.MRItems);
try
{
item = Item.Bind(base.MailboxSession, itemId, null);
}
catch (ObjectNotFoundException)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, userResponse, "Cannot find the meeting-request as specified in the reqest.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemNotFound");
return(false);
}
meetingRequest = (item as MeetingRequest);
if (base.Version >= 141 && meetingRequest == null)
{
calendarItemBase = (item as CalendarItemBase);
if (calendarItemBase != null)
{
calendarItemBase.OpenAsReadWrite();
}
}
if (meetingRequest == null && calendarItemBase == null)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolVersionMismatch, userResponse, "The item is not meeting-request or calendar item.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ItemNotValid");
return(false);
}
item = null;
if (meetingRequest != null)
{
if (meetingRequest.IsOrganizer())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "The organizer of this meeting request is the mailbox owner. Checking meetingRequest.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MRIsOrganizer");
return(false);
}
if (meetingRequest.IsDelegated())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "Cannot respond to a delegated meeting request. Use Outlook", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MRIsDelegated");
return(false);
}
if (meetingRequest.IsOutOfDate())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "Cannot respond to a OutOfDated meeting request.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "MRIsOutOfDate");
return(false);
}
meetingRequest.OpenAsReadWrite();
storeObjectId = meetingRequest.Id.ObjectId;
calendarItemBase = meetingRequest.UpdateCalendarItem(false);
}
if (calendarItemBase == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "NullCalItemInMRCmd");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.ServerError, null, false);
}
if (calendarItemBase.IsOrganizer())
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "The organizer of this meeting request is the mailbox owner. Checking calendarItem.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CalIsOrganizer");
return(false);
}
if (calendarItemBase.IsCancelled)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "Cannot respond to a canceled meeting.", usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "CalIsCancelled");
return(false);
}
if (userResponse != null)
{
ResponseType responseType;
if (!(userResponse == "1"))
{
if (!(userResponse == "2"))
{
if (!(userResponse == "3"))
{
goto IL_22F;
}
responseType = ResponseType.Decline;
}
else
{
responseType = ResponseType.Tentative;
}
}
else
{
responseType = ResponseType.Accept;
}
try
{
using (calendarItemBase.RespondToMeetingRequest(responseType))
{
}
}
catch (SaveConflictException ex)
{
this.AppendNonSuccessXmlNode(requestId, StatusCode.Sync_ProtocolError, userResponse, "A conflict calendar item has been detected: " + ex.Message, usingLongId);
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "SavedWithConflicts");
return(false);
}
calendarItemBase.Load();
if (meetingRequest != null)
{
meetingRequest.Save(SaveMode.ResolveConflicts);
}
if (responseType != ResponseType.Decline)
{
if (calendarItemBase is CalendarItemOccurrence)
{
storeObjectId2 = ((CalendarItemOccurrence)calendarItemBase).MasterId.ObjectId;
}
else
{
storeObjectId2 = calendarItemBase.Id.ObjectId;
}
}
else
{
base.MailboxSession.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
calendarItemBase.Id
});
}
calendarItemBase.Dispose();
calendarItemBase = null;
if (storeObjectId != null)
{
base.MailboxSession.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
storeObjectId
});
}
goto IL_339;
}
IL_22F:
throw new ArgumentException(string.Format("Unexpected userResponse value \"{0}\"", userResponse));
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
}
if (meetingRequest != null)
{
meetingRequest.Dispose();
}
if (item != null)
{
item.Dispose();
}
}
IL_339:
string calendarId = null;
if (storeObjectId2 != null)
{
MailboxSyncItemId mailboxSyncItemId = MailboxSyncItemId.CreateForNewItem(storeObjectId2);
if (this.CalendarItemIdMapping.Contains(mailboxSyncItemId))
{
calendarId = this.CalendarItemIdMapping[mailboxSyncItemId];
}
else
{
calendarId = this.CalendarItemIdMapping.Add(mailboxSyncItemId);
this.calendarSyncStateChangedFlag = true;
}
}
this.AppendXmlNode(requestId, StatusCode.Success, calendarId, userResponse, usingLongId);
return(true);
}
private Command.ExecutionState ForwardUsingXso(StoreObjectId smartId)
{
Item smartItem = base.GetSmartItem(smartId);
MessageItem messageItem = null;
VersionedId versionedId = null;
MessageItem messageItem2 = null;
CalendarItemBase calendarItemBase = null;
try
{
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts);
messageItem = MessageItem.Create(base.MailboxSession, defaultFolderId);
base.ParseMimeToMessage(messageItem);
messageItem.Save(SaveMode.NoConflictResolution);
messageItem.Load();
versionedId = messageItem.Id;
messageItem.Dispose();
messageItem = MessageItem.Bind(base.MailboxSession, versionedId);
RmsTemplate rmsTemplate = null;
SendMailBase.IrmAction irmAction = base.GetIrmAction(delegate(RightsManagedMessageItem originalRightsManagedItem)
{
if (originalRightsManagedItem == null)
{
throw new ArgumentNullException("originalRightsManagedItem");
}
if (!originalRightsManagedItem.UsageRights.IsUsageRightGranted(ContentRight.Forward))
{
throw new AirSyncPermanentException(StatusCode.IRM_OperationNotPermitted, false)
{
ErrorStringForProtocolLogger = "sfcEOperationNotPermitted"
};
}
}, ref smartItem, out rmsTemplate);
Microsoft.Exchange.Data.Storage.BodyFormat bodyFormat = messageItem.Body.Format;
MeetingMessage meetingMessage = smartItem as MeetingMessage;
string text;
if ((base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) && meetingMessage != null && !meetingMessage.IsDelegated() && (meetingMessage is MeetingRequest || meetingMessage is MeetingCancellation))
{
text = string.Empty;
}
else
{
using (TextReader textReader = messageItem.Body.OpenTextReader(bodyFormat))
{
text = textReader.ReadToEnd();
}
Body body = (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody) ? ((RightsManagedMessageItem)smartItem).ProtectedBody : smartItem.Body;
if (body.Format == Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml)
{
if (bodyFormat == Microsoft.Exchange.Data.Storage.BodyFormat.TextPlain)
{
XmlDocument xmlDocument = new SafeXmlDocument();
XmlNode xmlNode = xmlDocument.CreateElement("PRE");
XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("STYLE");
xmlAttribute.Value = "word-wrap:break-word; font-size:10.0pt; font-family:Tahoma; color:black";
xmlNode.Attributes.Append(xmlAttribute);
xmlNode.InnerText = text;
text = xmlNode.OuterXml;
}
bodyFormat = Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml;
}
}
ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(bodyFormat);
replyForwardConfiguration.ConversionOptionsForSmime = AirSyncUtility.GetInboundConversionOptions();
replyForwardConfiguration.AddBodyPrefix(text);
if (base.Version >= 120)
{
if (smartItem is MessageItem)
{
messageItem2 = ((MessageItem)smartItem).CreateForward(defaultFolderId, replyForwardConfiguration);
if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage)
{
messageItem2 = base.GetRightsManagedReplyForward(messageItem2, irmAction, rmsTemplate);
}
}
else if (smartItem is CalendarItem)
{
CalendarItem calendarItem = (CalendarItem)smartItem;
calendarItemBase = base.GetCalendarItemBaseToReplyOrForward(calendarItem);
messageItem2 = calendarItemBase.CreateForward(defaultFolderId, replyForwardConfiguration);
if (!calendarItem.IsMeeting)
{
BodyConversionUtilities.CopyBody(messageItem, messageItem2);
}
}
if (messageItem2 == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ForwardFailed");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false);
}
if (base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage)
{
RightsManagedMessageItem rightsManagedMessageItem = messageItem2 as RightsManagedMessageItem;
if (rightsManagedMessageItem != null)
{
rightsManagedMessageItem.ProtectedAttachmentCollection.RemoveAll();
}
else
{
messageItem2.AttachmentCollection.RemoveAll();
}
}
base.CopyMessageContents(messageItem, messageItem2, false, (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) ? smartItem : null);
base.SendMessage(messageItem2);
}
else if (smartItem is MessageItem)
{
using (ItemAttachment itemAttachment = messageItem.AttachmentCollection.AddExistingItem(smartItem))
{
MessageItem messageItem3 = (MessageItem)smartItem;
itemAttachment.FileName = messageItem3.Subject + itemAttachment.FileExtension;
itemAttachment.Save();
}
base.SendMessage(messageItem);
}
else if (smartItem is CalendarItem)
{
CalendarItem calendarItem2 = (CalendarItem)smartItem;
messageItem2 = calendarItem2.CreateForward(defaultFolderId, replyForwardConfiguration);
if (messageItem2 == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ForwardFailed2");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false);
}
if (!calendarItem2.IsMeeting)
{
BodyConversionUtilities.CopyBody(messageItem, messageItem2);
}
base.CopyMessageContents(messageItem, messageItem2, false, null);
base.SendMessage(messageItem2);
}
}
finally
{
if (messageItem != null)
{
if (versionedId != null)
{
base.MailboxSession.Delete(DeleteItemFlags.HardDelete, new StoreId[]
{
versionedId
});
}
messageItem.Dispose();
}
if (smartItem != null)
{
smartItem.Dispose();
}
if (messageItem2 != null)
{
messageItem2.Dispose();
}
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
}
}
return(Command.ExecutionState.Complete);
}
// Token: 0x06000B71 RID: 2929 RVA: 0x00049A1C File Offset: 0x00047C1C
protected override void HandleEventInternal(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item, List <KeyValuePair <string, object> > customDataToLog)
{
ResourceBookingAssistantLogEntry resourceBookingAssistantLogEntry = new ResourceBookingAssistantLogEntry
{
MapiEventFlag = mapiEvent.EventMask.ToString(),
MailboxGuid = itemStore.MailboxGuid,
TenantGuid = itemStore.MailboxOwner.MailboxInfo.OrganizationId.GetTenantGuid(),
DatabaseGuid = itemStore.MailboxOwner.MailboxInfo.GetDatabaseGuid()
};
try
{
string text = (item != null) ? item.ClassName : mapiEvent.ObjectClass;
resourceBookingAssistantLogEntry.ObjectClass = text;
if (itemStore.GetDefaultFolderId(DefaultFolderType.Calendar) == null)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, Guid>((long)this.GetHashCode(), "{0}: Mailbox: {1} - Calendar folder does not exist. Skipping processing.", TraceContext.Get(), mapiEvent.MailboxGuid);
resourceBookingAssistantLogEntry.IsCalendarFolderNotAvailable = true;
}
else
{
CachedState cachedState = AssistantsService.CachedObjectsList.GetCachedState(mapiEvent.MailboxGuid);
bool flag = ResourceCheck.DetailedCheckForAutomatedBooking(mapiEvent, itemStore, item, cachedState);
resourceBookingAssistantLogEntry.IsAutomatedBooking = flag;
if (flag)
{
if (item == null)
{
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: HandleEvent was passed a null item.", new object[]
{
TraceContext.Get()
});
}
else
{
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Automatic Booking is on.", new object[]
{
TraceContext.Get()
});
if (item is MeetingMessage)
{
MeetingMessage meetingMessage = item as MeetingMessage;
resourceBookingAssistantLogEntry.MeetingSender = meetingMessage.Sender.EmailAddress;
resourceBookingAssistantLogEntry.MeetingInternetMessageId = meetingMessage.InternetMessageId;
if (meetingMessage.IsDelegated())
{
ResourceBookingAssistant.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Deleting delegated meeting message: ID={1}", TraceContext.Get(), item.Id.ToString());
itemStore.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
meetingMessage.Id
});
RbaLog.LogEntry(itemStore, meetingMessage, EvaluationResults.Delete);
resourceBookingAssistantLogEntry.IsDelegatedMeetingRequest = true;
return;
}
}
cachedState.LockForRead();
CalendarConfiguration calendarConfiguration;
try
{
calendarConfiguration = (cachedState.State[0] as CalendarConfiguration);
}
finally
{
cachedState.ReleaseReaderLock();
}
bool flag2 = false;
try
{
if (item is MeetingRequest)
{
flag2 = (item as MeetingRequest).IsOrganizer();
}
else if (item is MeetingCancellation)
{
flag2 = (item as MeetingCancellation).IsOrganizer();
}
}
catch (ObjectNotFoundException innerException)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Object Not Found. ID={1}", TraceContext.Get(), item.Id.ToString());
throw new TransientMailboxException(innerException);
}
resourceBookingAssistantLogEntry.IsOrganizer = flag2;
if (!ObjectClass.IsOfClass(text, "IPM.Schedule.Meeting") || flag2)
{
if (calendarConfiguration.DeleteNonCalendarItems && (mapiEvent.EventMask & MapiEventTypeFlags.NewMail) != (MapiEventTypeFlags)0)
{
ResourceBookingAssistant.Tracer.TraceError((long)this.GetHashCode(), "{0}: Deleting a non-meeting message", new object[]
{
TraceContext.Get()
});
if (item is MessageItem)
{
RbaLog.LogEntry(itemStore, item as MessageItem, EvaluationResults.Delete);
}
itemStore.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
item.Id
});
resourceBookingAssistantLogEntry.DeleteNonMeetingMessage = true;
}
}
else
{
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Message is the right class", new object[]
{
TraceContext.Get()
});
if (!(item is MeetingMessage))
{
ResourceBookingAssistant.Tracer.TraceError((long)this.GetHashCode(), "{0}: Unexpected: Message class matched, but is not the correct object type. Ignoring message.", new object[]
{
TraceContext.Get()
});
}
else
{
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Message is MeetingMessage", new object[]
{
TraceContext.Get()
});
resourceBookingAssistantLogEntry.IsMeetingMessage = true;
MeetingMessage meetingMessage = item as MeetingMessage;
CalendarItemBase calendarItemBase = null;
DateTime utcNow = DateTime.UtcNow;
resourceBookingAssistantLogEntry.StartProcessingTime = utcNow;
for (int i = 0; i < 2; i++)
{
IEnumerable <VersionedId> duplicates;
Exception ex;
bool calendarItem = CalendarAssistant.GetCalendarItem(meetingMessage, ResourceBookingAssistant.Tracer, ref calendarItemBase, false, out duplicates, out ex);
resourceBookingAssistantLogEntry.AddExceptionToLog(ex);
if (!calendarItem)
{
break;
}
if (calendarItemBase == null)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: Original CalendarItem for message {1} is null", TraceContext.Get(), meetingMessage.Id);
}
StoreObjectValidationError[] array = meetingMessage.Validate();
if (array != null && array.Length > 0)
{
ResourceBookingAssistant.Tracer.TraceError <object, StoreObjectValidationError>((long)this.GetHashCode(), "{0}: mtgMessage did not validate, {1}", TraceContext.Get(), array[0]);
resourceBookingAssistantLogEntry.IsMeetingMessageInvalid = true;
throw new SkipException(Strings.descSkipExceptionFailedValidateCalItem);
}
string text2 = string.Empty;
try
{
this.calProcessor.ProcessMeetingMessage(itemStore, meetingMessage, ref calendarItemBase, calendarConfiguration, duplicates, false);
text2 = meetingMessage.Id.ToString();
resourceBookingAssistantLogEntry.IsMeetingMessageProcessed = true;
resourceBookingAssistantLogEntry.MeetingMessageId = text2;
bool flag3 = false;
if (meetingMessage is MeetingRequest)
{
flag3 = (meetingMessage as MeetingRequest).IsOrganizer();
}
else if (meetingMessage is MeetingCancellation)
{
flag3 = (meetingMessage as MeetingCancellation).IsOrganizer();
}
else if (meetingMessage is MeetingResponse)
{
flag3 = true;
}
resourceBookingAssistantLogEntry.IsOrganizer = flag3;
resourceBookingAssistantLogEntry.IsDelegatedMeetingRequest = meetingMessage.IsDelegated();
if (calendarItemBase == null)
{
if (flag3)
{
RbaLog.LogEntry(itemStore, meetingMessage, EvaluationResults.IgnoreOrganizer);
}
else if (resourceBookingAssistantLogEntry.IsDelegatedMeetingRequest)
{
RbaLog.LogEntry(itemStore, meetingMessage, EvaluationResults.IgnoreDelegate);
}
}
if (calendarItemBase == null && meetingMessage is MeetingCancellation)
{
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Deleting a meeting cancellation without correlated calendar item found", new object[]
{
TraceContext.Get()
});
itemStore.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
meetingMessage.Id
});
RbaLog.LogEntry(itemStore, meetingMessage, EvaluationResults.Delete);
resourceBookingAssistantLogEntry.DeleteCanceledMeeting = true;
}
if (calendarItemBase != null)
{
StoreObjectValidationError[] array2 = calendarItemBase.Validate();
if (array2 != null && array2.Length > 0)
{
ResourceBookingAssistant.Tracer.TraceError <object, StoreObjectValidationError>((long)this.GetHashCode(), "{0}: calendar item did not validate, {1}", TraceContext.Get(), array2[0]);
throw new SkipException(Strings.descSkipExceptionFailedValidateCalItem);
}
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: About to process request", new object[]
{
TraceContext.Get()
});
EvaluationResults evaluationResults = EvaluationResults.None;
BookingRoles bookingRoles = BookingRoles.NoRole;
ResourceBookingProcessing.ProcessRequest(mapiEvent, itemStore, meetingMessage, ref calendarItemBase, calendarConfiguration, out evaluationResults, out bookingRoles);
resourceBookingAssistantLogEntry.IsResourceBookingRequestProcessed = true;
resourceBookingAssistantLogEntry.EvaluationResult = evaluationResults.ToString();
resourceBookingAssistantLogEntry.BookingRole = bookingRoles.ToString();
}
break;
}
catch (CorruptDataException ex2)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, string, CorruptDataException>((long)this.GetHashCode(), "{0}: The calendar item found was corrupted, so we could not do Resource Booking processing for message ID={1}, skipping event. Exception={2}", TraceContext.Get(), text2, ex2);
throw new SkipException(ex2);
}
catch (ADTransientException arg)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, string, ADTransientException>((long)this.GetHashCode(), "{0}: There was an tranisent AD error processing the calendar item during Resource Booking processing for message ID={1}, cleaning things up and retrying. Exception={2}", TraceContext.Get(), text2, arg);
throw;
}
catch (ObjectNotFoundException innerException2)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Object Not Found. ID={1}", TraceContext.Get(), text2);
throw new TransientMailboxException(innerException2);
}
catch (SaveConflictException ex3)
{
ResourceBookingAssistant.Tracer.TraceDebug <object, string, SaveConflictException>((long)this.GetHashCode(), "{0}: There was an error saving the calendar item during Resource Booking processing for message ID={1}, cleaning things up and retrying.Exception={2}", TraceContext.Get(), text2, ex3);
resourceBookingAssistantLogEntry.AddExceptionToLog(ex3);
}
catch (OccurrenceCrossingBoundaryException ex4)
{
resourceBookingAssistantLogEntry.AddExceptionToLog(ex4);
ResourceBookingAssistant.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Found an overlapping occurrence while processing message ID={1}. Cleaning things up and retrying", TraceContext.Get(), text2);
if (ex4.OccurrenceInfo == null)
{
ResourceBookingAssistant.Tracer.TraceError((long)this.GetHashCode(), "{0}: Unexpected: Handling OccurrenceCrossingBoundaryException, the OccurrenceInfo is null", new object[]
{
TraceContext.Get()
});
break;
}
VersionedId versionedId = ex4.OccurrenceInfo.VersionedId;
AggregateOperationResult aggregateOperationResult = meetingMessage.Session.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
versionedId
});
ResourceBookingAssistant.Tracer.TraceDebug <object, OperationResult>((long)this.GetHashCode(), "{0}: Deleting the occurrence when handling an OccurrenceCrossingBoundaryException, returned:{2}", TraceContext.Get(), aggregateOperationResult.OperationResult);
}
finally
{
ResourceBookingAssistant.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: In finally block.", new object[]
{
TraceContext.Get()
});
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
DateTime utcNow2 = DateTime.UtcNow;
TimeSpan timeSpan = utcNow2.Subtract(utcNow);
ResourceBookingPerfmon.AverageResourceBookingProcessingTime.IncrementBy((long)timeSpan.TotalMilliseconds);
ResourceBookingPerfmon.AverageResourceBookingProcessingTimeBase.Increment();
resourceBookingAssistantLogEntry.StartProcessingTime = utcNow;
resourceBookingAssistantLogEntry.StopProcessingTime = utcNow2;
ResourceBookingAssistant.TracerPfd.TracePfd <int, object, string>((long)this.GetHashCode(), "PFD IWR {0} {1}: Finished processing message. MeetingMessageID = {2}", 20247, TraceContext.Get(), text2);
}
i++;
}
}
}
}
}
}
}
catch (Exception ex5)
{
resourceBookingAssistantLogEntry.AddExceptionToLog(ex5);
throw ex5;
}
finally
{
customDataToLog.AddRange(resourceBookingAssistantLogEntry.FormatCustomData());
}
}
public void CopyOrMoveAppointment()
{
ExTraceGlobals.MailCallTracer.TraceDebug((long)this.GetHashCode(), "CalendarViewEventHandler.CrossCalendarCopyMove");
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("Id");
string changeKey = (string)base.GetParameter("CK");
OwaStoreObjectId owaStoreObjectId2 = (OwaStoreObjectId)base.GetParameter("fId");
bool flag = (bool)base.GetParameter("fC");
StoreObjectId storeObjectId = owaStoreObjectId2.StoreObjectId;
CalendarItemBase calendarItemBase = null;
if (Utilities.IsELCRootFolder(owaStoreObjectId2, base.UserContext))
{
throw new OwaInvalidRequestException("Cannot move messages to the root ELC folder.");
}
if (owaStoreObjectId.IsGSCalendar)
{
throw new OwaInvalidRequestException("Item id cannot be GS Calendar folder id");
}
if (owaStoreObjectId2.IsGSCalendar)
{
throw new OwaInvalidRequestException("Cannot copy/move to GS Calendar");
}
MailboxSession mailboxSession = owaStoreObjectId2.GetSessionForFolderContent(base.UserContext) as MailboxSession;
if (mailboxSession == null)
{
throw new OwaInvalidRequestException("Cannot copy/move to public folder by this function");
}
if (storeObjectId.ObjectType != StoreObjectType.CalendarFolder)
{
throw new OwaInvalidRequestException("This function only support to copy/move to calendar folder");
}
try
{
calendarItemBase = Utilities.GetItem <CalendarItemBase>(base.UserContext, owaStoreObjectId, changeKey, new PropertyDefinition[]
{
StoreObjectSchema.EffectiveRights
});
if (calendarItemBase.ParentId.Equals(storeObjectId))
{
this.RenderCopyMoveFail(-612884101);
}
else
{
MailboxSession mailboxSession2 = calendarItemBase.Session as MailboxSession;
if (mailboxSession2 == null)
{
throw new OwaInvalidRequestException("Cannot copy/move from public folder by this function");
}
if (!StringComparer.OrdinalIgnoreCase.Equals(mailboxSession2.MailboxOwner.LegacyDn, mailboxSession.MailboxOwner.LegacyDn))
{
if (flag)
{
this.RenderCopyMoveFail(-1539006262);
}
else
{
this.RenderCopyMoveFail(1992576846);
}
}
else
{
bool flag2 = Utilities.CanCreateItemInFolder(base.UserContext, owaStoreObjectId2) && !Utilities.IsExternalSharedInFolder(base.UserContext, owaStoreObjectId2);
if (!flag)
{
flag2 = (flag2 && CalendarUtilities.UserCanDeleteCalendarItem(calendarItemBase) && !Utilities.IsItemInExternalSharedInFolder(base.UserContext, calendarItemBase));
}
if (!flag2)
{
ExTraceGlobals.CalendarTracer.TraceDebug(0L, "User have no rights to remove item from source folder or create new item in target folder.");
this.Writer.Write("<div id=divOp _sOp=\"np\"></div>");
}
else
{
if (flag)
{
calendarItemBase.CopyToFolder(mailboxSession, storeObjectId);
}
else
{
calendarItemBase.MoveToFolder(mailboxSession, storeObjectId);
}
this.Writer.Write("<div id=divOp _sOp=\"rf\"></div>");
TargetFolderMRU.AddAndGetFolders(owaStoreObjectId2, base.UserContext);
}
}
}
}
catch (CalendarItemExistsException)
{
this.RenderCopyMoveFail(-95861205);
}
catch (FutureMeetingException)
{
this.RenderCopyMoveFail(((bool)base.GetParameter("rcr")) ? 225743507 : -989731968);
}
catch (PrimaryCalendarFolderException)
{
this.RenderCopyMoveFail(-812685732);
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug((long)this.GetHashCode(), "Calendar item could not be found");
throw;
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
// Token: 0x06000779 RID: 1913 RVA: 0x00034A3C File Offset: 0x00032C3C
private void HandleMeetingMessage(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item, List <KeyValuePair <string, object> > customDataToLog)
{
if (item == null)
{
string objectClass = mapiEvent.ObjectClass;
}
else
{
string className = item.ClassName;
}
if (itemStore.GetDefaultFolderId(DefaultFolderType.Calendar) == null)
{
CalendarAssistant.GeneralTracer.TraceDebug((long)this.GetHashCode(), "{0}: Calendar folder does not exist. Skipping processing.", new object[]
{
TraceContext.Get()
});
CalendarAssistantLog.LogEntry(itemStore, "Could not get default folder id", new object[0]);
return;
}
if (item == null)
{
return;
}
MeetingMessage meetingMessage = item as MeetingMessage;
if (meetingMessage != null && meetingMessage.IsArchiveMigratedMessage)
{
CalendarAssistant.CachedStateTracer.TraceDebug((long)this.GetHashCode(), "{0}: Skipping the processing of the meeting item as this is an EHA migration traffic.", new object[]
{
TraceContext.Get()
});
return;
}
CachedState cachedState = AssistantsService.CachedObjectsList.GetCachedState(mapiEvent.MailboxGuid);
bool flag = ResourceCheck.DetailedCheckForAutomatedBooking(mapiEvent, itemStore, item, cachedState);
if (itemStore != null)
{
string legacyDn = itemStore.MailboxOwner.LegacyDn;
}
if (flag)
{
CalendarAssistant.CachedStateTracer.TraceDebug((long)this.GetHashCode(), "{0}: Updated the cachedState object, but this is a resource mailbox.", new object[]
{
TraceContext.Get()
});
return;
}
cachedState.LockForRead();
CalendarConfiguration calendarConfiguration;
try
{
calendarConfiguration = (cachedState.State[0] as CalendarConfiguration);
}
finally
{
cachedState.ReleaseReaderLock();
}
if (calendarConfiguration.SkipProcessing)
{
CalendarAssistant.CachedStateTracer.TraceDebug((long)this.GetHashCode(), "{0}: SkipProcessing is set.", new object[]
{
TraceContext.Get()
});
return;
}
if (CalendarAssistant.ShouldIgnoreMessage(itemStore, item.ParentId, meetingMessage))
{
return;
}
string text = (string)Utils.SafeGetProperty(item, ItemSchema.InternetMessageId, "<null>");
if (CalendarAssistant.ShouldProcessMessageClass(mapiEvent) && CalendarAssistant.ShouldProcessSeriesMessages(mapiEvent, itemStore))
{
bool flag2 = false;
DateTime utcNow = DateTime.UtcNow;
if (meetingMessage != null)
{
CalendarItemBase calendarItemBase = null;
try
{
if (meetingMessage.IsDelegated())
{
this.calProcessor.OldMessageDeletion.PerformCleanUp(itemStore, item, calendarConfiguration, calendarItemBase, null);
}
else
{
IEnumerable <VersionedId> duplicates;
bool calendarItem = CalendarAssistant.GetCalendarItem(meetingMessage, CalendarAssistant.UnexpectedPathTracer, ref calendarItemBase, true, out duplicates);
if (calendarItem)
{
this.calProcessor.ProcessMeetingMessage(itemStore, meetingMessage, ref calendarItemBase, calendarConfiguration, duplicates, true, itemStore.MailboxOwner.IsResource.Value);
}
}
}
catch (OccurrenceCrossingBoundaryException ex)
{
CalendarAssistant.ProcessingTracer.TraceDebug <object, VersionedId>((long)meetingMessage.GetHashCode(), "{0}: Found an overlapping occurrence while processing message ID={1}. Cleaning things up and retrying", TraceContext.Get(), meetingMessage.Id);
StringBuilder stringBuilder = new StringBuilder(1024);
stringBuilder.AppendFormat("Found an overlapping occurrence while processing message ID={0}.", meetingMessage.Id);
if (ex.OccurrenceInfo == null)
{
CalendarAssistant.UnexpectedPathTracer.TraceError((long)this.GetHashCode(), "{0}: Unexpected: Handling OccurrenceCrossingBoundaryException, the OccurrenceInfo is null.", new object[]
{
TraceContext.Get()
});
stringBuilder.Append("Unexpected: Handling OccurrenceCrossingBoundaryException, the OccurrenceInfo is null.");
}
else
{
VersionedId versionedId = ex.OccurrenceInfo.VersionedId;
AggregateOperationResult aggregateOperationResult = meetingMessage.Session.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
versionedId
});
CalendarAssistant.ProcessingTracer.TraceDebug <object, OperationResult>((long)this.GetHashCode(), "{0}: Deleting the occurrence when handling an OccurrenceCrossingBoundaryException, returned:{1}", TraceContext.Get(), aggregateOperationResult.OperationResult);
stringBuilder.AppendFormat("Deleting the occurrence when handling an OccurrenceCrossingBoundaryException, returned: {0}", aggregateOperationResult.OperationResult);
}
CalendarAssistantLog.LogEntry(itemStore, ex, false, stringBuilder.ToString(), new object[0]);
}
catch (CorruptDataException ex2)
{
CalendarAssistant.ProcessingTracer.TraceDebug <object, CorruptDataException>((long)this.GetHashCode(), "{0}: Got a corrupt message, exception data:{1}", TraceContext.Get(), ex2);
CalendarAssistantLog.LogEntry(itemStore, ex2, false, "Got a corrupt message ID = {0}.", new object[]
{
meetingMessage.Id
});
}
finally
{
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
flag2 = true;
}
else if (item is MeetingInquiryMessage)
{
MeetingInquiryMessage meetingInquiryMessage = (MeetingInquiryMessage)item;
try
{
this.calProcessor.ProcessMeetingInquiryMessage(this.cvsGateway, itemStore, meetingInquiryMessage);
}
catch (CalendarVersionStoreNotPopulatedException ex3)
{
CalendarAssistant.ProcessingTracer.TraceWarning <object, CalendarVersionStoreNotPopulatedException>((long)this.GetHashCode(), "{0}: Failed to process an inquiry message, because the CVS is not populated yet. {1}", TraceContext.Get(), ex3);
CalendarAssistantLog.LogEntry(itemStore, ex3, false, "Failed to process an inquiry message ID = {0}, because the CVS is not populated yet.", new object[]
{
meetingInquiryMessage.Id
});
}
this.calProcessor.OldMessageDeletion.DeleteMessage(itemStore, item);
flag2 = true;
}
else
{
CalendarAssistant.UnexpectedPathTracer.TraceError((long)this.GetHashCode(), "{0}: Unexpected: Message class matched, but is not the correct object type. Ignoring message.", new object[]
{
TraceContext.Get()
});
CalendarAssistantLog.LogEntry(itemStore, "Unexpected: Message class matched, but is not the correct object type. Ignoring message ID = {0}.", new object[]
{
item.Id
});
}
if (flag2)
{
TimeSpan timeSpan = DateTime.UtcNow.Subtract(utcNow);
CalendarAssistantPerformanceCounters.LastCalAssistantProcessingTime.RawValue = (long)timeSpan.TotalMilliseconds;
CalendarAssistantPerformanceCounters.AverageCalAssistantProcessingTime.IncrementBy((long)timeSpan.TotalMilliseconds);
CalendarAssistantPerformanceCounters.AverageCalAssistantProcessingTimeBase.Increment();
CalendarAssistantPerformanceCounters.MeetingMessagesProcessed.Increment();
}
CalendarAssistant.GeneralTracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Finished processing message. InternetMessgeID = {1}", TraceContext.Get(), text);
CalendarAssistant.TracerPfd.TracePfd <int, object, string>((long)this.GetHashCode(), "PFD IWC {0} {1}: Finished processing message. InternetMessgeID = {2}", 21655, TraceContext.Get(), text);
}
}
// Token: 0x06000790 RID: 1936 RVA: 0x00035684 File Offset: 0x00033884
public void ProcessMeetingMessage(MailboxSession itemStore, MeetingMessage mtgMessage, ref CalendarItemBase originalCalItem, CalendarConfiguration mailboxConfig, IEnumerable <VersionedId> duplicates, bool performOmd, bool honorExternalMeetingMessageProcessingConfig)
{
bool isProcessed = mtgMessage.IsProcessed;
bool flag = this.PreProcessMessage(itemStore, mtgMessage, isProcessed, mtgMessage.CalendarProcessed);
bool flag2 = false;
if (!flag)
{
flag2 = CalendarProcessing.IsAutoAcceptanceProcessingRequired(itemStore, mtgMessage, originalCalItem);
}
if (flag || flag2)
{
int num = mailboxConfig.DefaultReminderTime;
if (num < 0 || num > 2629800)
{
num = CalendarProcessing.DefaultReminderMinutesBeforeStart;
}
int num2 = 3;
int i = num2;
if (this.honorProcessingConfiguration && originalCalItem == null && !mailboxConfig.AddNewRequestsTentatively && !mtgMessage.IsRepairUpdateMessage)
{
CalendarProcessing.ProcessingTracer.TraceDebug((long)mtgMessage.GetHashCode(), "{0}: Skipping processing because user settings for adding new items is false.", new object[]
{
TraceContext.Get()
});
return;
}
if (honorExternalMeetingMessageProcessingConfig && mtgMessage.SkipMessage(mailboxConfig.ProcessExternalMeetingMessages, originalCalItem))
{
CalendarProcessing.ProcessingTracer.TraceDebug <object, bool>((long)mtgMessage.GetHashCode(), "{0}: Skipping processing because user settings for processing external items is false. IsRepairUpdateMessage: {1}", TraceContext.Get(), mtgMessage.IsRepairUpdateMessage);
return;
}
while (i > 0)
{
try
{
if (flag)
{
if (!this.DoProcessingLogic(itemStore, mtgMessage, ref originalCalItem, num, ref i))
{
this.TraceDebugAndPfd(mtgMessage.GetHashCode(), string.Format("{0}: completedProcessing = {1}", TraceContext.Get(), false));
continue;
}
flag = false;
this.TraceDebugAndPfd(mtgMessage.GetHashCode(), string.Format("{0}: completedProcessing = {1}", TraceContext.Get(), true));
flag2 = CalendarProcessing.IsAutoAcceptanceProcessingRequired(itemStore, mtgMessage, originalCalItem);
}
if (flag2)
{
CalendarProcessing.AutoAcceptEvents(itemStore, originalCalItem);
flag2 = false;
}
if (!flag && !flag2)
{
break;
}
}
catch (ObjectExistedException exception)
{
this.TraceAndLogException(exception, itemStore, mtgMessage, i);
i--;
}
catch (SaveConflictException ex)
{
this.TraceAndLogException(ex, itemStore, mtgMessage, i);
i--;
if (originalCalItem != null)
{
originalCalItem.Dispose();
originalCalItem = null;
}
if (!CalendarAssistant.GetCalendarItem(mtgMessage, CalendarProcessing.UnexpectedPathTracer, ref originalCalItem, duplicates != null, out duplicates))
{
throw new SkipException(Strings.descSkipExceptionFailedToLoadCalItem, ex);
}
if (originalCalItem != null)
{
originalCalItem.OpenAsReadWrite();
}
}
catch (QuotaExceededException exception2)
{
this.TraceAndLogException(exception2, itemStore, mtgMessage, i);
i = -1;
}
catch (ObjectNotFoundException ex2)
{
this.TraceAndLogException(ex2, itemStore, mtgMessage, i);
throw new SkipException(ex2);
}
catch (VirusDetectedException exception3)
{
this.TraceAndLogException(exception3, itemStore, mtgMessage, i);
i = -1;
}
catch (VirusMessageDeletedException exception4)
{
this.TraceAndLogException(exception4, itemStore, mtgMessage, i);
i = -1;
}
catch (DataValidationException ex3)
{
this.TraceAndLogException(ex3, itemStore, mtgMessage, i);
throw new SkipException(ex3);
}
catch (RecurrenceException ex4)
{
this.TraceAndLogException(ex4, itemStore, mtgMessage, i);
throw new SkipException(ex4);
}
}
if (flag && i == 0)
{
string internetMessageId = mtgMessage.InternetMessageId;
CalendarProcessing.ProcessingTracer.TraceDebug <object, string>((long)mtgMessage.GetHashCode(), "{0}: Attempting a third time to process message, but without the catch blocks: {1}", TraceContext.Get(), internetMessageId);
this.DoProcessingLogic(itemStore, mtgMessage, ref originalCalItem, num, ref i);
}
}
if (ObjectClass.IsMeetingCancellationSeries(mtgMessage.ClassName) || ObjectClass.IsMeetingRequestSeries(mtgMessage.ClassName))
{
this.TryUnparkInstanceMessages(itemStore, mtgMessage.GetValueOrDefault <string>(MeetingMessageSchema.SeriesId), mtgMessage.GetValueOrDefault <int>(MeetingMessageSchema.SeriesSequenceNumber));
}
if (performOmd)
{
this.OldMessageDeletion.PerformCleanUp(itemStore, mtgMessage, mailboxConfig, originalCalItem, duplicates);
}
}
// Token: 0x06001589 RID: 5513 RVA: 0x0007F070 File Offset: 0x0007D270
internal override Command.ExecutionState ExecuteCommand()
{
MessageItem clientMessage = null;
Item item = null;
MessageItem messageItem = null;
VersionedId versionedId = null;
CalendarItemBase calendarItemBase = null;
try
{
base.ValidateBody();
StoreObjectId defaultFolderId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Drafts);
clientMessage = MessageItem.Create(base.MailboxSession, defaultFolderId);
base.ParseMimeToMessage(clientMessage);
clientMessage.Save(SaveMode.NoConflictResolution);
clientMessage.Load();
versionedId = clientMessage.Id;
clientMessage.Dispose();
clientMessage = MessageItem.Bind(base.MailboxSession, versionedId);
item = base.GetSmartItem();
RmsTemplate rmsTemplate = null;
bool isReplyAll = false;
SendMailBase.IrmAction irmAction = base.GetIrmAction(delegate(RightsManagedMessageItem originalRightsManagedItem)
{
if (originalRightsManagedItem == null)
{
throw new ArgumentNullException("originalRightsManagedItem");
}
isReplyAll = this.IsIrmReplyAll(originalRightsManagedItem, clientMessage);
}, ref item, out rmsTemplate);
Microsoft.Exchange.Data.Storage.BodyFormat bodyFormat = clientMessage.Body.Format;
MeetingMessage meetingMessage = item as MeetingMessage;
string text;
if ((base.ReplaceMime || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) && meetingMessage != null && !meetingMessage.IsDelegated() && (meetingMessage is MeetingCancellation || meetingMessage is MeetingRequest))
{
text = string.Empty;
}
else
{
using (TextReader textReader = clientMessage.Body.OpenTextReader(bodyFormat))
{
text = textReader.ReadToEnd();
}
Body body = (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.ReusePublishingLicenseInlineOriginalBody) ? ((RightsManagedMessageItem)item).ProtectedBody : item.Body;
if (body.Format == Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml)
{
if (bodyFormat == Microsoft.Exchange.Data.Storage.BodyFormat.TextPlain)
{
XmlDocument xmlDocument = new SafeXmlDocument();
XmlNode xmlNode = xmlDocument.CreateElement("PRE");
XmlAttribute xmlAttribute = xmlDocument.CreateAttribute("STYLE");
xmlAttribute.Value = "word-wrap:break-word; font-size:10.0pt; font-family:Tahoma; color:black";
xmlNode.Attributes.Append(xmlAttribute);
xmlNode.InnerText = text;
text = xmlNode.OuterXml;
}
bodyFormat = Microsoft.Exchange.Data.Storage.BodyFormat.TextHtml;
}
}
ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(bodyFormat);
replyForwardConfiguration.ConversionOptionsForSmime = AirSyncUtility.GetInboundConversionOptions();
replyForwardConfiguration.AddBodyPrefix(text);
if (item is MessageItem)
{
MessageItem messageItem2 = (MessageItem)item;
if (!messageItem2.IsReplyAllowed)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ReplyNotAllowed");
AirSyncPermanentException ex = new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MessageReplyNotAllowed, null, false);
throw ex;
}
if (isReplyAll)
{
messageItem = messageItem2.CreateReplyAll(defaultFolderId, replyForwardConfiguration);
}
else
{
messageItem = messageItem2.CreateReply(defaultFolderId, replyForwardConfiguration);
}
if (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicense || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseInlineOriginalBody || irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage)
{
messageItem = base.GetRightsManagedReplyForward(messageItem, irmAction, rmsTemplate);
}
}
else if (item is CalendarItem)
{
CalendarItem item2 = (CalendarItem)item;
calendarItemBase = base.GetCalendarItemBaseToReplyOrForward(item2);
messageItem = calendarItemBase.CreateReply(defaultFolderId, replyForwardConfiguration);
}
if (messageItem == null)
{
base.ProtocolLogger.SetValue(ProtocolLoggerData.Error, "ReplyFailed");
throw new AirSyncPermanentException(HttpStatusCode.InternalServerError, StatusCode.MailSubmissionFailed, null, false);
}
base.CopyMessageContents(clientMessage, messageItem, true, (irmAction == SendMailBase.IrmAction.CreateNewPublishingLicenseAttachOriginalMessage) ? item : null);
base.SendMessage(messageItem);
}
finally
{
if (clientMessage != null)
{
if (versionedId != null)
{
base.MailboxSession.Delete(DeleteItemFlags.HardDelete, new StoreId[]
{
versionedId
});
}
clientMessage.Dispose();
}
if (item != null)
{
item.Dispose();
}
if (messageItem != null)
{
messageItem.Dispose();
}
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
}
}
return(Command.ExecutionState.Complete);
}
// Token: 0x06002DB9 RID: 11705 RVA: 0x00102FA4 File Offset: 0x001011A4
private void NonEditResponseInternal(bool sendResponse)
{
ResponseType responseType = (ResponseType)base.GetParameter("Rsp");
StoreObjectType storeObjectType = (StoreObjectType)base.GetParameter("ItemType");
MeetingRequest meetingRequest = null;
CalendarItemBase calendarItemBase = null;
try
{
StoreObjectType storeObjectType2 = storeObjectType;
if (storeObjectType2 != StoreObjectType.MeetingRequest)
{
if (storeObjectType2 == StoreObjectType.CalendarItem)
{
calendarItemBase = base.GetRequestItem <CalendarItemBase>(new PropertyDefinition[0]);
MeetingUtilities.ThrowIfMeetingResponseInvalid(calendarItemBase);
}
}
else
{
this.properties = new PropertyDefinition[]
{
MeetingMessageSchema.CalendarProcessed,
StoreObjectSchema.ParentItemId
};
meetingRequest = this.GetMeetingRequest(this.properties);
calendarItemBase = MeetingUtilities.UpdateCalendarItem(meetingRequest);
if (calendarItemBase == null)
{
throw new OwaInvalidRequestException(string.Format("calendarItem associated with meetingRequest with Id {0} is null.", base.GetParameter("Id")));
}
}
this.UpdateItem(calendarItemBase);
Utilities.SaveItem(calendarItemBase);
calendarItemBase.Load();
MeetingUtilities.NonEditResponse(responseType, calendarItemBase, sendResponse, null);
calendarItemBase.Load();
if (meetingRequest != null)
{
this.UpdateItem(meetingRequest);
Utilities.SaveItem(meetingRequest);
MeetingUtilities.DeleteMeetingRequestAfterResponse(meetingRequest);
}
if (storeObjectType == StoreObjectType.CalendarItem)
{
this.Writer.Write("<div id=nid>");
this.Writer.Write(OwaStoreObjectId.CreateFromStoreObject(calendarItemBase).ToBase64String());
this.Writer.Write("</div>");
}
}
finally
{
if (meetingRequest != null)
{
meetingRequest.Dispose();
meetingRequest = null;
}
if (calendarItemBase != null)
{
calendarItemBase.Dispose();
calendarItemBase = null;
}
}
}
