public static RestClient CreateMockRestClient(string baseUrl, MockHttpMessageHandler messageHandler)
{
var restClientOptions = new RestClientOptions(baseUrl);
var restClient = new RestClient(messageHandler.ToHttpClient(), restClientOptions);
return(restClient);
}
/// <summary>
/// Constructor
/// </summary>
public KeycloakOpenId()
{
if (string.IsNullOrEmpty(KeycloakConfiguration.BaseUrl))
{
throw new KeycloakOpenIdException($"Not specify URL address for authentication user by \"{KeycloakConfiguration.Protocol}\"");
}
if (KeycloakConfiguration.Protocol == "openid-connect")
{
var options = new RestClientOptions(KeycloakConfiguration.BaseUrl)
{
Encoding = Encoding.UTF8,
CachePolicy = new CacheControlHeaderValue()
{
NoCache = true,
NoStore = true
},
Timeout = KeycloakConfiguration.ConnectionTimeout
};
_basicRestClient = new RestClient(options);
}
else
{
throw new NotImplementedException("Other client protocol than 'open-id' connect is not implemented. Please switch the client to 'openid-connect'.");
}
}
async Task AssertBody(Method method, bool disableCharset = false)
{
var options = new RestClientOptions(_server.Url)
{
DisableCharset = disableCharset
};
var client = new RestClient(options);
var request = new RestRequest(RequestBodyCapturer.Resource, method)
{
OnBeforeRequest = async m => {
_output.WriteLine(m.ToString());
_output.WriteLine(await m.Content !.ReadAsStringAsync());
}
};
const string bodyData = "abc123 foo bar baz BING!";
request.AddParameter(TextPlainContentType, bodyData, ParameterType.RequestBody);
await client.ExecuteAsync(request);
var expected = disableCharset ? ExpectedTextContentTypeNoCharset : ExpectedTextContentType;
AssertHasRequestBody(expected, bodyData);
}
public TwitterClient(string apiKey, string apiKeySecret)
{
var options = new RestClientOptions("https://api.twitter.com/2");
_client = new RestClient(options)
{
Authenticator = new TwitterAuthenticator("https://api.twitter.com", apiKey, apiKeySecret)
};
}
public async Task GetRequestWithContentType()
{
var options = new RestClientOptions("https://endim2jwvq8mr.x.pipedream.net/");
var client = new RestClient(options);
var request = new RestRequest("resource");
request.AddHeader("Content-Type", "application/force-download");
var response = await client.GetAsync(request);
}
/// <summary>
/// Configure the client using the provided options
/// </summary>
/// <param name="exchangeOptions">Options</param>
protected void Configure(RestClientOptions exchangeOptions)
{
RequestTimeout = exchangeOptions.RequestTimeout;
RateLimitBehaviour = exchangeOptions.RateLimitingBehaviour;
var rateLimiters = new List <IRateLimiter>();
foreach (var rateLimiter in exchangeOptions.RateLimiters)
{
rateLimiters.Add(rateLimiter);
}
RateLimiters = rateLimiters;
}
public MultipartFormDataTests(ITestOutputHelper output)
{
_output = output;
_server = SimpleServer.Create(RequestHandler.Handle);
var options = new RestClientOptions(_server.Url)
{
ConfigureMessageHandler = handler => new HttpTracerHandler(handler, new OutputLogger(output), HttpMessageParts.All)
};
_client = new RestClient(options);
}
private async static void GetMessageStatusCall(Guid messageId)
{
// Setup a RESTful client object using the message status URL with our API Space and message id incorporated
var options = new RestClientOptions(string.Format("https://api.comapi.com/apispaces/{0}/messages/{1}", APISPACE, messageId.ToString("D")))
{
ThrowOnAnyError = false,
Timeout = 30000
};
var client = new RestClient(options);
client.AddDefaultHeader("Content-Type", "application/json");
client.AddDefaultHeader("Accept", "application/json");
var request = new RestRequest();
request.AddHeader("Cache-Control", "no-cache");
request.AddHeader("authorization", "Bearer " + TOKEN); // Add the security token
// Make the web service call
var response = await client.ExecuteGetAsync(request);
switch (response.StatusCode)
{
case System.Net.HttpStatusCode.OK:
// Sucess output the response body
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine(FormatJson(response.Content));
Console.ForegroundColor = ConsoleColor.White;
// Inspect the status
dynamic statusObject = JsonConvert.DeserializeObject(response.Content);
// Check to see if the message is delivered
Console.WriteLine(string.Format("The message ({0}) is currently in the {1} status.", messageId.ToString("D"), statusObject.status));
Console.WriteLine(string.Format("It was sent on the {0} channel.", statusObject.statusDetails.channel));
Console.WriteLine(string.Empty);
break;
case System.Net.HttpStatusCode.NotFound:
// Sucess output the response body
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(string.Format("The message ({0}) was not found!", messageId.ToString("D")));
Console.ForegroundColor = ConsoleColor.White;
break;
default:
// Something went wrong.
throw new InvalidOperationException(string.Format("Call to Dotdigital Enterprise Communications API failed with status code ({0}), and body: {1}", response.StatusCode, response.Content));
}
}
async Task <string> GetToken()
{
var options = new RestClientOptions(_baseUrl);
using var client = new RestClient(options)
{
Authenticator = new HttpBasicAuthenticator(_clientId, _clientSecret),
};
var request = new RestRequest("oauth2/token")
.AddParameter("grant_type", "client_credentials");
var response = await client.PostAsync <TokenResponse>(request);
return($"{response!.TokenType} {response!.AccessToken}");
}
public RunMyAccountsClient(string tenant, string apikey)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls | SecurityProtocolType.Ssl3;
ApiKey = apikey;
RestClientOptions option = new RestClientOptions("https://service.runmyaccounts.com/api/latest/clients/");
option.Encoding = Encoding.UTF8;
client = new RestClient(option);
client.UseSerializer(() => new NewtonsoftJsonSerializer());
client.AddDefaultHeader("ContentType", "application/json");
client.AddDefaultParameter("api_key", apikey, ParameterType.QueryString);
client.AddDefaultParameter("tenant", tenant, ParameterType.UrlSegment);
}
/// <summary>
///
/// </summary>
/// <param name="baseurl"></param>
/// <returns></returns>
public RestClient CreateJsonBytesClient(string baseurl)
{
var _options = new RestClientOptions
{
BaseUrl = new System.Uri(baseurl),
Timeout = 10 * 1000,
UserAgent = __user_agent
};
var _client = new RestClient(_options);
//_client.RemoveHandler(__content_type);
//_client.AddHandler(__content_type, () => new RestSharpJsonNetDeserializer());
return(_client);
}
/// <summary>
///
/// </summary>
/// <param name="URLBase">Point at a different server</param>
public APIClient(string URLBase = "https://www.calcbench.com/api")
{
var options = new RestClientOptions(URLBase)
{
ThrowOnAnyError = true,
};
if (URLBase != "https://www.calcbench.com/api")
{
options.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
}
client = new RestClient(options);
client.UseNewtonsoftJson();
}
private async static void SendSMSBatch(SMSSendRequest[] smsRequests)
{
// Setup a REST client object using the message send URL with our API Space incorporated
var options = new RestClientOptions(string.Format("https://api.comapi.com/apispaces/{0}/messages/batch", CUSTOMER_APISPACE))
{
ThrowOnAnyError = false,
Timeout = 30000
};
var client = new RestClient(options);
client.AddDefaultHeader("Content-Type", "application/json");
client.AddDefaultHeader("Accept", "application/json");
var request = new RestRequest();
request.AddHeader("Cache-Control", "no-cache");
request.AddHeader("authorization", "Bearer " +
CreateImpersonationToken(
CUSTOMER_ACCOUNT_ID,
RESELLER_ACCOUNT_ID,
RESELLER_TOKEN_ISSUER,
RESELLER_TOKEN_SECRET)); // Add the security token
// Serialise our SMS request object to JSON for submission
string requestJson = JsonConvert.SerializeObject(smsRequests, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
request.AddParameter("application/json", requestJson, ParameterType.RequestBody);
// Make the web service call
var response = await client.ExecutePostAsync(request);
if (response.StatusCode != System.Net.HttpStatusCode.Accepted)
{
// Something went wrong.
throw new InvalidOperationException(string.Format("Call to Dotdigital Enterprise Communications API failed with status code ({0}), and body: {1}", response.StatusCode, response.Content));
}
else
{
// Sucess output the response body
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(FormatJson(response.Content));
Console.ForegroundColor = ConsoleColor.White;
}
}
public static IServiceCollection AddDiscogsProvider(this IServiceCollection services, IConfiguration configuration)
{
var discogsSettings = configuration.GetSection("DiscogsSettings").Get <DiscogsApiClientConfiguration>();
var discogsSettingsValidator = new DiscogsApiClientConfigurationValidator();
discogsSettingsValidator.ValidateAndThrow(discogsSettings);
services.AddSingleton <IDiscogsApiClientConfiguration>(_ => discogsSettings);
var restClientOptions = new RestClientOptions(discogsSettings.BaseUrl);
var restClient = new RestClient(restClientOptions);
services.AddScoped <IDiscogsApiClient, DiscogsApiClient>(_ => new DiscogsApiClient(discogsSettings, restClient));
services.AddScoped <IDiscogsProvider, DiscogsProvider>();
return(services);
}
public UpdatesService(PlatformService platform, ISettingsStorageService settingsStorage, SettingsService settings)
{
Platform = platform;
SettingsStorage = settingsStorage;
Settings = settings;
#if DEBUG
var uri = new Uri("http://localhost:5000/");
#else
var uri = new Uri("https://api.guerra24.net/");
#endif
var options = new RestClientOptions(uri)
{
UserAgent = "LRReader"
};
client = new RestClient(options);
client.UseNewtonsoftJson();
}
public static IServiceCollection AddComicVineProvider(this IServiceCollection services, IConfiguration configuration)
{
var comicVineSettings = configuration.GetSection("ComicVineSettings").Get <ComicVineApiClientConfiguration>();
var comicVineSettingsValidator = new ComicVineApiClientConfigurationValidator();
comicVineSettingsValidator.ValidateAndThrow(comicVineSettings);
services.AddSingleton <IComicVineApiClientConfiguration>(comicVineSettings);
var restClientOptions = new RestClientOptions(comicVineSettings.BaseUrl);
var restClient = new RestClient(restClientOptions);
services.AddScoped <IComicVineApiClient, ComicVineApiClient>(_ => new ComicVineApiClient(comicVineSettings, restClient));
services.AddScoped <IComicVineProvider, ComicVineProvider>();
return(services);
}
public static IServiceCollection AddBoardGameGeekProvider(this IServiceCollection services, IConfiguration configuration)
{
var boardGameGeekSettings = configuration.GetSection("BoardGameGeekSettings").Get <BoardGameGeekApiClientConfiguration>();
var boardGameGeekSettingsValidator = new BoardGameGeekApiClientConfigurationValidator();
boardGameGeekSettingsValidator.ValidateAndThrow(boardGameGeekSettings);
services.AddSingleton <IBoardGameGeekApiClientConfiguration>(boardGameGeekSettings);
var restClientOptions = new RestClientOptions($"{boardGameGeekSettings.BaseUrl}{boardGameGeekSettings.ApiVersion}");
var restClient = new RestClient(restClientOptions);
services.AddScoped <IBoardGameGeekApiClient, BoardGameGeekApiClient>(_ => new BoardGameGeekApiClient(boardGameGeekSettings, restClient));
services.AddScoped <IBoardGameGeekProvider, BoardGameGeekProvider>();
return(services);
}
public RestClient(RestClientOptions options, Action <HttpRequestHeaders>?configureDefaultHeaders = null)
{
UseDefaultSerializers();
Options = options;
CookieContainer = Options.CookieContainer ?? new CookieContainer();
_disposeHttpClient = true;
var handler = new HttpClientHandler();
ConfigureHttpMessageHandler(handler);
var finalHandler = Options.ConfigureMessageHandler?.Invoke(handler) ?? handler;
HttpClient = new HttpClient(finalHandler);
ConfigureHttpClient(HttpClient);
configureDefaultHeaders?.Invoke(HttpClient.DefaultRequestHeaders);
}
/// <summary>
///
/// </summary>
/// <param name="baseurl"></param>
/// <returns></returns>
public override RestClient CreateJsonClient(string baseurl)
{
var _options = new RestClientOptions
{
BaseUrl = new System.Uri(baseurl),
Timeout = 5 * 1000,
//ReadWriteTimeout = 32 * 1000,
UserAgent = __user_agent,
Encoding = Encoding.GetEncoding(65001)
};
var _client = new RestClient(_options);
//_client.RemoveHandler(__content_type);
//_client.AddHandler(__content_type, () => new RestSharpJsonNetDeserializer());
return(_client);
}
/// <summary>
/// ctor
/// </summary>
/// <param name="exchangeName">The name of the exchange this client is for</param>
/// <param name="exchangeOptions">The options for this client</param>
/// <param name="authenticationProvider">The authentication provider for this client (can be null if no credentials are provided)</param>
protected RestClient(string exchangeName, RestClientOptions exchangeOptions, AuthenticationProvider?authenticationProvider) : base(exchangeName, exchangeOptions, authenticationProvider)
{
if (exchangeOptions == null)
{
throw new ArgumentNullException(nameof(exchangeOptions));
}
RequestTimeout = exchangeOptions.RequestTimeout;
RequestFactory.Configure(exchangeOptions.RequestTimeout, exchangeOptions.Proxy, exchangeOptions.HttpClient);
RateLimitBehaviour = exchangeOptions.RateLimitingBehaviour;
var rateLimiters = new List <IRateLimiter>();
foreach (var rateLimiter in exchangeOptions.RateLimiters)
{
rateLimiters.Add(rateLimiter);
}
RateLimiters = rateLimiters;
}
private void GenerateTokenForInvalidIMSUser()
{
var restClientOptions = new RestClientOptions
{
BaseEndpoint = _testCfg.ERApiEndpoint,
TokenProvider = new ResourceOwnerFlow(
_testCfg.InvalidImsEndpoint,
_testCfg.ImsClientId,
_testCfg.InvalidImsClientSecret,
_testCfg.PrimaryUserName,
_testCfg.PrimaryUserPassword,
_testCfg.ImsScopes),
RetryPolicy = new DefaultRetryPolicy()
};
var erRestClient = new RestClient(restClientOptions);
scenarioContext.Set <IRestClient>(erRestClient, "InvalidIMSUser");
}
public static async Task Run()
{
var options = new RestClientOptions("https://api.muxiaoguo.cn/api/bad_or_luck")
{
ThrowOnAnyError = true,
Timeout = 1000
};
var client = new RestClient(options);
var request = new RestRequest()
.AddQueryParameter("Num", "11111111111");
var response = await client.PostAsync <MyResponse>(request, CancellationToken.None);
Console.WriteLine(response?.Msg);
Console.WriteLine(response?.Data?.Analysis);
Console.WriteLine(response?.Data?.BadORluck);
}
public void GivenAnIMSUserWithAnAccessToken(string userName)
{
var restClientOptions = new RestClientOptions
{
BaseEndpoint = _testCfg.ERApiEndpoint,
TokenProvider = new ResourceOwnerFlow(
_testCfg.ImsEndpoint,
_testCfg.ImsClientId,
_testCfg.ImsClientSecret,
_testCfg.PrimaryUserName,
_testCfg.PrimaryUserPassword,
_testCfg.ImsScopes),
RetryPolicy = new DefaultRetryPolicy()
};
var erRestClient = new RestClient(restClientOptions);
scenarioContext.Set <IRestClient>(erRestClient, "PrimaryIMSUser");
}
public static IServiceCollection AddGiantBombProvider(this IServiceCollection services, IConfiguration configuration)
{
var giantBombSettings = configuration.GetSection("GiantBombSettings").Get <GiantBombApiClientConfiguration>();
var giantBombSettingsValidator = new GiantBombApiClientConfigurationValidator();
giantBombSettingsValidator.ValidateAndThrow(giantBombSettings);
services.AddSingleton <IGiantBombApiClientConfiguration>(giantBombSettings);
var restClientOptions = new RestClientOptions(giantBombSettings.BaseUrl);
var restClient = new RestClient(restClientOptions);
restClient.UseNewtonsoftJson();
services.AddScoped <IGiantBombApiClient, GiantBombApiClient>(_ => new GiantBombApiClient(giantBombSettings, restClient));
services.AddScoped <IGiantBombProvider, GiantBombProvider>();
return(services);
}
public static IServiceCollection AddMovieDatabaseProvider(this IServiceCollection services, IConfiguration configuration)
{
var movieDatabaseSettings = configuration.GetSection("MovieDatabaseSettings").Get <MovieDatabaseApiClientConfiguration>();
var movieDatabaseSettingsValidator = new MovieDatabaseApiClientConfigurationValidator();
movieDatabaseSettingsValidator.ValidateAndThrow(movieDatabaseSettings);
services.AddSingleton <IMovieDatabaseApiClientConfiguration>(movieDatabaseSettings);
var restClientOptions = new RestClientOptions(movieDatabaseSettings.BaseUrl);
var restClient = new RestClient(restClientOptions);
restClient.UseNewtonsoftJson();
services.AddScoped <IMovieDatabaseApiClient, MovieDatabaseApiClient>(_ => new MovieDatabaseApiClient(movieDatabaseSettings, restClient));
services.AddScoped <IMovieDatabaseProvider, MovieDatabaseProvider>();
return(services);
}
public bool RefreshSettings(ServerProfile profile)
{
if (!Uri.IsWellFormedUriString(profile.ServerAddress, UriKind.Absolute))
{
return(false);
}
var options = new RestClientOptions(profile.ServerAddress)
{
UserAgent = "LRReader"
};
Client = new RestClient(options);
Client.UseNewtonsoftJson();
if (!string.IsNullOrEmpty(profile.ServerApiKey))
{
var base64Key = Convert.ToBase64String(Encoding.UTF8.GetBytes(profile.ServerApiKey));
Client.AddDefaultHeader("Authorization", $"Bearer {base64Key}");
}
return(true);
}
public ImgurClient(string clientId)
{
var options = new RestClientOptions(ImgurApiUrl)
{
ThrowOnAnyError = true,
FollowRedirects = true,
PreAuthenticate = true,
MaxTimeout = 20 * 1000,
//Proxy = new WebProxy("http://localhost:8080"),
ConfigureMessageHandler = orig =>
{
_rateLimitHandler = new RateLimitHandler(orig);
return(_rateLimitHandler);
}
};
_client = new RestClient(options);
_client.UseAuthenticator(new ImgurAuthenticator(clientId));
_client.UseNewtonsoftJson();
}
public RestClient(HttpClient httpClient, RestClientOptions?options = null, bool disposeHttpClient = false)
{
if (options?.CookieContainer != null)
{
throw new ArgumentException("Custom cookie container cannot be added to the HttpClient instance", nameof(options.CookieContainer));
}
UseDefaultSerializers();
HttpClient = httpClient;
Options = options ?? new RestClientOptions();
CookieContainer = new CookieContainer();
_disposeHttpClient = disposeHttpClient;
if (httpClient.BaseAddress != null && Options.BaseUrl == null)
{
Options.BaseUrl = httpClient.BaseAddress;
}
ConfigureHttpClient(HttpClient);
}
public NStackRepository(NStackConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(configuration.ApiKey))
{
throw new ArgumentNullException(configuration.ApiKey);
}
if (string.IsNullOrWhiteSpace(configuration.ApplicationId))
{
throw new ArgumentNullException(configuration.ApplicationId);
}
if (string.IsNullOrWhiteSpace(configuration.BaseUrl))
{
throw new ArgumentNullException(configuration.BaseUrl);
}
var options = new RestClientOptions(configuration.BaseUrl);
Client = new RestClient(options);
Client.UseSystemTextJson(new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
Converters =
{
new JsonStringEnumConverter()
}
});
Client.AddDefaultHeaders(new Dictionary <string, string>
{
{ "X-Application-Id", configuration.ApplicationId },
{ "X-Rest-Api-Key", configuration.ApiKey }
});
}
/// <summary>
/// Create OpenStack API client.
/// </summary>
/// <param name="openStackAddress">OpenStack address..</param>
public OpenStack(string openStackAddress)
{
_logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
if (string.IsNullOrEmpty(openStackAddress))
{
throw new OpenStackAPIException("Not specify URL address for OpenStack");
}
var options = new RestClientOptions($"{openStackAddress}:{OpenStackSettings.IdentityPort}/")
{
Encoding = Encoding.UTF8,
CachePolicy = new CacheControlHeaderValue()
{
NoCache = true,
NoStore = true
},
Timeout = OpenStackSettings.ConnectionTimeout
};
_basicRestClient = new RestClient(options);
}
