private static void Main() { // create the email template var template = new EmailTemplate("Test"); dynamic dtemplate = template; dtemplate.To = "*****@*****.**"; dtemplate.Message = "Hello, non-asp.net world! "; dtemplate.Test = "test property"; dtemplate.SubjectSuffix = DateTime.Now.ToShortTimeString(); dtemplate.Values = new[] {"one", "two", "three"}; template.Attach(@"c:\tmp\test2.log"); template.Attach(@"c:\tmp\cat.jpg", "CatImageId"); // TODO: put in progam folder // serialize and deserialize the email template var serializerSettings = new JsonSerializerSettings { Converters = new List<JsonConverter> { new AttachmentReadConverter(true) } }; var serializedTemplate = JsonConvert.SerializeObject(template, Formatting.Indented, serializerSettings); Console.WriteLine(serializedTemplate); Console.WriteLine("serialized size: {0}", serializedTemplate.Length); var deserializedTemplate = JsonConvert.DeserializeObject<EmailTemplate>(serializedTemplate, serializerSettings); // send the email template var engines = new ViewEngineCollection { new ResourceRazorViewEngine(typeof (Program).Assembly, @"ResourceSample.Resources.Views") }; var service = new SmtpMessagingService(engines); service.Send(deserializedTemplate); }
public ActionResult SimpleHtml() { dynamic email = new EmailTemplate("SimpleHtml"); email.Date = DateTime.UtcNow.ToString(); return new TemplateViewResult(email); }
public void Suspend_User(object s, EventArgs e) { if (!string.IsNullOrEmpty(Request.QueryString["uid"])) { int UserID = int.Parse(Request.QueryString["uid"]); //Cannot suspend the Administrator account. if (UserID != 1) { string Type = Request.Form["Type"]; string Note = Request.Form["Note"]; Blogic.SuspendUser(UserID, Type, Note); ProviderUserDetails user = new ProviderUserDetails(); user.FillUp(UserID); EmailTemplate SendeMail = new EmailTemplate(); //Flag = 1 = Suspension email notice. SendeMail.SendAccountSuspensionReinstateEmail(user.Email, user.Username, Type, 1); SendeMail = null; user = null; Response.Redirect("confirmusersuspenddeleteedit.aspx?mode=Suspend&uid=" + UserID); } } }
///<summary>Inserts one EmailTemplate into the database. Returns the new priKey.</summary> internal static long Insert(EmailTemplate emailTemplate) { if(DataConnection.DBtype==DatabaseType.Oracle) { emailTemplate.EmailTemplateNum=DbHelper.GetNextOracleKey("emailtemplate","EmailTemplateNum"); int loopcount=0; while(loopcount<100){ try { return Insert(emailTemplate,true); } catch(Oracle.DataAccess.Client.OracleException ex){ if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){ emailTemplate.EmailTemplateNum++; loopcount++; } else{ throw ex; } } } throw new ApplicationException("Insert failed. Could not generate primary key."); } else { return Insert(emailTemplate,false); } }
public void SendingRecipe(Object s, EventArgs e) { if (!string.IsNullOrEmpty(Request.QueryString["id"]) && !string.IsNullOrEmpty(Request.QueryString["n"]) && !string.IsNullOrEmpty(Request.QueryString["c"])) { EmailTemplate SendeMail = new EmailTemplate(); SendeMail.ItemID = (int)Util.Val(Request.QueryString["id"]); SendeMail.ItemName = Request.QueryString["n"].ToString(); SendeMail.Category = Request.QueryString["c"].ToString(); SendeMail.SenderName = Util.FormatTextForInput(Request.Form["txtFromName"]); SendeMail.SenderEmail = Util.FormatTextForInput(Request.Form["txtFromEmail"]); SendeMail.LyricEmail = Util.FormatTextForInput(Request.Form["txtToEmail"]); SendeMail.LyricName = Util.FormatTextForInput(Request.Form["toname"]); SendeMail.SendEmailRecipeToAFriend(); Panel1.Visible = false; lblsentmsg.Text = "<div style='text-align: center; border: solid 1px #800000; padding: 8px; margin-left: 25px; margin-right: 25px;'><span class='content12'>Thông điệp của bạn đã được gửi tới (<b>" + SendeMail.LyricEmail + "</b>).</span></div>"; SendeMail = null; } }
public ActionResult MultiPart() { dynamic email = new EmailTemplate("MultiPart"); email.Date = DateTime.UtcNow.ToString(); return new TemplateViewResult(email); }
protected void BtnCreate_Click( object sender, EventArgs e ) { if ( Page.IsValid ) { EmailTemplate emailTemplate = new EmailTemplate( StoreId, TxtName.Text ); emailTemplate.Save(); base.Redirect( WebUtils.GetPageUrl( Constants.Pages.EditEmailTemplate ) + "?id=" + emailTemplate.Id + "&storeId=" + emailTemplate.StoreId ); } }
private EmailTemplate mapToDomain(EmailTemplateViewModel input, EmailTemplate emailTemplate) { var emailTemplateModel = input.EmailTemplate; emailTemplate.Name= emailTemplateModel.Name; emailTemplate.Description= emailTemplateModel.Description; emailTemplate.Template= emailTemplateModel.Template; return emailTemplate; }
public ActionResult SendSimple() { dynamic email = new EmailTemplate("Simple"); email.Date = DateTime.UtcNow.ToString(); email.Send(); return RedirectToAction("Sent", "Home"); }
internal ResourceTemplateHelper(EmailTemplate emailTemplate, TemplateContext context) { Contract.Requires(emailTemplate != null); Contract.Requires(context != null); _emailTemplate = emailTemplate; _context = context; }
/// <summary> /// Sends email using a pre-defined email template /// If any of emailFromAddress/emailToAddress/emailCcAddress is String.Empty then EmailInfo will use corresponding address /// from Email template /// If emailToAddress OR emailCcAddress is not String.Empty the string will be appended to corresponding address of Email /// Template and saved in Email Info /// </summary> /// <param name="emailTemplateId">Email Template Id</param> /// <param name="emailFromAddress">From</param> /// <param name="emailToAddress">To: Comma separated string of email addresses</param> /// <param name="emailCcAddress">Cc: Comma separated string of email addresses</param> /// <param name="subjectPlaceholderValues">Place holder values for Subject template</param> /// <param name="bodyPlaceholderValues">Place holder values for Body template</param> /// <returns></returns> public static bool SendEmail(EmailTemplate emailTemplateId, string emailFromAddress, string emailToAddress, string emailCcAddress, Dictionary<string, string> subjectPlaceholderValues, Dictionary<string, string> bodyPlaceholderValues) { /* IEmailBDC emailBDC = (IEmailBDC) BDCFactory.Instance.Create(BDCType.Email); return emailBDC.SendEmail(emailTemplateId, emailFromAddress, emailToAddress, emailCcAddress, subjectPlaceholderValues, bodyPlaceholderValues);*/ return true; }
public EmailTemplateDto Map(EmailTemplate entity) { return new EmailTemplateDto { Id = entity.Id, Body = entity.Body, Name = entity.Name, Subject = entity.Subject }; }
public string Serialise(EmailTemplate template) { DataContractSerializer serialiser = new DataContractSerializer(typeof(EmailTemplate)); StringBuilder sb = new StringBuilder(); XmlWriter xw = XmlWriter.Create(sb); serialiser.WriteObject(xw, template); xw.Flush(); xw.Close(); return sb.ToString(); }
///<summary>Converts a DataTable to a list of objects.</summary> public static List<EmailTemplate> TableToList(DataTable table){ List<EmailTemplate> retVal=new List<EmailTemplate>(); EmailTemplate emailTemplate; for(int i=0;i<table.Rows.Count;i++) { emailTemplate=new EmailTemplate(); emailTemplate.EmailTemplateNum= PIn.Long (table.Rows[i]["EmailTemplateNum"].ToString()); emailTemplate.Subject = PIn.String(table.Rows[i]["Subject"].ToString()); emailTemplate.BodyText = PIn.String(table.Rows[i]["BodyText"].ToString()); retVal.Add(emailTemplate); } return retVal; }
public ActionResult EmailTemplate(EmailTemplate model) { var id = this.EmailTemplateService.Save(model); if (id > 0) { var data = this.EmailTemplateService.GetByID(id); return Json(data, JsonRequestBehavior.AllowGet); } else { return Content(""); } }
public void Attach_adds_attachment() { dynamic email = new EmailTemplate("Test"); var fileStream = new FileStream(@"c:\tmp\test2.log", FileMode.Open); fileStream.Position = 0; var memoryStream = new MemoryStream(); fileStream.CopyTo(memoryStream); //var attachment = new Attachment(new MemoryStream(), "name"); var attachment = new Attachment(memoryStream, "name"); email.Attach(attachment); ((EmailTemplate)email).Attachments.ShouldContain(attachment); Console.WriteLine(JsonConvert.SerializeObject(email, Formatting.Indented, new MemoryStreamJsonConverter())); }
//commented out as need to alter method or MOQ request current //[TestMethod] public void TestEmailTemplate() { var template = new EmailTemplate() { Body = "Body", Title = "Title" }; var text = template.TransformText(); var pm = new PreMailer.Net.PreMailer(text); var path = GetEmailFolderPath() + "app.css"; var css = File.ReadAllText(path); var il = pm.MoveCssInline(css: css); var res = il.Html; }
public void Save(EmailTemplate emailTemplate) { this._db.OpenConnection(); MySqlCommand command = this._db.CreateCommand(); command.CommandText = "UPDATE email_template SET displayname=?displayname, inleiding=?inleiding, informatie=?informatie, afsluiting=?afsluiting, afzenders=?afzenders WHERE id = ?id"; command.Parameters.Add(new MySqlParameter("?id", MySqlDbType.Int32)).Value = emailTemplate.Id; command.Parameters.Add(new MySqlParameter("?displayname", MySqlDbType.String)).Value = emailTemplate.Displayname; command.Parameters.Add(new MySqlParameter("?inleiding", MySqlDbType.Text)).Value = emailTemplate.Inleiding; command.Parameters.Add(new MySqlParameter("?informatie", MySqlDbType.Text)).Value = emailTemplate.Informatie; command.Parameters.Add(new MySqlParameter("?afsluiting", MySqlDbType.Text)).Value = emailTemplate.Afsluiting; command.Parameters.Add(new MySqlParameter("?afzenders", MySqlDbType.String)).Value = emailTemplate.Afzenders; this._db.ExecuteCommand(command); this._db.CloseConnection(); }
/// <summary> /// Fills list of available fields. /// </summary> /// <param name="emailTemplateObj">EmailTemplate object</param> protected void FillFieldsList(EmailTemplate emailTemplateObj) { ListItem newItem = null; // Insert double opt-in activation link if ((emailTemplateObj != null) && (emailTemplateObj.TemplateType == EmailTemplateType.DoubleOptIn)) { newItem = new ListItem(GetString("NewsletterTemplate.MacroActivationLink"), IssueHelper.MacroActivationLink); lstInsertField.Items.Add(newItem); } newItem = new ListItem(GetString("general.email"), IssueHelper.MacroEmail); lstInsertField.Items.Add(newItem); newItem = new ListItem(GetString("NewsletterTemplate.MacroFirstName"), IssueHelper.MacroFirstName); lstInsertField.Items.Add(newItem); newItem = new ListItem(GetString("NewsletterTemplate.MacroLastName"), IssueHelper.MacroLastName); lstInsertField.Items.Add(newItem); newItem = new ListItem(GetString("NewsletterTemplate.MacroUnsubscribeLink"), IssueHelper.MacroUnsubscribeLink); lstInsertField.Items.Add(newItem); }
public static void EditNewEmailTemplate(PanelPreferences preferences, EmailTemplate emailTemplate, string eid) { var communicationViewUrl = new Uri(preferences.PanelAdminUrl + "EmailWindow.aspx"); string communicationViewFormParams = GetEmailEditViewFormParams(emailTemplate, eid); var bytes = Encoding.ASCII.GetBytes(communicationViewFormParams); var communicationsRequest = AutomationHelper.CreatePost(communicationViewUrl, preferences.CookieJar); communicationsRequest.Referer = preferences.PanelAdminUrl + "EmailWindow.aspx"; communicationsRequest.ContentLength = bytes.Length; using (Stream os = communicationsRequest.GetRequestStream()) { os.Write(bytes, 0, bytes.Length); } var response = (HttpWebResponse)communicationsRequest.GetResponse(); string pageSource = String.Empty; using (var reader = new StreamReader(response.GetResponseStream())) { pageSource = reader.ReadToEnd(); } response.Close(); }
public IActionResult Put(EmailTemplate entityModel) { var emailTemplate = _emailTemplateService.FirstOrDefault(x => x.Id == entityModel.Id); //save it and respond emailTemplate.Subject = entityModel.Subject; emailTemplate.Name = entityModel.Name; emailTemplate.Template = entityModel.Template; emailTemplate.AdministrationEmail = entityModel.AdministrationEmail; emailTemplate.IsMaster = entityModel.IsMaster; //a system template can't be used as master if (entityModel.EmailAccountId > 0) { emailTemplate.EmailAccountId = entityModel.EmailAccountId; } _emailTemplateService.Update(emailTemplate); VerboseReporter.ReportSuccess("Sửa EmailTemplate thành công", "post"); return(RespondSuccess(emailTemplate)); }
internal ScenarioOptions(SendConfirmEmailMessageCommand command) { Command = command; Person = new Person { RevisionId = 6, Emails = new[] { new EmailAddress { Value = command.EmailAddress, }, }, }; EmailMessage = new EmailMessage { ToPerson = Person, Number = 7, }; EmailTemplate = new EmailTemplate(); }
public virtual Task SendTemplateEmail(Dictionary <string, string> substitutions, string subject, EmailTemplate emailTemplate, string fromEmail, string fromName, string toEmail, string toName) { if (toEmail == null) { throw new ArgumentNullException(nameof(toEmail), $"{toName} does not have an email assigned"); } return(SendTemplateEmail(substitutions, subject, emailTemplate, fromEmail, fromName, new List <EmailAddress> { new EmailAddress(toEmail, toName) })); }
public void Send(EmailTemplate template, params string[] recipients) { if (template == null) { throw new ArgumentNullException(nameof(template)); } if (recipients == null) { throw new ArgumentNullException(nameof(recipients)); } if (recipients.Length == 0) { throw new ArgumentException(@"Value cannot be an empty collection.", nameof(recipients)); } var request = new SendEmailRequest(template, recipients, _from); Task response = _api.RequestAsync("messages/send", request); response.Wait(); }
/// <summary> /// Handler for the SendNonWinnerEmailCommand /// </summary> /// <param name="command">The SendNonWinnerEmailCommand</param> public void HandleCommand(SendNonWinnerEmailCommand command) { List <string> nonWinners = eventRepository.GetAllNonWinnersForEvent(command.EventId); //Query for the email template EmailTemplate nonWinnerEmail = emailRepository.GetEmailTemplate(new EmailTemplate(Enumeration.TryFindById <EmailTemplateEnum>(3).DisplayValue)); if (nonWinners != null && nonWinners.Any()) { foreach (string email in nonWinners) { nonWinnerEmail.EmailSubject = nonWinnerEmail.EmailSubject.Replace("@@EventName@@", command.EventName); emailRepository.SendEmail(new Email( Me2YouConstants.EmailProfile, email, nonWinnerEmail.EmailSubject, nonWinnerEmail.EmailBody)); } } }
private static async Task <Response> SendGridMailForTemplate(EmailTemplate emailTemplate, string body = null, string destinationEmail = null, string destinationName = null, string subject = null) { var bd = body != null ? body : emailTemplate.EmailTemplateEmailBody.ToString(); return (await SendGridMail( new SendGridMessage() { #if DEBUG From = new EmailAddress("*****@*****.**", "fake argigero"), #else From = new EmailAddress(emailTemplate.EmailTemplateSenderEmail, emailTemplate.EmailTemplateSenderName), #endif Subject = subject ?? emailTemplate.EmailTemplateSubject, PlainTextContent = StripHTML(bd), HtmlContent = string.IsNullOrEmpty(bd) ? string.Empty : bd, }, destinationEmail ?? emailTemplate.EmailTemplateRecipientEmail , destinationName)); }
public void ShouldQueueEmail2Parm() { DateTime now = DateTime.Now; string expectedEmail = "*****@*****.**"; EmailTemplate emailTemplate = new EmailTemplate() { Id = Guid.Parse("93895b38-cc48-47a3-b592-c02691521b28"), CreatedBy = "Mocked Created By", CreatedDateTime = now, UpdatedBy = "Mocked Updated By", UpdatedDateTime = now, Subject = "Mock Subject", Body = "Mock Body", From = "*****@*****.**", }; Guid expectedEmailId = Guid.Parse("389425bc-0380-467f-b003-e03cfa871f83"); var mockLogger = new Mock <ILogger <EmailQueueService> >(); var mockJobclient = new Mock <IBackgroundJobClient>(); var mockEmailDelegate = new Mock <IEmailDelegate>(); mockEmailDelegate.Setup(s => s.GetEmailTemplate(It.IsAny <string>())).Returns(emailTemplate); mockEmailDelegate.Setup(s => s.InsertEmail(It.IsAny <Email>(), true)).Callback <Email, bool>((email, b) => email.Id = expectedEmailId); var mockMessagingVerificationDelegate = new Mock <IMessagingVerificationDelegate>(); var mockWebHosting = new Mock <IWebHostEnvironment>(); IEmailQueueService emailService = new EmailQueueService( mockLogger.Object, mockJobclient.Object, mockEmailDelegate.Object, mockMessagingVerificationDelegate.Object, mockWebHosting.Object); emailService.QueueNewEmail(expectedEmail, string.Empty, true); mockJobclient.Verify(x => x.Create( It.Is <Job>(job => job.Method.Name == "SendEmail" && (Guid)job.Args[0] == expectedEmailId), It.IsAny <EnqueuedState>())); mockEmailDelegate.Verify(x => x.InsertEmail(It.Is <Email>(email => email.Id == expectedEmailId && email.To == expectedEmail && email.Subject == emailTemplate.Subject && email.Body == emailTemplate.Body), true)); }
public void Startup() { this.template = new EmailTemplate { Id = 1, Code = "test", Title = "title", Subject = "#$AppName#", IsSystem = true, From = "#$UserEmail#", Notes = "Just a note", Message = "#$UserName#", Parameters = new List <TemplateParameter>() }; var param = new TemplateParameter { Id = 10, Title = "Custom", Notes = "Template note", Template = this.template }; this.template.Parameters.Add(param); var config = new BBWTConfig { App = new AppConfig { Name = "Test Application" } }; var user = new User { Name = "*****@*****.**", FirstName = "John", Surname = "Green" }; var templateService = new Mock <IEmailTemplateService>(); var configService = new Mock <IConfigService>(); var membershipService = new Mock <IMembershipService>(); templateService.Setup(s => s.GetTemplateByCode("test")).Returns(this.template); membershipService.Setup(s => s.GetCurrentUser()).Returns(user); configService.Setup(s => s.Settings).Returns(config); this.composer = new EmailComposer(templateService.Object, configService.Object, membershipService.Object); }
/// <summary> /// Return email template /// </summary> /// <param name="Code"></param> /// <returns></returns> public static EmailTemplate GetEmailTemplate(string Code) { //Accessing DB Layer DbCommand dbCommand = db.GetStoredProcCommand("prSelEmailTemplate"); //Adding Input parameters db.AddInParameter(dbCommand, "Code", DbType.String, Code); EmailTemplate objEmailTemplate = new EmailTemplate(); IDataReader dr = null; try { // Execute command dr = db.ExecuteReader(dbCommand); //Set Output if (dr.Read()) { objEmailTemplate.Id = Convert.ToInt32(dr["Id"]); objEmailTemplate.Text = dr["Text"].ToString(); objEmailTemplate.RespCode = 0; } else { objEmailTemplate.RespCode = 3; } } catch (Exception ex) { objEmailTemplate.RespCode = 1; objEmailTemplate.RespDesc = ex.ToString(); } finally { dr.Close(); } return(objEmailTemplate); }
public void SetUp() { var generateResetPasswordTokenResult = new GenerateResetPasswordTokenResult { Email = Test, Token = Test, Username = Test }; var emailTemplate = new EmailTemplate { TemplateName = Test, Subject = Test, Content = Test, AllowedParameters = new[] { "{{username}}", "{{callbackUrl}}" } }; request = new SendResetPasswordByAdminRequest { Login = Test }; userTokenGenerator = new Mock <IUserTokenGenerator>(); cryptoService = new Mock <ICryptoService>(); emailSender = new Mock <IEmailSender>(); emailTemplateGenerator = new Mock <IEmailTemplateGenerator>(); configuration = new Mock <IConfiguration>(); userTokenGenerator.Setup(c => c.GenerateResetPasswordToken(It.IsAny <string>())) .ReturnsAsync(generateResetPasswordTokenResult); cryptoService.Setup(c => c.Encrypt(It.IsAny <string>())) .Returns(Test); configuration.Setup(c => c.GetSection(It.IsAny <string>())) .Returns(new Mock <IConfigurationSection>().Object); emailTemplateGenerator.Setup(etg => etg.FindEmailTemplate(It.IsAny <string>())) .ReturnsAsync(emailTemplate); emailSender.Setup(es => es.Send(It.IsAny <EmailMessage>())) .ReturnsAsync(true); sendResetPasswordByAdminCommand = new SendResetPasswordByAdminCommand(userTokenGenerator.Object, cryptoService.Object, emailSender.Object, emailTemplateGenerator.Object, configuration.Object); }
private void SendEmails(EmailTemplate emailId, List <int> userIds, Dictionary <string, string> customKeys, List <int> coursesInAssignment, int assignmentId) { Email template = db.Emails.FirstOrDefault(e => e.emailId == (int)emailId); foreach (int userId in userIds) { //if user has completed this assigned activity then skip List <int?> coursesCompleted = db.Assignment_CoursesCompletedGet(assignmentId, userId).ToList(); IEnumerable <int?> coursesIncomplete = coursesInAssignment.Cast <int?>().Except(coursesCompleted); if (coursesIncomplete.Count() == 0) { continue; } //this user has not completed the assigned set... spam him/her User userInfo = db.Users.FirstOrDefault(u => u.userId == userId); string userEmail = userInfo.email; string body = template.body; string subject = template.subject; //handle name out of loop body = Utilities.ReplaceStringCaseInsensitive(body, "{FirstName}", userInfo.firstName); body = Utilities.ReplaceStringCaseInsensitive(body, "{LastName}", userInfo.lastName); foreach (KeyValuePair <string, string> code in customKeys) { body = Utilities.ReplaceStringCaseInsensitive(body, code.Key, code.Value); subject = Utilities.ReplaceStringCaseInsensitive(subject, code.Key, code.Value); } body = "<span style=\"font-family: Arial;font-size: 10pt;\">" + body + "</span>"; WriteMsg("Sending email " + emailId + " to " + userEmail); if (req.Url.Port == 443 || (req.Url.Port == 80 && req.Url.Host != "localhost")) { Utilities.SendEmail(ConfigurationManager.AppSettings.Get("DoNotReplyEmail"), userEmail, subject, body); } } }
private void SendConfirmationEmail(List <MyMergeData> mergeData) { var emailOptions = MyContent.EmailOptions; var template = new EmailTemplate(emailOptions.TemplateID); var email = new EMail(template); email.Save(); var name = string.Empty; var emailAddress = string.Empty; var myData = mergeData[0]; if (myData != null) { name = string.Concat(myData.DonorFirstName, " ", myData.DonorLastName).Trim(); emailAddress = myData.DonorEmail; if (!string.IsNullOrWhiteSpace(emailAddress)) { MergeFieldsData[] provider = { new MergeFieldsData(mergeData.ToArray()) }; var html = emailOptions.HTML; email.ContentHTML = Expand(emailOptions.HTML, mergeData.ToArray()); email.FromAddress = emailOptions.FromAddress; email.FromDisplayName = emailOptions.FromName; email.Subject = emailOptions.Subject; email.ReplyAddress = emailOptions.ReplyAddress; try { email.Send(emailAddress, name, API.Users.CurrentUser.RaisersEdgeID, API.Users.CurrentUser.UserID, provider, this.Page); } catch (Exception ex) { Common.LogErrorToDB(ex, false); } } } }
public ReturnType UpdateEmailTemplate(string emailtemplateCode, EmailTemplate emailtemplate) { try { using (AladingEntities alading = new AladingEntities(AppSettings.GetConnectionString())) { /*var result = alading.EmailTemplate.Where(p => p.EmailTemplateID == emailtemplateID).ToList();*/ var result = alading.EmailTemplate.Where(p => p.EmailTemplateCode == emailtemplateCode).ToList(); if (result.Count == 0) { return ReturnType.NotExisted; } EmailTemplate ob = result.First(); ob.EmailTemplateCode = emailtemplate.EmailTemplateCode; ob.Name = emailtemplate.Name; ob.Type = emailtemplate.Type; ob.Creator = emailtemplate.Creator; ob.Content = emailtemplate.Content; ob.CreationTime = emailtemplate.CreationTime; if (alading.SaveChanges() == 1) { return ReturnType.Success; } else { return ReturnType.OthersError; } } } catch (SqlException sex) { return ReturnType.ConnFailed; } catch (System.Exception ex) { return ReturnType.OthersError; } }
public When_EmailService_Is_Called_To_Send_Email() { var configuration = new MatchingConfiguration { SendEmailEnabled = true, GovNotifyApiKey = "TestApiKey" }; _notificationsApi = Substitute.For <IAsyncNotificationClient>(); var logger = Substitute.For <ILogger <EmailService> >(); var config = new MapperConfiguration(c => c.AddMaps(typeof(EmailHistoryMapper).Assembly)); var mapper = new Mapper(config); var emailTemplate = new EmailTemplate { Id = 1, TemplateId = "1599768C-7D3D-43AB-8548-82A4E5349468", TemplateName = "TemplateName" }; _emailTemplateRepository = Substitute.For <IRepository <EmailTemplate> >(); var emailHistoryRepository = Substitute.For <IRepository <EmailHistory> >(); _emailTemplateRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <EmailTemplate, bool> > >()).Returns(emailTemplate); var functionLogRepository = Substitute.For <IRepository <FunctionLog> >(); var emailService = new EmailService(configuration, _notificationsApi, _emailTemplateRepository, emailHistoryRepository, functionLogRepository, mapper, logger); _toAddress = "*****@*****.**"; var tokens = new Dictionary <string, string> { { "contactname", "name" } }; const string templateName = "TestTemplate"; emailService.SendEmailAsync(templateName, _toAddress, null, null, tokens, "System").GetAwaiter().GetResult(); }
public static string Mail(string emailTo, EmailTemplate Template) { string Res = string.Empty; try { MailMessage mail = new MailMessage(); if (emailTo.Contains(',')) { var emailList = emailTo.Split(','); foreach (var item in emailList) { mail.To.Add(item); } } else { mail.To.Add(emailTo); } mail.From = new MailAddress("*****@*****.**"); mail.Subject = Template.Header = "Please provide Subject here"; // Set Mail's Subject here mail.Body = Template.TemplateBody = "Please provide Body here"; // Set Mail's Body here mail.IsBodyHtml = true; mail.Priority = MailPriority.High; SmtpClient smtp = new SmtpClient(); smtp.Host = "mail.esolzdev.com"; smtp.Port = 25; smtp.UseDefaultCredentials = false; smtp.Credentials = new System.Net.NetworkCredential("*****@*****.**", "Pyc8a1!6"); smtp.EnableSsl = false; smtp.Send(mail); Res = "Success! Mail has been sent"; } catch (Exception ex) { Res = "Failed!" + ex.Message; } return(Res); }
private async Task <Result> SendMessage(EmailTemplate template, string bodyMessage, IEnumerable <string> mailingList) { var message = new MimeMessage(); message.From.Add(new MailboxAddress(emailSettings.Sender, emailSettings.Username)); message.To.AddRange(mailingList.Select(m => new MailboxAddress(string.Empty, m))); message.Subject = template.Subject; message.Body = new TextPart(MimeKit.Text.TextFormat.Html) { Text = bodyMessage }; message.Importance = template.Importance ? MessageImportance.High : MessageImportance.Normal; try { using (var smtpClient = new SmtpClient()) { smtpClient.AuthenticationMechanisms.Clear(); smtpClient.AuthenticationMechanisms.Add("NTLM"); smtpClient.ServerCertificateValidationCallback = (s, c, h, e) => true; await smtpClient.ConnectAsync(emailSettings.Host, Convert.ToInt32(emailSettings.Port), SecureSocketOptions.Auto); await smtpClient.AuthenticateAsync(new NetworkCredential(emailSettings.Username, emailSettings.Password)); await smtpClient.SendAsync(message); await smtpClient.DisconnectAsync(true); } logger.Information("The email was successfully sent", message); return(Result.Ok()); } catch (Exception e) { var error = $"An error occurred while sending the message: \"{message}\". Error: {e.Message}"; return(Result.Failure(error)); } }
public async Task SendLineItemStatusChangeEmail(LineItemStatusChange lineItemStatusChange, List <HSLineItem> lineItems, string firstName, string lastName, string email, EmailDisplayText lineItemEmailDisplayText) { var productsList = lineItems.Select(SendgridMappers.MapLineItemToProduct).ToList(); var templateData = new EmailTemplate <LineItemStatusChangeData>() { Data = new LineItemStatusChangeData { FirstName = firstName, LastName = lastName, Products = productsList, }, Message = new EmailDisplayText() { EmailSubject = lineItemEmailDisplayText?.EmailSubject, DynamicText = lineItemEmailDisplayText?.DynamicText, DynamicText2 = lineItemEmailDisplayText?.DynamicText2 } }; await SendSingleTemplateEmail(_settings?.SendgridSettings?.FromEmail, email, _settings?.SendgridSettings?.LineItemStatusChangeTemplateID, templateData); }
public async Task <IActionResult> AddEmailTemplate([FromBody] EmailTemplateViewModel emailTemplate) { if (ModelState.IsValid) { var group = await this._unitOfWork.UserGroups.GetGroupByNameAsync(emailTemplate.GroupName); if (await IsGroupAdmin(group.Name)) { EmailTemplate newEmailTemplate = Mapper.Map <EmailTemplate>(emailTemplate); newEmailTemplate.Group = group; this._unitOfWork.EmailTemplates.Add(newEmailTemplate); await this._unitOfWork.SaveChangesAsync(); return(new OkResult()); } else { return(new ChallengeResult()); } } return(BadRequest(ModelState)); }
public void ReplacesRazorInBothSubjectAndBody() { var emailTemplate = new EmailTemplate { Subject = "@Model.Subject Hello", Body = "@if (Model.IsTrue) { <p>@Model.TrueMessage</p> } else { <p>@Model.FalseMessage</p> }" }; var model = new { Subject = "Integration Test", TrueMessage = "It is true", FalseMessage = "A lie was told", IsTrue = true }; EmailMessage formatMessage = _emailTemplateFormatter.FormatMessage(emailTemplate, model, "*****@*****.**", "*****@*****.**", "From Me", emailTemplate.Id); Assert.AreEqual(model.Subject + " Hello", formatMessage.Subject); Assert.IsTrue(formatMessage.Body.Contains(model.TrueMessage)); Assert.IsFalse(formatMessage.Body.Contains(model.FalseMessage)); }
public ActionResult Create(Shipment shipment) { shipment.ReferenceNumber = ShipmentModel.GenerateReferenceNumber(shipment); shipment.ActualCollectionTime = shipment.PlannedCollectionTime; shipment.ActualTimeOfArrival = shipment.PlannedETA; shipment.CreateDate = shipment.ModifiedDate = DateTime.Now; if (ModelState.IsValid) { shipment.CreatedBy = User.Identity.Name; if (shipment.ReferralEnquiryID > 0) { var enquiry = db.Enquiries.Find(shipment.ReferralEnquiryID); if (enquiry == null) { return(RedirectToAction("Error")); } enquiry.Status = Enquiry.State.CLOSED; db.Entry(enquiry).State = EntityState.Modified; } db.Shipments.Add(shipment); db.SaveChanges(); if (shipment.InsuranceRequired) { shipment.Customer = db.Customers.Find(shipment.CustomerID); EmailTemplate.Send( "*****@*****.**", "*****@*****.**", "Shipment Insurance Request", EmailTemplate.PerpareInsuranceRequestEmail(shipment, @"~\views\EmailTemplate\InsuranceRequestEmail.html.cshtml"), true ); } return(RedirectToAction("Index")); } return(this.Create(shipment.CustomerID)); }
protected void btnAdd_Click(object sender, EventArgs e) { var emailTemplate = new EmailTemplate(); emailTemplate.CreatedOn = DateTime.Now; if (!FileUpload1.HasFile) { emailTemplate.EmailText = txtMailTemplate.InnerText; } else { emailTemplate.EmailText = UploadHtmlFile(); } emailTemplate.IsDelete = false; emailTemplate.Name = txtName.Text; emailTemplate.SheetId = Convert.ToInt32(ddlSheet.SelectedValue); emailTemplate.Subject = txtSubjectt.Text; _dbScheduler.EmailTemplates.InsertOnSubmit(emailTemplate); _dbScheduler.SubmitChanges(); txtMailTemplate.InnerText = ""; txtName.Text = ""; txtSubjectt.Text = ""; }
public Email(EmailTemplate emailTemplate) { EmailTemplate = emailTemplate; State = EmailState.Draft; foreach (var emailTemplatePart in emailTemplate.Parts) { switch (emailTemplatePart) { case HtmlEmailTemplatePart htmlEmailTemplatePart: _parts.Add(new HtmlEmailPart(htmlEmailTemplatePart.Html)); break; case VariableEmailTemplatePart variableEmailTemplatePart: _parts.Add(new VariableEmailPart(variableEmailTemplatePart.VariableType, variableEmailTemplatePart.Value)); break; default: throw new EmailMakerException("Unsupported email template part: " + emailTemplatePart.GetType()); } } }
public EmailTemplate Parse(string readAllText) { XDocument xdoc = XDocument.Parse(readAllText); var xml = xdoc.Element(XName.Get("emailTemplate", ns)); var template = new EmailTemplate() { Name = xml.Element(XName.Get("name", ns)).Value, From = xml.Element(XName.Get("from", ns)).Value, Subject = xml.Element(XName.Get("subject", ns)).Value, Text = xml.Element(XName.Get("text", ns)) != null ? xml.Element(XName.Get("text", ns)).Value : null, Html = xml.Element(XName.Get("html", ns)) != null ? xml.Element(XName.Get("html", ns)).Value : null, Culture = xml.Element(XName.Get("culture", ns)) != null ? xml.Element(XName.Get("culture", ns)).Value : null }; return template; }
public void Context() { _persistEmailTemplate(); var queryHandler = new GetAllEmailTemplateQueryHandler(UnitOfWork); _result = queryHandler.Execute <EmailTemplateDetailsDto>(new GetAllEmailTemplateQuery { UserId = _user.Id }); void _persistEmailTemplate() { _user = UserBuilder.New.Build(); UnitOfWork.Save(_user); _emailTemplate = EmailTemplateBuilder.New .WithInitialHtml("html") .WithName("template name") .WithUserId(_user.Id) .Build(); UnitOfWork.Save(_emailTemplate); } }
/// <summary> /// Sets the serial key for this digital good /// </summary> /// <param name="serialKeyData">Serial key to set</param> /// <param name="sendFulfillmentEmail">If <b>true</b> fulfillment email is sent</param> public void SetSerialKey(string serialKeyData, bool sendFulfillmentEmail) { if (IsSerialKeyAcquired()) { if (this.SerialKeyData == serialKeyData) { return; } } this.SerialKeyData = serialKeyData; if (sendFulfillmentEmail && !string.IsNullOrEmpty(serialKeyData)) { //initiate fulfillment email EmailTemplate template = EmailTemplateDataSource.Load(DigitalGood.FulfillmentEmailId); if (template != null) { SendEmail(template); } } }
public IActionResult OnGet() { var claimsIdentity = (ClaimsIdentity)User.Identity; var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier); var user = _unitofwork.ApplicationUser.GetFirstOrDefault(i => i.Id == claim.Value); string s = string.Join(" | ", RecoveryCodes); EmailTemplate emailTemplate = _db.EmailTemplates.Where(e => e.Id == Convert.ToInt32(EnEmailTemplate.TwoFAmail)).FirstOrDefault(); emailTemplate.Content = emailTemplate.Content.Replace("###Name###", user.Name); emailTemplate.Content = emailTemplate.Content.Replace("###Code###", s); _emailSender.SendEmailAsync(user.Email, emailTemplate.Subject, emailTemplate.Content); if (RecoveryCodes == null || RecoveryCodes.Length == 0) { return(RedirectToPage("./TwoFactorAuthentication")); } return(Page()); }
public async Task SaveAsync(EmailTemplate template) { var dbTemplate = await FindByNameAsync(template.TemplateName); using var trans = await db.Database.BeginTransactionAsync(); if (dbTemplate != null) { template.Id = dbTemplate.Id; db.EmailTemplates.Remove(dbTemplate); await db.SaveChangesAsync(); } else { template.Id = Guid.NewGuid().ToString(); } await db.EmailTemplates.AddAsync(template); await db.SaveChangesAsync(); await trans.CommitAsync(); }
public static bool AcceptRequisition(int employeeID, int requisitionID, String remarks) { bool result = false; LussisEntities context = new LussisEntities(); Employee approver = context.Employees.Where(emp => emp.EmpNo == employeeID).FirstOrDefault(); Requisition requisition = context.Requisitions.Where(req => req.ReqNo == requisitionID).FirstOrDefault(); // Process only if all values are present in the database if (approver != null && requisition != null) { requisition.Remarks = remarks; requisition.ApprovedBy = approver.EmpNo; requisition.DateReviewed = DateTime.Now.Date; requisition.Status = "Approved"; context.SaveChanges(); // Send Email EmailBackend.sendEmailStep( requisition.EmployeeWhoIssued.Email, EmailTemplate.GenerateRequisitionStatusChangedEmailSubject( requisition.ReqNo.ToString(), requisition.Status), EmailTemplate.GenerateRequisitonStatusChangedEmail( requisition.EmployeeWhoIssued.EmpName, requisition.ReqNo.ToString(), approver.EmpName, requisition.Status, requisition.Remarks) ); // Mark as sucessful result = true; } // Return operation result return(result); }
private EmailMessage Format(List <EmailJob> jobs, EmailTemplate template, App app, User user, List <EmailFormattingError> errors, bool noCache) { var context = CreateContext(jobs.Select(x => x.Notification), app, user); var subject = string.Empty; if (!string.IsNullOrWhiteSpace(template.Subject)) { subject = FormatSubject(template.Subject, context, errors) !; } string?bodyText = null; if (!string.IsNullOrWhiteSpace(template.BodyText)) { bodyText = FormatText(template.BodyText, context, jobs, errors) !; } string?bodyHtml = null; if (!string.IsNullOrWhiteSpace(template.BodyHtml)) { bodyHtml = FormatBodyHtml(template.BodyHtml, context, jobs, user.EmailAddress !, errors, noCache) !; } var message = new EmailMessage { BodyHtml = bodyHtml, BodyText = bodyText, FromEmail = template.FromEmail.OrDefault(jobs[0].FromEmail !), FromName = template.FromEmail.OrDefault(jobs[0].FromName !), Subject = subject, ToEmail = user.EmailAddress !, ToName = user.FullName, }; return(message); }
public async void SendRecoupmentProcessedEmail( EmailRequestWithUrl <RecoupmentProcessingNotificationViewModel> emailRequest, EmailTemplate templateType, string subject, bool appendFooter = true) { var body = _emailer.RenderTemplate(templateType, emailRequest) + (appendFooter ? _emailer.RenderTemplate("GeneralMailFooter") : string.Empty); using (var mailMessage = new MailMessage()) { mailMessage.Body = body; mailMessage.IsBodyHtml = true; mailMessage.Subject = subject; if (emailRequest.From != null) { mailMessage.From = emailRequest.From; } emailRequest.To.ToList().ForEach(mailMessage.To.Add); emailRequest.CC.ToList().ForEach(mailMessage.CC.Add); await _emailer.SendEmailAsync(mailMessage); } }
public async Task SendForgotPwd(ForgotPasswordRes req) { var email = new EmailTemplate { To = To, //To = "*****@*****.**", Bcc = Bcc, Subject = "EMECI - Recordatorio de contraseña", Title = "Protege tu salud y la de tu familia a través de EMECI", TypeEmailToSend = EmailTemplate.TypeEmail.forgotPwd, ForgotPwd = req }; try { await email.SendAsync(); } catch (Exception ex) { Log.Write($"EmailService, SendForgotPwd=> {ex.Message}"); } }
private async Task <string?> FormatHtml(EmailTemplate template, TemplateContext context, IEnumerable <UserNotification> notifications, bool noCache) { var markup = template.BodyHtml; if (string.IsNullOrWhiteSpace(markup)) { return(markup); } var result = RenderTemplate(markup, context, noCache); var html = await MjmlToHtmlAsync(result); if (string.IsNullOrWhiteSpace(html)) { return(html); } ValidateResult(markup, html, notifications); return(html); }
/// <summary> /// Handles the Click event of the btnSave control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void btnSave_Click( object sender, EventArgs e ) { EmailTemplateService emailTemplateService = new EmailTemplateService(); EmailTemplate emailTemplate; int emailTemplateId = int.Parse(hfEmailTemplateId.Value); if ( emailTemplateId == 0 ) { emailTemplate = new EmailTemplate(); emailTemplateService.Add( emailTemplate, CurrentPersonId ); } else { emailTemplate = emailTemplateService.Get( emailTemplateId ); } emailTemplate.Category = tbCategory.Text; emailTemplate.Title = tbTitle.Text; emailTemplate.From = tbFrom.Text; emailTemplate.To = tbTo.Text; emailTemplate.Cc = tbCc.Text; emailTemplate.Bcc = tbBcc.Text; emailTemplate.Subject = tbSubject.Text; emailTemplate.Body = tbBody.Text; if ( !emailTemplate.IsValid ) { // Controls will render the error messages return; } emailTemplateService.Save( emailTemplate, CurrentPersonId ); BindFilter(); BindGrid(); pnlDetails.Visible = false; pnlList.Visible = true; }
///<summary>Inserts one EmailTemplate into the database. Provides option to use the existing priKey.</summary> public static long Insert(EmailTemplate emailTemplate,bool useExistingPK){ if(!useExistingPK && PrefC.RandomKeys) { emailTemplate.EmailTemplateNum=ReplicationServers.GetKey("emailtemplate","EmailTemplateNum"); } string command="INSERT INTO emailtemplate ("; if(useExistingPK || PrefC.RandomKeys) { command+="EmailTemplateNum,"; } command+="Subject,BodyText) VALUES("; if(useExistingPK || PrefC.RandomKeys) { command+=POut.Long(emailTemplate.EmailTemplateNum)+","; } command+= "'"+POut.String(emailTemplate.Subject)+"'," +"'"+POut.String(emailTemplate.BodyText)+"')"; if(useExistingPK || PrefC.RandomKeys) { Db.NonQ(command); } else { emailTemplate.EmailTemplateNum=Db.NonQ(command,true); } return emailTemplate.EmailTemplateNum; }
public void TemplateProcessor_TokensAreReplaced() { EmailTemplate template = new EmailTemplate() { Name = "template name", Subject = "subject {token1}", Text = "text {token2}", Html = "html {token3}" }; TemplateProcessor processor = new TemplateProcessor(); var package = processor.CreatePackageFromTemplate(template, new NameValueCollection() { {"token1", "replacementvalue1"}, {"token2", "replacementvalue2"}, {"token3", "replacementvalue3"} }); Assert.That(package.Subject, Is.StringMatching("subject replacementvalue1")); Assert.That(package.Text, Is.StringMatching("text replacementvalue2")); Assert.That(package.Html, Is.StringMatching("html replacementvalue3")); }
public static string AddNewEmailTemplate(PanelPreferences preferences, EmailTemplate emailTemplate) { var communicationViewUrl = new Uri(preferences.PanelAdminUrl + "CommunicationsManagementView.aspx"); string communicationViewFormParams = GetCommunicationViewFormParams(emailTemplate); var bytes = Encoding.ASCII.GetBytes(communicationViewFormParams); var communicationsRequest = AutomationHelper.CreatePost(communicationViewUrl, preferences.CookieJar); communicationsRequest.Referer = preferences.PanelAdminUrl + "CommunicationsManagementView.aspx"; communicationsRequest.ContentLength = bytes.Length; using (Stream os = communicationsRequest.GetRequestStream()) { os.Write(bytes, 0, bytes.Length); } var response = (HttpWebResponse)communicationsRequest.GetResponse(); string pageSource = String.Empty; using (var reader = new StreamReader(response.GetResponseStream())) { pageSource = reader.ReadToEnd(); } string cookies = response.Headers["Set-Cookie"]; preferences.CookieJar.VcAuthentication = AutomationHelper.GetVcAuthentication(cookies); preferences.CookieJar.UniqueRequestId = AutomationHelper.GetReqId(cookies); response.Close(); return pageSource; }
//Handle button click event public void SendActivation_Click(Object sender, CommandEventArgs e) { if (e.CommandName == "SendActivation") { foreach (RepeaterItem ri in UserUnActivatedAccount.Items) { CheckBox chkID = (CheckBox)ri.FindControl("chkID"); Label User_name = (Label)ri.FindControl("User_name"); Label User_email = (Label)ri.FindControl("User_email"); Label User_guid = (Label)ri.FindControl("User_guid"); if (chkID != null) { if (chkID.Checked) { string UserName = User_name.Text.Trim(); string UserEmail = User_email.Text.Trim(); string UserGuid = User_guid.Text.Trim(); //Unfortunately, sending multiple emails to different recipients does not work in this code. //If you can figure out other solution, just drop me an email. //Instantiate emailtemplate object EmailTemplate SendeMail = new EmailTemplate(); SendeMail.LyricEmail = UserEmail; //Send the activation link SendeMail.SendActivationLink(UserName, UserGuid); SendeMail = null; Response.Redirect("confirmsendactivation.aspx"); } } } } }
public void SendingRecipe(Object s, EventArgs e) { //Instantiate emailtemplate object EmailTemplate SendeMail = new EmailTemplate(); SendeMail.ItemID = (int)Util.Val(Request.QueryString["id"]); SendeMail.ItemName = Request.QueryString["n"].ToString(); //Filters harmful scripts from input string. SendeMail.SenderName = Util.FormatTextForInput(Request.Form["txtFromName"]); SendeMail.SenderEmail = Util.FormatTextForInput(Request.Form["txtFromEmail"]); SendeMail.RecipientEmail = Util.FormatTextForInput(Request.Form["txtToEmail"]); SendeMail.RecipientName = Util.FormatTextForInput(Request.Form["toname"]); SendeMail.SendEmailRecipeToAFriend(); Panel1.Visible = false; lblsentmsg.Text = "Your message has been sent to " + SendeMail.RecipientEmail + "."; //Release allocated memory SendeMail = null; Util = null; }
public StandardEmail(EmailTemplate template) { Properties = new Dictionary<string, string>(); TemplatePath = GetTemplatePath(Enum.GetName(typeof (EmailTemplate), template)); }
private static string GetEmailEditViewFormParams(EmailTemplate emailTemplate, string eid) { string callBackMethod = "ServerSideLoadEmailById"; string Cart_Callback_Method_Param = eid; string formParameters = String.Format("Cart_Callback_Method={0}&Cart_Callback_Method_Param={1}", callBackMethod, Cart_Callback_Method_Param); return formParameters; }