public static void HasRoute(RouteCollection routes, string url, string body, BodyFormat bodyFormat, object expectations)
        {
            var propertyReader      = new PropertyReader();
            var expectedRouteValues = propertyReader.RouteValues(expectations);

            WebRouteAssert.HasRoute(routes, HttpMethod.Get, url, body, bodyFormat, expectedRouteValues);
        }
        public void ForwardEvent(StoreId id, ForwardEventParameters parameters, Event updateToEvent = null, int?seriesSequenceNumber = null, string occurrencesViewPropertiesBlob = null, CommandContext commandContext = null)
        {
            using (ICalendarItemBase calendarItemBase = this.Bind(id))
            {
                if (updateToEvent != null)
                {
                    calendarItemBase.OpenAsReadWrite();
                    this.UpdateOnly(updateToEvent, calendarItemBase, base.GetSaveMode(updateToEvent.ChangeKey, commandContext));
                }
                CalendarItemBase calendarItemBase2 = (CalendarItemBase)calendarItemBase;
                BodyFormat       targetFormat      = BodyFormat.TextPlain;
                if (parameters != null && parameters.Notes != null)
                {
                    targetFormat = parameters.Notes.ContentType.ToStorageType();
                }
                ReplyForwardConfiguration replyForwardParameters = new ReplyForwardConfiguration(targetFormat)
                {
                    ShouldSuppressReadReceipt = false
                };
                MailboxSession mailboxSession = base.Session as MailboxSession;
                using (MessageItem messageItem = calendarItemBase2.CreateForward(mailboxSession, CalendarItemBase.GetDraftsFolderIdOrThrow(mailboxSession), replyForwardParameters, seriesSequenceNumber, occurrencesViewPropertiesBlob))
                {
                    EventWorkflowParametersTranslator <ForwardEventParameters, ForwardEventParametersSchema> .Instance.SetPropertiesFromEntityOnStorageObject(parameters, messageItem);

                    foreach (Recipient <RecipientSchema> recipient in parameters.Forwardees)
                    {
                        messageItem.Recipients.Add(new Participant(recipient.Name, recipient.EmailAddress, "SMTP"));
                    }
                    MeetingMessage.SendLocalOrRemote(messageItem, true, true);
                }
            }
        }
Exemple #3
0
        public VoculaPage GetPage(string site, string path, bool recursion, BodyFormat format)
        {
            path = this.Tools.NormalizePath(path);
            string     pageFile = this.SiteDirectory + Path.DirectorySeparatorChar + site + path + $"page.{this.Lang}.md";
            VoculaPage page     = this.GetPage(pageFile);

            page.Path       = path;
            page.Breadcrumb = this.GetBreadcrumb(site, path);
            page.Body       = this.GetPageBody(site, path, pageFile, format);
            if (Directory.Exists(this.SiteDirectory + Path.DirectorySeparatorChar + site + path))
            {
                page.Alternatives = this.Tools.GetAlternatives(Array.FindAll(Directory.GetFiles(this.SiteDirectory + Path.DirectorySeparatorChar + site + path, "*.md"), x => x.Like($"%{Path.DirectorySeparatorChar}page.%.md")));
            }

            // Load subpages
            page.Children = new List <VoculaPage>();
            string fullPath = this.SiteDirectory + Path.DirectorySeparatorChar + site + path;

            if (recursion)
            {
                if (Directory.Exists(@fullPath))
                {
                    string[] dirs = Directory.GetDirectories(@fullPath);
                    foreach (string dir in dirs)
                    {
                        page.Children.Add(this.GetPage(site, dir.Replace(this.SiteDirectory + Path.DirectorySeparatorChar + site, "") + Path.DirectorySeparatorChar, recursion, BodyFormat.None));
                    }
                    page.Children.Sort((x, y) => DateTime.Compare(x.Date, y.Date));
                }
            }
            return(page);
        }
Exemple #4
0
        private void RestampItemCharset(Charset targetCharset, MemoryStream cachedHtml, Charset htmlCharsetDetectedFromMetaTag = null)
        {
            Charset    charset   = htmlCharsetDetectedFromMetaTag ?? ConvertUtils.GetItemMimeCharset(this.coreItem.PropertyBag);
            BodyFormat rawFormat = this.coreItem.Body.RawFormat;

            if (rawFormat == BodyFormat.TextHtml)
            {
                using (MemoryStream memoryStream = cachedHtml ?? this.LoadHtmlBodyInMemory())
                {
                    memoryStream.Position = 0L;
                    using (Stream stream = this.coreItem.Body.InternalOpenBodyStream(InternalSchema.HtmlBody, PropertyOpenMode.Create))
                    {
                        using (Stream stream2 = new ConverterStream(stream, new HtmlToHtml
                        {
                            InputEncoding = charset.GetEncoding(),
                            OutputEncoding = targetCharset.GetEncoding(),
                            DetectEncodingFromMetaTag = false
                        }, ConverterStreamAccess.Write))
                        {
                            Util.StreamHandler.CopyStreamData(memoryStream, stream2);
                        }
                    }
                }
            }
            this.SetItemCharset(targetCharset);
        }
Exemple #5
0
        protected override WorkState Do(WorkState currentWorkState)
        {
            this.CheckRequiredProperties();

            WorkState result = new WorkState(this)
            {
                Status            = Status.Succeeded,
                PreviousWorkState = currentWorkState
            };

            object formatValues = new
            {
                JobName  = Job.Name.Or("[JobName Not Set]"),
                WorkName = Job.CurrentWorkerName.Or("[WorkName Not Specified]"),
                Status   = Job.CurrentWorkState.Status.ToString(),
                Message  = Job.CurrentWorkState.Message.Or("&nbsp;")
            };

            Email email = new Email();

            email.Server(SmtpHost)
            .Port(int.Parse(Port))
            .IsBodyHtml(_isBodyHtml)
            .From(From)
            .To(Recipients.DelimitSplit(",", ";"))
            .Subject(SubjectFormat.NamedFormat(formatValues))
            .Body(BodyFormat.NamedFormat(formatValues))
            .UserName(UserName)
            .Password(Password)
            .EnableSsl(_enableSsl)
            .Send();

            return(result);
        }
 protected static void CheckRtf(BodyFormat sourceFormat, BodyFormat targetFormat)
 {
     if (targetFormat == BodyFormat.ApplicationRtf && sourceFormat == BodyFormat.TextPlain)
     {
         throw new InvalidOperationException(ServerStrings.ExBodyFormatConversionNotSupported(sourceFormat.ToString() + "->" + targetFormat.ToString()));
     }
 }
        private static BodyWriteConfiguration CreateBodyWriteConfiguration(BodyFormat bf)
        {
            BodyWriteConfiguration bodyWriteConfiguration = new BodyWriteConfiguration(bf, "utf-8");

            bodyWriteConfiguration.SetTargetFormat(bf, "utf-8", BodyCharsetFlags.DisableCharsetDetection);
            return(bodyWriteConfiguration);
        }
Exemple #8
0
        private void WriteMessageBody()
        {
            this.limitsTracker.CountMessageBody();
            BodyFormat rawFormat = this.item.Body.RawFormat;
            long       bodySize  = 0L;

            if (rawFormat == BodyFormat.TextHtml)
            {
                this.WriteMessageProperty(InternalSchema.HtmlBody, out bodySize);
                this.conversionResult.BodySize = bodySize;
                return;
            }
            this.WriteMessageProperty(InternalSchema.RtfSyncBodyCrc);
            this.WriteMessageProperty(InternalSchema.RtfSyncBodyCount);
            this.WriteMessageProperty(InternalSchema.RtfSyncBodyTag);
            this.WriteMessageProperty(InternalSchema.RtfInSync);
            this.WriteMessageProperty(InternalSchema.RtfSyncPrefixCount);
            this.WriteMessageProperty(InternalSchema.RtfSyncTrailingCount);
            if (rawFormat == BodyFormat.ApplicationRtf)
            {
                this.WriteMessageProperty(InternalSchema.RtfBody, out bodySize);
                this.conversionResult.BodySize = bodySize;
                return;
            }
            if (rawFormat == BodyFormat.TextPlain)
            {
                if (!this.item.Body.IsBodyDefined)
                {
                    return;
                }
                using (Stream textStream = this.item.OpenPropertyStream(InternalSchema.TextBody, PropertyOpenMode.ReadOnly))
                {
                    if (this.tnefType == TnefType.SummaryTnef)
                    {
                        using (Stream stream = this.tnefWriter.StartStreamProperty(InternalSchema.TextBody))
                        {
                            this.conversionResult.BodySize = Util.StreamHandler.CopyStreamData(textStream, stream);
                        }
                        textStream.Position = 0L;
                    }
                    using (Stream tnefStream = this.tnefWriter.StartStreamProperty(InternalSchema.RtfBody))
                    {
                        int inCodePage = this.item.Body.RawCharset.CodePage;
                        ConvertUtils.CallCts(ExTraceGlobals.CcOutboundTnefTracer, "ItemToTnefConverter::WriteMessageBody", ServerStrings.ConversionBodyConversionFailed, delegate
                        {
                            TextToRtf textToRtf     = new TextToRtf();
                            textToRtf.InputEncoding = Charset.GetEncoding(inCodePage);
                            using (Stream stream2 = new ConverterStream(textStream, textToRtf, ConverterStreamAccess.Read))
                            {
                                using (ConverterStream converterStream = new ConverterStream(stream2, new RtfToRtfCompressed(), ConverterStreamAccess.Read))
                                {
                                    Util.StreamHandler.CopyStreamData(converterStream, tnefStream);
                                }
                            }
                        });
                    }
                }
            }
        }
 internal static HeaderFooterFormat GetSupportedPrefixFormat(BodyFormat format)
 {
     if (format != BodyFormat.TextPlain)
     {
         return(HeaderFooterFormat.Html);
     }
     return(HeaderFooterFormat.Text);
 }
        // Token: 0x06001C01 RID: 7169 RVA: 0x0006D934 File Offset: 0x0006BB34
        private static void SetItemBody(Item item, BodyFormat bodyFormat, string bodyContent)
        {
            BodyWriteConfiguration configuration = new BodyWriteConfiguration(bodyFormat);

            using (TextWriter textWriter = item.Body.OpenTextWriter(configuration))
            {
                textWriter.Write(bodyContent);
            }
        }
Exemple #11
0
        private IList <RouteValue> ReadPropertiesFromBodyContent(BodyFormat bodyFormat)
        {
            var bodyTask = request.Content.ReadAsStringAsync();
            var body     = bodyTask.Result;

            var bodyReader = new BodyReader();

            return(bodyReader.ReadBody(body, bodyFormat));
        }
 private void Init(string phoneNumber, TelcomProvider provider, BodyFormat bodyFormat = BodyFormat.Sms)
 {
     if (phoneNumber.Length != 10)
     {
         throw new Exception("phoneNumber must be length 10");
     }
     PhoneNumber = phoneNumber;
     Provider    = provider;
     BodyFormat  = bodyFormat;
 }
 public void SetTargetFormat(BodyFormat targetFormat, Charset targetCharset, BodyCharsetFlags flags)
 {
     EnumValidator.ThrowIfInvalid <BodyFormat>(targetFormat, "targetFormat");
     if (targetCharset == null && (flags & BodyCharsetFlags.CharsetDetectionMask) == BodyCharsetFlags.DisableCharsetDetection)
     {
         throw new ArgumentNullException("targetCharset");
     }
     this.targetCharset      = targetCharset;
     this.targetFormat       = targetFormat;
     this.targetCharsetFlags = flags;
 }
        // Token: 0x06002EFA RID: 12026 RVA: 0x0010E534 File Offset: 0x0010C734
        private void ProcessApprovalResponse(bool isEdit)
        {
            MessageItem requestItem;
            MessageItem messageItem = requestItem = base.GetRequestItem <MessageItem>(ReadMessageEventHandler.ApprovalPrefetchProperties);

            try
            {
                if (!Utilities.IsValidUndecidedApprovalRequest(messageItem))
                {
                    throw new OwaInvalidRequestException("The approval request was invalid or was already decided");
                }
                string[] array = (string[])messageItem.VotingInfo.GetOptionsList();
                string   text  = (string)base.GetParameter("Vt");
                if (string.IsNullOrEmpty(text))
                {
                    throw new OwaInvalidRequestException("The approval vote was not supplied.");
                }
                if (array == null || Array.IndexOf <string>(array, text) == -1)
                {
                    throw new OwaInvalidRequestException("The attempted approval vote was invalid for the approval request.");
                }
                BodyFormat       replyForwardBodyFormat = ReplyForwardUtilities.GetReplyForwardBodyFormat(messageItem, base.UserContext);
                OwaStoreObjectId owaStoreObjectId       = (OwaStoreObjectId)base.GetParameter("fId");
                MessageItem      messageItem3;
                MessageItem      messageItem2 = messageItem3 = messageItem.CreateVotingResponse(string.Empty, replyForwardBodyFormat, base.UserContext.TryGetMyDefaultFolderId(DefaultFolderType.Drafts), text);
                try
                {
                    messageItem2.Save(SaveMode.ResolveConflicts);
                    messageItem2.Load();
                    if (!isEdit)
                    {
                        messageItem2.Send();
                    }
                    else
                    {
                        base.WriteNewItemId(messageItem2);
                    }
                }
                finally
                {
                    if (messageItem3 != null)
                    {
                        ((IDisposable)messageItem3).Dispose();
                    }
                }
            }
            finally
            {
                if (requestItem != null)
                {
                    ((IDisposable)requestItem).Dispose();
                }
            }
        }
        public void SetTargetFormat(BodyFormat targetFormat, string targetCharsetName, BodyCharsetFlags flags)
        {
            EnumValidator.ThrowIfInvalid <BodyFormat>(targetFormat, "targetFormat");
            Charset charset = null;

            if (!string.IsNullOrEmpty(targetCharsetName))
            {
                charset = ConvertUtils.GetCharsetFromCharsetName(targetCharsetName);
            }
            this.SetTargetFormat(targetFormat, charset, flags);
        }
 internal ReplyForwardConfiguration(BodyFormat targetFormat, ForwardCreationFlags flags, CultureInfo culture)
 {
     EnumValidator.ThrowIfInvalid <BodyFormat>(targetFormat, "targetFormat");
     EnumValidator.ThrowIfInvalid <ForwardCreationFlags>(flags, "flags");
     this.targetFormat         = targetFormat;
     this.forwardCreationFlags = flags;
     this.culture             = culture;
     this.bodyPrefix          = null;
     this.conversionCallbacks = null;
     this.subjectPrefix       = null;
 }
Exemple #17
0
 /// <summary>
 /// Gets the hash code
 /// </summary>
 /// <returns>Returns HashCode</returns>
 public override int GetHashCode()
 {
     return(String.Format("{0}|{1}|{2}|{3}|{4}|{5}|",
                          this.Parameters.Aggregate(0, (acc, next) => acc += next.GetHashCode()),
                          Kind.GetHashCode(),
                          Url?.GetHashCode() ?? 0,
                          Method.GetHashCode(),
                          BodyFormat.GetHashCode(),
                          Async.GetHashCode()
                          ).GetHashCode());
 }
Exemple #18
0
 private AipHttpRequest()
 {
     Headers = new Dictionary <string, string>();
     // 所有Url中附带aipSdk=CSharp参数
     Querys = new Dictionary <string, string> {
         { "aipSdk", "CSharp" }
     };
     Bodys           = new Dictionary <string, object>();
     Method          = "GET";
     BodyType        = BodyFormat.Formed;
     ContentEncoding = Encoding.UTF8;
 }
 public BodyReadConfiguration(BodyFormat targetFormat)
 {
     EnumValidator.ThrowIfInvalid <BodyFormat>(targetFormat, "targetFormat");
     this.format             = targetFormat;
     this.charset            = null;
     this.injectPrefix       = null;
     this.injectSuffix       = null;
     this.injectFormat       = BodyInjectionFormat.Text;
     this.conversionCallback = null;
     this.htmlFlags          = HtmlStreamingFlags.None;
     this.styleSheetLimit    = null;
 }
Exemple #20
0
 private AipHttpRequest()
 {
     Headers = new Dictionary <string, string>();
     // 所有Url中附带aipSdk=CSharp参数
     Querys = new Dictionary <string, string> {
         { "aipSdk", "CSharp" }
     };
     Bodys           = new Dictionary <string, object>();
     Method          = "GET";
     BodyType        = BodyFormat.Formed;
     ContentEncoding = Encoding.UTF8;
     System.Net.ServicePointManager.Expect100Continue = false;
 }
 public BodyWriteConfiguration(BodyFormat sourceFormat, Charset sourceCharset)
 {
     EnumValidator.ThrowIfInvalid <BodyFormat>(sourceFormat, "sourceFormat");
     this.sourceFormat       = sourceFormat;
     this.sourceCharset      = sourceCharset;
     this.targetFormat       = this.sourceFormat;
     this.targetCharset      = this.sourceCharset;
     this.targetCharsetFlags = BodyCharsetFlags.None;
     this.injectPrefix       = null;
     this.injectSuffix       = null;
     this.injectFormat       = BodyInjectionFormat.Text;
     this.htmlFlags          = HtmlStreamingFlags.None;
 }
Exemple #22
0
        public PreFormActionResponse Execute(OwaContext owaContext, out ApplicationElement applicationElement, out string type, out string state, out string action)
        {
            if (owaContext == null)
            {
                throw new ArgumentNullException("owaContext");
            }
            applicationElement = ApplicationElement.Item;
            type   = string.Empty;
            action = string.Empty;
            state  = string.Empty;
            PreFormActionResponse preFormActionResponse = new PreFormActionResponse();
            Item item  = null;
            Item item2 = null;
            Item item3 = null;

            try
            {
                HttpContext httpContext          = owaContext.HttpContext;
                UserContext userContext          = owaContext.UserContext;
                string      queryStringParameter = Utilities.GetQueryStringParameter(httpContext.Request, "fId", true);
                item = ReplyForwardUtilities.GetItemForRequest(owaContext, out item2);
                BodyFormat replyForwardBodyFormat = ReplyForwardUtilities.GetReplyForwardBodyFormat(item, userContext);
                item3 = ReplyForwardUtilities.CreatePostReplyItem(replyForwardBodyFormat, item as PostItem, userContext, Utilities.GetParentFolderId(item2, item));
                item3.Save(SaveMode.ResolveConflicts);
                item3.Load();
                preFormActionResponse.ApplicationElement = ApplicationElement.Item;
                preFormActionResponse.Type   = "IPM.Post";
                preFormActionResponse.Action = "PostReply";
                preFormActionResponse.AddParameter("Id", OwaStoreObjectId.CreateFromStoreObject(item3).ToBase64String());
                preFormActionResponse.AddParameter("fId", queryStringParameter);
            }
            finally
            {
                if (item != null)
                {
                    item.Dispose();
                    item = null;
                }
                if (item2 != null)
                {
                    item2.Dispose();
                    item2 = null;
                }
                if (item3 != null)
                {
                    item3.Dispose();
                    item3 = null;
                }
            }
            return(preFormActionResponse);
        }
        internal static ItemBody GetEntityBody(this IItem input, char[] buffer)
        {
            Body     body;
            BodyType bodyType;

            try
            {
                body = IrmUtils.GetBody(input);
                BodyFormat format = body.Format;
                bodyType = format.ToEntityType();
            }
            catch (PropertyErrorException ex)
            {
                ExTraceGlobals.CommonTracer.TraceDebug <string, string>(0L, "[BodyConverter::GetEntityBody] Encountered exception - Class: {0}; Message: {1}", ex.GetType().FullName, ex.Message);
                throw new CorruptDataException(Strings.ErrorItemCorrupt, ex);
            }
            catch (StoragePermanentException ex2)
            {
                if (ex2.InnerException is MapiExceptionNoSupport)
                {
                    throw new CorruptDataException(Strings.ErrorItemCorrupt, ex2);
                }
                ExTraceGlobals.CommonTracer.TraceDebug(0L, "[BodyConverter::GetEntityBody] Encountered exception - Class: {0}, Message: {1} Inner exception was not MapiExceptionNoSupport but rather Class: {2}; Message: {3}", new object[]
                {
                    ex2.GetType().FullName,
                    ex2.Message,
                    (ex2.InnerException == null) ? "<NULL>" : ex2.InnerException.GetType().FullName,
                    (ex2.InnerException == null) ? "<NULL>" : ex2.InnerException.Message
                });
                throw;
            }
            ItemBody itemBody = new ItemBody
            {
                ContentType = bodyType
            };

            using (TextWriter textWriter = new StringWriter())
            {
                if (bodyType == BodyType.Html)
                {
                    BodyConverter.WriteHtmlContent(textWriter, input, buffer);
                }
                else
                {
                    BodyConverter.WriteTextContent(textWriter, body, buffer);
                }
                itemBody.Content = textWriter.ToString();
            }
            return(itemBody);
        }
Exemple #24
0
        internal static string GetItemBody(Item item, BodyFormat desiredFormat)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            string result;

            using (TextReader textReader = item.Body.OpenTextReader(desiredFormat))
            {
                result = textReader.ReadToEnd();
            }
            return(result);
        }
        internal static BodyType ToEntityType(this BodyFormat input)
        {
            switch (input)
            {
            case BodyFormat.TextPlain:
                return(BodyType.Text);

            case BodyFormat.TextHtml:
            case BodyFormat.ApplicationRtf:
                return(BodyType.Html);

            default:
                throw new ArgumentOutOfRangeException("input");
            }
        }
        public static EmailMessage Create(BodyFormat bodyFormat, bool createAlternative, string charsetName)
        {
            if (bodyFormat != BodyFormat.Text && bodyFormat != BodyFormat.Html)
            {
                throw new ArgumentException(EmailMessageStrings.CannotCreateSpecifiedBodyFormat(bodyFormat.ToString()));
            }
            if (bodyFormat == BodyFormat.Text && createAlternative)
            {
                throw new ArgumentException(EmailMessageStrings.CannotCreateAlternativeBody);
            }
            Charset.GetCharset(charsetName);
            MimeTnefMessage mimeTnefMessage = new MimeTnefMessage(bodyFormat, createAlternative, charsetName);

            return(new EmailMessage(mimeTnefMessage));
        }
        private void SyncNotes(ContactItemType remoteItem, Contact localItem)
        {
            string     text       = string.Empty;
            BodyFormat bodyFormat = BodyFormat.TextPlain;

            if (remoteItem.Body != null)
            {
                text       = remoteItem.Body.Value;
                bodyFormat = this.Convert(remoteItem.Body.BodyType1);
                ItemSynchronizer.Tracer.TraceDebug <ContactItemSynchronizer, string>((long)this.GetHashCode(), "{0}: Copying body: {1}", this, text);
            }
            using (TextWriter textWriter = localItem.Body.OpenTextWriter(bodyFormat))
            {
                textWriter.Write(text);
            }
        }
        internal static void HasRoute(RouteCollection routes, HttpMethod method, string url, string body, BodyFormat bodyFormat, RouteValues expectedProps)
        {
            var pathUrl = UrlHelpers.PrependTilde(url);
            var httpContext = HttpMockery.ContextForUrl(method, pathUrl, body);
            var routeData = GetRouteDataWithAttributeFilter(routes, httpContext);

            if (routeData == null)
            {
                var message = string.Format("Should have found the route to '{0}'", url);
                Asserts.Fail(message);
            }

            var webRouteReader = new Reader();
            var actualProps = webRouteReader.GetRequestProperties(routeData, httpContext.Request, bodyFormat);
            var verifier = new Verifier(expectedProps, actualProps, url);
            verifier.VerifyExpectations();
        }
Exemple #29
0
        internal static StorePropertyDefinition GetBodyProperty(BodyFormat bodyFormat)
        {
            switch (bodyFormat)
            {
            case BodyFormat.TextPlain:
                return(InternalSchema.TextBody);

            case BodyFormat.TextHtml:
                return(InternalSchema.HtmlBody);

            case BodyFormat.ApplicationRtf:
                return(InternalSchema.RtfBody);

            default:
                throw new ArgumentOutOfRangeException("bodyFormat", string.Format("Invalid body format: {0}.", bodyFormat));
            }
        }
Exemple #30
0
        private static string CreatePostReplyForwardHeader(BodyFormat bodyFormat, Item item, UserContext userContext, string postToFolderName)
        {
            PostItem postItem = item as PostItem;

            if (postItem == null)
            {
                throw new ArgumentException("OWA logic error . CreatePostReplyForwardheader is called on a non-PostItem item.");
            }
            if (postToFolderName == null)
            {
                throw new ArgumentNullException("postToFolderName");
            }
            if (string.Empty == postToFolderName)
            {
                throw new ArgumentException("postToFolderName should not be empty. ");
            }
            StringBuilder stringBuilder = new StringBuilder();
            bool          outputHtml    = BodyFormat.TextHtml == bodyFormat;

            if (postItem.Sender != null)
            {
                if (Utilities.IsOnBehalfOf(postItem.Sender, postItem.From))
                {
                    stringBuilder.Append(string.Format(LocalizedStrings.GetHtmlEncoded(-1426120402), ReplyForwardUtilities.GetParticipantDisplayString(postItem.Sender, outputHtml), ReplyForwardUtilities.GetParticipantDisplayString(postItem.From, outputHtml)));
                }
                else
                {
                    ReplyForwardUtilities.AppendParticipantDisplayString(postItem.Sender, stringBuilder, outputHtml);
                }
            }
            string fromLabel = string.Empty;

            switch (bodyFormat)
            {
            case BodyFormat.TextPlain:
                fromLabel = LocalizedStrings.GetNonEncoded(-1376223345);
                return(ReplyForwardUtilities.CreatePostTextReplyForwardHeader(postItem, userContext, fromLabel, stringBuilder.ToString(), postToFolderName));

            case BodyFormat.TextHtml:
                fromLabel = LocalizedStrings.GetHtmlEncoded(-1376223345);
                return(ReplyForwardUtilities.CreatePostHtmlReplyForwardHeader(postItem, userContext, fromLabel, stringBuilder.ToString(), postToFolderName));

            default:
                throw new ArgumentException("Unsupported body format");
            }
        }
Exemple #31
0
        public static Item CreatePostReplyItem(BodyFormat bodyFormat, PostItem item, UserContext userContext, StoreObjectId parentFolderId)
        {
            PostItem postItem = null;
            bool     flag     = true;

            try
            {
                string bodyPrefix = ReplyForwardUtilities.CreateReplyForwardHeader(bodyFormat, item, userContext, parentFolderId);
                string legacyDN   = null;
                OwaStoreObjectIdType owaStoreObjectIdType = Utilities.GetOwaStoreObjectIdType(userContext, item);
                if (owaStoreObjectIdType == OwaStoreObjectIdType.OtherUserMailboxObject)
                {
                    legacyDN = Utilities.GetMailboxSessionLegacyDN(item);
                }
                OwaStoreObjectId destinationFolderId        = OwaStoreObjectId.CreateFromFolderId(parentFolderId, owaStoreObjectIdType, legacyDN);
                OwaStoreObjectId scratchPadForImplicitDraft = Utilities.GetScratchPadForImplicitDraft(StoreObjectType.Post, destinationFolderId);
                try
                {
                    ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(bodyFormat);
                    replyForwardConfiguration.ConversionOptionsForSmime = Utilities.CreateInboundConversionOptions(userContext);
                    replyForwardConfiguration.AddBodyPrefix(bodyPrefix);
                    postItem = item.ReplyToFolder(scratchPadForImplicitDraft.GetSession(userContext), scratchPadForImplicitDraft.StoreObjectId, replyForwardConfiguration);
                }
                catch (StoragePermanentException ex)
                {
                    if (ex.InnerException is MapiExceptionNoCreateRight)
                    {
                        throw new OwaAccessDeniedException(LocalizedStrings.GetNonEncoded(995407892), ex);
                    }
                    throw ex;
                }
                ReplyForwardUtilities.CopyMessageClassificationProperties(item, postItem, userContext);
                Utilities.SetPostSender(postItem, userContext, Utilities.IsPublic(item));
                postItem.ConversationTopic = item.ConversationTopic;
                flag = false;
            }
            finally
            {
                if (flag && postItem != null)
                {
                    postItem.Dispose();
                    postItem = null;
                }
            }
            return(postItem);
        }
		public IList<RouteValue> ReadBody(string body, BodyFormat bodyFormat)
		{
			switch (bodyFormat)
			{
				case BodyFormat.FormUrl:
					var formUrlReader = new FormUrlBodyReader();
					return formUrlReader.ReadBody(body);

				case BodyFormat.Json:
					var jsonReader = new JsonBodyReader();
					return jsonReader.ReadBody(body);

				case BodyFormat.None:
					return new List<RouteValue>();

				default:
					throw new ApplicationException("Unknown body format: " + bodyFormat);
			}
		}
Exemple #33
0
        public RouteValues GetRequestProperties(RouteData routeData, HttpRequestBase request, BodyFormat bodyFormat)
        {
            RouteValues result;

            if (routeData == null)
            {
                result = new RouteValues();
            }
            else
            {
                result = new RouteValues(routeData.Values);
            }

            var requestParams = ReadRequestParams(request.Params);
            result.AddRange(requestParams);

            var bodyContent = ReadPropertiesFromBodyContent(request, bodyFormat);
            result.AddRange(bodyContent);

            result.Area = ReadAreaFromRouteData(routeData);
            return result;
        }
Exemple #34
0
 public MimeBody(BodyFormat format)
 {
     this._format = format;
 }
 public static void HasApiRoute(HttpConfiguration config, string url, HttpMethod httpMethod,
     string body, BodyFormat bodyFormat, object expectations)
 {
     HasApiRoute(config, url, httpMethod, null, body, bodyFormat, expectations);
 }
Exemple #36
0
 public static IAsyncResult BeginQuickDirectSend(string from, string to, string subject, string body, BodyFormat bodyFormat, string attachmentPath, AsyncCallback callback)
 {
     SmtpClient._delegateQuickDirectSendAttach = SmtpClient.QuickDirectSend;
     return SmtpClient._delegateQuickDirectSendAttach.BeginInvoke(from, to, subject, body, bodyFormat, attachmentPath, callback, SmtpClient._delegateQuickDirectSendAttach);
 }
 public static void HasRoute(RouteCollection routes, string url, string body, BodyFormat bodyFormat, object expectations)
 {
     var propertyReader = new PropertyReader();
     var expectedRouteValues = propertyReader.RouteValues(expectations);
     WebRouteAssert.HasRoute(routes, HttpMethod.Get, url, body, bodyFormat, expectedRouteValues);
 }
 /// <summary>
 /// Creates the body template based on the specified content and format.
 /// </summary>
 /// <param name="content">The content.</param>
 /// <param name="format">The format to use.</param>
 public BodyTemplate(string content, BodyFormat format)
 {
     _content = content;
     _format = format;
 }
 public static void HasRoute(RouteCollection routes, string url, HttpMethod httpMethod, string body, BodyFormat bodyFormat, IDictionary<string, string> expectedProps)
 {
     var expectedRouteValues = new RouteValues(expectedProps);
     WebRouteAssert.HasRoute(routes, httpMethod, url, body, bodyFormat, expectedRouteValues);
 }
 public static void HasApiRoute(HttpConfiguration config, string url, HttpMethod httpMethod, string body, BodyFormat bodyFormat,  IDictionary<string, string> expectedProps)
 {
     var expectedRouteValues = new RouteValues(expectedProps);
     ApiRouteAssert.HasRoute(config, url, httpMethod, body, bodyFormat, expectedRouteValues);
 }
        public static void HasApiRoute(HttpConfiguration config, string url, HttpMethod httpMethod, string body, BodyFormat bodyFormat, object expectations)
        {
            var propertyReader = new PropertyReader();
            var expectedProps = propertyReader.RouteValues(expectations);

            ApiRouteAssert.HasRoute(config, url, httpMethod, body, bodyFormat, expectedProps);
        }
Exemple #42
0
 private IList<RouteValue> ReadPropertiesFromBodyContent(HttpRequestBase request, BodyFormat bodyFormat)
 {
     var body = GetRequestBody(request);
     var bodyReader = new BodyReader();
     return bodyReader.ReadBody(body, bodyFormat);
 }
Exemple #43
0
 /// <summary>
 /// This static method allows to send an email in 1 line of code.
 /// </summary>
 /// <param name="from">The email address of the person sending the message.</param>
 /// <param name="to">The email address of the message's recipient.</param>
 /// <param name="subject">The message's subject.</param>
 /// <param name="textBody">The text body of the message.</param>
 /// <param name="attachmentPath">The path to a file to be attached to the message.</param>
 /// <example>
 /// C#
 /// 
 /// SmtpClient.QuickDirectSend("*****@*****.**","*****@*****.**","Test","Hello this is a test!",BodyFormat.Text,"C:\\My Documents\\file.doc");
 ///
 /// VB.NET
 /// 
 /// SmtpClient.QuickDirectSend("*****@*****.**","*****@*****.**","Test","Hello this is a test!",BodyFormat.Text,"C:\My Documents\file.doc")
 /// 
 /// JScript.NET
 /// 
 /// SmtpClient.QuickDirectSend("*****@*****.**","*****@*****.**","Test","Hello this is a test!",BodyFormat.Text,"C:\\My Documents\\file.doc");
 /// </example>
 public static void QuickDirectSend(string from, string to, string subject, string body, BodyFormat bodyFormat, string attachmentPath)
 {
     ActiveUp.Net.Mail.SmtpClient.QuickSend(from, to, subject, body, bodyFormat, attachmentPath, string.Empty);
     /*ActiveUp.Net.Mail.Message message = new ActiveUp.Net.Mail.Message();
     //message.From.Add(new ActiveUp.Net.Mail.Address(from));
     message.From = new ActiveUp.Net.Mail.Address(from);
     message.To.Add(to);
     message.Subject = subject;
     if (bodyFormat == BodyFormat.Text)
         message.BodyText.Text = body;
     else
         message.BodyHtml.Text = body;
     if (!string.IsNullOrEmpty(attachmentPath))
         message.Attachments.Add(attachmentPath, false);
     message.DirectSend();*/
 }
 /// <summary>
 /// Creates the body template based on the specified content. The default format is Text.
 /// </summary>
 /// <param name="content">The content.</param>
 public BodyTemplate(string content)
 {
     _content = content;
     _format = BodyFormat.Text;
 }
		/// <summary>
		/// Add a templated body in the collection based on the specified content and body format.
		/// </summary>
		/// <param name="content">The content to use.</param>
		/// <param name="format">The message body format.</param>
		public void Add(string content, BodyFormat format)
		{
			List.Add(new BodyTemplate(content, format));
		}
 /// <summary>
 /// The default constructor.
 /// </summary>
 public BodyTemplate()
 {
     _content = string.Empty;
     _format = BodyFormat.Text;
 }
Exemple #47
-50
 /// <summary>
 /// This static method allows to send an email in 1 line of code.
 /// </summary>
 /// <param name="from">The email address of the person sending the message.</param>
 /// <param name="to">The email address of the message's recipient.</param>
 /// <param name="subject">The message's subject.</param>
 /// <param name="textBody">The text body of the message.</param>
 /// <example>
 /// C#
 /// 
 /// SmtpClient.QuickSend("*****@*****.**","*****@*****.**","Test","Hello this is a test!",BodyFormat.Text,"C:\\My Documents\\file.doc","mail.myhost.com");
 ///
 /// VB.NET
 /// 
 /// SmtpClient.QuickSend("*****@*****.**","*****@*****.**","Test","Hello this is a test!",BodyFormat.Text,"C:\My Documents\file.doc","mail.myhost.com")
 /// 
 /// JScript.NET
 /// 
 /// SmtpClient.QuickSend("*****@*****.**","*****@*****.**","Test","Hello this is a test!",BodyFormat.Text,"C:\\My Documents\\file.doc","mail.myhost.com");
 /// </example>
 public static void QuickSend(string from, string to, string subject, string body, BodyFormat bodyFormat, string attachmentPath, string smtpServer)
 {
     ActiveUp.Net.Mail.SmtpMessage message = new ActiveUp.Net.Mail.SmtpMessage();
     message.From = new ActiveUp.Net.Mail.Address(from);
     message.To.Add(to);
     message.Subject = subject;
     if (bodyFormat == BodyFormat.Text)
         message.BodyText.Text = body;
     else
         message.BodyHtml.Text = body;
     if (!string.IsNullOrEmpty(attachmentPath))
         message.Attachments.Add(attachmentPath, false);
     if (!string.IsNullOrEmpty(smtpServer))
         message.Send(smtpServer);
     else
         message.DirectSend();
 }