feat(api): статистика отображается в часовом поясе клиента

PARR.API/Contracts/V1/Requests/Queries/StatRobotHistoryQuery.cs

@@ -12,6 +12,6 @@ namespace PARR.API.Contracts.V1.Requests.Queries
         /// <summary>
         /// Фильтр за дату
         /// </summary>
-        public DateTime? Date { get; set; }
+        public DateOnly? Date { get; set; }
     }
 }

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

@@ -8,6 +8,6 @@
 
         public int DateCount { get; set; }
 
-        public DateTime Date { get; set; }
+        public DateOnly Date { get; set; }
     }
 }

PARR.API/Controllers/V1/RobotTaskController.cs

@@ -31,7 +31,7 @@ namespace PARR.API.Controllers.V1
         private readonly IClientService clientService;
         private readonly IRobotHistoryService robotHistoryService;
         private readonly IShortcodesService shortcodesService;
-        private readonly INextRunServiceV2 nextRunService;
+        private readonly INextRunService nextRunService;
         private readonly IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService;
 
         public RobotTaskController(
@@ -43,7 +43,7 @@ namespace PARR.API.Controllers.V1
             IClientService clientService,
             IRobotHistoryService robotHistoryService,
             IShortcodesService shortcodesService,
-            INextRunServiceV2 nextRunService,
+            INextRunService nextRunService,
             IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService
             )
         {

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

@@ -8,8 +8,9 @@ using PARR.API.Contracts.V1.Responses;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Contracts.V1.Responses.Statistics;
 using PARR.API.Controllers.V1.Base;
-using PARR.BLL.Services.Interfaces;
+using PARR.API.Helpers;
 using PARR.Constants;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces;
 
 namespace PARR.API.Controllers.V1.Statistics
@@ -23,34 +24,37 @@ namespace PARR.API.Controllers.V1.Statistics
         private readonly IOrderService orderService;
         private readonly IOrderStatusService orderStatusService;
         private readonly IMapper mapper;
-        private readonly ICalendarService calendarService;
+        private readonly INextRunService nextRunService;
 
         public StatOrderController(
             IOrderService orderService,
             IOrderStatusService orderStatusService,
             IMapper mapper,
-            ICalendarService calendarService
+            INextRunService nextRunService
             )
         {
             this.orderService = orderService;
             this.orderStatusService = orderStatusService;
             this.mapper = mapper;
-            this.calendarService = calendarService;
+            this.nextRunService = nextRunService;
         }
 
         /// <summary>
-        /// Статистика по нарядам - всего в ПАРР / загружено за последние сутки
+        /// Статистика по нарядам - всего в ПАРР / загружено за сегодня
         /// </summary>
         /// <returns></returns>
         [HttpGet(ApiRoutes.StatOrder.Get)]
-        public async Task<IActionResult> Get()
+        public async Task<IActionResult> Get([FromQuery] TimeZoneOffsetClient timeZoneQuery)
         {
-            var queryDate = DateTimeOffset.UtcNow.AddDays(-1);
+            var todayStartUtc = TimeZoneDateHelper.GetUtcSartOfDay(
+                DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime),
+                timeZoneQuery.TimeZoneOffset
+            );
 
             var response = new StatOrderResponse
             {
-                AllCount = await orderService.Get().CountAsync(),
+                AllCount = await orderService.Get().AsNoTracking().CountAsync(),
-                DownloadedLastDayCount = await orderService.Get().CountAsync(t => t.DateCreated >= queryDate)
+                DownloadedLastDayCount = await orderService.Get().AsNoTracking().CountAsync(t => t.DateCreated.UtcDateTime >= todayStartUtc)
             };
 
             return Ok(new Response<StatOrderResponse>(response, true));
@@ -66,9 +70,9 @@ namespace PARR.API.Controllers.V1.Statistics
         {
             var response = new StatTaskToEsppResponse
             {
-                AllCount = await orderService.Get().CountAsync(),
+                AllCount = await orderService.Get().AsNoTracking().CountAsync(),
                 // такая же логика в PARR.Master
-                TaskCount = await orderService.Get().CountAsync(t => t.NextStatusCode.HasValue && t.NextStatusCode.Value != t.StatusCode)
+                TaskCount = await orderService.Get().AsNoTracking().CountAsync(t => t.NextStatusCode.HasValue && t.NextStatusCode.Value != t.StatusCode)
             };
 
             return Ok(new Response<StatTaskToEsppResponse>(response, true));
@@ -82,8 +86,7 @@ namespace PARR.API.Controllers.V1.Statistics
         [HttpGet(ApiRoutes.StatOrder.Statuses)]
         public async Task<IActionResult> Statuses()
         {
-            var statuses = await orderStatusService.Get().OrderBy(t => t.Code).ToListAsync();
+            var statuses = await orderStatusService.Get().AsNoTracking().OrderBy(t => t.Code).ToListAsync();
-
 
             var response = new List<StatOrderStatusesResponse>();
             foreach (var stat in statuses)
@@ -91,7 +94,7 @@ namespace PARR.API.Controllers.V1.Statistics
                 response.Add(new StatOrderStatusesResponse
                 {
                     Status = mapper.Map<OrderStatusResponse>(stat),
-                    Count = await orderService.Get().CountAsync(t => t.StatusCode == stat.Code)
+                    Count = await orderService.Get().AsNoTracking().CountAsync(t => t.StatusCode == stat.Code)
                 });
             }
 
@@ -100,23 +103,26 @@ namespace PARR.API.Controllers.V1.Statistics
 
 
         /// <summary>
-        /// Статистика по нарядам - по статусу за последние сутки
+        /// Статистика по нарядам - по статусу за сегодня
         /// </summary>
         /// <param name="statusCode">1,2,3,4,5</param>
         /// <returns></returns>
         [HttpGet(ApiRoutes.StatOrder.GetStatusesLastDay)]
-        public async Task<IActionResult> GetStatusesLastDay([FromRoute] int statusCode)
+        public async Task<IActionResult> GetStatusesLastDay([FromRoute] int statusCode, [FromQuery] TimeZoneOffsetClient timeZoneQuery)
         {
-            var status = await orderStatusService.Get().FirstOrDefaultAsync(t => t.Code == statusCode);
+            var status = await orderStatusService.Get().AsNoTracking().FirstOrDefaultAsync(t => t.Code == statusCode);
 
             if (status == null)
                 return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Не найден статус с кодом: {statusCode}" } }));
 
-            var queryDate = DateTimeOffset.UtcNow.AddDays(-1);
+            var todayStartUtc = TimeZoneDateHelper.GetUtcSartOfDay(
+                DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime),
+                timeZoneQuery.TimeZoneOffset
+            );
 
             var response = new StatGetStatusesLastDayResponse
             {
-                Count = await orderService.Get().CountAsync(t => t.DateModified >= queryDate && t.StatusCode == statusCode),
+                Count = await orderService.Get().CountAsync(t => (t.DateModified.HasValue && t.DateModified.Value >= todayStartUtc) && t.StatusCode == statusCode),
                 Status = mapper.Map<OrderStatusResponse>(status)
             };
 
@@ -133,36 +139,30 @@ namespace PARR.API.Controllers.V1.Statistics
         [HttpGet(ApiRoutes.StatOrder.GetForPeriod)]
         public async Task<IActionResult> GetForPeriod([FromQuery] TimeZoneOffsetClient timeZoneQuery, [FromQuery] int startPeriodDays = 3)
         {
-            var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.UtcNow, timeZoneQuery.TimeZoneOffsetHours);
+            // Формируем период
-            var startPeriod = endPeriod.AddDays(-startPeriodDays);
+            var userEnd = DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime);
+            var userStart = userEnd.AddDays(-startPeriodDays);
 
-            var query = orderService.Get()
+            var (utcStart, utcEnd) = TimeZoneDateHelper.GetUtcDateRange(
-                            .Where(t =>
+                                                            userStart,
-                                t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                                                            userEnd.AddDays(1),
-                                && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                                                            timeZoneQuery.TimeZoneOffset);
-                            ).GroupBy(t => t.DateCreated.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
-                            .Select(t => new
-                            {
-                                Date = t.Key,
-                                OrderCount = t.Count()
-                            });
 
-            var result = await query.ToListAsync();
+            var allRecords = await orderService.Get()
+                         .AsNoTracking()
+                         .FilterByDateRangeUtc(t => t.DateCreated, utcStart, utcEnd)
+                         .Select(t => new { t.Id, t.DateCreated })
+                         .ToListAsync(); ;
 
-            var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
+            var resultDict = allRecords.GroupByUserDate(t => t.DateCreated, timeZoneQuery.TimeZoneOffset);
 
-            var response = new List<StatOrderGetForPeriodResponse>();
+            var daysList = await nextRunService.GetWorkDaysAsync(userStart, userEnd, false);
 
-            daysList.ForEach(date =>
+            var response = daysList.Select(date => new StatOrderGetForPeriodResponse
-            {
-                response.Add(new StatOrderGetForPeriodResponse
             {
                 Date = date,
-                    OrderCount = result.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.OrderCount ?? 0
+                OrderCount = resultDict.TryGetValue(date, out var cnt) ? cnt : 0
-                });
+            }).OrderBy(t => t.Date).ToList();
-            });
-
-            response = response.OrderBy(t => t.Date).ToList();
 
             return Ok(new Response<List<StatOrderGetForPeriodResponse>>(response, true));
         }

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

@@ -3,11 +3,13 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using PARR.API.Contracts.V1;
+using PARR.API.Contracts.V1.Requests.BaseRequests;
 using PARR.API.Contracts.V1.Requests.Queries;
 using PARR.API.Contracts.V1.Responses;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Contracts.V1.Responses.Statistics;
 using PARR.API.Controllers.V1.Base;
+using PARR.API.Helpers;
 using PARR.Constants;
 using PARR.DAL.Models;
 using PARR.DAL.Services.Interfaces;
@@ -40,10 +42,10 @@ namespace PARR.API.Controllers.V1.Statistics
         /// </summary>
         /// <returns></returns>
         [HttpGet(ApiRoutes.StatRobotHistory.Get)]
-        public async Task<IActionResult> Get([FromQuery] StatRobotHistoryQuery request)
+        public async Task<IActionResult> Get([FromQuery] StatRobotHistoryQuery request, [FromQuery] TimeZoneOffsetClient timeZoneQuery)
         {
             if (!request.Date.HasValue)
-                request.Date = DateTime.Now.Date;
+                request.Date = DateOnly.FromDateTime(DateTimeOffset.UtcNow.Date);
 
             // всего 
             var allStat = await robotHistoryService.Get()
@@ -51,9 +53,19 @@ namespace PARR.API.Controllers.V1.Statistics
                 .Select(t => new { HistoryLevel = t.Key, Count = t.Count() })
                 .ToListAsync();
 
+            // Формируем диапазон в пользовательском времени
+            var userDateStart = new DateTimeOffset(request.Date.Value.Year, request.Date.Value.Month, request.Date.Value.Day, 0, 0, 0, timeZoneQuery.TimeZoneOffset);
+            var userDateEnd = userDateStart.AddDays(1);
+
+            // Конвертируем в UTC для сравнения с БД
+            var utcStart = userDateStart.UtcDateTime;
+            var utcEnd = userDateEnd.UtcDateTime;
+
             // за дату
             var dateStat = await robotHistoryService.Get()
-                .Where(t => t.DateCreated.DateTime.Date == request.Date.Value.Date)
+                //.Where(t => t.DateCreated.DateTime.Date == request.Date.Value.Date)
+                //.Where(t => t.DateCreated.UtcDateTime >= utcStart && t.DateCreated.UtcDateTime < utcEnd)
+                .FilterByDateRangeUtc(t => t.DateCreated, utcStart, utcEnd)
                 .GroupBy(t => t.HistoryLevel)
                 .Select(t => new { HistoryLevel = t.Key, Count = t.Count() })
                 .ToListAsync();
@@ -73,7 +85,7 @@ namespace PARR.API.Controllers.V1.Statistics
                 {
                     AllCount = allStat.FirstOrDefault(t => t.HistoryLevel == level.Level)?.Count ?? 0,
                     DateCount = dateStat.FirstOrDefault(t => t.HistoryLevel == level.Level)?.Count ?? 0,
-                    Date = request.Date.Value.Date,
+                    Date = request.Date.Value,
                     Level = mapper.Map<RobotHistoryLevelResponse>(level)
                 });
             }

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

@@ -44,12 +44,13 @@ namespace PARR.API.Controllers.V1.Statistics
         public async Task<IActionResult> Get()
         {
             var confStat = await robotConfigurationService.Get()
+                           .AsNoTracking()
                            .GroupBy(t => new { t.RobotCode, t.RobotStatusCode })
                            .Select(t => new { RobotCode = t.Key.RobotCode, RobotStatusCode = t.Key.RobotStatusCode, Count = t.Count() })
                            .ToListAsync();
 
-            var robots = await robotService.Get().ToListAsync();
+            var robots = await robotService.Get().AsNoTracking().ToListAsync();
-            var robotStatuses = await robotStatusService.Get().ToListAsync();
+            var robotStatuses = await robotStatusService.Get().AsNoTracking().ToListAsync();
 
             var response = new List<StatRobotStatusResponse>();
 

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

@@ -49,12 +49,13 @@ namespace PARR.API.Controllers.V1.Statistics
         public async Task<IActionResult> Get()
         {
             var confStat = await robotConfigurationService.Get()
+                                .AsNoTracking()
                                 .GroupBy(t => new { t.RobotCode, t.TaskStatusCode })
                                 .Select(t => new { RobotCode = t.Key.RobotCode, TaskStatusCode = t.Key.TaskStatusCode, Count = t.Count() })
                                 .ToListAsync();
 
-            var robots = await robotService.Get().ToListAsync();
+            var robots = await robotService.Get().AsNoTracking().ToListAsync();
-            var statuses = await taskStatusService.Get().ToListAsync();
+            var statuses = await taskStatusService.Get().AsNoTracking().ToListAsync();
 
             var response = new List<StatRobotTaskResponse>();
 
@@ -95,7 +96,8 @@ namespace PARR.API.Controllers.V1.Statistics
 
 
             var query = robotHistoryService.Get()
-                            .Include(t => t.RobotConfiguration)
+                            //.Include(t => t.RobotConfiguration)
+                            .AsNoTracking()
                             .Where(t => t.RobotConfiguration!.RobotCode == (int)robot && t.DateCreated >= queryDate)
                             .GroupBy(t => new { Date = t.DateCreated.Date, Hour = t.DateCreated.Hour })
                             .Select(t => new

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

@@ -5,8 +5,9 @@ using PARR.API.Contracts.V1.Requests.BaseRequests;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Contracts.V1.Responses.Statistics;
 using PARR.API.Controllers.V1.Base;
-using PARR.BLL.Services.Interfaces;
+using PARR.API.Helpers;
 using PARR.Constants;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces;
 
 namespace PARR.API.Controllers.V1.Statistics
@@ -15,17 +16,17 @@ namespace PARR.API.Controllers.V1.Statistics
     {
         private readonly ITemplateService templateService;
         private readonly ITemplateHistoryService templateHistoryService;
-        private readonly ICalendarService calendarService;
+        private readonly INextRunService nextRunService;
 
         public StatTemplateAutoControlController(
             ITemplateService templateService,
             ITemplateHistoryService templateHistoryService,
-            ICalendarService calendarService
+            INextRunService nextRunService
             )
         {
             this.templateService = templateService;
             this.templateHistoryService = templateHistoryService;
-            this.calendarService = calendarService;
+            this.nextRunService = nextRunService;
         }
 
 
@@ -38,8 +39,14 @@ namespace PARR.API.Controllers.V1.Statistics
         [HttpGet(ApiRoutes.StatTemplateAutoControl.GetForPeriod)]
         public async Task<IActionResult> GetForPeriod([FromQuery] TimeZoneOffsetClient timeZoneQuery, [FromQuery] int startPeriodDays = 3)
         {
-            var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.Now, timeZoneQuery.TimeZoneOffsetHours);
+            //var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.Now, timeZoneQuery.TimeZoneOffsetHours);
-            var startPeriod = endPeriod.AddDays(-startPeriodDays);
+            //var startPeriod = endPeriod.AddDays(-startPeriodDays);
+
+            var userEndPeriod = DateTimeOffset.UtcNow.Add(timeZoneQuery.TimeZoneOffset);
+            var userStartPeriod = userEndPeriod.AddDays(-startPeriodDays);
+
+            var utcEndPeriod = userEndPeriod.UtcDateTime;
+            var utcStartPeriod = userStartPeriod.UtcDateTime;
 
             var templates = await templateService.Get()
                .Where(t =>
@@ -48,12 +55,16 @@ namespace PARR.API.Controllers.V1.Statistics
                         ((
                             // измененные
                             t.DateModified.HasValue
-                            && t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                            //&& t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
-                            && t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                            //&& t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                            && t.DateModified.Value.UtcDateTime >= utcStartPeriod
+                            && t.DateModified.Value.UtcDateTime <= utcEndPeriod
                         ) || (
                             // созданные
-                            t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                            //t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
-                            && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                            //&& t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                            t.DateCreated.UtcDateTime >= utcStartPeriod
+                            && t.DateCreated.UtcDateTime <= utcEndPeriod
                             && t.InitiatorComment != null
                             && !t.InitiatorComment.Contains(TemplateActivatorActionsEnum.ActivateAllForAutoControl.ToString())
                             && !t.InitiatorComment.Contains(TemplateActivatorActionsEnum.DeactivateAllForAutoControl.ToString())
@@ -72,8 +83,10 @@ namespace PARR.API.Controllers.V1.Statistics
             #region ищем созданные, но уже перемещенные в историю
             var createdTemplatesAndMoveToHistory = await templateService.Get().Include(t => t.TemplateHistories)
                 .Where(t =>
-                    t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                    //t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
-                    && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                    //&& t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                    t.DateCreated.UtcDateTime >= utcStartPeriod
+                    && t.DateCreated.UtcDateTime <= utcEndPeriod
                     && t.TemplateHistories.Any(x => x.InitiatorParrComponentId == Constants.ParrComponentsEnum.JobAutoControl)
                 )
                 .ToListAsync();
@@ -93,8 +106,10 @@ namespace PARR.API.Controllers.V1.Statistics
                             .Where(t =>
                                     t.InitiatorParrComponentId == Constants.ParrComponentsEnum.JobAutoControl
                                     && t.DateModified.HasValue
-                                    && t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                                    //&& t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
-                                    && t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                                    //&& t.DateModified.Value.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                                    && t.DateModified.Value.UtcDateTime >= utcStartPeriod
+                                    && t.DateModified.Value.UtcDateTime <= utcEndPeriod
                                 )
                             .Select(t => new QueryResult
                             {
@@ -112,31 +127,36 @@ namespace PARR.API.Controllers.V1.Statistics
             objs.AddRange(createdTemplatesAndMoveToHistory.Select(t => new QueryResult { DateCreated = t.DateCreated }));
 
             // создано
-            var creations = objs.Where(t => t.DateCreated.HasValue).GroupBy(t => t.DateCreated!.Value.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
+            var creations = objs.Where(t => t.DateCreated.HasValue)
-                                .Select(t => new { Date = t.Key, Created = t.Count() });
+                                     //.GroupBy(t => t.DateCreated!.Value.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
+                                     //.GroupBy(t => DateOnly.FromDateTime(t.DateCreated!.Value.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime))
+                                     //.ToDictionary(t => t.Key, t => t.Count());
+                                     .GroupByUserDate(t => t.DateCreated!.Value, timeZoneQuery.TimeZoneOffset);
 
             // активаций (сколько раз, а не сколько объектов)
             var activations = objs.Where(t => t.DateModified.HasValue && t.InitiatorComment != null && t.InitiatorComment.Contains(TemplateActivatorActionsEnum.ActivateAllForAutoControl.ToString()))
-                                    .GroupBy(t => t.DateModified!.Value.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
+                                    //.GroupBy(t => t.DateModified!.Value.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
-                                    .Select(t => new { Date = t.Key, Actiovations = t.Count() });
+                                    //.GroupBy(t => DateOnly.FromDateTime(t.DateModified!.Value.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime))
+                                    //.ToDictionary(t => t.Key, t => t.Count());
+                                    .GroupByUserDate(t => t.DateModified!.Value, timeZoneQuery.TimeZoneOffset);
 
             // деактиваций (сколько раз, а не сколько объектов)
             var deactivations = objs.Where(t => t.DateModified.HasValue && t.InitiatorComment != null && t.InitiatorComment.Contains(TemplateActivatorActionsEnum.DeactivateAllForAutoControl.ToString()))
-                                    .GroupBy(t => t.DateModified!.Value.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
+                                     //.GroupBy(t => t.DateModified!.Value.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
-                                    .Select(t => new { Date = t.Key, Deactivations = t.Count() });
+                                     //.GroupBy(t => DateOnly.FromDateTime(t.DateModified!.Value.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime))
+                                     //.ToDictionary(t => t.Key, t => t.Count());
+                                     .GroupByUserDate(t => t.DateModified!.Value, timeZoneQuery.TimeZoneOffset);
 
-            var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
+            //var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
-            var response = new List<StatTemplateAutoControlResponse>();
+            var daysList = await nextRunService.GetWorkDaysAsync(DateOnly.FromDateTime(userStartPeriod.DateTime), DateOnly.FromDateTime(userEndPeriod.DateTime), false);
 
-            daysList.ForEach(date => response.Add(new StatTemplateAutoControlResponse
+            var response = daysList.Select(date => new StatTemplateAutoControlResponse
             {
                 Date = date,
-                Activations = activations.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.Actiovations ?? 0,
+                Activations = activations.TryGetValue(date, out var countAct) ? countAct : 0,
-                Creations = creations.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.Created ?? 0,
+                Creations = creations.TryGetValue(date, out var countCrt) ? countCrt : 0,
-                Deactivations = deactivations.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.Deactivations ?? 0,
+                Deactivations = deactivations.TryGetValue(date, out var countDeact) ? countDeact : 0
-            }));
+            }).OrderBy(t => t.Date).ToList();
-
-            response = response.OrderBy(t => t.Date).ToList();
 
             return Ok(new Response<List<StatTemplateAutoControlResponse>>(response, true));
         }

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

@@ -6,9 +6,10 @@ using PARR.API.Contracts.V1.Requests.BaseRequests;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Contracts.V1.Responses.Statistics;
 using PARR.API.Controllers.V1.Base;
-using PARR.BLL.Services.Interfaces;
+using PARR.API.Helpers;
 using PARR.Constants;
 using PARR.DAL.Contracts;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces;
 
 namespace PARR.API.Controllers.V1.Statistics
@@ -20,15 +21,15 @@ namespace PARR.API.Controllers.V1.Statistics
     public class StatTemplateController : BaseApiController
     {
         private readonly ITemplateService templateService;
-        private readonly ICalendarService calendarService;
+        private readonly INextRunService nextRunService;
 
         public StatTemplateController(
             ITemplateService templateService,
-            ICalendarService calendarService
+            INextRunService nextRunService
             )
         {
             this.templateService = templateService;
-            this.calendarService = calendarService;
+            this.nextRunService = nextRunService;
         }
 
         /// <summary>
@@ -40,12 +41,12 @@ namespace PARR.API.Controllers.V1.Statistics
         {
             var response = new StatTemplateResponse
             {
-                ActivateScheduleCount = await templateService.Get().CountAsync(t => t.IsActiveSchedule),
+                ActivateScheduleCount = await templateService.Get().AsNoTracking().CountAsync(t => t.IsActiveSchedule),
-                ActivateTemplateCount = await templateService.Get().CountAsync(t => t.IsActiveTemplate),
+                ActivateTemplateCount = await templateService.Get().AsNoTracking().CountAsync(t => t.IsActiveTemplate),
-                TemplateAgentCount = await templateService.Get().Include(t => t.Job).ThenInclude(t=>t.Group).CountAsync(t => t.Job!.Group!.IsAgent),
+                TemplateAgentCount = await templateService.Get().AsNoTracking().CountAsync(t => t.Job!.Group!.IsAgent),
-                TemplateCount = await templateService.Get().CountAsync(),
+                TemplateCount = await templateService.Get().AsNoTracking().CountAsync(),
-                SyncEsppScheduleCount = await templateService.Get().Include(t => t.RobotConfigurations).CountAsync(t => t.RobotConfigurations.Any(c => c.RobotCode == (int)RobotsEnum.ScheduleOrder && c.TaskStatusCode == (int)TaskStatusEnum.Ok)),
+                SyncEsppScheduleCount = await templateService.Get().AsNoTracking().CountAsync(t => t.RobotConfigurations.Any(c => c.RobotCode == (int)RobotsEnum.ScheduleOrder && c.TaskStatusCode == (int)TaskStatusEnum.Ok)),
-                SyncEsppTemplatesCount = await templateService.Get().Include(t => t.RobotConfigurations).CountAsync(t => t.RobotConfigurations.Any(c => c.RobotCode == (int)RobotsEnum.TemplateOrder && c.TaskStatusCode == (int)TaskStatusEnum.Ok))
+                SyncEsppTemplatesCount = await templateService.Get().AsNoTracking().CountAsync(t => t.RobotConfigurations.Any(c => c.RobotCode == (int)RobotsEnum.TemplateOrder && c.TaskStatusCode == (int)TaskStatusEnum.Ok))
             };
 
             return Ok(new Response<StatTemplateResponse>(response, true));
@@ -61,33 +62,31 @@ namespace PARR.API.Controllers.V1.Statistics
         [HttpGet(ApiRoutes.StatTemplate.GetForPeriod)]
         public async Task<IActionResult> GetForPeriod([FromQuery] TimeZoneOffsetClient timeZoneQuery, [FromQuery] int startPeriodDays = 3)
         {
-            var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.UtcNow, timeZoneQuery.TimeZoneOffsetHours);
+            // Формируем период
-            var startPeriod = endPeriod.AddDays(-startPeriodDays);
+            var userEnd = DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime);
+            var userStart = userEnd.AddDays(-startPeriodDays);
 
-            var query = templateService.Get()
+            var (utcStart, utcEnd) = TimeZoneDateHelper.GetUtcDateRange(
-                            .Where(t =>
+                                                            userStart,
-                                t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                                                            userEnd.AddDays(1),
-                                && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                                                            timeZoneQuery.TimeZoneOffset);
-                                ).GroupBy(t => t.DateCreated.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
-                                .Select(t => new
-                                {
-                                    Date = t.Key,
-                                    CreatedObjs = t.Count()
-                                });
 
-            var result = await query.ToListAsync();
+            var allRecords = await templateService.Get()
+                            .AsNoTracking()
+                            .FilterByDateRangeUtc(t => t.DateCreated, utcStart, utcEnd)
+                            .Select(t => new { t.Id, t.DateCreated })
+                            .ToListAsync();
 
-            var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
+            var resultDict = allRecords.GroupByUserDate(t => t.DateCreated, timeZoneQuery.TimeZoneOffset);
 
-            var response = new List<StatTemplatePeriodResponse>();
 
-            daysList.ForEach(date => response.Add(new StatTemplatePeriodResponse
+            var daysList = await nextRunService.GetWorkDaysAsync(userStart, userEnd, false);
+
+            var response = daysList.Select(date => new StatTemplatePeriodResponse
             {
                 Date = date,
-                CreatedTemplatesCount = result.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.CreatedObjs ?? 0
+                CreatedTemplatesCount = resultDict.TryGetValue(date, out var cnt) ? cnt : 0
-            }));
+            }).OrderBy(t => t.Date).ToList();
-
-            response = response.OrderBy(t => t.Date).ToList();
 
             return Ok(new Response<List<StatTemplatePeriodResponse>>(response, true));
         }

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 INextRunServiceV2 nextRunService;
+        private readonly INextRunService 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,
-            INextRunServiceV2 nextRunService,
+            INextRunService nextRunService,
             ILogger<StatTemplateDistributionController> logger,
             IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService
             )

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

@@ -6,8 +6,9 @@ using PARR.API.Contracts.V1.Requests.BaseRequests;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Contracts.V1.Responses.Statistics;
 using PARR.API.Controllers.V1.Base;
-using PARR.BLL.Services.Interfaces;
+using PARR.API.Helpers;
 using PARR.Constants;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces.Unit;
 
 namespace PARR.API.Controllers.V1.Statistics
@@ -19,34 +20,36 @@ namespace PARR.API.Controllers.V1.Statistics
     public class StatUnitController : BaseApiController
     {
         private readonly IUnitService unitService;
-        private readonly ICalendarService calendarService;
+        private readonly INextRunService nextRunService;
 
         public StatUnitController(
             IUnitService unitService,
-            ICalendarService calendarService
+            INextRunService nextRunService
             )
         {
             this.unitService = unitService;
-            this.calendarService = calendarService;
+            this.nextRunService = nextRunService;
         }
 
         /// <summary>
-        /// Статистика синхронизации юнитов (ЭК) с АИХИТ за последние сутки
+        /// Статистика синхронизации юнитов (ЭК) с АИХИТ за сегодня
         /// </summary>
         /// <returns></returns>
         [HttpGet(ApiRoutes.StatUnit.Get)]
-        public async Task<IActionResult> Get()
+        public async Task<IActionResult> Get([FromQuery] TimeZoneOffsetClient timeZoneQuery)
         {
-            var queryDate = DateTimeOffset.UtcNow.AddDays(-1);
+            var todayStartUtc = TimeZoneDateHelper.GetUtcSartOfDay(
+                    DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime),
+                    timeZoneQuery.TimeZoneOffset
+                );
 
             var response = new StatUnitResponse
             {
-                AllHosts = await unitService.Get().CountAsync(),
+                AllHosts = await unitService.Get().AsNoTracking().CountAsync(),
-                CreatedLastDay = await unitService.Get().CountAsync(t => t.DateCreated >= queryDate),
+                CreatedLastDay = await unitService.Get().AsNoTracking().CountAsync(t => t.DateCreated.UtcDateTime >= todayStartUtc),
-                //UpdatedLastDay = await hostService.Get().CountAsync(t => t.DateModified.HasValue && t.DateModified.Value >= queryDate)
                 UpdatedLastDay = await unitService.Get()
-                                            .Include(t => t.UnitValues)
+                                            .Where(t => t.UnitValues.Any(v => v.DateModified.HasValue && v.DateModified.Value.UtcDateTime >= todayStartUtc))
-                                            .Where(t => t.UnitValues.Any(v => v.DateModified.HasValue && v.DateModified.Value >= queryDate))
+                                            .AsNoTracking()
                                             .CountAsync()
             };
 
@@ -63,37 +66,31 @@ namespace PARR.API.Controllers.V1.Statistics
         [HttpGet(ApiRoutes.StatUnit.GetForPeriod)]
         public async Task<IActionResult> GetForPeriod([FromQuery] TimeZoneOffsetClient timeZoneQuery, [FromQuery] int startPeriodDays = 3)
         {
-            var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.UtcNow, timeZoneQuery.TimeZoneOffsetHours);
+            // Формируем период
-            var startPeriod = endPeriod.AddDays(-startPeriodDays);
+            var userEnd = DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime);
+            var userStart = userEnd.AddDays(-startPeriodDays);
 
-            var query = unitService.Get()
+            var (utcStart, utcEnd) = TimeZoneDateHelper.GetUtcDateRange(
-                .Where(t =>
+                                                            userStart,
-                    t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                                                            userEnd.AddDays(1),
-                    && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                                                            timeZoneQuery.TimeZoneOffset);
-                )
-                .GroupBy(t => t.DateCreated.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
-                .Select(t => new
-                {
-                    Date = t.Key,
-                    UnitCount = t.Count()
-                });
 
-            var result = await query.ToListAsync();
+            var allRecords = await unitService.Get()
+                                   .AsNoTracking()
+                                   .FilterByDateRangeUtc(t => t.DateCreated, utcStart, utcEnd)
+                                   .Select(t => new { t.Id, t.DateCreated })
+                                    .ToListAsync();
 
-            var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
 
-            var response = new List<StatUnitPeriodResponse>();
+            var resultDict = allRecords.GroupByUserDate(t => t.DateCreated, timeZoneQuery.TimeZoneOffset);
 
-            daysList.ForEach(date =>
+            var daysList = await nextRunService.GetWorkDaysAsync(userStart, userEnd, false);
-            {
+
-                response.Add(new StatUnitPeriodResponse
+            var response = daysList.Select(date => new StatUnitPeriodResponse
             {
                 Date = date,
-                    CreatedUnitsCount = result.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.UnitCount ?? 0
+                CreatedUnitsCount = resultDict.TryGetValue(date, out var cnt) ? cnt : 0
-                });
+            }).OrderBy(t => t.Date).ToList();
-            });
-
-            response = response.OrderBy(t => t.Date).ToList();
 
             return Ok(new Response<List<StatUnitPeriodResponse>>(response, true));
         }

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

@@ -6,8 +6,8 @@ using PARR.API.Contracts.V1.Requests.BaseRequests;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Contracts.V1.Responses.Statistics;
 using PARR.API.Controllers.V1.Base;
-using PARR.BLL.Services.Interfaces;
 using PARR.Constants;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.Services.Interfaces.Unit;
 
@@ -21,32 +21,44 @@ namespace PARR.API.Controllers.V1.Statistics
     {
         private readonly IApplicationService applicationService;
         private readonly IUnitFieldValueService unitFieldValueService;
-        private readonly ICalendarService calendarService;
+        private readonly INextRunService nextRunService;
+
+        //private readonly ICalendarService calendarService;
 
         public StatUnitFieldValuesController(
             IApplicationService applicationService,
             IUnitFieldValueService unitFieldValueService,
-            ICalendarService calendarService
+            //ICalendarService calendarService
+            INextRunService nextRunService
             )
         {
             this.applicationService = applicationService;
             this.unitFieldValueService = unitFieldValueService;
-            this.calendarService = calendarService;
+            this.nextRunService = nextRunService;
+            //this.calendarService = calendarService;
         }
 
         /// <summary>
-        /// Статистика синхронизации полей юнитов (ЭК) с АИХИТ за последние сутки
+        /// Статистика синхронизации полей юнитов (ЭК) с АИХИТ за сегодня
         /// </summary>
         /// <returns></returns>
         [HttpGet(ApiRoutes.StatUnitFieldValues.Get)]
-        public async Task<IActionResult> Get()
+        public async Task<IActionResult> Get([FromQuery] TimeZoneOffsetClient timeZoneQuery)
         {
-            var queryDate = DateTimeOffset.UtcNow.AddDays(-1);
+            // Формируем начало "сегодня" в часовом поясе пользователя
+            var userNow = DateTimeOffset.UtcNow.ToOffset(timeZoneQuery.TimeZoneOffset);
+            var userTodayStart = new DateTimeOffset(
+                                            userNow.Year, userNow.Month, userNow.Day,
+                                            0, 0, 0,
+                                            timeZoneQuery.TimeZoneOffset);
+
+            // Конвертируем в UTC для запроса к БД
+            var todayStartUtc = userTodayStart.UtcDateTime;
 
             var response = new StatUnitFieldValuesResponse
             {
-                AllValues = await unitFieldValueService.Get().CountAsync(),
+                AllValues = await unitFieldValueService.Get().AsNoTracking().CountAsync(),
-                CreatedLastDay = await unitFieldValueService.Get().CountAsync(t => t.DateCreated >= queryDate),
+                CreatedLastDay = await unitFieldValueService.Get().AsNoTracking().CountAsync(t => t.DateCreated.UtcDateTime >= todayStartUtc),
                 //UpdatedLastDay = await applicationService.Get().CountAsync(t => t.DateModified.HasValue && t.DateModified.Value >= queryDate),
             };
 
@@ -63,37 +75,62 @@ namespace PARR.API.Controllers.V1.Statistics
         [HttpGet(ApiRoutes.StatUnitFieldValues.GetForPeriod)]
         public async Task<IActionResult> GetForPeriod([FromQuery] TimeZoneOffsetClient timeZoneQuery, [FromQuery] int startPeriodDays = 3)
         {
-            var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.UtcNow, timeZoneQuery.TimeZoneOffsetHours);
+            var userEndPeriod = DateTimeOffset.UtcNow.Add(timeZoneQuery.TimeZoneOffset);
-            var startPeriod = endPeriod.AddDays(-startPeriodDays);
+            var userStartPeriod = userEndPeriod.AddDays(-startPeriodDays);
 
-            var query = unitFieldValueService.Get()
+            var utcEndPeriod = userEndPeriod.UtcDateTime;
+            var utcStartPeriod = userStartPeriod.UtcDateTime;
+
+            var allRecords = await unitFieldValueService.Get()
+                            .AsNoTracking()
                             .Where(t =>
-                                t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+                                //t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
-                                && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+                                //&& t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
-                            )
+                                utcStartPeriod <= t.DateCreated.UtcDateTime && t.DateCreated.UtcDateTime < utcEndPeriod
-                            .GroupBy(t => t.DateCreated.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
+                            ).Select(t => new { t.Id, t.DateCreated })
-                            .Select(t => new
+                            .ToListAsync();
-                            {
-                                Date = t.Key,
-                                Count = t.Count()
-                            });
 
-            var result = await query.ToListAsync();
+            var resultDict = allRecords.GroupBy(t => DateOnly.FromDateTime(t.DateCreated.ToOffset(timeZoneQuery.TimeZoneOffset).DateTime))
+                                   .ToDictionary(t => t.Key, t => t.Count());
 
-            var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
+            //var endPeriod = calendarService.GetDateWithTimeZoneOffset(DateTimeOffset.UtcNow, timeZoneQuery.TimeZoneOffsetHours);
+            //var startPeriod = endPeriod.AddDays(-startPeriodDays);
 
-            var response = new List<StatApplicationPeriodResponse>();
+            //var query = unitFieldValueService.Get()
+            //                .Where(t =>
+            //                    t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date >= startPeriod.Date
+            //                    && t.DateCreated.DateTime.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date <= endPeriod.Date
+            //                )
+            //                .GroupBy(t => t.DateCreated.AddHours(timeZoneQuery.TimeZoneOffsetHours).Date)
+            //                .Select(t => new
+            //                {
+            //                    Date = t.Key,
+            //                    Count = t.Count()
+            //                });
 
-            daysList.ForEach(date =>
+            //var result = await query.ToListAsync();
-            {
+
-                response.Add(new StatApplicationPeriodResponse
+            //var daysList = calendarService.GetDatesForPeriod(startPeriod, endPeriod);
+            var daysList = await nextRunService.GetWorkDaysAsync(DateOnly.FromDateTime(userStartPeriod.DateTime), DateOnly.FromDateTime(userEndPeriod.DateTime), false);
+
+            //var response = new List<StatApplicationPeriodResponse>();
+
+            //daysList.ForEach(date =>
+            //{
+            //    response.Add(new StatApplicationPeriodResponse
+            //    {
+            //        Date = date,
+            //        CreatedApplicationsCount = result.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.Count ?? 0
+            //    });
+            //});
+
+            //response = response.OrderBy(t => t.Date).ToList();
+
+            var response = daysList.Select(date => new StatApplicationPeriodResponse
             {
                 Date = date,
-                    CreatedApplicationsCount = result.FirstOrDefault(t => DateOnly.FromDateTime(t.Date) == date)?.Count ?? 0
+                CreatedApplicationsCount = resultDict.TryGetValue(date, out var cnt) ? cnt : 0
-                });
+            }).OrderBy(t => t.Date).ToList();
-            });
-
-            response = response.OrderBy(t => t.Date).ToList();
 
             return Ok(new Response<List<StatApplicationPeriodResponse>>(response, true));
         }

PARR.API/Helpers/TimeZoneDateHelper.cs

@@ -0,0 +1,96 @@
+using System.Linq.Expressions;
+
+namespace PARR.API.Helpers
+{
+    /// <summary>
+    /// Хелпер для работы с датами в разных часовых поясах (UTC - пользователь). Используется для формирования СТАТИСТИКИ
+    /// </summary>
+    public static class TimeZoneDateHelper
+    {
+        /// <summary>
+        /// Создаёт начало дня (00:00:00) в часовом поясе пользователя и конвертирует в UTC
+        /// </summary>
+        /// <param name="userDate"></param>
+        /// <param name="userOffset"></param>
+        /// <returns></returns>
+        public static DateTime GetUtcSartOfDay(DateOnly userDate, TimeSpan userOffset)
+        {
+            var userStart = new DateTimeOffset(userDate.Year, userDate.Month, userDate.Day,
+                                                    0, 0, 0,
+                                                    userOffset);
+
+            return userStart.UtcDateTime;
+        }
+
+
+        /// <summary>
+        /// Создаёт полуоткрытый интервал [start; end) в UTC для фильтрации за период (end не включается)
+        /// </summary>
+        /// <param name="userStartDate"></param>
+        /// <param name="userEndDateExclusive"></param>
+        /// <param name="userOffset"></param>
+        /// <returns></returns>
+        public static (DateTime StartUtc, DateTime EndUtc) GetUtcDateRange(DateOnly userStartDate, DateOnly userEndDateExclusive, TimeSpan userOffset)
+        {
+            var start = new DateTimeOffset(
+                               userStartDate.Year, userStartDate.Month, userStartDate.Day,
+                               0, 0, 0, userOffset).UtcDateTime;
+
+            var end = new DateTimeOffset(
+                                userEndDateExclusive.Year, userEndDateExclusive.Month, userEndDateExclusive.Day,
+                                0, 0, 0, userOffset).UtcDateTime;
+
+            return (start, end);
+        }
+
+
+        /// <summary>
+        /// Применяет фильтр по дате к IQueryable
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="query"></param>
+        /// <param name="dateSelector"></param>
+        /// <param name="startUtc"></param>
+        /// <param name="endUtc"></param>
+        /// <returns></returns>
+        public static IQueryable<T> FilterByDateRangeUtc<T>(this IQueryable<T> query, Expression<Func<T, DateTimeOffset>> dateSelector, DateTime startUtc, DateTime endUtc)
+        {
+            // Строим выражение: t => t.DateCreated.UtcDateTime >= start && < end
+            var param = dateSelector.Parameters[0];
+            var body = Expression.AndAlso(
+                    // Строим левую часть: t.DateCreated.UtcDateTime >= startUtc
+                    Expression.GreaterThanOrEqual(
+                            Expression.Property(dateSelector.Body, nameof(DateTimeOffset.UtcDateTime)),
+                            Expression.Constant(startUtc, typeof(DateTime))
+                        ),
+                    // Строим правую часть: t.DateCreated.UtcDateTime < endUtc
+                    Expression.LessThan(
+                            Expression.Property(dateSelector.Body, nameof(DateTimeOffset.UtcDateTime)),
+                            Expression.Constant(endUtc, typeof(DateTime))
+                        )
+                );
+
+            //  Собираем финальную лямбду: t => (t.DateCreated.UtcDateTime >= start && < end)
+            var lambda = Expression.Lambda<Func<T, bool>>(body, param);
+
+            // Применяем к запросу
+            return query.Where(lambda);
+        }
+
+
+        /// <summary>
+        /// Группирует записи по дате в часовом поясе пользователя (для загруженных записей)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="source"></param>
+        /// <param name="dateSelector"></param>
+        /// <param name="userOffset"></param>
+        /// <returns></returns>
+        public static Dictionary<DateOnly, int> GroupByUserDate<T>(this IEnumerable<T> source, Func<T, DateTimeOffset> dateSelector, TimeSpan userOffset)
+        {
+            return source.GroupBy(t => DateOnly.FromDateTime(dateSelector(t).ToOffset(userOffset).DateTime))
+                            .ToDictionary(g => g.Key, g => g.Count());
+
+        }
+    }
+}

PARR.API/appsettings.json

@@ -110,7 +110,7 @@
       }
     ],
     "RabbitMq": {
-      "ThresholdConnections": 18
+      "ThresholdConnections": 28
     }
   }
 }

PARR.BLL/Services/Implementations/CalendarService.cs

@@ -7,6 +7,13 @@ namespace PARR.BLL.Services.Implementations
 {
     internal class CalendarService : ICalendarService
     {
+
+
+
+        // !!! Вообще не использовать этот класс!!! Удалить его!!! Есть же INextRunServiceV2, вот его и использовать!!!
+
+
+
         private readonly ILogger<CalendarService> logger;
 
         public CalendarService(ILogger<CalendarService> logger)

PARR.DAL/NextRunServices/INextRunService.cs

@@ -4,7 +4,7 @@ using PARR.DAL.NextRunServices.Models;
 
 namespace PARR.DAL.NextRunServices
 {
-    public interface INextRunServiceV2
+    public interface INextRunService
     {
         /// <summary>
         /// Распределить шаблоны в группе работ (получить список распределенных шаблонов с актуальными nextRun)

PARR.DAL/NextRunServices/NextRunService.cs

@@ -13,23 +13,23 @@ using PARR.DAL.Services.Interfaces.Schedule;
 
 namespace PARR.DAL.NextRunServices
 {
-    internal class NextRunServiceV2 : INextRunServiceV2
+    internal class NextRunService : INextRunService
     {
-        private readonly ILogger<NextRunServiceV2> logger;
+        private readonly ILogger<NextRunService> logger;
         private readonly ITemplateService templateService;
         private readonly IJobGroupService jobGroupService;
         private readonly IEsppScheduleTransformService esppScheduleTransformService;
-        private readonly ITemplateDistributorV2 templateDistributor;
+        private readonly ITemplateDistributor templateDistributor;
         private readonly IShortcodesService shortcodesService;
         private readonly IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService;
         private readonly SettingsFromDb settingsFromDb;
 
-        public NextRunServiceV2(
+        public NextRunService(
-            ILogger<NextRunServiceV2> logger,
+            ILogger<NextRunService> logger,
             ITemplateService templateService,
             IJobGroupService jobGroupService,
             IEsppScheduleTransformService esppScheduleTransformService,
-            ITemplateDistributorV2 templateDistributor,
+            ITemplateDistributor templateDistributor,
             IShortcodesService shortcodesService,
             IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService,
             SettingsFromDb settingsFromDb

PARR.DAL/NextRunServices/Subservices/ITemplateDistributor.cs

@@ -5,63 +5,47 @@ namespace PARR.DAL.NextRunServices.Subservices
     internal interface ITemplateDistributor
     {
         /// <summary>
-        /// Распределяет все шаблоны на указанный период, учитывая план нагрузки.
+        /// Распределить шаблоны
-        /// Возвращает список всех шаблонов с обновлёнными датами выполнения.
         /// </summary>
-        /// <param name="startDate">Дата начала распределения</param>
+        /// <param name="startDate">Дата начала, в любом часовом поясе</param>
-        /// <param name="duration">Длительность распределения, дней</param>
-        /// <param name="referenceDate">ReferenceDate</param>
-        /// <param name="allTemplates">Спиоск шаблонов для распределения</param>
-        /// <param name="excludeWeekends">Исключать выходные из распределения</param>
-        /// <returns></returns>
-        Task<List<TemplateNextRunResultDto>> DistributeTemplatesAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, List<TemplateNextRunDto> allTemplates, bool excludeWeekends);
-
-
-
-        /// <summary>
-        /// Возвращает актуальную дату выполнения для одного шаблона, учитывая план нагрузки.
-        /// Возвращает обновлённый шаблон с новой датой выполнения.
-        /// </summary>
-        /// <param name="startDate"></param>
         /// <param name="duration"></param>
         /// <param name="referenceDate"></param>
+        /// <param name="offset"></param>
+        /// <param name="allTemplates"></param>
+        /// <param name="excludeWeekends"></param>
+        /// <returns></returns>
+        Task<List<TemplateNextRunResultDto>> DistributeTemplatesAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TimeSpan? offset, List<TemplateNextRunDto> allTemplates, bool excludeWeekends);
+
+        /// <summary>
+        /// Метод проверяет, актуален ли текущий NextRun шаблона, если не актуален, возвращает актуальное значение 
+        /// При проверке загружаются шаблоны из БД! Если хотим рассчитывать nextRun для НЕСКОЛЬКИХ шаблонов, то следует рассчитать nextRun для одного шаблона, сохранить в БД, затем рассчитать для следующего
+        /// </summary>
+        /// <param name="startDate">Дата начала, в любом часовом поясе</param>
+        /// <param name="duration"></param>
+        /// <param name="referenceDate"></param>
+        /// <param name="offset"></param>
         /// <param name="targetTemplate"></param>
         /// <param name="allTemplates"></param>
         /// <param name="excludeWeekends"></param>
-        /// <param name="isNew">Новый шаблон</param>
+        /// <param name="isNew"></param>
         /// <returns></returns>
-        Task<TemplateNextRunResultDto> GetValidNextRunForTemplateAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TemplateNextRunDto targetTemplate, List<TemplateNextRunDto> allTemplates, bool excludeWeekends, bool isNew);
+        Task<TemplateNextRunResultDto> GetNextRunForTemplateAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TimeSpan? offset, 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>> GetWeekendsV2Async(DateOnly startDate, DateOnly endDate, DateTimeOffset referenceDate);
+        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);
-
 
         /// <summary>
-        /// Получить список рабочих дней
+        /// Получить список рабочих дней в диапазоне, исключая выходные и праздники.
         /// </summary>
         /// <param name="start"></param>
         /// <param name="end"></param>
-        /// <param name="excludeWeekends"></param>
+        /// <param name="excludeWeekends">Исключить выходные и праздники</param>
-        /// <param name="referenceDate"></param>
         /// <returns></returns>
-        Task<List<DateOnly>> GetWorkDaysV2Async(DateOnly start, DateOnly end, bool excludeWeekends, DateTimeOffset referenceDate);
+        Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends);
     }
 }
-

PARR.DAL/NextRunServices/Subservices/ITemplateDistributorV2.cs

@@ -1,51 +0,0 @@
-using PARR.DAL.NextRunServices.Models;
-
-namespace PARR.DAL.NextRunServices.Subservices
-{
-    internal interface ITemplateDistributorV2
-    {
-        /// <summary>
-        /// Распределить шаблоны
-        /// </summary>
-        /// <param name="startDate">Дата начала, в любом часовом поясе</param>
-        /// <param name="duration"></param>
-        /// <param name="referenceDate"></param>
-        /// <param name="offset"></param>
-        /// <param name="allTemplates"></param>
-        /// <param name="excludeWeekends"></param>
-        /// <returns></returns>
-        Task<List<TemplateNextRunResultDto>> DistributeTemplatesAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TimeSpan? offset, List<TemplateNextRunDto> allTemplates, bool excludeWeekends);
-
-        /// <summary>
-        /// Метод проверяет, актуален ли текущий NextRun шаблона, если не актуален, возвращает актуальное значение 
-        /// При проверке загружаются шаблоны из БД! Если хотим рассчитывать nextRun для НЕСКОЛЬКИХ шаблонов, то следует рассчитать nextRun для одного шаблона, сохранить в БД, затем рассчитать для следующего
-        /// </summary>
-        /// <param name="startDate">Дата начала, в любом часовом поясе</param>
-        /// <param name="duration"></param>
-        /// <param name="referenceDate"></param>
-        /// <param name="offset"></param>
-        /// <param name="targetTemplate"></param>
-        /// <param name="allTemplates"></param>
-        /// <param name="excludeWeekends"></param>
-        /// <param name="isNew"></param>
-        /// <returns></returns>
-        Task<TemplateNextRunResultDto> GetNextRunForTemplateAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TimeSpan? offset, TemplateNextRunDto targetTemplate, List<TemplateNextRunDto> allTemplates, bool excludeWeekends, bool isNew);
-
-        /// <summary>
-        /// Получить список выходных дней
-        /// </summary>
-        /// <param name="startDate"></param>
-        /// <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/ParrDalInstaller.cs

@@ -141,8 +141,7 @@ namespace PARR.DAL
 
             services.AddTransient<IEsppScheduleTransformService, EsppScheduleTransformService>();
             services.AddTransient<ITemplateDistributor, TemplateDistributor>();
-            services.AddTransient<ITemplateDistributorV2, TemplateDistributorV2>();
+            services.AddTransient<INextRunService, NextRunService>();
-            services.AddTransient<INextRunServiceV2, NextRunServiceV2>();
 
             #endregion
 

PARR.EsppScheduleSync/ScheduleSyncher.cs

@@ -226,7 +226,7 @@ namespace PARR.EsppScheduleSync
 
                 //nextRunWithTimeZone = nextRunModifierService.GetNextRunByAccountRobotTimeZone(template.NextRun);
 
-                var nextRunService = scope.ServiceProvider.GetRequiredService<INextRunServiceV2>();
+                var nextRunService = scope.ServiceProvider.GetRequiredService<INextRunService>();
                 //var shortcodeService = scope.ServiceProvider.GetRequiredService<IShortcodesService>();
 
                 //responseArea = shortcodeService.ApplyShortcodesAsync(template.Job!.ResponseAreaMask, template).GetAwaiter().GetResult();
@@ -327,7 +327,7 @@ namespace PARR.EsppScheduleSync
         private async Task<DateTimeOffset?> CalcNextRunWithRobotTzAsync(Guid templateId)
         {
             using var scope = serviceProvider.CreateScope();
-            var nextRunService = scope.ServiceProvider.GetRequiredService<INextRunServiceV2>();
+            var nextRunService = scope.ServiceProvider.GetRequiredService<INextRunService>();
 
             var nextRun = await nextRunService.GetNextRunForTemplateAsync(templateId, isNew: false);
 

PARR.NextRun/NextRunIntervalService.cs

@@ -46,10 +46,10 @@ namespace PARR.NextRun
                     //var esppSchService = scope.ServiceProvider.GetService<IEsppScheduleTransformService>();
                     var templateService = scope.ServiceProvider.GetService<ITemplateService>();
                     var jobGroupService = scope.ServiceProvider.GetService<IJobGroupService>();
-                    var nextRunService = scope.ServiceProvider.GetService<INextRunServiceV2>();
+                    var nextRunService = scope.ServiceProvider.GetService<INextRunService>();
 
                     if (templateService == null || nextRunService == null || jobGroupService == null)
-                        throw new Exception($"Не смог получить серивс {nameof(ITemplateService)} или {nameof(INextRunServiceV2)} или {nameof(IJobGroupService)}");
+                        throw new Exception($"Не смог получить серивс {nameof(ITemplateService)} или {nameof(INextRunService)} или {nameof(IJobGroupService)}");
 
                     await HandlerAsync(templateService, nextRunService, jobGroupService);
                 }
@@ -61,7 +61,7 @@ namespace PARR.NextRun
         /// Рассчет следующей даты срабатываения
         /// </summary>
         /// <returns></returns>
-        private async Task HandlerAsync(ITemplateService templateService, INextRunServiceV2 nextRunService, IJobGroupService jobGroupService)
+        private async Task HandlerAsync(ITemplateService templateService, INextRunService nextRunService, IJobGroupService jobGroupService)
         {
             logger.LogInformation("Начинаю обновлять NextRun по расписанию");
 
@@ -77,7 +77,7 @@ namespace PARR.NextRun
         }
 
 
-        private async Task UpdateNextRunAsync(ITemplateService templateService, INextRunServiceV2 nextRunService, IJobGroupService jobGroupService)
+        private async Task UpdateNextRunAsync(ITemplateService templateService, INextRunService nextRunService, IJobGroupService jobGroupService)
         {
             // выбираем все шаблоны с просроченным nextRun в статусе Used
 

PARR.NextRun/NextRunRabbitService.cs

@@ -100,7 +100,7 @@ namespace PARR.NextRun
             using var scope = serviceProvider.CreateScope();
 
             var templateService = scope.ServiceProvider.GetRequiredService<ITemplateService>();
-            var nextRunService = scope.ServiceProvider.GetRequiredService<INextRunServiceV2>();
+            var nextRunService = scope.ServiceProvider.GetRequiredService<INextRunService>();
 
             // Берем шаблоны только в статусе Used
             var templates = await templateService.Get()

PARR.TemplateDistributor/TemplateDistributor.cs

@@ -12,14 +12,14 @@ namespace PARR.TemplateDistributor
     {
         private readonly ILogger<TemplateDistributor> logger;
         //private readonly INextRunService nextRunService;
-        private readonly INextRunServiceV2 nextRunService;
+        private readonly INextRunService nextRunService;
         private readonly ITemplateService templateService;
         private readonly IRobotConfigurationService robotConfigurationService;
 
         public TemplateDistributor(
             ILogger<TemplateDistributor> logger,
             //INextRunService nextRunService,
-            INextRunServiceV2 nextRunService,
+            INextRunService nextRunService,
             ITemplateService templateService,
             IRobotConfigurationService robotConfigurationService
             )

PARR.TemplateGeneratorWorker/TemplateGenerator.cs

@@ -20,7 +20,7 @@ namespace PARR.TemplateGeneratorWorker
         private readonly IJobService jobService;
         private readonly IShortcodesService shortcodesService;
         private readonly ITemplateService templateService;
-        private readonly INextRunServiceV2 nextRunService;
+        private readonly INextRunService nextRunService;
 
         //private readonly INextRunService nextRunService;
 
@@ -33,7 +33,7 @@ namespace PARR.TemplateGeneratorWorker
             IJobService jobService,
             IShortcodesService shortcodesService,
             ITemplateService templateService,
-            INextRunServiceV2 nextRunService
+            INextRunService nextRunService
             //INextRunService nextRunService
             //IEsppScheduleTransformService esppScheduleTransformService
             )

PARR.TemplateUpdater/Services/TemplateUpdaterService.cs

@@ -19,7 +19,7 @@ namespace PARR.TemplateUpdater.Services
         private readonly IJobService jobService;
         private readonly IUnitService unitService;
         private readonly IRobotConfigurationService robotConfigurationService;
-        private readonly INextRunServiceV2 nextRunService;
+        private readonly INextRunService nextRunService;
 
         public TemplateUpdaterService(
                 ILogger<TemplateUpdaterService> logger,
@@ -27,7 +27,7 @@ namespace PARR.TemplateUpdater.Services
                 IJobService jobService,
                 IUnitService unitService,
                 IRobotConfigurationService robotConfigurationService,
-                INextRunServiceV2 nextRunService
+                INextRunService nextRunService
             )
         {
             this.logger = logger;

PARR.Test/NextRun/NextRunTest.cs

@@ -14,7 +14,7 @@ namespace PARR.Test.NextRun
         private readonly ITemplateService templateService;
         private readonly IShortcodesService shortcodesService;
         //private readonly ITemplateDistributorV2 templateDistributorV2;
-        private readonly INextRunServiceV2 nextRunServiceV2;
+        private readonly INextRunService nextRunServiceV2;
 
         public NextRunTest(
             /*ITemplateDistributor templateDistributor, */
@@ -22,7 +22,7 @@ namespace PARR.Test.NextRun
             ITemplateService templateService,
             IShortcodesService shortcodesService,
             //ITemplateDistributorV2 templateDistributorV2,
-            INextRunServiceV2 nextRunServiceV2
+            INextRunService nextRunServiceV2
             )
         {
             //this.templateDistributor = templateDistributor;

PARR.Test/Worker.cs

@@ -15,21 +15,21 @@ namespace PARR.Test
         private readonly ILogger<Worker> _logger;
         private readonly IEsppApiService esppApiService;
         private readonly IIntervalService intervalService;
-        private readonly ICalendarService calendarService;
+        //private readonly ICalendarService calendarService;
         private readonly IServiceProvider serviceProvider;
 
         public Worker(
             ILogger<Worker> logger,
             IEsppApiService esppApiService,
             IIntervalService intervalService,
-            ICalendarService calendarService,
+            //ICalendarService calendarService,
             IServiceProvider serviceProvider
             )
         {
             _logger = logger;
             this.esppApiService = esppApiService;
             this.intervalService = intervalService;
-            this.calendarService = calendarService;
+            //this.calendarService = calendarService;
             this.serviceProvider = serviceProvider;
         }