feat(api,dal): статистика распределения. Список рабочих и выходных формируется в зависимости от времени МСК

2026-01-28 14:40:40 +10:00
parent e60fbfdc3a
commit 76bd6aa111
9 changed files with 209 additions and 26 deletions
--- a/PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs
+++ b/PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs
@@ -19,6 +19,11 @@
        /// </summary>
        public int IsDeactivatedAllCount => ItemsList?.Sum(t => t.IsDeactivatedCount) ?? 0;

+        /// <summary>
+        /// Шаблонов назначенных на выходной день
+        /// </summary>
+        public int TemplatesInWeekendAllCount => ItemsList?.Sum(t => t.TemplatesInWeekendCount) ?? 0;
+
        public List<StatDistributorItemResponse>? ItemsList { get; set; }
    }

@@ -29,16 +34,19 @@
        public int AllCount => Statistics?.Sum(t => t.AllCount) ?? 0;
        public int IsActivatedCount => Statistics?.Sum(t => t.IsActivatedCount) ?? 0;
        public int IsDeactivatedCount => Statistics?.Sum(t => t.IsDeactivatedCount) ?? 0;
+        public int TemplatesInWeekendCount => Statistics?.Sum(t => t.TemplatesInWeekendCount) ?? 0;

        public List<StatTemplateDistributorDateStat>? Statistics { get; set; }
    }

    public class StatTemplateDistributorDateStat
    {
-        public DateOnly Date { get; set; }
+        public DateTimeOffset Date { get; set; }
+        public bool IsWorkDay { get; set; }
        public int AllCount { get; set; }
        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; }
    }

--- a/PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs
+++ b/PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs
@@ -59,6 +59,8 @@ 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)
@@ -88,8 +90,16 @@ namespace PARR.API.Controllers.V1.Statistics
                    ItemsList = null
                }, true));

+            var (dateStart, dateEnd) = GetStartEndPeriod(jobGroup, items.Max(t => t.Template.NextRun), timeZoneQuery.TimeZoneOffsetHours);
+
            // получаем список рабочих дней
-            var workDays = await GetWorkDaysAsync(jobGroup, items.Max(t => t.Template.NextRun));
+            // получет все дни, даже с выходными, чтоб видеть реальную картину
+            var workDays = await nextRunService.GetWorkDaysAsync(dateStart, dateEnd, false, jobGroup.ReferenceDate);
+
+            // получить список выходных дней (показываем только если IsExcludeWeekends = true)
+            var weekends = jobGroup.DistributionConfig.IsExcludeWeekends
+                                        ? await nextRunService.GetWeekendsAsync(dateStart, dateEnd, jobGroup.ReferenceDate)
+                                        : new HashSet<DateOnly>();

            var responseItemsList = new List<StatDistributorItemResponse>();

@@ -114,7 +124,7 @@ namespace PARR.API.Controllers.V1.Statistics

                foreach (var groupedItem in grouped)
                {
-                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value, workDays, timeZoneQuery.TimeZoneOffsetHours);
+                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value, workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate);
                    responseItemsList.Add(statResult);
                }
            }
@@ -123,7 +133,7 @@ namespace PARR.API.Controllers.V1.Statistics
                // не нужно группировать по рабочим группам

                // сразу формируем response
-                responseItemsList.Add(GetResponseByWorkGroup(null, items.Select(t => t.Template).ToList(), workDays, timeZoneQuery.TimeZoneOffsetHours));
+                responseItemsList.Add(GetResponseByWorkGroup(null, items.Select(t => t.Template).ToList(), workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate));
            }

            var response = new StatTemplateDistributorResponse
@@ -135,32 +145,46 @@ namespace PARR.API.Controllers.V1.Statistics
            return Ok(new Response<StatTemplateDistributorResponse>(response, true));
        }

-
-        private async Task<List<DateOnly>> GetWorkDaysAsync(JobGroup jobGroup, DateTimeOffset maxNextRunTemplate)
+        /// <summary>
+        /// Получить дату начала и конца периода
+        /// </summary>
+        /// <param name="jobGroup"></param>
+        /// <param name="maxNextRunTemplate"></param>
+        /// <param name="timeZoneOffsetHours"></param>
+        /// <returns></returns>
+        private (DateOnly dateStart, DateOnly dateEnd) GetStartEndPeriod(JobGroup jobGroup, DateTimeOffset maxNextRunTemplate, int timeZoneOffsetHours)
        {
            var durationDays = nextRunService.GetDurationDays(jobGroup.DistributionConfig!);

-            var dateStart = DateOnly.FromDateTime(DateTime.UtcNow);
+            var dateStart = DateOnly.FromDateTime(DateTime.UtcNow.AddHours(timeZoneOffsetHours));

            // последний день, не может быть меньше чем durationDays
            var dateEnd = dateStart.AddDays(durationDays);

            // последний день, не может быть меньше чем refDate+durationDays
-            var sumRefDuration = DateOnly.FromDateTime(jobGroup.ReferenceDate.AddDays(durationDays).Date);
+            var sumRefDuration = DateOnly.FromDateTime(jobGroup.ReferenceDate.AddHours(timeZoneOffsetHours).AddDays(durationDays).Date);
            if (dateEnd < sumRefDuration)
                dateEnd = sumRefDuration;

            // с DateEnd вообще какая-то шурпатня :(
            // как наглядно понять ок не ок распределяется, если на каком-то графике dateEnd может ухеать за период распределения
            // последний день, не может быть меньше чем дата последнего шаблона maxNextRunTemplate
-            var lastTempalteDate = DateOnly.FromDateTime(maxNextRunTemplate.Date);
+            var lastTempalteDate = DateOnly.FromDateTime(maxNextRunTemplate.AddHours(timeZoneOffsetHours).Date);
            if (dateEnd < lastTempalteDate)
                dateEnd = lastTempalteDate;

-            return await nextRunService.GetWorkDaysAsync(dateStart, dateEnd, jobGroup.DistributionConfig!.IsExcludeWeekends);
+            return (dateStart, dateEnd);
        }

-        private StatDistributorItemResponse GetResponseByWorkGroup(string? workGroupName, List<Template> templates, List<DateOnly> workDays, int timeZoneOffsetHours)
+        /// <summary>
+        /// Заполнить респонс
+        /// </summary>
+        /// <param name="workGroupName"></param>
+        /// <param name="templates"></param>
+        /// <param name="workDays"></param>
+        /// <param name="timeZoneOffsetHours"></param>
+        /// <returns></returns>
+        private StatDistributorItemResponse GetResponseByWorkGroup(string? workGroupName, List<Template> templates, List<DateOnly> workDays, HashSet<DateOnly> weekends, int timeZoneOffsetHours, DateTimeOffset referenceDate)
        {
            var result = new StatDistributorItemResponse
            {
@@ -168,7 +192,8 @@ namespace PARR.API.Controllers.V1.Statistics
                Statistics = workDays.OrderBy(t => t).Select(t => new StatTemplateDistributorDateStat
                {
                    AllCount = 0,
-                    Date = t,
+                    Date = new DateTimeOffset(t.Year, t.Month, t.Day, referenceDate.Hour, referenceDate.Minute, referenceDate.Second, referenceDate.Offset),
+                    IsWorkDay = !weekends.Contains(t),
                    IsActivatedCount = 0,
                    IsDeactivatedCount = 0,
                    Templates = new List<StatTempleteDistribItem>()
@@ -179,7 +204,7 @@ namespace PARR.API.Controllers.V1.Statistics
            // смещаем по часовой зоне и группируем по дате
            foreach (var templatesFromDate in templates.GroupBy(t => DateOnly.FromDateTime(t.NextRun.AddHours(timeZoneOffsetHours).Date)))
            {
-                var statisticsForDate = result.Statistics.FirstOrDefault(t => t.Date == templatesFromDate.Key);
+                var statisticsForDate = result.Statistics.FirstOrDefault(t => DateOnly.FromDateTime(t.Date.AddHours(timeZoneOffsetHours).Date) == templatesFromDate.Key);
                if (statisticsForDate == null)
                {
                    logger.LogWarning("В списке рабочих дней, нет дня для шаблонов {count} шт. выполняющихся в {date}", templatesFromDate.Count(), templatesFromDate.Key);
--- a/PARR.DAL/NextRunServices/INextRunService.cs
+++ b/PARR.DAL/NextRunServices/INextRunService.cs
@@ -51,7 +51,16 @@ namespace PARR.DAL.NextRunServices
        /// <param name="end"></param>
        /// <param name="excludeWeekends"></param>
        /// <returns></returns>
-        Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends);
+        Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends, DateTimeOffset referenceDate);
+
+        /// <summary>
+        /// Получить список выходных дней
+        /// </summary>
+        /// <param name="startDate"></param>
+        /// <param name="endDate"></param>
+        /// <param name="referenceDate"></param>
+        /// <returns></returns>
+        Task<HashSet<DateOnly>> GetWeekendsAsync(DateOnly startDate, DateOnly endDate, DateTimeOffset referenceDate);

    }
 }
--- a/PARR.DAL/NextRunServices/NextRunService.cs
+++ b/PARR.DAL/NextRunServices/NextRunService.cs
@@ -306,9 +306,16 @@ namespace PARR.DAL.NextRunServices
        }


-        public async Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends)
+        public async Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends, DateTimeOffset referenceDate)
        {
-            return await templateDistributor.GetWorkDaysAsync(start, end, excludeWeekends);
+            //return await templateDistributor.GetWorkDaysAsync(start, end, excludeWeekends);
+            return await templateDistributor.GetWorkDaysTESTAsync(start, end, excludeWeekends, referenceDate);
+
+        }
+
+        public async Task<HashSet<DateOnly>> GetWeekendsAsync(DateOnly startDate, DateOnly endDate, DateTimeOffset referenceDate)
+        {
+            return await templateDistributor.GetWeekendsTESTAsync(startDate, endDate, referenceDate);
        }
    }
 }
--- a/PARR.DAL/NextRunServices/Subservices/EsppScheduleTransformService.cs
+++ b/PARR.DAL/NextRunServices/Subservices/EsppScheduleTransformService.cs
@@ -100,11 +100,6 @@ namespace PARR.DAL.NextRunServices.Subservices

            // Возвращаем обратно в ЮТС
            nextRun = nextRun.ToOffset(TimeSpan.Zero);
-            //возможно для автораспределения нужно nextRun = nextRunModifierService.GetWorkDayAsync(nextRun).GetAwaiter().GetResult();
-
-            // тут может быть 21 час по МСК, то это предыдущие сутки, нужно отнять 1 день
-            //if (!DateResolver.IsCurrentDayRelativeMskTime(nextRun.Hour))
-            //    nextRun = nextRun.AddDays(-1);

            return nextRun;
        }
--- a/PARR.DAL/NextRunServices/Subservices/ITemplateDistributor.cs
+++ b/PARR.DAL/NextRunServices/Subservices/ITemplateDistributor.cs
@@ -2,7 +2,8 @@

 namespace PARR.DAL.NextRunServices.Subservices
 {
-    internal interface ITemplateDistributor
+    //TODO: internal
+    public interface ITemplateDistributor
    {
        /// <summary>
        /// Распределяет все шаблоны на указанный период, учитывая план нагрузки.
@@ -33,6 +34,16 @@ namespace PARR.DAL.NextRunServices.Subservices
        Task<TemplateNextRunResultDto> GetValidNextRunForTemplateAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TemplateNextRunDto targetTemplate, List<TemplateNextRunDto> allTemplates, bool excludeWeekends, bool isNew);
        
        
+        /// <summary>
+        /// Получить список выходных дней
+        /// </summary>
+        /// <param name="startDate"></param>
+        /// <param name="endDate"></param>
+        /// <param name="referenceDate"></param>
+        /// <returns></returns>
+        Task<HashSet<DateOnly>> GetWeekendsTESTAsync(DateOnly startDate, DateOnly endDate, DateTimeOffset referenceDate);
+
+
        /// <summary>
        /// Получить список рабочих дней
        /// </summary>
@@ -41,6 +52,10 @@ namespace PARR.DAL.NextRunServices.Subservices
        /// <param name="excludeWeekends"></param>
        /// <returns></returns>
        Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends);
+
+
+
+        Task<List<DateOnly>> GetWorkDaysTESTAsync(DateOnly start, DateOnly end, bool excludeWeekends, DateTimeOffset referenceDate);
    }
 }

--- a/PARR.DAL/NextRunServices/Subservices/TemplateDistributor.cs
+++ b/PARR.DAL/NextRunServices/Subservices/TemplateDistributor.cs
@@ -557,6 +557,56 @@ namespace PARR.DAL.NextRunServices.Subservices
        }


+        /// <summary>
+        /// Получить список выходных дней
+        /// </summary>
+        /// <param name="startDate"></param>
+        /// <param name="endDate"></param>
+        /// <returns></returns>
+        public async Task<HashSet<DateOnly>> GetWeekendsTESTAsync(DateOnly startDate, DateOnly endDate, DateTimeOffset referenceDate)
+        {
+            // проверяем это текущие или прошлые сутки относительно refDate, если надо, корректируем dateStart, dateEnd
+            bool isPreviousDays = IsPreviousDays(referenceDate);
+
+            if (isPreviousDays)
+            {
+                // Это предыдущие сутки, корректируем
+                startDate = startDate.AddDays(-1);
+                // так как мы потом будем сдвигать выходные дни влево, то надо взять на один день дальше, чтоб знать какой он
+                // вроде бы это не костыль
+                endDate = endDate.AddDays(1);
+                //endDate = endDate.AddDays(-1);
+
+                logger.LogDebug("Это предыдущие сутки относительно referenceDate: {referenceDate}, корректируем даты для получения выходных дней, новые значения dateStart: {dateStart}, dateEnd: {dateEnd}", referenceDate, startDate, endDate);
+            }
+
+            var weekends = await weekendDayService.GetWeekends(startDate, endDate).ToListAsync();
+
+            var weekendsResult = new List<DateOnly>();
+
+            if (isPreviousDays)
+            {
+                // так как должны быть предыдущие дни, отнимаем 1 день
+                foreach (var weekend in weekends)
+                {
+                    var previous = weekend.AddDays(-1);
+                    logger.LogDebug("Выходной день, -1, так как день должен быть предыдущий, старое значение {weekend}, новое {previous}", weekend, previous);
+                    weekendsResult.Add(previous);
+                }
+            }
+            else
+            {
+                weekendsResult = weekends;
+            }
+
+            logger.LogDebug("Найдено не рабочих дней: {Count}", weekendsResult.Count);
+            foreach (var weekend in weekendsResult)
+                logger.LogDebug("Не рабочий день: {weekend}", weekend);
+
+            return weekendsResult.ToHashSet();
+        }
+
+
        /// <summary>
        /// Возвращает список рабочих дней в диапазоне, исключая выходные и праздники.
        /// </summary>
@@ -591,5 +641,73 @@ namespace PARR.DAL.NextRunServices.Subservices
            return result;
        }

+
+        public async Task<List<DateOnly>> GetWorkDaysTESTAsync(DateOnly start, DateOnly end, bool excludeWeekends, DateTimeOffset referenceDate)
+        {
+            logger.LogDebug("Формирование списка рабочих дней, start: {start}, end: {end}, excludeWeekends: {excludeWeekends}, referenceDate: {referenceDate}", start, end, excludeWeekends, referenceDate);
+
+            // проверяем это текущие или прошлые сутки относительно refDate, если надо, корректируем dateStart, dateEnd
+            if (IsPreviousDays(referenceDate))
+            {
+                // Это предыдущие сутки, корректируем
+                start = start.AddDays(-1);
+                end = end.AddDays(-1);
+
+                logger.LogDebug("Это предыдущие сутки относительно referenceDate: {referenceDate}, корректируем даты, новые значения dateStart: {dateStart}, dateEnd: {dateEnd}", referenceDate, start, end);
+            }
+
+            // Получаем список выходных/праздничных дней
+            var weekends = new HashSet<DateOnly>();
+            if (excludeWeekends)
+                weekends = await GetWeekendsTESTAsync(start, end, referenceDate);
+
+            var result = new List<DateOnly>();
+            var date = start;
+
+            while (date <= end)
+            {
+                var dayOfWeek = date.DayOfWeek;
+                if (!weekends.Contains(date))
+                {
+                    result.Add(date);
+                }
+                date = date.AddDays(1);
+            }
+
+            logger.LogDebug("Найдено рабочих дней: {Count}", result.Count);
+            foreach (var workDay in result)
+                logger.LogDebug("Рабочий день: {workDay}", workDay);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Это предыдущие сутки? Относительно referenceDate и МСК времени
+        /// </summary>
+        /// <param name="referenceDate"></param>
+        /// <returns></returns>
+        private bool IsPreviousDays(DateTimeOffset referenceDate)
+        {
+            // смещение часов относительно UTC - MSK
+            int offsetMskHour = 3;
+
+            // если время больше 21 часа, то это текущие сутки, если меньше, то прошлые
+            int maxHour = 24 - offsetMskHour;
+
+            if (referenceDate.Hour >= maxHour && referenceDate.Hour <= 23)
+            {
+                // это прошлые сутки
+                logger.LogDebug("ReferenceDate {refDate} - прошлые стуки", referenceDate);
+                return true;
+            }
+            else
+            {
+                // это текущие сутки
+                logger.LogDebug("ReferenceDate {refDate} - текущие стуки", referenceDate);
+                return false;
+            }
+
+        }
+
    }
 }
--- a/PARR.Test/NextRun/NextRunTest.cs
+++ b/PARR.Test/NextRun/NextRunTest.cs
@@ -6,20 +6,23 @@ namespace PARR.Test.NextRun
 {
    internal class NextRunTest
    {
-        //private readonly ITemplateDistributor templateDistributor;
+        private readonly ITemplateDistributor templateDistributor;
        private readonly INextRunService nextRunService;

-        public NextRunTest(/*ITemplateDistributor templateDistributor,*/ INextRunService nextRunService)
+        public NextRunTest(ITemplateDistributor templateDistributor, INextRunService nextRunService)
        {
-            //this.templateDistributor = templateDistributor;
+            this.templateDistributor = templateDistributor;
            this.nextRunService = nextRunService;
        }

        int periodDays = 10;
-        DateTimeOffset referenceDate = new DateTimeOffset(2025, 1, 20, 5, 0, 0, TimeSpan.Zero);
+        DateTimeOffset referenceDate = new DateTimeOffset(2025, 1, 20, 3, 0, 0, TimeSpan.Zero);

        public async Task Test()
        {
+            // GetWorkDaysTESTAsync
+            var aaa = await templateDistributor.GetWorkDaysTESTAsync(GetDateStart(), GetDateStart().AddDays(periodDays), true, referenceDate);
+
            //await DistributeTemplatesAsync();
            //await GetValidNextRunForTemplateAsync();

--- a/PARR.Test/Worker.cs
+++ b/PARR.Test/Worker.cs
@@ -35,6 +35,9 @@ namespace PARR.Test

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
+            //var aaa = DateTimeOffset.UtcNow;
+            //var bbb = aaa.ToOffset(new TimeSpan(3, 0, 0));
+

            #region NextRunTest