feat(templateMatcher): добавлен метод UpdateTemplatesForJob, MatchTemplates переименован в SyncTemplatesForJob+расширена логика работы.

PARR.BLL/Domain/Mq/TemplateMatcherMq.cs

@@ -8,7 +8,6 @@ namespace PARR.BLL.Domain.Mq
         public Guid Id { get; set; }
         public SyncTaskEntityTypeEnum EntityType { get; set; }
         public TemplateMatcherActionEnum Action { get; set; }
-
+        public required HistoryInitiator Initiator { get; set; }
-        public required IHistoryInitiator Initiator { get; set; }
     }
 }

PARR.TemplateMatcher/ITemplateMatcher.cs

@@ -1,9 +1,10 @@
-namespace PARR.TemplateMatcher
+using PARR.Common.Domain;
+
+namespace PARR.TemplateMatcher
 {
     internal interface ITemplateMatcher
     {
-        Task MatchTemplatesForJob(Guid jobId);
+        Task SyncTemplatesForJob(Guid jobId, HistoryInitiator initiator);
-        Task MatchTemplatesForJobGroup(Guid jobGroupId);
+        Task UpdateTemplatesForJob(Guid jobId, HistoryInitiator initiator);
-        Task MatchTemplatesForTemplate(Guid templateId);
     }
 }

PARR.TemplateMatcher/MqTemplateMatcher.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Logging;
 using PARR.BLL.Domain.Mq;
 using PARR.BLL.Services.Interfaces;
+using PARR.Constants;
 using PARR.TemplateMatcher.Services.Interfaces;
 using PARR.TemplateMatcher.Settings;
 
@@ -46,7 +47,10 @@ namespace PARR.TemplateMatcher
 
             var query = transformService.GetModelFromJson<TemplateMatcherMq>(msg);
             if (query == null)
+            {
+                logger.LogWarning("Не удалось десериализовать сообщение в TemplateMatcherMq: {Message}", msg);
                 return;
+            }
 
             await using (var scope = serviceProvider.CreateAsyncScope())
             {
@@ -54,13 +58,38 @@ namespace PARR.TemplateMatcher
 
                 switch (query.EntityType)
                 {
-                    case Constants.SyncTaskEntityTypeEnum.Job:
+                    case SyncTaskEntityTypeEnum.Job:
                         var validatorService = GetServiceInScope<IJobValidatorService>(scope);
                         if (!await validatorService.IsValidAsync(query.Id))
+                        {
+                            logger.LogWarning("Сущность {EntityType} с Id {Id} не прошла валидацию", query.EntityType, query.Id);
                             return;
+                        }
 
-                        await templateMatcherService.MatchTemplatesForJob(query.Id);
+                        switch (query.Action)
+                        {
+                            case TemplateMatcherActionEnum.Sync:
+                                // Создать недостающие шаблоны, привязать к нужному Job, включить/выключить по фильтрам
+                                await templateMatcherService.SyncTemplatesForJob(query.Id, query.Initiator);
+                                break;
+                            case TemplateMatcherActionEnum.Update:
+                                // Обновить существующие шаблоны: имя, привязка к Job, вкл/выкл по фильтрам
+                                await templateMatcherService.UpdateTemplatesForJob(query.Id, query.Initiator);
+                                break;
+                            default:
+                                logger.LogWarning("Неизвестное действие для {EntityType}: {Action}", query.EntityType, query.Action);
+                                break;
+                        }
                         break;
+
+                    case SyncTaskEntityTypeEnum.JobGroup:
+                        logger.LogWarning("Обработка EntityType JobGroup не реализована. Id: {Id}, Action: {Action}", query.Id, query.Action);
+                        break;
+
+                    case SyncTaskEntityTypeEnum.Template:
+                        logger.LogWarning("Обработка EntityType Template не реализована. Id: {Id}, Action: {Action}", query.Id, query.Action);
+                        break;
+
                     default:
                         logger.LogWarning("Неизвестный тип сущности: {EntityType}", query.EntityType);
                         break;

PARR.TemplateMatcher/Settings/MqSettings.cs

@@ -1,10 +1,4 @@
 using PARR.BLL.Contracts.Interfaces;
-using PARR.BLL.Domain.Mq;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace PARR.TemplateMatcher.Settings
 {
@@ -12,6 +6,7 @@ namespace PARR.TemplateMatcher.Settings
     {
         public TemplateMatcher TemplateMatcher { get; set; } = new TemplateMatcher();
         public TemplateGenerator TemplateGenerator { get; set; } = new TemplateGenerator();
+        public TemplateUpdater TemplateUpdater { get; set; } = new TemplateUpdater();
     }
 
     internal class TemplateMatcher : IMqSettings
@@ -31,4 +26,13 @@ namespace PARR.TemplateMatcher.Settings
         public string Password { get; set; } = string.Empty;
         public ushort? PrefetchCount { get; set; } = 0;
     }
+
+    internal class TemplateUpdater : IMqSettings
+    {
+        public string HostName { get; set; } = string.Empty;
+        public string QueueName { get; set; } = string.Empty;
+        public string User { get; set; } = string.Empty;
+        public string Password { get; set; } = string.Empty;
+        public ushort? PrefetchCount { get; set; } = 0;
+    }
 }

PARR.TemplateMatcher/TemplateMatcher.cs

@@ -1,9 +1,14 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using PARR.BLL.Domain.Mq;
 using PARR.BLL.Services.Interfaces;
 using PARR.Common.Domain;
 using PARR.Constants;
 using PARR.DAL.DomainServices.Interfaces;
+using PARR.DAL.Models;
+using PARR.DAL.Models.Job;
+using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Job;
 using PARR.TemplateMatcher.Settings;
 using System.Text.Json;
 
@@ -15,58 +20,247 @@ namespace PARR.TemplateMatcher
         private readonly IUnitFilterService unitFilterService;
         private readonly MqSettings mqSettings;
         private readonly IMqService mqService;
+        private readonly ITemplateService templateService;
+        private readonly IJobService jobService;
+        private readonly IShortcodesService shortcodesService;
 
         public TemplateMatcher(
             ILogger<TemplateMatcher> logger,
             IUnitFilterService unitFilterService,
             MqSettings mqSettings,
-            IMqService mqService
+            IMqService mqService,
+            ITemplateService templateService,
+            IJobService jobService,
+            IShortcodesService shortcodesService
             )
         {
             this.logger = logger;
             this.unitFilterService = unitFilterService;
             this.mqSettings = mqSettings;
             this.mqService = mqService;
+            this.templateService = templateService;
+            this.jobService = jobService;
+            this.shortcodesService = shortcodesService;
         }
-        public async Task MatchTemplatesForJob(Guid jobId)
+
+
+        public async Task SyncTemplatesForJob(Guid jobId, HistoryInitiator initiator)
         {
-            var unitIdsToCreateTemplate = await unitFilterService.GetUnitsIdByJobFilterWithTemplateStatusAsync(jobId,false);
+            logger.LogDebug("Начало синхронизации шаблонов для JobId {JobId}", jobId);
 
-            if (unitIdsToCreateTemplate == null || !unitIdsToCreateTemplate.Any())
+            // 1. Получаем UnitId, которые должны иметь шаблоны (по фильтрам Job)
-                return;
+            var units = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
-
+            if (units == null)
-            foreach (var unitId in unitIdsToCreateTemplate)
             {
+                logger.LogWarning("Для JobId {JobId} фильтр вернул null. Пропускаем.", jobId);
+                return;
+            }
+            var expectedUnitIds = units.ToHashSet();
+
+            logger.LogDebug("Для JobId {JobId} найдено {Count} Unit'ов, соответствующих фильтрам.", jobId, expectedUnitIds.Count);
+
+            if (!expectedUnitIds.Any())
+            {
+                logger.LogInformation("Для JobId {JobId} не найдено Unit'ов, соответствующих фильтрам.", jobId);
+                return;
+            }
+
+            // 2. Получаем все шаблоны для этого Job
+            var existingTemplates = await templateService.Get()
+                                            .Where(t => t.JobId == jobId)
+                                            .ToListAsync();
+
+            logger.LogDebug("Для JobId {JobId} найдено {Count} существующих шаблонов.", jobId, existingTemplates.Count());
+
+            // 3. Получаем Job, чтобы получить маску имени
+            var job = await jobService.GetAsync(jobId);
+            if (job == null)
+            {
+                logger.LogError("Job с Id {JobId} не найден.", jobId);
+                return;
+            }
+
+            // 4. Находим UnitId, для которых нет шаблонов (нужно создать)
+            var existingUnitIds = existingTemplates.Select(t => t.UnitId).ToHashSet();
+            var unitIdsToCreate = expectedUnitIds.Except(existingUnitIds);
+
+            logger.LogDebug("Для JobId {JobId} найдено {Count} Unit'ов без шаблонов (требуется создание).", jobId, unitIdsToCreate.Count());
+
+            foreach (var unitId in unitIdsToCreate)
+            {
+                logger.LogInformation("Для UnitId {UnitId} нет шаблона, запрашиваем создание.", unitId);
+
                 var mqRequest = new TemplateGeneratorWorkerMq
                 {
                     JobId = jobId,
                     UnitId = unitId,
-                    HistoryInitiator = new HistoryInitiator { InitiatorComment = "Запрос на создание шаблона", InitiatorParrComponentId = ParrComponentsEnum.TemplateTaskGenerator }
+                    HistoryInitiator = initiator
                 };
 
                 var msg = JsonSerializer.Serialize(mqRequest);
-
-                //var result = new MqSendResult { IsSuccess = true };
                 var result = await mqService.SendAsync(mqSettings.TemplateGenerator, new[] { msg });
 
                 if (result.IsSuccess)
-                    logger.LogInformation($"Отправлен запрос на создание шаблона: {msg}");
+                    logger.LogInformation("Отправлен запрос на создание шаблона для UnitId {UnitId} в JobId {JobId}", unitId, jobId);
                 else
-                    logger.LogError($"Ошибка при отправке запроса на создание шаблона: {msg}");
+                    logger.LogError("Ошибка при отправке запроса на создание шаблона для UnitId {UnitId} в JobId {JobId}: {Message}", unitId, jobId, msg);
+            }
+
+            // 5. Находим шаблоны, которые больше не соответствуют фильтрам (нужно отключить/обновить)
+            var unitIdsToRemove = existingUnitIds.Except(expectedUnitIds);
+
+            logger.LogDebug("Для JobId {JobId} найдено {Count} Unit'ов с шаблонами, которые больше не соответствуют фильтрам (требуется обновление/отключение).", jobId, unitIdsToRemove.Count());
+
+            foreach (var template in existingTemplates)
+            {
+                var unitId = template.UnitId;
+                if (unitIdsToRemove.Contains(template.UnitId))
+                {
+                    logger.LogInformation("Шаблон {TemplateId} для UnitId {UnitId} больше не соответствует фильтрам Job. Требуется обновление статуса.", template.Id, template.UnitId);
+
+                    // 1. Меняем статус
+                    template.StatusTypeId = TemplateStatusTypeEnum.Updating;
+
+                    // 2. Сохраняем изменения в базе через сервис
+                    var saved = await templateService.CommitAsync(initiator);
+                    if (!saved)
+                    {
+                        logger.LogError(null, "Не удалось сохранить изменения шаблона {TemplateId} перед отправкой в очередь обновления.", template.Id);
+                        continue; // пропускаем этот шаблон
+                    }
+
+                    // 3. Подготовим сообщение
+                    var updateRequest = new TemplateUpdaterMq
+                    {
+                        TemplateId = template.Id,
+                        JobId = template.JobId,
+                        Name = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask, template.UnitId, jobId),
+                        IsActiveTemplate = template.IsActiveTemplate,
+                        IsActiveSchedule = false,
+                        LastRun = template.LastRun,
+                        NextRun = template.NextRun,
+                        UnitId = template.UnitId,
+                        Index = template.Index,
+                        StatusTypeId = TemplateStatusTypeEnum.Unused, // после обновления статус должен быть Unused
+                        Initiator = initiator
+                    };
+
+                    // 4. Отправляем в очередь
+                    await SendTemplateUpdateMessage(updateRequest);
+                }
+                else
+                {
+                    // Unit всё ещё соответствует фильтрам — проверим, нужно ли обновить имя
+                    logger.LogDebug("Шаблон {TemplateId} для UnitId {UnitId} соответствует фильтрам. Проверяем имя.", template.Id, unitId);
+                    await CheckAndSendNameUpdateIfRequired(template, job, initiator);
+                }
+            }
+
+            logger.LogDebug("Окончание синхронизации шаблонов для JobId {JobId}", jobId);
+        }
+
+
+        public async Task UpdateTemplatesForJob(Guid jobId, HistoryInitiator initiator)
+        {
+            logger.LogDebug("Начало обновления имён шаблонов для JobId {JobId}", jobId);
+
+            // 1. Получаем все шаблоны для этого Job
+            var existingTemplates = await templateService.Get()
+                                            .Where(t => t.JobId == jobId)
+                                            .ToListAsync();
+
+            logger.LogDebug("Для JobId {JobId} найдено {Count} существующих шаблонов.", jobId, existingTemplates.Count());
+
+            if (!existingTemplates.Any())
+            {
+                logger.LogInformation("Для JobId {JobId} не найдено существующих шаблонов для обновления имени.", jobId);
+                return;
+            }
+
+            // 2. Получаем Job, чтобы получить маску имени
+            var job = await jobService.GetAsync(jobId);
+            if (job == null)
+            {
+                logger.LogError("Job с Id {JobId} не найден.", jobId);
+                return;
+            }
+
+            foreach (var template in existingTemplates)
+            {
+                logger.LogDebug("Проверяем имя шаблона {TemplateId} для UnitId {UnitId}.", template.Id, template.UnitId);
+                // Проверяем, нужно ли обновить имя
+                await CheckAndSendNameUpdateIfRequired(template, job, initiator);
+            }
+
+            logger.LogDebug("Окончание обновления имён шаблонов для JobId {JobId}", jobId);
+        }
+
+
+        private async Task CheckAndSendNameUpdateIfRequired(Template template, Job job, HistoryInitiator initiator)
+        {
+            var expectedName = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask, template.UnitId, job.Id);
+
+            logger.LogDebug("Шаблон {TemplateId}: текущее имя '{CurrentName}', ожидаемое имя '{ExpectedName}'", template.Id, template.Name, expectedName);
+
+            if (template.Name != expectedName)
+            {
+                logger.LogInformation("Шаблон {TemplateId} для UnitId {UnitId} имеет устаревшее имя. Требуется обновление.", template.Id, template.UnitId);
+
+                // 1. Меняем статус в шаблоне
+                template.StatusTypeId = TemplateStatusTypeEnum.Updating;
+
+                // 2. Сохраняем изменения в базе через сервис
+                var saved = await templateService.CommitAsync(initiator);
+                if (!saved)
+                {
+                    logger.LogError("Не удалось сохранить изменения шаблона {TemplateId} перед отправкой в очередь обновления.", template.Id);
+                    return; // не отправляем сообщение, если не сохранили
+                }
+
+                // 3. Подготовим сообщение для отправки в очередь
+                var updateRequest = new TemplateUpdaterMq
+                {
+                    TemplateId = template.Id,
+                    JobId = template.JobId,
+                    Name = expectedName,
+                    IsActiveTemplate = template.IsActiveTemplate,
+                    IsActiveSchedule = template.IsActiveSchedule,
+                    LastRun = template.LastRun,
+                    NextRun = template.NextRun,
+                    UnitId = template.UnitId,
+                    Index = template.Index,
+                    StatusTypeId = TemplateStatusTypeEnum.Used,
+                    Initiator = initiator
+                };
+
+                // 4. Отправляем в очередь
+                await SendTemplateUpdateMessage(updateRequest);
+            }
+            else
+            {
+                logger.LogDebug("Шаблон {TemplateId} для UnitId {UnitId} имеет актуальное имя.", template.Id, template.UnitId);
             }
         }
 
-        public Task MatchTemplatesForJobGroup(Guid jobGroupId)
+
+        private async Task SendTemplateUpdateMessage(TemplateUpdaterMq updateRequest)
         {
-            throw new NotImplementedException();
+            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}: {Message}",
+                    updateRequest.TemplateId, msg);
+            }
         }
-
-        public Task MatchTemplatesForTemplate(Guid templateId)
-        {
-            throw new NotImplementedException();
-        }
-
-
-
     }
 }

PARR.TemplateMatcherWorker/appsettings.Development.json

@@ -17,8 +17,9 @@
       }
     ]
   },
-  "MqSettings": {
+    "MqSettings": {
-    "TemplateMatcher": { "HostName": "10.99.253.216" },
+        "TemplateMatcher": { "HostName": "10.99.253.216" },
-    "TemplateGenerator": { "HostName": "10.99.253.216" }
+        "TemplateGenerator": { "HostName": "10.99.253.216" },
-  }
+        "TemplateUpdater": { "HostName": "10.99.253.216" }
+    }
 }

PARR.TemplateMatcherWorker/appsettings.json

@@ -12,18 +12,24 @@
       }
     }
   },
-  "MqSettings": {
+    "MqSettings": {
-    "TemplateMatcher": {
+        "TemplateMatcher": {
-      "HostName": "parr-rabbitmq",
+            "HostName": "parr-rabbitmq",
-      "QueueName": "parr-template-matcher",
+            "QueueName": "parr-template-matcher",
-      "User": "template_matcher_reader",
+            "User": "template_matcher_reader",
-      "Password": "wzqj$Z@3:poasad;lk324@oot"
+            "Password": "wzqj$Z@3:poasad;lk324@oot"
-    },
+        },
-    "TemplateGenerator": {
+        "TemplateGenerator": {
-      "HostName": "parr-rabbitmq",
+            "HostName": "parr-rabbitmq",
-      "QueueName": "parr-template-generator",
+            "QueueName": "parr-template-generator",
-      "User": "template_generator_writer",
+            "User": "template_generator_writer",
-      "Password": "B;6h+yF$zQ0OSkLX"
+            "Password": "B;6h+yF$zQ0OSkLX"
+        },
+        "TemplateUpdater": {
+            "HostName": "parr-rabbitmq",
+            "QueueName": "parr-template-updater",
+            "User": "template_updater_writer",
+            "Password": "sjdhgfkJHGIUFDi14asd^12"
+        }
     }
-  }
 }