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);
}
