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);
}
}
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 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));
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name="from">An email address for a sender.</param>
/// <param name="to">An email address for a recipient.</param>
/// <param name="subject">The message subject line.</param>
/// <param name="body">The message body.</param>
/// <param name="headers">A collection of additional mail headers to send with the message.</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction.</returns>
public static async Task <PostmarkResponse> SendMessageAsync(this PostmarkClient client,
string from, string to, string subject, string body, IDictionary <string, string> headers = null)
{
var message = new PostmarkMessage(from, to, subject, body, headers);
return(await client.SendMessageAsync(message));
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "from">An email address for a sender.</param>
/// <param name = "to">An email address for a recipient.</param>
/// <param name = "subject">The message subject line.</param>
/// <param name = "body">The message body.</param>
/// <param name = "headers">A collection of additional mail headers to send with the message.</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction.</returns>
public PostmarkResponse SendMessage(string from, string to, string subject, string body,
NameValueCollection headers)
{
var message = new PostmarkMessage(from, to, subject, body, headers);
return(SendMessage(message));
}
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,
Headers = new HeaderCollection(){
{ "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;
}
/// <summary>
/// Add a file from the specified path to this message.
/// </summary>
/// <param name="message"></param>
/// <param name="path"></param>
/// <param name="contentType"></param>
/// <param name="contentId"></param>
public static void AddAttachment(this PostmarkMessage message,
string path, string contentType = null, string contentId = null)
{
var fi = new FileInfo(path);
var content = File.ReadAllBytes(path);
message.AddAttachment(content, fi.Name, contentType, contentId);
}
public string SendCriticalErrorEmail(string sendTo, string sendFrom, string dateTimeStamp, string errorInformation, string postMarkAPIKey)
{
_logger.DebugFormat("Sending critical error to: {0}", sendTo);
// Send a critical error email
string returnMessage = string.Empty;
// Build the message
StringBuilder oSB = new StringBuilder();
oSB.AppendLine("As of " + dateTimeStamp + " there was a critical error in the Invoice Processing Service.");
oSB.AppendLine("<br/>");
oSB.AppendLine("<br/>");
oSB.AppendLine("Error Information:");
oSB.AppendLine("<br/>");
oSB.AppendLine("<br/>");
oSB.AppendLine(errorInformation);
string finalBody = oSB.ToString();
string emailSubject = "Invoice Processing Critical Service Error - " + dateTimeStamp;
string postMarkServerTokenDesc = "X-Postmark-Server-Token";
// Build the email
PostmarkMessage message = new PostmarkMessage(sendFrom, sendTo, emailSubject, finalBody);
try
{
PostmarkMessage newMessage = new PostmarkMessage
{
From = sendFrom,
To = sendTo,
Subject = emailSubject,
HtmlBody = finalBody,
TextBody = string.Empty,
ReplyTo = sendFrom,
Headers = new NameValueCollection { { postMarkServerTokenDesc, postMarkAPIKey } }
};
PostmarkClient client = new PostmarkClient(postMarkAPIKey);
PostmarkResponse response = client.SendMessage(newMessage);
// Set the response information
string responseMessage = response.Status.ToString();
}//
catch (PostmarkDotNet.Validation.ValidationException exPM)
{
returnMessage = exPM.ToString();
_logger.ErrorFormat("Postmark validation error sending critical error email: {0}", returnMessage);
}
catch (Exception ex)
{
returnMessage = ex.ToString();
_logger.ErrorFormat("Exception sending critical error email: {0}", returnMessage);
}
return returnMessage;
}
private static void CleanPostmarkMessage(PostmarkMessage message)
{
message.From = message.From.Trim();
if (!string.IsNullOrEmpty(message.To))
{
message.To = message.To.Trim();
}
message.Subject = message.Subject != null?message.Subject.Trim() : "";
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "message">A prepared message instance</param>
/// <param name="callback">The callback invoked when a response is received from the API</param>
public void SendMessage(PostmarkMessage message, Action <PostmarkResponse> callback)
{
var request = NewEmailRequest();
CleanPostmarkMessage(message);
request.Entity = message;
BeginGetPostmarkResponse(request, callback);
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "message">A prepared message instance.</param>
/// <returns></returns>
public PostmarkResponse SendMessage(PostmarkMessage message)
{
var request = NewEmailRequest();
CleanPostmarkMessage(message);
request.Entity = message;
return(GetPostmarkResponse(request));
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name="client">The postmark client instance on which to do the send.</param>
/// <param name="from">An email address for a sender.</param>
/// <param name="to">An email address for a recipient.</param>
/// <param name="subject">The message subject line.</param>
/// <param name="textBody">The Plain Text Body to be used for the message, this may be null if HtmlBody is set.</param>
/// <param name="htmlBody">The HTML Body to be used for the message, this may be null if TextBody is set.</param>
/// <param name="headers">A collection of additional mail headers to send with the message.</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction.</returns>
public static async Task <PostmarkResponse> SendMessageAsync(this PostmarkClient client,
string from, string to, string subject, string textBody, string htmlBody,
IDictionary <string, string> headers = null,
IDictionary <string, string> metadata = null)
{
var message = new PostmarkMessage(from, to, subject, textBody, htmlBody,
new HeaderCollection(headers), metadata);
return(await client.SendMessageAsync(message));
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "message">A prepared message instance</param>
/// <param name="callback">The callback invoked when a response is received from the API</param>
public void SendMessage(PostmarkMessage message, Action<PostmarkResponse> callback)
{
var request = NewEmailRequest();
CleanPostmarkMessage(message);
request.Entity = message;
BeginGetPostmarkResponse(request, callback);
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "message">A prepared message instance</param>
/// <returns></returns>
public IAsyncResult BeginSendMessage(PostmarkMessage message)
{
var request = NewEmailRequest();
CleanPostmarkMessage(message);
request.Entity = message;
return(BeginGetPostmarkResponse(request));
}
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);
}
private static void GetMailMessageBcc(PostmarkMessage m, MailMessage message)
{
var sb = new StringBuilder(0);
if (message.Bcc.Count > 0)
{
foreach (var bcc in message.Bcc)
{
sb.AppendFormat("{0},", bcc.Address);
}
}
m.Bcc = sb.ToString();
}
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);
}
protected override void ProcessRecord()
{
var message = new PostmarkMessage
{
From = From,
To = To,
Subject = Subject,
HtmlBody = HtmlBody,
TextBody = TextBody,
ReplyTo = ReplyTo,
};
var response = PostmarkClient.SendMessage(message);
WriteObject(response);
}
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);
}
private static void GetMailMessageTo(PostmarkMessage m, MailMessage message)
{
var sb = new StringBuilder(0);
foreach (var to in message.To)
{
if (!string.IsNullOrEmpty(to.DisplayName))
{
sb.AppendFormat("{0} <{1}>,", to.DisplayName, to.Address);
}
else
{
sb.AppendFormat("{0},", to.Address);
}
}
m.To = sb.ToString();
}
private static void ValidatePostmarkMessage(PostmarkMessage message)
{
var specification = new ValidEmailSpecification();
if (string.IsNullOrEmpty(message.From) || !specification.IsSatisfiedBy(message.From))
{
throw new ValidationException("You must specify a valid 'From' email address.");
}
if (!string.IsNullOrEmpty(message.To))
{
var recipients = message.To.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var recipient in recipients.Where(email => !specification.IsSatisfiedBy(email)))
{
throw new ValidationException(
string.Format("The provided recipient address '{0}' is not valid", recipient)
);
}
}
if (!string.IsNullOrEmpty(message.ReplyTo) && !specification.IsSatisfiedBy(message.ReplyTo))
{
throw new ValidationException("If a 'ReplyTo' email address is included, it must be valid.");
}
if (!string.IsNullOrEmpty(message.Cc))
{
var ccs = message.Cc.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var cc in ccs.Where(email => !specification.IsSatisfiedBy(email)))
{
throw new ValidationException(
string.Format("The provided CC address '{0}' is not valid", cc)
);
}
}
if (!string.IsNullOrEmpty(message.Bcc))
{
var bccs = message.Bcc.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var bcc in bccs.Where(email => !specification.IsSatisfiedBy(email)))
{
throw new ValidationException(
string.Format("The provided BCC address '{0}' is not valid", bcc)
);
}
}
}
public static PostmarkResponse SendEmail(string toAddress, string fromAddress, string subject, string body, string attachmentName = "", params File[] files)
{
string attachmentContent = null;
if (files.Any())
{
try
{
attachmentContent = ZipFiles(files);
}
catch (Exception ex)
{
ErrorSignal.FromCurrentContext().Raise(new ApplicationException("Failed to zip email attachments.", ex));
}
}
var message = new PostmarkMessage
{
From = ConfigurationManager.AppSettings["PostmarkSignature"],
ReplyTo = fromAddress,
To = toAddress,
Subject = subject,
TextBody = body
};
if (attachmentContent != null)
{
var attachment = new PostmarkMessageAttachment
{
Name = attachmentName + ".zip",
ContentType = "application/zip",
Content = attachmentContent
};
message.Attachments.Add(attachment);
}
var client = new PostmarkClient(ConfigurationManager.AppSettings["PostmarkApiKey"]);
var result = client.SendMessage(message);
if (result.Status != PostmarkStatus.Success)
{
ErrorSignal.FromCurrentContext().Raise(new ApplicationException(String.Format("Failed to send email to {0}.\nReason: {1}", toAddress, result.Message)));
}
return result;
}
private static PostmarkMessage CreatePostmarkMessage(EmailMessage message)
{
var pm = new PostmarkMessage
{
From = message.From,
Subject = message.Subject,
TextBody = message.TextBody,
HtmlBody = message.HtmlBody,
To = message.To.Count > 0 ? string.Join(",", message.To) : "",
ReplyTo = message.ReplyTo.Count > 0 ? string.Join(",", message.ReplyTo) : "",
Cc = message.Cc.Count > 0 ? string.Join(",", message.Cc) : "",
Bcc = message.Bcc.Count > 0 ? string.Join(",", message.Bcc) : ""
};
foreach(var header in message.Headers)
{
pm.Headers.Add(header.Name, header.Value);
}
return pm;
}
private static void GetHtmlBodyFromAlternateViews(PostmarkMessage m, MailMessage message)
{
if (message.AlternateViews.Count <= 0)
{
return;
}
var plainTextView = message.AlternateViews.Where(v => v.ContentType.MediaType.Equals(MediaTypeNames.Text.Plain)).FirstOrDefault();
if (plainTextView != null)
{
m.TextBody = GetStringFromView(plainTextView);
}
var htmlView = message.AlternateViews.Where(v => v.ContentType.MediaType.Equals(MediaTypeNames.Text.Html)).FirstOrDefault();
if (htmlView != null)
{
m.HtmlBody = GetStringFromView(htmlView);
}
}
public void Can_send_message_with_token_and_signature_async()
{
var postmark = new PostmarkClient(_serverToken);
var email = new PostmarkMessage
{
To = _to,
From = _from, // This must be a verified sender signature
Subject = Subject,
TextBody = TextBody
};
var result = postmark.BeginSendMessage(email);
var response = postmark.EndSendMessage(result);
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.Success);
Console.WriteLine("Postmark -> {0}", response.Message);
}
public ActionResult Contact(PostmarkMessage msg)
{
msg.From = "*****@*****.**";
msg.To = "[email protected],[email protected]";
return View("ThankYou");
/*
try
{
PostmarkClient client = new PostmarkClient("d5e6b4a6-5c98-4e63-a9ce-c22e6d5cdafc");
PostmarkResponse response = client.SendMessage(msg);
return View("ThankYou");
}
catch
{
return View("Contact", msg);
}
*/
}
public void Can_send_message_with_CC_and_BCC()
{
var postmark = new PostmarkClient("POSTMARK_API_TEST");
var email = new PostmarkMessage
{
To = _invalidRecipient,
Cc = "*****@*****.**",
Bcc = "*****@*****.**",
From = _invalidRecipient,
Subject = _subject,
TextBody = _textBody
};
var response = postmark.SendMessage(email);
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.Success);
Console.WriteLine("Postmark -> " + response.Message);
}
public void Can_send_message_without_token_and_receive_401()
{
var postmark = new PostmarkClient("");
var email = new PostmarkMessage
{
To = _invalidRecipient,
From = _invalidRecipient,
Subject = _subject,
TextBody = _textBody
};
var response = postmark.SendMessage(email);
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.UserError);
Console.WriteLine("Postmark -> " + response.Message);
}
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);
Console.WriteLine("Postmark -> " + response.Message);
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "from">An email address for a sender.</param>
/// <param name = "to">An email address for a recipient.</param>
/// <param name = "subject">The message subject line.</param>
/// <param name = "textbody">The plain text body. Can be null if htmlbody is set.</param>
/// <param name="htmlbody">The html text body. Can be null if textbody is set.</param>
/// <param name = "headers">A collection of additional mail headers to send with the message.</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction.</returns>
public PostmarkResponse SendMessage(string from, string to, string subject, string textbody, string htmlbody, HeaderCollection headers)
{
var message = new PostmarkMessage(from, to, subject, textbody, htmlbody, headers);
return(SendMessage(message));
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name="message">A prepared message instance.</param>
/// <returns></returns>
public PostmarkResponse SendMessage(PostmarkMessage message)
{
var request = NewEmailRequest();
ValidatePostmarkMessage(message);
CleanPostmarkMessage(message);
request.Entity = message;
return GetPostmarkResponse(request);
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "from">An email address for a sender</param>
/// <param name = "to">An email address for a recipient</param>
/// <param name = "subject">The message subject line</param>
/// <param name = "textBody">The plain text message body. This may be null, if htmlBody is set.</param>
/// <param name = "htmlBody">The plain HTML message body. This may be null, if textBody is set.</param>
/// <param name = "headers">A collection of additional mail headers to send with the message</param>
/// <param name="callback">The callback invoked when a response is received from the API</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction</returns>
public void SendMessage(string from, string to, string subject, string textBody, string htmlBody, HeaderCollection headers, Action <PostmarkResponse> callback)
{
var message = new PostmarkMessage(from, to, subject, textBody, htmlBody, headers);
SendMessage(message, callback);
}
public void Can_send_message_with_token_and_signature_and_name_based_email()
{
var postmark = new PostmarkClient(_serverToken);
var email = new PostmarkMessage
{
To = _to,
From = string.Format("The Team <{0}>", _from), // This must 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.Success);
Console.WriteLine("Postmark -> " + response.Message);
}
public void SendPostMarkMail(string from, IEnumerable<string> to, string body, string subject, string postMarkToken,
IEnumerable<string> bcc = null, IEnumerable<string> cc = null,
IEnumerable<MailAttachment> attachments = null)
{
var msg = new PostmarkMessage
{
From = from,
To = String.Join(",", to),
Bcc = bcc == null ? "" : String.Join(",", bcc),
Cc = cc == null ? "" : String.Join(",", cc),
Subject = subject,
HtmlBody = body,
TextBody = body,
Tag = subject
};
if (attachments != null)
{
if (attachments.Count() > 0)
{
foreach (MailAttachment mailAttachment in attachments)
{
msg.AddAttachment(mailAttachment.ByteArray, mailAttachment.ContentType.MediaType, mailAttachment.Name);
}
}
}
var client = new PostmarkClient(postMarkToken);
IAsyncResult result = client.BeginSendMessage(msg);
if (result.AsyncWaitHandle.WaitOne())
{
PostmarkResponse response = client.EndSendMessage(result);
}
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "from">An email address for a sender</param>
/// <param name = "to">An email address for a recipient</param>
/// <param name = "subject">The message subject line</param>
/// <param name = "body">The message body</param>
/// <param name = "headers">A collection of additional mail headers to send with the message</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction</returns>
public IAsyncResult BeginSendMessage(string from, string to, string subject, string body, NameValueCollection headers)
{
var message = new PostmarkMessage(from, to, subject, body, headers);
return(BeginSendMessage(message));
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "from">An email address for a sender</param>
/// <param name = "to">An email address for a recipient</param>
/// <param name = "subject">The message subject line</param>
/// <param name = "body">The message body</param>
/// <param name = "headers">A collection of additional mail headers to send with the message</param>
/// <param name="callback">The callback invoked when a response is received from the API</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction</returns>
public void SendMessage(string from, string to, string subject, string body, NameValueCollection headers, Action <PostmarkResponse> callback)
{
var message = new PostmarkMessage(from, to, subject, body, headers);
SendMessage(message, callback);
}
private static void CleanPostmarkMessage(PostmarkMessage message)
{
message.From = message.From.Trim();
if(!string.IsNullOrEmpty(message.To))
{
message.To = message.To.Trim();
}
message.Subject = message.Subject != null ? message.Subject.Trim() : "";
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name="from">An email address for a sender.</param>
/// <param name="to">An email address for a recipient.</param>
/// <param name="subject">The message subject line.</param>
/// <param name="body">The message body.</param>
/// <param name="headers">A collection of additional mail headers to send with the message.</param>
/// <returns>A <see cref="PostmarkResponse"/> with details about the transaction.</returns>
public PostmarkResponse SendMessage(string from, string to, string subject, string body, NameValueCollection headers)
{
var message = new PostmarkMessage(from, to, subject, body, headers);
return SendMessage(message);
}
public void Can_send_message_with_zipfile_attachment()
{
var postmark = new PostmarkClient(_serverToken);
var email = new PostmarkMessage
{
To = _to,
From = _from, // This must be a verified sender signature
Subject = Subject,
TextBody = TextBody,
HtmlBody = HtmlBody
};
email.AddAttachment("zipfile.zip", "application/zip");
var response = postmark.SendMessage(email);
Assert.IsNotNull(response);
Assert.IsNotNullOrEmpty(response.Message);
Assert.IsTrue(response.Status == PostmarkStatus.Success);
Console.WriteLine("Postmark -> {0}", response.Message);
}
public void Can_send_message_with_token_and_signature_and_headers()
{
var postmark = new PostmarkClient(_serverToken);
var email = new PostmarkMessage
{
To = _to,
From = _from, // This must be a verified sender signature
Subject = _subject,
TextBody = _textBody,
};
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 -> " + response.Message);
}
/// <summary>
/// Initializes a new instance of the <see cref = "PostmarkMessage" /> class
/// based on an existing <see cref = "MailMessage" /> instance.
///
/// Only the first recipient of the message is added to the <see cref = "PostmarkMessage" />
/// instance.
/// </summary>
/// <param name = "message">The existing message.</param>
private static PostmarkMessage ConvertSystemMailMessage(MailMessage message)
{
var pm = new PostmarkMessage();
if (message.From != null)
{
pm.From = !string.IsNullOrEmpty(message.From.DisplayName)
? string.Format("{0} <{1}>", message.From.DisplayName, message.From.Address)
: message.From.Address;
}
GetMailMessageRecipients(pm, message);
pm.Subject = message.Subject;
pm.HtmlBody = message.IsBodyHtml ? message.Body : null;
pm.TextBody = message.IsBodyHtml ? null : message.Body;
GetHtmlBodyFromAlternateViews(pm, message);
//Disabling "ReplyTo" obsolecense warning, as we need to continue to map this for users of the API that cannot upgrade."
#pragma warning disable 0618
if (message.ReplyTo != null)
{
pm.ReplyTo = !string.IsNullOrEmpty(message.ReplyTo.DisplayName)
? string.Format("{0} <{1}>", message.ReplyTo.DisplayName, message.ReplyTo.Address)
: message.ReplyTo.Address;
}
#pragma warning restore 0618
var header = message.Headers.Get("X-PostmarkTag");
if (header != null)
{
pm.Tag = header;
}
pm.Headers = new HeaderCollection();
if (message.Headers != null)
{
foreach (var h in message.Headers.AllKeys)
{
pm.Headers.Add(h, message.Headers[h]);
}
}
pm.Attachments = new List <PostmarkMessageAttachment>(0);
foreach (var item in from attachment in message.Attachments
where attachment.ContentStream != null
let content = ReadStream(attachment.ContentStream, 8192)
select new PostmarkMessageAttachment
{
Name = attachment.Name,
ContentType = attachment.ContentType.ToString(),
Content = Convert.ToBase64String(content)
})
{
pm.Attachments.Add(item);
}
return(pm);
}
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);
}
private static void GetMailMessageRecipients(PostmarkMessage m, MailMessage message)
{
GetMailMessageTo(m, message);
GetMailMessageCc(m, message);
GetMailMessageBcc(m, message);
}
private static bool IsBodyHtml(PostmarkMessage message)
{
return !string.IsNullOrEmpty(message.HtmlBody);
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name = "from">An email address for a sender</param>
/// <param name = "to">An email address for a recipient</param>
/// <param name = "subject">The message subject line</param>
/// <param name = "textBody">The plain text message body. This may be null, if htmlBody is set.</param>
/// <param name = "htmlBody">The plain HTML message body. This may be null, if textBody is set.</param>
/// <param name = "headers">A collection of additional mail headers to send with the message</param>
/// <returns>A <see cref = "PostmarkResponse" /> with details about the transaction</returns>
public IAsyncResult BeginSendMessage(string from, string to, string subject, string textBody, string htmlBody, HeaderCollection headers)
{
var message = new PostmarkMessage(from, to, subject, textBody, htmlBody, headers);
return(BeginSendMessage(message));
}
private static void ValidatePostmarkMessage(PostmarkMessage message)
{
var specification = new ValidEmailSpecification();
if (string.IsNullOrEmpty(message.From) || !specification.IsSatisfiedBy(message.From))
{
throw new ValidationException("You must specify a valid 'From' email address.");
}
if (string.IsNullOrEmpty(message.To))
{
throw new ValidationException("You must specify a valid 'To' email address.");
}
var recipients = message.To.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var recipient in recipients.Where(email => !specification.IsSatisfiedBy(email)))
{
throw new ValidationException(
string.Format("The provided recipient address '{0}' is not valid", recipient)
);
}
if (!string.IsNullOrEmpty(message.ReplyTo) && !specification.IsSatisfiedBy(message.ReplyTo))
{
throw new ValidationException("If a 'ReplyTo' email address is included, it must be valid.");
}
if(!string.IsNullOrEmpty(message.Cc))
{
var ccs = message.Cc.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var cc in ccs.Where(email => !specification.IsSatisfiedBy(email)))
{
throw new ValidationException(
string.Format("The provided CC address '{0}' is not valid", cc)
);
}
}
if (!string.IsNullOrEmpty(message.Bcc))
{
var bccs = message.Bcc.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var bcc in bccs.Where(email => !specification.IsSatisfiedBy(email)))
{
throw new ValidationException(
string.Format("The provided BCC address '{0}' is not valid", bcc)
);
}
}
}
private static void CleanPostmarkMessage(PostmarkMessage message)
{
message.From = message.From.Trim();
message.To = message.To.Trim();
message.Subject = message.Subject != null ? message.Subject.Trim() : "";
}
/// <summary>
/// Sends a message through the Postmark API.
/// All email addresses must be valid, and the sender must be
/// a valid sender signature according to Postmark. To obtain a valid
/// sender signature, log in to Postmark and navigate to:
/// http://postmarkapp.com/signatures.
/// </summary>
/// <param name="message">A prepared message.</param>
/// <returns></returns>
public async Task <PostmarkResponse> SendMessageAsync(PostmarkMessage message)
{
return(await ProcessRequestAsync <PostmarkMessage, PostmarkResponse>("/email", HttpMethod.Post, message));
}
public void SendByApi()
{
PostmarkMessage message = new PostmarkMessage()
{
From = this.From
, To = this.To
, Cc = this.Cc
, Bcc = this.Bcc
,Subject = this.Subject
, ReplyTo = this.ReplyTo
};
if (this.IsBodyHtml)
message.HtmlBody = this.Body;
else
message.TextBody = this.Body;
if (this.Attachments != null && this.Attachments.Count > 0)
{
foreach (var attachment in this.Attachments)
{
var bytes = new Byte[attachment.ContentStream.Length];
attachment.ContentStream.Read(bytes, 0, bytes.Length);
message.AddAttachment(bytes, attachment.ContentType.ToString(), attachment.Name);
}
}
//Created just to get user name which will be used as ApiKey
SmtpClient sc = new SmtpClient();
PostmarkClient client = new PostmarkClient((sc.Credentials as NetworkCredential).UserName);
var response = client.SendMessage(message);
if (response.Status != PostmarkStatus.Success)
{
throw new System.Net.Mail.SmtpException(response.Message);
}
}
