From e5bc42741c71aaebfac762e670074a2436e737f9 Mon Sep 17 00:00:00 2001
From: Mikhail Trubnikov <ivc_trubnikovme@dvgd.rzd>
Date: Wed, 21 Jan 2026 16:28:17 +1000
Subject: [PATCH] =?UTF-8?q?feat(templateDistributor):=20=D0=B7=D0=B0=D0=B3?=
 =?UTF-8?q?=D0=BE=D1=82=D0=BE=D0=B2=D0=BA=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../V1/Requests/DistributeRequest.cs          |   2 +-
 .../Controllers/V1/DistributorController.cs   |   6 +-
 .../Validators/DistributeRequestValidator.cs  |  25 +-
 PARR.BLL/Domain/Mq/TemplateDistributorMq.cs   |   4 +-
 .../ITemplateDistributor.cs                   |  18 +-
 .../MqTemplateDistributor.cs                  |  10 +-
 .../Services/IValidatorService.cs             |   2 +-
 .../Services/ValidatorService.cs              |  38 +-
 .../TemplateDistributor.cs                    | 416 +-----------------
 PARR.TemplateDistributorWorker/Worker.cs      |  12 +-
 docker-compose.template-distributor.yml       |   2 +-
 11 files changed, 65 insertions(+), 470 deletions(-)

diff --git a/PARR.API/Contracts/V1/Requests/DistributeRequest.cs b/PARR.API/Contracts/V1/Requests/DistributeRequest.cs
index 26b81422..1930a6b4 100644
--- a/PARR.API/Contracts/V1/Requests/DistributeRequest.cs
+++ b/PARR.API/Contracts/V1/Requests/DistributeRequest.cs
@@ -2,6 +2,6 @@
 {
     public class DistributeRequest
     {
-        public Guid ApplicationInWorkId { get; set; }
+        public Guid JobGroupId { get; set; }
     }
 }
diff --git a/PARR.API/Controllers/V1/DistributorController.cs b/PARR.API/Controllers/V1/DistributorController.cs
index f102f938..31975fca 100644
--- a/PARR.API/Controllers/V1/DistributorController.cs
+++ b/PARR.API/Controllers/V1/DistributorController.cs
@@ -36,7 +36,7 @@ namespace PARR.API.Controllers.V1
 
 
         /// <summary>
-        /// Перераспределить шаблоны для регламентной работы
+        /// Перераспределить шаблоны для группы работ
         /// </summary>
         /// <returns></returns>
         [HttpPost(ApiRoutes.Distributor.Distribute)]
@@ -48,7 +48,7 @@ namespace PARR.API.Controllers.V1
 
             var requestToMq = new TemplateDistributorMq
             {
-                ApplicationInWorkId = request.ApplicationInWorkId
+                JobGroupId = request.JobGroupId
             };
 
             var msg = JsonSerializer.Serialize(requestToMq);
@@ -58,7 +58,7 @@ namespace PARR.API.Controllers.V1
             if (sendResult.IsSuccess)
                 return Created("", new Response<string?>(null, true, new List<ErrorModel>(), "Отправлен запрос на перераспределение регламентных работ."));
             else
-                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message="Ошибка при отправке данных."} }));
+                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при отправке данных." } }));
 
         }
     }
diff --git a/PARR.API/Validators/DistributeRequestValidator.cs b/PARR.API/Validators/DistributeRequestValidator.cs
index 2f051a46..f7826eae 100644
--- a/PARR.API/Validators/DistributeRequestValidator.cs
+++ b/PARR.API/Validators/DistributeRequestValidator.cs
@@ -1,24 +1,27 @@
 using FluentValidation;
+using Microsoft.EntityFrameworkCore;
 using PARR.API.Contracts.V1.Requests;
-using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Job;
 
 namespace PARR.API.Validators
 {
     public class DistributeRequestValidator : AbstractValidator<DistributeRequest>
     {
-        private readonly IApplicationsInWorkService applicationsInWorkService;
-
-        public DistributeRequestValidator(IApplicationsInWorkService applicationsInWorkService)
+        public DistributeRequestValidator(IJobGroupService jobGroupService)
         {
-            this.applicationsInWorkService = applicationsInWorkService;
-
-
-            RuleFor(t => t.ApplicationInWorkId).NotEmpty().MustAsync(async (entity, value, c) =>
+            RuleFor(t => t.JobGroupId).NotEmpty().MustAsync(async (entity, value, c) =>
             {
-                var appInWork = await applicationsInWorkService.GetAsync(value);
-
-                return appInWork != null;
+                return await jobGroupService.Get().FirstOrDefaultAsync(t => t.Id == value) != null;
             }).WithMessage("Недопустимое значение");
+
+            RuleFor(t => t.JobGroupId).NotEmpty().MustAsync(async (entity, value, c) =>
+            {
+                var jobGroup = await jobGroupService.Get()
+                                        .Include(t => t.DistributionConfig)
+                                        .FirstOrDefaultAsync(t => t.Id == value);
+
+                return jobGroup != null && jobGroup.IsAutoDistributionEnabled && jobGroup.DistributionConfig != null;
+            }).WithMessage("Отсутствуют настройки автораспределения");
         }
     }
 }
diff --git a/PARR.BLL/Domain/Mq/TemplateDistributorMq.cs b/PARR.BLL/Domain/Mq/TemplateDistributorMq.cs
index 38bcfd5e..82bb7d4a 100644
--- a/PARR.BLL/Domain/Mq/TemplateDistributorMq.cs
+++ b/PARR.BLL/Domain/Mq/TemplateDistributorMq.cs
@@ -1,10 +1,10 @@
 namespace PARR.BLL.Domain.Mq
 {
     /// <summary>
-    /// Модель в MQ, обновления расписаний шаблонов связанных с РР (для TemplateDistributor)
+    /// Модель в MQ, распределить шаблоны для JobGroupId (для TemplateDistributor)
     /// </summary>
     public class TemplateDistributorMq
     {
-        public Guid ApplicationInWorkId { get; set; }
+        public Guid JobGroupId { get; set; }
     }
 }
diff --git a/PARR.TemplateDistributor/ITemplateDistributor.cs b/PARR.TemplateDistributor/ITemplateDistributor.cs
index c28dd8ac..a819104d 100644
--- a/PARR.TemplateDistributor/ITemplateDistributor.cs
+++ b/PARR.TemplateDistributor/ITemplateDistributor.cs
@@ -1,22 +1,12 @@
-using PARR.DAL.Models;
-
-namespace PARR.TemplateDistributor
+namespace PARR.TemplateDistributor
 {
     public interface ITemplateDistributor
     {
         /// <summary>
-        /// Формирует расписание запуска для шаблонов относительно одной РР (без сохранения в БД), (реализует оба режима распределения РР)
+        /// Обновляет NextRun (сохраняет в БД)
         /// </summary>
-        /// <param name="templates"></param>
-        /// <param name="applicationInWorkId"></param>
+        /// <param name="jobGroupId"></param>
         /// <returns></returns>
-        Task<List<Template>> DistributeTemplateAsync(List<Template> templates, Guid applicationInWorkId, Guid workGroupid);
-
-        /// <summary>
-        /// Обновляет расписание запуска шаблонов по РР (сохраняет в БД)
-        /// </summary>
-        /// <param name="applicationInWorkId"></param>
-        /// <returns></returns>
-        Task UpdateScheduleAsync(Guid applicationInWorkId);
+        Task DistributeAsync(Guid jobGroupId);
     }
 }
diff --git a/PARR.TemplateDistributor/MqTemplateDistributor.cs b/PARR.TemplateDistributor/MqTemplateDistributor.cs
index edf40137..1d3d9abd 100644
--- a/PARR.TemplateDistributor/MqTemplateDistributor.cs
+++ b/PARR.TemplateDistributor/MqTemplateDistributor.cs
@@ -42,7 +42,7 @@ namespace PARR.TemplateDistributor
 
         public async Task StopAsync()
         {
-           await mqService.DisposeAsync();
+            await mqService.DisposeAsync();
         }
 
         private async Task UpdateScheduleAsync(string msg)
@@ -53,9 +53,9 @@ namespace PARR.TemplateDistributor
             if (query == null)
                 return;
 
-            if (!await validatorService.IsValidApplicationAndWorksAsync(query.ApplicationInWorkId))
+            if (!await validatorService.IsValidJobGroupAsync(query.JobGroupId))
             {
-                logger.LogError($"Некорректные параметры регламентной работы {nameof(query.ApplicationInWorkId)}: {query.ApplicationInWorkId}");
+                logger.LogError("Не корректные параметры группы работ {jobGroupId}. Не буду ничего делать.", query.JobGroupId);
                 return;
             }
 
@@ -63,9 +63,9 @@ namespace PARR.TemplateDistributor
             {
                 var service = scope.ServiceProvider.GetService<ITemplateDistributor>();
                 if (service == null)
-                    throw new Exception($"Не найден сервис: {nameof(service.GetType)}");
+                    throw new Exception($"Не найден сервис: {nameof(ITemplateDistributor)}");
 
-                await service.UpdateScheduleAsync(query.ApplicationInWorkId);
+                await service.DistributeAsync(query.JobGroupId);
 
             }
         }
diff --git a/PARR.TemplateDistributor/Services/IValidatorService.cs b/PARR.TemplateDistributor/Services/IValidatorService.cs
index 1730ced1..cdb6a1e2 100644
--- a/PARR.TemplateDistributor/Services/IValidatorService.cs
+++ b/PARR.TemplateDistributor/Services/IValidatorService.cs
@@ -2,6 +2,6 @@
 {
     internal interface IValidatorService
     {
-        Task<bool> IsValidApplicationAndWorksAsync(Guid applicationInWorkId);
+        Task<bool> IsValidJobGroupAsync(Guid applicationInWorkId);
     }
 }
diff --git a/PARR.TemplateDistributor/Services/ValidatorService.cs b/PARR.TemplateDistributor/Services/ValidatorService.cs
index 3b85e410..58dd8ed6 100644
--- a/PARR.TemplateDistributor/Services/ValidatorService.cs
+++ b/PARR.TemplateDistributor/Services/ValidatorService.cs
@@ -1,7 +1,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using PARR.DAL.Models.Job;
 using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Job;
 
 namespace PARR.TemplateDistributor.Services
 {
@@ -17,32 +19,30 @@ namespace PARR.TemplateDistributor.Services
             this.serviceProvider = serviceProvider;
             this.logger = logger;
         }
-        public async Task<bool> IsValidApplicationAndWorksAsync(Guid applicationInWorkId)
+        public async Task<bool> IsValidJobGroupAsync(Guid jobGroupId)
         {
             using (var scope = serviceProvider.CreateScope())
             {
-                //TODO Migratin to Job
-                //var service = scope.ServiceProvider.GetService<IApplicationsInWorkService>();
 
-                //if (service == null)
-                //    throw new Exception($"Не найден сервис: {nameof(IApplicationsInWorkService)}");
+                var service = scope.ServiceProvider.GetService<IJobGroupService>();
 
-                //var appInWork = await service.Get()//TODO Migratin to Job
-                //                                   //.Include(aiw => aiw.EsppSchValues)
-                //                                .FirstOrDefaultAsync(t => t.Id == applicationInWorkId);
+                if (service == null)
+                    throw new Exception($"Не найден сервис: {nameof(IJobGroupService)}");
 
-                //if (appInWork == null)
-                //{
-                //    logger.LogError($"Не найдена регалментная работа {nameof(applicationInWorkId)}: {applicationInWorkId}");
-                //    return false;
-                //}
+                var jobGroup = await service.Get().Include(t => t.DistributionConfig).FirstOrDefaultAsync(t => t.Id == jobGroupId);
 
-                //if (appInWork.IsAutoDistributionEnabled && appInWork.EsppSchValues.Count !=1)
-                //{
-                //    logger.LogError($"Регалментная работа {nameof(applicationInWorkId)}: {applicationInWorkId} должна иметь только одно значение EsppSchTypeValue" +
-                //        $", соответствующее режиму равномерного распределения по периоду");
-                //    return false;
-                //}
+                if (jobGroup == null)
+                {
+                    logger.LogError($"Не найдена группа работ с Id: {jobGroupId}", jobGroupId);
+                    return false;
+                }
+
+                if (!jobGroup.IsAutoDistributionEnabled || jobGroup.DistributionConfig == null)
+                {
+                    logger.LogError("Для группы работ {jobGroupId} отсутствуют настройки автораспределения. " +
+                        "IsAutoDistributionEnabled: {IsAutoDistributionEnabled}, есть настройки в таблице {DistributionConfig}, {existConfig}", jobGroupId, jobGroup.IsAutoDistributionEnabled, nameof(JobGroupDistributionConfig), jobGroup.DistributionConfig != null);
+                    return false;
+                }
 
                 return true;
             }
diff --git a/PARR.TemplateDistributor/TemplateDistributor.cs b/PARR.TemplateDistributor/TemplateDistributor.cs
index 1fcd64b4..02b6d675 100644
--- a/PARR.TemplateDistributor/TemplateDistributor.cs
+++ b/PARR.TemplateDistributor/TemplateDistributor.cs
@@ -3,6 +3,7 @@ using Microsoft.Extensions.Logging;
 using PARR.BLL.Services.Interfaces;
 using PARR.Constants;
 using PARR.DAL.Models;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.TransformServices;
 using System.Reflection.Metadata.Ecma335;
@@ -12,427 +13,30 @@ namespace PARR.TemplateDistributor
     internal class TemplateDistributor : ITemplateDistributor
     {
         private readonly ILogger<TemplateDistributor> logger;
-        private readonly ITemplateService templateService;
-        private readonly IApplicationsInWorkService applicationsInWorkService;
-        private readonly ICalendarService calendarService;
-        private readonly IEsppScheduleTransformService esppScheduleTransformService;
-        private readonly IWeekendDayService weekendDayService;
-        private readonly INextRunModifierService nextRunModifierService;
+        private readonly INextRunService nextRunService;
 
         public TemplateDistributor(
             ILogger<TemplateDistributor> logger,
-            ITemplateService templateService,
-            IApplicationsInWorkService applicationsInWorkService,
-            ICalendarService calendarService,
-            IEsppScheduleTransformService esppScheduleTransformService,
-            IWeekendDayService weekendDayService,
-            INextRunModifierService nextRunModifierService
+            INextRunService nextRunService
             )
         {
             this.logger = logger;
-            this.templateService = templateService;
-            this.applicationsInWorkService = applicationsInWorkService;
-            this.calendarService = calendarService;
-            this.esppScheduleTransformService = esppScheduleTransformService;
-            this.weekendDayService = weekendDayService;
-            this.nextRunModifierService = nextRunModifierService;
+            this.nextRunService = nextRunService;
         }
 
 
-        public async Task UpdateScheduleAsync(Guid applicationInWorkId)//TODO Migratin to Job
+        public async Task DistributeAsync(Guid jobGroupId)
         {
-            var appInWork = await applicationsInWorkService.GetAsync(applicationInWorkId);
+            // вызвать метод распределения, и получить новые даты
+            var distributedTemplates = await nextRunService.GetNextRunForJobGroupWithAutoDistributionAsync(jobGroupId);
 
-            var templates = await templateService.Get()
-                                                    .Include(t => t.Unit)//TODO Migratin to Job
-                                                                         //.ThenInclude(h => h!.WorkGroup)
-                                                    .Where(t => t.JobId == applicationInWorkId && t.Unit!.BaseFields!.WorkGroup != null)//TODO Migratin to Job
-                                                    .ToListAsync();
-
-            //Группируем шаблоны по рабочим группам
-            var workGroupsWithTemplates = templates.GroupBy(t => t.Unit!.BaseFields!.WorkGroup);
-
-            /*foreach (var workGroupWithTemplates in workGroupsWithTemplates)
+            if (distributedTemplates == null)
             {
-                var wgId = (Guid)workGroupWithTemplates.Key!;
-                var values = workGroupWithTemplates.ToList();
-
-                //Обновляем сразу время при необходимости, так как дальше будем работать только с датой
-                var timesList = values.Select(t => t.NextRun.TimeOfDay).Distinct().ToList();
-                if (timesList.Count() > 1 || (timesList.Count() == 1 && timesList[0] != appInWork!.ReferenceDate.TimeOfDay))
-                {
-                    values.ForEach(t =>
-                    {
-                        if (t.NextRun.TimeOfDay != appInWork!.ReferenceDate.TimeOfDay)
-                            t.NextRun = new DateTimeOffset(t.NextRun.Year, t.NextRun.Month, t.NextRun.Day,
-                                appInWork!.ReferenceDate.Hour, appInWork!.ReferenceDate.Minute, appInWork!.ReferenceDate.Second,
-                                new TimeSpan(0, 0, 0));
-                    });
-                    if (!await templateService.CommitAsync())
-                    {
-                        logger.LogError($"Ошибка записи изменений в БД при актуализации времени NextRun шаблонов РР({applicationInWorkId})");
-                        return;
-                    }
-                }
-
-                var distrTemplates = await DistributeTemplateAsync(new List<Template>(), applicationInWorkId, wgId);
-
-                if (distrTemplates.Any())
-                    if (!await templateService.CommitAsync())
-                        logger.LogError($"Ошибка записи изменений в БД при перераспределении NextRun шаблонов РР({applicationInWorkId})");
-            }*/
-            // TODO Migratin to Job
-        }
-
-
-        public async Task<List<Template>> DistributeTemplateAsync(List<Template> templates, Guid applicationInWorkId, Guid workGroupId)
-        {
-            //    var appInWork = await applicationsInWorkService.Get()
-            //                                                        .Include(aiw => aiw.EsppSchValues)
-            //                                                        .ThenInclude(esv => esv.EsppSchTypeValue)
-            //                                                        .ThenInclude(etv => etv!.DistributionPeriod)
-            //                                                    .FirstAsync(t => t.Id == applicationInWorkId);
-
-            //    var refDate = appInWork.ReferenceDate;
-
-            //    //Проверяем наличие распределения РР на период
-            //    if (appInWork.IsAutoDistributionEnabled)
-            //    {
-            //        var existingTemplates = await templateService.Get()
-            //                                            .Include(t => t.Unit)
-            //                                            .Where(t => t.JobId == applicationInWorkId 
-            //                                            //&& t.Host!.WorkGroupId == workGroupId//TODO Migratin to Job
-            //                                            )
-            //                                            .ToListAsync();
-
-            //        //Удалим из входных шаблонов уже существующие в БД (по идее, такого никогда не должно случиться)
-            //        var duplicates = templates.Select(t => t.Id).Where(t => existingTemplates.Any(et => et.Id == t)).ToList();
-            //        if (duplicates.Count > 0)
-            //        {
-            //            duplicates.ForEach(t =>
-            //            {
-            //                logger.LogWarning($"Для распределения AiW({applicationInWorkId}),workGroupId({workGroupId}) передан существующий в базе данных шаблон {t}");
-            //            });
-            //            templates.RemoveAll(t => duplicates.Any(dt => dt == t.Id));
-            //        }
-
-
-            //        existingTemplates.AddRange(templates);
-
-            //        //Если распределенная РР получаем начало
-            //        var period = appInWork.EsppSchValues.First()!.EsppSchTypeValue!.DistributionPeriod;
-            //        var periodType = ParseDistributionPeriodType(period!.Type);
-
-            //        var workDays = await GetWorkDaysAsync(appInWork);
-
-            //        var result = new List<Template>();
-
-            //        //распределяем РР отдельно активированные
-            //        var activatedTemplates = existingTemplates.Where(t => t.IsActiveTemplate && t.IsActiveSchedule).ToList();
-            //        if (activatedTemplates.Count > 0)
-            //        {
-            //            Distribute(ref activatedTemplates, refDate, period, periodType, workDays);
-            //            // result.AddRange(activatedTemplates);
-            //        }
-
-            //        //распределяем РР отдельно деактивированные
-            //        var deactivatedTemplates = existingTemplates.Where(t =>
-            //                                !t.IsActiveTemplate || !t.IsActiveSchedule || (
-            //                                !t.IsActiveTemplate && !t.IsActiveSchedule
-            //                                    )).ToList();
-            //        if (deactivatedTemplates.Count > 0)
-            //        {
-            //            Distribute(ref deactivatedTemplates, refDate, period, periodType, workDays);
-            //            // result.AddRange(deactivatedTemplates);
-            //        }
-
-
-            //        if (templates.Any())
-            //        {
-            //            // это была генерация шаблонов, не нужны все шаблоны, нужны только те которые передал для получения NextRun
-            //            result.AddRange(templates);
-            //        }
-            //        else
-            //        {
-            //            // это было распределение шаблонов, добавляем активированные и деактивированные
-            //            result.AddRange(activatedTemplates);
-            //            result.AddRange(deactivatedTemplates);
-            //        }
-
-            //        return result;
-            //        #region comments
-
-            //        //var d = new Dictionary<DateOnly, List<Template>>();
-            //        //foreach (var wd in workDays)
-            //        //{
-            //        //    var wrokDateTimeOffset = new DateTimeOffset(
-            //        //            wd.Year, wd.Month, wd.Day,
-            //        //            refDate.Hour, refDate.Minute, refDate.Second,
-            //        //            new TimeSpan(0, 0, 0));
-            //        //    if (wrokDateTimeOffset < DateTimeOffset.UtcNow)
-            //        //        wrokDateTimeOffset = esppScheduleTransformService.GetNextDateForDistributionRun(wrokDateTimeOffset, periodType, period.Duration);
-
-            //        //    var assignedTemplates = existingTemplates.Where(t => t.NextRun == wrokDateTimeOffset).ToList();
-            //        //    d.Add(wd, assignedTemplates);
-            //        //}
-
-            //        //var templatesPerStep = (double)templates.Count() / workDays.Count();//
-            //        //var currentTemplateStep = (int)Math.Ceiling(templatesPerStep);
-            //        //var delta = templatesPerStep - currentTemplateStep;
-            //        ////templates.First().NextRun = currentDay;
-            //        //var templateDistributed = 0;
-
-            //        ////Отталкиваясь от количества 
-            //        //while (templateDistributed < templates.Count())
-            //        //{
-            //        //    var wdCounts = d.Select(wd => wd.Value).OrderBy(count => count).ToArray();
-            //        //    var templateCountDelta = d.Max(t => t.Value.Count()) - d.Min(t => t.Value.Count());
-            //        //    var addingTemplatesCount = wdCounts.Length > 1 ?
-            //        //       (templateCountDelta == 0) ? (int)Math.Ceiling(templatesPerStep) : templateCountDelta :
-            //        //        (int)Math.Ceiling(templatesPerStep);
-            //        //    var workDaysWithMinTemplates = d.Where(wd => wd.Value == wdCounts[0]).ToArray();
-
-            //        //    if (workDaysWithMinTemplates.Length * addingTemplatesCount < templates.Count())
-            //        //    {
-            //        //        foreach (var wd in workDaysWithMinTemplates)
-            //        //        {
-            //        //            //Считаем DateTimeOffset, потому что у нас только дата пока 
-            //        //            var currentDay = new DateTimeOffset(
-            //        //            wd.Key.Year, wd.Key.Month, wd.Key.Day,
-            //        //            refDate.Hour, refDate.Minute, refDate.Second,
-            //        //            new TimeSpan(0, 0, 0));
-
-            //        //            templates.Skip(templateDistributed).Take(addingTemplatesCount).ToList().ForEach(t =>
-            //        //            {
-            //        //                t.NextRun = currentDay;
-            //        //                d[wd.Key].Add(t);
-            //        //            });
-            //        //            templateDistributed += addingTemplatesCount;
-
-            //        //        }
-            //        //    }
-            //        //    else
-            //        //    {
-            //        //        while (templateDistributed < templates.Count())
-            //        //        {
-            //        //            var wd = d.Where(wd => wd.Value == d.Min(t => t.Value)).First();
-            //        //            //Считаем DateTimeOffset, потому что у нас только дата пока 
-            //        //            var currentDay = new DateTimeOffset(
-            //        //            wd.Key.Year, wd.Key.Month, wd.Key.Day,
-            //        //            refDate.Hour, refDate.Minute, refDate.Second,
-            //        //            new TimeSpan(0, 0, 0));
-
-            //        //            templates.Skip(templateDistributed).Take(addingTemplatesCount).ToList().ForEach(t =>
-            //        //            {
-            //        //                t.NextRun = currentDay;
-            //        //                d[wd.Key].Add(t);
-            //        //            });
-            //        //            templateDistributed += addingTemplatesCount;
-            //        //        }
-            //        //    }
-            //        //}
-
-            //        #endregion
-            //    }
-            //    else
-            //        // templates.ForEach(t => t.NextRun = appInWork!.ReferenceDate);
-            //        // это не автораспределение, по ReferenceDate получаем ближайший рабочий день
-            //        templates.ForEach(async t => t.NextRun = await nextRunModifierService.GetWorkDayAsync(appInWork!.ReferenceDate));
-
-            //    return templates;
-            return new List<Template>();
-        }
-
-        private void Distribute(ref List<Template> templates, DateTimeOffset refDate, DistributionPeriod period, DistributionPeriodTypeEnum periodType, List<DateOnly> workDays)
-        {
-            //Готовим план распределения
-            var distrPlan = GetDistributionPlan(workDays, templates.Count);
-
-            //Проверяем шаблоны уже распределённые, чтобы не перемещать лишний раз
-            var templateToDistrib = GetTemplatesToDistribute(ref distrPlan, templates);
-
-
-            string? loggerWorkGroup = templates.FirstOrDefault()?.Unit?.BaseFields?.WorkGroup != null ? templates.FirstOrDefault()?.Unit.BaseFields.WorkGroup : templates.FirstOrDefault()?.Unit?.BaseFields?.WorkGroup?.ToString();
-            logger.LogInformation($"{GetType().Name}(AppInWId:{templates.Select(t => t.JobId).First()}, " +
-                $"WorkGroup:{loggerWorkGroup}) " +
-                $"запланировал изменение даты следующего срабатывания у {templateToDistrib.Count()} существующих шаблона(ов), {templates.Count() - templateToDistrib.Count()} остались без изменений");
-
-            if (!templateToDistrib.Any())
+                logger.LogWarning("При распределении шаблонов по jobGroupId {jobGroupId} вернулся null. Это ошибка. Прекращаю распределение.", jobGroupId);
                 return;
-
-            var distributedTemplates = 0;
-            //Распределяем шаблоны в соответствии с планом непосредственно
-            foreach (var workDay in distrPlan)
-            {
-                var templatesCountForCurDay = workDay.Value;
-                if (templatesCountForCurDay < 1)
-                    continue;
-
-                templateToDistrib.Skip(distributedTemplates).Take(templatesCountForCurDay).ToList().ForEach(t =>
-                {
-                    var nextRun = new DateTimeOffset(
-                            workDay.Key.Year, workDay.Key.Month, workDay.Key.Day,
-                            refDate.Hour, refDate.Minute, refDate.Second,
-                            new TimeSpan(0, 0, 0));
-                    if (nextRun < DateTimeOffset.UtcNow)
-                        nextRun = esppScheduleTransformService.GetNextDateForDistributionRun(nextRun, periodType, period.Duration);
-
-                    t.NextRun = nextRun;
-                });
-
-                distributedTemplates += templatesCountForCurDay;
-
-                distrPlan[workDay.Key] -= templatesCountForCurDay;
-            }
-        }
-
-        /// <summary>
-        /// Получить список рабочих дней из календаря и перенести прошедшие даты на следующий период по РР
-        /// </summary>
-        /// <param name="appInWork"></param>
-        /// <returns></returns>
-        private async Task<List<DateOnly>> GetWorkDaysAsync(ApplicationsInWork appInWork)
-        {
-            //var period = appInWork.EsppSchValues.FirstOrDefault()?.EsppSchTypeValue?.DistributionPeriod;
-            //var periodType = ParseDistributionPeriodType(period!.Type);
-
-            ////старт период, берем сейчас, будем получать рабочие дни с вычетом выходных на весь период сразу.
-            //var startPeriod = DateOnly.FromDateTime(DateTimeOffset.UtcNow.Date);
-            //// старт период считаем относительно refDate
-            ////var startPeriod = await esppScheduleTransformService.GetStartPeriodForDateAsync(appInWork.Id, appInWork.ReferenceDate, appInWork.ReferenceDate, periodType, period.Duration);
-
-            //var workDays = calendarService.GetWorkDatesForPeriod(startPeriod, TimeOnly.FromDateTime(appInWork.ReferenceDate.DateTime), periodType, period.Duration, weekendDayService.GetWeekends);
-
-            //#region старая логика
-            ////var resultWorkDays = new List<DateOnly>();
-
-            ////workDays.ForEach(wd =>
-            ////{
-            ////    var wrokDateTimeOffset = new DateTimeOffset(
-            ////                                wd.Year, wd.Month, wd.Day,
-            ////                                appInWork.ReferenceDate.Hour, appInWork.ReferenceDate.Minute, appInWork.ReferenceDate.Second,
-            ////                                new TimeSpan(0, 0, 0));
-
-            ////    if (wrokDateTimeOffset < DateTimeOffset.UtcNow)
-            ////    {
-            ////        wrokDateTimeOffset = esppScheduleTransformService.GetNextDateForDistributionRun(wrokDateTimeOffset, periodType, period.Duration);
-            ////        //wd = DateOnly.FromDateTime(wrokDateTimeOffset.DateTime);
-            ////        resultWorkDays.Add(DateOnly.FromDateTime(wrokDateTimeOffset.DateTime));
-            ////    }
-            ////    else
-            ////    {
-            ////        resultWorkDays.Add(wd);
-            ////    }
-            ////});
-
-            //////----- убираем даты, которые могли выйти за конец периода (из-за сдвига NextRun по рабочим дням)
-            ////var endPeriod = calendarService.GetEndPeriodDate(DateOnly.FromDateTime(DateTimeOffset.UtcNow.Date), periodType, period.Duration);
-            ////resultWorkDays = resultWorkDays.Where(t => t <= endPeriod).Distinct().OrderBy(t => t).ToList();
-            //////-----
-
-            ////return resultWorkDays;
-            //#endregion
-
-            //return workDays;
-
-            return new List<DateOnly>();
-        }
-
-        /// <summary>
-        /// Проверить соответствие распределения существующих шаблонов нововму плану.
-        /// На выходе получаем шаблоны, которым требуется изменить дату следующего запуска.
-        /// </summary>
-        /// <param name="distributionPlan"></param>
-        /// <param name="templates"></param>
-        /// <returns></returns>
-        private List<Template> GetTemplatesToDistribute(ref Dictionary<DateOnly, int> distributionPlan, List<Template> templates)
-        {
-            var result = new List<Template>();
-
-            foreach (var wd in distributionPlan)
-            {
-                var templatesInWd = templates.Where(t => DateOnly.FromDateTime(t.NextRun.DateTime) == wd.Key).ToList();
-
-                if (templatesInWd.Any() && templatesInWd.Count > wd.Value)
-                {
-                    result.AddRange(templatesInWd.Skip(wd.Value).Take(templatesInWd.Count - wd.Value).ToList());
-                    distributionPlan[wd.Key] -= wd.Value;
-                }
-                else
-                    distributionPlan[wd.Key] -= templatesInWd.Count;
             }
 
-            //Определим шаблоны за границами рабочих дней. Их тоже необходимо перераспределить
-            var workDays = distributionPlan.Keys.ToList();
-            var templateWithNextRunOut = templates.Where(t => workDays.All(w => w != DateOnly.FromDateTime(t.NextRun.DateTime))).ToList();
-
-            if (templateWithNextRunOut.Any())
-                result.AddRange(templateWithNextRunOut);
-
-            if (result.Any())
-                //Обнулим nextRun
-                result.ForEach(t => t.NextRun = DateTimeOffset.MinValue);
-
-            return result;
-        }
-
-
-        private DistributionPeriodTypeEnum ParseDistributionPeriodType(string value)
-        {
-            var result = (DistributionPeriodTypeEnum)Enum.Parse(typeof(DistributionPeriodTypeEnum), value);
-
-            return result;
-        }
-
-
-        private Dictionary<DateOnly, int> GetDistributionPlan(List<DateOnly> workDays, int templateCount)
-        {
-            var result = new Dictionary<DateOnly, int>();
-            //Заполняем будующий план датами из полученных на входе данных
-            foreach (var wd in workDays)
-            {
-                var workDate = new DateOnly(wd.Year, wd.Month, wd.Day);
-                result.Add(workDate, 0);
-            }
-
-            var templateDistributedCount = 0;//количество распределённых на текущий момент шаблонов
-
-            //Если количество шаблонов больше количества рабочих дней, то сразу распределяем их равным количеством по всем рабочим дням
-            if (templateCount >= workDays.Count)
-            {
-                //количеством шаблонов на один рабочий день
-                var mainPartTemplateCountToDistribute = templateCount / workDays.Count;
-
-                //перебираем рабочие дня и записываем количество шаблонов
-                foreach (var item in result)
-                {
-                    result[item.Key] = mainPartTemplateCountToDistribute;
-
-                    templateDistributedCount += mainPartTemplateCountToDistribute;
-                }
-            }
-
-            var daysBetweenTemplates = (double)workDays.Count / (templateCount % workDays.Count);//количество дней между шаблонами, если распределить их равномерно
-            var currentStepBetweenTemplates = (double)Math.Floor(daysBetweenTemplates);//инициализация шага перехода между датами запуска двух шаблонов
-            var balance = (double)daysBetweenTemplates - Math.Floor(currentStepBetweenTemplates);//остаток между датами, потому что мы берём целые дни, его нужно учесть в следующей итирации
-            var currentDayIndex = 0;//инициализация индекса даты словаря рабочих дней
-
-            while (templateDistributedCount < templateCount)
-            {
-                //лишняя проверка так как шагом ранее мы распределям шаблоны равным количеством и currentStepBetweenTemplates не может быть меньше одного дня
-                //if (currentStepBetweenTemplates > 0)
-                //{
-                result[result.ElementAt(currentDayIndex).Key] += 1;
-                templateDistributedCount++;
-                currentDayIndex += (int)Math.Floor(currentStepBetweenTemplates);
-                //}
-
-                currentStepBetweenTemplates = daysBetweenTemplates + balance;
-                balance = daysBetweenTemplates - currentStepBetweenTemplates;
-            }
-
-            return result;
+            // получить список шаблонов, сравнить их с распределенными, обновить даты, сохранить
         }
     }
-
 }
diff --git a/PARR.TemplateDistributorWorker/Worker.cs b/PARR.TemplateDistributorWorker/Worker.cs
index 364b5f6e..40913a08 100644
--- a/PARR.TemplateDistributorWorker/Worker.cs
+++ b/PARR.TemplateDistributorWorker/Worker.cs
@@ -4,25 +4,23 @@ namespace PARR.TemplateDistributorWorker
 {
     public class Worker : BackgroundService
     {
-        private readonly ILogger<Worker> _logger;
         private readonly IMqTemplateDistributor mqTemplateDistributor;
 
         public Worker(ILogger<Worker> logger, IMqTemplateDistributor mqTemplateDistributor)
         {
-            _logger = logger;
             this.mqTemplateDistributor = mqTemplateDistributor;
         }
 
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
-           await mqTemplateDistributor.StartAsync();
+            await mqTemplateDistributor.StartAsync();
+            await Task.Delay(Timeout.Infinite, stoppingToken);
         }
 
-        public override Task StopAsync(CancellationToken cancellationToken)
+        public override async Task StopAsync(CancellationToken cancellationToken)
         {
-            mqTemplateDistributor.StopAsync().Wait();
-
-            return base.StopAsync(cancellationToken);
+            await mqTemplateDistributor.StopAsync();
+            await base.StopAsync(cancellationToken);
         }
     }
 }
diff --git a/docker-compose.template-distributor.yml b/docker-compose.template-distributor.yml
index 1e5c5c36..cf0bc65e 100644
--- a/docker-compose.template-distributor.yml
+++ b/docker-compose.template-distributor.yml
@@ -17,7 +17,7 @@ services:
         fluentd-buffer-limit: '52428800'
         tag: parr.template-distributor.serilog
     deploy:
-      replicas: 2  
+      replicas: 1  
     networks:
       parr-network: