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

feat(dal): RedisCacheService - работа с Hash объектами

Browse Source
This commit is contained in:
Mikhail Trubnikov
2026-03-17 13:50:06 +10:00
parent 3f013e2bfc
commit 547cb894be
5 changed files with 200 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
PARR.API/Contracts/V1/ApiRoutes.cs
View File

@@ -49,20 +49,7 @@
public const string GetNextRun = Base + "/tests/next-run";
public const string GetNextScheduleDate = Base + "/tests/next-schedule-date/" + paramApplicationInWorkId + "/" + paramDate;
public const string GetNextSchedule = Base + "/tests/next-schedule/" + paramApplicationInWorkId + "/" + paramDate;
public const string CreateCache = Base + "/tests/cache/";
public const string IsWorkDay = Base + "/tests/is-work-day/";
public const string TestHandler = Base + "/tests/test/";
public const string GetWorkDay = Base + "/tests/get-work-day/{date}";
public const string paramDate = "{lastRunDate}";
public const string paramApplicationInWorkId = "{applicationInWorkId}";
}
public static class Template

163
PARR.API/Controllers/V1/TestController.cs
View File

@@ -1,16 +1,12 @@
using AutoMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Responses.Base;
using PARR.API.Controllers.V1.Base;
using PARR.API.Services.Interfaces;
using PARR.DAL.Cache.Services.Base;
using PARR.DAL.DomainServices.UnitFilterService;
using PARR.DAL.NextRunServices;
using PARR.DAL.Services.Interfaces;
using PARR.DAL.Services.Interfaces.Job;
using PARR.DAL.Services.Interfaces.Unit;
namespace PARR.API.Controllers.V1
@@ -19,43 +15,19 @@ namespace PARR.API.Controllers.V1
public class TestController : BaseApiController
{
private readonly IClientService clientService;
//private readonly IEsppScheduleTransformService esppScheduleTransformService;
private readonly IRedisCacheService redisCacheService;
private readonly IWeekendDayService weekendDayService;
private readonly IUnitService unitService;
private readonly IFieldFilterService fieldFilterService;
private readonly IJobService jobService;
private readonly IJobUnitFilterService jobUnitFilterService;
private readonly IUnitFilterService unitFilterService;
private readonly IMapper mapper;
private readonly INextRunService nextRunService;
private readonly ITemplateService templateService;
public TestController(
IClientService clientService,
//IEsppScheduleTransformService esppScheduleTransformService,
IRedisCacheService redisCacheService,
IWeekendDayService weekendDayService,
IUnitService unitService,
IFieldFilterService fieldFilterService,
IJobService jobService,
IJobUnitFilterService jobUnitFilterService,
IUnitFilterService unitFilterService,
IMapper mapper,
INextRunService nextRunService,
ITemplateService templateService
)
{
this.clientService = clientService;
//this.esppScheduleTransformService = esppScheduleTransformService;
this.redisCacheService = redisCacheService;
this.weekendDayService = weekendDayService;
this.unitService = unitService;
this.fieldFilterService = fieldFilterService;
this.jobService = jobService;
this.jobUnitFilterService = jobUnitFilterService;
this.unitFilterService = unitFilterService;
this.mapper = mapper;
this.nextRunService = nextRunService;
this.templateService = templateService;
}
@@ -92,124 +64,47 @@ namespace PARR.API.Controllers.V1
}
///// <summary>
///// Получить следующую дату запуска
///// </summary>
///// <param name="applicationInWorkId"></param>
///// <param name="lastRunDate"></param>
///// <returns></returns>
//[HttpGet(ApiRoutes.Test.GetNextScheduleDate)]
//public async Task<IActionResult> GetNextScheduleDate([FromRoute] Guid applicationInWorkId, [FromRoute] DateTimeOffset lastRunDate)
//{
// var result = await esppScheduleTransformService.GetNextDateAsync(applicationInWorkId, lastRunDate);
// return Ok(result);
//}
///// <summary>
///// Получить следующее расписание
///// Записать в кэш
///// </summary>
///// <param name="applicationInWorkId"></param>
///// <param name="lastRunDate"></param>
///// <param name="request"></param>
///// <returns></returns>
//[HttpGet(ApiRoutes.Test.GetNextSchedule)]
//public async Task<IActionResult> GetNextSchedule([FromRoute] Guid applicationInWorkId, [FromRoute] DateTimeOffset lastRunDate)
//[HttpPost(ApiRoutes.Test.CreateCache)]
//public async Task<IActionResult> CreateCache()
//{
// var result = await esppScheduleTransformService.GetNextScheduleAsync(applicationInWorkId, lastRunDate);
// return Ok(result);
// var hashKey = redisCacheService.GetKey(new[] { "test", "mxa" });
// var ttl = TimeSpan.FromMinutes(10);
// await redisCacheService.SetHashFieldAsync(hashKey, "t1", "val1", ttl);
// await redisCacheService.SetHashFieldAsync(hashKey, "t2", "val2");
// await redisCacheService.SetHashFieldAsync(hashKey, "t3", "val3");
// var length = await redisCacheService.GetHashLengthAsync(hashKey);
// var get = await redisCacheService.GetHashFieldAsync<string>(hashKey, "t1");
// var getAll = await redisCacheService.GetAllHashFieldsAsync<string>(hashKey);
// await redisCacheService.DeleteHashFieldAsync(hashKey, "t1");
// var getT1 = await redisCacheService.GetHashFieldAsync<string>(hashKey, "t1");
// var exist = await redisCacheService.HashFieldExistsAsync(hashKey, "t2");
// await redisCacheService.DeleteHashAsync(hashKey);
// var getT_1 = await redisCacheService.GetHashFieldAsync<string>(hashKey, "t1");
// await redisCacheService.SetHashTtlAsync(hashKey, ttl);
// return Ok();
//}
/// <summary>
/// Записать в кэш и получить обратно значение из кэша
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost(ApiRoutes.Test.CreateCache)]
public async Task<IActionResult> CreateCache([FromBody] CaheRequestTest request)
{
await redisCacheService.SetCachedDataAsync(request.Key, request, TimeSpan.FromMinutes(1));
var fromCache = await redisCacheService.GetCachedDataAsync<CaheRequestTest>(request.Key);
return Ok(new { fromCache });
}
/// <summary>
/// Проверка, это рабочий день?
/// </summary>
/// <param name="date"></param>
/// <returns></returns>
[HttpGet(ApiRoutes.Test.IsWorkDay)]
public async Task<IActionResult> IsWorkDay([FromQuery] DateOnly date)
{
return Ok(await weekendDayService.IsWorkDayAsync(date, true));
}
/// <summary>
/// Тестовый метод
/// </summary>
/// <returns></returns>
[HttpGet(ApiRoutes.Test.TestHandler)]
public async Task<IActionResult> Test()
{
//var job = new Job
//{
// Id = Guid.NewGuid(),
// Name = "ВИ-VMWARE ТО-1 Мониторинг и анализ работы виртуальной инфраструктуры",
// DateCreated = DateTimeOffset.Now,
// TemplateNameMask = "ЭИТИ_%РГ%_%ТНК%_%ЭК%",
// TnkId = Guid.Parse("9b7e0251-cb13-427c-ac71-16baa2a111dd")
//};
//var jobDetails = new JobDetails {
// Id = Guid.NewGuid(),
// UnitFilter = "ВРТ-VMWARE-*",
// JobId = job.Id,
// ShortDescription = "Мониторинг и анализ работы виртуальной инфраструктуры",
// FullDescription = "Проверка журналов (лог-файла) событий (warning, alarm) объектов виртуальной инфраструктуры (ВМ, хост, кластер, датацентр, virtual center и др.)",
// Solution = "Работы проведены",
// Duration = "7 00:00:00",
// ReferenceDate = new DateTimeOffset(2026,01,01,00,00,00,new TimeSpan(0))
//};
//var fieldFilter = new FieldFilter
//{
// Id = Guid.NewGuid(),
// JobDetailsId = jobDetails.Id,
// FieldId = Guid.Parse("08b42860-09a7-4a1f-aa4f-0290e86df884"),
// ValueMask = "виртуальный комплекс"
//};
////await jobService.CreateAsync(job);
////await jobService.CommitAsync();
//if (await jobService.CreateAsync(job))
// if (await jobDetailsService.CreateAsync(jobDetails))
// if (await fieldFilterService.CreateAsync(fieldFilter))
// await jobService.CommitAsync();
//var unit = await unitService.Get().Include(t => t.Parents).Include(t => t.Childs).FirstOrDefaultAsync(t => t.Id == Guid.Parse("01fda0bd-3423-4b12-965b-2947153d1d87"));
//var parent = unit?.Parents;
//var child = unit?.Childs;
return Ok();
}
//[HttpGet(ApiRoutes.Test.GetWorkDay)]
//public async Task<IActionResult> GetWorkDay([FromRoute] DateTimeOffset date)
//{
// var result = await esppScheduleTransformService.GetWorkDayAsync(date);
// return Ok(result);
//}
}
public class CaheRequestTest
{
public required string Key { get; set; }
public required string Value { get; set; }
}
}

70
PARR.DAL/Cache/Services/Base/IRedisCacheService.cs
View File

@@ -57,5 +57,75 @@
/// <param name="isUseHash"></param>
/// <returns></returns>
string GetKey(string[] keyParts, bool isUseHash = false);
#region Работа с Hash
/// <summary>
/// Изменить одно поле в Hash
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="hashKey"></param>
/// <param name="field"></param>
/// <param name="value"></param>
/// <param name="ttl">Если указано, обновится у всего Hash. Если не указано и hash не существовал, создастся Hash с бесокнечным ttl</param>
/// <returns></returns>
Task SetHashFieldAsync<T>(string hashKey, string field, T value, TimeSpan? ttl = null);
/// <summary>
/// Получить значение поля из Hash
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="hashKey"></param>
/// <param name="field"></param>
/// <returns></returns>
Task<T?> GetHashFieldAsync<T>(string hashKey, string field);
/// <summary>
/// Получить все значения из Hash
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="hashKey"></param>
/// <returns></returns>
Task<Dictionary<string, T>> GetAllHashFieldsAsync<T>(string hashKey);
/// <summary>
/// Удалить одну запись из Hash
/// </summary>
/// <param name="hashKey"></param>
/// <param name="field"></param>
/// <returns></returns>
Task DeleteHashFieldAsync(string hashKey, string field);
/// <summary>
/// Есть ли запись в Hash
/// </summary>
/// <param name="hashKey"></param>
/// <param name="field"></param>
/// <returns></returns>
Task<bool> HashFieldExistsAsync(string hashKey, string field);
/// <summary>
/// Удалить весь Hash
/// </summary>
/// <param name="hashKey"></param>
/// <returns></returns>
Task DeleteHashAsync(string hashKey);
/// <summary>
/// Получить количество записей в Hash
/// </summary>
/// <param name="hashKey"></param>
/// <returns></returns>
Task<long> GetHashLengthAsync(string hashKey);
/// <summary>
/// Установить TTL для Hash
/// </summary>
/// <param name="hashKey"></param>
/// <param name="ttl"></param>
/// <returns></returns>
Task SetHashTtlAsync(string hashKey, TimeSpan ttl);
#endregion
}
}

92
PARR.DAL/Cache/Services/Base/RedisCacheService.cs
View File

@@ -1,17 +1,26 @@
using Microsoft.Extensions.Caching.Distributed;
using StackExchange.Redis;
using System.Text.Json;
using static System.Runtime.InteropServices.JavaScript.JSType;
namespace PARR.DAL.Cache.Services.Base
{
internal class RedisCacheService : IRedisCacheService
{
private readonly IDistributedCache cache;
private readonly IDatabase redis;
public RedisCacheService(IDistributedCache cache)
public RedisCacheService(
IDistributedCache cache,
IConnectionMultiplexer connectionMultiplexer
)
{
this.cache = cache;
this.redis = connectionMultiplexer.GetDatabase();
}
#region Распределенный кэш IDistributedCache
public async Task<T?> GetCachedDataAsync<T>(string key)
{
var jsonData = await cache.GetStringAsync(key);
@@ -69,6 +78,85 @@ namespace PARR.DAL.Cache.Services.Base
cache.Remove(key);
}
#endregion
#region Нативные операции Redis, Redis Hash
public async Task SetHashFieldAsync<T>(string hashKey, string field, T value, TimeSpan? ttl = null)
{
// меняет одно поле в Hash
var jsonData = JsonSerializer.Serialize(value);
// true - поля не было, создалось новое. false - поле было, обновили значение
var result = await redis.HashSetAsync(hashKey, field, jsonData);
// если указан ttl, обновим для всего Hash
// если не указан и ранее был создан hashKey, оставит его ttl; а если hashKey не было, то создаст его БЕССРОЧНЫМ!!!
if (ttl.HasValue)
await SetHashTtlAsync(hashKey, ttl.Value);
}
public async Task<T?> GetHashFieldAsync<T>(string hashKey, string field)
{
// получить значение поля из Hash
var value = await redis.HashGetAsync(hashKey, field);
if (value.IsNullOrEmpty)
return default;
return JsonSerializer.Deserialize<T>(value);
}
public async Task<Dictionary<string, T>> GetAllHashFieldsAsync<T>(string hashKey)
{
// получить все записи из Hash
var objs = await redis.HashGetAllAsync(hashKey);
if (objs.Length == 0)
return new Dictionary<string, T>();
var result = objs.ToDictionary(
t => t.Name.ToString(),
t => JsonSerializer.Deserialize<T>(t.Value)
);
return result!;
}
public async Task DeleteHashFieldAsync(string hashKey, string field)
{
// удалить запись из Hash
await redis.HashDeleteAsync(hashKey, field);
}
public async Task<bool> HashFieldExistsAsync(string hashKey, string field)
{
// есть ли запись в Hash
return await redis.HashExistsAsync(hashKey, field);
}
public async Task DeleteHashAsync(string hashKey)
{
// удалить весь Hash
await redis.KeyDeleteAsync(hashKey);
}
public async Task<long> GetHashLengthAsync(string hashKey)
{
// кол-во записей в hash
return await redis.HashLengthAsync(hashKey);
}
public async Task SetHashTtlAsync(string hashKey, TimeSpan ttl)
{
// Установить ttl для Hash
await redis.KeyExpireAsync(hashKey, ttl);
}
#endregion
#region Helpers
public string GetKey(string[] keyParts, bool isUseHash = false)
{
@@ -91,5 +179,7 @@ namespace PARR.DAL.Cache.Services.Base
return keyStr;
}
#endregion
}
}

11
PARR.DAL/ParrDalInstaller.cs
View File

@@ -24,6 +24,7 @@ using PARR.DAL.Services.Interfaces.Job;
using PARR.DAL.Services.Interfaces.Schedule;
using PARR.DAL.Services.Interfaces.Unit;
using PARR.DAL.Settings;
using StackExchange.Redis;
namespace PARR.DAL
{
@@ -45,16 +46,24 @@ namespace PARR.DAL
#region Redis + cache services
services.AddSingleton<IConnectionMultiplexer>(sp =>
{
// IConnectionMultiplexer - для нативных операций Redis
var connectionString = configuration.GetConnectionString("RedisConnection");
return ConnectionMultiplexer.Connect(connectionString);
});
services.AddStackExchangeRedisCache(opt =>
{
opt.Configuration = configuration.GetConnectionString("RedisConnection");
});
var groupedShortcodesCacheSettings = new GroupedShortcodesCacheSettings();
configuration.GetSection(nameof(GroupedShortcodesCacheSettings)).Bind(groupedShortcodesCacheSettings);
services.AddSingleton(groupedShortcodesCacheSettings);
services.AddTransient<IRedisCacheService, RedisCacheService>();
services.AddSingleton<IRedisCacheService, RedisCacheService>();
#endregion