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