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