Email services are part of Infrastructure, Email templates?

[X-GeneIT]

Hi, I'm using this template for one of my projects based on .NET6 & Vuejs. I had run into issues initially (mostly with Automapper & Identity) but going through with discussion and issues reported here really helped me to overcome those issues. So thank you all for your contributions.
Now, I'm at the final stage of the project where I need to implement email notifications. I created email services within Infrastructure layer. but I'm not sure whether to create razor views for email templates under WebUI or Infrastructure.

I really appreciate it if someone could please share an opinion here!

[amadoa]

I have generated Emails and PDFs in this template using the razor view engine. For the most part I referenced this article.
https://www.learnrazorpages.com/advanced/render-partial-to-string

• Add the IRazorPartialToStringRenderer & IEmailService interfaces in src/Application/Common/Interfaces
• Add the RazorPartialToStringRenderer & DemoEmailService class to src/Infrastructure/Email
• In src/Infrastructure/ConfigureServices.cs add

   services.AddTransient<IEmailService, DemoEmailService>();
   services.AddTransient<IRazorPartialToStringRenderer, RazorPartialToStringRenderer>();

• Add the razor email template in src/WebUI/Pages/Shared

This is where I divert a bit from the article.

In your command or query (src/Application/...) the handler method will accept parameters for IRazorPartialToStringRenderer and IEmailService.
In the Handle method you will be able to generate the html with something like this

var body = await _renderer.RenderPartialToStringAsync("_ContactEmailPartial", ContactForm);

Then you can pass the body into the email service and send the email.

Hope this was helpful

[MakeStuffGo]

It is an excelent example by @amadoa on how to implement email-service, but the question was wheter you should create the razor views for email templates under WebUI or Infrastructure.

In my opinion the e-mail templates should recide in infrastructure. Like you wrote in your second post @X-GeneIT.

The infrastructure layer should not know about the UI. Application and UI could reside on sepearte servers even. Furthermore, UI should be replaceable, and there could be multiple different implementations of the UIs using the same Application back-end. It could be an app on Android, Windows, mac etc. Whatever it is it should not affect other layers.

Here's what I would do:
put IEmailService interface in src/Application/Common/Interfaces
, because your application probably only cares that it wants to send an email somewhere. Not the technology that is used to format or send the email.

Implement that interface in infrastructure layer.

• That way you can change the underlying implemention without changes to the application layer. You might want to use an 3rd party email service at some point where the templates are set up in the 3rd party service itself.
• You could of course still do the implementation with RazorPartialToStringRenderer and razor-pages as the templates. But then you'll have those in infrastructure. They could still be kept neatly in that separate razor project if you want by adding a new one and reference it from Infrastructure, "EmailTemplates.csproj" for example. Just as long as it is separeate from the actual webUI.

[X-GeneIT]

@MakeStuffGo In my case, the frontend (UI) is totally separated from the backend (Api usage). so my email templates reside within WebUI and call them from Application layer. BasedEmail model (independent from technology) also resides within Application layer. RazorPartialToStringRenderer & EmailServices reside within Infrastructure. i.e. no any additional dependency created between WebUI and Infrastructure layers other than those dependency injection references that already exist. Do you see any drawbacks with this approach? Thanks!

[MakeStuffGo]

@X-GeneIT

..., so my email templates reside within WebUI and call them from Application layer.

If you're saying that you reference the email templates defined in WebUI from the Application Layer, then please read below Application in project overview-page

This layer contains all application logic. It is dependent on the domain layer, but has no dependencies on any other layer or project. This layer defines interfaces that are implemented by outside layers. For example, if the application need to access a notification service, a new interface would be added to application and an implementation would be created within infrastructure.

[X-GeneIT]

@MakeStuffGo, I'm with you. how about create a separate razor project under Infrastructure folder and with Infrastructure.Email namespace then move all RazorPartialToStringRenderer, EmailServices, Models, Templates, etc.. to the same project? or even create the project in a different folder called Infrastructure.Email within src folder.

[X-GeneIT]

@MakeStuffGo I moved all email related implementation to a different project : Infrastructure.Email. Now when I try to run the solution, I get following error. I'm aware that adding services.AddRazorPages() to WebUI.ConfigureServices should solve the issue but. Is there a way to keep WebUI independent of Razor?

Ex. Is there a way I could refence IRazorViewEngine in Infrastructure.Email instead of WebUI?

What should I try different here? I really appreciate it if you could please shed a light here.

System.AggregateException: 'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: MediatR.IRequestHandler`2[Esca.Application.User.Commands.UpdateUser.UpdateUserCommand,System.String] Lifetime: Transient ImplementationType: Esca.Application.User.Commands.UpdateUser.UpdateUserComandHandler': Unable to resolve service for type 'Microsoft.AspNetCore.Mvc.Razor.IRazorViewEngine' while attempting to activate 'Esca.Infrastructure.Email.Services.RazorViewToStringRenderer'.)

namespace Esca.Application.User.Commands.UpdateUser;
public record UpdateUserCommand : IRequest<string>
{
    public string? Id { get; set; }
    public int AdrBookId { get; set; }
    public string? RoleId { get; set; }
    public bool ResendEmailVerification { get; set; }
}

public class UpdateUserComandHandler : IRequestHandler<UpdateUserCommand, string>
{
    private readonly IApplicationDbContext _context;
    private readonly IAuthenticationService _authenticationService;
    private readonly ISendEmailService _sendEmailService;
    public UpdateUserComandHandler(IApplicationDbContext context, IAuthenticationService authenticationService, ISendEmailService sendEmailService)
    {
        _context = context;
        _authenticationService = authenticationService;
        _sendEmailService = sendEmailService;
    }

    public async Task<string> Handle(UpdateUserCommand request, CancellationToken cancellationToken)
    {
        var adrBook = await _context.AdrBooks.FindAsync(new object[] { request.AdrBookId }, cancellationToken);
        if (adrBook == null)
        {
            throw new NotFoundException(nameof(AdrBook), request.AdrBookId);
        }
       // Logic to update user goes here...

        if (request.ResendEmailVerification)
        {
            var url = await _authenticationService.GenerateEmailConfirmationTokenAsync(request.Id);
            if (adrBook.Email != null)
            {
                var fullName = string.Format("{0} {1}", adrBook.FirstName, adrBook.LastName);
                await _sendEmailService.SendVerifyEmail(fullName, adrBook.Email, url);
            }
        }
        return request.Id;
    }
}

namespace Esca.Infrastructure.Email.Services;

public class SendEmailService : ISendEmailService
{
    private readonly IWebHostEnvironment _webHostEnvironment;
    private readonly IRazorViewToStringRenderer _renderToStringRenderer;
    public SendEmailService(IWebHostEnvironment webHostEnvironment, IRazorViewToStringRenderer renderToStringRenderer)
    {
        _webHostEnvironment = webHostEnvironment;
        _renderToStringRenderer = renderToStringRenderer;
    }

    public async Task<string> SendVerifyEmail(string fullName, string toEmail, string url)
    {
        var verifyEmailDto = new VerifyEmailDto
        {
            FullName = fullName,
            Subject = "Verify Email",
        };
        verifyEmailDto.CallBackUrl = new CallBackUrl { LinkText = "Verify Email Now", Url = url };
        verifyEmailDto.ToRecipients.Add(new Recipient { Email = toEmail, Name = fullName });
        verifyEmailDto.FromRecipient.Add(new Recipient { Email = "[email protected]", Name = "System Adminstrator" });
        verifyEmailDto.Body = await _renderToStringRenderer.RenderViewToStringAsync("/EmailTemplates/Auth/VerifyEmail.cshtml", verifyEmailDto);
        return SendEmail(verifyEmailDto);
    }
    
    private string SendEmail(BaseEmail baseEmail)
    {
        var returnVal = "YES";
        var message = new MimeMessage();

        foreach (var from in baseEmail.FromRecipient)
        {
            message.From.Add(new MailboxAddress(from.Name, from.Email));
        }

        foreach (var to in baseEmail.ToRecipients)
        {
            message.To.Add(new MailboxAddress(to.Name, to.Email));
        }

        foreach (var to in baseEmail.BccRecipients)
        {
            message.Bcc.Add(new MailboxAddress(to.Name, to.Email));
        }

        message.Subject = baseEmail.Subject;

        var bodyBuilder = new BodyBuilder
        {
            HtmlBody = baseEmail.Body
        };
        GetAllImgTagsEmbedded(bodyBuilder);

        foreach (var attachment in baseEmail.MailAttachment)
        {
            if (attachment != null && attachment.FilePath != null)
            {
                bodyBuilder.Attachments.Add(attachment.OriginalFileName, File.ReadAllBytes(attachment.FilePath));
            }
        }
        message.Body = bodyBuilder.ToMessageBody();

        try
        {
            SendToPickupDirectory(message);
        }
        catch (Exception ex)
        {
            returnVal = string.Format("{0},{1}", "NO", ex.Message);
        }
        return returnVal;
    }
    private string GetAllImgTagsEmbedded(BodyBuilder bodyBuilder)
    {
        // Logic to embed images 
    }
    private void SendToPickupDirectory(MimeMessage message)
    {
        // Get the pick up directory
    }
}`

[fakhrulhilal]

I'm separating email sending into 3 parts:

1. Email template compiler
   Its job is reading email template (currently in HTML format), populating placeholder variable (currently using {variable_name} format), then give the rendered HTML format. It also provides conversion from HTML to plain text. It's highly suggested to set plain text alternative when sending HTML email. We can also apply layout template here. So the email wrapper will pass only partial body.
2. Email sender
   Its job is sending email to SMTP or other provider. This can be implemented in builtin .NET lib or using MailKit or any 3rd party email service provider (like sendgrid). It accepts common sending email parameter, i.e. TO, CC, BCC, subject, email body (both HTML and plain text), etc.
3. Email wrapper
   Its main job just wrapper for all of those 2 above. It only accepts destination (TO, CC, BCC), subject, partial body.

The way to do that, create IEmailTemplate, IEmailSender, IEmailService in [app layer]\Common\Services. The implementation will be done in infrastructure layer, for example, we can write RazorEmailTemplate for dealing with razor style HTML template. Implementation of IEmailService can be done in application layer, but let's write it in infrastructure layer for consistency purpose.

I store the email templates in WebUI layer, because it's easier to get the template folder path (by relying on IWebHostEnvironment.WebRootPath. If you want to store in infrastructure layer, then you need to add additional interface (let's say ITemplatePathProvider) and implement it in WebUI layer (let's say WebTemplatePathProvider) and inject this service in IEmailTemplate implementation.

To get full illustration here
Application layer

public interface IEmailSender
{
    Task SendAsync(CompiledEmailMessage message);
}

public interface IEmailTemplate
{
    Task<EmailBody> CompileAsync(string bodyPath, IEnumerable<Placeholder> placeholders);
}

public interface IEmailService
{
    Task SendAsync(EmailMessage message);
}

public interface ITemplatePathProvider
{
    string Resolve(string relativePath);
}

public record EmailAttachment(Func<Stream> StreamFactory, string FileName, string MimeType = "application/octet-stream");
public record EmailBody(string Html, string PlainText);
public record Placeholder(string Name, string Value);
public record EmailAddress(string Address, string DisplayName)
{
    public static implicit operator EmailAddress(string address) => new(address, string.Empty);
}
public record CompiledEmailMessage(string Subject, EmailBody Body, EmailAddress From,
    IEnumerable<EmailAddress> To,
    IEnumerable<EmailAddress>? Cc = null,
    IEnumerable<EmailAddress>? Bcc = null,
    IEnumerable<EmailAttachment>? Attachments = null);

public record EmailMessage(string Subject, string BodyPath, IEnumerable<Placeholder> Placeholders,
    EmailAddress From, IEnumerable<EmailAddress> To,
    IEnumerable<EmailAddress>? Cc = null,
    IEnumerable<EmailAddress>? Bcc = null,
    IEnumerable<EmailAttachment>? Attachments = null);

Infrastructure layer

public class TemplateOptions
{
    public string LayoutPath { get; set; } = string.Empty;
}

public class RazorEmailTemplate : IEmailTemplate
{
    private readonly ITemplatePathProvider _pathProvider;
    private readonly TemplateOptions _options;

    public RazorEmailTemplate(ITemplatePathProvider pathProvider, IOptions<TemplateOptions> options) {
        _options = options.Value;
        _pathProvider = pathProvider;
    }

    public Task<EmailBody> CompileAsync(string partialBodyPath, IEnumerable<Placeholder> placeholders) {
        string layoutPath = _pathProvider.Resolve(_options.LayoutPath);
        string bodyPath = _pathProvider.Resolve(partialBodyPath);
        // TODO: compile body given layout above
        // TODO: do placeholder replacement
        // TODO: build plain text version
        throw new NotImplementedException();
    }
}

WebUI layer

using System;
using System.IO;
using Microsoft.AspNetCore.Hosting;

public interface ITemplatePathProvider
{
    string Resolve(string relativePath);
}

public class WebTemplateProvider : ITemplatePathProvider
{
    private readonly string _basePath;

    public WebTemplateProvider(IWebHostEnvironment env)
    {
        _basePath = env.WebRootPath
            .Replace('/', Path.DirectorySeparatorChar)
            .TrimEnd(Path.DirectorySeparatorChar);
    }

    public string Resolve(string relativePath)
    {
        if (string.IsNullOrWhiteSpace(relativePath))
        {
            throw new ArgumentNullException(nameof(relativePath));
        }

        relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar).TrimStart(Path.DirectorySeparatorChar);
        // it can accept ~/folder of just /folder format
        return relativePath.StartsWith('~')
            ? relativePath.Replace("~", _basePath)
            : Path.Combine(_basePath, relativePath);
    }
}

And finally, you can write email service wrapper as follows (can be in infrastructure/application layer)

public class EmailService : IEmailService
{
    private readonly IEmailSender _emailSender;
    private readonly IEmailTemplate _emailTemplate;

    public EmailService(IEmailTemplate emailTemplate, IEmailSender emailSender) {
        _emailTemplate = emailTemplate;
        _emailSender = emailSender;
    }

    public async Task SendAsync(EmailMessage message) {
        var emailBody = await _emailTemplate.CompileAsync(message.BodyPath, message.Placeholders);
        var compiledMessage = new CompiledEmailMessage(message.Subject, emailBody, message.From, message.To,
            message.Cc, message.Bcc, message.Attachments);
        await _emailSender.SendAsync(compiledMessage);
    }
}