public static void Run(string myBlob, string filename, Order ordersRow, TraceWriter log, out SendGridMessage message)
{
var email = ordersRow.Email;
log.Info($"Order from Email: {email}\n License file name: {filename} ");
var byteText = System.Text.Encoding.UTF8.GetBytes(myBlob);
var initiator = new EmailAddress("*****@*****.**", "Paycor");
var attachments = new List <SendGrid.Helpers.Mail.Attachment>
{
new SendGrid.Helpers.Mail.Attachment
{
Content = System.Convert.ToBase64String(byteText),
Type = "text/plain",
Filename = "license.lic",
Disposition = "attachment",
ContentId = "License File"
}
};
var recipientEmailAddresses = new List <EmailAddress> {
new EmailAddress(email, "Ashif Anwar")
};
message = MailHelper.CreateSingleEmailToMultipleRecipients(initiator, recipientEmailAddresses,
"Thank you for your order", "Your license file is attached", "Your license file is attached");
message.AddAttachments(attachments);
}
private async Task <Response> SendEmail()
{
var apiKey = ConfigurationManager.AppSettings["SENDGRID_API_KEY"];
var client = new SendGridClient(apiKey: apiKey);
var from = new EmailAddress(this.FromEmail, this.FromName);
var subject = this.Subject;
var to = new EmailAddress(this.ToEmail, this.ToName);
SendGridMessage message = null;
if (IsBodyHtml)
{
message = MailHelper.CreateSingleEmail(from, to, subject, "", this.Body);
}
else
{
message = MailHelper.CreateSingleEmail(from, to, subject, this.Body, "");
}
if (Attachments != null && Attachments.Length > 0)
{
message.AddAttachments(Attachments.ToList());
}
var response = await client.SendEmailAsync(message);
return(response);
}
/// <summary>
/// Semd email
/// </summary>
/// <param name="subject"></param>
/// <param name="toEmail"></param>
/// <param name="toName"></param>
/// <param name="data"></param>
/// <param name="attachments"></param>
/// <returns></returns>
public async Task <bool> SendEmail(
string subject,
string toEmail,
string toName,
IEmail data,
IEnumerable <Attachment> attachments
)
{
if (data == null)
{
throw new Exception("Please define data for email");
}
if (string.IsNullOrEmpty(toEmail))
{
logger.LogDebug($"Message {data.TemplateId} not delivered because email is not defined");
return(false);
}
logger.LogInformation($"Sending {data.TemplateId} email to {toEmail}");
if (!Name2Id.ContainsKey(data.TemplateId))
{
System.Console.WriteLine($"Template not found: {data.TemplateId}: {subject} {Newtonsoft.Json.JsonConvert.SerializeObject(data)}");
return(false);
}
var msg = new SendGridMessage()
{
TemplateId = Name2Id[data.TemplateId],
Personalizations = new List <Personalization>()
{
new Personalization()
{
TemplateData = data
}
}
};
msg.AddTo(new EmailAddress(toEmail, toName));
msg.From = new EmailAddress(fromEmail, fromName);
if (attachments.Any())
{
msg.AddAttachments(attachments);
}
var serialize = msg.Serialize();
var response = await client.RequestAsync(SendGridClient.Method.POST, requestBody : serialize, urlPath : "mail/send");
if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
{
return(true);
}
logger.LogError(await response.Body.ReadAsStringAsync());
logger.LogError(serialize);
return(false);
}
/// <summary>
/// Sends asynchronously.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>
/// A task returning a boolean indicating
/// whether or not the send was successful.
/// </returns>
public async Task SendAsync(EmailMessage message)
{
_logger.LogDebug($"Sending email: {JsonConvert.SerializeObject(message)}");
var to = message.To.Split(';', StringSplitOptions.RemoveEmptyEntries);
var cc = string.IsNullOrWhiteSpace(message.CC) ? new List <string>() : message.CC.Split(';', StringSplitOptions.RemoveEmptyEntries).Except(to, StringComparer.OrdinalIgnoreCase).ToList();
var bcc = string.IsNullOrWhiteSpace(message.BCC) ? new List <string>() : message.BCC.Split(';', StringSplitOptions.RemoveEmptyEntries).Except(to, StringComparer.OrdinalIgnoreCase).ToList();
var sendGridMessage = new SendGridMessage();
sendGridMessage.SetFrom(string.IsNullOrWhiteSpace(message.From) ? _emailConfiguration.SupportEmail : message.From);
sendGridMessage.AddTos(to.Select(t => new EmailAddress(t)).ToList());
if (cc.Count > 0)
{
sendGridMessage.AddCcs(cc.Select(t => new EmailAddress(t)).ToList());
}
if (bcc.Count > 0)
{
sendGridMessage.AddBccs(bcc.Select(t => new EmailAddress(t)).ToList());
}
if (message.Attachments != null && message.Attachments.Count > 0)
{
sendGridMessage.AddAttachments(message.Attachments.Select(attachment => new Attachment()
{
Filename = attachment.Key, Content = attachment.Value.ToBase64()
}).ToList());
}
if (message is TemplateEmailMessage templateEmailMessage)
{
sendGridMessage.SetTemplateId(templateEmailMessage.TemplateId);
sendGridMessage.SetTemplateData(templateEmailMessage.TemplateData);
}
else if (message is HtmlEmailMessage htmlEmailMessage)
{
sendGridMessage.SetSubject(htmlEmailMessage.Subject);
sendGridMessage.AddContent(MimeType.Html, htmlEmailMessage.Body);
}
var response = await _sendGridClient.SendEmailAsync(sendGridMessage);
_logger.LogDebug($"Sendgrid response: {await response.Body?.ReadAsStringAsync()}");
if (response.StatusCode < HttpStatusCode.OK || response.StatusCode >= HttpStatusCode.Ambiguous)
{
throw new PasswordlessException($"Unable to send email : {await response.Body?.ReadAsStringAsync()}");
}
}
protected override void ConfigurarMensaje(string asunto, string contenido)
{
_message.Subject = asunto;
_message.HtmlContent = contenido;
if (_message.Attachments != null)
{
_message.Attachments.Clear();
}
if (_adjuntos != null && _adjuntos.Count > 0)
{
_message.AddAttachments(_adjuntos);
}
}
public void SendGridMessage_AddAttachments_Adds_All_Attachments()
{
// Arrange
var sut = new SendGridMessage();
var attachments = new[]
{
new Attachment(),
new Attachment()
};
// Act
sut.AddAttachments(attachments);
// Assert
Assert.Equal(attachments.Length, sut.Attachments.Count);
}
protected override async Task SendEmailInternalAsync(EmailModel emailModel)
{
var msg = new SendGridMessage
{
From = emailModel.From != null
? new EmailAddress(emailModel.From.Email, emailModel.From.Name)
: new EmailAddress(_config.EmailAddress, _config.Name),
Subject = emailModel.Subject,
HtmlContent = emailModel.HtmlBody,
PlainTextContent = emailModel.TextBody // TODO: convert html to plain text?
};
msg.AddTos(emailModel.Recipients.Select(a => new EmailAddress(a.Email, a.Name)).ToList());
if (emailModel.Cc?.Any() == true)
{
msg.AddCcs(emailModel.Cc.Select(a => new EmailAddress(a.Email, a.Name)).ToList());
}
if (emailModel.Bcc?.Any() == true)
{
msg.AddBccs(emailModel.Bcc.Select(a => new EmailAddress(a.Email, a.Name)).ToList());
}
if (emailModel.Attachments?.Any() == true)
{
msg.AddAttachments(emailModel.Attachments.Select(a => new global::SendGrid.Helpers.Mail.Attachment
{
Filename = a.Filename,
Content = Convert.ToBase64String(a.Bytes),
Type = a.ContentType,
Disposition = a.ContentDisposition,
ContentId = a.ContentId
}));
}
var client = new SendGridClient(_config.Key);
var response = await client.SendEmailAsync(msg);
if (response.StatusCode != HttpStatusCode.OK)
{
var responseBody = await response.Body.ReadAsStringAsync();
throw new EmailSenderException($"SendGrid returned {response.StatusCode} status code ({responseBody})");
}
}
public void SendGridMessage_AddAttachments_Doesnt_Use_Provided_List_As_Property()
{
// Arrange
var sut = new SendGridMessage();
var attachments = new List <Attachment>
{
new Attachment(),
new Attachment()
};
// Act
sut.AddAttachments(attachments);
// Assert
Assert.Equal(attachments.Count(), sut.Attachments.Count);
Assert.NotSame(attachments, sut.Attachments);
}
/// <summary>
/// Adds the attachment streams.
/// </summary>
/// <param name="mail">The mail object to which the attachments should be added.</param>
/// <param name="attachments">The attachments.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>Task.</returns>
protected virtual async Task AddAttachmentStreamsAsync(SendGridMessage mail,
IDictionary <string, Stream> attachments, CancellationToken token = default(CancellationToken))
{
if (attachments != null && attachments.Any())
{
var sgAttachments = new List <Attachment>();
foreach (var stream in attachments)
{
sgAttachments.Add(new Attachment
{
Content = await stream.Value.ToBase64StringAsync(),
Filename = stream.Key,
Disposition = "attachment"
});
}
mail.AddAttachments(sgAttachments);
}
}
public Task SendAsync(MailMessageDTO message)
{
var web = new SendGridClient(apiKey);
var msg = new SendGridMessage()
{
From = ConvertMailAddress(message.From),
ReplyTo = message.ReplyTo.Select(ConvertMailAddress).FirstOrDefault(),
Subject = message.Subject
};
msg.AddTos(message.To.Select(ConvertMailAddress).ToList());
if (message.Cc.Count > 0)
{
msg.AddCcs(message.Cc.Select(ConvertMailAddress).ToList());
}
if (message.Bcc.Count > 0)
{
msg.AddBccs(message.Bcc.Select(ConvertMailAddress).ToList());
}
if (message.Attachments.Count > 0)
{
msg.AddAttachments(message.Attachments.Select(ConvertAttachment).ToList());
}
if (string.IsNullOrWhiteSpace(message.BodyHtml))
{
msg.PlainTextContent = message.BodyText;
}
else
{
msg.HtmlContent = message.BodyHtml;
}
ProcessTemplate(msg, message.MailingTemplate);
OnMessageSending(msg);
return(web.SendEmailAsync(msg));
}
public async Task SendNotification(List <Documents> documents,
string destination,
string subject,
string content)
{
var client = SendGridConfig.Instance();
var myMessage = new SendGridMessage();
myMessage.HtmlContent = content;
List <Attachment> attachments = new List <Attachment>();
foreach (var item in documents)
{
byte[] imageArray = File.ReadAllBytes(item.Path);
string base64Representation = Convert.ToBase64String(imageArray);
attachments.Add(new Attachment()
{
Content = base64Representation,
Type = item.Type,
Filename = item.Filename,
Disposition = item.Disposition,
ContentId = item.ContentId
});
}
if (attachments.Any())
{
myMessage.AddAttachments(attachments);
}
myMessage.AddTo(destination);
myMessage.From = new EmailAddress("*****@*****.**", "Daniel Vasquez");
myMessage.Subject = subject;
myMessage.SetClickTracking(false, false);
await client.SendEmailAsync(myMessage);
}
public static void Run([TimerTrigger("0 */3 * * * *")] TimerInfo myTimer,
[Blob("images", Connection = "AzureWebJobsStorage")] CloudBlobContainer images,
[Blob("thumbnails", Connection = "AzureWebJobsStorage")] CloudBlobContainer thumbnails,
[SendGrid(ApiKey = "SendgridConfiguration", From = "*****@*****.**", To = "*****@*****.**", Subject = "Azure Cleanup process")] out SendGridMessage message,
ILogger log)
{
message = new SendGridMessage();
var listAttachment = new List <Attachment>();
listAttachment.AddRange(CleanUp(images, log).ConfigureAwait(false).GetAwaiter().GetResult());
listAttachment.AddRange(CleanUp(thumbnails, log).ConfigureAwait(false).GetAwaiter().GetResult());
if (listAttachment.Count > 0)
{
message.AddAttachments(listAttachment);
message.AddContent("text/html", "Please find the attached list of files after cleanup.");
}
else
{
message.AddContent("text/html", "No file foud for cleanup.");
}
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
}
public void SendGridMessage_AddAttachments_Doesnt_Touch_Attachments_Passed_In()
{
// Arrange
var sut = new SendGridMessage();
var content = "content";
var contentId = "contentId";
var disposition = "disposition";
var filename = "filename";
var type = "type";
var attachment = new Attachment
{
Content = content,
ContentId = contentId,
Disposition = disposition,
Filename = filename,
Type = type
};
var attachments = new[] { attachment };
// Act
sut.AddAttachments(attachments);
// Assert
Assert.Single(sut.Attachments);
var addedAttachment = sut.Attachments.First();
Assert.Same(attachment, addedAttachment);
Assert.Equal(attachment.Content, addedAttachment.Content);
Assert.Equal(attachment.ContentId, addedAttachment.ContentId);
Assert.Equal(attachment.Disposition, addedAttachment.Disposition);
Assert.Equal(attachment.Filename, addedAttachment.Filename);
Assert.Equal(attachment.Type, addedAttachment.Type);
}
public async Task <Response> SendEmail(EmailAddress from, IEnumerable <EmailAddress> tos, string templateId, object dynamicTemplateData, IEnumerable <Attachment> attachments = null, IEnumerable <EmailAddress> ccList = null)
{
var emailMessage = new SendGridMessage();
emailMessage.SetFrom(from);
emailMessage.AddTos(tos.ToList());
if (ccList != null && ccList.Count() > 0)
{
emailMessage.AddCcs(ccList.ToList());
}
emailMessage.SetTemplateId(templateId);
emailMessage.SetTemplateData(dynamicTemplateData);
if (attachments != null)
{
emailMessage.AddAttachments(attachments);
}
var response = await _sendGridClient.SendEmailAsync(emailMessage);
return(response);
}
public async Task <ResponseMessage> SendAsync(EmailMessage message)
{
// Message
var msg = new SendGridMessage();
msg.Subject = message.Subject;
msg.From = new EmailAddress(message.From);
msg.PlainTextContent = message.Body;
msg.AddTos(message.To.Select(s => new EmailAddress(s)).ToList());
if (message.CC.Count > 0)
{
msg.AddCcs(message.CC.Select(s => new EmailAddress(s)).ToList());
}
if (message.BCC.Count > 0)
{
msg.AddBccs(message.BCC.Select(s => new EmailAddress(s)).ToList());
}
if (message.Attachments.Count > 0)
{
msg.AddAttachments(message.Attachments.Select(s => new Attachment
{
Filename = s,
Content = Convert.ToBase64String(System.IO.File.ReadAllBytes(s))
}).ToList());
}
// Send
var client = new SendGridClient(this.settings.ApiKey);
var response = await client.SendEmailAsync(msg);
// Return
return(new ResponseMessage(response.StatusCode.ToString()));
}
/// <summary>
/// Rabbit MQ Email sender
/// </summary>
/// <param name="subject"></param>
/// <param name="toEmail"></param>
/// <param name="toName"></param>
/// <param name="data"></param>
/// <param name="attachments"></param>
/// <returns></returns>
public async Task <bool> SendEmail(string subject, string toEmail, string toName, IEmail data, IEnumerable <Attachment> attachments)
{
try
{
try
{
var msg = new SendGridMessage()
{
TemplateId = data.TemplateId,
Personalizations = new List <Personalization>()
{
new Personalization()
{
TemplateData = data
}
}
};
if (!string.IsNullOrEmpty(subject))
{
msg.Subject = subject;
}
msg.AddTo(new EmailAddress(toEmail, toName));
msg.From = new EmailAddress(settings.Value.FromEmail, settings.Value.FromName);
if (!string.IsNullOrEmpty(settings.Value.ReplyToEmail))
{
if (!string.IsNullOrEmpty(settings.Value.ReplyToName))
{
msg.ReplyTo = new EmailAddress(settings.Value.ReplyToEmail, settings.Value.ReplyToName);
}
else
{
msg.ReplyTo = new EmailAddress(settings.Value.ReplyToEmail);
}
}
if (attachments.Any())
{
msg.AddAttachments(attachments);
}
var serialize = Encoding.UTF8.GetBytes(msg.Serialize());
var factory = new ConnectionFactory()
{
HostName = settings.Value.HostName,
UserName = settings.Value.RabbitUserName,
Password = settings.Value.RabbitPassword,
VirtualHost = settings.Value.VirtualHost
};
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();
channel.BasicPublish(exchange: settings.Value.Exchange,
routingKey: settings.Value.QueueName,
body: serialize);
logger.LogInformation($"Sent {data.TemplateId} email to {Helpers.Hash.GetSHA256Hash(settings.Value.CoHash + toEmail)}");
return(true);
}
catch (Exception ex)
{
logger.LogError(ex, $"Failed to PostMessagesAsync to rabbit sms queue. Exception: {ex.Message}");
throw;
}
}
catch (Exception exc)
{
logger.LogError(exc, $"Failed to PostMessagesAsync to rabbit sms queue. Exception: {exc.Message}");
return(false);
}
}
public static async Task Run(
[QueueTrigger("emails")] OutgoingEmail email,
[SendGrid] IAsyncCollector <SendGridMessage> messageCollector, ILogger log)
{
try
{
if (email is null)
{
throw new ArgumentNullException(nameof(email));
}
else if (email.Tos is null || !email.Tos.Any())
{
throw new ArgumentException("There must be at least one recipient.", nameof(email.Tos));
}
else if (string.IsNullOrWhiteSpace(email.Body))
{
throw new ArgumentNullException("There must be a body for the email.", nameof(email.Body));
}
log.LogInformation("Starting email process");
var message = new SendGridMessage();
message.SetFrom(new EmailAddress(Environment.GetEnvironmentVariable("FromEmail"), Environment.GetEnvironmentVariable("FromName")));
message.SetSubject(email.Subject);
message.HtmlContent = email.Body;
var hardcodedToEmail = Environment.GetEnvironmentVariable("ToEmail");
if (string.IsNullOrWhiteSpace(hardcodedToEmail))
{
foreach (var toEmail in email.Tos)
{
log.LogInformation("email: {toEmail}", toEmail);
message.AddTo(toEmail);
}
}
else
{
log.LogInformation("harcoded email: {email}", hardcodedToEmail);
message.AddTo(hardcodedToEmail);
}
if (email.Attachments != null && email.Attachments.Any())
{
log.LogInformation("Have {count} attachment(s)", email.Attachments.Count);
var storageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
var client = storageAccount.CreateCloudBlobClient();
var container = client.GetContainerReference(Environment.GetEnvironmentVariable("Container_Name"));
await container.CreateIfNotExistsAsync();
foreach (var file in email.Attachments)
{
var dirRef = container.GetDirectoryReference(file);
var isDirectory = dirRef.ListBlobs().Count() > 0;
if (isDirectory)
{
log.LogInformation("Processing folder: {file}", file);
var bag = new ConcurrentBag <Attachment>();
var taskList = new List <Task>();
foreach (CloudBlob b in dirRef.ListBlobs(useFlatBlobListing: true))
{
taskList.Add(Task.Run(async() => bag.Add(await DownloadBlob(b, log))));
}
await Task.WhenAll(taskList);
if (bag.Any())
{
message.AddAttachments(bag.ToList());
}
else
{
log.LogWarning("There are no files in the {folder} folder", file);
}
}
else
{
log.LogInformation("Processing file: {file}", file);
var blobRef = container.GetBlobReference(file);
if (await blobRef.ExistsAsync())
{
message.Attachments.Add(await DownloadBlob(blobRef, log));
}
else
{
throw new ArgumentException($"The file {file} does not exists", nameof(file));
}
}
}
}
log.LogDebug("Sending an email with the subject: {subject}", email.Subject);
await messageCollector.AddAsync(message);
log.LogInformation("Finished sending email");
}
