public void Given_Validation_Error_With_CancellationToken_When_PutAsync_Invoked_Then_It_Should_Throw_Exception(HttpStatusCode statusCode) { var requestUri = "http://localhost"; var payload = "{ \"hello\": \"world\" }"; var exception = new SchemaValidationException(); var validator = new Mock <ISchemaValidator>(); validator.Setup(p => p.ValidateAsync(It.IsAny <string>(), It.IsAny <string>())).ThrowsAsync(exception); var path = "default.json"; var func = default(Func <Task>); using (var handler = this._fixture.CreateFakeHttpMessageHandler(statusCode, payload)) using (var httpClient = this._fixture.CreateHttpClient(handler)) using (var content = this._fixture.CreateHttpContent()) using (var source = this._fixture.CreateCancellationTokenSource()) { func = async() => await HttpClientExtensions.PutAsync(httpClient, requestUri, content, validator.Object, path, source.Token).ConfigureAwait(false); func.Should().Throw <SchemaValidationException>(); func = async() => await HttpClientExtensions.PutAsync(httpClient, new Uri(requestUri), content, validator.Object, path, source.Token).ConfigureAwait(false); func.Should().Throw <SchemaValidationException>(); } }
public async Task Given_Validation_Result_With_CancellationToken_When_PatchAsync_Invoked_Then_It_Should_Return_Result(HttpStatusCode statusCode) { var requestUri = "http://localhost"; var payload = "{ \"hello\": \"world\" }"; var validator = new Mock <ISchemaValidator>(); validator.Setup(p => p.ValidateAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(true); var path = "default.json"; using (var response = this._fixture.CreateHttpResponseMessage(statusCode, payload)) using (var handler = this._fixture.CreateFakeHttpMessageHandler(response)) using (var httpClient = this._fixture.CreateHttpClient(handler)) using (var content = this._fixture.CreateHttpContent()) using (var source = this._fixture.CreateCancellationTokenSource()) { var result = await HttpClientExtensions.PatchAsync(httpClient, requestUri, content, validator.Object, path, source.Token).ConfigureAwait(false); result.Should().Be(response); } using (var response = this._fixture.CreateHttpResponseMessage(statusCode, payload)) using (var handler = this._fixture.CreateFakeHttpMessageHandler(response)) using (var httpClient = this._fixture.CreateHttpClient(handler)) using (var content = this._fixture.CreateHttpContent()) using (var source = this._fixture.CreateCancellationTokenSource()) { var result = await HttpClientExtensions.PatchAsync(httpClient, new Uri(requestUri), content, validator.Object, path, source.Token).ConfigureAwait(false); result.Should().Be(response); } }
public async Task <Course> UpdateObject(Course updateCourse) { Course course = new Course(); try { var json = JsonConvert.SerializeObject(updateCourse); var body = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = await HttpClientExtensions.PatchAsync(client, Constants.HOSTNAME + Constants.COURSE_PATH + "/externalId:" + Constants.COURSE_ID, body); if (response.IsSuccessStatusCode) { Debug.WriteLine(@" Course successfully updated."); var content = await response.Content.ReadAsStringAsync(); course = JsonConvert.DeserializeObject <Course>(content); } } catch (Exception ex) { Debug.WriteLine(@" ERROR {0}", ex.Message); } return(course); }
public static void ConfigureContainer(IUnityContainer container) { container.RegisterFactory <HttpClient>(_ => HttpClientExtensions.CreateHttpClient(), new TransientLifetimeManager()); container.RegisterFactory <StaticLicenseConfiguration>(ResolveStaticLicenseConfiguration, new TransientLifetimeManager()); container.RegisterType <ISourceCodeParser, SourceCodeParser>(new TransientLifetimeManager()); container.RegisterType <ILicenseCache, LicenseCache>(new ContainerControlledLifetimeManager()); container.RegisterType <ILicenseResolver, LicenseResolver>(new TransientLifetimeManager()); container.RegisterType <IPackageRepository, PackageRepository>(new TransientLifetimeManager()); // nuget container.RegisterFactory <NuGetConfiguration>(ResolveNuGetConfiguration, new ContainerControlledLifetimeManager()); container.RegisterType <ISourceCodeReferenceProvider, NuGetSourceCodeReferenceProvider>(PackageSources.NuGet, new TransientLifetimeManager()); container.RegisterType <IPackageResolver, NuGetPackageResolver>(PackageSources.NuGet, new TransientLifetimeManager()); container.RegisterType <ILicenseSourceByUrl, NuGetLicenseSource>(KnownHosts.NuGetLicense, new TransientLifetimeManager()); container.RegisterType <IPackageRepositoryAdapter, NuGetPackageRepositoryAdapter>(PackageSources.NuGet, new TransientLifetimeManager()); // npm container.RegisterFactory <NpmConfiguration>(ResolveNpmConfiguration, new ContainerControlledLifetimeManager()); container.RegisterType <ISourceCodeReferenceProvider, NpmSourceCodeReferenceProvider>(PackageSources.Npm, new TransientLifetimeManager()); container.RegisterType <IPackageRepositoryAdapter, NpmPackageRepositoryAdapter>(PackageSources.Npm, new TransientLifetimeManager()); container.RegisterType <IPackageResolver, NpmPackageResolver>(PackageSources.Npm, new TransientLifetimeManager()); // github container.RegisterFactory <GitHubConfiguration>(ResolveGitHubConfiguration, new ContainerControlledLifetimeManager()); container.RegisterType <ILicenseSourceByUrl, GitHubLicenseSource>(KnownHosts.GitHub, new TransientLifetimeManager()); container.RegisterType <ILicenseSourceByUrl, GitHubLicenseSource>(KnownHosts.GitHubRaw, new TransientLifetimeManager()); container.RegisterType <ILicenseSourceByUrl, GitHubLicenseSource>(KnownHosts.GitHubApi, new TransientLifetimeManager()); // custom container.RegisterType <IPackageRepositoryAdapter, CustomPackageRepositoryAdapter>(PackageSources.Custom, new TransientLifetimeManager()); }
public void Given_Error_Response_With_CancellationToken_When_PatchAsync_Invoked_Then_It_Should_Throw_Exception(HttpStatusCode statusCode) { var requestUri = "http://localhost"; var validator = new Mock <ISchemaValidator>(); var path = "default.json"; var func = default(Func <Task>); using (var handler = this._fixture.CreateFakeHttpMessageHandler(statusCode)) using (var httpClient = this._fixture.CreateHttpClient(handler)) using (var content = this._fixture.CreateHttpContent()) using (var source = this._fixture.CreateCancellationTokenSource()) { func = async() => await HttpClientExtensions.PatchAsync(httpClient, requestUri, content, validator.Object, path, source.Token).ConfigureAwait(false); func.Should().Throw <HttpRequestException>(); } using (var handler = this._fixture.CreateFakeHttpMessageHandler(statusCode)) using (var httpClient = this._fixture.CreateHttpClient(handler)) using (var content = this._fixture.CreateHttpContent()) using (var source = this._fixture.CreateCancellationTokenSource()) { func = async() => await HttpClientExtensions.PatchAsync(httpClient, new Uri(requestUri), content, validator.Object, path, source.Token).ConfigureAwait(false); func.Should().Throw <HttpRequestException>(); } }
private DefaultMicrosoftTeamsLogicAppPostMessageClient CreateClient(DefaultMicrosoftTeamsLogicAppPostMessageClientSettings settings = null, HttpClient httpClient = null) { if (settings == null) { settings = new DefaultMicrosoftTeamsLogicAppPostMessageClientSettings() { Active = true, EndpointUrl = "https://loremipsum.com/api/v1/postmessage" }; } if (httpClient == null) { httpClient = HttpClientExtensions.CreateMockHttpClient( new DefaultMicrosoftTeamsPostMessageResponse() { MessageId = "M123456789" } ); } var notifier = new DefaultMicrosoftTeamsLogicAppPostMessageClient(httpClient, settings); return(notifier); }
public static async Task <LoginResult> Start(IBrowser browser) { //Do not use this in production environment. var handler = HttpClientExtensions.CreateHttpClientHandler(true); var options = new OidcClientOptions { Authority = Config.IdentityServerUrl, BackchannelHandler = handler, Browser = browser, ClientId = "NativeClient", ClientSecret = "KHG+TZ8aaVx2h3^!vJ65", FilterClaims = false, Flow = OidcClientOptions.AuthenticationFlow.AuthorizationCode, LoadProfile = true, Scope = "openid profile Api1 Cluster", RedirectUri = Config.NativeClientUrl, RefreshTokenInnerHttpHandler = handler, ResponseMode = OidcClientOptions.AuthorizeResponseMode.Redirect }; var client = new OidcClient(options); return(await client.LoginAsync(new LoginRequest())); }
private Task<T> ExecuteRequest<T>(string request, CancellationToken cancellationToken = default(CancellationToken)) { HttpClient httpClient = HttpClientExtensions.CreateCompressionHttpClient(); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(RequestConstants.AcceptHeader)); httpClient.DefaultRequestHeaders.Add(RequestConstants.ClientIdHeaderKey, RequestConstants.ClientIdHeaderValue); return httpClient.ExecuteRequest<T>(request, cancellationToken); }
public async Task <Term> UpdateObject(Term updateTerm) { Term term = new Term(); try { var json = JsonConvert.SerializeObject(updateTerm); var body = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = await HttpClientExtensions.PatchAsync(client, Constants.HOSTNAME + Constants.TERM_PATH + "/externalId:" + Constants.TERM_ID, body); Constants.RESPONSERESULT = "Fail"; if (response.IsSuccessStatusCode) { Debug.WriteLine(@" Term successfully updated."); var content = await response.Content.ReadAsStringAsync(); term = JsonConvert.DeserializeObject <Term>(content); Constants.RESPONSERESULT = "Update"; } } catch (Exception ex) { Debug.WriteLine(@" ERROR {0}", ex.Message); } return(term); }
private static async Task <string> TryGetUserProfile(string accessToken) { if (string.IsNullOrWhiteSpace(accessToken)) { throw new ArgumentException(); } var httpClient = new HttpClient(HttpClientExtensions.CreateHttpClientHandler(true)); httpClient.SetBearerToken(accessToken); string result; var response = await httpClient.GetAsync($"{Common.Config.ApiUrl}/api/User/Alice"); if (response.IsSuccessStatusCode) { result = await response.Content.ReadAsStringAsync(); } else { result = response.ReasonPhrase; } return(result); }
public async Task <bool> UpdatePatientAsync(Patient patient) { string JSONresult = JsonConvert.SerializeObject(patient); //using (var client = new HttpClient()) //{ // client.DefaultRequestHeaders.Add("Accept", "application/fhir+json"); // client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/fhir+json; charset=utf-8"); // var a = new StringContent(JSONresult, Encoding.UTF8, "application/fhir+json"); // var response = await client.PutAsync(APIurl + patient.Id, // new StringContent(JSONresult, Encoding.UTF8, "application/fhir+json")).ConfigureAwait(false); // response.EnsureSuccessStatusCode(); // //return response.IsSuccessStatusCode; //} var client = new HttpClient(); client.DefaultRequestHeaders.Add("Accept", "application/fhir+json"); client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/fhir+json; charset=utf-8"); var httpResponse = await HttpClientExtensions.PutAsJsonAsync <Patient>(client, APIurl + patient.Id + "?_format=json", patient); var RequestBody = JsonConvert.SerializeObject(patient); var httpStatus = httpResponse.StatusCode; var UpdateResponse = await httpResponse.Content.ReadAsStringAsync(); return(true); }
public void Given_Null_Parameters_When_SendAsync_Invoked_Then_It_Should_Throw_Exception(string verb) { var requestUri = "http://localhost"; var validator = new Mock <ISchemaValidator>(); var func = default(Func <Task>); using (var httpClient = this._fixture.CreateHttpClient()) using (var request = this._fixture.CreateHttpRequestMessage(verb, requestUri)) { func = async() => await HttpClientExtensions.SendAsync(null, null, null, null).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, null, null, null).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, request, null, null).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, request, validator.Object, null).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); } }
public void Given_Error_Response_With_HttpCompletionOption_And_CancellationToken_When_SendAsync_Invoked_Then_It_Should_Throw_Exception(string verb, HttpStatusCode statusCode, HttpCompletionOption option) { var requestUri = "http://localhost"; var payload = "{ \"hello\": \"world\" }"; var exception = new SchemaValidationException(); var validator = new Mock <ISchemaValidator>(); validator.Setup(p => p.ValidateAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(true); var path = "default.json"; var func = default(Func <Task>); using (var response = this._fixture.CreateHttpResponseMessage(statusCode, payload)) using (var handler = this._fixture.CreateFakeHttpMessageHandler(response)) using (var httpClient = this._fixture.CreateHttpClient(handler)) using (var source = this._fixture.CreateCancellationTokenSource()) using (var request = this._fixture.CreateHttpRequestMessage(verb, requestUri, payload)) { func = async() => await HttpClientExtensions.SendAsync(httpClient, request, option, validator.Object, path, source.Token).ConfigureAwait(false); func.Should().Throw <HttpRequestException>(); } }
public void Given_Null_Parameters_With_HttpCompletionOption_And_CancellationToken_When_SendAsync_Invoked_Then_It_Should_Throw_Exception(string verb, HttpCompletionOption option) { var requestUri = "http://localhost"; var validator = new Mock <ISchemaValidator>(); var token = default(CancellationToken); var path = "default.json"; var func = default(Func <Task>); using (var httpClient = this._fixture.CreateHttpClient()) using (var request = this._fixture.CreateHttpRequestMessage(verb, requestUri)) { func = async() => await HttpClientExtensions.SendAsync(null, null, option, null, null, token).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, null, option, null, null, token).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, request, option, null, null, token).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, request, option, validator.Object, null, token).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); func = async() => await HttpClientExtensions.SendAsync(httpClient, request, option, validator.Object, path, token).ConfigureAwait(false); func.Should().Throw <ArgumentNullException>(); } }
public async Task <IActionResult> Profile() { var accessToken = await _httpContextAccessor.HttpContext.GetTokenAsync("access_token"); _logger.LogInformation(new EventId(LogEvents.AccessTokenRetrieved), $"Access Token: successfully retrieved."); var httpClient = new HttpClient(HttpClientExtensions.CreateHttpClientHandler(true)); httpClient.SetBearerToken(accessToken); string result; var response = await httpClient.GetAsync($"{Common.Config.ApiUrl}/api/User/Alice"); if (response.IsSuccessStatusCode) { result = await response.Content.ReadAsStringAsync(); } else { result = response.ReasonPhrase; } ViewBag.Response = result; return(View("~/User/Profile.cshtml")); }
public async Task <VideoRoot> GetLivestreamDetails(string videoId, CancellationToken cancellationToken = default(CancellationToken)) { if (IsNullOrWhiteSpace(videoId)) { throw new ArgumentNullException(nameof(videoId)); } var request = $"{RequestConstants.VideoLivestreamDetails}&id={videoId}"; var livestreamDetails = await HttpClientExtensions.ExecuteRequest <VideoRoot>(request, cancellationToken); request = $"{RequestConstants.VideoSnippet}&id={videoId}"; var snippetDetails = await HttpClientExtensions.ExecuteRequest <VideoRoot>(request, cancellationToken); if (livestreamDetails?.Items?.Count > 0 && snippetDetails?.Items?.Count > 0) { livestreamDetails.Items[0].Snippet = snippetDetails.Items[0].Snippet; } else { // youtube just returns empty values when no stream was found throw new HttpRequestWithStatusException(HttpStatusCode.BadRequest, "Channel not found " + videoId); } return(livestreamDetails); }
public void CreateBasicAuthTest() { HttpClient httpClient = null; // TODO: Initialize to an appropriate value HttpClientExtensions.CreateBasicAuth(httpClient); httpClient.DefaultRequestHeaders.Authorization.Should().NotBeNull(); }
public async Task <Membership> UpdateObject(Membership updateMembership) { Membership membership = new Membership(); try { var json = JsonConvert.SerializeObject(updateMembership); var body = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = await HttpClientExtensions.PatchAsync(client, Constants.HOSTNAME + Constants.COURSE_PATH + "/externalId:" + Constants.COURSE_ID + "users/externalId:" + Constants.USER_ID, body); if (response.IsSuccessStatusCode) { Debug.WriteLine(@" Membership successfully updated."); var content = await response.Content.ReadAsStringAsync(); membership = JsonConvert.DeserializeObject <Membership>(content); } } catch (Exception ex) { Debug.WriteLine(@" ERROR {0}", ex.Message); } return(membership); }
public async Task HttpClientExtensions_SendAsync_Headers_SetsHeaders() { var method = HttpMethod.Get; var uri = new Uri("http://example.com"); var customHeaders = new Dictionary <string, IEnumerable <string> > { ["header0"] = new string[0], ["header1"] = new [] { "first-value" }, ["header2"] = new [] { "first-value", "second-value" }, ["header3"] = new [] { "first-value", "second-value", "third-value" }, }; var httpHandler = new TestHttpMessageHandler { ThrowOnUnexpectedRequest = true }; httpHandler.Setup(method, uri, request => { Assert.False(request.Headers.Contains("header0")); Assert.True(request.Headers.Contains("header1")); Assert.True(request.Headers.Contains("header2")); Assert.True(request.Headers.Contains("header3")); Assert.Equal(customHeaders["header1"], request.Headers.GetValues("header1")); Assert.Equal(customHeaders["header2"], request.Headers.GetValues("header2")); Assert.Equal(customHeaders["header3"], request.Headers.GetValues("header3")); return(new HttpResponseMessage()); }); var httpClient = new HttpClient(httpHandler); await HttpClientExtensions.SendAsync(httpClient, method, uri, customHeaders); }
public async Task <MessageModel <WeChatApi> > GetOpenIDAsync(string appid, string secret, string code) { MessageModel <WeChatApi> result = new MessageModel <WeChatApi>(); string funName = "Get Wechat Data By Code"; try { var url = $"/sns/jscode2session?appid={appid}&secret={secret}&js_code={code}&grant_type=authorization_code"; var wechatResponse = await HttpClientExtensions.GetData <WeChatApi>(_client, _logger, url); if (!string.IsNullOrEmpty(wechatResponse.openid)) { _logger.LogInformation($"{funName},获取open - {wechatResponse.openid}"); result.success = true; result.msg = "获取OpenId成功"; result.response = wechatResponse; } else { result.success = false; result.msg = "获取OpenId失败"; _logger.LogError($"{funName}:获取OpenId失败"); } } catch (Exception ex) { result.success = false; result.msg = funName + "调用外部接口异常:。" + ex.Message; _logger.LogError(ex, (string)$"{funName}调用外部接口异常:{ex.Message}"); } return(result); }
public static async Task <List <TimelineTweet> > GetTimelineByWebAsync(string screenName) { using (var client = HttpClientExtensions.CreateClient(referer: "https://twitter.com/" + screenName, useGZip: true)) { client.DefaultRequestHeaders.Accept.ParseAdd("application/json, text/javascript, */*; q=0.01"); client.DefaultRequestHeaders.Add("x-previous-page-name", "profile"); client.DefaultRequestHeaders.Add("x-twitter-active-user", "yes"); var json = JToken.Parse(await client.GetStringAsync( $"https://twitter.com/i/profiles/show/{screenName}/timeline/tweets?include_available_features=1&include_entities=1&reset_error_state=false")); var doc = new HtmlDocument(); doc.LoadHtml(json["items_html"].ToString()); return((from liNode in doc.DocumentNode.ChildNodes.Where(v => v.Name == "li") let pinned = liNode.Attributes.First(v => v.Name == "class").Value.Trim().EndsWith("pinned") let id = long.Parse(liNode.Attributes.First(v => v.Name == "data-item-id").Value) let div = liNode.ChildNodes.First(v => v.Name == "div").ChildNodes.Last(v => v.Name == "div") let content = div.ChildNodes.First(v => v.Name == "div" && v.Attributes.Any(att => att.Value == "js-tweet-text-container")) .InnerText .Trim() select new TimelineTweet() { Id = id, Pinned = pinned, ScreenName = screenName, Retweeted = liNode.ChildNodes.First(v => v.Name == "div").ChildNodes.First(v => v.Name == "div") .InnerText.Contains("Retweeted"), Content = content }).ToList()); } }
public async Task PostAsync_settings_OKAsync() { //_uri.Path = "api/account/settings"; await _client.LogInAsync(); var response = await _client.PostAsync("api/account/settings", HttpClientExtensions.CreateJsonString(_settings)); response.EnsureSuccessStatusCode(); // _uri.Path = "api/profile/159489"; response = await _client.GetAsync("api/profile/159489"); response.EnsureSuccessStatusCode(); var str = await response.Content.ReadAsStringAsync(); var d = JObject.Parse(str); var tutor = d["tutor"]?.Value <JObject>() ?? throw new ArgumentNullException("d[\"tutor\"]?.Value<JObject>()"); var firstName = d["firstName"]?.Value <string>(); var lastName = d["lastName"]?.Value <string>(); var price = tutor["price"]?.Value <decimal>(); firstName.Should().Be("Tester"); lastName.Should().Be("User"); price.Should().Be(55M); }
public async Task PostAsync_Chat_Read_OKAsync() { await _client.LogInAsync(); //_uri.Path = "api/chat"; object msg = new { message = "Hi", otherUser = 160171 }; object otherUser = new { email = "*****@*****.**", password = "******" }; object read = new { otherUserId = 159039 }; var response = await _client.PostAsync("api/chat", HttpClientExtensions.CreateJsonString(msg)); response.EnsureSuccessStatusCode(); var str = await response.Content.ReadAsStringAsync(); if (!string.IsNullOrEmpty(str)) { str.IsValidJson().Should().BeTrue("the invalid string is {0}", str); } //_uri.Path = "api/login"; response = await _client.PostAsync("api/login", HttpClientExtensions.CreateJsonString(otherUser)); response.EnsureSuccessStatusCode(); str = await response.Content.ReadAsStringAsync(); if (!string.IsNullOrEmpty(str)) { str.IsValidJson().Should().BeTrue("the invalid string is {0}", str); } // _uri.Path = "api/chat/read"; response = await _client.PostAsync("api/chat/read", HttpClientExtensions.CreateJsonString(read)); response.EnsureSuccessStatusCode(); str = await response.Content.ReadAsStringAsync(); if (!string.IsNullOrEmpty(str)) { str.IsValidJson().Should().BeTrue("the invalid string is {0}", str); } }
public async Task <User> UpdateObject(User updateuser) { User user = new User(); try { #region "Set Updateuser User" UpdateUser upuser = new UpdateUser(); upuser.externalId = updateuser.externalId; upuser.password = updateuser.password; upuser.userName = updateuser.userName; upuser.studentId = updateuser.studentId; //user.educationLevel = string.Empty; //user.gender = string.Empty; //user.birthDate = string.Empty; upuser.systemRoleIds = updateuser.systemRoleIds; upuser.availability = updateuser.availability; upuser.name = updateuser.name; //job.title = string.Empty; //job.department = string.Empty; //job.company = string.Empty; upuser.job = updateuser.job; upuser.contact = updateuser.contact; upuser.address = updateuser.address; upuser.locale = updateuser.locale; #endregion var json = JsonConvert.SerializeObject(upuser); var body = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage response = await HttpClientExtensions.PatchAsync(client, Constants.HOSTNAME + Constants.USER_PATH + "/externalId:" + Constants.USER_ID, body); Constants.RESPONSERESULT = "Fail"; if (response.IsSuccessStatusCode) { Debug.WriteLine(@" User successfully updated."); if (response.IsSuccessStatusCode) { var content = await response.Content.ReadAsStringAsync(); user = JsonConvert.DeserializeObject <User>(content); Constants.RESPONSERESULT = "Update"; } } } catch (Exception ex) { Debug.WriteLine(@" ERROR {0}", ex.Message); } return(user); }
public static async Task <VtuberDatabaseEntity[]> GetDatabaseEntitiesAsync() { using (var client = HttpClientExtensions.CreateClient()) { var json = JToken.Parse(await client.GetStringAsync("https://vdb.vtbs.moe/json/list.json")); return(json["vtbs"].ToObject <VtuberDatabaseEntity[]>()); } }
public async Task Ask_Course_Without_UniAsync() { await _client.PostAsync("api/login", HttpClientExtensions.CreateJsonString(_credentials)); var response = await _client.PostAsync("api/question", HttpClientExtensions.CreateJsonString(_question)); response.EnsureSuccessStatusCode(); }
public static async Task <BilibiliUser> GetBilibiliUserAsync(long userId) { using (var client = HttpClientExtensions.CreateClient(useGZip: true)) { var json = JObject.Parse(await client.GetStringAsync(Sign("https://api.bilibili.com/x/space/app/index", new { mid = userId }))); return(json["data"]["info"].ToObject <BilibiliUser>()); } }
public async Task PostAsync_Upload_Regular_FileNameAsync() { await _client.LogInAsync(); var response = await _client.PostAsync(_uri.Path + "/upload", HttpClientExtensions.CreateJsonString(_doc1)); response.EnsureSuccessStatusCode(); }
public void ThrowIfStatusNotSuccessfulTest() { //Arrange HttpResponseMessage response = null; // TODO: Initialize to an appropriate value //Act and Assert. ExceptionHelper.AssertThrows <Exception>(() => HttpClientExtensions.ThrowIfStatusNotSuccessful(response)); }
protected RepositoryBaseOnline(HttpClientExtensions httpClient, IHttpResilientClient httpClientResilientClient) { _httpClient = httpClient; _httpClientResilientClient = httpClientResilientClient; _httpClient.ClearHeaderValue(); _httpClient.SetApplicationMediaType(WebAPIKeys.ApplicationMediaType); //_httpClient.SetApplicationAuthorization(TokenType.AccessToken, WebAPIKeys.CurrentToken); }