private static HttpContent GetHttpContent <TPayload>(MercuryRequest <TPayload> request)
where TPayload : class
{
var json = JsonConvert.SerializeObject(request);
return(new StringContent(json, Encoding.UTF8, JsonMediaType));
}
public async Task <IActionResult> QueueMailAsync([FromBody] MercuryRequest <ExpandoObject> request, CancellationToken token)
{
var sendResult = await mediator.Send(new QueueMailRequest(request), token).ConfigureAwait(false);
if (sendResult.IsFailed)
{
return(BadRequest(MercuryResult.BadRequestResult(sendResult)));
}
return(Accepted(MercuryResult.AcceptedResult()));
}
public async Task <MercuryResult> QueueAsync <TPayload>(MercuryRequest <TPayload> request, CancellationToken token = default)
where TPayload : class
{
var content = GetHttpContent(request);
var response = await httpClient
.PostAsync($"api/v{settings.Version}/queue", content)
.ConfigureAwait(false);
return(await DeserializeAsync(response).ConfigureAwait(false));
}
private EmailMessage Map(MercuryRequest <ExpandoObject> request, EmailMetadata metadata, string body)
{
return(new EmailMessage
{
From = metadata.From ?? settings.From,
Tos = request.Tos,
Ccs = request.Ccs,
Bccs = request.Bccs,
Subject = metadata.Subject,
Body = body
});
}
public async Task <Result> SendAsync(MercuryRequest <ExpandoObject> request, CancellationToken token)
{
logger.WithScope("@Request", request).LogDebug("Starting to process email request.");
var validationResult = Validate(request);
if (validationResult.IsFailed)
{
return(validationResult);
}
token.ThrowIfCancellationRequested();
logger.LogDebug("Generating email body.");
var bodyResult = await GetEmailBodyAsync(request, token).ConfigureAwait(false);
if (bodyResult.IsFailed)
{
return(bodyResult);
}
logger.WithScope("Body", bodyResult.Value).LogDebug("Generated email body.");
token.ThrowIfCancellationRequested();
logger.LogDebug("Extracting metadata.");
var metadataResult = await GetMetadataAsync(request, token).ConfigureAwait(false);
if (metadataResult.IsFailed)
{
return(metadataResult);
}
logger.WithScope("@Metadata", metadataResult.Value).LogDebug("Extracted metadata.");
token.ThrowIfCancellationRequested();
logger.LogDebug("Mapping to message.");
var message = Map(request, metadataResult.Value, bodyResult.Value);
logger.WithScope("@Message", message).LogDebug("Mapped to message.");
token.ThrowIfCancellationRequested();
logger.LogDebug("Sending email.");
return(await emailer.SendAsync(message, token).ConfigureAwait(false));
}
private async Task <Result <EmailMetadata> > GetMetadataAsync(MercuryRequest <ExpandoObject> request, CancellationToken token)
{
var metadataPath = pathFinder.GetMetadataPath(request.TemplateKey);
var resourceResult = await resourceLoader.LoadAsync(metadataPath, token).ConfigureAwait(false);
if (resourceResult.IsFailed)
{
return(resourceResult.ToResult <EmailMetadata>());
}
token.ThrowIfCancellationRequested();
var metadataObj = JsonConvert.DeserializeObject <EmailMetadata>(resourceResult.Value);
return(Result.Ok(metadataObj));
}
private Result Validate(MercuryRequest <ExpandoObject> request)
{
if (request == null)
{
logger.LogError(EmailRequestNullFailureMessage);
return(Result.Fail(EmailRequestNullFailureMessage));
}
var validationResult = validator.Validate(request);
if (!validationResult.IsValid)
{
var errors = validationResult.Errors.Select(x => x.ErrorMessage);
logger.WithErrorScope(errors).LogError(EmailRequestInvalidFailureMessage);
return(Result.Fail(new Error(EmailRequestInvalidFailureMessage).CausedBy(errors)));
}
return(Result.Ok());
}
private async Task <Result <string> > GetEmailBodyAsync(MercuryRequest <ExpandoObject> request, CancellationToken token)
{
var templatePath = pathFinder.GetTemplatePath(request.TemplateKey);
var templateResult = await resourceLoader.LoadAsync(templatePath, token).ConfigureAwait(false);
if (templateResult.IsFailed)
{
return(templateResult);
}
token.ThrowIfCancellationRequested();
var templateProcessingResult = templateProcessor.Process(templateResult.Value, request.Payload);
if (templateProcessingResult.IsFailed)
{
return(templateProcessingResult);
}
return(Result.Ok(templateProcessingResult.Value));
}
public QueueMailRequest(MercuryRequest <ExpandoObject> request)
{
Request = request;
}
public SendMailRequest(MercuryRequest <ExpandoObject> request)
{
Request = request;
}
