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 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 static async Task <T> ExceuteMutationAsyn <T>(string graphQLQueryType, string completeQueryString)
{
try
{
var request = new GraphQLRequest
{
Query = completeQueryString
};
var response = await graphQLHttpClient.SendMutationAsync <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 <T>(stringResult);
return(result);
}
catch (Exception ex)
{
throw;
}
}
private async void Button1_Click(object sender, EventArgs e)
{
if (textBox1.Text.Trim() != "")
{
GraphQLRequest request = new GraphQLRequest();
request.Query = GraphQLQueries.ADD_MOVIE;
string name = textBox1.Text.Trim();
int year = Convert.ToInt32(numericUpDown1.Value);
int imdb = Convert.ToInt32(numericUpDown2.Value);
string subject = textBox2.Text.Trim();
request.Variables = new { name = name, year = year, imdb = imdb, subject = subject, directorId = id };
var result = await client.SendMutationAsync(request);
if (result.Errors != null)
{
MessageBox.Show(result.Errors[0].Message);
}
else
{
Movie movie = JsonConvert.DeserializeObject <Movie>(result.Data.addMovie.ToString());
string movieId = movie.id;
int count = form1.listView1.Items.Count;
form1.listView1.Items.Add(movieId);
form1.listView1.Items[count].SubItems.Add(name);
form1.listView1.Items[count].SubItems.Add(year.ToString());
form1.listView1.Items[count].SubItems.Add(imdb.ToString());
form1.listView1.Items[count].SubItems.Add(subject);
this.Hide();
}
}
}
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 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 static async Task UpdateWaitTime(string rideId, string waitTime)
{
try
{
var updateRequest = new GraphQLRequest
{
Query = @"mutation updateWaitTime($rideId: String, $waitTime: String) {
update_rides(where: {id:{_eq: $rideId}}, _set: {waitTime:$waitTime}) {
returning {
name
waitTime
}
}
}",
Variables = new
{
rideId = rideId,
waitTime = waitTime
}
};
await _graphQLClient.SendMutationAsync <dynamic>(updateRequest);
}catch (Exception ex)
{
Thread.Sleep(2000);
}
}
protected override async Task OnInitializedAsync()
{
var uri = new Uri(NavigationManager.BaseUri + "graphql");
var graphQLClient = new GraphQLHttpClient(uri, new SystemTextJsonSerializer());
var heroRequest = new GraphQLRequest
{
Query = @"mutation($credentials:LoginInput!){
login(credentials: $credentials){
id
username
}
}",
Variables = new
{
credentials = new
{
username = "******",
password = "******"
}
}
};
var graphQLResponse = await graphQLClient.SendMutationAsync(heroRequest, () => new { userLogin = new User() });
var personName = graphQLResponse.Data?.userLogin;
var options = new JsonSerializerOptions
{
WriteIndented = true
};
_graphQlJson = JsonSerializer.Serialize(personName, options);
}
public async Task <dynamic> ExecuteMutationAsync(string query, Dictionary <string, object> args)
{
try
{
if (_client == null)
{
_client = new GraphQLHttpClient(_endPointUrl);
}
//turn args into anonymous object
dynamic 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
};
//check query string
//var graphQLString = JsonConvert.SerializeObject(assentRequest, _client.Options.JsonSerializerSettings);
var graphQLResponse = await _client.SendMutationAsync(assentRequest);// SendQueryAsync(assentRequest);
return(graphQLResponse.Data);
}
catch (Exception ex)
{
return(ex);
}
}
private async void Button1_Click(object sender, EventArgs e)
{
if (textBox1.Text.Trim() != null)
{
GraphQLRequest request = new GraphQLRequest();
request.Query = GraphQLQueries.ADD_DIRECTOR;
string name = textBox1.Text.Trim();
int birth = Convert.ToInt32(numericUpDown1.Value);
request.Variables = new { name = name, birth = birth };
var result = await client.SendMutationAsync(request);
if (result.Errors != null)
{
MessageBox.Show(result.Errors[0].Message);
}
else
{
Director director = JsonConvert.DeserializeObject <Director>(result.Data.addDirector.ToString());
string id = director.id;
int count = form1.listView2.Items.Count;
form1.listView2.Items.Add(id);
form1.listView2.Items[count].SubItems.Add(name);
form1.listView2.Items[count].SubItems.Add(birth.ToString());
this.Hide();
}
}
}
public async static Task CreateOrderMutation()
{
using (var graphQLClient = new GraphQLHttpClient("https://*****:*****@"mutation ($order:OrderDetailInputType!) {
createOrder(orderDetail:$order) {
id
orderStatus
addressLine1
addressLine2
pizzaDetails {
id
toppings
}
}
}",
Variables = new
{
order = new
{
addressLine1 = "ICH" + DateTime.Now,
addressLine2 = "Brasilia" + DateTime.Now,
mobileNo = "999",
amount = 500,
pizzaDetails = new[]
{
new
{
name = "Randel's pizza" + DateTime.Now,
price = 10,
size = 5,
toppings = Toppings.ExtraCheese
}
}
}
}
};
var response = await graphQLClient.SendMutationAsync <CreateOrderResponse>(createOrderMutation);
Console.WriteLine();
Console.WriteLine($"{nameof(CreateOrderDetail.Id)}: {response.Data.CreateOrder.Id}");
Console.WriteLine($"{nameof(CreateOrderDetail.AddressLine1)}: {response.Data.CreateOrder.AddressLine1}");
Console.WriteLine($"{nameof(CreateOrderDetail.AddressLine2)}: {response.Data.CreateOrder.AddressLine2}");
Console.WriteLine($"{nameof(CreateOrderDetail.OrderStatus)}: {response.Data.CreateOrder.OrderStatus}");
foreach (var item in response.Data.CreateOrder.PizzaDetails)
{
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~");
Console.WriteLine();
Console.WriteLine($"{nameof(Pizzadetail.Id)}: {item.Id}");
Console.WriteLine($"{nameof(Pizzadetail.Toppings)}: {item.Toppings}");
Console.WriteLine();
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~");
}
}
}
public async Task <TK> SendMutationAsync <TK>(string schemaName, string mutationName, GraphQLRequest request) where TK : class
{
var response = await m_client.SendMutationAsync(request);
response.Data = response.Data[schemaName];
var result = response.GetDataFieldAs <TK>(mutationName);
return(result);
}
private async Task <T> SendMutation <T>(string accessToken, string query)
{
if (!_client.HttpClient.DefaultRequestHeaders.Contains("Authorization"))
{
_client.HttpClient.DefaultRequestHeaders.Add("Authorization", accessToken);
}
var response = await _client.SendMutationAsync <T>(new GraphQLRequest(query));
return(response.Data);
}
public async Task <bool> ToggleFavorite(string productId)
{
var graphQlRequest = new GraphQLRequest()
{
Query = Mutations.ToggleFavorite,
Variables = new { productId }
};
var response = await m_client.SendMutationAsync(graphQlRequest, () => new { makeFavorite = false });
return(response.Data.makeFavorite);
}
public async Task <GraphQLResponse <RetornoLogin> > Login(string email, string password)
{
var login = new GraphQLRequest
{
Query = @"
mutation ($input: LoginMutationInput!) {
login(input: $input) {
user {
apiKey
}
}
}",
Variables = new
{
input = new
{
email,
password
}
}
};
var graphQLResponse = await _client.SendMutationAsync <RetornoLogin>(login);
if (graphQLResponse.Data.Login.User == null)
{
throw new Exception("Não foi possivel efetuar o login na loggi");
}
_apiToken = graphQLResponse.Data.Login.User.ApiKey;
_email = email;
IsLogged = true;
_client.HttpClient.DefaultRequestHeaders.Add("Authorization", String.Format("ApiKey {0}:{1}", _email, _apiToken));
return(graphQLResponse);
}
//public static async Task<GraphQLResponse<dynamic>> CreateAnswer(this GraphQLHttpClient client, CreateAnswerCmd cmd)
//{
// const string query =
// @"mutation createAnswer($cmd: CreateAnswerCmd!){
// createAnswer(cmd: $cmd){
// successful
// answerId
// failureText
// }
// }";
// var request = new GraphQLRequest(query, new Dictionary<string, object>()
// {
// {"cmd", cmd}
// });
// return await client.SendMutationAsync<dynamic>(request);
//}
public static async Task <GraphQLResponse <dynamic> > VoteUp(this GraphQLHttpClient client, VoteUpCmd cmd)
{
const string query =
@"mutation voteUp($cmd: VoteUpCmd!){
voteUp(cmd: $cmd){
successful
failureText
}
}";
var request = new GraphQLRequest(query, new Dictionary <string, object>()
{
{ "cmd", cmd }
});
return(await client.SendMutationAsync <dynamic>(request));
}
public async Task <TValue> ExecuteMutation <TValue>(string query, object variables = null)
{
var byteArray = Encoding.ASCII.GetBytes($"{apiKey}:{apiPassword}");
_graphClient.HttpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var request = new GraphQLRequest()
{
Query = query
};
request.Variables = variables ?? null;
var response = await _graphClient.SendMutationAsync <TValue>(request);
return(response.Data);
}
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 <Guid> AddReviewAsync(ReviewModel review, CancellationToken cancellationToken = default)
{
var request = new GraphQLRequest
{
Query = @"mutation($review: reviewInput!) {
createReview(review: $review) {
id
}
}",
Variables = new { review }
};
var response = await _client.SendMutationAsync(
request: request,
defineResponseType : () => new { createReview = new { id = new Guid() } },
cancellationToken : cancellationToken);
return(response.Errors?.Any() ?? default ? default : response.Data.createReview.id);
}
public async Task <MutationRunStats> RunAsync()
{
var result = new MutationRunStats();
var payload = CreatePayload();
result.PayloadSizeInKb = Encoding.UTF8.GetByteCount(payload) / (double)1024;
result.Start = DateTime.UtcNow;
var response = await _client.SendMutationAsync <object>(new GraphQLRequest
{
Query = payload
});
result.Errors = response.Errors;
result.End = DateTime.UtcNow;
return(result);
}
public static async Task <GraphQLResponse <dynamic> > CreateTenantAndAdmin(this GraphQLHttpClient client, CreateTenantCmd createTenantCmd)
{
const string query =
@"mutation createTenant($cmd: CreateTenantCmd!) {
createTenant(cmd: $cmd) {
successful
tenantId
adminName
}
}";
var request = new GraphQLRequest(query, new Dictionary <string, object>()
{
{ "cmd", createTenantCmd }
});
var result = await client.SendMutationAsync <dynamic>(request);
Assert.IsNull(result.Errors);
return(result);
}
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);
}
public async void SendMutationFact()
{
var mutationRequest = new GraphQLRequest(@"
mutation CreateHuman($human: HumanInput!) {
createHuman(human: $human) {
id
name
homePlanet
}
}" ,
new { human = new { name = "Han Solo", homePlanet = "Corellia" } });
var queryRequest = new GraphQLRequest(@"
query Human($id: String!){
human(id: $id) {
name
}
}" );
var mutationResponse = await StarWarsClient.SendMutationAsync(mutationRequest, () => new
{
createHuman = new
{
Id = "",
Name = "",
HomePlanet = ""
}
});
Assert.Null(mutationResponse.Errors);
Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
queryRequest.Variables = new { id = mutationResponse.Data.createHuman.Id };
var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } });
Assert.Null(queryResponse.Errors);
Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
}
public override async Task <int> ExecuteAsync()
{
if (_options.Labels?.Count() == 0)
{
throw new InvalidOperationException("No label(s) specified");
}
var graphClient = new GraphQLHttpClient("https://api.github.com/graphql", new NewtonsoftJsonSerializer());
graphClient.HttpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_options.GitHubPat}");
graphClient.HttpClient.DefaultRequestHeaders.Add("User-Agent", "arsub/0.1");
var issuesToSubscribeVariables = new IssuesToSubscribeVariables
{
query = $"is:issue state:open {IncludingLabelsFilter()} repo:{_options.Repo} {DateRangeFilter()}",
after = (string)null,
};
var issuesToSubscribeRequest = new GraphQLRequest
{
Query = @"
query IssuesToSubscribe($query:String!, $after:String) {
search(query: $query, type: ISSUE, first: 100, after: $after) {
nodes {
... on Issue {
__typename
id
number
title
updatedAt
url
labels(first: 100) {
nodes {
name
}
}
}
}
pageInfo {
endCursor
hasNextPage
}
issueCount
}
}",
OperationName = "IssuesToSubscribe",
Variables = issuesToSubscribeVariables,
};
var subscribeToIssueMutation = new GraphQLRequest
{
Query = @"
mutation SubscribeToIssue($issue:String!, $state:SubscriptionState!) {
__typename
updateSubscription(input: {state: $state, subscribableId: $issue}) {
clientMutationId
}
}",
OperationName = "SubscribeToIssue"
};
int countSubscribed = 0;
bool nextPage = true;
while (nextPage)
{
Logger.LogDebug($"GraphQL query to {graphClient.HttpClient.BaseAddress} with query:{issuesToSubscribeRequest.Query}\nusing variables:\n{JsonConvert.SerializeObject(issuesToSubscribeRequest.Variables, Formatting.Indented)}");
var issuesQueryResult = await graphClient.SendQueryAsync <dynamic>(issuesToSubscribeRequest);
if (issuesQueryResult.Errors?.Any() == true)
{
Logger.LogError($"GraphQL query errors: {JsonConvert.SerializeObject(issuesQueryResult.Errors, Formatting.Indented)}");
return(Constants.ErrorCode);
}
Logger.LogDebug($"GraphQL query result: \n{JsonConvert.SerializeObject(issuesQueryResult.Data, Formatting.Indented)}");
dynamic data = issuesQueryResult.Data;
foreach (dynamic issue in data.search.nodes)
{
// TODO: test if already subscribed by events and ignore if unsubscribed afer it have received that label
subscribeToIssueMutation.Variables = new
{
issue = issue.id,
state = SubscriptionStatusStrategy,
};
Logger.LogDebug($"GraphQL mutation {graphClient.HttpClient.BaseAddress} with mutation:{subscribeToIssueMutation.Query}\nusing variables:\n{JsonConvert.SerializeObject(subscribeToIssueMutation.Variables, Formatting.Indented)}");
if (!_options.WhatIf)
{
var mutation = await graphClient.SendMutationAsync <dynamic>(subscribeToIssueMutation);
if (mutation.Errors?.Any() != true)
{
Logger.LogDebug($"GraphQL query mutation result: \n{JsonConvert.SerializeObject(mutation, Formatting.Indented)}");
}
else
{
Logger.LogError($"GraphQL mutation errors: {JsonConvert.SerializeObject(mutation.Errors, Formatting.Indented)}");
return(Constants.ErrorCode);
// TODO: retry?
}
}
countSubscribed++;
Console.WriteLine($"{issue.url} => {issue.title}");
}
if (issuesQueryResult.Errors?.Any() != true && data.search.pageInfo.hasNextPage == true)
{
issuesToSubscribeVariables.after = (string)data.search.pageInfo.endCursor;
}
else
{
nextPage = false;
}
}
if (countSubscribed > 0)
{
Console.WriteLine($"Succesfully changed subscription to {countSubscribed} issues");
}
else
{
Console.WriteLine($"No issue found!");
}
return(Constants.SuccessCode);
}
static async Task Main(string[] args)
{
Console.WriteLine("configuring client ...");
using (var client = new GraphQLHttpClient("http://*****:*****@"
mutation($input: MessageInputType){
addMessage(message: $input){
content
}
}" )
{
Variables = new
{
input = new
{
fromId = "2",
content = message,
sentAt = DateTime.Now
}
}
};
var result = await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
if (result.Errors != null && result.Errors.Length > 0)
{
Console.WriteLine($"request returned {result.Errors.Length} errors:");
foreach (var item in result.Errors)
{
Console.WriteLine($"{item.Message}");
}
}
}while(!quit);
Console.WriteLine("shutting down ...");
}
Console.WriteLine("subscriptions disposed ...");
}
Console.WriteLine("client disposed ...");
}
static async Task Main(string[] args)
{
var graphQLClient = new GraphQLHttpClient("https://*****:*****@"query {
newOrders {
addressLine1
addressLine2
amount
}
}";
var newOrderResponse = await graphQLClient.SendQueryAsync(newOrdersQuery);
List <NewOrderDetails> newOrderDetails = newOrderResponse.GetDataFieldAs <List <NewOrderDetails> >("newOrders");
#endregion
string createOrderMutation = @"mutation ($order:OrderDetailsInputType!) {
createOrder(orderDetails:$order)
{
id
orderStatus
addressLine1
addressLine2
pizzaDetails
{
id
toppings
}
}
}";
GraphQLRequest createOrderRequest = new GraphQLRequest
{
Query = createOrderMutation,
Variables = new
{
order = new
{
addressLine1 = "1 Address Line",
addressLine2 = "2 Address Line",
mobileNo = "0123456789",
amount = 500,
pizzaDetails = new[] {
new {
name = "My Nilay Pizza",
price = 10,
size = 5,
toppings = "EXTRA_CHEESE"
}
}
}
}
};
var createOrderResponse = await graphQLClient.SendMutationAsync(createOrderRequest);
CreateOrderDetails orderDetails = createOrderResponse.GetDataFieldAs <CreateOrderDetails>("createOrder");
}
public async Task <GraphQLResponse <TResponse> > SendMutationAsync <TResponse>(IRequest request, CancellationToken token = default)
{
request.EnsureNotNull();
return(await _client.SendMutationAsync <TResponse>(GraphQLRequestFactory.Create(request.Query, request.OperationName, request.Variables), token).ConfigureAwait(true));
}
