feat(api,dal): templateController - убрана страрая логика ЗО. StatTemplateDistributorController - обновлена логика отображения статистики

PARR.API/Contracts/V1/Requests/BaseRequests/TimeZoneOffsetClient.cs

@@ -1,10 +1,23 @@
-namespace PARR.API.Contracts.V1.Requests.BaseRequests
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+
+namespace PARR.API.Contracts.V1.Requests.BaseRequests
 {
     /// <summary>
     /// Смещение таймзоны относительно клиента
     /// </summary>
     public class TimeZoneOffsetClient
     {
+        /// <summary>
+        /// Удалить TimeZoneOffsetHours и не использовать!!!!!! Использовать только в минутах TimeZoneOffsetMinutes
+        /// </summary>
         public int TimeZoneOffsetHours { get; set; } = 0;
+
+        /// <summary>
+        /// Часовая зона клиента, в минутах
+        /// </summary>
+        public int TimeZoneOffsetMinutes { get; set; } = 0;
+
+        [BindNever]
+        public TimeSpan TimeZoneOffset => TimeSpan.FromMinutes(TimeZoneOffsetMinutes);
     }
 }

PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs

@@ -29,7 +29,10 @@
 
     public class StatDistributorItemResponse
     {
-        public string? WorkGroupName { get; set; }
+        /// <summary>
+        /// Наименование поля по которому группируется
+        /// </summary>
+        public string? GroupFieldName { get; set; }
 
         public int AllCount => Statistics?.Sum(t => t.AllCount) ?? 0;
         public int IsActivatedCount => Statistics?.Sum(t => t.IsActivatedCount) ?? 0;
@@ -47,15 +50,19 @@
         public int IsActivatedCount { get; set; }
         public int IsDeactivatedCount { get; set; }
         public int TemplatesInWeekendCount => !IsWorkDay && Templates != null ? Templates.Count : 0;
-        public List<StatTempleteDistribItem>? Templates { get; set; }
+        public List<StatTemplateDistribItem>? Templates { get; set; }
     }
 
-    public class StatTempleteDistribItem
+    public class StatTemplateDistribItem
     {
+        /// <summary>
+        /// TemplateId
+        /// </summary>
+        public Guid Id { get; set; }    
         public required string Name { get; set; }
         public DateTimeOffset NextRun { get; set; }
         public bool IsActiveTemplate { get; set; }
         public bool IsActiveSchedular { get; set; }
-        public required ScheduleResponseAreaTimeOffsetResponse ResponseAreaOffset { get; set; }
+        //public required ScheduleResponseAreaTimeOffsetResponse ResponseAreaOffset { get; set; }
     }
 }

PARR.API/Contracts/V1/Responses/TemplateResponse.cs

@@ -45,7 +45,7 @@
 
         public bool IsAutoDistributionEnabled { get; set; }
 
-        public ScheduleResponseAreaTimeOffsetResponse? ResponseAreaOffset { get; set; }
+        //public ScheduleResponseAreaTimeOffsetResponse? ResponseAreaOffset { get; set; }
     }
 
 

PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs

@@ -29,7 +29,7 @@ namespace PARR.API.Controllers.V1.Statistics
         private readonly IJobGroupService jobGroupService;
         private readonly IMapper mapper;
         private readonly IShortcodesService shortcodesService;
-        private readonly INextRunService nextRunService;
+        private readonly INextRunServiceV2 nextRunService;
         private readonly ILogger<StatTemplateDistributionController> logger;
         private readonly IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService;
 
@@ -38,7 +38,7 @@ namespace PARR.API.Controllers.V1.Statistics
             IJobGroupService jobGroupService,
             IMapper mapper,
             IShortcodesService shortcodesService,
-            INextRunService nextRunService,
+            INextRunServiceV2 nextRunService,
             ILogger<StatTemplateDistributionController> logger,
             IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService
             )
@@ -63,8 +63,6 @@ namespace PARR.API.Controllers.V1.Statistics
         {
             // eadc5498-dba6-4f10-9b4b-a1653e3c3e61
 
-            //TODO: похоже что timeZoneQuery лишняя
-
             var jobGroup = await jobGroupService.Get()
                                     .Include(t => t.DistributionConfig)
                                         .ThenInclude(t => t.DistributionPeriod)
@@ -95,65 +93,86 @@ namespace PARR.API.Controllers.V1.Statistics
                     ItemsList = null
                 }, true));
 
-            var (dateStart, dateEnd) = GetStartEndPeriod(jobGroup, items.Max(t => t.Template.NextRun), timeZoneQuery.TimeZoneOffsetHours);
+
+            var (dateStart, dateEnd) = GetStartEndPeriod(jobGroup, items.Min(t => t.Template.NextRun), items.Max(t => t.Template.NextRun), timeZoneQuery.TimeZoneOffset);
 
             // получаем список рабочих дней
             // получет все дни, даже с выходными, чтоб видеть реальную картину
-            var workDays = await nextRunService.GetWorkDaysAsync(dateStart, dateEnd, false, jobGroup.ReferenceDate);
+            var allDays = await nextRunService.GetWorkDaysAsync(dateStart, dateEnd, false);
 
             // получить список выходных дней (показываем только если IsExcludeWeekends = true)
             var weekends = jobGroup.DistributionConfig.IsExcludeWeekends
-                                        ? await nextRunService.GetWeekendsAsync(dateStart, dateEnd, jobGroup.ReferenceDate)
+                                        ? await nextRunService.GetWeekendsAsync(dateStart, dateEnd)
                                         : new HashSet<DateOnly>();
 
+
             var responseItemsList = new List<StatDistributorItemResponse>();
 
             if (jobGroup.DistributionConfig.IsGroupingByWorkGroup)
             {
                 // тут группируем по рабочим группам
+                logger.LogDebug("Группируем по рабочим группам");
 
                 // Получаем список пар (WorkGroupName, Template)
-                var templatesWithWorkGroupNames = new List<(string WorkGroupName, (Template Template, string ResponseArea))>();
+                var templatesWithWorkGroupNames = new List<(string WorkGroupName, Template Template)>();
 
-                // получаем названия рабочих групп и ЗО
+                // получаем названия рабочих групп
                 foreach (var item in items)
                 {
                     var workGroupName = await shortcodesService.ApplyShortcodesAsync(item.WorkGroupMask, item.Template);
-                    var responseArea = await shortcodesService.ApplyShortcodesAsync(item.ResponseAreaMask, item.Template);
+                    templatesWithWorkGroupNames.Add((workGroupName, item.Template));
-                    templatesWithWorkGroupNames.Add((workGroupName, (item.Template, responseArea)));
                 }
 
                 // Группируем по WorkGroupName
                 var grouped = templatesWithWorkGroupNames
                                     .GroupBy(x => x.WorkGroupName)
-                                    .ToDictionary(g => g.Key, g => g.Select(x => x.Item2).ToList());
+                                    .ToDictionary(g => g.Key, g => g.Select(x => x.Template).ToList());
 
                 foreach (var groupedItem in grouped)
                 {
-                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value.ToList(), workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate);
+                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value.ToList(), allDays, weekends, timeZoneQuery.TimeZoneOffset);
+                    responseItemsList.Add(statResult);
+                }
+            }
+            else if (jobGroup.IsResponseAreaTimezone && !jobGroup.DistributionConfig.IsGroupingByWorkGroup)
+            {
+                // грппируем только по ЗО
+                logger.LogDebug("Группируем по ЗО");
+
+                // Будет группироваться по EsppValue, по MSK, MSK+1...
+                // получаем названия ЗО, из ЗО часовой пояс, формируем список шаблонов с часовым поясом ЗО
+                var templatesWithTimeZone = new List<(Template Template, string MskTimeZone)>();
+                foreach (var item in items)
+                {
+                    var responseArea = await shortcodesService.ApplyShortcodesAsync(item.ResponseAreaMask, item.Template);
+                    var mskTimeZone = scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea);
+                    templatesWithTimeZone.Add((item.Template, mskTimeZone.EsppValue));
+                }
+
+                // Группируем по часовому поясу
+                var grouped = templatesWithTimeZone
+                                 .GroupBy(x => x.MskTimeZone)
+                                 .ToDictionary(g => g.Key, g => g.Select(x => x.Template).ToList());
+
+                foreach (var groupedItem in grouped)
+                {
+                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value.ToList(), allDays, weekends, timeZoneQuery.TimeZoneOffset);
                     responseItemsList.Add(statResult);
                 }
             }
             else
             {
-                // не нужно группировать по рабочим группам
+                // не нужно группировать
-
+                logger.LogDebug("Без группировки");
-                // получаем названия ЗО
-                var templatesWithResponseArea = new List<(Template Template, string ResponseArea)>();
-                foreach (var item in items)
-                {
-                    var responseArea = await shortcodesService.ApplyShortcodesAsync(item.ResponseAreaMask, item.Template);
-                    templatesWithResponseArea.Add((item.Template, responseArea));
-                }
 
                 // сразу формируем response
-                responseItemsList.Add(GetResponseByWorkGroup(null, templatesWithResponseArea, workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate));
+                responseItemsList.Add(GetResponseByWorkGroup(null, items.Select(t => t.Template).ToList(), allDays, weekends, timeZoneQuery.TimeZoneOffset));
             }
 
             var response = new StatTemplateDistributorResponse
             {
                 JobGroup = mapper.Map<JobGroupWithDistributionConfigResponse>(jobGroup),
-                ItemsList = responseItemsList.OrderBy(t => t.WorkGroupName).ToList()
+                ItemsList = responseItemsList.OrderBy(t => t.GroupFieldName).ToList()
             };
 
             return Ok(new Response<StatTemplateDistributorResponse>(response, true));
@@ -163,29 +182,33 @@ namespace PARR.API.Controllers.V1.Statistics
         /// Получить дату начала и конца периода
         /// </summary>
         /// <param name="jobGroup"></param>
+        /// <param name="minNextRunTemplate"></param>
         /// <param name="maxNextRunTemplate"></param>
-        /// <param name="timeZoneOffsetHours"></param>
+        /// <param name="clientOffset"></param>
         /// <returns></returns>
-        private (DateOnly dateStart, DateOnly dateEnd) GetStartEndPeriod(JobGroup jobGroup, DateTimeOffset maxNextRunTemplate, int timeZoneOffsetHours)
+        private (DateOnly dateStart, DateOnly dateEnd) GetStartEndPeriod(JobGroup jobGroup, DateTimeOffset minNextRunTemplate, DateTimeOffset maxNextRunTemplate, TimeSpan clientOffset)
         {
             var durationDays = nextRunService.GetDurationDays(jobGroup.DistributionConfig!);
 
-            var dateStart = DateOnly.FromDateTime(DateTime.UtcNow.AddHours(timeZoneOffsetHours));
+            var dateStart = DateOnly.FromDateTime(DateTime.UtcNow.Add(clientOffset));
 
             // последний день, не может быть меньше чем durationDays
             var dateEnd = dateStart.AddDays(durationDays);
 
             // последний день, не может быть меньше чем refDate+durationDays
-            var sumRefDuration = DateOnly.FromDateTime(jobGroup.ReferenceDate.AddHours(timeZoneOffsetHours).AddDays(durationDays).Date);
+            var sumRefDuration = DateOnly.FromDateTime(jobGroup.ReferenceDate.Add(clientOffset).AddDays(durationDays).Date);
             if (dateEnd < sumRefDuration)
                 dateEnd = sumRefDuration;
 
-            // с DateEnd вообще какая-то шурпатня :(
-            // как наглядно понять ок не ок распределяется, если на каком-то графике dateEnd может ухеать за период распределения
             // последний день, не может быть меньше чем дата последнего шаблона maxNextRunTemplate
-            var lastTempalteDate = DateOnly.FromDateTime(maxNextRunTemplate.AddHours(timeZoneOffsetHours).Date);
+            var lastTemplateDate = DateOnly.FromDateTime(maxNextRunTemplate.Add(clientOffset).Date);
-            if (dateEnd < lastTempalteDate)
+            if (dateEnd < lastTemplateDate)
-                dateEnd = lastTempalteDate;
+                dateEnd = lastTemplateDate;
+
+            // Дата начала, не может быть меньше чем minNextRunTemplate
+            var minNextRunDate = DateOnly.FromDateTime(minNextRunTemplate.Add(clientOffset).Date);
+            if (dateStart < minNextRunDate)
+                dateStart = minNextRunDate;
 
             return (dateStart, dateEnd);
         }
@@ -193,49 +216,49 @@ namespace PARR.API.Controllers.V1.Statistics
         /// <summary>
         /// Заполнить респонс
         /// </summary>
-        /// <param name="workGroupName"></param>
+        /// <param name="groupFieldName"></param>
         /// <param name="templateList"></param>
-        /// <param name="workDays"></param>
+        /// <param name="allDays"></param>
-        /// <param name="timeZoneOffsetHours"></param>
+        /// <param name="weekends"></param>
+        /// <param name="clientOffset"></param>
         /// <returns></returns>
-        private StatDistributorItemResponse GetResponseByWorkGroup(string? workGroupName, List<(Template Template, string ResponseArea)> templateList, List<DateOnly> workDays, HashSet<DateOnly> weekends, int timeZoneOffsetHours, DateTimeOffset referenceDate)
+        private StatDistributorItemResponse GetResponseByWorkGroup(string? groupFieldName, List<Template> templateList, List<DateOnly> allDays, HashSet<DateOnly> weekends, TimeSpan clientOffset)
         {
             var result = new StatDistributorItemResponse
             {
-                WorkGroupName = workGroupName,
+                GroupFieldName = groupFieldName,
-                Statistics = workDays.OrderBy(t => t).Select(t => new StatTemplateDistributorDateStat
+                Statistics = allDays.OrderBy(t => t).Select(t => new StatTemplateDistributorDateStat
                 {
                     AllCount = 0,
-                    Date = new DateTimeOffset(t.Year, t.Month, t.Day, referenceDate.Hour, referenceDate.Minute, referenceDate.Second, referenceDate.Offset),
+                    // вычтем clientOffset, чтоб когда на клиенте он прибавился обратно, дата стала верной для клиента
+                    Date = new DateTimeOffset(t.Year, t.Month, t.Day, 0, 0, 0, TimeSpan.Zero).Add(-clientOffset),
                     IsWorkDay = !weekends.Contains(t),
                     IsActivatedCount = 0,
                     IsDeactivatedCount = 0,
-                    Templates = new List<StatTempleteDistribItem>()
+                    Templates = new List<StatTemplateDistribItem>()
                 }).ToList()
             };
 
-            //foreach (var templatesFromDate in templates.GroupBy(t => DateOnly.FromDateTime(t.NextRun.Date)))
+            // смещаем по часовой зоне клиента и группируем по дате
-            // смещаем по часовой зоне и группируем по дате
+            foreach (var templatesFromDate in templateList.GroupBy(t => DateOnly.FromDateTime(t.NextRun.Add(clientOffset).Date)))
-            //foreach (var templatesFromDate in templates.GroupBy(t => DateOnly.FromDateTime(t.NextRun.AddHours(timeZoneOffsetHours).Date)))
-            foreach (var templatesFromDate in templateList.GroupBy(t => DateOnly.FromDateTime(t.Template.NextRun.AddHours(timeZoneOffsetHours).Date)))
             {
-                var statisticsForDate = result.Statistics.FirstOrDefault(t => DateOnly.FromDateTime(t.Date.AddHours(timeZoneOffsetHours).Date) == templatesFromDate.Key);
+                var statisticsForDate = result.Statistics.FirstOrDefault(t => DateOnly.FromDateTime(t.Date.Add(clientOffset).Date) == templatesFromDate.Key);
                 if (statisticsForDate == null)
                 {
-                    logger.LogWarning("В списке рабочих дней, нет дня для шаблонов {count} шт. выполняющихся в {date}", templatesFromDate.Count(), templatesFromDate.Key);
+                    logger.LogWarning("В списке дней, нет дня для шаблонов {count} шт. выполняющихся в {date}", templatesFromDate.Count(), templatesFromDate.Key);
                     continue;
                 }
 
                 statisticsForDate.AllCount = templatesFromDate.Count();
-                statisticsForDate.IsDeactivatedCount = templatesFromDate.Count(t => !t.Template.IsActiveTemplate || !t.Template.IsActiveSchedule);
+                statisticsForDate.IsDeactivatedCount = templatesFromDate.Count(t => !t.IsActiveTemplate || !t.IsActiveSchedule);
-                statisticsForDate.IsActivatedCount = templatesFromDate.Count(t => t.Template.IsActiveTemplate && t.Template.IsActiveSchedule);
+                statisticsForDate.IsActivatedCount = templatesFromDate.Count(t => t.IsActiveTemplate && t.IsActiveSchedule);
-                statisticsForDate.Templates = templatesFromDate.Select(t => new StatTempleteDistribItem
+                statisticsForDate.Templates = templatesFromDate.Select(t => new StatTemplateDistribItem
                 {
-                    Name = t.Template.Name,
+                    Id = t.Id,
-                    IsActiveSchedular = t.Template.IsActiveSchedule,
+                    Name = t.Name,
-                    IsActiveTemplate = t.Template.IsActiveTemplate,
+                    IsActiveSchedular = t.IsActiveSchedule,
-                    NextRun = t.Template.NextRun,
+                    IsActiveTemplate = t.IsActiveTemplate,
-                    ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(t.ResponseArea))
+                    NextRun = t.NextRun
                 })
                 .OrderBy(t => t.Name)
                 .ToList();

PARR.API/Controllers/V1/TemplateController.cs

@@ -36,7 +36,6 @@ namespace PARR.API.Controllers.V1
         private readonly ILogger<TemplateController> logger;
         private readonly IShortcodesService shortcodesService;
         private readonly IOrderService orderService;
-        private readonly INextRunService nextRunService;
         private readonly SettingsFromDb settingsFromDb;
         private readonly IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService;
 
@@ -48,7 +47,6 @@ namespace PARR.API.Controllers.V1
             ILogger<TemplateController> logger,
             IShortcodesService shortcodesService,
             IOrderService orderService,
-            INextRunService nextRunService,
             SettingsFromDb settingsFromDb,
             IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService
             )
@@ -60,7 +58,6 @@ namespace PARR.API.Controllers.V1
             this.logger = logger;
             this.shortcodesService = shortcodesService;
             this.orderService = orderService;
-            this.nextRunService = nextRunService;
             this.settingsFromDb = settingsFromDb;
             this.scheduleResponseAreaTimeOffsetService = scheduleResponseAreaTimeOffsetService;
         }
@@ -138,7 +135,7 @@ namespace PARR.API.Controllers.V1
                 {
                     //await ApplyTemplateShortcodesAsync(responseItem, templates.First(t => t.Id == responseItem.Id));
                     await ApplyTemplateShortcodesAsync(responseItem, templatesDict[responseItem.Id]);
-                    FillResponseAreaOffset(responseItem);
+                    //FillResponseAreaOffset(responseItem);
                 }
                 //logger.LogDebug("Получение шорткодов: {ElapsedMs} мс", sw.ElapsedMilliseconds);
                 //sw.Stop();
@@ -183,7 +180,7 @@ namespace PARR.API.Controllers.V1
 
             var response = mapper.Map<TemplateResponse>(template);
             await ApplyTemplateShortcodesAsync(response, template);
-            FillResponseAreaOffset(response);
+            //FillResponseAreaOffset(response);
 
             var ordersCountResult = await GetOrdersCountAsync(new List<Guid> { response.Id });
             response.OrderCount = ordersCountResult.Count > 0 ? ordersCountResult.First().Value : 0;
@@ -277,7 +274,7 @@ namespace PARR.API.Controllers.V1
             var response = mapper.Map<TemplateListResponse>(templateToResponse);
 
             await ApplyTemplateShortcodesAsync(response, templateToResponse);
-            FillResponseAreaOffset(response);
+            //FillResponseAreaOffset(response);
 
             var ordersCountResult = await GetOrdersCountAsync(new List<Guid> { response.Id });
             response.OrderCount = ordersCountResult.Count > 0 ? ordersCountResult.First().Value : 0;
@@ -323,36 +320,36 @@ namespace PARR.API.Controllers.V1
         }
 
 
-        /// <summary>
+        ///// <summary>
-        /// Заполнить ResponseAreaOffset
+        ///// Заполнить ResponseAreaOffset
-        /// </summary>
+        ///// </summary>
-        /// <param name="response"></param>
+        ///// <param name="response"></param>
-        private void FillResponseAreaOffset(TemplateBaseResponse response)
+        //private void FillResponseAreaOffset(TemplateBaseResponse response)
-        {
+        //{
-            // если стоит галка IsResponseAreaTimezone и есть ЗО, то возвращаем оффсет
+        //    // если стоит галка IsResponseAreaTimezone и есть ЗО, то возвращаем оффсет
-            if (response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea))
+        //    if (response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea))
-            {
+        //    {
-                var responseArea = response.ResponseArea;
+        //        var responseArea = response.ResponseArea;
-                response.ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
+        //        response.ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
-            }
+        //    }
-            else
+        //    else
-            {
+        //    {
-                response.ResponseAreaOffset = null;
+        //        response.ResponseAreaOffset = null;
-            }
+        //    }
 
-            //var responseArea = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
+        //    //var responseArea = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
-            //                                ? response.ResponseArea
+        //    //                                ? response.ResponseArea
-            //                                : settingsFromDb.DefaultResponseAreaToTimeOffset;
+        //    //                                : settingsFromDb.DefaultResponseAreaToTimeOffset;
 
-            //response.NextRunResponseAreaInLocal = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
+        //    //response.NextRunResponseAreaInLocal = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
-            //                                            ? nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, response.ResponseArea)
+        //    //                                            ? nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, response.ResponseArea)
-            //                                            // возвращаем в дефолтной зоне
+        //    //                                            // возвращаем в дефолтной зоне
-            //                                            : nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, settingsFromDb.DefaultResponseAreaToTimeOffset);
+        //    //                                            : nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, settingsFromDb.DefaultResponseAreaToTimeOffset);
 
-            //response.NextRunResponseAreaInLocal = nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, responseArea);
+        //    //response.NextRunResponseAreaInLocal = nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, responseArea);
 
-            //response.ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
+        //    //response.ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
-        }
+        //}
 
     }
 }

PARR.DAL/NextRunServices/INextRunServiceV2.cs

@@ -1,4 +1,5 @@
 using PARR.Constants;
+using PARR.DAL.Models.Job;
 using PARR.DAL.NextRunServices.Models;
 
 namespace PARR.DAL.NextRunServices
@@ -38,6 +39,28 @@ namespace PARR.DAL.NextRunServices
         /// <returns></returns>
         TimeSpan GetEsppAccountOffset();
 
+        /// <summary>
+        /// Получить продолжительность в днях
+        /// </summary>
+        /// <param name="config"></param>
+        /// <returns></returns>
+        int GetDurationDays(JobGroupDistributionConfig config);
 
+        /// <summary>
+        /// Получить список рабочих дней в диапазоне, исключая выходные и праздники.
+        /// </summary>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <param name="excludeWeekends">Исключить выходные и праздники</param>
+        /// <returns></returns>
+        Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends);
+
+        /// <summary>
+        /// Получить список выходных дней
+        /// </summary>
+        /// <param name="startDate"></param>
+        /// <param name="endDate"></param>
+        /// <returns></returns>
+        Task<HashSet<DateOnly>> GetWeekendsAsync(DateOnly startDate, DateOnly endDate);
     }
 }

PARR.DAL/NextRunServices/NextRunServiceV2.cs

@@ -675,12 +675,7 @@ namespace PARR.DAL.NextRunServices
         }
 
 
-        /// <summary>
+        public int GetDurationDays(JobGroupDistributionConfig config)
-        /// Получить продолжительность в днях
-        /// </summary>
-        /// <param name="config"></param>
-        /// <returns></returns>
-        private int GetDurationDays(JobGroupDistributionConfig config)
         {
             var period = config.DistributionPeriod;
             var periodType = period!.Type;
@@ -714,6 +709,17 @@ namespace PARR.DAL.NextRunServices
         }
 
 
+        public async Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends)
+        {
+            return await templateDistributor.GetWorkDaysAsync(start, end, excludeWeekends);
+        }
+
+
+        public async Task<HashSet<DateOnly>> GetWeekendsAsync(DateOnly startDate, DateOnly endDate)
+        {
+            return await templateDistributor.GetWeekendsAsync(startDate, endDate);
+        }
+
         /// <summary>
         /// Получить часовую зону для распределения
         /// </summary>

PARR.DAL/NextRunServices/Subservices/ITemplateDistributorV2.cs

@@ -38,5 +38,14 @@ namespace PARR.DAL.NextRunServices.Subservices
         /// <param name="endDate"></param>
         /// <returns></returns>
         Task<HashSet<DateOnly>> GetWeekendsAsync(DateOnly startDate, DateOnly endDate);
+
+        /// <summary>
+        /// Получить список рабочих дней в диапазоне, исключая выходные и праздники.
+        /// </summary>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <param name="excludeWeekends">Исключить выходные и праздники</param>
+        /// <returns></returns>
+        Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends);
     }
 }

PARR.DAL/NextRunServices/Subservices/TemplateDistributorV2.cs

@@ -1189,14 +1189,7 @@ namespace PARR.DAL.NextRunServices.Subservices
         }
 
 
-        /// <summary>
+        public async Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends)
-        /// Получить список рабочих дней в диапазоне, исключая выходные и праздники.
-        /// </summary>
-        /// <param name="start"></param>
-        /// <param name="end"></param>
-        /// <param name="excludeWeekends">Исключить выходные и праздники</param>
-        /// <returns></returns>
-        private async Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends)
         {
             // Получаем список выходных/праздничных дней
             var weekends = new HashSet<DateOnly>();

PARR.NextRun/NextRunManager.cs

@@ -117,139 +117,6 @@ namespace PARR.NextRun
         }
 
 
-        #region old
    
-        /// <summary>
-        /// Обновить nextRun для ВСЕХ шаблонов, для групп у которых расписание ЕСПП (выключено автораспределение)
-        /// </summary>
-        /// <returns></returns>
-        private async Task UpdateNextRunWithEsppScheduleAsync(ITemplateService templateService, INextRunService nextRunService, IJobGroupService jobGroupService)
-        {
-            // выбираем шаблоны которые не учавствуют в автораспределении
-            // и у которых Used
-            // обновляем для всех шаблонов, у которых nextRun!=рассчитанному
-
-            var templatesForUpdate = await templateService.Get()
-                                        .Where(t =>
-                                            t.StatusTypeId == TemplateStatusTypeEnum.Used
-                                            && t.Job!.Group!.IsAutoDistributionEnabled == false
-                                            && t.NextRun < DateTimeOffset.UtcNow
-                                        ).ToListAsync();
-
-
-            logger.LogInformation("Найдено шаблонов с выключенным автораспределением, с просроченным NextRun {count} шт.", templatesForUpdate.Count);
-
-            if (!templatesForUpdate.Any())
-                return;
-
-            foreach (var template in templatesForUpdate)
-            {
-                var newNextRun = await nextRunService.GetNextRunForTemplateAsync(template.Id, false);
-
-                template.LastRun = template.NextRun;
-                template.NextRun = newNextRun;
-            }
-
-            if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
-            {
-                logger.LogInformation("Обновлены значения ПРОСРОЧЕННЫХ полей NextRun для шаблонов с ВЫКЛЮЧЕННЫМ автораспределением, {count} шт.", templatesForUpdate.Count);
-            }
-            else
-            {
-                logger.LogError("Ошибка при обновлении ПРОСРОЧЕННЫХ значений полей NextRun, для шаблонов {count} шт., с ВЫКЛЮЧЕННЫМ автораспределением", templatesForUpdate.Count);
-            }
-
-
-
-            //// выбираем шаблоны которые не учавствуют в автораспределении
-            //// и у которых Used
-            //// затем группируем по GroupId, так как nextRun и расписание настраивается для группы, то для всех дочерних шаблонов, nextRun будет одинаковым
-            //// обновляем для всех шаблонов, у которых nextRun!=рассчитанному
-
-
-            //var groups = await jobGroupService.Get()
-            //                        .Where(t => t.IsAutoDistributionEnabled == false)
-            //                        .Select(t => new { t.Id, t.ReferenceDate })
-            //                        .ToListAsync();
-
-            //logger.LogInformation("Найдено {GroupCount} групп с выключенным автораспределением для обработки.", groups.Count);
-
-            //foreach (var group in groups)
-            //{
-            //    //получаем по каждой группе следующий nextRun и сравниваем с существующим, если не равны, то обновляем
-            //    //var nextRun = await esppScheduleTransformService.GetNextDateAsync(group.Id, group.ReferenceDate);
-            //    var nextRun = await nextRunService.GetNextRunForJobGroupWithEsppSchedulleAsync(group.Id);
-
-
-            //    // Загружаем только шаблоны текущей группы где nextRun в БД не равен расчетному
-            //    var templatesToUpdate = await templateService.Get()
-            //                            .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used && t.Job!.GroupId == group.Id && t.NextRun != nextRun)
-            //                            .ToListAsync();
-
-            //    logger.LogInformation("Для группы {groupId}, шаблонов для обновления где nextRun!=рассчетному {newNextRun} найдено {count} шт.", group.Id, nextRun, templatesToUpdate.Count);
-
-            //    if (!templatesToUpdate.Any())
-            //        continue;
-
-            //    // Обновляем
-            //    foreach (var template in templatesToUpdate)
-            //    {
-            //        template.LastRun = template.NextRun;
-            //        template.NextRun = nextRun;
-            //    }
-
-            //    // Коммитим изменения для этой группы
-            //    if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
-            //        logger.LogInformation($"Обновлены значения полей NextRun для шаблонов группы: {group.Id} с выключенным автораспределением, " +
-            //            $"refDate: {group.ReferenceDate}. Обновлен nextRun: {nextRun} для шаблонов {templatesToUpdate.Count} шт.");
-            //    else
-            //    {
-            //        logger.LogError($"Ошибка при обновлении значений полей NextRun: {nextRun}, для шаблонов {templatesToUpdate.Count} шт., группы {group.Id} с выключенным автораспределением, refDate: {group.ReferenceDate} ");
-            //    }
-            //}
-
-        }
-
-
-        /// <summary>
-        /// Обновить ПРОСРОЧЕННЫЕ NextRun для групп у которых включено автораспределение
-        /// </summary>
-        /// <param name="templateService"></param>
-        /// <param name="nextRunService"></param>
-        /// <param name="jobGroupService"></param>
-        /// <returns></returns>
-        private async Task UpdateNextRunWithAutodistributeScheduleAsync(ITemplateService templateService, INextRunService nextRunService, IJobGroupService jobGroupService)
-        {
-            // получаем список всех шаблонов с включенным автораспределением у которых ПРОСРОЧЕН nextRun и они Used
-            // обновляем у них NextRun
-
-            var templatesForUpdate = await templateService.Get()
-                                        .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used && t.Job.Group.IsAutoDistributionEnabled == true && t.NextRun < DateTimeOffset.UtcNow)
-                                        .ToListAsync();
-
-            logger.LogInformation("Найдено шаблонов с автораспределением, с просроченным NextRun {count} шт.", templatesForUpdate.Count);
-
-            if (!templatesForUpdate.Any())
-                return;
-
-            foreach (var template in templatesForUpdate)
-            {
-                var newNextRun = await nextRunService.GetNextRunForTemplateAsync(template.Id, false);
-
-                template.LastRun = template.NextRun;
-                template.NextRun = newNextRun;
-            }
-
-            if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
-            {
-                logger.LogInformation("Обновлены значения ПРОСРОЧЕННЫХ полей NextRun для шаблонов с ВКЛЮЧЕННЫМ автораспределением, {count} шт.", templatesForUpdate.Count);
-            }
-            else
-            {
-                logger.LogError("Ошибка при обновлении ПРОСРОЧЕННЫХ значений полей NextRun, для шаблонов {count} шт., с ВКЛЮЧЕННЫМ автораспределением", templatesForUpdate.Count);
-            }
-        }
-
-        #endregion
     }
 }

PARR.Test/NextRun/NextRunTest.cs

@@ -10,7 +10,7 @@ namespace PARR.Test.NextRun
     internal class NextRunTest
     {
         //private readonly ITemplateDistributor templateDistributor;
-        private readonly INextRunService nextRunService;
+        //private readonly INextRunService nextRunService;
         private readonly ITemplateService templateService;
         private readonly IShortcodesService shortcodesService;
         //private readonly ITemplateDistributorV2 templateDistributorV2;
@@ -18,7 +18,7 @@ namespace PARR.Test.NextRun
 
         public NextRunTest(
             /*ITemplateDistributor templateDistributor, */
-            INextRunService nextRunService,
+            //INextRunService nextRunService,
             ITemplateService templateService,
             IShortcodesService shortcodesService,
             //ITemplateDistributorV2 templateDistributorV2,
@@ -26,7 +26,7 @@ namespace PARR.Test.NextRun
             )
         {
             //this.templateDistributor = templateDistributor;
-            this.nextRunService = nextRunService;
+            //this.nextRunService = nextRunService;
             this.templateService = templateService;
             this.shortcodesService = shortcodesService;
             //this.templateDistributorV2 = templateDistributorV2;