public async Task<bool> SendRequest()
{
try
{
var config = new ConfigurationViewModel();
var uri = new Uri(config.Uri + _path);
var filter = new HttpBaseProtocolFilter();
if (config.IsSelfSigned == true)
{
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
}
var httpClient = new HttpClient(filter);
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("text/plain"));
httpClient.DefaultRequestHeaders.UserAgent.Add(new HttpProductInfoHeaderValue(new HttpProductHeaderValue("Mozilla", "5.0").ToString()));
httpClient.DefaultRequestHeaders.UserAgent.Add(new HttpProductInfoHeaderValue(new HttpProductHeaderValue("Firefox", "26.0").ToString()));
var reponse = await httpClient.GetAsync(uri);
httpClient.Dispose();
return reponse.IsSuccessStatusCode;
}
catch (Exception)
{
return false;
}
}
public async Task LoadFlickrPhotosAsync(string feedUrl)
{
Photos.Clear();
var filter = new HttpBaseProtocolFilter();
var client = new HttpClient(filter);
var respText = await client.GetStringAsync(new Uri(feedUrl));
// safe check
respText = respText.Replace("\'", "\\'");
// process respText
JsonObject jsonObject = JsonObject.Parse(respText);
JsonArray jsonArray = jsonObject["items"].GetArray();
foreach (JsonValue val in jsonArray)
{
JsonObject item = val.GetObject();
Photos.Add(new PhotoItem()
{
Title = item["title"].GetString(),
Link = item["link"].GetString(),
PhotoUrl = item["media"].GetObject()["m"].GetString()
});
}
}
public static async Task<string> HttpGet(string uri)
{
if (Config.IsNetWork)
{
NotifyControl notify = new NotifyControl();
notify.Text = "亲,努力加载中...";
notify.Show();
var _filter = new HttpBaseProtocolFilter();
using (HttpClient httpClient = new HttpClient(_filter))
{
_filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
HttpResponseMessage response = new HttpResponseMessage();
response = await httpClient.GetAsync(new Uri(uri, UriKind.Absolute));
responseString = await response.Content.ReadAsStringAsync();
notify.Hide();
}
}
return responseString;
}
public async void Execute(string token, string content)
{
Uri uri = new Uri(API_ADDRESS + path);
var rootFilter = new HttpBaseProtocolFilter();
rootFilter.CacheControl.ReadBehavior = Windows.Web.Http.Filters.HttpCacheReadBehavior.MostRecent;
rootFilter.CacheControl.WriteBehavior = Windows.Web.Http.Filters.HttpCacheWriteBehavior.NoCache;
HttpClient client = new HttpClient(rootFilter);
//client.DefaultRequestHeaders.Add("timestamp", DateTime.Now.ToString());
if(token != null)
client.DefaultRequestHeaders.Add("x-access-token", token);
System.Threading.CancellationTokenSource source = new System.Threading.CancellationTokenSource(2000);
HttpResponseMessage response = null;
if (requestType == GET)
{
try
{
response = await client.GetAsync(uri).AsTask(source.Token);
}
catch (TaskCanceledException)
{
response = null;
}
}else if (requestType == POST)
{
HttpRequestMessage msg = new HttpRequestMessage(new HttpMethod("POST"), uri);
if (content != null)
{
msg.Content = new HttpStringContent(content);
msg.Content.Headers.ContentType = new HttpMediaTypeHeaderValue("application/json");
}
try
{
response = await client.SendRequestAsync(msg).AsTask(source.Token);
}
catch (TaskCanceledException)
{
response = null;
}
}
if (response == null)
{
if (listener != null)
listener.onTaskCompleted(null, requestCode);
}
else
{
string answer = await response.Content.ReadAsStringAsync();
if(listener != null)
listener.onTaskCompleted(answer, requestCode);
}
}
async Task GetBearerTokenAsync()
{
var req = new HttpRequestMessage(HttpMethod.Post, new Uri(OAuth2Token));
req.Headers.Add("Authorization", "Basic " + BasicToken);
req.Headers.Add("User-Agent", UserAgent);
req.Headers.Add("Expect", "100-continue");
req.Content = new HttpStringContent("grant_type=client_credentials", Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/x-www-form-urlencoded");
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = SupportsCompression,
ProxyCredential = ProxyCredential,
UseProxy = UseProxy
};
using (var client = new HttpClient(baseFilter))
{
var msg = await client.SendRequestAsync(req);
await TwitterErrorHandler.ThrowIfErrorAsync(msg);
string response = await msg.Content.ReadAsStringAsync();
var responseJson = JsonMapper.ToObject(response);
BearerToken = responseJson.GetValue<string>("access_token");
}
}
private async void btnExecuta_Click(object sender, RoutedEventArgs e)
{
HttpBaseProtocolFilter Filtro = new HttpBaseProtocolFilter();
Filtro.CacheControl.ReadBehavior = Windows.Web.Http.Filters.HttpCacheReadBehavior.MostRecent;
Filtro.CacheControl.WriteBehavior = Windows.Web.Http.Filters.HttpCacheWriteBehavior.NoCache;
var httpClient = new HttpClient(Filtro);
httpClient.BaseAddress = new Uri("http://192.168.25.80/");
//httpClient.Timeout = TimeSpan.FromMinutes(1);
httpClient.Timeout = TimeSpan.FromSeconds(3);
//httpClient.Timeout = TimeSpan.FromMilliseconds(200);
try
{
var Resposta = httpClient.GetAsync("").Result;
if (Resposta.IsSuccessStatusCode)
{
lblResultado.Text = Resposta.Content.ReadAsStringAsync().Result.ToString();
HttpBaseProtocolFilter
}
}
catch (HttpRequestException)
{
lblResultado.Text = "Servidor Não Disponível";
}
catch (TimeoutException)
{
lblResultado.Text = "Tempo Expirado";
}
}
internal static HttpClient GetHttpClient()
{
var filter = new HttpBaseProtocolFilter() { AllowAutoRedirect = false, AutomaticDecompression = true };
var client = new HttpClient(filter);
return client;
}
public async Task InvalidateAsync()
{
EncodeCredentials();
var req = new HttpRequestMessage(HttpMethod.Post, new Uri(OAuth2InvalidateToken));
req.Headers.Add("Authorization", "Basic " + BasicToken);
req.Headers.Add("User-Agent", UserAgent);
req.Headers.Add("Expect", "100-continue");
req.Content = new HttpStringContent("access_token=" + BearerToken, Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/x-www-form-urlencoded");
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = true
};
//var handler = new HttpClientHandler();
//if (handler.SupportsAutomaticDecompression)
// handler.AutomaticDecompression = DecompressionMethods.GZip;
//if (Proxy != null && handler.SupportsProxy)
// handler.Proxy = Proxy;
using (var client = new HttpClient(baseFilter))
{
var msg = await client.SendRequestAsync(req);
await TwitterErrorHandler.ThrowIfErrorAsync(msg);
string response = await msg.Content.ReadAsStringAsync();
var responseJson = JsonMapper.ToObject(response);
BearerToken = responseJson.GetValue<string>("access_token");
}
}
private void GetCookies_Click(object sender, RoutedEventArgs e)
{
try
{
// 'AddressField' is a disabled text box, so the value is considered trusted input. When enabling the
// text box make sure to validate user input (e.g., by catching FormatException as shown in scenario 1).
Uri uri = new Uri(AddressField.Text);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
HttpCookieCollection cookieCollection = filter.CookieManager.GetCookies(uri);
OutputField.Text = cookieCollection.Count + " cookies found.\r\n";
foreach (HttpCookie cookie in cookieCollection)
{
OutputField.Text += "--------------------\r\n";
OutputField.Text += "Name: " + cookie.Name + "\r\n";
OutputField.Text += "Domain: " + cookie.Domain + "\r\n";
OutputField.Text += "Path: " + cookie.Path + "\r\n";
OutputField.Text += "Value: " + cookie.Value + "\r\n";
OutputField.Text += "Expires: " + cookie.Expires + "\r\n";
OutputField.Text += "Secure: " + cookie.Secure + "\r\n";
OutputField.Text += "HttpOnly: " + cookie.HttpOnly + "\r\n";
}
}
catch (Exception ex)
{
rootPage.NotifyUser("Error: " + ex.Message, NotifyType.ErrorMessage);
}
}
private void GetCookies_Click(object sender, RoutedEventArgs e)
{
try
{
Uri resourceAddress;
if (!Helpers.TryGetUri(AddressField.Text, out resourceAddress))
{
rootPage.NotifyUser("Invalid URI.", NotifyType.ErrorMessage);
return;
}
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
HttpCookieCollection cookieCollection = filter.CookieManager.GetCookies(resourceAddress);
OutputField.Text = cookieCollection.Count + " cookies found.\r\n";
foreach (HttpCookie cookie in cookieCollection)
{
OutputField.Text += "--------------------\r\n";
OutputField.Text += "Name: " + cookie.Name + "\r\n";
OutputField.Text += "Domain: " + cookie.Domain + "\r\n";
OutputField.Text += "Path: " + cookie.Path + "\r\n";
OutputField.Text += "Value: " + cookie.Value + "\r\n";
OutputField.Text += "Expires: " + cookie.Expires + "\r\n";
OutputField.Text += "Secure: " + cookie.Secure + "\r\n";
OutputField.Text += "HttpOnly: " + cookie.HttpOnly + "\r\n";
}
}
catch (Exception ex)
{
rootPage.NotifyUser("Error: " + ex.Message, NotifyType.ErrorMessage);
}
}
protected string Get(string partUrl)
{
using (var filter = new HttpBaseProtocolFilter())
{
filter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired);
filter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.InvalidName);
filter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Untrusted);
using (var wc = new HttpClient(filter))
{
bool completed = false;
var url = BuildUrl(partUrl);
var task = wc.GetStringAsync(url);
task.Completed = delegate { completed = true; };
while (!completed)
{
Task.Delay(200).Wait();
}
var content = task.GetResults();
return content.TrimWhiteSpaceAndQuotes();
}
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
HttpBaseProtocolFilter baseProtocolFilter = new HttpBaseProtocolFilter();
meteredConnectionFilter = new HttpMeteredConnectionFilter(baseProtocolFilter);
httpClient = new HttpClient(meteredConnectionFilter);
cts = new CancellationTokenSource();
}
public override async void receive_file(String devicename, String add, int not)
{
try
{
_httpurl = new Uri(add);
_httpprogress = new Progress<HttpProgress>(ProgressHandler);
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod("GET"), _httpurl);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
_httpclient = new HttpClient(filter);
_cancel_token_source = new CancellationTokenSource();
_cancel_token = _cancel_token_source.Token;
scan_network_speed();
_stopwatch.Start();
_httpresponse = await _httpclient.SendRequestAsync(request).AsTask(_cancel_token, _httpprogress);
StorageFolder folder = KnownFolders.PicturesLibrary;
StorageFile file = await folder.CreateFileAsync(this.filepath, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream filestream = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream filewriter = filestream.GetOutputStreamAt(0);
_datawriter = new DataWriter(filewriter);
_timer.Cancel();
_transferspeed /= 1024;
_message = format_message(_stopwatch.Elapsed, "Transferspeed", _transferspeed.ToString(), " kB/s");
this.callback.on_transfer_speed_change(_message, this.results);
this.main_view.text_to_logs(_message.Replace("\t", " "));
_stopwatch.Stop();
_buffer = await _httpresponse.Content.ReadAsBufferAsync();
_datawriter.WriteBuffer(_buffer);
await _datawriter.StoreAsync();
_datawriter.Dispose();
filewriter.Dispose();
filestream.Dispose();
_httpresponse.Content.Dispose();
_httpresponse.Dispose();
_httpclient.Dispose();
_message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath);
this.callback.on_file_received(_message, this.results);
this.main_view.text_to_logs(_message.Replace("\t", " "));
}
catch (Exception e)
{
append_error_tolog(e, _stopwatch.Elapsed, "");
}
}
/// <summary>
/// Moves needed cookies to globaly used client by WebViews control, web view authentication in other words.
/// </summary>
/// <returns></returns>
public static async Task InitializeContextForWebViews(bool mobile)
{
if (_webViewsInitialized)
return;
_webViewsInitialized = true;
var filter = new HttpBaseProtocolFilter();
var httpContext = await MalHttpContextProvider.GetHttpContextAsync();
var cookies = httpContext.Handler.CookieContainer.GetCookies(new Uri(MalHttpContextProvider.MalBaseUrl));
if (mobile)
{
filter.CookieManager.SetCookie(new HttpCookie("view", "myanimelist.net", "/") { Value = "sp" });
}
foreach (var cookie in cookies.Cast<Cookie>())
{
try
{
var newCookie = new HttpCookie(cookie.Name, cookie.Domain, cookie.Path) { Value = cookie.Value };
filter.CookieManager.SetCookie(newCookie);
}
catch (Exception)
{
var msg = new MessageDialog( "Authorization failed while rewriting cookies, I don't know why this is happenning and after hours of debugging it fixed itself after reinstall. :(","Something went wrong™");
await msg.ShowAsync();
}
}
filter.AllowAutoRedirect = true;
Windows.Web.Http.HttpClient client = new Windows.Web.Http.HttpClient(filter); //use globaly by webviews
}
public MainPage()
{
this.InitializeComponent();
filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
httpClient = new HttpClient(filter);
string username = "******";
string password = "******";
var buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(username + ":" + password, Windows.Security.Cryptography.BinaryStringEncoding.Utf8);
string base64token = Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(buffer);
HttpCredentialsHeaderValue authHeader = new HttpCredentialsHeaderValue("Basic", base64token);
// var ah = new HttpCredentialsHeaderValue("Authentication", "Basic YWRtaW46YWRtaW4=")
httpClient.DefaultRequestHeaders.Authorization = authHeader;
// Took some time to figure out a "bug"? when using "deflate" which is default...
// httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "deflate"); //Problem here...
httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "gzip");
// httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "");
// We're not using this at the moment...
cts = new CancellationTokenSource();
}
protected override HttpClient CreateClient()
{
var filter = new HttpBaseProtocolFilter();
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
var client = new HttpClient(new WinRtHttpClientHandler(filter));
return client;
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// In this scenario we just create an HttpClient instance with default settings. I.e. no custom filters.
// For examples on how to use custom filters see other scenarios.
filter = new HttpBaseProtocolFilter();
httpClient = new HttpClient(filter);
cts = new CancellationTokenSource();
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
HttpBaseProtocolFilter baseProtocolFilter = new HttpBaseProtocolFilter();
HttpRetryFilter retryFilter = new HttpRetryFilter(baseProtocolFilter);
httpClient = new HttpClient(retryFilter);
cts = new CancellationTokenSource();
UpdateAddressField();
}
public MyShowService([Dependency] IParser parser)
{
_parser = parser;
var protocolFilter = new HttpBaseProtocolFilter {AutomaticDecompression = true};
_httpClient = new HttpClient(protocolFilter);
_httpClient.DefaultRequestHeaders.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("application/json"));
_httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new HttpContentCodingWithQualityHeaderValue("utf-8"));
}
public static void ClearCookiesForUrl(this WebView webView, Uri uri)
{
var filter = new HttpBaseProtocolFilter();
var cookies = filter.CookieManager.GetCookies(uri);
foreach (var cookie in cookies)
{
filter.CookieManager.DeleteCookie(cookie);
}
}
/// <summary>
/// Instantiates a OneDrive connector object. Requires a call to "login" function to complete authorization.
/// </summary>
public IoTOneDriveConnector()
{
var filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
filter.AllowUI = false;
httpClient = new HttpClient(filter);
}
/// <summary>
/// Attemps to login to the server
/// </summary>
/// <param name="username">The Username</param>
/// <param name="password">The Password</param>
/// <returns>
/// true if the app was able to login
/// </returns>
public async Task<LoginStatus> LoginAsync(string username, string password)
{
UriBuilder builder;
try
{
builder = new UriBuilder(new Uri(settings.ServerUrl));
builder.Path = "/Account/Login";
}
catch(UriFormatException)
{
return LoginStatus.InvalidServerUrl;
}
HttpBaseProtocolFilter httpFilter = new HttpBaseProtocolFilter();
using (var client = new HttpClient(httpFilter))
{
var content = new Windows.Web.Http.HttpFormUrlEncodedContent(new KeyValuePair<String, String>[]
{
new KeyValuePair<string, string>("Email", username),
new KeyValuePair<string, string>("Password", password),
new KeyValuePair<string, string>("RememberMe", "true")
});
HttpResponseMessage result = null;
try
{
result = await client.PostAsync(builder.Uri, content);
}
catch (COMException ce)
{
if(ce.HResult == -2147012867)
{
return LoginStatus.UnableToConnectToServer;
}
return LoginStatus.Error;
}
if (result.StatusCode == HttpStatusCode.Ok)
{
var cookies = httpFilter.CookieManager.GetCookies(new Uri($"{builder.Scheme}://{builder.Host}:{builder.Port}"));
var authz = cookies.FirstOrDefault(i => String.Compare(i.Name, "Authz") == 0);
if(authz != null)
{
this.authz = authz;
return LoginStatus.Success;
}
else
{
return LoginStatus.ErrorAuthenticating;
}
}
}
return LoginStatus.Unknown;
}
public static API createWebsite()
{
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient http = new HttpClient(filter);
API web = new API(http, "None");
web.cookieMonster = filter.CookieManager;
Frame rootFrame = Window.Current.Content as Frame;
return web;
}
/// <summary>
/// 获取B站网页的Cookie
/// </summary>
/// <returns></returns>
public static string GetCookies()
{
HttpBaseProtocolFilter hb = new HttpBaseProtocolFilter();
HttpCookieCollection cookieCollection = hb.CookieManager.GetCookies(new Uri("http://bilibili.com/"));
string cookie = "";
foreach (HttpCookie item in cookieCollection)
{
cookie += item.Name + "=" + item.Value + ";";
}
return(cookie);
}
HttpClient GetAutoPickerHttpClient(string clientId)
{
if (autoPickerHttpClient == null)
{
var bpf = new HttpBaseProtocolFilter();
autoPicker = new AuthFilters.SwitchableAuthFilter(bpf);
//You can add multiple fiters (twitter, google etc) if you are connecting to more than one service.
autoPicker.AddOAuth2Filter(MakeFacebook(clientId, bpf));
autoPickerHttpClient = new HttpClient(autoPicker);
}
return(autoPickerHttpClient);
}
public static string Getcookestring(string uri)
{
string responsecooke = "";
HttpBaseProtocolFilter httpBaseProtocolFilter = new HttpBaseProtocolFilter();
HttpCookieCollection cookieCollection = httpBaseProtocolFilter.CookieManager.GetCookies(new Uri(uri));
foreach (HttpCookie item in cookieCollection)
{
responsecooke += item.Name + "=" + item.Value + "; ";
}
return(responsecooke);
}
public HttpSession()
{
m_filter = new HttpBaseProtocolFilter();
m_filter.AllowAutoRedirect = false;
m_filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Expired);
m_filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
m_filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
m_filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
m_client = new HttpClient(m_filter);
}
private void init()
{
filter = new HttpBaseProtocolFilter();
httpClient = new HttpClient(filter);
cts = new CancellationTokenSource();
RE = new Dictionary <string, object>();
RE.Add("头部数据", null);
RE.Add("返回内容", null);
RE.Add("访问错误", null);
RE.Add("缓存标记", null);
}
private async void button5_Click(object sender, RoutedEventArgs e)
{
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient webclient = new HttpClient(filter);
// Get the custom JSON Light feed Zipped service method
var result = await webclient.GetStringAsync(new Uri("http://localhost:1494/Northwind.svc/GetSuppliersLiteZip"));
await new MessageDialog("Received payload of " + result.Length + " characters").ShowAsync();
JSONZipCount.Text = result.Length.ToString();
}
HttpClient GetAutoPickerHttpClient(string clientId)
{
if (autoPickerHttpClient == null)
{
var bpf = new HttpBaseProtocolFilter();
autoPicker = new AuthFilters.SwitchableAuthFilter(bpf);
//You can add multiple fiters (twitter, google etc) if you are connecting to more than one service.
autoPicker.AddOAuth2Filter(MakeFacebook(clientId, bpf));
autoPickerHttpClient = new HttpClient(autoPicker);
}
return autoPickerHttpClient;
}
private async void QueryRoomButton_Click(object sender, RoutedEventArgs e)
{
DateTimeOffset StartDateTime = (DateTimeOffset)StartDatePicker.Date.Value.Date + StartTimePicker.Time;
DateTimeOffset EndDateTime = (DateTimeOffset)EndDatePicker.Date.Value.Date + EndTimePicker.Time;
if (StartDateTime.DateTime.Minute % 15 != 0)
{
StartDateTime = StartDateTime - TimeSpan.FromMinutes(StartDateTime.DateTime.Minute % 15);
}
if (EndDateTime.DateTime.Minute % 15 != 0)
{
EndDateTime = EndDateTime + TimeSpan.FromMinutes(15 - EndDateTime.DateTime.Minute % 15);
}
var filter = new HttpBaseProtocolFilter();
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Expired);
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
HttpClient httpClient = new HttpClient(filter); HttpStringContent content = new HttpStringContent("st=" + StartDateTime.ToString("yyyy-MM-dd HH:mm:ss") + "&et=" + EndDateTime.ToString("yyyy-MM-dd HH:mm:ss"), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/x-www-form-urlencoded");
HttpRequestResult requestResult = await httpClient.TryPostAsync(new Uri("https://a.rouor.com/LoisMeeting/record/room"), content);
if (requestResult.Succeeded)
{
if (JsonObject.TryParse(requestResult.ResponseMessage.Content.ToString(), out JsonObject resultJsonObject))
{
if (resultJsonObject.GetNamedNumber("r") == 0)
{
JsonArray dataJsonArray = resultJsonObject.GetNamedArray("d");
if (dataJsonArray.Count <= 0)
{
Status.Insert(0, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss ") + "該時間段内沒有可以會議室，請重新選擇時段！");
return;
}
else
{
string room = StartDateTime.ToString("yyyy/MM/dd HH:mm--") + EndDateTime.ToString("yyyy/MM/dd HH:mm") + "空閑會議室有：";
for (uint i = 0; i < dataJsonArray.Count; i++)
{
room += dataJsonArray.GetObjectAt(i).GetNamedString("name") + "; ";
}
Status.Insert(0, room);
}
}
else
{
Status.Insert(0, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss ") + resultJsonObject.GetNamedString("e"));
}
}
}
}
/// <summary>
/// Submits the http put request to the specified uri.
/// </summary>
/// <param name="uri">The uri to which the put request will be issued.</param>
/// <param name="body">The HTTP content comprising the body of the request.</param>
/// <returns>Task tracking the PUT completion.</returns>
#pragma warning disable 1998
private async Task <Stream> PutAsync(
Uri uri,
IHttpContent body = null)
{
IBuffer dataBuffer = null;
HttpBaseProtocolFilter httpFilter = new HttpBaseProtocolFilter();
httpFilter.AllowUI = false;
if (this.deviceConnection.Credentials != null)
{
httpFilter.ServerCredential = new PasswordCredential();
httpFilter.ServerCredential.UserName = this.deviceConnection.Credentials.UserName;
httpFilter.ServerCredential.Password = this.deviceConnection.Credentials.Password;
}
using (HttpClient client = new HttpClient(httpFilter))
{
this.ApplyHttpHeaders(client, HttpMethods.Put);
// Send the request
IAsyncOperationWithProgress <HttpResponseMessage, HttpProgress> responseOperation = client.PutAsync(uri, null);
TaskAwaiter <HttpResponseMessage> responseAwaiter = responseOperation.GetAwaiter();
while (!responseAwaiter.IsCompleted)
{
}
using (HttpResponseMessage response = responseOperation.GetResults())
{
if (!response.IsSuccessStatusCode)
{
throw new DevicePortalException(response);
}
if (response.Content != null)
{
using (IHttpContent messageContent = response.Content)
{
IAsyncOperationWithProgress <IBuffer, ulong> bufferOperation = messageContent.ReadAsBufferAsync();
while (bufferOperation.Status != AsyncStatus.Completed)
{
}
dataBuffer = bufferOperation.GetResults();
}
}
}
}
return((dataBuffer != null) ? dataBuffer.AsStream() : null);
}
//private async Task GetReDataAsync()
//{
// if (this._groups.Count != 0)
// return;
// Uri dataUri = new Uri("ms-appx:///DataModel/ReData.json");
// StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(dataUri);
// string jsonText = await FileIO.ReadTextAsync(file);
// JsonObject jsonObject = JsonObject.Parse(jsonText);
// JsonArray jsonArray = jsonObject["Groups"].GetArray();
// foreach (JsonValue groupValue in jsonArray)
// {
// JsonObject groupObject = groupValue.GetObject();
// ReDataGroup group = new ReDataGroup(groupObject["UniqueId"].GetString(),
// groupObject["Title"].GetString());
// int index = 0;
// foreach (JsonValue itemValue in groupObject["Items"].GetArray())
// {
// JsonObject itemObject = itemValue.GetObject();
// string uniqueIdTmp = itemObject["UniqueId"].GetString();
// string titleTmp = itemObject["Title"].GetString();
// string subTitleTmp = itemObject["Subtitle"].GetString();
// string imagePathTmp = itemObject["ImagePath"].GetString();
// string descriptionTmp = itemObject["Description"].GetString();
// string playUrlTmp = itemObject["PlayUrl"].GetString();
// ReDataItem ri = new ReDataItem(index, uniqueIdTmp);
// group.Items.Add(ri);
// index++;
// }
// this.Groups.Add(group);
// }
//}
private async Task GetWebServiceDataAsync()
{
if (this._groups.Count != 0)
{
return;
}
try
{
string requestUrl = "http://replatform.cloudapp.net:8000/getTopicalSummary/?uuid={0}&type={1}&from={2}&to={3}";
requestUrl = String.Format(requestUrl, App.gDeviceName, App.gDeviceType, App.NavigationRoadmap.GetFrom(), App.NavigationRoadmap.GetTo());
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient httpClient = new HttpClient(filter);
CancellationTokenSource cts = new CancellationTokenSource();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.Default;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.Default;
Uri resourceUri;
if (!Uri.TryCreate(requestUrl.Trim(), UriKind.Absolute, out resourceUri))
{
return;
}
HttpResponseMessage response = await httpClient.GetAsync(resourceUri).AsTask(cts.Token);
string jsonText = await Helpers.GetResultAsync(response, cts.Token);
GetResultJsonData(jsonText);
if (filter != null)
{
filter.Dispose();
filter = null;
}
if (httpClient != null)
{
httpClient.Dispose();
httpClient = null;
}
if (cts != null)
{
cts.Dispose();
cts = null;
}
}
catch (Exception) {}
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlQuery"/> class.
/// </summary>
/// <param name="url">URL of XML page</param>
public XmlQuery(string url)
{
uri = new Uri(url);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
// TODO add ignorable errors
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
client = new Windows.Web.Http.HttpClient(filter);
// TODO get rid of this gross .Wait(). Maybe caller should just call GetXml();
Task.Run(async() => await GetXml()).Wait();
}
private Client()
{
var httpFilter = new HttpBaseProtocolFilter {
AllowAutoRedirect = false
};
httpFilter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
this.CookieManager = httpFilter.CookieManager;
this.HttpClient = new MyHttpClient(this, new HttpClient(new RedirectFilter(httpFilter)));
this.Settings = new SettingCollection(this);
ResetExCookie();
}
string tpp = "30"; /* NUM_PER_PAGE is a STRING! */
public JsonHandler()
{
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
hc = new HttpClient(filter);
loaderURL = ResourceLoader.GetForCurrentView("S1APIs");
strUrlBaseApi = loaderURL.GetString("URL_BASE_MOBILE_API");
strForumList = loaderURL.GetString("FORUM_LIST");
strThreadList = loaderURL.GetString("THREAD_LIST");
strPostList = loaderURL.GetString("POST_LIST");
strAuth = loaderURL.GetString("URL_AUTH");
}
public async Task TestClient()
{
var filter = new HttpBaseProtocolFilter();
// filter.IgnorableServerCertificateErrors.Add()
using (var client = new HttpClient(new WinRtHttpClientHandler(filter)))
{
var html = await client.GetStringAsync("http://www.microsoft.com");
Assert.IsNotNull(html);
}
}
public static API createWebsite()
{
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient http = new HttpClient(filter);
API web = new API(http, "None");
web.cookieMonster = filter.CookieManager;
Frame rootFrame = Window.Current.Content as Frame;
return(web);
}
internal static void SignOut()
{
ExSettings.Current.ECookie = "";
// Remove all cookies used by the app
HttpBaseProtocolFilter f = new HttpBaseProtocolFilter();
var cookies = f.CookieManager.GetCookies(new Uri("https://exhentai.org/"));
foreach (var cookie in cookies)
{
f.CookieManager.DeleteCookie(cookie);
}
}
/// <summary>
/// Constructs a new Sitecore Connection object.
/// </summary>
public SitecoreConnection()
{
baseAddress = new Uri(SitecoreServerUri);
filter = new HttpBaseProtocolFilter();
client = new HttpClient(filter);
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.NoCache;
var headers = client.DefaultRequestHeaders;
headers.UserAgent.TryParseAdd(RobbieUserAgent);
ClearAllCookies();
}
/// <summary>
/// Выполняет асинхронный запрос.
/// </summary>
/// <param name="request">The HTTP request message to send.</param>
/// <returns>Объект, представляющий асинхронный операцию.</returns>
private static IAsyncOperationWithProgress <HttpResponseMessage, HttpProgress> SendRequestAsync(HttpRequestMessage request)
{
using (var protocolFilter = new HttpBaseProtocolFilter())
{
using (var client = new HttpClient(protocolFilter))
{
protocolFilter.AutomaticDecompression = true;
client.DefaultRequestHeaders.AcceptEncoding.Add(new HttpContentCodingWithQualityHeaderValue("gzip"));
client.DefaultRequestHeaders.AcceptEncoding.Add(new HttpContentCodingWithQualityHeaderValue("deflate"));
return(client.SendRequestAsync(request));
}
}
}
public HackerNewsHtmlClient(IAnalytics analytics)
{
this.analytics = analytics;
var filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
filter.AllowUI = false;
filter.AllowAutoRedirect = true;
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
client = new HttpClient(filter);
}
internal HttpClient GetHttpClient()
{
if (this.httpClient == null)
{
this.handler = new HttpBaseProtocolFilter();
this.httpClient = new HttpClient(this.handler);
}
this.handler.AutomaticDecompression = this.UseCompression;
this.handler.UseProxy = this.UseProxy;
return(this.httpClient);
}
internal static void DeleteFacebookCookies()
{
try
{
HttpBaseProtocolFilter myFilter = new HttpBaseProtocolFilter();
var cookieManager = myFilter.CookieManager;
HttpCookieCollection myCookieJar = cookieManager.GetCookies(new Uri("https://facebook.com/"));
foreach (HttpCookie cookie in myCookieJar)
{
cookieManager.DeleteCookie(cookie);
}
}
catch { }
try
{
HttpBaseProtocolFilter myFilter = new HttpBaseProtocolFilter();
var cookieManager = myFilter.CookieManager;
HttpCookieCollection myCookieJar = cookieManager.GetCookies(new Uri("https://www.facebook.com/"));
foreach (HttpCookie cookie in myCookieJar)
{
cookieManager.DeleteCookie(cookie);
}
}
catch { }
try
{
HttpBaseProtocolFilter myFilter = new HttpBaseProtocolFilter();
var cookieManager = myFilter.CookieManager;
HttpCookieCollection myCookieJar = cookieManager.GetCookies(new Uri("https://m.facebook.com/"));
foreach (HttpCookie cookie in myCookieJar)
{
cookieManager.DeleteCookie(cookie);
}
}
catch { }
try
{
HttpBaseProtocolFilter myFilter = new HttpBaseProtocolFilter();
var cookieManager = myFilter.CookieManager;
HttpCookieCollection myCookieJar = cookieManager.GetCookies(new Uri("https://instagram.com/"));
foreach (HttpCookie cookie in myCookieJar)
{
cookieManager.DeleteCookie(cookie);
}
}
catch { }
}
internal static async Task <TaskLogAPI> Save(TaskLogAPI item)
{
item.logDate = item.logDateInternal.ToString("dd MMM yyyy");
TaskLogAPI result = null;
HttpBaseProtocolFilter RootFilter = new HttpBaseProtocolFilter();
RootFilter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
RootFilter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
using (HttpClient client = new HttpClient(RootFilter))
{
string suffix = item.id > 0 ? string.Format("/{0}", item.id) : string.Empty;
Uri uri = new Uri(
string.Format(
"{0}/{1}{2}",
AppSettings.ServerUrl,
APICommon.TASKLOG_PATH,
suffix));
try
{
HttpStringContent content = new HttpStringContent(item.ToJson(), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json");
HttpResponseMessage response;
if (item.id <= 0)
{
response = await client.PostAsync(uri, content);
}
else
{
response = await client.PutAsync(uri, content);
}
response.EnsureSuccessStatusCode();
string resultStr = await response.Content.ReadAsStringAsync();
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(TaskLogAPI));
MemoryStream ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes(resultStr));
result = (TaskLogAPI)js.ReadObject(ms);
}
catch (Exception ex)
{
throw ex;
}
}
return(result);
}
public static IAsyncOperation <PackageVersion?> CheckAsync()
{
return(AsyncInfo.Run <PackageVersion?>(async token =>
{
var currentVersion = Package.Current.Id.Version;
using (var filter = new HttpBaseProtocolFilter())
{
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.NoCache;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
using (var client = new HttpClient(filter))
{
var r = await client.GetAsync(ReleaseUri);
var version = new string(r.RequestMessage.RequestUri.Segments.Last().Select(c => char.IsDigit(c) ? c : ' ').ToArray());
var subver = version.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries).Select(s => ushort.Parse(s)).ToArray();
if (subver.Length != 3)
{
return null;
}
var newVersion = new PackageVersion
{
Major = subver[0],
Minor = subver[1],
Build = subver[2],
Revision = 0
};
if (newVersion.Major > currentVersion.Major)
{
return newVersion;
}
else if (newVersion.Major < currentVersion.Major)
{
return null;
}
if (newVersion.Minor > currentVersion.Minor)
{
return newVersion;
}
else if (newVersion.Minor < currentVersion.Minor)
{
return null;
}
if (newVersion.Build > currentVersion.Build)
{
return newVersion;
}
return null;
}
}
}));
}
private static async Task <HttpResponseMessage> GetResponseMessage(HttpRequestSettings settings)
{
var filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
var httpClient = new HttpClient(filter);
AddRequestHeaders(httpClient, settings);
HttpResponseMessage response = await httpClient.GetAsync(settings.RequestedUri);
return(response);
}
private async Task <byte[]> GetWebData(Uri uri, bool bypassCahce)
{
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
if (bypassCahce)
{
filter.get_CacheControl().put_ReadBehavior((HttpCacheReadBehavior)1);
}
HttpClient client = new HttpClient((IHttpFilter)filter);
IBuffer ibuff = await client.GetBufferAsync(uri);
byte[] buff = WindowsRuntimeBufferExtensions.ToArray(ibuff);
return(buff);
}
private void CreateHttpClient(ref HttpClient httpClient)
{
///Create the http client for OneDrive requests
if (httpClient != null)
{
httpClient.Dispose();
}
var filter = new HttpBaseProtocolFilter();
//Clear cache
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
httpClient = new HttpClient(filter);
}
private async Task PostWebServiceDataAsync(string mediaId)
{
try
{
Random random = new Random();
int r = random.Next();
string requestUrl = "http://replatform.cloudapp.net:8000/userAction?uuid={0}&type={1}&media_id={2}&from={3}&to={4}&r={5}";
string userid = App.gDeviceName;
requestUrl = String.Format(requestUrl, userid, App.gDeviceType, mediaId, App.NavigationRoadmap.GetFrom(), App.NavigationRoadmap.GetTo(), r);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient httpClient = new HttpClient(filter);
CancellationTokenSource cts = new CancellationTokenSource();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.Default;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.Default;
Uri resourceUri;
if (!Uri.TryCreate(requestUrl.Trim(), UriKind.Absolute, out resourceUri))
{
return;
}
HttpResponseMessage response = await httpClient.GetAsync(resourceUri).AsTask(cts.Token);
string jsonText = await Helpers.GetResultAsync(response, cts.Token);
GetPostUserActionResult(jsonText);
if (filter != null)
{
filter.Dispose();
filter = null;
}
if (httpClient != null)
{
httpClient.Dispose();
httpClient = null;
}
if (cts != null)
{
cts.Dispose();
cts = null;
}
}
catch (Exception) { }
}
/// <summary>
/// Returns a new HttpClient that does not write to the WinINET cache, and has Gzip/Deflate supports,
/// and cache-control header set to prevent caching as 'private, max-age=0, no-cache'
/// </summary>
/// <returns></returns>
public static HttpClient CreateNonCachingClient()
{
var RootFilter = new HttpBaseProtocolFilter();
RootFilter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
RootFilter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
var client = new HttpClient(RootFilter);
client.EnableGzipDeflate();
client.DefaultRequestHeaders.CacheControl.TryParseAdd("private");
client.DefaultRequestHeaders.CacheControl.TryParseAdd("max-age=0");
client.DefaultRequestHeaders.CacheControl.TryParseAdd("no-cache");
return client;
}
/// <summary>
/// Submits the http post request to the specified uri.
/// </summary>
/// <param name="uri">The uri to which the post request will be issued.</param>
/// <param name="requestStream">Optional stream containing data for the request body.</param>
/// <param name="requestStreamContentType">The type of that request body data.</param>
/// <returns>Task tracking the completion of the POST request</returns>
#pragma warning disable 1998
private async Task <Stream> PostAsync(
Uri uri,
Stream requestStream = null,
string requestStreamContentType = null)
{
HttpStreamContent requestContent = null;
IBuffer dataBuffer = null;
if (requestStream != null)
{
requestContent = new HttpStreamContent(requestStream.AsInputStream());
requestContent.Headers.Remove(ContentTypeHeaderName);
requestContent.Headers.TryAppendWithoutValidation(ContentTypeHeaderName, requestStreamContentType);
}
HttpBaseProtocolFilter httpFilter = new HttpBaseProtocolFilter();
httpFilter.AllowUI = false;
if (this.deviceConnection.Credentials != null)
{
httpFilter.ServerCredential = new PasswordCredential();
httpFilter.ServerCredential.UserName = this.deviceConnection.Credentials.UserName;
httpFilter.ServerCredential.Password = this.deviceConnection.Credentials.Password;
}
using (HttpClient client = new HttpClient(httpFilter))
{
this.ApplyHttpHeaders(client, HttpMethods.Post);
using (HttpResponseMessage response = await client.PostAsync(uri, requestContent))
{
if (!response.IsSuccessStatusCode)
{
throw await DevicePortalException.CreateAsync(response);
}
this.RetrieveCsrfToken(response);
if (response.Content != null)
{
using (IHttpContent messageContent = response.Content)
{
dataBuffer = await messageContent.ReadAsBufferAsync();
}
}
}
}
return((dataBuffer != null) ? dataBuffer.AsStream() : null);
}
private async void button5_Click(object sender, RoutedEventArgs e)
{
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient webclient = new HttpClient(filter);
// Get the custom JSON Light feed Zipped service method
var result = await webclient.GetStringAsync(new Uri("http://localhost:1494/Northwind.svc/GetSuppliersLiteZip"));
await new MessageDialog("Received payload of " + result.Length + " characters").ShowAsync();
JSONZipCount.Text = result.Length.ToString();
}
/// <summary>
/// 发送一个GET请求
/// </summary>
/// <param name="url"></param>
/// <param name="headers"></param>
/// <param name="cookie"></param>
/// <returns></returns>
public async static Task <HttpResults> Get(string url, IDictionary <string, string> headers = null)
{
try
{
HttpBaseProtocolFilter fiter = new HttpBaseProtocolFilter();
fiter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired);
using (var client = new HttpClient(fiter))
{
if (headers != null)
{
foreach (var item in headers)
{
client.DefaultRequestHeaders.Add(item.Key, item.Value);
}
}
var response = await client.GetAsync(new Uri(url));
if (!response.IsSuccessStatusCode)
{
return(new HttpResults()
{
code = (int)response.StatusCode,
status = false,
message = StatusCodeToMessage((int)response.StatusCode)
});
}
response.EnsureSuccessStatusCode();
HttpResults httpResults = new HttpResults()
{
code = (int)response.StatusCode,
status = response.StatusCode == HttpStatusCode.Ok,
results = await response.Content.ReadAsStringAsync(),
message = StatusCodeToMessage((int)response.StatusCode)
};
return(httpResults);
}
}
catch (Exception ex)
{
LogHelper.WriteLog("GET请求失败" + url, LogType.ERROR, ex);
return(new HttpResults()
{
code = ex.HResult,
status = false,
message = "网络请求出现错误(GET)"
});
}
}
public async static Task <IDocument> DownloadNewsHtml(int page = 1)
{
var url = string.Format(NewsBaseUrl + "/m?page={0}", page);
var uri = new Uri(url, UriKind.Absolute);
var filter = new HttpBaseProtocolFilter();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
using (var client = new HttpClient(filter))
{
var html = await client.GetStringAsync(uri);
return(DocumentBuilder.Html(html));
}
}
public WindowsHttpClient()
{
var rootFilter = new HttpBaseProtocolFilter();
rootFilter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
rootFilter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
http = new HttpClient(rootFilter);
http.DefaultRequestHeaders.Accept.Clear();
http.DefaultRequestHeaders.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("application/xml"));
http.DefaultRequestHeaders.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("text/xml"));
http.DefaultRequestHeaders.UserAgent.Clear();
http.DefaultRequestHeaders.UserAgent.ParseAdd("Apache-HttpClient");
}
internal static void CreateHttpClient(ref HttpClient httpClient)
{
if (httpClient != null)
{
httpClient.Dispose();
}
//添加过滤器
IHttpFilter filter = new HttpBaseProtocolFilter();
filter = new PlugInFilter(filter);
httpClient = new HttpClient(filter);
//添加User-Agent
httpClient.DefaultRequestHeaders.UserAgent.Add(new Windows.Web.Http.Headers.HttpProductInfoHeaderValue("mySample", "v1"));
}
/// <summary>
/// Sends a layout request to server and returns the HTTP response, if any.
/// </summary>
/// <param name="apiId">optional api id, overrides the given id by SDKData.</param>
/// <returns>A HttpResponseMessage containing the server response or null in case of an error.</returns>
public async Task<ResponseMessage> RetrieveLayoutResponse(string apiId)
{
Logger.Trace("RetrieveLayoutResponse");
HttpRequestMessage requestMessage = new HttpRequestMessage();
HttpBaseProtocolFilter baseProtocolFilter = new HttpBaseProtocolFilter();
baseProtocolFilter.CacheControl.ReadBehavior = HttpCacheReadBehavior.MostRecent;
baseProtocolFilter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.NoCache;
requestMessage.Method = HttpMethod.Get;
requestMessage.RequestUri = new Uri(Configuration.LayoutUri);
HttpClient apiConnection = new HttpClient(baseProtocolFilter);
apiConnection.DefaultRequestHeaders.Add(Constants.XApiKey, string.IsNullOrEmpty(apiId) ? Configuration.ApiKey : apiId);
apiConnection.DefaultRequestHeaders.Add(Constants.Xiid, SdkData.DeviceId);
string geoHash = await ServiceManager.LocationService.GetGeoHashedLocation();
if (!string.IsNullOrEmpty(geoHash))
{
apiConnection.DefaultRequestHeaders.Add(Constants.Xgeo, geoHash);
}
apiConnection.DefaultRequestHeaders.Add(Constants.AdvertisementIdentifierHeader,
string.IsNullOrEmpty(SdkData.UserId) ? Windows.System.UserProfile.AdvertisingManager.AdvertisingId : SdkData.UserId);
HttpResponseMessage responseMessage;
try
{
responseMessage = await apiConnection.SendRequestAsync(requestMessage);
}
catch (Exception ex)
{
LastCallResult = NetworkResult.NetworkError;
System.Diagnostics.Debug.WriteLine("LayoutManager.RetrieveLayoutResponseAsync(): Failed to send HTTP request: " + ex.Message);
return new ResponseMessage() {IsSuccess = false};
}
Logger.Trace("RetrieveLayoutResponse HTTPCode: {0}", responseMessage.StatusCode);
if (responseMessage.IsSuccessStatusCode)
{
LastCallResult = NetworkResult.Success;
return new ResponseMessage()
{
Content = responseMessage.Content.ToString(),
Header = responseMessage.Headers.ToString(),
StatusCode = responseMessage.StatusCode,
IsSuccess = responseMessage.IsSuccessStatusCode
};
}
LastCallResult = NetworkResult.UnknownError;
return new ResponseMessage() {StatusCode = responseMessage.StatusCode, IsSuccess = responseMessage.IsSuccessStatusCode};
}
private async Task PostWebServiceDataAsync(string mediaId)
{
try
{
Random random = new Random();
int r = random.Next();
string requestUrl = "http://replatform.cloudapp.net:8000/userAction?uuid={0}&type={1}&media_id={2}&from={3}&to={4}&r={5}";
string userid = App.gDeviceName;
requestUrl = String.Format(requestUrl, userid, App.gDeviceType, mediaId, App.NavigationRoadmap.GetFrom(), App.NavigationRoadmap.GetTo(), r);
HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
filter.AutomaticDecompression = true;
HttpClient httpClient = new HttpClient(filter);
CancellationTokenSource cts = new CancellationTokenSource();
filter.CacheControl.ReadBehavior = HttpCacheReadBehavior.Default;
filter.CacheControl.WriteBehavior = HttpCacheWriteBehavior.Default;
Uri resourceUri;
if (!Uri.TryCreate(requestUrl.Trim(), UriKind.Absolute, out resourceUri))
{
return;
}
HttpResponseMessage response = await httpClient.GetAsync(resourceUri).AsTask(cts.Token);
string jsonText = await Helpers.GetResultAsync(response, cts.Token);
GetPostUserActionResult(jsonText);
if (filter != null)
{
filter.Dispose();
filter = null;
}
if (httpClient != null)
{
httpClient.Dispose();
httpClient = null;
}
if (cts != null)
{
cts.Dispose();
cts = null;
}
}
catch (Exception) { }
}
public static async Task<string> GetEncryptedPassword(string passWord)
{
string base64String;
try
{
//https://secure.bilibili.com/login?act=getkey&rnd=4928
//https://passport.bilibili.com/login?act=getkey&rnd=4928
HttpBaseProtocolFilter httpBaseProtocolFilter = new HttpBaseProtocolFilter();
httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired);
httpBaseProtocolFilter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Untrusted);
Windows.Web.Http.HttpClient httpClient = new Windows.Web.Http.HttpClient(httpBaseProtocolFilter);
//WebClientClass wc = new WebClientClass();
string stringAsync = await httpClient.GetStringAsync((new Uri("https://secure.bilibili.com/login?act=getkey&rnd=" + new Random().Next(1000,9999), UriKind.Absolute)));
JObject jObjects = JObject.Parse(stringAsync);
string str = jObjects["hash"].ToString();
string str1 = jObjects["key"].ToString();
string str2 = string.Concat(str, passWord);
string str3 = Regex.Match(str1, "BEGIN PUBLIC KEY-----(?<key>[\\s\\S]+)-----END PUBLIC KEY").Groups["key"].Value.Trim();
byte[] numArray = Convert.FromBase64String(str3);
AsymmetricKeyAlgorithmProvider asymmetricKeyAlgorithmProvider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1);
CryptographicKey cryptographicKey = asymmetricKeyAlgorithmProvider.ImportPublicKey(WindowsRuntimeBufferExtensions.AsBuffer(numArray), 0);
IBuffer buffer = CryptographicEngine.Encrypt(cryptographicKey, WindowsRuntimeBufferExtensions.AsBuffer(Encoding.UTF8.GetBytes(str2)), null);
base64String = Convert.ToBase64String(WindowsRuntimeBufferExtensions.ToArray(buffer));
}
catch (Exception)
{
throw;
//base64String = pw;
}
return base64String;
}
