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;
}
}
