public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var inputs = query.Variables.ToInputs();
var schema = new Schema()
{
Query = new DieterQuery(_db),
Mutation = new DieterMutation(_db, _userManager, _signInManager)
};
var result = await new DocumentExecuter().ExecuteAsync(_ =>
{
_.Schema = schema;
_.Query = query.Query;
_.OperationName = query.OperationName;
_.Inputs = inputs;
}).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task SimplePersonInsert()
{
GraphQlQuery graphQuery = new GraphQlQuery();
graphQuery.OperationName = "addPerson";
graphQuery.Variables = JObject.Parse(@"{""person"":{""firstName"":""Joe"",""lastName"":""Doe""}}");
graphQuery.Query = @"
mutation ($person: PersonInput!) {
addPerson(person: $person) {
firstName
lastName
}
}";
var json = await fixture.QueryGraphQLAsync(graphQuery);
var expectedJson = @"
{
data: {
addPerson: {
firstName: 'Joe',
lastName: 'Doe'
}
}
}";
Assert.True(fixture.JsonEquals(expectedJson, json));
}
/// <summary>
/// Resolves all queries on guest accesses
/// </summary>
/// <param name="graphQlQuery"></param>
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// LANGUAGES: a list of all lang codes
graphQlQuery.FieldAsync <SearchResultType>(
"searchResults",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "query"
}
),
resolve: async(context) =>
{
var searchResult = await _searchUseCase.Handle(new SearchRequest(
context.GetArgument <string>("query")
));
var channelsWithTruncatedDescription =
TruncateChannelDescriptions(searchResult.Channels);
var truncatedDescriptionResults = searchResult with {
Channels = channelsWithTruncatedDescription
};
// map entity to model
return(_mapper.Map <SearchResultModel>(truncatedDescriptionResults));
}
);
}
/// <summary>
/// Resolves all queries on guest accesses
/// </summary>
/// <param name="graphQlQuery"></param>
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// LANGUAGES: a list of all lang codes
graphQlQuery.FieldAsync <BooleanGraphType>(
"flagExists",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "channelId"
}
),
resolve: async(context) =>
{
// read user context dictionary
var userContext = (GraphQlUserContext)context.UserContext;
var userId = userContext.GetUserId();
// require user to be authenticated
if (userId == null)
{
return(false);
}
// map entity to model
return(await _flagRepository.FlagExists(
context.GetArgument <string>("channelId"),
userId
));
}
);
}
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 executer exception", ex);
return(BadRequest(ex));
}
}
public async Task <IHttpActionResult> Post([FromBody] GraphQlQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var exectionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query,
Inputs = query.Variables.ToInputs()
};
try
{
var result = await new DocumentExecuter().ExecuteAsync(exectionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(Json(result.Errors));
}
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
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));
}
/// <summary>
/// Resolves all queries on guest accesses
/// </summary>
/// <param name="graphQlQuery"></param>
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// TOPICS OVERVIEW
graphQlQuery.FieldAsync <ListGraphType <SubscriberType> >(
"subscriberHistory",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "channelId"
},
new QueryArgument <IntGraphType> {
Name = "days"
}
),
resolve: async(context) =>
{
var result = await _subscriberRepository.GetHistory(
context.GetArgument <string>("channelId"),
context.GetArgument <int>("days", 7)
);
// map entity to model
return(_mapper.Map <List <SubscriberModel> >(result));
}
);
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query,
[FromServices] IEnumerable <IValidationRule> validationRules)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var inputs = query.Variables.ToInputs();
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query,
Inputs = inputs,
UserContext = new GraphQlUserContext
{
User = User
},
ValidationRules = validationRules,
#if (DEBUG)
ExposeExceptions = true,
EnableMetrics = true,
#endif
};
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
//?.ToObject<Dictionary<string,object>>()
var inputs = query.Variables?.ToObject <Dictionary <string, object> >();
//// inputs = JsonConvert.DeserializeObject<Dictionary<string, object>>(inputs?.ToString());
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query,
Inputs = inputs.ToInputs()
};
var result = await _documentExecuter.ExecuteAsync(executionOptions);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
// var inputs
}
public static async Task <string> PostToJsonAsync(this GraphQlClient client, GraphQlQuery query, params KeyValuePair <string, string>[] headers)
{
var response = await client.PostQueryAsync(query, headers);
await using var stream = response?.GetResponseStream();
using var reader = new StreamReader(stream ?? throw new InvalidOperationException(), Encoding.UTF8);
return(reader.ReadToEnd());
}
public IActionResult Post([FromBody] GraphQlQuery query)
{
var output = new GraphQlDocument(query.Query)
.Validate(typeof(Query))
.Run(new Query())
.GetOutput();
return(Ok(output));
}
public GraphQlController(
ILogger <GraphQlController> logger,
GraphQlQuery graphQlQuery,
IDocumentExecuter documentExecuter,
ISchema schema)
{
_graphQlQuery = graphQlQuery ?? throw new ArgumentNullException(nameof(graphQlQuery));
_documentExecuter = documentExecuter;
_schema = schema;
_logger = logger;
}
public IActionResult Post([FromBody] GraphQlQuery query)
{
var graphResponse = model.RunQuery(new GraphQuery {
Query = query.Query, OperationName = query.OperationName ?? "", Variables = query.Variables ?? ""
});
logger.LogDebug(graphResponse.Response);
JObject foo = JObject.Parse(graphResponse.Response);
return(Ok(foo));
}
public async Task <IActionResult> Post(
[FromQuery]
[SwaggerParameter("Explicit query", Required = false)]
string query,
[FromBody]
[SwaggerParameter("Graph query model", Required = true)]
GraphQlQuery model,
CancellationToken cancellationToken)
{
if (model == null)
{
return(BadRequest("Missing query body."));
}
// Determine query to execute
var queryToExecute = query ?? model.Query;
if (!string.IsNullOrWhiteSpace(model.NamedQuery) &&
!_namedQueries.TryGetValue(model.NamedQuery, out queryToExecute))
{
return(BadRequest($"Named query, {model.NamedQuery}, not found."));
}
var startTime = DateTime.UtcNow;
var executionOptions =
new ExecutionOptions
{
Schema = _schema,
Query = queryToExecute,
OperationName = model.OperationName,
Inputs = model.Variables.ToInputs(),
UserContext = User,
CancellationToken = cancellationToken,
ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
},
ExposeExceptions = true,
EnableMetrics = true
};
executionOptions.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
var result = await _documentExecuter.ExecuteAsync(executionOptions);
result.EnrichWithApolloTracing(startTime);
return(result.Errors?.Count > 0
? (IActionResult)BadRequest(result)
: Json(result, new JsonSerializerSettings {
MaxDepth = 64
}));
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery graphQlQuery)
{
var executionOptions = ValidateGraphQuery(graphQlQuery);
var result = await _documentExecuter.ExecuteAsync(executionOptions);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> Post1([FromBody] GraphQlQuery query)
{
try
{
var result = await _graphQlService.ExecuteSchema(query);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest());
}
}
/// <summary>
/// Resolves all queries on guest accesses
/// </summary>
/// <param name="graphQlQuery"></param>
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// LANGUAGES: a list of all lang codes
graphQlQuery.FieldAsync <ListGraphType <LanguageType> >(
"languages",
resolve: async(context) =>
{
var languages = await _languageRepository.GetAll();
// map entity to model
return(_mapper.Map <List <LanguageModel> >(languages));
}
);
}
public async Task<IActionResult> Post([FromBody] GraphQlQuery query)
{
var schema = new MySchema();
var inputs = new GraphQL.Inputs(query.Variables.AsDictionary());//.ToInputs();
var result = await new DocumentExecuter().ExecuteAsync(
schema.GraphQlSchema, null, query.Query, query.OperationName, inputs);
if (result.Errors?.Count > 0)
{
return BadRequest();
}
return Ok(result);
}
public async Task <string> QueryGraphQLAsync(GraphQlQuery query)
{
var result = await DocumentExecuter
.ExecuteAsync(options =>
{
options.Schema = Schema;
options.Query = query.Query;
options.Inputs = query.Variables != null ? new Inputs(StringExtensions.GetValue(query.Variables) as Dictionary <string, object>) : null;
})
.ConfigureAwait(false);
var json = new DocumentWriter(indent: true).Write(result);
return(json);
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var result = await new DocumentExecuter().ExecuteAsync(x =>
{
x.Schema = schema;
x.Query = query.Query;
x.Inputs = query.Variables.ToInputs();
});
if (result.Errors?.Count > 0)
{
return(BadRequest(result.Errors));
}
return(Ok(result));
}
private ExecutionOptions ValidateGraphQuery(GraphQlQuery graphQlQuery)
{
if (graphQlQuery is null)
{
throw new ArgumentNullException($"{nameof(graphQlQuery)} was not informed.");
}
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = graphQlQuery.Query,
Inputs = graphQlQuery.Variables?.ToInputs()
};
return(executionOptions);
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query
};
var result = await _documentExecuter.ExecuteAsync(executionOptions);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var schema = new Schema {
Query = new AuthorQuery(blogService)
};
var result = await new DocumentExecuter().ExecuteAsync(x =>
{
x.Schema = schema;
x.Query = query.Query;
x.Inputs = query.Variables;
});
if (result.Errors?.Count > 0)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <object> Post([FromBody] GraphQlQuery query)
{
var schema = new Schema {
Query = new ArticleCatalogue(dataService)
};
var result = await new DocumentExecuter().ExecuteAsync(x =>
{
x.Schema = schema;
x.Query = query.Query;
x.Inputs = query.Variables;
});
if (result.Errors?.Count > 0)
{
return(string.Empty);
}
return(result);
}
/// <summary>
/// Resolves all queries on guest accesses
/// </summary>
/// <param name="graphQlQuery"></param>
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// TOPICS OVERVIEW
graphQlQuery.FieldAsync <ListGraphType <TopicOverviewType> >(
"topicsOverview",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "language"
}
),
resolve: async(context) =>
{
var result = await _topicsOverviewUseCase.Handle(
new TopicsOverviewRequest(context.GetArgument <string>("language"))
);
// map entity to model
return(_mapper.Map <List <TopicOverviewModel> >(result.Topics));
}
);
// LANGUAGES: a list of all lang codes
graphQlQuery.FieldAsync <TopicDetailType>(
"topicDetail",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "topicId"
}
),
resolve: async(context) =>
{
var result = await _topicDetailUseCase.Handle(
new TopicDetailRequest(context.GetArgument <string>("topicId"))
);
var truncatedDescriptionResult = result with {
Channels = TruncateChannelDescriptions(result.Channels)
};
// map entity to model
return(_mapper.Map <TopicDetailModel>(truncatedDescriptionResult));
}
);
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var inputs = query.Variables.ToInputs();
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = query.Query;
_.OperationName = query.OperationName;
_.Inputs = inputs;
});
if (result.Errors?.Count > 0)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var schema = new Schema {
Query = new StarWarsQuery()
};
var result = await new DocumentExecuter().ExecuteAsync(x =>
{
x.Schema = schema;
x.Query = query.Query;
});
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
public void ResolveQuery(GraphQlQuery graphQlQuery)
{
// IDENTIFY CHANNELS: take a list of url hints and identify sailing channels from them
graphQlQuery.FieldAsync <ListGraphType <ChannelIdentificationType> >(
"channelSuggestions",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ListGraphType <StringGraphType> > > {
Name = "channelIds"
},
new QueryArgument <StringGraphType> {
Name = "source"
}
),
resolve: async(context) =>
{
// read user context dictionary
var userContext = (GraphQlUserContext)context.UserContext;
var userId = userContext.GetUserId();
// require user to be authenticated
if (userId == null)
{
return(null);
}
var result = await _channelSuggestionsUseCase.Handle(
new ChannelSuggestionsRequest(
context.GetArgument <List <string> >("channelIds"),
userId,
context.GetArgument <string>("source")
)
);
var truncatedSuggestions =
TruncateChannelIdentificationDescription(result.Suggestions);
// map entity to model
return(_mapper.Map <List <ChannelIdentificationModel> >(truncatedSuggestions));
}
);
}
public async Task <IActionResult> Post([FromBody] GraphQlQuery query)
{
var extractedApiKey = ExtractApiKey();
if (!extractedApiKey.HasValue || extractedApiKey.Value.Equals(Startup.Configuration.GetValue <Guid>("GlobalAdminKey")))
{
return(Unauthorized());
}
var executionOptions = new ExecutionOptions {
Schema = _schema, Query = query.Query
};
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest(result.Errors));
}
return(Ok(result));
}
