static void Main(string[] args) { using (GraphQLClient client = new GraphQLClient(StoreAddress)) { GraphQLRequest request = new GraphQLRequest { Query = "query {getDistributorProduct(id: 107891) {id price stock ean}}" }; var response = client.PostAsync(request); // tu trzeba Result łapać bo żadanie nie jest await'owany if (response.Result.Data != null) { Console.WriteLine(response.Result.Data); } else { Console.WriteLine("Błąd "); } } Console.WriteLine("Done. Press any key to exit.."); Console.ReadLine(); }
public static GraphQLClient GetClientInstance() { lock (locker){ if (client == null) { Console.WriteLine("{ AuthenticatedGraphQLClient } Creating authenticated graphql client."); string ksvcsURI = Environment.GetEnvironmentVariable("REMOTE_KSVC_ENDPOINT_URL"); if (String.IsNullOrWhiteSpace(ksvcsURI)) { throw new Exception("REMOTE_KSVC_ENDPOINT_URL environment variable is null/empty."); } client = new GraphQLClient(ksvcsURI); // Pass names of environment variables to OAuth fetcher to get credentials. var authFetcher = OAuthFetcher.CreateFetcherUsingEnvironmentVariableNames( "MACHINE_TO_MACHINE_APP_AUTH_DOMAIN", "MACHINE_TO_MACHINE_APP_AUTH_CLIENT_ID", "MACHINE_TO_MACHINE_APP_AUTH_CLIENT_SECRET", "MACHINE_TO_MACHINE_APP_AUTH_IDENTIFIER"); var oauth = authFetcher.GetOAuthToken(); if (oauth != null) { client.DefaultRequestHeaders.Add("Authorization", $"Bearer {oauth.AccessToken??""}"); } return(client); } else { return(client); } } }
public async Task <JsonResult> Test1() { string query = "query getAllCourses { getCourses { id name } }"; var heroRequest = new GraphQLRequest { Query = query, OperationName = "SchoolQuery" }; var graphQLClient = new GraphQLClient("http://localhost:13515/api/school"); var graphQLResponse = await graphQLClient.PostAsync(heroRequest); string json = JsonConvert.SerializeObject(graphQLResponse.Data); var result = JsonConvert.DeserializeObject <Dictionary <string, List <Course> > >(json); List <Course> courses = new List <Course>(); foreach (var obj in result.Values.ElementAt(0)) { Course course = new Course(); course.Id = obj.Id; course.Name = obj.Name; courses.Add(course); } return(Json(courses, JsonRequestBehavior.AllowGet)); }
/// <summary> /// Method to perform a GraphQL request for a given query, before formatting the data into a given type /// </summary> /// <param name="query">The query to execute</param> /// <param name="objectType">Enum that specifies the target parse type</param> /// <returns>GraphQLResponse formatted in the type specified</returns> public async Task <object> Perform_GraphQL_Request(string query, GitHub_Model_Types objectType) { // Create a new GraphQL request with the target query var commitData = new GraphQLRequest { Query = query }; // Create a new GraphQL client that refernces the GitHub API v4 endpoint as a base URL var client = new GraphQLClient("https://api.github.com/graphql"); // Add a "User-Agent" header to identify the request client.DefaultRequestHeaders.Add("User-Agent", "request"); // Add the GitHub API token included in secrets as a Bearer authorisation token. Required to authorise the request client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _config.Access_Token); // Get the request response var response = await client.PostAsync(commitData); // Convert the data to the target type and return return(Convert_GraphQL_Response_Data(response, objectType)); }
public async Task <string> GraphqlConexionString(string query, bool requiredToken) { try { var GraphQLApiUrl = Environment.GetEnvironmentVariable("GRAPHQL_URI"); var requestHeaders = new NameValueCollection(); if (!requiredToken) { var JWToken = _identityHelper.GetCurrentToken(); requestHeaders.Add("Authorization", $"Bearer {JWToken}"); } IGraphQLClient graphQLClient = new GraphQLClient(new HttpClient(), GraphQLApiUrl, requestHeaders); var responseBodySTring = await graphQLClient.QueryAsync(query); return(responseBodySTring); } catch (Exception) { return(null); } }
public static async Task <T> QueryAsync <T>(string query) { var req = new GraphQLRequest(); req.Query = query; try { var graphQLClient = new GraphQLClient("http://192.168.0.248:4000/graphql"); var post = await graphQLClient.PostAsync(req); Console.WriteLine("dostalem: " + post.Data.ToString()); // JsonConvert.Des var deserialized = JsonConvert.DeserializeObject <T>(post.Data.ToString()); return(deserialized); } catch (Exception ex) { Console.WriteLine("GraphQl request failed: " + query + " msg: " + ex.Message); return(default(T)); } }
protected override async void OnAppearing() { base.OnAppearing(); var client = new GraphQLClient("https://swapi.apis.guru/"); GraphQLRequest graphQLRequest = new GraphQLRequest { Query = @"query{ allFilms { films { title director } } }" }; GraphQLResponse graphQLResponse = await client.PostAsync(graphQLRequest); FilmData.ItemsSource = graphQLResponse.Data.allFilms.films.ToObject <List <Film> >(); }
public static async Task <T> PostQueryAsync <T>(string endpoint, string query, string section, CancellationToken?token = null) { var gqlClient = new GraphQLClient(endpoint, new GraphQLClientOptions { MediaType = new MediaTypeHeaderValue("application/json") }); try { var gqlResponse = await gqlClient.PostQueryAsync(query, token ?? CancellationToken.None); if (gqlResponse.Errors?.Length > 0) { throw new GraphQLException(gqlResponse.Errors[0]); } var result = gqlResponse.GetDataFieldAs <T>(section); return(result); } finally { gqlClient.Dispose(); } }
public async Task StartAsync(IDialogContext context) { var reply = context.MakeMessage(); HeroCard card = new HeroCard(); var query = @"query { viewer{ name repositories(first: 100) { nodes { name } } } }"; var client = new GraphQLClient(); string data = client.Query(query, null); AllRepository obj = Newtonsoft.Json.JsonConvert.DeserializeObject <AllRepository>(data); List <CardAction> button = new List <CardAction>(); CardAction cardAction; foreach (Node1 rep in obj.data.viewer.repositories.nodes) { cardAction = new CardAction(ActionTypes.ImBack, rep.name, value: rep.name); button.Add(cardAction); } card.Title = "Below are your repositories"; card.Subtitle = "To get detail click on it"; card.Buttons = button; Attachment attachment = card.ToAttachment(); reply.Attachments.Add(attachment); await context.PostAsync(reply); context.Wait(RepositoryDetailData); }
public async Task <IActionResult> Index() { var query = @"query($id:String!, $time:DateTime) { stopPlace (id: $id) { id, name, estimatedCalls (startTime:$time, timeRange: 72100, numberOfDepartures: 10) {realtime, aimedArrivalTime expectedArrivalTime, date, destinationDisplay {frontText} } } }"; var request = new GraphQLRequest() { Query = query, Variables = new { id = "NSR:StopPlace:4000", time = "2019-10-20T14:30:00+0200" } }; var graphQLClient = new GraphQLClient("https://api.entur.io/journey-planner/v2/graphql"); graphQLClient.DefaultRequestHeaders.Add("ET-Client-Name", "test"); var graphQLResponse = await graphQLClient.PostAsync(request); var temp = graphQLResponse.GetDataFieldAs <StopPlace>("stopPlace"); for (int i = 0; i < temp.EstimatedCalls.Count; i++) { DateTime aimedTime = DateTime.Parse(temp.EstimatedCalls[i].AimedArrivalTime); DateTime expectedTime = DateTime.Parse(temp.EstimatedCalls[i].ExpectedArrivalTime); if (expectedTime > aimedTime) { temp.EstimatedCalls[i].Late = true; } else { temp.EstimatedCalls[i].Late = false; } } return(View(temp)); }
public Task <TreeNode> GetNodeAsync(int Id) { TreeNode aux_node = null; GraphQLRequest request = new GraphQLRequest { Query = @" { node(id:" + Id + @") { id, parentId, label, date } }" }; var graphQLClient = new GraphQLClient("http://localhost:6000/api/nodes"); System.Console.WriteLine($"-- to POST {Id}"); try { var graphQLResponse = graphQLClient.PostAsync(request).GetAwaiter().GetResult(); //var graphQLResponse = graphQLClient.Post(request); var x = graphQLResponse.Data.node; System.Console.WriteLine(x); aux_node = x.ToObject <TreeNode>(); } catch (Exception e) { System.Console.WriteLine(e); } System.Console.WriteLine("-- after POST"); return(Task.FromResult(aux_node)); }
protected override async void OnAppearing() { var client = new GraphQLClient("https://swapi.apis.guru/"); GraphQLRequest graphQlRequest = new GraphQLRequest() { Query = "query{ allFilms{ films { id,title,director } }}" }; GraphQLResponse graphQLResponse = await client.PostAsync(graphQlRequest); List <Film> films = graphQLResponse.Data.allFilms.films.ToObject <List <Film> >(); film_list.ItemsSource = films; base.OnAppearing(); }
public async Task <List <string> > GetDonor() { var result = new List <string>(); var donorRequest = new GraphQLRequest() { Query = @" query { viewer { sponsorshipsAsMaintainer (includePrivate: true, first: 100) { nodes { sponsor { login, databaseId } } } } }" }; var grapqlClient = new GraphQLClient("https://api.github.com/graphql"); grapqlClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_githubApiConfiguration.Token}"); grapqlClient.DefaultRequestHeaders.Add("User-Agent", "listrr.pro graphql client"); var graphqlResponse = await grapqlClient.PostAsync(donorRequest); foreach (var node in graphqlResponse.Data.viewer.sponsorshipsAsMaintainer.nodes) { result.Add(node.sponsor.databaseId.ToString()); } return(result); }
static dynamic do_query_with_caching(string query, IDatabase redisDB, GraphQLClient graphQL) { // Try to get the query result from redis // Check if a result was returned (the query IS in the cache) if () // If the query IS NOT in the cache { // Issue graphQL query // Convert graphQL response to JSON string // Conditionally store result in Redis cache if () { // Add to cache } // Return JObject } else // The query IS in the cache { // Parse JSON string into JObject and return } }
public IEnumerator QueryWithArgs() { var client = new GraphQLClient(Uri); var request = new Request { Query = "query ContinentNameByCode($code: ID!) { continent(code: $code) { name } }", Variables = new { code = "EU" } }; var responseType = new { continent = new { name = "" } }; var response = client.Send(() => responseType, request); yield return(response.AsCoroutine()); Assert.IsNull(response.Result.Errors); var data = response.Result.Data; Assert.IsNotNull(data); Assert.IsNotNull(data.continent); Assert.AreEqual(data.continent.name, "Europe"); }
public async Task GetCountryInvalidQuery() { var query = @"query($id:String){ Country{ name} Timezone{ _id countries(_id:$id) } }"; var variables = new { id = "51" }; try { var responseObject = await GraphQLClient.QueryAsync(query, variables); var countryList = responseObject.GetParsedData <CountryList>(); } catch (GraphQLException ex) { //ReportEvent.Fail(Constants.currentTest, "Bad Response from Server: " + ex.StatusCode); ReportHelper.LogFail(currentTest, "Exception Occured: Message: " + ex.Error.ToString()); } }
protected async Task <GraphQLResponse> PostRequestAsync( string query) { var token = await _tokenService.RequestTokenAsync(); if (token == null) { return(null); } SetHeader(token); try { var graphQLRequest = new GraphQLRequest() { Query = query }; var response = await GraphQLClient.PostAsync(graphQLRequest); if (response.Errors != null) { HandleGraphQlError($"Error occurred while upload HomeMatic values with GraphQL.", response); return(null); } return(response); } catch (Exception ex) { _logger.LogError(2232, ex, $"Error occurred while uploading HomeMatic values with GraphQL"); // '{content}'."); return(null); } }
public static async Task <List <DSCity> > GetCitiesByPattern(string pattern) { var apiKey = ConfigurationManager.AppSetting["AppSettings:DonorSearchApiKey"]; var apiPath = ConfigurationManager.AppSetting["AppSettings:DonorSearchApiPath"]; var cities = new List <DSCity>(); using (var graphQlClient = new GraphQLClient(apiPath + apiKey)) { var cityRequest = new GraphQLRequest { Query = @"query cities($title: String) { cities(title: $title) { id title area region { id title } country { id title } } }", OperationName = "cities", Variables = new { title = pattern } }; var graphQlResponse = await graphQlClient.PostAsync(cityRequest); cities = graphQlResponse.GetDataFieldAs <List <DSCity> >("cities"); } return(cities); }
public async Task <GraphQLResponse> RunQuery(string query, IList <KeyValuePair <string, string> > variables) { var request = new GraphQLRequest { Query = query, Variables = variables }; if (_graphQlClient == null) { _graphQlClient = new GraphQLClient(GitHubApiPath) { DefaultRequestHeaders = { Authorization = new AuthenticationHeaderValue("Bearer", _tokenFunc.Invoke()) } }; _graphQlClient.DefaultRequestHeaders.Add("User-Agent", _user); } var graphQlResponse = await _graphQlClient.PostAsync(request); return(graphQlResponse); }
public static async Task <BoardsQueryResultData> GetBoards() { var graphQLClient = new GraphQLClient("https://api.monday.com/v2"); graphQLClient.DefaultRequestHeaders.Add("Authorization", Config("MDC_API_TOKEN")); var boardsQueryRequest = new GraphQL.Common.Request.GraphQLRequest { Query = @"{ boards { id name columns { title id type } groups { title id } } }" }; try { var graphQLResponse = await graphQLClient.PostAsync(boardsQueryRequest); return(graphQLResponse.Data.ToObject <BoardsQueryResultData>()); } catch (Exception e) { Error(e, "Error retrieving boards from monday.com API."); return(null); } }
/// <summary> /// Return a fully constructed Public Content Api client /// </summary> /// <returns>Public Content Api Client</returns> public Sdl.Tridion.Api.Client.ApiClient CreateClient() { var graphQl = new GraphQLClient(_endpoint, new Logger(), _oauth); var client = new Sdl.Tridion.Api.Client.ApiClient(graphQl, new Logger()) { // Make sure our requests come back as R2 json DefaultModelType = DataModelType.R2 }; // Add context data to client var claimStore = AmbientDataContext.CurrentClaimStore; if (claimStore == null) { Log.Debug("No claimstore found (is the ADF module configured in the Web.Config?) so unable to populate claims for PCA."); } var headers = claimStore?.Get <Dictionary <string, string[]> >(new Uri(WebClaims.REQUEST_HEADERS)); if (headers != null && headers.ContainsKey(PreviewSessionTokenHeader)) { Log.Debug($"Adding {PreviewSessionTokenHeader} to client."); client.HttpClient.Headers[PreviewSessionTokenHeader] = headers[PreviewSessionTokenHeader]; } var cookies = claimStore?.Get <Dictionary <string, string> >(new Uri(WebClaims.REQUEST_COOKIES)); if (cookies != null && cookies.ContainsKey(PreviewSessionTokenCookie)) { Log.Debug($"Adding {PreviewSessionTokenCookie} to client."); client.HttpClient.Headers[PreviewSessionTokenHeader] = cookies[PreviewSessionTokenCookie]; } foreach (var claim in _globalClaimValues) { Log.Debug($"Forwarding on global claim {claim.Key} with value {claim.Value}"); client.GlobalContextData.ClaimValues.Add(claim.Value); } if (!_claimForwarding) { Log.Debug("Claim forwarding from the claimstore has been disabled. Set pca-claim-forwarding to true in your appSettings to allow forwarding."); return(client); } if (claimStore == null) { Log.Debug("The claimstore is not available so no claim forwarding from claimstore will be performed. Make sure the ADF module is configured in the Web.Config to enable this option."); return(client); } // Forward all claims var forwardedClaimValues = AmbientDataContext.ForwardedClaims; if (forwardedClaimValues == null || forwardedClaimValues.Count <= 0) { return(client); } var forwardedClaims = forwardedClaimValues.Select(claim => new Uri(claim, UriKind.RelativeOrAbsolute)) .Distinct() .Where(uri => claimStore.Contains(uri) && claimStore.Get <object>(uri) != null && !uri.ToString().Equals("taf:session:preview:preview_session")) .ToDictionary(uri => uri, uri => claimStore.Get <object>(uri)); if (forwardedClaims.Count <= 0) { Log.Debug("No claims from claimstore to forward."); return(client); } foreach (var claim in forwardedClaims) { Log.Debug($"Forwarding claim {claim.Key} from claimstore to PCA client."); client.GlobalContextData.ClaimValues.Add(new ClaimValue { Uri = claim.Key.ToString(), Value = JsonConvert.SerializeObject(claim.Value), Type = ClaimValueType.STRING }); } return(client); }
private void Awake() { DontDestroyOnLoad(this.gameObject); client = new GraphQLClient(apiUrl); }
public ClientOrderRepository(GraphQLClient client) : base(client) { }
public ProductGraphClient(GraphQLClient client) { _client = client; }
public ProxyWrapper(Uri host) { AdministrationUri = host; AdministrationClient = new RestClient(host); GraphQLClient = new GraphQLClient($"{host}graphql"); }
public ReservationGraphqlClient(GraphQLClient client) { _client = client; }
protected override async void OnAppearing() { //ResponseLabel.Text = "Fetching data"; //var client = new HttpClient(); //client.DefaultRequestHeaders.Add("Authorization", ""); //client.DefaultRequestHeaders.Add("User-Agent", ""); //var stringContent = new StringContent "{/ "query { user(login: manavbliss) { bio, id, company, name, createdAt } }\"}"}; //var httpRes //var client = new GraphQLClient("https://api.github.com/graphql"); var client = new GraphQLClient("https://swapi.apis.guru/"); // client.DefaultRequestHeaders.Add("User-Agent", "Graphql Api"); //client.DefaultRequestHeaders.Add("Authorization", "bearer 7e434a81dcf48fc753e4aceca78e5c9174747bcc"); //var stringContent = new StringContent("{\"query\":\"query {user(login: manavbliss) { bio, id, company, name, createdAt } }\"}"); GraphQLRequest graphQlRequest = new GraphQLRequest() { //Query = "query {user(login: manavbliss) { bio,id,company,name,createdAt }}" Query = "query{ allFilms{ films { id,title,episodeID,director } }}" }; GraphQLResponse graphQLResponse = await client.PostAsync(graphQlRequest); //List<Film> films = graphQLResponse.Data.allFilms.films; //List<Film> items = ((JArray)Array).Select(x => new SelectableEnumItem //{ // title = (string)x["title"], //}).ToList(); //film_list.ItemsSource = films; List <Film> films = graphQLResponse.Data.allFilms.films.ToObject <List <Film> >(); film_list.ItemsSource = films; Console.WriteLine("Manav" + films[0].Title); foreach (var film in films) { Console.WriteLine("Title {0}", film.Title); } //posts = JsonConvert.DeserializeObject<List<Models.Film>>(graphQLResponse.Data.allFilms.films.title); ////Assigning the ObservableCollection to MyListView in the XAML of this file //Post_List.ItemsSource = posts; base.OnAppearing(); }
public HomeController() { _client = new GraphQLClient(); }
public static async Task <List <HouseholdModel> > GetHouseholdsAsync() { var response = (await GraphQLClient.PostQueryAsync(Queries.HouseholdsQuery)).ThrowIfNotSuccessful(); return(response.GetDataFieldAs <List <HouseholdModel> >("households")); }
public static async Task <List <NotificationModel> > GetNotificationsAsync() { var response = (await GraphQLClient.PostQueryAsync(Queries.NotificationsQuery)).ThrowIfNotSuccessful(); return(response.GetDataFieldAs <List <NotificationModel> >("notifications")); }