public void AddAboutPanel(AboutPanel panel)
{
if (!_account.IsAuthenticated)
{
_account.RaiseError(
"Authentication is required to use mutations. Set the AuthorizationToken property with your user token to authenticate");
}
GraphQLRequest _req = new GraphQLRequest
{
Query =
$"mutation{{panelAdd(input:{{ type: {panel.PanelType} }}) {{ err {{ message }} panel {{ id }}}}}}"
};
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLResponse res = Task.Run(() => _account.Client.SendMutationAsync(_req)).Result;
if (res.Errors != null)
{
_account.RaiseError($"An error occured while creating a new panel: {res.Errors[0].Message}");
}
UpdateAboutPanel(new AboutPanel(int.Parse(res.Data.panel.id.ToString()), panel.PanelType, panel.PanelTitle,
panel.PanelText, panel.PanelImageUrl, panel.PanelUrlDestination));
}
public void EqualityOperatorFact()
{
var graphQLResponse1 = new GraphQLResponse();
var graphQLResponse2 = new GraphQLResponse();
Assert.True(graphQLResponse1 == graphQLResponse2);
}
public override void ResetSeed()
{
try
{
GraphQLRequest LoginReq = new GraphQLRequest
{
Query = "mutation{rotateServerSeed{ seed seedHash nonce } changeClientSeed(seed:\"" + R.Next(0, int.MaxValue).ToString() + "\"){seed}}"
};
GraphQLResponse Resp = GQLClient.PostAsync(LoginReq).Result;
if (Resp.Data != null)
{
pdSeed user = Resp.GetDataFieldAs <pdSeed>("rotateServerSeed");
}
else if (Resp.Errors != null && Resp.Errors.Length > 0)
{
foreach (var x in Resp.Errors)
{
Parent.DumpLog("GRAPHQL ERROR PD RESETSEED: " + x.Message, 1);
}
}
}
catch (Exception e)
{
Parent.updateStatus("Failed to reset seed.");
}
}
public async void Post_ShouldReturnNHLStatsQueryPlayerofTypeObject()
{
GraphQLClient gqlClient = new GraphQLClient("http://*****:*****@"{
__type(name:" + char.ConvertFromUtf32(34) + "NHLStatsQuery" + char.ConvertFromUtf32(34) + @") {
name
fields {
name
type {
name
kind
ofType {
name
kind
}
}
}
}
}"
};
GraphQLResponse gqlResponse = await gqlClient.PostAsync(gqlRequest);
JToken playerstypeofkind = gqlResponse.Data.SelectToken("$.__type.fields[?(@.name=='players')].type.ofType.kind"); //$.data.__type.fields[?(@.name=="players")].type.ofType.kind
//IEnumerable<JToken> fieldstypes = gqlResponse.Data.SelectTokens("$..fields[?(@.name=='players')].type");
Assert.Equal("OBJECT", playerstypeofkind);
}
public void Equality2Fact()
{
var graphQLResponse1 = new GraphQLResponse();
var graphQLResponse2 = new GraphQLResponse();
Assert.Equal(graphQLResponse1, graphQLResponse2);
}
public async Task <IActionResult> GetUserRepositories([FromBody] SearchUserRepository value)
{
try
{
GraphQLRequest request = new GraphQLRequest();
request.Query = this.LoadQueryFromFile("RepositoriesByUserName");
if (value.Count == 0)
{
request.Variables = new
{
userName = value.UserName
};
}
else
{
request.Variables = new
{
userName = value.UserName,
count = value.Count
};
}
request.OperationName = "RepositoriesByUserName";
GraphQLResponse response = await this.Client.PostAsync(request);
return(Ok(response.Data));
}
catch (Exception)
{
throw;
}
}
public async Task <IEnumerable <BasketPositionModel> > GetCustomerBasket(long customerId)
{
GraphQLRequest request = new GraphQLRequest
{
Query = @"
query BasketQuery($customerId: Int!) {
basket(customerId: $customerId) {
id
customerId
productId
productName
productDescription
quantity
price
}
}",
Variables = new { customerId = customerId }
};
GraphQLResponse response = await this.graphQLClient.PostAsync(request);
if (response.Errors != null && response.Errors.Any())
{
throw new HttpRequestException(response.Errors[0].Message);
}
return(response.GetDataFieldAs <List <BasketPositionModel> >("basket"));
}
protected GraphQLResponse ExecuteRequestWithRetry(GraphQLClient client, GraphQLRequest request, int retries = 10)
{
int i = 0;
GraphQLResponse response = null;
Exception ex = null;
string message = string.Empty;
do
{
message = string.Empty;
try
{
response = client.PostAsync(request).Result;
}
catch (Exception e)
{
message = e.Message;
Thread.Sleep(500);
ex = e;
}
}while (message != string.Empty && i++ < retries);
if (i >= 10)
{
throw ex;
}
return(response);
}
public static async Task <GraphQLResponse> ExecuteAsync(string query, IDictionary <string, object> variables = null, bool throwOnError = true)
{
GraphQLResponse resp = null;
try {
var req = new GraphQLRequest()
{
Query = query, Variables = variables
};
resp = await ThingsServer.ExecuteAsync(req);
if (!resp.IsSuccess())
{
var errText = resp.GetErrorsAsText();
Debug.WriteLine("Errors: \r\n" + errText);
}
} catch (Exception ex) {
TestEnv.LogException(query, ex);
throw;
}
if (resp != null && resp.Errors != null && resp.Errors.Count > 0 && throwOnError)
{
throw new Exception($"Request failed: {resp.Errors[0].Message}");
}
return(resp);
}
public void RemoveModerator(string moderatorUsername)
{
if (!_account.IsAuthenticated)
{
_account.RaiseError(
"Authentication is required to use mutations. Set the AuthorizationToken property with your user token to authenticate");
}
GraphQLRequest _req = new GraphQLRequest
{
Query = $"mutation{{moderatorRemove(username: \"{moderatorUsername}\") {{ err {{ message }}}}}}"
};
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLResponse res = Task.Run(() => _account.Client.SendMutationAsync(_req)).Result;
if (res.Errors != null)
{
_account.RaiseError($"An error occured while removing moderator: {res.Errors[0].Message}");
}
}
public UserData GetMyInfo()
{
if (!_account.IsAuthenticated)
{
_account.RaiseError("Authentication is required to use this query. Set the Dlive.AuthorizationToken property with your user token to authenticate");
return(new UserData());
}
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLResponse response = _account.Client.SendQueryAsync(GraphqlHelper.GetQueryString(QueryType.ME)).Result;
if (response.Data.me == null)
{
throw new AccountException($"User data was not received, this could be caused by an expired user token!");
}
RawUserData userData = response.GetDataFieldAs <RawUserData>("me");
return(userData.ToUserData());
}
public void SetAboutPanelOrder(AboutPanel[] panels)
{
if (!_account.IsAuthenticated)
{
_account.RaiseError(
"Authentication is required to use mutations. Set the AuthorizationToken property with your user token to authenticate");
}
List <int> ids = new List <int>();
foreach (AboutPanel panel in panels)
{
ids.Add(panel.PanelId);
}
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLRequest _req = new GraphQLRequest
{
Query = $"mutation{{panelDelete(input:{{ ids: {ids.ToArray()} }}) {{ err {{ message }}}}}}"
};
GraphQLResponse res = Task.Run(() => _account.Client.SendMutationAsync(_req)).Result;
if (res.Errors != null)
{
_account.RaiseError($"An error occured while updating panel order: {res.Errors[0].Message}");
}
}
public void DeleteAboutPanel(int id)
{
if (!_account.IsAuthenticated)
{
_account.RaiseError(
"Authentication is required to use mutations. Set the AuthorizationToken property with your user token to authenticate");
}
GraphQLRequest _req = new GraphQLRequest
{
Query = $"mutation{{panelDelete(input:{{ id: {id} }}) {{ err {{ message }}}}}}"
};
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLResponse res = Task.Run(() => _account.Client.SendMutationAsync(_req)).Result;
if (res.Errors != null)
{
_account.RaiseError($"An error occured while deleting panel: {res.Errors[0].Message}");
}
}
public void UpdateAboutPanel(AboutPanel panel)
{
if (!_account.IsAuthenticated)
{
_account.RaiseError(
"Authentication is required to use mutations. Set the AuthorizationToken property with your user token to authenticate");
}
GraphQLRequest _req = new GraphQLRequest
{
Query =
$"mutation{{panelUpdate(input:{{ id: {panel.PanelId}, title: \"{panel.PanelTitle}\", body: \"{panel.PanelText}\", imageURL: \"{(panel.PanelImageUrl == null ? "" : panel.PanelImageUrl.ToString())}\", imageLinkURL: \"{(panel.PanelUrlDestination == null ? "" : panel.PanelUrlDestination.ToString())}\" }}) {{ err {{ message }}}}}}"
};
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLResponse res = Task.Run(() => _account.Client.SendMutationAsync(_req)).Result;
if (res.Errors != null)
{
_account.RaiseError($"An error occured while updating panel: {res.Errors[0].Message}");
}
}
public async Task <CustomerModel> Get(long customerId)
{
GraphQLRequest request = new GraphQLRequest
{
Query = @"
query CustomerQuery($customerId: ID!) {
customer(id: $customerId) {
id
firstName
surname
address
email
}
}",
Variables = new { customerId = customerId }
};
GraphQLResponse response = await this.graphQLClient.PostAsync(request);
if (response.Errors != null && response.Errors.Any())
{
throw new HttpRequestException(response.Errors[0]?.Message);
}
return(response.GetDataFieldAs <CustomerModel>("customer"));
}
/// <summary>
/// Creates a new Link from the given builder, signs it and executes the GraphQL
/// mutation.
/// </summary>
/// <typeparam name="TLinkData"></typeparam>
/// <param name="linkBuilder">The linkBuilder<see cref="TraceLinkBuilder{TLinkData}"/></param>
/// <returns>The <see cref="Task{TraceState{TState, TLinkData}}"/></returns>
private async Task <TraceState <TState, TLinkData> > CreateLinkAsync <TLinkData>(TraceLinkBuilder <TLinkData> linkBuilder)
{
// extract signing key from config
SdkConfig sdkConfig = await GetConfigAsync();
Ed25519PrivateKeyParameters signingPrivateKey = sdkConfig.SigningPrivateKey;
// build the link
TraceLink <TLinkData> link = linkBuilder.Build();
// sign the link
link.Sign(signingPrivateKey.GetEncoded(), "[version,data,meta]");
string linkObjJson = JsonHelper.ToJson(link.ALink);
Dictionary <string, object> linkObj = JsonHelper.ObjectToMap(link.GetLink());
Dictionary <string, object> dataObj = JsonHelper.ObjectToMap(((TraceLink <TLinkData>)link).FormData());
Dictionary <string, object> variables = new Dictionary <string, object>
{
["link"] = linkObj,
["data"] = dataObj
};
// Debug.WriteLine("Request : " + JsonHelper.ToJson(dataObj));
// execute graphql query
GraphQLResponse jsonResponse = await this.client.GraphqlAsync(GraphQL.MUTATION_CREATELINK, variables, null, null);
var trace = jsonResponse.Data.createLink.trace;
return(this.MakeTraceState <TLinkData>(trace));
}
public override bool InternalSendTip(string User, decimal amount)
{
try
{
//mutation{sendTip(userId:"", amount:0, currency:btc,isPublic:true,chatId:""){id currency amount}}
string userid = GetUid(User);
string chatid = "";
string Tippayload = "mutation SendTip($userId: String!, $amount: Float!, $currency: CurrencyEnum!, $isPublic: Boolean, $chatId: String!, $tfaToken: String) {sendTip(userId: $userId, amount: $amount, currency: $currency, isPublic: $isPublic, chatId: $chatId, tfaToken: $tfaToken) { id amount currency user { id name __typename } sendBy { id name balances { available { amount currency __typename } vault { amount currency __typename } __typename } __typename } __typename } }";
GraphQLRequest req = new GraphQLRequest();
req.Query = Tippayload;
req.Variables = new
{
name = User,
amount = amount,
isPublic = true,
userId = userid,
chatId = chatid,
currency = Currency,
tfaToken = (string)null
};
GraphQLResponse Resp = GQLClient.PostAsync(req).Result;
return(Resp.Data.sendTip.id.Value != null);
}
catch (Exception e)
{
/*if (e.Response != null)
* {
*
* string sEmitResponse = new StreamReader(e.Response.GetResponseStream()).ReadToEnd();
* Parent.updateStatus(sEmitResponse);
*
* }*/
}
return(false);
}
/// <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);
}
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);
}
private void QueryCallback(GraphQLResponse response)
{
print(response.Result);
var info = response.GetValue <QInfo>("info");
text.text = $"Info: {info.id}\nName: {info.name}\nDescription: {info.description}";
}
protected override async void OnAppearing()
{
base.OnAppearing();
var client = new GraphQLClient("https://swapi.apis.guru/");
client.DefaultRequestHeaders.Add("User-Agent", " GraphQLApp");
GraphQLRequest graphQLRequest = new GraphQLRequest
{
Query = "query{ allFilms { films { title director} } }"
};
try
{
GraphQLResponse response = await client.PostAsync(graphQLRequest);
List <Film> films = new List <Film>();
foreach (Newtonsoft.Json.Linq.JObject f in response.Data.allFilms.films)
{
Film film = f.ToObject <Film>();
films.Add(film);
}
film_list.ItemsSource = films;
}
catch (HttpRequestException ex)
{
Console.WriteLine((string)ex.Message + " :: " + ex.InnerException.Message);
}
}
/// <summary>
/// Given a trace id or a previous link return the previous link.
/// </summary>
/// <typeparam name="TLinkData"></typeparam>
/// <param name="input"> .traceId the id of the trace </param>
/// <returns>The <see cref="Task{TraceLink{TLinkData}}"/></returns>
public async Task <TraceLink <TLinkData> > GetHeadLinkAsync <TLinkData>(ParentLink <TLinkData> input)
{
TraceLink <TLinkData> headLink = input.PrevLink;
// if prevLink was not provided
if (headLink == null && input.TraceId != null)
{
Dictionary <String, object> variables = new Dictionary <String, object>
{
{ "traceId", input.TraceId }
};
string query = GraphQL.QUERY_GETHEADLINK;
// execute graphql query
GraphQLResponse <dynamic> jsonResponse = await this.client.GraphqlAsync(query, variables, null, null);
var trace = jsonResponse.Data.trace;
string raw = trace.head.raw.ToString();
TLinkData data = JsonHelper.ObjectToObject <TLinkData>(trace.head.data);
// convert the raw response to a link object
headLink = new TraceLink <TLinkData>(Stratumn.Chainscript.Link.FromObject(raw), data);
}
if (headLink != null)
{
return(headLink);
}
else
{
throw new TraceSdkException("Previous link or trace Id must be provided");
}
}
public static AnimeResult GetAnimeResultFromResponse(GraphQLResponse response)
{
dynamic data = response.Data.Media;
return(new AnimeResult()
{
MalId = data.idMal,
AlId = data.id,
Title = (data.title.native.ToString() as string).IfTargetIsNullOrEmpty((data.title.romaji.ToString() as string).IfTargetIsNullOrEmpty(data.title.english.ToString() as string)),
Status = data.status,
Synopsis = data.description,
Type = data.type,
Episodes = data.episodes,
Score = data.averageScore,
ImageUrl = data.coverImage.large,
SiteUrl = data.siteUrl,
Source = data.source,
Duration = data.duration,
Broadcast = data.airingSchedule.nodes.Count > 0
? DateTimeOffset.FromUnixTimeSeconds((long)(data.airingSchedule.nodes[0].airingAt)).UtcDateTime.ToString("dddd, dd MMMM HH:mm (UTC)")
: null,
TrailerUrl = data.trailer != null ? (data.trailer.site == "youtube" ? $"https://www.youtube.com/watch?v={data.trailer.id}" : $"https://www.dailymotion.com/video/{data.trailer.id}") : null,
Studio = data.studios.nodes.Count > 0 ? data.studios.nodes[0].name : null,
StudioUrl = data.studios.nodes.Count > 0 ? data.studios.nodes[0].siteUrl : null,
ApiType = ApiType.AniList,
});
}
/// <summary>
/// The GetTraceDetails
/// </summary>
/// <typeparam name="TLinkData"></typeparam>
/// <param name="input">The input<see cref="GetTraceDetailsInput"/></param>
/// <returns>The <see cref="Task{TraceDetails{TLinkData}}"/></returns>
public async Task <TraceDetails <TLinkData> > GetTraceDetailsAsync <TLinkData>(GetTraceDetailsInput input)
{
Dictionary <string, object> getTraceDetailsInput = JsonHelper.ObjectToMap(input);
// delegate the graphql request execution
// execute graphql query
GraphQLResponse <dynamic> jsonResponse = await this.client.GraphqlAsync(GraphQL.QUERY_GETTRACEDETAILS, getTraceDetailsInput, null, null);
var trace = jsonResponse.Data.trace;
var info = trace.links.info;
int totalCount = (int)trace.links.totalCount;
IList <TraceLink <TLinkData> > links = new List <TraceLink <TLinkData> >();
// get all the groups that are owned by one of my accounts
foreach (var lNode in trace.links.nodes)
{
JObject nodeRaw = lNode.raw;
TLinkData nodeData = JsonHelper.ObjectToObject <TLinkData>(lNode.data);
links.Add((TraceLink <TLinkData>)TraceLink <TLinkData> .FromObject <TLinkData>(nodeRaw.ToString(Newtonsoft.Json.Formatting.None),
nodeData));
}
// the details response object
return(new TraceDetails <TLinkData>(links, totalCount, info.ToObject <Info>()));
}
public void Constructor1Fact()
{
var graphQLResponse = new GraphQLResponse();
Assert.Null(graphQLResponse.Data);
Assert.Null(graphQLResponse.Errors);
}
public ValidationData MappingDataQuate(GraphQLResponse data, string SessionID)
{
try
{
ValidationData OutPutData = new ValidationData();
OutPutData.cancelPolicy.refundable = data.Data.hotelX.quote.optionQuote.cancelPolicy.refundable;
if (data.Data.hotelX.quote.optionQuote.cancelPolicy.cancelPenalties != null)
{
foreach (var item in data.Data.hotelX.quote.optionQuote.cancelPolicy.cancelPenalties)
{
var cancel = new CancelPenalty();
cancel.currency = item.currency;
cancel.hoursBefore = item.hoursBefore;
cancel.value = item.value;
cancel.penaltyType = item.penaltyType;
OutPutData.cancelPolicy.cancelPenalties.Add(cancel);
}
}
OutPutData.optionRefId = data.Data.hotelX.quote.optionQuote.optionRefId;
OutPutData.price.currency = data.Data.hotelX.quote.optionQuote.price.currency;
OutPutData.price.net = data.Data.hotelX.quote.optionQuote.price.net;
OutPutData.status = data.Data.hotelX.quote.optionQuote.status;
return(OutPutData);
}
catch (Exception ex)
{
var requestData = JsonConvert.SerializeObject(ex);
LoggerHelper.WriteToFile("SMLogs/ValidationMapException", "ValidationMapException_" + SessionID, "ValidationMapException", requestData);
throw;
}
}
public async Task <ProductModel> GetProductById(long productId)
{
GraphQLRequest request = new GraphQLRequest
{
Query = @"
query ProductQuery($productId: ID!) {
product(id: $productId) {
id
name
description
price
count
}
}",
Variables = new { productId = productId }
};
using (GraphQLClient graphQLClient = new GraphQLClient(this.options))
{
GraphQLResponse response = await graphQLClient.PostAsync(request);
if (response.Errors != null && response.Errors.Any())
{
throw new HttpRequestException(response.Errors[0].Message);
}
return(response.GetDataFieldAs <ProductModel>("product"));
}
}
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 override bool InternalSendTip(string User, decimal amount)
{
try
{
//mutation{sendTip(userId:"", amount:0, currency:btc,isPublic:true,chatId:""){id currency amount}}
string userid = GetUid(User);
GraphQLRequest LoginReq = new GraphQLRequest
{
Query = "mutation{sendTip(userId:\"" + userid + "\", amount:" + amount.ToString("0.00000000", System.Globalization.NumberFormatInfo.InvariantInfo) + ", currency:" + Currency.ToLower() + ",isPublic:true,chatId:\"14939265-52a4-404e-8a0c-6e3e10d915b4\"){id currency amount}}"
};
GraphQLResponse Resp = GQLClient.PostAsync(LoginReq).Result;
return(Resp.Data.sendTip.id.Value != null);
}
catch (Exception e)
{
/*if (e.Response != null)
* {
*
* string sEmitResponse = new StreamReader(e.Response.GetResponseStream()).ReadToEnd();
* Parent.updateStatus(sEmitResponse);
*
* }*/
}
return(false);
}
public void AddChestValue(int amountToAdd)
{
if (!_account.IsAuthenticated)
{
_account.RaiseError(
"Authentication is required to use mutations. Set the AuthorizationToken property with your user token to authenticate");
}
GraphQLRequest _req = new GraphQLRequest
{
Query = $"mutation{{treasureChestUserTransfer(amount:\"{amountToAdd}\") {{ err {{ message }}}}}}"
};
if (!Dlive.CanExecuteQuery())
{
Task.Delay((Dlive.NextIntervalReset - DateTime.Now).Milliseconds).Wait();
}
Dlive.IncreaseQueryCounter();
GraphQLResponse res = Task.Run(() => _account.Client.SendMutationAsync(_req)).Result;
if (res.Errors != null)
{
_account.RaiseError($"An error occured while adding value to chest: {res.Errors[0].Message}");
}
}
