refactor: rename domain types and introduce TransactionBehavior pattern

- Rename Template -> EmailTemplate, Provider -> EmailChannel, ProviderSettings -> EmailChannelSettings, ProviderType -> EmailChannelType, ProviderUsage -> EmailChannelUsage throughout all layers - Add Undefined = 0 to EmailChannelType enum for safe default handling - Remove SaveChangesAsync from EfRepository methods — repositories now only stage changes - Add SaveChangesAsync to IUnitOfWork and EfUnitOfWork - Add TransactionBehavior MediatR pipeline: wraps every handler in a transaction, saves and commits on success, rolls back on exception - Add MediatR package reference to Services project Ref: IT-628 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-05-02 00:16:47 +03:00
parent 088eab0428
commit 6dcc911fc2
28 changed files with 290 additions and 251 deletions
@@ -0,0 +1,100 @@
+using System.Text.Json;
+using HrynCo.NotificationService.DAL.Abstract.Providers;
+using HrynCo.NotificationService.DAL.Abstract.Repositories;
+using HrynCo.NotificationService.DAL.EF.Core;
+using HrynCo.NotificationService.DAL.EF.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace HrynCo.NotificationService.DAL.EF.Repositories;
+
+internal sealed class EmailChannelRepository : EfRepository<EmailChannelEntity>, IEmailChannelRepository
+{
+    public EmailChannelRepository(NotificationDbContext dbContext) : base(dbContext)
+    {
+    }
+
+    public async Task<IReadOnlyList<EmailChannel>> GetByServiceAsync(string serviceName, CancellationToken ct = default)
+    {
+        var entities = await DbSet
+            .Where(x => x.ServiceName == serviceName)
+            .OrderBy(x => x.Priority)
+            .ToListAsync(ct);
+
+        return entities.Select(MapToDomain).ToList();
+    }
+
+    public async Task<EmailChannel?> GetByIdAsync(Guid id, CancellationToken ct = default)
+    {
+        EmailChannelEntity? entity = await DbSet.FindAsync([id], ct);
+        return entity is null ? null : MapToDomain(entity);
+    }
+
+    public Task AddAsync(EmailChannel channel, CancellationToken ct = default)
+    {
+        return base.AddAsync(MapToEntity(channel), ct);
+    }
+
+    public Task UpdateAsync(EmailChannel channel, CancellationToken ct = default)
+    {
+        EmailChannelEntity entity = MapToEntity(channel);
+        entity.Updated = DateTimeOffset.UtcNow;
+        Update(entity);
+        return Task.CompletedTask;
+    }
+
+    public async Task DeleteAsync(EmailChannel channel, CancellationToken ct = default)
+    {
+        EmailChannelEntity? entity = await DbSet.FindAsync([channel.Id], ct);
+        if (entity is not null)
+        {
+            Delete(entity);
+        }
+    }
+
+    private static EmailChannel MapToDomain(EmailChannelEntity e)
+    {
+        return new EmailChannel
+        {
+            Id = e.Id,
+            ServiceName = e.ServiceName,
+            Priority = e.Priority,
+            EmailChannelType = e.EmailChannelType,
+            Settings = DeserializeSettings(e.EmailChannelType, e.SettingsJson),
+            DailyLimit = e.DailyLimit,
+            MonthlyLimit = e.MonthlyLimit,
+            WarnThresholdPercent = e.WarnThresholdPercent,
+            IsActive = e.IsActive,
+            Created = e.Created,
+            Updated = e.Updated
+        };
+    }
+
+    private static EmailChannelEntity MapToEntity(EmailChannel p)
+    {
+        return new EmailChannelEntity
+        {
+            Id = p.Id,
+            ServiceName = p.ServiceName,
+            Priority = p.Priority,
+            EmailChannelType = p.EmailChannelType,
+            SettingsJson = JsonSerializer.Serialize(p.Settings),
+            DailyLimit = p.DailyLimit,
+            MonthlyLimit = p.MonthlyLimit,
+            WarnThresholdPercent = p.WarnThresholdPercent,
+            IsActive = p.IsActive,
+            Created = p.Created,
+            Updated = p.Updated
+        };
+    }
+
+    private static EmailChannelSettings DeserializeSettings(EmailChannelType type, string json)
+    {
+        return type switch
+        {
+            EmailChannelType.Smtp => JsonSerializer.Deserialize<SmtpChannelSettings>(json)
+                                 ?? throw new InvalidOperationException(
+                                     "Failed to deserialize SMTP EmailChannel settings."),
+            _ => throw new InvalidOperationException($"Unknown or undefined email channel type: {type}")
+        };
+    }
+}
@@ -5,15 +5,15 @@ using Microsoft.EntityFrameworkCore;

 namespace HrynCo.NotificationService.DAL.EF.Repositories;

-internal sealed class ProviderUsageRepository : EfRepository<ProviderUsageEntity>, IProviderUsageRepository
+internal sealed class EmailChannelUsageRepository : EfRepository<EmailChannelUsageEntity>, IEmailChannelUsageRepository
 {
-    public ProviderUsageRepository(NotificationDbContext dbContext) : base(dbContext)
+    public EmailChannelUsageRepository(NotificationDbContext dbContext) : base(dbContext)
    {
    }

    public async Task<int> GetDailyCountAsync(Guid providerId, DateOnly date, CancellationToken ct = default)
    {
-        ProviderUsageEntity? entity = await DbSet
+        EmailChannelUsageEntity? entity = await DbSet
            .FirstOrDefaultAsync(x => x.ProviderId == providerId && x.Date == date, ct);

        return entity?.SentCount ?? 0;
@@ -28,18 +28,17 @@ internal sealed class ProviderUsageRepository : EfRepository<ProviderUsageEntity
            .SumAsync(x => x.SentCount, ct);
    }

-    public async Task IncrementAsync(Guid providerId, DateOnly date, CancellationToken ct = default)
+    public async Task IncrementUsageAsync(Guid providerId, DateOnly date, CancellationToken ct = default)
    {
-        DateTimeOffset now = DateTimeOffset.UtcNow;
+        EmailChannelUsageEntity? entity = await DbSet
+            .FirstOrDefaultAsync(x => x.ProviderId == providerId && x.Date == date, ct);

-        // Atomic upsert: insert with count=1 or increment existing count.
-        await DbContext.Database.ExecuteSqlAsync(
-            $"""
-             INSERT INTO provider_usage (id, provider_id, date, sent_count, created)
-             VALUES ({Guid.NewGuid()}, {providerId}, {date}, 1, {now})
-             ON CONFLICT (provider_id, date) DO UPDATE SET
-                 sent_count = provider_usage.sent_count + 1,
-                 updated    = {now}
-             """, ct);
+        if (entity is null)
+            await AddAsync(new EmailChannelUsageEntity { ProviderId = providerId, Date = date, SentCount = 1 }, ct);
+        else
+        {
+            entity.SentCount++;
+            Update(entity);
+        }
    }
-}
+}
@@ -0,0 +1,77 @@
+using HrynCo.NotificationService.DAL.Abstract.Repositories;
+using HrynCo.NotificationService.DAL.Abstract.Templates;
+using HrynCo.NotificationService.DAL.EF.Core;
+using HrynCo.NotificationService.DAL.EF.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace HrynCo.NotificationService.DAL.EF.Repositories;
+
+internal sealed class EmailTemplateRepository : EfRepository<EmailTemplateEntity>, IEmailEmailTemplateRepository
+{
+    public EmailTemplateRepository(NotificationDbContext dbContext) : base(dbContext)
+    {
+    }
+
+    public async Task<IReadOnlyList<EmailTemplate>> GetByServiceAsync(string serviceName, CancellationToken ct = default)
+    {
+        List<EmailTemplateEntity> entities = await DbSet
+            .Where(x => x.ServiceName == serviceName)
+            .ToListAsync(ct);
+
+        return entities.Select(MapToDomain).ToList();
+    }
+
+    public async Task<EmailTemplate?> GetAsync(string serviceName, string key, string languageCode, CancellationToken ct = default)
+    {
+        EmailTemplateEntity? entity = await DbSet.FirstOrDefaultAsync(
+            x => x.ServiceName == serviceName && x.Key == key && x.LanguageCode == languageCode, ct);
+
+        return entity is null ? null : MapToDomain(entity);
+    }
+
+    public Task AddAsync(EmailTemplate EmailTemplate, CancellationToken ct = default) =>
+        base.AddAsync(MapToEntity(EmailTemplate), ct);
+
+    public Task UpdateAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
+    {
+        EmailTemplateEntity entity = MapToEntity(EmailTemplate);
+        entity.Updated = DateTimeOffset.UtcNow;
+        Update(entity);
+        return Task.CompletedTask;
+    }
+
+    public async Task DeleteAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
+    {
+        EmailTemplateEntity? entity = await DbSet.FindAsync([EmailTemplate.Id], ct);
+        if (entity is not null)
+            Delete(entity);
+    }
+
+    private static EmailTemplate MapToDomain(EmailTemplateEntity e) => new()
+    {
+        Id = e.Id,
+        ServiceName = e.ServiceName,
+        Key = e.Key,
+        LanguageCode = e.LanguageCode,
+        Subject = e.Subject,
+        HtmlBody = e.HtmlBody,
+        TextBody = e.TextBody,
+        Variables = e.Variables.Select(v => new EmailTemplateVariable { Name = v.Name, Required = v.Required }).ToList(),
+        Created = e.Created,
+        Updated = e.Updated
+    };
+
+    private static EmailTemplateEntity MapToEntity(EmailTemplate t) => new()
+    {
+        Id = t.Id,
+        ServiceName = t.ServiceName,
+        Key = t.Key,
+        LanguageCode = t.LanguageCode,
+        Subject = t.Subject,
+        HtmlBody = t.HtmlBody,
+        TextBody = t.TextBody,
+        Variables = t.Variables.Select(v => new EmailTemplateVariableData { Name = v.Name, Required = v.Required }).ToList(),
+        Created = t.Created,
+        Updated = t.Updated
+    };
+}
@@ -1,85 +0,0 @@
-using System.Text.Json;
-using HrynCo.NotificationService.DAL.Abstract.Providers;
-using HrynCo.NotificationService.DAL.Abstract.Repositories;
-using HrynCo.NotificationService.DAL.EF.Core;
-using HrynCo.NotificationService.DAL.EF.Entities;
-using Microsoft.EntityFrameworkCore;
-
-namespace HrynCo.NotificationService.DAL.EF.Repositories;
-
-internal sealed class ProviderRepository : EfRepository<ProviderEntity>, IProviderRepository
-{
-    public ProviderRepository(NotificationDbContext dbContext) : base(dbContext)
-    {
-    }
-
-    public async Task<IReadOnlyList<Provider>> GetByServiceAsync(string serviceName, CancellationToken ct = default)
-    {
-        List<ProviderEntity> entities = await DbSet
-            .Where(x => x.ServiceName == serviceName)
-            .OrderBy(x => x.Priority)
-            .ToListAsync(ct);
-
-        return entities.Select(MapToDomain).ToList();
-    }
-
-    public async Task<Provider?> GetByIdAsync(Guid id, CancellationToken ct = default)
-    {
-        ProviderEntity? entity = await DbSet.FindAsync([id], ct);
-        return entity is null ? null : MapToDomain(entity);
-    }
-
-    public Task AddAsync(Provider provider, CancellationToken ct = default) =>
-        base.AddAsync(MapToEntity(provider), ct);
-
-    public Task UpdateAsync(Provider provider, CancellationToken ct = default)
-    {
-        ProviderEntity entity = MapToEntity(provider);
-        entity.Updated = DateTimeOffset.UtcNow;
-        return base.UpdateAsync(entity, ct);
-    }
-
-    public async Task DeleteAsync(Provider provider, CancellationToken ct = default)
-    {
-        ProviderEntity? entity = await DbSet.FindAsync([provider.Id], ct);
-        if (entity is not null)
-            await base.DeleteAsync(entity, ct);
-    }
-
-    private static Provider MapToDomain(ProviderEntity e) => new()
-    {
-        Id = e.Id,
-        ServiceName = e.ServiceName,
-        Priority = e.Priority,
-        ProviderType = e.ProviderType,
-        Settings = DeserializeSettings(e.ProviderType, e.SettingsJson),
-        DailyLimit = e.DailyLimit,
-        MonthlyLimit = e.MonthlyLimit,
-        WarnThresholdPercent = e.WarnThresholdPercent,
-        IsActive = e.IsActive,
-        Created = e.Created,
-        Updated = e.Updated
-    };
-
-    private static ProviderEntity MapToEntity(Provider p) => new()
-    {
-        Id = p.Id,
-        ServiceName = p.ServiceName,
-        Priority = p.Priority,
-        ProviderType = p.ProviderType,
-        SettingsJson = JsonSerializer.Serialize(p.Settings),
-        DailyLimit = p.DailyLimit,
-        MonthlyLimit = p.MonthlyLimit,
-        WarnThresholdPercent = p.WarnThresholdPercent,
-        IsActive = p.IsActive,
-        Created = p.Created,
-        Updated = p.Updated
-    };
-
-    private static ProviderSettings DeserializeSettings(ProviderType type, string json) => type switch
-    {
-        ProviderType.Smtp => JsonSerializer.Deserialize<SmtpProviderSettings>(json)
-            ?? throw new InvalidOperationException("Failed to deserialize SMTP provider settings."),
-        _ => throw new InvalidOperationException($"Unknown provider type: {type}")
-    };
-}
@@ -1,76 +0,0 @@
-using HrynCo.NotificationService.DAL.Abstract.Repositories;
-using HrynCo.NotificationService.DAL.Abstract.Templates;
-using HrynCo.NotificationService.DAL.EF.Core;
-using HrynCo.NotificationService.DAL.EF.Entities;
-using Microsoft.EntityFrameworkCore;
-
-namespace HrynCo.NotificationService.DAL.EF.Repositories;
-
-internal sealed class TemplateRepository : EfRepository<TemplateEntity>, ITemplateRepository
-{
-    public TemplateRepository(NotificationDbContext dbContext) : base(dbContext)
-    {
-    }
-
-    public async Task<IReadOnlyList<Template>> GetByServiceAsync(string serviceName, CancellationToken ct = default)
-    {
-        List<TemplateEntity> entities = await DbSet
-            .Where(x => x.ServiceName == serviceName)
-            .ToListAsync(ct);
-
-        return entities.Select(MapToDomain).ToList();
-    }
-
-    public async Task<Template?> GetAsync(string serviceName, string key, string languageCode, CancellationToken ct = default)
-    {
-        TemplateEntity? entity = await DbSet.FirstOrDefaultAsync(
-            x => x.ServiceName == serviceName && x.Key == key && x.LanguageCode == languageCode, ct);
-
-        return entity is null ? null : MapToDomain(entity);
-    }
-
-    public Task AddAsync(Template template, CancellationToken ct = default) =>
-        base.AddAsync(MapToEntity(template), ct);
-
-    public Task UpdateAsync(Template template, CancellationToken ct = default)
-    {
-        TemplateEntity entity = MapToEntity(template);
-        entity.Updated = DateTimeOffset.UtcNow;
-        return base.UpdateAsync(entity, ct);
-    }
-
-    public async Task DeleteAsync(Template template, CancellationToken ct = default)
-    {
-        TemplateEntity? entity = await DbSet.FindAsync([template.Id], ct);
-        if (entity is not null)
-            await base.DeleteAsync(entity, ct);
-    }
-
-    private static Template MapToDomain(TemplateEntity e) => new()
-    {
-        Id = e.Id,
-        ServiceName = e.ServiceName,
-        Key = e.Key,
-        LanguageCode = e.LanguageCode,
-        Subject = e.Subject,
-        HtmlBody = e.HtmlBody,
-        TextBody = e.TextBody,
-        Variables = e.Variables.Select(v => new TemplateVariable { Name = v.Name, Required = v.Required }).ToList(),
-        Created = e.Created,
-        Updated = e.Updated
-    };
-
-    private static TemplateEntity MapToEntity(Template t) => new()
-    {
-        Id = t.Id,
-        ServiceName = t.ServiceName,
-        Key = t.Key,
-        LanguageCode = t.LanguageCode,
-        Subject = t.Subject,
-        HtmlBody = t.HtmlBody,
-        TextBody = t.TextBody,
-        Variables = t.Variables.Select(v => new TemplateVariableData { Name = v.Name, Required = v.Required }).ToList(),
-        Created = t.Created,
-        Updated = t.Updated
-    };
-}