public async Task <ActionResult> EnviarEmail(MailMessageModel model)
{
try
{
SmtpClient client = new SmtpClient("smtp.gmail.com", 587);
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential("*****@*****.**", "Id!li0cas");
client.EnableSsl = true;
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(model.Email);
mailMessage.To.Add(model.Destinatario);
mailMessage.IsBodyHtml = true;
mailMessage.Body = "<p><strong>Nome do cliente: </strong>" + model.Nome + "</p>"
+ "<p><strong>Email do cliente: </strong>" + model.Email + "</p>"
+ "<p><strong>Nº de animais: </strong>" + model.NAnimais + "</p>"
+ "<p><strong>Data da consulta: </strong>" + model.Data.Day + "/" + model.Data.Month + "/" + model.Data.Year + "</p>"
+ "<p><strong>Mensagem: </strong>" + model.Mensagem + "</p>";
mailMessage.Subject = "SRCD - Pedido de marcação de consulta";
await client.SendMailAsync(mailMessage);
TempData["StatusMessage"] = "Email enviado!";
return(RedirectToAction("Details", new { Id = model.ClinicId }));
}
catch (Exception)
{
TempData["StatusMessage"] = "Ocorreu um erro ao enviar o email. Preencha todos os campos e verifique a sua conexão a internet, por favor.";
return(RedirectToAction("Details", new { Id = model.ClinicId }));
}
}
public async Task <IActionResult> CreateMail(MailMessageModel model)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (userId == null)
{
throw new ApplicationException($"User ID was not found in user claims!");
}
var user = await _dbContext.Users
.Include(appUser => appUser.SmtpConfigurations)
.SingleOrDefaultAsync(appUser => appUser.Id == userId);
// for now using only one configuration
var firstSmtpConf = user.SmtpConfigurations.First();
var sender = new MailSender(firstSmtpConf);
var message = new MimeMessage();
message.From.Add(new MailboxAddress(user.UserName, firstSmtpConf.Username));
message.To.Add(new MailboxAddress(model.Recipent, model.Recipent));
message.Subject = model.Title;
message.Body = new TextPart("html")
{
Text = model.Content
};
await sender.SendMailAsync(message);
return(RedirectToAction("Index"));
}
private static SmtpClient InitSmtpMail(MailMessageModel entity, out MailMessage mail)
{
mail = new MailMessage();
try
{
if (entity.ToMailList.Count > 0)
{
var client = new SmtpClient();
foreach (string address in entity.ToMailList)
{
mail.To.Add(new MailAddress(address));
}
mail.From = new MailAddress(entity.FromMail);
mail.Subject = entity.Subject;
mail.Body = entity.Body;
mail.BodyEncoding = Encoding.UTF8;
mail.IsBodyHtml = true;
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential(entity.FromMail, entity.FromMailPwd);
client.Host = entity.Host;
client.Port = entity.Port;
client.EnableSsl = true;
return client;
}
return null;
}
catch (Exception ex)
{
LogHelp.Instance.Write(ex.Message, MessageType.Error, typeof(NetMailDAL), MethodBase.GetCurrentMethod().Name);
return null;
}
}
internal MailMessageContext(MailboxContext mailbox, MailMessageModel message)
{
_mailbox = mailbox;
_message = message;
_attachments = new ObservableCollection <AttachmentContext>();
_elevateTrustLevelCommand = new RelayCommand(OnElevateTrustCommand);
}
private void IfCustomersRelayMessageToEachCustomer(MailMessageModel mailMessage, Dictionary <Guid, UserMessage> messages)
{
//If CustomerIds are provided, send message to every user for that customer
if (mailMessage.CustomerIds != null && mailMessage.CustomerIds.Any())
{
foreach (var customer in mailMessage.CustomerIds)
{
//var users = _userProfileLogic.GetUsers(new UserFilterModel() { CustomerId = customer });
var users = _userRepo.GetUsersForCustomerOrAccount(customer);
foreach (var user in users)
{
if (!messages.ContainsKey(user.UserId))
{
messages.Add(user.UserId, new UserMessage()
{
Body = mailMessage.Message.Body,
Subject = mailMessage.Message.Subject,
Label = mailMessage.Message.Label,
Mandatory = mailMessage.Message.Mandatory,
UserId = user.UserId,
NotificationType = NotificationType.Mail
});
}
}
}
}
}
private static SmtpClient InitSmtpMail(MailMessageModel entity, out MailMessage mail)
{
mail = new MailMessage();
try
{
if (entity.ToMailList.Count > 0)
{
var client = new SmtpClient();
foreach (string address in entity.ToMailList)
{
mail.To.Add(new MailAddress(address));
}
mail.From = new MailAddress(entity.FromMail);
mail.Subject = entity.Subject;
mail.Body = entity.Body;
mail.BodyEncoding = Encoding.UTF8;
mail.IsBodyHtml = true;
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential(entity.FromMail, entity.FromMailPwd);
client.Host = entity.Host;
client.Port = entity.Port;
client.EnableSsl = true;
return(client);
}
return(null);
}
catch (Exception ex)
{
LogHelp.Instance.Write(ex.Message, MessageType.Error, typeof(NetMailDAL), MethodBase.GetCurrentMethod().Name);
return(null);
}
}
public async Task <IHttpActionResult> SendTestEmail()
{
var mailMessage = new MailMessageModel("*****@*****.**", "Test", "<strong style=\"color: red\">Zawartość<strong>");
await mailService.SendEmailAsyncTask(mailMessage);
return(Ok());
}
private static void ExtractLinkIfPresent(MailMessageModel mailMessage)
{
if (mailMessage.Message.Link != null)
{
mailMessage.Message.Body += string.Format("{0}=\"{1}\"",
Constants.USERMESSAGES_LINKTOKEN,
mailMessage.Message.Link);
}
}
internal async Task DeleteMessagesAsync(MailMessageContext[] messages, string trashFolder)
{
var uids = messages.Select(x => x.Uid).ToArray();
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var mailbox = await session.SelectAsync(Name);
if (IsTrash)
{
await mailbox.DeleteMailsAsync(uids);
}
else
{
await mailbox.MoveMailsAsync(uids, trashFolder);
}
}
}
}
using (var context = new DatabaseContext()) {
await context.Database.Connection.OpenAsync();
foreach (var message in messages)
{
var id = message.Id;
using (var transaction = context.Database.BeginTransaction()) {
try {
var mime = await context.MimeMessages
.FirstOrDefaultAsync(x => x.MessageId == id);
context.MimeMessages.Remove(mime);
await context.SaveChangesAsync();
var model = new MailMessageModel {
Id = message.Id,
MailboxId = Id
};
context.MailMessages.Attach(model);
context.MailMessages.Remove(model);
await context.SaveChangesAsync();
transaction.Commit();
App.Context.NotifyMessageRemoved(message);
} catch (Exception) {
transaction.Rollback();
}
}
}
}
}
protected Tuple <MailMessage, SmtpClient> GetData(MailMessageModel mailMessageModel, SmtpSettingsModel smtpSettingsModel)
{
PrepareSending(ref smtpSettingsModel);
var message = mailMessageModel.GetMailMessage(smtpSettingsModel);
var client = smtpSettingsModel.GetSmtpClient();
return(Tuple.Create(message, client));
}
private void RelayAlert(MailMessageModel mailMessage, Dictionary <Guid, UserMessage> messages)
{
if ((mailMessage.BranchesToAlert != null) && (mailMessage.BranchesToAlert.Length > 0))
{
RelayAlertToUsersInBranches(mailMessage, messages);
}
else
{
RelayAlertToAllUsers(mailMessage, messages);
}
}
/// <summary>
/// Write log file message
/// </summary>
/// <param name="msg"></param>
private void Send(MailMessageModel msg)
{
try
{
NetMailDAL.SendMail(msg);
}
catch (Exception e)
{
LogHelp.Instance.Write(e, MessageType.Error, GetType(), MethodBase.GetCurrentMethod().Name);
}
}
public Task SendAsync(IdentityMessage message)
{
// Plug in your email service here to send an email.
//return Task.FromResult(0);
var mailService = ServiceLocator.Current.GetInstance <IMailServiceAsyncTask>();
var mailMessage = new MailMessageModel(message.Destination, message.Subject, message.Body);
return(mailService.SendEmailAsyncTask(mailMessage));
}
/// <summary>
/// Enqueue a new log message and release a semaphore
/// </summary>
/// <param name="msg">Log message</param>
public void SendMail(MailMessageModel msg)
{
if (msg != null)
{
lock (_lockObject)
{
_mailMessages.Enqueue(msg);
_semaphore.Release();
}
}
}
private static Task TestMail()
{
SmtpSettingsModel smtpSettingsModel = new SmtpSettingsModel("*****@*****.**", "*****@*****.**", "Pawl", "password", "smtp.gmail.com", 587, true);
MailMessageModel mailMessageModel = new MailMessageModel("[email protected],[email protected]", "Test", "Testowy", true, new[] { @"D:\Downloads\teekst.txt", @"D:\Downloads\teekst2.txt" });
IMailServiceAsyncTask mailService = new MailServiceAsyncTask(new TraceLogger(new LogMessageFactory()));
return(mailService.SendEmailAsyncTask(mailMessageModel, smtpSettingsModel));
}
public void SendMail(DateTime errorDateTime, string user, string className, string methodName, string messageContent, string stackContent)
{
MailMessageModel msg = new MailMessageModel()
{
FromMail = ConfigurationManager.AppSettings[CommonConstants.FromMail],
FromMailPwd = ConfigurationManager.AppSettings[CommonConstants.FromMailPwd],
ToMailList = new List <string>(ConfigurationManager.AppSettings[CommonConstants.ToMailList].Split(CommonConstants.CommaSplitTags.ToCharArray())),
Host = ConfigurationManager.AppSettings[CommonConstants.MailHost],
Port = Convert.ToInt32(ConfigurationManager.AppSettings[CommonConstants.MailPort]),
Subject = CommonConstants.MailSubjectTags,
Body = string.Format(CommonConstants.EmailBodyTags, errorDateTime, user, className, methodName, messageContent, stackContent)
};
SendMail(msg);
}
/// <summary>
/// Write message to log file
/// </summary>
private void SendMailMessage()
{
MailMessageModel mailMessage = null;
lock (_lockObject)
{
if (_mailMessages.Count > 0)
{
mailMessage = _mailMessages.Dequeue();
}
}
if (mailMessage != null)
{
Send(mailMessage);
}
}
public OperationReturnModel <bool> CreateMessage(MailMessageModel mailMessage)
{
OperationReturnModel <bool> ret = new OperationReturnModel <bool>();
try
{
_msgLogic.CreateMailMessage(mailMessage);
ret.SuccessResponse = true;
ret.IsSuccess = true;
}
catch (Exception ex)
{
_log.WriteErrorLog("CreateMessage", ex);
ret.ErrorMessage = ex.Message;
ret.SuccessResponse = false;
ret.IsSuccess = false;
}
return(ret);
}
public static void SendMail(MailUtilParaModel para, MailMessageModel message)
{
//Generate Message
var mailMessage = new MimeMailMessage();
mailMessage.From = new MimeMailAddress(para.MailAddress);
//para.ReciverAddressList.ForEach(f=>mailMessage.To.Add(f));
mailMessage.To.Add(para.ReciverAddresses);
mailMessage.Subject = message.Subject;
mailMessage.Body = message.Text;
//Create Smtp Client
var mailer = new MimeMailer(para.ServerHost, para.ServerPort);
mailer.User = para.LogonUserName;
mailer.Password = para.Password;
mailer.SslType = (SslMode)para.SSLType;
mailer.AuthenticationMode = AuthenticationType.Base64;
mailer.SendMailAsync(mailMessage);
}
public static bool SendAsync(MailMessageModel entity)
{
var result = false;
if (entity == null || entity.ToMailList == null)
{
return(false);
}
MailMessage mail;
var client = InitSmtpMail(entity, out mail);
if (client != null)
{
AsyncAciton = entity.AsyncAction;
client.SendCompleted += SendCompletedCallback;
client.SendAsync(mail, null);
result = true;
}
return(result);
}
internal async Task RestoreMessagesAsync(ICollection <MailMessageContext> messages)
{
try {
var inbox = GetInbox();
var trash = GetTrashMailbox();
using (var connection = new ImapConnection {
Security = _account.ImapSecurity
}) {
using (var auth = await connection.ConnectAsync(_account.ImapHost, _account.ImapPort)) {
using (var session = await auth.LoginAsync(_account.ImapUsername, _account.ImapPassword)) {
var mailbox = await session.SelectAsync(trash.Name);
await mailbox.MoveMailsAsync(messages.Select(x => x.Uid).ToArray(), inbox.Name);
}
}
}
using (var database = new DatabaseContext()) {
foreach (var message in messages)
{
try {
var model = new MailMessageModel {
Id = message.Id,
MailboxId = Id
};
database.MailMessages.Attach(model);
database.MailMessages.Remove(model);
} catch (Exception ex) {
Logger.Error(ex);
throw;
}
}
await database.SaveChangesAsync();
}
App.Context.NotifyMessagesRemoved(messages);
} catch (Exception ex) {
Logger.Error(ex);
}
}
private void GetBranchesToAlert(MailMessageModel mailMessage, List <UserProfile> users)
{
List <string> branches = Configuration.GetCommaSeparatedValues(mailMessage.BranchesToAlert);
foreach (string branch in branches)
{
List <Customer> customers = _custRepo.GetCustomersForBranch(branch);
Parallel.ForEach(customers,
new ParallelOptions {
MaxDegreeOfParallelism = 4
},
customer =>
{
var lusers = _userRepo.GetUsersForCustomerOrAccount(customer.CustomerId);
if (lusers != null && lusers.Count > 0)
{
users.AddRange(lusers);
}
});
}
}
private void RelayAlertToAllUsers(MailMessageModel mailMessage, Dictionary <Guid, UserMessage> messages)
{
List <UserProfile> users = _userRepo.GetExternalUsers();
users.AddRange(_userRepo.GetInternalUsers());
foreach (var user in users)
{
if (!messages.ContainsKey(user.UserId))
{
messages.Add(user.UserId, new UserMessage()
{
Body = mailMessage.Message.Body,
Subject = mailMessage.Message.Subject,
Label = mailMessage.Message.Label,
Mandatory = mailMessage.Message.Mandatory,
UserId = user.UserId,
NotificationType = mailMessage.Message.NotificationType
});
}
}
}
private void RelayAlertToUsersInBranches(MailMessageModel mailMessage, Dictionary <Guid, UserMessage> messages)
{
List <UserProfile> users = new List <UserProfile>();
GetBranchesToAlert(mailMessage, users);
foreach (var user in users)
{
if (!messages.ContainsKey(user.UserId))
{
messages.Add(user.UserId, new UserMessage()
{
Body = mailMessage.Message.Body,
Subject = mailMessage.Message.Subject,
Label = mailMessage.Message.Label,
Mandatory = mailMessage.Message.Mandatory,
UserId = user.UserId,
NotificationType = mailMessage.Message.NotificationType
});
}
}
}
private void IfUsersRelayMessageToEachUser(MailMessageModel mailMessage, Dictionary <Guid, UserMessage> messages)
{
//Add any messages to specific users
if (mailMessage.UserIds != null && mailMessage.UserIds.Any())
{
foreach (var user in mailMessage.UserIds)
{
if (!messages.ContainsKey(user))
{
messages.Add(user, new UserMessage()
{
Body = mailMessage.Message.Body,
Subject = mailMessage.Message.Subject,
Label = mailMessage.Message.Label,
Mandatory = mailMessage.Message.Mandatory,
UserId = user,
NotificationType = NotificationType.Mail
});
}
}
}
}
public void CreateMailMessage(MailMessageModel mailMessage)
{
Dictionary <Guid, UserMessage> messages = new Dictionary <Guid, UserMessage>();
IfCustomersRelayMessageToEachCustomer(mailMessage, messages);
IfUsersRelayMessageToEachUser(mailMessage, messages);
//Add messages to all users in the case of system alert
if (mailMessage.IsAlert)
{
ExtractLinkIfPresent(mailMessage);
RelayAlert(mailMessage, messages);
}
//Create all of the message records
foreach (var message in messages)
{
_userMessageRepository.Create(message.Value);
}
_uow.SaveChanges();
}
public static bool SendMail(MailMessageModel entity)
{
try
{
var result = false;
if (entity == null || entity.ToMailList == null)
{
return(false);
}
MailMessage mail;
var client = InitSmtpMail(entity, out mail);
if (client != null)
{
client.Send(mail);
result = true;
}
return(result);
}
catch (Exception ex)
{
LogHelp.Instance.Write(ex.Message, MessageType.Error, typeof(NetMailDAL), MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// Write log file message
/// </summary>
/// <param name="msg"></param>
private void Send(MailMessageModel msg)
{
try
{
NetMailDAL.SendMail(msg);
}
catch (Exception e)
{
LogHelp.Instance.Write(e, MessageType.Error, GetType(), MethodBase.GetCurrentMethod().Name);
}
}
/// <summary>
/// Enqueue a new log message and release a semaphore
/// </summary>
/// <param name="msg">Log message</param>
public void SendMail(MailMessageModel msg)
{
if (msg != null)
{
lock (_lockObject)
{
_mailMessages.Enqueue(msg);
_semaphore.Release();
}
}
}
public Task SendEmailAsyncTask(MailMessageModel mailMessageModel, SmtpSettingsModel smtpSettingsModel = null)
{
var data = GetData(mailMessageModel, smtpSettingsModel);
return(SendEmailAsyncTask(data.Item1, data.Item2));
}
public void SendEmailAsync(MailMessageModel mailMessageModel, SmtpSettingsModel smtpSettingsModel = null)
{
var data = GetData(mailMessageModel, smtpSettingsModel);
SendEmailAsync(data.Item1, data.Item2);
}
public static bool SendMail(MailMessageModel entity)
{
try
{
var result = false;
if (entity == null || entity.ToMailList == null) return false;
MailMessage mail;
var client = InitSmtpMail(entity, out mail);
if (client != null)
{
client.Send(mail);
result = true;
}
return result;
}
catch (Exception ex)
{
LogHelp.Instance.Write(ex.Message, MessageType.Error, typeof(NetMailDAL), MethodBase.GetCurrentMethod().Name);
return false;
}
}
public void SendMail(DateTime errorDateTime, string user, string className, string methodName, string messageContent, string stackContent)
{
MailMessageModel msg = new MailMessageModel()
{
FromMail = ConfigurationManager.AppSettings[CommonConstants.FromMail],
FromMailPwd = ConfigurationManager.AppSettings[CommonConstants.FromMailPwd],
ToMailList = new List<string>(ConfigurationManager.AppSettings[CommonConstants.ToMailList].Split(CommonConstants.CommaSplitTags.ToCharArray())),
Host = ConfigurationManager.AppSettings[CommonConstants.MailHost],
Port = Convert.ToInt32(ConfigurationManager.AppSettings[CommonConstants.MailPort]),
Subject = CommonConstants.MailSubjectTags,
Body = string.Format(CommonConstants.EmailBodyTags, errorDateTime, user, className, methodName, messageContent, stackContent)
};
SendMail(msg);
}
public IActionResult CreateMail()
{
MailMessageModel model = new MailMessageModel();
return(View("CreateMail"));
}
public static bool SendAsync(MailMessageModel entity)
{
var result = false;
if (entity == null || entity.ToMailList == null) return false;
MailMessage mail;
var client = InitSmtpMail(entity, out mail);
if (client != null)
{
AsyncAciton = entity.AsyncAction;
client.SendCompleted += SendCompletedCallback;
client.SendAsync(mail, null);
result = true;
}
return result;
}
