public async Task<string> Send(IMessage message)
{
var msg = new SendGridMessage();
msg.Subject = message.Subject;
msg.From = new MailAddress(message.From);
msg.Html = message.Body;
msg.AddTo(message.To);
msg.EnableClickTracking();
msg.EnableOpenTracking();
try
{
var transportWeb = new Web(_apiKey);
await transportWeb.DeliverAsync(msg);
}
catch (Exception ex)
{
throw new MailerException(ex.Message, MailerException.enReason.RejectByProvider);
}
return null;
}
public override async Task<bool> SendNotificationAsync(PushNotificationItem notificationItem, object message, CancellationToken ct)
{
var cfg = (SendGridDeliveryProviderConfiguration)Configuration;
var sent = false;
//implicit conversion operator
MailMessage smsg = message as SerializableMailMessage;
if (smsg != null)
{
try
{
var hView = smsg.AlternateViews.First(v => v.ContentType.MediaType == "text/html");
var tView = smsg.AlternateViews.First(v => v.ContentType.MediaType == "text/plain");
var sendGridMessage = new SendGridMessage
{
To = new[]
{
new MailAddress(notificationItem.Destination.DestinationAddress,
notificationItem.Destination.SubscriberName)
},
From = new MailAddress(cfg.FromAddress, cfg.FromDisplayName),
Subject = smsg.Subject,
Html = hView.ContentStream.ReadToString(),
Text = tView.ContentStream.ReadToString()
};
if (cfg.EnableClickTracking ?? false)
{
sendGridMessage.EnableClickTracking();
}
if (cfg.EnableGravatar ?? false)
{
sendGridMessage.EnableGravatar();
}
if (cfg.EnableOpenTracking ?? false)
{
sendGridMessage.EnableOpenTracking();
}
if (cfg.SendToSink ?? false)
{
sendGridMessage.SendToSink();
}
var transport = new Web(cfg.ApiKey);
await transport.DeliverAsync(sendGridMessage);
sent = true;
}
catch
{
sent = false;
//TODO: log this somewhere
}
}
return sent;
}
public void Send()
{
SendGridMessage client = new SendGridMessage();
client.From = new MailAddress(From);
client.AddTo(To);
client.Subject = Subject;
client.Text = Regex.Replace(Body, "<.*?>", string.Empty);
client.Html = Body.Replace("\r\n", "<br>");
client.EnableClickTracking();
client.EnableOpenTracking();
Web transport = new Web(ConfigurationManager.AppSettings[GetType().Name]);
transport.DeliverAsync(client).ConfigureAwait(false);
}
/// <summary>
/// Sends the mail batch using the SendGrid API
/// </summary>
/// <param name="mail">The mail.</param>
/// <param name="recipients">The recipients.</param>
/// <param name="onlyTestDontSendMail">if set to <c>true</c> [only test dont send mail].</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override bool SendMailBatch(MailInformation mail, IEnumerable<JobWorkItem> recipients, bool onlyTestDontSendMail)
{
var settings = GetSettings();
if (recipients == null || recipients.Any() == false)
throw new ArgumentException("No workitems", "recipients");
if (recipients.Count() > 1000)
throw new ArgumentOutOfRangeException("recipients", "SendGrid supports maximum 1000 recipients per batch send.");
var msg = new SendGridMessage();
msg.From = new MailAddress(mail.From);
msg.Subject = mail.Subject;
msg.Html = mail.BodyHtml;
msg.Text = mail.BodyText;
// Add recipinets to header, to hide other recipients in to field.
List<string> addresses = recipients.Select(r => r.EmailAddress).ToList();
msg.Header.SetTo(addresses);
msg.AddSubstitution("%recipient%", addresses);
// To send message we need to have a to address, set that to from
msg.To = new MailAddress[] { msg.From };
if (mail.EnableTracking)
{
// true indicates that links in plain text portions of the email
// should also be overwritten for link tracking purposes.
msg.EnableClickTracking(true);
msg.EnableOpenTracking();
}
if(mail.CustomProperties.ContainsKey("SendGridCategory"))
{
string category = mail.CustomProperties["SendGridCategory"] as string;
if (string.IsNullOrEmpty(category) == false)
msg.SetCategory(category);
}
var credentials = new NetworkCredential(settings.Username, settings.Password);
// Create an Web transport for sending email.
var transportWeb = new Web(credentials);
transportWeb.Deliver(msg);
return true;
}
public async Task SendEmail(string subject, string fromEmail, string fromName, List<string> toEmailsList, string plainBody, string htmlBody)
{
var myMessage = new SendGridMessage {From = new MailAddress(fromEmail, fromName)};
myMessage.AddTo(toEmailsList);
myMessage.Subject = subject;
if (!string.IsNullOrEmpty(htmlBody))
{
myMessage.Html = htmlBody;
}
if (!string.IsNullOrEmpty(plainBody))
{
myMessage.Text = plainBody;
}
//myMessage.EnableFooter("PLAIN TEXT FOOTER", "<p><em>HTML FOOTER</em></p>");
myMessage.EnableClickTracking(true);
var credentials = new NetworkCredential(UserName, Password);
var transportWeb = new Web(credentials);
await transportWeb.DeliverAsync(myMessage);
}
public async Task<HttpResponseMessage> SendEmail(Email email)
{
var myMessage = new SendGridMessage();
myMessage.From = new MailAddress(email.from);
List<string> recipients = email.recipients.Split(',', ';').ToList<string>();
myMessage.AddTo(recipients);
myMessage.Subject = email.subject;
myMessage.Text = string.IsNullOrEmpty(email.text) ? null : email.text;
myMessage.Html = string.IsNullOrEmpty(email.html) ? null : email.html;
myMessage.EnableClickTracking(email.clickTracking);
var transportWeb = new Web(ConfigurationManager.AppSettings["SendgridApiKey"]);
await transportWeb.DeliverAsync(myMessage);
return Request.CreateResponse(HttpStatusCode.OK);
}
public void Test_EnablingClickTracking_true()
{
var mail = BasicMailBuilder
.EnableClickTracking(true)
.Build();
var message = new SendGridMessage();
message.EnableClickTracking(true);
Assert.IsFalse(string.IsNullOrEmpty(message.Header.JsonString()));
Assert.AreEqual(message.Header.JsonString(), mail.Header.JsonString());
}
private static Task sendMailWithSendgrid(string email, string dni, string url)
{
// Create the email object first, then add the properties.
SendGridMessage mensaje = new SendGridMessage();
mensaje.AddTo(email);
mensaje.From = new MailAddress("*****@*****.**", "Administracion Cent11");
mensaje.Subject = "Creando usuario con dni " + dni;
mensaje.Text = String.Format("<a href='{0}'>Click para activar usuario</a>", url);
mensaje.Html = String.Format("<a href='{0}'>Click para activar usuario</a>", url);
mensaje.EnableClickTracking(true);
// Create an Web transport for sending email.
var transportWeb = new Web(SendGridMailApiKey);
// Send the email, which returns an awaitable task.
return transportWeb.DeliverAsync(mensaje);
}
/// <summary>
/// Point the urls to Sendgrid Servers so that the clicks can be logged before
/// being directed to the appropriate link
/// http://docs.sendgrid.com/documentation/apps/click-tracking/
/// </summary>
public void EnableClickTrackingEmail()
{
//create a new message object
var message = new SendGridMessage();
//set the message recipients
foreach (var recipient in _to)
{
message.AddTo(recipient);
}
//set the sender
message.From = new MailAddress(_from);
//set the message body
var timestamp = DateTime.Now.ToString("HH:mm:ss tt");
message.Html = "<p style='color:red';>Hello World HTML </p> <a href='http://microsoft.com'>Checkout Microsoft!!</a>";
message.Html += "<p>Sent At : " + timestamp + "</p>";
message.Text = "hello world http://microsoft.com";
//set the message subject
message.Subject = "Hello World Click Tracking Test";
//create an instance of the Web transport mechanism
var transportInstance = new Web(new NetworkCredential(_username, _password));
//enable clicktracking
message.EnableClickTracking();
//send the mail
transportInstance.DeliverAsync(message);
}
public static void SendEmailViaSendGrid(string to, string from, string subject, string htmlBody, MailType type, string textBody, string[] multipleTo = null)
{
try
{
//var message = SendGrid.GenerateInstance();
var message = new SendGridMessage();
if (String.IsNullOrEmpty(to))
message.AddTo(multipleTo);
else
message.AddTo(to);
//if (multipleTo != null)
// message.AddTo(multipleTo);
//else
// message.AddTo(to);
message.From = new System.Net.Mail.MailAddress(from);
message.Subject = subject;
if (type == MailType.TextOnly)
message.Text = textBody.Replace(@"\r\n", Environment.NewLine);
else if (type == MailType.HtmlOnly)
message.Html = htmlBody;
else
{
message.Html = htmlBody;
message.Text = textBody;
}
//Dictionary<string, string> collection = new Dictionary<string, string>();
//collection.Add("header", "header");
//message.Headers = collection;
message.EnableOpenTracking();
message.EnableClickTracking();
message.DisableUnsubscribe();
message.DisableFooter();
message.EnableBypassListManagement();
//var transportInstance = SMTP.GenerateInstance(new System.Net.NetworkCredential(SendGridUsername, SendGridPassword), SendGridSmtpHost, SendGridSmtpPort);
var transportInstance = new Web(new System.Net.NetworkCredential(SendGridUsername, SendGridPassword));
transportInstance.Deliver(message);
if (String.IsNullOrEmpty(to))
Console.WriteLine("SendGrid: Email was sent successfully to " + multipleTo);
else
Console.WriteLine("SendGrid: Email was sent successfully to " + to);
}
catch (Exception)
{
if (String.IsNullOrEmpty(to))
Console.WriteLine("SendGrid: Unable to send email to " + multipleTo);
else
Console.WriteLine("SendGrid: Unable to send email to " + to);
throw;
}
}
public MailBuilder EnableClickTracking(bool includePlainText = false)
{
sendgrid.EnableClickTracking(includePlainText);
return(this);
}
public void EnableClickTracking()
{
var header = new Header();
var sendgrid = new SendGridMessage(header);
sendgrid.EnableClickTracking(true);
var json = header.JsonString();
Assert.AreEqual("{\"filters\" : {\"clicktrack\" : {\"settings\" : {\"enable\" : \"1\",\"enable_text\" : \"1\"}}}}",
json);
}
/// <summary>
/// This function will send the email via SendGrid.
/// </summary>
/// <param name="kMessage">MailMessage - Message object to send</param>
protected void SendSendGridEmail(MailMessage kMessage)
{
try
{
StringBuilder sb = new StringBuilder();
sb.Append("Date:");
sb.AppendLine();
sb.Append(DateTime.Now.ToString());
sb.AppendLine();
// Create the email object first, then add the properties.
var sgMessage = new SendGridMessage();
// Add the message properties.
sgMessage.From = new MailAddress(kMessage.From.ToString());
sb.Append("From:");
sb.AppendLine();
sb.Append(sgMessage.From.Address);
sb.AppendLine();
// Add multiple addresses to the To field.
sb.Append("To:");
sb.AppendLine();
foreach (MailAddress address in kMessage.To)
{
sgMessage.AddTo(address.Address);
sb.Append(address.Address + ";");
}
sb.AppendLine();
sgMessage.Subject = kMessage.Subject;
sb.Append("Subject:");
sb.AppendLine();
sb.Append(sgMessage.Subject);
sb.AppendLine();
// HTML & plain-text
if (kMessage.AlternateViews.Count > 0)
{
foreach (AlternateView view in kMessage.AlternateViews)
{
// Position must be reset first
if (view.ContentStream.CanSeek)
{
view.ContentStream.Position = 0;
}
using (StreamWrapper wrappedStream = StreamWrapper.New(view.ContentStream))
{
using (StreamReader reader = StreamReader.New(wrappedStream))
{
if (view.ContentType.MediaType == MediaTypeNames.Text.Html)
{
sgMessage.Html = reader.ReadToEnd();
}
else if (view.ContentType.MediaType == MediaTypeNames.Text.Plain)
{
sgMessage.Text = reader.ReadToEnd();
}
}
}
}
}
sb.Append("Body:");
if (ValidationHelper.GetString(sgMessage.Html, "") != "")
{
sb.Append(sgMessage.Html);
}
else
{
sb.Append(sgMessage.Text);
}
sb.AppendLine();
//Handle any attachments
sb.Append("Attachments:");
sb.AppendLine();
foreach (Attachment attachment in kMessage.Attachments)
{
sgMessage.AddAttachment(attachment.ContentStream, attachment.Name);
sb.Append(attachment.Name);
sb.AppendLine();
}
//Enable click tracking
sgMessage.EnableClickTracking(true);
// Create credentials, specifying your user name and password.
var credentials = new NetworkCredential("[SendGridLogin]", "[SendGridPassword]");
// Create an Web transport for sending email.
var transportWeb = new Web(credentials);
// Send the email.
transportWeb.Deliver(sgMessage);
//Log the email details to the Event Log
EventLogProvider.LogInformation("SendSendGridEmail", "EMAIL SENT", ValidationHelper.GetString(sb, ""));
}
catch (Exception ex)
{
EventLogProvider.LogException("SendSendGridEmail", "EXCEPTION", ex);
}
}
public void SendSMTP(string from, string to, string subject, string message, string cc = null, string bcc = null, string attachments = null, string alternateText = null, bool trackLinks = false)
{
SendGridMessage mailMessage = new SendGridMessage();
MailAddress fromAddress = new MailAddress(from);
List<string> recipients = to.Replace(",", ";").Split(';').ToList();
mailMessage.From = fromAddress;
mailMessage.AddTo(recipients);
mailMessage.Subject = subject;
mailMessage.Html = message;
mailMessage.Text = alternateText;
if(!String.IsNullOrEmpty(attachments))
{
List<string> attachmentFiles = attachments.Replace(",", ";").Split(';').ToList();
foreach(string attachmentFile in attachmentFiles)
{
mailMessage.AddAttachment(attachmentFile);
}
}
mailMessage.EnableClickTracking(trackLinks);
NetworkCredential credentials = new NetworkCredential(this._smtpUser, this._smtpPassword);
var webTransport = new Web(credentials);
webTransport.DeliverAsync(mailMessage).Wait();
}
