internal static void CopyBodyWithPrefix(Body sourceBody, Body targetBody, ReplyForwardConfiguration configuration, BodyConversionCallbacks callbacks)
{
ReplyForwardCommon.CheckRtf(sourceBody.RawFormat, targetBody.RawFormat);
BodyReadConfiguration configuration2 = new BodyReadConfiguration(sourceBody.RawFormat, sourceBody.RawCharset.Name);
BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(sourceBody.RawFormat, sourceBody.RawCharset.Name);
bodyWriteConfiguration.SetTargetFormat(configuration.TargetFormat, sourceBody.Charset);
if (!string.IsNullOrEmpty(configuration.BodyPrefix))
{
bodyWriteConfiguration.AddInjectedText(configuration.BodyPrefix, null, configuration.BodyPrefixFormat);
}
if (callbacks.HtmlCallback != null || callbacks.RtfCallback != null)
{
bodyWriteConfiguration.HtmlCallback = callbacks.HtmlCallback;
bodyWriteConfiguration.RtfCallback = callbacks.RtfCallback;
if (!configuration.ShouldSkipFilterHtmlOnBodyWrite)
{
bodyWriteConfiguration.HtmlFlags = HtmlStreamingFlags.FilterHtml;
}
}
using (Stream stream = sourceBody.OpenReadStream(configuration2))
{
using (Stream stream2 = targetBody.OpenWriteStream(bodyWriteConfiguration))
{
Util.StreamHandler.CopyStreamData(stream, stream2);
}
}
}
public PostItem ReplyToFolder(StoreSession session, StoreId parentFolderId, ReplyForwardConfiguration configuration)
{
this.CheckDisposed("ReplyToFolder");
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(parentFolderId, "parentFolderId");
Util.ThrowOnNullArgument(configuration, "configuration");
PostItem postItem = null;
bool flag = false;
PostItem result;
try
{
postItem = PostItem.Create(session, parentFolderId);
ReplyCreation replyCreation = new ReplyCreation(this, postItem, configuration, false, false, true);
replyCreation.PopulateProperties();
postItem[InternalSchema.IconIndex] = IconIndex.PostItem;
flag = true;
result = postItem;
}
finally
{
if (!flag && postItem != null)
{
postItem.Dispose();
postItem = null;
}
}
return(result);
}
internal VotingResponse(MessageItem originalItem, MessageItem newItem, ReplyForwardConfiguration configuration, string votingResponse) : base(originalItem, newItem, configuration, true)
{
this.votingResponse = votingResponse;
this.newItem.SafeSetProperty(InternalSchema.IsVotingResponse, 1);
int lastAction = originalItem.VotingInfo.GetOptionsList().IndexOf(votingResponse) + 1;
this.newItem.SafeSetProperty(InternalSchema.ReplyForwardStatus, ReplyForwardUtils.EncodeReplyForwardStatus((LastAction)lastAction, IconIndex.MailReplied, originalItem.Id));
}
public static void CreatePostReplyForwardHeader(ReplyForwardConfiguration configuration, Item item, ForwardReplyHeaderOptions options, CultureInfo culture)
{
if (!(item is PostItem))
{
throw new ArgumentException("CreatePostReplyForwardheader is called on a non-PostItem item.");
}
PostItem postItem = (PostItem)item;
StringBuilder stringBuilder = new StringBuilder();
bool outputHtml = BodyFormat.TextHtml == configuration.TargetFormat;
if (postItem.Sender != null)
{
if (postItem.From != null && string.Compare(postItem.Sender.DisplayName, postItem.From.DisplayName, StringComparison.Ordinal) != 0)
{
stringBuilder.Append(string.Format(ClientStrings.OnBehalfOf.ToString(culture), ReplyForwardHeader.GetParticipantDisplayString(postItem.Sender, outputHtml), ReplyForwardHeader.GetParticipantDisplayString(postItem.From, outputHtml)));
}
else
{
ReplyForwardHeader.AppendParticipantDisplayString(postItem.Sender, stringBuilder, outputHtml);
}
}
string fromLabel = string.Empty;
BodyInjectionFormat bodyPrefixFormat;
string bodyPrefix;
switch (configuration.TargetFormat)
{
case BodyFormat.TextPlain:
fromLabel = ClientStrings.FromColon.ToString(culture);
bodyPrefixFormat = BodyInjectionFormat.Text;
bodyPrefix = ReplyForwardHeader.CreatePostTextReplyForwardHeader(postItem, options, fromLabel, stringBuilder.ToString(), culture, configuration.TimeZone);
break;
case BodyFormat.TextHtml:
fromLabel = ClientStrings.FromColon.ToString(culture);
bodyPrefixFormat = BodyInjectionFormat.Html;
bodyPrefix = ReplyForwardHeader.CreatePostHtmlReplyForwardHeader(postItem, options, fromLabel, stringBuilder.ToString(), culture, configuration.TimeZone);
break;
default:
throw new ArgumentException("Unsupported body format");
}
configuration.AddBodyPrefix(bodyPrefix, bodyPrefixFormat);
}
internal ForwardCreation(Item originalItem, MessageItem message, ReplyForwardConfiguration parameters) : base(originalItem, message, parameters, true)
{
LastAction lastAction = LastAction.Forward;
IconIndex iconIndex = IconIndex.MailForwarded;
if (this.originalItemSigned)
{
iconIndex = IconIndex.MailSmimeSignedForwarded;
}
else if (this.originalItemEncrypted)
{
iconIndex = IconIndex.MailEncryptedForwarded;
}
else if (this.originalItemIrm)
{
iconIndex = IconIndex.MailIrmForwarded;
}
if (originalItem.Id != null && originalItem.Id.ObjectId != null && !originalItem.Id.ObjectId.IsFakeId && !(originalItem is PostItem))
{
this.newItem.SafeSetProperty(InternalSchema.ReplyForwardStatus, ReplyForwardUtils.EncodeReplyForwardStatus(lastAction, iconIndex, originalItem.Id));
}
}
internal ReplyForwardCommon(Item originalItem, Item newItem, ReplyForwardConfiguration parameters, bool decodeSmime)
{
Util.ThrowOnNullArgument(parameters, "parameters");
if (decodeSmime && ObjectClass.IsSmime(originalItem.ClassName))
{
if (parameters.ConversionOptionsForSmime == null || parameters.ConversionOptionsForSmime.IgnoreImceaDomain || parameters.ConversionOptionsForSmime.ImceaEncapsulationDomain == null)
{
throw new InvalidOperationException("Cannot decode SMIME without valid ConversionOptionsForSmime");
}
this.originalItem = originalItem;
MessageItem messageItem = originalItem as MessageItem;
if (messageItem != null)
{
Item item = messageItem.FetchSmimeContent(parameters.ConversionOptionsForSmime.ImceaEncapsulationDomain);
if (item != null)
{
this.originalItem = item;
this.originalItem[InternalSchema.NormalizedSubjectInternal] = messageItem.GetValueOrDefault <string>(InternalSchema.NormalizedSubjectInternal, string.Empty);
this.originalItem[InternalSchema.Sender] = messageItem.Sender;
this.originalItem[InternalSchema.From] = messageItem.From;
}
}
}
else
{
this.originalItem = originalItem;
}
this.newItem = newItem;
this.parameters = parameters;
this.culture = ReplyForwardUtils.CalculateReplyForwardCulture(parameters.Culture, newItem);
if (this.culture == null)
{
throw new InvalidOperationException("Forward message culture is unknown");
}
this.FetchPropertiesFromOriginalItem();
if (originalItem is MessageItem)
{
if (originalItem.MapiMessage != null)
{
SetReadFlags readFlag = parameters.ShouldSuppressReadReceipt ? SetReadFlags.SuppressReceipt : SetReadFlags.None;
try
{
StoreSession session = originalItem.Session;
bool flag = false;
try
{
if (session != null)
{
session.BeginMapiCall();
session.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
originalItem.MapiMessage.SetReadFlag(readFlag);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotSetReadFlags, ex, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("ReplyForwardCommon::ctor.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotSetReadFlags, ex2, session, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("ReplyForwardCommon::ctor.", new object[0]),
ex2
});
}
finally
{
try
{
if (session != null)
{
session.EndMapiCall();
if (flag)
{
session.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
}
catch (StoragePermanentException)
{
}
catch (StorageTransientException)
{
}
}
(this.originalItem as MessageItem).IsRead = true;
}
else if (this.originalItem is CalendarItemOccurrence)
{
this.parentPropValues[ParentPropertyIndex.IsRecurring] = true;
this.parentPropValues[ParentPropertyIndex.AppointmentRecurring] = false;
this.parentPropValues[ParentPropertyIndex.RecurrenceType] = 0;
this.parentPropValues[ParentPropertyIndex.TimeZoneBlob] = new PropertyError(InternalSchema.TimeZoneBlob, PropertyErrorCode.NotFound);
this.parentPropValues[ParentPropertyIndex.AppointmentRecurrenceBlob] = new PropertyError(InternalSchema.AppointmentRecurrenceBlob, PropertyErrorCode.NotFound);
this.parentPropValues[ParentPropertyIndex.IsException] = true;
if (string.IsNullOrEmpty(this.parentPropValues[ParentPropertyIndex.RecurrencePattern] as string))
{
CalendarItemOccurrence calendarItemOccurrence = this.originalItem as CalendarItemOccurrence;
this.parentPropValues[ParentPropertyIndex.RecurrencePattern] = calendarItemOccurrence.OccurrencePropertyBag.MasterCalendarItem.GenerateWhen();
}
}
string valueOrDefault = originalItem.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
this.originalItemSigned = (ObjectClass.IsOfClass(valueOrDefault, "IPM.Note.Secure.Sign") || ObjectClass.IsSmimeClearSigned(valueOrDefault));
if (!this.originalItemSigned)
{
this.originalItemEncrypted = (ObjectClass.IsOfClass(valueOrDefault, "IPM.Note.Secure") || ObjectClass.IsSmime(valueOrDefault));
}
string valueOrDefault2 = originalItem.GetValueOrDefault <string>(InternalSchema.ContentClass, string.Empty);
this.originalItemIrm = ObjectClass.IsRightsManagedContentClass(valueOrDefault2);
}
internal ReplyCreation(Item originalItem, Item newItem, ReplyForwardConfiguration parameters, bool isReplyAll, bool shouldUseSender, bool decodeSmime) : base(originalItem, newItem, parameters, decodeSmime)
{
this.Initialize(originalItem, isReplyAll, shouldUseSender);
}
public MessageItem CreateReplyAll(MailboxSession session, StoreId parentFolderId, ReplyForwardConfiguration configuration)
{
this.CheckDisposed("CreateReplyAll");
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(parentFolderId, "parentFolderId");
Util.ThrowOnNullArgument(configuration, "configuration");
return(base.InternalCreateReplyAll(session, parentFolderId, configuration));
}
public override MessageItem CreateReplyAll(MailboxSession session, StoreId parentFolderId, ReplyForwardConfiguration configuration)
{
this.CheckDisposed("CreateReplyAll");
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(parentFolderId, "parentFolderId");
Util.ThrowOnNullArgument(configuration, "configuration");
ExTraceGlobals.StorageTracer.Information((long)this.GetHashCode(), "RightsManagedMessageItem::CreateReplyAll.");
if (this.decodedItem == null)
{
return(base.CreateReplyAll(session, parentFolderId, configuration));
}
this.CheckPermission(ContentRight.ReplyAll);
return(this.CreateReplyForwardInternal(session, parentFolderId, configuration, delegate(RightsManagedMessageItem original, RightsManagedMessageItem result, ReplyForwardConfiguration configurationPassed)
{
RightsManagedReplyCreation rightsManagedReplyCreation = new RightsManagedReplyCreation(original, result, configurationPassed, true);
rightsManagedReplyCreation.PopulateProperties();
}));
}
private static void GenerateHeader(ReplyForwardConfiguration replyForwardConfiguration, Item originalItem)
{
ReplyForwardHeader.CreateForwardReplyHeader(replyForwardConfiguration, originalItem, RuleMessageUtils.headerOptions);
}
public static MessageItem CreateForward(MessageItem originalItem, bool asAttachment, CultureInfo culture, string imceaDomain, string xLoop, ExTimeZone timeZone, IRuleEvaluationContext context)
{
Util.ThrowOnNullArgument(originalItem, "originalItem");
Util.ThrowOnNullArgument(culture, "culture");
Util.ThrowOnNullOrEmptyArgument(imceaDomain, "imceaDomain");
ExTraceGlobals.StorageTracer.Information(0L, "RuleMessageUtils::CreateForward.");
MessageItem messageItem = null;
bool flag = false;
MessageItem result;
try
{
ForwardCreationFlags forwardCreationFlags = ForwardCreationFlags.None;
string className = originalItem.ClassName;
if (ObjectClass.IsMeetingMessage(className))
{
forwardCreationFlags |= ForwardCreationFlags.TreatAsMeetingMessage;
}
messageItem = context.CreateMessageItem(InternalSchema.ContentConversionProperties);
messageItem[InternalSchema.ItemClass] = "IPM.Note";
StoreSession storeSession = context.StoreSession ?? originalItem.Session;
if (asAttachment)
{
ForwardAsAttachmentCreation forwardAsAttachmentCreation = new ForwardAsAttachmentCreation(originalItem, messageItem, new ReplyForwardConfiguration(forwardCreationFlags, culture)
{
XLoop = xLoop,
TimeZone = timeZone,
ConversionOptionsForSmime = new InboundConversionOptions(storeSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), imceaDomain)
});
forwardAsAttachmentCreation.PopulateProperties();
}
else
{
bool flag2 = ObjectClass.IsMeetingCancellation(className);
bool flag3 = ObjectClass.IsMeetingRequest(className);
bool isRestricted = originalItem.IsRestricted;
if (flag2)
{
messageItem[InternalSchema.ItemClass] = "IPM.Schedule.Meeting.Canceled";
messageItem[InternalSchema.IconIndex] = IconIndex.AppointmentMeetCancel;
}
else if (flag3)
{
messageItem[InternalSchema.ItemClass] = "IPM.Schedule.Meeting.Request";
messageItem[InternalSchema.IsResponseRequested] = true;
messageItem[InternalSchema.IsReplyRequested] = true;
}
else if (isRestricted)
{
messageItem[StoreObjectSchema.ContentClass] = "rpmsg.message";
messageItem.IconIndex = IconIndex.MailIrm;
}
BodyFormat format = originalItem.Body.Format;
ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(format, forwardCreationFlags, culture);
replyForwardConfiguration.XLoop = xLoop;
replyForwardConfiguration.TimeZone = timeZone;
replyForwardConfiguration.ConversionOptionsForSmime = new InboundConversionOptions(storeSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), imceaDomain);
RuleMessageUtils.GenerateHeader(replyForwardConfiguration, originalItem);
ForwardCreation forwardCreation = new ForwardCreation(originalItem, messageItem, replyForwardConfiguration);
forwardCreation.PopulateProperties();
if (flag2 || flag3)
{
AppointmentStateFlags appointmentStateFlags = messageItem.GetValueOrDefault <AppointmentStateFlags>(InternalSchema.AppointmentState);
appointmentStateFlags |= (AppointmentStateFlags.Meeting | AppointmentStateFlags.Received);
messageItem[InternalSchema.AppointmentState] = appointmentStateFlags;
int num = messageItem.GetValueOrDefault <int>(InternalSchema.AppointmentAuxiliaryFlags, 0);
num |= 4;
messageItem[InternalSchema.AppointmentAuxiliaryFlags] = num;
if (flag3)
{
List <BlobRecipient> list = BlobRecipientParser.ReadRecipients(originalItem, InternalSchema.UnsendableRecipients);
list = MeetingRequest.FilterBlobRecipientList(list);
list = MeetingRequest.MergeRecipientLists(originalItem.Recipients, list);
list = MeetingRequest.FilterBlobRecipientList(list);
BlobRecipientParser.WriteRecipients(messageItem, InternalSchema.UnsendableRecipients, list);
}
}
}
flag = true;
result = messageItem;
}
finally
{
if (!flag && messageItem != null)
{
messageItem.Dispose();
messageItem = null;
}
}
return(result);
}
internal RuleReplyCreation(MessageItem originalItem, MessageItem newItem, MessageItem template, ReplyForwardConfiguration configuration) : this(originalItem, newItem, template, configuration, false)
{
}
internal RuleReplyCreation(MessageItem originalItem, MessageItem newItem, MessageItem template, ReplyForwardConfiguration configuration, bool shouldUseSender) : base(originalItem, newItem, configuration, false, shouldUseSender, false)
{
this.template = template;
}
protected override void ValidateForwardArguments(MailboxSession session, StoreObjectId parentFolderId, ReplyForwardConfiguration replyForwardParameters)
{
base.ValidateForwardArguments(session, parentFolderId, replyForwardParameters);
if (!this.IsForwardAllowed)
{
throw new InvalidOperationException("A forward can't be created on a read-only calendar item. Call MakeModifiedOccurrence() first.");
}
}
internal RightsManagedForwardCreation(RightsManagedMessageItem originalItem, RightsManagedMessageItem message, ReplyForwardConfiguration parameters) : base(originalItem, message, parameters)
{
}
internal RightsManagedReplyCreation(RightsManagedMessageItem originalItem, RightsManagedMessageItem message, ReplyForwardConfiguration parameters, bool isReplyAll) : base(originalItem, message, parameters, isReplyAll, false, true)
{
}
public static void CreateForwardReplyHeader(ReplyForwardConfiguration configuration, Item item, ForwardReplyHeaderOptions headerOptions = null)
{
if (!(item is MessageItem) && !(item is CalendarItemBase) && !(item is PostItem))
{
throw new ArgumentException("HTML reply forward headers can only be created for MessageItem, CalendarItemBase and PostItem");
}
if (headerOptions == null)
{
headerOptions = new ForwardReplyHeaderOptions();
}
CultureInfo cultureInfo = configuration.Culture ?? item.Session.InternalCulture;
if (item is PostItem)
{
ReplyForwardHeader.CreatePostReplyForwardHeader(configuration, item, headerOptions, cultureInfo);
}
IList <IRecipientBase> toRecipients = null;
IList <IRecipientBase> ccRecipients = null;
string from = string.Empty;
string sender = null;
string fromLabel = ClientStrings.FromColon.ToString(cultureInfo);
string toLabel = ClientStrings.ToColon.ToString(cultureInfo);
string ccLabel = ClientStrings.CcColon.ToString(cultureInfo);
bool isMeetingItem = ObjectClass.IsMeetingMessage(item.ClassName);
if (item is MessageItem)
{
MessageItem messageItem = (MessageItem)item;
if (messageItem.From != null)
{
from = messageItem.From.DisplayName;
}
if (messageItem.Sender != null)
{
sender = messageItem.Sender.DisplayName;
}
toRecipients = ReplyForwardHeader.GetMessageRecipientCollection(RecipientItemType.To, messageItem);
ccRecipients = ReplyForwardHeader.GetMessageRecipientCollection(RecipientItemType.Cc, messageItem);
}
else if (item is CalendarItemBase)
{
CalendarItemBase calendarItemBase = (CalendarItemBase)item;
if (calendarItemBase.Organizer != null)
{
from = calendarItemBase.Organizer.DisplayName;
}
toRecipients = ReplyForwardHeader.GetCalendarItemRecipientCollection(AttendeeType.Required, calendarItemBase);
ccRecipients = ReplyForwardHeader.GetCalendarItemRecipientCollection(AttendeeType.Optional, calendarItemBase);
}
BodyInjectionFormat bodyPrefixFormat;
string bodyPrefix;
switch (configuration.TargetFormat)
{
case BodyFormat.TextPlain:
bodyPrefixFormat = BodyInjectionFormat.Text;
bodyPrefix = ReplyForwardHeader.CreateTextReplyForwardHeader(item, headerOptions, fromLabel, from, sender, toLabel, ccLabel, toRecipients, ccRecipients, isMeetingItem, cultureInfo, configuration.TimeZone);
break;
case BodyFormat.TextHtml:
case BodyFormat.ApplicationRtf:
bodyPrefixFormat = BodyInjectionFormat.Html;
bodyPrefix = ReplyForwardHeader.CreateHtmlReplyForwardHeader(item, headerOptions, fromLabel, from, sender, toLabel, ccLabel, toRecipients, ccRecipients, isMeetingItem, cultureInfo, configuration.TimeZone);
break;
default:
throw new ArgumentException("Unsupported body format");
}
configuration.AddBodyPrefix(bodyPrefix, bodyPrefixFormat);
}
public override MessageItem CreateForward(MailboxSession session, StoreId parentFolderId, ReplyForwardConfiguration configuration)
{
this.CheckDisposed("CreateForward");
ExTraceGlobals.MeetingMessageTracer.Information <GlobalObjectId>((long)this.GetHashCode(), "Storage.MeetingMessage.CreateForward: GOID={0}", this.GlobalObjectId);
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(parentFolderId, "parentFolderId");
Util.ThrowOnNullArgument(configuration, "configuration");
MeetingRequest meetingRequest = null;
bool flag = false;
MessageItem result;
try
{
meetingRequest = (base.IsSeriesMessage ? MeetingRequest.CreateMeetingRequestSeries(session) : MeetingRequest.CreateMeetingRequest(session));
ForwardCreation forwardCreation = new ForwardCreation(this, meetingRequest, configuration);
forwardCreation.PopulateProperties();
meetingRequest.AdjustAppointmentStateFlagsForForward();
List <BlobRecipient> mergedRecipientList = this.GetMergedRecipientList();
meetingRequest.SetUnsendableRecipients(mergedRecipientList);
base.LocationIdentifierHelperInstance.SetLocationIdentifier(42485U, LastChangeAction.CreateForward);
flag = true;
result = meetingRequest;
}
finally
{
if (!flag && meetingRequest != null)
{
meetingRequest.Dispose();
meetingRequest = null;
}
}
return(result);
}
internal OofReplyCreation(MessageItem originalItem, MessageItem newItem, MessageItem template, ReplyForwardConfiguration configuration) : base(originalItem, newItem, configuration, false, true, true)
{
this.template = template;
}
internal ForwardAsAttachmentCreation(MessageItem originalItem, MessageItem message, ReplyForwardConfiguration configuration) : base(originalItem, message, configuration, true)
{
}
private RightsManagedMessageItem CreateReplyForwardInternal(MailboxSession session, StoreId parentFolderId, ReplyForwardConfiguration configuration, RightsManagedMessageItem.ReplyForwardCreationCall call)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(parentFolderId, "parentFolderId");
Util.ThrowOnNullArgument(configuration, "configuration");
if ((configuration.ForwardCreationFlags & (ForwardCreationFlags.PreserveSender | ForwardCreationFlags.TreatAsMeetingMessage)) != ForwardCreationFlags.None)
{
throw new InvalidOperationException("Invalid forward creation flags used.");
}
RightsManagedMessageItem result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
RightsManagedMessageItem rightsManagedMessageItem = RightsManagedMessageItem.Create(session, parentFolderId, this.options);
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
call(this, rightsManagedMessageItem, configuration);
rightsManagedMessageItem.CopyLicenseDataFrom(this);
disposeGuard.Success();
result = rightsManagedMessageItem;
}
return(result);
}
public PostItem ReplyToFolder(StoreId parentFolderId, ReplyForwardConfiguration configuration)
{
return(this.ReplyToFolder(base.Session, parentFolderId, configuration));
}
