feat(templateMatcher): Рефакторинг, основной метод синхронизации GroupedTemplateSynchronizer разбит на отдельные классы; Неиспользуемые шаблоны теперь привязываются к ЭК КОСМПЛЕКСЫ-[ЗО].

2026-05-14 16:47:27 +10:00
parent f7a74d315a
commit 90e6352117
30 changed files with 1150 additions and 864 deletions
--- a/PARR.TemplateMatcher/Services/Implementations/SimpleTemplateSynchronizer.cs
+++ b/PARR.TemplateMatcher/Services/Implementations/SimpleTemplateSynchronizer.cs
@@ -0,0 +1,716 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using PARR.Core.Common.Interfaces.RabbitServices;
+using PARR.Core.Repositories.Interfaces;
+using PARR.Core.Repositories.Interfaces.Job;
+using PARR.Core.Repositories.Interfaces.Unit;
+using PARR.Core.Services.MatchingStatusService;
+using PARR.Core.Services.UnitFilterService;
+using PARR.Domain.Cache.Models;
+using PARR.Domain.Common.Rabbit.Messages.TemplateMatching;
+using PARR.Domain.Entities;
+using PARR.Domain.Entities.Base.History;
+using PARR.Domain.Entities.Job;
+using PARR.Domain.Entities.Unit;
+using PARR.Domain.Enums;
+using PARR.Domain.Settings;
+using PARR.TemplateMatcher.Services.Interfaces;
+using PARR.TemplateMatcher.Settings;
+
+namespace PARR.TemplateMatcher.Services.Implementations;
+
+internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
+{
+#if DEBUG
+    private readonly Guid targetUnitId = Guid.Parse("358437ac-1eeb-4c00-840c-998326f657ac");
+#endif
+
+    private const bool DefaultUsedTemplateState = false;
+    private const bool DefaultUsedScheduleState = false;
+
+    private readonly ILogger<SimpleTemplateSynchronizer> logger;
+    private readonly IUnitFilterService unitFilterService;
+    private readonly MqSettings mqSettings;
+    private readonly IRabbitService mqService;
+    private readonly ITemplateRepository templateService;
+    private readonly IJobRepository jobService;
+    private readonly ITemplateReuser templateReuser;
+    private readonly ITemplateDeactivator templateDeactivator;
+    private readonly ITemplateNameNormalizer templateNameNormalizer;
+    private readonly ITemplateUpdaterMqSender templateUpdaterMqSender;
+    private readonly IMatchingStatusService matchingStatusService;
+    private readonly SettingsFromDb settingsFromDb;
+    private readonly IOptions<TemplateSettings> templateSettings;
+    private readonly IUnitFieldRepository unitFieldService;
+    private readonly IUnitInValueRepository unitInValueService;
+    private readonly IUnitRepository unitRepository;
+
+    public SimpleTemplateSynchronizer(
+        ILogger<SimpleTemplateSynchronizer> logger,
+        IUnitFilterService unitFilterService,
+        MqSettings mqSettings,
+        IRabbitService mqService,
+        ITemplateRepository templateService,
+        IJobRepository jobService,
+        ITemplateReuser templateReuser,
+        ITemplateDeactivator templateDeactivator,
+        ITemplateNameNormalizer templateNameNormalizer,
+        ITemplateUpdaterMqSender templateUpdaterMqSender,
+        IMatchingStatusService matchingStatusService,
+        SettingsFromDb settingsFromDb,
+        IOptions<TemplateSettings> templateSettings,
+        IUnitFieldRepository unitFieldService,
+        IUnitInValueRepository unitInValueService,
+        IUnitRepository unitRepository
+        )
+    {
+        this.logger = logger;
+        this.unitFilterService = unitFilterService;
+        this.mqSettings = mqSettings;
+        this.mqService = mqService;
+        this.templateService = templateService;
+        this.jobService = jobService;
+        this.templateReuser = templateReuser;
+        this.templateDeactivator = templateDeactivator;
+        this.templateNameNormalizer = templateNameNormalizer;
+        this.templateUpdaterMqSender = templateUpdaterMqSender;
+        this.matchingStatusService = matchingStatusService;
+        this.settingsFromDb = settingsFromDb;
+        this.templateSettings = templateSettings;
+        this.unitFieldService = unitFieldService;
+        this.unitInValueService = unitInValueService;
+        this.unitRepository = unitRepository;
+    }
+
+    public async Task SyncTemplatesForJobAsync(Guid jobId, HistoryInitiator initiator)
+    {
+        // === Специальная обработка для Job неиспользуемых шаблонов ===
+        if (jobId == settingsFromDb.JobIdForUnusedTemplates)
+        {
+            logger.LogInformation("Обработка синхронизации для Job неиспользуемых шаблонов {JobId}", jobId);
+            await SyncUnusedTemplatesAsync(jobId, initiator);
+            return;
+        }
+
+        // === Обычная логика для всех остальных Job ===
+        logger.LogDebug("Начало синхронизации шаблонов для Job {JobId}", jobId);
+
+        // === Проверка: уже запущена? ===
+        var existingStatus = await matchingStatusService.GetStatusAsync(jobId, SyncTaskEntityTypeEnum.Job);
+        if (existingStatus.DetailsJobs?.Any() == true)
+        {
+            logger.LogWarning("Синхронизация для Job {JobId} уже запущена. Пропускаем.", jobId);
+            return;
+        }
+
+        // === Устанавливаем статус "в процессе" ===
+        var initialStatus = new MatchingStatusItemDto
+        {
+            DateStart = DateTimeOffset.UtcNow,
+            Action = TemplateMatcherActionEnum.Sync,
+            Comment = "Начало синхронизации"
+        };
+        await matchingStatusService.SetMatchingStatusAsync(
+            jobId,
+            SyncTaskEntityTypeEnum.Job,
+            new MatchingStatusItem { Data = initialStatus, Timestamp = DateTimeOffset.UtcNow, Source = nameof(SimpleTemplateSynchronizer) },
+            TimeSpan.FromMinutes(35)
+        );
+
+        try
+        {
+            var job = await jobService.Get()
+                .AsNoTracking()
+                .Include(j => j.AutoControl)
+                .Include(j => j.Tnk)
+                .Include(j => j.Group)
+                    .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);
+                await UpdateMatchingStatusAsync(jobId, "Job не найден");
+                return;
+            }
+
+            // === Получение отфильтрованных юнитов с полной информацией ===
+            var filteredUnits = await unitFilterService.GetUnitsByJobFilterAsync(jobId);
+            if (filteredUnits == null || !filteredUnits.Any())
+            {
+                logger.LogInformation("Для Job {JobId} фильтры не дали Unit'ов.", jobId);
+
+                var existingTemplatesForDeactivation = await templateService.Get()
+                    .AsNoTracking()
+                    .Include(t => t.UnitsInTemplate)
+                    .Where(t => t.JobId == jobId && t.StatusTypeId == TemplateStatusTypeEnum.Used)
+                    .ToListAsync();
+
+                await UpdateMatchingStatusAsync(jobId, $"Нет Unit'ов. Деактивация {existingTemplatesForDeactivation.Count} шаблонов...");
+
+                foreach (var unusedTemplate in existingTemplatesForDeactivation)
+                {
+                    logger.LogInformation("Деактивация лишнего шаблона {TemplateId} (Job {JobId}, UnitId {UnitId}).", unusedTemplate.Id, jobId, unusedTemplate.UnitId);
+                    await templateDeactivator.DeactivateTemplateAsync(unusedTemplate, initiator);
+                }
+
+                await UpdateMatchingStatusAsync(jobId, "Синхронизация завершена: нет Unit'ов");
+                await matchingStatusService.DeleteMatchingStatusAsync(jobId, SyncTaskEntityTypeEnum.Job);
+                logger.LogInformation("Синхронизация шаблонов завершена для Job {JobId}.", jobId);
+                return;
+            }
+
+            // Извлекаем ID юнитов для последующих операций
+            var unitIds = filteredUnits.Select(u => u.Id).ToList();
+
+#if DEBUG
+            // Отладка: проверить, есть ли юнит в unitIds
+            if (unitIds.Contains(targetUnitId))
+            {
+                logger.LogDebug("Юнит {TargetUnitId} найден в unitIds.", targetUnitId);
+            }
+            else
+            {
+                logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIds.", targetUnitId);
+            }
+#endif
+
+            var existingTemplates = await templateService.Get()
+                .Include(t => t.UnitsInTemplate)
+                .Include(t => t.Job)
+                    .ThenInclude(t => t!.Group)
+                        .ThenInclude(t => t!.GroupType)
+                .Include(t => t.Job)
+                    .ThenInclude(t => t!.Tnk)
+                .Include(t => t.Unit)
+                .Where(t => t.JobId == jobId)
+                .ToListAsync();
+
+            var existingUsedTemplates = existingTemplates
+                .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used)
+                .ToList();
+
+            var existingUnitIds = existingUsedTemplates
+                .Select(t => t.UnitId)
+                .ToHashSet();
+
+            var newUnitIds = unitIds.Except(existingUnitIds).ToList();
+            var unusedTemplates = existingUsedTemplates
+                .Where(t => !unitIds.Contains(t.UnitId))
+                .ToList();
+
+            foreach (var unitId in newUnitIds)
+            {
+                var reusableTemplate = await templateReuser.TryReuseOneUnusedTemplateAsync(jobId, unitId, initiator);
+                if (reusableTemplate != null)
+                {
+                    logger.LogInformation("Переиспользован шаблон {TemplateId} для Job {JobId}, UnitId {UnitId}.", reusableTemplate.Id, jobId, unitId);
+
+                    // === Создаём временный Template для нормализации имени ===
+                    var tempTemplateForName = new Template
+                    {
+                        Id = reusableTemplate.Id,
+                        Name = reusableTemplate.Name,
+                        JobId = jobId,
+                        UnitId = unitId,
+                        Index = reusableTemplate.Index,
+                        Job = job, // загруженный job
+                        Unit = reusableTemplate.Unit, // может быть null — нормально
+                        UnitsInTemplate = new List<UnitsInTemplate>() // для простого шаблона
+                    };
+
+                    var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(tempTemplateForName);
+                    //var nextRun = await nextRunService.GetNextRunForTemplateAsync(reusableTemplate.Id, true);
+
+                    var updateRequest = new TemplateUpdaterMessage
+                    {
+                        TemplateId = reusableTemplate.Id,
+                        JobId = jobId,
+                        UnitId = unitId,
+                        Name = expectedName,
+                        IsActiveTemplate = job.AutoControl?.InitUsedTemplateState ?? DefaultUsedTemplateState,
+                        IsActiveSchedule = job.AutoControl?.InitUsedScheduleState ?? DefaultUsedScheduleState,
+                        StatusTypeId = TemplateStatusTypeEnum.Used,
+                        Initiator = initiator,
+                        //NextRun = nextRun,
+                        IsNew = true,
+                        UnitsInTemplate = new List<UnitInTemplateMessage>() // для простого шаблона
+                    };
+
+                    await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
+                }
+                else
+                {
+                    logger.LogDebug("Создание нового шаблона для Job {JobId}, UnitId {UnitId}.", jobId, unitId);
+                    await CreateSimpleTemplateAsync(jobId, unitId, initiator);
+                }
+            }
+
+            // === Обработка существующих шаблонов (проверка имени) ===
+            foreach (var template in existingUsedTemplates)
+            {
+                if (unitIds.Contains(template.UnitId))
+                {
+                    var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(template);
+                    if (!string.Equals(template.Name, expectedName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", template.Id, template.Name, expectedName);
+
+
+                        var updateRequest = new TemplateUpdaterMessage
+                        {
+                            TemplateId = template.Id,
+                            JobId = jobId,
+                            UnitId = template.UnitId,
+                            Name = expectedName,
+                            IsActiveTemplate = template.IsActiveTemplate,
+                            IsActiveSchedule = template.IsActiveSchedule,
+                            IsNew = false,
+                            Index = template.Index,
+                            StatusTypeId = TemplateStatusTypeEnum.Used,
+                            Initiator = initiator,
+                            UnitsInTemplate = new List<UnitInTemplateMessage>() // для простого шаблона
+                        };
+
+                        await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
+                    }
+                }
+            }
+
+            // === Деактивация лишних шаблонов ===
+            foreach (var unusedTemplate in unusedTemplates)
+            {
+                logger.LogInformation("Деактивация лишнего шаблона {TemplateId} (Job {JobId}, UnitId {UnitId}).", unusedTemplate.Id, jobId, unusedTemplate.UnitId);
+                await templateDeactivator.DeactivateTemplateAsync(unusedTemplate, initiator);
+            }
+
+            // === Успешное завершение ===
+            await UpdateMatchingStatusAsync(jobId, "Синхронизация завершена успешно");
+            await matchingStatusService.DeleteMatchingStatusAsync(jobId, SyncTaskEntityTypeEnum.Job);
+            logger.LogInformation("Синхронизация шаблонов завершена для Job {JobId}.", jobId);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при синхронизации Job {JobId}", jobId);
+            await UpdateMatchingStatusAsync(jobId, $"Ошибка: {ex.Message}");
+            throw;
+        }
+    }
+
+    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("Обновление шаблонов для Job {JobId}", jobId);
+
+        // === Проверка: уже запущена? ===
+        var existingStatus = await matchingStatusService.GetStatusAsync(jobId, SyncTaskEntityTypeEnum.Job);
+        if (existingStatus.DetailsJobs?.Any() == true)
+        {
+            logger.LogWarning("Обновление для Job {JobId} уже запущено. Пропускаем.", jobId);
+            return;
+        }
+
+        var initialStatus = new MatchingStatusItemDto
+        {
+            DateStart = DateTimeOffset.UtcNow,
+            Action = TemplateMatcherActionEnum.Update,
+            Comment = "Начало обновления имён"
+        };
+        await matchingStatusService.SetMatchingStatusAsync(
+            jobId,
+            SyncTaskEntityTypeEnum.Job,
+            new MatchingStatusItem { Data = initialStatus, Timestamp = DateTimeOffset.UtcNow, Source = nameof(SimpleTemplateSynchronizer) },
+            TimeSpan.FromMinutes(30)
+        );
+
+        try
+        {
+            var job = await jobService.Get()
+                .AsNoTracking()
+                .Include(j => j.AutoControl)
+                .Include(j => j.Tnk)
+                .Include(j => j.Group)
+                    .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);
+                await UpdateMatchingStatusAsync(jobId, "Job не найден");
+                return;
+            }
+
+            // === Получение отфильтрованных юнитов с полной информацией ===
+            var filteredUnits = await unitFilterService.GetUnitsByJobFilterAsync(jobId);
+            if (filteredUnits == null || !filteredUnits.Any())
+            {
+                logger.LogInformation("Для Job {JobId} фильтры не дали Unit'ов.", jobId);
+                await UpdateMatchingStatusAsync(jobId, "Нет Unit'ов — обновление не требуется");
+                await matchingStatusService.DeleteMatchingStatusAsync(jobId, SyncTaskEntityTypeEnum.Job);
+                return;
+            }
+
+            // Извлекаем ID юнитов для последующих операций
+            var unitIds = filteredUnits.Select(u => u.Id).ToList();
+
+#if DEBUG
+            // Отладка: проверить, есть ли юнит в unitIds
+            if (unitIds.Contains(targetUnitId))
+            {
+                logger.LogDebug("Юнит {TargetUnitId} найден в unitIds.", targetUnitId);
+            }
+            else
+            {
+                logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIds.", targetUnitId);
+            }
+#endif
+
+            var existingTemplates = await templateService.Get()
+                .AsNoTracking()
+                .Include(t => t.Unit)
+                .Include(t => t.UnitsInTemplate)
+                .Include(t => t.Job)
+                    .ThenInclude(t => t!.Group)
+                        .ThenInclude(t => t!.GroupType)
+                .Include(t => t.Job)
+                    .ThenInclude(t => t!.Tnk)
+                .Where(t => t.JobId == jobId && t.StatusTypeId == TemplateStatusTypeEnum.Used)
+                .ToListAsync();
+
+            foreach (var template in existingTemplates)
+            {
+                if (unitIds.Contains(template.UnitId))
+                {
+                    var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(template);
+                    if (!string.Equals(template.Name, expectedName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", template.Id, template.Name, expectedName);
+
+                        //var nextRun = await nextRunService.GetNextRunForTemplateAsync(template.Id, false);
+
+                        var updateRequest = new TemplateUpdaterMessage
+                        {
+                            TemplateId = template.Id,
+                            JobId = jobId,
+                            UnitId = template.UnitId,
+                            Name = expectedName,
+                            IsActiveTemplate = template.IsActiveTemplate,
+                            IsActiveSchedule = template.IsActiveSchedule,
+                            //LastRun = template.LastRun,
+                            //NextRun = nextRun,
+                            IsNew = false,
+                            Index = template.Index,
+                            StatusTypeId = TemplateStatusTypeEnum.Used,
+                            Initiator = initiator,
+                            UnitsInTemplate = new List<UnitInTemplateMessage>() // для простого шаблона
+                        };
+
+                        await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
+                    }
+                }
+            }
+
+            await UpdateMatchingStatusAsync(jobId, "Обновление завершено");
+            await matchingStatusService.DeleteMatchingStatusAsync(jobId, SyncTaskEntityTypeEnum.Job);
+            logger.LogInformation("Обновление шаблонов завершено для Job {JobId}.", jobId);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при обновлении Job {JobId}", jobId);
+            await UpdateMatchingStatusAsync(jobId, $"Ошибка: {ex.Message}");
+            throw;
+        }
+    }
+
+
+    private async Task SyncUnusedTemplatesAsync(Guid unusedJobId, HistoryInitiator initiator)
+    {
+        var existingStatus = await matchingStatusService.GetStatusAsync(unusedJobId, SyncTaskEntityTypeEnum.Job);
+        if (existingStatus.DetailsJobs?.Any() == true)
+        {
+            logger.LogWarning("Синхронизация для Job неиспользуемых шаблонов {JobId} уже запущена. Пропускаем.", unusedJobId);
+            return;
+        }
+
+        var initialStatus = new MatchingStatusItemDto
+        {
+            DateStart = DateTimeOffset.UtcNow,
+            Action = TemplateMatcherActionEnum.Sync,
+            Comment = "Синхронизация неиспользуемых шаблонов"
+        };
+        await matchingStatusService.SetMatchingStatusAsync(
+            unusedJobId,
+            SyncTaskEntityTypeEnum.Job,
+            new MatchingStatusItem { Data = initialStatus, Timestamp = DateTimeOffset.UtcNow, Source = nameof(SimpleTemplateSynchronizer) },
+            TimeSpan.FromMinutes(30)
+        );
+
+        try
+        {
+            // 1. Находим ID нужных полей
+            var zoRgField = await unitFieldService.GetByAihitNameAsync("ЗОНА_ОТВЕТСТВЕННОСТИ");
+            var tagField = await unitFieldService.GetByAihitNameAsync("ПАРР тег");
+
+            if (zoRgField == null || tagField == null)
+            {
+                logger.LogError("Не найдены поля 'ЗОНА_ОТВЕТСТВЕННОСТИ' или 'Тег'. Синхронизация прервана.");
+                await UpdateMatchingStatusAsync(unusedJobId, "Ошибка конфигурации полей");
+                return;
+            }
+
+            var zoRgFieldId = zoRgField.Id;
+            var tagFieldId = tagField.Id;
+            const string targetTagValue = "ПАРР-НЕИСП";
+
+            // 2. Находим ValueId для тега "ПАРР-НЕИСП"
+            var targetTagValueId = await unitInValueService.Get()
+                .AsNoTracking()
+                .Where(uiv => uiv.FieldId == tagFieldId && uiv.Value != null && uiv.Value.Value == targetTagValue)
+                .Select(uiv => uiv.ValueId)
+                .FirstOrDefaultAsync();
+
+            if (targetTagValueId == Guid.Empty)
+            {
+                logger.LogWarning("Значение '{TagValue}' для поля 'Тег' не найдено в справочнике UnitFieldValue.", targetTagValue);
+            }
+
+            var unusedJob = await jobService.Get()
+                .AsNoTracking()
+                .Include(j => j.Group)
+                .FirstOrDefaultAsync(j => j.Id == unusedJobId);
+
+            if (unusedJob == null)
+            {
+                logger.LogError("Job неиспользуемых шаблонов {JobId} не найден.", unusedJobId);
+                await UpdateMatchingStatusAsync(unusedJobId, "Job не найден");
+                return;
+            }
+
+            var unusedTemplates = await templateService.Get()
+                .Include(t => t.Unit)
+                .Include(t => t.Job)
+                    .ThenInclude(t => t.Group)
+                        .ThenInclude(t => t.GroupType)
+                .Include(t => t.Job)
+                    .ThenInclude(t => t.Tnk)
+                .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Unused)
+                .ToListAsync();
+
+            if (!unusedTemplates.Any())
+            {
+                logger.LogInformation("Не найдено шаблонов со статусом Unused.");
+                await UpdateMatchingStatusAsync(unusedJobId, "Нет шаблонов для обработки");
+                await matchingStatusService.DeleteMatchingStatusAsync(unusedJobId, SyncTaskEntityTypeEnum.Job);
+                return;
+            }
+
+            await UpdateMatchingStatusAsync(unusedJobId, $"Найдено {unusedTemplates.Count} шаблонов для обработки");
+
+            int processed = 0;
+            var allTemplateUnitIds = unusedTemplates.Select(t => t.UnitId).Distinct().ToList();
+
+            // Получаем значения ЗОНА_ОТВЕТСТВЕННОСТИ для всех юнитов шаблонов
+            var unitZoRgValues = await unitInValueService.GetByUnitIdsAndFieldIdsAsync(allTemplateUnitIds, new List<Guid> { zoRgFieldId });
+            var unitToZoRgValueMap = unitZoRgValues
+                .Where(uiv => uiv.ValueId != Guid.Empty)
+                .ToDictionary(uiv => uiv.UnitId, uiv => uiv.ValueId);
+
+            foreach (var template in unusedTemplates)
+            {
+                try
+                {
+                    if (template.Unit == null)
+                    {
+                        logger.LogWarning("У шаблона {TemplateId} отсутствует Unit. Пропускаем.", template.Id);
+                        processed++;
+                        continue;
+                    }
+
+                    if (!unitToZoRgValueMap.TryGetValue(template.UnitId, out var currentZoRgValueId))
+                    {
+                        logger.LogDebug("У юнита {UnitId} шаблона {TemplateId} нет значения поля ЗОНА_ОТВЕТСТВЕННОСТИ. Пропускаем замену UnitId.", template.UnitId, template.Id);
+
+                        // Исправлено: используем другое имя или просто вызываем метод
+                        var nameForUpdate = await GenerateUnusedTemplateNameAsync(template, unusedJob, template.Unit);
+                        await SendUpdateRequest(template, unusedJobId, nameForUpdate, initiator, template.UnitId);
+                        processed++;
+                        continue;
+                    }
+
+                    Guid? targetUnitId = null;
+
+                    if (targetTagValueId != Guid.Empty)
+                    {
+                        var candidatesWithZoRg = await unitInValueService.Get()
+                            .AsNoTracking()
+                            .Where(uiv => uiv.FieldId == zoRgFieldId && uiv.ValueId == currentZoRgValueId)
+                            .Select(uiv => uiv.UnitId)
+                            .Distinct()
+                            .ToListAsync();
+
+                        if (candidatesWithZoRg.Any())
+                        {
+                            // Сначала проверим, есть ли вообще такие юниты
+                            var foundUnitId = await unitInValueService.Get()
+                                .AsNoTracking()
+                                .Where(uiv => uiv.FieldId == tagFieldId && uiv.ValueId == targetTagValueId && candidatesWithZoRg.Contains(uiv.UnitId))
+                                .Select(uiv => uiv.UnitId)
+                                .FirstOrDefaultAsync();
+
+                            // Если нашли реальный Guid (не Empty), то используем его
+                            if (foundUnitId != Guid.Empty)
+                            {
+                                targetUnitId = foundUnitId;
+                            }
+                        }
+                    }
+
+                    Guid finalUnitId = targetUnitId ?? template.UnitId;
+                    Unit finalUnit = template.Unit;
+
+                    if (targetUnitId.HasValue && targetUnitId.Value != template.UnitId)
+                    {
+                        logger.LogInformation("Для шаблона {TemplateId} найден новый UnitId {NewUnitId} (был {OldUnitId}).",
+                            template.Id, targetUnitId.Value, template.UnitId);
+
+                        // Загружаем новый юнит для генерации имени
+                        var newUnit = await unitRepository.Get().AsNoTracking()
+                                                .FirstOrDefaultAsync(u => u.Id == targetUnitId.Value);
+
+                        if (newUnit != null)
+                            finalUnit = newUnit;
+                        else
+                        {
+                            logger.LogWarning("Не удалось загрузить новый юнит {UnitId}. Используем старый.", targetUnitId.Value);
+                            finalUnitId = template.UnitId;
+                        }
+                    }
+
+                    // Здесь expectedName объявляется впервые в этой итерации цикла, конфликта нет
+                    var expectedName = await GenerateUnusedTemplateNameAsync(template, unusedJob, finalUnit);
+                    await SendUpdateRequest(template, unusedJobId, expectedName, initiator, finalUnitId);
+
+                    processed++;
+                    await UpdateMatchingStatusAsync(unusedJobId, $"Обработано: {processed}/{unusedTemplates.Count}");
+                }
+                catch (Exception ex)
+                {
+                    logger.LogError(ex, "Ошибка при обработке шаблона {TemplateId}", template.Id);
+                }
+            }
+
+            await UpdateMatchingStatusAsync(unusedJobId, "Синхронизация неиспользуемых шаблонов завершена");
+            await matchingStatusService.DeleteMatchingStatusAsync(unusedJobId, SyncTaskEntityTypeEnum.Job);
+            logger.LogInformation("Синхронизация неиспользуемых шаблонов завершена. Обработано {Count} шаблонов.", unusedTemplates.Count);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Ошибка при синхронизации неиспользуемых шаблонов для Job {JobId}", unusedJobId);
+            await UpdateMatchingStatusAsync(unusedJobId, $"Ошибка: {ex.Message}");
+            throw;
+        }
+    }
+
+    private async Task SendUpdateRequest(Template template, Guid jobId, string name, HistoryInitiator initiator, Guid unitId)
+    {
+        var updateRequest = new TemplateUpdaterMessage
+        {
+            TemplateId = template.Id,
+            JobId = jobId,
+            UnitId = unitId,
+            Name = name,
+            IsActiveTemplate = false,
+            IsActiveSchedule = false,
+            IsNew = false,
+            Index = null,
+            StatusTypeId = template.StatusTypeId,
+            Initiator = initiator,
+            UnitsInTemplate = new List<UnitInTemplateMessage>()
+        };
+
+        await templateUpdaterMqSender.SendTemplateUpdateMessageAsync(updateRequest);
+    }
+
+
+    private async Task<string> GenerateUnusedTemplateNameAsync(Template template, Job unusedJob, Unit unit)
+    {
+        var tempJob = new Job
+        {
+            Id = unusedJob.Id,
+            Name = unusedJob.Name,
+            WorkName = unusedJob.WorkName,
+            MinValueRelationships = unusedJob.MinValueRelationships,
+            MaxValueRelationships = unusedJob.MaxValueRelationships,
+            IsParentRelationships = unusedJob.IsParentRelationships,
+            TemplateNameMask = templateSettings.Value.UnusedTemplateNameMask,
+            WorkGroupMask = unusedJob.WorkGroupMask,
+            ResponseAreaMask = unusedJob.ResponseAreaMask,
+            TnkId = unusedJob.TnkId,
+            GroupId = unusedJob.GroupId,
+            Group = unusedJob.Group,
+            Tnk = unusedJob.Tnk,
+            UnitFilters = unusedJob.UnitFilters,
+            Templates = unusedJob.Templates,
+            AutoControl = unusedJob.AutoControl
+        };
+
+        var tempTemplateForName = new Template
+        {
+            Id = template.Id,
+            Name = template.Name,
+            JobId = unusedJob.Id,
+            UnitId = unit.Id,
+            Index = null,
+            Job = tempJob,
+            Unit = unit,
+            UnitsInTemplate = new List<UnitsInTemplate>()
+        };
+
+        return await templateNameNormalizer.GetNormalizedTemplateNameAsync(tempTemplateForName);
+    }
+
+
+    private async Task CreateSimpleTemplateAsync(Guid jobId, Guid unitId, HistoryInitiator initiator)
+    {
+        logger.LogInformation("Создание нового простого шаблона для Job {JobId}, UnitId {UnitId}.", jobId, unitId);
+
+        var mqRequest = new TemplateGeneratorMessage
+        {
+            JobId = jobId,
+            UnitId = unitId,
+            UnitsInTemplate = new List<UnitInTemplateMessage>(), // для простого шаблона
+            HistoryInitiator = initiator
+        };
+
+        var result = await mqService.SendAsync(mqSettings.TemplateGenerator, new List<object> { mqRequest });
+
+        if (!result.IsSuccess)
+            logger.LogError("Ошибка отправки команды создания простого шаблона для Job {JobId}, UnitId {UnitId}.", jobId, unitId);
+    }
+
+
+    private async Task UpdateMatchingStatusAsync(Guid jobId, string comment)
+    {
+        var status = new MatchingStatusItemDto
+        {
+            DateStart = DateTimeOffset.UtcNow,
+            Action = TemplateMatcherActionEnum.Sync,
+            Comment = comment
+        };
+        await matchingStatusService.SetMatchingStatusAsync(
+            jobId,
+            SyncTaskEntityTypeEnum.Job,
+            new MatchingStatusItem { Data = status, Timestamp = DateTimeOffset.UtcNow, Source = nameof(SimpleTemplateSynchronizer) },
+            TimeSpan.FromMinutes(30)
+        );
+    }
+}