Beispiel #1
0
        protected override bool DoSendMsg(Message msg)
        {
            if (msg == null || msg.TOAddress.IsNullOrWhiteSpace())
            {
                throw new WebException("TwilioSink.DoSendMsg(msg==null)");
            }

            if (msg.TOAddress.IsNullOrWhiteSpace())
            {
                throw new WebException("TwilioSink.DoSendMsg(msg.TOAddress==null)");
            }

            if (msg.Body.IsNullOrEmpty())
            {
                throw new WebException("TwilioSink.DoSendMsg(msg.body==null");
            }

            var addressees =
                msg.MessageAddress.All.Where(a => SupportedChannelNames.Any(n => n.EqualsOrdIgnoreCase(a.ChannelName)));

            var from    = Uri.EscapeDataString(From);
            var body    = Uri.EscapeDataString(msg.Body);
            var auth    = HDR_AUTHORIZATION_TOKEN.Args(AuthorizationKey);
            var wasSent = false;

            foreach (var addressee in addressees)
            {
                var to = Uri.EscapeDataString(addressee.ChannelAddress);
                try
                {
                    var wasSentNow = doCall(from, to, body, auth);
                    wasSent |= wasSentNow;
                }
                catch (Exception error)
                {
                    var et = error.ToMessageWithType();
                    Log(MessageType.Error, "{0}.DoSendMsg(msg): {1}".Args(this.GetType().FullName, et), et);
                }
            }
            return(wasSent);
        }
Beispiel #2
0
        /// <summary>
        /// MessageSink DoSendMsg implementation
        /// </summary>
        /// <param name="msg">Message</param>
        protected override bool DoSendMsg(Message msg)
        {
            if (msg == null || msg.TOAddress.IsNullOrWhiteSpace())
            {
                return(false);
            }

            var addressees =
                msg.MessageAddress.All.Where(a => SupportedChannelNames.Any(n => n.EqualsOrdIgnoreCase(a.ChannelName)));

            var fa = msg.FROMAddress;
            var fn = msg.FROMName;

            if (fa.IsNullOrWhiteSpace())
            {
                fa = DefaultFromAddress;
            }
            if (fn.IsNullOrWhiteSpace())
            {
                fn = DefaultFromName;
            }

            var fromAddress = "{0} <{1}>".Args(fn, fa);

            var sent = false;

            foreach (var addressee in addressees)
            {
                var request = new WebClient.RequestParams(this)
                {
                    Method         = HTTPRequestMethod.POST,
                    BodyParameters = new Dictionary <string, string>(),
                    UserName       = "******",
                    Password       = AuthorizationKey
                };

                addParameter(request.BodyParameters, MAIL_PARAM_FROM, fromAddress);
                addParameter(request.BodyParameters, MAIL_PARAM_TO,
                             "{0} <{1}>".Args(addressee.Name, addressee.ChannelAddress));
                if (msg.CC.IsNotNullOrWhiteSpace())
                {
                    addParameter(request.BodyParameters, MAIL_PARAM_CC, msg.CC);
                }
                if (msg.BCC.IsNotNullOrWhiteSpace())
                {
                    addParameter(request.BodyParameters, MAIL_PARAM_BCC, msg.BCC);
                }
                if (msg.Subject.IsNotNullOrWhiteSpace())
                {
                    addParameter(request.BodyParameters, MAIL_PARAM_SUBJECT, msg.Subject);
                }
                if (msg.Body.IsNotNullOrWhiteSpace())
                {
                    addParameter(request.BodyParameters, MAIL_PARAM_TEXT, msg.Body);
                }
                if (msg.RichBody.IsNotNullOrWhiteSpace())
                {
                    addParameter(request.BodyParameters, MAIL_PARAM_HTML, msg.RichBody);
                }

                if (msg.Attachments != null)
                {
                    foreach (var attachment in msg.Attachments.Where(a => a.Content != null))
                    {
                        //TODO
                    }
                }

                try
                {
                    if (TestMode)
                    {
                        request.BodyParameters.Add(API_PARAM_TESTMODE, "yes");
                    }

                    WebClient.GetString(ServiceUrl, request);
                    sent = true;
                }
                catch (Exception error)
                {
                    var et = error.ToMessageWithType();
                    Log(MessageType.Error, "{0}.DoSendMsg(msg): {1}".Args(this.GetType().FullName, et), et);
                }
            }

            return(sent);
        }
Beispiel #3
0
        protected override bool DoSendMsg(Message msg)
        {
            if (msg == null || msg.TOAddress.IsNullOrWhiteSpace())
            {
                return(false);
            }

            var fa = msg.FROMAddress;
            var fn = msg.FROMName;

            if (fa.IsNullOrWhiteSpace())
            {
                fa = DefaultFromAddress;
            }
            if (fn.IsNullOrWhiteSpace())
            {
                fn = DefaultFromName;
            }

            var addressees =
                msg.MessageAddress.All.Where(a => SupportedChannelNames.Any(n => n.EqualsOrdIgnoreCase(a.ChannelName)));

            var from    = new MailAddress(fa, fn);
            var wasSent = false;

            foreach (var addressee in addressees)
            {
                var to = new MailAddress(addressee.ChannelAddress, addressee.Name);

                using (var email = new MailMessage(from, to))
                {
                    email.Subject = msg.Subject;

                    if (msg.CC.IsNotNullOrWhiteSpace())
                    {
                        email.CC.Add(msg.CC);
                    }

                    if (msg.BCC.IsNotNullOrWhiteSpace())
                    {
                        email.Bcc.Add(msg.BCC);
                    }

                    if (msg.HTMLBody.IsNullOrWhiteSpace())
                    {
                        email.Body = msg.Body;
                    }
                    else
                    {
                        if (msg.Body.IsNullOrWhiteSpace())
                        {
                            email.IsBodyHtml = true;
                            email.Body       = msg.HTMLBody;
                        }
                        else
                        {
                            email.Body = msg.Body;
                            var alternateHTML = AlternateView.CreateAlternateViewFromString(msg.HTMLBody, new System.Net.Mime.ContentType(ContentType.HTML));
                            email.AlternateViews.Add(alternateHTML);
                        }
                    }

                    if (msg.Attachments != null)
                    {
                        foreach (var att in msg.Attachments.Where(a => a.Content != null))
                        {
                            var ema = new Attachment(new System.IO.MemoryStream(att.Content), new System.Net.Mime.ContentType(att.ContentType));

                            if (att.Name.IsNotNullOrWhiteSpace())
                            {
                                ema.ContentDisposition.FileName = att.Name;
                            }

                            email.Attachments.Add(ema);
                        }
                    }

                    try
                    {
                        m_Smtp.Send(email);
                        wasSent = true;
                    }
                    catch (Exception error)
                    {
                        var et = error.ToMessageWithType();
                        Log(MessageType.Error, "{0}.DoSendMsg(msg): {1}".Args(this.GetType().FullName, et), et);
                    }
                }
            }

            return(wasSent);
        }