feat(api,templateActivator): обновлена логика templateActivator

PARR.API/Contracts/V1/ApiRoutes.cs

@@ -416,9 +416,12 @@
         /// </summary>
         public static class TemplateActivator
         {
-            public const string SendRequest = Base + "/jobs/" + jobId + "/template-activator";
+            public const string SendRequest = Base + "/templates/change-state";
 
-            public const string jobId = "{jobId}";
+
+            //public const string SendRequest = Base + "/jobs/" + jobId + "/template-activator";
+
+            //public const string jobId = "{jobId}";
         }
 
         #endregion

PARR.API/Contracts/V1/Requests/TemplateActivatorRequest.cs

@@ -4,9 +4,34 @@ namespace PARR.API.Contracts.V1.Requests
 {
     public class TemplateActivatorRequest
     {
+        ///// <summary>
+        ///// Действие по активации/деактивации
+        ///// </summary>
+        //public TemplateActivatorActionsEnum Action { get; set; }
+
         /// <summary>
-        /// Действие по активации/деактивации
+        /// ИД объекта, JobGroupId, JobId, TemplateId
         /// </summary>
-        public TemplateActivatorActionsEnum Action { get; set; }
+        public Guid Id { get; set; }
+
+        /// <summary>
+        /// Тип объекта
+        /// </summary>
+        public SyncTaskEntityTypeEnum EntityType { get; set; }
+
+        ///// <summary>
+        ///// Учитывать неиспользованные шаблоны
+        ///// </summary>
+        //public bool AllowUnused { get; set; } = false;
+
+        /// <summary>
+        /// Объект воздейстивя (шаблон, расписание)
+        /// </summary>
+        public TemplateActivatorEsppObjectTypesEnum EsppObject { get; set; }
+
+        /// <summary>
+        /// Новое состояние объекта
+        /// </summary>
+        public bool NewState { get; set; }
     }
 }

PARR.API/Controllers/V1/RobotTaskRobotStatusController.cs

@@ -56,7 +56,7 @@ namespace PARR.API.Controllers.V1
 
             //если успех, изменяем статус задания на успех
             if (request.RobotStatusCode == RobotStatusEnum.Complete)
-                robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Ok, ref config);
+                robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Ok, config);
 
             if (!await robotConfigurationService.CommitAsync())
                 return BadRequest("Ошибка при изменении статуса работы робота.");

PARR.API/Controllers/V1/TemplateActivatorController.cs

@@ -50,25 +50,20 @@ namespace PARR.API.Controllers.V1
         /// <summary>
         /// Отправить запрос на активацию/деактивацию шаблонов/расписаний
         /// </summary>
-        /// <param name="jobId"></param>
         /// <returns></returns>
         [HttpPost(ApiRoutes.TemplateActivator.SendRequest)]
-        public async Task<IActionResult> SendRequest([FromRoute] Guid jobId, [FromBody] TemplateActivatorRequest request)
+        public async Task<IActionResult> SendRequest([FromBody] TemplateActivatorRequest request)
         {
             var resultValidate = await validator.ValidateAsync(request);
             if (!resultValidate.IsValid)
                 return BadRequest(new Response(resultValidate.Errors));
 
-            var job = await jobService.GetAsync(jobId);
-
-            if (job == null)
-                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { FieldName = nameof(jobId), Message = "Некорректное значение" } }));
-
-
             var mqRequest = new TemplateActivatorMq
             {
-                JobId = jobId,
+                Id = request.Id,
-                Action = request.Action,
+                EntityType = request.EntityType,
+                EsppObject = request.EsppObject,
+                NewState = request.NewState,
                 HistoryInitiator = new HistoryInitiator { InitiatorIp = clientService.GetClientIp()?.ToString(), InitiatorParrComponentId = ParrComponentsEnum.Api }
             };
 

PARR.API/Controllers/V1/TemplateController.cs

@@ -118,6 +118,9 @@ namespace PARR.API.Controllers.V1
         [HttpPut(ApiRoutes.Template.ChangeState)]
         public async Task<IActionResult> ChangeState([FromRoute] Guid id, [FromBody] TemplateChangeStateRequest request)
         {
+            //TODO:!!! Возможно тут не надо сразу менять, а отправить запрос в TemplateActivator и пусть он сам занимается своей работой!!!
+
+
             var template = await templateService.GetWithIncludes()
                                                            .Include(t => t.Unit).ThenInclude(t => t!.UnitValues).ThenInclude(t => t.Field)
                                                            .Include(t => t.Unit).ThenInclude(t => t!.UnitValues).ThenInclude(t => t.Value)
@@ -135,16 +138,16 @@ namespace PARR.API.Controllers.V1
             {
                 template.IsActiveTemplate = request.IsActiveTemplate;
                 //необходимо обновить шаблон
-                var config = robotConfigurationService.GetFromTemplateByRobotCode(RobotsEnum.TemplateOrder, ref template);
+                var config = robotConfigurationService.GetFromTemplateByRobotCode(RobotsEnum.TemplateOrder, template);
-                robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, ref config);
+                robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, config);
             }
 
             if (template.IsActiveSchedule != request.IsActiveSchedule)
             {
                 template.IsActiveSchedule = request.IsActiveSchedule;
                 //необходимо обновить расписание
-                var config = robotConfigurationService.GetFromTemplateByRobotCode(RobotsEnum.ScheduleOrder, ref template);
+                var config = robotConfigurationService.GetFromTemplateByRobotCode(RobotsEnum.ScheduleOrder, template);
-                robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, ref config);
+                robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, config);
             }
 
             if (!await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Изменён статус шаблона/расписания", InitiatorIp = clientService.GetClientIp()?.ToString(), InitiatorParrComponentId = ParrComponentsEnum.Api }))

PARR.API/Validators/TemplateActivatorRequestValidator.cs

@@ -1,16 +1,43 @@
 using FluentValidation;
 using PARR.API.Contracts.V1.Requests;
 using PARR.Constants;
+using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Job;
 
 namespace PARR.API.Validators
 {
     public class TemplateActivatorRequestValidator : AbstractValidator<TemplateActivatorRequest>
     {
-        public TemplateActivatorRequestValidator()
+        public TemplateActivatorRequestValidator(
+                ITemplateService templateService,
+                IJobService jobService,
+                IJobGroupService jobGroupService
+            )
         {
-            RuleFor(t => t.Action).Must(action =>
+            RuleFor(t => t.EntityType).Must(type =>
-                 Enum.IsDefined(typeof(TemplateActivatorActionsEnum), action)
+                 Enum.IsDefined(typeof(SyncTaskEntityTypeEnum), type)
-            ).WithMessage("Некорректное значение action");
+            ).WithMessage("Некорректное значение EntityType");
+
+            RuleFor(t => t.EsppObject).Must(obj =>
+                Enum.IsDefined(typeof(TemplateActivatorEsppObjectTypesEnum), obj)
+            ).WithMessage("Некорректное значение EsppObject");
+
+            RuleFor(t => t.Id)
+                .MustAsync(async (entity, value, c) =>
+                {
+                    switch (entity.EntityType)
+                    {
+                        case SyncTaskEntityTypeEnum.JobGroup:
+                            return await jobGroupService.GetAsync(value) != null;
+                        case SyncTaskEntityTypeEnum.Job:
+                            return await jobService.GetAsync(value) != null;
+                        case SyncTaskEntityTypeEnum.Template:
+                            return await templateService.GetAsync(value) != null;
+                    }
+
+                    return false;
+                })
+                .WithMessage("Некорректное значение Id");
         }
     }
 }

PARR.API/appsettings.json

@@ -55,7 +55,7 @@
       "HostName": "parr-rabbitmq",
       "QueueName": "parr-template-activator",
       "User": "template_activator_writer",
-      "Password": "Gfkjhsdg*%fsdf"
+      "Password": "Gfkjhsdg\\*%fsdf"
     },
     "TemplatesMatcher": {
       "HostName": "parr-rabbitmq",

PARR.BLL/Domain/Mq/TemplateActivatorMq.cs

@@ -9,18 +9,35 @@ namespace PARR.BLL.Domain.Mq
     public class TemplateActivatorMq
     {
         /// <summary>
-        /// Id регламентной работы
+        /// ИД объекта, JobGroupId, JobId, TemplateId
         /// </summary>
-        public Guid JobId { get; set; }
+        public Guid Id { get; set; }
 
         /// <summary>
-        /// Действие по активации/деактивации
+        /// Тип объекта
         /// </summary>
-        public TemplateActivatorActionsEnum Action { get; set; }
+        public SyncTaskEntityTypeEnum EntityType { get; set; }
+
+        /// <summary>
+        /// Учитывать неиспользованные шаблоны
+        /// </summary>
+        public bool AllowUnused { get; set; } = false;
+
+        /// <summary>
+        /// Объект воздейстивя (шаблон, расписание)
+        /// </summary>
+        public TemplateActivatorEsppObjectTypesEnum EsppObject { get; set; }
+
+        /// <summary>
+        /// Новое состояние объекта
+        /// </summary>
+        public bool NewState { get; set; }
 
         /// <summary>
         /// Инициатор изменений
         /// </summary>
-        public HistoryInitiator? HistoryInitiator { get; set; }
+        public required HistoryInitiator HistoryInitiator { get; set; }
     }
+
+
 }

PARR.Constants/ParrComponentsEnum.cs

@@ -1,8 +1,11 @@
-namespace PARR.Constants
+using System.Text.Json.Serialization;
+
+namespace PARR.Constants
 {
     /// <summary>
     /// Компоненты ПАРР
     /// </summary>
+    [JsonConverter(typeof(JsonStringEnumConverter))]
     public enum ParrComponentsEnum
     {
         // Тут указываем только Worker`ы

PARR.Constants/TemplateActivatorActionsEnum.cs

@@ -1,5 +1,7 @@
 namespace PARR.Constants
 {
+    //todo: удалить!!!
+
     /// <summary>
     /// Действия с шаблонами/расписаниями для TemplateActivator
     /// </summary>

PARR.Constants/TemplateActivatorEsppObjectTypesEnum.cs

@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace PARR.Constants
+{
+    /// <summary>
+    /// Объект воздействия активатора
+    /// </summary>
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    public enum TemplateActivatorEsppObjectTypesEnum
+    {
+        /// <summary>
+        /// Шаблон
+        /// </summary>
+        Template=0,
+
+        /// <summary>
+        /// Расписание
+        /// </summary>
+        Schedule =1,
+    }
+}

PARR.DAL/Services/Implementations/RobotConfigurationService.cs

@@ -25,7 +25,7 @@ namespace PARR.DAL.Services.Implementations
         protected override DataContext EntitiContext => dataContext;
 
 
-        public void ChangeTaskStatus(TaskStatusEnum taskStatus, ref RobotConfiguration configuration)
+        public void ChangeTaskStatus(TaskStatusEnum taskStatus,  RobotConfiguration configuration)
         {
             configuration.TaskStatusCode = (int)taskStatus;
 
@@ -70,7 +70,7 @@ namespace PARR.DAL.Services.Implementations
             }
         }
 
-        public RobotConfiguration GetFromTemplateByRobotCode(RobotsEnum robotsEnum, ref Template template)
+        public RobotConfiguration GetFromTemplateByRobotCode(RobotsEnum robotsEnum, Template template)
         {
             var config = template.RobotConfigurations.FirstOrDefault(t => t.RobotCode == (int)robotsEnum);
 

PARR.DAL/Services/Interfaces/IRobotConfigurationService.cs

@@ -19,7 +19,7 @@ namespace PARR.DAL.Services.Interfaces
         /// </summary>
         /// <param name="taskStatus"></param>
         /// <param name="configuration"></param>
-        void ChangeTaskStatus(TaskStatusEnum taskStatus, ref RobotConfiguration configuration);
+        void ChangeTaskStatus(TaskStatusEnum taskStatus, RobotConfiguration configuration);
 
         /// <summary>
         /// Поиск невыполненных заданий и установка им статуса ошибки робота
@@ -35,6 +35,6 @@ namespace PARR.DAL.Services.Interfaces
         /// <param name="robotsEnum"></param>
         /// <param name="template"></param>
         /// <returns></returns>
-        RobotConfiguration GetFromTemplateByRobotCode(RobotsEnum robotsEnum, ref Template template);
+        RobotConfiguration GetFromTemplateByRobotCode(RobotsEnum robotsEnum, Template template);
     }
 }

PARR.TemplateActivator/ITemplateActivator.cs

@@ -1,15 +1,22 @@
-using PARR.Common.Domain;
+using PARR.BLL.Domain.Mq;
-using PARR.Constants;
 
 namespace PARR.TemplateActivator;
 
 public interface ITemplateActivator
 {
+    ///// <summary>
+    ///// Обновить состояние шаблонов или расписаний в соответствии со значением параметра action по applicationInWorkId
+    ///// </summary>
+    ///// <param name="applicationInWorkId"></param>
+    ///// <param name="action"></param>
+    ///// <returns></returns>
+    ////Task ChangeStateAsync(Guid applicationInWorkId, TemplateActivatorActionsEnum action, IHistoryInitiator? historyInitiator);
+
+
     /// <summary>
-    /// Обновить состояние шаблонов или расписаний в соответствии со значением параметра action по applicationInWorkId
+    /// Обновить состояние шаблонов и расписаний
     /// </summary>
-    /// <param name="applicationInWorkId"></param>
+    /// <param name="query"></param>
-    /// <param name="action"></param>
     /// <returns></returns>
-    Task ChangeStateAsync(Guid applicationInWorkId, TemplateActivatorActionsEnum action, IHistoryInitiator? historyInitiator);
+    Task ChangeStateAsync(TemplateActivatorMq query);
 }

PARR.TemplateActivator/MqTemplateActivator.cs

@@ -40,15 +40,15 @@ internal class MqTemplateActivator : IMqTemplateActivator
 
     private async Task UpdateTemplateStatusAsync(string msg)
     {
-        logger.LogInformation($"{this.GetType().Name}. Получили запрос: {msg}");
+        logger.LogInformation($"Получили запрос: {msg}");
 
         var query = transformService.GetModelFromJson<TemplateActivatorMq>(msg);
         if (query == null)
             return;
 
-        if (!await validatorService.IsValidApplicationInWorkAsync(query.JobId))
+        if (!await validatorService.IsValidObjectIdAsync(query.Id, query.EntityType))
         {
-            logger.LogError($"{this.GetType().Name}. Некорректные параметры регламентной работы {nameof(query.JobId)}: {query.JobId}");
+            logger.LogError($"Не найдет объект {nameof(query.Id)}: {query.Id}, типа {nameof(query.EntityType)}: {query.EntityType}.");
             return;
         }
 
@@ -56,10 +56,9 @@ internal class MqTemplateActivator : IMqTemplateActivator
         {
             var service = scope.ServiceProvider.GetService<ITemplateActivator>();
             if (service == null)
-                throw new Exception($"{this.GetType().Name}. Не найден сервис: {nameof(service.GetType)}");
+                throw new Exception($"Не найден сервис: {nameof(service.GetType)}");
-
-            await service.ChangeStateAsync(query.JobId, query.Action, query.HistoryInitiator);
 
+            await service.ChangeStateAsync(query);
         }
     }
 

PARR.TemplateActivator/Services/IValidatorService.cs

@@ -4,5 +4,6 @@ namespace PARR.TemplateActivator;
 
 internal interface IValidatorService
 {
-    Task<bool> IsValidApplicationInWorkAsync(Guid applicationInWorkId);
+    //Task<bool> IsValidApplicationInWorkAsync(Guid applicationInWorkId);
+    Task<bool> IsValidObjectIdAsync(Guid id, SyncTaskEntityTypeEnum entityType);
 }

PARR.TemplateActivator/Services/ValidatorService.cs

@@ -1,9 +1,15 @@
-using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using PARR.Constants;
+using PARR.DAL.Models;
+using PARR.DAL.Models.Base;
+using PARR.DAL.Models.Job;
 using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Base;
+using PARR.DAL.Services.Interfaces.Job;
 
 namespace PARR.TemplateActivator;
+
 internal class ValidatorService : IValidatorService
 {
     private readonly IServiceProvider serviceProvider;
@@ -18,25 +24,44 @@ internal class ValidatorService : IValidatorService
     }
 
 
-    public async Task<bool> IsValidApplicationInWorkAsync(Guid applicationInWorkId)
+    public async Task<bool> IsValidObjectIdAsync(Guid id, SyncTaskEntityTypeEnum entityType)
+    {
+        switch (entityType)
+        {
+            case (SyncTaskEntityTypeEnum.JobGroup):
+                return await IsValidAync<IJobGroupService, JobGroup>(id);
+
+            case (SyncTaskEntityTypeEnum.Job):
+                return await IsValidAync<IJobService, Job>(id);
+
+            case (SyncTaskEntityTypeEnum.Template):
+                return await IsValidAync<ITemplateService, Template>(id);
+        }
+
+        return false;
+    }
+
+
+    private async Task<bool> IsValidAync<TService, TEntity>(Guid id)
+                                                where TService : class, IBaseService<TEntity>
+                                                where TEntity : class, IBase
     {
         using (var scope = serviceProvider.CreateScope())
         {
-            var service = scope.ServiceProvider.GetService<IApplicationsInWorkService>();
+            var service = scope.ServiceProvider.GetService<TService>();
-
             if (service == null)
-                throw new Exception($"Не найден сервис: {nameof(IApplicationsInWorkService)}");
+                throw new Exception($"Не найден сервис: {typeof(TService).Name}");
 
-            var appInWork = await service.Get()
+            var obj = await service.GetAsync(id);
-                                            .FirstOrDefaultAsync(t => t.Id == applicationInWorkId);
 
-            if (appInWork == null)
+            if (obj == null)
             {
-                logger.LogError($"Не найдена регалментная работа {nameof(applicationInWorkId)}: {applicationInWorkId}");
+                logger.LogError($"Не объект {nameof(id)}: {id} в {typeof(TService).Name}");
                 return false;
             }
 
             return true;
         }
     }
+
 }

PARR.TemplateActivator/TemplateActivator.cs

@@ -1,13 +1,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using PARR.BLL.Helpers;
+using PARR.BLL.Domain.Mq;
-using PARR.Common.Domain;
 using PARR.Constants;
 using PARR.DAL.Contracts;
 using PARR.DAL.Models;
 using PARR.DAL.Services.Interfaces;
-using System.Threading.Channels;
-using System.Threading.Tasks;
 
 namespace PARR.TemplateActivator;
 
@@ -16,275 +13,100 @@ internal class TemplateActivator : ITemplateActivator
     private readonly ILogger<TemplateActivator> logger;
     private readonly ITemplateService templateService;
     private readonly IRobotConfigurationService robotConfigurationService;
-    private readonly IJobAutoControlService jobAutoControlService;
+    //private readonly IJobAutoControlService jobAutoControlService;
-    private readonly IApplicationsInWorkService applicationsInWorkService;
+    //private readonly IApplicationsInWorkService applicationsInWorkService;
 
     public TemplateActivator(
         ILogger<TemplateActivator> logger,
         ITemplateService templateService,
-        IRobotConfigurationService robotConfigurationService,
+        IRobotConfigurationService robotConfigurationService
-        IJobAutoControlService jobAutoControlService,
+        //IJobAutoControlService jobAutoControlService,
-        IApplicationsInWorkService applicationsInWorkService
+        //IApplicationsInWorkService applicationsInWorkService
         )
     {
         this.logger = logger;
         this.templateService = templateService;
         this.robotConfigurationService = robotConfigurationService;
-        this.jobAutoControlService = jobAutoControlService;
+        //this.jobAutoControlService = jobAutoControlService;
-        this.applicationsInWorkService = applicationsInWorkService;
+        //this.applicationsInWorkService = applicationsInWorkService;
+    }
+
+    public async Task ChangeStateAsync(TemplateActivatorMq query)
+    {
+        var templates = await GetTemplatesAsync(query);
+
+        logger.LogInformation($"Объектов для изменения: {templates.Count} шт.");
+
+        if (templates.Count == 0)
+            return;
+
+        switch (query.EsppObject)
+        {
+            case TemplateActivatorEsppObjectTypesEnum.Template:
+                foreach (var template in templates)
+                {
+                    template.IsActiveTemplate = query.NewState;
+                    UpdateRobotConfiguration(RobotsEnum.TemplateOrder, template);
+                }
+                break;
+
+            case TemplateActivatorEsppObjectTypesEnum.Schedule:
+                foreach (var template in templates)
+                {
+                    template.IsActiveSchedule = query.NewState;
+                    UpdateRobotConfiguration(RobotsEnum.ScheduleOrder, template);
+                }
+                break;
+        }
+
+        if (!await templateService.CommitAsync(query.HistoryInitiator))
+            logger.LogError($"Не удалось записать измения в БД о новых состояниях шаблонов и расписаний.");
+
+        logger.LogInformation($"Изменено состояние объектов: {templates.Count}");
+
+    }
+
+    private async Task<List<Template>> GetTemplatesAsync(TemplateActivatorMq query)
+    {
+        // ищем все шаблоны попадающие под условие
+        var templatesQuery = templateService.Get();
+
+        switch (query.EsppObject)
+        {
+            case TemplateActivatorEsppObjectTypesEnum.Template:
+                //нужно изменить шаблоны
+                templatesQuery = templatesQuery.Where(t => t.IsActiveTemplate != query.NewState);
+                break;
+
+            case TemplateActivatorEsppObjectTypesEnum.Schedule:
+                //нужно изменить расписания
+                templatesQuery = templatesQuery.Where(t => t.IsActiveSchedule != query.NewState);
+                break;
         }
 
 
-    public async Task ChangeStateAsync(Guid applicationInWorkId, TemplateActivatorActionsEnum action, IHistoryInitiator? historyInitiator)//TODO Migratin to Job
+        switch (query.EntityType)
         {
-        var query = templateService.Get()
+            case SyncTaskEntityTypeEnum.JobGroup:
-                           .Include(t => t.RobotConfigurations).ThenInclude(t => t.Robot)
+                templatesQuery = templatesQuery.Where(t => t.Job!.GroupId == query.Id);
-                           .Where(t => t.JobId == applicationInWorkId);//TODO Migratin to Job
-        var changes = 0;
-        switch (action)
-        {
-            case TemplateActivatorActionsEnum.ActivateAllTemplates:
-                logger.LogInformation($"Получен запрос на активацию всех шаблонов");
-                query = query.Where(t => !t.IsActiveTemplate);
-                changes = await UpdateTemplateStateAsync(query, true);
                 break;
-            case TemplateActivatorActionsEnum.ActivateTemplatesWithActiveSchedules:
+            case SyncTaskEntityTypeEnum.Job:
-                logger.LogInformation($"Получен запрос на активацию всех шаблонов, у которых активировано расписание");
+                templatesQuery = templatesQuery.Where(t => t.JobId == query.Id);
-                query = query.Where(t => !t.IsActiveTemplate && t.IsActiveSchedule);
-                changes = await UpdateTemplateStateAsync(query, true);
                 break;
-            case TemplateActivatorActionsEnum.DeactivateAllTemplates:
+            case SyncTaskEntityTypeEnum.Template:
-                logger.LogInformation($"Получен запрос на деактивацию всех шаблонов");
+                templatesQuery = templatesQuery.Where(t => t.Id == query.Id);
-                query = query.Where(t => t.IsActiveTemplate);
-                changes = await UpdateTemplateStateAsync(query, false);
-                break;
-            case TemplateActivatorActionsEnum.DeactivateTemplatesWithDeactivationSchedules:
-                logger.LogInformation($"Получен запрос на деактивацию всех шаблонов, у которых неактивированы расписания");
-                query = query.Where(t => t.IsActiveTemplate && !t.IsActiveSchedule);
-                changes = await UpdateTemplateStateAsync(query, false);
-                break;
-            case TemplateActivatorActionsEnum.ActivateAllSchedules:
-                logger.LogInformation($"Получен запрос на активацию всех расписаний");
-                query = query.Where(t => !t.IsActiveSchedule);
-                changes = await UpdateScheduleStateAsync(query, true);
-                break;
-            case TemplateActivatorActionsEnum.DeactivateAllSchedules:
-                logger.LogInformation($"Получен запрос на деактивацию всех расписаний");
-                query = query.Where(t => t.IsActiveSchedule);
-                changes = await UpdateScheduleStateAsync(query, false);
-                break;
-            case TemplateActivatorActionsEnum.ActivateSchedulesWithActiveTemplates:
-                logger.LogInformation($"Получен запрос на активацию всех расписаний, у которых активированы шаблоны");
-                query = query.Where(t => t.IsActiveTemplate && !t.IsActiveSchedule);
-                changes = await UpdateScheduleStateAsync(query, true);
-                break;
-            case TemplateActivatorActionsEnum.DeactivateSchedulesWithDeactivationTemplates:
-                logger.LogInformation($"Получен запрос на деактивацию всех расписаний, у которых неактивированы шаблоны");
-                query = query.Where(t => !t.IsActiveTemplate && t.IsActiveSchedule);
-                changes = await UpdateScheduleStateAsync(query, false);
-                break;
-            case TemplateActivatorActionsEnum.DeactivateSchedulesWithTemplateSyncErrors:
-                logger.LogInformation($"Получен запрос на деактивацию всех расписаний, у которых шаблоны синхронизированы с ошибкой");
-                query = query.Where(t => t.IsActiveTemplate &&
-                    t.RobotConfigurations.Any(t =>
-                        t.RobotCode == (int)RobotsEnum.TemplateOrder &&
-                        t.RobotStatusCode == (int)RobotStatusEnum.Error)
-                    );
-                changes = await UpdateScheduleStateAsync(query, false);
-                break;
-            case TemplateActivatorActionsEnum.DeactivateAllForAutoControl:
-                logger.LogInformation($"Получен запрос на деактивацию шаблонов и расписаний, для ЭК неудовлетворяющим условиям автоконтроля");
-                changes = await CoordinateJobsWithAutoControlAsync(applicationInWorkId, query, false);
-                break;
-            case TemplateActivatorActionsEnum.ActivateAllForAutoControl:
-                logger.LogInformation($"Получен запрос на активацию шаблонов и расписаний, для ЭК удовлетворяющим условиям автоконтроля");
-                changes = await CoordinateJobsWithAutoControlAsync(applicationInWorkId, query, true);
                 break;
             default:
-                break;
+                // прекращаем, чтоб слуяайно не обновить все шаблоны
+                throw new InvalidOperationException($"Неверный тип объекта. {nameof(query.EntityType)}: {query.EntityType}");
         }
 
-        if (historyInitiator != null)
+        if (query.AllowUnused == false)
-        {
+            // учитываем только шаблоны которые не помеченные как IsUnused = true (неиспользуемые)
-            historyInitiator.InitiatorComment += $" Action: {action.ToString()}";
+            // т е берем только используемые шаблоны
-            historyInitiator.InitiatorComment = historyInitiator.InitiatorComment.Trim();
+            templatesQuery = templatesQuery.Where(t => t.IsUnused == false);
-        }
 
-        if (changes > 0 && !await templateService.CommitAsync(historyInitiator))
+        return await templatesQuery.Include(t => t.RobotConfigurations).ToListAsync();
-            logger.LogError($"{GetType().Name} не удалось записать измения в БД о новых состояниях шаблонов и расписаний регламентной работы Id {applicationInWorkId}");
-
-        logger.LogDebug($"{GetType().Name} изменил состояние шаблонов/расписаний({changes}) регламентной работы Id {applicationInWorkId}");
-    }
-
-    private async Task<int> CoordinateJobsWithAutoControlAsync(Guid applicationInWorkId, IQueryable<Template> query, bool isActivate)
-    {
-        var changes = 0;
-
-        //Добавляем информацию о рабочих группах для возможности их фильтрации
-        query = query.Include(t => t.Unit);//TODO Migratin to Job
-
-        //Получаем настройки авто-контроля
-        var jobAutoControlSettings = await GetJobAutoControlSettingsAsync(applicationInWorkId);
-        if (jobAutoControlSettings == null)
-            return 0;
-
-        var trueEkStatuses = jobAutoControlSettings.JobAutoControlInEkStatuses;
-        var trueMasks = jobAutoControlSettings.JobEkMasks;
-
-        if (!trueEkStatuses.Any() || !trueMasks.Any())
-        {
-            logger.LogWarning($"В ApplicationInWork({applicationInWorkId}) не заданы настройки фильтрации статусов ЭК хоста или маски его имени");
-            return 0;
-        }
-
-        //Фильтруем обратное состояние - активированные для деактивации
-        query = FilterTemplatesQueryByWrongState(query, jobAutoControlSettings, isActivate);
-
-        //Фильтруем по маскам ЭК
-        var templates = FilterTemplatesByNameNotMatchToMasks(query, trueMasks);
-
-        if (!templates.Any())
-            return 0;
-
-        //Фильтруем по рабочим группам
-        var appInWorkWorkGroups = GetApplicationInWorkWorkGroups(applicationInWorkId);
-        if (appInWorkWorkGroups.Any())
-            templates = templates.Where(t => appInWorkWorkGroups.Any(awg => t.Unit!.BaseFields!.WorkGroup == awg.WorkGroup!.Name)).ToList();//TODO Migratin to Job
-
-        //Фильтруем соответствие статусов ЭК условиям автоконтроля
-        var checkEkStatus = FilterTemplatesByWrongEkStatus(templates, trueEkStatuses, isActivate);
-        //Меняем состояние отфильтрованных шаблонов если какие-то остались
-        if (checkEkStatus.Any())
-            changes = UpdateState(checkEkStatus,
-                isActivate ? jobAutoControlSettings.OnTemplateIsActive : jobAutoControlSettings.OffTemplateIsActive,
-                isActivate ? jobAutoControlSettings.OnScheduleIsActive : jobAutoControlSettings.OffScheduleIsActive);
-
-        return changes;
-    }
-
-    private List<AppInWorkInWorkGroup> GetApplicationInWorkWorkGroups(Guid applicationInWorkId)
-    {
-        var appInWorkInWorkGroups = applicationsInWorkService.Get()
-                                 .Include(aiw => aiw.WorkGroups)
-                                 .FirstOrDefault(t => t.Id == applicationInWorkId)?.WorkGroups;
-
-        if (appInWorkInWorkGroups != null)
-            return appInWorkInWorkGroups.ToList();
-
-        return new List<AppInWorkInWorkGroup>();
-    }
-
-    private List<Template> FilterTemplatesByWrongEkStatus(List<Template> templates, ICollection<JobAutoControlInEkStatus> trueEkStatuses, bool isActivate)
-    {
-        if (isActivate)
-            return templates.Where(t => trueEkStatuses.Any(tes => tes.EkStatus!.Name == t.Unit!.BaseFields!.Status)).ToList();//TODO Migratin to Job
-
-        return templates.Where(t => !trueEkStatuses.Any(tes => tes.EkStatus!.Name == t.Unit!.BaseFields!.Status)).ToList();//TODO Migratin to Job
-    }
-
-    private List<Template> FilterTemplatesByNameNotMatchToMasks(IQueryable<Template> query, ICollection<JobEkMask> trueMasks)
-    {
-        var result = new List<Template>();
-        foreach (var mask in trueMasks)
-        {
-            var templates = query.Where(t => EF.Functions.Like(t.Unit!.Name.ToLower(), SqlHelpers.RegexToLike(mask.Name))).ToList();
-            result.AddRange(templates);
-        }
-
-        return result;
-    }
-
-    private IQueryable<Template> FilterTemplatesQueryByWrongState(IQueryable<Template> query, JobAutoControl jobAutoControlSettings, bool isActivate)
-    {
-        if (isActivate)
-            return query.Where(t => t.IsActiveTemplate != jobAutoControlSettings.OnTemplateIsActive || t.IsActiveSchedule != jobAutoControlSettings.OnScheduleIsActive);
-
-        return query.Where(t => t.IsActiveTemplate != jobAutoControlSettings.OffTemplateIsActive || t.IsActiveSchedule != jobAutoControlSettings.OffScheduleIsActive);
-    }
-
-    private async Task<JobAutoControl> GetJobAutoControlSettingsAsync(Guid applicationInWorkId)
-    {
-        return await jobAutoControlService.Get()
-                            .Include(jac => jac.JobAutoControlInEkStatuses)
-                            .Include(jac => jac.JobEkMasks)
-                            .Where(jac => jac.ApplicationInWorkId == applicationInWorkId).FirstAsync();
-    }
-
-
-
-
-
-    /// <summary>
-    /// Обновить состояние расписаний по запросу query на newState, без записи в БД. Возвращает количество шаблонов требующих фиксации в БД
-    /// </summary>
-    /// <param name="query"></param>
-    /// <param name="newState"></param>
-    /// <returns></returns>
-    private async Task<int> UpdateScheduleStateAsync(IQueryable<Template> query, bool newState)
-    {
-        var templates = await query.Select(t => t).ToListAsync();
-
-        if (templates.Any())
-            templates.ForEach(t =>
-            {
-                t.IsActiveSchedule = newState;
-                UpdateRobotConfiguration(RobotsEnum.ScheduleOrder, t);
-            });
-
-        templates.ForEach(t => t.IsActiveSchedule = newState);
-
-        return templates.Count;
-    }
-
-
-    /// <summary>
-    /// Обновить состояние шаблонов по запросу query на newState, без записи в БД. Возвращает количество расписаний требующих фиксацию в БД
-    /// </summary>
-    /// <param name="query"></param>
-    /// <param name="newState"></param>
-    /// <returns></returns>
-    private async Task<int> UpdateTemplateStateAsync(IQueryable<Template> query, bool newState)
-    {
-        var templates = await query.Select(t => t).ToListAsync();
-
-        if (templates.Any())
-            templates.ForEach(t =>
-            {
-                t.IsActiveTemplate = newState;
-                UpdateRobotConfiguration(RobotsEnum.TemplateOrder, t);
-            });
-
-
-        return templates.Count;
-    }
-
-
-    /// <summary>
-    /// Обновить состояние шаблонов по запросу query на newState, без записи в БД. Возвращает количество расписаний требующих фиксацию в БД
-    /// </summary>
-    /// <param name="query"></param>
-    /// <param name="newState"></param>
-    /// <returns></returns>
-    private async Task<int> UpdateStateAsync(IQueryable<Template> query, bool newTemplateState, bool newSchedulerState)
-    {
-        var templates = await query.Select(t => t).ToListAsync();
-
-        return UpdateState(templates, newTemplateState, newSchedulerState);
-    }
-
-
-    private int UpdateState(List<Template> templates, bool newTemplateState, bool newSchedulerState)
-    {
-        if (templates.Any())
-            templates.ForEach(t =>
-            {
-                t.IsActiveTemplate = newTemplateState;
-                t.IsActiveSchedule = newSchedulerState;
-                UpdateRobotConfiguration(RobotsEnum.TemplateOrder, t);
-            });
-
-
-        return templates.Count;
     }
 
 
@@ -295,7 +117,264 @@ internal class TemplateActivator : ITemplateActivator
     /// <param name="t"></param>
     private void UpdateRobotConfiguration(RobotsEnum robotsEnum, Template t)
     {
-        var config = robotConfigurationService.GetFromTemplateByRobotCode(robotsEnum, ref t);
+        var config = robotConfigurationService.GetFromTemplateByRobotCode(robotsEnum, t);
-        robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, ref config);
+        robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, config);
     }
+
+
+
+    #region old
+
+    //public async Task ChangeStateAsyncOld(Guid applicationInWorkId, TemplateActivatorActionsEnum action, IHistoryInitiator? historyInitiator)//TODO Migratin to Job
+    //{
+    //    var query = templateService.Get()
+    //                       .Include(t => t.RobotConfigurations).ThenInclude(t => t.Robot)
+    //                       .Where(t => t.JobId == applicationInWorkId);//TODO Migratin to Job
+    //    var changes = 0;
+    //    switch (action)
+    //    {
+    //        case TemplateActivatorActionsEnum.ActivateAllTemplates:
+    //            logger.LogInformation($"Получен запрос на активацию всех шаблонов");
+    //            query = query.Where(t => !t.IsActiveTemplate);
+    //            changes = await UpdateTemplateStateAsync(query, true);
+    //            break;
+    //        case TemplateActivatorActionsEnum.ActivateTemplatesWithActiveSchedules:
+    //            logger.LogInformation($"Получен запрос на активацию всех шаблонов, у которых активировано расписание");
+    //            query = query.Where(t => !t.IsActiveTemplate && t.IsActiveSchedule);
+    //            changes = await UpdateTemplateStateAsync(query, true);
+    //            break;
+    //        case TemplateActivatorActionsEnum.DeactivateAllTemplates:
+    //            logger.LogInformation($"Получен запрос на деактивацию всех шаблонов");
+    //            query = query.Where(t => t.IsActiveTemplate);
+    //            changes = await UpdateTemplateStateAsync(query, false);
+    //            break;
+    //        case TemplateActivatorActionsEnum.DeactivateTemplatesWithDeactivationSchedules:
+    //            logger.LogInformation($"Получен запрос на деактивацию всех шаблонов, у которых неактивированы расписания");
+    //            query = query.Where(t => t.IsActiveTemplate && !t.IsActiveSchedule);
+    //            changes = await UpdateTemplateStateAsync(query, false);
+    //            break;
+    //        case TemplateActivatorActionsEnum.ActivateAllSchedules:
+    //            logger.LogInformation($"Получен запрос на активацию всех расписаний");
+    //            query = query.Where(t => !t.IsActiveSchedule);
+    //            changes = await UpdateScheduleStateAsync(query, true);
+    //            break;
+    //        case TemplateActivatorActionsEnum.DeactivateAllSchedules:
+    //            logger.LogInformation($"Получен запрос на деактивацию всех расписаний");
+    //            query = query.Where(t => t.IsActiveSchedule);
+    //            changes = await UpdateScheduleStateAsync(query, false);
+    //            break;
+    //        case TemplateActivatorActionsEnum.ActivateSchedulesWithActiveTemplates:
+    //            logger.LogInformation($"Получен запрос на активацию всех расписаний, у которых активированы шаблоны");
+    //            query = query.Where(t => t.IsActiveTemplate && !t.IsActiveSchedule);
+    //            changes = await UpdateScheduleStateAsync(query, true);
+    //            break;
+    //        case TemplateActivatorActionsEnum.DeactivateSchedulesWithDeactivationTemplates:
+    //            logger.LogInformation($"Получен запрос на деактивацию всех расписаний, у которых неактивированы шаблоны");
+    //            query = query.Where(t => !t.IsActiveTemplate && t.IsActiveSchedule);
+    //            changes = await UpdateScheduleStateAsync(query, false);
+    //            break;
+    //        case TemplateActivatorActionsEnum.DeactivateSchedulesWithTemplateSyncErrors:
+    //            logger.LogInformation($"Получен запрос на деактивацию всех расписаний, у которых шаблоны синхронизированы с ошибкой");
+    //            query = query.Where(t => t.IsActiveTemplate &&
+    //                t.RobotConfigurations.Any(t =>
+    //                    t.RobotCode == (int)RobotsEnum.TemplateOrder &&
+    //                    t.RobotStatusCode == (int)RobotStatusEnum.Error)
+    //                );
+    //            changes = await UpdateScheduleStateAsync(query, false);
+    //            break;
+    //        case TemplateActivatorActionsEnum.DeactivateAllForAutoControl:
+    //            logger.LogInformation($"Получен запрос на деактивацию шаблонов и расписаний, для ЭК неудовлетворяющим условиям автоконтроля");
+    //            changes = await CoordinateJobsWithAutoControlAsync(applicationInWorkId, query, false);
+    //            break;
+    //        case TemplateActivatorActionsEnum.ActivateAllForAutoControl:
+    //            logger.LogInformation($"Получен запрос на активацию шаблонов и расписаний, для ЭК удовлетворяющим условиям автоконтроля");
+    //            changes = await CoordinateJobsWithAutoControlAsync(applicationInWorkId, query, true);
+    //            break;
+    //        default:
+    //            break;
+    //    }
+
+    //    if (historyInitiator != null)
+    //    {
+    //        historyInitiator.InitiatorComment += $" Action: {action.ToString()}";
+    //        historyInitiator.InitiatorComment = historyInitiator.InitiatorComment.Trim();
+    //    }
+
+    //    if (changes > 0 && !await templateService.CommitAsync(historyInitiator))
+    //        logger.LogError($"{GetType().Name} не удалось записать измения в БД о новых состояниях шаблонов и расписаний регламентной работы Id {applicationInWorkId}");
+
+    //    logger.LogDebug($"{GetType().Name} изменил состояние шаблонов/расписаний({changes}) регламентной работы Id {applicationInWorkId}");
+    //}
+
+    //private async Task<int> CoordinateJobsWithAutoControlAsync(Guid applicationInWorkId, IQueryable<Template> query, bool isActivate)
+    //{
+    //    var changes = 0;
+
+    //    //Добавляем информацию о рабочих группах для возможности их фильтрации
+    //    query = query.Include(t => t.Unit);//TODO Migratin to Job
+
+    //    //Получаем настройки авто-контроля
+    //    var jobAutoControlSettings = await GetJobAutoControlSettingsAsync(applicationInWorkId);
+    //    if (jobAutoControlSettings == null)
+    //        return 0;
+
+    //    var trueEkStatuses = jobAutoControlSettings.JobAutoControlInEkStatuses;
+    //    var trueMasks = jobAutoControlSettings.JobEkMasks;
+
+    //    if (!trueEkStatuses.Any() || !trueMasks.Any())
+    //    {
+    //        logger.LogWarning($"В ApplicationInWork({applicationInWorkId}) не заданы настройки фильтрации статусов ЭК хоста или маски его имени");
+    //        return 0;
+    //    }
+
+    //    //Фильтруем обратное состояние - активированные для деактивации
+    //    query = FilterTemplatesQueryByWrongState(query, jobAutoControlSettings, isActivate);
+
+    //    //Фильтруем по маскам ЭК
+    //    var templates = FilterTemplatesByNameNotMatchToMasks(query, trueMasks);
+
+    //    if (!templates.Any())
+    //        return 0;
+
+    //    //Фильтруем по рабочим группам
+    //    var appInWorkWorkGroups = GetApplicationInWorkWorkGroups(applicationInWorkId);
+    //    if (appInWorkWorkGroups.Any())
+    //        templates = templates.Where(t => appInWorkWorkGroups.Any(awg => t.Unit!.BaseFields!.WorkGroup == awg.WorkGroup!.Name)).ToList();//TODO Migratin to Job
+
+    //    //Фильтруем соответствие статусов ЭК условиям автоконтроля
+    //    var checkEkStatus = FilterTemplatesByWrongEkStatus(templates, trueEkStatuses, isActivate);
+    //    //Меняем состояние отфильтрованных шаблонов если какие-то остались
+    //    if (checkEkStatus.Any())
+    //        changes = UpdateState(checkEkStatus,
+    //            isActivate ? jobAutoControlSettings.OnTemplateIsActive : jobAutoControlSettings.OffTemplateIsActive,
+    //            isActivate ? jobAutoControlSettings.OnScheduleIsActive : jobAutoControlSettings.OffScheduleIsActive);
+
+    //    return changes;
+    //}
+
+    //private List<AppInWorkInWorkGroup> GetApplicationInWorkWorkGroups(Guid applicationInWorkId)
+    //{
+    //    var appInWorkInWorkGroups = applicationsInWorkService.Get()
+    //                             .Include(aiw => aiw.WorkGroups)
+    //                             .FirstOrDefault(t => t.Id == applicationInWorkId)?.WorkGroups;
+
+    //    if (appInWorkInWorkGroups != null)
+    //        return appInWorkInWorkGroups.ToList();
+
+    //    return new List<AppInWorkInWorkGroup>();
+    //}
+
+    //private List<Template> FilterTemplatesByWrongEkStatus(List<Template> templates, ICollection<JobAutoControlInEkStatus> trueEkStatuses, bool isActivate)
+    //{
+    //    if (isActivate)
+    //        return templates.Where(t => trueEkStatuses.Any(tes => tes.EkStatus!.Name == t.Unit!.BaseFields!.Status)).ToList();//TODO Migratin to Job
+
+    //    return templates.Where(t => !trueEkStatuses.Any(tes => tes.EkStatus!.Name == t.Unit!.BaseFields!.Status)).ToList();//TODO Migratin to Job
+    //}
+
+    //private List<Template> FilterTemplatesByNameNotMatchToMasks(IQueryable<Template> query, ICollection<JobEkMask> trueMasks)
+    //{
+    //    var result = new List<Template>();
+    //    foreach (var mask in trueMasks)
+    //    {
+    //        var templates = query.Where(t => EF.Functions.Like(t.Unit!.Name.ToLower(), SqlHelpers.RegexToLike(mask.Name))).ToList();
+    //        result.AddRange(templates);
+    //    }
+
+    //    return result;
+    //}
+
+    //private IQueryable<Template> FilterTemplatesQueryByWrongState(IQueryable<Template> query, JobAutoControl jobAutoControlSettings, bool isActivate)
+    //{
+    //    if (isActivate)
+    //        return query.Where(t => t.IsActiveTemplate != jobAutoControlSettings.OnTemplateIsActive || t.IsActiveSchedule != jobAutoControlSettings.OnScheduleIsActive);
+
+    //    return query.Where(t => t.IsActiveTemplate != jobAutoControlSettings.OffTemplateIsActive || t.IsActiveSchedule != jobAutoControlSettings.OffScheduleIsActive);
+    //}
+
+    //private async Task<JobAutoControl> GetJobAutoControlSettingsAsync(Guid applicationInWorkId)
+    //{
+    //    return await jobAutoControlService.Get()
+    //                        .Include(jac => jac.JobAutoControlInEkStatuses)
+    //                        .Include(jac => jac.JobEkMasks)
+    //                        .Where(jac => jac.ApplicationInWorkId == applicationInWorkId).FirstAsync();
+    //}
+
+    ///// <summary>
+    ///// Обновить состояние расписаний по запросу query на newState, без записи в БД. Возвращает количество шаблонов требующих фиксации в БД
+    ///// </summary>
+    ///// <param name="query"></param>
+    ///// <param name="newState"></param>
+    ///// <returns></returns>
+    //private async Task<int> UpdateScheduleStateAsync(IQueryable<Template> query, bool newState)
+    //{
+    //    var templates = await query.Select(t => t).ToListAsync();
+
+    //    if (templates.Any())
+    //        templates.ForEach(t =>
+    //        {
+    //            t.IsActiveSchedule = newState;
+    //            UpdateRobotConfiguration(RobotsEnum.ScheduleOrder, t);
+    //        });
+
+    //    templates.ForEach(t => t.IsActiveSchedule = newState);
+
+    //    return templates.Count;
+    //}
+
+
+    ///// <summary>
+    ///// Обновить состояние шаблонов по запросу query на newState, без записи в БД. Возвращает количество расписаний требующих фиксацию в БД
+    ///// </summary>
+    ///// <param name="query"></param>
+    ///// <param name="newState"></param>
+    ///// <returns></returns>
+    //private async Task<int> UpdateTemplateStateAsync(IQueryable<Template> query, bool newState)
+    //{
+    //    var templates = await query.Select(t => t).ToListAsync();
+
+    //    if (templates.Any())
+    //        templates.ForEach(t =>
+    //        {
+    //            t.IsActiveTemplate = newState;
+    //            UpdateRobotConfiguration(RobotsEnum.TemplateOrder, t);
+    //        });
+
+
+    //    return templates.Count;
+    //}
+
+
+    ///// <summary>
+    ///// Обновить состояние шаблонов по запросу query на newState, без записи в БД. Возвращает количество расписаний требующих фиксацию в БД
+    ///// </summary>
+    ///// <param name="query"></param>
+    ///// <param name="newState"></param>
+    ///// <returns></returns>
+    //private async Task<int> UpdateStateAsync(IQueryable<Template> query, bool newTemplateState, bool newSchedulerState)
+    //{
+    //    var templates = await query.Select(t => t).ToListAsync();
+
+    //    return UpdateState(templates, newTemplateState, newSchedulerState);
+    //}
+
+
+    //private int UpdateState(List<Template> templates, bool newTemplateState, bool newSchedulerState)
+    //{
+    //    if (templates.Any())
+    //        templates.ForEach(t =>
+    //        {
+    //            t.IsActiveTemplate = newTemplateState;
+    //            t.IsActiveSchedule = newSchedulerState;
+    //            UpdateRobotConfiguration(RobotsEnum.TemplateOrder, t);
+    //        });
+
+
+    //    return templates.Count;
+    //}
+
+
+
+
+    #endregion
 }

PARR.TemplateActivatorWorker/Worker.cs

@@ -16,13 +16,13 @@ namespace PARR.TemplateActivatorWorker
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             await mqTemplateActivator.StartAsync();
+            await Task.Delay(Timeout.Infinite, stoppingToken);
         }
 
-        public override Task StopAsync(CancellationToken cancellationToken)
+        public override async Task StopAsync(CancellationToken cancellationToken)
         {
-            mqTemplateActivator.StopAsync().Wait();
+            await mqTemplateActivator.StopAsync();
-
+            await base.StopAsync(cancellationToken);
-            return base.StopAsync(cancellationToken);
         }
     }
 }