kshkulev/hcs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement result getter

Browse Source
This commit is contained in:
HOME-LAPTOP\kshkulev
2025-11-01 19:15:07 +09:00
parent 6fc2db95ec
commit 821eeb41ae
16 changed files with 243 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Hcs.Broker.Mock/Api/MockNsiCommonApi.cs
View File

@ -1,4 +1,5 @@
using Hcs.Broker.Api;
using Hcs.Broker.Api.Request;
using Hcs.Service.Async.NsiCommon;
namespace Hcs.Broker.Mock.Api
@ -28,5 +29,15 @@ namespace Hcs.Broker.Mock.Api
return Guid.NewGuid().ToString();
}
public async Task<RequestSingleResult<NsiItemType>> GetExportNsiItemResultAsync(string messageGuid)
{
await Task.Delay(3000);
return new RequestSingleResult<NsiItemType>()
{
Ready = false
};
}
}
}

11
Hcs.Broker/Api/INsiCommonApi.cs
View File

@ -1,4 +1,5 @@
using Hcs.Service.Async.NsiCommon;
using Hcs.Broker.Api.Request;
using Hcs.Service.Async.NsiCommon;
namespace Hcs.Broker.Api
{
@ -22,7 +23,6 @@ namespace Hcs.Broker.Api
/// <returns>Перечень общесистемных справочников</returns>
Task<NsiListType> ExportNsiListAsync(ListGroup listGroup, CancellationToken token = default);
/// <summary>
/// Запрашивает экспорт данных общесистемного справочника
/// </summary>
@ -31,5 +31,12 @@ namespace Hcs.Broker.Api
/// <param name="token">Токен отмены</param>
/// <returns>Идентификатор сообщения операции экспорта</returns>
Task<string> RequestExportNsiItemAsync(int registryNumber, ListGroup listGroup, CancellationToken token = default);
/// <summary>
/// Возвращает результат экспорта данных общесистемного справочника
/// </summary>
/// <param name="messageGuid">Идентификатор сообщения операции экспорта</param>
/// <returns>Результат запроса</returns>
Task<RequestSingleResult<NsiItemType>> GetExportNsiItemResultAsync(string messageGuid);
}
}

10
Hcs.Broker/Api/NsiCommonApi.cs
View File

@ -1,4 +1,5 @@
using Hcs.Broker.Api.Request.Exception;
using Hcs.Broker.Api.Request;
using Hcs.Broker.Api.Request.Exception;
using Hcs.Broker.Api.Request.NsiCommon;
using Hcs.Service.Async.NsiCommon;
@ -41,5 +42,12 @@ namespace Hcs.Broker.Api
var request = new ExportNsiItemRequest(client);
return await request.SendAsync(registryNumber, listGroup, token);
}
/// <inheritdoc cref="INsiCommonApi"/>
public async Task<RequestSingleResult<NsiItemType>> GetExportNsiItemResultAsync(string messageGuid)
{
var request = new ExportNsiItemRequest(client);
return await request.GetResultAsync(messageGuid);
}
}
}

2
Hcs.Broker/Api/Request/Adapter/IErrorMessage.cs
View File

@ -5,5 +5,7 @@
string ErrorCode { get; }
string Description { get; }
string StackTrace { get; }
}
}

21
Hcs.Broker/Api/Request/NsiCommon/ExportNsiItemRequest.cs
View File

@ -1,4 +1,5 @@
using Hcs.Broker.Internal;
using Hcs.Broker.Api.Request.Adapter;
using Hcs.Broker.Internal;
using Hcs.Service.Async.NsiCommon;
namespace Hcs.Broker.Api.Request.NsiCommon
@ -36,17 +37,29 @@ namespace Hcs.Broker.Api.Request.NsiCommon
ListGroup = listGroup
};
return await StartSendAsync(request, async asyncClient =>
return await SendAsync(request, async asyncClient =>
{
var response = await asyncClient.exportNsiItemAsync(CreateRequestHeader(), request);
return response.AckRequest.Ack;
}, token);
}
internal async Task<NsiItemType?> GetResultAsync(string messageGuid)
internal async Task<RequestSingleResult<NsiItemType>> GetResultAsync(string messageGuid)
{
var result = await ExecuteGetResultAsync(messageGuid);
return result?.Item as NsiItemType;
if (result == null)
{
return RequestSingleResult<NsiItemType>.CreateNotReady();
}
if (result.Item is NsiItemType nsiItem)
{
return RequestSingleResult<NsiItemType>.CreateSuccessful(nsiItem);
}
else if (result.Item is IErrorMessage errorMessage)
{
return RequestSingleResult<NsiItemType>.CreateFailed(errorMessage);
}
return RequestSingleResult<NsiItemType>.CreateFailed(null);
}
}
}

2
Hcs.Broker/Api/Request/RequestBase.cs
View File

@ -149,7 +149,7 @@ namespace Hcs.Broker.Api.Request
}
}
protected async Task<string> StartSendAsync(
protected async Task<string> SendAsync(
object request,
Func<TAsyncClient, Task<TAck>> sender,
CancellationToken token)

43
Hcs.Broker/Api/Request/RequestSingleResult.cs Normal file
View File

@ -0,0 +1,43 @@
using Hcs.Broker.Api.Request.Adapter;
namespace Hcs.Broker.Api.Request
{
public class RequestSingleResult<T>
{
public bool Ready { get; set; }
public bool Success { get; set; }
public T? Result { get; set; }
public IErrorMessage? ErrorMessage { get; set; }
public static RequestSingleResult<T> CreateNotReady()
{
return new RequestSingleResult<T>
{
Ready = false
};
}
public static RequestSingleResult<T> CreateSuccessful(T result)
{
return new RequestSingleResult<T>
{
Ready = true,
Success = true,
Result = result
};
}
public static RequestSingleResult<T> CreateFailed(IErrorMessage? errorMessage)
{
return new RequestSingleResult<T>
{
Ready = true,
Success = false,
ErrorMessage = errorMessage
};
}
}
}

2
Hcs.WebApp/BackgroundServices/OperationExecutors/ExecutorFactory.cs
View File

@ -14,7 +14,7 @@ namespace Hcs.WebApp.BackgroundServices.OperationExecutors
return new ExportNsiItemExecutor_15_7_0_1(client, scope, operation);
}
throw new NotImplementedException();
throw new NotImplementedException($"Не удалось создать выполнителя операции типа {operation.Type}");
}
}
}

7
Hcs.WebApp/BackgroundServices/ResultGetters/IResultGetter.cs Normal file
View File

@ -0,0 +1,7 @@
namespace Hcs.WebApp.BackgroundServices.ResultGetters
{
public interface IResultGetter
{
Task<ResultGetterResponse> GetAsync();
}
}

29
Hcs.WebApp/BackgroundServices/ResultGetters/NsiCommon/ExportNsiItemGetter_15_7_0_1.cs Normal file
View File

@ -0,0 +1,29 @@
using Hcs.Broker;
using Hcs.WebApp.Data.Hcs;
using Hcs.WebApp.Services;
namespace Hcs.WebApp.BackgroundServices.ResultGetters.NsiCommon
{
public class ExportNsiItemGetter_15_7_0_1(IClient client, IServiceScope scope, Operation operation) : ResultGetterBase(client, scope, operation)
{
public override async Task<ResultGetterResponse> GetAsync()
{
var result = await client.NsiCommon.GetExportNsiItemResultAsync(operation.MessageGuid!);
if (!result.Ready)
{
return ResultGetterResponse.NotReady;
}
if (result.Success)
{
var registryService = scope.ServiceProvider.GetRequiredService<RegistryService>();
var registry = await registryService.GetRegistryByOperationIdAsync(operation.Id);
// TODO
return ResultGetterResponse.Successful;
}
return ResultGetterResponse.Failed;
}
}
}

14
Hcs.WebApp/BackgroundServices/ResultGetters/ResultGetterBase.cs Normal file
View File

@ -0,0 +1,14 @@
using Hcs.Broker;
using Hcs.WebApp.Data.Hcs;
namespace Hcs.WebApp.BackgroundServices.ResultGetters
{
public abstract class ResultGetterBase(IClient client, IServiceScope scope, Operation operation) : IResultGetter
{
protected readonly IClient client = client;
protected readonly IServiceScope scope = scope;
protected readonly Operation operation = operation;
public abstract Task<ResultGetterResponse> GetAsync();
}
}

21
Hcs.WebApp/BackgroundServices/ResultGetters/ResultGetterFactory.cs Normal file
View File

@ -0,0 +1,21 @@
using Hcs.Broker;
using Hcs.WebApp.BackgroundServices.ResultGetters.NsiCommon;
using Hcs.WebApp.Data.Hcs;
namespace Hcs.WebApp.BackgroundServices.ResultGetters
{
public class ResultGetterFactory
{
public IResultGetter CreateResultGetter(IServiceScope scope, IClient client, Operation operation)
{
switch (operation.Type)
{
case Operation.OperationType.NsiCommon_ExportNsiItem_15_7_0_1:
return new ExportNsiItemGetter_15_7_0_1(client, scope, operation);
}
throw new NotImplementedException($"Не удалось создать получателя результата операции типа {operation.Type}");
}
}
}

9
Hcs.WebApp/BackgroundServices/ResultGetters/ResultGetterResponse.cs Normal file
View File

@ -0,0 +1,9 @@
namespace Hcs.WebApp.BackgroundServices.ResultGetters
{
public enum ResultGetterResponse
{
NotReady,
Successful,
Failed
}
}

70
Hcs.WebApp/BackgroundServices/ResultWaitService.cs
View File

@ -1,17 +1,32 @@
using Hcs.Broker;
using Hcs.Broker.Logger;
using Hcs.Broker.MessageCapturer;
using Hcs.WebApp.BackgroundServices.ResultGetters;
using Hcs.WebApp.Config;
using Hcs.WebApp.Data.Hcs;
using Hcs.WebApp.Services;
namespace Hcs.WebApp.BackgroundServices
{
public class ResultWaitService(ResultWaitState state, IServiceScopeFactory scopeFactory) : BackgroundService
public class ResultWaitService(
ResultWaitState state,
ResultGetterFactory resultGetterFactory,
IServiceScopeFactory scopeFactory) : BackgroundService
{
private class WaitState
{
public int attempt;
public int timer;
public bool done;
}
private const int ITERATION_TIME = 10000;
private const int SLEEP_TIME = 30000;
private readonly ResultWaitState state = state;
private readonly ResultGetterFactory resultGetterFactory = resultGetterFactory;
private readonly IServiceScopeFactory scopeFactory = scopeFactory;
private readonly List<(Operation operation, WaitState state)> entries = [];
private Broker.Logger.ILogger logger;
private IMessageCapturer messageCapturer;
@ -28,9 +43,60 @@ namespace Hcs.WebApp.BackgroundServices
while (state.TryDequeueOperation(out var operation))
{
if (stoppingToken.IsCancellationRequested) return;
entries.Add(new (operation, new WaitState()));
}
await Task.Delay(SLEEP_TIME, stoppingToken);
if (entries.Count > 0)
{
await Task.Delay(ITERATION_TIME, stoppingToken);
var scope = scopeFactory.CreateScope();
foreach (var entry in entries)
{
entry.state.timer += ITERATION_TIME;
var send = entry.state.attempt switch
{
0 => entry.state.timer >= 10000,
1 => entry.state.timer >= 60000,
2 => entry.state.timer >= 300000,
3 => entry.state.timer >= 900000,
_ => entry.state.timer >= 1800000,
};
if (send)
{
try
{
var resultGetter = resultGetterFactory.CreateResultGetter(scope, client, entry.operation);
var response = await resultGetter.GetAsync();
switch (response)
{
case ResultGetterResponse.Successful:
case ResultGetterResponse.Failed:
entry.state.done = true;
break;
}
}
catch (Exception e)
{
var headquartersService = scope.ServiceProvider.GetRequiredService<HeadquartersService>();
await headquartersService.SetOperationEndedWithFailAsync(entry.operation.Id, e.Message);
entry.state.done = true;
}
entry.state.attempt++;
entry.state.timer = 0;
}
}
entries.RemoveAll(x => x.state.done);
}
else
{
await Task.Delay(SLEEP_TIME, stoppingToken);
}
}
}

7
Hcs.WebApp/BackgroundServices/ResultWaiters/IResultWaiter.cs
View File

@ -1,7 +0,0 @@
namespace Hcs.WebApp.BackgroundServices.ResultWaiters
{
public interface IResultWaiter
{
// TODO
}
}

2
Hcs.WebApp/Program.cs
View File

@ -1,6 +1,7 @@
using Hcs.WebApp.BackgroundServices;
using Hcs.WebApp.BackgroundServices.CampaignManagers;
using Hcs.WebApp.BackgroundServices.OperationExecutors;
using Hcs.WebApp.BackgroundServices.ResultGetters;
using Hcs.WebApp.Components;
using Hcs.WebApp.Components.Shared;
using Hcs.WebApp.Data.Hcs;
@ -68,6 +69,7 @@ builder.Services.AddSingleton<OperationExecutionState>();
builder.Services.AddSingleton<ResultWaitState>();
builder.Services.AddSingleton<ManagerFactory>();
builder.Services.AddSingleton<ExecutorFactory>();
builder.Services.AddSingleton<ResultGetterFactory>();
builder.Services.AddHostedService<CampaignManagementService>();
builder.Services.AddHostedService<OperationExecutionService>();