public OutboundMessagePostmarkResponse SendPostmarkMessage(OutboundMessageRequest messageRequest)
{
if (messageRequest == null)
{
throw new ArgumentNullException(nameof(messageRequest));
}
var postmarkMessage = Mapper.Map <OutboundMessageRequest, PostmarkMessage>(messageRequest);
var postmarkClient = new PostmarkDotNet.PostmarkClient(_serverToken);
var postmarkResponse = new PostmarkResponse();
var task = Task.Run(async() =>
{
postmarkResponse = await postmarkClient.SendMessageAsync(postmarkMessage);
});
try
{
task.Wait();
}
catch (AggregateException ae)
{
var innerException = ae.InnerExceptions.FirstOrDefault();
throw new CommunicationException("External service exception occured on SendPostmarkMessage.",
innerException);
}
return(Mapper.Map <PostmarkResponse, OutboundMessagePostmarkResponse>(postmarkResponse));
}
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 async Task ClientCanRetrieveServerInformation()
{
var client = new PostmarkClient(WRITE_TEST_SERVER_TOKEN);
var server = await client.GetServerAsync();
Assert.NotNull(server);
Assert.Contains(WRITE_TEST_SERVER_TOKEN, server.ApiTokens);
}
public async Task ClientCanSendMessage()
{
var client = new PostmarkClient(WRITE_TEST_SERVER_TOKEN);
var response = await client
.SendMessageAsync(WRITE_TEST_SENDER_EMAIL_ADDRESS, WRITE_TEST_EMAIL_RECIPIENT_ADDRESS,
"Testing the postmark client: " + DateTime.Now, "<b>This is only a test!</b>");
// This should successfully send.
Assert.AreEqual(0, response.ErrorCode);
Assert.AreEqual("OK", response.Message);
}
public async Task ClientCanUpdateServerName()
{
var client = new PostmarkClient(WRITE_TEST_SERVER_TOKEN);
var serverName = "test-server " + DateTime.Now.ToString("o");
var nonModifiedServer = await client.GetServerAsync();
var updatedServer = await client.EditServerAsync(name: serverName);
var modifiedServer = await client.GetServerAsync();
Assert.AreNotEqual(nonModifiedServer.Name, updatedServer.Name, "Updated server name should be different than current name");
Assert.AreEqual(serverName, updatedServer.Name, "Updated server name returned from EditServer should be the same as the value passed in.");
Assert.AreEqual(serverName, modifiedServer.Name, "Updated server name returned from subsequent call to GetServer should show new name.");
}
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 async Task SetupAsync()
{
_client = new PostmarkClient(WRITE_TEST_SERVER_TOKEN);
var id = Guid.NewGuid().ToString("n");
_serverPrefix = "integration-test-server-";
_name = _serverPrefix + id;
_color = ServerColors.Purple;
_inboundHookUrl = "http://www.example.com/inbound/" + id;
_bounceHookUrl = "http://www.example.com/bounce/" + id;
_openHookUrl = "http://www.example.com/opened/" + id;
//_inboundDomain = "inbound-" + id + ".exmaple.com";
await CompletionSource;
}
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 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;
}
/// <summary>
/// Sends a batch of up to messages 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="messages">A prepared message batch.</param>
/// <returns></returns>
public static async Task <IEnumerable <PostmarkResponse> > SendMessagesAsync(this PostmarkClient client, IEnumerable <PostmarkMessage> messages)
{
return(await client.SendMessagesAsync(messages.ToArray()));
}
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_get_inbound_message_detail_from_api()
{
var postmark = new PostmarkClient(_serverToken);
var inboundmessages = postmark.GetInboundMessages(10, 1);
var inboundMessage =
postmark.GetInboundMessageDetail(inboundmessages.InboundMessages.FirstOrDefault().MessageID);
Assert.IsNotNull(inboundMessage);
}
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);
}
}
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);
}
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 Can_get_outbound_message_details_and_dump_by_messages_id()
{
var postmark = new PostmarkClient(_serverToken);
var messages = postmark.GetOutboundMessages(1, 0);
var messagedetails = postmark.GetOutboundMessageDetail(messages.Messages.FirstOrDefault().MessageID);
var messagedump = postmark.GetOutboundMessageDump(messages.Messages.FirstOrDefault().MessageID);
Assert.IsNotNull(messagedetails.Body);
Assert.IsNotNull(messagedump.Body);
}
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_get_bounce_tags()
{
var postmark = new PostmarkClient(_serverToken);
var stats = postmark.GetBounceTags();
Assert.IsNotNull(stats);
}
protected override async Task SetupAsync()
{
_client = new PostmarkDotNet.PostmarkClient(READ_SELENIUM_TEST_SERVER_TOKEN);
await CompletionSource;
}
public void Can_get_inbound_messages_from_messages_api()
{
var postmark = new PostmarkClient(_serverToken);
var inboundmessages = postmark.GetInboundMessages(10, 0);
Assert.AreEqual(1, inboundmessages.InboundMessages.Count);
}
public void Can_send_message_with_tracking_enabled()
{
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,
TrackOpens = true
};
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_retrieve_outbound_messages_from_messages_api()
{
var postmark = new PostmarkClient(_serverToken);
var messages = postmark.GetOutboundMessages(3, 0);
Assert.AreEqual(3, messages.Messages.Count);
}
public void Can_get_bounces()
{
var postmark = new PostmarkClient(_serverToken);
var stats = postmark.GetBounces(PostmarkBounceType.HardBounce, 1, 10);
Assert.IsNotNull(stats);
}
public void Can_send_message_with_file_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,
};
email.AddAttachment("logo.png", "image/png");
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_get_delivery_stats()
{
var postmark = new PostmarkClient(_serverToken);
var stats = postmark.GetDeliveryStats();
Assert.IsNotNull(stats);
}
/// <summary>
/// Send a System.Net.MailMessage (transparently converts to the PostmarkMessage).
/// </summary>
/// <param name="client"></param>
/// <param name="message"></param>
/// <returns></returns>
public static async Task <PostmarkResponse> SendMessageAsync
(this PostmarkClient client, MailMessage message)
{
return(await client.SendMessageAsync(ConvertSystemMailMessage(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>
/// Send a System.Net.MailMessage(s) (transparently converts to the PostmarkMessages).
/// </summary>
/// <param name="client"></param>
/// <param name="messages"></param>
/// <returns></returns>
public static async Task <IEnumerable <PostmarkResponse> > SendMessagesAsync
(this PostmarkClient client, params MailMessage[] messages)
{
return(await client.SendMessagesAsync(messages.Select(ConvertSystemMailMessage)));
}
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);
}
/// <summary>
/// Sends an email
/// </summary>
/// <param name="emailAccount">Email account to use</param>
/// <param name="subject">Subject</param>
/// <param name="body">Body</param>
/// <param name="from">From address</param>
/// <param name="to">To address</param>
/// <param name="bcc">BCC addresses list</param>
/// <param name="cc">CC addresses ist</param>
/// <summary>
/// Sends an email
/// </summary>
/// <param name="emailAccount">Email account to use</param>
/// <param name="subject">Subject</param>
/// <param name="body">Body</param>
/// <param name="fromAddress">From address</param>
/// <param name="fromName">From display name</param>
/// <param name="toAddress">To address</param>
/// <param name="toName">To display name</param>
/// <param name="bcc">BCC addresses list</param>
/// <param name="cc">CC addresses ist</param>
///
public void SendEmail(string email, string message)
{
try
{
PostmarkMessage msg = new PostmarkMessage
{
Tag = "Application Successful",
From = _EmailAccount.UserName,
To = email,
Subject = _EmailAccount.EmailName,
HtmlBody = message
};
PostmarkClient client = new PostmarkClient(_EmailAccount.ServerToken);
IAsyncResult result = client.BeginSendMessage(msg);
if (result.AsyncWaitHandle.WaitOne())
{
PostmarkResponse response = client.EndSendMessage(result);
//return true;
}
}
catch (Exception ex)
{
throw new System.ArgumentException(ex.Message);
}
}
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);
}
protected override async Task SetupAsync()
{
_client = new PostmarkDotNet.PostmarkClient(READ_SELENIUM_TEST_SERVER_TOKEN);
await CompletionSource;
}
protected override async Task SetupAsync()
{
_client = new PostmarkClient(WRITE_TEST_SERVER_TOKEN);
await CompletionSource;
}
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);
}
}
