using HRM.BO; using HRM.BO.Configuration; using Ease.Core.Model; using Ease.Core.Utility; using System; using System.Collections.Generic; using System.IO; using System.Net.Mail; using System.Threading; namespace HRM.DA { /// /// The single place mail actually leaves the system when it goes to many /// recipients at once. /// /// The contract every caller can rely on: /// - the batch and every recipient row are written BEFORE the first mail /// is sent, so nothing is lost if the run dies halfway; /// - one bad recipient - missing address, a document that will not build, /// an SMTP refusal - is recorded against that recipient and the run /// carries on; /// - the reason is stored, in full, on the recipient's own row; /// - a later retry can replay exactly those rows and nothing else. /// /// It knows nothing about payslips, tax certificates or bonuses. The caller /// supplies the addressing, the text and a resolver that produces the /// attachment, which is what lets one implementation serve every mail type. /// public class EmailDispatchService : IEmailDispatchService { private readonly IMasterEmailLogService _masterEmailLogService; public EmailDispatchService(IMasterEmailLogService masterEmailLogService) { _masterEmailLogService = masterEmailLogService; } /// Longest a single error text is allowed to grow in the log. private const int MaxErrorLength = 3000; #region Create public int CreateBatch(EmailDispatchRequest request) { if (request == null) { throw new ServiceException("Email dispatch request cannot be null."); } if (request.Recipients == null || request.Recipients.Count == 0) { throw new ServiceException("No recipient was supplied for this email."); } DateTime now = DateTime.Now; MasterEmailLog log = new MasterEmailLog(); log.EmailType = request.EmailType; log.Description = request.Description; log.PayrollTypeID = request.PayrollTypeID; log.ParameterJson = request.ParameterJson; log.PreserveAttachment = request.PreserveAttachment; log.BatchStatus = EnumEmailBatchStatus.Pending; log.StartTime = now; log.CreatedBy = request.UserID; log.CreatedDate = now; List details = new List(); foreach (EmailRecipient recipient in request.Recipients) { MasterEmailLogDetails detail = new MasterEmailLogDetails(); detail.EmployeeID = recipient.EmployeeID; detail.EmployeeNo = recipient.EmployeeNo; detail.EmployeeName = recipient.EmployeeName; // MailFrom is filled in at send time from EmailSettings - the // batch may well be created by a different process than the one // that ends up sending it. detail.MailFrom = string.Empty; detail.MailTo = recipient.MailTo; detail.CC = recipient.CC; detail.Subject = recipient.Subject; detail.Body = recipient.Body; detail.SalaryMonth = recipient.SalaryMonth; detail.ReferenceID = recipient.ReferenceID; // Recipients the caller already knows cannot be mailed are // logged as Skipped rather than quietly dropped - that list is // the whole point of "who did not get their payslip". string skipReason = ResolveSkipReason(recipient); if (!string.IsNullOrEmpty(skipReason)) { detail.SendStatus = EnumEmailSendStatus.Skipped; detail.ErrorMessage = skipReason; } else { detail.SendStatus = EnumEmailSendStatus.Pending; detail.ErrorMessage = string.Empty; } details.Add(detail); } return _masterEmailLogService.SaveBatch(log, details); } private static string ResolveSkipReason(EmailRecipient recipient) { if (!string.IsNullOrWhiteSpace(recipient.SkipReason)) { return recipient.SkipReason.Trim(); } if (string.IsNullOrWhiteSpace(recipient.MailTo)) { return "Email address missing."; } if (!MailSender.IsValidEmail(recipient.MailTo.Trim())) { return "Invalid email address: " + recipient.MailTo.Trim(); } return null; } #endregion #region Send public EmailDispatchResult Send(EmailDispatchRequest request, EmailSettings emailSettings) { int masterEmailLogID = CreateBatch(request); return ProcessBatch(masterEmailLogID, request, emailSettings); } public EmailDispatchResult ProcessBatch(int masterEmailLogID, EmailDispatchRequest request, EmailSettings emailSettings) { Func resolver = request == null ? null : request.AttachmentResolver; bool preserveAttachment = request == null || request.PreserveAttachment; int delay = request == null ? 500 : request.DelayBetweenMailsInMs; int userID = request == null ? 0 : request.UserID; List pending = _masterEmailLogService.GetDetails(masterEmailLogID, EnumEmailSendStatus.Pending); foreach (MasterEmailLogDetails detail in pending) { EmailAttachmentInfo attachment = null; if (resolver != null) { // Building the document is the most failure-prone step - // no processed salary for that month, no data for that one // employee. It belongs inside the per-recipient guard. try { attachment = resolver(ToRecipient(detail)); } catch (Exception ex) { ExceptionLog.Write(ex); MarkResult(detail, EnumEmailSendStatus.Failed, "Attachment could not be produced: " + Flatten(ex), null, preserveAttachment, userID); continue; } } SendOne(detail, attachment, emailSettings, preserveAttachment, userID); if (delay > 0) { Thread.Sleep(delay); } } EmailDispatchResult result = BuildResult(masterEmailLogID, userID, true); return result; } #endregion #region Retry public EmailDispatchResult RetryFailed(int masterEmailLogID, EmailSettings emailSettings, int userID, Func attachmentResolver) { MasterEmailLog log = _masterEmailLogService.Get(masterEmailLogID); if (log == null) { throw new ServiceException("Email log not found."); } List failed = _masterEmailLogService.GetDetails(masterEmailLogID, EnumEmailSendStatus.Failed); if (failed.Count == 0) { // Nothing to do, but still refresh the header so the screen is // consistent with what is actually in the detail rows. return BuildResult(masterEmailLogID, userID, true); } _masterEmailLogService.MarkRetryStarted(masterEmailLogID, userID); foreach (MasterEmailLogDetails detail in failed) { EmailAttachmentInfo attachment = null; try { if (detail.HasAttachment) { // The exact file that was mailed the first time. This is // what makes retry work for every mail type without the // retry screen knowing how any of them are built. byte[] stored = _masterEmailLogService.GetAttachment(detail.ID); if (stored != null && stored.Length > 0) { attachment = new EmailAttachmentInfo(detail.AttachmentName, stored); } } if (attachment == null && attachmentResolver != null) { attachment = attachmentResolver(detail); } } catch (Exception ex) { ExceptionLog.Write(ex); MarkResult(detail, EnumEmailSendStatus.Failed, "Attachment could not be produced: " + Flatten(ex), null, log.PreserveAttachment, userID); continue; } SendOne(detail, attachment, emailSettings, log.PreserveAttachment, userID); Thread.Sleep(500); } return BuildResult(masterEmailLogID, userID, true); } #endregion #region Sending one recipient /// /// Sends to one recipient and records the outcome. Never throws: every /// failure ends up on the row instead, which is what keeps a batch of a /// thousand alive when a handful of addresses are bad. /// private void SendOne(MasterEmailLogDetails detail, EmailAttachmentInfo attachment,EmailSettings emailSettings, bool preserveAttachment, int userID) { MemoryStream attachmentStream = null; try { string to = detail.MailTo == null ? string.Empty : detail.MailTo.Trim(); if (string.IsNullOrEmpty(to) || !MailSender.IsValidEmail(to)) { MarkResult(detail, EnumEmailSendStatus.Skipped, "Email address missing or invalid.", null, preserveAttachment, userID); return; } detail.MailFrom = emailSettings == null ? string.Empty : emailSettings.FromAddress; MailSender mailSender = new MailSender(); mailSender.AddTo(to); if (!string.IsNullOrWhiteSpace(detail.CC)) { mailSender.CC = detail.CC.Trim(); } mailSender.Subject = detail.Subject; mailSender.Body = detail.Body; if (attachment != null && attachment.Data != null && attachment.Data.Length > 0) { attachmentStream = new MemoryStream(attachment.Data); string fileName = string.IsNullOrWhiteSpace(attachment.FileName) ? "attachment.pdf" : attachment.FileName; mailSender.SendMail(emailSettings, new Attachment(attachmentStream, fileName)); detail.AttachmentName = fileName; } else { mailSender.SendMail(emailSettings); } MarkResult(detail, EnumEmailSendStatus.Success, string.Empty, attachment == null ? null : attachment.Data, preserveAttachment, userID); } catch (Exception ex) { ExceptionLog.Write(ex); MarkResult(detail, EnumEmailSendStatus.Failed, Flatten(ex), attachment == null ? null : attachment.Data, preserveAttachment, userID); } finally { if (attachmentStream != null) { attachmentStream.Dispose(); } } } /// /// Writes one recipient's outcome. Wrapped so that a database hiccup /// while logging cannot take down the send loop that is still running. /// private void MarkResult(MasterEmailLogDetails detail, EnumEmailSendStatus status, string error, byte[] attachmentData, bool preserveAttachment, int userID) { DateTime now = DateTime.Now; detail.SendStatus = status; detail.ErrorMessage = Trim(error); detail.AttemptCount = detail.AttemptCount + 1; detail.ModifiedBy = userID; detail.ModifiedDate = now; if (status == EnumEmailSendStatus.Success) { detail.SentTime = now; } if (detail.AttemptCount > 1) { detail.LastRetryDate = now; } // A failed attachment is worth keeping too: it is what the retry // will re-send, and it is evidence of what the employee was meant // to receive. detail.AttachmentData = preserveAttachment ? attachmentData : null; try { _masterEmailLogService.UpdateDetailResult(detail); } catch (Exception ex) { ExceptionLog.Write(ex); } } #endregion #region Helpers private EmailDispatchResult BuildResult(int masterEmailLogID, int userID, bool markEnded) { EmailDispatchResult result = new EmailDispatchResult(); result.MasterEmailLogID = masterEmailLogID; try { MasterEmailLog log = _masterEmailLogService.RefreshBatchCounters(masterEmailLogID, markEnded, userID); if (log != null) { result.TotalCount = log.TotalCount; result.SuccessCount = log.SuccessCount; result.FailedCount = log.FailedCount; result.SkippedCount = log.SkippedCount; result.BatchStatus = log.BatchStatus; } } catch (Exception ex) { ExceptionLog.Write(ex); } return result; } private static EmailRecipient ToRecipient(MasterEmailLogDetails detail) { EmailRecipient recipient = new EmailRecipient(); recipient.EmployeeID = detail.EmployeeID; recipient.EmployeeNo = detail.EmployeeNo; recipient.EmployeeName = detail.EmployeeName; recipient.MailTo = detail.MailTo; recipient.CC = detail.CC; recipient.Subject = detail.Subject; recipient.Body = detail.Body; recipient.SalaryMonth = detail.SalaryMonth; recipient.ReferenceID = detail.ReferenceID; return recipient; } /// /// The useful part of an SMTP failure is almost always in an inner /// exception, so the whole chain goes into the log. /// private static string Flatten(Exception ex) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); Exception current = ex; while (current != null) { if (sb.Length > 0) { sb.Append(" --> "); } sb.Append(current.Message); current = current.InnerException; } return sb.ToString(); } private static string Trim(string value) { if (string.IsNullOrEmpty(value)) { return string.Empty; } return value.Length <= MaxErrorLength ? value : value.Substring(0, MaxErrorLength); } #endregion } }