internal static MailDTO PairToProtocol(MailDTO mailDTO, ProtocolDTO protocolDTO)
        {
            var mailbox = (MailboxDTO)mailDTO.Mailbox;

            if (mailbox.IsPEC())
            {
                FacadeFactory.Instance.PECMailFacade.PairToProtocol(mailDTO, protocolDTO);
                return(mailDTO);
            }
            else if (mailbox.IsPOL())
            {
                //Non eseguo alcuna attività in quanto l'associazione viene già fatta nel metodo di invio POL
                return(mailDTO);
            }
            else if (mailbox.IsMessage())
            {
                MessageEmail    savedMessage       = FacadeFactory.Instance.MessageEmailFacade.GetById(int.Parse(mailDTO.Id));
                DSWMessage      currentMessage     = savedMessage.Message;
                Protocol        protocol           = FacadeFactory.Instance.ProtocolFacade.GetById(protocolDTO.UniqueId.Value);
                ProtocolMessage newProtocolMessage = new ProtocolMessage(ref protocol, ref currentMessage);
                FacadeFactory.Instance.ProtocolMessageFacade.Save(ref newProtocolMessage);
                return(mailDTO);
            }

            var message = string.Format("Mailbox.TypeName \"{0}\" non gestito.", mailDTO.Mailbox.TypeName);

            throw new NotImplementedException(message);
        }
Exemple #2
0
        private void SendEmailMessage(Reminder reminder, Profile profile, Contact contact)
        {
            string fromEmailAddress = profile.EmailAddress;
            string toEmailAddress   = contact.EmailAddress;
            string emailSubject     = string.Format("Reminder from {0} {1} - {2}", profile.FirstName, profile.LastName, DateTime.Now.ToString());
            string emailBody        = this.EmailMessageToSend(reminder, profile, contact);
            var    emailMessage     = new MessageEmail();

            emailMessage.Send(fromEmailAddress, toEmailAddress, emailSubject, emailBody);
        }
Exemple #3
0
//		public JsonResult Send()
//		{
//			var contactList = new List<SelectListItem>();
//			DateTime currentDateTime;
//			try
//			{
//				var reminders = new ReminderDb().Reminders;

//				foreach (var reminder in reminders)
//				{
//					TimeSpan timeDifference;

//					var contact = new ReminderDb().Contacts.Where(c => c.Id == reminder.ContactId).FirstOrDefault();

//					int prodServerTimeDifference = 0;

//					switch (contact.TimeZone)
//					{
//						case "PST": prodServerTimeDifference = Convert.ToInt32(ConfigurationManager.AppSettings["PSTOffSetHours"]); break;
//						case "MST": prodServerTimeDifference = Convert.ToInt32(ConfigurationManager.AppSettings["MSTOffSetHours"]); break;
//						case "CST": prodServerTimeDifference = Convert.ToInt32(ConfigurationManager.AppSettings["CSTOffSetHours"]); break;
//						case "EST": prodServerTimeDifference = Convert.ToInt32(ConfigurationManager.AppSettings["ESTOffSetHours"]); break;
//					}

//#if DEBUG
//					currentDateTime = DateTime.Now;
//#else
//					currentDateTime = DateTime.Now.AddHours(prodServerTimeDifference);
//#endif

//					timeDifference = reminder.ReminderDateTime - currentDateTime;
//					int RemdinerMinutes = Convert.ToInt32(ConfigurationManager.AppSettings["RemdinerMinutes"]);


//					if (timeDifference.Seconds > 0 && timeDifference.Minutes <= RemdinerMinutes && reminder.ReminderDateTime.Date.Equals(currentDateTime.Date) && !reminder.Sent)
//					{

//						var profile = _db.Profiles.ToList().Find(p => p.Id == contact.ProfileId);
//						if (contact.Active && !profile.DeActivate)
//						{
//							bool reminderSent = false;
//							if (contact.SendEmail)
//							{
//								SendEmail(reminder, profile, contact);

//								contactList.Add(new SelectListItem()
//													{
//															Text = string.Format("{0} {1}", contact.FirstName.Trim(), contact.LastName.Trim()),
//															Value = reminder.Message

//													});
//								reminderSent = true;

//								var reminderHistory = new ReminderHistory();
//								reminderHistory.ContactId = contact.Id;
//								reminderHistory.Message = reminder.Message;
//								reminderHistory.ProfileId = profile.Id;
//								reminderHistory.ReminderDateTime = reminder.ReminderDateTime;
//								reminderHistory.ReminderId = reminder.Id;
//								reminderHistory.EmailSent = true;
//								reminderHistory.SMSSent = false;
//								reminderHistory.MessageSentDateTime = currentDateTime;
//								_db.ReminderHistories.Add(reminderHistory);
//								_db.Save();
//							}

//							if (contact.SendSMS)
//							{
//								SendSMS(reminder, profile, contact);

//								contactList.Add(new SelectListItem()
//								{
//									Text = string.Format("{0} {1}", contact.FirstName.Trim(), contact.LastName.Trim()),
//									Value = contact.Id.ToString().Trim()
//								});

//								reminderSent = true;

//								var reminderHistory = new ReminderHistory();
//								reminderHistory.ContactId = contact.Id;
//								reminderHistory.Message = reminder.Message;
//								reminderHistory.ProfileId = profile.Id;
//								reminderHistory.ReminderDateTime = reminder.ReminderDateTime;
//								reminderHistory.ReminderId = reminder.Id;
//								reminderHistory.EmailSent = false;
//								reminderHistory.SMSSent = true;
//								reminderHistory.MessageSentDateTime = currentDateTime;
//								_db.ReminderHistories.Add(reminderHistory);
//								_db.Save();
//							}

//							if (reminderSent)
//							{
//								_db.Reminders.ToList().Find(r => r.Id == reminder.Id).Sent = true;
//								_db.Save();
//							}

//						}
//					}

//				}

//			}
//			catch (Exception exception)
//			{
//				contactList.Add(new SelectListItem(){Selected = false, Text = exception.Message, Value = exception.InnerException.ToString()});
//			}

//			if (contactList.Count == 0)
//			{
//				contactList.Add(new SelectListItem(){Selected = false, Text = "No appointments to send out", Value = "none"});
//			}

//			return Json(contactList, JsonRequestBehavior.AllowGet);
//		}

        public void SendEmail(Reminder reminder, Profile profile, Contact contact)
        {
            string fromEmailAddress = profile.EmailAddress;
            string toEmailAddress   = contact.EmailAddress;
            string emailSubject     = string.Format("Reminder from {0} {1} - {2}", profile.FirstName, profile.LastName, DateTime.Now.ToString());
            string emailBody        = string.Format("Hi {0}, <br/> This is a reminder for you to {1} at {2}. <br/> Sincerely,<br/> {3}", contact.FirstName.Trim(), reminder.Message, reminder.ReminderDateTime.DayOfWeek + " " + reminder.ReminderDateTime.ToString(), profile.FirstName);

            var emailMessage = new MessageEmail();

            emailMessage.Send(fromEmailAddress, toEmailAddress, emailSubject, emailBody);
        }
Exemple #4
0
        public ResponseToRequest <QuotationDetailsViewDTO> sendMail(QuotationDetailsViewDTO quotation)
        {
            var response = new ResponseToRequest <QuotationDetailsViewDTO>
            {
                code          = STATE_MAIL_OK,
                dateResponse  = DateTime.UtcNow,
                modelResponse = quotation,
                message       = MESSAGE_SUCCESS_EMAIL
            };
            var mailResponse = new MessageEmail()
                               .addFrom(EMAIL_EMISOR)
                               .addToList(EMAIL_RECEPTOR)
                               .addSubject(EMAIL_SUBJECT)
                               .addBodyMessage(formatMessageForQuotation(quotation))
                               .enableBodyHtml()
                               .send();

            if (!mailResponse)
            {
                response.code    = 400; // bad request
                response.message = MESSAGE_FAILED_EMAIL;
            }
            return(response);
        }
Exemple #5
0
        public override void SingleWork()
        {
            IList <DSWMessage> messages = Facade.MessageFacade.GetMessagesToSend(DSWMessage.MessageTypeEnum.Email, DSWMessage.MessageStatusEnum.Active).Take(Parameters.MaxMailsForSession).ToList();

            FileLogger.Info(Name, string.Format("Trovati {0} messaggi da spedire.", messages.Count));
            foreach (DSWMessage message in messages)
            {
                if (Cancel)
                {
                    FileLogger.Info(Name, "Chiusura modulo invocata dall'utente.");
                    return;
                }

                FileLogger.Info(Name, String.Format("Inizio elaborazione messaggio [{0}]", message.Id));
                try
                {
                    MailMessage            item           = new MailMessage();
                    MailAddress            originalSender = null;
                    IList <MessageContact> mittente       = Facade.MessageContactFacade.GetByMessage(message, MessageContact.ContactPositionEnum.Sender) ?? new List <MessageContact>();
                    FileLogger.Debug(Name, String.Format("Numero mittenti: {0}", mittente.Count));
                    MessageContactEmail mittenteEmail = null;

                    if (mittente.Any())
                    {
                        mittenteEmail = Facade.MessageContactEmailFacade.GetByContact(mittente.First());
                    }

                    if (mittenteEmail != null)
                    {
                        item.From      = new MailAddress(mittenteEmail.Email, mittenteEmail.Description);
                        originalSender = item.From;
                    }

                    FileLogger.Debug(Name, String.Format("Parameters.Sender: {0}", Parameters.Sender));
                    if (!string.IsNullOrEmpty(Parameters.Sender))
                    {
                        item.From = new MailAddress(Parameters.Sender);
                        if (mittenteEmail != null)
                        {
                            item.ReplyToList.Add(new MailAddress(mittenteEmail.Email, mittenteEmail.Description));
                        }
                    }
                    FileLogger.Debug(Name, String.Format("item.From = {0}", item.From));
                    if (item.From == null)
                    {
                        throw new ArgumentNullException("Email sender is not specified");
                    }


                    IList <MessageContact> destinatari = Facade.MessageContactFacade.GetByMessage(message) ?? new List <MessageContact>();
                    FileLogger.Debug(Name, string.Format("Numero destinatari: {0}", destinatari.Count));
                    MessageContactEmail messageContactEmail = null;
                    foreach (MessageContact messageContact in destinatari)
                    {
                        messageContactEmail = Facade.MessageContactEmailFacade.GetByContact(messageContact);
                        if (!string.IsNullOrEmpty(messageContactEmail.Email) && messageContact.ContactPosition != MessageContact.ContactPositionEnum.Sender)
                        {
                            switch (messageContact.ContactPosition)
                            {
                            case MessageContact.ContactPositionEnum.Recipient:
                            {
                                item.To.Add(new MailAddress(messageContactEmail.Email, messageContactEmail.Description));
                                break;
                            }

                            case MessageContact.ContactPositionEnum.RecipientCc:
                            {
                                item.CC.Add(new MailAddress(messageContactEmail.Email, messageContactEmail.Description));
                                break;
                            }

                            case MessageContact.ContactPositionEnum.RecipientBcc:
                            {
                                item.Bcc.Add(new MailAddress(messageContactEmail.Email, messageContactEmail.Description));
                                break;
                            }

                            default:
                                break;
                            }
                            FileLogger.Debug(Name, $"Aggiunto destinatario {messageContactEmail.Description} ({messageContactEmail.Email}) in {messageContact.ContactPosition}");
                        }
                    }


                    MessageEmail email = Facade.MessageEmailFacade.GetByMessage(message);

                    item.Subject = !string.IsNullOrEmpty(email.Subject) ? email.Subject : Parameters.DefaultSubject;
                    item.Subject = string.IsNullOrEmpty(item.Subject) ? item.Subject : item.Subject.Replace("\r\n", String.Empty).Replace("\n", String.Empty);
                    FileLogger.Debug(Name, "item.Subject = " + item.Subject);

                    item.Body = !string.IsNullOrEmpty(email.Body) ? email.Body : Parameters.DefaultBody;
                    FileLogger.Debug(Name, "item.Body = " + item.Body);

                    item.IsBodyHtml = true;

                    var allegati = Facade.MessageAttachmentFacade.GetByMessageAsDocumentInfoListForceStream(message);

                    FileLogger.Debug(Name, String.Format("Numero allegati: {0}", allegati.Count));
                    foreach (var allegato in allegati)
                    {
                        FileLogger.Debug(Name, string.Format("Signature documento {0}.", allegato.Signature));
                        item.Attachments.Add(new Attachment(new MemoryStream(allegato.Stream), FileHelper.ReplaceUnicode(FileHelper.ConvertUnicodeToAscii(allegato.Name)), allegato.IsCompliantPrint ? MediaTypeNames.Application.Pdf : MediaTypeNames.Application.Octet));
                        FileLogger.Debug(Name, string.Format("Allegato {0} aggiunto.", FileHelper.ReplaceUnicode(FileHelper.ConvertUnicodeToAscii(allegato.Name))));
                    }

                    // Impostazione Priority
                    item.Priority = email.Priority;
                    _mailClient   = new MailClient(
                        Parameters.ServerType.ToString(),
                        Parameters.Server, Parameters.ServerPort,
                        Parameters.AuthenticationType,
                        Parameters.UserName, Parameters.UserPassword, Parameters.UserDomain);

                    // In caso di modalità DEBUG modifico i destinatari con quello di default:
                    if (Parameters.DebugModeEnabled)
                    {
                        // Creo una nuova mail alla quale aggiungo come allegato la mail originale
                        var debugMail = new MailMessage
                        {
                            Subject = String.Format("Inoltro messaggio per DEBUG {0} -> ", email.Subject),
                            From    = item.From,
                            Body    = "In allegato la mail che sarebbe stata spedita."
                        };

                        // Aggiungo il destinatario di debug
                        debugMail.To.Add(new MailAddress(Parameters.DebugModeAddress, "DEBUG ADDRESS"));

                        // Aggiungo la mail come allegato
                        debugMail.Attachments.Add(item.ToAttachment(new DirectoryInfo(Parameters.TempFolder)));

                        // Sostituisco item con il debugMail
                        item = debugMail;

                        FileLogger.Info(Name, string.Format("Modificato l'indirizzo di invio della mail con l'indirizzo {0}.", Parameters.DebugModeAddress));
                    }
                    var emlData = _mailClient.Send(item,
                                                   !String.IsNullOrEmpty(Parameters.TempFolder) ? new DirectoryInfo(Parameters.TempFolder) : null, true,
                                                   email.IsDispositionNotification, originalSender == null ? item.From : originalSender);
                    // Salvo in Biblos l'eml inviato
                    if (message.Location != null)
                    {
                        var emlDocument = new MemoryDocumentInfo(emlData, "Messaggio.eml")
                        {
                            Signature = "*"
                        }.ArchiveInBiblos(message.Location.DocumentServer, message.Location.ProtBiblosDSDB);
                        email.EmlDocumentId = emlDocument.DocumentId;
                    }
                    email.SentDate = DateTime.Now;
                    Facade.MessageEmailFacade.Update(ref email);

                    OnSent(message);

                    FileLogger.Info(Name, string.Format("Fine elaborazione messaggio [{0}].", message.Id));
                }
                catch (Exception ex)
                {
                    OnError(message, ex);
                }
                finally
                {
                    // Attendo sempre 15 secondi tra un invio e il successivo
                    Thread.Sleep(Parameters.SleepBetweenSends * 1000);
                }
            }
            NHibernateSessionManager.Instance.CloseTransactionAndSessions();
            _mailClient = null;
        }
 public SendingEmailResult(MessageEmail users)
 {
     Users = users;
 }