feat(templateMatcher): refactoring

PARR.TemplateMatcher/Services/Implemetaions/GroupedTemplateSynchronizer.cs

@@ -5,8 +5,6 @@ using PARR.BLL.Services.Interfaces;
 using PARR.Common.Domain;
 using PARR.Constants;
 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.Models.Unit;
@@ -18,12 +16,14 @@ 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 GroupedTemplateSynchronizer : ITemplateSynchronizer
 {
-    private const bool DefaultUnusedTemplateState = false;
-    private const bool DefaultUnusedScheduleState = false;
+#if DEBUG
+    private readonly Guid targetUnitId = Guid.Parse("d4322a08-246b-4380-8953-8ce4a8446235");
+#endif
+
     private const bool DefaultUsedTemplateState = false;
     private const bool DefaultUsedScheduleState = false;
 
@@ -37,11 +37,12 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
     private readonly ITemplateService templateService;
     private readonly IJobGroupService jobGroupService;
     private readonly ITemplateReuser templateReuser;
-    private readonly IShortcodesService shortcodesService;
     private readonly IEsppScheduleTransformService esppScheduleTransformService;
     private readonly IUnitRegionalEkPtkGroupService regionalEkPtkGroupService;
     private readonly IUnitFieldService unitFieldService;
-    private readonly IJobService jobService;
+    private readonly ITemplateDeactivator templateDeactivator;
+    private readonly ITemplateNameNormalizer templateNameNormalizer;
+    private readonly ITemplateUpdaterMqSender templateUpdaterMqSender;
 
     public GroupedTemplateSynchronizer(
         ILogger<GroupedTemplateSynchronizer> logger,
@@ -54,11 +55,12 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         ITemplateService templateService,
         IJobGroupService jobGroupService,
         ITemplateReuser templateReuser,
-        IShortcodesService shortcodesService,
         IEsppScheduleTransformService esppScheduleTransformService,
         IUnitRegionalEkPtkGroupService regionalEkPtkGroupService,
         IUnitFieldService unitFieldService,
-        IJobService jobService
+        ITemplateDeactivator templateDeactivator,
+        ITemplateNameNormalizer templateNameNormalizer,
+        ITemplateUpdaterMqSender templateUpdaterMqSender
         )
     {
         this.logger = logger;
@@ -71,11 +73,12 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         this.templateService = templateService;
         this.jobGroupService = jobGroupService;
         this.templateReuser = templateReuser;
-        this.shortcodesService = shortcodesService;
         this.esppScheduleTransformService = esppScheduleTransformService;
         this.regionalEkPtkGroupService = regionalEkPtkGroupService;
         this.unitFieldService = unitFieldService;
-        this.jobService = jobService;
+        this.templateDeactivator = templateDeactivator;
+        this.templateNameNormalizer = templateNameNormalizer;
+        this.templateUpdaterMqSender = templateUpdaterMqSender;
     }
 
     public async Task SyncTemplatesForJobAsync(Guid jobId, HistoryInitiator initiator)
@@ -108,7 +111,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
         var jobsInGroup = jobGroup.Jobs.ToList();
 
-        // --- Получение FieldId и разрешённых значений для "РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК" ---
+        // --- НОВАЯ ЛОГИКА: Получение FieldId и разрешённых значений для "РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК" ---
         var workGroupField = await unitFieldService.GetByAihitNameAsync("РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК");
         if (workGroupField == null)
         {
@@ -123,17 +126,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
         logger.LogDebug("Найдено {Count} значений из UnitRegionalEkPtkGroup для проверки поля 'РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК'.", regionalGroupValueIds.Count);
 
-
-        // Загружаем заранее подготовленный Job (например, для неиспользуемых шаблонов)
-        var unusedJobId = Guid.Parse("8f85a91c-a223-4686-bb69-1f0ee73624f2");
-
-        var unusedJob = await jobService.Get()
-            .AsNoTracking()
-            .Include(j => j.Tnk)
-            .Include(j => j.Group)
-                .ThenInclude(g => g.GroupType)
-            .FirstOrDefaultAsync(j => j.Id == unusedJobId);
-
         // 2. Найти Job с максимальным MaxValueRelationships
         var maxJob = jobsInGroup
             .Where(j => j.MaxValueRelationships.HasValue)
@@ -162,6 +154,19 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             return;
         }
 
+#if DEBUG
+        // ✅ Отладка: проверить, есть ли юнит в expectedUnitIds
+        if (expectedUnitIds.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в expectedUnitIds.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в expectedUnitIds.", targetUnitId);
+            //return; // ❌ юнит отсеялся на этом этапе
+        }
+#endif
+
         // 4. Отфильтровать expectedUnitIds по GroupingUnitFieldId (дополнительный фильтр)
         if (!jobGroup.GroupingUnitFieldId.HasValue)
         {
@@ -185,6 +190,19 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             .Select(u => u.Id)
             .ToHashSet();
 
+#if DEBUG
+        // ✅ Отладка: проверить, есть ли юнит в unitIdsWithValidGroupingFieldSet
+        if (unitIdsWithValidGroupingFieldSet.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в unitIdsWithValidGroupingFieldSet.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIdsWithValidGroupingFieldSet.", targetUnitId);
+            //return; // ❌ юнит отсеялся на этом этапе
+        }
+#endif
+
         logger.LogDebug("После фильтрации по GroupingUnitFieldId осталось {Count} юнитов.", unitIdsWithValidGroupingFieldSet.Count);
 
         if (!unitIdsWithValidGroupingFieldSet.Any())
@@ -204,6 +222,19 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             .Select(u => u.Id) // Выбираем Id юнита
             .ToHashSet(); // И снова в HashSet
 
+#if DEBUG
+        // ✅ Отладка: проверить, есть ли юнит в unitIdsWithValidWorkGroupFieldSet
+        if (unitIdsWithValidWorkGroupFieldSet.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в unitIdsWithValidWorkGroupFieldSet.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIdsWithValidWorkGroupFieldSet.", targetUnitId);
+            //return; // ❌ юнит отсеялся на этом этапе
+        }
+#endif
+
         logger.LogDebug("После фильтрации по 'РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК' осталось {Count} юнитов.", unitIdsWithValidWorkGroupFieldSet.Count);
 
         if (!unitIdsWithValidWorkGroupFieldSet.Any())
@@ -225,6 +256,20 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             .Where(link => unitIdsWithValidGroupingFieldSet.Contains(link.ParentUnitId) || unitIdsWithValidGroupingFieldSet.Contains(link.ChildUnitId))
             .ToListAsync();
 
+#if DEBUG
+        // ✅ Отладка: проверить, юнит участвует в potentialUnitInUnitLinks
+        var potentialLinksContainingTarget = potentialUnitInUnitLinks.Where(l => l.ParentUnitId == targetUnitId || l.ChildUnitId == targetUnitId).ToList();
+        if (potentialLinksContainingTarget.Any())
+        {
+            logger.LogDebug("Юнит {TargetUnitId} участвует в {Count} потенциальных связях UnitInUnit.", targetUnitId, potentialLinksContainingTarget.Count);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ участвует в потенциальных связях UnitInUnit.", targetUnitId);
+            // ❌ юнит отсеялся на этом этапе, если связи не требовались
+        }
+#endif
+
         logger.LogDebug("Найдено {Count} потенциальных связей UnitInUnit.", potentialUnitInUnitLinks.Count);
 
         // Загрузить UnitInValue для всех ParentUnitId и ChildUnitId из potentialUnitInUnitLinks
@@ -288,6 +333,20 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             }
         }
 
+#if DEBUG
+        // ✅ Отладка: проверить, юнит участвует в filteredUnitInUnitLinks
+        var filteredLinksContainingTarget = filteredUnitInUnitLinks.Where(l => l.ParentUnitId == targetUnitId || l.ChildUnitId == targetUnitId).ToList();
+        if (filteredLinksContainingTarget.Any())
+        {
+            logger.LogDebug("Юнит {TargetUnitId} участвует в {Count} отфильтрованных связях UnitInUnit.", targetUnitId, filteredLinksContainingTarget.Count);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ участвует в отфильтрованных связях UnitInUnit.", targetUnitId);
+            // ❌ юнит отсеялся на этом этапе, если связи требовались
+        }
+#endif
+
         logger.LogDebug("После применения RelationshipFilters осталось {Count} связей UnitInUnit.", filteredUnitInUnitLinks.Count);
 
         // --- Сгруппировать юниты из unitIdsWithValidGroupingFieldSet по связанному юниту ---
@@ -317,6 +376,22 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
         logger.LogDebug("Сформировано {Count} групп по связанным юнитам до разрешения конфликтов.", groupedRelationships.Count);
 
+#if DEBUG
+        // ✅ Отладка: проверить, юнит есть в groupedRelationships.Values
+        var allUnitsInGroups = groupedRelationships.Values.SelectMany(x => x).ToList();
+        if (allUnitsInGroups.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в groupedRelationships.Values до разрешения конфликтов.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в groupedRelationships.Values до разрешения конфликтов.", targetUnitId);
+            // ❌ юнит отсеялся на этапе группировки
+        }
+
+        logger.LogDebug("Содержимое groupedRelationships до разрешения конфликтов: [{Groups}]", string.Join(", ", groupedRelationships.Select(kvp => $"Key: {kvp.Key}, Values: [{string.Join(", ", kvp.Value)}]")));
+#endif
+
         // --- Разрешение конфликта - один юнит из unitIdsWithValidGroupingFieldSet только в одном списке значений ---
         var unitToKeys = new Dictionary<Guid, List<Guid>>(); // Карта: юнит из списка -> список ключей, где он встречается
 
@@ -334,9 +409,34 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             }
         }
 
+#if DEBUG
+        // ✅ Отладка: проверить, юнит есть в unitToKeys до поиска конфликтов
+        if (unitToKeys.ContainsKey(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в unitToKeys до поиска конфликтов, находится в {Count} группах: [{Groups}]", targetUnitId, unitToKeys[targetUnitId].Count, string.Join(", ", unitToKeys[targetUnitId]));
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitToKeys до поиска конфликтов.", targetUnitId);
+        }
+#endif
+
         // Найти юниты, которые находятся в нескольких списках
         var conflictedUnits = unitToKeys.Where(kvp => kvp.Value.Count > 1).ToList();
 
+#if DEBUG
+        // ✅ Отладка: проверить, юнит в conflictedUnits
+        var targetConflictedEntry = conflictedUnits.FirstOrDefault(c => c.Key == targetUnitId);
+        if (targetConflictedEntry.Key != default)
+        {
+            logger.LogDebug("Юнит {TargetUnitId} находится в {Count} группах (конфликт).", targetUnitId, targetConflictedEntry.Value.Count);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ находится в конфликте (не в нескольких группах).", targetUnitId);
+        }
+#endif
+
         foreach (var conflictedUnitEntry in conflictedUnits)
         {
             var unitId = conflictedUnitEntry.Key;
@@ -367,6 +467,20 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             }
         }
 
+#if DEBUG
+        // ✅ Отладка: проверить, юнит есть в groupedRelationships.Values после разрешения конфликтов
+        var allUnitsInGroupsAfterConflictResolution = groupedRelationships.Values.SelectMany(x => x).ToList();
+        if (allUnitsInGroupsAfterConflictResolution.Contains(targetUnitId))
+        {
+            logger.LogDebug("Юнит {TargetUnitId} найден в groupedRelationships.Values после разрешения конфликтов.", targetUnitId);
+        }
+        else
+        {
+            logger.LogDebug("Юнит {TargetUnitId} НЕ найден в groupedRelationships.Values после разрешения конфликтов.", targetUnitId);
+            // ❌ юнит отсеялся на этапе разрешения конфликтов
+        }
+#endif
+
         // Удаляем ключи, у которых список стал пустым после разрешения конфликтов
         var keysToRemove = groupedRelationships.Where(kvp => kvp.Value.Count == 0).Select(kvp => kvp.Key).ToList();
         foreach (var key in keysToRemove)
@@ -377,11 +491,26 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
         logger.LogDebug("Сформировано {Count} групп по связанным юнитам после разрешения конфликтов.", groupedRelationships.Count);
 
+#if DEBUG
+        logger.LogDebug("Содержимое groupedRelationships после разрешения конфликтов: [{Groups}]", string.Join(", ", groupedRelationships.Select(kvp => $"Key: {kvp.Key}, Values: [{string.Join(", ", kvp.Value)}]")));
+#endif
+
         // 7. Разбить каждую группу и сопоставить с Job
         foreach (var kvp in groupedRelationships)
         {
             var relationshipUnitId = kvp.Key; // Связанный юнит (не из unitIdsWithValidGroupingFieldSet)
             var childUnitIds = kvp.Value; // Юниты из unitIdsWithValidGroupingFieldSet, связанные с regionalUnitId
+            if (childUnitIds.Count == 0)
+                continue;
+#if DEBUG
+            // ✅ Отладка: проверить, есть ли ВРТ-AOS-05-ДВС в childUnitIds
+            var childUnitNames = childUnitIds.Select(id => unitService.Get().AsNoTracking().Where(u => u.Id == id).Select(u => u.Name).FirstOrDefaultAsync().GetAwaiter().GetResult() ?? id.ToString()).ToList();
+            if (childUnitNames.Contains("ВРТ-AOS-05-ДВС"))
+            {
+                var relationshipUnitName = await unitService.Get().AsNoTracking().Where(u => u.Id == relationshipUnitId).Select(u => u.Name).FirstOrDefaultAsync();
+                logger.LogDebug("Группа с ключом {Key} (название: {Name}) содержит юнит 'ВРТ-AOS-05-ДВС' в childUnitIds: [{ChildUnitNames}]", relationshipUnitId, relationshipUnitName, string.Join(", ", childUnitNames));
+            }
+#endif
 
             logger.LogDebug("Обработка связанного юнита {RegionalUnitId} с {Count} юнитами из списка.", relationshipUnitId, childUnitIds.Count);
 
@@ -431,7 +560,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                         logger.LogDebug("Шаблон {TemplateId} (Job {JobId}, Regional {RegionalId}, Index {Index}) актуален по юнитам.", existingTemplateForSubGroup.Id, targetJob.Id, relationshipUnitId, i);
 
                         // Проверить, изменилось ли имя шаблона (например, из-за %МАКС:...% или %ТНК-КРАТКО%)
-                        var expectedName = await GetNormalizedTemplateNameAsync(targetJob, relationshipUnitId, i, subGroup);
+                        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(targetJob, relationshipUnitId, i, subGroup);
                         if (!string.Equals(existingTemplateForSubGroup.Name, expectedName, StringComparison.OrdinalIgnoreCase))
                         {
                             logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", existingTemplateForSubGroup.Id, existingTemplateForSubGroup.Name, expectedName);
@@ -448,13 +577,13 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                                 IsActiveSchedule = existingTemplateForSubGroup.IsActiveSchedule,
                                 LastRun = existingTemplateForSubGroup.LastRun,
                                 NextRun = nextRun,
-                                Index = i ,
+                                Index = i,
                                 StatusTypeId = TemplateStatusTypeEnum.Used,
                                 Initiator = initiator,
                                 UnitsInTemplate = subGroup
                             };
 
-                            await SendTemplateUpdateMessage(updateRequest);
+                            await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
                         }
                         else
                         {
@@ -485,7 +614,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                     {
                         logger.LogInformation("Переиспользован шаблон {TemplateId} для Job {JobId}, связанного юнита {RegionalId}, Index {Index}.", reusableTemplate.Id, targetJob.Id, relationshipUnitId, i);
 
-                        var expectedName = await GetNormalizedTemplateNameAsync(targetJob, relationshipUnitId, i, subGroup);
+                        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(targetJob, relationshipUnitId, i, subGroup);
                         var nextRun = await GetNextRunAsync(targetJob);
 
                         var updateRequest = new TemplateUpdaterMq
@@ -503,7 +632,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                             UnitsInTemplate = subGroup
                         };
 
-                        await SendTemplateUpdateMessage(updateRequest);
+                        await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
                     }
                     else
                     {
@@ -553,7 +682,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             if (!expectedTemplateKeys.Contains(key))
             {
                 logger.LogInformation("Деактивация лишнего шаблона {TemplateId} (Job {JobId}, Regional {UnitId}, Index {Index}).", existingTemplate.Id, existingTemplate.JobId, existingTemplate.UnitId, existingTemplate.Index);
-                await DeactivateTemplateAsync(existingTemplate, existingTemplate.JobId, unusedJob, initiator);
+                await templateDeactivator.DeactivateTemplateAsync(existingTemplate, initiator);
             }
         }
 
@@ -613,7 +742,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             return;
         }
 
-        var expectedName = await GetNormalizedTemplateNameAsync(targetJob, template.UnitId, template.Index, newUnitIds);
+        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(targetJob, template.UnitId, template.Index, newUnitIds);
         var nextRun = await GetNextRunAsync(targetJob, template.NextRun);
 
         var updateRequest = new TemplateUpdaterMq
@@ -632,7 +761,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             UnitsInTemplate = newUnitIds
         };
 
-        await SendTemplateUpdateMessage(updateRequest);
+        await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
     }
 
     private async Task CreateGroupedTemplateAsync(Guid jobId, Guid regionalUnitId, List<Guid> unitIds, int index, HistoryInitiator initiator)
@@ -655,132 +784,9 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             logger.LogError("Ошибка отправки команды создания группового шаблона для Job {JobId}, связанного юнита {RegionalUnitId}, Index {Index}.", jobId, regionalUnitId, index);
     }
 
-    private async Task<bool> DeactivateTemplateAsync(
-        Template template,
-        Guid jobId,
-        Job unusedJob,
-        HistoryInitiator initiator)
-    {
-        if (template.StatusTypeId == TemplateStatusTypeEnum.Updating)
-            return true;
-
-        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,
-            UnitId = template.UnitId,
-            Name = GetTemplateNameForUnused(expectedName),
-            IsActiveTemplate = DefaultUnusedTemplateState,
-            IsActiveSchedule = DefaultUnusedScheduleState,
-            LastRun = template.LastRun,
-            NextRun = template.NextRun,
-            Index = null,
-            StatusTypeId = TemplateStatusTypeEnum.Unused,
-            Initiator = initiator,
-            UnitsInTemplate = new List<Guid>()
-        };
-
-        await SendTemplateUpdateMessage(updateRequest);
-        return true;
-    }
-
-    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<string> GetNormalizedTemplateNameAsync(Job targetJob, Guid unitId, int? index = null, List<Guid>? templateUnitIds = null)
-    {
-        // Подготовка объекта TemplateForShortcodes для передачи в ShortcodesService
-        var templateForShortcodes = new TemplateForShortcodes
-        {
-            Id = Guid.Empty, // Не используется в подстановке, но нужен для структуры
-            Index = index+1,
-            JobId = targetJob.Id,
-            UnitId = unitId,
-            Job = new JobForShortcodes
-            {
-                Group = targetJob.Group != null ? new JobGroupForShortcodes
-                {
-                    Id = targetJob.Group.Id,
-                    GroupingUnitFieldId = targetJob.Group.GroupingUnitFieldId,
-                    GroupType = targetJob.Group.GroupType != null ? new JobGroupTypeForShortcodes
-                    {
-                        Code = targetJob.Group.GroupType.Code
-                    } : null,
-                    GroupName = targetJob.Group.GroupName
-                } : null,
-                Tnk = targetJob.Tnk != null ? new TnkForShortcodes
-                {
-                    Name = targetJob.Tnk.Name,
-                    ShortName = targetJob.Tnk.ShortName ?? ""
-                } : null,
-                WorkName = targetJob.WorkName,
-                Name = targetJob.Name
-            },
-            // Преобразование List<Guid> в List<UnitInTemplateForShortcodes>
-            UnitsInTemplate = templateUnitIds?.Select(id => new UnitInTemplateForShortcodes { UnitId = id }).ToList() ?? new List<UnitInTemplateForShortcodes>()
-        };
-
-        var rawName = await shortcodesService.ApplyShortcodesAsync(targetJob.TemplateNameMask, templateForShortcodes);
-        return rawName.ToUpper();
-    }
-
     private async Task<DateTimeOffset> GetNextRunAsync(Job targetJob, DateTimeOffset? currentNextRun = null)
     {
-        var now = DateTimeOffset.UtcNow;
-        if (currentNextRun.HasValue && currentNextRun.Value > now)
-        {
-            return currentNextRun.Value;
-        }
-
-        var referenceDate = targetJob.Group?.ReferenceDate ?? now;
+        var referenceDate = targetJob.Group?.ReferenceDate ?? DateTimeOffset.UtcNow;
         return await esppScheduleTransformService.GetNextDateAsync(targetJob.GroupId, referenceDate);
     }
 }