public static IServiceCollection AddLearnerService(this IServiceCollection serviceCollection)
{
serviceCollection.AddTransient <ILearnerService>(s =>
{
var settings = s.GetService <IOptions <MatchedLearnerApi> >().Value;
var clientBuilder = new HttpClientBuilder()
.WithDefaultHeaders()
.WithLogging(s.GetService <ILoggerFactory>());
if (!string.IsNullOrEmpty(settings.Identifier))
{
clientBuilder.WithManagedIdentityAuthorisationHeader(new ManagedIdentityTokenGenerator(settings));
}
var client = clientBuilder.Build();
if (!settings.ApiBaseUrl.EndsWith("/"))
{
settings.ApiBaseUrl += "/";
}
client.BaseAddress = new Uri(settings.ApiBaseUrl);
return(new LearnerService(client, settings.Version));
});
return(serviceCollection);
}
public async Task get_all_capabilities_return_expected_list_with_only_v2()
{
using (var builder = new HttpClientBuilder())
{
var capNewWithoutContext = new CapabilityBuilder().Build();
var ctx = new ContextBuilder().WithAccountId(null).WithRoleArn(null).WithRoleEmail(null).Build();
var capNewWithContext = new CapabilityBuilder().WithContexts(ctx).Build();
var populatedContext = new ContextBuilder().Build();
var capNewWithPopulatedContext = new CapabilityBuilder().WithContexts(populatedContext).Build();
Capability[] stubCapabilities = new[] { capNewWithContext, capNewWithoutContext, capNewWithPopulatedContext };
var client = builder
.WithService <ICapabilityApplicationService>(new StubCapabilityApplicationService(stubCapabilities: stubCapabilities))
.Build();
var request = new HttpRequestMessage(HttpMethod.Get, "api/v1/adsync");
request.Headers.Authorization = BasicAuthCredentials.BASIC_AUTHENTICATION_HEADER_VALUE;
var response = await client.SendAsync(request);
var content = await response.Content.ReadAsStringAsync();
Assert.Equal(
expected: $"{{\"items\":[{{\"identifier\":\"foo-582a4\",\"members\":[],\"isV1\":false,\"awsAccountId\":\"222222222222\",\"awsRoleArn\":\"arn:aws:iam::528563840976:role/aws-elasticbeanstalk-ec2-role\"}}]}}",
actual: content);
}
}
private static IServiceCollection AddBusinessCentralClient <T>(this IServiceCollection serviceCollection, Func <HttpClient, IServiceProvider, string, int, bool, T> instance) where T : class
{
serviceCollection.AddTransient(s =>
{
var settings = s.GetService <IOptions <BusinessCentralApiClient> >().Value;
var clientBuilder = new HttpClientBuilder()
.WithDefaultHeaders()
.WithApimAuthorisationHeader(settings)
.WithLogging(s.GetService <ILoggerFactory>())
.WithHandler(new TransientRetryHandler(p => p.RetryAsync(3)));
var httpClient = clientBuilder.Build();
if (!settings.ApiBaseUrl.EndsWith("/"))
{
settings.ApiBaseUrl += "/";
}
httpClient.BaseAddress = new Uri(settings.ApiBaseUrl);
return(instance.Invoke(httpClient, s, settings.ApiVersion, settings.PaymentRequestsLimit, settings.ObfuscateSensitiveData));
});
return(serviceCollection);
}
public HttpClientBuilderTests()
{
_cacheHandlers = new Mock <IHttpClientCache>();
_logger = new Mock <IOcelotLogger>();
_factory = new Mock <IDelegatingHandlerHandlerFactory>();
_builder = new HttpClientBuilder(_factory.Object, _cacheHandlers.Object, _logger.Object);
}
public async Task Will_Handle_CapabilityRegisteredEvent()
{
//Arrange
using var builder = new HttpClientBuilder();
var teamCreatedEventHandlerStub = new TeamCreatedEventHandlerStub();
var domEventRegistration = new DomainEventRegistration
{
EventTypeName = "capability_registered",
EventType = typeof(CapabilityRegisteredDomainEvent),
Topic = "foo"
};
using var client = builder
.WithService <IEventHandler>(teamCreatedEventHandlerStub)
.WithService(domEventRegistration)
.Build();
//Act
var input = @"{
""eventName"": ""capability_registered"",
""version"": ""1"",
""payload"": {
""capabilityName"": ""ADFS-ViewOnly"",
""roleArn"": ""arn:aws:iam::738063116313:role/ADFS-ViewOnly""
}
}";
var content = new JsonContent(input);
var response = await client.PostAsync("/api/events", content);
//Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(teamCreatedEventHandlerStub.HandleAsyncGotCalled);
}
public static IServiceCollection AddHttpClient(this IServiceCollection servicecollection, Action <IHttpClientBuilder> action = null)
{
servicecollection.AddChainOfResponsability(c =>
{
var builder = new HttpClientBuilder(c);
builder.Add <TracingMiddleware>();
builder.Add <MemoryCacheMiddleware>();
builder.Add <TokenAuthenticatorMiddleware>();
builder.Add <HttpMiddelware>();
builder.Add <BasicHttpAuthenticatorMiddleware>();
if (action != null)
{
action(builder);
}
});
servicecollection.TryAddSingleton <IHttpFluentHandler, HttpFluentHandler>();
servicecollection.TryAddSingleton <IHttpHandler, HttpHandler>();
return(servicecollection);
}
private static IServiceCollection AddClient <T>(
this IServiceCollection serviceCollection,
Func <HttpClient, IServiceProvider, T> instance) where T : class
{
serviceCollection.AddTransient(s =>
{
var settings = s.GetService <IOptions <EmployerIncentivesApiOptions> >().Value;
var clientBuilder = new HttpClientBuilder()
.WithDefaultHeaders()
.WithApimAuthorisationHeader(settings)
.WithLogging(s.GetService <ILoggerFactory>());
var httpClient = clientBuilder.Build();
if (!settings.ApiBaseUrl.EndsWith("/"))
{
settings.ApiBaseUrl += "/";
}
httpClient.BaseAddress = new Uri(settings.ApiBaseUrl);
return(instance.Invoke(httpClient, s));
});
return(serviceCollection);
}
private Browser GetBrowser(string radioName, string radioUrl, IParser parser)
{
var configuration = ScrapperConfigurationBuilder.Create()
.AddScrapper(radioName, radioUrl)
.Build();
var httpClient = HttpClientBuilder
.Create()
.WithGetAsync(radioUrl, FileLoader.Get($"Ressources.{radioName}.message.json"))
.Build();
var parsers = new[] { parser };
return(new Browser(cfg =>
{
cfg.Module <ScrapperModule>();
cfg.Dependency(configuration);
cfg.Dependency(httpClient);
cfg.Dependency <IScrapper>(typeof(RadioScrapper));
cfg.Dependency <IEnumerable <IParser> >(parsers);
cfg.RequestStartup((container, pipelines, context) => {
ErrorHandler.Enable(pipelines, container.Resolve <IResponseNegotiator>());
});
cfg.ResponseProcessors(new[] { typeof(JsonProcessor) });
cfg.StatusCodeHandlers(new[] { typeof(StatusCodeHandler404), typeof(StatusCodeHandler500) });
}));
}
public async Task <T> Execute <T>(HttpClientBuilder builder)
{
var result = await builder.Build().SendAsync(builder.HttpRequest);
var v = await result.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <T>(v));
}
//GET: ForgotPassword/resetPassword
public ActionResult resetPassword(string token)
{
HttpClient httpClient = HttpClientBuilder.Get();
HttpResponseMessage response = httpClient.GetAsync("forgotpssd/reset_password").Result;
response.EnsureSuccessStatusCode();
return(View());
}
private HttpClient CreateHttpClient(bool allowsAutoRedirect = true)
{
return(HttpClientBuilder.Create(allowsAutoRedirect)
.WithBasicAuthenticationFrom(_connectionConfig)
.AcceptJson()
.AcceptOctetStream()
.Build());
}
public ActionResult resetPassword(ResetPassword resetPassword)
{
HttpClient httpClient = HttpClientBuilder.Get();
HttpResponseMessage response = httpClient.PostAsJsonAsync <ResetPassword>("forgotpssd/reset_password", resetPassword).Result;
return(View());
}
public async Task Should_Accept_Defined_Http_Status(int statusCode)
{
var response = await HttpClientBuilder.Create(BASE_URL)
.Path("status").Path(statusCode)
.AsyncGet()
.AcceptStatusCodes(statusCode)
.GetResponse();
}
public HttpClientBuilderTests()
{
var messageHandlerBuilder = Substitute.For <HttpMessageHandlerBuilder>();
messageHandlerBuilder.Build().Returns(Substitute.For <HttpMessageHandler>());
_clientBuilder = new HttpClientBuilder(messageHandlerBuilder);
}
public HttpClient(HttpClientBuilder builder)
{
_host = builder.Host;
_keepAlive = builder.KeepAlive;
_sender = builder.Sender ?? new HttpSenderAsync(_host, builder.Decoders);
Timeout = builder.Timeout;
_requestPreprocessor = builder.RequestMiddleware;
_responsePreprocessor = builder.ResponseMiddleware;
}
/// <inheritdoc cref="IProxyResponseBuilder.WithProxy(IProxyAndRecordSettings)"/>
public IResponseBuilder WithProxy(IProxyAndRecordSettings settings)
{
Check.NotNull(settings, nameof(settings));
ProxyAndRecordSettings = settings;
_httpClientForProxy = HttpClientBuilder.Build(settings);
return(this);
}
private static void InitializeAfterRegenerateWebsiteService()
{
AfterRegenerateWebSiteHttpBuilder = new HttpClientBuilder(() => new AuthenticationConfiguration
{
ApiKey = RegenerateApiKeyApiResult.Value.MerchantSite.ApiKey, SiteId = RegenerateApiKeyApiResult.Value.MerchantSite.SiteID
});
AfterRegenerateWebsiteHttpClient = AfterRegenerateWebSiteHttpBuilder.Build();
AfterRegenerateManagementService = new Sdk.Services.WebsiteManagementService(AfterRegenerateWebsiteHttpClient, BaseAddress);
}
public void SetUp()
{
var httpClient = new HttpClientBuilder()
.WithGetAlbumDetailsSuccessfulResponse()
.Build();
var builder = TestWebHostBuilder.BuildTestWebHostForStartUp <Startup>(httpClient);
_testServer = new TestServer(builder);
}
/// <summary>
/// ユーザーの投稿動画の情報をセットします。
/// </summary>
/// <returns></returns>
public async Task SetUserVideoInfo()
{
using (var client = HttpClientBuilder.NewHttpClient())
{
var httpUserVideo = await new HttpUserVideoInfoBuilder().Build(userId, client);
videoSamune = httpUserVideo.GetVideoSamune();
videoTitle = httpUserVideo.GetVideoTitle();
videoURL = httpUserVideo.GetVideoURL();
}
}
private async static Task <string[]> GetMylistId(string userId)
{
using (var client = HttpClientBuilder.NewHttpClient())
{
var response = await client.GetAsync(ApiURL.GET_USER_MYLIST(userId));
string[] mylistInfo = XmlParse.ParseMylistXml(await response.Content.ReadAsStringAsync());
return(mylistInfo);
}
}
public async Task AddPayment(PaymentModel paymentModel)
{
var clientBuilder = new HttpClientBuilder()
.AsPost()
.WithBaseRoute(BaseRoute)
.WithBody <PaymentModel>(paymentModel)
.WithRoute(Routes.Payment.POST_Payment);
await Execute(clientBuilder);
}
public RestClientFactoryConfig(IHttpClientBuilder httpClientBuilder)
{
HttpClientBuilder = httpClientBuilder ?? throw new ArgumentNullException(nameof(httpClientBuilder));
UseDefaultHandlers = true;
HttpClientBuilder.AddHttpMessageHandler(() => new DefaultJsonHandler(new Config
{
UseDefaultHandlers = UseDefaultHandlers
}));
}
public async Task <PaymentModel> GetOrderItem(Guid id)
{
var clientBuilder = new HttpClientBuilder()
.AsGET()
.WithBaseRoute(BaseRoute)
.WithUriSehment("id", id)
.WithRoute(Routes.Payment.GET_Payment);
return(await Execute <PaymentModel>(clientBuilder));
}
public async Task SuccessFlow()
{
var correlationId = Guid.NewGuid().ToString();
ContextResolver.SetContext(new CorrelationContext(correlationId));
var innerHandler = setupMockHandler(validateHeader);
var client = HttpClientBuilder.CreateClient(innerHandler.Object, new[] { new CorrelationContextInjector() });
await client.GetAsync("http://bing.com");
}
/// <inheritdoc />
public IRemoteService <T> Create <T>(string baseUrl)
{
if (string.IsNullOrEmpty(baseUrl))
{
throw new ArgumentNullException(nameof(baseUrl), "Parameter can't be null or empty.");
}
var httpClient = new HttpClientBuilder().WithBaseUrl(baseUrl).Build();
return(Create <T>(httpClient));
}
public async Task NoInjectors()
{
var correlationId = Guid.NewGuid().ToString();
ContextResolver.SetContext(correlationId);
var innerHandler = setupMockHandler(validateNoHeader);
var client = HttpClientBuilder.CreateClient(innerHandler.Object, new List <IContextInjector <string, HttpRequestMessage> >());
await client.GetAsync("http://bing.com");
}
public async Task Should_Request_And_Deserialize_Model_With_Guid()
{
var model =
await HttpClientBuilder.Create(BASE_URL)
.Path("uuid")
.AsyncGet()
.GetEntity <ModelWithGuid>();
Assert.NotNull(model);
Assert.NotEqual(Guid.Empty, model.Uuid);
}
private HttpClient CreateHttpClient()
{
var httpClient = new HttpClientBuilder()
.WithDefaultHeaders()
.WithBearerAuthorisationHeader(new AzureADBearerTokenGenerator(_config))
.Build();
httpClient.BaseAddress = new Uri(_config.ApiBaseUrl);
return(httpClient);
}
private static HttpClient CreateHttpClient(ProviderRelationshipApiConfiguration configuration)
{
var httpClient = new HttpClientBuilder()
.WithDefaultHeaders()
.WithBearerAuthorisationHeader(new AzureADBearerTokenGenerator(configuration))
.Build();
httpClient.BaseAddress = new Uri(configuration.ApiBaseUrl);
return(httpClient);
}
/// <summary>Initializes a new instance of the <see cref="UserService" /> class.</summary>
/// <param name="jwtUtil">The JWT utility.</param>
/// <param name="vaultUtil">The vault utility.</param>
/// <param name="client">The client.</param>
/// <param name="fileUtil">The file utility.</param>
public UserService(
JwtUtil jwtUtil,
VaultUtil vaultUtil,
HttpClientBuilder client,
FileUtil fileUtil
)
{
settings = vaultUtil.decrypt <Settings>();
this.jwtUtil = jwtUtil;
this.client = client;
this.fileUtil = fileUtil;
}
