up

src/Notifier/StellaOps.Notifier/StellaOps.Notifier.WebService/Services/NotifyTemplateService.cs

@@ -0,0 +1,273 @@
+using System.Text.Json.Nodes;
+using Microsoft.Extensions.Logging;
+using StellaOps.Notify.Models;
+using StellaOps.Notify.Storage.Mongo.Repositories;
+
+namespace StellaOps.Notifier.WebService.Services;
+
+/// <summary>
+/// Default implementation of INotifyTemplateService with locale fallback and version tracking.
+/// </summary>
+public sealed class NotifyTemplateService : INotifyTemplateService
+{
+    private const string DefaultLocale = "en-us";
+
+    private readonly INotifyTemplateRepository _repository;
+    private readonly INotifyTemplateRenderer _renderer;
+    private readonly TimeProvider _timeProvider;
+    private readonly ILogger<NotifyTemplateService> _logger;
+
+    public NotifyTemplateService(
+        INotifyTemplateRepository repository,
+        INotifyTemplateRenderer renderer,
+        TimeProvider timeProvider,
+        ILogger<NotifyTemplateService> logger)
+    {
+        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+        _renderer = renderer ?? throw new ArgumentNullException(nameof(renderer));
+        _timeProvider = timeProvider ?? TimeProvider.System;
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public async Task<NotifyTemplate?> GetByKeyAsync(
+        string tenantId,
+        string key,
+        string locale,
+        NotifyChannelType? channelType = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(tenantId);
+        ArgumentException.ThrowIfNullOrWhiteSpace(key);
+
+        locale = NormalizeLocale(locale);
+
+        var allTemplates = await _repository.ListAsync(tenantId, cancellationToken).ConfigureAwait(false);
+
+        // Filter by key
+        var matching = allTemplates.Where(t => t.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+
+        // Filter by channel type if specified
+        if (channelType.HasValue)
+        {
+            matching = matching.Where(t => t.ChannelType == channelType.Value);
+        }
+
+        var candidates = matching.ToArray();
+
+        // Try exact locale match
+        var exactMatch = candidates.FirstOrDefault(t =>
+            t.Locale.Equals(locale, StringComparison.OrdinalIgnoreCase));
+
+        if (exactMatch is not null)
+        {
+            return exactMatch;
+        }
+
+        // Try language-only match (e.g., "en" from "en-us")
+        var languageCode = locale.Split('-')[0];
+        var languageMatch = candidates.FirstOrDefault(t =>
+            t.Locale.StartsWith(languageCode, StringComparison.OrdinalIgnoreCase));
+
+        if (languageMatch is not null)
+        {
+            _logger.LogDebug("Template {Key} not found for locale {Locale}, using {FallbackLocale}.",
+                key, locale, languageMatch.Locale);
+            return languageMatch;
+        }
+
+        // Fall back to default locale
+        var defaultMatch = candidates.FirstOrDefault(t =>
+            t.Locale.Equals(DefaultLocale, StringComparison.OrdinalIgnoreCase));
+
+        if (defaultMatch is not null)
+        {
+            _logger.LogDebug("Template {Key} not found for locale {Locale}, using default locale.",
+                key, locale);
+            return defaultMatch;
+        }
+
+        // Return any available template for the key
+        return candidates.FirstOrDefault();
+    }
+
+    public Task<NotifyTemplate?> GetByIdAsync(
+        string tenantId,
+        string templateId,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(tenantId);
+        ArgumentException.ThrowIfNullOrWhiteSpace(templateId);
+
+        return _repository.GetAsync(tenantId, templateId, cancellationToken);
+    }
+
+    public async Task<IReadOnlyList<NotifyTemplate>> ListAsync(
+        string tenantId,
+        string? keyPrefix = null,
+        string? locale = null,
+        NotifyChannelType? channelType = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(tenantId);
+
+        var allTemplates = await _repository.ListAsync(tenantId, cancellationToken).ConfigureAwait(false);
+
+        IEnumerable<NotifyTemplate> filtered = allTemplates;
+
+        if (!string.IsNullOrWhiteSpace(keyPrefix))
+        {
+            filtered = filtered.Where(t => t.Key.StartsWith(keyPrefix, StringComparison.OrdinalIgnoreCase));
+        }
+
+        if (!string.IsNullOrWhiteSpace(locale))
+        {
+            var normalizedLocale = NormalizeLocale(locale);
+            filtered = filtered.Where(t => t.Locale.Equals(normalizedLocale, StringComparison.OrdinalIgnoreCase));
+        }
+
+        if (channelType.HasValue)
+        {
+            filtered = filtered.Where(t => t.ChannelType == channelType.Value);
+        }
+
+        return filtered.OrderBy(t => t.Key).ThenBy(t => t.Locale).ToArray();
+    }
+
+    public async Task<NotifyTemplate> UpsertAsync(
+        NotifyTemplate template,
+        string updatedBy,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(template);
+        ArgumentException.ThrowIfNullOrWhiteSpace(updatedBy);
+
+        var now = _timeProvider.GetUtcNow();
+
+        // Check for existing template to preserve creation metadata
+        var existing = await _repository.GetAsync(template.TenantId, template.TemplateId, cancellationToken)
+            .ConfigureAwait(false);
+
+        var updatedTemplate = NotifyTemplate.Create(
+            templateId: template.TemplateId,
+            tenantId: template.TenantId,
+            channelType: template.ChannelType,
+            key: template.Key,
+            locale: template.Locale,
+            body: template.Body,
+            renderMode: template.RenderMode,
+            format: template.Format,
+            description: template.Description,
+            metadata: template.Metadata,
+            createdBy: existing?.CreatedBy ?? updatedBy,
+            createdAt: existing?.CreatedAt ?? now,
+            updatedBy: updatedBy,
+            updatedAt: now);
+
+        await _repository.UpsertAsync(updatedTemplate, cancellationToken).ConfigureAwait(false);
+
+        _logger.LogInformation(
+            "Template {TemplateId} (key={Key}, locale={Locale}) upserted by {UpdatedBy}.",
+            updatedTemplate.TemplateId, updatedTemplate.Key, updatedTemplate.Locale, updatedBy);
+
+        return updatedTemplate;
+    }
+
+    public async Task DeleteAsync(
+        string tenantId,
+        string templateId,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(tenantId);
+        ArgumentException.ThrowIfNullOrWhiteSpace(templateId);
+
+        await _repository.DeleteAsync(tenantId, templateId, cancellationToken).ConfigureAwait(false);
+
+        _logger.LogInformation("Template {TemplateId} deleted from tenant {TenantId}.", templateId, tenantId);
+    }
+
+    public Task<TemplatePreviewResult> PreviewAsync(
+        NotifyTemplate template,
+        JsonNode? samplePayload,
+        TemplateRenderOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(template);
+
+        options ??= new TemplateRenderOptions();
+
+        // Apply redaction to payload if allowlist is specified
+        var redactedFields = new List<string>();
+        var processedPayload = samplePayload;
+
+        if (options.RedactionAllowlist is { Count: > 0 })
+        {
+            processedPayload = ApplyRedaction(samplePayload, options.RedactionAllowlist, redactedFields);
+        }
+
+        // Render body
+        var renderedBody = _renderer.Render(template, processedPayload, options);
+
+        // Render subject if present in metadata
+        string? renderedSubject = null;
+        if (template.Metadata.TryGetValue("subject", out var subjectTemplate))
+        {
+            var subjectTemplateObj = NotifyTemplate.Create(
+                templateId: "subject-preview",
+                tenantId: template.TenantId,
+                channelType: template.ChannelType,
+                key: "subject",
+                locale: template.Locale,
+                body: subjectTemplate);
+            renderedSubject = _renderer.Render(subjectTemplateObj, processedPayload, options);
+        }
+
+        // Build provenance link if requested
+        string? provenanceLink = null;
+        if (options.IncludeProvenance && !string.IsNullOrWhiteSpace(options.ProvenanceBaseUrl))
+        {
+            provenanceLink = $"{options.ProvenanceBaseUrl.TrimEnd('/')}/templates/{template.TemplateId}";
+        }
+
+        var result = new TemplatePreviewResult
+        {
+            RenderedBody = renderedBody,
+            RenderedSubject = renderedSubject,
+            RenderMode = template.RenderMode,
+            Format = options.FormatOverride ?? template.Format,
+            RedactedFields = redactedFields,
+            ProvenanceLink = provenanceLink
+        };
+
+        return Task.FromResult(result);
+    }
+
+    private static JsonNode? ApplyRedaction(JsonNode? payload, IReadOnlySet<string> allowlist, List<string> redactedFields)
+    {
+        if (payload is not JsonObject obj)
+        {
+            return payload;
+        }
+
+        var result = new JsonObject();
+
+        foreach (var (key, value) in obj)
+        {
+            if (allowlist.Contains(key))
+            {
+                result[key] = value?.DeepClone();
+            }
+            else
+            {
+                result[key] = "[REDACTED]";
+                redactedFields.Add(key);
+            }
+        }
+
+        return result;
+    }
+
+    private static string NormalizeLocale(string? locale)
+    {
+        return string.IsNullOrWhiteSpace(locale) ? DefaultLocale : locale.ToLowerInvariant();
+    }
+}