public async Task HandleAsync(
            IWebSocketContext context,
            GenericOperationMessage message,
            CancellationToken cancellationToken)
        {
            QueryRequest request = message.Payload.ToObject <QueryRequest>();

            IExecutionResult result = await context.QueryExecuter.ExecuteAsync(
                new Execution.QueryRequest(request.Query, request.OperationName)
            {
                VariableValues = QueryMiddlewareUtilities
                                 .DeserializeVariables(request.Variables),
                Services = QueryMiddlewareUtilities
                           .CreateRequestServices(context.HttpContext)
            },
                cancellationToken).ConfigureAwait(false);

            if (result is IResponseStream responseStream)
            {
                context.RegisterSubscription(
                    new Subscription(context, responseStream, message.Id));
            }
            else if (result is IQueryExecutionResult queryResult)
            {
                await context.SendSubscriptionDataMessageAsync(
                    message.Id, queryResult, cancellationToken);

                await context.SendSubscriptionCompleteMessageAsync(
                    message.Id, cancellationToken);
            }
        }
示例#2
0
        public async Task HandleAsync(
            IWebSocketContext context,
            GenericOperationMessage message,
            CancellationToken cancellationToken)
        {
            QueryRequestDto payload = message.Payload.ToObject <QueryRequestDto>();

            IQueryRequestBuilder requestBuilder =
                QueryRequestBuilder.New()
                .SetQuery(payload.Query)
                .SetOperation(payload.OperationName)
                .SetVariableValues(QueryMiddlewareUtilities
                                   .ToDictionary(payload.Variables))
                .SetServices(context.HttpContext.CreateRequestServices());

            await context.PrepareRequestAsync(requestBuilder)
            .ConfigureAwait(false);

            IExecutionResult result =
                await context.QueryExecutor.ExecuteAsync(
                    requestBuilder.Create(), cancellationToken)
                .ConfigureAwait(false);

            if (result is IResponseStream responseStream)
            {
                context.RegisterSubscription(
                    new Subscription(context, responseStream, message.Id));
            }
            else if (result is IReadOnlyQueryResult queryResult)
            {
                await context.SendSubscriptionDataMessageAsync(
                    message.Id, queryResult, cancellationToken)
                .ConfigureAwait(false);

                await context.SendSubscriptionCompleteMessageAsync(
                    message.Id, cancellationToken)
                .ConfigureAwait(false);
            }
        }
        private async Task SendResultsAsync()
        {
            while (!_responseStream.IsCompleted &&
                   !_cts.IsCancellationRequested)
            {
                IQueryExecutionResult result =
                    await _responseStream.ReadAsync(_cts.Token);

                if (result != null)
                {
                    await _context.SendSubscriptionDataMessageAsync(
                        Id, result, _cts.Token);
                }
            }

            if (_responseStream.IsCompleted && !_cts.IsCancellationRequested)
            {
                await _context.SendSubscriptionCompleteMessageAsync(
                    Id, _cts.Token);

                Completed?.Invoke(this, EventArgs.Empty);
            }
        }