hrynco-notification-service/HrynCo.NotificationService.DAL.EF/Repositories/EmailTemplateRepository.cs

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
    : NotificationBaseRepository<EmailTemplateEntity>, IEmailTemplateRepository
{
    public EmailTemplateRepository(NotificationDbContext dbContext) : base(dbContext)
    {
    }

    public async Task<IReadOnlyList<EmailTemplate>> GetAllAsync(CancellationToken ct = default)
    {
        List<EmailTemplateEntity> entities = await EfRepository.Get()
            .AsNoTracking()
            .ToListAsync(ct);
        return entities.Select(MapToDomain).ToList();
    }

    public async Task<IReadOnlyList<EmailTemplate>> GetByServiceAsync(string serviceName, CancellationToken ct = default)
    {
        List<EmailTemplateEntity> entities = await EfRepository.Get()
            .AsNoTracking()
            .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 EfRepository.Get()
            .AsNoTracking()
            .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)
    {
        return EfRepository.AddAsync(MapToEntity(EmailTemplate));
    }

    public async Task UpdateAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
    {
        EmailTemplateEntity? entity = await EfRepository.Get()
            .FirstOrDefaultAsync(x => x.Id == EmailTemplate.Id, ct);

        if (entity is null)
        {
            return;
        }

        entity.ServiceName = EmailTemplate.ServiceName;
        entity.Key = EmailTemplate.Key;
        entity.LanguageCode = EmailTemplate.LanguageCode;
        entity.Subject = EmailTemplate.Subject;
        entity.HtmlBody = EmailTemplate.HtmlBody;
        entity.TextBody = EmailTemplate.TextBody;
        entity.Variables = EmailTemplate.Variables
            .Select(v => new EmailTemplateVariableData { Name = v.Name, Required = v.Required })
            .ToList();

        await EfRepository.SaveChangesAsync();
    }

    public async Task DeleteAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
    {
        EmailTemplateEntity? entity = await EfRepository.Get()
            .FirstOrDefaultAsync(x => x.Id == EmailTemplate.Id, ct);
        if (entity is not null)
            await EfRepository.DeleteAsync(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
    };
}