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)); }