public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
_logger.LogError("Argument null exception for query - CHECK {0}", nameof(query));
throw new ArgumentNullException(nameof(query));
}
var inputs = query.Variables.ToInputs();
try
{
var files = this.Request.HasFormContentType ? this.Request.Form.Files : null;
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query,
Inputs = inputs,
Root = files,
ValidationRules = _validationRule
};
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(StatusCode(400, result));
}
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError(ex, "Something really went wrong - CHECK: {0}", ex.Message);
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var executionOptions = new ExecutionOptions {
Schema = _schema, Query = query.Query
};
try
{
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var executionOptions = new ExecutionOptions {
Schema = _schema, Query = query.Query
};
try
{
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
_logger.LogError("GraphQL errors: {0}", result.Errors);
return(BadRequest(result));
}
_logger.LogDebug("GraphQL execution result: {result}", JsonConvert.SerializeObject(result.Data));
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError("Document exexuter exception", ex);
return(BadRequest(ex));
}
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var inputs = query.Variables.ToInputs();
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query,
Inputs = inputs
};
var result = await _documentExecuter
.ExecuteAsync(executionOptions);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async System.Threading.Tasks.Task <object> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var executionOptions = new ExecutionOptions()
{
Schema = _schema,
Query = query.Query,
Inputs = query.Variables.ToInputs()
};
try
{
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
return(Ok(result));
}
catch (Exception ex)
{
}
return(null);
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
try
{
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = query.Query;
_.OperationName = query.OperationName;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
}).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task GetUserByIdTest()
{
User user = new User()
{
Email = "*****@*****.**",
GivvenName = "Peter",
FamilyName = "Johnson"
};
//Setup db data
await _context.DbContext.Users.AddAsync(user);
await _context.DbContext.SaveChangesAsync();
//Api call
var query = new GraphQLQuery()
{
Query = $"{{user(id: \"{user.Id}\") {{id,givvenName,familyName,email,created}} }}"
};
string postData = JsonConvert.SerializeObject(query);
var response = await _context.Client.PostAsync("/graphql", new StringContent(postData, Encoding.UTF8, "application/json"));
//Check status code
response.StatusCode.Should().Be(HttpStatusCode.OK);
//Parse response
string responseStr = await response.Content.ReadAsStringAsync();
GraphUserResponse graphQlResponse = JsonConvert.DeserializeObject <GraphUserResponse>(responseStr);
//Compare response data and original data
user.Should().Equals(graphQlResponse.Data.user);
}
/// <summary>
///
/// </summary>
/// <param name="body"></param>
/// <returns></returns>
public void GraphqlPost(GraphQLQuery body)
{
var path = "/graphql";
path = path.Replace("{format}", "json");
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, String>();
var fileParams = new Dictionary <String, FileParameter>();
String postBody = null;
postBody = ApiClient.Serialize(body); // http body (model) parameter
// authentication setting, if any
String[] authSettings = new String[] { };
// make the HTTP request
IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling GraphqlPost: " + response.Content, response.Content);
}
else if (((int)response.StatusCode) == 0)
{
throw new ApiException((int)response.StatusCode, "Error calling GraphqlPost: " + response.ErrorMessage, response.ErrorMessage);
}
return;
}
public async Task <IActionResult> GraphQLApi([FromBody] GraphQLQuery query)
{
// Create inputs. Convert Variables thành kiểu Inputs
var inputs = query.Variables.ToInputs();
// Create schema
var schema = new Schema
{
Query = new RetailerQuery(_retailerRepo)
};
// Truyền tham số vào hàm ExecuteAsync để thực hiện GraphQL request
var result = await _documentExecuter.ExecuteAsync(x =>
{
x.Schema = schema;
x.Query = query.Query;
x.OperationName = query.OperationName;
x.Inputs = inputs;
});
if (result.Errors?.Count > 0)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var inputs = query.Variables.ToInputs();
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query.Query,
Inputs = inputs
};
var result = await documentExecuter
.ExecuteAsync(executionOptions)
.ConfigureAwait(false);
if (result.Errors != null &&
result.Errors.Count > 0)
{
return(NotFound());
}
return(Ok(result));
}
public GraphQLProcessor(GraphQLQuery graphQlQuery, ISchema schema, IDocumentExecuter executer, IDocumentWriter writer)
{
_graphQLQuery = graphQlQuery;
_schema = schema;
_executer = executer;
_writer = writer;
}
public async Task IntrospectionTest()
{
using (var resolver = new TestResolver(Setup))
{
var schema = resolver.Resolve <ISchema>();
var query = new GraphQLQuery
{
Query =
"\n query IntrospectionQuery {\n __schema {\n queryType { name }\n mutationType { name }\n subscriptionType { name }\n types {\n ...FullType\n }\n directives {\n name\n description\n locations\n args {\n ...InputValue\n }\n }\n }\n }\n\n fragment FullType on __Type {\n kind\n name\n description\n fields(includeDeprecated: true) {\n name\n description\n args {\n ...InputValue\n }\n type {\n ...TypeRef\n }\n isDeprecated\n deprecationReason\n }\n inputFields {\n ...InputValue\n }\n interfaces {\n ...TypeRef\n }\n enumValues(includeDeprecated: true) {\n name\n description\n isDeprecated\n deprecationReason\n }\n possibleTypes {\n ...TypeRef\n }\n }\n\n fragment InputValue on __InputValue {\n name\n description\n type { ...TypeRef }\n defaultValue\n }\n\n fragment TypeRef on __Type {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n }\n }\n }\n }\n }\n }\n }\n }\n"
};
var documentExecuter = resolver.Resolve <IDocumentExecuter>();
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query.Query
};
var result = await
documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(true);
Assert.IsNotNull(result);
Assert.IsTrue(result.Errors == null,
string.Concat(result.Errors != null && result.Errors.Any()
? result.Errors
: new ExecutionErrors()));
}
}
private void ValidateQuery(GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
}
//[HttpPost]
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
var _result = await new DocumentExecuter().ExecuteAsync(options =>
{
options.Schema = new Schema
{
Query = new Query(),
Mutation = new Mutation()
};
options.Query = query.Query;
options.OperationName = query.OperationName;
options.Inputs = query.Variables.ToInputs();
options.UserContext = new GraphQLUserContext()
{
//{"AccessToken",ControllerHelper.GetAccessToken(Request) },
//{"Username",ControllerHelper.GetUsername(Request) },
//{"UserPassword",ControllerHelper.GetUserPassword(Request) },
//{"CurrentPassword",ControllerHelper.GetCurrentPassword(Request) },
//{"NewPassword",ControllerHelper.GetNewPassword(Request) },
//{"ActivateAccountId",ControllerHelper.GetActivateAccountId(Request) },
{ "IWebHostEnvironment", _webHostEnvironment }
};
//options.ComplexityConfiguration = new ComplexityConfiguration { MaxDepth = 15 };
});
if (_result.Errors?.Count > 0)
{
return(BadRequest(new ApiErrorResp(_result.Errors)));
}
HttpContext.Response.ContentType = "application/json";
await new DocumentWriter().WriteAsync(HttpContext.Response.Body, _result);
return(Ok());
}
public async Task should_handle_start_subscriptions()
{
/* Given */
var query = new GraphQLQuery
{
OperationName = "test",
Query = "subscription",
Variables = JObject.FromObject(new { test = "variable" })
};
var messageContext = CreateMessage(
MessageTypes.GQL_START, query);
_subscriptionExecuter.SubscribeAsync(Arg.Any <ExecutionOptions>())
.Returns(CreateStreamResult);
_determinator.IsSubscription(Arg.Any <ExecutionOptions>()).Returns(true);
/* When */
await _sut.HandleMessageAsync(messageContext).ConfigureAwait(false);
/* Then */
await _subscriptionExecuter.Received()
.SubscribeAsync(Arg.Is <ExecutionOptions>(
context => context.Schema == _schema &&
context.Query == query.Query &&
context.Inputs.ContainsKey("test")))
.ConfigureAwait(false);
var connectionSubscriptions = _sut.Subscriptions[messageContext.ConnectionId];
Assert.True(connectionSubscriptions.ContainsKey(messageContext.Op.Id));
}
public GraphQLController(GraphQLQuery graphQLQuery, ISchema schema, IDocumentExecuter documentExecuter, IUtilityService utilityService, IServiceProvider serviceProvider)
{
_graphQLQuery = graphQLQuery;
_schema = schema;
_documentExecuter = documentExecuter;
_utilityService = utilityService;
_serviceProvider = serviceProvider;
}
public void Serialize_OfType_OverridesAttributeTypeName()
{
var query = new GraphQLQuery <BlogPost>()
.OfType("overriden_type")
.ToString();
Assert.Contains("overriden_type {", query);
}
public void Serialize_EnumArgument_AddsNameNotValue()
{
var query = new GraphQLQuery <BlogPost>()
.WithArgument("category", Category.News)
.ToString();
Assert.Contains("blog_post(category: News", query);
}
public void Serialize_ArgumentWithoutProperty_AddsProperArgumentSyntax()
{
var query = new GraphQLQuery <BlogPost>()
.WithArgument("id", 1)
.ToString();
Assert.Contains("blog_post(id: 1)", query);
}
public void Serialize_OperationName_AddsSyntax()
{
var query = new GraphQLQuery <BlogPost>()
.AsOperation("GetBlogPosts")
.ToString();
Assert.Contains("query GetBlogPosts", query);
}
public void Serialize_ArgumentWithProperty_AddsProperArgumentSyntax()
{
var query = new GraphQLQuery <BlogPost>()
.WithArgument(x => x.Title, "length", 5)
.ToString();
Assert.Contains("title(length: 5)", query);
}
public void Serialize_WithIgnore_DoesNotContainField()
{
var query = new GraphQLQuery <BlogPost>()
.ShouldIgnore(x => x.Title)
.ToString();
Assert.DoesNotContain("full_name", query);
}
public void Serialize_WithOfType_UsesProvidedTypeInQuery()
{
var query = new GraphQLQuery <BlogPost>()
.OfType("some_remote_type")
.ToString();
Assert.Contains("some_remote_type", query);
}
public void Serialize_Map_UsesPropertyWithoutAttribute()
{
var query = new GraphQLQuery <BlogPost>()
.WithMapping(x => x.UnMappedField, "unmapped_field")
.ToString();
Assert.Contains("unmapped_field", query);
}
/// Query the GraphQL API over POST
public async Task <IActionResult> Post([FromBody] GraphQLQuery query, [FromHeader] string token)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
return(await PreformQuery(query, token));
}
public void Resolve(GraphQLQuery graphQLQuery)
{
graphQLQuery.FieldAsync <ResponseGraphType <MapType> >(
"map",
arguments: new QueryArguments(
new QueryArgument <StringGraphType>()
{
Name = "mapId"
}),
resolve: async context =>
{
var id = context.GetArgument <Guid>("mapId");
var mapFromRepo = await _playerRepository.GetMapByIdAsync(id);
var mapToRetun = Mapper.Map <MapDto>(mapFromRepo);
return(Response(mapToRetun));
});
graphQLQuery.FieldAsync <ResponseListGraphType <MapType> >(
"maps",
resolve: async context =>
{
var mapsFromRepo = await _playerRepository.GetAllMapsAsync();
var mapsToReturn = Mapper.Map <IEnumerable <MapDto> >(mapsFromRepo);
return(Response(mapsToReturn));
});
graphQLQuery.FieldAsync <ResponseGraphType <MapType> >(
"createMap",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <MapInputType> > {
Name = "map"
}
),
resolve: async context =>
{
var map = context.GetArgument <MapForCreationDto>("map");
var mapEntity = Mapper.Map <Map>(map);
await _playerRepository.AddMapAsync(mapEntity);
var mapToReturn = Mapper.Map <MapDto>(mapEntity);
return(Response(mapToReturn));
});
graphQLQuery.FieldAsync <ResponseGraphType <MapType> >(
"updateMap",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <MapInputType> > {
Name = "map"
}
),
resolve: async context =>
{
var map = context.GetArgument <MapForManipulationDto>("map");
var mapEntity = Mapper.Map <Map>(map);
await _playerRepository.UpdateMapAsync(mapEntity);
var mapToReturn = Mapper.Map <MapDto>(mapEntity);
return(Response(mapToReturn));
});
}
public async Task <ActionResult> CreateOrder()
{
CreateOrderVm createOrderVm = new CreateOrderVm();
//get customers
var graphQLClient = new GraphQLClient("http://localhost:13515/api/school");
GraphQLQuery graphQLQuery = GraphQLHelper.GetGraphQLQuery("GetCustomers");
var heroRequest = new GraphQLRequest {
Query = graphQLQuery.Body, OperationName = "GetAllCustomers"
};
var graphQLResponse = await graphQLClient.PostAsync(heroRequest);
string json = JsonConvert.SerializeObject(graphQLResponse.Data);
var result = JsonConvert.DeserializeObject <Dictionary <string, List <Customer> > >(json);
List <Customer> customers = new List <Customer>();
foreach (var obj in result.Values.ElementAt(0))
{
customers.Add(obj);
}
createOrderVm.Customers = customers;
//get employees
graphQLQuery = GraphQLHelper.GetGraphQLQuery("GetEmployees");
heroRequest = new GraphQLRequest {
Query = graphQLQuery.Body, OperationName = "GetAllEmployees"
};
graphQLResponse = await graphQLClient.PostAsync(heroRequest);
json = JsonConvert.SerializeObject(graphQLResponse.Data);
var result2 = JsonConvert.DeserializeObject <Dictionary <string, List <Employee> > >(json);
List <Employee> employees = new List <Employee>();
foreach (var obj in result2.Values.ElementAt(0))
{
employees.Add(obj);
}
createOrderVm.Employees = employees;
//get shippers
graphQLQuery = GraphQLHelper.GetGraphQLQuery("GetShippers");
heroRequest = new GraphQLRequest {
Query = graphQLQuery.Body, OperationName = "GetAllShippers"
};
graphQLResponse = await graphQLClient.PostAsync(heroRequest);
json = JsonConvert.SerializeObject(graphQLResponse.Data);
var result3 = JsonConvert.DeserializeObject <Dictionary <string, List <Shipper> > >(json);
List <Shipper> shippers = new List <Shipper>();
foreach (var obj in result3.Values.ElementAt(0))
{
shippers.Add(obj);
}
createOrderVm.Shippers = shippers;
return(View(createOrderVm));
}
public void Serialize_MultiArgumentWithoutProperty_AddsProperArgumentSyntax()
{
var query = new GraphQLQuery <BlogPost>()
.WithArgument("id", 2)
.WithArgument("before", "8/31/2020")
.ToString();
Assert.Contains("blog_post(id: 2, before: \"8/31/2020\"", query);
}
public Task <OneOf <User, IAniListError> > GetAniListNotificationCount(CancellationToken cToken = default)
{
var query = new GraphQLQuery
{
Query = QueryStore.GetUserNotificationCount
};
return(GetResponseAsync <User>(query, cToken));
}
public Task <OneOf <User, IAniListError> > GetCurrentUser(CancellationToken cToken)
{
var query = new GraphQLQuery
{
Query = QueryStore.GetCurrentUser
};
return(GetResponseAsync <User>(query, cToken));
}
