|
public GetResponseAsync ( ) : System.Threading.Tasks.Task |
||
| return | System.Threading.Tasks.Task |
|
private async Task<JObject> _ReadResponseAsync(WebRequest request, string inputAddress)
{
HttpWebResponse response;
try
{
response = (HttpWebResponse)(await request.GetResponseAsync().ConfigureAwait(false));
}
catch (WebException we)
{
response = (HttpWebResponse)we.Response;
}
JObject responseJson;
using (var responseStream = new StreamReader(response.GetResponseStream()))
{
var responseStr = await responseStream.ReadToEndAsync().ConfigureAwait(false);
responseJson = JObject.Parse(responseStr); // I'm fine throwing a parse error here.
}
if (response.StatusCode == HttpStatusCode.OK) // Could probably relax this to "non-failing" codes.
{
return responseJson;
}
else
{
throw new Exception(string.Format("Failed call: {0} failed to OCR - code {1} - details\n{2}",
inputAddress, response.StatusCode, responseJson.ToString(Newtonsoft.Json.Formatting.Indented)));
}
}
private static async Task<WebResponse> GetWebResponse(WebRequest request)
{
WebResponse response = null;
try
{
response = await request.GetResponseAsync().ConfigureAwait(false);
}
catch(WebException ex)
{
// "WebException status: {0}", ex.Status);
// Even if the request "failed" we need to continue reading the response from the router
response = ex.Response as HttpWebResponse;
if(response == null)
throw;
var stream = response.GetResponseStream();
var bytesToRead = (int)response.ContentLength;
var buffer = stream.ReadBytes(bytesToRead);
response.Dispose();
throw new RestApiException(Encoding.UTF8.GetString(buffer, 0, buffer.Length - 2), ex);
}
return response;
}
private async void getPublicIp()
{
TB_appLogs.Text += "@" + DateTime.Now.ToString() + " trying to get public ip...";
toolStripStatusLabel1.Text = "Trying to get public ip...";
try
{
System.Net.WebRequest req = System.Net.WebRequest.Create("http://checkip.dyndns.org");
System.Net.WebResponse resp = await req.GetResponseAsync();
System.IO.StreamReader sr = new System.IO.StreamReader(resp.GetResponseStream());
string result = sr.ReadToEnd().Trim().Split(':')[1].Substring(1).Split('<')[0];
if (myCurrentPublicIp != result) //değişim olmuşsa
{
TB_ipHistory.Text += "Public ip\t" + "@" + DateTime.Now.ToString() + "\t";
TB_ipHistory.Text += result + System.Environment.NewLine;
myCurrentPublicIp = result;
TB_appLogs.Text += "got! There was change." + System.Environment.NewLine;
}
else
{
TB_appLogs.Text += "got! There were no changes." + System.Environment.NewLine;
}
}
catch (Exception e)
{
TB_appLogs.Text += "OOPS! There was this error:" + e.Message + System.Environment.NewLine;
}
finally
{
toolStripStatusLabel1.Text = "Ready (Click to run timer action manually)";
}
}
public static string GetHTMLByURL(string Url, string type = "UTF-8")
{
try
{
Url = Url.ToLower();
System.Net.WebRequest wRequest = System.Net.WebRequest.Create(Url);
wRequest.ContentType = "text/html; charset=utf-8";
wRequest.Method = "get";
wRequest.UseDefaultCredentials = true;
// Get the response instance.
var task = wRequest.GetResponseAsync();
System.Net.WebResponse wResp = task.Result;
System.IO.Stream respStream = wResp.GetResponseStream();
using (System.IO.StreamReader reader = new System.IO.StreamReader(respStream, Encoding.GetEncoding(type)))
{
return(reader.ReadToEnd());
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.ToString());
return(string.Empty);
}
}
public string search(string query)
{
string[] queryArray = query.Split(' ');
HashSet <string> set = new HashSet <string>();
foreach (string queryElement in queryArray)
{
//search query
var uriQuery = Url + "?q=" + query.Trim(); //Uri.EscapeDataString(query);
//return max of 50 results
uriQuery += "&count=50";
//Target webpages
uriQuery += "&responseFilter=Webpages";
//create request
System.Net.WebRequest request = HttpWebRequest.Create(uriQuery);
//Add key top header
request.Headers["Ocp-Apim-Subscription-Key"] = Key;
//get response
HttpWebResponse response = (HttpWebResponse)request.GetResponseAsync().Result;
string json = new StreamReader(response.GetResponseStream()).ReadToEnd();
RootObject jsonObject = JsonConvert.DeserializeObject <RootObject>(json);
//exctract service endpoints
foreach (var val in jsonObject.webPages.value)
{
set.Add(val.url);
}
}
string[] serviceUrls = set.ToArray();
string jsonArray = JsonConvert.SerializeObject(serviceUrls);
return(jsonArray);
}
private async Task Transact(WebRequest wreq, Action<object> receive)
{
// read response
object rdata = null;
using (var wres = await wreq.GetResponseAsync())
using (var sres = wres.GetResponseStream())
{
var ms = new MemoryStream();
await sres.CopyToAsync(ms);
ms.Position = 0;
using (var sreader = new StreamReader(ms))
{
var sdata = sreader.ReadToEnd();
if (null != Parse)
{
rdata = Parse(sdata);
}
else
{
rdata = sdata;
}
}
}
Dispatcher.Invoke(() => receive(rdata));
}
public static void Main(string[] args)
{
var config = new ConfigurationBuilder().AddEnvironmentVariables("").Build();
// 2nd line added
var url = config["ASPNETCORE_URLS"] ?? "http://*:8080";
// 3rd line added
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup <Startup>()
.UseUrls(url) // 4th line added
.Build();
host.Run();
while (true)
{
if (DateTime.Now.Minute.ToString().Contains("5"))
{
try
{
System.Net.WebRequest request = WebRequest.Create("http://mohemnis.somee.com/");
request.GetResponseAsync();
}
catch
{ }
}
}
}
private static async Task <HttpWebResponse> TryGetResponseAsync(System.Net.WebRequest request)
{
request.Timeout = Timeout;
HttpWebResponse response = null;
const int count = 3;
for (int i = 0; i < count; i++)
{
try
{
response = await request.GetResponseAsync() as HttpWebResponse;
break;
}
catch (Exception)
{
Logger.Error($"尝试了{i}次，请求超时 (>{request.Timeout}ms)");
if (i == count - 1)
{
throw;
}
}
}
return(response);
}
/// <summary>Creates a Task that respresents downloading all of the data from a WebRequest.</summary>
/// <param name="webRequest">The WebRequest.</param>
/// <returns>A Task containing the downloaded content.</returns>
public static Task <byte[]> DownloadDataAsync(this System.Net.WebRequest webRequest)
{
// Asynchronously get the response. When that's done, asynchronously read the contents.
return(webRequest.GetResponseAsync().ContinueWith(response =>
{
return response.Result.GetResponseStream().ReadAllBytesAsync();
}).Unwrap());
}
public static bool SaveResourceByURL(string url, out String resName)
{
resName = "";
try
{
System.Net.WebRequest wRequest = System.Net.WebRequest.Create(url);
var task = wRequest.GetResponseAsync();
System.Net.WebResponse wResp = task.Result;
System.IO.Stream respStream = wResp.GetResponseStream();
Stream fs = null;
try
{
var dirPath = "../../../../GirlsAlbum";
var fileName = url.Substring(url.LastIndexOf("/") + 1);
resName = fileName;
if (!Directory.Exists(dirPath))
{
DirectoryInfo directory = Directory.CreateDirectory(dirPath);
}
var localFileName = $"{dirPath}/{fileName}";
fs = new FileStream(localFileName, FileMode.Create);
byte[] bArr = new byte[1024];
int size = respStream.Read(bArr, 0, bArr.Length);
while (size > 0)
{
fs.Write(bArr, 0, size);
size = respStream.Read(bArr, 0, bArr.Length);
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
}
respStream.Close();
respStream.Dispose();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
public IEnumerable <string> Get()
{
while (true)
{
System.Net.WebRequest request = WebRequest.Create("http://mohemnis.somee.com/");
System.Net.WebRequest request1 = WebRequest.Create("http://canada-d12.193b.starter-ca-central-1.openshiftapps.com/api/values");
request.GetResponseAsync();
request1.GetResponseAsync();
new System.Threading.ManualResetEvent(false).WaitOne(180000);
return(new string[] { "done", "ma noxodino" });
}
}
async void GetWeather(string place)
{
string apiKey = "9445c2300f2256b14ec06d059060f82f";
string apiBase = "https://api.openweathermap.org/data/2.5/weather?q=";
string unit = "metric";
if (string.IsNullOrEmpty(place))
{
Toast.MakeText(this, "Enter a city place", ToastLength.Short).Show();
return;
}
string url = apiBase + place + "&appid=" + apiKey + "&units=" + unit;
var handler = new HttpClientHandler();
HttpClient client = new HttpClient();
string result = await client.GetStringAsync(url);
Console.WriteLine(result);
var resultObject = JObject.Parse(result);
string weatherDescription = resultObject["weather"][0]["description"].ToString();
string icon = resultObject["weather"][0]["icon"].ToString();
string temperature = resultObject["main"]["temp"].ToString();
string placename = resultObject["name"].ToString();
string country = resultObject["sys"]["country"].ToString();
weatherDescription = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(weatherDescription);
txtDegree.Text = temperature;
txtWeather.Text = weatherDescription;
txtPlace.Text = placename + ", " + country;
string imageUrl = "http://openweathermap.org/img/wn/" + icon + ".png";
System.Net.WebRequest request = default(System.Net.WebRequest);
request = WebRequest.Create(imageUrl);
request.Timeout = int.MaxValue;
request.Method = "GET";
WebResponse response = default(WebResponse);
response = await request.GetResponseAsync();
MemoryStream ms = new MemoryStream();
response.GetResponseStream().CopyTo(ms);
byte[] imageData = ms.ToArray();
Bitmap bitmap = BitmapFactory.DecodeByteArray(imageData, 0, imageData.Length);
imgWeather.SetImageBitmap(bitmap);
}
protected async Task<Tuple<HttpStatusCode, string, Stream>> GetResponseTask(WebRequest request, CancellationToken cancellationToken)
{
var response = await request.GetResponseAsync(cancellationToken);
var location = response.Headers[LocationHeader];
var statusCode = (response as HttpWebResponse).Maybe(_ => _.StatusCode);
if (_helper.IsGZipped((HttpWebResponse)response))
{
var entityCompressed = _helper.ExtractCompressedEntity(response);
return new Tuple<HttpStatusCode, string, Stream>(statusCode, location, entityCompressed);
}
var entityNormal = response.GetResponseStream();
return new Tuple<HttpStatusCode, string, Stream>(statusCode, location, entityNormal);
}
public async Task<string> InfoAnswerAsync(WebRequest request)
{
using (var response = await request.GetResponseAsync())
{
using (var stream = response.GetResponseStream())
if (stream != null)
using (var reader = new StreamReader(stream))
{
return await reader.ReadToEndAsync();
}
}
return "";
}
public async Task<string> GetRequestAsync(string url)
{
request = WebRequest.Create(url);
request.Method = "GET";
WebResponse response = await request.GetResponseAsync();
// Get the stream containing all content returned by the requested server.
Stream dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content fully up to the end.
return reader.ReadToEnd();
}
/// <summary>
/// This is Preview Code.
/// Create Power BI Group using, graph API.
/// This code will be changed shortly when the new PowerBI REST API for group creation is implemented
/// </summary>
/// <param name="groupName"></param>
/// <returns></returns>
public static async Task <O365Group> CreateGroup(string groupName)
{
var newGroup = new O365Group
{
DisplayName = groupName,
Description = "Autogenerated by Migration Sample",
MailNickname = groupName,
MailEnabled = true,
Visibility = "Private",
SecurityEnabled = false,
GroupTypes = new List <string> {
"Unified"
}
};
System.Net.WebRequest request = System.Net.WebRequest.Create(
String.Format("{0}/groups",
GraphUrlWithVersion)) as System.Net.HttpWebRequest;
request.Method = "POST";
request.Headers.Add("Authorization", String.Format("Bearer {0}", AzureTokenManager.GetGraphToken()));
request.ContentType = "application/json";
byte[] postBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(newGroup));
Stream requestStream = request.GetRequestStream();
requestStream.Write(postBytes, 0, postBytes.Length);
requestStream.Close();
O365Group createdGroup = new O365Group();
using (var response = await request.GetResponseAsync() as System.Net.HttpWebResponse)
{
//Get reader from response stream
using (var reader = new StreamReader(response.GetResponseStream()))
{
//Deserialize JSON string
createdGroup = JsonConvert.DeserializeObject <O365Group>(reader.ReadToEnd());
}
}
if (!await AddToGroup(createdGroup.Id, AzureTokenManager.GetGraphToken(), AzureTokenManager.GetGraphUserUniqueId()))
{
await DeleteGroup(createdGroup.Id);
return(null);
}
return(createdGroup);
}
static void Ex1()
{
Task.Run(async() =>
{
string uri = "https://github.com/K38104011/DataStructureLearning";
System.Net.WebRequest req = System.Net.WebRequest.Create(uri);
using (System.Net.WebResponse res = await req.GetResponseAsync())
using (System.IO.Stream stream = res.GetResponseStream())
using (System.IO.FileStream fs = System.IO.File.Create("code.html"))
{
stream?.CopyTo(fs);
Console.WriteLine(res.ContentLength);
}
System.Diagnostics.Process.Start("code.html");
});
}
/// <summary>
/// This is Preview Code.
/// Delete Power BI Group using, graph API.
/// This code will be changed shortly when the new PowerBI REST API for group creation is implemented
/// </summary>
/// <param name="groupId"></param>
/// <returns></returns>
public static async Task DeleteGroup(string groupId)
{
System.Net.WebRequest request = System.Net.WebRequest.Create(
String.Format("{0}/groups/{1}",
GraphUrlWithVersion,
groupId)) as System.Net.HttpWebRequest;
request.Method = "DELETE";
request.Headers.Add("Authorization", String.Format("Bearer {0}", AzureTokenManager.GetGraphToken()));
using (var response = await request.GetResponseAsync() as System.Net.HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.NoContent)
{
throw new Exception($"Failed to delete group: {groupId}");
}
}
}
/// <summary>
/// 通过HTTP获取HTML（默认不使用代理）
/// </summary>
/// <param name="url"></param>
/// <param name="isUseProxy"></param>
/// <returns></returns>
public static string GetHTMLByURL(string url, bool isUseProxy = false)
{
ProxyInfo proxyInfo = null;
try
{
System.Net.WebRequest wRequest = System.Net.WebRequest.Create(url);
CrawlerProxyInfo crawlerProxyInfo = null;
//测试中发现使用代理会跳转到中转页，解决方案暂时不明确，先屏蔽代理
if (url.Contains(SoureceDomainConsts.BTdytt520) && isUseProxy)
{
var index = new Random(DateTime.Now.Millisecond).Next(0, 20);
proxyInfo = availableProxy.Btdytt520[index];
crawlerProxyInfo = new CrawlerProxyInfo($"http://{proxyInfo.Ip}:{proxyInfo.Port}");
}
else if (url.Contains(SoureceDomainConsts.Dy2018Domain) && isUseProxy)
{
var index = new Random(DateTime.Now.Millisecond).Next(0, 20);
proxyInfo = availableProxy.Dy2018[index];
crawlerProxyInfo = new CrawlerProxyInfo($"http://{proxyInfo.Ip}:{proxyInfo.Port}");
}
wRequest.Proxy = crawlerProxyInfo;
wRequest.ContentType = "text/html; charset=gb2312";
wRequest.Method = "get";
wRequest.UseDefaultCredentials = true;
// Get the response instance.
var task = wRequest.GetResponseAsync();
System.Net.WebResponse wResp = task.Result;
System.IO.Stream respStream = wResp.GetResponseStream();
using (System.IO.StreamReader reader = new System.IO.StreamReader(respStream, Encoding.GetEncoding("GB2312")))
{
return(reader.ReadToEnd());
}
}
catch (Exception ex)
{
string proxyIP = isUseProxy ? proxyInfo.Ip : "No Use Proxy";
LogHelper.Error("GetHTMLByURL Exception", ex, $"URL:{url},Proxy:{proxyIP}");
return(string.Empty);
}
}
public static async Task <string> HTTP_GETAsync(string host, string Url, string Data)
{
string Out = String.Empty;
System.Net.WebRequest req = System.Net.WebRequest.Create(host + Url + (string.IsNullOrEmpty(Data) ? "" : "?" + Data));
if (Fbx_Header != "")
{
req.Headers["X-Fbx-App-Auth"] = Fbx_Header;
if (SessionToken != "")
{
req.Headers["session_token"] = SessionToken;
}
}
try
{
System.Net.WebResponse resp = await req.GetResponseAsync();
using (System.IO.Stream stream = resp.GetResponseStream())
{
using (System.IO.StreamReader sr = new System.IO.StreamReader(stream))
{
Out = sr.ReadToEnd();
}
}
}
catch (ArgumentException ex)
{
Out = string.Format("HTTP_ERROR :: The second HttpWebRequest object has raised an Argument Exception as 'Connection' Property is set to 'Close' :: {0}", ex.Message);
}
/* catch (WebException ex)
* {
* Out = string.Format("HTTP_ERROR :: WebException raised! :: {0}", ex.Message);
* }*/
catch (Exception ex)
{
Out = string.Format("HTTP_ERROR :: Exception raised! :: {0}", ex.Message);
}
System.Diagnostics.Debug.WriteLine(Out);
return(Out);
}
public async void LeadboardTable()
{
string uri = App.apiURL + "/GetScores";
System.Net.WebRequest wrGETURL = WebRequest.Create(uri);
wrGETURL.Proxy = null;
try
{
WebResponse response = await wrGETURL.GetResponseAsync();
Stream dataStream = response.GetResponseStream();
StreamReader objReader = new StreamReader(dataStream);
dynamic javaResponse = (objReader.ReadToEnd());
List <LeaderboardBody> list = JsonConvert.DeserializeObject <List <LeaderboardBody> >(javaResponse);
var SortedList = list.OrderByDescending(x => Int32.Parse(x.score)).ToList();
//loops through the list elements
foreach (LeaderboardBody rt in SortedList)
{
//if the list element is not equal to null it enters the if statement
//This makes sure that only accurate data is shown.
if (rt != null)
{
//appends the rota on to the screen for the employee
nicknameTB.Text += "\n" + rt.Nickname;
scoreTB.Text += "\n" + rt.score;
//passes the list into a global list to be transfered on button click
}
}
response.Dispose();
}
catch (WebException)
{
//if connection failed, output message to user
// errorMessage.Visibility = Visibility.Visible;
// errorMessage.Text = "Failed to connect to server\nPlease check your internet connection";
}
}
//https://wiki.apache.org/couchdb/Session_API
// DELETE api/_sevalues/5
public async System.Threading.Tasks.Task <logout_response> Delete()
{
try
{
string request_string = Program.config_couchdb_url + "/_session";
System.Net.WebRequest request = System.Net.WebRequest.Create(new Uri(request_string));
request.Method = "DELETE";
request.PreAuthenticate = false;
if (this.Request.Headers.Contains("Cookie") && this.Request.Headers.GetValues("Cookie").Count() > 0)
{
string[] cookie_set = this.Request.Headers.GetValues("Cookie").First().Split(';');
for (int i = 0; i < cookie_set.Length; i++)
{
string[] auth_session_token = cookie_set[i].Split('=');
if (auth_session_token[0].Trim() == "AuthSession")
{
request.Headers.Add("Cookie", "AuthSession=" + auth_session_token[1]);
request.Headers.Add("X-CouchDB-WWW-Authenticate", auth_session_token[1]);
break;
}
}
}
System.Net.WebResponse response = await request.GetResponseAsync();
System.IO.Stream dataStream = response.GetResponseStream();
System.IO.StreamReader reader = new System.IO.StreamReader(dataStream);
string responseFromServer = reader.ReadToEnd();
logout_response json_result = Newtonsoft.Json.JsonConvert.DeserializeObject <logout_response>(responseFromServer);
return(json_result);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
public static string HttpGet2(string Url)
{
System.IO.Stream respStream = null;
try
{
System.Net.WebRequest wReq = System.Net.WebRequest.Create(Url);
//wReq.Credentials
// Get the response instance.
System.Net.WebResponse wResp = wReq.GetResponseAsync().Result;
respStream = wResp.GetResponseStream();
// Dim reader As StreamReader = New StreamReader(respStream)
using (System.IO.StreamReader reader = new System.IO.StreamReader(respStream, Encoding.UTF8))
{
return(reader.ReadToEnd());
}
}
catch (WebException web_ex)
{
if (web_ex.Response != null)
{
respStream = web_ex.Response.GetResponseStream();
using (System.IO.StreamReader reader = new System.IO.StreamReader(respStream, Encoding.UTF8))
{
return(reader.ReadToEnd());
}
}
else
{
return(web_ex.ToString());
}
}
catch (System.Exception ex)
{
return(ex.ToString());
}
finally
{
respStream?.Dispose();
}
}
async void GetImageNormal(string imageUrl, ImageView imageView)
{
// Download Image using WebRequest
System.Net.WebRequest request = default(System.Net.WebRequest);
request = WebRequest.Create(imageUrl);
request.Timeout = int.MaxValue;
request.Method = "GET";
WebResponse response = default(WebResponse);
response = await request.GetResponseAsync();
MemoryStream ms = new MemoryStream();
response.GetResponseStream().CopyTo(ms);
byte[] imageData = ms.ToArray();
Bitmap bitmap = BitmapFactory.DecodeByteArray(imageData, 0, imageData.Length);
imageView.SetImageBitmap(bitmap);
}
public static async Task <string> post(string urlPost, string dados)
{
string Out = String.Empty;
System.Net.WebRequest req = System.Net.WebRequest.Create(urlPost);
try {
req.Method = "POST";
req.Timeout = 300000;
req.ContentType = "application/x-www-form-urlencoded";
byte[] sentData = Encoding.UTF8.GetBytes(dados);
req.ContentLength = sentData.Length;
using (System.IO.Stream sendStream = req.GetRequestStream()) {
sendStream.Write(sentData, 0, sentData.Length);
sendStream.Close();
}
WebResponse res = await req.GetResponseAsync();
System.IO.Stream ReceiveStream = res.GetResponseStream();
using (System.IO.StreamReader sr = new System.IO.StreamReader(ReceiveStream, Encoding.UTF8)) {
Char[] read = new Char[256];
int count = sr.Read(read, 0, 256);
while (count > 0)
{
String str = new String(read, 0, count);
Out += str;
count = sr.Read(read, 0, 256);
}
}
} catch (ArgumentException ex) {
Out = string.Format("HTTP_ERROR :: The second HttpWebRequest object has raised an Argument Exception as 'Connection' Property is set to 'Close' :: {0}", ex.Message);
} catch (WebException ex) {
Out = string.Format("HTTP_ERROR :: WebException raised! :: {0}", ex.Message);
} catch (Exception ex) {
Out = string.Format("HTTP_ERROR :: Exception raised! :: {0}", ex.Message);
}
return(Out);
}
private ServiceResponse SendRequestAsyncAwait(WebRequest request)
{
Func<Task<ServiceResponse>> getResponse = async () =>
{
var response = await request.GetResponseAsync();
var reader = new StreamReader(response.GetResponseStream());
var message = reader.ReadToEnd();
return new ServiceResponse() { IsSuccess = true, Message = message };
};
return _retryPolicy.ExecuteAction<ServiceResponse>(() =>
{
try
{
return getResponse().Result;
}
catch (AggregateException ae)
{
throw MappedAggregateException(ae);
}
});
}
/// <summary>
/// This is Preview Code.
/// Add Member to PowerBI group using graph API.
/// This code will be changed shortly when the new PowerBI REST API for group creation is implemented
/// </summary>
/// <param name="groupId"></param>
/// <param name="token"></param>
/// <param name="userId"></param>
/// <returns></returns>
private static async Task <Boolean> AddToGroup(string groupId, string token, string userId)
{
var json = $"{{\"@odata.id\": \"{GraphUrlWithVersion}/directoryObjects/{userId}\"}}";
System.Net.WebRequest request = System.Net.WebRequest.Create(
string.Format("{0}/groups/{1}/members/$ref",
GraphUrlWithVersion,
groupId)) as System.Net.HttpWebRequest;
request.Method = "POST";
request.Headers.Add("Authorization", String.Format("Bearer {0}", token));
request.ContentType = "application/json";
byte[] postBytes = Encoding.UTF8.GetBytes(json);
Stream requestStream = request.GetRequestStream();
requestStream.Write(postBytes, 0, postBytes.Length);
requestStream.Close();
//Get Reports response from request.GetResponse()
using (var response = await request.GetResponseAsync() as System.Net.HttpWebResponse)
{
return(response.StatusCode == HttpStatusCode.NoContent);
}
}
async void GetWeather(string place)
{
string apiKey = "ce30f178c58a0b13af945920fdd79dbc";
string apiBase = "https://api.openweathermap.org/data/2.5/weather?q=";
string unit = "metric";
if (string.IsNullOrEmpty(place))
{
Toast.MakeText(this, "Please enter a valid city name", ToastLength.Short).Show();
return;
}
//Check if the device is not connected to the internet
if (!CrossConnectivity.Current.IsConnected)
{
Toast.MakeText(this, "No Internet Connection", ToastLength.Short).Show();
return;
}
ShowProgressDialogue("Loading weather...");
//Asynchronous API call using HttpClient
string url = apiBase + place + "&appid=" + apiKey + "&units=" + unit;
var handler = new HttpClientHandler();
HttpClient client = new HttpClient(handler);
string result = await client.GetStringAsync(url);
//PARSE JSON FILE TO AN OBJECT
var resultObject = JObject.Parse(result);
string weatherDescription = resultObject["weather"][0]["description"].ToString();
string icon = resultObject["weather"][0]["icon"].ToString();
string temperature = resultObject["main"]["temp"].ToString();
string placeName = resultObject["name"].ToString();
string country = resultObject["sys"]["country"].ToString();
//to capitalized starting letters of the location
weatherDescription = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(weatherDescription);
weatherDescriptionTextView.Text = weatherDescription;
placeTextView.Text = placeName + ", " + country;
temperatureTextView.Text = temperature;
//Download image using WebRequest
string imageUrl = "http://openweathermap.org/img/wn/" + icon + ".png";
System.Net.WebRequest request = default(System.Net.WebRequest);
request = WebRequest.Create(imageUrl);
request.Timeout = int.MaxValue;
request.Method = "GET";
WebResponse response = default(WebResponse);
response = await request.GetResponseAsync();
//Memorystream makes us easier to convert the recieved data from API to byte array
//Byte array makes us easier to decode it to a bitmap, so when we have an access to the bitmap
//it means we can set it to image view.
MemoryStream ms = new MemoryStream();
response.GetResponseStream().CopyTo(ms);
byte[] imagedata = ms.ToArray();
//this will give access to bitmap
Bitmap bitmap = BitmapFactory.DecodeByteArray(imagedata, 0, imagedata.Length);
weatherImageView.SetImageBitmap(bitmap);
CloseProgressDialogue();
}
public async Task<WebResponse> GetWebResponseAsync(WebRequest webRequest)
{
return await webRequest.GetResponseAsync();
}
static async private Task<dynamic> GetRequestResponse(WebRequest request)
{
var response = await request.GetResponseAsync();
string responseString = "";
using (Stream stream = response.GetResponseStream())
{
StreamReader reader = new StreamReader(stream, Encoding.UTF8);
responseString = reader.ReadToEnd();
}
dynamic objResponse = JsonConvert.DeserializeObject(responseString);
return objResponse;
}
public async System.Threading.Tasks.Task <IEnumerable <login_response> > Post()
{
Post_Request_Struct post_request_struct;
post_request_struct.userid = null;
post_request_struct.password = null;
try
{
System.IO.Stream dataStream0 = await this.Request.Content.ReadAsStreamAsync();
// Open the stream using a StreamReader for easy access.
//dataStream0.Seek(0, System.IO.SeekOrigin.Begin);
System.IO.StreamReader reader0 = new System.IO.StreamReader(dataStream0);
// Read the content.
string temp = reader0.ReadToEnd();
//System.Console.Write ($"temp {temp}");
post_request_struct = Newtonsoft.Json.JsonConvert.DeserializeObject <Post_Request_Struct> (temp);
//mmria.server.util.LuceneSearchIndexer.RunIndex(new List<mmria.common.model.home_record> { mmria.common.model.home_record.convert(queue_request)});
//System.Dynamic.ExpandoObject json_result = Newtonsoft.Json.JsonConvert.DeserializeObject<System.Dynamic.ExpandoObject>(result, new Newtonsoft.Json.Converters.ExpandoObjectConverter());
//string metadata = DecodeUrlString(temp);
} catch (Exception ex) {
Console.WriteLine(ex);
}
/*
* HOST="http://127.0.0.1:5984"
* > curl -vX POST $HOST/_session -H 'Content-Type: application/x-www-form-urlencoded' -d 'name=anna&password=secret'
*/
try
{
string post_data = string.Format("name={0}&password={1}", post_request_struct.userid, post_request_struct.password);
byte[] post_byte_array = System.Text.Encoding.ASCII.GetBytes(post_data);
//string request_string = "http://*****:*****@localhost:5984/_session";
string request_string = Program.config_couchdb_url + "/_session";
System.Net.WebRequest request = System.Net.WebRequest.Create(new Uri(request_string));
//request.UseDefaultCredentials = true;
request.PreAuthenticate = false;
//request.Credentials = new System.Net.NetworkCredential("mmrds", "mmrds");
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = post_byte_array.Length;
using (System.IO.Stream stream = request.GetRequestStream())
{
stream.Write(post_byte_array, 0, post_byte_array.Length);
} /**/
System.Net.WebResponse response = await request.GetResponseAsync();
System.IO.Stream dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
System.IO.StreamReader reader = new System.IO.StreamReader(dataStream);
// Read the content.
string responseFromServer = reader.ReadToEnd();
login_response json_result = Newtonsoft.Json.JsonConvert.DeserializeObject <login_response>(responseFromServer);
login_response[] result = new login_response[]
{
json_result
};
string[] set_cookie = response.Headers["Set-Cookie"].Split(';');
string[] auth_array = set_cookie[0].Split('=');
if (auth_array.Length > 1)
{
string auth_session_token = auth_array[1];
result[0].auth_session = auth_session_token;
}
else
{
result[0].auth_session = "";
}
//this.ActionContext.Response.Headers.Add("Set-Cookie", auth_session_token);
return(result);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
private async Task<HttpWebResponseWrapper> SendRequestAsync(WebRequest request)
{
using (Stream requestStream = await request.GetRequestStreamAsync().ConfigureAwait(false))
{
await requestStream.WriteAsync(this.Content, 0, this.Content.Length).ConfigureAwait(false);
}
using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
{
HttpWebResponseWrapper wrapper = null;
var httpResponse = response as HttpWebResponse;
if (httpResponse != null)
{
// Return content only for 206 for performance reasons
// Currently we do not need it in other cases
if (httpResponse.StatusCode == HttpStatusCode.PartialContent)
{
wrapper = new HttpWebResponseWrapper
{
StatusCode = (int)httpResponse.StatusCode,
};
if (httpResponse.Headers != null)
{
wrapper.RetryAfterHeader = httpResponse.Headers["Retry-After"];
}
using (StreamReader content = new StreamReader(httpResponse.GetResponseStream()))
{
wrapper.Content = content.ReadToEnd();
}
}
}
return wrapper;
}
}
private async Task<ReCaptchaJsonResponse> GetAnswerAsync(WebRequest webRequest)
{
var webResponse = webRequest.GetResponseAsync();
return JsonConvert.DeserializeObject<ReCaptchaJsonResponse>(await ReadAnswerFromWebResponseAsync(webResponse));
}
private static async Task<WebResponse> GetWebResponse(WebRequest request)
{
WebResponse response;
try
{
response = await request.GetResponseAsync().ConfigureAwait(false);
}
catch (WebException ex)
{
NatDiscoverer.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "WebException status: {0}", ex.Status);
// Even if the request "failed" we need to continue reading the response from the router
response = ex.Response as HttpWebResponse;
if (response == null)
throw;
}
return response;
}
async Task<WebResponse> GetWebResponseTaskAsync (WebRequest request, CancellationToken token)
{
token.ThrowIfCancellationRequested ();
WebResponse response = await request.GetResponseAsync ();
token.ThrowIfCancellationRequested ();
responseHeaders = response.Headers;
return response;
}
private static async Task<bool> RequestImagePathTryBingApiAsync(Uri uri, string path)
{
galleryRequest = WebRequest.CreateHttp(uri);
try
{
using (var response = await galleryRequest.GetResponseAsync())
using (var stream = response.GetResponseStream())
{
try
{
using (var image = Image.FromStream(stream, true, true))
{
image.Save(path, ImageFormat.Jpeg);
}
return true;
}
catch (Exception) { }
}
}
catch (WebException e)
{
// only consume case where response isn't canceled
if (e.Status == WebExceptionStatus.RequestCanceled) throw e;
galleryRequest = null;
}
return false;
}
private async Task SendRequestAsync(WebRequest request)
{
using (Stream requestStream = await request.GetRequestStreamAsync().ConfigureAwait(false))
{
await requestStream.WriteAsync(this.Content, 0, this.Content.Length).ConfigureAwait(false);
}
using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
{
}
}
public async System.Threading.Tasks.Task <IEnumerable <session_response> > Get()
{
try
{
string request_string = Program.config_couchdb_url + "/_session";
System.Net.WebRequest request = System.Net.WebRequest.Create(new Uri(request_string));
request.PreAuthenticate = false;
if (!string.IsNullOrWhiteSpace(this.Request.Cookies["AuthSession"]))
{
string auth_session_value = this.Request.Cookies["AuthSession"];
request.Headers.Add("Cookie", "AuthSession=" + auth_session_value);
request.Headers.Add("X-CouchDB-WWW-Authenticate", auth_session_value);
}
/*
* if(this.Request.Headers.Contains("Cookie") && this.Request.Headers.GetValues("Cookie").Count() > 0)
* {
* string[] cookie_set = this.Request.Headers.GetValues("Cookie").First().Split(';');
* for(int i = 0; i < cookie_set.Length; i++)
* {
* string[] auth_session_token = cookie_set[i].Split('=');
* if(auth_session_token[0].Trim() == "AuthSession")
* {
* request.Headers.Add("Cookie", "AuthSession=" + auth_session_token[1]);
* request.Headers.Add("X-CouchDB-WWW-Authenticate", auth_session_token[1]);
* break;
* }
* }
* }
*/
System.Net.WebResponse response = await request.GetResponseAsync();
System.IO.Stream dataStream = response.GetResponseStream();
System.IO.StreamReader reader = new System.IO.StreamReader(dataStream);
string responseFromServer = reader.ReadToEnd();
session_response json_result = Newtonsoft.Json.JsonConvert.DeserializeObject <session_response>(responseFromServer);
if (response.Headers["Set-Cookie"] != null)
{
string[] set_cookie = response.Headers["Set-Cookie"].Split(';');
string[] auth_array = set_cookie[0].Split('=');
if (auth_array.Length > 1)
{
string auth_session_token = auth_array[1];
json_result.auth_session = auth_session_token;
}
else
{
json_result.auth_session = "";
}
}
/*
* < HTTP/1.1 200 OK
* < Set-Cookie: AuthSession=YW5uYTo0QUIzOTdFQjrC4ipN-D-53hw1sJepVzcVxnriEw;
* < Version=1; Path=/; HttpOnly
* > ...
* <
* {"ok":true}*/
session_response[] result = new session_response[]
{
json_result
};
return(result);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
private static async Task DownloadAndSavePhoto(string targetFileName, WebRequest request, byte[] buffer)
{
using (var target = new FileStream(targetFileName, FileMode.Create, FileAccess.Write))
{
using (WebResponse response = await request.GetResponseAsync())
{
using (Stream stream = response.GetResponseStream())
{
int read;
while ((read = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
await target.WriteAsync(buffer, 0, read);
}
}
}
}
}
private async Task<string> ReadResponseAsync(WebRequest webRequest)
{
try
{
using (var response = await webRequest.GetResponseAsync())
{
return ReadWebResponse(response);
}
}
catch (WebException ex)
{
throw GenerateWebReqestGetResponseException(ex, webRequest);
}
}
private async static Task<HttpWebResponse> GetWebResponse(WebRequest wreq)
{
WebResponse webResponse;
webResponse = await wreq.GetResponseAsync();
return (HttpWebResponse)webResponse;
}
/// <summary>Creates a Task that respresents downloading all of the data from a WebRequest.</summary>
/// <param name="webRequest">The WebRequest.</param>
/// <returns>A Task containing the downloaded content.</returns>
public static Task <byte[]> DownloadDataAsync(this WebRequest webRequest)
{
return(webRequest.GetResponseAsync().ContinueWith <Task <byte[]> >(response => response.Result.GetResponseStream().ReadAllBytesAsync()).Unwrap <byte[]>());
}
private static async Task<string> ExecuteWebRequestAsync(WebRequest request)
{
ExceptionDispatchInfo capturedException;
try
{
using (var response = await request.GetResponseAsync())
{
return await ReadStreamAsync(response.GetResponseStream());
}
}
catch (WebException ex)
{
if (ex.Response == null)
{
throw;
}
capturedException = ExceptionDispatchInfo.Capture(ex);
}
var wex = (WebException)capturedException.SourceException;
var statusCode = ((HttpWebResponse)wex.Response).StatusCode;
using (var stream = wex.Response.GetResponseStream())
{
var result = await ReadStreamAsync(stream);
var stripeError = request.RequestUri.ToString().Contains("oauth")
? Mapper<StripeError>.MapFromJson(result)
: Mapper<StripeError>.MapFromJson(result, "error");
throw new StripeException(statusCode, stripeError, stripeError.Message);
}
}
async void GetWeatherForcast(string place)
{
string apiKey = "bae28df78f81c27a2be7a7e3f1ef3c4e";
string apiBase = "https://api.openweathermap.org/data/2.5/forecast?q=";
string unit = "metric";
if (string.IsNullOrEmpty(place))
{
Toast.MakeText(this, "please enter a valid city name", ToastLength.Short).Show();
return;
}
if (!CrossConnectivity.Current.IsConnected)
{
Toast.MakeText(this, "No internet connection", ToastLength.Short).Show();
return;
}
ShowProgressDialogue("Fetching weather...");
// Asynchronous API call using HttpClient
string url = apiBase + place + "&appid=" + apiKey + "&units=" + unit;
var handler = new HttpClientHandler();
using (var client = new HttpClient(handler))
{
HttpResponseMessage response = await client.GetAsync(url);
if (response.IsSuccessStatusCode)
{
var result = await client.GetStringAsync(url);
if (!string.IsNullOrEmpty(result))
{
Console.WriteLine(result);
var resultObject = JObject.Parse(result);
string weatherDescription1 = resultObject["list"][5]["weather"][0]["description"].ToString();
string weatherDescription2 = resultObject["list"][13]["weather"][0]["description"].ToString();
string weatherDescription3 = resultObject["list"][21]["weather"][0]["description"].ToString();
string icon1 = resultObject["list"][5]["weather"][0]["icon"].ToString();
string icon2 = resultObject["list"][13]["weather"][0]["icon"].ToString();
string icon3 = resultObject["list"][21]["weather"][0]["icon"].ToString();
string temperature1 = resultObject["list"][5]["main"]["temp"].ToString();
string temperature2 = resultObject["list"][13]["main"]["temp"].ToString();
string temperature3 = resultObject["list"][21]["main"]["temp"].ToString();
string Day1 = resultObject["list"][5]["dt_txt"].ToString().Substring(0, 10);
string Day2 = resultObject["list"][13]["dt_txt"].ToString().Substring(0, 10);
string Day3 = resultObject["list"][21]["dt_txt"].ToString().Substring(0, 10);
weatherDescription1 = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(weatherDescription1);
txtDesFirst.Text = weatherDescription1;
txtDesSecond.Text = weatherDescription2;
txtDesThird.Text = weatherDescription3;
txtTempFirst.Text = temperature1;
txtTempSecond.Text = temperature2;
txtTempThird.Text = temperature3;
txtDayFirst.Text = Day1;
txtDaySecond.Text = Day2;
txtDayThird.Text = Day3;
// Download Image using WebRequest
string ImageUrl1 = "http://openweathermap.org/img/w/" + icon1 + ".png";
System.Net.WebRequest request1 = default(System.Net.WebRequest);
request1 = WebRequest.Create(ImageUrl1);
request1.Timeout = int.MaxValue;
request1.Method = "GET";
MemoryStream ms1 = new MemoryStream();
(await request1.GetResponseAsync()).GetResponseStream().CopyTo(ms1);
byte[] imageData1 = ms1.ToArray();
Bitmap bitmap1 = BitmapFactory.DecodeByteArray(imageData1, 0, imageData1.Length);
weatherImageFirst.SetImageBitmap(bitmap1);
// Download Image using WebRequest
string ImageUrl2 = "http://openweathermap.org/img/w/" + icon2 + ".png";
System.Net.WebRequest request2 = default(System.Net.WebRequest);
request2 = WebRequest.Create(ImageUrl2);
request2.Timeout = int.MaxValue;
request2.Method = "GET";
MemoryStream ms2 = new MemoryStream();
(await request2.GetResponseAsync()).GetResponseStream().CopyTo(ms2);
byte[] imageData2 = ms2.ToArray();
Bitmap bitmap2 = BitmapFactory.DecodeByteArray(imageData2, 0, imageData2.Length);
weatherImageSecond.SetImageBitmap(bitmap2);
// Download Image using WebRequest
string ImageUrl3 = "http://openweathermap.org/img/w/" + icon3 + ".png";
System.Net.WebRequest request3 = default(System.Net.WebRequest);
request3 = WebRequest.Create(ImageUrl3);
request3.Timeout = int.MaxValue;
request3.Method = "GET";
MemoryStream ms3 = new MemoryStream();
(await request3.GetResponseAsync()).GetResponseStream().CopyTo(ms3);
byte[] imageData3 = ms3.ToArray();
Bitmap bitmap3 = BitmapFactory.DecodeByteArray(imageData3, 0, imageData3.Length);
weatherImageThird.SetImageBitmap(bitmap3);
}
else
{
Toast.MakeText(this, "invalid city name", ToastLength.Short).Show();
}
}
else
{
Toast.MakeText(this, "an error occured please try again", ToastLength.Short).Show();
}
}
ClossProgressDialogue();
}
public override WebResponse GetResponse(WebRequest webRequest)
{
var task = webRequest.GetResponseAsync();
task.Wait();
var webRes = task.Result;
return webRes;
}
async void GetWeather(string place)
{
string apiKey = "bae28df78f81c27a2be7a7e3f1ef3c4e";
string apiBase = "https://api.openweathermap.org/data/2.5/weather?q=";
string unit = "metric";
if (string.IsNullOrEmpty(place))
{
Toast.MakeText(this, "please enter a valid city name", ToastLength.Short).Show();
return;
}
if (!CrossConnectivity.Current.IsConnected)
{
Toast.MakeText(this, "No internet connection", ToastLength.Short).Show();
return;
}
ShowProgressDialogue("Fetching weather...");
// Asynchronous API call using HttpClient
string url = apiBase + place + "&appid=" + apiKey + "&units=" + unit;
var handler = new HttpClientHandler();
HttpClient client = new HttpClient(handler);
string result = await client.GetStringAsync(url);
Console.WriteLine(result);
var resultObject = JObject.Parse(result);
string weatherDescription = resultObject["weather"][0]["description"].ToString();
string icon = resultObject["weather"][0]["icon"].ToString();
string temperature = resultObject["main"]["temp"].ToString();
string placename = resultObject["name"].ToString();
string country = resultObject["sys"]["country"].ToString();
weatherDescription = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(weatherDescription);
weatherDescriptionTextView.Text = weatherDescription;
placeTextView.Text = placename + ", " + country;
temperatureTextView.Text = temperature;
// Download Image using WebRequest
string ImageUrl = "http://openweathermap.org/img/w/" + icon + ".png";
System.Net.WebRequest request = default(System.Net.WebRequest);
request = WebRequest.Create(ImageUrl);
request.Timeout = int.MaxValue;
request.Method = "GET";
WebResponse response = default(WebResponse);
response = await request.GetResponseAsync();
MemoryStream ms = new MemoryStream();
response.GetResponseStream().CopyTo(ms);
byte[] imageData = ms.ToArray();
Bitmap bitmap = BitmapFactory.DecodeByteArray(imageData, 0, imageData.Length);
weatherImageView.SetImageBitmap(bitmap);
ClossProgressDialogue();
}
private async Task<RavenJToken> ReadJsonInternalAsync(WebRequest responseTask)
{
WebResponse response;
try
{
response = await responseTask.GetResponseAsync().ConfigureAwait(false);
sp.Stop();
}
catch (WebException e)
{
sp.Stop();
var result = HandleErrors(e);
if (result == null)
throw;
return result;
}
ResponseHeaders = new NameValueCollection(response.Headers);
ResponseStatusCode = ((HttpWebResponse)response).StatusCode;
HandleReplicationStatusChanges(ResponseHeaders, primaryUrl, operationUrl);
using (response)
using (var responseStream = response.GetResponseStreamWithHttpDecompression())
{
var data = await RavenJToken.TryLoadAsync(responseStream).ConfigureAwait(false);
if (Method == "GET" && ShouldCacheRequest)
{
factory.CacheResponse(Url, data, ResponseHeaders);
}
factory.InvokeLogRequest(owner, () => new RequestResultArgs
{
DurationMilliseconds = CalculateDuration(),
Method = webRequest.Method,
HttpResult = (int) ResponseStatusCode,
Status = RequestStatus.SentToServer,
Result = (data ?? "").ToString(),
Url = webRequest.RequestUri.PathAndQuery,
PostedData = postedData
});
return data;
}
}
static IEnumerable<Task> _getResponseAsync(TaskCompletionSource<WebResponse> tcs, WebRequest request, TimeSpan timeout)
{
using (var cancellation_token = new Concurrency.TimeoutToken(timeout))
using (var registration_token = cancellation_token.Token.Register(() => { request.Abort(); }))
{
using (var task_get_response = request.GetResponseAsync())
{
yield return task_get_response;
tcs.SetFromTask(task_get_response);
yield break;
}
}
}
protected virtual void ExecuteWebRequestAsync(WebRequest buildGetWebRequest)
{
if (buildGetWebRequest == null)
{
return;
}
buildGetWebRequest.GetResponseAsync();
}
private static async Task<string> ExecuteWebRequestAsync(WebRequest webRequest)
{
try
{
using (var response = await webRequest.GetResponseAsync())
{
return await ReadStreamAsync(response.GetResponseStream());
}
}
catch (WebException webException)
{
if (webException.Response != null)
{
var statusCode = ((HttpWebResponse)webException.Response).StatusCode;
var stripeError = new StripeError();
if (webRequest.RequestUri.ToString().Contains("oauth"))
stripeError = Mapper<StripeError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()));
else
stripeError = Mapper<StripeError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()), "error");
throw new StripeException(statusCode, stripeError, stripeError.Message);
}
throw;
}
}
