feat(api): статистика по регламентным работам по ЗО, РГ, РР

PARR.API/Contracts/V1/ApiRoutes.cs

@@ -248,11 +248,21 @@
             public const string Get = BaseStat + "/template-distribution/{applicationInWorkId}";
         }
 
-        public static class StatStatResponseAreaWorkLoad
+        public static class StatResponseAreaWorkLoad
         {
             public const string GetAll = BaseStat + "/response-area-workloads/";
         }
 
+        public static class StatWorkGroupWorkLoad
+        {
+            public const string Get = BaseStat + "/work-group-workloads/{responseAreaCode}";
+        }
+
+        public static class StatWorkWorkLoad
+        {
+            public const string Get = BaseStat + "/work-workloads/{workGroupId}";
+        }
+
         #endregion
 
         #region Наряды

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

@@ -1,8 +1,6 @@
-using System.Runtime.InteropServices;
+namespace PARR.API.Contracts.V1.Responses
-
-namespace PARR.API.Contracts.V1.Responses
 {
-    public class ApplicationInWorkResponse
+    public class ApplicationInWorkBaseResponse
     {
         public Guid Id { get; set; }
 
@@ -14,16 +12,18 @@ namespace PARR.API.Contracts.V1.Responses
 
         public required string Solution { get; set; }
 
-        //public DateTimeOffset? LastRun { get; set; }
-
-        //public DateTimeOffset NextRun { get; set; }
-
         public DateTimeOffset ReferenceDate { get; set; }
 
         public bool IsAutoDistributionEnabled { get; set; }
 
         public bool IsAgent { get; set; }
 
+        public ApplicationResponse? Application { get; set; }
+    }
+
+
+    public class ApplicationInWorkResponse : ApplicationInWorkBaseResponse
+    {
         public string? AgentName { get; set; }
 
         public int? AgentTimeOutSec { get; set; }
@@ -32,8 +32,6 @@ namespace PARR.API.Contracts.V1.Responses
 
         public WorkResponse? Work { get; set; }
 
-        public ApplicationResponse? Application { get; set; }
-
         public int TemplatesCount { get; set; }
 
 

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

@@ -1,15 +1,7 @@
 namespace PARR.API.Contracts.V1.Responses.Statistics
 {
-    public class StatResponseAreaWorkLoadResponse
+    public class StatResponseAreaWorkLoadResponse : StatWorkLoadDataBaseResponse
     {
         public required ResponseAreaResponse ResponseArea { get; set; }
-
-        public List<StatWorkLoadDataResponse> WorkLoad { get; set; }
-    }
-
-    public class StatWorkLoadDataResponse
-    {
-        public DateTimeOffset Date { get; set; }
-        public int TemplateCount { get; set; }
     }
 }

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

@@ -0,0 +1,7 @@
+namespace PARR.API.Contracts.V1.Responses.Statistics
+{
+    public class StatWorkGroupWorkLoadResponse : StatWorkLoadDataBaseResponse
+    {
+        public required WorkGroupResponse WorkGroup { get; set; }
+    }
+}

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

@@ -0,0 +1,17 @@
+namespace PARR.API.Contracts.V1.Responses.Statistics
+{
+    public class StatWorkLoadDataBaseResponse
+    {
+        public List<StatWorkLoadDataResponse> WorkLoad { get; set; }
+
+        public int WorksCount => WorkLoad?.Sum(t => t.TemplateCount) ?? 0;
+
+        public double AverageWorksCount => Math.Round((double)WorksCount / WorkLoad.Count(), 2);
+    }
+
+    public class StatWorkLoadDataResponse
+    {
+        public DateTimeOffset Date { get; set; }
+        public int TemplateCount { get; set; }
+    }
+}

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

@@ -0,0 +1,7 @@
+namespace PARR.API.Contracts.V1.Responses.Statistics
+{
+    public class StatWorkWorkLoadResponse : StatWorkLoadDataBaseResponse
+    {
+        public required ApplicationInWorkBaseResponse Job { get; set; }
+    }
+}

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

@@ -8,7 +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.API.Services.Interfaces;
 using PARR.Constants;
+using PARR.DAL.Models;
 using PARR.DAL.Services.Interfaces;
 
 namespace PARR.API.Controllers.V1.Statistics
@@ -22,16 +24,19 @@ namespace PARR.API.Controllers.V1.Statistics
         private readonly ITemplateService templateService;
         private readonly IResponseAreaService responseAreaService;
         private readonly IMapper mapper;
+        private readonly IWorkLoadService workLoadService;
 
         public StatResponseAreaWorkLoadController(
             ITemplateService templateService,
             IResponseAreaService responseAreaService,
-            IMapper mapper
+            IMapper mapper,
+            IWorkLoadService workLoadService
             )
         {
             this.templateService = templateService;
             this.responseAreaService = responseAreaService;
             this.mapper = mapper;
+            this.workLoadService = workLoadService;
         }
 
 
@@ -39,35 +44,15 @@ namespace PARR.API.Controllers.V1.Statistics
         /// Статистика загрузки РР по всем ЗО 
         /// </summary>
         /// <returns></returns>
-        [HttpGet(ApiRoutes.StatStatResponseAreaWorkLoad.GetAll)]
+        [HttpGet(ApiRoutes.StatResponseAreaWorkLoad.GetAll)]
         public async Task<IActionResult> GetAll([FromQuery] WorkloadBaseQuery requestQuery)
         {
-            //начинаем не с сегодняшнего дня, а с завтра, так как на сегодня уже некоторые работы были проведены и дата изменилась
+            var daysList = workLoadService.GetDatesForPeriod(requestQuery);
-            var queryStartDate = DateTimeOffset.UtcNow.Date.AddDays(1);
-            var queryEndDate = requestQuery.IsMonth == true ? queryStartDate.AddDays(30) : queryStartDate.AddDays(6);
 
-            //-----------
+            IQueryable<Template> query = templateService.Get()
-            var daysList = new List<DateTimeOffset>();
+                .Include(t => t.Host).ThenInclude(t => t.WorkGroup);
-            daysList.Add(new DateTimeOffset(queryStartDate, new TimeSpan(0)));
 
-            while (daysList.Last() < queryEndDate)
+            query = workLoadService.FilterTemplatesQuery(query, requestQuery);
-            {
-                daysList.Add(daysList.Last().AddDays(1));
-            }
-            //-----------
-
-
-            var query = templateService.Get()
-                .Include(t => t.Host).ThenInclude(t => t.WorkGroup)
-                .Where(t =>
-                        t.NextRun.DateTime.Date >= queryStartDate.Date && t.NextRun.DateTime.Date <= queryEndDate.Date
-                        );
-
-            if (requestQuery.IsActiveTemplate.HasValue)
-                query = query.Where(t => t.IsActiveTemplate == requestQuery.IsActiveTemplate.Value);
-
-            if (requestQuery.IsActiveSchedule.HasValue)
-                query = query.Where(t => t.IsActiveTemplate == requestQuery.IsActiveSchedule.Value);
 
 
             var groupedQuery = query.GroupBy(t => new { t.NextRun.DateTime.Date, t.Host!.WorkGroup!.ResponseAreaCode })

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

@@ -0,0 +1,97 @@
+using AutoMapper;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using PARR.API.Contracts.V1;
+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.Services.Interfaces;
+using PARR.DAL.Models;
+using PARR.DAL.Services.Interfaces;
+
+namespace PARR.API.Controllers.V1.Statistics
+{
+    /// <summary>
+    /// Статистика загрузки регламентными работами по рабочим группам
+    /// </summary>
+    public class StatWorkGroupWorkLoadController : BaseApiController
+    {
+        private readonly ITemplateService templateService;
+        private readonly IWorkLoadService workLoadService;
+        private readonly IWorkGroupService workGroupService;
+        private readonly IMapper mapper;
+
+        public StatWorkGroupWorkLoadController(
+            ITemplateService templateService,
+            IWorkLoadService workLoadService,
+            IWorkGroupService workGroupService,
+            IMapper mapper
+            )
+        {
+            this.templateService = templateService;
+            this.workLoadService = workLoadService;
+            this.workGroupService = workGroupService;
+            this.mapper = mapper;
+        }
+
+
+        /// <summary>
+        /// Статистика загрузки регламентными работами рабочих групп по ЗО
+        /// </summary>
+        /// <param name="responseAreaCode"></param>
+        /// <param name="requestQuery"></param>
+        /// <returns></returns>
+        [HttpGet(ApiRoutes.StatWorkGroupWorkLoad.Get)]
+        public async Task<IActionResult> Get([FromRoute] int responseAreaCode, [FromQuery] WorkloadBaseQuery requestQuery)
+        {
+            var daysList = workLoadService.GetDatesForPeriod(requestQuery);
+
+            IQueryable<Template> query = templateService.Get()
+                                            .Include(t => t.Host);
+
+            query = workLoadService.FilterTemplatesQuery(query, requestQuery).Where(t => t.Host!.WorkGroup!.ResponseAreaCode == responseAreaCode);
+
+            var groupedQuery = query.GroupBy(t => new { t.NextRun.DateTime.Date, t.Host!.WorkGroupId })
+                                        .Select(t => new
+                                        {
+                                            WorkGroupId = t.Key.WorkGroupId,
+                                            Date = t.Key.Date,
+                                            TemplateCount = t.Count()
+                                        });
+
+            var queryResult = await groupedQuery.ToListAsync();
+
+            //if (!queryResult.Any())
+            //    return NoContent();
+
+
+            var allWorkGroups = await workGroupService.Get()
+                                            .Include(t => t.ResponseArea)
+                                            .Where(t => t.ResponseAreaCode == responseAreaCode)
+                                            .ToListAsync();
+
+            var response = new List<StatWorkGroupWorkLoadResponse>();
+
+            allWorkGroups.ForEach(wg =>
+            {
+                var workLoads = daysList.Select(t => new StatWorkLoadDataResponse
+                {
+                    Date = t,
+                    TemplateCount = queryResult.FirstOrDefault(x => x.WorkGroupId == wg.Id && x.Date.Date == t.Date)?.TemplateCount ?? 0
+                }).OrderBy(t => t.Date).ToList();
+
+                response.Add(new StatWorkGroupWorkLoadResponse
+                {
+                    WorkGroup = mapper.Map<WorkGroupResponse>(wg),
+                    WorkLoad = workLoads
+                });
+            });
+
+            response = response.OrderBy(t => t.WorkGroup.Name).ToList();
+
+            return Ok(new Response<List<StatWorkGroupWorkLoadResponse>>(response, true));
+        }
+    }
+}

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

@@ -0,0 +1,95 @@
+using AutoMapper;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using PARR.API.Contracts.V1;
+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.Services.Interfaces;
+using PARR.DAL.Models;
+using PARR.DAL.Services.Interfaces;
+
+namespace PARR.API.Controllers.V1.Statistics
+{
+    /// <summary>
+    /// Статистика загрузки регламентными работами по Видам работ(works)
+    /// </summary>
+    public class StatWorkWorkLoadController : BaseApiController
+    {
+        private readonly ITemplateService templateService;
+        private readonly IWorkLoadService workLoadService;
+        private readonly IMapper mapper;
+
+        public StatWorkWorkLoadController(
+                ITemplateService templateService,
+                IWorkLoadService workLoadService,
+                IMapper mapper
+            )
+        {
+            this.templateService = templateService;
+            this.workLoadService = workLoadService;
+            this.mapper = mapper;
+        }
+
+
+        /// <summary>
+        /// Статистика загрузки регламентными работами по Видам работ(works)
+        /// </summary>
+        /// <param name="workGroupId"></param>
+        /// <param name="requestQuery"></param>
+        /// <returns></returns>
+        [HttpGet(ApiRoutes.StatWorkWorkLoad.Get)]
+        public async Task<IActionResult> Get([FromRoute] Guid workGroupId, [FromQuery] WorkloadBaseQuery requestQuery)
+        {
+            var daysList = workLoadService.GetDatesForPeriod(requestQuery);
+
+            IQueryable<Template> query = templateService.Get()
+                                            .Include(t => t.Host);
+
+            query = workLoadService.FilterTemplatesQuery(query, requestQuery).Where(t => t.Host!.WorkGroupId == workGroupId);
+
+            var groupedQuery = query.GroupBy(t => new { t.NextRun.DateTime.Date, t.ApplicationInWorkId })
+                                    .Select(t => new
+                                    {
+                                        ApplicationInWorkId = t.Key.ApplicationInWorkId,
+                                        Date = t.Key.Date,
+                                        TemplateCount = t.Count()
+                                    });
+
+            var queryResult = await groupedQuery.ToListAsync();
+
+
+            // получаем только работы по которым есть шаблоны (активированные/деакт) и за любой период
+            var allAppInWorks = await templateService.Get()
+                                                    .Include(t => t.Host)
+                                                    .Include(t => t.ApplicationsInWork).ThenInclude(t => t.Application).ThenInclude(t => t.ApplicationType)
+                                                    .Where(t => t.Host.WorkGroupId == workGroupId)
+                                                    .Select(t => t.ApplicationsInWork)
+                                                    .Distinct()
+                                                    .ToListAsync();
+
+            var response = new List<StatWorkWorkLoadResponse>();
+
+            allAppInWorks.ForEach(appInWork =>
+            {
+                var workLoads = daysList.Select(t => new StatWorkLoadDataResponse
+                {
+                    Date = t,
+                    TemplateCount = queryResult.FirstOrDefault(x => x.ApplicationInWorkId == appInWork.Id && x.Date.Date == t.Date)?.TemplateCount ?? 0
+                }).OrderBy(t => t.Date).ToList();
+
+                response.Add(new StatWorkWorkLoadResponse
+                {
+                    Job = mapper.Map<ApplicationInWorkBaseResponse>(appInWork),
+                    WorkLoad = workLoads
+                });
+            });
+
+            response = response.OrderBy(t => t.Job.ShortDescription).ToList();
+
+            return Ok(new Response<List<StatWorkWorkLoadResponse>>(response, true));
+        }
+    }
+}

PARR.API/Installers/ApiServicesInstaller.cs

@@ -21,6 +21,7 @@ namespace PARR.API.Installers
 
             services.AddTransient<IClientService, ClientService>();
             services.AddTransient<IAuthService, AuthService>();
+            services.AddTransient<IWorkLoadService, WorkLoadService>();
 
 
         }

PARR.API/MappingProfiles/DomainToResponseProfile.cs

@@ -262,9 +262,14 @@ namespace PARR.API.MappingProfiles
 
             #region ApplicationInWork
 
+            CreateMap<ApplicationsInWork, ApplicationInWorkBaseResponse>()
+                .Include<ApplicationsInWork, ApplicationInWorkResponse>()
+                .ForMember(d => d.Application, o => o.MapFrom(s => s.Application));
+
+            CreateMap<ApplicationsInWork, ApplicationInWorkBaseResponse>();
+
             CreateMap<ApplicationsInWork, ApplicationInWorkResponse>()
                 .ForMember(d => d.Work, o => o.MapFrom(s => s.Work))
-                .ForMember(d => d.Application, o => o.MapFrom(s => s.Application))
                 .ForMember(d => d.TemplatesCount, o => o.MapFrom(s => s.Templates.Count()))
                 .ForMember(d => d.Schedule, o => o.MapFrom<ApplicationInWorkScheduleResolver>())
                 .ForMember(d => d.WorkGroups, o => o.MapFrom(s => s.WorkGroups.OrderBy(t => t.WorkGroup.Name).Select(t => t.WorkGroup)));

PARR.API/Services/Implementations/WorkLoadService.cs

@@ -0,0 +1,58 @@
+using PARR.API.Contracts.V1.Requests.Queries;
+using PARR.API.Services.Interfaces;
+using PARR.DAL.Models;
+
+namespace PARR.API.Services.Implementations
+{
+    internal class WorkLoadService : IWorkLoadService
+    {
+        private DateTime GetStartDate()
+        {
+            //начинаем не с сегодняшнего дня, а с завтра, так как на сегодня уже некоторые работы были проведены и их дата изменилась
+            return DateTimeOffset.UtcNow.Date.AddDays(1);
+        }
+
+
+        private DateTime GetEndDate(bool? isMonth)
+        {
+            var startDate = GetStartDate();
+
+            return isMonth == true ? startDate.AddDays(30) : startDate.AddDays(6);
+        }
+
+
+        public List<DateTimeOffset> GetDatesForPeriod(WorkloadBaseQuery requestQuery)
+        {
+            var startDate = GetStartDate();
+            var endDate = GetEndDate(requestQuery.IsMonth);
+
+            var daysList = new List<DateTimeOffset>();
+
+            daysList.Add(new DateTimeOffset(startDate, new TimeSpan(0)));
+
+            while (daysList.Last() < endDate)
+                daysList.Add(daysList.Last().AddDays(1));
+
+            return daysList.OrderBy(t => t).ToList();
+        }
+
+
+        public IQueryable<Template> FilterTemplatesQuery(IQueryable<Template> query, WorkloadBaseQuery requestQuery)
+        {
+            var startDate = GetStartDate();
+            var endDate = GetEndDate(requestQuery.IsMonth);
+
+            query = query.Where(t =>
+                        t.NextRun.DateTime.Date >= startDate.Date && t.NextRun.DateTime.Date <= endDate.Date
+                        );
+
+            if (requestQuery.IsActiveTemplate.HasValue)
+                query = query.Where(t => t.IsActiveTemplate == requestQuery.IsActiveTemplate.Value);
+
+            if (requestQuery.IsActiveSchedule.HasValue)
+                query = query.Where(t => t.IsActiveTemplate == requestQuery.IsActiveSchedule.Value);
+
+            return query;
+        }
+    }
+}

PARR.API/Services/Interfaces/IWorkLoadService.cs

@@ -0,0 +1,18 @@
+using PARR.API.Contracts.V1.Requests.Queries;
+using PARR.DAL.Models;
+
+namespace PARR.API.Services.Interfaces
+{
+    /// <summary>
+    /// Сервисы по формированию статистики загрузки рабочих групп/ЗО, и тд регламентными работами
+    /// </summary>
+    public interface IWorkLoadService
+    {
+        IQueryable<Template> FilterTemplatesQuery(IQueryable<Template> query, WorkloadBaseQuery requestQuery);
+
+        List<DateTimeOffset> GetDatesForPeriod(WorkloadBaseQuery requestQuery);
+
+        //DateTime GetEndDate(DateTime startDate, bool? isMonth);
+        //DateTime GetStartDate();
+    }
+}