private void PostResponded(SharingResponseType responseType)
{
if (!this.SharingMessageType.IsRequest)
{
throw new InvalidOperationException("Only can response to a request message.");
}
base.OpenAsReadWrite();
this.SharingResponseType = responseType;
this.SharingResponseTime = new ExDateTime?(ExDateTime.Now);
ConflictResolutionResult conflictResolutionResult = base.Save(SaveMode.ResolveConflicts);
if (conflictResolutionResult.SaveStatus == SaveResult.IrresolvableConflict)
{
ExTraceGlobals.SharingTracer.TraceError <IExchangePrincipal, VersionedId>((long)this.GetHashCode(), "{0}: Conflict occurred when saving response-status into request message {1}", this.MailboxSession.MailboxOwner, base.Id);
}
if (responseType == SharingResponseType.Denied)
{
try
{
SharingProvider targetSharingProvider = this.GetTargetSharingProvider();
targetSharingProvider.PerformRevocation(this.MailboxSession, this.SharingContext);
}
catch (StoragePermanentException arg)
{
ExTraceGlobals.SharingTracer.TraceError <IExchangePrincipal, StoragePermanentException>((long)this.GetHashCode(), "{0}: Error occurred when revoking sharing from denied requester. Exception = {1}", this.MailboxSession.MailboxOwner, arg);
}
}
}
protected override void OnBeforeSend()
{
base.CoreItem.SaveRecipients();
CheckRecipientsResults checkRecipientsResults = this.CheckRecipients();
if (checkRecipientsResults.InvalidRecipients != null && checkRecipientsResults.InvalidRecipients.Length > 0)
{
throw new InvalidSharingRecipientsException(checkRecipientsResults.InvalidRecipients, new RecipientNotSupportedByAnyProviderException());
}
this.PerformInvitation();
this.SharingContext.SerializeToMessage(this);
this.AddBodyPrefix(this.CreateBodyPrefix());
this.isSending = true;
if (this.SharingMessageType.IsResponseToRequest)
{
SharingMessageItem sharingMessageItem = this.TryGetOriginalMessage();
if (sharingMessageItem != null)
{
try
{
SharingResponseType responseTypeFromMessageType = SharingMessageItem.GetResponseTypeFromMessageType(this.SharingMessageType);
sharingMessageItem.PostResponded(responseTypeFromMessageType);
}
finally
{
sharingMessageItem.Dispose();
}
}
}
this[MessageItemSchema.RecipientReassignmentProhibited] = !this.IsPublishing;
base.OnBeforeSend();
}
private static LocalizedString GetSubjectPrefixFromResponseType(SharingResponseType responseType)
{
switch (responseType)
{
case SharingResponseType.Allowed:
return(ClientStrings.SharingRequestAllowed);
case SharingResponseType.Denied:
return(ClientStrings.SharingRequestDenied);
default:
throw new ArgumentException("responseType");
}
}
private static SharingMessageType GetMessageTypeFromResponseType(SharingResponseType responseType)
{
switch (responseType)
{
case SharingResponseType.Allowed:
return(SharingMessageType.AcceptOfRequest);
case SharingResponseType.Denied:
return(SharingMessageType.DenyOfRequest);
default:
throw new ArgumentException("responseType");
}
}
private SharingMessageItem CreateRequestResponseMessage(SharingResponseType responseType, StoreId destFolderId)
{
if (base.IsDraft)
{
throw new InvalidOperationException("Cannot response on draft message.");
}
if (!this.SharingMessageType.IsRequest)
{
throw new InvalidOperationException("Only can response to a request message.");
}
StoreId defaultFolderId = this.MailboxSession.GetDefaultFolderId(this.SharedFolderType);
SharingMessageItem sharingMessageItem = SharingMessageItem.InternalCreate(this.MailboxSession, destFolderId, defaultFolderId, this.GetTargetSharingProvider());
sharingMessageItem.SharingMessageType = SharingMessageItem.GetMessageTypeFromResponseType(responseType);
sharingMessageItem.Recipients.Add(base.From);
sharingMessageItem[SharingMessageItemSchema.SharingOriginalMessageEntryId] = HexConverter.HexStringToByteArray(base.StoreObjectId.ToHexEntryId());
sharingMessageItem[InternalSchema.NormalizedSubject] = this[InternalSchema.NormalizedSubject];
sharingMessageItem[InternalSchema.SubjectPrefix] = SharingMessageItem.GetSubjectPrefixFromResponseType(responseType).ToString(this.MailboxSession.InternalPreferedCulture);
return(sharingMessageItem);
}
