Get hcs request result separately

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

@@ -42,5 +42,11 @@ namespace Hcs.Broker.Api.Request.NsiCommon
                 return response.AckRequest.Ack;
             }, token);
         }
+
+        internal async Task<NsiItemType?> GetResultAsync(string messageGuid)
+        {
+            var result = await ExecuteGetResultAsync(messageGuid);
+            return result?.Item as NsiItemType;
+        }
     }
 }

Hcs.Broker/Api/Request/RequestBase.cs

@@ -307,6 +307,34 @@ namespace Hcs.Broker.Api.Request
             return ack.MessageGUID;
         }
 
+        protected async Task<TResult?> ExecuteGetResultAsync(string messageGuid)
+        {
+            using var asyncClient = CreateAsyncClient();
+            var requestHeader = RequestHelper.CreateHeader<TRequestHeader>(client);
+            var requestBody = new TGetStateRequest
+            {
+                MessageGUID = messageGuid
+            };
+            var response = await asyncClient.GetStateAsync(requestHeader, requestBody);
+            var result = response.GetStateResult;
+            if (result.RequestState == (int)AsyncRequestStateType.Ready)
+            {
+                if (result is IQueryable queryableResult)
+                {
+                    queryableResult.OfType<TErrorMessage>().ToList().ForEach(x =>
+                    {
+                        throw RemoteException.CreateNew(x.ErrorCode, x.Description);
+                    });
+                }
+                else if (result is TErrorMessage x)
+                {
+                    throw RemoteException.CreateNew(x.ErrorCode, x.Description);
+                }
+                return (TResult)result;
+            }
+            return default;
+        }
+
         private TAsyncClient CreateAsyncClient()
         {
             var asyncClient = (TAsyncClient)Activator.CreateInstance(typeof(TAsyncClient), binding, RemoteAddress);
@@ -347,9 +375,9 @@ namespace Hcs.Broker.Api.Request
         /// Из документации ГИС ЖКХ:
         /// Также рекомендуем придерживаться следующего алгоритма отправки запросов на получение статуса обработки пакета в случае использования асинхронных сервисов ГИС ЖКХ (в рамках одного MessageGUID):
         /// - первый запрос getState направлять не ранее чем через 10 секунд, после получения квитанции о приеме пакета с бизнес-данными от сервиса ГИС КЖХ;
-        /// - в случае, если на первый запрос getSate получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 60 секунд после отправки предыдущего запроса;
+        /// - в случае, если на первый запрос getState получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 60 секунд после отправки предыдущего запроса;
-        /// - в случае, если на второй запрос getSate получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 300 секунд после отправки предыдущего запроса;
+        /// - в случае, если на второй запрос getState получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 300 секунд после отправки предыдущего запроса;
-        /// - в случае, если на третий запрос getSate получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 900 секунд после отправки предыдущего запроса;
+        /// - в случае, если на третий запрос getState получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 900 секунд после отправки предыдущего запроса;
         /// - в случае, если на четвертый(и все последующие запросы) getState получен результат с RequestState равным "1" или "2", то следующий запрос getState необходимо направлять не ранее чем через 1800 секунд после отправки предыдущего запроса.
         /// </summary>
         private async Task<TResult> WaitForResultAsync(

Hcs.WebApp/BackgroundServices/OperationExecutionService.cs

@@ -60,7 +60,7 @@ namespace Hcs.WebApp.BackgroundServices
             using var scope = scopeFactory.CreateScope();
             var headquartersService = scope.ServiceProvider.GetRequiredService<HeadquartersService>();
 
-            var operations = await headquartersService.GetInitiatedOperationsAsync();
+            var operations = await headquartersService.GetNotExecutedOperationsAsync();
             foreach (var operation in operations)
             {
                 state.EnqueueOperation(operation);
@@ -70,7 +70,7 @@ namespace Hcs.WebApp.BackgroundServices
         private void InitializeClient()
         {
             logger = new ActionLogger();
-            messageCapturer = new FileMessageCapturer("messages", logger);
+            messageCapturer = new FileMessageCapturer("outgoing", logger);
 
             using var scope = scopeFactory.CreateScope();
             var configuration = scope.ServiceProvider.GetRequiredService<IConfiguration>();

Hcs.WebApp/BackgroundServices/ResultWaitService.cs

@@ -1,7 +1,61 @@
-namespace Hcs.WebApp.BackgroundServices
+using Hcs.Broker;
+using Hcs.Broker.Logger;
+using Hcs.Broker.MessageCapturer;
+using Hcs.WebApp.Config;
+using Hcs.WebApp.Services;
+
+namespace Hcs.WebApp.BackgroundServices
 {
-    public class ResultWaitService
+    public class ResultWaitService(ResultWaitState state, IServiceScopeFactory scopeFactory) : BackgroundService
     {
-        // TODO
+        private const int SLEEP_TIME = 30000;
+
+        private readonly ResultWaitState state = state;
+        private readonly IServiceScopeFactory scopeFactory = scopeFactory;
+
+        private Broker.Logger.ILogger logger;
+        private IMessageCapturer messageCapturer;
+        private IClient client;
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            await InitializeStateAsync();
+
+            InitializeClient();
+
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                while (state.TryDequeueOperation(out var operation))
+                {
+                    if (stoppingToken.IsCancellationRequested) return;
+                }
+
+                await Task.Delay(SLEEP_TIME, stoppingToken);
+            }
+        }
+
+        private async Task InitializeStateAsync()
+        {
+            using var scope = scopeFactory.CreateScope();
+            var headquartersService = scope.ServiceProvider.GetRequiredService<HeadquartersService>();
+
+            var operations = await headquartersService.GetResultWaitingOperationsAsync();
+            foreach (var operation in operations)
+            {
+                state.EnqueueOperation(operation);
+            }
+        }
+
+        private void InitializeClient()
+        {
+            logger = new ActionLogger();
+            messageCapturer = new FileMessageCapturer("incoming", logger);
+
+            using var scope = scopeFactory.CreateScope();
+            var configuration = scope.ServiceProvider.GetRequiredService<IConfiguration>();
+            var config = configuration.GetSection("BrokerConfig").Get<BrokerConfig>()!;
+            var clientProvider = scope.ServiceProvider.GetRequiredService<IClientProvider>();
+            client = clientProvider.CreateClient(config, logger, messageCapturer);
+        }
     }
 }

Hcs.WebApp/BackgroundServices/ResultWaiters/IResultWaiter.cs

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

Hcs.WebApp/Services/HeadquartersService.cs

@@ -19,11 +19,19 @@ namespace Hcs.WebApp.Services
                           select campaign).ToListAsync();
         }
 
-        public async Task<IEnumerable<Operation>> GetInitiatedOperationsAsync()
+        public async Task<IEnumerable<Operation>> GetNotExecutedOperationsAsync()
         {
             using var context = GetNewContext();
             return await (from operation in context.Operations
-                          where string.IsNullOrEmpty(operation.MessageGuid)
+                          where string.IsNullOrEmpty(operation.MessageGuid) && !operation.EndedAt.HasValue
+                          select operation).ToListAsync();
+        }
+
+        public async Task<IEnumerable<Operation>> GetResultWaitingOperationsAsync()
+        {
+            using var context = GetNewContext();
+            return await (from operation in context.Operations
+                          where !string.IsNullOrEmpty(operation.MessageGuid) && !operation.EndedAt.HasValue
                           select operation).ToListAsync();
         }