Example #1
0
 public CompleteEmails(ILogger logger, EmailBatch emailBatch, DateTimeOffset dateSent, IEnumerable <Jibberwock.Persistence.DataAccess.TableTypes.Emails.Email> emails)
     : base(logger)
 {
     EmailBatch   = emailBatch;
     DateSent     = dateSent;
     EmailRecords = emails;
 }
Example #2
0
        protected EmailBatchTypeHandlerBase(ILogger logger, IReadableDataSource dataSource, EmailBatch emailBatch, SendGridConfiguration sendGridConfiguration)
        {
            _logger                = logger;
            _dataSource            = dataSource;
            _sendGridConfiguration = sendGridConfiguration;

            EmailBatch = emailBatch;
        }
Example #3
0
        public void Send(int pendingId, IFile filesys)
        {
            List <EmailBatch> batches = new List <EmailBatch>();

            EmailBatch batch = CreateEmailBatch(pendingId);

            if (batch != null)
            {
                batches.Add(batch);
                SendEmailBatches(batches, filesys);
            }
        }
Example #4
0
        public void SendAll(IFile filesys)
        {
            IQueryable <PendingReport> reports = _context.PendingReports.Where(r => (!r.Deleted));

            reports = reports.Where(r => r.State == 1).Where(r => r.CID != null);

            List <EmailBatch> batches = new List <EmailBatch>();

            foreach (PendingReport report in reports.ToList())
            {
                EmailBatch batch = CreateEmailBatch(report.PendingId);
                if (batch != null)
                {
                    batches.Add(batch);
                }
            }

            if (batches.Count > 0)
            {
                SendEmailBatches(batches, filesys);
            }
        }
Example #5
0
        private EmailBatch CreateEmailBatch(int pendingId)
        {
            EmailBatch batch = new EmailBatch();

            batch.Recipients = new List <EmailRecipient>();
            string emailDomain = EmailConfig.Me.InternalEmailDomain;

            batch.Postmaster = EmailConfig.Me.Postmaster;

            PendingReport pr = this.Read(pendingId);

            batch.Name = pr.FullReportNo.Trim();

            if (pr.State != 1)
            {
                Log.Me.Error("State != 1 for " + pr.FullReportNo + ", so report send was blocked.");
                return(null);
            }

            if (!pr.CID.HasValue || pr.CID <= 0)
            {
                Log.Me.Error("Could not get CID for " + pr.FullReportNo);
                return(null);
            }

            int    cid        = pr.CID.Value;
            string attachment = pr.eFileName;

            Log.Me.Debug("Getting the From email address");
            Recipient r = null;

            if (!pr.RecipientID.HasValue || pr.RecipientID <= 0)
            {
                Log.Me.Error("RecipientID not set.");
                return(null);
            }
            else
            {
                r = _context.RecipientRepo.Read(pr.RecipientID);

                if (r == null || r.Email == null || r.Name == null)
                {
                    Log.Me.Error("Recipient data not set. RecipientID was " + pr.RecipientID.ToString());
                    return(null);
                }
            }
            batch.From = r.ToMailAddress();

            Log.Me.Debug("From: " + batch.From.ToString());

            Log.Me.Debug("-------------------------------------------------------------------------------------");
            Log.Me.Debug("Email Circulation Log for CID : " + cid.ToString());
            Log.Me.Debug("-------------------------------------------------------------------------------------");
            Log.Me.Debug("");

            //------------------------------------------------------------------------------------------------
            // If we find a ReportLink tag we need to replace it with a link to the PTOPAC_Link project
            //------------------------------------------------------------------------------------------------
            string company = EmailConfig.Me.Company;
            string support = EmailConfig.Me.CatalogueSupport;

            string linkPath = EmailConfig.Me.PortalLinkURL;

            if (linkPath != null)
            {
                linkPath += cid.ToString();
            }
            Log.Me.Debug("Portal Link = " + (linkPath ?? "(empty)"));

            //-----------------------------------------------------------------------
            // Loop through all the recipients -
            //-----------------------------------------------------------------------
            string IntExt;

            Log.Me.Debug("Getting the list of Email Recipients from the database");
            IQueryable <Circulation> circs = _context.Circulations;

            circs = circs.Where(c => c.PendingId == pendingId);

            foreach (Circulation circ in circs.ToList())
            {
                //---------------------------------------------------
                // What type of Delivery is this? ES, EF or EC ?
                //---------------------------------------------------
                string deliveryType = circ.ElecDeliveryCode;
                if (deliveryType != null)
                {
                    Log.Me.Debug("------------------------------------------------------------");
                    Log.Me.Debug("Building Email Message");
                    EmailRecipient recipient = new EmailRecipient();
                    recipient.To = new MailAddress(circ.Email, circ.Name);
                    //--------------------------------------------------------------------
                    // Figure out if the current recipient is internal or external
                    //--------------------------------------------------------------------
                    if (circ.Email.Trim().Right(emailDomain.Length).ToLower() == emailDomain)
                    {
                        IntExt = "I";
                    }
                    else
                    {
                        IntExt = "X";
                    }

                    Log.Me.Debug("  To            : " + recipient.To.ToString());
                    Log.Me.Debug("  From          : " + batch.Postmaster.ToString());

                    string deliveryMsg = "";
                    if (deliveryType == "EF")
                    {
                        deliveryMsg = "Electronic FULL";
                    }
                    else if (deliveryType == "EC")
                    {
                        deliveryMsg = "Electronic SUMMARY with CD to follow";
                    }
                    else
                    {
                        deliveryMsg = "Electronic SUMMARY";
                    }

                    recipient.DeliveryType = deliveryType + IntExt;

                    if (deliveryType == "EF")
                    {
                        recipient.Attachment = attachment;
                    }

                    Log.Me.Debug("  Delivery Type : " + deliveryMsg);

                    recipient.MailMergeFields = new Dictionary <string, string>();
                    recipient.MailMergeFields.Add("FromName", batch.From.DisplayName);
                    recipient.MailMergeFields.Add("FromEmail", batch.From.Address);
                    recipient.MailMergeFields.Add("ReportNumber", pr.FullReportNo ?? "");
                    recipient.MailMergeFields.Add("Title", pr.Title ?? "");
                    recipient.MailMergeFields.Add("Authors", pr.Author ?? "");
                    recipient.MailMergeFields.Add("Summary", pr.Abstract ?? "");
                    recipient.MailMergeFields.Add("ReportLink", linkPath ?? "");
                    recipient.MailMergeFields.Add("Company", company ?? "");
                    recipient.MailMergeFields.Add("CatalogueSupport", support ?? "");

                    batch.Recipients.Add(recipient);
                }
            }

            Log.Me.Debug(batch.Recipients.Count().ToString() + " recipients");
            if (batch.Recipients.Count() == 0)
            {
                // No recipients, so nothing to send, we can just set the Status to 2.
                // TODO Set status to 2
                return(null);
            }

            PendingReport pr2 = this.Read(pendingId);

            if (pr2.State != 1)
            {
                Log.Me.Error("Possible race condition. Right at the end of CreateEmailBatch State != 1 for " + pr2.FullReportNo + ", so report send was blocked.");
                return(null);
            }

            // Mark the report as sent
            pr2.State    = 2; // Set State to "Sent"
            pr2.DateSent = DateTime.Now;
            this.Update(pr2); // Update Record
            // Also update the state of Circulation
            //_context.CirculationRepo.SetState(pr.PendingId, 2); not needed any more

            return(batch);
        }
Example #6
0
 public CompleteBatch(ILogger logger, EmailBatch emailBatch)
     : base(logger)
 {
     EmailBatch = emailBatch;
 }
Example #7
0
 public void InsertEmailBatch(EmailBatch emailbatch)
 {
     conn.Execute("usp_EmailBatch_Create", new { CarId = emailbatch.CarId, EmailId = emailbatch.EmailId },
                  commandType: CommandType.StoredProcedure);
 }
Example #8
0
 public StartBatch(ILogger logger, EmailBatch emailBatch)
     : base(logger)
 {
     EmailBatch = emailBatch;
 }
Example #9
0
 public NotificationEmailBatchTypeHandler(ILogger logger, IReadableDataSource dataSource, EmailBatch emailBatch, SendGridConfiguration sendGridConfiguration)
     : base(logger, dataSource, emailBatch, sendGridConfiguration)
 {
 }
Example #10
0
        private void WriteHtml(IEnumerable <Car> values, string subject)
        {
            var strBldr   = new StringBuilder();
            var strWriter = new StringWriter(strBldr);
            var writer    = new HtmlTextWriter(strWriter);

            writer.RenderBeginTag(HtmlTextWriterTag.Html);

            // <head>
            writer.RenderBeginTag(HtmlTextWriterTag.Head);

            writer.AddAttribute("type", "text/css");
            writer.RenderBeginTag(HtmlTextWriterTag.Style);
            writer.Write("table { border-collapse: separate; }");
            writer.Write("border-spacing: 0 5px; }");
            writer.RenderEndTag();

            // </head>
            writer.RenderEndTag();

            // <body>



            writer.RenderBeginTag(HtmlTextWriterTag.Body);

            writer.AddStyleAttribute("width", " 100%");

            writer.RenderBeginTag(HtmlTextWriterTag.Table); //Main Table
            writer.RenderBeginTag(HtmlTextWriterTag.Tr);
            writer.RenderBeginTag(HtmlTextWriterTag.Td);

            var counter = 0;

            foreach (var val in values)
            {
                if (val.EmailSent)
                {
                    continue;
                }

                writer.AddStyleAttribute("width", " 100%");

                writer.AddStyleAttribute("background-color", counter % 2 == 0 ? " #3399FF" : " #999966");

                writer.RenderBeginTag(HtmlTextWriterTag.Table);

                //writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                //writer.RenderBeginTag(HtmlTextWriterTag.Td);
                //writer.Write("&nbsp;");
                //writer.RenderEndTag();
                //writer.RenderEndTag();

                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);

                writer.AddStyleAttribute("width", " 100%");
                writer.RenderBeginTag(HtmlTextWriterTag.Table);

                writer.RenderBeginTag(HtmlTextWriterTag.Tr);

                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.Write(val.DateIn.ToString("MM/dd/yyyy hh:mm:ss tt", CultureInfo.InvariantCulture));
                writer.RenderEndTag();

                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                // To do
                writer.Write(_feeds.Where(x => x.Id == val.FeedId).FirstOrDefault().FeedCity);

                writer.RenderEndTag();

                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                // To Do
                writer.Write(_feeds.Where(x => x.Id == val.FeedId).FirstOrDefault().FeedState);
                writer.RenderEndTag();

                writer.RenderEndTag();
                writer.RenderEndTag();

                writer.RenderEndTag();
                writer.RenderEndTag();

                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.Write(val.Title);
                writer.RenderEndTag();
                writer.RenderEndTag();



                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.Write(val.Description);
                writer.RenderEndTag();
                writer.RenderEndTag();

                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.AddAttribute(HtmlTextWriterAttribute.Href, val.Link);
                writer.RenderBeginTag(HtmlTextWriterTag.A);
                writer.Write(val.Link);
                writer.RenderEndTag(); //A
                writer.RenderEndTag();
                writer.RenderEndTag();
                writer.RenderEndTag();
                counter++;
            }


            writer.RenderEndTag();
            writer.RenderEndTag();
            writer.RenderEndTag(); //End Main Table



            // </body>
            writer.RenderEndTag();
            // </html>
            writer.RenderEndTag();

            var html  = strBldr.ToString();
            var email = new Email
            {
                EmailGeneratedDate = DateTime.Now,
                EmailMessage       = html,
                EmailSent          = false,
                EmailSubject       = subject
            };
            //  Logger.Debug(html);
            int id = DataAccess.InsertEmail(email);

            foreach (var v in values)
            {
                var batch = new EmailBatch {
                    EmailId = id, CarId = v.Id
                };
                DataAccess.InsertEmailBatch(batch);
                DataAccess.UpdateMailSent(v.Id);
                v.EmailSent = true;
            }
        }
 public GetInvitationBatch(ILogger logger, EmailBatch emailBatch)
     : base(logger)
 {
     EmailBatch = emailBatch;
 }
        static void Main(string[] args)
        {
            Config.Setup("appsettings.json", Directory.GetCurrentDirectory(), null, "MistwarePostmanTest");

            string connection = Config.Get("AzureConnectionString");
            string container  = Config.Get("AzureContainer");
            string logs       = Config.Get("Logs");
            IFile  filesys    = FileBootstrap.SetupFileSys(connection, container, null, logs);

            Log.Me.LogFile = "MistwarePostmanTest.log";

            EmailBatch batch = new EmailBatch();

            batch.Postmaster = new MailAddress("noreply@" + Config.Get("TestDomain"), "ACME Postmaster");
            batch.From       = new MailAddress(Config.Get("TestEmail"), Config.Get("TestPerson"));
            batch.Name       = "Test Batch";
            batch.Recipients = new List <EmailRecipient>();

            EmailRecipient r1 = new EmailRecipient();

            r1.To              = new MailAddress(Config.Get("TestEmail"), Config.Get("TestPerson"));
            r1.DeliveryType    = "Summary";
            r1.Attachment      = null;
            r1.MailMergeFields = new Dictionary <string, string>();
            r1.MailMergeFields.Add("FromName", "Fred Bloggs");
            r1.MailMergeFields.Add("FromEmail", "*****@*****.**");
            r1.MailMergeFields.Add("ISBN", "9780141198354");
            r1.MailMergeFields.Add("Title", "Bleak House");
            r1.MailMergeFields.Add("Authors", "Charles Dickens");
            r1.MailMergeFields.Add("Summary", "A satirical story about the British judiciary system. \nEsther Summerson is a lonely girl who was raised by her aunt and is taken in by John Jarndyce, a rich philanthropist. Parts of the story are told from her point of view.");
            r1.MailMergeFields.Add("Link", "https://en.wikipedia.org/wiki/Bleak_House");
            batch.Recipients.Add(r1);

            EmailRecipient r2 = new EmailRecipient();

            r2.To              = new MailAddress(Config.Get("TestEmail"), Config.Get("TestPerson"));
            r2.DeliveryType    = "Full";
            r2.Attachment      = "BleakHouse.pdf";
            r2.MailMergeFields = new Dictionary <string, string>();
            r2.MailMergeFields.Add("FromName", "Fred Bloggs");
            r2.MailMergeFields.Add("FromEmail", "*****@*****.**");
            r2.MailMergeFields.Add("ISBN", "9780141198354");
            r2.MailMergeFields.Add("Title", "Bleak House");
            r2.MailMergeFields.Add("Authors", "Charles Dickens");
            batch.Recipients.Add(r2);

            List <EmailBatch> batches = new List <EmailBatch>();

            batches.Add(batch);

            Log.Me.Info("About to kick off the Emailing Thread");
            MailEngine engine = new MailEngine();

            engine.SendGridKey = Config.Get("SendGridKey");
            engine.FileSys     = filesys;
            engine.LoadTemplates(Directory.GetCurrentDirectory() + "/", "EmailTemplates.txt");
            filesys.ChangeDirectory(Config.Get("UploadDirectory"));
            filesys.FileUpload(Directory.GetCurrentDirectory() + "/" + "BleakHouse.pdf");
            engine.Start(batches);

            Thread.Sleep(10000); // Wait 10 secs, so thread will finish before we kill the app.
            filesys.FileDelete("BleakHouse.pdf");
        }