feat(templates): add service language template management
Add normalized service and template catalogs, scoped administration, migration, validation, and regression coverage. Ref: IT-1601
This commit is contained in:
@@ -1,120 +1,232 @@
|
||||
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
|
||||
internal sealed class EmailTemplateRepository(NotificationDbContext db, TemplateMutationRunner mutations)
|
||||
: IEmailTemplateRepository, IEmailTemplateDefinitionRepository
|
||||
{
|
||||
public EmailTemplateRepository(NotificationDbContext dbContext) : base(dbContext)
|
||||
{
|
||||
}
|
||||
private IQueryable<EmailTemplateEntity> Languages => db.Templates
|
||||
.Include(t => t.Definition).ThenInclude(d => d.Service).Include(t => t.ServiceLanguage);
|
||||
private IQueryable<EmailTemplateDefinitionEntity> Definitions => db.TemplateDefinitions
|
||||
.Include(d => d.Service).ThenInclude(s => s.Languages)
|
||||
.Include(d => d.Languages).ThenInclude(t => t.ServiceLanguage);
|
||||
|
||||
public async Task<IReadOnlyList<EmailTemplate>> GetAllAsync(string? serviceName = null, string? key = null, CancellationToken ct = default)
|
||||
{
|
||||
IQueryable<EmailTemplateEntity> query = EfRepository.Get();
|
||||
|
||||
var query = Languages.AsNoTracking();
|
||||
if (!string.IsNullOrWhiteSpace(serviceName))
|
||||
{
|
||||
query = query.Where(x => x.ServiceName == serviceName);
|
||||
}
|
||||
|
||||
query = query.Where(t => t.Definition.Service.Name == serviceName);
|
||||
if (!string.IsNullOrWhiteSpace(key))
|
||||
{
|
||||
query = query.Where(x => x.Key == key);
|
||||
}
|
||||
|
||||
List<EmailTemplateEntity> entities = await query
|
||||
.OrderBy(x => x.ServiceName).ThenBy(x => x.Key)
|
||||
.AsNoTracking()
|
||||
.ToListAsync(ct);
|
||||
return entities.Select(MapToDomain).ToList();
|
||||
query = query.Where(t => t.Definition.Key == key);
|
||||
var entities = await query.OrderBy(t => t.Definition.Service.Name).ThenBy(t => t.Definition.Key)
|
||||
.ThenBy(t => t.ServiceLanguage.Code).ToListAsync(ct);
|
||||
return entities.Select(MapLanguage).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 Task<IReadOnlyList<EmailTemplate>> GetByServiceAsync(string serviceName, CancellationToken ct = default) =>
|
||||
GetAllAsync(serviceName, ct: ct);
|
||||
|
||||
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);
|
||||
var code = languageCode;
|
||||
var entity = await Languages.AsNoTracking().SingleOrDefaultAsync(t =>
|
||||
t.Definition.Service.Name == serviceName && t.Definition.Key == key && t.ServiceLanguage.Code == code, ct);
|
||||
return entity is null ? null : MapLanguage(entity);
|
||||
}
|
||||
|
||||
public Task AddAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
|
||||
public async Task<EmailTemplateDefinition?> GetDefinitionAsync(string serviceName, string key, CancellationToken ct = default)
|
||||
{
|
||||
return EfRepository.AddAsync(MapToEntity(EmailTemplate));
|
||||
var entity = await Definitions.AsNoTracking().SingleOrDefaultAsync(d => d.Service.Name == serviceName && d.Key == key, ct);
|
||||
return entity is null ? null : MapDefinition(entity);
|
||||
}
|
||||
|
||||
public async Task UpdateAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
|
||||
public Task AddAsync(EmailTemplate template, CancellationToken ct = default) => mutations.ExecuteAsync(async () =>
|
||||
{
|
||||
EmailTemplateEntity? entity = await EfRepository.Get()
|
||||
.FirstOrDefaultAsync(x => x.Id == EmailTemplate.Id, ct);
|
||||
|
||||
if (entity is null)
|
||||
ValidateLegacy(template);
|
||||
var definition = await FindDefinitionAsync(template.ServiceName, template.Key, ct);
|
||||
if (definition is null)
|
||||
{
|
||||
return;
|
||||
await RequireServiceLanguageAsync(template.ServiceName, template.LanguageCode, ct);
|
||||
definition = await CreateDefinitionAsync(template.ServiceName, template.Key, template.Variables, ct);
|
||||
}
|
||||
EnsureMatchingContract(definition, template.Variables);
|
||||
await RequireServiceLanguageAsync(template.ServiceName, template.LanguageCode, ct);
|
||||
var code = template.LanguageCode;
|
||||
if (definition.Languages.Any(t => t.ServiceLanguage.Code == code))
|
||||
throw new EmailTemplateWriteException("This language already exists for the template.");
|
||||
var language = NewLanguage(template, definition);
|
||||
definition.Languages.Add(language);
|
||||
db.Templates.Add(language);
|
||||
Touch(definition);
|
||||
}, ct);
|
||||
|
||||
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();
|
||||
public Task UpdateAsync(EmailTemplate template, CancellationToken ct = default) => mutations.ExecuteAsync(async () =>
|
||||
{
|
||||
ValidateLegacy(template);
|
||||
var definition = await RequireDefinitionAsync(template.ServiceName, template.Key, ct);
|
||||
EnsureMatchingContract(definition, template.Variables);
|
||||
var language = definition.Languages.SingleOrDefault(t => t.Id == template.Id)
|
||||
?? throw new EmailTemplateWriteException("The language changed or was removed. Reload the template.");
|
||||
SetContent(language, template);
|
||||
Touch(definition);
|
||||
}, ct);
|
||||
|
||||
await EfRepository.SaveChangesAsync();
|
||||
public Task DeleteAsync(EmailTemplate template, CancellationToken ct = default) => mutations.ExecuteAsync(async () =>
|
||||
{
|
||||
var definition = await RequireDefinitionAsync(template.ServiceName, template.Key, ct);
|
||||
var language = definition.Languages.SingleOrDefault(t => t.Id == template.Id)
|
||||
?? throw new EmailTemplateWriteException("The language changed or was removed. Reload the template.");
|
||||
db.Templates.Remove(language);
|
||||
Touch(definition);
|
||||
}, ct);
|
||||
|
||||
public Task SaveDefinitionAsync(EmailTemplateDefinition definition, bool isNew, CancellationToken ct = default) => mutations.ExecuteAsync(async () =>
|
||||
{
|
||||
EmailTemplateValidation.ValidateDefinition(definition);
|
||||
await ValidateServiceLanguagesAsync(definition, ct);
|
||||
var entity = await LoadForSaveAsync(definition, isNew, ct);
|
||||
entity.Variables = MapVariables(definition.Variables);
|
||||
SynchronizeLanguages(entity, definition.Languages);
|
||||
Touch(entity);
|
||||
definition.Id = entity.Id;
|
||||
definition.Revision = entity.Revision;
|
||||
}, ct);
|
||||
|
||||
private async Task<EmailTemplateDefinitionEntity> LoadForSaveAsync(EmailTemplateDefinition model, bool isNew, CancellationToken ct)
|
||||
{
|
||||
var entity = await FindDefinitionAsync(model.ServiceName, model.Key, ct);
|
||||
if (isNew)
|
||||
{
|
||||
if (entity is not null)
|
||||
throw new EmailTemplateWriteException("A template with this service and key already exists.");
|
||||
return await CreateDefinitionAsync(model.ServiceName, model.Key, model.Variables, ct);
|
||||
}
|
||||
if (entity is null || entity.Id != model.Id || entity.Revision != model.Revision)
|
||||
throw new EmailTemplateWriteException("This template changed after you opened it. Reload before saving; your entered values are retained.");
|
||||
return entity;
|
||||
}
|
||||
|
||||
public async Task DeleteAsync(EmailTemplate EmailTemplate, CancellationToken ct = default)
|
||||
private void SynchronizeLanguages(EmailTemplateDefinitionEntity definition, IReadOnlyList<EmailTemplate> languages)
|
||||
{
|
||||
EmailTemplateEntity? entity = await EfRepository.Get()
|
||||
.FirstOrDefaultAsync(x => x.Id == EmailTemplate.Id, ct);
|
||||
if (entity is not null)
|
||||
await EfRepository.DeleteAsync(entity);
|
||||
var codes = languages.Select(t => t.LanguageCode).ToHashSet(StringComparer.Ordinal);
|
||||
db.Templates.RemoveRange(definition.Languages.Where(t => !codes.Contains(t.ServiceLanguage.Code)));
|
||||
foreach (var model in languages)
|
||||
{
|
||||
var code = model.LanguageCode;
|
||||
var entity = definition.Languages.SingleOrDefault(t => t.ServiceLanguage.Code == code);
|
||||
if (entity is null)
|
||||
{
|
||||
var language = NewLanguage(model, definition);
|
||||
definition.Languages.Add(language);
|
||||
db.Templates.Add(language);
|
||||
}
|
||||
else
|
||||
SetContent(entity, model);
|
||||
}
|
||||
}
|
||||
|
||||
private static EmailTemplate MapToDomain(EmailTemplateEntity e) => new()
|
||||
public async Task<IReadOnlyList<EmailTemplateDefinition>> GetDefinitionsAsync(string? serviceName = null, string? key = null, CancellationToken ct = default)
|
||||
{
|
||||
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
|
||||
var query = Definitions.AsNoTracking();
|
||||
if (!string.IsNullOrWhiteSpace(serviceName))
|
||||
query = query.Where(d => d.Service.Name == serviceName);
|
||||
if (!string.IsNullOrWhiteSpace(key))
|
||||
query = query.Where(d => d.Key == key);
|
||||
var entities = await query.OrderBy(d => d.Service.Name).ThenBy(d => d.Key).ToListAsync(ct);
|
||||
return entities.Select(MapDefinition).ToList();
|
||||
}
|
||||
|
||||
private async Task RequireServiceLanguageAsync(string serviceName, string code, CancellationToken ct)
|
||||
{
|
||||
if (!await db.ServiceLanguages.AnyAsync(l => l.Service.Name == serviceName && l.Code == code, ct))
|
||||
throw new EmailTemplateWriteException("Language is not in this service's catalog. Add it in the service editor first.", false);
|
||||
}
|
||||
|
||||
private async Task ValidateServiceLanguagesAsync(EmailTemplateDefinition definition, CancellationToken ct)
|
||||
{
|
||||
var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Name == definition.ServiceName
|
||||
&& (definition.ServiceId == Guid.Empty || s.Id == definition.ServiceId), ct)
|
||||
?? throw new EmailTemplateWriteException("Service does not exist. Create the service first.", false);
|
||||
var codes = service.Languages.Select(l => l.Code).ToHashSet(StringComparer.Ordinal);
|
||||
if (definition.Languages.Any(l => !codes.Contains(l.LanguageCode)))
|
||||
throw new EmailTemplateWriteException("Language is not in this service's catalog. Add it in the service editor first.", false);
|
||||
}
|
||||
|
||||
private Task<EmailTemplateDefinitionEntity?> FindDefinitionAsync(string serviceName, string key, CancellationToken ct) =>
|
||||
Definitions.SingleOrDefaultAsync(d => d.Service.Name == serviceName && d.Key == key, ct);
|
||||
|
||||
private async Task<EmailTemplateDefinitionEntity> RequireDefinitionAsync(string serviceName, string key, CancellationToken ct) =>
|
||||
await FindDefinitionAsync(serviceName, key, ct)
|
||||
?? throw new EmailTemplateWriteException("The template was removed. Reload the template list.");
|
||||
|
||||
private async Task<EmailTemplateDefinitionEntity> CreateDefinitionAsync(string serviceName, string key,
|
||||
IReadOnlyList<EmailTemplateVariable> variables, CancellationToken ct)
|
||||
{
|
||||
var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Name == serviceName, ct)
|
||||
?? throw new EmailTemplateWriteException("Service does not exist. Create the service and its language codes first.", false);
|
||||
var entity = new EmailTemplateDefinitionEntity
|
||||
{
|
||||
Service = service, Key = key, Variables = MapVariables(variables), Created = DateTimeOffset.UtcNow
|
||||
};
|
||||
db.TemplateDefinitions.Add(entity);
|
||||
return entity;
|
||||
}
|
||||
|
||||
private static void ValidateLegacy(EmailTemplate template)
|
||||
{
|
||||
EmailTemplateValidation.ValidateIdentity(template.ServiceName, template.Key);
|
||||
EmailTemplateValidation.ValidateLanguage(template);
|
||||
EmailTemplateValidation.ValidateVariables(template.Variables);
|
||||
}
|
||||
|
||||
private static void EnsureMatchingContract(EmailTemplateDefinitionEntity definition, IReadOnlyList<EmailTemplateVariable> variables)
|
||||
{
|
||||
var shared = definition.Variables.Select(v => new EmailTemplateVariable { Name = v.Name, Required = v.Required }).ToList();
|
||||
if (!EmailTemplateValidation.ContractsEqual(shared, variables))
|
||||
throw new EmailTemplateWriteException("Variables conflict with the shared template contract. Edit shared variables in the template editor.");
|
||||
}
|
||||
|
||||
private static void Touch(EmailTemplateDefinitionEntity definition)
|
||||
{
|
||||
definition.Revision = Guid.NewGuid();
|
||||
definition.Updated = DateTimeOffset.UtcNow;
|
||||
}
|
||||
|
||||
private static List<EmailTemplateVariableData> MapVariables(IReadOnlyList<EmailTemplateVariable> variables) =>
|
||||
variables.Select(v => new EmailTemplateVariableData { Name = v.Name, Required = v.Required }).ToList();
|
||||
|
||||
private static EmailTemplateEntity NewLanguage(EmailTemplate model, EmailTemplateDefinitionEntity definition) => new()
|
||||
{
|
||||
Id = model.Id, Definition = definition, ServiceId = definition.Service.Id,
|
||||
ServiceLanguage = definition.Service.Languages.SingleOrDefault(l => l.Code == model.LanguageCode)
|
||||
?? throw new EmailTemplateWriteException("Language is not in this service's catalog. Add it in the service editor first.", false),
|
||||
Subject = model.Subject, HtmlBody = model.HtmlBody, TextBody = model.TextBody, Created = model.Created
|
||||
};
|
||||
|
||||
private static EmailTemplateEntity MapToEntity(EmailTemplate t) => new()
|
||||
private static void SetContent(EmailTemplateEntity entity, EmailTemplate model)
|
||||
{
|
||||
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
|
||||
entity.Subject = model.Subject;
|
||||
entity.HtmlBody = model.HtmlBody;
|
||||
entity.TextBody = model.TextBody;
|
||||
entity.Updated = DateTimeOffset.UtcNow;
|
||||
}
|
||||
|
||||
private static EmailTemplate MapLanguage(EmailTemplateEntity entity) => new()
|
||||
{
|
||||
Id = entity.Id, ServiceName = entity.Definition.Service.Name, Key = entity.Definition.Key,
|
||||
LanguageCode = entity.ServiceLanguage.Code, Subject = entity.Subject, HtmlBody = entity.HtmlBody, TextBody = entity.TextBody,
|
||||
Variables = entity.Definition.Variables.Select(v => new EmailTemplateVariable { Name = v.Name, Required = v.Required }).ToList(),
|
||||
Created = entity.Created, Updated = entity.Updated
|
||||
};
|
||||
|
||||
private static EmailTemplateDefinition MapDefinition(EmailTemplateDefinitionEntity entity) => new()
|
||||
{
|
||||
Id = entity.Id, ServiceId = entity.ServiceId, ServiceName = entity.Service.Name, Key = entity.Key, Revision = entity.Revision,
|
||||
Variables = entity.Variables.Select(v => new EmailTemplateVariable { Name = v.Name, Required = v.Required }).ToList(),
|
||||
Languages = entity.Languages.OrderBy(t => t.ServiceLanguage.Code).Select(MapLanguage).ToList(),
|
||||
Created = entity.Created, Updated = entity.Updated
|
||||
};
|
||||
}
|
||||
|
||||
@@ -0,0 +1,188 @@
|
||||
using HrynCo.NotificationService.DAL.Abstract.Repositories;
|
||||
using HrynCo.NotificationService.DAL.Abstract.Templates;
|
||||
using HrynCo.NotificationService.DAL.EF.Entities;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace HrynCo.NotificationService.DAL.EF.Repositories;
|
||||
|
||||
internal sealed class NotificationServiceRepository(NotificationDbContext db, TemplateMutationRunner mutations) : INotificationServiceRepository
|
||||
{
|
||||
public async Task<IReadOnlyList<NotificationServiceInfo>> GetAllAsync(CancellationToken ct = default)
|
||||
{
|
||||
var services = await db.Services.AsNoTracking().Include(s => s.Languages).OrderBy(s => s.Name).ToListAsync(ct);
|
||||
var counts = await VersionCountsAsync(ct);
|
||||
return services.Select(s => Map(s, counts)).ToList();
|
||||
}
|
||||
|
||||
public async Task<NotificationServiceInfo?> GetAsync(Guid id, CancellationToken ct = default)
|
||||
{
|
||||
var service = await db.Services.AsNoTracking().Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == id, ct);
|
||||
return service is null ? null : Map(service, await VersionCountsAsync(ct));
|
||||
}
|
||||
|
||||
public Task SaveAsync(NotificationServiceInfo model, bool isNew, CancellationToken ct = default) => mutations.ExecuteAsync(async () =>
|
||||
{
|
||||
Validate(model);
|
||||
var service = await LoadForSaveAsync(model, isNew, ct);
|
||||
await ValidateLanguageChangesAsync(service, model, ct);
|
||||
await StageLanguageCodeChangesAsync(service, model.Languages, ct);
|
||||
service.Name = model.Name;
|
||||
SynchronizeLanguages(service, model.Languages);
|
||||
Touch(service);
|
||||
await TouchDefinitionsAsync(service.Id, ct);
|
||||
model.Id = service.Id;
|
||||
model.Revision = service.Revision;
|
||||
}, ct);
|
||||
|
||||
public Task RemoveLanguageAsync(Guid serviceId, Guid languageId, int expectedVersionCount, Guid expectedRevision, CancellationToken ct = default) =>
|
||||
mutations.ExecuteAsync(async () =>
|
||||
{
|
||||
var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == serviceId, ct)
|
||||
?? throw new EmailTemplateWriteException("Service no longer exists. Reload services.");
|
||||
var language = service.Languages.SingleOrDefault(l => l.Id == languageId)
|
||||
?? throw new EmailTemplateWriteException("Language no longer exists. Reload the service.");
|
||||
var versions = await db.Templates.Where(t => t.ServiceLanguageId == languageId).ToListAsync(ct);
|
||||
if (service.Revision != expectedRevision || versions.Count != expectedVersionCount)
|
||||
throw new EmailTemplateWriteException("The service or affected version count changed. Review the current count and confirm again.");
|
||||
db.Templates.RemoveRange(versions);
|
||||
// Save dependent removals first because language deletion is restricted by its FK.
|
||||
await db.SaveChangesAsync(ct);
|
||||
db.ServiceLanguages.Remove(language);
|
||||
Touch(service);
|
||||
await TouchDefinitionsAsync(serviceId, ct);
|
||||
}, ct);
|
||||
|
||||
private async Task<ServiceEntity> LoadForSaveAsync(NotificationServiceInfo model, bool isNew, CancellationToken ct)
|
||||
{
|
||||
if (await db.Services.AnyAsync(s => s.Name == model.Name && s.Id != model.Id, ct))
|
||||
throw new EmailTemplateWriteException("A service with this name already exists.");
|
||||
if (isNew)
|
||||
{
|
||||
var created = new ServiceEntity { Name = model.Name, Created = DateTimeOffset.UtcNow };
|
||||
db.Services.Add(created);
|
||||
return created;
|
||||
}
|
||||
var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == model.Id, ct);
|
||||
if (service is null || service.Revision != model.Revision)
|
||||
throw new EmailTemplateWriteException("This service changed after you opened it. Reload before saving.");
|
||||
return service;
|
||||
}
|
||||
|
||||
private async Task ValidateLanguageChangesAsync(ServiceEntity service, NotificationServiceInfo model, CancellationToken ct)
|
||||
{
|
||||
var ids = service.Languages.Select(l => l.Id).ToHashSet();
|
||||
if (model.Languages.Any(l => l.Id != Guid.Empty && !ids.Contains(l.Id)))
|
||||
throw new EmailTemplateWriteException("A language changed or was removed. Reload the service.");
|
||||
ValidateChangedCodes(service, model.Languages);
|
||||
var retained = model.Languages.Select(l => l.Id).ToHashSet();
|
||||
var removed = service.Languages.Where(l => !retained.Contains(l.Id)).ToList();
|
||||
foreach (var language in removed)
|
||||
{
|
||||
var count = await db.Templates.CountAsync(t => t.ServiceLanguageId == language.Id, ct);
|
||||
if (count > 0)
|
||||
throw new EmailTemplateWriteException($"Cannot remove language '{language.Code}': {count} version(s) use it. Use the separate delete-with-versions confirmation.");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task StageLanguageCodeChangesAsync(ServiceEntity service, IReadOnlyList<ServiceLanguageInfo> languages, CancellationToken ct)
|
||||
{
|
||||
var requested = languages.Where(l => l.Id != Guid.Empty).ToDictionary(l => l.Id, l => l.Code);
|
||||
var removed = service.Languages.Where(l => !requested.ContainsKey(l.Id)).ToList();
|
||||
var changed = service.Languages.Where(l => requested.TryGetValue(l.Id, out var code) && code != l.Code).ToList();
|
||||
if (removed.Count == 0 && changed.Count == 0)
|
||||
return;
|
||||
foreach (var language in removed)
|
||||
{
|
||||
db.ServiceLanguages.Remove(language);
|
||||
service.Languages.Remove(language);
|
||||
}
|
||||
var reserved = service.Languages.Select(l => l.Code).Concat(languages.Select(l => l.Code)).ToHashSet(StringComparer.Ordinal);
|
||||
foreach (var language in changed)
|
||||
language.Code = TemporaryCode(reserved);
|
||||
// Free old codes before final assignments, supporting swaps and replacing unused rows.
|
||||
// These temporary identifiers remain invisible outside this transaction.
|
||||
await db.SaveChangesAsync(ct);
|
||||
}
|
||||
|
||||
private static string TemporaryCode(HashSet<string> reserved)
|
||||
{
|
||||
string code;
|
||||
do { code = "~" + Guid.NewGuid().ToString("N")[..9]; }
|
||||
while (!reserved.Add(code));
|
||||
return code;
|
||||
}
|
||||
|
||||
private void SynchronizeLanguages(ServiceEntity service, IReadOnlyList<ServiceLanguageInfo> languages)
|
||||
{
|
||||
var retained = languages.Select(l => l.Id).ToHashSet();
|
||||
db.ServiceLanguages.RemoveRange(service.Languages.Where(l => !retained.Contains(l.Id)));
|
||||
foreach (var model in languages)
|
||||
{
|
||||
var entity = service.Languages.SingleOrDefault(l => l.Id == model.Id);
|
||||
if (entity is null)
|
||||
db.ServiceLanguages.Add(new ServiceLanguageEntity { Service = service, Code = model.Code, Created = DateTimeOffset.UtcNow });
|
||||
else
|
||||
entity.Code = model.Code;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task TouchDefinitionsAsync(Guid serviceId, CancellationToken ct)
|
||||
{
|
||||
var definitions = await db.TemplateDefinitions.Where(d => d.ServiceId == serviceId).ToListAsync(ct);
|
||||
foreach (var definition in definitions)
|
||||
{
|
||||
definition.Revision = Guid.NewGuid();
|
||||
definition.Updated = DateTimeOffset.UtcNow;
|
||||
}
|
||||
}
|
||||
|
||||
private Task<Dictionary<Guid, int>> VersionCountsAsync(CancellationToken ct) => db.Templates.AsNoTracking()
|
||||
.GroupBy(t => t.ServiceLanguageId).Select(g => new { Id = g.Key, Count = g.Count() })
|
||||
.ToDictionaryAsync(g => g.Id, g => g.Count, ct);
|
||||
|
||||
private static void Validate(NotificationServiceInfo service)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(service.Name) || service.Name.Length > 100)
|
||||
throw new EmailTemplateWriteException("Service name is required and must be at most 100 characters.", false);
|
||||
foreach (var language in service.Languages)
|
||||
ValidateCode(language.Code);
|
||||
if (service.Languages.Select(l => l.Code).Distinct(StringComparer.Ordinal).Count() != service.Languages.Count)
|
||||
throw new EmailTemplateWriteException("Language codes must be unique within the service.", false);
|
||||
var ids = service.Languages.Where(l => l.Id != Guid.Empty).Select(l => l.Id).ToList();
|
||||
if (ids.Distinct().Count() != ids.Count)
|
||||
throw new EmailTemplateWriteException("Each service language can appear only once.", false);
|
||||
}
|
||||
|
||||
private static void ValidateCode(string code)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(code) || code.Length > 10)
|
||||
throw new EmailTemplateWriteException("Language codes are required and must be at most 10 characters.", false);
|
||||
}
|
||||
|
||||
private static void ValidateChangedCodes(ServiceEntity service, IReadOnlyList<ServiceLanguageInfo> languages)
|
||||
{
|
||||
var persisted = service.Languages.ToDictionary(l => l.Id, l => l.Code);
|
||||
foreach (var language in languages)
|
||||
{
|
||||
if (persisted.TryGetValue(language.Id, out var original) && original == language.Code)
|
||||
continue;
|
||||
if (!System.Text.RegularExpressions.Regex.IsMatch(language.Code, "^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$"))
|
||||
throw new EmailTemplateWriteException("Use letters, numbers and hyphens in new or renamed language codes, without spaces. Codes are case-sensitive.", false);
|
||||
}
|
||||
}
|
||||
|
||||
private static void Touch(ServiceEntity service)
|
||||
{
|
||||
service.Revision = Guid.NewGuid();
|
||||
service.Updated = DateTimeOffset.UtcNow;
|
||||
}
|
||||
|
||||
private static NotificationServiceInfo Map(ServiceEntity service, IReadOnlyDictionary<Guid, int> counts) => new()
|
||||
{
|
||||
Id = service.Id, Name = service.Name, Revision = service.Revision,
|
||||
Languages = service.Languages.OrderBy(l => l.Code).Select(l => new ServiceLanguageInfo
|
||||
{
|
||||
Id = l.Id, Code = l.Code, VersionCount = counts.GetValueOrDefault(l.Id)
|
||||
}).ToList()
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user