private CustomResponse HttpRequest(IRestRequest request, string url, Dictionary<string, string> parameters = null)
{
try
{
IRestClient client = new RestClient();
IRestResponse response = new RestResponse();
client.BaseUrl = new Uri(url);
if (parameters != null)
{
foreach (var item in parameters)
{
request.AddParameter(item.Key, item.Value);
}
}
response = client.Execute(request);
var myResponse = new CustomResponse();
myResponse.StatusCode = response.StatusCode;
myResponse.Content = response.Content;
return myResponse;
}
catch(Exception ex)
{
throw ex;
}
}
public override void AddFilter(IRestRequest request)
{
base.AddFilter(request);
if (MinimumId != null)
{
request.AddParameter("min_id", MinimumId, ParameterType.GetOrPost);
}
if (MaximumId != null)
{
request.AddParameter("max_id", MaximumId, ParameterType.GetOrPost);
}
if (Name != null)
{
request.AddParameter("name", Name, ParameterType.GetOrPost);
}
if (ParentId != null)
{
request.AddParameter("parent_id", ParentId, ParameterType.GetOrPost);
}
if (IsVisible != null)
{
request.AddParameter("is_visible", IsVisible, ParameterType.GetOrPost);
}
}
public override void AddFilter(IRestRequest request) {
base.AddFilter(request);
if (StateName != null) {
request.AddParameter("state", StateName, ParameterType.GetOrPost);
}
if (StateAbbreviation != null) {
request.AddParameter("state_abbreviation", StateAbbreviation, ParameterType.GetOrPost);
}
}
public override void AddFilter(IRestRequest request) {
base.AddFilter(request);
if (CountryName != null) {
request.AddParameter("country", CountryName, ParameterType.GetOrPost);
}
if (CountryIso2 != null) {
request.AddParameter("country_iso2", CountryIso2, ParameterType.GetOrPost);
}
if (CountryIso3 != null) {
request.AddParameter("country_iso3", CountryIso3, ParameterType.GetOrPost);
}
}
public void Populate(IRestRequest request)
{
if (!string.IsNullOrEmpty(_bankAccount.Description))
request.AddParameter("description", _bankAccount.Description);
request.AddParameter("routing_number", _bankAccount.RoutingNumber);
request.AddParameter("account_number", _bankAccount.AccountNumber);
request.AddParameter("account_type", _bankAccount.AccountType == AccountType.Company ? "company" : "individual");
request.AddParameter("signatory", _bankAccount.Signatory);
if(_bankAccount.MetaData != null)
new MetaDataPopulator(_bankAccount.MetaData).Populate(request);
}
public virtual void AddFilter(IRestRequest request)
{
if (this.IfModifiedSince != null)
request.AddHeader("If-Modified-Since", String.Format(RFC2822_DATE_FORMAT, this.IfModifiedSince));
if (this.Limit != null)
{
request.AddParameter("limit", Limit, ParameterType.GetOrPost);
}
if (this.Page != null)
{
request.AddParameter("page", Page, ParameterType.GetOrPost);
}
}
public override void AddFilter(IRestRequest request)
{
base.AddFilter(request);
if (this.Name != null)
{
request.AddParameter("name", this.Name, ParameterType.GetOrPost);
}
if (this.IsDefault != null)
{
request.AddParameter("is_default", this.IsDefault, ParameterType.GetOrPost);
}
}
public override void AddFilter(IRestRequest request) {
base.AddFilter(request);
if (this.Name != null) {
request.AddParameter("name", this.Name, ParameterType.GetOrPost);
}
if (this.DisplayName != null) {
request.AddParameter("display_name", this.DisplayName, ParameterType.GetOrPost);
}
if (this.OptionType != null) {
request.AddParameter("type", this.OptionType, ParameterType.GetOrPost);
}
}
public void Populate(IRestRequest request)
{
var addressPopulator = new AddressPopulator(_address);
addressPopulator.Populate(request);
if (_addressInfo.Description != null) request.AddParameter("description", _addressInfo.Description);
if (_addressInfo.MetaData != null)
{
var populator = new MetaDataPopulator(_addressInfo.MetaData);
populator.Populate(request);
}
if (_addressInfo.Name != null) request.AddParameter("name", _addressInfo.Name);
if (_addressInfo.Phone != null) request.AddParameter("phone", _addressInfo.Phone);
if (_addressInfo.Email != null) request.AddParameter("email", _addressInfo.Email);
if (_addressInfo.Company != null) request.AddParameter("company", _addressInfo.Company);
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
public void Authenticate(IRestClient client, IRestRequest request)
{
// only add the Authorization parameter if it hasn't been added by a previous Execute
if (request.Parameters.Any(p => p.Name != null && p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
return;
request.AddParameter("Authorization", this._authHeader, ParameterType.HttpHeader);
}
private void PopulateRoutes(IRestRequest request)
{
foreach (var route in _definition.Routes)
{
request.AddParameter("routes", route.ToString());
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
if(!request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
{
request.AddParameter("Authorization", "SuTToken " + _token, ParameterType.HttpHeader);
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
if (request.Parameters.Exists(p => p.Name.Equals("Cookie", StringComparison.InvariantCultureIgnoreCase)))
return;
request.AddParameter("cookie", _authHeader, ParameterType.HttpHeader);
}
public override void Authenticate(IRestClient client, IRestRequest request)
{
// only add the Authorization parameter if it hasn't been added.
if (!request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
{
request.AddParameter("Authorization", _authorizationValue, ParameterType.HttpHeader);
}
}
public void Populate(IRestRequest request)
{
if (_data == null) return;
foreach (var kvp in _data)
{
request.AddParameter(string.Format("data[{0}]", kvp.Key), kvp.Value);
}
}
public void Populate(IRestRequest request)
{
if (!string.IsNullOrEmpty(_definition.Description))
request.AddParameter("description", _definition.Description);
PopulateRoutes(request);
PopulateSubEntities(request);
PopulateTargetType(request);
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
public void Authenticate(IRestClient client, IRestRequest request)
{
if (HasDigestHeader)
{
var digestHeader = GetDigestHeader(client, request);
request.AddParameter("Authorization", digestHeader, ParameterType.HttpHeader);
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
if (!string.IsNullOrEmpty(AccessToken))
{
request.AddHeader("Authorization", string.Format("Bearer {0}", AccessToken));
}
request.AddParameter("app_key", AppKey);
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
public void Authenticate(IRestClient client, IRestRequest request)
{
// only add the Authorization parameter if it hasn't been added by a previous Execute
if (request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
return;
var token = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", _username, _password)));
var authHeader = string.Format("Basic {0}", token);
request.AddParameter("Authorization", authHeader, ParameterType.HttpHeader);
}
public void Populate(IRestRequest request)
{
if (_target.AddressId != null)
{
request.AddParameter(_type, _target.AddressId);
}
else
{
var addressPopulator = new AddressPopulator(_target.Address, _type);
addressPopulator.Populate(request);
}
}
public void Populate(IRestRequest request)
{
if (_address.Name != null) request.AddParameter(Wrap("name"), _address.Name);
if (_address.Line1 != null) request.AddParameter(Wrap("address_line1"), _address.Line1);
if (_address.Line2 != null) request.AddParameter(Wrap("address_line2"), _address.Line2);
if (_address.City != null) request.AddParameter(Wrap("address_city"), _address.City);
if (_address.State != null) request.AddParameter(Wrap("address_state"), _address.State);
if (_address.ZipCode != null) request.AddParameter(Wrap("address_zip"), _address.ZipCode);
if (_address.Country != null) request.AddParameter(Wrap("address_country"), _address.Country);
}
public void Populate(IRestRequest request)
{
var toPopulator = new TargetAddressPopulator(_letterDefinition.ToAddress, "to");
var fromPopulator = new TargetAddressPopulator(_letterDefinition.FromAddress, "from");
var filePopulator = new LobImageFilePopulator(_letterDefinition.File, "file");
var dataPopulator = new DataPopulator(_letterDefinition.Data);
var metadataPopulator = new MetaDataPopulator(_letterDefinition.MetaData);
toPopulator.Populate(request);
fromPopulator.Populate(request);
filePopulator.Populate(request);
dataPopulator.Populate(request);
metadataPopulator.Populate(request);
request.AddParameter("color", _letterDefinition.Color);
request.AddParameter("description", _letterDefinition.Description);
request.AddParameter("double_sided", _letterDefinition.DoubleSided);
PopulateReturnEnvelope(request);
PopulateAddressPlacement(request);
PopulateExtraService(request);
}
public void Authenticate(IRestClient client, IRestRequest request)
{
// NetworkCredentials always makes two trips, even if with PreAuthenticate,
// it is also unsafe for many partial trust scenarios
// request.Credentials = Credentials;
// thanks TweetSharp!
// request.Credentials = new NetworkCredential(username, password);
// only add the Authorization parameter if it hasn't been added by a previous Execute
if (!request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
{
request.AddParameter("Authorization", this.authHeader, ParameterType.HttpHeader);
}
}
protected async Task<string> ExecuteTaskASync(IRestRequest request)
{
//Workaround to invalidate WebRequest cache from client
request.AddParameter("no-cache", Guid.NewGuid());
var response = await RestClient.ExecuteTaskAsync(request);
if (response.ErrorException != null)
throw response.ErrorException;
HttpRequestHelper.HandleHttpCodes(response.StatusCode);
return response.Content;
}
public override void AddFilter(IRestRequest request) {
base.AddFilter(request);
if (this.CouponCode != null) {
request.AddParameter("code", this.CouponCode, ParameterType.GetOrPost);
}
if (this.CouponType != null) {
request.AddParameter("type", this.CouponType, ParameterType.GetOrPost);
}
if (this.Name != null) {
request.AddParameter("name", this.Name, ParameterType.GetOrPost);
}
if (this.MinId != null) {
request.AddParameter("min_id", this.MinId, ParameterType.GetOrPost);
}
if (this.MaxId != null) {
request.AddParameter("max_id", this.MaxId, ParameterType.GetOrPost);
}
}
private void PopulateAddressPlacement(IRestRequest request)
{
var value = "";
switch (_letterDefinition.AddressPlacement)
{
case AddressPlacement.InsertBlankPage:
value = "insert_blank_page";
break;
case AddressPlacement.TopFirstPage:
value = "top_first_page";
break;
}
request.AddParameter("address_placement", value);
}
private void PopulateTargetType(IRestRequest request)
{
var value = "";
switch (_definition.TargetType)
{
case TargetType.All:
value = "all";
break;
case TargetType.Residential:
value = "residential";
break;
}
request.AddParameter("target_type", value);
}
public void Authenticate(IRestClient client, IRestRequest request)
{
var nonce = GetNonce();
var url = client.BuildUri(request);
request.AddParameter("nonce", nonce, ParameterType.GetOrPost);
var @params = request.Parameters.Where(p => p.Type == ParameterType.GetOrPost)
.Select(p => p.Name.UrlEncode() + "=" + p.Value.ToString().UrlEncode());
var hmacSig = GenerateSignature(string.Join("&", @params.ToArray()), this.apiSecret);
request.AddHeader("x-api-key", this.apiKey)
.AddHeader("x-api-sign", hmacSig);
}
public void Authenticate(IRestClient client, IRestRequest request) {
// NetworkCredentials always makes two trips, even if with PreAuthenticate,
// it is also unsafe for many partial trust scenarios
// request.Credentials = Credentials;
// thanks TweetSharp!
// request.Credentials = new NetworkCredential(_username, _password);
// only add the Authorization parameter if it hasn't been added by a previous Execute
if (!request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
{
var token = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", _username, _password)));
var authHeader = string.Format("Basic {0}", token);
request.AddParameter("Authorization", authHeader, ParameterType.HttpHeader);
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
request.Credentials = new NetworkCredential(_user, _pass);
// TODO: Figure out how to remove the if.. currently PUT does not work if the DigestAuthFixer is in place
if (request.Method == Method.GET)
{
var url = client.BuildUri(request).ToString();
var uri = new Uri(url);
var digestAuthFixer = new DigestAuthFixer(client.BaseUrl, _user, _pass);
digestAuthFixer.GrabResponse(uri.PathAndQuery);
var digestHeader = digestAuthFixer.GetDigestHeader(uri.PathAndQuery);
request.AddParameter("Authorization", digestHeader, ParameterType.HttpHeader);
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
if (request.Method == Method.PUT)
{
//Do the parameters as URL segments for PUT
request.AddParameter("oauth_consumer_key", _consumerKey, ParameterType.UrlSegment);
request.AddParameter("oauth_nonce", GenerateNonce(), ParameterType.UrlSegment);
if (!string.IsNullOrEmpty(_token))
{
request.AddParameter("oauth_token", _token, ParameterType.UrlSegment);
}
request.AddParameter("oauth_timestamp", GenerateTimeStamp(), ParameterType.UrlSegment);
request.AddParameter("oauth_signature_method", SignatureMethod, ParameterType.UrlSegment);
request.AddParameter("oauth_version", "1.0", ParameterType.UrlSegment);
request.Parameters.Sort(new QueryParameterComparer());
request.AddParameter("oauth_signature", GenerateSignature(request), ParameterType.UrlSegment);
}
else
{
request.AddParameter("oauth_version", "1.0");
request.AddParameter("oauth_nonce", GenerateNonce());
request.AddParameter("oauth_timestamp", GenerateTimeStamp());
request.AddParameter("oauth_signature_method", SignatureMethod);
request.AddParameter("oauth_consumer_key", _consumerKey);
if (!string.IsNullOrEmpty(_token))
{
request.AddParameter("oauth_token", _token);
}
request.Parameters.Sort(new QueryParameterComparer());
request.AddParameter("oauth_signature", GenerateSignature(request));
}
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
public void Authenticate(IRestClient client, IRestRequest request)
{
request.AddParameter(_usernameKey, _username);
request.AddParameter(_passwordKey, _password);
}
/// <summary>
/// Automatically create parameters from object properties
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="obj">Object to serialize to the request body</param>
/// <param name="objProperties">The object properties</param>
/// <param name="filterMode">Include or exclude the properties?</param>
/// <returns>The request object to allow call chains</returns>
public static IRestRequest AddObject(this IRestRequest request, object obj, IEnumerable <string> objProperties, PropertyFilterMode filterMode)
{
var type = obj.GetType();
var objectProperties = objProperties == null ? null : new HashSet <string>(objProperties);
var addedProperties = new HashSet <string>();
while (type != typeof(object))
{
#if NO_TYPEINFO
var typeInfo = type;
var props = typeInfo.GetProperties();
#else
var typeInfo = type.GetTypeInfo();
var props = typeInfo.DeclaredProperties;
#endif
foreach (var prop in props.Where(x => !addedProperties.Contains(x.Name)))
{
bool isAllowed;
if (objectProperties == null)
{
isAllowed = true;
}
else
{
if (filterMode == PropertyFilterMode.Include)
{
isAllowed = objectProperties.Contains(prop.Name);
}
else
{
isAllowed = !objectProperties.Contains(prop.Name);
}
}
if (!isAllowed)
{
continue;
}
addedProperties.Add(prop.Name);
var propType = prop.PropertyType;
var val = prop.GetValue(obj, null);
if (val != null)
{
if (propType.IsArray)
{
var elementType = propType.GetElementType();
#if NO_TYPEINFO
var elementTypeInfo = elementType;
#else
var elementTypeInfo = elementType.GetTypeInfo();
#endif
if (((Array)val).Length > 0 &&
(elementTypeInfo.IsPrimitive || elementTypeInfo.IsValueType || elementType == typeof(string)))
{
// convert the array to an array of strings
var values = (from object item in (Array)val select item.ToString()).ToArray();
val = string.Join(",", values);
}
else
{
// try to cast it
val = string.Join(",", (string[])val);
}
}
request.AddParameter(prop.Name, val);
}
}
type = typeInfo.BaseType;
}
return(request);
}
public static IRestRequest AddParameterIfNotNull <T>(this IRestRequest request, string paramName, T?value)
where T : struct
{
return(value == null ? request : request.AddParameter(paramName, value.Value));
}
/// <summary>
/// Add a file parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="bytes">File content</param>
/// <param name="fileName">File name</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddFile(this IRestRequest request, string name, byte[] bytes, string fileName)
{
return(request.AddParameter(FileParameter.Create(name, bytes, fileName)));
}
public static IRestRequest AddFile(this IRestRequest request, FileParameter parameter)
{
return(request.AddParameter(parameter));
}
private void ConfigureHttp(IRestRequest request, IHttp http)
{
http.Encoding = this.Encoding;
http.AlwaysMultipartFormData = request.AlwaysMultipartFormData;
#if !PocketPC
http.UseDefaultCredentials = request.UseDefaultCredentials;
#endif
http.ResponseWriter = request.ResponseWriter;
#if !PocketPC
http.CookieContainer = CookieContainer;
#endif
// move RestClient.DefaultParameters into Request.Parameters
foreach (var p in DefaultParameters)
{
if (request.Parameters.Any(p2 => p2.Name == p.Name && p2.Type == p.Type))
{
continue;
}
request.AddParameter(p);
}
// Add Accept header based on registered deserializers if none has been set by the caller.
#if PocketPC
if (request.Parameters.All(p2 => p2.Name.ToLower() != "accept"))
#else
if (request.Parameters.All(p2 => p2.Name.ToLowerInvariant() != "accept"))
#endif
{
var accepts = string.Join(", ", AcceptTypes.ToArray());
request.AddParameter("Accept", accepts, ParameterType.HttpHeader);
}
http.Url = BuildUri(request);
http.PreAuthenticate = this.PreAuthenticate;
var userAgent = UserAgent ?? http.UserAgent;
http.UserAgent = userAgent.HasValue() ? userAgent : "RestSharp/" + version;
var timeout = request.Timeout > 0 ? request.Timeout : Timeout;
if (timeout > 0)
{
http.Timeout = timeout;
}
var readWriteTimeout = request.ReadWriteTimeout > 0 ? request.ReadWriteTimeout : ReadWriteTimeout;
if (readWriteTimeout > 0)
{
http.ReadWriteTimeout = readWriteTimeout;
}
#if !SILVERLIGHT
http.FollowRedirects = FollowRedirects;
#endif
#if FRAMEWORK
if (ClientCertificates != null)
{
http.ClientCertificates = this.ClientCertificates;
}
http.MaxRedirects = MaxRedirects;
#endif
if (request.Credentials != null)
{
http.Credentials = request.Credentials;
}
var headers = from p in request.Parameters
where p.Type == ParameterType.HttpHeader
select new HttpHeader
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (var header in headers)
{
http.Headers.Add(header);
}
var cookies = from p in request.Parameters
where p.Type == ParameterType.Cookie
select new HttpCookie
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (var cookie in cookies)
{
http.Cookies.Add(cookie);
}
var @params = from p in request.Parameters
where p.Type == ParameterType.GetOrPost &&
p.Value != null
select new HttpParameter
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (var parameter in @params)
{
http.Parameters.Add(parameter);
}
foreach (var file in request.Files)
{
http.Files.Add(new HttpFile
{
Name = file.Name,
ContentType = file.ContentType,
Writer = file.Writer,
FileName = file.FileName,
ContentLength = file.ContentLength
});
}
var body = (from p in request.Parameters
where p.Type == ParameterType.RequestBody
select p).FirstOrDefault();
// Only add the body if there aren't any files to make it a multipart form request
// If there are files, then add the body to the HTTP Parameters
if (body != null)
{
http.RequestContentType = body.Name;
if (!http.Files.Any())
{
object val = body.Value;
if (val is byte[])
{
http.RequestBodyBytes = (byte[])val;
}
else
{
http.RequestBody = Convert.ToString(body.Value);
}
}
else
{
http.Parameters.Add(new HttpParameter
{
Name = body.Name,
Value = Convert.ToString(body.Value)
});
}
}
#if FRAMEWORK
this.ConfigureProxy(http);
#endif
}
public override void AddFilter(IRestRequest request)
{
base.AddFilter(request);
if (this.MinimumId != null)
{
request.AddParameter("min_id", this.MinimumId, ParameterType.GetOrPost);
}
if (this.MaximumId != null)
{
request.AddParameter("max_id", this.MaximumId, ParameterType.GetOrPost);
}
if (this.FirstName != null)
{
request.AddParameter("first_name", this.FirstName, ParameterType.GetOrPost);
}
if (this.LastName != null)
{
request.AddParameter("last_name", this.LastName, ParameterType.GetOrPost);
}
if (this.Company != null)
{
request.AddParameter("company", this.Company, ParameterType.GetOrPost);
}
if (this.Email != null)
{
request.AddParameter("email", this.Email, ParameterType.GetOrPost);
}
if (this.Phone != null)
{
request.AddParameter("phone", this.Phone, ParameterType.GetOrPost);
}
if (this.StoreCredit != null)
{
request.AddParameter("store_credit", this.StoreCredit, ParameterType.GetOrPost);
}
if (this.CustomerGroupId != null)
{
request.AddParameter("customer_group_id", this.CustomerGroupId, ParameterType.GetOrPost);
}
if (this.MinDateCreated != null)
{
request.AddParameter("min_date_created", String.Format(RFC2822_DATE_FORMAT, this.MinDateCreated), ParameterType.GetOrPost);
}
if (this.MaxDateCreated != null)
{
request.AddParameter("max_date_created", String.Format(RFC2822_DATE_FORMAT, this.MaxDateCreated), ParameterType.GetOrPost);
}
}
// web client adds this random value to each and every request
private IRestRequest AddRandom(IRestRequest request)
{
return(request.AddParameter(RandomParam, _random.Value.NextDouble(), ParameterType.QueryString));
}
private IRestRequest AddLocation(IRestRequest request, string location)
{
return(request.AddParameter(LocationParam, location, ParameterType.QueryString));
}
/// <summary>
/// 调用所有OpenAPI时，除了各接口私有的参数外，所有OpenAPI都需要传入基于OAuth2.0协议的通用参数
/// 将这些通用参数加入RestRequest
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
public override void Authenticate(IRestClient client, IRestRequest request)
{
request.AddParameter("access_token", AccessToken, ParameterType.GetOrPost);
request.AddParameter("openid", openId, ParameterType.GetOrPost);
request.AddParameter("oauth_consumer_key", consumerKey, ParameterType.GetOrPost);
}
private void ConfigureHttp(IRestRequest request, IHttp http)
{
http.Encoding = this.Encoding;
http.AlwaysMultipartFormData = request.AlwaysMultipartFormData;
http.UseDefaultCredentials = request.UseDefaultCredentials;
http.ResponseWriter = request.ResponseWriter;
http.CookieContainer = this.CookieContainer;
// move RestClient.DefaultParameters into Request.Parameters
foreach (Parameter p in this.DefaultParameters)
{
if (request.Parameters.Any(p2 => p2.Name == p.Name && p2.Type == p.Type))
{
continue;
}
request.AddParameter(p);
}
// Add Accept header based on registered deserializers if none has been set by the caller.
if (request.Parameters.All(p2 => p2.Name.ToLowerInvariant() != "accept"))
{
string accepts = string.Join(", ", this.AcceptTypes.ToArray());
request.AddParameter("Accept", accepts, ParameterType.HttpHeader);
}
http.Url = this.BuildUri(request);
http.PreAuthenticate = this.PreAuthenticate;
string userAgent = this.UserAgent ?? http.UserAgent;
http.UserAgent = userAgent.HasValue()
? userAgent
: "RestSharp/" + version;
int timeout = request.Timeout > 0
? request.Timeout
: this.Timeout;
if (timeout > 0)
{
http.Timeout = timeout;
}
int readWriteTimeout = request.ReadWriteTimeout > 0
? request.ReadWriteTimeout
: this.ReadWriteTimeout;
if (readWriteTimeout > 0)
{
http.ReadWriteTimeout = readWriteTimeout;
}
#if !SILVERLIGHT
http.FollowRedirects = this.FollowRedirects;
#endif
#if UNITY_5_0_OR_NEWER || UNITY_2017_1_OR_NEWER
if (this.ClientCertificates != null)
{
http.ClientCertificates = this.ClientCertificates;
}
http.MaxRedirects = this.MaxRedirects;
http.CachePolicy = this.CachePolicy;
#endif
if (request.Credentials != null)
{
http.Credentials = request.Credentials;
}
IEnumerable <HttpHeader> headers = from p in request.Parameters
where p.Type == ParameterType.HttpHeader
select new HttpHeader
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (HttpHeader header in headers)
{
http.Headers.Add(header);
}
IEnumerable <HttpCookie> cookies = from p in request.Parameters
where p.Type == ParameterType.Cookie
select new HttpCookie
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (HttpCookie cookie in cookies)
{
http.Cookies.Add(cookie);
}
IEnumerable <HttpParameter> @params = from p in request.Parameters
where p.Type == ParameterType.GetOrPost && p.Value != null
select new HttpParameter
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (HttpParameter parameter in @params)
{
http.Parameters.Add(parameter);
}
foreach (FileParameter file in request.Files)
{
http.Files.Add(new HttpFile
{
Name = file.Name,
ContentType = file.ContentType,
Writer = file.Writer,
FileName = file.FileName,
ContentLength = file.ContentLength
});
}
Parameter body = request.Parameters.FirstOrDefault(p => p.Type == ParameterType.RequestBody);
// Only add the body if there aren't any files to make it a multipart form request
// If there are files, then add the body to the HTTP Parameters
if (body != null)
{
http.RequestContentType = body.Name;
if (!http.Files.Any())
{
object val = body.Value;
if (val is byte[])
{
http.RequestBodyBytes = (byte[])val;
}
else
{
http.RequestBody = Convert.ToString(body.Value);
}
}
else
{
http.Parameters.Add(new HttpParameter
{
Name = body.Name,
Value = Convert.ToString(body.Value),
ContentType = body.ContentType
});
}
}
#if UNITY_5_0_OR_NEWER || UNITY_2017_1_OR_NEWER
this.ConfigureProxy(http);
#endif
}
public void Authenticate(IRestClient client, IRestRequest request)
{
request.AddParameter("Authorization", _authHeader, ParameterType.HttpHeader);
}
private void ConfigureHttp(IRestRequest request, IHttp http)
{
http.CookieContainer = CookieContainer;
http.ResponseWriter = request.ResponseWriter;
// move RestClient.DefaultParameters into Request.Parameters
foreach (var p in DefaultParameters)
{
if (request.Parameters.Any(p2 => p2.Name == p.Name && p2.Type == p.Type))
{
continue;
}
request.AddParameter(p);
}
// Add Accept header based on registered deserializers if none has been set by the caller.
if (!request.Parameters.Any(p2 => p2.Name.ToLowerInvariant() == "accept"))
{
var accepts = string.Join(", ", AcceptTypes.ToArray());
request.AddParameter("Accept", accepts, ParameterType.HttpHeader);
}
http.Url = BuildUri(request);
var userAgent = UserAgent ?? http.UserAgent;
http.UserAgent = userAgent.HasValue() ? userAgent : "RestSharp " + version.ToString();
var timeout = request.Timeout > 0 ? request.Timeout : Timeout;
if (timeout > 0)
{
http.Timeout = timeout;
}
#if !SILVERLIGHT
http.FollowRedirects = FollowRedirects;
#endif
#if FRAMEWORK
if (ClientCertificates != null)
{
http.ClientCertificates = ClientCertificates;
}
http.MaxRedirects = MaxRedirects;
#endif
if (request.Credentials != null)
{
http.Credentials = request.Credentials;
}
var headers = from p in request.Parameters
where p.Type == ParameterType.HttpHeader
select new HttpHeader
{
Name = p.Name,
Value = p.Value.ToString()
};
foreach (var header in headers)
{
http.Headers.Add(header);
}
var cookies = from p in request.Parameters
where p.Type == ParameterType.Cookie
select new HttpCookie
{
Name = p.Name,
Value = p.Value.ToString()
};
foreach (var cookie in cookies)
{
http.Cookies.Add(cookie);
}
var @params = from p in request.Parameters
where p.Type == ParameterType.GetOrPost &&
p.Value != null
select new HttpParameter
{
Name = p.Name,
Value = p.Value.ToString()
};
foreach (var parameter in @params)
{
http.Parameters.Add(parameter);
}
foreach (var file in request.Files)
{
http.Files.Add(new HttpFile {
Name = file.Name, ContentType = file.ContentType, Writer = file.Writer, FileName = file.FileName, ContentLength = file.ContentLength
});
}
var body = (from p in request.Parameters
where p.Type == ParameterType.RequestBody
select p).FirstOrDefault();
if (body != null)
{
object val = body.Value;
if (val is byte[])
{
http.RequestBodyBytes = (byte[])val;
}
else
{
http.RequestBody = body.Value.ToString();
}
http.RequestContentType = body.Name;
}
#if FRAMEWORK
ConfigureProxy(http);
#endif
}
public override void Authenticate(IRestClient client, IRestRequest request)
{
request.AddParameter("oauth_token", AccessToken, ParameterType.GetOrPost);
}
/// <summary> Adds the provided private token to the request as a header. </summary>
/// <param name="client"> The <see cref="IRestClient" />. </param>
/// <param name="request"> The <see cref="IRestRequest" /> to add the header to. </param>
public void Authenticate(IRestClient client, IRestRequest request)
{
request.AddParameter("PRIVATE-TOKEN", PrivateToken, ParameterType.HttpHeader);
}
/// <summary>
/// Add a file parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="input">File content</param>
/// <param name="fileName">File name</param>
/// <param name="contentType">Content type for the parameter (only applicable to a Body parameter)</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddFile(this IRestRequest request, string name, Stream input, string fileName, string contentType)
{
return(request.AddParameter(FileParameter.Create(name, input, fileName, contentType)));
}
/// <summary>
/// Add a parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddParameter(this IRestRequest request, string name, object value)
{
return(request.AddParameter(new Parameter {
Name = name, Value = value, Type = ParameterType.GetOrPost
}));
}
/// <summary>
/// Add a parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <param name="type">Type of the parameter</param>
/// <param name="contentType">Content type for the parameter (only applicable to a Body parameter)</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddParameter(this IRestRequest request, string name, object value, ParameterType type, string contentType)
{
return(request.AddParameter(new Parameter {
Name = name, Value = value, Type = type, ContentType = contentType
}));
}
private void ConfigureHttp(IRestRequest request, IHttp http)
{
#if !WindowsCE
http.CookieContainer = CookieContainer;
#endif
// move RestClient.DefaultParameters into Request.Parameters
foreach (var p in DefaultParameters)
{
if (request.Parameters.Any(p2 => p2.Name == p.Name && p2.Type == p.Type))
{
continue;
}
request.AddParameter(p);
}
http.Url = BuildUri(request);
var userAgent = UserAgent ?? http.UserAgent;
http.UserAgent = userAgent.HasValue() ? userAgent : "RestSharp " + version.ToString();
var timeout = request.Timeout > 0 ? request.Timeout : Timeout;
if (timeout > 0)
{
http.Timeout = timeout;
}
#if !SILVERLIGHT
http.FollowRedirects = FollowRedirects;
#endif
#if FRAMEWORK
if (ClientCertificates != null)
{
http.ClientCertificates = ClientCertificates;
}
http.MaxRedirects = MaxRedirects;
#endif
if (request.Credentials != null)
{
http.Credentials = request.Credentials;
}
var headers = from p in request.Parameters
where p.Type == ParameterType.HttpHeader
select new HttpHeader
{
Name = p.Name,
Value = p.Value.ToString()
};
foreach (var header in headers)
{
http.Headers.Add(header);
}
var cookies = from p in request.Parameters
where p.Type == ParameterType.Cookie
select new HttpCookie
{
Name = p.Name,
Value = p.Value.ToString()
};
foreach (var cookie in cookies)
{
http.Cookies.Add(cookie);
}
var @params = from p in request.Parameters
where p.Type == ParameterType.GetOrPost &&
p.Value != null
select new HttpParameter
{
Name = p.Name,
Value = p.Value.ToString()
};
foreach (var parameter in @params)
{
http.Parameters.Add(parameter);
}
foreach (var file in request.Files)
{
http.Files.Add(new HttpFile {
Name = file.Name, ContentType = file.ContentType, Writer = file.Writer, FileName = file.FileName, ContentLength = file.ContentLength
});
}
var body = (from p in request.Parameters
where p.Type == ParameterType.RequestBody
select p).FirstOrDefault();
if (body != null)
{
http.RequestBody = body.Value.ToString();
http.RequestContentType = body.Name;
}
}
public HttpRequestWrapper AddParameter(string name, object value)
{
_request.AddParameter(name, value);
return(this);
}
private IRestRequest ApplySecret(IRestRequest request, Uri url)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var urlStr = url.ToString();
if (_authV2 && urlStr.ContainsIgnoreCase("/v2/"))
{
var apiKey = "BITSTAMP " + _key.UnSecure();
var version = "v2";
var nonce = Guid.NewGuid().ToString();
var timeStamp = ((long)TimeHelper.UnixNowMls).To <string>();
var payload = request
.Parameters
.Where(p => p.Type == ParameterType.GetOrPost && p.Value != null)
.OrderBy(p => p.Name)
.Select(p => $"{p.Name}={p.Value}")
.Join("&");
var str = apiKey +
request.Method +
url.Host +
url.PathAndQuery.Remove(url.Query, true) +
url.Query +
"application/json" +
nonce +
timeStamp +
version +
payload;
var signature = _hasher
.ComputeHash(str.UTF8())
.Digest()
.ToUpperInvariant();
request
.AddHeader("X-Auth", apiKey)
.AddHeader("X-Auth-Signature", signature)
.AddHeader("X-Auth-Nonce", nonce)
.AddHeader("X-Auth-Timestamp", timeStamp)
.AddHeader("X-Auth-Version", version);
}
else
{
var nonce = _nonceGen.GetNextId();
var signature = _hasher
.ComputeHash((nonce + _clientId + _key.UnSecure()).UTF8())
.Digest()
.ToUpperInvariant();
request
.AddParameter("key", _key.UnSecure())
.AddParameter("nonce", nonce)
.AddParameter("signature", signature);
}
return(request);
}
private void AddOAuthData(IRestClient client, IRestRequest request, OAuthWorkflow workflow)
{
var url = client.BuildUri(request).ToString();
var queryStringStart = url.IndexOf('?');
if (queryStringStart != -1)
{
url = url.Substring(0, queryStringStart);
}
OAuthWebQueryInfo oauth;
#if PocketPC
var method = request.Method.ToString().ToUpper();
#else
var method = request.Method.ToString().ToUpperInvariant();
#endif
var parameters = new WebParameterCollection();
// include all GET and POST parameters before generating the signature
// according to the RFC 5849 - The OAuth 1.0 Protocol
// http://tools.ietf.org/html/rfc5849#section-3.4.1
// if this change causes trouble we need to introduce a flag indicating the specific OAuth implementation level,
// or implement a seperate class for each OAuth version
if (!request.AlwaysMultipartFormData && !request.Files.Any())
{
foreach (var p in client.DefaultParameters.Where(p => p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString))
{
parameters.Add(new WebPair(p.Name, p.Value.ToString()));
}
foreach (var p in request.Parameters.Where(p => p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString))
{
parameters.Add(new WebPair(p.Name, p.Value.ToString()));
}
}
else
{
// if we are sending a multipart request, only the "oauth_" parameters should be included in the signature
foreach (var p in client.DefaultParameters.Where(
p => (p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString) && p.Name.StartsWith("oauth_")))
{
parameters.Add(new WebPair(p.Name, p.Value.ToString()));
}
foreach (var p in request.Parameters.Where(
p => (p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString) && p.Name.StartsWith("oauth_")))
{
parameters.Add(new WebPair(p.Name, p.Value.ToString()));
}
}
switch (Type)
{
case OAuthType.RequestToken:
workflow.RequestTokenUrl = url;
oauth = workflow.BuildRequestTokenInfo(method, parameters);
break;
case OAuthType.AccessToken:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildAccessTokenInfo(method, parameters);
break;
case OAuthType.ClientAuthentication:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildClientAuthAccessTokenInfo(method, parameters);
break;
case OAuthType.ProtectedResource:
oauth = workflow.BuildProtectedResourceInfo(method, parameters, url);
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (ParameterHandling)
{
case OAuthParameterHandling.HttpAuthorizationHeader:
parameters.Add("oauth_signature", oauth.Signature);
request.AddHeader("Authorization", GetAuthorizationHeader(parameters));
break;
case OAuthParameterHandling.UrlOrPostParameters:
parameters.Add("oauth_signature", oauth.Signature);
foreach (var parameter in parameters.Where(parameter =>
!parameter.Name.IsNullOrBlank() &&
(parameter.Name.StartsWith("oauth_") || parameter.Name.StartsWith("x_auth_"))))
{
request.AddParameter(parameter.Name, HttpUtility.UrlDecode(parameter.Value));
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
internal IHttp ConfigureHttp(IRestRequest request)
{
var http = Http.Create();
http.Encoding = Encoding;
http.AlwaysMultipartFormData = request.AlwaysMultipartFormData;
http.UseDefaultCredentials = request.UseDefaultCredentials;
http.ResponseWriter = request.ResponseWriter;
http.AdvancedResponseWriter = request.AdvancedResponseWriter;
http.CookieContainer = CookieContainer;
http.AutomaticDecompression = AutomaticDecompression;
http.WebRequestConfigurator = WebRequestConfigurator;
// move RestClient.DefaultParameters into Request.Parameters
foreach (var p in DefaultParameters)
{
var parameterExists = request.Parameters.Any(p2 => p2.Name == p.Name && p2.Type == p.Type);
if (AllowMultipleDefaultParametersWithSameName)
{
var isMultiParameter = MultiParameterTypes.Any(pt => pt == p.Type);
parameterExists = !isMultiParameter && parameterExists;
}
if (parameterExists)
{
continue;
}
request.AddParameter(p);
}
// Add Accept header based on registered deserializers if none has been set by the caller.
if (request.Parameters.All(p2 => p2.Name.ToLowerInvariant() != "accept"))
{
var accepts = string.Join(", ", AcceptTypes.ToArray());
request.AddParameter("Accept", accepts, ParameterType.HttpHeader);
}
http.Url = BuildUri(request);
http.Host = BaseHost;
http.PreAuthenticate = PreAuthenticate;
http.UnsafeAuthenticatedConnectionSharing = UnsafeAuthenticatedConnectionSharing;
var userAgent = UserAgent ?? http.UserAgent;
http.UserAgent = userAgent.HasValue()
? userAgent
: "RestSharp/" + version;
var timeout = request.Timeout != 0
? request.Timeout
: Timeout;
if (timeout != 0)
{
http.Timeout = timeout;
}
var readWriteTimeout = request.ReadWriteTimeout != 0
? request.ReadWriteTimeout
: ReadWriteTimeout;
if (readWriteTimeout != 0)
{
http.ReadWriteTimeout = readWriteTimeout;
}
http.FollowRedirects = FollowRedirects;
if (ClientCertificates != null)
{
http.ClientCertificates = ClientCertificates;
}
http.MaxRedirects = MaxRedirects;
http.CachePolicy = CachePolicy;
http.Pipelined = Pipelined;
if (request.Credentials != null)
{
http.Credentials = request.Credentials;
}
if (!string.IsNullOrEmpty(ConnectionGroupName))
{
http.ConnectionGroupName = ConnectionGroupName;
}
var headers = from p in request.Parameters
where p.Type == ParameterType.HttpHeader
select new HttpHeader
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (var header in headers)
{
http.Headers.Add(header);
}
var cookies = from p in request.Parameters
where p.Type == ParameterType.Cookie
select new HttpCookie
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (var cookie in cookies)
{
http.Cookies.Add(cookie);
}
var @params = from p in request.Parameters
where p.Type == ParameterType.GetOrPost && p.Value != null
select new HttpParameter
{
Name = p.Name,
Value = Convert.ToString(p.Value)
};
foreach (var parameter in @params)
{
http.Parameters.Add(parameter);
}
foreach (var file in request.Files)
{
http.Files.Add(new HttpFile
{
Name = file.Name,
ContentType = file.ContentType,
Writer = file.Writer,
FileName = file.FileName,
ContentLength = file.ContentLength
});
}
var body = request.Parameters.FirstOrDefault(p => p.Type == ParameterType.RequestBody);
// Only add the body if there aren't any files to make it a multipart form request
// If there are files or AlwaysMultipartFormData = true, then add the body to the HTTP Parameters
if (body != null)
{
http.RequestContentType = body.Name;
if (!http.AlwaysMultipartFormData && !http.Files.Any())
{
var val = body.Value;
if (val is byte[] bytes)
{
http.RequestBodyBytes = bytes;
}
else
{
http.RequestBody = Convert.ToString(body.Value);
}
}
else
{
http.Parameters.Add(new HttpParameter
{
Name = body.Name,
Value = Convert.ToString(body.Value),
ContentType = body.ContentType
});
}
}
http.AllowedDecompressionMethods = request.AllowedDecompressionMethods;
http.Proxy = Proxy ?? (WebRequest.DefaultWebProxy ?? HttpWebRequest.GetSystemWebProxy());
http.RemoteCertificateValidationCallback = RemoteCertificateValidationCallback;
return(http);
}
private void AddOAuthData(IRestClient client, IRestRequest request, OAuthWorkflow workflow)
{
var url = client.BuildUri(request).ToString();
OAuthWebQueryInfo oauth;
var method = request.Method.ToString().ToUpperInvariant();
var parameters = new WebParameterCollection();
// for non-GET style requests make sure params are part of oauth signature
if (request.Method != Method.GET && request.Method != Method.DELETE)
{
foreach (var p in request.Parameters.Where(p => p.Type == ParameterType.GetOrPost))
{
parameters.Add(new WebPair(p.Name, p.Value.ToString()));
}
}
switch (Type)
{
case OAuthType.RequestToken:
workflow.RequestTokenUrl = url;
oauth = workflow.BuildRequestTokenInfo(method, parameters);
break;
case OAuthType.AccessToken:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildAccessTokenInfo(method, parameters);
break;
case OAuthType.ClientAuthentication:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildClientAuthAccessTokenInfo(method, parameters);
break;
case OAuthType.ProtectedResource:
oauth = workflow.BuildProtectedResourceInfo(method, parameters, url);
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (ParameterHandling)
{
case OAuthParameterHandling.HttpAuthorizationHeader:
parameters.Add("oauth_signature", oauth.Signature);
request.AddHeader("Authorization", GetAuthorizationHeader(parameters));
break;
case OAuthParameterHandling.UrlOrPostParameters:
parameters.Add("oauth_signature", HttpUtility.UrlDecode(oauth.Signature));
foreach (var parameter in parameters)
{
request.AddParameter(parameter.Name, parameter.Value);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void PostTweet(string message)
{
Request = new RestRequest("/update.json", Method.POST);
Request.AddParameter("status", message, ParameterType.GetOrPost);
GetResponse();
}
/// <summary>
/// 添加Ucloud对象.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="obj">The object.</param>
/// <param name="includedProperties">The included properties.</param>
/// <returns>IRestRequest对象</returns>
public static IRestRequest AddUObject(this IRestRequest request, object obj, params string[] includedProperties)
{
// automatically create parameters from object props
var type = obj.GetType();
var props = type.GetProperties();
foreach (var prop in props)
{
bool isAllowed = includedProperties.Length == 0 ||
(includedProperties.Length > 0 && includedProperties.Contains(prop.Name));
if (!isAllowed)
{
continue;
}
var propType = prop.PropertyType;
var val = prop.GetValue(obj, null);
if (val == null)
{
continue;
}
if (propType.IsArray)
{
var elementType = propType.GetElementType();
if (((Array)val).Length > 0 &&
elementType != null &&
(elementType.IsPrimitive || elementType.IsValueType || elementType == typeof(string)))
{
// convert the array to an array of strings
var values = (from object item in ((Array)val)
select item.ToString())
.ToArray <string>();
val = string.Join(",", values);
}
else
{
// try to cast it
val = string.Join(",", (string[])val);
}
}
if (propType.IsNlist())
{
if (((NList)val).Count > 0)
{
// convert the array to an array of strings
var values = (from object item in ((NList)val)
select item.ToString())
.ToList();
for (int i = 0; i < values.Count; i++)
{
request.AddParameter(prop.Name + '.' + i, values[i]);
}
}
continue;
}
var propName = prop.Name;
if (propName.Contains("__"))
{
propName = propName.Replace("__", "-");
}
request.AddParameter(propName, val);
}
return(request);
}
/// <summary>
/// Called just before issuing request to third-party service when everything is ready.
/// Allows to add extra parameters to request or do any other needed preparations.
/// </summary>
protected override void BeforeGetUserInfo(IRestRequest request)
{
request.AddParameter("uids", _userId);
request.AddParameter("fields", "uid,first_name,last_name,photo");
}
public static void AddQueryString(this IRestRequest request, string name, object value)
{
request.AddParameter(name, value.ToString(), ParameterType.GetOrPost);
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
/// <param name="credentials">The credentials used for the authentication</param>
/// <returns>The task the authentication is performed on</returns>
public override async Task PreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
{
request.AddParameter("oauth_token", await Client.GetCurrentToken(), ParameterType.GetOrPost);
}