Hi, No, it didn't help.

If I add .NotAsync() I am getting the following on the first send (no matter within async or sync method):

System.InvalidOperationException
  HResult=0x80131509
  Message=Cannot resolve scoped service 'Microsoft.AspNetCore.Mvc.ViewFeatures.Buffers.IViewBufferScope' from root provider.
  Source=Microsoft.Extensions.DependencyInjection
  StackTrace:
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteValidator.ValidateResolution(Type serviceType, IServiceScope scope, IServiceScope rootScope)
   at Microsoft.Extensions.DependencyInjection.ServiceProvider.GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngineScope.GetService(Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService[T](IServiceProvider provider)
   at Microsoft.AspNetCore.Mvc.Razor.RazorView.<RenderAsync>d__18.MoveNext()
   at NewsletterStudio.Web.Rendering.RazorHostViewRenderer.<RenderToStringAsync>d__6.MoveNext()
   at NewsletterStudio.Web.Rendering.RazorHostViewRenderer.RenderPartialViewToString(String viewName, Object model)
   at NewsletterStudio.Core.Rendering.EmailRenderer.Render(IRecipientDataModel recipient)
   at NewsletterStudio.Core.Sending.Transactional.TransactionalEmailSender.Send(SendTransactionalEmailRequest request)

Hi Markus, It is UmbracoApiController. It's a pretty basic call atm because we just started developing it.

The controller action gets customer emails and then processes them in foreach loop that calls the ITransactionalEmailService and its SendReminderEmail() action, the one that I pasted initially. That's it.

We have a scheduled task that runs the following action:

public class ReminderApiController : UmbracoApiController
{
    private readonly ITransactionalEmailService _transactionalEmailService;

    public ReminderApiController(ITransactionalEmailService transactionalEmailService)
    {
        _transactionalEmailService = transactionalEmailService;
    }

    [HttpGet]
    public async Task<IActionResult> SendReminder(string subjectTemplate)
    {
        var customersToEmail = await GetCustomers();

        foreach (var customer in customersToEmail)
        {
            _transactionalEmailService.SendReminderEmail(customer);
        }

        ...
    }
}

It happens locally. We only started developing this feature to try NS' transactional emails.

Not sure what else you wanna know?

I have simplified it for you so hopefully you'll be able to replicate it:

Controller:

public class ReminderApiController : UmbracoApiController
{
    private readonly IMediator _mediator;

    public ReminderApiController(IMediator mediator)
    {
        _mediator = mediator;
    }

    [HttpGet]
    public async Task<IActionResult> SendReminder(string subjectTemplate = "Reminder")
    {
        var query = new ReminderHandler.Query(subjectTemplate);

        var response = await _mediator.Send(query);

        return Ok(JsonConvert.SerializeObject(response));
    }
}

Handler:

internal class ReminderHandler
{
    #region Query
    public record class Query(string SubjectTemplate) : IRequest<Result>;

    public class Result
    {
        public List<string> Errors { get; set; }
        public bool Success { get; set; }
    }
    #endregion

    #region Handler
    public class QueryHandler : IRequestHandler<Query, Result>
    {
        #region Private properties
        private readonly ITransactionalEmailService _transactionalEmailService;
        #endregion

        #region Constuctor
        public QueryHandler(
            ITransactionalEmailService transactionalEmailService
        )
        {
            _transactionalEmailService = transactionalEmailService;
        }
        #endregion

        #region Handler
        public async Task<Result> Handle(Query request, CancellationToken cancellationToken)
        {
            var result = new Result();
            var errors = new List<string>();

            try
            {
                var customersToEmail = await GetCustomers(request.SubjectTemplate);

                foreach (var customer in customersToEmail)
                {
                    _transactionalEmailService.SendReminderEmail(customer);
                }

                result.Success = true;
            }
            catch (Exception ex)
            {
                errors.Add(ex.Message);
            }

            result.Errors = errors;

            return result;
        }
        #endregion

        private async Task<List<ReminderEmailModel>> GetCustomers(string subjectTemplate)
        {
            var customers = new List<ReminderEmailModel>
            {
                new ReminderEmailModel()
                {
                    EncodedRef = "ref 1",
                    ProductTitle = "Title 1",
                    FirstName = "Mary",
                    Email = "[email protected]",
                    DestinationCountry = "Spain",
                    Subject = subjectTemplate
                },
                new ReminderEmailModel()
                {
                    EncodedRef = "ref 2",
                    ProductTitle = "Title 2",
                    FirstName = "John",
                    Email = "[email protected]",
                    DestinationCountry = "Turkey",
                    Subject = subjectTemplate
                },
                new ReminderEmailModel()
                {
                    EncodedRef = "ref 3",
                    ProductTitle = "Title 3",
                    FirstName = "John",
                    Email = "[email protected]",
                    DestinationCountry = "Greece",
                    Subject = subjectTemplate
                }
            };

            return customers;
        }
    }
    #endregion
}

Model:

[TransactionalEmail("Reminder", Alias)]
public class ReminderEmailModel
{
    public const string Alias = "reminder";

    [MergeField("Encoded Ref", "encodedRef")]
    public string EncodedRef { get; set; }

    [MergeField("Product Title", "productTitle")]
    public string ProductTitle { get; set; }

    [MergeField("First Name", "firstName")]
    public string FirstName { get; set; }

    public string DestinationCountry { get; set; }

    public string Subject { get; set; }

    public string Email { get; set; }
}

Service:

public class TransactionalEmailService : ITransactionalEmailService
{
    private readonly INewsletterStudioService _newsletterStudioService;

    public TransactionalEmailService(
        INewsletterStudioService newsletterStudioService
        )
    {
        _newsletterStudioService = newsletterStudioService;
    }

    public CommandResult<SendTransactionalEmailResponse> SendReminderEmail(ReminderEmailModel customer)
    {
        return _newsletterStudioService.SendTransactional(
            SendTransactionalEmailRequest.Create(customer)
                .SendTo(customer.Email)
                .WithSubject(customer.Subject)
                .Build()
        );
    }
}

The transactional template exists in the BO with the reminder model selected.

The above code hits the mentioned error on returning SendTransactional.

The first email gets through and gets logged, but the following ones don't due to the error.

We now use NS version 10.0.13. The same error as in the version 10.0.8 persists.

Adding NotAsync() as per our instruction above still throws the error I mentioned earlier:

System.InvalidOperationException HResult=0x80131509 Message=Cannot resolve scoped service 'Microsoft.AspNetCore.Mvc.ViewFeatures.Buffers.IViewBufferScope' from root provider. Source=Microsoft.Extensions.DependencyInjection
StackTrace: at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteValidator.ValidateResolution(Type serviceType, IServiceScope scope, IServiceScope rootScope) at Microsoft.Extensions.DependencyInjection.ServiceProvider.GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
at Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngineScope.GetService(Type serviceType) at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType) at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService[T](IServiceProvider provider) at Microsoft.AspNetCore.Mvc.Razor.RazorView.

However, the upgrade to 10.0.14 fixed the issue and we can now send transactional emails in the loop.

We've detected other issues though, related to inserting a content link that I described here: https://our.umbraco.com/packages/backoffice-extensions/newsletter-studio-the-email-studio/comments//114081-issues-inserting-a-content-link-with-params-in-email-template