Implement result getter

Hcs.Broker.Mock/Api/MockNsiCommonApi.cs

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

Hcs.Broker/Api/INsiCommonApi.cs

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

Hcs.Broker/Api/NsiCommonApi.cs

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

Hcs.Broker/Api/Request/Adapter/IErrorMessage.cs

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

Hcs.Broker/Api/Request/NsiCommon/ExportNsiItemRequest.cs

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

Hcs.Broker/Api/Request/RequestBase.cs

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

Hcs.Broker/Api/Request/RequestSingleResult.cs

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

Hcs.WebApp/BackgroundServices/OperationExecutors/ExecutorFactory.cs

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

Hcs.WebApp/BackgroundServices/ResultGetters/IResultGetter.cs

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

Hcs.WebApp/BackgroundServices/ResultGetters/NsiCommon/ExportNsiItemGetter_15_7_0_1.cs

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

Hcs.WebApp/BackgroundServices/ResultGetters/ResultGetterBase.cs

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

Hcs.WebApp/BackgroundServices/ResultGetters/ResultGetterFactory.cs

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

Hcs.WebApp/BackgroundServices/ResultGetters/ResultGetterResponse.cs

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

Hcs.WebApp/BackgroundServices/ResultWaitService.cs

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

Hcs.WebApp/BackgroundServices/ResultWaiters/IResultWaiter.cs

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

Hcs.WebApp/Program.cs

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