public async Task <GraphQLResponse <T> > SendQueryAsync <T>(string query)
{
var request = new GraphQLHttpRequest
{
Query = query
};
GraphQLResponse <T> result = null;
var countIteration = 10;
for (int i = 0; i <= countIteration; i++)
{
try
{
result = await this.SendQueryAsync <T>(request);
break;
}
catch (Exception)
{
if (i == countIteration)
{
throw;
}
}
}
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
}));
}
public static async Task <string> ExecuteOperation(int[] range, int target)
{
string returnString;
try
{
var client = new GraphQLHttpClient(new GraphQLHttpClientOptions {
EndPoint = new Uri(Constants.BackendConstants.GraphQLApiUrl)
}, new NewtonsoftJsonSerializer());
var requestString = "mutation ($input:OperationInput!){combination(input:$input) { }}";
var operationInput = new
{ input = new {
target = target,
range = range
} };
var request = new GraphQLHttpRequest
{
Query = requestString,
Variables = operationInput
};
var response = await client.SendMutationAsync <Dictionary <string, int[]> >(request);
var resultString = response.Data;
returnString = String.Join(",", resultString["combination"]);
}
catch (Exception)
{
returnString = "Erro.";
}
return(returnString);
}
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);
}
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();
}
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 void Test1()
{
var client = testFixtureBase.CreateWebApplicationFactory();
var graphQLClient = new GraphQLHttpClient(new GraphQLHttpClientOptions
{
EndPoint = new Uri("http://localhost/graphql")
}, new NewtonsoftJsonSerializer(), client);
var request = new GraphQLHttpRequest
{
Query = @"{
products {
id,
name,
price,
description,
components {
id,
name,
description
}
}
}"
};
var response = await graphQLClient.SendQueryAsync <ProductQueryResponse>(request);
var product = response.Data.Products.FirstOrDefault(x => x.Id == 1);
product.Description.Should().Be("Description 1");
}
private async Task <GraphQLHttpResponse <ResponseType> > SendRequest(GraphQLHttpRequest request)
{
using var httpRequestMessage = request.ToHttpRequestMessage(_graphQLHttpClientOptions, _graphQLJsonSerializer);
using var httpResponseMessage = await _client.SendAsync(httpRequestMessage);
var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync();
if (httpResponseMessage.IsSuccessStatusCode)
{
var graphQLResponse = await JsonSerializer.DeserializeAsync <GraphQLResponse <ResponseType> >(contentStream, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
var graphQLHttpResponse = graphQLResponse.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
if (graphQLHttpResponse.Errors?.Any() ?? false)
{
var errorMessages = string.Join(", ", graphQLHttpResponse.Errors.Select(x => x.Message));
throw new HttpRequestException($"Failed to call Tibber API: {errorMessages}");
}
return(graphQLHttpResponse);
}
string content = null;
if (contentStream != null)
{
using var sr = new StreamReader(contentStream);
content = await sr.ReadToEndAsync();
}
throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
}
public async Task <ActionResult> Create(IFormCollection collection)
{
string mutation = $@"
mutation {{
createMovie(inputMovie: {{
title: ""{collection["title"]}"",
price: {collection["price"]}
}})
{{
id
title
price
}}
}}
";
GraphQLHttpClient client = new GraphQLHttpClient(BackEndConstants.GraphQLUrl, new NewtonsoftJsonSerializer());
GraphQLHttpRequest request = new GraphQLHttpRequest(mutation);
try
{
await client.SendMutationAsync <Movie>(request);
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
return(View());
}
}
public async Task Can_Create_New_Movie()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "CreateMovie",
Variables = new
{
movie = new
{
title = "Blade Runner",
description = "A blade runner must pursue and terminate four replicants who stole a ship in space, and have returned to Earth to find their creator",
yearReleased = 1982,
genre = "scifi"
}
}
};
var response = await _graphQlHttpClient.SendMutationAsync <MovieResponseType>(query);
response.Errors.Should().BeNull();
// Does not work. For unknown reasons Movie is null.
// It works in the Playground, though.
// So it must be a client problem.
// response.Data.Movie.Should().NotBeNull();
}
public async Task Can_Update_Movie()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "UpdateMovie",
Variables = new
{
movie = new
{
Id = new Guid("20DB69D0-7760-4C3F-A484-032423E61018"),
Title = "Sabrina",
Description = "An ugly duckling having undergone a remarkable change, still harbors feelings for her crush: a carefree playboy, but not before his business-focused brother has something to say about it.",
Genre = "romance",
YearReleased = 1996,
}
}
};
var response = await _graphQlHttpClient.SendMutationAsync <MovieResponseType>(query);
response.Errors.Should().BeNull();
// Does not work. For unknown reasons Movie is null.
// It works in the Playground, though.
// So it must be a client problem.
// response.Data.Movie.Should().NotBeNull();
}
public async Task <T> FetchValuesAsync <T>(
string query)
{
var request = new GraphQLHttpRequest(query);
var response = await _httpClient.SendQueryAsync <T>(request);
return(response.Data);
}
public Task <GraphQLResponse <T> > SendQueryAsync <T>(string query, object variables)
{
var request = new GraphQLHttpRequest
{
Query = query,
Variables = variables
};
return(_client.SendQueryAsync <T>(request));
}
public async Task <Option <IEnumerable <Repository>, AllegroApiException> > GetUserRepositoriesAsync(string username)
{
string query = _embeddedResourceService.GetResource("Me.Bartecki.Allegro.Infrastructure.Integrations.RepositoryStores.GitHub.GitHubQuery.graphql");
try
{
bool isNextPageAvailable = false;
string nextPageId = null;
List <GitHubRepository> repositories = new List <GitHubRepository>();
do
{
var request = new GraphQLHttpRequest(query,
new
{
username = username,
nextCursorId = nextPageId
});
var response = await _client.SendQueryAsync <RootResponse>(request);
if (response.Errors?.Any() == true)
{
return(GetException(response));
}
repositories.AddRange(response.Data.User.Repositories.Nodes);
//Handle pagination
var pageInfo = response.Data.User.Repositories.PageInfo;
isNextPageAvailable = pageInfo.HasNextPage;
if (isNextPageAvailable)
{
nextPageId = pageInfo.EndCursor;
}
} while (isNextPageAvailable);
return(Option.Some <IEnumerable <Repository>, AllegroApiException>(repositories.Select(Convert)));
}
catch (GraphQLHttpException httpRequestException) when(
httpRequestException.HttpResponseMessage.StatusCode == HttpStatusCode.Unauthorized)
{
//Rethrow this exception, critical misconfiguration.
throw;
}
catch (GraphQLHttpException httpRequestException)
{
var errorCode = ErrorCodes.RepositorySource_UnableToReach;
var apiException = new AllegroApiException(
errorCode,
httpRequestException.Message,
httpRequestException);
return(Option.None <IEnumerable <Repository>, AllegroApiException>(apiException));
}
}
private async Task <List <ArticleData> > GetArticleData(string query)
{
var request = new GraphQLHttpRequest
{
Query = $"{{searchPages(query: \"{query}\") {{url wikidotInfo {{title rating}} " +
$"alternateTitles {{title}} attributions {{user {{name}}}}}}}}",
};
var response = await _graphQlClient.SendQueryAsync <ResponseType>(request);
return(response.Data.SearchPages);
}
public async Task Can_Get_All_Genres()
{
var query = new GraphQLHttpRequest
{
Query = @"{ genres { name }}"
};
var response = await _graphQlHttpClient.SendQueryAsync <GenresResponseCollectionType>(query);
response.Errors.Should().BeNull();
response.Data.Genres.Count.Should().BePositive();
}
public async Task Can_Get_All_Seats()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "AllSeats",
};
var response = await _graphQlHttpClient.SendQueryAsync <SeatResponseCollectionType>(query);
response.Errors.Should().BeNull();
response.Data.Seats.Count.Should().BePositive();
}
public async Task Can_Get_Single_Movie_By_Id()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "MovieById",
Variables = new { id = "20db69d0-7760-4c3f-a484-032423e61018" }
};
var response = await _graphQlHttpClient.SendQueryAsync <MovieResponseType>(query);
response.Errors.Should().BeNull();
response.Data.Movie.Should().NotBeNull();
}
public async void PreprocessHttpRequestMessageIsCalled()
{
var callbackTester = new CallbackMonitor <HttpRequestMessage>();
var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
{
PreprocessHttpRequestMessage = callbackTester.Invoke
};
var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
Assert.Null(response.Errors);
Assert.Equal("Luke", response.Data.Human.Name);
}
public void SubscribeToUpdates()
{
var client = new GraphQLHttpClient(httpsLocalhostGraphql, new SystemTextJsonSerializer());
var query = new GraphQLHttpRequest
{
Query = @"subscription { reviewAdded { title productId } }"
};
var result = client.CreateSubscriptionStream <ProductReviewSubscriptionResponse>(query);
//result.Subscribe(response =>
//{
// var review = response.Data;
//});
}
public async Task <ProductModel> GetProduct(int id)
{
var client = new GraphQLHttpClient(httpsLocalhostGraphql, new SystemTextJsonSerializer());
var query = new GraphQLHttpRequest
{
Query = @"
query productQuery($productId: ID!)
{ product(id: $productId)
{ id name price
}
}",
Variables = new { productId = id }
};
var response = await client.SendQueryAsync <ProductResponse>(query);
return(response.Data.Product);
}
public async Task <ProductReviewModel> AddReview(ProductReviewModelInput review)
{
var client = new GraphQLHttpClient(httpsLocalhostGraphql, new SystemTextJsonSerializer());
var query = new GraphQLHttpRequest
{
Query = @"
mutation($review: reviewInput!)
{
createReview(review: $review)
{
id title
}
}",
Variables = new { review }
};
var response = await client.SendMutationAsync <ProductReviewResponse>(query);
return(response.Data.CreateReview);
}
public async Task <PostModel> GetRandomPost()
{
var query = new GraphQLHttpRequest
{
Query = @"
query getRandomPost
{
post: randomPost
{
title
url
shortDesciption
imageUrl
}
}",
};
var response = await client.SendQueryAsync <PostContainer>(query);
return(response.Data.Post);
}
public async void PreprocessHttpRequestMessageIsCalled()
{
var callbackTester = new CallbackMonitor <HttpRequestMessage>();
var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
{
PreprocessHttpRequestMessage = callbackTester.Invoke
};
using (var setup = SetupTest()) {
var defaultHeaders = setup.Client.HttpClient.DefaultRequestHeaders;
var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
.ConfigureAwait(false);
callbackTester.CallbackShouldHaveBeenInvoked(message => {
Assert.Equal(defaultHeaders, message.Headers);
});
Assert.Null(response.Errors);
Assert.Equal("Luke", response.Data.Human.Name);
}
}
public async static Task Main(string[] args)
{
using var httpClient = testServer.CreateClient();
using var graphqlClient = httpClient.AsGraphQLClient($"{testServer.BaseAddress}graphql");
var graphQLHttpRequest = new GraphQLHttpRequest {
Query = @"
{
repository(owner: ""graphql-dotnet"", name: ""graphql-client"") {
databaseId,
id,
name,
url
}
}"
};
var graphQLHttpResponse = await graphqlClient.SendHttpQueryAsync <Schema>(graphQLHttpRequest);
Console.WriteLine(JsonSerializer.Serialize(graphQLHttpResponse, new JsonSerializerOptions {
WriteIndented = true
}));
}
public async Task Can_Get_All_Movies_With_Paging_Filter()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "AllMovies",
Variables = new
{
filter = new { skip = 1, take = 1 }
}
};
var response = await _graphQlHttpClient.SendQueryAsync <MovieResponseCollectionType>(query);
response.Errors.Should().BeNull();
var movieList = response.Data.Movies;
movieList.Should().NotBeNull();
movieList.Count.Should().BePositive();
}
public async Task Can_Not_Create_Movie_With_Future_Release_Date()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "CreateMovie",
Variables = new
{
movie = new
{
Title = "...",
Description = "...",
Genre = "romance",
YearReleased = DateTime.UtcNow.Year + 3,
}
}
};
var response = await _graphQlHttpClient.SendMutationAsync <MovieResponseType>(query);
response.Errors.Should().NotBeNull();
}
public async Task <PostModel> GetPost(int id)
{
var query = new GraphQLHttpRequest
{
Query = @"
query getPost($pid: ID!)
{
post(id: $pid)
{
title
url
shortDesciption
imageUrl
}
}",
Variables = new { pid = id }
};
var response = await client.SendQueryAsync <PostContainer>(query);
return(response.Data.Post);
}
public async Task Can_Get_All_Movies_With_OrderBy_Filter()
{
var query = new GraphQLHttpRequest
{
Query = Query,
OperationName = "AllMovies",
Variables = new
{
filter = new { orderBy = "title" }
}
};
var response = await _graphQlHttpClient.SendQueryAsync <MovieResponseCollectionType>(query);
response.Errors.Should().BeNull();
var movieList = response.Data.Movies;
movieList.Should().NotBeNull();
movieList.Count.Should().BePositive();
movieList.Should().BeInDescendingOrder(mov => mov.Title);
}
public async Task <Product> Get(int productId)
{
var query = new GraphQLHttpRequest
{
Query = @"
query product($productId: ID!)
{
product(id: $productId)
{
id
name
description
}
}
",
Variables = new { productId }
};
var response = await _client.SendMutationAsync <ProductContainer>(query);
return(response.Data.Product);
}
