protected virtual async Task <HttpClient> CreateClientAsync(Request request)
{
string name;
if (UseProxy)
{
var proxy = await _proxyService.GetAsync(request.Timeout);
if (proxy == null)
{
throw new SpiderException("获取代理失败");
}
name = $"{Const.ProxyPrefix}{proxy}";
}
else
{
name = request.RequestUri.Host;
}
return(HttpClientFactory.CreateClient(name));
}
private async Task HandleSelected(ChangeEventArgs changeEventArgs)
{
foreach (var file in await FileReaderService.CreateReference(_input).EnumerateFilesAsync())
{
if (file == null)
{
continue;
}
var fileInfo = await file.ReadFileInfoAsync();
await using var ms = await file.CreateMemoryStreamAsync(4 * 1024);
var content = new MultipartFormDataContent();
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data");
content.Add(new StreamContent(ms, Convert.ToInt32(ms.Length)), "image", fileInfo.Name);
ImgUrl = await Repository.UploadAdImage(content, HttpClientFactory.CreateClient(Configuration["Service:Api:AnonymousApiName"]),
NavigationManager);
Console.WriteLine($"Upload Ad Image {ImgUrl}");
await OnChange.InvokeAsync(ImgUrl);
}
}
public List <string> GetForecast(
int zipcode,
DateTime date,
TemperatureTypeEnum temperatureType,
ForecastTypeEnum forecastType)
{
try
{
CheckParametersValid(zipcode, date, temperatureType, forecastType);
}
catch (ArgumentException ae)
{
//ToDo Fehlermeldung an UI
}
// = "Orchestrierung", ruft Methoden auf ohne zu wissen, woher bspw. Parameter herkommen
// Funktionales Programmieren
_temperatureStrategy = TemperatureStrategyFactory.GetTemperatureStrategy(temperatureType);
// Exercise: New Provider (e.g. Random) and change next Line to see if it still work
IWeatherForecastProvider weatherForecastProvider = new OpenWeatherAPI(HttpClientFactory.CreateClient(), "a1fcc507923163ff1bae113a80d8f82a");
WeatherForecast weatherForecast = new WeatherForecast(weatherForecastProvider);
_forecastStrategy = ForecastStrategyFactory.GetForecastStrategy(forecastType, weatherForecast);
List <string> result = new List <string>();
try
{
result = _forecastStrategy.GetForecast(zipcode, _temperatureStrategy, date);
}
catch (ZipNotFoundException ex)
{
result.Add(ex.Message);
}
catch (Exception ex)
{
result.Add($"Exception: {ex.Message}");
}
return(result);
}
public async Task JumboAsync(
[Summary("The emoji to jumbofy.")]
string emoji)
{
string emojiUrl;
if (Emote.TryParse(emoji, out var found))
{
emojiUrl = found.Url;
}
else
{
var codepoint = char.ConvertToUtf32(emoji, 0);
var codepointHex = codepoint.ToString("X").ToLower();
emojiUrl = $"https://raw.githubusercontent.com/twitter/twemoji/gh-pages/2/72x72/{codepointHex}.png";
}
try
{
var client = HttpClientFactory.CreateClient();
var req = await client.GetStreamAsync(emojiUrl);
await Context.Channel.SendFileAsync(req, Path.GetFileName(emojiUrl), Context.User.Mention);
try
{
await Context.Message.DeleteAsync();
}
catch (HttpRequestException)
{
Log.Information("Couldn't delete message after jumbofying.");
}
}
catch (HttpRequestException)
{
await ReplyAsync($"Sorry {Context.User.Mention}, I don't recognize that emoji.");
}
}
public async Task <HttpResponseMessage> ExecuteStatementAsync(string ksql)
{
try
{
using (var httpClient = httpClientFactory.CreateClient())
{
var statement = new KSqlStatement
{
ksql = ksql
};
var json = JsonSerializer.Serialize(statement);
var data = new StringContent(json, Encoding.UTF8, "application/json");
httpClient.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/vnd.ksql.v1+json"));
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, "/ksql")
{
Content = data
};
var cancellationToken = new CancellationToken();
var httpResponseMessage = await httpClient.SendAsync(httpRequestMessage,
HttpCompletionOption.ResponseHeadersRead,
cancellationToken);
return(httpResponseMessage);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
protected virtual async Task <IdentityModelDiscoveryDocumentCacheItem> GetDiscoveryResponse(IdentityClientConfiguration configuration)
{
var tokenEndpointUrlCacheKey = CalculateDiscoveryDocumentCacheKey(configuration);
var discoveryDocumentCacheItem = await DiscoveryDocumentCache.GetAsync(tokenEndpointUrlCacheKey);
if (discoveryDocumentCacheItem == null)
{
DiscoveryDocumentResponse discoveryResponse;
using (var httpClient = HttpClientFactory.CreateClient(HttpClientName))
{
var request = new DiscoveryDocumentRequest
{
Address = configuration.Authority,
Policy =
{
RequireHttps = configuration.RequireHttps
}
};
IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage?.Invoke(request);
discoveryResponse = await httpClient.GetDiscoveryDocumentAsync(request);
}
if (discoveryResponse.IsError)
{
throw new AbpException($"Could not retrieve the OpenId Connect discovery document! " +
$"ErrorType: {discoveryResponse.ErrorType}. Error: {discoveryResponse.Error}");
}
discoveryDocumentCacheItem = new IdentityModelDiscoveryDocumentCacheItem(discoveryResponse.TokenEndpoint, discoveryResponse.DeviceAuthorizationEndpoint);
await DiscoveryDocumentCache.SetAsync(tokenEndpointUrlCacheKey, discoveryDocumentCacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(configuration.CacheAbsoluteExpiration)
});
}
return(discoveryDocumentCacheItem);
}
protected override async Task OnInitializedAsync()
{
CurrentCulture = CultureInfo.CurrentCulture.DisplayName;
var authState = await authenticationStateTask;
var user = authState.User;
var httpClient = HttpClientFactory.CreateClient(Configuration["Service:Api:ApiName"]);
await httpClient.PostAsJsonAsync <EventTrackingItem>("api/EventTracker", new EventTrackingItem
{
Category = "Subscription",
Key = "start",
CreatedDate = DateTime.UtcNow,
Id = Guid.NewGuid(),
UserId = user.FindFirstValue(ClaimTypes.NameIdentifier)
});
var subscriptionPacks = await httpClient.GetAsync("api/SubPack/GetAll");
if (subscriptionPacks.IsSuccessStatusCode)
{
var json = await subscriptionPacks.Content.ReadAsStringAsync();
listSubscriptionPack = JsonConvert.DeserializeObject <List <SubscriptionPack> >(json);
}
await httpClient.PostAsJsonAsync <EventTrackingItem>("api/EventTracker", new EventTrackingItem
{
Category = "Subscription",
Key = "Start",
CreatedDate = DateTime.UtcNow,
Id = Guid.NewGuid(),
UserId = user.FindFirstValue(ClaimTypes.NameIdentifier)
});
await base.OnInitializedAsync();
}
public override async Task <EntityOperationResult <CurrencyDto> > Handle(DateTime date)
{
Logger.LogInformation("building url to get html data.");
var dateUrl = System.Web.HttpUtility.UrlEncode($"{date:dd/MM/yyyy}");
var uri = new Uri(ServiceSettings.Url + "&fecha=" + dateUrl);
Logger.LogInformation("Building http request with url {uri}", uri);
var httpRequest = new HttpRequestMessage
{
RequestUri = uri,
Method = new HttpMethod("GET")
};
Logger.LogInformation("Sending request to Bna server.");
var client = HttpClientFactory.CreateClient();
var httpResponse = await client.SendAsync(httpRequest).ConfigureAwait(false);
Logger.LogInformation("Getting Html content of the Bna.");
var htmlPage = await httpResponse.Content.ReadAsStringAsync();
return(await GetDataFromHtmlAsync(htmlPage, date));
}
public async Task <IEnumerable <ExternalEntityDto> > GetColors()
{
if (httpClient == null)
{
httpClient = HttpClientFactory.CreateClient("SoltaniHttpClient");
}
if (colors == null)
{
HttpResponseMessage result = await httpClient.GetAsync("GetParameter?type=20");
if (result.IsSuccessStatusCode)
{
colors = JsonConvert.DeserializeObject <IEnumerable <ExternalEntityDto> >(await result.Content.ReadAsStringAsync());
}
else
{
throw new Exception(result.ReasonPhrase);
}
}
return(colors);
}
public async Task <string> SendAsync(string url)
{
var client = HttpClientFactory.CreateClient();
var requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
var uri = new Uri(url, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
var baseUrl = string.Empty;
try
{
//Blazor tiered -- mode
var remoteServiceConfig = await RemoteServiceConfigurationProvider.GetConfigurationOrDefaultAsync("Default");
baseUrl = remoteServiceConfig.BaseUrl;
client.BaseAddress = new Uri(baseUrl);
AddHeaders(requestMessage);
await HttpClientAuthenticator.Authenticate(new RemoteServiceHttpClientAuthenticateContext(client,
requestMessage, new RemoteServiceConfiguration(baseUrl), string.Empty));
}
catch (AbpException) // Blazor-Server mode.
{
baseUrl = NavigationManager.BaseUri;
client.BaseAddress = new Uri(baseUrl);
foreach (var header in HttpContextAccessor.HttpContext.Request.Headers)
{
requestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray());
}
}
}
var response = await client.SendAsync(requestMessage);
return(await response.Content.ReadAsStringAsync());
}
private HttpClient GetDefaultClient(string endPointName)
{
return(HttpClientFactory.CreateClient(endPointName));
}
private HttpClient GetClient(Uri uri)
{
return(HttpClientFactory.CreateClient(uri.IsOnion() ? OnionNamedClient : ClearnetNamedClient));
}
public void CreateClient()
{
var testee = new HttpClientFactory();
testee.CreateClient().Should().NotBeNull();
}
/// <summary>
/// Execute the request (which is unguarded)
/// </summary>
/// <param name="request">The request to execute</param>
/// <param name="ct">The cancellation token to use</param>
/// <returns>The <see cref="IHttpResponseMessage"/> for the request</returns>
protected async Task <IHttpResponseMessage> ExecuteRequest(IRestRequest request, CancellationToken ct)
{
AddDefaultParameters(request);
while (true)
{
if (Authenticator != null && Authenticator.CanPreAuthenticate(this, request, Credentials))
{
await Authenticator.PreAuthenticate(this, request, Credentials);
}
// Lazy initialization of the HTTP client
if (_httpClient == null)
{
_httpClient = HttpClientFactory.CreateClient(this, request);
}
bool failed = true;
var message = HttpClientFactory.CreateRequestMessage(this, request);
try
{
var bodyData = GetContent(request);
if (bodyData != null)
{
message.Content = bodyData;
}
if (message.Content != null)
{
var content = message.Content;
foreach (var param in request.Parameters.Where(x => x.Type == ParameterType.HttpHeader && x.IsContentParameter()))
{
if (content.Headers.Contains(param.Name))
{
content.Headers.Remove(param.Name);
}
if (param.ValidateOnAdd)
{
content.Headers.Add(param.Name, param.ToRequestString());
}
else
{
content.Headers.TryAddWithoutValidation(param.Name, param.ToRequestString());
}
}
}
ModifyRequestBeforeAuthentication(_httpClient, message);
if (Authenticator != null && Authenticator.CanPreAuthenticate(_httpClient, message, Credentials))
{
await Authenticator.PreAuthenticate(_httpClient, message, Credentials);
}
var response = await _httpClient.SendAsync(message, ct);
try
{
if (!response.IsSuccessStatusCode)
{
if (Authenticator != null && Authenticator.CanHandleChallenge(_httpClient, message, Credentials, response))
{
await Authenticator.HandleChallenge(_httpClient, message, Credentials, response);
continue;
}
if (!IgnoreResponseStatusCode)
{
response.EnsureSuccessStatusCode();
}
}
failed = false;
}
finally
{
if (failed)
{
if (response != null)
{
response.Dispose();
}
else
{
message.Dispose();
}
message = null;
}
}
return(response);
}
finally
{
if (failed && message != null)
{
message.Dispose();
}
}
}
}
protected override async Task OnParametersSetAsync()
{
var authState = await authenticationStateTask;
User = authState.User;
var httpClient = HttpClientFactory.CreateClient(Configuration["Service:Api:AnonymousApiName"]);
if (User.Identity.IsAuthenticated)
{
if (string.IsNullOrEmpty(ProfileId))
{
ProfileId = User.FindFirstValue(ClaimTypes.NameIdentifier);
}
await httpClient.PostAsJsonAsync <EventTrackingItem>("api/EventTracker", new EventTrackingItem
{
Category = "Navigation",
Key = $"ViewProfile#{ProfileId}",
CreatedDate = DateTime.UtcNow,
Id = Guid.NewGuid(),
UserId = User.FindFirstValue(ClaimTypes.NameIdentifier)
});
}
else
{
await httpClient.PostAsJsonAsync <EventTrackingItem>("api/EventTracker", new EventTrackingItem
{
Category = "Navigation",
Key = $"ViewProfile#{ProfileId}",
CreatedDate = DateTime.UtcNow,
Id = Guid.NewGuid()
});
}
var apiUrl = $"/api/viewProfile/{ProfileId}";
var uri = Navigation.ToAbsoluteUri(Navigation.Uri);
if (QueryHelpers.ParseQuery(uri.Query).TryGetValue("social", out var _social))
{
apiUrl += $"?social={_social}";
await httpClient.PostAsJsonAsync <EventTrackingItem>("api/EventTracker", new EventTrackingItem
{
UserId = UserProfile?.Id,
Category = "Navigation",
Key = $"ViewProfileFromSocial#{_social}",
CreatedDate = DateTime.UtcNow,
Id = Guid.NewGuid()
});
}
var getProfile = await httpClient.GetAsync(apiUrl);
if (getProfile.StatusCode == System.Net.HttpStatusCode.NotFound)
{
Navigation.NavigateTo(Navigation.ToAbsoluteUri($"/Identity/Account/Register?PinCode={ProfileId}").ToString(), true);
}
getProfile.EnsureSuccessStatusCode();
var json = await getProfile.Content.ReadAsStringAsync();
UserProfile = Newtonsoft.Json.JsonConvert.DeserializeObject <ViewApplicationUser>(json);
NavigationUrlService.SetUrls($"https://www.google.com/maps/search/?api=1&query={UserProfile.Address},{UserProfile.City}%20{UserProfile.Country}&query_place_id={UserProfile.DisplayName}",
Navigation.ToAbsoluteUri($"/contact/import/{UserProfile.Id}").ToString());
NavigationUrlService.ShowImport = true;
if (User.Identity.IsAuthenticated)
{
NavigationUrlService.ShowContacts = true;
NavigationUrlService.ShowMyAds = true;
if (User.FindFirstValue(ClaimTypes.NameIdentifier).Equals(UserProfile.Id))
{
NavigationUrlService.ShowImport = false;
NavigationUrlService.ShowEditProfile = true;
}
}
await InvokeAsync(StateHasChanged);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
await base.ProcessAsync(context, output);
// ignore, if already has integrity
if (context.AllAttributes.ContainsName("integrity"))
{
return;
}
// get resource address
var attribute = context.TagName switch
{
"script" => context.AllAttributes["src"],
"link" => context.AllAttributes["href"],
_ => throw new NotSupportedException($"Tag '{context.TagName}' is not supported for sub-resource integrity.")
};
var content = attribute.Value switch
{
string value => value,
HtmlString htmlString => htmlString.Value,
_ => null
};
if (content == null)
{
return;
}
if (content.StartsWith("//", StringComparison.OrdinalIgnoreCase))
{
content = ViewContext.HttpContext.Request.Scheme + ":" + content;
}
// ignore same site
if (!content.Contains("://", StringComparison.OrdinalIgnoreCase))
{
return;
}
// ignore malformed URIs
if (!Uri.TryCreate(content, UriKind.Absolute, out var uri))
{
return;
}
// calculate hash or get from cache
var key = $"SRI_{content}";
var integrity = await MemoryCache.GetOrCreateAsync(key, async cacheEntry =>
{
cacheEntry.SetAbsoluteExpiration(DateTimeOffset.MaxValue);
cacheEntry.SetPriority(CacheItemPriority.High);
using var http = HttpClientFactory.CreateClient();
try
{
using var stream = await http.GetStreamAsync(uri);
using var hashAlgorithm = SHA256.Create();
var hash = await hashAlgorithm.ComputeHashAsync(stream);
var encoded = Convert.ToBase64String(hash);
var value = $"sha256-{encoded}";
return(value);
}
catch (HttpRequestException ex)
{
Logger.LogWarning(ex, ex.Message);
return(null);
}
});
if (integrity == null)
{
return;
}
output.Attributes.Add("integrity", integrity);
output.Attributes.Add("crossorigin", "anonymous");
}
}
protected HttpClient GetClient()
{
return(HttpClientFactory.CreateClient(HttpClientName));
}
public async Task <AuthenticationResult> Authentication(string code)
{
var hc = HttpClientFactory.CreateClient("DiscordApp");
var clientSecret = Configuration.GetValue <string>("DiscordClientSeclet");
if (string.IsNullOrEmpty(clientSecret))
{
return(await StubAuthentication());
}
var form = new Dictionary <string, string>();
form.Add("client_id", StaticSettings.DiscordAppClientId);
form.Add("client_secret", clientSecret);
form.Add("grant_type", "authorization_code");
form.Add("redirect_uri", GetRedirectUrl());
form.Add("code", code);
form.Add("scope ", "identify guilds webhook.incoming");
var formContent = new FormUrlEncodedContent(form);
var c = await hc.PostAsync("https://discordapp.com/api/oauth2/token", formContent);
var json = await c.Content.ReadAsStringAsync();
var tokenInfo = Newtonsoft.Json.JsonConvert.DeserializeObject <DiscordTokenTokenInfo>(json);
//該当ユーザーがVETメンバーなのかのチェック
var memberInfo = await GetVetMember(tokenInfo.access_token);
if (!memberInfo.isVetMember)
{
return(new AuthenticationResult
{
IsAuthenticated = false
});
}
var user = memberInfo.user;
var entity = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == user.Id);
if (entity == null)
{
entity = await JoinUser(user);
}
else
{
entity.AvatarId = user.AvatarId;
entity.DiscordId = user.Id;
entity.Name = user.Username;
}
DbContext.SaveChanges();
#if DEBUG
// entity = DbContext.VetMembers.Find(12);
#endif
return(new AuthenticationResult
{
IsAuthenticated = true,
User = entity
});
}
protected override async Task OnParametersSetAsync()
{
var client = HttpClientFactory.CreateClient("ServerAPI.NonAuthorized");
Contract = await client.GetFromJsonAsync <ContractDetailVm>($"api/contract/{Id}");
}
public async Task InspectAsync(ResponseAnalysisContext context, CancellationToken cancellationToken)
{
if (context.IsHtml())
{
var html = context.ReadAsString();
// find all script tags
foreach (var index in FastHtmlParser.FindAllTagIndexes(html, "script"))
{
// get 'src' attribute
var src = FastHtmlParser.GetAttributeValueAtTag(html, "src", index);
if (src.IndexOf(':') != -1 || src.StartsWith("//", StringComparison.Ordinal))
{
// check whether there is an 'integrity' attribute alrady
var integrity = FastHtmlParser.GetAttributeValueAtTag(html, "integrity", index);
if (integrity.Length > 0)
{
continue;
}
// compute integrity
var sri = await MemoryCache.GetOrCreateAsync($"SRI_{src}", async ce =>
{
ce.SetAbsoluteExpiration(DateTimeOffset.MaxValue);
ce.SetPriority(CacheItemPriority.High);
var client = HttpClientFactory.CreateClient();
try
{
// download script
using var request = new HttpRequestMessage(HttpMethod.Get, RelativeTo(src).ToString());
request.Headers.TryAddWithoutValidation("Origin", $"{context.HttpContext.Request.Scheme}://{context.HttpContext.Request.Host}");
using var response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(null);
}
if (response.Content == null)
{
return(null);
}
if (!response.Headers.Any(h => h.Key.StartsWith("Access-Control-Allow", StringComparison.OrdinalIgnoreCase)))
{
return(null);
}
var stream = await response.Content.ReadAsStreamAsync();
// compute hash
var hash = HashAlgorithmPool.Sha256.ComputeHash(stream);
var base64 = Convert.ToBase64String(hash);
return($"sha256-{base64}");
}
catch (HttpRequestException)
{
return(null);
}
});
// add attribute
if (sri != null)
{
context.AddChange(FastHtmlParser.CreateInsertAttributeChange(html, index, "script", "integrity", sri));
if (FastHtmlParser.GetAttributeValueAtTag(html, "crossorigin", index).Length == 0)
{
context.AddChange(FastHtmlParser.CreateInsertAttributeChange(html, index, "script", "crossorigin", "anonymous"));
}
}
}
}
}
}
public virtual async Task <ReGeocodeLocation> InverseAsync(AmapInverseHttpRequestParamter requestParamter)
{
if (requestParamter.Locations.Length > 20)
{
var localizer = ServiceProvider.GetRequiredService <IStringLocalizer <AmapLocationResource> >();
var localizerError = localizer["SupportsResolveAddress", 20];
localizerError = localizer["ResolveLocationFailed", localizerError];
if (Options.VisableErrorToClient)
{
throw new UserFriendlyException(localizerError);
}
throw new AbpException($"Resolution address failed:{localizerError}!");
}
var client = HttpClientFactory.CreateClient(AmapHttpConsts.HttpClientName);
var requestUrlBuilder = new StringBuilder(128);
requestUrlBuilder.Append("http://restapi.amap.com/v3/geocode/regeo");
requestUrlBuilder.AppendFormat("?key={0}", Options.ApiKey);
requestUrlBuilder.AppendFormat("&batch={0}", requestParamter.Batch);
requestUrlBuilder.AppendFormat("&output={0}", requestParamter.Output);
requestUrlBuilder.AppendFormat("&radius={0}", requestParamter.Radius);
requestUrlBuilder.AppendFormat("&extensions={0}", requestParamter.Extensions);
requestUrlBuilder.AppendFormat("&homeorcorp={0}", requestParamter.HomeOrCorp);
requestUrlBuilder.AppendFormat("&location=");
for (int i = 0; i < requestParamter.Locations.Length; i++)
{
requestUrlBuilder.AppendFormat("{0},{1}", Math.Round(requestParamter.Locations[i].Longitude, 6),
Math.Round(requestParamter.Locations[i].Latitude, 6));
if (i < requestParamter.Locations.Length - 1)
{
requestUrlBuilder.Append("|");
}
}
if (!requestParamter.PoiType.IsNullOrWhiteSpace())
{
requestUrlBuilder.AppendFormat("&poitype={0}", requestParamter.PoiType);
}
if (!requestParamter.PoiType.IsNullOrWhiteSpace())
{
requestUrlBuilder.AppendFormat("&poitype={0}", requestParamter.PoiType);
}
if (!requestParamter.Sig.IsNullOrWhiteSpace())
{
requestUrlBuilder.AppendFormat("&sig={0}", requestParamter.Sig);
}
if (requestParamter.RoadLevel.HasValue)
{
requestUrlBuilder.AppendFormat("&roadlevel={0}", requestParamter.RoadLevel);
}
var requestMessage = new HttpRequestMessage(HttpMethod.Get, requestUrlBuilder.ToString());
var response = await client.SendAsync(requestMessage, GetCancellationToken());
if (!response.IsSuccessStatusCode)
{
throw new AbpException($"Amap request service returns error! HttpStatusCode: {response.StatusCode}, ReasonPhrase: {response.ReasonPhrase}");
}
var resultContent = await response.Content.ReadAsStringAsync();
var amapResponse = JsonSerializer.Deserialize <AmapInverseLocationResponse>(resultContent);
if (!amapResponse.IsSuccess())
{
var localizerFactory = ServiceProvider.GetRequiredService <IStringLocalizerFactory>();
var localizerError = amapResponse.GetErrorMessage().Localize(localizerFactory);
if (Options.VisableErrorToClient)
{
var localizer = ServiceProvider.GetRequiredService <IStringLocalizer <AmapLocationResource> >();
localizerError = localizer["ResolveLocationFailed", localizerError];
throw new UserFriendlyException(localizerError);
}
throw new AbpException($"Resolution address failed:{localizerError}!");
}
var inverseLocation = new ReGeocodeLocation
{
Street = amapResponse.Regeocode.AddressComponent.StreetNumber.Street,
AdCode = amapResponse.Regeocode.AddressComponent.AdCode,
Address = amapResponse.Regeocode.Address,
City = amapResponse.Regeocode.AddressComponent.City.JoinAsString(","),
Country = amapResponse.Regeocode.AddressComponent.Country,
District = amapResponse.Regeocode.AddressComponent.District,
Number = amapResponse.Regeocode.AddressComponent.StreetNumber.Number,
Province = amapResponse.Regeocode.AddressComponent.Province,
Town = amapResponse.Regeocode.AddressComponent.TownShip.JoinAsString(" ")
};
return(inverseLocation);
}
public virtual async Task <GecodeLocation> PositiveAsync(AmapPositiveHttpRequestParamter requestParamter)
{
var client = HttpClientFactory.CreateClient(AmapHttpConsts.HttpClientName);
var requestUrlBuilder = new StringBuilder(128);
requestUrlBuilder.Append("http://restapi.amap.com/v3/geocode/geo");
requestUrlBuilder.AppendFormat("?key={0}", Options.ApiKey);
requestUrlBuilder.AppendFormat("&address={0}", requestParamter.Address);
if (!requestParamter.City.IsNullOrWhiteSpace())
{
requestUrlBuilder.AppendFormat("&city={0}", requestParamter.City);
}
if (!requestParamter.Output.IsNullOrWhiteSpace())
{
requestUrlBuilder.AppendFormat("&output={0}", requestParamter.Output);
}
if (!requestParamter.Sig.IsNullOrWhiteSpace())
{
requestUrlBuilder.AppendFormat("&sig={0}", requestParamter.Sig);
}
requestUrlBuilder.AppendFormat("&batch={0}", requestParamter.Batch);
var requestMessage = new HttpRequestMessage(HttpMethod.Get, requestUrlBuilder.ToString());
var response = await client.SendAsync(requestMessage, GetCancellationToken());
if (!response.IsSuccessStatusCode)
{
throw new AbpException($"Amap request service returns error! HttpStatusCode: {response.StatusCode}, ReasonPhrase: {response.ReasonPhrase}");
}
var resultContent = await response.Content.ReadAsStringAsync();
var amapResponse = JsonSerializer.Deserialize <AmapPositiveHttpResponse>(resultContent);
if (!amapResponse.IsSuccess())
{
var localizerFactory = ServiceProvider.GetRequiredService <IStringLocalizerFactory>();
var localizerError = amapResponse.GetErrorMessage().Localize(localizerFactory);
if (Options.VisableErrorToClient)
{
var localizer = ServiceProvider.GetRequiredService <IStringLocalizer <AmapLocationResource> >();
localizerError = localizer["ResolveLocationFailed", localizerError];
throw new UserFriendlyException(localizerError);
}
throw new AbpException($"Resolution address failed:{localizerError}!");
}
if (amapResponse.Count <= 0)
{
var localizer = ServiceProvider.GetRequiredService <IStringLocalizer <AmapLocationResource> >();
var localizerError = localizer["ResolveLocationZero"];
if (Options.VisableErrorToClient)
{
throw new UserFriendlyException(localizerError);
}
throw new AbpException(localizerError);
}
var locations = amapResponse.Geocodes[0].Location.Split(",");
var postiveLocation = new GecodeLocation
{
Longitude = double.Parse(locations[0]),
Latitude = double.Parse(locations[1]),
Level = amapResponse.Geocodes[0].Level
};
postiveLocation.AddAdditional("Geocodes", amapResponse.Geocodes);
return(postiveLocation);
}
public Task GW2Wiki(CommandContext commandContext, [RemainingText] string searchTerm)
{
return(InvokeAsync(commandContext,
async commandContextContainer =>
{
var embedBuilder = new DiscordEmbedBuilder
{
Color = DiscordColor.Green
};
embedBuilder.WithTitle(LocalizationGroup.GetText("SearchResults", "Search results"));
var client = HttpClientFactory.CreateClient();
using (var response = await client.GetAsync(QueryHelpers.AddQueryString("https://wiki.guildwars2.com/api.php",
new Dictionary <string, string>
{
["action"] = "query",
["srwhat"] = "title",
["list"] = "search",
["format"] = "json",
["srsearch"] = searchTerm,
}))
.ConfigureAwait(false))
{
var jsonResult = await response.Content
.ReadAsStringAsync()
.ConfigureAwait(false);
var stringBuilder = new StringBuilder(1024);
var searchResult = JsonConvert.DeserializeObject <SearchQueryRoot>(jsonResult);
if (searchResult?.Query?.Search?.Count > 0)
{
foreach (var result in searchResult.Query.Search)
{
var current = "> " + Formatter.MaskedUrl(result.Title, new Uri("https://wiki.guildwars2.com/?curid=" + result.PageId)) + "\n";
if (current.Length + stringBuilder.Length > stringBuilder.Capacity)
{
break;
}
stringBuilder.Append(current);
}
}
stringBuilder.Append("\u200B");
embedBuilder.AddField(LocalizationGroup.GetText("TitleSearch", "Title search"), stringBuilder.ToString());
}
using (var response = await client.GetAsync(QueryHelpers.AddQueryString("https://wiki.guildwars2.com/api.php",
new Dictionary <string, string>
{
["action"] = "query",
["srwhat"] = "text",
["list"] = "search",
["format"] = "json",
["srsearch"] = searchTerm,
}))
.ConfigureAwait(false))
{
var jsonResult = await response.Content
.ReadAsStringAsync()
.ConfigureAwait(false);
var stringBuilder = new StringBuilder(1024);
var searchResult = JsonConvert.DeserializeObject <SearchQueryRoot>(jsonResult);
if (searchResult?.Query?.Search?.Count > 0)
{
foreach (var result in searchResult.Query.Search)
{
var current = "> " + Formatter.MaskedUrl(result.Title, new Uri("https://wiki.guildwars2.com/?curid=" + result.PageId)) + "\n";
if (current.Length + stringBuilder.Length > stringBuilder.Capacity)
{
break;
}
stringBuilder.Append(current);
}
}
stringBuilder.Append("\u200B");
embedBuilder.AddField(LocalizationGroup.GetText("TextSearch", "Text search"), stringBuilder.ToString());
}
embedBuilder.WithThumbnail("https://media.discordapp.net/attachments/847555191842537552/861182143987712010/gw2.png");
embedBuilder.WithFooter("Scruffy", "https://cdn.discordapp.com/app-icons/838381119585648650/823930922cbe1e5a9fa8552ed4b2a392.png?size=64");
embedBuilder.WithTimestamp(DateTime.Now);
await commandContextContainer.Message
.RespondAsync(embedBuilder)
.ConfigureAwait(false);
}));
}
public async Task Connect(string name = "")
{
if (string.IsNullOrEmpty(name))
{
name = Option.CurrentRemote;
}
Logger.LogInformation($"Connect to remote {name}.");
if (Option.Remotes.TryGetValue(name, out var remote))
{
Logger.LogInformation($"Detect remote {remote.Name} ({Enum.GetName(typeof(RemoteType), remote.Type)}).");
switch (remote.Type)
{
case RemoteType.LocalFS:
Remote = new FileSystemBlogService(
new PhysicalFileProvider(remote.Uri).AsFileProvider());
break;
case RemoteType.RemoteFS:
{
var client = HttpClientFactory.CreateClient();
client.BaseAddress = new Uri(remote.Uri);
Remote = new FileSystemBlogService(
new HttpFileProvider(client));
}
break;
case RemoteType.Api:
{
var client = HttpClientFactory.CreateClient();
client.BaseAddress = new Uri(remote.Uri);
Remote = new ApiBlogService(client);
}
break;
case RemoteType.Git:
{
FSBuilder builder = new FSBuilder(Environment.CurrentDirectory);
Logger.LogInformation("Pull git repository.");
try
{
using var repo = new Repository(GitTempFolder);
// Credential information to fetch
LibGit2Sharp.PullOptions options = new LibGit2Sharp.PullOptions();
// User information to create a merge commit
var signature = new LibGit2Sharp.Signature(
new Identity("AcBlog.Tools.Sdk", "tools.sdk@acblog"), DateTimeOffset.Now);
// Pull
LibGit2Sharp.Commands.Pull(repo, signature, options);
}
catch
{
builder.EnsureDirectoryEmpty(GitTempFolder);
Repository.Clone(remote.Uri, GitTempFolder);
}
Remote = new FileSystemBlogService(
new PhysicalFileProvider(Path.Join(Environment.CurrentDirectory, GitTempFolder)).AsFileProvider());
}
break;
}
Remote.PostService.Context.Token = remote.Token;
Option.CurrentRemote = name;
await SaveOption();
}
else
{
throw new Exception("No remote");
}
}
protected HttpClient CreateClient() => HttpClientFactory?.CreateClient() ?? new HttpClient();
public async Task <Models.FileInfoResult> DownloadPackage(string packageFileName)
{
var httpClient = HttpClientFactory.CreateClient("PalaceServer");
httpClient.BaseAddress = new Uri(PalaceSettings.UpdateServerUrl);
var url = $"/api/microservices/download/{packageFileName}";
HttpResponseMessage response = null;
try
{
response = await httpClient.GetAsync(url);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
return(null);
}
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
Logger.LogWarning("response fail for download {0}", url);
return(null);
}
if (!response.Content.Headers.Contains("content-disposition"))
{
Logger.LogWarning("response fail for {0} header content-disposition not found", url);
return(null);
}
var contentDisposition = response.Content.Headers.GetValues("content-disposition").FirstOrDefault();
if (string.IsNullOrWhiteSpace(contentDisposition))
{
Logger.LogWarning("response fail for {0} header content-disposition empty", url);
return(null);
}
if (!System.IO.Directory.Exists(PalaceSettings.DownloadDirectory))
{
System.IO.Directory.CreateDirectory(PalaceSettings.DownloadDirectory);
}
var result = new Models.FileInfoResult();
result.ZipFileName = System.IO.Path.Combine(PalaceSettings.DownloadDirectory, contentDisposition.Split(';')[1].Split('=')[1]);
if (File.Exists(result.ZipFileName))
{
File.Delete(result.ZipFileName);
}
using (var fs = new System.IO.FileStream(result.ZipFileName, System.IO.FileMode.Create))
{
var stream = response.Content.ReadAsStreamAsync().Result;
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
int pos = 0;
while ((pos = stream.Read(buffer, 0, bufferSize)) > 0)
{
fs.Write(buffer, 0, pos);
}
fs.Close();
}
return(result);
}
/// <summary>
/// 发送请求数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="urlArguments">Url构造器</param>
/// <param name="method">请求类型</param>
/// <param name="contentCall">HttpContent请求内容</param>
/// <param name="mediaType">mediaType数据格式，请求格式和返回格式一致（JSON、MessagePack）</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
public virtual async Task <T> HttpSendAsync <T>(UrlArguments urlArguments, HttpMethod method, Func <HttpContent> contentCall, HttpMediaType mediaType = HttpMediaType.Json, CancellationToken cancellationToken = default)
where T : class, new()
{
HttpClient client = HttpClientFactory.CreateClient(string.IsNullOrEmpty(urlArguments.ClientName) ? "apiClient" : urlArguments.ClientName);
string requestUrl = urlArguments.Complete().Url;
string _mediaType = mediaType.Description();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(_mediaType));
HttpResponseMessage responseMessage = null;
if (client.BaseAddress == null)
{
HttpRequestMessage requestMessage = new HttpRequestMessage
{
Method = method,
RequestUri = new Uri(requestUrl)
};
foreach (var accept in client.DefaultRequestHeaders.Accept)
{
requestMessage.Headers.Accept.Add(accept);
}
requestMessage.Headers.Authorization = client.DefaultRequestHeaders.Authorization;
RequestHeaders(requestMessage.Headers);
requestMessage.Content = contentCall?.Invoke();
//if (requestMessage.Content != null)
// requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(_mediaType);
responseMessage = await client.SendAsync(requestMessage, cancellationToken);
}
else
{
RequestHeaders(client.DefaultRequestHeaders);
HttpContent content = contentCall?.Invoke();
//if (content != null)
// content.Headers.ContentType = new MediaTypeHeaderValue(_mediaType);
responseMessage = await SendAsync(client, requestUrl, method, content, cancellationToken);
}
switch (mediaType)
{
case HttpMediaType.MessagePack:
{
var res = await responseMessage.Content.ReadAsByteArrayAsync();
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"{client.BaseAddress}{requestUrl} MediaType：{_mediaType}，Method：{method.Method}，HttpMessage Read Byte Data Length：{res.Length}");
}
return(res.ToMsgPackObject <T>());
}
case HttpMediaType.MessagePackJackson:
{
var res = await responseMessage.Content.ReadAsStringAsync();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"{client.BaseAddress}{requestUrl} MediaType：{_mediaType}，Method：{method.Method}，HttpMessage Read Jackson Data：{res}");
}
return(res.ToMsgPackBytesFromJson().ToMsgPackObject <T>());
}
default:
{
var res = await responseMessage.Content.ReadAsStringAsync();
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"{client.BaseAddress}{requestUrl} MediaType：{_mediaType}，Method：{method.Method}，HttpMessage Read Json Data：{res}");
}
return(res.ToObject <T>());
}
}
}
protected virtual HttpClient CreateClient(Request request)
{
return(HttpClientFactory.CreateClient(request.RequestUri.Host));
}
public async Task DeleteBirthday(Person person)
{
using (var httpClient = HttpClientFactory.CreateClient()) {
await httpClient.DeleteAsync($"{BirthdayAPI}/{person.Id}");
}
}
protected override async Task OnInitializedAsync()
{
var client = HttpClientFactory.CreateClient("ServerAPI.NonAuthorized");
ContractsList = await client.GetFromJsonAsync <ContractsListVm>("api/contract");
}
