public string Request(RestSharp.Method method, string endPoint, Dictionary<string,object> headers, Dictionary<string, object> parameters, Dictionary<string, object> queryParameters, string body) { RestClient client = new RestClient(baseURL); RestRequest request = new RestRequest(endPoint, method); client.Authenticator = authenticator; foreach (var key in headers.Keys) { if(headers[key].GetType().ToString().StartsWith("System.Collections.Generics.List")) { request.AddHeader(key,JsonConvert.SerializeObject(headers[key])); } else { request.AddHeader(key,headers[key].ToString()); } } foreach (var key in parameters.Keys) { request.AddParameter(key, parameters[key]); } foreach (var key in queryParameters.Keys) { if (headers[key].GetType().ToString().StartsWith("System.Collections.Generics.List")) { request.AddQueryParameter(key, JsonConvert.SerializeObject(queryParameters[key])); } else { request.AddQueryParameter(key, queryParameters[key].ToString()); } } var response = client.Execute(request); return response.Content; }
public string Translate(string resource, string locale, string targetLocale) { var restClient = new RestClient(_baseUrl); var request = new RestRequest("Translate") { OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; } }; request.AddQueryParameter("text", resource); request.AddQueryParameter("from", locale); request.AddQueryParameter("to", targetLocale); request.AddHeader("Authorization", $"Bearer {_accessToken.access_token}"); var response = restClient.Get(request); return response.Content.Replace("\"", ""); }
/// <summary> /// Check if the plexIdleTimeout has elapsed since the last play /// </summary> /// <returns>true if no videos were marked watched since the timer interval</returns> public bool NoRecentPlay() { int plexIdleTimeout; int.TryParse(Properties.Settings.Default.PlexIdleTimeout, out plexIdleTimeout); if (string.IsNullOrEmpty(_user.authenticationToken)) { throw new Exception("No authentication token."); } var client = new RestClient("http://localhost:32400/status/sessions/history/all"); var request = new RestRequest(Method.GET); request.AddQueryParameter("X-Plex-Token", _user.authenticationToken); request.AddQueryParameter("X-Plex-Container-Start", "0"); request.AddQueryParameter("X-Plex-Container-Size", "1"); IRestResponse<PlexHistoryObjects.MediaContainer> response = client.Execute<PlexHistoryObjects.MediaContainer>(request); if (response.Data.Video != null) { var lastStream = response.Data.Video; DateTime lastStreamDateTime = UnixTimeStampToDateTime(double.Parse(lastStream.ViewedAt)); TimeSpan timeSpan = DateTime.Now - lastStreamDateTime; var msSinceLastStream = timeSpan.TotalMilliseconds; Trace.WriteLine("Last stream: " + lastStream.GrandparentTitle + " at " + lastStreamDateTime.ToUniversalTime()); return msSinceLastStream >= (plexIdleTimeout * Global.Minutes); } else { return true; } }
public RedirectResult SignIn(string login, string password, string appId, string redirectUri, string state) { var client = new RestClient("http://localhost:9999/api/"); var signInRequest = new RestRequest("Auth/SignIn"); signInRequest.AddQueryParameter("login",login); signInRequest.AddQueryParameter("password",password); signInRequest.AddQueryParameter("appId",appId); signInRequest.AddQueryParameter("redirectUri", redirectUri); signInRequest.AddQueryParameter("state","666"); var response = client.Post(signInRequest); var url = response.ResponseUri.ToString(); var urlArr = url.Split('?', '=', '&'); var user = Auth(login, password); if (user == null) throw new ArgumentException("Неверная пара логин/пароль"); var app = _appDataReposytory.AppDatas.FirstOrDefault(e => e.Id.ToString() == appId); if (app == null) throw new Exception("Нет приложения с таким appId"); _codes.Add(urlArr[2], user.Id); //_sessionHelper.CreateNewSession(user, app); return new RedirectResult(url); }
public async Task <Binance.WithdrawtHistory> GetWithdrawHistoryAsync(string asset = null) { const string endpoint = "/wapi/v3/withdrawHistory.html"; var serverTime = await GetServerTime(); var offset = serverTime - DateTime.UtcNow; var request = new RestSharp.RestRequest(endpoint, RestSharp.Method.GET); if (asset != null) { request.AddQueryParameter("asset", asset); } request.AddQueryParameter("timestamp", ToUnixTimestamp(DateTime.UtcNow.Add(offset)).ToString()); var uri = client.BuildUri(request); var signature = ByteArrayToHexString(SignString(uri.Query.Replace("?", string.Empty))); request.AddQueryParameter("signature", signature); request.AddHeader("X-MBX-APIKEY", ApiKey.ToManagedString()); var response = await client.ExecuteTaskAsync <Binance.WithdrawtHistory>(request).ConfigureAwait(false); if (response.IsSuccessful) { UpdateWeight(1); var result = response.Data; return(result); } else { throw new Exception(response.ErrorMessage); } }
public SignResult SignIn(SignInViewModel user) { var request = new RestSharp.RestRequest(AccountAPI.SignIn) { //JsonSerializer = new NewtonsoftJsonSerializer() }; request.AddQueryParameter("userId", user.UserId); request.AddQueryParameter("password", user.Password); IRestResponse response = _client.Get(request); var apiResponse = JsonConvert.DeserializeObject <GenericAPIResponse>(response.Content); var res = new SignResult() { Succeed = apiResponse.Success, ErrorMessage = apiResponse.Error }; if (apiResponse.Success) { var authResult = JsonConvert.DeserializeObject <AuthenticateResultModel>(apiResponse.Result.ToString()); res.User = new User() { UserId = authResult.UserId }; res.AccessToken = authResult.AccessToken; } return(res); }
public TimetableModel GetTimetable(string operatorName, string stopIdentifier, int numResults) { var request = new RestRequest("v1/timetables", Method.GET); request.RequestFormat = RestSharp.DataFormat.Json; request.AddQueryParameter("OperatorName", operatorName); request.AddQueryParameter("StopIdentifier", stopIdentifier); request.AddQueryParameter("NumResults", numResults.ToString()); var response = Client.Execute<TimetableModel>(request); if (response.StatusCode == System.Net.HttpStatusCode.OK) { if (response.Data == null || response.Data.Operator == null || response.Data.StopName == null || response.Data.TimetableEntry == null) { return null; } return response.Data; } else { Logger.Instance.Write("GetTimetable", LogLevel.Medium, "Call failed with status code " + response.StatusCode); return null; } }
public object GetObject(string resourceKey, CultureInfo culture) { var locale = (culture ?? GetCurrentUserCulture()).ToString(); var key = $"Resource{_applicationName}|{_resourceSet}|{resourceKey}|{locale}"; return _cacheProvider.GetValue(key, () => { var restRequest = new RestRequest("/api/resource") { OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; } }; restRequest.AddQueryParameter("application", _applicationName); restRequest.AddQueryParameter("resourceSet", _resourceSet); restRequest.AddQueryParameter("resourceKey", resourceKey); restRequest.AddQueryParameter("locale", locale); try { var response = _restClient.Get<Resource>(restRequest); if (response.ErrorMessage == "Unable to connect to the remote server") throw new HttpConnectionException(string.Format(Errors.UnableToConnect, _restClient.BaseUrl), response.ErrorException); if (response.StatusCode == HttpStatusCode.InternalServerError) throw new HttpConnectionException(Errors.ServerError, response.ErrorException); return response.Data.Value; } catch (Exception) { return resourceKey; } }); }
private static IRestRequest BuildRestRequestForMatchHistoryBySequenceNumber(int sequenceNumber, int matchesRequested) { var request = new RestRequest(RequestPaths.Dota2.Match.MatchHistoryBySequenceNumber); if (sequenceNumber > 0) request.AddQueryParameter("start_at_match_seq_num", sequenceNumber); if (matchesRequested > 0) request.AddQueryParameter("matches_requested", matchesRequested); return request; }
protected virtual RestRequest CreateRequest(string action, Method method = Method.POST, object body = null) { var request = new RestRequest(action, method) { RequestFormat = DataFormat.Json }; var includeBody = new[] { Method.POST, Method.PUT, Method.PATCH }.Contains(method); foreach (var header in headers) { request.AddHeader(header.Key, header.Value); } request.AddHeader("Authorization", "Bearer " + apiToken); request.AddHeader("User-Agent", GetUserAgent()); request.Timeout = timeout; if (body != null) { if (IsAnonymousType(body.GetType())) { if (includeBody) { request.AddJsonBody(body); } else { foreach (var prop in body.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public)) { request.AddQueryParameter(prop.Name, prop.GetValue(body).ToString()); } } } else { if (includeBody) { request.AddParameter("application/json", JsonConvert.SerializeObject(body), ParameterType.RequestBody); } else { body = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(body)); foreach (var prop in JObject.FromObject(body).Properties()) { request.AddQueryParameter(prop.Name, prop.Value.ToString()); } } } } return(request); }
/// <summary> /// Authenticate user by given username and password. /// </summary> /// <param name="username">Account username or email</param> /// <param name="password">Account password</param> /// <returns></returns> public TokenResult AuthenticateUser(string username, string password) { var request = new RestRequest(); request.Resource = "tokens"; request.Method = Method.POST; request.AddQueryParameter("username", username); request.AddQueryParameter("password", password); return Execute<TokenResult>(request); }
private string GetGiphy(string search) { var request = new RestRequest("/v1/gifs/translate", Method.GET); request.AddQueryParameter("s", search); request.AddQueryParameter("rating", Rating); request.AddQueryParameter("api_key", GiphyApiKey); var response = _client.Execute<dynamic>(request); var url = response.Data["data"]["images"]["fixed_height"]["url"]; return url; }
public string ExecuteQuery(string input,string page) { var request = new RestRequest(Resource); request.AddParameter("connectorId", ConnectorID, ParameterType.UrlSegment); if (!String.IsNullOrEmpty(input)) request.AddQueryParameter("input", input); if (!String.IsNullOrEmpty(page)) request.AddQueryParameter("page", page); return Execute(request); }
public IEnumerable<ScheduledGame> GetScheduledLeagueGames(DateTime dateMin = default(DateTime), DateTime dateMax = default(DateTime)) { var request = new RestRequest(RequestPaths.Dota2.League.ScheduledLeagueGames); var defaultDateTime = default(DateTime); if (dateMin != defaultDateTime) request.AddQueryParameter("date_min", dateMin.ToUnixTime()); if (dateMax != defaultDateTime) request.AddQueryParameter("date_max", dateMax.ToUnixTime()); var response = Execute<ScheduledLeagueGamesResponseWrapper>(request); return Mapper.Map<List<ScheduledGame>>(response.Games); }
internal void Apply(RestRequest request) { // offset and and limit request.AddQueryParameter("offset", _offset.ToString()); request.AddQueryParameter("limit", _limit.ToString()); // filter if needed if (_filter != null) _filter.Apply(request); // marker if needed if (_marker != null) _marker.Apply(request); }
public async Task <Binance.Blank> TestPlaceOrderAsync(string symbol, TradeSide side, Binance.OrderType type, decimal amount, decimal?price = null, decimal?stopPrice = null, Binance.TimeInForce tif = Binance.TimeInForce.GTC, string newClientOrderId = null) { var serverTime = await GetServerTime(); var offset = serverTime - DateTime.UtcNow; var request = new RestSharp.RestRequest(TestPlaceOrderEndpoint, RestSharp.Method.POST); request.AddQueryParameter("symbol", symbol); request.AddQueryParameter("side", side.ToString().ToUpper()); request.AddQueryParameter("type", type.ToString().ToUpper()); request.AddQueryParameter("quantity", amount.ToString()); request.AddQueryParameter("newOrderRespType", "RESULT"); request.AddQueryParameter("timeInForce", tif.ToString().ToUpper()); //request.AddQueryParameter("recvWindow", 60000); if (price != null) { request.AddQueryParameter("price", price.Value.ToString()); } if (newClientOrderId != null) { request.AddQueryParameter("newClientOrderId", newClientOrderId); } var result = await RequestSignedApiAsync <Binance.Blank>(request, TestPlaceOrderWeight, offset); return(result); }
static void Main() { var client = new RestClient("http://localhost:2741/api/calculator"); var request = new RestRequest("distance", Method.POST); request.AddQueryParameter("startX", "5"); request.AddQueryParameter("startY", "5"); request.AddQueryParameter("endX", "10"); request.AddQueryParameter("endY", "10"); RestResponse response = (RestResponse)client.Execute(request); var content = response.Content; Console.WriteLine(content); }
public static RestRequest GetDefaultRestRequest(string paramResource, Method paramMethod, Object paramBody) { SimpleJson.SimpleJson.CurrentJsonSerializerStrategy = new IgnoreNullValuesJsonSerializerStrategy(); RestRequest localRequest = new RestRequest { Resource = paramResource, Method = paramMethod, RequestFormat = DataFormat.Json, JsonSerializer = new NewtonsoftJsonSerializer() }; localRequest.AddHeader("Accept-Encoding", "gzip"); if (paramBody != null) { if (paramMethod == Method.GET || paramMethod == Method.DELETE) { foreach (var localJProperty in JObject.FromObject(paramBody).Properties().Where(x => !String.IsNullOrEmpty(x.Value.ToString()))) { localRequest.AddQueryParameter(localJProperty.Name, localJProperty.Value.ToString()); } } else { localRequest.AddJsonBody(paramBody); } } localRequest.Timeout = (int)TimeSpan.FromSeconds(60).TotalMilliseconds; return(localRequest); }
public static dynamic Get(string url, Dictionary <string, string> dic = null) { var client = new RestSharp.RestClient(url); var request = new RestSharp.RestRequest(RestSharp.Method.GET); try { if (dic != null) { foreach (var item in dic) { request.AddQueryParameter(item.Key, item.Value); } } request.AddHeader("header", "Accept: application/json"); RestResponse response = (RestResponse)client.Execute(request); var content = response.Content; return(content); } catch (Exception ex) { throw ex; } finally { client.ClearHandlers(); } }
public string ExecuteSearch(string query) { var request = new RestRequest(ResourceSearch); request.AddQueryParameter("q", query); return Execute(request); }
public IEnumerable<League> GetLeagueListing(string language = "en") { var request = new RestRequest(RequestPaths.Dota2.League.LeagueListing); request.AddQueryParameter("language", language); var response = Execute<LeagueListingResponseWrapper>(request); return Mapper.Map<List<League>>(response.Leagues); }
// Creates and sets up a RestRequest prior to a call. private RestRequest PrepareRequest( String path, RestSharp.Method method, Dictionary<String, String> queryParams, String postBody, Dictionary<String, String> headerParams, Dictionary<String, String> formParams, Dictionary<String, FileParameter> fileParams, Dictionary<String, String> pathParams) { var request = new RestRequest(path, method); // add path parameter, if any foreach(var param in pathParams) request.AddParameter(param.Key, param.Value, ParameterType.UrlSegment); // add header parameter, if any foreach(var param in headerParams) request.AddHeader(param.Key, param.Value); // add query parameter, if any foreach(var param in queryParams) request.AddQueryParameter(param.Key, param.Value); // add form parameter, if any foreach(var param in formParams) request.AddParameter(param.Key, param.Value); // add file parameter, if any foreach(var param in fileParams) request.AddFile(param.Value.Name, param.Value.Writer, param.Value.FileName, param.Value.ContentType); if (postBody != null) // http body (model) parameter request.AddParameter("application/json", postBody, ParameterType.RequestBody); return request; }
public void Should_update_users_status() { var url = string.Format("https://{0}/v2", EndpointHost); var client = new RestClient(url); var request = new RestRequest("/user/" + RestSharp.Contrib.HttpUtility.UrlEncode(Email), Method.PUT); request.AddQueryParameter("auth_token", Token); var user = new HipChatUser() { name = "", email = Email, presence = new Presence() { status = "blah", show = "away" }, mention_name = "" }; request.AddJsonBody(user); request.RequestFormat = DataFormat.Json; request.AddHeader("Content-type", "application/json"); request.AddHeader("Accept", "application/json"); var response = client.Execute(request); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); }
public MatchDetail GetMatch(string matchId) { var request = new RestRequest(RequestPaths.Dota2.Match.MatchDetails, Method.GET); request.AddQueryParameter("match_id", matchId); var response = Execute<MatchDetailResponse>(request); return Mapper.Map<MatchDetail>(response); }
public async Task <List <Binance.PriceTicker24hr> > Get24hrPriceTickerAsync(string symbol = null) { const string endpoint = "/api/v1/ticker/24hr"; var request = new RestSharp.RestRequest(endpoint, RestSharp.Method.GET); if (!string.IsNullOrWhiteSpace(symbol)) { request.AddQueryParameter("symbol", symbol); } var response = await client.ExecuteTaskAsync <List <Binance.PriceTicker24hr> >(request).ConfigureAwait(false); #if DEBUG System.IO.File.WriteAllText("ticker24h.json", response.Content); #endif if (response.IsSuccessful) { UpdateWeight(symbol != null ? 1 : 40); var result = response.Data; return(result); } else { throw new Exception(response.ErrorMessage); } }
/// <summary> /// Gets all the users in an account /// </summary> public virtual Task<UsersInfo> GetAsync(string email) { var request = new RestRequest(Method.GET); request.Resource = "users"; request.AddQueryParameter("x-user-email", email); return this.Sdk.ExecuteAsync<UsersInfo>(request); }
private static void OutputTradeInformation(string inputMarket, string inputCurrency) { var client = new RestClient { BaseUrl = new Uri(ConfigurationManager.AppSettings["BitcoinChartsBaseUri"]) }; var request = new RestRequest { Resource = "v1/trades.csv" }; request.AddQueryParameter("symbol", string.Concat(inputMarket, inputCurrency)); var response = client.Execute(request); if (response.StatusCode == HttpStatusCode.OK && response.Content.Length > 0) { var latestTradeData = response.Content.Substring(0, response.Content.IndexOf("\n")); var latestTradePice = Convert.ToDecimal(latestTradeData.Split(',')[1]); Console.WriteLine(latestTradePice.ToString("F2")); } else { Console.WriteLine("No data."); } }
private static JToken processAuthTokenJson(Dictionary<string, string> parameters, RestRequest request, Func<JContainer, JToken> process) { string userId = parameters[SessionParameter.User]; request.AddParameter("userId", userId, ParameterType.UrlSegment); request.AddQueryParameter("app", "cmissync"); return processJson(parameters, request, process); }
public async Task <List <Binance.Order> > GetOpenOrdersAsync(string symbol = null) { const string endpoint = "/api/v3/openOrders"; var serverTime = await GetServerTime(); var offset = serverTime - DateTime.UtcNow; var request = new RestSharp.RestRequest(endpoint, RestSharp.Method.GET); if (symbol != null) { request.AddQueryParameter("symbol", symbol); } var response = await RequestSignedApiAsync <List <Binance.Order> >(request, offset); if (response.IsSuccessful) { UpdateWeight(symbol != null ? 1 : 40); var result = response.Data; return(result); } else { throw new Exception(response.ErrorMessage); } }
/// <summary> /// http://docs.couchdb.org/en/2.0.0/api/document/common.html#obtaining-an-extended-revision-history /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <CouchResponse> GetRevisionInfoAsync(string id) { var request = new RestSharp.RestRequest(Helper.EncodeID(id), RestSharp.Method.GET); request.AddQueryParameter("revs_info", "true"); return(await client.http.ExecuteAsync(request)); }
/// <summary> /// Saves a tuple of key and value, both strings. Doesn't give a feedback whether the insert was successful or not. /// </summary> /// <param name="key">The key under which to insert.</param> /// <param name="value">The value to be inserted.</param> public void Save(string key, string value) { var request = new RestRequest("set", Method.POST); request.AddHeader("Content-Type", "application/x-www-form-urlencoded"); request.AddHeader("Accept", "*/*"); request.AddQueryParameter("key", key); request.AddQueryParameter("value", value); var response = _restClient.Execute(request); if (response.ResponseStatus == ResponseStatus.Error) { Logger.Log(string.Format("{0} ({1}:{2})", response.ErrorMessage, _ip, _port)); } }
public LeaguePrizePool GetPrizePoolForLeague(int leagueId) { var request = new RestRequest(RequestPaths.Dota2.League.LeaguePrizePool); request.AddQueryParameter("leagueid", leagueId); var response = Execute<LeaguePrizePoolResponse>(request); return Mapper.Map<LeaguePrizePool>(response); }
public Task<string> ExecuteSearchAsync(string query) { var request = new RestRequest(ResourceSearch); request.AddQueryParameter("q", query); return ExecuteAsync(request); }
public bool AuthorizationRevoke() { string path = string.Format("{0}revoke", rootPath); var request = new RestRequest(path, Method.GET) { RequestFormat = DataFormat.Json }; request.AddQueryParameter("access_token", settings.AccessToken); var response = client.Execute(request); return response.Content.Contains("ok"); }
internal RestSharp.RestRequest BuildRequest(StreamFeed feed, String path, Method method) { var request = new RestRequest(BaseUrlPath + feed.UrlPath + path, method); request.AddHeader("Authorization", feed.FeedTokenId + " " + feed.Token); request.AddHeader("Content-Type", "application/json"); request.AddQueryParameter("api_key", _apiKey); request.Timeout = _options.Timeout; return request; }
public void GetStreamOfDeviceEvents(string deviceId,string eventPrefix = ""){ var request = new RestRequest ("v1/devices/{deviceId}/events/{eventPrefix}"); request.AddQueryParameter ("deviceId", deviceId); if (!String.IsNullOrEmpty (eventPrefix)) { request.AddParameter("eventPrefix", eventPrefix); } request.AddQueryParameter ("access_token", AccessToken); var encoding = ASCIIEncoding.ASCII; var client = new RestClient (BaseUrl); request.ResponseWriter = (responseStream) => ReadStreamForever (responseStream, encoding); client.DownloadData (request); }
/// <summary> /// Assign contacts to the specified list. /// </summary> /// <param name="id">List ID</param> /// <param name="contactIds">Contact IDs</param> /// <returns></returns> public LinkResult AddContactsToList(int id, int[] contactIds) { var request = new RestRequest(Method.PUT); request.Resource = "lists/{id}/contacts"; request.AddUrlSegment("id", id.ToString()); if (contactIds != null && contactIds.Length > 0) request.AddQueryParameter("contacts", string.Join(",", contactIds)); return Execute<LinkResult>(request); }
public static GameData GetGame(string name, string platform = null) { var getGameURL = baseURL + "/GetGame.php"; var getGameAPI = new RestSharp.RestClient(getGameURL); var apiRequest = new RestSharp.RestRequest(Method.POST); apiRequest.AddQueryParameter("name", name); if (!string.IsNullOrEmpty(platform)) { apiRequest.AddQueryParameter("platform", platform); } apiRequest.RequestFormat = DataFormat.Xml; var response = getGameAPI.Execute(apiRequest); var gameData = ProcessXML.ParseXMLToModel <GameData>(response.Content); return(gameData); }
// Creates and sets up a RestRequest prior to a call. private RestRequest PrepareRequest( String path, RestSharp.Method method, Dictionary <String, String> queryParams, Object postBody, Dictionary <String, String> headerParams, Dictionary <String, String> formParams, Dictionary <String, FileParameter> fileParams, Dictionary <String, String> pathParams, String contentType) { var request = new RestRequest(path, method); request.JsonSerializer = new NewtonsoftJsonSerializer(); // add path parameter, if any foreach (var param in pathParams) { request.AddParameter(param.Key, param.Value, ParameterType.UrlSegment); } // add header parameter, if any foreach (var param in headerParams) { request.AddHeader(param.Key, param.Value); } // add query parameter, if any foreach (var param in queryParams) { request.AddQueryParameter(param.Key, param.Value); } // add form parameter, if any foreach (var param in formParams) { request.AddParameter(param.Key, param.Value); } // add file parameter, if any foreach (var param in fileParams) { request.AddFile(param.Value.Name, param.Value.Writer, param.Value.FileName, param.Value.ContentType); } if (postBody != null) // http body (model or byte[]) parameter { if (postBody.GetType() == typeof(String)) { request.AddParameter("application/json", postBody, ParameterType.RequestBody); } else if (postBody.GetType() == typeof(byte[])) { request.AddParameter(contentType, postBody, ParameterType.RequestBody); } } return(request); }
/// <summary> /// http://docs.couchdb.org/en/2.1.2/api/database/common.html#post--db /// </summary> /// <param name="json"></param> /// <param name="batchMode">http://docs.couchdb.org/en/2.1.2/api/database/common.html#batch-mode-writes</param> /// <returns></returns> public async Task <CouchResponse> InsertAsync(JToken json, bool batchMode = false) { var request = new RestSharp.RestRequest(RestSharp.Method.POST); if (batchMode) { request.AddQueryParameter("batch", "ok"); } request.AddParameter("application/json", json, ParameterType.RequestBody); return(await client.http.ExecuteAsync(request)); }
private static dynamic Execute(Options opts, Method method, object body) { RestClient client = new RestClient(opts.Url) { Authenticator = new HttpBasicAuthenticator(opts.User, opts.Pass) }; var request = new RestSharp.RestRequest("", method); if (method != Method.GET) { request.AddQueryParameter("action", opts.Action); } if (body != null && method != Method.GET) { request.AddJsonBody(body); } var response = client.Execute <dynamic>(request); if (response.ErrorException != null) { Console.WriteLine("Exception | {0}", opts.Url); Console.WriteLine(response.ErrorException.Message); throw new Exception(); } var statusCodes = new List <HttpStatusCode> { HttpStatusCode.OK, HttpStatusCode.Created, HttpStatusCode.Accepted, HttpStatusCode.NoContent }; if (response.StatusCode == HttpStatusCode.UnprocessableEntity && opts.Action != "upgrade") { return(response.Data); } if (statusCodes.Contains(response.StatusCode) == false) { Console.WriteLine("Invalid StatusCode | {0}", opts.Url); Console.WriteLine(response.StatusDescription); throw new Exception(); } return(response.Data); }
private RestRequest BuildRequest(string url, Method method, FilterBase filter = null) { if (!url.EndsWith("/")) { url += "/"; } var request = new RestRequest(url, method) { RequestFormat = DataFormat.Json }; request.AddHeader("Authorization", "Token " + _token); request.AddHeader("Accept-Language", Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName); if (_debugMode) { request.AddHeader("X-Log", "1"); } request.JsonSerializer = _serializer; if (filter != null) { if (filter.ModifiedSince != null) { request.AddQueryParameter("date_modified__gt", filter.ModifiedSince.Value.ToString("YYYY-DD-MMTHH:mm:ss")); } if (filter.Limit != null) { request.AddQueryParameter("limit", filter.Limit.Value.ToString()); } if (filter.Offset != null) { request.AddQueryParameter("offset", filter.Offset.Value.ToString()); } } return(request); }
public async Task <Binance.WithdrawtHistory> GetWithdrawHistoryAsync(string asset = null) { var serverTime = await GetServerTime(); var offset = serverTime - DateTime.UtcNow; var request = new RestSharp.RestRequest(GetWithdrawHistoryEndpoint, RestSharp.Method.GET); if (asset != null) { request.AddQueryParameter("asset", asset); } var result = await RequestSignedApiAsync <Binance.WithdrawtHistory>(request, GetWithdrawHistoryWeight, offset); return(result); }
public Request AddParameter(string parameter, string value, bool urlSegment = false) { switch (_Method) { case Method.Post: _RestRequest.AddParameter(parameter, value, ParameterType.QueryString); break; case Method.Get: if (urlSegment) { _RestRequest.AddUrlSegment(parameter, value); } else { _RestRequest.AddQueryParameter(parameter, value); } break; } return(this); }
public Task <BaseRestSharp.RestResponse> InvokeCall(HttpServiceRequest httpRequest, bool throwException = true, bool isElasticLog = false, bool invokeAsync = false) { ServicePointManager.DefaultConnectionLimit = 200; // Base URL BaseRestSharp.RestClient client = new BaseRestSharp.RestClient(httpRequest.Url); BaseRestSharp.IRestResponse response = null; Stopwatch watch = new Stopwatch(); // Method to be triggered BaseRestSharp.RestRequest request = new BaseRestSharp.RestRequest(httpRequest.Action, (BaseRestSharp.Method)httpRequest.MethodType) { Timeout = httpRequest.Timeout }; if (httpRequest.CookieJar != null) { foreach (Cookie cookie in httpRequest.CookieJar) { request.AddCookie(cookie.Name, cookie.Value); } } if (httpRequest.Body != null) { request.RequestFormat = BaseRestSharp.DataFormat.Json; request.AddJsonBody(httpRequest.Body); } if (httpRequest.Headers != null) { foreach (KeyValuePair <string, string> header in httpRequest.Headers.ToList()) { request.AddHeader(header.Key, header.Value); } } if (httpRequest.QueryStringParameters != null) { foreach (KeyValuePair <string, string> param in httpRequest.QueryStringParameters.ToList()) { request.AddQueryParameter(param.Key, param.Value); } } watch.Start(); BaseRestSharp.RestResponse customRestResponse = null; TaskCompletionSource <BaseRestSharp.RestResponse> taskCompletionSource = new TaskCompletionSource <BaseRestSharp.RestResponse>(); response = client.Execute(request); watch.Stop(); taskCompletionSource.SetResult(customRestResponse); ResponseVerifications(response, throwException, httpRequest.Url, httpRequest.MethodType); return(taskCompletionSource.Task); }
/// <summary> /// add a query parameter to the request /// </summary> /// <param name="key">parameter key</param> /// <param name="value">value</param> /// <returns>this HttpProvider</returns> public HttpProvider WithQueryParameter(string key, string value) { _request.AddQueryParameter(key, value); return(this); }
public async Task<Object> CallApiAsync(String Path, RestSharp.Method Method, Dictionary<String, String> QueryParams, String PostBody, Dictionary<String, String> HeaderParams, Dictionary<String, String> FormParams, Dictionary<String, String> FileParams, String[] AuthSettings) { var request = new RestRequest(Path, Method); UpdateParamsForAuth(QueryParams, HeaderParams, AuthSettings); // add default header, if any foreach(KeyValuePair<string, string> defaultHeader in this.defaultHeaderMap) request.AddHeader(defaultHeader.Key, defaultHeader.Value); // add header parameter, if any foreach(KeyValuePair<string, string> param in HeaderParams) request.AddHeader(param.Key, param.Value); // add query parameter, if any foreach(KeyValuePair<string, string> param in QueryParams) request.AddQueryParameter(param.Key, param.Value); // add form parameter, if any foreach(KeyValuePair<string, string> param in FormParams) request.AddParameter(param.Key, param.Value); // add file parameter, if any foreach(KeyValuePair<string, string> param in FileParams) request.AddFile(param.Key, param.Value); if (PostBody != null) { request.AddParameter("application/json", PostBody, ParameterType.RequestBody); // http body (model) parameter } return (Object) await restClient.ExecuteTaskAsync(request); }
public RedirectResult SignIn(string login, string password, string appId, string redirectUri, string state) { var client = new RestClient(SiteConn.AuthWebApiServer); var signInRequest = new RestRequest("Auth/SignIn"); signInRequest.AddQueryParameter("login",login); signInRequest.AddQueryParameter("password",password); signInRequest.AddQueryParameter("appId",appId); signInRequest.AddQueryParameter("redirectUri", redirectUri); signInRequest.AddQueryParameter("state","666"); var response = client.Post(signInRequest); if (response == null) return new RedirectResult(redirectUri); //получаю куки с токеном if (response.Cookies != null) { return new RedirectResult(redirectUri); } return null; }