public EmailNotificationResponse Send(EmailNotificationRequest request)
{
var message = _postmarkMessageFactory.Create(request);
var response = AsyncHelper.RunSync(() => _postmarkClient.SendMessageAsync(message));
return(new EmailNotificationResponse
{
IsSent = response.Status == PostmarkStatus.Success,
Message = response.ErrorCode.ToString(CultureInfo.InvariantCulture)
});
}
public async Task SendNotifyEnquireRemedy(ProductBaseDto T, string email)
{
var message = new TemplatedPostmarkMessage
{
To = email,
From = "*****@*****.**",
TemplateId = 15937570,
TemplateModel = new Dictionary <string, object>
{
{ "username", email },
{ "remedyname", T.Name },
{ "brand", dc.Brand.Where(o => o.BrandId == T.BrandId).First().Name },
{ "registration", T.Registration },
{ "formulation", T.Formulation },
{ "concentration", T.Concentration },
{ "active", dc.ProductActiveIngredient.Include(o => o.ActiveIngredient).Where(o => o.ProductBaseId == T.ProductBaseId).First().ActiveIngredient.Name },
{ "enquiredURL", "http://farmboek.dankospark.co.za/details/brand/" + T.BrandId }
}
};
var client = new PostmarkClient("20222232-ba77-4976-b1c5-921816baa7e2");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
public async Task EmailToProviderAsync(EnquiryDto T, Vacation stock, Resort resort, Supplier supplier, UnitSizes unitSize)
{
var message = new TemplatedPostmarkMessage
{
To = supplier.Email,
From = EmailFrom,
TemplateId = 13249489,
TemplateModel = new Dictionary <string, object>
{
{ "provider", supplier.Description },
{ "resort", resort.Description },
{ "arrival", stock.Arrival.Date.ToString("dd/MM/yyyy") },
{ "nights", stock.Nights },
{ "unitSize", unitSize.Description },
{ "product_name", "Holiday Booker" },
{ "company_name", "Holiday Booker" }
}
};
var client = new PostmarkClient("ba4b7707-54c8-49d7-83d5-e215483fe37c");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
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);
}
}
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));
}
}
public void SendCancellationReciept(string name, string email, string endDate, string departmentName)
{
var message = new TemplatedPostmarkMessage
{
From = FROM_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkCancelRecieptTemplateId,
TemplateModel = new Dictionary <string, object> {
{ "action_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/User/Subscription" },
{ "subscriptions_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/User/Subscription" },
{ "feedback_url", LIVECHAT_URL },
{ "help_url", HELP_URL },
{ "trial_extension_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/User/Subscription" },
{ "export_url", "" },
{ "plans_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/Home/Pricing" },
{ "close_account_url", HELP_URL },
},
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
var response = client.SendMessageAsync(message).Result;
if (response.Status != PostmarkStatus.Success)
{
//Console.WriteLine("Response was: " + response.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));
}
}
/*==========================================================================================================================
| 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 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 Task notify(ArbitrageData T, string pEmail)
{
try
{
var message = new TemplatedPostmarkMessage
{
From = "*****@*****.**",
To = pEmail,
TemplateAlias = "bitcoinArbitrage",
TemplateModel = new Dictionary <string, object> {
{ "percent", Convert.ToString(T.PercentageProfitBeforeCost * 100) },
{ "date", Convert.ToString(T.DateCaptured) },
{ "krakenprice", Convert.ToString(T.KrakenXBTEUR) },
{ "lunoprice", Convert.ToString(T.LunoXBTZAR) },
{ "eurotozar", Convert.ToString(T.EURZAR) }
},
};
var client = new PostmarkClient("ba0d1e9f-0b0b-442f-a350-9504a5015caf");
var response = await client.SendMessageAsync(message);
if (response.Status != PostmarkStatus.Success)
{
Console.WriteLine("Response was: " + response.Message);
}
}
catch (Exception e)
{
Console.WriteLine("Email fail: " + e.Message);
}
}
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 */ } {
public async Task SendCouldNotFindUser(string username)
{
var message = new TemplatedPostmarkMessage
{
To = username,
From = "*****@*****.**",
TemplateId = 15914912,
TemplateModel = new Dictionary <string, object>
{
{ "username", username }
}
};
var client = new PostmarkClient("20222232-ba77-4976-b1c5-921816baa7e2");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
public async Task SendResetPasswordEmail(string username, string resetToken)
{
var message = new TemplatedPostmarkMessage
{
To = username,
From = "*****@*****.**",
TemplateId = 15914723,
TemplateModel = new Dictionary <string, object>
{
{ "username", username },
// { "action_url", "http://farmboek.dankospark.co.za/resetpassword/"+ username + "/" + resetToken}
{ "action_url", "http://localhost:4200/resetpassword/" + username + "/" + resetToken.Replace('/', '_') }
}
};
var client = new PostmarkClient("20222232-ba77-4976-b1c5-921816baa7e2");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
public async Task SendNotifyAdmin(string type, string productorremedy, string name, string lastname, string idnumber, string cell, string email, string brand, string action_url)
{
var message = new TemplatedPostmarkMessage
{
To = "*****@*****.**",
From = "*****@*****.**",
TemplateId = 16196502,
TemplateModel = new Dictionary <string, object>
{
{ "name", name },
{ "lastname", lastname },
{ "type", type },
{ "productorremedy", productorremedy },
{ "idnumber", idnumber },
{ "brand", brand },
{ "cell", cell },
{ "email", email },
{ "action_url", action_url }
}
};
var client = new PostmarkClient("20222232-ba77-4976-b1c5-921816baa7e2");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
public async Task SendNotifyEnquireProblemAndService(string email, string brand, string entry, int id)
{
var message = new TemplatedPostmarkMessage
{
To = email,
From = "*****@*****.**",
TemplateId = 15925178,
TemplateModel = new Dictionary <string, object>
{
{ "name", email },
{ "entryName", entry },
{ "brandName", brand },
{ "enquiredURL", "http://farmboek.dankospark.co.za/details/brand/" + id }
}
};
var client = new PostmarkClient("20222232-ba77-4976-b1c5-921816baa7e2");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
//New Invoice Generated
public async Task NewInvoiceGenerated(string invoiceNum, int stockId)
{
var message = new TemplatedPostmarkMessage
{
To = "*****@*****.**",
From = EmailFrom,
TemplateAlias = "newInvoice",
TemplateModel = new Dictionary <string, object>
{
{ "invoiceNum", invoiceNum },
{ "stockId", stockId },
}
};
var client = new PostmarkClient("ba4b7707-54c8-49d7-83d5-e215483fe37c");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
public async Task SendNewEmailAsync(string email)
{
var message = new TemplatedPostmarkMessage
{
To = EmailFrom,
From = EmailFrom,
TemplateAlias = "newEmail",
TemplateModel = new Dictionary <string, object>
{
{ "email", email }
}
};
var client = new PostmarkClient("ba4b7707-54c8-49d7-83d5-e215483fe37c");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
public async Task EmailToClientAsync(EnquiryDto T, Vacation stock, Resort resort, Supplier supplier, UnitSizes unitSize)
{
var message = new TemplatedPostmarkMessage
{
To = T.Email,
From = EmailFrom,
TemplateId = 20752183,
TemplateModel = new Dictionary <string, object>
{
{ "name", T.Name },
{ "resort", resort.Description },
{ "date", stock.Arrival.Date.ToString("dd/MM/yyyy") },
{ "nights", stock.Nights },
{ "unitsize", unitSize.Description },
{ "priceToPay", stock.Price2Pay },
{ "link", resort.Link },
{ "adults", T.Adults },
{ "kids", T.Under12 },
{ "note", T.Note }
}
};
var client = new PostmarkClient("ba4b7707-54c8-49d7-83d5-e215483fe37c");
var sendResult = await client.SendMessageAsync(message);
if (sendResult.Status == PostmarkStatus.Success)
{
Console.WriteLine(sendResult.Status);
}
else
{
Console.WriteLine(sendResult.Status);
}
}
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 async Task <bool> SendMessageMail(string email, string subject, string messageSubject, string messageBody, string senderEmail, string senderName, string sentOn, int messageId)
{
var templateModel = new Dictionary <string, object> {
{ "sender_name", senderName },
{ "title", subject },
{ "body", HtmlToTextHelper.ConvertHtml(messageBody) },
//{ "attachment_details", new []{
//new Dictionary<string,object> {
// { "attachmnet_url", "attachmnet_url_Value" },
// { "attachment_name", "attachment_name_Value" },
// { "attachment_size", "attachment_size_Value" },
// { "attachment_type", "attachment_type_Value" },
//}
//}
//},
{ "action_url", $"https://resgrid.com/User/Messages/ViewMessage?messageId={messageId}" },
{ "timestamp", sentOn },
{ "commenter_name", senderName }
};
if (SystemBehaviorConfig.OutboundEmailType == OutboundEmailTypes.Postmark)
{
var message = new TemplatedPostmarkMessage
{
From = DONOTREPLY_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkMessageTemplateId,
TemplateModel = templateModel,
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
try
{
PostmarkResponse response = await client.SendMessageAsync(message);
if (response.Status != PostmarkStatus.Success)
{
return(false);
}
return(true);
}
catch (Exception) { }
}
else
{
var template = Mustachio.Parser.Parse(GetTempate("Message.html"));
var content = template(templateModel);
Email newEmail = new Email();
newEmail.HtmlBody = content;
newEmail.Sender = FROM_EMAIL;
newEmail.To.Add(email);
return(await _emailSender.Send(newEmail));
}
return(false);
}
public void SendInviteMail(string code, string departmentName, string email, string senderName, string senderEmail)
{
// Example request
var message = new TemplatedPostmarkMessage
{
From = FROM_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkInviteTemplateId,
TemplateModel = new Dictionary <string, object> {
{ "invite_sender_name", senderName },
{ "department_name", departmentName },
{ "action_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/Account/CompleteInvite?inviteCode={code}" },
{ "support_email", FROM_EMAIL },
{ "live_chat_url", LIVECHAT_URL },
{ "help_url", HELP_URL },
{ "sender_email", senderEmail },
{ "invite_sender_organization_name", departmentName },
},
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
try
{
PostmarkResponse response = client.SendMessageAsync(message).Result;
if (response.Status != PostmarkStatus.Success)
{
//Console.WriteLine("Response was: " + response.Message);
}
}
catch (Exception) { }
}
public void SendNewDepartmentLinkMail(string name, string departmentName, string data, string email, int departmentId)
{
// Example request
var message = new TemplatedPostmarkMessage
{
From = FROM_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkNewDepLinkTemplateId,
TemplateModel = new Dictionary <string, object> {
{ "name", name },
{ "action_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}" },
{ "login_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/Account/LogOn" },
{ "department_name", departmentName },
{ "data", data },
{ "support_email", FROM_EMAIL },
{ "live_chat_url", LIVECHAT_URL },
{ "help_url", HELP_URL },
},
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
try
{
PostmarkResponse response = client.SendMessageAsync(message).Result;
if (response.Status != PostmarkStatus.Success)
{
//Console.WriteLine("Response was: " + response.Message);
}
}
catch (Exception) { }
}
public void SendChargeFailed(string name, string email, string endDate, string departmentName, string planName)
{
// Example request
var message = new TemplatedPostmarkMessage
{
From = FROM_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkChargeFailedTemplateId,
TemplateModel = new Dictionary <string, object> {
{ "plan_name", planName },
{ "action_url", UPDATEBILLINGINFO_URL },
{ "subscriptions_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/User/Subscription" },
{ "feedback_url", LIVECHAT_URL },
{ "help_url", HELP_URL },
{ "trial_extension_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/User/Subscription" },
{ "export_url", "" },
{ "close_account_url", HELP_URL },
},
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
try
{
PostmarkResponse response = client.SendMessageAsync(message).Result;
if (response.Status != PostmarkStatus.Success)
{
//Console.WriteLine("Response was: " + response.Message);
}
}
catch (Exception) { }
}
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");
}
}
public void Any(DailyPostViewRequest req)
{
// we need a way to get all posts but for now let's just get the top 15
var result = base.Gateway.Send(new PostQueryRequest()
{
Skip = 0, Take = 15
});
var posts = result.Results;
using (var db = _dbConnectionFactory.Open())
{
var q = db.From <PostLog>()
.Where(x => x.RequestType == typeof(PostRequest).ToString() &&
x.EntryDate >= req.Date &&
x.EntryDate < req.Date.AddDays(1))
.GroupBy(x => x.Identifier)
.Select(x => new { x.Identifier, Total = Sql.Count("*") });
var results = db.Dictionary <string, int>(q);
foreach (var p in posts)
{
p.ViewsToday = results.ContainsKey(p.Id) ? results[p.Id] : 0;
}
;
}
var client = new PostmarkClient(_appSettings.Get <string>("PostmarkApi:ServerToken"));
try
{
ScriptContext sc = new ScriptContext().Init();
var template = sc.RenderScript(@"
<table>
<tr><th>Title</th><th>Today's Views</th></tr>
{{#each post in posts}}
<tr>
<td>{{post.title}}</td><td>{{post.ViewsToday}}</td>
</tr>
{{/each}}
</table>
", new Dictionary <string, object>()
{
{ "posts", posts }
});
var sendResult = client.SendMessageAsync(new PostmarkMessage()
{
From = _appSettings.Get <string>("PostmarkApi:FromEmail"),
To = _appSettings.Get <string>("PostmarkApi:ToEmail"),
Subject = $"Daily Blog Post Report - {req.Date.ToString("yyyy-MM-dd")}",
HtmlBody = template
}).Result;
if (sendResult.Status == PostmarkStatus.Success) /* Handle success */ } {
public async void 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, "Plain text body", "<b>This is only a test!</b>");
// This should successfully send.
Assert.Equal(0, response.ErrorCode);
Assert.Equal("OK", response.Message);
}
public async Task <bool> SendWelcomeMail(string name, string departmentName, string userName, string password, string email, int departmentId)
{
var templateModel = new Dictionary <string, object> {
{ "name", name },
{ "action_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}" },
{ "login_url", $"{Config.SystemBehaviorConfig.ResgridBaseUrl}/Account/LogOn" },
{ "department_id", departmentId },
{ "department_name", departmentName },
{ "username", userName },
{ "password", password },
{ "support_email", FROM_EMAIL },
{ "live_chat_url", LIVECHAT_URL },
{ "help_url", HELP_URL },
};
if (SystemBehaviorConfig.OutboundEmailType == OutboundEmailTypes.Postmark)
{
var message = new TemplatedPostmarkMessage
{
From = FROM_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkWelcomeTemplateId,
TemplateModel = templateModel,
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
try
{
PostmarkResponse response = await client.SendMessageAsync(message);
if (response.Status != PostmarkStatus.Success)
{
return(false);
}
return(true);
}
catch (Exception) { }
}
else
{
var template = Mustachio.Parser.Parse(GetTempate("Welcome.html"));
var content = template(templateModel);
Email newEmail = new Email();
newEmail.HtmlBody = content;
newEmail.Sender = FROM_EMAIL;
newEmail.To.Add(email);
return(await _emailSender.Send(newEmail));
}
return(false);
}
public async Task <bool> SendPasswordResetMail(string name, string password, string userName, string email, string departmentName)
{
var templateModel = new Dictionary <string, object> {
{ "name", name },
{ "department_Name", departmentName },
{ "login_url", LOGIN_URL },
{ "username", userName },
{ "password", password },
{ "support_url", LIVECHAT_URL },
{ "action_url", LOGIN_URL },
{ "operating_system", "" },
{ "browser_name", "" },
};
if (SystemBehaviorConfig.OutboundEmailType == OutboundEmailTypes.Postmark)
{
var message = new TemplatedPostmarkMessage
{
From = FROM_EMAIL,
To = email,
TemplateId = Config.OutboundEmailServerConfig.PostmarkResetPasswordTemplateId,
TemplateModel = templateModel,
};
var client = new PostmarkClient(Config.OutboundEmailServerConfig.PostmarkApiKey);
try
{
PostmarkResponse response = await client.SendMessageAsync(message);
if (response.Status != PostmarkStatus.Success)
{
return(false);
}
return(true);
}
catch (Exception) { }
}
else
{
var template = Mustachio.Parser.Parse(GetTempate("PasswordReset.html"));
var content = template(templateModel);
Email newEmail = new Email();
newEmail.HtmlBody = content;
newEmail.Sender = FROM_EMAIL;
newEmail.To.Add(email);
return(await _emailSender.Send(newEmail));
}
return(false);
}
public static PostmarkResponse SendMessage(this PostmarkClient client, string from,
string to, string subject, string body, NameValueCollection headers)
{
var headerDictionary = new Dictionary <string, string>();
foreach (var h in headers.AllKeys)
{
headerDictionary[h] = headers[h];
}
return(client.SendMessageAsync(to, from, subject, body, headerDictionary).WaitForResult());
}
/// <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);
}
