feat(templateMatcher): refactoring

PARR.TemplateMatcher/Services/Implemetaions/SimpleTemplateSynchronizer.cs

@@ -4,25 +4,25 @@ using PARR.BLL.Domain.Mq;
 using PARR.BLL.Services.Interfaces;
 using PARR.Common.Domain;
 using PARR.Constants;
-using PARR.DAL.Contracts;
 using PARR.DAL.DomainServices.Interfaces;
 using PARR.DAL.DomainServices.Shortcodes;
-using PARR.DAL.DomainServices.Shortcodes.Models;
-using PARR.DAL.Models;
 using PARR.DAL.Models.Job;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.Services.Interfaces.Job;
+using PARR.DAL.Services.Interfaces.Unit;
 using PARR.DAL.TransformServices;
 using PARR.TemplateMatcher.Services.Interfaces;
 using PARR.TemplateMatcher.Settings;
 using System.Text.Json;
 
-namespace PARR.TemplateMatcher.Services.Implemetaions;
+namespace PARR.TemplateMatcher.Services.Implementations;
 
 internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
 {
-    private const bool DefaultUnusedTemplateState = false;
-    private const bool DefaultUnusedScheduleState = false;
+#if DEBUG
+    private readonly Guid targetUnitId = Guid.Parse("358437ac-1eeb-4c00-840c-998326f657ac");
+#endif
+
     private const bool DefaultUsedTemplateState = false;
     private const bool DefaultUsedScheduleState = false;
 
@@ -33,19 +33,30 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
     private readonly ITemplateService templateService;
     private readonly IJobService jobService;
     private readonly ITemplateReuser templateReuser;
-    private readonly IShortcodesService shortcodesService;
     private readonly IEsppScheduleTransformService esppScheduleTransformService;
+    private readonly ITemplateDeactivator templateDeactivator;
+    private readonly ITemplateNameNormalizer templateNameNormalizer;
+    private readonly ITemplateUpdaterMqSender templateUpdaterMqSender;
 
     public SimpleTemplateSynchronizer(
         ILogger<SimpleTemplateSynchronizer> logger,
         IUnitFilterService unitFilterService,
+        IUnitInUnitService unitInUnitService,
+        IUnitInValueService unitInValueService,
+        IUnitService unitService,
         MqSettings mqSettings,
         IMqService mqService,
         ITemplateService templateService,
         IJobService jobService,
         ITemplateReuser templateReuser,
         IShortcodesService shortcodesService,
-        IEsppScheduleTransformService esppScheduleTransformService)
+        IEsppScheduleTransformService esppScheduleTransformService,
+        IUnitRegionalEkPtkGroupService regionalEkPtkGroupService,
+        IUnitFieldService unitFieldService,
+        ITemplateDeactivator templateDeactivator,
+        ITemplateNameNormalizer templateNameNormalizer,
+        ITemplateUpdaterMqSender templateUpdaterMqSender
+        )
     {
         this.logger = logger;
         this.unitFilterService = unitFilterService;
@@ -54,120 +65,82 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
         this.templateService = templateService;
         this.jobService = jobService;
         this.templateReuser = templateReuser;
-        this.shortcodesService = shortcodesService;
         this.esppScheduleTransformService = esppScheduleTransformService;
-    }
-
-    public async Task SyncTemplatesForJobGroupAsync(Guid jobGroupId, HistoryInitiator initiator)
-    {
-        logger.LogWarning("SimpleTemplateSynchronizer: SyncTemplatesForJobGroup вызван для JobGroupId {JobGroupId}. Это не поддерживаемая операция.", jobGroupId);
-        // Не делаем ничего
-        return;
+        this.templateDeactivator = templateDeactivator;
+        this.templateNameNormalizer = templateNameNormalizer;
+        this.templateUpdaterMqSender = templateUpdaterMqSender;
     }
 
     public async Task SyncTemplatesForJobAsync(Guid jobId, HistoryInitiator initiator)
     {
-        logger.LogDebug("Начало синхронизации шаблонов для JobId {JobId}", jobId);
+        logger.LogDebug("Начало синхронизации шаблонов для Job {JobId}", jobId);
 
-        // Загружаем заранее подготовленный Job (например, для неиспользуемых шаблонов)
-        var unusedJobId = Guid.Parse("8f85a91c-a223-4686-bb69-1f0ee73624f2");
-
-        var unusedJob = await jobService.Get()
+        var job = await jobService.Get()
             .AsNoTracking()
+            .Include(j => j.AutoControl)
             .Include(j => j.Tnk)
             .Include(j => j.Group)
-                .ThenInclude(g => g.GroupType)
-            .FirstOrDefaultAsync(j => j.Id == unusedJobId);
+                .ThenInclude(g => g!.GroupType)
+            .Include(j => j.UnitFilters)
+                .ThenInclude(uf => uf.RelationshipFilters)
+            .FirstOrDefaultAsync(j => j.Id == jobId);
 
-        var expectedUnitIds = await GetExpectedUnitIdsAsync(jobId) ?? new HashSet<Guid>();
-        logger.LogDebug("JobId {JobId}: найдено {Count} UnitId по фильтрам.", jobId, expectedUnitIds.Count);
-
-        var job = await GetJobWithGroupAndAutoControlAsync(jobId);
         if (job == null)
         {
-            logger.LogError("Job с Id {JobId} не найден.", jobId);
+            logger.LogWarning("Job {JobId} не найден.", jobId);
             return;
         }
 
-        // Проверяем, является ли Job "групповым"
-        bool isGroupJob = job.Group != null && job.Group.GroupType?.Code == JobGroupTypesEnum.Group;
-
-        if (isGroupJob && job.Group!.GroupingUnitFieldId.HasValue)
+        var unitIds = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
+        if (unitIds == null || !unitIds.Any())
         {
-            logger.LogInformation("Job {JobId} является групповым. Используйте SyncTemplatesForJobGroup для синхронизации.", jobId);
-            return; // Ничего не делаем для группового Job
+            logger.LogInformation("Для Job {JobId} фильтры не дали Unit'ов.", jobId);
+            return;
         }
 
+#if DEBUG
+        // ✅ Отладка: проверить, есть ли юнит в unitIds
+        if (unitIds.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в unitIds.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIds.", targetUnitId);
+            return; // ❌ юнит отсеялся на этом этапе
+        }
+#endif
+
         var existingTemplates = await templateService.Get()
             .AsNoTracking()
+            .Include(t => t.UnitsInTemplate)
             .Where(t => t.JobId == jobId)
             .ToListAsync();
 
-        logger.LogDebug("JobId {JobId}: {Expected} ожидаемых UnitId, {Existing} существующих шаблонов.",
-            jobId, expectedUnitIds.Count, existingTemplates.Count);
+        var existingUnitIds = existingTemplates
+            .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used)
+            .Select(t => t.UnitId)
+            .ToHashSet();
 
-        // Обработка случая: фильтр вернул 0 UnitId → деактивировать ВСЕ шаблоны
-        if (!expectedUnitIds.Any())
-        {
-            if (existingTemplates.Any())
-            {
-                logger.LogInformation("Для JobId {JobId} фильтры не дали Unit'ов — будет деактивировано {Count} шаблонов.",
-                    jobId, existingTemplates.Count);
-
-                foreach (var template in existingTemplates)
-                {
-                    await DeactivateTemplateAsync(template, jobId, unusedJob, initiator);
-                }
-            }
-            else
-            {
-                logger.LogInformation("Для JobId {JobId} нет Unit'ов по фильтрам и нет существующих шаблонов — синхронизация завершена.", jobId);
-            }
-
-            logger.LogInformation("Синхронизация завершена для JobId {JobId} (фильтр пуст).", jobId);
-            return;
-        }
-
-        // Деактивация шаблонов, которые вышли из фильтра
-        var templatesToDeactivate = existingTemplates
-            .Where(t => !expectedUnitIds.Contains(t.UnitId))
+        var newUnitIds = unitIds.Except(existingUnitIds).ToList();
+        var unusedTemplates = existingTemplates
+            .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used && !unitIds.Contains(t.UnitId))
             .ToList();
 
-        foreach (var template in templatesToDeactivate)
+        foreach (var unitId in newUnitIds)
         {
-            await DeactivateTemplateAsync(template, jobId, unusedJob, initiator);
-        }
+            var reusableTemplate = await templateReuser.TryReuseOneUnusedTemplateAsync(jobId, unitId, initiator);
 
-        // Перечитываем шаблоны после деактивации
-        existingTemplates = await templateService.Get()
-            .AsNoTracking()
-            .Include(t => t.Job)
-            .ThenInclude(t => t.Tnk)
-            .Where(t => t.JobId == jobId)
-            .ToListAsync();
-
-        var unitToTemplate = existingTemplates.ToDictionary(t => t.UnitId, t => t);
-
-        // UnitId без шаблона → попытка переиспользования или создание
-        var unitIdsMissingTemplates = expectedUnitIds
-            .Where(unitId => !unitToTemplate.ContainsKey(unitId))
-            .ToList();
-
-        var unitIdsToCreateFresh = new List<Guid>();
-
-        foreach (var unitId in unitIdsMissingTemplates)
-        {
-            var reused = await templateReuser.TryReuseOneUnusedTemplateAsync(jobId, unitId, initiator);
-            if (reused != null) // если захват успешен
+            if (reusableTemplate != null)
             {
-                logger.LogInformation("Переиспользован шаблон {TemplateId} для UnitId {UnitId}.", reused.Id, unitId);
+                logger.LogInformation("Переиспользован шаблон {TemplateId} для Job {JobId}, UnitId {UnitId}.", reusableTemplate.Id, jobId, unitId);
 
-                var expectedName = await GetNormalizedTemplateNameAsync(job, unitId);
-                var nextRun = await GetNextRunAsync(job); // всегда пересчитываем для нового назначения
+                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(job, unitId);
+                var nextRun = await GetNextRunAsync(job);
 
                 var updateRequest = new TemplateUpdaterMq
                 {
-                    TemplateId = reused.Id,
+                    TemplateId = reusableTemplate.Id,
                     JobId = jobId,
                     UnitId = unitId,
                     Name = expectedName,
@@ -176,362 +149,135 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
                     StatusTypeId = TemplateStatusTypeEnum.Used,
                     Initiator = initiator,
                     NextRun = nextRun,
-                    UnitsInTemplate = new List<Guid>() // Для простого шаблона
+                    UnitsInTemplate = new List<Guid>() // для простого шаблона
                 };
 
-                await SendTemplateUpdateMessage(updateRequest);
+                await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
             }
             else
             {
-                logger.LogInformation("Нет доступных Unused-шаблонов для UnitId {UnitId} → создадим новый.", unitId);
-                unitIdsToCreateFresh.Add(unitId);
+                logger.LogDebug("Создание нового шаблона для Job {JobId}, UnitId {UnitId}.", jobId, unitId);
+                await CreateSimpleTemplateAsync(jobId, unitId, initiator);
             }
         }
 
-        // Обновление/реактивация шаблонов, оставшихся в фильтре
-        var templatesInFilter = existingTemplates
-            .Where(t => expectedUnitIds.Contains(t.UnitId))
-            .ToList();
-
-        foreach (var template in templatesInFilter)
+        foreach (var unusedTemplate in unusedTemplates)
         {
-            var expectedName = await GetNormalizedTemplateNameAsync(job, template.UnitId);
-            await ReactivateOrRenameTemplateAsync(template, job, expectedName, initiator);
+            logger.LogInformation("Деактивация лишнего шаблона {TemplateId} (Job {JobId}, UnitId {UnitId}).", unusedTemplate.Id, jobId, unusedTemplate.UnitId);
+            await templateDeactivator.DeactivateTemplateAsync(unusedTemplate, initiator);
         }
 
-        // Создание новых шаблонов
-        foreach (var unitId in unitIdsToCreateFresh)
-        {
-            await SendTemplateGeneratorMessageAsync(jobId, unitId, initiator);
-        }
+        logger.LogInformation("Синхронизация шаблонов завершена для Job {JobId}.", jobId);
+    }
 
-        logger.LogInformation("Синхронизация завершена для JobId {JobId}.", jobId);
+    public async Task SyncTemplatesForJobGroupAsync(Guid jobGroupId, HistoryInitiator initiator)
+    {
+        logger.LogWarning("SimpleTemplateSynchronizer: SyncTemplatesForJobGroup вызван для JobGroup {JobGroupId}. Это не поддерживаемая операция.", jobGroupId);
     }
 
     public async Task UpdateTemplatesForJobAsync(Guid jobId, HistoryInitiator initiator)
     {
-        logger.LogDebug("Начало обновления шаблонов для JobId {JobId}", jobId);
+        logger.LogDebug("Обновление шаблонов для Job {JobId}", jobId);
 
-        // Загружаем заранее подготовленный Job (например, для неиспользуемых шаблонов)
-        var unusedJobId = Guid.Parse("8f85a91c-a223-4686-bb69-1f0ee73624f2");
-
-        var unusedJob = await jobService.Get()
+        var job = await jobService.Get()
             .AsNoTracking()
+            .Include(j => j.AutoControl)
             .Include(j => j.Tnk)
             .Include(j => j.Group)
-                .ThenInclude(g => g.GroupType)
-            .FirstOrDefaultAsync(j => j.Id == unusedJobId);
+                .ThenInclude(g => g!.GroupType)
+            .Include(j => j.UnitFilters)
+                .ThenInclude(uf => uf.RelationshipFilters)
+            .FirstOrDefaultAsync(j => j.Id == jobId);
+
+        if (job == null)
+        {
+            logger.LogWarning("Job {JobId} не найден.", jobId);
+            return;
+        }
+
+        var unitIds = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
+        if (unitIds == null || !unitIds.Any())
+        {
+            logger.LogInformation("Для Job {JobId} фильтры не дали Unit'ов.", jobId);
+            return;
+        }
+
+#if DEBUG
+        // ✅ Отладка: проверить, есть ли юнит в unitIds
+        if (unitIds.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в unitIds.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIds.", targetUnitId);
+            return; // ❌ юнит отсеялся на этом этапе
+        }
+#endif
 
         var existingTemplates = await templateService.Get()
             .AsNoTracking()
-            .Where(t => t.JobId == jobId)
+            .Include(t => t.UnitsInTemplate)
+            .Where(t => t.JobId == jobId && t.StatusTypeId == TemplateStatusTypeEnum.Used)
             .ToListAsync();
 
-        if (!existingTemplates.Any()) return;
-
-        var job = await GetJobWithGroupAndAutoControlAsync(jobId);
-        if (job == null) return;
-
-        var currentUnitIds = await GetExpectedUnitIdsAsync(jobId) ?? new HashSet<Guid>();
-        logger.LogDebug("JobId {JobId}: {Count} UnitId по текущему фильтру.", jobId, currentUnitIds.Count);
-
         foreach (var template in existingTemplates)
         {
-            logger.LogDebug("Обработка шаблона {TemplateId} (UnitId {UnitId}).", template.Id, template.UnitId);
-
-            bool unitStillInFilter = currentUnitIds.Contains(template.UnitId);
-            var expectedName = await GetNormalizedTemplateNameAsync(job, template.UnitId);
-
-            TemplateStatusTypeEnum targetStatus;
-            bool targetIsActiveTemplate;
-            bool targetIsActiveSchedule;
-
-            if (unitStillInFilter)
+            if (unitIds.Contains(template.UnitId))
             {
-                targetStatus = TemplateStatusTypeEnum.Used;
-                targetIsActiveTemplate = template.IsActiveTemplate;
-                targetIsActiveSchedule = template.IsActiveSchedule;
-            }
-            else
-            {
-                targetStatus = TemplateStatusTypeEnum.Unused;
-                targetIsActiveTemplate = DefaultUnusedTemplateState;
-                targetIsActiveSchedule = DefaultUnusedScheduleState;
-
-                // ✅ Вычисляем имя шаблона с новым unusedJob
-                if (unusedJob != null)
+                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(job, template.UnitId);
+                if (!string.Equals(template.Name, expectedName, StringComparison.OrdinalIgnoreCase))
                 {
-                    expectedName = await GetNormalizedTemplateNameAsync(unusedJob, template.UnitId);
+                    logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", template.Id, template.Name, expectedName);
+
+                    var nextRun = await GetNextRunAsync(job, template.NextRun);
+
+                    var updateRequest = new TemplateUpdaterMq
+                    {
+                        TemplateId = template.Id,
+                        JobId = jobId,
+                        UnitId = template.UnitId,
+                        Name = expectedName,
+                        IsActiveTemplate = template.IsActiveTemplate,
+                        IsActiveSchedule = template.IsActiveSchedule,
+                        LastRun = template.LastRun,
+                        NextRun = nextRun,
+                        Index = template.Index,
+                        StatusTypeId = TemplateStatusTypeEnum.Used,
+                        Initiator = initiator,
+                        UnitsInTemplate = new List<Guid>() // для простого шаблона
+                    };
+
+                    await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
                 }
-                else
-                {
-                    logger.LogError("Job для деактивированных шаблонов не найден.");
-                    expectedName = GetTemplateNameForUnused(template.Name);
-                }
-
-                logger.LogInformation("Шаблон {TemplateId} (UnitId {UnitId}) → деактивация.", template.Id, template.UnitId);
             }
-
-            bool needsUpdate = template.StatusTypeId != TemplateStatusTypeEnum.Updating &&
-                               (
-                                   // 1. Статус изменился (например, Used → Unused или Unused → Used)
-                                   template.StatusTypeId != targetStatus ||
-
-                                   // 2. Для Used — имя должно соответствовать шаблону
-                                   (targetStatus == TemplateStatusTypeEnum.Used && template.Name != expectedName) ||
-
-                                   // 3. Флаги изменились (редко, но возможно через AutoControl изменение)
-                                   template.IsActiveTemplate != targetIsActiveTemplate ||
-                                   template.IsActiveSchedule != targetIsActiveSchedule
-                               );
-
-            if (!needsUpdate) continue;
-
-            template.StatusTypeId = TemplateStatusTypeEnum.Updating;
-            template.DateModified = DateTimeOffset.UtcNow;
-
-            if (!await templateService.CommitAsync(initiator))
-            {
-                logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating.", template.Id);
-                continue;
-            }
-
-            var nextRun = await GetNextRunAsync(job, template.NextRun);
-
-            var updateRequest = new TemplateUpdaterMq
-            {
-                TemplateId = template.Id,
-                JobId = unitStillInFilter ? jobId : unusedJob?.Id ?? jobId, // ✅ Используем unusedJob.Id, если деактивация
-                UnitId = template.UnitId,
-                Name = expectedName,
-                IsActiveTemplate = targetIsActiveTemplate,
-                IsActiveSchedule = targetIsActiveSchedule,
-                LastRun = template.LastRun,
-                NextRun = nextRun,
-                Index = template.Index,
-                StatusTypeId = targetStatus,
-                Initiator = initiator,
-                UnitsInTemplate = template.UnitsInTemplate.Select(t => t.UnitId).ToList() // Для простого шаблона это список из одного элемента или пустой
-            };
-
-            await SendTemplateUpdateMessage(updateRequest);
         }
 
-        logger.LogInformation("Обновление шаблонов завершено для JobId {JobId}.", jobId);
+        logger.LogInformation("Обновление шаблонов завершено для Job {JobId}.", jobId);
     }
 
-    // --- Вспомогательные методы ---
-    private async Task<bool> DeactivateTemplateAsync(
-        Template template,
-        Guid jobId,
-        Job unusedJob,
-        HistoryInitiator initiator)
+    private async Task CreateSimpleTemplateAsync(Guid jobId, Guid unitId, HistoryInitiator initiator)
     {
-        if (template.StatusTypeId == TemplateStatusTypeEnum.Updating)
-            return true; // уже в обработке
+        logger.LogInformation("Создание нового простого шаблона для Job {JobId}, UnitId {UnitId}.", jobId, unitId);
 
-        if (template.StatusTypeId == TemplateStatusTypeEnum.Unused)
-        {
-            logger.LogDebug("Шаблон {TemplateId} уже неактивен (Unused), пропускаем деактивацию.", template.Id);
-            return true;
-        }
-
-        logger.LogInformation("Шаблон {TemplateId} (UnitId {UnitId}) → деактивация.",
-            template.Id, template.UnitId);
-
-        template.StatusTypeId = TemplateStatusTypeEnum.Updating;
-        template.DateModified = DateTimeOffset.UtcNow;
-
-        if (!await templateService.CommitAsync(initiator))
-        {
-            logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating.", template.Id);
-            return false;
-        }
-
-        if (unusedJob == null)
-        {
-            logger.LogError("Job для деактивированных шаблонов не найден.");
-            return false;
-        }
-
-        // ✅ Вычисляем имя шаблона с новым Job
-        var expectedName = await GetNormalizedTemplateNameAsync(unusedJob, template.UnitId);
-
-        var updateRequest = new TemplateUpdaterMq
-        {
-            TemplateId = template.Id,
-            JobId = unusedJob.Id, // ✅ Используем unusedJob.Id
-            UnitId = template.UnitId,
-            Name = GetTemplateNameForUnused(expectedName), // ✅ Используем новое имя
-            IsActiveTemplate = DefaultUnusedTemplateState,
-            IsActiveSchedule = DefaultUnusedScheduleState,
-            LastRun = template.LastRun,
-            NextRun = template.NextRun,
-            Index = template.Index,
-            StatusTypeId = TemplateStatusTypeEnum.Unused,
-            Initiator = initiator,
-            UnitsInTemplate = new List<Guid>() // Для простого шаблона
-        };
-
-        await SendTemplateUpdateMessage(updateRequest);
-        return true;
-    }
-
-    private async Task<bool> ReactivateOrRenameTemplateAsync(
-        Template template,
-        Job job,
-        string expectedName,
-        HistoryInitiator initiator)
-    {
-        if (template.StatusTypeId == TemplateStatusTypeEnum.Updating)
-            return true;
-
-        bool needsUpdate = template.Name != expectedName
-                           || template.StatusTypeId != TemplateStatusTypeEnum.Used;
-
-        if (!needsUpdate) return true;
-
-        logger.LogInformation("Шаблон {TemplateId}: требуется обновление имени или реактивация.", template.Id);
-
-        template.StatusTypeId = TemplateStatusTypeEnum.Updating;
-        template.DateModified = DateTimeOffset.UtcNow;
-
-        if (!await templateService.CommitAsync(initiator))
-        {
-            logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating.", template.Id);
-            return false;
-        }
-
-        var nextRun = await GetNextRunAsync(job, template.NextRun);
-
-        var updateRequest = new TemplateUpdaterMq
-        {
-            TemplateId = template.Id,
-            JobId = job.Id,
-            UnitId = template.UnitId,
-            Name = expectedName,
-            IsActiveTemplate = template.IsActiveTemplate,
-            IsActiveSchedule = template.IsActiveSchedule,
-            LastRun = template.LastRun,
-            NextRun = nextRun,
-            Index = template.Index,
-            StatusTypeId = TemplateStatusTypeEnum.Used,
-            Initiator = initiator,
-            UnitsInTemplate = template.UnitsInTemplate.Select(t => t.UnitId).ToList() // Для простого шаблона это список из одного элемента
-        };
-
-        await SendTemplateUpdateMessage(updateRequest);
-        return true;
-    }
-
-    private async Task<bool> SendTemplateGeneratorMessageAsync(
-        Guid jobId,
-        Guid unitId,
-        HistoryInitiator initiator)
-    {
-        logger.LogInformation("Создание нового шаблона для UnitId {UnitId}.", unitId);
         var mqRequest = new TemplateGeneratorMq
         {
             JobId = jobId,
             UnitId = unitId,
-            HistoryInitiator = initiator,
-            UnitsInTemplate = new List<Guid>() // Для простого шаблона
+            UnitsInTemplate = new List<Guid>(), // для простого шаблона
+            HistoryInitiator = initiator
         };
 
         var msg = JsonSerializer.Serialize(mqRequest);
         var result = await mqService.SendAsync(mqSettings.TemplateGenerator, new[] { msg });
 
         if (!result.IsSuccess)
-            logger.LogError("Ошибка отправки команды создания шаблона для UnitId {UnitId}.", unitId);
-
-        return result.IsSuccess;
-    }
-
-    private async Task SendTemplateUpdateMessage(TemplateUpdaterMq updateRequest)
-    {
-        logger.LogDebug("Отправка сообщения в очередь '{Queue}' для шаблона {TemplateId}",
-            mqSettings.TemplateUpdater.QueueName, updateRequest.TemplateId);
-
-        var msg = JsonSerializer.Serialize(updateRequest);
-        var result = await mqService.SendAsync(mqSettings.TemplateUpdater, new[] { msg });
-
-        if (result.IsSuccess)
-        {
-            logger.LogInformation("Отправлен запрос на обновление шаблона {TemplateId}", updateRequest.TemplateId);
-        }
-        else
-        {
-            logger.LogError("Ошибка при отправке запроса на обновление шаблона {TemplateId} в очередь '{Queue}'.",
-                updateRequest.TemplateId, mqSettings.TemplateUpdater.QueueName);
-        }
-    }
-
-    private string GetTemplateNameForUnused(string templateName)
-    {
-        return templateName + "_" + DateTimeOffset.UtcNow.ToUnixTimeSeconds();
-    }
-
-    private async Task<Job?> GetJobWithGroupAndAutoControlAsync(Guid jobId)
-    {
-        return await jobService.Get()
-            .AsNoTracking()
-            .Include(j => j.Tnk)
-            .Include(j => j.Group)
-                .ThenInclude(j => j.GroupType)
-            .Include(j => j.AutoControl)
-            .FirstOrDefaultAsync(j => j.Id == jobId);
-    }
-
-    private async Task<HashSet<Guid>> GetExpectedUnitIdsAsync(Guid jobId)
-    {
-        var units = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
-        return units?.ToHashSet() ?? new HashSet<Guid>();
-    }
-
-    private async Task<string> GetNormalizedTemplateNameAsync(Job job, Guid unitId)
-    {
-        // Создаём TemplateForShortcodes "на лету", без запроса к БД
-        var templateForShortcodes = new TemplateForShortcodes
-        {
-            Id = Guid.Empty, // шаблон ещё не создан
-            Index = null,
-            JobId = job.Id,
-            UnitId = unitId,
-            Job = new JobForShortcodes
-            {
-                Group = job.Group == null ? null : new JobGroupForShortcodes
-                {
-                    GroupingUnitFieldId = job.Group.GroupingUnitFieldId,
-                    GroupType = job.Group.GroupType == null ? null : new JobGroupTypeForShortcodes
-                    {
-                        Code = job.Group.GroupType.Code
-                    },
-                    GroupName = job.Group.GroupName
-                },
-                Tnk = job.Tnk == null ? null : new TnkForShortcodes
-                {
-                    Name = job.Tnk.Name,
-                    ShortName = job.Tnk.ShortName ?? ""
-                },
-                WorkName = job.WorkName,
-                Name = job.Name
-            },
-            UnitsInTemplate = new List<UnitInTemplateForShortcodes>() // для простого шаблона
-        };
-
-        var rawName = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask, templateForShortcodes);
-        return rawName.ToUpper();
+            logger.LogError("Ошибка отправки команды создания простого шаблона для Job {JobId}, UnitId {UnitId}.", jobId, unitId);
     }
 
     private async Task<DateTimeOffset> GetNextRunAsync(Job job, DateTimeOffset? currentNextRun = null)
     {
-        var now = DateTimeOffset.UtcNow;
-        if (currentNextRun.HasValue && currentNextRun.Value > now)
-        {
-            return currentNextRun.Value;
-        }
-
-        var referenceDate = job.Group?.ReferenceDate ?? now;
+        var referenceDate = job.Group?.ReferenceDate ?? DateTimeOffset.UtcNow;
         return await esppScheduleTransformService.GetNextDateAsync(job.GroupId, referenceDate);
     }
 }