public async Task SendEmailAsync(string email, string subject, string htmlMessage)
{
MailjetClient client =
new MailjetClient(_mailJetSettings.PublicKey, _mailJetSettings.PrivateKey);
MailjetRequest request = new MailjetRequest
{
Resource = Send.Resource,
};
// construct your email with builder
var malJetEmail = new TransactionalEmailBuilder()
.WithFrom(new SendContact(_mailJetSettings.Email))
.WithSubject(subject)
.WithHtmlPart(htmlMessage)
.WithTo(new SendContact(email))
.Build();
// invoke API to send malJetEmail
var response = await client.SendTransactionalEmailAsync(malJetEmail);
if (response.Messages.Length == 1)
{
Console.WriteLine("Success");
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var client = new MailjetClient(_mailjetConfiguration.PublicApiKey, _mailjetConfiguration.PrivateApiKey);
var email = new TransactionalEmail
{
From = new SendContact(_emailConfiguration.SenderAddress, _emailConfiguration.SenderName),
Subject = "Health Check",
ReplyTo = new SendContact(_emailConfiguration.ReplyToAddress, _emailConfiguration.SenderName),
CustomCampaign = _mailjetConfiguration.Campaign,
To = new List <SendContact>
{
new SendContact("*****@*****.**")
},
TextPart = "This e-mail is sent from a health check and should never reach anybody."
};
await client.SendTransactionalEmailAsync(email, true);
return(await Task.FromResult(HealthCheckResult.Healthy("Mailjet is healthy.")));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Mailjet Healthcheck failed: {ex.Message}");
return(await Task.FromResult(HealthCheckResult.Unhealthy("Mailjet is not healthy.")));
}
}
public async Task SendMessage(Message <TContent> message)
{
var email = new TransactionalEmailBuilder()
.WithFrom(new SendContact(_senderEmail, _senderName))
.WithSubject(message.Subject)
.WithTextPart(GetTextPart(message.Content))
.WithHtmlPart(GetHtmlPart(message.Content))
.WithCustomId(GetCustomId(message.Content))
.WithTo(new SendContact(message.Contact.Email, message.Contact.Name))
.Build();
var response = await _mailjetClient.SendTransactionalEmailAsync(email);
foreach (var responseMessage in response.Messages)
{
if (responseMessage.Status == "success")
{
_logger.LogInformation("Message sent for: {Email}",
GetEmailList(responseMessage));
}
else
{
_logger.LogInformation("Message fail for : {Email}",
GetEmailList(responseMessage));
}
}
}
public async Task SendTransactionalEmailAsync_ReturnsParsedResponse()
{
// arrange
string jsonResponse = File.ReadAllText(@"MockResponses/SendEmailV31Response.json");
_handler.When("https://api.mailjet.com/v3.1/*")
.Respond("application/json", jsonResponse);
// act
var response = await _client.SendTransactionalEmailAsync(new TransactionalEmail()
{
DeduplicateCampaign = true
});
// assert
Assert.AreEqual(1, response.Messages.Length);
var message = response.Messages[0];
Assert.AreEqual("CustomValue", message.CustomID);
Assert.AreEqual("success", message.Status);
// errors
var error = message.Errors.Single();
Assert.AreEqual("1ab23cd4-e567-8901-2345-6789f0gh1i2j", error.ErrorIdentifier);
Assert.AreEqual("send-0010", error.ErrorCode);
Assert.AreEqual(400, error.StatusCode);
Assert.AreEqual("Template ID \"123456789\" doesn't exist for your account.", error.ErrorMessage);
Assert.AreEqual("TemplateID", error.ErrorRelatedTo.Single());
// to
var to = message.To.Single();
Assert.AreEqual("*****@*****.**", to.Email);
Assert.AreEqual("1ab23cd4-e567-8901-2345-6789f0gh1i2j", to.MessageUUID);
Assert.AreEqual(1234567890987654400, to.MessageID);
Assert.AreEqual("https://api.mailjet.com/v3/message/1234567890987654321", to.MessageHref);
// cc & bcc
Assert.IsNotNull(message.Cc);
Assert.IsNotNull(message.Bcc);
}
public async Task SendTransactionalEmailAsync_SendsEmail()
{
// arrange
var email = new TransactionalEmailBuilder()
.WithFrom(new SendContact(_senderEmail))
.WithSubject("Test subject")
.WithHtmlPart("<h1>Header</h1>")
.WithTo(new SendContact(_senderEmail))
.Build();
// act
var response = await _client.SendTransactionalEmailAsync(email);
// assert
Assert.AreEqual(1, response.Messages.Length);
var message = response.Messages[0];
Assert.AreEqual("success", message.Status);
Assert.AreEqual(_senderEmail, message.To.Single().Email);
}
public async Task SendAsync(EmailMessage message,
CancellationToken ct = default)
{
var email = new TransactionalEmailBuilder()
.WithFrom(new SendContact(
message.FromEmail,
message.FromName))
.WithTo(new SendContact(
message.ToEmail,
message.ToName))
.WithSubject(message.Subject)
.WithHtmlPart(message.BodyHtml)
.WithTextPart(message.BodyText)
.Build();
var responses = await mailjetClient.SendTransactionalEmailAsync(email);
if (responses.Messages is not {
Length : 1
})
public async Task Send(string recipientAddress, string subject, string htmlBody, string textBody, params IEmailAttachment[] attachments)
{
if (string.IsNullOrWhiteSpace(recipientAddress))
{
throw new ArgumentOutOfRangeException(nameof(recipientAddress));
}
var client = new MailjetClient(_mailjetConfig.PublicApiKey, _mailjetConfig.PrivateApiKey);
var email = new TransactionalEmail
{
From = new SendContact(_emailConfig.SenderAddress, _emailConfig.SenderName),
Subject = subject,
ReplyTo = new SendContact(_emailConfig.ReplyToAddress, _emailConfig.SenderName),
CustomCampaign = _mailjetConfig.Campaign,
To = new List <SendContact>
{
new SendContact(recipientAddress)
},
TextPart = textBody,
HTMLPart = htmlBody,
Attachments = new List <Attachment>(),
};
foreach (var attachment in attachments)
{
new FileExtensionContentTypeProvider().TryGetContentType(attachment.Filename, out var contentType);
email.Attachments.Add(new Attachment(attachment.Filename, contentType ?? "application/octet-stream", Convert.ToBase64String(attachment.Bytes)));
}
try
{
await client.SendTransactionalEmailAsync(email);
}
catch (Exception ex)
{
throw new Exception($"Sending email via MailJet failed.{Environment.NewLine}: {ex.Message}", ex);
}
}
public static async Task SendEmail(string emailAddress, string url)
{
MailjetClient client = new MailjetClient(
Environment.GetEnvironmentVariable("$MJ_APIKEY_PUBLIC", EnvironmentVariableTarget.Machine),
Environment.GetEnvironmentVariable("$MJ_APIKEY_PRIVATE", EnvironmentVariableTarget.Machine));
MailjetRequest request = new MailjetRequest
{
Resource = Send.Resource,
};
// construct your email with builder
var email = new TransactionalEmailBuilder()
.WithFrom(new SendContact("*****@*****.**"))
.WithSubject("YouTube Wrapped data ready to view")
.WithHtmlPart("<p>Hey there!</p> <p>We are pleased to inform you that your data is ready to view at: <br/>" + url + "</p>")
.WithTo(new SendContact(emailAddress))
.Build();
// invoke API to send email
var response = await client.SendTransactionalEmailAsync(email);
}
public async Task SendEmailWithTemplate(long templateId)
{
// arrange
var testArrayWithValues = new []
{
new { title = "testTitle1" },
new { title = "testTitle2" },
};
var variables = new Dictionary <string, object>
{
{ "testVariableName", "testVariableValue" },
{ "items", testArrayWithValues }
};
var email = new TransactionalEmailBuilder()
.WithTo(new SendContact(_senderEmail))
.WithFrom(new SendContact(_senderEmail))
.WithSubject("Test subject " + DateTime.UtcNow)
.WithTemplateId(templateId)
.WithVariables(variables)
.WithTemplateLanguage(true)
.WithTemplateErrorDeliver(true)
.WithTemplateErrorReporting(new SendContact(_senderEmail))
.Build();
// act
var response = await _client.SendTransactionalEmailAsync(email);
// assert
Assert.AreEqual(1, response.Messages.Length);
var message = response.Messages[0];
Assert.AreEqual("success", message.Status);
Assert.AreEqual(_senderEmail, message.To.Single().Email);
}
public async Task <bool> SendToken(MailRequest mailRequest)
{
try
{
MailjetClient client = new MailjetClient(
_mailSettings.MJ_APIKEY_PUBLIC,
_mailSettings.MJ_APIKEY_PRIVATE);
MailjetRequest request = new MailjetRequest
{
Resource = Send.Resource,
};
var email = new TransactionalEmailBuilder()
.WithFrom(new SendContact(_mailSettings.Mail))
.WithSubject(mailRequest.Subject)
.WithHtmlPart(mailRequest.Body)
.WithTo(new SendContact(mailRequest.ToEmail))
.Build();
var response = await client.SendTransactionalEmailAsync(email);
Console.WriteLine(response);
if (response.Messages.Length != 1)
{
throw new Exception();
}
}
catch (Exception e) {
Console.WriteLine(e.Message);
return(false);
}
return(true);
}
