public static async Task <EmailResponse> SendCancellationEmail(Attendee _Attendee, HtmlTag html)
{
var message = new PostmarkMessage()
{
To = _Attendee.EmailAddress,
From = "*****@*****.**",
TrackOpens = true,
Subject = "Windforce Developer Conference Cancellation",
HtmlBody = html.Text,
Tag = "Windforce Developer Conference Cancellation",
};
var client = new PostmarkClient(_EmailAPIKey);
var sendResult = await client.SendMessageAsync(message);
EmailResponse EmailSendResponse = EmailResponse.Failure;
if (sendResult.Status == PostmarkStatus.Success)
{
EmailSendResponse = EmailResponse.Success;
}
else
{
EmailSendResponse = EmailResponse.Failure;
}
return(EmailSendResponse);
}
public async void SendEmail(string to)
{
var mailHeader = new MailHeader("X-CUSTOM-HEADER", "Header content");
var headers = new HeaderCollection();
headers.Add(mailHeader);
var message = new PostmarkMessage()
{
To = to,
From = "*****@*****.**",
TrackOpens = true,
Subject = "A complex email",
TextBody = "Plain Text Body",
HtmlBody = "<html><body><img src=\"cid:embed_name.jpg\"/></body></html>",
Tag = "New Year's Email Campaign",
Headers = headers
};
var imageContent = File.ReadAllBytes("test.jpg");
message.AddAttachment(imageContent, "test.jpg", "image/jpg", "cid:embed_name.jpg");
var client = new PostmarkClient("6cce5c93-a59e-4f32-b37d-c71525956b6b");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success) /* Handle success */ } {
private PostmarkMessage ConstructMessage(string inboundAddress, int number = 0)
{
var message = new PostmarkMessage()
{
From = WRITE_TEST_SENDER_EMAIL_ADDRESS,
To = WRITE_TEST_SENDER_EMAIL_ADDRESS,
Cc = WRITE_TEST_EMAIL_RECIPIENT_ADDRESS,
Bcc = "*****@*****.**",
Subject = String.Format("Integration Test - {0} - Message #{1}", TESTING_DATE, number),
HtmlBody = String.Format("Testing the Postmark .net client, <b>{0}</b>", TESTING_DATE),
TextBody = "This is plain text.",
TrackOpens = true,
TrackLinks = LinkTrackingOptions.HtmlAndText,
Headers = new HeaderCollection()
{
new MailHeader("X-Integration-Testing-Postmark-Type-Message", TESTING_DATE.ToString("o"))
},
ReplyTo = inboundAddress,
Tag = "integration-testing"
};
var content = "{ \"name\" : \"data\", \"age\" : null }";
message.Attachments.Add(new PostmarkMessageAttachment()
{
ContentType = "application/json",
Name = "test.json",
Content = Convert.ToBase64String(Encoding.UTF8.GetBytes(content))
});
return(message);
}
protected async void btnTestPostmark_Click(object sender, EventArgs e)
{
// Send an email asynchronously:
var message = new PostmarkMessage()
{
To = "*****@*****.**",
From = "*****@*****.**",
TrackOpens = true,
Subject = "Forgot Password",
TextBody = "Forgot Password?",
HtmlBody = "<html><body>Forgot Password?</body></html>",
Tag = "Password Reset"
};
//var imageContent = File.ReadAllBytes("test.jpg");
//message.AddAttachment(imageContent, "test.jpg", "image/jpg", "cid:embed_name.jpg");
var client = new PostmarkClient("e8603c27-0841-47fe-8cc6-daf4163de446");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Response.Write("OK");
}
else /* Resolve issue.*/ } {
public void CanConsructPostmarkMessageFromMailMessage()
{
var message = new MailMessage
{
From = new MailAddress("*****@*****.**", "Doc"),
To =
{
new MailAddress("*****@*****.**", "B")
},
ReplyToList = { new MailAddress("*****@*****.**", "C") },
Subject = "Hello",
Body = "TEST"
};
var plainView = AlternateView.CreateAlternateViewFromString("abc", Encoding.UTF8, "text/plain");
var htmlView = AlternateView.CreateAlternateViewFromString("<p>abc</p>", Encoding.UTF8, "text/html");
message.AlternateViews.Add(plainView);
message.AlternateViews.Add(htmlView);
var doc = PostmarkMessage.FromMailMessage(message);
Assert.Equal("Hello", doc.Subject);
Assert.Equal("abc", doc.TextBody);
Assert.Equal("<p>abc</p>", doc.HtmlBody);
Assert.Equal(@"""Doc"" <*****@*****.**>", doc.From);
Assert.Equal(@"""B"" <*****@*****.**>", doc.To);
}
public static PostmarkMessage ToPostmarkMessage(this MailMessage mailMessage)
{
var postmarkMessage = new PostmarkMessage
{
From = mailMessage.From.Address,
ReplyTo = mailMessage.ReplyToList.FirstOrDefault()?.Address,
To = string.Join(",", mailMessage.To.Select(to => to.Address)),
Cc = string.Join(",", mailMessage.CC.Select(cc => cc.Address)),
Bcc = string.Join(",", mailMessage.Bcc.Select(bcc => bcc.Address)),
Subject = mailMessage.Subject,
HtmlBody = mailMessage.IsBodyHtml
? mailMessage.Body
: null,
TextBody = !mailMessage.IsBodyHtml
? mailMessage.Body
: null
};
foreach (var mailAttachment in mailMessage.Attachments)
{
postmarkMessage.AddAttachment(mailAttachment.ContentStream, mailAttachment.Name, mailAttachment.ContentType.MediaType, mailAttachment.ContentId);
}
return(postmarkMessage);
}
public bool SendEmail(string from, string replyTo, string subject, string body, string to)
{
try
{
const string postmarkApiKey = "30ddd0b0-0b9a-432e-a892-3c8739aabf0c";
var message = new PostmarkMessage
{
From = from.Trim(),
To = to.Trim(),
Subject = subject,
HtmlBody = body,
TextBody = body,
ReplyTo = replyTo ?? from
};
var client = new PostmarkClient(postmarkApiKey.Trim());
var response = client.SendMessage(message);
}
catch (Exception)
{
return(false);
}
return(true);
}
public async Task <bool> SendEmail(EmailModel emailModel)
{
var message = new PostmarkMessage()
{
To = emailModel.Recipient,
From = emailModel.Sender,
TrackOpens = emailModel.TrackOpens,
Subject = emailModel.Subject,
TextBody = emailModel.TextBody,
HtmlBody = emailModel.HtmlBody,
MessageStream = emailModel.MessageStream,
Tag = emailModel.Tag
};
var client = new PostmarkClient(API_KEY);
try
{
var sendResult = await client.SendMessageAsync(message);
System.Threading.Thread.Sleep(500);
if (sendResult.Status == PostmarkStatus.Success)
{
return(true);
}
else
{
return(false);
}
}
catch (PostmarkValidationException)
{
return(false);
}
}
/*==========================================================================================================================
| SEND
\-------------------------------------------------------------------------------------------------------------------------*/
/// <summary>
/// Sends the <see cref="MailMessage"/> via SendGrid.
/// </summary>
public async Task SendAsync(MailMessage mailMessage) {
/*------------------------------------------------------------------------------------------------------------------------
| Assemble email
\-----------------------------------------------------------------------------------------------------------------------*/
PostmarkMessage message = new PostmarkMessage {
To = String.Join(", ", mailMessage.To.Select(x => x.Address)),
From = mailMessage.From.Address,
Subject = mailMessage.Subject,
TrackOpens = true
};
// Conditionally set body
if (mailMessage.IsBodyHtml) {
message.HtmlBody = mailMessage.Body;
}
else {
message.TextBody = mailMessage.Body;
}
/*------------------------------------------------------------------------------------------------------------------------
| Send email
\-----------------------------------------------------------------------------------------------------------------------*/
var response = await _smptClient.SendMessageAsync(message);
/*------------------------------------------------------------------------------------------------------------------------
| Validate response
\-----------------------------------------------------------------------------------------------------------------------*/
if (response.Status != PostmarkStatus.Success) {
throw new SmtpException(response.Message);
}
}
public static void SendEmail(string subject, string message, string recipient, string template)
{
var email = new PostmarkMessage
{
From = "*****@*****.**",
To = recipient
};
// email.Bcc = EmailRecipientSettings.Default.To;
email.Subject = subject;
// string filename = Path.Combine(HttpRuntime.AppDomainAppPath, "EmailTemplates/" + template);
var filename = Path.Combine(
Directory.GetCurrentDirectory(), "wwwroot/templates",
template);
string content = File.ReadAllText(filename);
content = content.Replace("#NotificationContent", message);
content = content.Replace("#date", DateTime.Today.ToString("dd-MMM-yyyy"));
content = content.Replace("#YEAR", DateTime.Now.Year.ToString());
email.HtmlBody = content;
email.TextBody = content;
var client = new PostmarkClient(EmailSettings.ServerToken);
IAsyncResult result = client.BeginSendMessage(email);
if (result.AsyncWaitHandle.WaitOne())
{
var response = client.EndSendMessage(result);
//return true;
}
}
public override Task SendEmailAsync(string email, string subject, string message)
{
var postmarkServerToken = Settings.Password;
var originEmailAddress = Settings.FromEmail;
if (!string.IsNullOrWhiteSpace(postmarkServerToken))
{
var emailMessage = new PostmarkMessage()
{
From = originEmailAddress,
To = email,
Subject = subject,
TextBody = message,
HtmlBody = message
};
var client = new PostmarkClient(postmarkServerToken);
return(client.SendMessageAsync(emailMessage));
}
else
{
Logger.LogError("Postmark server token is not configured, so we're not able to send emails.");
return(Task.FromResult(0));
}
}
//[Ignore("This test sends two real emails.")]
public void Can_send_batched_messages()
{
var postmark = new PostmarkClient(_serverToken);
var first = new PostmarkMessage
{
To = _to,
From = _from, // This must be a verified sender signature
Subject = Subject,
TextBody = TextBody,
HtmlBody = HtmlBody
};
var second = new PostmarkMessage
{
To = _to,
From = _from, // This must be a verified sender signature
Subject = Subject,
TextBody = TextBody,
HtmlBody = HtmlBody
};
var responses = postmark.SendMessages(first, second);
Assert.AreEqual(2, responses.Count());
foreach (var response in responses)
{
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.Success);
Console.WriteLine("Postmark -> {0}", response.Message);
}
}
//[Ignore("This test sends a real email.")]
public void Can_send_message_with_token_and_signature_and_headers_and_timeout()
{
var postmark = new PostmarkClient(_serverToken, 10);
var email = new PostmarkMessage
{
To = _to,
From = _from, // This must be a verified sender signature
Subject = Subject,
TextBody = TextBody,
HtmlBody = HtmlBody
};
email.Headers.Add("X-Header-Test-1", "This is a header value");
email.Headers.Add("X-Header-Test-2", "This is another header value");
var response = postmark.SendMessage(email);
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.Success);
Assert.AreNotEqual(default(DateTime), response.SubmittedAt, "Missing submitted time value.");
Console.WriteLine("Postmark -> {0}", response.Message);
}
public void Can_detect_html_in_message()
{
var message = new PostmarkMessage(_from, _to, Subject, "Have a <b>great</b> day!");
Assert.IsNotNull(message);
Assert.IsTrue(IsBodyHtml(message));
}
public void Can_detect_plain_text_message()
{
var message = new PostmarkMessage(_from, _to, Subject, "Have a great day!");
Assert.IsNotNull(message);
Assert.IsFalse(IsBodyHtml(message));
}
public Task SendEmailAsync(string email, string subject, string message)
{
var postmarkServerToken = configurationRootService[Config.POSTMARK_SERVER_TOKEN];
var originEmailAddress = configurationRootService[Config.EMAIL_FROM_ADDRESS];
if (!string.IsNullOrWhiteSpace(postmarkServerToken))
{
var emailMessage = new PostmarkMessage()
{
From = originEmailAddress,
To = email,
Subject = subject,
TextBody = message,
HtmlBody = message
};
var client = new PostmarkClient(postmarkServerToken);
return(client.SendMessageAsync(emailMessage));
}
else
{
logger.LogWarning("Postmark server token is not configured, so we're not able to send emails.");
return(Task.FromResult(0));
}
}
/// <summary>
/// Send Email is a method for sending an email
/// This is how the app integrates with Postmark API to send a message from teh send notification page
/// It shows a bootstrap modal for either fails and success.
/// </summary>
public bool SendEmail()
{
// Send an email asynchronously:
var message = new PostmarkMessage()
{
To = "*****@*****.**",
From = "*****@*****.**",
TrackOpens = true,
Subject = "A complex email",
TextBody = "Plain Text Body",
HtmlBody = "<html><body><p>A new notification has arrived.</p></body></html>",
Tag = "New Year's Email Campaign",
Headers = new HeaderCollection
{
{ "X-CUSTOM-HEADER", "Header content" }
}
};
//var imageContent = File.ReadAllBytes("test.jpg");
//message.AddAttachment(imageContent, "test.jpg", "image/jpg", "cid:embed_name.jpg");
PostmarkClient client = new PostmarkClient("efc7197a-4c0d-4f4b-92f7-43c612ed74b1");
PostmarkResponse response = client.SendMessage(message);
if (response.Status != PostmarkStatus.Success)
{
return(false);
}
else
{
return(true);
}
}
public static async Task Main(string[] args)
{
var message = new PostmarkMessage()
{
To = "*****@*****.**",
From = "*****@*****.**",
TrackOpens = true,
Subject = "Our First Test Email",
TextBody = "Hello, this is our first test email",
HtmlBody = "<strong>Hello</strong> dear Postmark user.",
MessageStream = "outbound",
Tag = "Test Email"
};
var client = new PostmarkClient("7e3947d6-ad88-41aa-91ae-8166ae128b21");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine("Success");
}
else
{
Console.WriteLine("Failure");
}
}
/// <summary>
/// Send the mail to the list of users based on the defined template
/// </summary>
/// <param name="emailTolist"></param>
/// <param name="subject"></param>
/// <param name="message"></param>
/// <param name="templateFileName"></param>
/// <param name="emailCcList"></param>
/// <param name="emailBccList"></param>
/// <returns></returns>
public void Send(List <string> emailTolist, string subject, List <string> changeObject, Dictionary <string, string> changeValue, string templateFileName, List <string> emailCcList = null, List <string> emailBccList = null)
{
SetSupporInfo(changeValue);
GetEmailSetting();
// Example asynchronous request
PostmarkMessage message = new PostmarkMessage()
{
From = senderEmail,
Cc = string.IsNullOrEmpty(_appSettings.EmailSettings.CCEmail) ? null : _appSettings.EmailSettings.CCEmail
};
foreach (var email in emailTolist)
{
message.To = email;
}
if (emailCcList != null && emailCcList.Count > 0)
{
foreach (var emailCc in emailTolist)
{
message.Cc = emailCc;
}
}
if (emailBccList != null && emailBccList.Count > 0)
{
foreach (var emailBcc in emailBccList)
{
message.Cc = emailBcc;
}
}
message.Subject = subject;
string emailBody = BodyTemplate.CreateMailBody(changeObject, changeValue, templateFileName, senderName, NotificationType.Email);
message.HtmlBody = emailBody;
//File Attachment for Images in Mail
string filePath = Directory.GetCurrentDirectory() + "\\wwwroot\\TemplateImages\\";
List <string> files = Directory.GetFiles(filePath).ToList();
foreach (string file in files)
{
var imageContent = File.ReadAllBytes(file);
message.AddAttachment(imageContent, file.Replace(filePath, "").ToLower(), "image/png", "cid:" + file.Replace(filePath, "").ToLower());
}
var client = new PostmarkClient(postMarkKey);
var sendResult = client.SendMessageAsync(message);
}
public async Task <ServiceResult> SendEmailAsync(PostmarkMessage message)
{
//TODO - handle results from sending postmark message
var serviceResult = new ServiceResult();
var postmarkKey = await _systemServices.GetSettingAsync("PostMarkKey");
var client = new PostmarkClient(postmarkKey.Value);
var sendResult = await client.SendMessageAsync(message);
return(serviceResult);
}
public void Can_send_message_with_token_and_signature_and_invalid_recipient_and_throw_validation_exception()
{
var postmark = new PostmarkClient(_serverToken);
var email = new PostmarkMessage
{
To = "earth",
From = _from,
Subject = Subject,
TextBody = TextBody
};
postmark.SendMessage(email);
}
public void SendEmail(string from, string to, string subject, string bodyText)
{
var message = new PostmarkMessage
{
From = from,
To = to,
Subject = subject,
TextBody = bodyText,
ReplyTo = "*****@*****.**"
};
var client = new PostmarkClient(_apiKey);
var response = client.SendMessage(message);
}
public async Task <ServiceResult> SendEmailAsync(string toEmail, string fromEmail, string replyToEmail, string subject, string message, string tag)
{
var postmarkMessage = new PostmarkMessage()
{
To = toEmail,
From = fromEmail,
TrackOpens = true,
ReplyTo = replyToEmail,
Tag = tag,
Subject = subject,
TextBody = message
};
return(await SendEmailAsync(postmarkMessage));
}
public void Can_generate_postmarkmessage_from_mailmessage()
{
var mm = new MailMessage
{
Subject = "test",
Body = "test"
};
mm.Headers.Add("X-PostmarkTag", "mytag");
var pm = new PostmarkMessage(mm);
Assert.AreEqual(mm.Subject, pm.Subject);
Assert.AreEqual(mm.Body, pm.TextBody);
Assert.AreEqual("mytag", pm.Tag);
}
/// <summary>
/// Creates a new Postmark message for the given recipient.
/// </summary>
private PostmarkMessage CreateMessage(
EmailRecipient recipient,
string subject,
string body,
bool broadcast,
EmailSender customSender = null,
ThreadInfo threadInfo = null)
{
var message = new PostmarkMessage()
{
To = $"{recipient.Name} {recipient.EmailAddress}",
From = customSender != null
? $"{customSender.Name} {customSender.FromAddress}"
: $"CS Classroom {_config.DefaultFromEmail}",
TrackOpens = true,
Subject = subject,
HtmlBody = body,
MessageStream = broadcast
? _config.BroadcastMessageStream
: _config.TransactionalMessageStream
};
if (threadInfo != null)
{
var headers = new Dictionary <string, string>();
headers["Message-Id"] = $"<{threadInfo.MessageId}>";
if (threadInfo.InReplyTo != null)
{
headers["In-Reply-To"] = $"<{threadInfo.InReplyTo}>";
}
if (threadInfo.References != null)
{
headers["References"] = string.Join
(
" ",
threadInfo.References.Select(r => $"<{r}>")
);
}
message.Headers = new HeaderCollection(headers);
}
return(message);
}
public async Task <ServiceResult> SendEmailAsync(string toEmail, string subject, string message)
{
var systemEmail = await _systemServices.GetSettingAsync("Email-Admin");
var postmarkMessage = new PostmarkMessage()
{
To = toEmail,
From = systemEmail.Value,
TrackOpens = true,
ReplyTo = systemEmail.Value,
Tag = "account",
Subject = subject,
TextBody = message
};
return(await SendEmailAsync(postmarkMessage));
}
public void Can_generate_postmarkmessage_using_correct_tag_header_from_mailmessage()
{
var mm = new MailMessage
{
Subject = "test",
Body = "test"
};
mm.To.Add("*****@*****.**");
mm.Headers.Add("X-PM-Tag", "correct tag");
//This header should be overridden by using the correct 'X-PM-Tag'
mm.Headers.Add("X-PostmarkTag", "overridden tag");
var pm = new PostmarkMessage(mm);
Assert.AreEqual("correct tag", pm.Tag);
}
public async Task <bool> SendEmail(MailMessage email)
{
try
{
var to = new StringBuilder();
foreach (var t in email.To)
{
if (to.Length == 0)
{
to.Append(t.Address);
}
else
{
to.Append("," + t.Address);
}
}
var message = new PostmarkMessage(email.From.Address, to.ToString(), email.Subject, StringHelpers.StripHtmlTagsCharArray(email.Body), email.Body);
var newClient = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
message.From = null;
var response = await newClient.SendMessageAsync(message);
if (response.ErrorCode != 200 && response.ErrorCode != 406 && response.Message != "OK" &&
!response.Message.Contains("You tried to send to a recipient that has been marked as inactive"))
{
Logging.LogError(string.Format(
"Error from PostmarkEmailSender->SendEmail: {3} {0} FromEmail:{1} ToEmail:{2}",
response.Message, email.From.Address, email.To.First().Address, response.ErrorCode));
return(false);
}
return(true);
}
catch (PostmarkValidationException) { }
catch // (Exception ex)
{
//if (!ex.ToString().Contains("You tried to send to a recipient that has been marked as inactive."))
// Logging.LogException(ex);
}
return(false);
}
/// <summary>
/// Send the mail to the list of users based on the defined template
/// </summary>
/// <param name="emailTolist"></param>
/// <param name="subject"></param>
/// <param name="message"></param>
/// <param name="templateFileName"></param>
/// <param name="emailCcList"></param>
/// <param name="emailBccList"></param>
/// <returns></returns>
public void Send(List <string> emailTolist, string subject, string message, string templateFileName, List <string> emailCcList = null, List <string> emailBccList = null, string name = "")
{
GetEmailSetting();
// Example asynchronous request
PostmarkMessage postMarkMessage = new PostmarkMessage()
{
From = senderEmail,
};
foreach (var email in emailTolist)
{
postMarkMessage.To = email;
}
if (emailCcList != null && emailCcList.Count > 0)
{
foreach (var emailCc in emailTolist)
{
postMarkMessage.Cc = emailCc;
}
}
if (emailBccList != null && emailBccList.Count > 0)
{
foreach (var emailBcc in emailBccList)
{
postMarkMessage.Cc = emailBcc;
}
}
postMarkMessage.Subject = subject;
string emailBody = BodyTemplate.CreateMailBody(message, templateFileName, senderName, NotificationType.Email, name);
postMarkMessage.HtmlBody = emailBody;
//var imageContent = File.ReadAllBytes("test.jpg");
//message.AddAttachment(imageContent, "test.jpg", "image/jpg", "cid:embed_name.jpg");
var client = new PostmarkClient(postMarkKey);
var sendResult = client.SendMessageAsync(postMarkMessage);
}
public void Can_send_message_without_signature_and_receive_422()
{
var postmark = new PostmarkClient(_serverToken);
var email = new PostmarkMessage
{
To = InvalidRecipient,
From = InvalidRecipient, // This must not be a verified sender signature
Subject = Subject,
TextBody = TextBody
};
var response = postmark.SendMessage(email);
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.UserError);
}
