internal MessageEntityDto BuildPaymentVerificationMessage(PaymentMessageVm payment) { MessageEntityDto message = null; int titleId = 301; EmailContent emailContent = _unitOfWork.EmailContent.Single(c => c.EmailTitleId == titleId); if (emailContent.EmailBody != null) { message = new MessageEntityDto(); message.FromHrRecordId = 1; message.ToMessageDetails = base.BuildToMessageDetails(payment.UserId); message.MessageSubject = string.Format(emailContent.EmailSubject); message.MessageDetails = string.Format(emailContent.EmailBody, payment.DealerName, payment.OrderId); message.SMSText = string.Format(emailContent.Smsbody, payment.DealerName, payment.OrderId); message.NotificationText = string.Format(emailContent.NotifcationBody, payment.OrderId); message.MessagingDate = DateTime.Now; message.ReferenceId = payment.OrderId; message.ReferenceType = 1; message.RedirectLink = ""; message.ReferenceDate = payment.OrderDate; message.EmailTitleId = emailContent.EmailTitleId ?? 0; message.EmailNotificationTypeId = 1; } return(message); }
public void CheckMailTest() { var email = new EmailContent() { Content = "kh_11111111" }; var filter = new SendCustomerIDFilter(); var result = filter.CheckMail(email); Assert.AreEqual(result.Status, EmailStatus.NotViolated); email = new EmailContent() { Content = "aksjfh akjfhkasjdfh aksjdfh kfajsf kajshdfaf 11111 1111" }; result = filter.CheckMail(email); Assert.IsTrue(result.Status == EmailStatus.NotViolated); email = new EmailContent() { Content = "aksjfh akjfhkasjdfh kh_123456 aksjdfh kfajsf kajshdfaf 11111 1111" }; result = filter.CheckMail(email); Assert.IsTrue(result.Status == EmailStatus.Violated); }
public static void SendEmail(Usuario Usuario, EmailContent emailContent) { var fromAddress = new MailAddress("*****@*****.**", "SCAAD UABC"); var toAddress = new MailAddress(Usuario.Email, Usuario.UserName); const string fromPassword = "******"; var smtp = new SmtpClient { Host = "smtp.gmail.com", Port = 587, EnableSsl = true, DeliveryMethod = SmtpDeliveryMethod.Network, Credentials = new NetworkCredential(fromAddress.Address, fromPassword), Timeout = 20000 }; using (var message = new MailMessage(fromAddress, toAddress) { Subject = emailContent.Subject, Body = emailContent.Body, IsBodyHtml = true }) { smtp.Send(message); } }
internal MessageEntityDto BuildOrderConfirmationMessage(OrderMessageVm order) { MessageEntityDto message = null; int titleId = 101; EmailContent emailContent = _unitOfWork.EmailContent.Single(s => s.EmailTitleId == titleId); if (emailContent.EmailBody != null) { //DealerName={0}, Order No={1} message = new MessageEntityDto(); message.FromHrRecordId = 1; message.ToMessageDetails = base.BuildToMessageDetails(order.UserId); //message.CcMessageDetails = BuildCcMessageDetails(); message.MessageSubject = string.Format(emailContent.EmailSubject); message.MessageDetails = string.Format(emailContent.EmailBody, order.DealerName, order.OrderNo); message.SMSText = string.Format(emailContent.Smsbody, order.DealerName, order.OrderNo); message.NotificationText = string.Format(emailContent.NotifcationBody, order.DealerName, order.OrderNo); message.MessagingDate = DateTime.Now; message.ReferenceId = order.OrderId; message.ReferenceType = 1; // message.MenuId = _messageService.MenuId; message.ModuleId = 1; message.RedirectLink = ""; message.ReferenceDate = order.OrderDate; message.EmailTitleId = emailContent.EmailTitleId ?? 0; message.EmailNotificationTypeId = 1; } return(message); }
// TODO: Get invoice email content // TODO: File upload support /// <summary> /// Remind your customer about an unpaid invoice by email. Reminder will be sent, only for the invoices which are in open or /// overdue status. /// </summary> /// <param name="invoiceId">The invoice to send a reminder for.</param> /// <param name="email">The content of the email to send to the customer.</param> /// <returns>A response indicating whether the response was successful.</returns> public async Task <bool> RemindCustomerAsync(string invoiceId, EmailContent email) { var response = await PostDataAsync <EmailContent, ZohoBooksMessage> (string.Format("{0}/paymentreminder", invoiceId), email, OrganizationIdFilter); return(response.Code == 0); }
private void SendResetPasswordEmail(AccountModel accountModel, IConfiguration configuration) { string subject = string.Format("{0} Email notification ... Password Reset to {1}!", configuration.ApplicationName(), configuration.SiteName()); string siteLink = configuration.PasswordResetUrl() + "?key=" + accountModel.ForgotPasswordKey.Value.ToString(); StringBuilder sb = new StringBuilder(); // Add email heading sb.Append(string.Format("Dear {0} User.", configuration.ApplicationName())); sb.Append("<br />"); sb.Append("<br />"); sb.Append(string.Format("This Email confirms that you have requested a password reset please click the below link to reset your password.")); sb.Append("<br />"); sb.Append(string.Format("<a href='{0}'>Click Here</a>", siteLink)); sb.Append("<br />"); EmailContent emailContent = new EmailContent { Configuration = configuration.EmailConfiguration(), From = configuration.InfoAddress(), To = new List <EmailAddress> { new EmailAddress { Address = accountModel.EmailAddress, Name = accountModel.Firstname + " " + accountModel.Lastname } }, Subject = subject, HtmlBody = sb.ToString() }; this.emailHandler.SendEmail(emailContent); }
public async Task SendGmail(EmailContent model) { var service = new GmailService(new BaseClientService.Initializer { HttpClientInitializer = GoogleCredential.FromAccessToken(token1), }); //send email var msg = new AE.Net.Mail.MailMessage { Subject = model.subject, Body = model.body, From = new MailAddress(name), }; string Mails = model.to; var recipients = Mails.Split(' '); foreach (var recipient in recipients) { msg.To.Add(new MailAddress(recipient)); msg.ReplyTo.Add(msg.From); var msgStr = new StringWriter(); msg.Save(msgStr); await service.Users.Messages.Send(new Message() { Raw = Base64UrlEncode(msgStr.ToString()) }, "me").ExecuteAsync(); } }
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByNameAsync(model.Email); if (user == null) { // Don't reveal that the user does not exist or is not confirmed return(Json("<div class='alert alert-success'>Success</div>")); } // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id); var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); //send email var recipient = new EmailRecipient(user.Email); var content = new EmailContent() .Title("Password Reset") .Button(callbackUrl, "#32c5d2", "#FFF", "Password Reset"); new Email(recipient, "Password Reset", content.ToHtml()).Send(); return(Json("<div class='alert alert-success'>Email sent</div>")); } // If we got this far, something failed, redisplay form return(Json("<div class='alert alert-danger'>FAILED</div>")); }
public bool AddSessionMail(Notification notification, Common.Entity.Session session) { User addedByUser = UserDataAccesor.GetUserById(notification.AddedBy); EmailContent emailContent = GetEmailContent(notification , addedByUser , notification.Title); foreach (var user in UnitOfWork.SessionRepository.GetSessionWithAttendees(session.Id).UserSessionMappings) { emailContent.EmailRecipients.Add(new EmailRecipient { EmailAddress = user.User1.Email, EmailRecipientType = (int)Common.Enumeration.EmailRecipientType.To }); } emailContent.EmailRecipients.Add(new EmailRecipient { EmailAddress = addedByUser.Email, EmailRecipientType = (int)Common.Enumeration.EmailRecipientType.CarbonCopy }); UnitOfWork.EmailRepository.Add(emailContent); //TODO:EmailRepository needs to be EmailContentRepository. return(UnitOfWork.Commit() > 0); }
public bool AddNewFeedbackMail(Notification notification, User addedFor, int feedbackId) { User addedByUser = UserDataAccesor.GetUserById(notification.AddedBy); EmailContent emailContent = GetEmailContent(notification , addedByUser , notification.Title); emailContent.EmailRecipients.Add(new EmailRecipient { EmailAddress = addedFor.Email, EmailRecipientType = (int)Common.Enumeration.EmailRecipientType.To }); foreach (var user in UnitOfWork.EmailAlertSubscriptionRepository.GetAllSubscribedMentors(addedFor.UserId) .Where(user => user.SubscribedByUserId != addedByUser.UserId)) { emailContent.EmailRecipients.Add(new EmailRecipient { EmailAddress = user.User.Email, EmailRecipientType = (int)Common.Enumeration.EmailRecipientType.CarbonCopy }); } UnitOfWork.EmailRepository.Add(emailContent); //TODO:EmailRepository needs to be EmailContentRepository. return(UnitOfWork.Commit() > 0); }
public async Task <FormElementActionResponse> PerformElementActionAsync(long tenantId, long elementId, FormElementActionRequest request, IPageContext context) { // Get form settings, domain and current page details FormElementSettings settings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId); Page page = await _pageService.ReadPageAsync(tenantId, context.PageId); WebDomain domain = await _domainService.ReadDomainByRedirectUrlAsync(tenantId, null); Tenant tenant = await _tenantService.ReadTenantAsync(tenantId); // Construct email IEnumerable <FormFieldLabelValue> labelValues = GetFormFieldLabelValues(settings, request); EmailContent content = GetEmailContent(page, labelValues); Email email = GetEmail(tenant, domain, page, settings, content); // Send finished email _emailService.Send(email); // Return response return(new FormElementActionResponse { Message = settings.SubmittedMessage }); }
protected void btnShowReport_Click(object sender, EventArgs e) { EmailContentDAL newContentDal = new EmailContentDAL(); UserSelection newSelection = new UserSelection(); EmailContent emailContent = newContentDal.GetEmailContentByID(BatchID, out newSelection); if (newSelection != null) { PopulateSelectionCriterion(newSelection); } if (emailContent != null) { PopulateEmailContent(emailContent); } EmailDeliveryDAL newDal = new EmailDeliveryDAL(); IList <EmailDelivery> emails = newDal.GetSendEmail(BatchID); gvEmailSend.PageIndex = 0; gvEmailSend.DataSource = emails; gvEmailSend.DataBind(); if (emails.Count > 10) { lblResult.Text = string.Format("Showing result(s) 1-10 of {0}", emails.Count.ToString()); } else if (emails.Count > 0) { lblResult.Text = string.Format("Showing result(s) 1-{0} of {0}", emails.Count.ToString()); } else { lblResult.Text = string.Empty; } }
static void Main(string[] args) { debugMode = File.Exists(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "debug.txt")); EmailConfig.SetRootPath(Environment.CurrentDirectory); EmailConfig.RefreshData(); ec = EmailConfig.EmailTemplates[EmailType.ReminderEmail.ToString()]; List <Employee> managers = EmployeeBLL.GetManagers(); foreach (Employee m in managers) { #if DEBUG //if (m.Email.ToLower() != "*****@*****.**") // continue; #endif if (m.IsActive) { //Console.WriteLine(m.FirstName + " " + m.LastName); if (SendReminderEmail(m)) { Info("Email sent out!"); #if DEBUG //break; #endif } } } #if DEBUG Console.WriteLine("Done"); Console.ReadKey(); #endif }
public async Task SendEmail(EmailContent model, CancellationToken cancellationToken) { if (await checkCredential()) { //send email var msg = new AE.Net.Mail.MailMessage { Subject = model.subject, Body = model.body, From = new MailAddress(emailAddress), }; string Mails = model.to; var recipients = Mails.Split(' '); //var recipients = new[] { model.to}; foreach (var recipient in recipients) { msg.To.Add(new MailAddress(recipient)); msg.ReplyTo.Add(msg.From); var msgStr = new StringWriter(); msg.Save(msgStr); await service.Users.Messages.Send(new Message() { Raw = Base64UrlEncode(msgStr.ToString()) }, "me").ExecuteAsync(); } } }
private EmailContent GetEmailContent(EmailModel model) { var emailContent = new EmailContent(); switch (model.EmailType) { case EmailTypes.RegisteredSuccessfully: emailContent.Header = "Registrierung bei EventCorp"; emailContent.Body = "Vielen Dank, dass sich sich für uns entschieden haben"; break; case EmailTypes.Subscribed: break; case EmailTypes.Unsubscribed: break; case EmailTypes.ChangedUserData: break; case EmailTypes.ChangedPassword: break; case EmailTypes.UserRegistered: break; case EmailTypes.EventCreated: break; default: throw new ArgumentOutOfRangeException(); } return emailContent; }
public Email GetCreateUserEmail(Web web, Domain domain, string email, string alias, Token confirmToken) { // Get to recipients EmailAddress toEmailAddress = new EmailAddress { Email = email, DisplayName = alias }; IEnumerable <EmailAddress> toAddresses = Enumerable.Repeat(toEmailAddress, 1); IEnumerable <EmailAddress> configurationToAddresses = _emailConfigurationService.GetToEmailRecipients(); if (configurationToAddresses != null) { toAddresses.Concat(configurationToAddresses); } // Get from (and reply to) email address string host = _webHelperService.GetHostFromUrl(domain.Url, true).ToLower(); EmailAddress fromEmailAddress = new EmailAddress { Email = string.Format("donotreply@{0}", host), DisplayName = web.Name }; // Get email content EmailContent content = GetCreateUserEmailContent(web.TenantId, email, alias, confirmToken); // Return resulting email return(new Email { Content = content, FromAddress = fromEmailAddress, ToAddresses = toAddresses, ReplyToAddress = fromEmailAddress, BccAddresses = _emailConfigurationService.GetBccEmailRecipients() }); }
public IHttpActionResult SendEmail([FromBody] EmailContent content) { string body = "Name: " + content.Name + '\n' + "Subject: " + content.Subject + '\n' + "Email: " + content.Email + '\n' + "Message: " + content.Message; string username = ""; string password = ""; try { // Open the text file using a stream reader. using (StreamReader sr = new StreamReader(@"c:\contactUsEmailCredentials.txt")) { // Read the stream to a string, and write the string to the console. username = sr.ReadLine(); password = sr.ReadLine(); } } catch (Exception e) { return(BadRequest()); } var client = new SmtpClient("smtp.gmail.com", 587) { Credentials = new NetworkCredential(username, password), EnableSsl = true, }; client.Send(content.Email, "*****@*****.**", content.Subject, body); Console.WriteLine("Sent"); return(Ok()); }
public HttpResponseMessage GetReservationDetails(string emailBody) { Reservation reservation = new Reservation(); EmailContent emailContent = new EmailContent(); emailContent.EmailBody = emailBody; ClaimService service = new ClaimService(); try { reservation = service.GetReservationDetails(emailContent); if (reservation != null) { return(Request.CreateResponse <Reservation>(HttpStatusCode.OK, reservation)); } else { return(Request.CreateResponse(HttpStatusCode.BadRequest)); } } catch (Exception ex) { return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message)); } }
public IActionResult changecorrepondingauthor(int id) { var ArticleAuthorship = _context.ArticleAuthorships.SingleOrDefault(a => a.Id == id); Manuscript manuscript = _context.Manuscripts.Include(a => a.Journal).SingleOrDefault(m => m.Id == ArticleAuthorship.ManuscriptId); if (manuscript == null) { return(NotFound()); } manuscript.CorrespondingAuthorId = ArticleAuthorship.AuthorUserId; _context.Update(manuscript); _context.SaveChanges(); //========================================================================== EmailContent Reviewercontent = _context.EmailContents.Where(m => m.UniqueName.ToString() == "6a761361-e63c-47b6-a409-a0b7f4cb0971").SingleOrDefault(); StringBuilder MyStringBuilder = new StringBuilder("<h2 align='right'>اسم المجلة : "); MyStringBuilder.Append(manuscript.Journal.ArName); MyStringBuilder.Append("</h2>"); MyStringBuilder.Append("<br/>"); MyStringBuilder.AppendFormat(string.Format("<h3 align ='center'><a href='https://portal.arid.my/ar-LY/Manuscripts/Edit/{0}' >", manuscript.Id)); MyStringBuilder.Append("اضغط هنا للاطلاع على تفاصيل البحث"); MyStringBuilder.Append("</a></h3><hr/>"); BackgroundJob.Schedule(() => _emailSender.SendEmailAsync(ArticleAuthorship.Email, Reviewercontent.ArSubject, Reviewercontent.ArContent + MyStringBuilder.ToString()), TimeSpan.FromSeconds(10)); //========================================================================== return(RedirectToAction("Details", "Journals", new { /* routeValues, for example: */ id = manuscript.JournalId })); }
public bool RecallLeave(string pkleaveInfoID, string employeeID) { Log.Info(GlobalParams.StartRecallLeave); bool result = false; try { EmailConfig.SetRootPath(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath); LeaveInfo leaveInfo = LeaveBLL.GetLeaveInfoByID(pkleaveInfoID); result = LeaveBLL.RecallLeave(pkleaveInfoID); Employee employee = EmployeeBLL.GetEmployeeByID(employeeID); if (result && EmailConfig.EmailTemplates.ContainsKey(EmailType.ApplyLeave.ToString())) { Log.Info(GlobalParams.StartMail); EmailContent ec = EmailConfig.EmailTemplates[EmailType.RecallLeave.ToString()]; // {0} - Manager First Name // {1} - First Name // {2} - Hours // {3} - Leave Type // {4} - Reason // {5} - Description // {6} - Start // {7} - End // {8} - CARSAddress string emailBody = string.Format(ec.Body, employee.Manager.FirstName, employee.FirstName, leaveInfo.Hours, leaveInfo.Type.Name + " Leave", leaveInfo.Reason, leaveInfo.Description, leaveInfo.FirstStartTime.ToString(EmailConfig.TimeFormatInEmail), leaveInfo.LastEndTime.ToString(EmailConfig.TimeFormatInEmail), EmailConfig.CARSAddress); // {0} - First Name // {1} - Hours // {2} - Leave Type string emailTitle = string.Format(ec.Title, employee.FirstName, leaveInfo.Hours, leaveInfo.Type.Name + " Leave"); string employeeEmail = GetEmail(employee.Email); string managerEmail = GetEmail(employee.Manager.Email); List <string> ccList = new List <string>(); ccList.Add(employeeEmail); #if DEBUG managerEmail = "*****@*****.**"; #endif SendMail sender = new SendMail(managerEmail, ccList, EmailConfig.EmailAccount, emailBody, emailTitle, EmailConfig.Password, EmailConfig.Host); sender.Send(); Log.Info(GlobalParams.EndMail); } else { Log.Warn(GlobalParams.MailError); throw new Exception(GlobalParams.MailError); } } catch (Exception ex) { Log.Exception(ex.StackTrace); Log.Exception(ex.Message); throw ex; } Log.Info(GlobalParams.EndRecallLeave); return(result); }
public async Task <IActionResult> Create([Bind("Id,BadgeId,UserId,DateofRequest,DateofGrant,IsRejected,RejectCount,RejectReason,IsGranted")] UserBadge userBadge) { //if (ModelState.IsValid) //{ var Badge = _context.Badges .SingleOrDefault(m => m.Id == userBadge.BadgeId); var UserDetails = _context.Users .SingleOrDefault(m => m.Id == userBadge.UserId); userBadge.DateofGrant = DateTime.Now; userBadge.DateofGrant = DateTime.Now; userBadge.DateofRequest = DateTime.Now; userBadge.IsGranted = true; userBadge.RejectCount = 0; userBadge.IsRejected = false; //userBadge.UserId = id; _context.Add(userBadge); EmailContent content = _context.EmailContents.Where(m => m.Id == Badge.EmailContentId).SingleOrDefault(); await _emailSender.SendEmailAsync(UserDetails.Email, content.ArSubject, content.ArContent); await _context.SaveChangesAsync(); return(RedirectToAction("Index")); //ViewData["BadgeId"] = new SelectList(_context.Badges, "Id", "ArBadgeName", userBadge.BadgeId); ////ViewData["UserId"] = new SelectList(_context.Users, "Id", "ArName", userBadge.UserId); //ViewData["UserId"] = new SelectList(_userManager.Users.Where(u => u.Id == userBadge.UserId), "Id", "ArName"); //return View(userBadge); }
public async Task <IActionResult> Edit(int id, [Bind("Id,BadgeId,UserId,DateofRequest,DateofGrant,IsRejected,RejectCount,RejectReason,IsGranted")] UserBadge userBadge) { if (id != userBadge.Id) { return(NotFound()); } if (ModelState.IsValid) { try { var Badge = _context.Badges .SingleOrDefault(m => m.Id == userBadge.BadgeId); var UserDetails = _context.Users .SingleOrDefault(m => m.Id == userBadge.UserId); if (userBadge.IsGranted == true) { userBadge.DateofGrant = DateTime.Now; // EmailContent content = _context.EmailContents.Where(m => m.Id == 1).SingleOrDefault(); EmailContent content = _context.EmailContents.Where(m => m.Id == Badge.EmailContentId).SingleOrDefault(); await _emailSender.SendEmailAsync(UserDetails.Email, content.ArSubject, content.ArContent); } if (userBadge.IsRejected == true) { userBadge.RejectCount++; if (userBadge.BadgeId == 1) { EmailContent content = _context.EmailContents.Where(m => m.UniqueName.ToString() == "979f0462-f293-4223-909e-6b5c51bb91f5").SingleOrDefault(); await _emailSender.SendEmailAsync(UserDetails.Email, content.ArSubject, content.ArContent); } else { EmailContent content = _context.EmailContents.Where(m => m.UniqueName.ToString() == "21b9d8a1-1833-49a7-9d7e-c734c8d59529").SingleOrDefault(); //var Badge = _context.Badges.SingleOrDefault(a => a.Id == userBadge.BadgeId); string BadgeName = "�� ��� �������� ��� ����� " + Badge.ArBadgeName; await _emailSender.SendEmailAsync(UserDetails.Email, BadgeName, content.ArContent + userBadge.RejectReason); } } _context.Update(userBadge); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserBadgeExists(userBadge.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("Unapproved")); } //ViewData["BadgeId"] = new SelectList(_context.Badges, "Id", "ArBadgeName", userBadge.BadgeId); //ViewData["UserId"] = new SelectList(_context.Users, "Id", "ArName", userBadge.UserId); //ViewData["UserId"] = new SelectList(_userManager.Users.Where(u => u.Id == _userManager.GetUserId(User)), "Id", "ArName"); return(View(userBadge)); }
public void When_MessageDispatched_SendIsCalledOnClient() { //Given var smtpClientMock = mockRepository.Create <ISmtpClient>(); var sut = new EmailDispatcher(smtpClientMock.Object); var emailContent = new EmailContent { Body = "This is a body", Subject = "This is a subject", ToAddresses = new List <string> { "*****@*****.**" } }; var smtpSettings = new SmtpSettings { Host = "localhost", Port = 25, UseSsl = false, }; smtpClientMock.SetupAllProperties(); smtpClientMock.Setup(m => m.Send(It.IsAny <MailMessage>())).Verifiable(); //When sut.DispatchEmail(emailContent, smtpSettings); //Then smtpClientMock.Verify(m => m.Send(It.IsAny <MailMessage>()), Times.Once()); }
public Email GetCreatePostEmail(string email, string alias, long postId, int?page, string subject, string postAlias) { // Get to recipients EmailAddress toEmailAddress = new EmailAddress { Email = email, DisplayName = alias }; IEnumerable <EmailAddress> toAddresses = Enumerable.Repeat(toEmailAddress, 1); IEnumerable <EmailAddress> configurationToAddresses = _emailConfigurationService.GetToEmailRecipients(); if (configurationToAddresses != null) { toAddresses.Concat(configurationToAddresses); } // Get email content EmailContent content = GetCreatePostEmailContent(email, alias, postId, page, subject, postAlias); // Return resulting email return(new Email { Content = content, FromAddress = _emailConfigurationService.GetFromEmailRecipient(), ToAddresses = toAddresses, ReplyToAddress = _emailConfigurationService.GetReplyToEmailRecipient(), BccAddresses = _emailConfigurationService.GetBccEmailRecipients() }); }
public bool sendmail(EmailContent mailContent) { bool success = false; MailMessage message = new MailMessage(); message.From = new MailAddress(mailContent.from); message.IsBodyHtml = true; foreach (var recp in mailContent.recipients) { message.To.Add(recp.); } if (!string.IsNullOrEmpty(mailContent.cc)) { message.To.Add(new MailAddress(mailContent.cc)); } message.Subject = mailContent.SubjectLine; message.Body = mailContent.Body; SmtpClient client = new SmtpClient(); client.Send(message); return(success); }
public void SendMail(EmailSendConfigure emailConfig, EmailContent content) { //Construimos el Mensaje de email para ser enviado MailMessage msg = ConstructEmailMessage(emailConfig, content); Send(msg, emailConfig); }
public bool AddNewDiscussionMail(Notification notification) { User addedByUser = UserDataAccesor.GetUserById(notification.AddedBy); List <EmailAlertSubscription> subscriptionList = UnitOfWork.EmailAlertSubscriptionRepository .GetAllSubscribedMentors(addedByUser.UserId) .Where(x => x.SubscribedByUserId != addedByUser.UserId) .Distinct() .ToList(); if (!subscriptionList.Any()) { return(true); // escape the routine if no one is subscribed to this trainee. } EmailContent emailContent = GetEmailContent(notification, addedByUser, notification.Title); foreach (var user in subscriptionList) { emailContent.EmailRecipients.Add(new EmailRecipient { EmailAddress = user.User.Email, EmailRecipientType = (int)Common.Enumeration.EmailRecipientType.To }); } UnitOfWork.EmailRepository.Add(emailContent); return(UnitOfWork.Commit() > 0); }
public void SendEmail() { EmailClient client = CreateEmailClient(); #region Snippet:Azure_Communication_Email_Send // Create the email content var emailContent = new EmailContent("This is the subject"); emailContent.PlainText = "This is the body"; // Create the recipient list var emailRecipients = new EmailRecipients( new List <EmailAddress> { new EmailAddress( //@@ email: "<recipient email address>" //@@ displayName: "<recipient displayname>" /*@@*/ email: TestEnvironment.ToEmailAddress, /*@@*/ displayName: "Customer Name") }); // Create the EmailMessage var emailMessage = new EmailMessage( //@@ sender: "<Send email address>" // The email address of the domain registered with the Communication Services resource /*@@*/ sender: TestEnvironment.AzureManagedFromEmailAddress, emailContent, emailRecipients); SendEmailResult sendResult = client.Send(emailMessage); Console.WriteLine($"Email id: {sendResult.MessageId}"); #endregion Snippet:Azure_Communication_Email_Send Assert.False(string.IsNullOrEmpty(sendResult.MessageId)); }
public HttpResponseMessage GetExpenseDetails(string emailBody) { Expense expense = new Expense(); EmailContent emailContent = new EmailContent(); emailContent.EmailBody = emailBody; ClaimService service = new ClaimService(); try { expense = service.GetExpenseDetails(emailContent); if (expense != null) { return(Request.CreateResponse <Expense>(HttpStatusCode.OK, expense)); } else { return(Request.CreateResponse(HttpStatusCode.BadRequest)); } } catch (Exception ex) { return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message)); } }
public async Task SendCustomEmail_OkAsync(Role role) { using (var dbContext = InMemoryDatabaseHelper.GetDbContext()) { var user = await new ApplicationUserFactory(role).BuildAsync(dbContext); var emailContent = new EmailContent( @from: "*****@*****.**", subject: "test", body: "<p> Hello world </P>", recipients: new List <string>() { "*****@*****.**" }); var emailSender = new Mock <IEmailSender>(); emailSender .Setup(x => x.SendSingleEmailAsync(It.IsAny <IEmailContent>())) .ReturnsAsync((IEmailContent x) => { Assert.Single(x.Recipients); Assert.Empty(x.Cc); Assert.Equal(emailContent.Subject, x.Subject); Assert.Equal(emailContent.From, x.From); Assert.True(x.Recipients.Contains("*****@*****.**")); return(It.IsAny <IEmailResponse>()); }); var service = Target(user, emailSender); await service.SendCustomEmailAsync(emailContent); } }
public FilterResult CheckMail(EmailContent email) { try { var words = email.Content.Split(new char[0]).Where(s => s.Length > 0); var illegalWords = words.Where(s => s.Length == 9 && s.ToLower().StartsWith("kh_") && s.Substring(3, 6).All(char.IsDigit)); if (illegalWords.Any()) { return(new FilterResult() { Status = EmailStatus.Violated, Message = "Gửi mã khách hàng" }); } return(new FilterResult() { Status = EmailStatus.NotViolated }); } catch (System.Exception ex) { return(new FilterResult() { Status = EmailStatus.NotViolated }); // todo log the exception here } }
public async Task<bool> SendEmail(string template, string mailTo, string subject, object model) { var content = new EmailContent { HtmlText = templateExecutor.Execute(template + ".cshtml", model), PlainText = templateExecutor.Execute(template + ".txt", model) }; var message = messageCreator.Create(mailTo, subject, content); return await sender.SendAsync(message); }
public async Task<bool> SendPasswordResetRequest(string emailAddress, string passwordResetUrl) { var model = new { PasswordResetUrl = passwordResetUrl, }; EmailContent content = new EmailContent() { HtmlText = templateExecutor.Execute("PasswordResetRequest.cshtml", model), PlainText = templateExecutor.Execute("PasswordResetRequest.txt", model) }; using (MailMessage message = messageCreator.Create(emailAddress, "Reset your WEEE password", content)) { return await sender.SendAsync(message); } }
public async Task<bool> SendActivateUserAccount(string emailAddress, string activationUrl) { var model = new { ActivationUrl = activationUrl, }; EmailContent content = new EmailContent() { HtmlText = templateExecutor.Execute("ActivateUserAccount.cshtml", model), PlainText = templateExecutor.Execute("ActivateUserAccount.txt", model) }; using (MailMessage message = messageCreator.Create(emailAddress, "Activate your WEEE user account", content)) { return await sender.SendAsync(message); } }
public async Task<bool> SendOrganisationUserRequest(string emailAddress, string organisationName) { var model = new { OrganisationName = organisationName, ExternalUserLoginUrl = configuration.ExternalUserLoginUrl, }; EmailContent content = new EmailContent() { HtmlText = templateExecutor.Execute("OrganisationUserRequest.cshtml", model), PlainText = templateExecutor.Execute("OrganisationUserRequest.txt", model) }; using (MailMessage message = messageCreator.Create(emailAddress, "New request to access your organisation", content)) { return await sender.SendAsync(message); } }
public async Task<bool> SendOrganisationContactDetailsChanged(string emailAddress, string schemeName) { var model = new { SchemeName = schemeName }; EmailContent content = new EmailContent { HtmlText = templateExecutor.Execute("OrganisationContactDetailsChanged.cshtml", model), PlainText = templateExecutor.Execute("OrganisationContactDetailsChanged.txt", model) }; var subject = string.Format("Change of contact details for {0}", schemeName); using (MailMessage message = messageCreator.Create(emailAddress, subject, content)) { return await sender.SendAsync(message, true); } }
public async Task<bool> SendTestEmail(string emailAddress) { EmailContent content = new EmailContent { HtmlText = templateExecutor.Execute("Test.cshtml", null), PlainText = templateExecutor.Execute("Test.txt", null) }; using (MailMessage message = messageCreator.Create(emailAddress, "Test email from WEEE", content)) { return await sender.SendAsync(message, false); } }
public async Task<bool> SendInternalUserAccountActivated(string emailAddress, string userFullName, string userEmailAddress, string viewUserLink) { var model = new { EmailAddress = userEmailAddress, FullName = userFullName, ViewUserLink = viewUserLink }; EmailContent content = new EmailContent { HtmlText = templateExecutor.Execute("InternalUserAccountActivated.cshtml", model), PlainText = templateExecutor.Execute("InternalUserAccountActivated.txt", model) }; using (MailMessage message = messageCreator.Create(emailAddress, "New internal user request", content)) { return await sender.SendAsync(message, true); } }
public async Task<bool> SendSchemeDataReturnSubmitted(string emailAddress, string schemeName, int complianceYear, int quarter, bool isResubmission) { var model = new { SchemeName = schemeName, ComplianceYear = complianceYear, Quarter = quarter, IsResubmission = isResubmission }; EmailContent content = new EmailContent { HtmlText = templateExecutor.Execute("SchemeDataReturnSubmitted.cshtml", model), PlainText = templateExecutor.Execute("SchemeDataReturnSubmitted.txt", model) }; using (MailMessage message = messageCreator.Create(emailAddress, string.Format("Data return submission for {0}", schemeName), content)) { return await sender.SendAsync(message, true); } }
public async Task<bool> SendSchemeMemberSubmitted(string emailAddress, string schemeName, int complianceYear, int numberOfWarnings) { var model = new { SchemeName = schemeName, ComplianceYear = complianceYear, NumberOfWarnings = numberOfWarnings }; EmailContent content = new EmailContent { HtmlText = templateExecutor.Execute("SchemeMemberSubmitted.cshtml", model), PlainText = templateExecutor.Execute("SchemeMemberSubmitted.txt", model) }; using (MailMessage message = messageCreator.Create(emailAddress, string.Format("Member registration submission for {0}", schemeName), content)) { return await sender.SendAsync(message, true); } }
public async Task<bool> SendOrganisationUserRequestCompleted(Domain.Organisation.OrganisationUser organisationUser) { var model = new { OrganisationName = organisationUser.Organisation.OrganisationName, Approved = organisationUser.UserStatus == UserStatus.Active, ExternalUserLoginUrl = configuration.ExternalUserLoginUrl }; EmailContent content = new EmailContent() { HtmlText = templateExecutor.Execute("OrganisationUserRequestCompleted.cshtml", model), PlainText = templateExecutor.Execute("OrganisationUserRequestCompleted.txt", model) }; using (MailMessage message = messageCreator.Create(organisationUser.User.Email, "Your request to access a WEEE organisation", content)) { return await sender.SendAsync(message); } }
public bool SendEmail(string ToAddress, EmailContent objContent, string CC) { try { String strSMTPUsername = System.Configuration.ConfigurationManager.AppSettings["MailUsername"]; String strSMTPPassword = System.Configuration.ConfigurationManager.AppSettings["MailPassword"]; SmtpClient objSmtpClient = new SmtpClient(System.Configuration.ConfigurationManager.AppSettings["SMTPHost"]); String strFromAddress = System.Configuration.ConfigurationManager.AppSettings["DefaultMailFrom"]; String strDefaultMailRecipient = System.Configuration.ConfigurationManager.AppSettings["DebugRecipient"]; MailMessage objMailMessage = new MailMessage(); MailAddress objFromMailAddress = new MailAddress(strFromAddress); String strEmailTemplate = ""; if (strSMTPUsername.Length > 0 && strSMTPPassword.Length > 0) { objSmtpClient.UseDefaultCredentials = false; objSmtpClient.Credentials = new NetworkCredential(strSMTPUsername, strSMTPPassword); } if (objContent.EmailTemplatePathLocal.Length > 0) { strEmailTemplate = ReadFile(objContent.EmailTemplatePathLocal); strEmailTemplate = strEmailTemplate.Replace("[ServerPath]", objContent.ImageHostDomain); strEmailTemplate = strEmailTemplate.Replace("[Greeting]", objContent.Greeting); strEmailTemplate = strEmailTemplate.Replace("[PartingComments]", objContent.PartingComments); strEmailTemplate = strEmailTemplate.Replace("[FooterText]", objContent.FooterText); strEmailTemplate = strEmailTemplate.Replace("[BodyText]", objContent.BodyText); } else { strEmailTemplate = "<p>" + objContent.Greeting + "</p>" + "<p>" + objContent.BodyText + "</p>" + "<p>" + objContent.PartingComments + "</p>" + "<p>" + objContent.FooterText + "</p>"; } if (ToAddress.IndexOf(",") > -1) { string[] arrAddresses = ToAddress.Split(','); foreach (string strAddress in arrAddresses) { if (strAddress.Trim().Length > 0) { objMailMessage.To.Add(strAddress.Trim()); } } } else { if (ToAddress.Length > 0) { objMailMessage.To.Add(ToAddress); } else { objMailMessage.To.Add(strDefaultMailRecipient); } } if (CC.Length > 0) { foreach (string strCCEmail in CC.Split(',')) { objMailMessage.Bcc.Add(new MailAddress(strCCEmail)); } } objMailMessage.From = objFromMailAddress; objMailMessage.Subject = objContent.Subject; objMailMessage.Body = strEmailTemplate; objMailMessage.IsBodyHtml = true; objSmtpClient.Send(objMailMessage); return true; } catch (Exception) { return false; } }