Refactor PdfService and introduce TemplateService

Refactored PdfService to delegate template rendering and time zone handling to the newly introduced TemplateService, simplifying its logic. Added ITemplateService interface and TemplateGenerationRequest/TemplateResponse models to encapsulate template rendering functionality.

Introduced TemplateGenerationRequestValidator for input validation and updated Program.cs to register new services and endpoints, including the /api/template endpoint for rendering templates to HTML. Simplified TimeZoneService logic and removed redundant code.

Improved maintainability, modularity, and error handling by separating concerns and enhancing code readability.

Closes #30

Author: marcominerva

src/PdfSmith.BusinessLayer/Services/Interfaces/ITemplateService.cs

@@ -0,0 +1,9 @@
+using OperationResults;
+using PdfSmith.Shared.Models;
+
+namespace PdfSmith.BusinessLayer.Services.Interfaces;
+
+public interface ITemplateService
+{
+    Task<Result<TemplateResponse>> CreateAsync(TemplateGenerationRequest request, CancellationToken cancellationToken);
+}

src/PdfSmith.BusinessLayer/Services/PdfService.cs

@@ -1,57 +1,24 @@
-using System.Globalization;
-using System.Net.Mime;
-using Microsoft.Extensions.DependencyInjection;
+using System.Net.Mime;
 using OperationResults;
-using PdfSmith.BusinessLayer.Exceptions;
-using PdfSmith.BusinessLayer.Extensions;
 using PdfSmith.BusinessLayer.Generators.Interfaces;
 using PdfSmith.BusinessLayer.Services.Interfaces;
-using PdfSmith.BusinessLayer.Templating.Interfaces;
 using PdfSmith.Shared.Models;
 using TinyHelpers.Extensions;
 
 namespace PdfSmith.BusinessLayer.Services;
 
-public class PdfService(IServiceProvider serviceProvider, IPdfGenerator pdfGenerator, ITimeZoneService timeZoneService) : IPdfService
+public class PdfService(ITemplateService templateService, IPdfGenerator pdfGenerator) : IPdfService
 {
     public async Task<Result<StreamFileContent>> GeneratePdfAsync(PdfGenerationRequest request, CancellationToken cancellationToken)
     {
-        var templateEngine = serviceProvider.GetKeyedService<ITemplateEngine>(request.TemplateEngine!.ToLowerInvariant().Trim());
+        var templateResponse = await templateService.CreateAsync(request, cancellationToken);
 
-        if (templateEngine is null)
+        if (!templateResponse.Success)
         {
-            return Result.Fail(FailureReasons.ClientError, "Unable to render the template", $"The template engine '{request.TemplateEngine}' has not been registered");
+            return Result.Fail(templateResponse.FailureReason, templateResponse.ErrorMessage!, templateResponse.ErrorDetail!, templateResponse.ValidationErrors);
         }
 
-        var timeZoneInfo = timeZoneService.GetTimeZone();
-
-        if (timeZoneInfo is null)
-        {
-            var timeZoneId = timeZoneService.GetTimeZoneHeaderValue();
-            if (timeZoneId is not null)
-            {
-                // If timeZoneInfo is null, but timeZoneId has a value, it means that the time zone specified in the header is invalid.
-                return Result.Fail(FailureReasons.ClientError, "Unable to find the time zone", $"The time zone '{timeZoneId}' is invalid or is not available on the system");
-            }
-        }
-
-        string? content;
-        try
-        {
-            var model = request.Model?.ToExpandoObject(timeZoneInfo);
-
-            cancellationToken.ThrowIfCancellationRequested();
-
-            content = await templateEngine.RenderAsync(request.Template, model, CultureInfo.CurrentCulture, cancellationToken);
-
-            cancellationToken.ThrowIfCancellationRequested();
-        }
-        catch (TemplateEngineException ex)
-        {
-            return Result.Fail(FailureReasons.ClientError, "Unable to render the template", ex.Message);
-        }
-
-        var output = await pdfGenerator.CreateAsync(content, request.Options, cancellationToken);
+        var output = await pdfGenerator.CreateAsync(templateResponse.Content.Result, request.Options, cancellationToken);
 
         cancellationToken.ThrowIfCancellationRequested();
 

src/PdfSmith.BusinessLayer/Services/TemplateService.cs

@@ -0,0 +1,53 @@
+using System.Globalization;
+using Microsoft.Extensions.DependencyInjection;
+using OperationResults;
+using PdfSmith.BusinessLayer.Exceptions;
+using PdfSmith.BusinessLayer.Extensions;
+using PdfSmith.BusinessLayer.Services.Interfaces;
+using PdfSmith.BusinessLayer.Templating.Interfaces;
+using PdfSmith.Shared.Models;
+
+namespace PdfSmith.BusinessLayer.Services;
+
+public class TemplateService(IServiceProvider serviceProvider, ITimeZoneService timeZoneService) : ITemplateService
+{
+    public async Task<Result<TemplateResponse>> CreateAsync(TemplateGenerationRequest request, CancellationToken cancellationToken)
+    {
+        var templateEngine = serviceProvider.GetKeyedService<ITemplateEngine>(request.TemplateEngine!.ToLowerInvariant().Trim());
+
+        if (templateEngine is null)
+        {
+            return Result.Fail(FailureReasons.ClientError, "Unable to render the template", $"The template engine '{request.TemplateEngine}' has not been registered");
+        }
+
+        var timeZoneInfo = timeZoneService.GetTimeZone();
+
+        if (timeZoneInfo is null)
+        {
+            var timeZoneId = timeZoneService.GetTimeZoneHeaderValue();
+            if (timeZoneId is not null)
+            {
+                // If timeZoneInfo is null, but timeZoneId has a value, it means that the time zone specified in the header is invalid.
+                return Result.Fail(FailureReasons.ClientError, "Unable to find the time zone", $"The time zone '{timeZoneId}' is invalid or is not available on the system");
+            }
+        }
+
+        string? content;
+        try
+        {
+            var model = request.Model?.ToExpandoObject(timeZoneInfo);
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            content = await templateEngine.RenderAsync(request.Template, model, CultureInfo.CurrentCulture, cancellationToken);
+
+            cancellationToken.ThrowIfCancellationRequested();
+        }
+        catch (TemplateEngineException ex)
+        {
+            return Result.Fail(FailureReasons.ClientError, "Unable to render the template", ex.Message);
+        }
+
+        return new TemplateResponse(content);
+    }
+}

src/PdfSmith.BusinessLayer/Services/TimeZoneService.cs

@@ -21,7 +21,7 @@ public class TimeZoneService(IHttpContextAccessor httpContextAccessor) : ITimeZo
 
     public string? GetTimeZoneHeaderValue()
     {
-        if (httpContextAccessor.HttpContext?.Request?.Headers?.TryGetValue(HeaderKey, out var timeZone) ?? false)
+        if (httpContextAccessor.HttpContext?.Request?.Headers?.TryGetValue(HeaderKey, out var timeZone) == true)
         {
             return timeZone.ToString();
         }

src/PdfSmith.BusinessLayer/Validations/TemplateGenerationRequestValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+using PdfSmith.Shared.Models;
+
+namespace PdfSmith.BusinessLayer.Validations;
+
+public class TemplateGenerationRequestValidator : AbstractValidator<TemplateGenerationRequest>
+{
+    public TemplateGenerationRequestValidator()
+    {
+        RuleFor(r => r.Template).NotEmpty();
+        RuleFor(r => r.TemplateEngine).NotEmpty().When(r => r.Model is not null);
+    }
+}

src/PdfSmith.Shared/Models/PdfGenerationRequest.cs

@@ -5,20 +5,10 @@ namespace PdfSmith.Shared.Models;
 
 [method: JsonConstructor]
 public record class PdfGenerationRequest(string Template, JsonDocument? Model, PdfOptions? Options, string? TemplateEngine = null, string? FileName = null)
+    : TemplateGenerationRequest(Template, Model, TemplateEngine)
 {
     public PdfGenerationRequest(string template, object? model, PdfOptions? options = null, string? templateEngine = null, string? fileName = null)
         : this(template, ToJsonDocument(model), options, templateEngine, fileName)
     {
     }
-
-    private static JsonDocument? ToJsonDocument(object? model)
-    {
-        if (model is null)
-        {
-            return null;
-        }
-
-        var jsonString = JsonSerializer.Serialize(model, JsonSerializerOptions.Default);
-        return JsonDocument.Parse(jsonString);
-    }
 }

src/PdfSmith.Shared/Models/TemplateGenerationRequest.cs

@@ -0,0 +1,24 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace PdfSmith.Shared.Models;
+
+[method: JsonConstructor]
+public record class TemplateGenerationRequest(string Template, JsonDocument? Model, string? TemplateEngine = null)
+{
+    public TemplateGenerationRequest(string template, object? model, string? templateEngine = null)
+        : this(template, ToJsonDocument(model), templateEngine)
+    {
+    }
+
+    protected static JsonDocument? ToJsonDocument(object? model)
+    {
+        if (model is null)
+        {
+            return null;
+        }
+
+        var jsonString = JsonSerializer.Serialize(model, JsonSerializerOptions.Default);
+        return JsonDocument.Parse(jsonString);
+    }
+}

src/PdfSmith.Shared/Models/TemplateResponse.cs

@@ -0,0 +1,3 @@
+namespace PdfSmith.Shared.Models;
+
+public record class TemplateResponse(string Result);

src/PdfSmith/Program.cs

@@ -57,6 +57,7 @@
 builder.Services.AddKeyedSingleton<ITemplateEngine, RazorTemplateEngine>("razor");
 builder.Services.AddKeyedSingleton<ITemplateEngine, HandlebarsTemplateEngine>("handlebars");
 
+builder.Services.AddSingleton<ITemplateService, TemplateService>();
 builder.Services.AddSingleton<IPdfGenerator, ChromiumPdfGenerator>();
 builder.Services.AddSingleton<IPdfService, PdfService>();
 
@@ -183,6 +184,25 @@
     ResponseWriter = HealthChecksResponseWriter()
 });
 
+app.MapPost("/api/template", async (TemplateGenerationRequest request, ITemplateService templateService, HttpContext httpContext) =>
+{
+    var result = await templateService.CreateAsync(request, httpContext.RequestAborted);
+
+    var response = httpContext.CreateResponse(result);
+    return response;
+})
+.WithName("CreateTemplate")
+.WithSummary("Renders a template to HTML using the specified template engine")
+.WithDescription("Accepts a template (string) and a model (JSON) and returns the rendered HTML as a string. Supports Razor, Scriban, and Handlebars via the 'templateEngine' property. The template is rendered using the request culture and optional time zone header. Useful to preview or validate templates before generating a PDF.")
+.WithValidation<TemplateGenerationRequest>()
+.Produces<TemplateResponse>(StatusCodes.Status200OK)
+.RequireAuthorization()
+.WithRequestTimeout(new RequestTimeoutPolicy
+{
+    Timeout = TimeSpan.FromSeconds(5),
+    TimeoutStatusCode = StatusCodes.Status408RequestTimeout
+});
+
 app.MapPost("/api/pdf", async (PdfGenerationRequest request, IPdfService pdfService, HttpContext httpContext) =>
 {
     var result = await pdfService.GeneratePdfAsync(request, httpContext.RequestAborted);
@@ -191,8 +211,8 @@
     return response;
 })
 .WithName("GeneratePdf")
-.WithSummary("Dynamically generates a PDF document using a provided template and model")
-.WithDescription("This endpoint accepts a template (as a string) and a model (as a JSON object) to generate a PDF document on the fly. The template can use the Razor, Scriban, or Handlebars engine, specified via the 'templateEngine' property. The model is injected into the template for dynamic content rendering. Additional PDF options and a custom file name can be provided. The result is a PDF file generated according to the submitted template and data.")
+.WithSummary("Renders a template and generates a PDF using the specified template engine")
+.WithDescription("Accepts a template (string) and a model (JSON) and returns a generated PDF document. Supports Razor, Scriban, and Handlebars via the 'templateEngine' property. The model is injected into the template for dynamic content rendering. Additional PDF options and a custom file name can be provided. The template is rendered using the request culture and optional time zone header.")
 .WithValidation<PdfGenerationRequest>()
 .Produces(StatusCodes.Status200OK, contentType: MediaTypeNames.Application.Pdf)
 .RequireAuthorization()