public static Response <T> HttpGet <T>(string address, Encoding encoding = null, WebProxy proxy = null, string bearer = null, string contentType = contentTypeJson) where T : class { try { //WebClient client = new WebClient(); //client.Headers.Add(HttpRequestHeader.ContentType, contentType); //client.Headers.Add(HttpRequestHeader.UserAgent, "application!"); //client.Encoding = encoding; //if (proxy?.Address != null) //{ // client.Proxy = proxy; //} var client = CreateWebClient(contentType, encoding, proxy, bearer); var stringResult = client.DownloadString(address); return(ResponseFactory.Create(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(stringResult))); } catch (Exception ex) { return(ResponseFactory.CreateError <T>(ex.Message)); } }
public static Response <string> HttpGetString(string address, string contentType = contentTypeJson, WebProxy proxy = null) { try { //WebClient client = new WebClient(); //client.Headers.Add(HttpRequestHeader.ContentType, contentType); //client.Headers.Add(HttpRequestHeader.UserAgent, "application!"); //client.Encoding = Encoding.UTF8; //if (proxy?.Address != null) //{ // client.Proxy = proxy; //} var client = CreateWebClient(contentType, Encoding.UTF8, proxy, bearer: null); var stringResult = client.DownloadString(address); return(ResponseFactory.Create(stringResult)); } catch (Exception ex) { return(ResponseFactory.CreateError <string>(ex.Message)); } }
public static async Task <Response <GoogleGeolocationResult> > GetLocationAsync(string key) { try { var networks = NativeWifi.EnumerateBssNetworks(); var wifiAccessPoints = networks.Select(i => new Wifiaccesspoint() { channel = i.Channel, macAddress = i.Bssid.ToString(), signalStrength = i.SignalStrength, }).ToArray(); // //System.IO.File.WriteAllText("vezarat.txt", Newtonsoft.Json.JsonConvert.SerializeObject(wifiAccessPoints)); foreach (var item in wifiAccessPoints) { Debug.WriteLine($"mac: {item.macAddress}, signal:{item.signalStrength}, channel: {item.channel}"); } return(await GetLocationAsync(key, wifiAccessPoints)); //var url = $"https://www.googleapis.com/geolocation/v1/geolocate?key={key}"; //return await Helpers.NetHelper.HttpPostAsync<GoogleGeolocationResult>(url, parameter); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); //return new GoogleGeolocationResult() { accuracy = int.MaxValue }; return(ResponseFactory.CreateError <GoogleGeolocationResult>(ex.GetMessagePlus())); } }
// 1400.02.14 // send encrypted message and get encrypted message public async static Task <Response <TResponse> > EncryptedHttpPostAsync <TResponse>(string url, object parameter, WebProxy proxy, string encPubKey, string decPriKey) where TResponse : class { try { var message = EncryptedMessage.Create(parameter, encPubKey); //var response = await NetHelper.HttpPostAsync<EncryptedMessage>(url, message, null, proxy); var response = await NetHelper.HttpPostAsync <EncryptedMessage>(new HttpParameters() { Address = url, Data = message, Proxy = proxy }); if (response.HasNotNullResult()) { return(ResponseFactory.Create <TResponse>(response.Result.Decrypt <TResponse>(decPriKey))); } else { return(ResponseFactory.CreateError <TResponse>(response.ErrorMessage)); } } catch (Exception ex) { return(ResponseFactory.CreateError <TResponse>(ex.Message)); } }
public static Response <T> HttpPost <T>(HttpParameters parameters) where T : class { try { var result = HttpPostString(parameters); return(ResponseFactory.Create <T>(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(result.Result))); } catch (Exception ex) { return(ResponseFactory.CreateError <T>(ex.GetFullMessage())); } }
public static Response <bool> HttpDelete(string address, string contentType = contentTypeJson, WebProxy proxy = null, string bearerToken = null) { try { var client = CreateWebClient(contentType, Encoding.UTF8, proxy, bearer: bearerToken); var stringResult = client.UploadData(address, "DELETE", new byte[0]); return(ResponseFactory.Create(true)); } catch (Exception ex) { return(ResponseFactory.CreateError <bool>(ex.Message)); } }
public static async Task <Response <string> > HttpPostXmlAsync(string address, string xmlData, Encoding encoding, WebProxy proxy = null) { try { var client = CreateWebClient(contentTypeXml, encoding, proxy); var stringResult = await client.UploadStringTaskAsync(address, xmlData); return(ResponseFactory.Create <string>(stringResult)); } catch (Exception ex) { return(ResponseFactory.CreateError <string>(ex.Message)); } }
public static async Task <Response <BingIsolineResult> > GetIsolineAsync(Point centerGeographic, double timeLimit, string key) { try { var pointString = $"{centerGeographic.Y.ToString(CultureInfo.InvariantCulture)},{centerGeographic.X.ToString(CultureInfo.InvariantCulture)}"; var url = $"https://dev.virtualearth.net/REST/v1/Routes/Isochrones?waypoint={pointString}&maxTime={timeLimit}&timeUnit=second&key={key}"; return(await Helpers.NetHelper.HttpGetAsync <BingIsolineResult>(url)); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return(ResponseFactory.CreateError <BingIsolineResult>(ex.GetMessagePlus())); } }
public static async Task <Response <HereIsolineResult> > GetIsolineAsync(Point centerGeographic, double timeLimit, string appCode, string appId) { try { var pointString = $"{centerGeographic.Y.ToString(CultureInfo.InvariantCulture)},{centerGeographic.X.ToString(CultureInfo.InvariantCulture)}"; var url = $"https://isoline.route.api.here.com/routing/7.2/calculateisoline.json?app_id={appId}&app_code={appCode}&start=geo!{pointString}&range={timeLimit}&rangetype=time&mode=shortest;car;traffic:enabled"; return(await Helpers.NetHelper.HttpGetAsync <HereIsolineResult>(url)); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return(ResponseFactory.CreateError <HereIsolineResult>(ex.GetMessagePlus())); } }
public static async Task <Response <GeoReferencedImage> > GetAsync(Point centerGeoPoint, int width, int height, BoundingBox mbb, int zoom) { try { WebClient client = new WebClient(); var center = mbb.Center; var url = $@"https://maps.googleapis.com/maps/api/staticmap?center={center.Y},{center.X}&zoom={zoom}&size={width}x{height}&maptype=roadmap"; var byteImage = await client.DownloadDataTaskAsync(url); return(ResponseFactory.Create(new GeoReferencedImage(byteImage, mbb))); } catch (Exception ex) { return(ResponseFactory.CreateError <GeoReferencedImage>(ex.GetMessagePlus())); } }
private static Response <string> HttpUploadString(HttpParameters parameters, string httpMethod) { try { var client = CreateWebClient(parameters.ContentType, parameters.Encoding, parameters.Proxy, parameters.Bearer, parameters.Headers); var stringData = Newtonsoft.Json.JsonConvert.SerializeObject(parameters.Data, new Newtonsoft.Json.JsonSerializerSettings() { NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore }); var stringResult = client.UploadString(parameters.Address, httpMethod, stringData); return(ResponseFactory.Create(stringResult)); } catch (Exception ex) { return(ResponseFactory.CreateError <string>(ex.Message)); } }
public static async Task <Response <GoogleDirectionsResult> > GetDirectionAsync(Point start, Point end, string key) { try { var startString = GoogleServiceUtility.ParseToString(start); var endString = GoogleServiceUtility.ParseToString(end); var time = GoogleServiceUtility.GetNow(); var url = $"https://maps.googleapis.com/maps/api/directions/json?origin={startString}&destination={endString}&alternatives=true&departure_time={time}&key={key}"; return(await Helpers.NetHelper.HttpGetAsync <GoogleDirectionsResult>(url)); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return(ResponseFactory.CreateError <GoogleDirectionsResult>(ex.Message)); } }
public static Response <WazeGeoRssResult> GetRss(BoundingBox geographicBound, long _epoc = -1) { //https://www.waze.com/row-rtserver/web/TGeoRSS?ma=600&mj=100&mu=100&left=51.263646841049194&right=51.328981161117554&bottom=35.72281242757668&top=35.74842331753895&_=1520571802973 var time = DateTime.UtcNow - IRI.Ket.Common.Extensions.DateTimeExtensions.JulianDate; long epoc = ((long)time.TotalSeconds) * (long)1000; epoc = _epoc > 0 ? _epoc : epoc; //epoc = 1520571803066; var url = $"https://www.waze.com/row-rtserver/web/TGeoRSS?ma=600&mj=1&mu=400&left={geographicBound.XMin}&right={geographicBound.XMax}&bottom={geographicBound.YMin}&top={geographicBound.YMax}&_={epoc}"; //var result = await IRI.Ket.Common.Helpers.NetHelper.HttpGetAsync<WazeGeoRssResult>(url); try { WebClient client = new WebClient(); client.Headers.Add(HttpRequestHeader.Accept, "application/json, text/javascript, */*; q=0.01"); client.Headers.Add(HttpRequestHeader.AcceptLanguage, "en-US,en;q=0.9"); client.Headers.Add(HttpRequestHeader.Cookie, "_csrf_token=MGNYlmxqIUAR87QomEqOgXyEIvXOQ7ni1WK_EMqyYk8;_web_session=YlBPcnpkY0pNeHUzYU9LOXQ2aGtlWDYzeTBrQ2c2UHZuNk1VNmhnUkpibz0tLVlDUFF6bkZIeGFmUjhHUlNET2kwRUE9PQ%3D%3D--87c91cc13cedf517dc0bf3f1770e9d092f83e116;_ga=GA1.2.1611471394.1520548309;_gid=GA1.2.441536613.1520548309"); client.Headers.Add(HttpRequestHeader.Host, "www.waze.com"); client.Headers.Add("X-Requested-With", "XMLHttpRequest"); client.Headers.Add(HttpRequestHeader.Referer, "https://www.waze.com/livemap"); client.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip, deflate, br"); client.Headers.Add(HttpRequestHeader.UserAgent, "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36"); client.Encoding = Encoding.UTF8; var stringResult = new StreamReader(new GZipStream(client.OpenRead(url), CompressionMode.Decompress)).ReadToEnd(); var result = Newtonsoft.Json.JsonConvert.DeserializeObject <WazeGeoRssResult>(stringResult); return(ResponseFactory.Create(result)); } catch (Exception ex) { return(ResponseFactory.CreateError <WazeGeoRssResult>(ex.GetMessagePlus())); } }
public static async Task <Response <GoogleDistanceMatrixResult> > GetDistanceMatrixAsync(List <Point> origins, List <Point> destinations, string key) { try { var originString = string.Join("|", origins.Select(p => $"{p.Y.ToString(CultureInfo.InvariantCulture)},{p.X.ToString(CultureInfo.InvariantCulture)}")); var destinationString = string.Join("|", destinations.Select(p => $"{p.Y.ToString(CultureInfo.InvariantCulture)},{p.X.ToString(CultureInfo.InvariantCulture)}")); var time = (int)(DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds; var url = $"https://maps.googleapis.com/maps/api/distancematrix/json?units=metric&origins={originString}&destinations={destinationString}&departure_time={time}&key={key}"; return(await Helpers.NetHelper.HttpGetAsync <GoogleDistanceMatrixResult>(url)); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return(ResponseFactory.CreateError <GoogleDistanceMatrixResult>(ex.GetMessagePlus())); //return new Response<GoogleDistanceMatrixResult>() { Result = new GoogleDistanceMatrixResult() { rows = new Row[0] }, IsFailed = true, ErrorMessage = ex.Message }; } }
public static async Task <Response <GoogleGeolocationResult> > GetLocationAsync(string key, Wifiaccesspoint[] networks, System.Net.WebProxy proxy = null) { try { var parameter = new GoogleGeolocationParameters() { wifiAccessPoints = networks }; var url = $"https://www.googleapis.com/geolocation/v1/geolocate?key={key}"; return(await Helpers.NetHelper.HttpPostAsync <GoogleGeolocationResult>(new Helpers.HttpParameters() { Address = url, Data = parameter, Proxy = proxy })); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return(ResponseFactory.CreateError <GoogleGeolocationResult>(ex.GetMessagePlus())); } }
private static async Task <Response <GoogleOAuthUserInfoResult> > GetUserInfo(string access_token) { //("Making API Call to Userinfo..."); // builds the request // sends the request HttpWebRequest userinfoRequest = (HttpWebRequest)WebRequest.Create(userinfoRequestURI); userinfoRequest.Method = "GET"; userinfoRequest.Headers.Add(string.Format("Authorization: Bearer {0}", access_token)); userinfoRequest.ContentType = "application/x-www-form-urlencoded"; userinfoRequest.Accept = "Accept=text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"; // gets the response WebResponse userinfoResponse = await userinfoRequest.GetResponseAsync(); string resultString = null; using (StreamReader userinfoResponseReader = new StreamReader(userinfoResponse.GetResponseStream())) { // reads response body //string userinfoResponseText = await userinfoResponseReader.ReadToEndAsync(); //output(userinfoResponseText); resultString = await userinfoResponseReader.ReadToEndAsync(); } try { return(ResponseFactory.Create(JsonHelper.ParseFromJson <GoogleOAuthUserInfoResult>(resultString))); } catch (Exception ex) { return(ResponseFactory.CreateError <GoogleOAuthUserInfoResult>(ex.Message)); } }
public static async Task <MapzenIsochroneResult> GetIsochroneAsync(Point geodeticPoint, string apiKey) { // var url = $"matrix.mapzen.com/isochrone?json={{\"locations\":[{{\"lat\":{geodeticPoint.Y},\"lon\":{geodeticPoint.X}}}],\"costing\":\"bicycle\",\"contours\":[{{\"time\":15,\"color\":\"ff0000\"}}]}}&id=Walk_From_Office&api_key={apiKey}"; var parameter = new MapzenRouteCostingModel() { locations = new Location[] { new Location() { lon = geodeticPoint.X, lat = geodeticPoint.Y } }, costing = "auto", contours = new Contour[] { new Contour() { time = 4, color = "ff0000" } }, polygons = true, }; var url = $"http://matrix.mapzen.com/isochrone?id=Walk_From_Office&api_key={apiKey}"; var result = await Helpers.NetHelper.HttpPostAsync <MapzenIsochroneResult>(new Helpers.HttpParameters() { Address = url, Data = parameter }); if (result == null) { ResponseFactory.CreateError <string>("NULL VALUE"); return(null); } else { return(ResponseFactory.Create(result?.Result)?.Result); } }
public static Response <GoogleGeolocationResult> GetLocation(string key, List <Wifiaccesspoint> networks) { try { var parameter = new GoogleGeolocationParameters() { wifiAccessPoints = networks.ToArray() }; var url = $"https://www.googleapis.com/geolocation/v1/geolocate?key={key}"; //return Helpers.NetHelper.HttpPost<GoogleGeolocationResult>(url, parameter, null, null); return(Helpers.NetHelper.HttpPost <GoogleGeolocationResult>(new Helpers.HttpParameters() { Address = url, Data = parameter })); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return(ResponseFactory.CreateError <GoogleGeolocationResult>(ex.GetMessagePlus())); } }
public static Response <byte[]> HttpGetDownloadData(string address, string contentType, WebProxy proxy = null) { try { //WebClient client = new WebClient(); //client.Headers.Add(HttpRequestHeader.ContentType, contentType); //client.Headers.Add(HttpRequestHeader.UserAgent, "application!"); //if (proxy?.Address != null) //{ // client.Proxy = proxy; //} var client = CreateWebClient(contentType, null, proxy, bearer: null); var resultByteArray = client.DownloadData(address); return(ResponseFactory.Create(resultByteArray)); } catch (Exception ex) { return(ResponseFactory.CreateError <byte[]>(ex.Message)); } }
public static Response <byte[]> HttpPostDownloadData(string address, object data, Encoding encoding, string contentType = contentTypeJson, WebProxy proxy = null, string bearer = null) { try { //WebClient client = new WebClient(); //client.Headers.Add(HttpRequestHeader.ContentType, contentType); //client.Headers.Add(HttpRequestHeader.UserAgent, "application!"); //if (!string.IsNullOrWhiteSpace(bearer)) //{ // client.Headers.Add(HttpRequestHeader.Authorization, $"Bearer {bearer}"); //} //client.Encoding = encoding; //if (proxy?.Address != null) //{ // client.Proxy = proxy; //} var client = CreateWebClient(contentType, encoding, proxy, bearer); var stringData = Newtonsoft.Json.JsonConvert.SerializeObject(data, new Newtonsoft.Json.JsonSerializerSettings() { NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore }); var result = client.UploadData(address, Encoding.UTF8.GetBytes(stringData)); return(ResponseFactory.Create(result)); } catch (Exception ex) { return(ResponseFactory.CreateError <byte[]>(ex.Message)); } }
private static async Task <Response <GoogleOAuthUserInfoResult> > PerformCodeExchange(string code, string code_verifier, string redirectURI) { //("Exchanging code for tokens..."); // builds the request //string tokenRequestURI = "https://www.googleapis.com/oauth2/v4/token"; string tokenRequestBody = string.Format("code={0}&redirect_uri={1}&client_id={2}&code_verifier={3}&client_secret={4}&scope=&grant_type=authorization_code", code, System.Uri.EscapeDataString(redirectURI), _clientID, code_verifier, _clientSecret ); // sends the request HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenRequestURI); tokenRequest.Method = "POST"; tokenRequest.ContentType = "application/x-www-form-urlencoded"; tokenRequest.Accept = "Accept=text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"; byte[] _byteVersion = Encoding.ASCII.GetBytes(tokenRequestBody); tokenRequest.ContentLength = _byteVersion.Length; Stream stream = tokenRequest.GetRequestStream(); await stream.WriteAsync(_byteVersion, 0, _byteVersion.Length); stream.Close(); try { // gets the response WebResponse tokenResponse = await tokenRequest.GetResponseAsync(); using (StreamReader reader = new StreamReader(tokenResponse.GetResponseStream())) { // reads response body string responseText = await reader.ReadToEndAsync(); //output(responseText); // converts to dictionary Dictionary <string, string> tokenEndpointDecoded = Newtonsoft.Json.JsonConvert.DeserializeObject <Dictionary <string, string> >(responseText); string access_token = tokenEndpointDecoded["access_token"]; return(await GetUserInfo(access_token)); } } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { var response = ex.Response as HttpWebResponse; if (response != null) { //output("HTTP: " + response.StatusCode); using (StreamReader reader = new StreamReader(response.GetResponseStream())) { // reads response body string responseText = reader.ReadToEnd(); return(ResponseFactory.CreateError <GoogleOAuthUserInfoResult>(responseText)); //output(responseText); } } } } return(ResponseFactory.CreateError <GoogleOAuthUserInfoResult>(string.Empty)); }
public static async Task <Response <GoogleOAuthUserInfoResult> > RunOAuth2() { // Generates state and PKCE values. string state = CryptographyHelper.GetRandomDataBase64url(32); string code_verifier = CryptographyHelper.GetRandomDataBase64url(32); string code_challenge = CryptographyHelper.GetBase64urlEncodeNoPadding(HashAlgorithmHelper.GetSha256(code_verifier)); const string code_challenge_method = "S256"; // Creates a redirect URI using an available port on the loopback address. string redirectURI = string.Format("http://{0}:{1}/", IPAddress.Loopback, NetHelper.GetRandomUnusedPort()); //output("redirect URI: " + redirectURI); // Creates an HttpListener to listen for requests on that redirect URI. var http = new HttpListener(); http.Prefixes.Add(redirectURI); //output("Listening.."); http.Start(); // Creates the OAuth 2.0 authorization request. string authorizationRequest = string.Format("{0}?response_type=code&scope=email%20openid%20profile&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}", authorizationEndpoint, System.Uri.EscapeDataString(redirectURI), _clientID, state, code_challenge, code_challenge_method); // Opens request in the browser. System.Diagnostics.Process.Start(authorizationRequest); // Waits for the OAuth authorization response. var context = await http.GetContextAsync(); // Brings this app back to the foreground. //this.Activate(); // Sends an HTTP response to the browser. var response = context.Response; string responseString = string.Format("<html><head><meta http-equiv='refresh' content='10;url=https://google.com'></head><body>Please return to the app.</body></html>"); var buffer = System.Text.Encoding.UTF8.GetBytes(responseString); response.ContentLength64 = buffer.Length; var responseOutput = response.OutputStream; Task responseTask = responseOutput.WriteAsync(buffer, 0, buffer.Length).ContinueWith((task) => { responseOutput.Close(); http.Stop(); //Console.WriteLine("HTTP server stopped."); }); // Checks for errors. if (context.Request.QueryString.Get("error") != null) { //output(String.Format("OAuth authorization error: {0}.", context.Request.QueryString.Get("error"))); return(ResponseFactory.CreateError <GoogleOAuthUserInfoResult>($"OAuth authorization error: {context.Request.QueryString.Get("error")}.")); } if (context.Request.QueryString.Get("code") == null || context.Request.QueryString.Get("state") == null) { //output("Malformed authorization response. " + context.Request.QueryString); return(ResponseFactory.CreateError <GoogleOAuthUserInfoResult>("Malformed authorization response. " + context.Request.QueryString)); } // extracts the code var code = context.Request.QueryString.Get("code"); var incoming_state = context.Request.QueryString.Get("state"); // Compares the receieved state to the expected value, to ensure that // this app made the request which resulted in authorization. if (incoming_state != state) { //output(String.Format("Received request with invalid state ({0})", incoming_state)); return(ResponseFactory.CreateError <GoogleOAuthUserInfoResult>($"Received request with invalid state ({incoming_state})")); } //output("Authorization code: " + code); // Starts the code exchange at the Token Endpoint. return(await PerformCodeExchange(code, code_verifier, redirectURI)); }