public async Task <IActionResult> Index([FromRoute] int id) { var query = new GraphQLRequest { Query = @" query results ($pg: Int){ episodes (page: $pg) { info { count pages next prev } results { id name air_date episode } } }", Variables = new { pg = id } }; ViewData["Page"] = id == 0 ? 1 : id; var response = await client.SendQueryAsync <EpisodeResponseType>(query); return(View(response.Data)); }
public async Task <IActionResult> Index([FromRoute] int id = 1) { var query = new GraphQLRequest { Query = @" query results($pg: Int) { characters (page: $pg) { info { count pages next prev } results { name created id image species } } }", Variables = new { pg = id } }; var response = await client.SendQueryAsync <CharacterResponseType>(query); return(View(response.Data)); }
public async Task <List <ProductModel> > GetAllProductsAsync(CancellationToken cancellationToken = default) { var request = new GraphQLRequest { Query = @"query getAll { products { items { id name price rating photoUrl description stock introduceAt } } }", OperationName = "getAll" }; var response = await _client.SendQueryAsync( request : request, defineResponseType : () => new { products = new { items = new List <ProductModel>() } }, cancellationToken : cancellationToken); return(response.Errors?.Any() ?? default ? default : response.Data.products.items); }
public static async Task <List <T> > ExceuteQueryReturnListAsyn <T>(string graphQLQueryType, string completeQueryString) { try { var request = new GraphQLRequest { Query = completeQueryString }; var response = await graphQLHttpClient.SendQueryAsync <object>(request); var stringResult = response.Data.ToString(); stringResult = stringResult.Replace($"\"{graphQLQueryType}\":", string.Empty); stringResult = stringResult.Remove(0, 1); stringResult = stringResult.Remove(stringResult.Length - 1, 1); var result = JsonConvert.DeserializeObject <List <T> >(stringResult); return(result); } catch (Exception ex) { throw; } }
public async Task <Brand[]> GetBrands() { var request = new GraphQLRequest { Query = @"query { production { brands { id brandName } } }" }; var response = await _client.SendQueryAsync <GraphQLResponse>(request); return(response.Data.Production.Brands); }
public async Task <string> FindBrew(string gtin) { var graphQlRequest = new GraphQLRequest { Query = Queries.BrewByGtin, Variables = new { gtin }, }; var response = await m_client.SendQueryAsync(graphQlRequest, () => new { Id = "" }); return(response.Data.Id); }
public async Task Can_Get_All_Theatres() { var query = new GraphQLHttpRequest { Query = Query, OperationName = "AllTheatres", }; var response = await _graphQlHttpClient.SendQueryAsync <TheatreResponseCollectionType>(query); response.Errors.Should().BeNull(); response.Data.Theatres.Count.Should().BePositive(); }
private async Task <string> FetchResult(CancellationToken cancellationToken) { string query = @" query JobStatus($id: String!) { job(id: $id) { id ready status result } } "; var request = new GraphQLRequest() { Query = query, OperationName = "JobStatus", Variables = new { id = Id } }; var response = await _graphQLHttpClient.SendQueryAsync <dynamic>(request, cancellationToken); if (response.Errors != null) { throw new GraphQLException(response.Errors); } var job = response.Data.job; string status = (string)job.status; var jobStatus = (JobStatus)Enum.Parse(typeof(JobStatus), status); if (jobStatus != JobStatus.SUCCESS) { throw new RuntimeException($"Job finished with status : {status}"); } var result = job.result; if (result == null) { throw new RuntimeException("Job has finished with no results"); } string output = (string)result; return(output); }
public async Task <IActionResult> Index() { var query = new GraphQLRequest { Query = @" query { characters { results { id name } } episodes{ results { id name } } locations { results { id name } } }" }; var response = await client.SendQueryAsync <FullResponseType>(query); return(View(response.Data)); }
public async Task <List <TResult> > GetPages <TResponse, TResult>(GraphQLHttpRequest req, Func <TResponse, IEnumerable <TResult> > process) { PageInfo pageInfo = null; var result = new List <TResult>(); do { if (pageInfo != null) { ((QueryParams)req.Variables).After = pageInfo.EndCursor; } var res = await Policy .WrapAsync(httpRetryPolicies) .ExecuteAsync(() => client.SendQueryAsync <TResponse>(req)); if (res.Errors?.Count() > 0) { return(result); } result.AddRange(process(res.Data)); pageInfo = HasPagingInfo(res); }while (pageInfo != null && pageInfo.HasNextPage); return(result); }
public async Task <string> Get() { var graphQLClient = new GraphQLHttpClient("http://*****:*****@"query{ materials{ id name description gwp_z concrete_scm_details{ fly_ash } pct80_gwp_per_category_declared_unit manufacturer{ name alt_names location{ country postalCode } } plant{ name alt_names location{ localName } owned_by{ name location{ country } } } } } " }; var response = await graphQLClient.SendQueryAsync(request, () => new { materials = new List <Material>() }); List <Material> materials = response.Data.materials; for (int i = 0; i < materials.Count; i++) { DebugOutput("Amount of materials: " + i); } if (response.Errors != null && response.Errors.Any()) { throw new ApplicationException(response.Errors[0].Message); } return(JsonSerializer.Serialize(response, new JsonSerializerOptions { WriteIndented = true })); }
static void Main(string[] args) { /* var graphClient = new GraphQLClient("http://*****:*****@"query { viewer { login } }" * }; * var test = graphClient.PostAsync(request).Result;*/ using (var graphQLHttpClient = new GraphQLHttpClient("http://*****:*****@"bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyaWQiOiIzIiwidW5pcXVlX25hbWUiOiJ2aWN0b3J5IiwiZW1haWwiOiJ2aWN0b3JpYXJhZGV2YUB5YWhvby5jby5ueiIsImZpcnN0bmFtZSI6IlZpY3RvcmlhIiwibGFzdG5hbWUiOiJSYWRldmEiLCJyb2xlIjoiQWRtaW4iLCJuYmYiOjE1Mzk1MTU1MzYsImV4cCI6MTUzOTUxNzMzNiwiaWF0IjoxNTM5NTE1NTM2LCJpc3MiOiJTbWFydFN0b3JlcyIsImF1ZCI6IkN1c3RvbUNsaWVudCJ9.9XxG8i0WLGhRoWA97NDl98V4J3a9nCOIaH8CYoqN1OY"); var result = graphQLHttpClient.SendQueryAsync(@" { orders { id } } " ).Result; Console.WriteLine(result.Data); Console.ReadKey(); } }
public async Task <ClassificationCounts> GetReductionAsync(string subjectId) { GraphQLResponse response = new GraphQLResponse(); var answersRequest = new GraphQLRequest { Query = @" query AnswerCount($workflowId: ID!, $subjectId: ID!) { workflow(id: $workflowId) { subject_reductions(subjectId: $subjectId, reducerKey: T0_Stats) { data } } }", OperationName = "AnswerCount", Variables = new { workflowId = Config.WorkflowId, subjectId } }; try { response = await GraphQLClient.SendQueryAsync(answersRequest); } catch (System.Exception e) { System.Console.WriteLine("Graph QL Error: {0}", e.Message); } return(ParseGraphQLResponse(response)); }
public async void SendQueryAsyncShouldPreserveUriParametersFact() { var endpoint = new Uri("http://localhost/api/graphql?code=my-secret-api-key"); var handlerStub = new HttpHandlerStub(); GraphQLHttpClientOptions options = new GraphQLHttpClientOptions() { EndPoint = endpoint, HttpMessageHandler = handlerStub }; GraphQLHttpClient systemUnderTest = new GraphQLHttpClient(options); var response = await systemUnderTest.SendQueryAsync(new GraphQLRequest { Query = @" { person(personID: ""1"") { name } }" }); var actualRequestUri = handlerStub.LastRequest.RequestUri; var queryParams = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(actualRequestUri.Query); Assert.True(queryParams.ContainsKey("code"), "Expected code query parameter to be preserved"); Assert.Equal("my-secret-api-key", queryParams["code"]); }
private UserData GetUsers(GraphQLRequest request) { var response = _client.SendQueryAsync <object>(request); var result = JsonConvert.DeserializeObject <UserData>(response.Result.Data.ToString()); return(result); }
public async static Task NewOrdersQuery() { using (var graphQLClient = new GraphQLHttpClient("https://*****:*****@" query { newOrders { id addressLine1 addressLine2 amount } }" }; var newOrderResponse = await graphQLClient.SendQueryAsync <NewOrdersResponse>(newOrdersQuery); foreach (var newOrderDetail in newOrderResponse.Data.NewOrders) { Console.WriteLine("~~~~~~~~~~~~~~~~~~~~"); Console.WriteLine(); Console.WriteLine($"{nameof(NewOrderDetail.Id)}: {newOrderDetail.Id}"); Console.WriteLine($"{nameof(NewOrderDetail.AddressLine1)}: {newOrderDetail.AddressLine1}"); Console.WriteLine($"{nameof(NewOrderDetail.AddressLine2)}: {newOrderDetail.AddressLine2}"); Console.WriteLine($"{nameof(NewOrderDetail.Amount)}: {newOrderDetail.Amount}"); Console.WriteLine(); Console.WriteLine("~~~~~~~~~~~~~~~~~~~~"); } } }
/// <summary> /// Gets the basic information about a server. /// </summary> /// <param name="serverUrl"></param> /// <returns></returns> public static async Task <ServerInfo> GetServerInfo(string serverUrl) { using var httpClient = new HttpClient(); using var gqlClient = new GraphQLHttpClient(new GraphQLHttpClientOptions() { EndPoint = new Uri(new Uri(serverUrl), "/graphql") }, new NewtonsoftJsonSerializer(), httpClient); var request = new GraphQLRequest { Query = @" query { serverInfo { name company } }" }; var response = await gqlClient.SendQueryAsync <ServerInfoResponse>(request); if (response.Errors != null) { return(null); } response.Data.serverInfo.url = serverUrl; return(response.Data.serverInfo); }
/// <summary> /// Executes the query and returns a responseEntity of type passed </summary> /// <param name="url"> </param> /// <param name="auth"> </param> /// <param name="query"> </param> /// <param name="Variables"> </param> /// <param name="tClass"> /// @return </param> public async Task <GraphQLResponse <dynamic> > GraphqlExecute(string url, string query, IDictionary <string, object> variables, GraphQLOptions opts) { GraphQLHttpClient graphClient = new GraphQLHttpClient(url, new NewtonsoftJsonSerializer()); graphClient.HttpClient.DefaultRequestHeaders.Add("User-Agent", this.userAgent); graphClient.HttpClient.DefaultRequestHeaders.Add("Authorization", await this.GetAuthorizationHeader(null)); GraphQLRequestCamel request = new GraphQLRequestCamel(query, variables); try { return(await graphClient.SendQueryAsync <dynamic>(request)); } catch (GraphQLHttpRequestException e) { if (opts == null) { opts = defaultGraphQLOptions; } int retry = opts.Retry; // handle errors explicitly // extract the status from the error response // if 401 and retry > 0 then we can retry if (e.StatusCode == HttpStatusCode.Unauthorized && retry > 0) { // unauthenticated request might be because token expired // clear token and retry this.ClearToken(); opts.Retry -= 1; return(await this.GraphqlExecute(url, query, variables, opts)); } // otherwise rethrow throw new TraceSdkException(e.Content); } }
static async Task Main(string[] args) { var options = new GraphQLHttpClientOptions { UseWebSocketForQueriesAndMutations = false, EndPoint = new System.Uri("https://*****:*****@" query northwindQuery { customers { customerId, companyName, contactName } }" }; var response = await client.SendQueryAsync <CustomerResponse>(request); var x = response.Data.Customers.FirstOrDefault(); }
public async Task <dynamic> ExecuteQueryAsync(string query, Dictionary <string, object> args) { try { if (_client == null) { _client = new GraphQLHttpClient(_endPointUrl); } dynamic eo = null; if (args != null && args.Count > 0) { eo = args.Aggregate(new ExpandoObject() as IDictionary <string, Object>, (a, p) => { a.Add(p.Key, p.Value); return(a); }); } var assentRequest = new GraphQLRequest() { Query = query, Variables = eo }; var graphQLResponse = await _client.SendQueryAsync(assentRequest);// SendQueryAsync(assentRequest); return(graphQLResponse.Data); } catch (Exception ex) { return(ex.Message); } }
static async Task Main(string[] args) { var options = new GraphQLHttpClientOptions { EndPoint = new Uri("http://echo.somee.com/netflixgraph/graphql"), }; var client = new GraphQLHttpClient(options, new NewtonsoftJsonSerializer()); var query = "{ actionShows { casts } }"; var request = new GraphQLHttpRequest { Query = query }; var graphQLResponse = await client.SendQueryAsync <object>(request); var stringResult = graphQLResponse.Data.ToString(); //stringResult = stringResult.Replace($"\"actionShows\":", string.Empty); //stringResult = stringResult.Remove(0, 1); //stringResult = stringResult.Remove(stringResult.Length - 1, 1); var result = JsonConvert.DeserializeObject <Data>(stringResult.ToString()); for (int i = 0; i < result.ActionShows.Length; i++) { Console.WriteLine(result.ActionShows[i].Casts); } Console.Read(); }
/// <summary> /// Performs a GraphQL query with the specified query text and returns the specified type. /// </summary> /// <typeparam name="T">The type of the result</typeparam> /// <param name="query">The query to perform</param> /// <param name="key">The key to get for the data</param> /// <returns>The result data</returns> protected async Task <T> QueryAsync <T>(string query, string key) { try { GraphQLHttpClient client = await this.GetGraphQLClient(); GraphQLResponse <JObject> response = await client.SendQueryAsync <JObject>(new GraphQLRequest(query)); Logger.Log(LogLevel.Debug, JSONSerializerHelper.SerializeToString(response)); if (response.Errors != null && response.Errors.Length > 0) { foreach (GraphQLError error in response.Errors) { Logger.Log(LogLevel.Error, $"GraphQL Query Error: {query} - {error.Message}"); } } if (response.Data != null && response.Data.ContainsKey(key)) { return(response.Data[key].ToObject <T>()); } } catch (Exception ex) { Logger.Log(ex); } return(default(T)); }
static async Task Main(string[] args) { using var graphQLClient = new GraphQLHttpClient("http://wish.mirero.co.kr/api/graphql", new SystemTextJsonSerializer()); var Request = new GraphQLRequest { Query = @" { project(fullPath: ""mirero/team/solution-group/bootcamp"") { name issues(createdAfter: ""2020-07-10T00:00:00"") { nodes { title } pageInfo { endCursor hasNextPage } } } }" }; var graphQLResponse = await graphQLClient.SendQueryAsync <Response>(Request); Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true })); }
public static async Task Main(string[] args) { using var graphQLClient = new GraphQLHttpClient("#TutajWkleićUrl"); var testRequest = new GraphQLRequest { Query = @" query { getDistributorProduct(id: ""71889"") { id key ean } }" , }; var graphQLResponse = await graphQLClient.SendQueryAsync <GetDistributorProductResponse>(testRequest); Console.WriteLine("raw response:"); Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true })); Console.WriteLine(); Console.WriteLine("Press any key to quit..."); Console.ReadKey(); }
public static async Task <WarcraftLogsDamageResponse> GetResponse(string bearerToken, string combatEncounterId, WarcraftLogsDamageResponse.TableDataType tdt) { using (var graphQLClient = new GraphQLHttpClient(WARCRAFTLOGS_GRAPHQL_ENDPOINT, new SystemTextJsonSerializer())) { graphQLClient.HttpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {bearerToken}"); var dpsChartRequest = new GraphQLRequest { Query = @"query($combatId: String, $tdt: TableDataType, $timestampEnd: Float){ reportData{ report(code: $combatId) { table(dataType: $tdt, startTime: 0, endTime: $timestampEnd) } } }", Variables = new { combatId = combatEncounterId, tdt = tdt.ToString(), timestampEnd = (float)DateTimeOffset.UtcNow.ToUnixTimeSeconds() } }; var response = await graphQLClient.SendQueryAsync <WarcraftLogsDamageResponse>(dpsChartRequest); return(response.Data); } }
private async Task GetLaunch() { Launch = null; var launchRequest = new GraphQLRequest { Query = @"query getLaunch($id: ID!) { launch(id: $id) { id is_tentative upcoming mission_name links { article_link video_link flickr_images mission_patch } launch_date_utc details } }", Variables = new { id = _launchId, } }; var response = await _client.SendQueryAsync <Types.Query>(launchRequest); if (!(response.Errors ?? Array.Empty <GraphQLError>()).Any()) { Launch = response.Data.launch; } }
/// <summary> /// Gets basic user information given a token and a server. /// </summary> /// <param name="token"></param> /// <param name="url"></param> /// <returns></returns> public static async Task <UserInfo> GetUserInfo(string token, string url) { using var httpClient = new HttpClient(); httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}"); using var gqlClient = new GraphQLHttpClient(new GraphQLHttpClientOptions() { EndPoint = new Uri(new Uri(url), "/graphql") }, new NewtonsoftJsonSerializer(), httpClient); var request = new GraphQLRequest { Query = @" query { user { name email id company } }" }; var response = await gqlClient.SendQueryAsync <UserInfoResponse>(request); if (response.Errors != null) { return(null); } return(response.Data.user); }
private static async Task GetAllMovies(GraphQLHttpClient _gqlClient) { //Query q = new Query(); string queryText = $"query{{movies{{movieID, title}}}}"; string queryName = "movies"; try { var request = new GraphQLRequest { Query = queryText }; var response = await _gqlClient.SendQueryAsync <object>(request); string result = response.Data.ToString(); result = result.Replace($"\"{queryName}\":", string.Empty); result = result.Remove(0, 1); result = result.Remove(result.Length - 1, 1); var collection = JsonConvert.DeserializeObject <IEnumerable <Movie> >(result); foreach (Movie m in collection) { Console.WriteLine("Movie ID: {0} - Title: {1}", m.MovieID, m.Title); } } catch (Exception e) { Console.WriteLine(e.Message); } }
public async Task <IActionResult> GetCountries() { using (var graphQLClient = new GraphQLHttpClient("http://*****:*****@"{ countries { geoname_id code name iso_numeric continent continent_name capital population currency_code neighbours { geoname_id code name country_geoname_id } } }", }; return(Ok(await graphQLClient.SendQueryAsync <object>(query))); } }
/// <summary>Returns all Pokemons</summary> public async Task <IEnumerable <Pokemon> > GetAllPokemons() { var query = new Query <Pokemon>("pokemons") .AddArguments(new { first = 100 }) .AddField(p => p.Id) .AddField(p => p.Number) .AddField(p => p.Name) .AddField(p => p.Height, hq => hq .AddField(h => h.Minimum) .AddField(h => h.Maximum) ) .AddField(p => p.Weight, wq => wq .AddField(w => w.Minimum) .AddField(w => w.Maximum) ) .AddField(p => p.Types); var request = new GraphQLRequest { Query = "{" + query.Build() + "}" }; using var client = new GraphQLHttpClient(this.graphqlPokemonUrl, new NewtonsoftJsonSerializer()); GraphQLResponse <PokemonsResponse> response = await client.SendQueryAsync <PokemonsResponse>(request); return(response.Data.Pokemons); }