Merge branch 'report' into dev

PARR.API/Contracts/V1/ApiRoutes.cs

@@ -303,6 +303,8 @@
             public const string WorkGroup = BaseStat + "/workload/work-groups";
 
             public const string ResponseArea = BaseStat + "/workload/response-areas";
+
+            public const string ReportInfo = BaseStat + "/workload/report-info";
         }
 
         #endregion
@@ -564,6 +566,15 @@
 
         #endregion
 
+        #region Tasks
+
+        public static class Tasks
+        {
+            public const string GetActiveTasks = Base + "/tasks/active";
+        }
+
+        #endregion
+
     }
 
 }

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

@@ -0,0 +1,9 @@
+namespace PARR.API.Contracts.V1.Responses
+{
+    public record ActiveTaskResponse : TaskItemBaseResponse
+    {
+        public required TaskItemTypeResponse Type { get; init; }
+
+        public required TaskItemStatusResponse Status { get; init; }
+    }
+}

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

@@ -0,0 +1,14 @@
+using PARR.Domain.DTOs.Workload;
+
+namespace PARR.API.Contracts.V1.Responses.Statistics
+{
+    /// <summary>
+    /// Инфо о формирование КЭШ для отчета Workload
+    /// </summary>
+    public record StatWorkloadCacheInfoResponse
+    {
+        public WorkloadCacheInfo.StatusEnum Status { get; set; }
+
+        public DateTimeOffset? Date { get; init; }
+    }
+}

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

@@ -0,0 +1,21 @@
+namespace PARR.API.Contracts.V1.Responses
+{
+    public record TaskItemBaseResponse
+    {
+        public Guid Id { get; init; }
+
+        public DateTimeOffset DateCreated { get; init; }
+
+        public DateTimeOffset? DateModified { get; init; }
+
+        public int RetryCount { get; init; }
+
+        public DateTimeOffset? ProcessedAt { get; init; }
+    }
+
+    public record TaskItemResponse : TaskItemBaseResponse
+    {
+
+    }
+
+}

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

@@ -0,0 +1,13 @@
+using PARR.Domain.Enums;
+
+namespace PARR.API.Contracts.V1.Responses
+{
+    public record TaskItemStatusResponse
+    {
+        public TaskItemStatusEnum Code { get; init; }
+
+        public required string Name { get; init; }
+
+        public required string Description { get; init; }
+    }
+}

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

@@ -0,0 +1,33 @@
+using PARR.Domain.Enums;
+
+namespace PARR.API.Contracts.V1.Responses
+{
+    public record TaskItemTypeResponse
+    {
+        public TaskTypeEnum Code { get; init; }
+
+        public required string Name { get; init; }
+
+        public required string Description { get; init; }
+
+        /// <summary>
+        /// Максимальное кол-во попыток
+        /// </summary>
+        public int MaxRetries { get; init; }
+
+        /// <summary>
+        /// Максимальное время выполнения
+        /// </summary>
+        public int MaxExecutionTimeMinutes { get; init; }
+
+        /// <summary>
+        /// Одновременно может быть только одна задача или несколько
+        /// </summary>
+        public bool IsSingleton { get; init; }
+
+        /// <summary>
+        /// Сколько дней хранить в БД
+        /// </summary>
+        public int RetentionDays { get; init; }
+    }
+}

PARR.API/Controllers/V1/GeneratorTemplateController.cs

@@ -1,95 +0,0 @@
-namespace PARR.API.Controllers.V1
-{
-    //[Authorize(Roles = ParrRoles.Administrator.Role)]
-    //public class GeneratorTemplateController : BaseApiController
-    //{
-    //    private readonly IValidator<GeneratorTemplateRequest> validator;
-    //    private readonly IRabbitService mqService;
-    //    private readonly IUriService uriService;
-    //    private readonly MqSettings mqSettings;
-    //    private readonly IClientService clientService;
-
-    //    public GeneratorTemplateController(
-    //        IValidator<GeneratorTemplateRequest> validator,
-    //        IRabbitService mqService,
-    //        IUriService uriService,
-    //        MqSettings mqSettings,
-    //        IClientService clientService
-    //        )
-    //    {
-    //        this.validator = validator;
-    //        this.mqService = mqService;
-    //        this.uriService = uriService;
-    //        this.mqSettings = mqSettings;
-    //        this.clientService = clientService;
-    //    }
-
-    //    /// !!!!!!!!!! Это старый контроллер, удалить !!!!!!!!!!
-
-
-    //    /// <summary>
-    //    /// Запрос на генерацию шаблонов
-    //    /// </summary>
-    //    /// <returns></returns>
-    //    [HttpPost(ApiRoutes.GeneratorTemplate.Create)]
-    //    public async Task<IActionResult> Create([FromBody] GeneratorTemplateRequest request)
-    //    {
-    //        var resultValidate = await validator.ValidateAsync(request);
-    //        if (!resultValidate.IsValid)
-    //            return BadRequest(new Response(resultValidate.Errors));
-
-    //        var result = true;
-
-    //        request.Ek.ForEach(ek =>
-    //        {
-    //            //todo: проверить в ForEach(async status - отрабатывает ли нормально async, возможно надо переделать в обычный foreach
-    //            request.Status.ForEach(async status =>
-    //            {
-    //                var obj = new GeneratorTemplateMq
-    //                {
-    //                    Action = request.Action,
-    //                    ApplicationId = request.ApplicationId,
-    //                    Ek = ek,
-    //                    WorkId = request.WorkId,
-    //                    StatusEk = status,
-    //                    IsActiveTemplate = request.IsActiveTemplate,
-    //                    IsActiveSchedule = request.IsActiveSchedule,
-    //                    HistoryInitiator = new HistoryInitiator { InitiatorIp = clientService.GetClientIp()?.ToString(), InitiatorParrComponentId = ParrComponentsEnum.Api }
-    //                };
-
-    //                //var msg = JsonSerializer.Serialize(obj);
-
-    //                //var _result = await mqService.SendAsync(mqSettings.GenerateTemplates, new[] { msg });
-    //                var _result = await mqService.SendAsync(mqSettings.GenerateTemplates, new List<object> { obj });
-
-    //                if (_result.IsSuccess == false)
-    //                    result = false;
-
-    //            });
-    //        });
-
-    //        //var obj = new GeneratorTemplateMq
-    //        //{
-    //        //    Action = request.Action,
-    //        //    ApplicationId = request.ApplicationId,
-    //        //    Ek = request.Ek,
-    //        //    WorkId = request.WorkId,
-    //        //    StatusEk = request.Status,
-    //        //    IsActiveTemplate = request.IsActiveTemplate,
-    //        //    IsActiveSchedule = request.IsActiveSchedule
-    //        //};
-
-    //        //var msg = JsonSerializer.Serialize(obj);
-
-    //        //var result = mqService.Send(mqSettings.GenerateTemplates, new[] { msg });
-
-    //        //if (!result.IsSuccess)
-    //        if (!result)
-    //            return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при отправке данных." } }));
-
-    //        var createdUri = uriService.GetAllUri(ApiRoutes.Template.GetAll);
-
-    //        return Created(createdUri, new Response<string?>(null, true, new List<ErrorModel>(), "Отправлен запрос на генерацию шаблонов."));
-    //    }
-    //}
-}

PARR.API/Controllers/V1/JobAutoControlController.cs

@@ -1,212 +0,0 @@
-using Microsoft.AspNetCore.Authorization;
-using PARR.API.Controllers.V1.Base;
-using PARR.Domain.Common.Roles;
-
-namespace PARR.API.Controllers.V1
-{
-    /// <summary>
-    /// Управление автоматическим созданием/деактивацией/активацией РР
-    /// </summary>
-    [Authorize(Roles = ParrRoles.Administrator.Role)]
-    public class JobAutoControlController : BaseApiController
-    {
-        //private readonly IJobAutoControlService jobAutoControlService;
-        //private readonly IApplicationsInWorkService applicationsInWorkService;
-        //private readonly IMapper mapper;
-        //private readonly IValidator<JobAutoControlRequest> validator;
-        //private readonly IUriService uriService;
-
-        //public JobAutoControlController(
-        //    IJobAutoControlService jobAutoControlService,
-        //    IApplicationsInWorkService applicationsInWorkService,
-        //    IMapper mapper,
-        //    IValidator<JobAutoControlRequest> validator,
-        //    IUriService uriService
-        //    )
-        //{
-        //    this.jobAutoControlService = jobAutoControlService;
-        //    this.applicationsInWorkService = applicationsInWorkService;
-        //    this.mapper = mapper;
-        //    this.validator = validator;
-        //    this.uriService = uriService;
-        //}
-
-
-        ///// <summary>
-        ///// Получить настройки автоматического управления РР
-        ///// </summary>
-        ///// <param name="applicationInWorkId"></param>
-        ///// <returns></returns>
-        //[HttpGet(ApiRoutes.JobAutoControl.Get)]
-        //public async Task<IActionResult> Get([FromRoute] Guid applicationInWorkId)
-        //{
-        //    var obj = await jobAutoControlService.Get()
-        //        .Include(t => t.ApplicationsInWork).ThenInclude(t => t.WorkGroups).ThenInclude(t => t.WorkGroup)
-        //        .Include(t => t.JobEkMasks)
-        //        .Include(t => t.JobAutoControlInEkStatuses).ThenInclude(t => t.EkStatus)
-        //        .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
-
-        //    if (obj == null)
-        //    {
-        //        // проверим, есть ли вообще такой AppInWork
-        //        var appInWork = await applicationsInWorkService.GetAsync(applicationInWorkId);
-        //        if (appInWork == null)
-        //            return NotFound();
-
-        //        return NoContent();
-        //    }
-
-        //    var response = mapper.Map<JobAutoControlResponse>(obj);
-
-        //    return Ok(new Response<JobAutoControlResponse>(response, true));
-        //}
-
-
-        ///// <summary>
-        ///// Создать настройки автоматического управления РР
-        ///// </summary>
-        ///// <param name="applicationInWorkId"></param>
-        ///// <param name="request"></param>
-        ///// <returns></returns>
-        //[HttpPost(ApiRoutes.JobAutoControl.Create)]
-        //public async Task<IActionResult> Create([FromRoute] Guid applicationInWorkId, [FromBody] JobAutoControlRequest request)
-        //{
-        //    var exist = await jobAutoControlService.Get().FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
-        //    if (exist != null)
-        //        return BadRequest(new Response(false, new List<ErrorModel> {
-        //            new ErrorModel { FieldName = nameof(applicationInWorkId), Message = $"Запись с {nameof(applicationInWorkId)}: {applicationInWorkId} уже существует." }
-        //        }));
-
-        //    var resultValidate = await validator.ValidateAsync(request);
-        //    if (!resultValidate.IsValid)
-        //        return BadRequest(new Response(resultValidate.Errors));
-
-        //    var newObj = new DAL.Models.JobAutoControl
-        //    {
-        //        Id = Guid.NewGuid(),
-        //        ApplicationInWorkId = applicationInWorkId,
-        //        CreateNew = request.CreateNew,
-        //        Deactivate = request.Deactivate,
-        //        Activate = request.Activate,
-        //        OnTemplateIsActive = request.OnTemplateIsActive,
-        //        OnScheduleIsActive = request.OnScheduleIsActive,
-        //        OffTemplateIsActive = request.OffTemplateIsActive,
-        //        OffScheduleIsActive = request.OffScheduleIsActive
-        //    };
-
-        //    // убираем пробелы и дубли
-        //    request.EkMasks.Where(t => t.Trim() != string.Empty).Distinct().ToList().ForEach(mask => newObj.JobEkMasks.Add(new JobEkMask
-        //    {
-        //        Id = Guid.NewGuid(),
-        //        DateCreated = DateTimeOffset.UtcNow,
-        //        Name = mask.Trim(),
-        //        JobAutoControlId = newObj.Id
-        //    }));
-
-        //    request.EnabledEkStatuses.ForEach(status => newObj.JobAutoControlInEkStatuses.Add(new JobAutoControlInEkStatus
-        //    {
-        //        EkStatusCode = (int)status,
-        //        JobAutoControlId = newObj.Id
-        //    }));
-
-        //    if (!await jobAutoControlService.CreateAsync(newObj) || !await jobAutoControlService.CommitAsync())
-        //        return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при создани записи." } }));
-
-        //    var locationUri = uriService.GetUri(ApiRoutes.JobAutoControl.Get, ApiRoutes.JobAutoControl.appInWorkId, applicationInWorkId);
-
-        //    var createdObj = await jobAutoControlService.Get()
-        //        .Include(t => t.ApplicationsInWork).ThenInclude(t => t.WorkGroups).ThenInclude(t => t.WorkGroup)
-        //        .Include(t => t.JobEkMasks)
-        //        .Include(t => t.JobAutoControlInEkStatuses).ThenInclude(t => t.EkStatus)
-        //        .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
-
-        //    return Created(locationUri, new Response<JobAutoControlResponse>(mapper.Map<JobAutoControlResponse>(createdObj), true));
-        //}
-
-
-        ///// <summary>
-        ///// Обновить настройки автоматического управления РР
-        ///// </summary>
-        ///// <param name="applicationInWorkId"></param>
-        ///// <param name="request"></param>
-        ///// <returns></returns>
-        //[HttpPut(ApiRoutes.JobAutoControl.Update)]
-        //public async Task<IActionResult> Update([FromRoute] Guid applicationInWorkId, [FromBody] JobAutoControlRequest request)
-        //{
-        //    var resultValidate = await validator.ValidateAsync(request);
-        //    if (!resultValidate.IsValid)
-        //        return BadRequest(new Response(resultValidate.Errors));
-
-        //    var orig = await jobAutoControlService.Get()
-        //        .Include(t => t.JobEkMasks)
-        //        .Include(t => t.JobAutoControlInEkStatuses)
-        //        .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
-
-        //    if (orig == null)
-        //        return BadRequest(new Response(false, new List<ErrorModel> {
-        //            new ErrorModel { FieldName = nameof(applicationInWorkId), Message = $"Запись с {nameof(applicationInWorkId)}: {applicationInWorkId} не существует." }
-        //        }));
-
-
-        //    orig.DateModified = DateTimeOffset.UtcNow;
-        //    orig.CreateNew = request.CreateNew;
-        //    orig.Deactivate = request.Deactivate;
-        //    orig.Activate = request.Activate;
-        //    orig.OnTemplateIsActive = request.OnTemplateIsActive;
-        //    orig.OnScheduleIsActive = request.OnScheduleIsActive;
-        //    orig.OffTemplateIsActive = request.OffTemplateIsActive;
-        //    orig.OffScheduleIsActive = request.OffScheduleIsActive;
-
-        //    orig.JobEkMasks.Clear();
-        //    // убираем пробелы и дубли
-        //    request.EkMasks.Where(t => t.Trim() != string.Empty).Distinct().ToList().ForEach(mask => orig.JobEkMasks.Add(new JobEkMask
-        //    {
-        //        //Id = Guid.NewGuid(), // не пойму почему не нужно это поле. с ним ошибка. 
-        //        DateCreated = DateTimeOffset.UtcNow,
-        //        Name = mask.Trim(),
-        //        JobAutoControlId = orig.Id
-        //    }));
-
-        //    orig.JobAutoControlInEkStatuses.Clear();
-        //    request.EnabledEkStatuses.ForEach(status => orig.JobAutoControlInEkStatuses.Add(new JobAutoControlInEkStatus
-        //    {
-        //        EkStatusCode = (int)status,
-        //        JobAutoControlId = orig.Id
-        //    }));
-
-        //    if (!await jobAutoControlService.CommitAsync())
-        //        return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при изменении записи." } }));
-
-
-        //    var updatedObj = await jobAutoControlService.Get()
-        //       .Include(t => t.ApplicationsInWork).ThenInclude(t => t.WorkGroups).ThenInclude(t => t.WorkGroup)
-        //       .Include(t => t.JobEkMasks)
-        //       .Include(t => t.JobAutoControlInEkStatuses).ThenInclude(t => t.EkStatus)
-        //       .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
-
-        //    return Ok(new Response<JobAutoControlResponse>(mapper.Map<JobAutoControlResponse>(updatedObj), true));
-        //}
-
-
-        ///// <summary>
-        ///// Удалить настройки автоматического управления РР
-        ///// </summary>
-        ///// <param name="applicationInWorkId"></param>
-        ///// <returns></returns>
-        //[HttpDelete(ApiRoutes.JobAutoControl.Delete)]
-        //public async Task<IActionResult> Delete([FromRoute] Guid applicationInWorkId)
-        //{
-        //    var obj = await jobAutoControlService.Get().FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
-
-        //    if (obj == null)
-        //        return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при удалении настроект. Не найден настройки с {nameof(applicationInWorkId)}: {applicationInWorkId}" } }));
-
-        //    if (!jobAutoControlService.Delete(obj) || !await jobAutoControlService.CommitAsync())
-        //        return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при удалении настроек." } }));
-
-        //    return NoContent();
-        //}
-
-
-    }
-}

PARR.API/Controllers/V1/ShortcodeApplyController.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using PARR.API.Contracts.V1;
 using PARR.API.Contracts.V1.Requests;
@@ -7,9 +8,11 @@ using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Controllers.V1.Base;
 using PARR.Core.Repositories.Interfaces;
 using PARR.Core.Services.Shortcodes;
+using PARR.Domain.Common.Roles;
 
 namespace PARR.API.Controllers.V1
 {
+    [Authorize(Roles = ParrRoles.Administrator.Role)]
     public class ShortcodeApplyController : BaseApiController
     {
         private readonly ILogger<ShortcodeController> logger;

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

@@ -1,7 +1,6 @@
 using AutoMapper;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using NodaTime;
 using PARR.API.Contracts.V1;
 using PARR.API.Contracts.V1.Requests.BaseRequests;
 using PARR.API.Contracts.V1.Requests.Queries;
@@ -71,8 +70,6 @@ namespace PARR.API.Controllers.V1.Statistics
         }
 
 
-
-
         /// <summary>
         /// Сформировать отчетность
         /// </summary>
@@ -111,6 +108,22 @@ namespace PARR.API.Controllers.V1.Statistics
         }
 
 
+        /// <summary>
+        /// Получить информацию о формировании КЭШ
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(ApiRoutes.Workload.ReportInfo)]
+        public async Task<IActionResult> GetReportInfo()
+        {
+            var report = await workloadService.GetReportInfoAsync();
+
+            var response = mapper.Map<StatWorkloadCacheInfoResponse>(report);
+
+            return Ok(new Response<StatWorkloadCacheInfoResponse>(response, true));
+        }
+
+
+
         /// <summary>
         /// Универсальный метод получения отчетности
         /// </summary>
@@ -124,7 +137,7 @@ namespace PARR.API.Controllers.V1.Statistics
             var report = await workloadService.GetWorkloadReport(reportType, dateStart, durationDays, offset, filter);
 
             if (report == null)
-                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Необходимо сформировать отчетность." } }));
+                return BadRequest(new Response<string?>(null, false, new List<ErrorModel> { new ErrorModel { Message = "Необходимо сформировать отчетность." } }, "empty"));
 
             var resonse = mapper.Map<StatWorkloadReportResponse>(report);
 

PARR.API/Controllers/V1/SyncTaskController.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
 using PARR.API.Contracts.V1;
 using PARR.API.Contracts.V1.Requests;
 using PARR.API.Contracts.V1.Responses.Base;
@@ -8,11 +9,13 @@ using PARR.API.Settings;
 using PARR.Core.Common.Interfaces.RabbitServices;
 using PARR.Core.Services.MatchingStatusService;
 using PARR.Domain.Common.Rabbit.Messages;
+using PARR.Domain.Common.Roles;
 using PARR.Domain.Entities.Base.History;
 using PARR.Domain.Enums;
 
 namespace PARR.API.Controllers.V1
 {
+    [Authorize(Roles = ParrRoles.Administrator.Role)]
     public class SyncTaskController : BaseApiController
     {
         private readonly ILogger<SyncTaskController> logger;

PARR.API/Controllers/V1/TaskController.cs

@@ -0,0 +1,51 @@
+using AutoMapper;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using PARR.API.Contracts.V1;
+using PARR.API.Contracts.V1.Responses;
+using PARR.API.Contracts.V1.Responses.Base;
+using PARR.API.Controllers.V1.Base;
+using PARR.Core.Services.TaskServices.Interfaces;
+using PARR.Domain.Common.Roles;
+using PARR.Domain.Enums;
+
+namespace PARR.API.Controllers.V1
+{
+    /// <summary>
+    /// Контроллер по управлению Task (задания, очереди)
+    /// </summary>
+    [Authorize(Roles = ParrRoles.Administrator.Role)]
+    public class TaskController : BaseApiController
+    {
+        private readonly ITaskManagementService taskManagementService;
+        private readonly IMapper mapper;
+
+        public TaskController(
+                ITaskManagementService taskManagementService,
+                IMapper mapper
+            )
+        {
+            this.taskManagementService = taskManagementService;
+            this.mapper = mapper;
+        }
+
+
+        /// <summary>
+        /// Получить список активных задач (задания, очереди)
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(ApiRoutes.Tasks.GetActiveTasks)]
+        public async Task<IActionResult> GetActiveTasks([FromQuery] TaskTypeEnum? typeCode)
+        {
+            var activeTasks = await taskManagementService.GetActiveTasksAsync(typeCode);
+
+            if (activeTasks.Count == 0)
+                return NoContent();
+
+            var response = mapper.Map<List<ActiveTaskResponse>>(activeTasks);
+
+            return Ok(new Response<List<ActiveTaskResponse>>(response, true));
+        }
+
+    }
+}

PARR.API/Controllers/V1/TaskStatusController.cs

@@ -11,6 +11,9 @@ using PARR.Domain.Common.Roles;
 
 namespace PARR.API.Controllers.V1
 {
+    /// <summary>
+    /// Статусы заданий роботам
+    /// </summary>
     [Authorize(Roles = ParrRoles.EsppRobot.RoleOrAdmin)]
     public class TaskStatusController : BaseApiController
     {
@@ -27,7 +30,7 @@ namespace PARR.API.Controllers.V1
         }
 
         /// <summary>
-        /// Получить список статусов заданий
+        /// Получить список статусов заданий роботам
         /// </summary>
         /// <returns></returns>
         [HttpGet(ApiRoutes.TaskStatus.GetAll)]

PARR.API/Infrastructure/Middleware/GlobalExceptionHandler.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Diagnostics;
+
+namespace PARR.API.Infrastructure.Middleware
+{
+    public class GlobalExceptionHandler//: IExceptionHandler
+    {
+        //todo:
+    }
+}

PARR.API/MappingProfiles/DomainToResponseProfile.cs

@@ -6,6 +6,7 @@ using PARR.API.MappingProfiles.Resolvers;
 using PARR.Core.Repositories.Interfaces.Schedule;
 using PARR.Domain.DTOs.Matching;
 using PARR.Domain.DTOs.Shortcode;
+using PARR.Domain.DTOs.TaskDTO;
 using PARR.Domain.DTOs.Workload;
 using PARR.Domain.Entities;
 using PARR.Domain.Entities.Base.History;
@@ -443,6 +444,29 @@ namespace PARR.API.MappingProfiles
 
             CreateMap<WorkloadDailyItem, WorkloadDailyItemResponse>();
 
+
+
+            CreateMap<WorkloadCacheInfo, StatWorkloadCacheInfoResponse>();
+
+            #endregion
+
+
+            #region Task
+
+            //CreateMap<TaskItemBase, TaskItemBaseResponse>()
+            //    .Include<TaskItemBase, TaskItemResponse>()
+            //    .Include<TaskItemBase, ActiveTaskResponse>();
+
+            //CreateMap<TaskItemBase, TaskItemResponse>();
+
+            CreateMap<ActiveTask, ActiveTaskResponse>();
+                    
+            // ---
+
+            CreateMap<TaskType, TaskItemTypeResponse>();
+
+            CreateMap<PARR.Domain.DTOs.TaskDTO.TaskStatus, TaskItemStatusResponse>();
+
             #endregion
 
         }

PARR.API/appsettings.json

@@ -111,7 +111,7 @@
       }
     ],
     "RabbitMq": {
-      "ThresholdConnections": 28
+      "ThresholdConnections": 29
     }
   }
 }

PARR.Core/Common/Interfaces/IRedisCacheService.cs

@@ -94,6 +94,14 @@
         /// <returns></returns>
         Task<T?> GetHashFieldAsync<T>(string hashKey, string field);
 
+        /// <summary>
+        /// Получить случайную первую запись из Hash
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="hashKey"></param>
+        /// <returns></returns>
+        Task<(string Field, T? Value)?> GetFirstHashFieldAsync<T>(string hashKey);
+
         /// <summary>
         /// Получить все значения из Hash
         /// </summary>

PARR.Core/DependencyInjection.cs

@@ -107,6 +107,8 @@ namespace PARR.Core
             services.AddScoped<WorkloadCacheService>();
             services.AddScoped<IWorkloadService, WorkloadService>();
 
+            services.AddSingleton<IWorkloadIntervalService, WorkloadIntervalService>();
+
             #endregion
 
             #region NextRun

PARR.Core/Infrastructure/Mapping/TaskMappingProfile.cs

@@ -0,0 +1,36 @@
+using AutoMapper;
+using PARR.Domain.DTOs.TaskDTO;
+
+namespace PARR.Core.Infrastructure.Mapping
+{
+    /// <summary>
+    /// Маппинг все что касается Task
+    /// </summary>
+    internal class TaskMappingProfile : Profile
+    {
+        public TaskMappingProfile()
+        {
+            #region TaskItem
+            CreateMap<Domain.Entities.TaskEntities.TaskItem, TaskItemBase>()
+                .Include<Domain.Entities.TaskEntities.TaskItem, Domain.DTOs.TaskDTO.TaskItem>()
+                .Include<Domain.Entities.TaskEntities.TaskItem, Domain.DTOs.TaskDTO.ActiveTask>();
+
+            CreateMap<Domain.Entities.TaskEntities.TaskItem, Domain.DTOs.TaskDTO.TaskItem>();
+            #endregion
+
+            #region ActiveTask
+            CreateMap<Domain.Entities.TaskEntities.TaskItem, ActiveTask>()
+                .ForMember(d => d.Type, o => o.MapFrom(s => s.TaskType))
+                .ForMember(d => d.Status, o => o.MapFrom(s => s.TaskStatus));
+            #endregion
+
+            #region TaskType
+            CreateMap<Domain.Entities.TaskEntities.TaskType, Domain.DTOs.TaskDTO.TaskType>();
+            #endregion
+
+            #region TaskStatus
+            CreateMap<Domain.Entities.TaskEntities.TaskStatus, Domain.DTOs.TaskDTO.TaskStatus>();
+            #endregion
+        }
+    }
+}

PARR.Core/PARR.Core.csproj

@@ -6,10 +6,6 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Folder Include="Infrastructure\" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
     <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.5.2" />

PARR.Core/Services/TaskServices/Implementations/TaskManagementService.cs

@@ -1,11 +1,12 @@
-using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using PARR.Core.Common.Interfaces.RabbitServices;
 using PARR.Core.Repositories.Interfaces.TaskRepositories;
 using PARR.Core.Services.TaskServices.Interfaces;
 using PARR.Domain.Common.Rabbit.Messages;
+using PARR.Domain.DTOs.TaskDTO;
 using PARR.Domain.Entities.Base.History;
-using PARR.Domain.Entities.TaskEntities;
 using PARR.Domain.Enums;
 using PARR.Domain.Settings;
 using System.Text.Encodings.Web;
@@ -19,24 +20,29 @@ namespace PARR.Core.Services.TaskServices.Implementations
         private readonly ITaskTypeRepository taskTypeRepository;
         private readonly ITaskRepository taskRepository;
         private readonly IRabbitService rabbitService;
+        private readonly IMapper mapper;
 
         public TaskManagementService(
                 ILogger<TaskManagementService> logger,
                 ITaskTypeRepository taskTypeRepository,
                 ITaskRepository taskRepository,
-                IRabbitService rabbitService
+                IRabbitService rabbitService,
+                IMapper mapper
             )
         {
             this.logger = logger;
             this.taskTypeRepository = taskTypeRepository;
             this.taskRepository = taskRepository;
             this.rabbitService = rabbitService;
+            this.mapper = mapper;
         }
 
 
         public async Task<Guid> CreateTaskAsync<T>(TaskTypeEnum typeCode, T payload, IHistoryInitiator initiator, IMqSettings mqSettings)
         {
-            var taskType = await taskTypeRepository.Get().AsNoTracking().FirstOrDefaultAsync(t => t.Code == typeCode);
+            var taskType = await taskTypeRepository.Get()
+                                    .AsNoTracking()
+                                    .FirstOrDefaultAsync(t => t.Code == typeCode);
 
             if (taskType == null)
             {
@@ -59,7 +65,7 @@ namespace PARR.Core.Services.TaskServices.Implementations
             var payloadStr = PayloadToString(payload);
 
             // Создаем новую запись задачи
-            var task = new TaskItem
+            var task = new Domain.Entities.TaskEntities.TaskItem
             {
                 Id = Guid.NewGuid(),
                 TypeCode = typeCode,
@@ -99,12 +105,29 @@ namespace PARR.Core.Services.TaskServices.Implementations
         }
 
 
+        public async Task<List<ActiveTask>> GetActiveTasksAsync(TaskTypeEnum? typeCode = null)
+        {
+            var query = taskRepository.Get()
+                            .AsNoTracking()
+                            .Include(t => t.TaskStatus)
+                            .Include(t => t.TaskType)
+                            .Where(t => t.StatusCode == TaskItemStatusEnum.Pending || t.StatusCode == TaskItemStatusEnum.Processing);
+
+            if (typeCode.HasValue)
+                query = query.Where(t => t.TypeCode == typeCode.Value);
+
+            var tasks = await query.OrderByDescending(t => t.DateCreated).ToListAsync();
+
+            return mapper.Map<List<ActiveTask>>(tasks);
+        }
+
+
         /// <summary>
         /// Получить активную singleton задачу указанного типа
         /// </summary>
         /// <param name="typeCode"></param>
         /// <returns></returns>
-        private async Task<TaskItem?> GetActiveSingletonTaskAsync(TaskTypeEnum typeCode)
+        private async Task<Domain.Entities.TaskEntities.TaskItem?> GetActiveSingletonTaskAsync(TaskTypeEnum typeCode)
         {
             return await taskRepository.Get().AsNoTracking()
                                         .FirstOrDefaultAsync(t => t.TypeCode == typeCode && (

PARR.Core/Services/TaskServices/Interfaces/ITaskManagementService.cs

@@ -1,4 +1,5 @@
-using PARR.Domain.Entities.Base.History;
+using PARR.Domain.DTOs.TaskDTO;
+using PARR.Domain.Entities.Base.History;
 using PARR.Domain.Enums;
 using PARR.Domain.Settings;
 
@@ -10,7 +11,8 @@ namespace PARR.Core.Services.TaskServices.Interfaces
     public interface ITaskManagementService
     {
         /// <summary>
-        /// Создать новую задачу в БД и опубликовать в очередь
+        /// Создать новую задачу в БД и опубликовать в очередь.
+        /// В случае ошибок генерирует Exception.
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="typeCode">Тип задачи</param>
@@ -19,5 +21,13 @@ namespace PARR.Core.Services.TaskServices.Interfaces
         /// <param name="mqSettings">Настройки очереди</param>
         /// <returns></returns>
         Task<Guid> CreateTaskAsync<T>(TaskTypeEnum typeCode, T payload, IHistoryInitiator initiator, IMqSettings mqSettings);
+
+
+        /// <summary>
+        /// Получить список активных задач
+        /// </summary>
+        /// <param name="typeCode"></param>
+        /// <returns></returns>
+        Task<List<ActiveTask>> GetActiveTasksAsync(TaskTypeEnum? typeCode = null);
     }
 }

PARR.Core/Services/Workload/Implementations/WorkloadCacheService.cs

@@ -328,6 +328,18 @@ namespace PARR.Core.Services.Workload.Implementations
         }
 
 
+        /// <summary>
+        /// Вернуть первую запись из TamplateCache если есть
+        /// </summary>
+        /// <returns></returns>
+        public async Task<TemplateCache?> GetFirstTemplateCacheAsync()
+        {
+            var cache = await redisCacheService.GetFirstHashFieldAsync<TemplateCache>(redisCacheService.GetKey(cacheTemplateKey));
+
+            return cache?.Value;
+        }
+
+
         /// <summary>
         /// Формирует ключ для отчета Workload
         /// </summary>

PARR.Core/Services/Workload/Implementations/WorkloadIntervalService.cs

@@ -0,0 +1,55 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PARR.Core.Common.Interfaces;
+using PARR.Core.Services.TaskServices.Interfaces;
+using PARR.Core.Services.Workload.Interfaces;
+using PARR.Domain.Entities.Base.History;
+using PARR.Domain.Settings;
+
+namespace PARR.Core.Services.Workload.Implementations
+{
+    internal class WorkloadIntervalService : IWorkloadIntervalService
+    {
+        private readonly ILogger<WorkloadIntervalService> logger;
+        private readonly IIntervalService intervalService;
+        private readonly IServiceProvider serviceProvider;
+
+        public WorkloadIntervalService(
+                ILogger<WorkloadIntervalService> logger,
+                IIntervalService intervalService,
+                IServiceProvider serviceProvider
+            )
+        {
+            this.logger = logger;
+            this.intervalService = intervalService;
+            this.serviceProvider = serviceProvider;
+        }
+
+        public async Task StartAsync(TimeSpan interval, IMqSettings mqSettings)
+        {
+            logger.LogInformation("Запуск сервиса формирования кэш отчетов Workload по интервалу.");
+
+            await intervalService.IntervalInitAsync(async () =>
+            {
+
+                await using (var scope = serviceProvider.CreateAsyncScope())
+                {
+                    var taskManagementService = scope.ServiceProvider.GetRequiredService<ITaskManagementService>();
+
+                    var initiator = new HistoryInitiator { InitiatorParrComponentId = Domain.Enums.ParrComponentsEnum.WorkloadBuilder, InitiatorComment = $"Генерация кэш workload по интервалу '{interval}'" };
+
+                    try
+                    {
+                        var taskId = await taskManagementService.CreateTaskAsync<object?>(Domain.Enums.TaskTypeEnum.Workload, default, initiator, mqSettings);
+                        logger.LogInformation("Создана задача {taskId} на формирование кэш отчета.", taskId);
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.LogError(ex, "Ошибка при отправке задания на формирование кэш отчета.");
+                    }
+                }
+
+            }, interval);
+        }
+    }
+}

PARR.Core/Services/Workload/Implementations/WorkloadService.cs

@@ -1,7 +1,9 @@
 using Microsoft.Extensions.Logging;
 using PARR.Core.Services.NextRunServices;
+using PARR.Core.Services.TaskServices.Interfaces;
 using PARR.Core.Services.Workload.Interfaces;
 using PARR.Core.Services.Workload.Models;
+using PARR.Domain.DTOs.TaskDTO;
 using PARR.Domain.DTOs.Workload;
 using PARR.Domain.Enums;
 
@@ -12,16 +14,19 @@ namespace PARR.Core.Services.Workload.Implementations
         private readonly ILogger<WorkloadService> logger;
         private readonly WorkloadCacheService workloadCacheService;
         private readonly INextRunService nextRunService;
+        private readonly ITaskManagementService taskManagementService;
 
         public WorkloadService(
                 ILogger<WorkloadService> logger,
                 WorkloadCacheService workloadCacheService,
-                INextRunService nextRunService
+                INextRunService nextRunService,
+                ITaskManagementService taskManagementService
             )
         {
             this.logger = logger;
             this.workloadCacheService = workloadCacheService;
             this.nextRunService = nextRunService;
+            this.taskManagementService = taskManagementService;
         }
 
 
@@ -107,6 +112,39 @@ namespace PARR.Core.Services.Workload.Implementations
             return report;
         }
 
+
+        public async Task<WorkloadCacheInfo> GetReportInfoAsync()
+        {
+            // может быть три статуса
+            // 1 - отчет сейчас формируется (дата начала формирования отчета)
+            // 2 - отчет сформирован (вернуть дату формирования кэш)
+            // 3 - отчет сейчас не формируется, кэша нет (date = null)
+
+
+            // 1. проверить что выполнились все задания на обновление кэш
+            var activeTasks = await taskManagementService.GetActiveTasksAsync(TaskTypeEnum.Workload);
+            if (activeTasks.Count > 0)
+            {
+                // идет формирование отчета
+                // задача может быт только одна, так как у нее такой тип
+                var task = activeTasks.First();
+
+                return new WorkloadCacheInfo { Status = WorkloadCacheInfo.StatusEnum.Processing, Date = task.DateCreated };
+            }
+
+            // 2. получить дату кэш
+            // Если нет активных задач, значит может быть кэш существует, пробуем получить дату из кэш
+            var templateCache = await workloadCacheService.GetFirstTemplateCacheAsync();
+            if (templateCache != null)
+            {
+                return new WorkloadCacheInfo { Status = WorkloadCacheInfo.StatusEnum.Generated, Date = templateCache.Timestamp };
+            }
+
+            // Если кэш нет, то возвращаем null    
+            return new WorkloadCacheInfo { Status = WorkloadCacheInfo.StatusEnum.NotFound };
+        }
+
+
         /// <summary>
         /// Получить список дней для отчета, с отметкой выходной/рабочий
         /// </summary>
@@ -115,7 +153,7 @@ namespace PARR.Core.Services.Workload.Implementations
         /// <returns></returns>
         private async Task<List<WorkloadDayItem>> GetReportDays(DateOnly dateStart, int durationDays)
         {
-            var dateEnd = dateStart.AddDays(durationDays);
+            var dateEnd = dateStart.AddDays(durationDays - 1);
             var days = await nextRunService.GetWorkDaysAsync(dateStart, dateEnd, false);
             var weekends = await nextRunService.GetWeekendsAsync(dateStart, dateEnd);
 

PARR.Core/Services/Workload/Interfaces/IWorkloadIntervalService.cs

@@ -0,0 +1,18 @@
+using PARR.Domain.Settings;
+
+namespace PARR.Core.Services.Workload.Interfaces
+{
+    /// <summary>
+    /// Формирование кэш отчетов по интервалу
+    /// </summary>
+    public interface IWorkloadIntervalService
+    {
+        /// <summary>
+        /// Запуск формирования по интервалу
+        /// </summary>
+        /// <param name="interval">Интервал</param>
+        /// <param name="mqSettings">Настройки очереди куда отправлять задание</param>
+        /// <returns></returns>
+        Task StartAsync(TimeSpan interval, IMqSettings mqSettings);
+    }
+}

PARR.Core/Services/Workload/Interfaces/IWorkloadService.cs

@@ -8,6 +8,12 @@ namespace PARR.Core.Services.Workload.Interfaces
     /// </summary>
     public interface IWorkloadService
     {
+        /// <summary>
+        /// Получить статус кэш/отчета
+        /// </summary>
+        /// <returns></returns>
+        Task<WorkloadCacheInfo> GetReportInfoAsync();
+
         /// <summary>
         /// Получить отчет о загруженности
         /// </summary>

PARR.DAL/Context/DataContext.cs

@@ -518,7 +518,8 @@ namespace PARR.DAL.Context
                     new() { Id = ParrComponentsEnum.NextRun, Name = ParrComponentsEnum.NextRun.ToString(), Description = "Рассчет даты следующего срабатывания" },
                     new() { Id = ParrComponentsEnum.TemplateActivator, Name = ParrComponentsEnum.TemplateActivator.ToString(), Description = "Активатор шаблонов / расписаний" },
                     new() { Id = ParrComponentsEnum.TemplateDistributor, Name = ParrComponentsEnum.TemplateDistributor.ToString(), Description = "Автораспределение РР" },
-                    new() { Id = ParrComponentsEnum.TemplateTaskGenerator, Name = ParrComponentsEnum.TemplateTaskGenerator.ToString(), Description = "Генератор шаблонов" }
+                    new() { Id = ParrComponentsEnum.TemplateTaskGenerator, Name = ParrComponentsEnum.TemplateTaskGenerator.ToString(), Description = "Генератор шаблонов" },
+                    new() { Id = ParrComponentsEnum.WorkloadBuilder, Name = ParrComponentsEnum.WorkloadBuilder.ToString(), Description = "Генератор кэша отчетов workload" }
                     );
             });
 
@@ -579,7 +580,7 @@ namespace PARR.DAL.Context
             {
                 f.HasData(new Domain.Entities.TaskEntities.TaskType[]
                     {
-                        new() { Code = TaskTypeEnum.Workload, Name = TaskTypeEnum.Workload.ToString(), Description = "Формирование данных для отчетности - Загруженность", MaxRetries = 2, IsSingleton=true, MaxExecutionTimeMinutes=60, RetentionDays=90 }
+                        new() { Code = TaskTypeEnum.Workload, Name = TaskTypeEnum.Workload.ToString(), Description = "Формирование данных для отчетности - Загруженность", MaxRetries = 2, IsSingleton=true, MaxExecutionTimeMinutes=90, RetentionDays=90 }
                     }
                 );
             });

PARR.Domain/Cache/Models/Base/IBaseCache.cs

@@ -5,10 +5,19 @@
     /// </summary>
     public interface IBaseCache<T>
     {
+        /// <summary>
+        /// Объект
+        /// </summary>
         public T Data { get; set; }
-
+        
+        /// <summary>
+        /// Дата формирования Cache
+        /// </summary>
         public DateTimeOffset Timestamp { get; set; }
 
+        /// <summary>
+        /// Источник Cache (class)
+        /// </summary>
         public string Source { get; set; }
     }
 }

PARR.Domain/DTOs/TaskDTO/ActiveTask.cs

@@ -0,0 +1,12 @@
+namespace PARR.Domain.DTOs.TaskDTO
+{
+    /// <summary>
+    /// DTO
+    /// </summary>
+    public record ActiveTask : TaskItemBase
+    {
+        public required TaskType Type { get; init; }
+
+        public required TaskStatus Status { get; init; }
+    }
+}

PARR.Domain/DTOs/TaskDTO/TaskItem.cs

@@ -0,0 +1,26 @@
+namespace PARR.Domain.DTOs.TaskDTO
+{
+    /// <summary>
+    /// DTO
+    /// </summary>
+    public record TaskItemBase
+    {
+        public Guid Id { get; init; }
+
+        public DateTimeOffset DateCreated { get; init; }
+
+        public DateTimeOffset? DateModified { get; init; }
+
+        public int RetryCount { get; init; }
+
+        public DateTimeOffset? ProcessedAt { get; init; }
+    }
+
+    /// <summary>
+    /// DTO
+    /// </summary>
+    public record TaskItem : TaskItemBase
+    {
+        //todo:
+    }
+}

PARR.Domain/DTOs/TaskDTO/TaskStatus.cs

@@ -0,0 +1,16 @@
+using PARR.Domain.Enums;
+
+namespace PARR.Domain.DTOs.TaskDTO
+{
+    /// <summary>
+    /// DTO
+    /// </summary>
+    public record TaskStatus
+    {
+        public TaskItemStatusEnum Code { get; init; }
+
+        public required string Name { get; init; }
+
+        public required string Description { get; init; }
+    }
+}

PARR.Domain/DTOs/TaskDTO/TaskType.cs

@@ -0,0 +1,36 @@
+using PARR.Domain.Enums;
+
+namespace PARR.Domain.DTOs.TaskDTO
+{
+    /// <summary>
+    /// DTO
+    /// </summary>
+    public record TaskType
+    {
+        public TaskTypeEnum Code { get; init; }
+
+        public required string Name { get; init; }
+
+        public required string Description { get; init; }
+
+        /// <summary>
+        /// Максимальное кол-во попыток
+        /// </summary>
+        public int MaxRetries { get; init; }
+
+        /// <summary>
+        /// Максимальное время выполнения
+        /// </summary>
+        public int MaxExecutionTimeMinutes { get; init; }
+
+        /// <summary>
+        /// Одновременно может быть только одна задача или несколько
+        /// </summary>
+        public bool IsSingleton { get; init; }
+
+        /// <summary>
+        /// Сколько дней хранить в БД
+        /// </summary>
+        public int RetentionDays { get; init; }
+    }
+}

PARR.Domain/DTOs/Workload/WorkloadCacheInfo.cs

@@ -0,0 +1,36 @@
+using System.Text.Json.Serialization;
+
+namespace PARR.Domain.DTOs.Workload
+{
+    /// <summary>
+    /// Инфо о состоянии КЭШ для отчета Workload
+    /// </summary>
+    public record WorkloadCacheInfo
+    {
+        /// <summary>
+        /// Статус отчета
+        /// </summary>
+        [JsonConverter(typeof(JsonStringEnumConverter))]
+        public enum StatusEnum
+        {
+            /// <summary>
+            /// Отчет формируется
+            /// </summary>
+            Processing = 1,
+
+            /// <summary>
+            /// Отчет сформирован
+            /// </summary>
+            Generated = 2,
+
+            /// <summary>
+            /// Нет отчета
+            /// </summary>
+            NotFound = 3
+        }
+
+        public StatusEnum Status { get; init; }
+
+        public DateTimeOffset? Date { get; init; }
+    }
+}

PARR.Domain/Enums/ParrComponentsEnum.cs

@@ -79,6 +79,11 @@ namespace PARR.Domain.Enums
         /// <summary>
         /// Генератор Template
         /// </summary>
-        TemplateTaskGenerator = 13
+        TemplateTaskGenerator = 13,
+
+        /// <summary>
+        /// Генератор кэша отчетов Workload
+        /// </summary>
+        WorkloadBuilder = 14
     }
 }

PARR.Infrastructure/Redis/RedisCacheService.cs

@@ -213,6 +213,38 @@ namespace PARR.Infrastructure.Redis
             return JsonSerializer.Deserialize<T>(value);
         }
 
+        public async Task<(string Field, T? Value)?> GetFirstHashFieldAsync<T>(string hashKey)
+        {
+            logger.LogDebug("Запрос первого поля из хеша '{HashKey}'", hashKey);
+
+            int attempts = 0;
+            int maxAttempts = 5;
+
+            await foreach (var entry in redis.HashScanAsync(hashKey, pageSize: 1))
+            {
+                if (++attempts > maxAttempts)
+                {
+                    logger.LogWarning("Превышен лимит попыток ({Max}) для хеша '{HashKey}'", maxAttempts, hashKey);
+                    return null;
+                }
+
+                if (entry.Value.IsNullOrEmpty)
+                {
+                    logger.LogDebug("Поле '{Field}' в хеше '{HashKey}' пустое, пропускаем", entry.Name, hashKey);
+                    continue;
+                }
+
+                var deserialized = JsonSerializer.Deserialize<T>(entry.Value);
+
+                logger.LogDebug("Получено поле '{Field}' из хеша '{HashKey}', тип: {Type}", entry.Name, hashKey, typeof(T).Name);
+
+                return (entry.Name.ToString(), deserialized);
+            }
+
+            logger.LogDebug("Хеш '{HashKey}' пуст или не существует", hashKey);
+            return null;
+        }
+
         public async Task<Dictionary<string, T>> GetAllHashFieldsAsync<T>(string hashKey)
         {
             // получить все записи из Hash

PARR.WorkloadBuilderWorker/IntervalWorker.cs

@@ -0,0 +1,25 @@
+using PARR.Core.Services.Workload.Interfaces;
+using PARR.WorkloadBuilderWorker.Settings;
+
+namespace PARR.WorkloadBuilderWorker
+{
+    public class IntervalWorker : BackgroundService
+    {
+        private readonly ILogger<IntervalWorker> logger;
+        private readonly IWorkloadIntervalService workloadIntervalService;
+        private readonly WorkerSettings workerSettings;
+
+        public IntervalWorker(ILogger<IntervalWorker> logger, IWorkloadIntervalService workloadIntervalService, WorkerSettings workerSettings)
+        {
+            this.logger = logger;
+            this.workloadIntervalService = workloadIntervalService;
+            this.workerSettings = workerSettings;
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            logger.LogInformation("Запуск {workerName}", nameof(IntervalWorker));
+            await workloadIntervalService.StartAsync(workerSettings.RepeatEvery, workerSettings.MqSettings);
+        }
+    }
+}

PARR.WorkloadBuilderWorker/Program.cs

@@ -46,8 +46,25 @@ builder.Configuration.AddDalConfigurations(builder.Services);
 builder.Services.AddDallSettings(builder.Configuration);
 #endregion
 
+// Задается через переменные окружеия
+var runRabbit = builder.Configuration.GetValue<bool>("ENABLE_RABBIT", true);
+var runInterval = builder.Configuration.GetValue<bool>("ENABLE_INTERVAL", true);
 
-builder.Services.AddHostedService<Worker>();
+if (runRabbit)
+{
+    builder.Services.AddHostedService<RabbitWorker>();
+}
+
+if (runInterval)
+{
+    builder.Services.AddHostedService<IntervalWorker>();
+}
+
+// Настройка краша при ошибке. Если хоть один из воркеров упадет, то падает целиком проект
+builder.Services.Configure<HostOptions>(options =>
+{
+    options.BackgroundServiceExceptionBehavior = BackgroundServiceExceptionBehavior.StopHost;
+});
 
 var host = builder.Build();
 host.Run();

PARR.WorkloadBuilderWorker/RabbitWorker.cs

@@ -3,13 +3,15 @@ using PARR.WorkloadBuilderWorker.Settings;
 
 namespace PARR.WorkloadBuilderWorker
 {
-    public class Worker : BackgroundService
+    public class RabbitWorker : BackgroundService
     {
+        private readonly ILogger<RabbitWorker> logger;
         private readonly IWorkloadCacheBuilderService workloadCacheBuilderService;
         private readonly WorkerSettings workerSettings;
 
-        public Worker(ILogger<Worker> logger, IWorkloadCacheBuilderService workloadCacheBuilderService, WorkerSettings WorkerSettings)
+        public RabbitWorker(ILogger<RabbitWorker> logger, IWorkloadCacheBuilderService workloadCacheBuilderService, WorkerSettings WorkerSettings)
         {
+            this.logger = logger;
             this.workloadCacheBuilderService = workloadCacheBuilderService;
             this.workerSettings = WorkerSettings;
         }
@@ -17,6 +19,7 @@ namespace PARR.WorkloadBuilderWorker
 
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
+            logger.LogInformation("Запуск {workerName}", nameof(RabbitWorker));
             await workloadCacheBuilderService.ProcessMessagesAsync(workerSettings.MqSettings);
         }
 

PARR.WorkloadBuilderWorker/Settings/WorkerSettings.cs

@@ -4,6 +4,14 @@ namespace PARR.WorkloadBuilderWorker.Settings
 {
     public record WorkerSettings
     {
+        /// <summary>
+        /// Настройки MQ
+        /// </summary>
         public MqSettingsBase MqSettings { get; init; } = new();
+
+        /// <summary>
+        /// Интервал повторений
+        /// </summary>
+        public TimeSpan RepeatEvery { get; init; }
     }
 }

PARR.WorkloadBuilderWorker/appsettings.json

@@ -28,6 +28,7 @@
       "QueueName": "parr-task-workload",
       "User": "task_workload_reader",
       "Password": "sdjfgIYFdifyKJFDhvsad@!314d"
-    }
+    },
+    "RepeatEvery": "12:00:00"
   }
 }

docker-compose.dcproj

@@ -9,6 +9,7 @@
     <DockerServiceName>parr.api</DockerServiceName>
   </PropertyGroup>
   <ItemGroup>
+    <None Include="docker-compose.task-reconciliation.yml" />
     <None Include="docker-compose.template-matcher.yml" />
     <None Include="docker-compose.template-generator.yml" />
     <None Include="docker-compose.aihit-loader.yml" />
@@ -25,6 +26,7 @@
     <None Include="docker-compose.template-activator.yml" />
     <None Include="docker-compose.template-distributor.yml" />
     <None Include="docker-compose.template-updater.yml" />
+    <None Include="docker-compose.workload-builder.yml" />
     <None Include="docker-compose.yml" />
     <None Include=".dockerignore" />
     <None Include="stack.yml" />

docker-compose.workload-builder.yml

@@ -2,11 +2,13 @@ version: '3.4'
 
 # workload builder
 services:
-  parr-workload-builder:
+  parr-workload-builder-interval:
     image: harbor.dvgd.rzd/parr/parr-workload-builder:${tag:-latest}
     environment:
       - ASPNETCORE_ENVIRONMENT=Production
       - TZ=Europe/Moscow
+      - ENABLE_RABBIT=false
+      - ENABLE_INTERVAL=true
     logging:
       driver: fluentd
       options:
@@ -15,7 +17,28 @@ services:
         fluentd-max-retries: '30'
         fluentd-async: 'true'
         fluentd-buffer-limit: '52428800'
-        tag: parr.workload-builder.serilog
+        tag: parr.workload-builder-interval.serilog
+    deploy:
+      replicas: 1
+    networks:
+      - parr-network
+
+  parr-workload-builder-rabbit:
+    image: harbor.dvgd.rzd/parr/parr-workload-builder:${tag:-latest}
+    environment:
+      - ASPNETCORE_ENVIRONMENT=Production
+      - TZ=Europe/Moscow
+      - ENABLE_RABBIT=true
+      - ENABLE_INTERVAL=false
+    logging:
+      driver: fluentd
+      options:
+        fluentd-address: dvgd-efk-01.dvgd.oao.rzd:24224
+        fluentd-retry-wait: '10s'
+        fluentd-max-retries: '30'
+        fluentd-async: 'true'
+        fluentd-buffer-limit: '52428800'
+        tag: parr.workload-builder-rabbit.serilog
     deploy:
       replicas: 1
     networks: