public async Task <RegisterPersistedQueryResult> TryRegisterQueryAsync(GraphQlRequest request, CancellationToken cancellationToken)
{
if (request.Query == null)
{
if (!await _persistedQueryManager.IsSupportedAsync(cancellationToken))
{
return(RegisterPersistedQueryResult.PersistedQueryNotSupported);
}
return(RegisterPersistedQueryResult.NoQueryToRegister);
}
if (request.Extensions?.GetValue("persistedQuery") == null)
{
return(RegisterPersistedQueryResult.NoPersistedQuery);
}
if (!await _persistedQueryManager.IsSupportedAsync(cancellationToken))
{
return(RegisterPersistedQueryResult.PersistedQueryNotSupported);
}
// Validate hash
if ((string)request.Extensions["persistedQuery"]["sha256Hash"] != Helpers.GetSha256Hash(request.Query))
{
return(RegisterPersistedQueryResult.PersistedQueryNotSupported);
}
await _persistedQueryManager.AddPersistedQueryAsync((string)request.Extensions["persistedQuery"]["sha256Hash"], request.Query, cancellationToken);
return(RegisterPersistedQueryResult.QueryRegistered);
}
void ExecuteOperationAsync(string id, GraphQlRequest request, IServiceProvider serviceProvider, CancellationToken cancellationToken)
{
var executor = serviceProvider.GetService <IGraphQLExecutor>();
var executionBuilderResolver = serviceProvider.GetService <IExecutionBuilderResolver>();
var realtimeExecuter = new RealTimeQueryExecuter(executionBuilderResolver, executor, _rootType, id);
realtimeExecuter.Execute(request, executerCallback, cancellationToken);
}
public async Task <IActionResult> Post([FromBody] GraphQlRequest query)
{
try
{
var result = await _documentExecuter.ExecuteAsync(config =>
{
config.Schema = _schema;
config.Query = query.Query;
config.Inputs = query.Variables.ToInputs();
});
return(Ok(result));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <ActionResult <Dictionary <string, object> > > ExecuteQuery([FromQuery] string query, [FromQuery] string operationName, [FromQuery] string variables, [FromQuery] string extensions, CancellationToken cancellationToken)
{
var request = new GraphQlRequest()
{
Query = query,
OperationName = operationName,
Variables = variables != null?JsonConvert.DeserializeObject <JObject>(variables) : null,
Extensions = extensions != null?JsonConvert.DeserializeObject <JObject>(extensions) : null
};
var result = await ExecuteAsync(request, cancellationToken);
if (HttpContext.Response.StatusCode != 200)
{
return(StatusCode(HttpContext.Response.StatusCode));
}
return(new ActionResult <Dictionary <string, object> >(result.result));
}
public async Task <IActionResult> ApplicationListAsync()
{
const string QueryName = "applicationSummaries";
var request = new GraphQlRequest
{
Query = $@"
query {{
{QueryName} {{
id
companyName
status
date
description
}}
}}
"
};
GraphQlResponse <JObject> result = await _graphQlService.ExecuteQuery <GraphQlResponse <JObject> >(request);
var jobApplicationSummaries = result.Data[QueryName]
.ToObject <List <JobApplicationSummary> >();
return(Ok(jobApplicationSummaries));
}
public async Task <IActionResult> Index([FromBody] GraphQlRequest request)
{
var result = await _graphQlService.ExecuteQuery <JObject>(request);
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] GraphQlRequest graphQlRequest)
{
return(Content(await _graphQlAdapter.Search(graphQlRequest.Query, HttpContext.GetLanguagePreferences()), "application/json"));
}
public void Execute(GraphQlRequest request, Action <OperationMessage> callback, CancellationToken cancellationToken)
{
var executionBuilder = _executionBuilderResolver.GetGraphqlExecutionBuilder(_root);
_executor.ExecuteAsync(executionBuilder, request, _root, new ExecutionDataDictionary()
{
{ "IsRealtimeRequest", true }
}, cancellationToken)
.ContinueWith(result =>
{
if (result.IsFaulted)
{
callback(new OperationMessage()
{
Id = _operationId,
Type = OperationType.GraphqlError,
Payload = new JValue(result.Exception.Message)
});
;
}
var executionData = result.Result.ExecutionData;
var executionResult = result.Result.ExecutionResult;
if (executionResult is SubscriptionExecutionResult subscriptionExecutionResult)
{
if (subscriptionExecutionResult.Streams?.Values.SingleOrDefault() == null)
{
callback(new OperationMessage()
{
Id = _operationId,
Payload = JToken.FromObject(executionResult.ToResultDictionary()),
Type = OperationType.GraphqlError
});
}
else
{
var stream = subscriptionExecutionResult.Streams.Values.Single();
stream.Synchronize().Subscribe(
onNext: (data) => callback(new OperationMessage()
{
Id = _operationId,
Payload = JToken.FromObject(data.ToResultDictionary()),
Type = OperationType.GraphqlData
}),
onError: (error) => callback(new OperationMessage()
{
Id = _operationId,
Payload = new JValue(error.Message),
Type = OperationType.GraphqlError
}),
onCompleted: () => callback(new OperationMessage()
{
Id = _operationId,
Type = OperationType.GraphqlComplete
}),
token: cancellationToken
);
}
}
else
{
var dictionary = executionResult.ToResultDictionary();
callback(new OperationMessage()
{
Id = _operationId,
Payload = JToken.FromObject(dictionary),
Type = OperationType.GraphqlData
});
}
});
}
async Task <(Dictionary <string, object> result, IExecutionDataDictionary data)> ExecuteAsync(GraphQlRequest graphQlRequest, CancellationToken cancellationToken)
{
var root = GetRoot();
var executionBuilder = _executionBuilderResolver.GetGraphqlExecutionBuilder(root);
var result = await _executor.ExecuteAsync(executionBuilder, graphQlRequest, root, new ExecutionDataDictionary()
{
{ "IsHttpRequest", true },
{ "HttpContext", HttpContext }
}, cancellationToken);
var dictionary = result.ExecutionResult.ToResultDictionary();
return(dictionary, result.ExecutionData);
}
