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));
}
