//send one mail
private static void SendMail(MailDto mail, SmtpDto smtp = null)
{
SendMails(new List <MailDto>()
{
mail
}, smtp);
}
private void SendActivationMails(IList <Artist> artists)
{
//prepare the emails set the dto
IList <MailDto> mailingList = new List <MailDto>();
var template = _emailsManager.GetOne(filter: c => c.Type == EmailTemplateType.InvitedArtist);
foreach (var artist in artists)
{
var mailDto = new MailDto();
mailDto.EmailAddress = artist.User.Email;
mailDto.Subject = template.Subject;
mailDto.Body = template.Body.Replace("[Name]", artist.User.Name);
var code = _userManager.GeneratePasswordResetTokenAsync(artist.User).Result;
var callbackUrl = Url.ResetPasswordCallbackLink(artist.User.Id.ToString(), code, Request.Scheme);
mailDto.Body = mailDto.Body.Replace("[Link]", "<a href=" + callbackUrl + ">" + template.LinkText + "</a>");
mailingList.Add(mailDto);
}
var configuration = _emailsManager.GetConfiguration();
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
_emailsManager.SendMultipleMails(mailingList, configuration);
}).Start();
}
/// <summary>
/// send one mail
/// </summary>
/// <param name="mail">email model</param>
/// <param name="smtp">smtp model</param>
/// <param name="sync">sync send or not, false(web ap), console(true)</param>
public static void Send(MailDto mail, SmtpDto smtp = null, bool sync = false)
{
Sends(new List <MailDto>()
{
mail
}, smtp, sync);
}
public void Save(MailDto data)
{
var entity = new Mail(data.Subject, data.Subject, data._mailFrom, data._mailTo);
MailCollection.InsertOne(entity);
// _context.Mails.InsertOne(entity);
}
public async Task SendTargetIsDownMailAsync(TargetDto targetDto)
{
var to = targetDto.UserEmail;
var mailBody = Messages.TargetMailBody(targetDto.Name, targetDto.Url, targetDto.Interval, DateTime.Now);
var mailSubject = Messages.TargetMailSubject;
var mailDto = new MailDto
{
Text = mailBody,
Title = mailSubject,
To = to
};
try
{
await SendMailAsync(to, mailSubject, mailBody);
_logger.LogInformation("Mail sended to {0} at {1} successfully, target url:{2}", to, DateTime.Now, targetDto.Url);
mailDto.IsSend = true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error when send mail to {0} at {1}", to, DateTime.Now);
mailDto.IsSend = false;
}
finally
{
await AddAsync(mailDto);
}
}
private void PrepareAndSendMails(IList <Artist> artists, ApplicationUser recordLabel)
{
//prepare the emails set the dto
IList <MailDto> mailingList = new List <MailDto>();
var template = _repository.GetAll <EmailTemplate>().Where(c => c.Type == EmailTemplateType.DeletedArtist).FirstOrDefault();
foreach (var artist in artists)
{
var artistDto = new MailDto();
artistDto.EmailAddress = artist.User.Email;
artistDto.Subject = template.Subject;
artistDto.Body = template.Body.Replace("[Name]", artist.User.Name);
mailingList.Add(artistDto);
}
var mailDto = new MailDto();
template = _repository.GetAll <EmailTemplate>().Where(c => c.Type == EmailTemplateType.DeletedRecordLabel).FirstOrDefault();
mailDto.EmailAddress = recordLabel.Email;
mailDto.Subject = template.Subject;
mailDto.Body = template.Body.Replace("[Name]", recordLabel.Name);
mailingList.Add(mailDto);
var configuration = _repository.GetAll <Configuration>().ToList();
//fire and forget
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
_emailsManager.SendMultipleMails(mailingList, configuration);
}).Start();
}
static public void InsertMessageInQueue(MailDto mailDto)
{
MessageQueue msmq;
try
{
string qname = @".\Private$\Mails";
if (!MessageQueue.Exists(qname))
{
//Console.Write("No such Q path! Creating...");
msmq = MessageQueue.Create(qname);
msmq.Label = "test";
msmq.Send(mailDto);
}
else
{
msmq = new MessageQueue(qname);
msmq.Label = "test";
msmq.Send(mailDto);
}
msmq.Close();
}
catch
{
throw;
}
}
public MailOutputDto Save([FromBody] MailDto mailDto)
{
var setPassword = (mailDto.Id != 0 && !string.IsNullOrEmpty(mailDto.Password)) ||
mailDto.Id == 0;
var secret = Guid.NewGuid().ToString();
var mail = new Mail
{
Id = mailDto.Id,
EmailAddress = mailDto.EmailAddress,
EnableSsl = mailDto.EnableSsl,
Host = mailDto.Host,
Name = mailDto.Name,
Password = setPassword ? encryption.Encrypt(mailDto.Password, secret) : string.Empty,
Port = mailDto.Port,
UserId = user.Id
};
context.Update(mail);
context.Entry(mail).Property(x => x.Password).IsModified = setPassword;
context.SaveChanges();
return(new MailOutputDto
{
Id = mail.Id,
EmailAddress = mail.EmailAddress,
EnableSsl = mail.EnableSsl,
Host = mail.Host,
Name = mail.Name,
Password = mailDto.Password,
Port = mail.Port,
Secret = setPassword ? secret : null
});
}
public Task <SwaggerResponse> SendMailAsync(MailDto mailMessage)
{
var headers = new Dictionary <string, IEnumerable <string> >();
try
{
var userId = _httpContextAccessor.HttpContext.User.FindFirst(cl => cl.Type.Equals("id")).Value;
var profile = _unitOfWork.AppProfiles.FindById(userId);
var to = new EmailAddress {
Email = "*****@*****.**"
};
var from = new EmailAddress {
Email = profile.Identity.Email
};
var mailPayload = new MailPayload {
Subject = mailMessage.Subject, Body = mailMessage.Body, From = from
};
mailPayload.ToList.Add(from);
_mailClient.SetOptions(_mailConfigOptions);
_mailClient.SendEmail(mailPayload);
return(Task.Run(() => new SwaggerResponse(StatusCodes.Status200OK, headers)));
}
catch (Exception exception)
{
return(HandleException(exception, headers));
}
}
public static async Task UpdateAsync(ApiDto apiDto, MailDto mailDto, ContextDto contextDto)
{
try
{
var httpClient = HttpClientHelper.Get(apiDto);
var integratorDto = await GetIntegratorAsync(httpClient, MyStatusId);
if (integratorDto != null && integratorDto.Version == MyVersion)
{
return;
}
await ExternalTableHelper.PostAsync(httpClient, "HrLinkCompany", GetExternalTablePostModel());
await DatabaseHelper.RecreateViewsAsync(httpClient, GetSkillsWorkflowIntegrationHrLinkCompanies());
if (!await DatabaseHelper.ExistsViewAsync(apiDto, "SkillsWorkflowIntegrationHrLinkCompanies"))
{
throw new Exception("View SkillsWorkflowIntegrationHrLinkCompanies not created.");
}
await PostIntegratorAsync(httpClient);
}
catch (Exception exception)
{
var groupId = contextDto.TenantId.ToString() + "-" + Updater.MyStatusId.ToString();
await MailHelper.SendEmailAsync(mailDto, "Error updating HrLink structure.", MailHelper.GetBodyTextOf(contextDto, exception.InnerException?.Message ?? exception.Message), mailDto.AdministratorMail, null, true, groupId);
}
}
public static async Task SendMailAsync(MailDto mailDto)
{
var smtpServer = new SmtpClient("smtp.gmail.com", 587);//todo add pop - imap clients
var mail = new MailMessage {
From = new MailAddress(mailDto.SenderEmailAddress)
};
mail.To.Add(mailDto.ToEmailAddress);
mail.Subject = mailDto.Subject;
mail.IsBodyHtml = true;
var htmlBody = "";
htmlBody += "<div>" + mailDto.Message + "</div>";
AlternateView htmlView = AlternateView.CreateAlternateViewFromString(htmlBody, null, "text/html");
mail.AlternateViews.Add(htmlView);
mail.Body = htmlBody;
smtpServer.UseDefaultCredentials = false;
smtpServer.Credentials = new NetworkCredential(mailDto.SenderEmailAddress, mailDto.SenderPassword);
smtpServer.EnableSsl = true;
await smtpServer.SendMailAsync(mail);
}
public Controller(List <ApiDto> tenants, MailDto mailDto)
{
Tenants = tenants ?? throw new ArgumentNullException(nameof(tenants));
MailDto = mailDto ?? throw new ArgumentNullException(nameof(mailDto));
_companyHelper = new CompanyHelper();
_userHelper = new UserHelper();
}
public async Task <bool> SendMail(string to, string subject, string body)
{
var uri = $"learning/Utility/sendemail";
var message = $"There was an error while attempting to send email to: {to} with subject: {subject}";
var mailDto = new MailDto(to, subject, body);
return(await _apiContext.PostActionAsync(uri, mailDto, message));
}
public void MailTest()
{
MailDto dto = new MailDto();
dto.Subject = "您的文章《九宫山游记》有新的评论，请注意查收！";
dto.Body = "中国武汉网友：写的真心不错！";
Assert.AreEqual(MailHelper.Send(dto), true);
}
public async Task <IActionResult> SendAsync(MailDto mailDto)
{
if (areParametersWrong())
{
return(new JsonResult(new ExceptionDto {
Message = "Could not send the email"
})
{
StatusCode = 422
});
}
var message = new MimeMessage();
var from = new MailboxAddress(mailDto.Mail,
mailDto.Mail);
message.From.Add(from);
var to = new MailboxAddress("User",
recipient);
message.To.Add(to);
message.Subject = "New message from TAB clinic from: " + mailDto.Mail;
var bodyBuilder = new BodyBuilder();
bodyBuilder.TextBody = mailDto.Message;
message.Body = bodyBuilder.ToMessageBody();
var client = new SmtpClient();
try
{
await client.ConnectAsync(smtp, port, true);
await client.AuthenticateAsync(login, password);
client.Send(message);
client.Disconnect(true);
client.Dispose();
}
catch (Exception e)
{
return(new JsonResult(new ExceptionDto {
Message = "Could not send the email"
})
{
StatusCode = 422
});
}
return(new JsonResult(mailDto)
{
StatusCode = 201
});
}
public async Task <IActionResult> SendSlack([FromBody] MailDto slackMessage)
{
if (!ModelState.IsValid)
{
return(HandleInvalidModelState(ModelState));
}
var result = await _implementation.SendSlackAsync(slackMessage).ConfigureAwait(false);
return(ProcessResponse(result));
}
public void Send(string subject, string message, string _mailTo, string _mailFrom)
{
Debug.WriteLine($"mail from {_mailFrom } to {_mailTo} CloudMailService");
Debug.WriteLine($"subject {subject}");
Debug.WriteLine($"message {message}");
var data = new MailDto(subject, message, _mailTo, _mailFrom);
_dataRepository.Save(data);
}
//[ProducesResponseType(200, Type = typeof(IEnumerable<MailDto>))]
//[ProducesResponseType(404)]
public IActionResult SendMail(MailDto mailDto)
{
try
{
return(Ok(_IMailService.SendMailAsync(mailDto)));
}
catch (Exception ex)
{
return(Ok(ex.ToString()));
}
}
public async Task <ServiceResult <MailDto> > AddAsync(MailDto mailDto)
{
var mail = _mapper.Map <Mail>(mailDto);
var addedMail = await _mailRepository.AddAsync(mail);
return(new ServiceResult <MailDto>
{
Result = _mapper.Map <MailDto>(addedMail)
});
}
public static string ExportPrisonersInbox(SoftJailDbContext context, string prisonersNames)
{
var names = prisonersNames.Split(',');
var prisoners = context.Prisoners
.Include(p => p.Mails)
.Where(p => names.Any(n => n == p.FullName))
.ToArray();
var result = new List <PrisonerDto>();
foreach (var p in prisoners)
{
PrisonerDto prisonerDto = new PrisonerDto
{
Id = p.Id,
IncarcerationDate = p.IncarcerationDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture),
Name = p.FullName,
};
var messages = new List <MailDto>();
foreach (var m in p.Mails)
{
var charArray = m.Description.ToCharArray();
Array.Reverse(charArray);
var desc = new string(charArray);
MailDto mailDto = new MailDto {
Description = desc
};
messages.Add(mailDto);
}
prisonerDto.EncryptedMessages = messages.ToArray();
result.Add(prisonerDto);
}
var export = result.OrderBy(a => a.Name).ThenBy(a => a.Id).ToArray();
var sb = new StringBuilder();
var serializer = new XmlSerializer(typeof(PrisonerDto[]), new XmlRootAttribute("Prisoners"));
serializer.Serialize(new StringWriter(sb), export, new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty }));
var xml = sb.ToString();
return(xml);
}
public MailDto GeneratePasswordMail(string userName, string secret, string mailTo)
{
string url = "https://karasayfa.com/#/reset?secret=" + secret;
MailDto dto = service.GetMailTemplate(MailType.PasswordReminder);
dto.HtmlMessage = dto.HtmlMessage.Replace("{{UserName}}", userName)
.Replace("{{Secret}}", url);
dto.Textmessage = dto.Textmessage.Replace("{{UserName}}", userName)
.Replace("{{Secret}}", url);
dto.ReceiverAddress = mailTo;
return(dto);
}
//send many mails
public static void Sends(List <MailDto> mails, SmtpDto smtp = null, bool sync = false)
{
//change receiver to tester if need !!
var mail = new MailDto();// = null;
var testMode = !string.IsNullOrEmpty(_Fun.Config.TesterMail);
if (testMode)
{
mail = mails[0];
mail.ToUsers = StrToUsers(_Fun.Config.TesterMail);
mail.CcUsers = null;
}
//sync = true; //temp add
if (sync)
{
if (testMode)
{
SendMail(mail, smtp);
}
else
{
SendMails(mails, smtp);
}
}
else
{
if (testMode)
{
var thread = new Thread(delegate()
{
SendMail(mail, smtp);
});
thread.Start();
}
else
{
/*
* Task.Factory.StartNew(() =>
* {
* SendMails(mails, smtp);
* });
*/
var thread = new Thread(delegate()
{
SendMails(mails, smtp);
});
thread.Start();
}
}
}
public MailDto GenerateMessageMail(string userName, string messageFrom, string mailTo, string content)
{
MailDto dto = service.GetMailTemplate(MailType.GotMessage);
dto.HtmlMessage = dto.HtmlMessage.Replace("{{UserName}}", userName)
.Replace("{{MessageFrom}}", messageFrom)
.Replace("{{Date}}", DateTime.Now.ToShortTimeString())
.Replace("{{Message}}", content);
dto.Textmessage = dto.Textmessage.Replace("{{UserName}}", userName)
.Replace("{{MessageFrom}}", messageFrom)
.Replace("{{Message}}", content);
dto.ReceiverAddress = mailTo;
return(dto);
}
public async Task <MimeMessage> GetMessage(MailDto mailDto, bool useSsl, UniqueId emailId)
{
using (var imapClient = new ImapClient())
{
imapClient.CheckCertificateRevocation = false;
await imapClient.ConnectAsync(mailDto.Server, ImapPort, useSsl);
await imapClient.AuthenticateAsync(mailDto.Name, mailDto.Password);
var inbox = imapClient.Inbox;
await inbox.OpenAsync(FolderAccess.ReadOnly);
return(await inbox.GetMessageAsync(emailId));
}
}
public async Task <IEnumerable <IMessageSummary> > GetAllSubjects(MailDto mailDto, bool useSsl)
{
using (var imapClient = new ImapClient())
{
imapClient.CheckCertificateRevocation = false;
await imapClient.ConnectAsync(mailDto.Server, ImapPort, useSsl);
await imapClient.AuthenticateAsync(mailDto.Name, mailDto.Password);
var inbox = imapClient.Inbox;
await inbox.OpenAsync(FolderAccess.ReadOnly);
return(await inbox.FetchAsync(0, -1, MessageSummaryItems.Full | MessageSummaryItems.UniqueId));
}
}
public void PrepareContactFormMail(string name, string email, string message)
{
var recieverMail = _repository.Get <Configuration>(filter: x => x.Key == ConfigurationKey.ContactFormRecieverMail).FirstOrDefault().Value;
var template = _repository.GetAll <EmailTemplate>().Where(x => x.Type == EmailTemplateType.ContactForm).FirstOrDefault();
var bodyToSend = message + "<br> <br> Sender:<br>Name: " + name + "<br>Email Address: " + email;
var configuration = _repository.GetAll <Configuration>().ToList();
var mail = new MailDto()
{
EmailAddress = email,
Subject = template.Subject,
Body = bodyToSend
};
SendMailSmtp(mail, configuration);
}
public bool Post([FromBody] MailDto email)
{
try
{
MailMessage objmail = new MailMessage();
MailAddressCollection mails = new MailAddressCollection();
foreach (string mail in email.destinations)
{
mails.Add(new MailAddress(mail));
}
objmail.Subject = "Appel D'Offres";
objmail.From = new MailAddress(email.author);
foreach (string fi in email.documents)
{
Attachment fichier = new Attachment(fi);
objmail.Attachments.Add(fichier);
}
foreach (MailAddress destinator in mails)
{
objmail.To.Add(destinator);
}
objmail.Body = "Code:" + email.offer.code + "<br/>" +
"Intitule:" + email.offer.intitule + "<br/>" +
"Libelle:" + email.offer.categorie.libelle + "<br/>" +
"Description:" + email.offer.description + "<br/>" +
"Date Limit:" + email.offer.dateLimit + "<br/>" +
"Place Of Depot:" + email.offer.placeDepot;
objmail.IsBodyHtml = true;
SmtpClient client = new SmtpClient("smtp.gmail.com", 587);
client.EnableSsl = true;
client.Credentials = new System.Net.NetworkCredential("*****@*****.**", email.password);
client.Send(objmail);
return(true);
} catch (Exception e)
{
Debug.WriteLine(e.Message + e.StackTrace);
throw;
}
}
private static void AddImage(MailDto mail, string imageId, string imagePath)
{
if (!File.Exists(imagePath))
{
return;
}
if (mail.ImageIds == null)
{
mail.ImageIds = new List <string>();
mail.ImagePaths = new List <string>();
}
mail.ImageIds.Add(imageId);
mail.ImagePaths.Add(imagePath);
}
public async Task <GenericResponse> TestMail(MailDto mailDto)
{
// Deneme amaçlı eklendi
//ServiceResult service = await mailer.SendAsync(new string[]{"*****@*****.**","*****@*****.**"}, null, null, "test","denemem eerer", null);
ServiceResult result = await mailer.SendAsync(mailDto.recipients, mailDto.bccList, mailDto.ccList, mailDto.subject, mailDto.body, mailDto.attachments);
if (result.Success)
{
return(GenericResponse.Ok());
}
else
{
return(GenericResponse.Error(ResultType.Error, result.Error, "TC_TM_01", StatusCodes.Status500InternalServerError));
}
}
private MailDto CreateMail(Message message, string uid)
{
var result = new MailDto
{
Identifier = uid,
DateTime = message.Headers.DateSent,
MailFrom = message.Headers.From.DisplayName,
Email = message.Headers.From.Address,
Subject = message.Headers.Subject,
Body = this.GetTexts(message.MessagePart).ToList().Join("\n"),
IsHtml = false,
Attachements = this.GetAttachements(message.MessagePart).ToList(),
};
return(result);
}
