protected override void SendUnrecLetter(Mime m, AddressList fromList, EMailSourceHandlerException e)
        {
            try {
                var attachments = m.Attachments.Where(a => !String.IsNullOrEmpty(a.GetFilename())).Aggregate("", (s, a) => s + String.Format("\"{0}\"\r\n", a.GetFilename()));
                var ms          = new MemoryStream(m.ToByteData());
                FailMailSend(m.MainEntity.Subject, fromList.ToAddressListString(),
                             m.MainEntity.To.ToAddressListString(), m.MainEntity.Date, ms, attachments, e.Message);

                DocumentReceiveLog.Log(GetFirmCodeByFromList(fromList), _addressId, null, _currentDocumentType.DocType, String.Format(@"{0}
Тема            : {1}
Отправители     : {2}
Получатели      : {3}
Список вложений :
{4}
",
                                                                                                                                      e.Message,
                                                                                                                                      m.MainEntity.Subject,
                                                                                                                                      fromList.ToAddressListString(),
                                                                                                                                      m.MainEntity.To.ToAddressListString(),
                                                                                                                                      attachments), IMAPHandler.CurrentUID);
            }
            catch (Exception exMatch) {
                _logger.Error("Не удалось отправить нераспознанное письмо", exMatch);
            }
        }
Esempio n. 2
0
 protected override void SendUnrecLetter(Mime m, AddressList fromList, EMailSourceHandlerException e)
 {
     try {
         var attachments = m.Attachments.Where(a => !String.IsNullOrEmpty(a.GetFilename())).Aggregate("", (s, a) => s + String.Format("\"{0}\"\r\n", a.GetFilename()));
         var ms          = new MemoryStream(m.ToByteData());
         FailMailSend(m.MainEntity.Subject, fromList.ToAddressListString(),
                      m.MainEntity.To.ToAddressListString(), m.MainEntity.Date, ms, attachments, e.Message);
     }
     catch (Exception exMatch) {
         _logger.Error("Не удалось отправить нераспознанное письмо", exMatch);
     }
 }
        public void SendErrorLetterToSupplier(EMailSourceHandlerException e, Mime sourceLetter)
        {
            try {
                var miniMailException = e as MiniMailException;
                if (miniMailException != null)
                {
                    e.MailTemplate = TemplateHolder.GetTemplate(miniMailException.Template);
                }

                if (e.MailTemplate.IsValid())
                {
                    var FromList = MimeEntityExtentions.GetAddressList(sourceLetter);

                    var from = new AddressList();

                    @from.Parse("*****@*****.**");

                    var responseMime = new Mime();
                    responseMime.MainEntity.From = @from;
#if DEBUG
                    var toList = new AddressList {
                        new MailboxAddress(Settings.Default.SMTPUserFail)
                    };
                    responseMime.MainEntity.To = toList;
#else
                    responseMime.MainEntity.To = FromList;
#endif
                    responseMime.MainEntity.Subject     = e.MailTemplate.Subject;
                    responseMime.MainEntity.ContentType = MediaType_enum.Multipart_mixed;

                    var testEntity = responseMime.MainEntity.ChildEntities.Add();
                    testEntity.ContentType             = MediaType_enum.Text_plain;
                    testEntity.ContentTransferEncoding = ContentTransferEncoding_enum.QuotedPrintable;
                    testEntity.DataText = e.GetBody(sourceLetter);

                    var attachEntity = responseMime.MainEntity.ChildEntities.Add();
                    attachEntity.ContentType                 = MediaType_enum.Application_octet_stream;
                    attachEntity.ContentTransferEncoding     = ContentTransferEncoding_enum.Base64;
                    attachEntity.ContentDisposition          = ContentDisposition_enum.Attachment;
                    attachEntity.ContentDisposition_FileName = (!String.IsNullOrEmpty(sourceLetter.MainEntity.Subject)) ? sourceLetter.MainEntity.Subject + ".eml" : "Unrec.eml";
                    attachEntity.Data = sourceLetter.ToByteData();

                    Send(responseMime);
                }
                else
                {
                    _logger.ErrorFormat("Для исключения '{0}' не установлен шаблон", e.GetType());
                }
            }
            catch (Exception exception) {
                _logger.WarnFormat("Ошибка при отправке письма поставщику: {0}", exception);
            }
        }
        protected virtual void SendUnrecLetter(Mime m, AddressList from, EMailSourceHandlerException exception)
        {
            try {
                var attachments = m.Attachments.Where(a => !String.IsNullOrEmpty(a.GetFilename())).Aggregate("", (s, a) => s + String.Format("\"{0}\"\r\n", a.GetFilename()));
                var ms          = new MemoryStream(m.ToByteData());
#if !DEBUG
                SmtpClientEx.QuickSendSmartHost(
                    Settings.Default.SMTPHost,
                    25,
                    Environment.MachineName,
                    Settings.Default.ServiceMail,
                    new[] { Settings.Default.UnrecLetterMail },
                    ms);
#endif
                FailMailSend(m.MainEntity.Subject, from.ToAddressListString(),
                             m.MainEntity.To.ToAddressListString(), m.MainEntity.Date, ms, attachments, exception.Message);
                DownloadLogEntity.Log((ulong)PriceSourceType.EMail, String.Format("Письмо не распознано.Причина : {0}; Тема :{1}; От : {2}",
                                                                                  exception.Message, m.MainEntity.Subject, from.ToAddressListString()));
            }
            catch (Exception exMatch) {
                _logger.Error("Не удалось отправить нераспознанное письмо", exMatch);
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Sends specified mime message.
        /// </summary>
        /// <param name="message">Message to send.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>message</b> is null.</exception>
        public static void QuickSend(Mime message)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            string from = "";
            if (message.MainEntity.From != null && message.MainEntity.From.Count > 0)
            {
                from = ((MailboxAddress) message.MainEntity.From[0]).EmailAddress;
            }

            List<string> recipients = new List<string>();
            if (message.MainEntity.To != null)
            {
                MailboxAddress[] addresses = message.MainEntity.To.Mailboxes;
                foreach (MailboxAddress address in addresses)
                {
                    recipients.Add(address.EmailAddress);
                }
            }
            if (message.MainEntity.Cc != null)
            {
                MailboxAddress[] addresses = message.MainEntity.Cc.Mailboxes;
                foreach (MailboxAddress address in addresses)
                {
                    recipients.Add(address.EmailAddress);
                }
            }
            if (message.MainEntity.Bcc != null)
            {
                MailboxAddress[] addresses = message.MainEntity.Bcc.Mailboxes;
                foreach (MailboxAddress address in addresses)
                {
                    recipients.Add(address.EmailAddress);
                }

                // We must hide BCC
                message.MainEntity.Bcc.Clear();
            }

            foreach (string recipient in recipients)
            {
                QuickSend(null, from, recipient, new MemoryStream(message.ToByteData()));
            }
        }