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