public async Task <ActionResult> Apply(Links links)
{
Uri uri = new Uri(links.Url);
using (HttpClient client = new HttpClient()
{
BaseAddress = uri
})
{
client.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("Mozilla/5.0"));
client.DefaultRequestHeaders.Referrer = Request.Url;
return(await await client.GetAsync(uri.PathAndQuery).ContinueWith(async t =>
{
if (t.IsFaulted || t.IsCanceled)
{
return ResultData(null, false, "添加失败！检测到您的网站疑似挂了，或者连接到你网站的时候超时，请检查下！");
}
var res = await t;
if (res.IsSuccessStatusCode)
{
var s = await res.Content.ReadAsStringAsync();
if (s.Contains(CommonHelper.GetSettings("Domain")))
{
bool b = LinksBll.AddOrUpdateSaved(l => l.Url, links) > 0;
return ResultData(null, b, b ? "添加成功！这可能有一定的延迟，如果没有看到您的链接，请稍等几分钟后刷新页面即可，如有疑问，请联系站长。" : "添加失败！这可能是由于网站服务器内部发生了错误，如有疑问，请联系站长。");
}
return ResultData(null, false, $"添加失败！检测到您的网站上未将本站设置成友情链接，请先将本站主域名：{CommonHelper.GetSettings("Domain")}在您的网站设置为友情链接，并且能够展示后，再次尝试添加即可！");
}
return ResultData(null, false, "添加失败！检测到您的网站疑似挂了！返回状态码为：" + res.StatusCode);
}));
}
}
public static void InitializeVssClientSettings(ProductInfoHeaderValue additionalUserAgent, IWebProxy proxy, IVssClientCertificateManager clientCert)
{
var headerValues = new List <ProductInfoHeaderValue>();
headerValues.Add(additionalUserAgent);
headerValues.Add(new ProductInfoHeaderValue($"({RuntimeInformation.OSDescription.Trim()})"));
if (VssClientHttpRequestSettings.Default.UserAgent != null && VssClientHttpRequestSettings.Default.UserAgent.Count > 0)
{
headerValues.AddRange(VssClientHttpRequestSettings.Default.UserAgent);
}
VssClientHttpRequestSettings.Default.UserAgent = headerValues;
VssClientHttpRequestSettings.Default.ClientCertificateManager = clientCert;
if (PlatformUtil.RunningOnLinux || PlatformUtil.RunningOnMacOS)
{
// The .NET Core 2.1 runtime switched its HTTP default from HTTP 1.1 to HTTP 2.
// This causes problems with some versions of the Curl handler.
// See GitHub issue https://github.com/dotnet/corefx/issues/32376
VssClientHttpRequestSettings.Default.UseHttp11 = true;
}
VssHttpMessageHandler.DefaultWebProxy = proxy;
}
private GitHubRelease LoadGitHubRelease()
{
using var cts = new CancellationTokenSource(DefaultTimeout);
var uri = new Uri($"https://api.github.com/repos/{Owner}/{Repository}/releases/latest");
using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri)
{
Headers =
{
Accept = { MediaTypeWithQualityHeaderValue.Parse("application/vnd.github.v3+json") },
UserAgent = { ProductInfoHeaderValue.Parse("Anything") }
}
};
using var httpResponseMessage = httpClient.Send(httpRequestMessage, cts.Token);
httpResponseMessage.EnsureSuccessStatusCode();
using var stream = httpResponseMessage.Content.ReadAsStream(cts.Token);
using var streamReader = new StreamReader(stream, Encoding.UTF8);
var content = streamReader.ReadToEnd();
var gitHubRelease = JsonConvert.DeserializeObject <GitHubRelease>(content);
return(gitHubRelease);
}
/// <summary>
/// Creates a new HTTP tracker.
/// </summary>
/// <param name="uri">The tracker URI.</param>
public HttpTracker(Uri uri)
: base(uri)
{
if (!string.Equals(uri.Scheme, "http", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("The URI-scheme is not HTTP or HTTPS.", "uri");
}
this.announceUri = uri;
this.scrapeUri = GetScrapeUri(uri);
this.key = GenerateRandomKey();
var assemblyVersion = AssemblyHelper.GetAssemblyVersion(typeof(HttpTracker));
var userAgentProductInfo = new ProductInfoHeaderValue("TorrentSwifter", assemblyVersion.ToString(3));
client = new HttpClient();
client.DefaultRequestHeaders.UserAgent.Add(userAgentProductInfo);
if (!string.IsNullOrEmpty(uri.UserInfo))
{
string userInfo = uri.UserInfo;
if (userInfo.IndexOf(':') != -1)
{
byte[] userInfoBytes = Encoding.ASCII.GetBytes(userInfo);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(userInfoBytes));
}
}
}
public static IConveyBuilder AddOcsClient(this IConveyBuilder builder, string sectionName = SectionName)
{
if (string.IsNullOrEmpty(sectionName))
{
sectionName = SectionName;
}
var ocsOptions = builder.GetOptions <OcsOptions>(sectionName);
if (string.IsNullOrEmpty(ocsOptions.InternalHttpClientName))
{
ocsOptions.InternalHttpClientName = "OcsClient";
}
builder.Services.AddSingleton(ocsOptions);
builder.Services.AddHttpClient(ocsOptions.InternalHttpClientName, c =>
{
c.BaseAddress = new Uri(ocsOptions.StorageUrl);
c.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("OcsClient"));
c.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
});
builder.Services.AddTransient <IRequestHandler, RequestHandler.RequestHandler>();
builder.Services.AddTransient <IOcsClient, OcsClient>();
builder.Services.AddTransient <IAuthManager, AuthManager>();
return(builder);
}
private async Task <string> GetUpdateUrl(string version)
{
if (_updateUrlCache.TryGetValue(version, out var url))
{
return(url);
}
var currentVersion = Assembly.GetExecutingAssembly().GetName().Version ?? new Version(1, 0);
var userAgent = new ProductInfoHeaderValue(AppName, currentVersion.ToString(3));
using var client = new HttpClient { BaseAddress = _updateUrls.BaseAddressForApiRequests() };
client.DefaultRequestHeaders.UserAgent.Add(userAgent);
var response = await client.GetAsync(_updateUrls.ListReleases());
response.EnsureSuccessStatusCode();
var releases = JsonConvert.DeserializeObject <List <Release> >(await response.Content.ReadAsStringAsync());
var release = releases
.Where(x => string.IsNullOrEmpty(version) || x.HtmlUrl.Contains(version, StringComparison.OrdinalIgnoreCase))
.Where(FilterRelease)
.OrderByDescending(x => x.PublishedAt)
.First();
var updateUrl = release.HtmlUrl.Replace("/tag/", "/download/", StringComparison.OrdinalIgnoreCase);
_updateUrlCache[version] = updateUrl;
return(updateUrl);
}
public HttpClientFactory(IHttpClientFactoryParameters parameters, IWebReaderManagerParameters webReaderManagerParameters, IProductInfoHeaderValueFactory userAgentFactory, Func <HttpClientHandler> httpClientHandlerFactory)
{
if (null == parameters)
{
throw new ArgumentNullException("parameters");
}
if (null == webReaderManagerParameters)
{
throw new ArgumentNullException("webReaderManagerParameters");
}
if (null == userAgentFactory)
{
throw new ArgumentNullException("userAgentFactory");
}
if (null == httpClientHandlerFactory)
{
throw new ArgumentNullException("httpClientHandlerFactory");
}
this._referrer = parameters.Referrer;
this._userAgent = userAgentFactory.Create();
this._credentials = parameters.Credentials;
this._cookieContainer = parameters.CookieContainer;
this._webReaderManagerParameters = webReaderManagerParameters;
this._httpClientHandlerFactory = httpClientHandlerFactory;
}
/// <summary>
/// Creates a new instance of <see cref="HttpClient"/> that can be used to consume
/// the Electronic Updates Metadata Web API.
/// </summary>
/// <returns>
/// The created instance of <see cref="HttpClient"/>.
/// </returns>
protected virtual HttpClient CreateHttpClient()
{
var assembly = Assembly.GetEntryAssembly();
var assemblyName = assembly.GetName();
var contentTypeHeader = new MediaTypeWithQualityHeaderValue(this.ContentType);
var userAgentHeader = new ProductInfoHeaderValue(assemblyName.Name, assemblyName.Version.ToString());
HttpClient client = new HttpClient();
try
{
client.BaseAddress = _serviceUri;
// Add any other default and/or custom HTTP request headers here
client.DefaultRequestHeaders.Accept.Add(contentTypeHeader);
client.DefaultRequestHeaders.UserAgent.Add(userAgentHeader);
return(client);
}
catch (Exception)
{
client.Dispose();
throw;
}
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { ProductInfoHeaderValue.Parse(input); });
Assert.False(ProductInfoHeaderValue.TryParse(input, out ProductInfoHeaderValue result));
Assert.Null(result);
}
private static async Task <HttpRequestMessage> PrepareRequest(HttpRequestMessage requestMessage)
{
// add serializer media type
var serializer = requestMessage.GetContentSerializer();
var acceptHeader = new MediaTypeWithQualityHeaderValue(serializer.ContentType);
requestMessage.Headers.Accept.Add(acceptHeader);
if (requestMessage.Headers.UserAgent.Count == 0)
{
// user-agent header required
var headerValue = new ProductInfoHeaderValue("FluentRest", "5.0.0.0");
requestMessage.Headers.UserAgent.Add(headerValue);
}
// set request uri from builder
var urlBuilder = requestMessage.GetUrlBuilder();
requestMessage.RequestUri = urlBuilder.ToUri();
// set content from serializer
var httpContent = await GetContent(requestMessage).ConfigureAwait(false);
requestMessage.Content = httpContent;
return(requestMessage);
}
/// <summary>
/// Sends a request using specified fluent request as an asynchronous operation.
/// </summary>
/// <param name="fluentRequest">The fluent request to send.</param>
/// <returns>
/// The task object representing the asynchronous operation.
/// </returns>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="ArgumentNullException"><paramref name="fluentRequest" /> is <see langword="null" />.</exception>
public async Task <FluentResponse> SendAsync(FluentRequest fluentRequest)
{
if (fluentRequest == null)
{
throw new ArgumentNullException(nameof(fluentRequest));
}
var httpClient = new HttpClient(HttpHandler, DisposeHandler);
var headerValue = new ProductInfoHeaderValue(ThisAssembly.AssemblyProduct, ThisAssembly.AssemblyVersion);
httpClient.DefaultRequestHeaders.UserAgent.Add(headerValue);
FluentResponse fluentResponse;
int count = 0;
do
{
var httpRequest = await TransformRequest(fluentRequest).ConfigureAwait(false);
var httpResponse = await httpClient
.SendAsync(httpRequest, fluentRequest.CompletionOption, fluentRequest.CancellationToken)
.ConfigureAwait(false);
fluentResponse = await TransformResponse(fluentRequest, httpResponse).ConfigureAwait(false);
// track call count to prevent infinite loop
count++;
} while (fluentResponse.ShouldRetry && count <= MaxRetry);
return(fluentResponse);
}
partial void CustomInitialize()
{
// The Schema version is 3.1, put into the Microsoft-BotFramework header
// https://github.com/Microsoft/botbuilder-dotnet/issues/471
HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Microsoft-BotFramework", "3.1"));
// The Client SDK Version
// https://github.com/Microsoft/botbuilder-dotnet/blob/d342cd66d159a023ac435aec0fdf791f93118f5f/doc/UserAgents.md
HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("BotBuilder", GetClientVersion(this)));
// Additional Info. Conditionally add this to avoid any illegal characters in the ProductInfo.
// https://github.com/Microsoft/botbuilder-dotnet/blob/d342cd66d159a023ac435aec0fdf791f93118f5f/doc/UserAgents.md
var platformUserAgent = $"({GetASPNetVersion()}; {GetOsVersion()}; {GetArchitecture()})";
if (ProductInfoHeaderValue.TryParse(platformUserAgent, out var item))
{
HttpClient.DefaultRequestHeaders.UserAgent.Add(item);
}
HttpClient.DefaultRequestHeaders.ExpectContinue = false;
// Override the contract resolver with the Default because we want to be able to serialize annonymous types
SerializationSettings.ContractResolver = new DefaultContractResolver();
DeserializationSettings.ContractResolver = new DefaultContractResolver();
}
/// <summary>
/// Cmdlet begin process. Write to logs, setup Http Tracing and initialize profile
/// </summary>
protected override void BeginProcessing()
{
PromptForDataCollectionProfileIfNotExists();
InitializeQosEvent();
if (string.IsNullOrEmpty(ParameterSetName))
{
WriteDebugWithTimestamp(string.Format("{0} begin processing without ParameterSet.", this.GetType().Name));
}
else
{
WriteDebugWithTimestamp(string.Format("{0} begin processing with ParameterSet '{1}'.", this.GetType().Name, ParameterSetName));
}
if (DefaultContext != null && DefaultContext.Account != null && DefaultContext.Account.Id != null)
{
WriteDebugWithTimestamp(string.Format("using account id '{0}'...", DefaultContext.Account.Id));
}
_httpTracingInterceptor = _httpTracingInterceptor ?? new RecordingTracingInterceptor(_debugMessages);
_adalListener = _adalListener ?? new DebugStreamTraceListener(_debugMessages);
RecordingTracingInterceptor.AddToContext(_httpTracingInterceptor);
DebugStreamTraceListener.AddAdalTracing(_adalListener);
ProductInfoHeaderValue userAgentValue = new ProductInfoHeaderValue(
ModuleName, string.Format("v{0}", ModuleVersion));
AzureSession.ClientFactory.UserAgents.Add(userAgentValue);
AzureSession.ClientFactory.AddHandler(new CmdletInfoHandler(this.CommandRuntime.ToString(), this.ParameterSetName));
base.BeginProcessing();
}
public async Task <ActionResult> Check(string link)
{
Uri uri = new Uri(link);
using (var client = new HttpClient()
{
BaseAddress = uri
})
{
client.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("Mozilla/5.0"));
return(await await client.GetAsync(uri.PathAndQuery).ContinueWith(async t =>
{
if (t.IsFaulted || t.IsCanceled)
{
return ResultData(null, false, link + " 似乎挂了！");
}
var res = await t;
if (res.IsSuccessStatusCode)
{
var s = await res.Content.ReadAsStringAsync();
if (s.Contains(CommonHelper.GetSettings("Domain")))
{
return ResultData(null, true, "友情链接正常！");
}
return ResultData(null, false, link + " 对方似乎没有本站的友情链接！");
}
return ResultData(null, false, link + " 对方网站返回错误的状态码！http响应码为：" + res.StatusCode);
}));
}
}
public static void AddDefaultRequestHeaders(HttpClient httpClient)
{
// The Schema version is 3.1, put into the Microsoft-BotFramework header
var botFwkProductInfo = new ProductInfoHeaderValue("Microsoft-BotFramework", "3.1");
if (!httpClient.DefaultRequestHeaders.UserAgent.Contains(botFwkProductInfo))
{
httpClient.DefaultRequestHeaders.UserAgent.Add(botFwkProductInfo);
}
// The Client SDK Version
// https://github.com/Microsoft/botbuilder-dotnet/blob/d342cd66d159a023ac435aec0fdf791f93118f5f/doc/UserAgents.md
var botBuilderProductInfo = new ProductInfoHeaderValue("BotBuilder", GetClientVersion());
if (!httpClient.DefaultRequestHeaders.UserAgent.Contains(botBuilderProductInfo))
{
httpClient.DefaultRequestHeaders.UserAgent.Add(botBuilderProductInfo);
}
// Additional Info.
// https://github.com/Microsoft/botbuilder-dotnet/blob/d342cd66d159a023ac435aec0fdf791f93118f5f/doc/UserAgents.md
var userAgent = $"({GetASPNetVersion()}; {GetOsVersion()}; {GetArchitecture()})";
if (ProductInfoHeaderValue.TryParse(userAgent, out var additionalProductInfo))
{
if (!httpClient.DefaultRequestHeaders.UserAgent.Contains(additionalProductInfo))
{
httpClient.DefaultRequestHeaders.UserAgent.Add(additionalProductInfo);
}
}
httpClient.DefaultRequestHeaders.ExpectContinue = false;
}
public static HttpRequestMessage UserAgent(this HttpRequestMessage request, string agent)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var parts = agent.Split(' ').ToList();
for (var i = parts.Count - 1; i > 0; i--)
{
if (parts[i].EndsWith(')') &&
!parts[i].StartsWith('('))
{
parts[i - 1] += " " + parts[i];
parts.RemoveAt(i);
}
}
request.Headers.UserAgent.Clear();
foreach (var part in parts)
{
if (ProductInfoHeaderValue.TryParse(part, out var value))
{
request.Headers.UserAgent.Add(value);
}
}
return(request);
}
public async Task <ActionResult> Check(string link)
{
HttpClient.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("Mozilla/5.0"));
return(await await HttpClient.GetAsync(link).ContinueWith(async t =>
{
if (t.IsFaulted || t.IsCanceled)
{
return ResultData(null, false, link + " 似乎挂了！");
}
var res = await t;
if (!res.IsSuccessStatusCode)
{
return ResultData(null, false, link + " 对方网站返回错误的状态码！http响应码为：" + res.StatusCode);
}
var s = await res.Content.ReadAsStringAsync();
if (s.Contains(Request.Host.Host))
{
return ResultData(null, true, "友情链接正常！");
}
return ResultData(null, false, link + " 对方似乎没有本站的友情链接！");
}));
}
public static async Task <bool> TriggerWorkflowAsync(string targetRepoName, string targetBranchName, long?pr_number)
{
using (var client = new HttpClient())
{
var GITHUB_PAT = Environment.GetEnvironmentVariable("GITHUB_PAT");
var GITHUB_ACCOUNT_NAME = Environment.GetEnvironmentVariable("GITHUB_ACCOUNT_NAME");
var GITHUB_REPO_NAME = Environment.GetEnvironmentVariable("GITHUB_REPO_NAME");
var GITHUB_ACTION_ID = Environment.GetEnvironmentVariable("GITHUB_ACTION_ID");
var request = new HttpRequestMessage(HttpMethod.Post, $"https://api.github.com/repos/{GITHUB_ACCOUNT_NAME}/{GITHUB_REPO_NAME}/actions/workflows/{GITHUB_ACTION_ID}/dispatches")
{
Headers =
{
Authorization = new AuthenticationHeaderValue("token", GITHUB_PAT),
UserAgent = { ProductInfoHeaderValue.Parse("RunPipeline") },
Accept = { MediaTypeWithQualityHeaderValue.Parse("application/vnd.github.v3+json") }
},
Content = new StringContent($"{{ \"ref\":\"master\", \"inputs\": {{\"repo\": \"{targetRepoName}\", \"branch\": \"{targetBranchName}\", \"target_repository\": \"{GITHUB_ACCOUNT_NAME}/{GITHUB_REPO_NAME}\", \"target_pr\": \"{pr_number}\"}} }}")
};
using (var response = await client.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
return(true);
}
}
return(false);
}
}
/// <summary>
/// 检查友链
/// </summary>
public void CheckLinks()
{
var links = _linksService.GetQuery(l => !l.Except).AsParallel();
var client = _httpClientFactory.CreateClient();
client.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("MasuitBot-link/1.0"));
client.DefaultRequestHeaders.Referrer = new Uri("https://masuit.com");
client.Timeout = TimeSpan.FromSeconds(10);
Parallel.ForEach(links, link =>
{
var prev = link.Status;
client.GetStringAsync(link.Url).ContinueWith(t =>
{
if (t.IsCanceled || t.IsFaulted)
{
link.Status = Status.Unavailable;
}
else
{
link.Status = !t.Result.Contains(CommonHelper.SystemSettings["Domain"]) ? Status.Unavailable : Status.Available;
}
if (link.Status != prev)
{
link.UpdateTime = DateTime.Now;
}
}).Wait();
});
_linksService.SaveChanges();
}
internal async Task<JToken> Get(string type, string workspace, IDictionary<string, string> query)
{
var uri = new Uri(
Endpoint +
type +
QueryHelpers.AddQueryString(
QueryHelpers.AddQueryString("", query),
new Dictionary<string, string> {
{ "user_agent", UserAgent },
{ "workspace_id", workspace },
{ "order_field", "date" },
{ "order_desc", "on" },
}
)
);
var request = new HttpRequestMessage(HttpMethod.Get, uri);
request.Headers.UserAgent.Clear();
request.Headers.UserAgent.Add(ProductInfoHeaderValue.Parse(UserAgent));
request.Headers.Authorization = new AuthenticationHeaderValue("basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Token}:api_token")));
var response = await Client.SendAsync(request);
var text = await response.Content.ReadAsStringAsync();
return JToken.Parse(text);
}
/// <summary>
/// 上传图片到百度图床
/// </summary>
/// <param name="file">文件名</param>
/// <returns></returns>
private static (string, bool) UploadImageFallback2(string file)
{
string url = string.Empty;
bool success = false;
string ext = Path.GetExtension(file);
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("Mozilla/5.0"));
using (var stream = File.OpenRead(file))
{
using (var bc = new StreamContent(stream))
{
bc.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "".CreateShortToken() + ext,
Name = "uploaded_file[]"
};
using (var content = new MultipartFormDataContent
{
bc
})
{
var code = httpClient.PostAsync("https://upload.cc/image_upload", content).ContinueWith(t =>
{
if (t.IsCanceled || t.IsFaulted)
{
return(0);
}
var res = t.Result;
if (res.IsSuccessStatusCode)
{
string s = res.Content.ReadAsStringAsync().Result;
var token = JObject.Parse(s);
if ((int)token["code"] == 100)
{
url = "https://upload.cc/" + (string)token["success_image"][0]["url"];
return(1);
}
}
return(2);
}).Result;
if (code == 1)
{
success = true;
}
}
}
}
}
if (success)
{
return(url, success);
}
return(UploadImageFallback3(file));
}
/// <summary>
/// 检查友链
/// </summary>
public void CheckLinks()
{
var links = _linksService.GetQuery(l => !l.Except).AsParallel();
var client = _httpClientFactory.CreateClient();
client.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("Mozilla/5.0"));
client.DefaultRequestHeaders.Referrer = new Uri("https://masuit.com");
client.Timeout = TimeSpan.FromSeconds(10);
Parallel.ForEach(links, link =>
{
client.GetAsync(link.Url).ContinueWith(async t =>
{
if (t.IsCanceled || t.IsFaulted)
{
link.Status = Status.Unavailable;
return;
}
var res = await t;
if (res.IsSuccessStatusCode)
{
link.Status = !(await res.Content.ReadAsStringAsync()).Contains(CommonHelper.SystemSettings["Domain"]) ? Status.Unavailable : Status.Available;
}
else
{
link.Status = Status.Unavailable;
}
}).Wait();
});
_linksService.SaveChanges();
}
private static void CheckInvalidGetProductInfoLength(string input, int startIndex)
{
ProductInfoHeaderValue result = null;
Assert.Equal(0, ProductInfoHeaderValue.GetProductInfoLength(input, startIndex, out result));
Assert.Null(result);
}
public void Ctor_ProductStringOverload_MatchExpectation()
{
ProductInfoHeaderValue productInfo = new ProductInfoHeaderValue("product", "1.0");
Assert.Equal(new ProductHeaderValue("product", "1.0"), productInfo.Product);
Assert.Null(productInfo.Comment);
}
private void CheckValidTryParse(string input, ProductInfoHeaderValue expectedResult)
{
ProductInfoHeaderValue result = null;
Assert.True(ProductInfoHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
}
private void CheckInvalidTryParse(string input)
{
ProductInfoHeaderValue result = null;
Assert.False(ProductInfoHeaderValue.TryParse(input, out result));
Assert.Null(result);
}
public async Task <string> GetTokenForInstallationAsync(long installationId)
{
var appToken = await GetTokenForApplicationAsync();
using (var client = new HttpClient())
{
string url = $"https://api.github.com/app/installations/{installationId}/access_tokens";
var request = new HttpRequestMessage(HttpMethod.Post, url)
{
Headers =
{
Authorization = new AuthenticationHeaderValue("Bearer", appToken),
UserAgent =
{
ProductInfoHeaderValue.Parse("DontMergeMeYet"),
},
Accept =
{
MediaTypeWithQualityHeaderValue.Parse("application/vnd.github.machine-man-preview+json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync();
var obj = JObject.Parse(json);
return(obj["token"]?.Value <string>());
}
}
}
/// <summary>
/// 上传图片到人民网图床
/// </summary>
/// <param name="stream"></param>
/// <param name="file"></param>
/// <returns></returns>
public async Task <(string url, bool success)> UploadPeople(Stream stream, string file)
{
bool success = false;
_httpClient.DefaultRequestHeaders.UserAgent.Add(ProductInfoHeaderValue.Parse("Chrome/72.0.3626.96"));
using var sc = new StreamContent(stream);
using var mc = new MultipartFormDataContent
{
{ sc, "Filedata", Path.GetFileName(file) },
{ new StringContent("." + Path.GetExtension(file)), "filetype" }
};
var str = await _httpClient.PostAsync("http://bbs1.people.com.cn/postImageUpload.do", mc).ContinueWith(t =>
{
if (t.IsCompletedSuccessfully)
{
var res = t.Result;
if (res.IsSuccessStatusCode)
{
string result = res.Content.ReadAsStringAsync().Result;
string url = "http://bbs1.people.com.cn" + (string)JObject.Parse(result)["imageUrl"];
if (url.EndsWith(Path.GetExtension(file)))
{
success = true;
return(url);
}
}
}
return("");
});
return(str, success);
}
public AsyncClient(
string auth,
int timeout,
ProductInfoHeaderValue userAgent,
HttpMessageHandler httpMessageHandler = null
)
{
_httpMessageHandler = httpMessageHandler ?? new HttpClientHandler();
try
{
_httpClient = new HttpClient(_httpMessageHandler)
{
DefaultRequestHeaders =
{
Authorization = new AuthenticationHeaderValue("Basic", auth),
Accept = { new MediaTypeWithQualityHeaderValue("application/json") },
UserAgent = { userAgent }
},
Timeout = TimeSpan.FromMilliseconds(timeout)
};
}
catch
{
_httpClient?.Dispose();
_httpMessageHandler.Dispose();
throw;
}
}
/// <summary>
/// Returns <c>true</c> if the User-Agent HTTP header value is valid, otherwise returns <c>false</c>.
/// </summary>
/// <param name="headerValues">The header values.</param>
/// <returns><c>true</c> if the User-Agent HTTP header values are valid; otherwise, <c>false</c>.</returns>
public override bool IsValid(StringValues headerValues)
{
var isValid = false;
if (!StringValues.IsNullOrEmpty(headerValues))
{
var value = string.Join(" ", headerValues);
var values = Split(value)
.Select(
x =>
{
var parsed = ProductInfoHeaderValue.TryParse(x, out ProductInfoHeaderValue productInfo);
return(new
{
Parsed = parsed,
ProductInfo = productInfo
});
})
.ToArray();
isValid = values.All(x => x.Parsed) &&
values
.Where(x => x.ProductInfo.Product != null)
.All(x => !string.IsNullOrWhiteSpace(x.ProductInfo.Product.Name));
}
return(isValid);
}
public static bool TryParse (string input, out ProductInfoHeaderValue parsedValue)
{
parsedValue = null;
var lexer = new Lexer (input);
string comment;
if (lexer.ScanCommentOptional (out comment)) {
if (comment == null)
return false;
parsedValue = new ProductInfoHeaderValue ();
parsedValue.Comment = comment;
return true;
}
ProductHeaderValue res;
if (!ProductHeaderValue.TryParse (input, out res))
return false;
parsedValue = new ProductInfoHeaderValue (res);
return true;
}
