/// <summary> /// Makes the HTTP request (Sync). /// </summary> /// <param name="path">URL path.</param> /// <param name="method">HTTP method.</param> /// <param name="queryParams">Query parameters.</param> /// <param name="postBody">HTTP body (POST request).</param> /// <param name="headerParams">Header parameters.</param> /// <param name="formParams">Form parameters.</param> /// <param name="fileParams">File parameters.</param> /// <param name="authSettings">Authentication settings.</param> /// <returns>Object</returns> public Object CallApi(String path, RestSharp.Method method, Dictionary<String, String> queryParams, String postBody, Dictionary<String, String> headerParams, Dictionary<String, String> formParams, Dictionary<String, FileParameter> fileParams, String[] authSettings) { var request = new RestRequest(path, method); UpdateParamsForAuth(queryParams, headerParams, authSettings); // add default header, if any foreach(var defaultHeader in _defaultHeaderMap) request.AddHeader(defaultHeader.Key, defaultHeader.Value); // 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.AddParameter(param.Key, param.Value, ParameterType.GetOrPost); // add form parameter, if any foreach(var param in formParams) request.AddParameter(param.Key, param.Value, ParameterType.GetOrPost); // 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 (Object)RestClient.Execute(request); }
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 override void PrepareRequest(RestSharp.RestRequest req) { req.AddParameter("clientString", _clientString, ParameterType.GetOrPost); req.AddParameter("client_id", _clientId, ParameterType.GetOrPost); req.AddParameter("userLogin", _username, ParameterType.GetOrPost); req.AddParameter("password", _password, ParameterType.GetOrPost); }
// 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 SDK.Http.IHttpResponse ToHttpResponse(RestSharp.IRestResponse response) { bool transportError = false; var responseMessages = new List<string>(); transportError = response.ResponseStatus == RestSharp.ResponseStatus.TimedOut || response.ResponseStatus == RestSharp.ResponseStatus.Aborted; if (response.ErrorException != null) { responseMessages.Add(response.ErrorException.Message); } else if (!string.IsNullOrEmpty(response.ErrorMessage)) { responseMessages.Add(response.ErrorMessage); } if (!string.IsNullOrEmpty(response.StatusDescription)) { responseMessages.Add(response.StatusDescription); } var headers = this.ToHttpHeaders(response.Headers); return new Impl.Http.DefaultHttpResponse( (int)response.StatusCode, string.Join(Environment.NewLine, responseMessages), headers, response.Content, response.ContentType, transportError); }
/// <summary> /// Adds the API token key to the REST request header /// </summary> public void Authenticate(RestSharp.IRestClient client, RestSharp.IRestRequest request) { if (!request.Parameters.Any(p => p.Name.Equals("X-TOKEN", StringComparison.OrdinalIgnoreCase))) { var token = string.Format("{0}", _apiToken); request.AddParameter("X-TOKEN", token, ParameterType.HttpHeader); } }
public Object CallApi(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 response = Task.Run(async () => { var resp = await CallApiAsync(Path, Method, QueryParams, PostBody, HeaderParams, FormParams, FileParams, AuthSettings); return resp; }); return response.Result; }
public async Task<AddACHNodeResponse> AddACHNodeAsync(AddACHNodeRequest msg) { var req = new RestRequest("node/add", Method.POST); var body = new { login = new { oauth_key = msg.OAuth.Key }, user = new { fingerprint = msg.Fingerprint }, node = new { type = "ACH-US", info = new { nickname = msg.Nickname, name_on_account = msg.NameOnAccount, account_num = msg.AccountNumber, routing_num = msg.RoutingNumber, type = msg.AccountType.ToString().ToUpper(), @class = msg.AccountClass.ToString().ToUpper() }, extra = new { supp_id = msg.LocalId } } }; req.AddJsonBody(body); var resp = await this._api.ExecuteTaskAsync(req); RaiseOnAfterRequest(body, req, resp); dynamic data = SimpleJson.DeserializeObject(resp.Content); if (resp.IsHttpOk() && data.success) { var node = data.nodes[0]; var info = node.info; return new AddACHNodeResponse { Success = true, IsActive = node.is_active, Permission = ParseNodePermission(node.allowed), Message = ApiHelper.TryGetMessage(data), SynapseNodeOId = node._id["$oid"] }; } else { return new AddACHNodeResponse { Success = false, Message = ApiHelper.TryGetError(data) }; } }
protected RestSharp.IRestResponse Execute(string url, RestSharp.Method method, List<Header> headers) { if (headers == null) headers = new List<Header>(); RestSharp.IRestClient client = new RestSharp.RestClient(Root); RestSharp.IRestRequest request = new RestSharp.RestRequest(url, method); foreach (var header in headers) { request.AddParameter(header.Name, header.Value, RestSharp.ParameterType.HttpHeader); } request.RequestFormat = RestSharp.DataFormat.Json; var response = client.Execute(request); return response; }
private void CopyHeaders(SDK.Http.HttpHeaders httpHeaders, RestSharp.IRestRequest restRequest) { if (httpHeaders == null) { return; } foreach (var header in httpHeaders) { foreach (var value in header.Value) { restRequest.AddHeader(header.Key, value); } } }
internal bool CheckException(RestSharp.IRestResponse response) { if (response.ErrorException != null) { _log.Error(string.Format("Response error. StockID: {0}, Date: {1}", MineCar.StockID, MineCar.MiningDate), response.ErrorException); return false; } else if (!response.RawBytes.Any()) { _log.ErrorFormat("RawBytes is empty. StockID: {0}, Date: {1}", MineCar.StockID, MineCar.MiningDate); return false; } return true; }
/// <summary> /// Get 请求 /// </summary> /// <typeparam name="T">泛型</typeparam> /// <param name="baseUrl">根域名:http://apk.neters.club/</param> /// <param name="url">接口:api/xx/yy</param> /// <param name="pragm">参数:id=2&name=老张</param> /// <remarks></remarks> /// <returns></returns> public static T GetApi <T>(string baseUrl, string url, string pragm = "") { var client = new RestSharp(baseUrl); var request = client.Execute(string.IsNullOrEmpty(pragm) ? new RestRequest(url, Method.GET) : new RestRequest($"{url}?{pragm}", Method.GET)); if (request.StatusCode != HttpStatusCode.OK) { return((T)Convert.ChangeType(request.ErrorMessage, typeof(T))); } dynamic temp = Newtonsoft.Json.JsonConvert.DeserializeObject(request.Content, typeof(T)); return((T)temp); }
public RestAPIResponse Request(string endpoint, dynamic parameters = null, RestSharp.Method method = Method.GET) { var request = new RestRequest(endpoint, method); RestAPIResponse result = null; if (parameters != null) request.Parameters.AddRange(APIHelpers.ParseParameters(endpoint, parameters)); IRestResponse response = _client.Execute(request); if(endpoint == "pull") { result = new PullAPIResponse() { RateLimit = APIHelpers.ParseRateLimitHeaders(response.Headers), StatusCode = response.StatusCode, PullDetails = APIHelpers.ParsePullDetailHeaders(response.Headers) }; result.Data = APIHelpers.DeserializeResponse(response.Content, ((PullAPIResponse)result).PullDetails.Format); } else { result = new RestAPIResponse() { RateLimit = APIHelpers.ParseRateLimitHeaders(response.Headers), StatusCode = response.StatusCode }; result.Data = APIHelpers.DeserializeResponse(response.Content); } switch((int)response.StatusCode) { // Ok status codes case 200: case 201: case 202: case 204: break; //Error status codes case 400: case 401: case 403: case 404: case 405: case 409: case 413: case 416: case 500: case 503: throw new RestAPIException(result, (APIHelpers.HasAttr(result.Data, "error")) ? result.Data.error : "The request failed, please see the Data & StatusCode properties for more details."); } return result; }
// This is utility function used to set Request Header and Request Parameters. private void WarmupRequest(RestSharp.Method currentMethod,string host,string requestURL , Dictionary<string,string> parameters, Dictionary<string,string> header) { restClient = new RestClient(host); restRequest = new RestRequest(requestURL, currentMethod); if(parameters!=null) foreach (string paramKey in parameters.Keys) { restRequest.AddParameter(paramKey,parameters[paramKey]); } if(header!= null) foreach (string headerKey in header.Keys) { restRequest.AddParameter(headerKey, parameters[headerKey]); } }
private string Request(string path, RestSharp.Method method, string Data) { var request = new RestRequest(path, method); request.AddParameter("text/plain", Data, ParameterType.RequestBody); RestResponse response = Cli.Execute(request); var code = response.StatusCode; if(code == HttpStatusCode.Created || code == HttpStatusCode.OK || code == HttpStatusCode.NoContent) { return response.Content; } else { string ErrorMessage = Json.Deserialize<CoconutError> (response.Content).Message; throw new CoconutException(ErrorMessage); } }
// Creates and sets up a RestRequest prior to a call. protected virtual 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); // 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; }
// 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, String[] authSettings) { var request = new RestRequest(path, method); String epath = path; foreach(var v in pathParams) epath = epath.Replace("{" + v.Key + "}", v.Value); UpdateParamsForAuth(epath, method, queryParams, headerParams, formParams, authSettings); // add default header, if any foreach(var defaultHeader in _defaultHeaderMap) request.AddHeader(defaultHeader.Key, defaultHeader.Value); // 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 static void Append(string p, RestSharp.IRestResponse response) { #if false StringBuilder sb = new StringBuilder(); var request = response.Request; if (request != null) { sb.Append(request.Resource); if (request.Parameters != null && request.Parameters.Count > 0) { sb.Append("?"); foreach (var item in request.Parameters) sb.AppendFormat("{0}={1}&", item.Name, item.Value); } } Append(p, sb.ToString(), response.Content); #endif }
public static void PrepareServiceCall(CommonQueryParameters.SignatureMethodTypes methodType,string awsAccessKeyId, string awsSecretAccessKey, out RestSharp.RestClient restClient, out RestSharp.RestRequest restRequest) { var signer = methodType == CommonQueryParameters.SignatureMethodTypes.HmacSHA1 ? (HMAC) new HMACSHA1() : new HMACSHA256(System.Text.Encoding.UTF8.GetBytes(awsSecretAccessKey)); var dateHeaderValue = DateTime.UtcNow.ToString("r"); var stringToSign = signer.ComputeHash(Encoding.UTF8.GetBytes(dateHeaderValue)); var requestSignature = Convert.ToBase64String(stringToSign); var awsAuthHeaderValue = String.Format( "AWS3-HTTPS AWSAccessKeyId={0}, Algorithm={1}, Signature={2}", awsAccessKeyId, methodType, requestSignature ); restClient = new RestSharp.RestClient("https://email.us-east-1.amazonaws.com") { FollowRedirects = true }; restRequest = new RestSharp.RestRequest(Method.POST); restRequest.AddHeader("X-Amzn-Authorization", awsAuthHeaderValue); restRequest.AddHeader("x-amz-date", dateHeaderValue); }
/// <summary> /// Enumerates the client's cookie container looking for the cookie requested and calls the action when the cookie is found /// </summary> /// <param name="client">The client to be processed against</param> /// <param name="cookieName">The name of the cookie to locate</param> /// <param name="foundCookie">The action to occur if the cookie is found</param> /// <returns>Whether or not the cookie is found</returns> private static bool FindCookie(RestSharp.IRestClient client, string cookieName, Action<Cookie> foundCookie) { bool result = false; if (client != null && client.CookieContainer != null || client.CookieContainer.GetCookies(client.BaseUrl).Count >= 0) { foreach (Cookie cookie in client.CookieContainer.GetCookies(client.BaseUrl)) { if (string.Equals(cookie.Name, cookieName) == true) { if (foundCookie != null) { foundCookie(cookie); } result = true; break; } } } return result; }
/// <summary> /// Creates a new Insurance entity from JSON /// </summary> /// <param name="json">JSON to use</param> /// <param name="deserializer">Deserializer to use</param> /// <returns></returns> public static new Entity CreateEntity(string json, RestSharp.Deserializers.JsonDeserializer deserializer) { return Deserialize<Insurance>(json, deserializer); }
/// <summary> /// Makes the asynchronous HTTP request. /// </summary> /// <param name="path">URL path.</param> /// <param name="method">HTTP method.</param> /// <param name="queryParams">Query parameters.</param> /// <param name="postBody">HTTP body (POST request).</param> /// <param name="headerParams">Header parameters.</param> /// <param name="formParams">Form parameters.</param> /// <param name="fileParams">File parameters.</param> /// <param name="pathParams">Path parameters.</param> /// <param name="contentType">Content type.</param> /// <returns>The Task instance.</returns> public async System.Threading.Tasks.Task<Object> CallApiAsync( 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 = PrepareRequest( path, method, queryParams, postBody, headerParams, formParams, fileParams, pathParams, contentType); InterceptRequest(request); var response = await RestClient.ExecuteTaskAsync(request); InterceptResponse(request, response); return (Object)response; }
/// <summary> /// Makes the HTTP request (Sync). /// </summary> /// <param name="path">URL path.</param> /// <param name="method">HTTP method.</param> /// <param name="queryParams">Query parameters.</param> /// <param name="postBody">HTTP body (POST request).</param> /// <param name="headerParams">Header parameters.</param> /// <param name="formParams">Form parameters.</param> /// <param name="fileParams">File parameters.</param> /// <param name="pathParams">Path parameters.</param> /// <param name="contentType">Content Type of the request</param> /// <returns>Object</returns> public Object CallApi( 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 = PrepareRequest( path, method, queryParams, postBody, headerParams, formParams, fileParams, pathParams, contentType); // set timeout RestClient.Timeout = Configuration.Timeout; // set user agent RestClient.UserAgent = Configuration.UserAgent; InterceptRequest(request); var response = RestClient.Execute(request); InterceptResponse(request, response); return (Object) response; }
/// <summary> /// Makes the HTTP request (Sync). /// </summary> /// <param name="path">URL path.</param> /// <param name="method">HTTP method.</param> /// <param name="queryParams">Query parameters.</param> /// <param name="postBody">HTTP body (POST request).</param> /// <param name="headerParams">Header parameters.</param> /// <param name="formParams">Form parameters.</param> /// <param name="fileParams">File parameters.</param> /// <param name="pathParams">Path parameters.</param> /// <param name="contentType">Content Type of the request</param> /// <returns>Object</returns> public Object CallApi( 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 = PrepareRequest( path, method, queryParams, postBody, headerParams, formParams, fileParams, pathParams, contentType); var response = RestClient.Execute(request); return (Object) response; }
/// <summary> /// Makes the asynchronous HTTP request. /// </summary> /// <param name="path">URL path.</param> /// <param name="method">HTTP method.</param> /// <param name="queryParams">Query parameters.</param> /// <param name="postBody">HTTP body (POST request).</param> /// <param name="headerParams">Header parameters.</param> /// <param name="formParams">Form parameters.</param> /// <param name="fileParams">File parameters.</param> /// <param name="pathParams">Path parameters.</param> /// <param name="authSettings">Authentication settings.</param> /// <returns>The Task instance.</returns> public async System.Threading.Tasks.Task<Object> CallApiAsync( 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, String[] authSettings) { var request = PrepareRequest( path, method, queryParams, postBody, headerParams, formParams, fileParams, pathParams, authSettings); var response = await RestClient.ExecuteTaskAsync(request); StatusCode = (int)response.StatusCode; ResponseHeaders = response.Headers.ToDictionary(x => x.Name, x => x.Value.ToString()); return (Object)response; }
public DropNetResult(RestSharp.RestResponse m) { StatusCode = m.StatusCode; }
/// <summary> /// Creates a new ChecklistValue entity from JSON /// </summary> /// <param name="json">JSON to use</param> /// <param name="deserializer">Deserializer to use</param> /// <returns></returns> public static new Entity CreateEntity(string json, RestSharp.Deserializers.JsonDeserializer deserializer) { return Deserialize<ChecklistValue>(json, deserializer); }
public static void GetToken() { var restApi = new RestSharp(); }
/// <summary> /// Create entity from JSON /// </summary> /// <param name="json">JSON to use</param> /// <param name="deserializer">Deserializer to use</param> /// <returns></returns> public static new Entity CreateEntity(string json, RestSharp.Deserializers.JsonDeserializer deserializer) { return Deserialize<MetadataHolder>(json, deserializer); }
private static bool IsValidBaseUrl(RestSharp.IRestClient client, SDK.Http.IHttpRequest request) { return request.CanonicalUri .ToString() .Contains(client.BaseUrl.ToString()); }
/// <summary> /// Adds the authentication tokens to the request if the parameters don't include them /// </summary> /// <param name="request">The request object to be checked</param> private RestSharp.IRestRequest AddAuthTokensAsNecessary(RestSharp.IRestRequest request) { if (string.IsNullOrEmpty(loginToken) == false && request.Parameters.Count(x => string.Equals(x.Name, clientConfig.TokenCookieName) == true) == 0) { request.AddParameter(clientConfig.TokenCookieName, loginToken); } if (string.IsNullOrEmpty(sessionToken) == false && request.Parameters.Count(x => string.Equals(x.Name, clientConfig.SessionCookieName) == true) == 0) { request.AddParameter(clientConfig.SessionCookieName, sessionToken); } return request; }
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); }