public Task SendEmailAsync(IEmailAddress from, string subject, string message, IEnumerable <IEmailAttachment> attachments, IEmailAddress[] to, IEmailAddress[] cc, IEmailAddress[] bcc, IEmailAddress replyTo = null, bool plainTextOnly = false)
{
if (plainTextOnly)
{
return(DoMockupAndSendEmailAsync(
from,
replyTo,
to,
cc,
bcc,
subject,
message,
null,
attachments));
}
return(DoMockupAndSendEmailAsync(
from,
replyTo,
to,
cc,
bcc,
subject,
message,
string.Format("<html><header></header><body>{0}</body></html>", message),
attachments));
}
public IUserInvitation Create(IAccount account, IEmailAddress emailAddress)
{
UserInvitation result = Create(new UserInvitationData(), account, emailAddress);
result.ExpirationTimestamp = DateTime.UtcNow;
return(result);
}
///<inheritdoc/>
public void AddBccRecipient(IEmailAddress recipient)
{
if (_bcc.FirstOrDefault(x => x.Email == recipient.Email) == null)
{
_bcc.Add(recipient);
}
}
public IEmailMessageBuilder AddFromAddress(string name, string address)
{
FromAddress = new EmailAddress {
Name = name, Address = address
};
return(this);
}
///<inheritdoc/>
public async Task <(SendMailResult, Guid)> SendMail(IMessage message, IEmailAddress redirectTo)
{
Guid requestId = await _mailRepository.SaveRequestAsync(message);
IMessageHandle msgToSend;
if (_isProduction)
{
msgToSend =
new Message
(
message.Subject,
message.Content,
message.From,
message.ReplyTo,
message.To.ToList(),
message.Cc.ToList(),
message.Bcc.ToList(),
message.Files.ToList(),
message.EnableHtml
);
}
else
{
if (string.IsNullOrWhiteSpace((redirectTo ?? _redirectOptions).Email))
{
throw new ArgumentNullException("RedirectTo options parameters is not defined in application settings");
}
msgToSend =
new Message
(
message.Subject,
message.Content,
message.From,
message.ReplyTo,
new List <IEmailAddress>()
{
redirectTo ?? _redirectOptions
},
null,
null,
message.Files.ToList(),
message.EnableHtml
);
}
if (message.Headers.Count > 0)
{
foreach (KeyValuePair <string, string> header in message.Headers)
{
msgToSend.AddHeader(header.Key, header.Value);
}
}
SendMailResult mailResult = await _sender.SendMailAsync(msgToSend);
return(mailResult, requestId);
}
public User(UserData userData,
IEmailAddressFactory emailAddressFactory,
IUserDataSaver dataSaver,
IEmailAddress emailAddress)
: this(userData, emailAddressFactory, dataSaver)
{
_emailAddress = emailAddress;
}
public void Populate(IEmailAddress email)
{
if (email == null) return;
this.Email = email.Email;
this.Id = email.Id;
this.IsPrimary = email.IsPrimary;
this.EmailUsageEnum = email.EmailUsageEnum;
}
public async void Send(IEmailAddress fromEmail, IEmailAddress toEmail, string subject, string body)
{
var apiKey = Environment.GetEnvironmentVariable("SENDGRID_API_KEY") ?? throw new Exception("SENDGRID_API_KEY environment variable not found.");
var client = new SendGridClient(apiKey);
var from = new SendGrid.Helpers.Mail.EmailAddress(fromEmail.Email, fromEmail.Name);
var to = new SendGrid.Helpers.Mail.EmailAddress(toEmail.Email, toEmail.Name);
var msg = MailHelper.CreateSingleEmail(from, to, subject, body, null);
var response = await client.SendEmailAsync(msg).ConfigureAwait(false);
}
public Task SendEmailAsync(
IEmailAddress from,
IEnumerable <IEmailAddress> recipients,
string subject,
string text,
string html)
{
return(SendEmailAsync(from, recipients, subject, text, html, Enumerable.Empty <IEmailAttachment>()));
}
public UserInvitation(UserInvitationData data,
IUserInvitationDataSaver dataSaver,
IEmailAddressFactory emailAddressFactory,
IAccount account,
IEmailAddress emailAddress) : this(data, dataSaver, emailAddressFactory)
{
_account = account;
_emailAddress = emailAddress;
}
public Task SendEmailAsync(IEmailAddress from, string subject, string message, params IEmailAddress[] to)
{
return(DoMockupAndSendEmailAsync(
from,
to,
subject,
message,
string.Format("<html><header></header><body>{0}</body></html>", message)));
}
public async Task SendEmailAsync(
IEmailAddress from,
IEnumerable <IEmailAddress> recipients,
string subject,
string text,
string html)
{
using (var client = new HttpClient())
{
var message = new HttpRequestMessage(HttpMethod.Post, "https://api.sendgrid.com/api/mail.send.json");
var variables = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("api_user", this.apiUser),
new KeyValuePair <string, string>("api_key", this.apiKey),
new KeyValuePair <string, string>("from", from.Email),
new KeyValuePair <string, string>("fromname", from.DisplayName),
new KeyValuePair <string, string>("subject", subject),
new KeyValuePair <string, string>("text", text),
new KeyValuePair <string, string>("html", html),
};
if (recipients.Count() == 1)
{
variables.Add(new KeyValuePair <string, string>("to", recipients.First().Email));
variables.Add(new KeyValuePair <string, string>("toname", recipients.First().DisplayName));
}
else
{
foreach (var recipient in recipients)
{
variables.Add(new KeyValuePair <string, string>("to[]", recipient.Email));
variables.Add(new KeyValuePair <string, string>("toname[]", recipient.DisplayName));
}
}
using (var content = new MultipartFormDataContent())
{
foreach (var variable in variables)
{
content.Add(new StringContent(variable.Value), variable.Key);
}
message.Content = content;
using (var response = await client.SendAsync(message))
{
var responseBody = JsonConvert.DeserializeObject(await response.Content.ReadAsStringAsync());
if (!response.IsSuccessStatusCode)
{
throw new Exception("Cannot Send Email");
}
}
}
}
}
public EmailRecipient(IEmailAddress emailAddress, RecipientType recipientType = RecipientType.To)
{
if (emailAddress == null)
{
throw new ArgumentNullException(nameof(emailAddress));
}
this.emailAddress = emailAddress;
this.recipientType = recipientType;
}
public void Populate(IEmailAddress email)
{
if (email == null)
{
return;
}
this.Email = email.Email;
this.Id = email.Id;
this.IsPrimary = email.IsPrimary;
this.EmailUsageEnum = email.EmailUsageEnum;
}
/// <summary>
/// Sets the BCC address.
/// </summary>
/// <param name="email">The email</param>
public Email SetBccAddress(IEmailAddress email)
{
if (email == null)
{
return(this);
}
this.Bcc.Add(new MailAddress(email.EmailAddress, email.EmailName));
return(this);
}
/// <summary>
/// Sets the cc address.
/// </summary>
/// <param name="email">The email</param>
public Email SetCcAddress(IEmailAddress email)
{
if (string.IsNullOrEmpty(email?.EmailAddress) || IsEmailExist(email))
{
return(this);
}
this.CC.Add(new MailAddress(email.EmailAddress, email.EmailName));
return(this);
}
public SmtpMessage(List <IEmailAddress> to, IEmailAddress from, string subject, string body)
{
To = HasNoAddresses(to)
? throw new ArgumentException("To field of email must contain at least one email address")
: to;
From = from ?? throw new ArgumentException("Email message must have a from address");
Subject = subject;
Body = body;
}
public Task SendEmailAsync(IEmailAddress from, IEnumerable <IEmailAddress> recipients, string subject, string text, string html)
{
this.inMemoryEmailRepository.Save(new InMemoryEmail
{
Subject = subject,
MessageText = text,
MessageHtml = html,
To = recipients.ToArray(),
From = from,
});
return(Task.FromResult(0));
}
private async Task <bool> UserCanAccessInvitation(CoreSettings settings, IUserInvitation userInvitation)
{
bool result = UserCanAccessAccount(userInvitation.AccountId);
if (!result)
{
string email = User.Claims.First(c => c.Type == ClaimTypes.Email).Value;
IEmailAddress emailAddress = await userInvitation.GetEmailAddress(settings);
result = string.Equals(email, emailAddress.Address, StringComparison.OrdinalIgnoreCase);
}
return(result);
}
/// <summary>
/// Create a new message instance
/// </summary>
/// <param name="subject">E-mail subject</param>
/// <param name="content">E-mail content</param>
/// <param name="from">Sender's e-mail</param>
/// <param name="replyTo">ReplyTo's e-mail</param>
/// <param name="to">Recipient's e-mails</param>
/// <param name="cc">Cc recipient's e-mails</param>
/// <param name="bcc">Bcc recipient's e-mails</param>
/// <param name="files">Files to attach</param>
/// <param name="enableHtml">Indicates whether the message will be sent in html format</param>
public Message(string subject, string content, IEmailAddress from, IEmailAddress replyTo, IEnumerable <IEmailAddress> to, IEnumerable <IEmailAddress> cc, IEnumerable <IEmailAddress> bcc, IEnumerable <IFileAttachment> files, bool enableHtml)
{
Subject = subject;
Content = content;
From = from;
ReplyTo = replyTo;
_to = to.ToList();
_cc = cc?.ToList() ?? new List <IEmailAddress>();
_bcc = bcc?.ToList() ?? new List <IEmailAddress>();
_files = files?.ToList() ?? new List <IFileAttachment>();
EnableHtml = enableHtml;
_headers = new Dictionary <string, string>();
}
public UsuarioAppService(IUsuarioRepository usuarioRepository, IEncryptData encryptData, IMapper mapper,
IUsuarioService user, INotificationService notificationService, ITokenService tokenService, IEmailAddress emailAddress,
IEmailRepository emailRepository, IOptions <ScanTextClientSettings> optionsClientSettings)
{
_usuarioRepository = usuarioRepository;
_encryptData = encryptData;
_mapper = mapper;
_user = user;
_notificationService = notificationService;
_tokenService = tokenService;
_emailAddress = emailAddress;
_emailRepository = emailRepository;
_clientSettings = optionsClientSettings.Value;
}
private async Task <IEmailAddress> GetEmailAddress(CoreSettings settings,
IEmailAddressFactory emailAddressFactory,
IEmailAddressSaver emailAddressSaver,
string address)
{
IEmailAddress result = await emailAddressFactory.GetByAddress(settings, address);
if (result == null)
{
result = emailAddressFactory.Create(address);
await emailAddressSaver.Create(settings, result);
}
return(result);
}
public ImagemAppService(IImagemRepository imagemRepository, IMapper mapper,
IUsuarioService user, IEmailRepository emailRepository, IUsuarioRepository usuarioRepository,
IEmailAddress emailAddress, INotificationService notificationService, IFileRepository fileRepository)
{
_imagemRepository = imagemRepository;
_mapper = mapper;
_user = user;
_emailRepository = emailRepository;
_usuarioRepository = usuarioRepository;
_emailAddress = emailAddress;
_notificationService = notificationService;
_fileRepository = fileRepository;
IdUsuario = _user.GetUserId();
}
public IUser Create(string referenceId, IEmailAddress emailAddress)
{
if (emailAddress == null)
{
throw new ArgumentNullException(nameof(emailAddress));
}
if (string.IsNullOrEmpty(referenceId))
{
throw new ArgumentNullException(nameof(referenceId));
}
return(new User(new UserData()
{
ReferenceId = referenceId
}, _emailAddressFactory, _dataSaver, emailAddress));
}
public async Task SendTemplatedEmailAsync <T>(IEmailAddress from, string templateKey, T context, params IEmailAddress[] to)
{
var subjectTemplate = await this.GetTemplateAsync(templateKey, EmailTemplateType.Subject);
var textTemplate = await this.GetTemplateAsync(templateKey, EmailTemplateType.BodyText);
var htmlTemplate = await this.GetTemplateAsync(templateKey, EmailTemplateType.BodyHtml);
await this.DoMockupAndSendEmailAsync(
from,
to,
subjectTemplate.Apply(context),
textTemplate.Apply(context),
htmlTemplate.Apply(context));
}
public Task SendEmailAsync(IEmailAddress from, IEnumerable <IEmailAddress> recipients, IEnumerable <IEmailAddress> ccRecipients, IEnumerable <IEmailAddress> bccRecipients, string subject, string text, string html, IEnumerable <IEmailAttachment> attachments, IEmailAddress replyTo = null)
{
this.inMemoryEmailRepository.Save(new InMemoryEmail
{
Subject = subject,
MessageText = text,
MessageHtml = html,
To = recipients.ToArray(),
Cc = ccRecipients.ToArray(),
Bcc = bccRecipients.ToArray(),
From = from,
ReplyTo = replyTo,
Attachments = attachments
});
return(Task.FromResult(0));
}
public async Task SendTemplatedEmailAsync <T>(IEmailAddress from, string templateKey, T context, IEnumerable <IEmailAttachment> attachments, IEmailAddress[] to, IEmailAddress[] cc, IEmailAddress[] bcc, IEmailAddress replyTo = null)
{
var subjectTemplate = await this.GetTemplateAsync(templateKey, EmailTemplateType.Subject);
var textTemplate = await this.GetTemplateAsync(templateKey, EmailTemplateType.BodyText);
var htmlTemplate = await this.GetTemplateAsync(templateKey, EmailTemplateType.BodyHtml);
await this.DoMockupAndSendEmailAsync(
from,
replyTo,
to,
cc,
bcc,
subjectTemplate.Apply(context),
textTemplate.Apply(context),
htmlTemplate.Apply(context),
attachments);
}
private async Task DoMockupAndSendEmailAsync(
IEmailAddress from,
IEmailAddress replyTo,
IEnumerable <IEmailAddress> recipients,
IEnumerable <IEmailAddress> ccRecipients,
IEnumerable <IEmailAddress> bccRecipients,
string subject,
string text,
string html,
IEnumerable <IEmailAttachment> attachments)
{
var mockedUpRecipients = new List <IEmailAddress>();
var finalToRecipients = MockRecipients(recipients, mockedUpRecipients);
var finalCcRecipients = MockRecipients(ccRecipients, mockedUpRecipients);
var finalBccRecipients = MockRecipients(bccRecipients, mockedUpRecipients);
if (mockedUpRecipients.Any())
{
var disclaimer = this.options.Mockup.Disclaimer;
var joinedMockedUpRecipients = string.Join(", ", mockedUpRecipients.Select(r => $"{r.DisplayName} ({r.Email})"));
text = string.Concat(text, Environment.NewLine, disclaimer, Environment.NewLine, joinedMockedUpRecipients);
if (html != null)
{
html = string.Concat(html, "<br/><i>", disclaimer, "<br/>", joinedMockedUpRecipients, "</i>");
}
}
await this.provider.SendEmailAsync(
from,
finalToRecipients,
finalCcRecipients,
finalBccRecipients,
subject,
text,
html,
attachments,
replyTo : replyTo);
}
private async Task <IUser> GetUser()
{
IUser user;
IEmailAddress emailAddress = null;
using (ILifetimeScope scope = _container.BeginLifetimeScope())
{
string subscriber = User.Claims.First(c => c.Type == ClaimTypes.NameIdentifier).Value;
IUserFactory userFactory = scope.Resolve <IUserFactory>();
IEmailAddressFactory emailAddressFactory = scope.Resolve <IEmailAddressFactory>();
SettingsFactory settingsFactory = scope.Resolve <SettingsFactory>();
user = await userFactory.GetByReferenceId(settingsFactory.CreateAccount(_settings.Value), subscriber);
if (user == null)
{
string email = User.Claims.First(c => c.Type == ClaimTypes.Email).Value;
emailAddress = await emailAddressFactory.GetByAddress(settingsFactory.CreateAccount(_settings.Value), email);
if (emailAddress == null)
{
emailAddress = emailAddressFactory.Create(email);
IEmailAddressSaver emailAddressSaver = scope.Resolve <IEmailAddressSaver>();
await emailAddressSaver.Create(settingsFactory.CreateAccount(_settings.Value), emailAddress);
}
user = userFactory.Create(subscriber, emailAddress);
user.Name = User.Claims.First(c => string.Equals(c.Type, "name", StringComparison.OrdinalIgnoreCase)).Value;
SetSuperUser(user);
IUserSaver userSaver = scope.Resolve <IUserSaver>();
await userSaver.Create(settingsFactory.CreateAccount(_settings.Value), user);
}
else
{
user.Name = User.Claims.First(c => string.Equals(c.Type, "name", StringComparison.OrdinalIgnoreCase)).Value;
SetSuperUser(user);
IUserSaver userSaver = scope.Resolve <IUserSaver>();
await userSaver.Update(settingsFactory.CreateAccount(_settings.Value), user);
}
}
return(user);
}
public static IEmailAddress GetEmail(this Contact contact, string emailKey, bool createIfNotExists = false, bool makePreferred = false)
{
var emails = contact.GetEmails();
IEmailAddress email = null;
if (emails.Entries.Contains(emailKey))
{
email = emails.Entries[emailKey];
}
else if (createIfNotExists)
{
email = emails.Entries.Create(emailKey);
}
if (makePreferred)
{
emails.Preferred = emailKey;
}
return(email);
}
public async Task SendEmailAsync(
IEmailAddress from,
IEnumerable <IEmailAddress> recipients,
string subject,
string text,
string html)
{
var message = new MimeMessage();
message.From.Add(new MailboxAddress(from.DisplayName, from.Email));
foreach (var recipient in recipients)
{
message.To.Add(new MailboxAddress(from.DisplayName, from.Email));
}
message.Subject = subject;
var builder = new BodyBuilder();
builder.TextBody = text;
builder.HtmlBody = html;
message.Body = builder.ToMessageBody();
using (var client = new SmtpClient())
{
await client.ConnectAsync(this.host, this.port, SecureSocketOptions.None);
client.AuthenticationMechanisms.Remove("XOAUTH2");
if (!string.IsNullOrWhiteSpace(this.username))
{
await client.AuthenticateAsync(this.username, this.password);
}
await client.SendAsync(message);
await client.DisconnectAsync(true);
}
}
public EmailAddress(IEmailAddress email)
{
this.Populate(email);
}
public void ShouldSetPreferredEmail([Frozen] IContactProfileProvider contactProfileProvider, [Greedy] ContactProfileService contactProfileService, string email, IEmailAddress emailAddress)
{
contactProfileService.SetPreferredEmail(emailAddress.SmtpAddress);
contactProfileProvider.Emails.Entries[contactProfileProvider.Emails.Preferred].SmtpAddress.ShouldBeEquivalentTo(emailAddress.SmtpAddress);
}
