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"));
}
