public static void Main(string[] args)
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("guest", "guest")
};
const string root = "http://localhost:55672/api/";
//settings.Configure<SimpleJsonSerializer>(s =>
// s.ConfigureSettings(c =>
// {
// c.ContractResolver = new RabbitContractResolver();
// }));
var client = HttpClient.Create(root, settings);
client.BeforeRequest += delegate(object sender, BeforeRequestEventArgs eventArgs)
{
eventArgs.Request.AddHeader("Accept", string.Empty);
};
var resource = client.BuildRelativeResource("vhosts", new { });
var vhosts = client.Get("vhosts")
.OnOk()
.As <List <Vhost> >();
Console.WriteLine(vhosts[0].Name);
Console.ReadLine();
}
private HttpMessageInvoker GetClientInernal(HttpClientSettings clientSetting, params DelegatingHandler[] handlers)
{
var defaultHandlers = new DelegatingHandler[]
{
new PixivHeaderValueHandler()
};
handlers = handlers == null ? defaultHandlers : handlers.Concat(defaultHandlers).ToArray();
var httpClient = SimpleHttpClient.HttpClientFactory.Create((handler) =>
{
handler.Settings = new SimpleHttpClient.HttpConnectionSettings()
{
AutomaticDecompression = DecompressionMethods.GZip
};
if (_enableDirectConnect)
{
handler.Settings.EndPointProvider = new PixivEndPointProvider();
}
}, handlers);
if (clientSetting != null)
{
httpClient.Timeout = clientSetting.Timeout;
}
return(httpClient);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton(Configuration);
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddOptions();
services.Configure <VaultSettings>(Configuration.GetSection("Vault"));
services.AddKeyVault(Configuration);
var appInsightsSettings = new AppInsightsSettings();
Configuration.Bind("AppInsights:Context", appInsightsSettings);
var instrumentationKey = services.GetSecret(Configuration, Configuration["AppInsights:InstrumentationKeySecret"]);
services.AddAppInsights(appInsightsSettings, instrumentationKey);
services.AddLogging(instrumentationKey);
services.Configure <DocDbSettings>("SourceDb", Configuration.GetSection("SourceDb"));
services.Configure <DocDbSettings>("ChangeDb", Configuration.GetSection("ChangeDb"));
services.Configure <ChangeTrackSettings>(Configuration.GetSection("ChangeTracking"));
var clientSettings = new HttpClientSettings();
Configuration.Bind("Clients:EventsProducerApi", clientSettings);
services.AddClient <IChangeTracker, ChangeTracker>(clientSettings);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
public static void Main(string[] args)
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("guest", "guest")
};
const string root = "http://localhost:55672/api/";
//settings.Configure<SimpleJsonSerializer>(s =>
// s.ConfigureSettings(c =>
// {
// c.ContractResolver = new RabbitContractResolver();
// }));
var client = HttpClient.Create(root, settings);
client.BeforeRequest += delegate(object sender, BeforeRequestEventArgs eventArgs)
{
eventArgs.Request.AddHeader("Accept", string.Empty);
};
var resource = client.BuildRelativeResource("vhosts", new { });
var vhosts = client.Get("vhosts")
.OnOk()
.As<List<Vhost>>();
Console.WriteLine(vhosts[0].Name);
Console.ReadLine();
}
/// <summary>
/// Registers implementations that are specific for SphyrnidaeTech.com
/// </summary>
/// <param name="services">The service collection</param>
/// <param name="app">Your version of IApplicationSettings</param>
/// <param name="env">Your specific IEnvironmentSettings</param>
public static void RegisterSphyrnidaeServices(this IServiceCollection services, IApplicationSettings app, IEnvironmentSettings env)
{
var config = new ServiceConfiguration();
var http = new HttpClientSettings(null, env);
// Standard overrides
services.TryAddScoped <IIdentityHelper, SphyrnidaeIdentityHelper>();
services.TryAddScoped <ILoggerConfiguration, SphyrnidaeLoggerConfiguration>();
services.TryAddSingleton <ILoggers, SphyrnidaeLoggers>();
services.TryAddTransient <IFeatureToggleSettings, SphyrnidaeFeatureToggleSettings>();
services.TryAddTransient <IVariableSettings, SphyrnidaeVariableSettings>();
services.TryAddTransient <IUserPreferenceSettings, SphyrnidaeUserPreferenceSettings>();
// Email
services.TryAddTransient <IEmail, DotNetEmail>();
services.TryAddTransient <IDotNetEmailSettings, SphyrnidaeDotNetEmailSettings>();
services.TryAddTransient <IEmailDefaultSettings, SphyrnidaeEmailDefaultSettings>();
services.TryAddTransient <IEmailSettings, SphyrnidaeEmailSettings>();
// Repositories
services.TryAddTransient <ILogRepo, LogRepo>();
services.TryAddTransient <IDefaultUserRepo, DefaultUserRepo>();
// Web Services
services.TryAddTransient <IApiAuthenticationWebService, SphyrnidaeApiAuthenticationWebService>();
services.TryAddTransient <IFeatureToggleWebService, FeatureToggleWebService>();
services.TryAddTransient <IUserPreferenceWebService, UserPreferenceWebService>();
services.TryAddTransient <IVariableWebService, VariableWebService>();
SphyrnidaeServiceRegistration.AddCommonServices(services, config, app, env, http);
}
private static void ConfigureUnsecureHttpClientOptions(IServiceProvider provider, HttpClient client)
{
HttpClientSettings options = provider.GetService <IConfiguration>()
.GetSection(HttpClientSettings.Section)
.Get <HttpClientSettings>();
client.BaseAddress = new Uri(options.Url);
}
protected override IHttpClient CreateClient()
{
var settings = new HttpClientSettings();
settings.Serializers.Clear();
settings.Serializers.Add(new DotNetXmlSerializer());
settings.Logger = new ConsoleLogger();
return HttpClient.Create("http://localhost:1337/api", settings);
}
protected virtual IHttpClient CreateClient()
{
var settings = new HttpClientSettings
{
Logger = new ConsoleLogger()
};
return(HttpClient.Create(ApiUrl, settings));
}
internal RequestExecutor(Uri uri)
{
var settings = new HttpClientSettings
{
UserAgent = new UserAgent(UserAgentString),
};
_client = HttpClient.Create(uri.AbsoluteUri, settings);
}
protected virtual IHttpClient CreateClient()
{
var settings = new HttpClientSettings
{
Logger = new ConsoleLogger()
};
return HttpClient.Create(ApiUrl, settings);
}
public override HttpMessageHandler CreateHttpMessageHandler(Uri uri, HttpClientSettings settings)
{
if (MacPlatformSettings.UseNSUrlSessionHandler)
{
return(CreateNSUrlSessionHandler(uri, settings));
}
return(defaultProvider.CreateHttpMessageHandler(uri, settings));
}
protected override IHttpClient CreateClient()
{
var settings = new HttpClientSettings();
settings.Serializers.Clear();
settings.Serializers.Add(new DotNetXmlSerializer());
settings.Logger = new ConsoleLogger();
return(HttpClient.Create("http://localhost:1337/api", settings));
}
public void Constructor_Null_Parameters_Returns_HttpClientSettings_Returns_HttpClientSettings_With_Null_Properties()
{
//Act
var httpSettings = new HttpClientSettings(null, null, null, null, null);
//Assert
Assert.IsInstanceOfType(httpSettings, typeof(HttpClientSettings));
Assert.AreEqual(null, httpSettings.BaseUrl);
Assert.AreEqual(null, httpSettings.ClientId);
Assert.AreEqual(null, httpSettings.ClientSecret);
Assert.AreEqual(null, httpSettings.Authority);
Assert.AreEqual(null, httpSettings.XClientIdHeader);
}
private static void ConfigureSecureHttpClientOptions(IServiceProvider provider, HttpClient client)
{
HttpClientSettings options = provider.GetService <IConfiguration>()
.GetSection(HttpClientSettings.Section)
.Get <HttpClientSettings>();
client.BaseAddress = new Uri(options.Url);
//https://stackoverflow.com/questions/30858890/how-to-use-httpclient-to-post-with-authentication
var byteArray = new UTF8Encoding().GetBytes($"{options.ClientId}:{options.ClientSecret}");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
}
public HttpMessageInvoker GetClient(HttpClientSettings clientSetting, params DelegatingHandler[] handlers)
{
if (_httpClient == null)
{
lock (_syncObject)
{
if (_httpClient == null)
{
_httpClient = GetClientInernal(clientSetting, handlers);
}
}
}
return(_httpClient);
}
public void Contructor_Right_Parameters_Returns_HttpClientSettings_With_Right_Properties()
{
//Arrange
//all necessary variables already set
//Act
var httpSettings = new HttpClientSettings(_urlBase, _defaultClientId, _defaultClientSecret, _authority, _xClientIdHeader);
//Assert
Assert.IsInstanceOfType(httpSettings, typeof(HttpClientSettings));
Assert.AreEqual(_urlBase, httpSettings.BaseUrl);
Assert.AreEqual(_defaultClientId, httpSettings.ClientId);
Assert.AreEqual(_defaultClientSecret, httpSettings.ClientSecret);
Assert.AreEqual(_authority, httpSettings.Authority);
Assert.AreEqual(_xClientIdHeader, httpSettings.XClientIdHeader);
}
public ApiFixture()
{
host = new WebHostBuilder()
.UseKestrel()
.UseStartup <Startup>()
.UseUrls(ApiUrl)
.Build();
host.Start();
var settings = new HttpClientSettings();
settings.Middleware.Append(new ConsoleLoggingMiddleware());
Client = HttpClient.Create("http://localhost:1337/api", settings);
}
public async void ShouldHaveCustomUserAgent(string userAgent)
{
var settings = new HttpClientSettings();
settings.Middleware.Append(new ConsoleLoggingMiddleware());
settings.Middleware.Replace(new UserAgentMiddleware(new UserAgent(userAgent)));
var client = HttpClient.Create("http://localhost:1337/api", settings);
var response = await client
.Get("middleware/echo-user-agent")
.OnOk()
.AsString();
Assert.Equal(userAgent, response);
}
public async void ShouldAddCustomHeaders(string name)
{
var settings = new HttpClientSettings();
settings.Middleware.Append(new ConsoleLoggingMiddleware());
settings.Middleware.Append(new CustomHeadersMiddleware(name));
var client = HttpClient.Create("http://localhost:1337/api", settings);
var response = await client
.Get("middleware/echo-header", new { headerName = "x-special-name" })
.OnOk()
.AsString();
Assert.Contains(name, response);
}
private static void AddHttpClients(IServiceCollection services,
HttpClientSettings section, Dictionary <string, Type> handlers, IPolicyRegistry <string> registry)
{
if (string.IsNullOrEmpty(section.PriorityType) ||
section.BaseAddresses == null || section.BaseAddresses.Count == 0 ||
section.Settings == null || section.Settings.Count == 0)
{
return;
}
var priorityType = Type.GetType(section.PriorityType);
if (priorityType == null)
{
return;
}
foreach (var setting in section.Settings.Where(e => //Enum.TryParse(priorityType, e.Priority, out var priority) &&
section.BaseAddresses.ContainsKey(e.BaseAddress)))
{
// 注册 HTTP 客户
var builder = services.AddHttpClient(setting.Priority,
c => { c.BaseAddress = new Uri(section.BaseAddresses[setting.BaseAddress]); });
// 设置 HTTP 处理程序
if (setting.DelegatingHandlers?.Count > 0)
{
foreach (var handler in setting.DelegatingHandlers.Where(handlers.ContainsKey))
{
builder.AddHttpMessageHandler(provider =>
(DelegatingHandler)provider.GetRequiredService(handlers[handler]));
}
}
// 设置 HTTP 处理程序生存期
if (setting.HandlerLifetime.HasValue)
{
builder.SetHandlerLifetime(TimeSpan.FromMinutes(setting.HandlerLifetime.Value));
}
// 设置 HTTP 错误处理政策
if (setting.ErrorPolicies?.Count > 0)
{
foreach (var policy in setting.ErrorPolicies.Where(registry.ContainsKey))
{
builder.AddPolicyHandlerFromRegistry(policy);
}
}
}
}
public IbmClasifierService()
{
var settings = new HttpClientSettings()
{
Handlers = new List <DelegatingHandler>()
{
new BasicAuthorizationHandler(
ConfigurationManager.AppSettings["IbmClasifierUsername"],
ConfigurationManager.AppSettings["IbmClasifierPassword"]
),
new HandingExceptionDelegatingHandler()
},
BaseUri = new Uri(ConfigurationManager.AppSettings["IbmClasifierBaseUrl"])
};
httpRequester = new HttpRequester(new Core.HttpClientFactory.HttpClientFactory(settings));
}
internal static HttpHandlerResourceV3 CreateResource(PackageSource packageSource, ICredentialService credentialService, bool nonInteractive = false)
{
var sourceUri = packageSource.SourceUri;
var settings = new HttpClientSettings {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
SourceAuthenticationRequired = false,
NonInteractive = nonInteractive
};
var rootHandler = HttpClientProvider.CreateHttpMessageHandler(sourceUri, settings);
// HTTP handler pipeline can be injected here, around the client handler
HttpMessageHandler messageHandler = new MonoDevelopServerWarningLogHandler(rootHandler);
var innerHandler = messageHandler;
messageHandler = new StsAuthenticationHandler(packageSource, TokenStore.Instance)
{
InnerHandler = messageHandler
};
innerHandler = messageHandler;
var credentialsHandler = GetHttpCredentialsHandler(rootHandler);
messageHandler = new NuGetHttpSourceAuthenticationHandler(packageSource, credentialsHandler, credentialService)
{
InnerHandler = innerHandler
};
// Have to pass a dummy HttpClientProvider since it may not be used by a native implementation, such as on the Mac.
// It looks like the only place this is used in NuGet is with the DownloadResourcePluginProvider in order to pass the
// HttpClientHandler's Proxy to the GetCredentialsRequestHandler. There is no plugin support yet in MonoDevelop but
// this may be a problem in the future. Possibly a custom DownloadResourcePluginProvider would be required or possibly
// a HttpClientProvider created with just its Proxy property set based on the current proxy for that url.
var clientHandler = GetOrCreateHttpClientHandler(rootHandler);
// Get the proxy from NuGet's ProxyCache which has support for proxy information define in the NuGet.Config file.
var proxy = ProxyCache.Instance.GetUserConfiguredProxy();
if (proxy != null)
{
clientHandler.Proxy = proxy;
}
var resource = new HttpHandlerResourceV3(clientHandler, messageHandler);
return(resource);
}
public static void Main(string[] args)
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("guest", "guest")
};
const string root = "http://localhost:55672/api/";
settings.Configure<JsonDotNetSerializer>(s =>
s.ConfigureSettings(c =>
{
c.ContractResolver = new RabbitContractResolver();
}));
var client = HttpClient.Create(root, settings);
var options = new
{
vhost = "integration",
name = "ErrorQueue",
count = "1",
requeue = "true",
encoding = "auto",
truncate = "50000"
};
var resource = client.BuildRelativeResource("queues/:vhost/:queue/get", new
{
vhost = "integration",
queue = "ErrorQueue"
});
var request = new PostRequest(
resource, new ObjectRequestBody(options));
request.AddHeader("Accept", string.Empty);
var messages = client.Run(request)
.OnOk()
.As<List<Message>>();
Console.WriteLine(messages.Count);
Console.ReadLine();
}
/// <summary>
/// Http 中间处理程序
/// </summary>
/// <param name="services"></param>
/// <param name="section"></param>
/// <returns></returns>
private static Dictionary <string, Type> AddDelegatingHandlers(IServiceCollection services,
HttpClientSettings section)
{
var handlers = new Dictionary <string, Type>();
if (section.DelegatingHandlers?.Count > 0)
{
foreach (var handler in section.DelegatingHandlers.Where(e => !string.IsNullOrEmpty(e.Value)))
{
var handlerType = Type.GetType(handler.Value);
if (handlerType != null && typeof(DelegatingHandler).IsAssignableFrom(handlerType))
{
services.AddTransient(handlerType);
handlers.Add(handler.Key, handlerType);
}
}
}
return(handlers);
}
/// <summary>
/// Http 错误处理程序
/// </summary>
/// <param name="services"></param>
/// <param name="section"></param>
/// <returns></returns>
private static IPolicyRegistry <string> AddHttpErrorPolicies(IServiceCollection services,
HttpClientSettings section)
{
var registry = services.AddPolicyRegistry();
if (section.RetryPolicies?.Count > 0)
{
foreach (var policy in section.RetryPolicies.Where(e => e.Value != null))
{
if (!registry.ContainsKey(policy.Key))
{
//错误重试次数
registry.Add(policy.Key, HttpPolicyExtensions.HandleTransientHttpError().RetryAsync(policy.Value.RetryCount));
}
}
}
if (section.WaitAndRetryPolicies?.Count > 0)
{
foreach (var policy in section.WaitAndRetryPolicies.Where(e => e.Value?.SleepDurations?.Length > 0))
{
if (!registry.ContainsKey(policy.Key))
{
//重试间隔/毫秒
registry.Add(policy.Key, HttpPolicyExtensions.HandleTransientHttpError().WaitAndRetryAsync(policy.Value.SleepDurations.Select(e => TimeSpan.FromMilliseconds(e))));
}
}
}
if (section.CircuitBreakerPolicies?.Count > 0)
{
foreach (var policy in section.CircuitBreakerPolicies.Where(e => e.Value != null))
{
if (!registry.ContainsKey(policy.Key))
{
//断路时间/毫秒
registry.Add(policy.Key, HttpPolicyExtensions.HandleTransientHttpError().CircuitBreakerAsync(policy.Value.HandledEventsAllowedBeforeBreaking, TimeSpan.FromMilliseconds(policy.Value.DurationOfBreak)));
}
}
}
return(registry);
}
HttpMessageHandler CreateNSUrlSessionHandler(Uri uri, HttpClientSettings settings)
{
var config = NSUrlSessionConfiguration.DefaultSessionConfiguration;
config.RequestCachePolicy = NSUrlRequestCachePolicy.ReloadIgnoringLocalCacheData;
config.URLCache = null;
var sessionHandler = new NSUrlSessionCredentialsHandler(config)
{
DisableCaching = true,
AllowAutoRedirect = settings.AllowAutoRedirect,
};
if (!settings.SourceAuthenticationRequired)
{
return(sessionHandler);
}
return(new HttpSourceAuthenticationHandler(uri, sessionHandler, sessionHandler));
}
private IHttpClient BuildClient()
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("guest", "guest")
};
settings.Configure <DefaultJsonSerializer>(s =>
{
s.JsonSerializerStrategy = new RabbitJsonSerializerStrategy();
});
var rootWithReplacements = root.FormatWithReplacements();
var client = HttpClient.Create(rootWithReplacements, settings);
// add an accept header to all requests otherwise the api will complain
client.BeforeRequest += (sender, args) =>
args.Request.AddHeader("Accept", string.Empty);
return(client);
}
private IHttpClient BuildClient()
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("guest", "guest")
};
settings.Configure<DefaultJsonSerializer>(s =>
{
s.JsonSerializerStrategy = new RabbitJsonSerializerStrategy();
});
var rootWithReplacements = root.FormatWithReplacements();
var client = HttpClient.Create(rootWithReplacements, settings);
// add an accept header to all requests otherwise the api will complain
client.BeforeRequest += (sender, args) =>
args.Request.AddHeader("Accept", string.Empty);
return client;
}
public static void Main(string[] args)
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("username", "password"),
UserAgent = new UserAgent("SpeakEasy (username)")
};
var client = HttpClient.Create("https://basecamp.com/1816438/api/v1/", settings);
var projects = client.Get("projects.json").OnOk().As<List<Project>>();
foreach (var project in projects)
{
Console.WriteLine(project.Name);
}
var person = client.Get("people/me.json").OnOk().As<Person>();
Console.WriteLine(person.Name);
Console.WriteLine(person.EmailAddress);
Console.ReadLine();
}
public static void Main(string[] args)
{
var settings = new HttpClientSettings
{
Authenticator = new BasicAuthenticator("username", "password"),
UserAgent = new UserAgent("SpeakEasy (username)")
};
var client = HttpClient.Create("https://basecamp.com/1816438/api/v1/", settings);
var projects = client.Get("projects.json").OnOk().As <List <Project> >();
foreach (var project in projects)
{
Console.WriteLine(project.Name);
}
var person = client.Get("people/me.json").OnOk().As <Person>();
Console.WriteLine(person.Name);
Console.WriteLine(person.EmailAddress);
Console.ReadLine();
}
public HttpRequestMessageBuilder(HttpMethod httpMethod, UriBuilder uriBuilder, HttpClientSettings httpSettings)
{
this.HttpMethod = httpMethod;
this.UriBuilder = uriBuilder;
this.JsonSetting = httpSettings.JsonSerializerSettings;
this.DefaultStringFormatter = new StringFormatAttribute(httpSettings.DateTimeFormat);
this.Headers = new HttpNameValueCollection();
this.Cookies = new List <CookieHeaderValue>();
this.PathParams = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
this.QueryStrings = new HttpNameValueCollection();
this.FormBodys = new HttpNameValueCollection();
//this.StreamBodys = new List<Tuple<string, Stream>>();
//this.Files = new List<KeyValuePair<string, FileInfo>>();
this.RawContents = new List <HttpContent>();
}
//public List<KeyValuePair<string, FileInfo>> Files { get; set; }
public HttpRequestMessageBuilder(HttpMethod httpMethod, UriBuilder uriBuilder, HttpClientSettings httpSettings, bool keepOrginalQueryString)
: this(httpMethod, uriBuilder, httpSettings)
{
if (!string.IsNullOrWhiteSpace(uriBuilder.Query))
{
var parsedQueryString = HttpUtility.ParseQueryString(uriBuilder.Query, Utf8Encoding);
foreach (var k in parsedQueryString.Keys)
{
this.QueryStrings.Add(k.ToString(), parsedQueryString.GetValues(k.ToString()));
}
}
}
public CodeGenerationService(IOptions <HttpClientSettings> options)
{
_options = options.Value;
}
public static Task <IHttpResult> ToHttpResult(this Task <HttpResponseMessage> responseMessageTask, Type returnObjectType, HttpClientSettings httpClientSettings)
{
var actionContext = new EmptyActionContext();
actionContext.HttpClientSettings = httpClientSettings;
actionContext.ReturnTypeDescription.ReturnType = typeof(IHttpResult);
actionContext.ReturnTypeDescription.TargetObjectType = returnObjectType;
return(responseMessageTask.Then(responseMessage => ToHttpResult(responseMessage, returnObjectType, actionContext)));
}
public static Task <IHttpResult> ParseAsHttpResult(this Task <HttpResponseMessage> responseMessageTask, Type returnObjectType, HttpClientSettings httpClientSettings)
{
return(responseMessageTask.Then(async responseMessage =>
{
IHttpResult httpResult = (IHttpResult)Activator.CreateInstance(typeof(HttpResult <>).MakeGenericType(returnObjectType), httpClientSettings.JsonSerializerSettings);
httpResult.Headers = responseMessage.Headers;
httpResult.IsSuccessStatusCode = responseMessage.IsSuccessStatusCode;
httpResult.ReasonPhrase = responseMessage.ReasonPhrase;
httpResult.StatusCode = responseMessage.StatusCode;
httpResult.Version = responseMessage.Version;
if (responseMessage.Content != null)
{
httpResult.ContentHeaders = responseMessage.Content.Headers;
}
if (responseMessage.IsSuccessStatusCode)
{
if (returnObjectType.IsBulitInType())
{
httpResult.Content = ObjectExtensions.ChangeType(await responseMessage.Content.ReadAsStringAsync(), returnObjectType);
responseMessage.Dispose();
}
else if (typeof(Stream).IsAssignableFrom(returnObjectType))
{
httpResult.Content = await responseMessage.Content.ReadAsStreamAsync();
}
else if (typeof(byte[]) == returnObjectType)
{
httpResult.Content = await responseMessage.Content.ReadAsByteArrayAsync();
responseMessage.Dispose();
}
else
{
httpResult.Content = await responseMessage.Content.ReadAsAsync(returnObjectType, new[] { httpClientSettings.JsonMediaTypeFormatter });
responseMessage.Dispose();
}
}
else
{
httpResult.ErrorMessage = await responseMessage.Content.ReadAsStringAsync();
responseMessage.Dispose();
}
return httpResult;
}));
}
/// <summary>
/// Get the permissions a user has to a resource. Get a summary of the permissions a user has to a particular resource.
/// </summary>
public AuthressClient(ITokenProvider tokenProvider, HttpClientSettings settings, IHttpClientHandlerFactory customHttpClientHandlerFactory = null)
{
authressHttpClientProvider = new HttpClientProvider(settings, tokenProvider, customHttpClientHandlerFactory);
}
public static IPushClient CreateApiClient(HttpClientSettings settings)
{
return(new PushClient(new HttpEventPusher <EffectiveAuthorizationEvent>(settings, new PingFederateAuthenticationProvider(settings.Authority.AbsoluteUri, settings.ClientId, settings.ClientSecret, settings.XClientIdHeader))));
}
