mikhail/parr_api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'report' into dev

Browse Source
This commit is contained in:
Mikhail Trubnikov
2026-05-19 09:51:51 +10:00
parent b267dfe7c5 178d136dba
commit edc96bda33
43 changed files with 695 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
PARR.Core/Common/Interfaces/IRedisCacheService.cs
View File

@@ -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>

2
PARR.Core/DependencyInjection.cs
View File

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

36
PARR.Core/Infrastructure/Mapping/TaskMappingProfile.cs Normal file
View File

@@ -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
}
}
}

4
PARR.Core/PARR.Core.csproj
View File

@@ -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" />

35
PARR.Core/Services/TaskServices/Implementations/TaskManagementService.cs
View File

@@ -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 && (

14
PARR.Core/Services/TaskServices/Interfaces/ITaskManagementService.cs
View File

@@ -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);
}
}

12
PARR.Core/Services/Workload/Implementations/WorkloadCacheService.cs
View File

@@ -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>

55
PARR.Core/Services/Workload/Implementations/WorkloadIntervalService.cs Normal file
View File

@@ -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);
}
}
}

42
PARR.Core/Services/Workload/Implementations/WorkloadService.cs
View File

@@ -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);

18
PARR.Core/Services/Workload/Interfaces/IWorkloadIntervalService.cs Normal file
View File

@@ -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);
}
}

6
PARR.Core/Services/Workload/Interfaces/IWorkloadService.cs
View File

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