|
public UploadStringTaskAsync ( System address, string data ) : System.Threading.Tasks.Task |
||
| address | System | |
| data | string | |
| return | System.Threading.Tasks.Task |
|
public async void Register(UtsData data)
{
string json = JsonConvert.SerializeObject(data);
Log.Info("Register", json);
// Request Address of the API
string url = Server.url + "api/student/register";
String result = null;
using (WebClient wc = new WebClient())
{
wc.Headers[HttpRequestHeader.ContentType] = "application/json; charset=utf-8";
wc.Headers.Add("AppKey", "66666");
result = await wc.UploadStringTaskAsync(new Uri(url), json);
Log.Info("Register SUCCESS", result);
HomeController loginController = new HomeController();
await loginController.login(data.StudentId);
}
}
public async Task<string> GetAuthenticationData(Dictionary<string, string> authenticationFields)
{
string username = authenticationFields[Field_Username];
string password = authenticationFields[Field_Password];
using (WebClient client = new WebClient())
{
client.Headers.Set("Content-Type", "application/json");
client.Headers.Add(HttpRequestHeader.Authorization, $"Basic {Base64Encode(username + ":" + password)}");
string json = await client.UploadStringTaskAsync($"{BitlyBaseUrl}/oauth/access_token", $"grant_type=password&username={username}&password={password}");
if (json.StartsWith("{"))
{
json = json.Replace(@"""data"": [ ], ", string.Empty);
JsonResponse data = JsonConvert.DeserializeObject<JsonResponse>(json);
if (data.status_txt == "OK")
{
return data.data.url;
}
else
{
throw new Exception(data.status_txt);
}
}
else
{
return json;
}
}
}
public async Task <string> DeleteAsync(WebHeaderCollection headers, string address, string data)
{
System.Net.WebClient client = new System.Net.WebClient
{
Headers = headers,
CachePolicy = new HttpRequestCachePolicy()
};
client.Headers["UserAgent"] = _userAgent;
try
{
return(await client.UploadStringTaskAsync(address, "DELETE", data));
}
catch (WebException e)
{
EsiModel returned = BuildException(e, null, null, address, data);
if (returned != null)
{
return(string.Empty);
}
throw;
}
}
public async void SendNotification(string channelURI, string payload, NotificationType type = NotificationType.Raw)
{
if (WNSAuthentication.Instance.oAuthToken.AccessToken != null && !WNSAuthentication.Instance.IsRefreshInProgress)
{
using (var client = new WebClient())
{
SetHeaders(type, client);
try
{
await client.UploadStringTaskAsync(new Uri(channelURI), payload);
}
catch (WebException webException)
{
if (webException?.Response != null)
HandleError(((HttpWebResponse)webException.Response).StatusCode, channelURI, payload);
Debug.WriteLine(String.Format("Failed WNS authentication. Error: {0}", webException.Message));
}
catch (Exception)
{
HandleError(HttpStatusCode.Unauthorized, channelURI, payload);
}
}
}
else
{
StoreNotificationForSending(channelURI, payload);
}
}
async public Task SendEvent()
{
using (var client = new WebClient()) {
client.Headers[HttpRequestHeader.ContentType] = "application/json";
await client.UploadStringTaskAsync(sseUri, "POST", JsonConvert.SerializeObject(this));
/* exception handling? what would we even do...
try {
result = (await client.UploadStringTaskAsync(new Uri(url), "POST", json));
}
catch (WebException exception) {
string responseText;
if (exception.Response != null) {
var responseStream = exception.Response.GetResponseStream();
if (responseStream != null) {
using (var reader = new StreamReader(responseStream)) {
responseText = reader.ReadToEnd();
Debug.WriteLine(responseText);
}
}
}
}
*/
}
}
public void RSPEC_WebClient(string address, Uri uriAddress, byte[] data,
NameValueCollection values)
{
System.Net.WebClient webclient = new System.Net.WebClient();
// All of the following are Questionable although there may be false positives if the URI scheme is "ftp" or "file"
//webclient.Download * (...); // Any method starting with "Download"
webclient.DownloadData(address); // Noncompliant
webclient.DownloadDataAsync(uriAddress, new object()); // Noncompliant
webclient.DownloadDataTaskAsync(uriAddress); // Noncompliant
webclient.DownloadFile(address, "filename"); // Noncompliant
webclient.DownloadFileAsync(uriAddress, "filename"); // Noncompliant
webclient.DownloadFileTaskAsync(address, "filename"); // Noncompliant
webclient.DownloadString(uriAddress); // Noncompliant
webclient.DownloadStringAsync(uriAddress, new object()); // Noncompliant
webclient.DownloadStringTaskAsync(address); // Noncompliant
// Should not raise for events
webclient.DownloadDataCompleted += Webclient_DownloadDataCompleted;
webclient.DownloadFileCompleted += Webclient_DownloadFileCompleted;
webclient.DownloadProgressChanged -= Webclient_DownloadProgressChanged;
webclient.DownloadStringCompleted -= Webclient_DownloadStringCompleted;
//webclient.Open * (...); // Any method starting with "Open"
webclient.OpenRead(address);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ {{Make sure that this http request is sent safely.}}
webclient.OpenReadAsync(uriAddress, new object()); // Noncompliant
webclient.OpenReadTaskAsync(address); // Noncompliant
webclient.OpenWrite(address); // Noncompliant
webclient.OpenWriteAsync(uriAddress, "STOR", new object()); // Noncompliant
webclient.OpenWriteTaskAsync(address, "POST"); // Noncompliant
webclient.OpenReadCompleted += Webclient_OpenReadCompleted;
webclient.OpenWriteCompleted += Webclient_OpenWriteCompleted;
//webclient.Upload * (...); // Any method starting with "Upload"
webclient.UploadData(address, data); // Noncompliant
webclient.UploadDataAsync(uriAddress, "STOR", data); // Noncompliant
webclient.UploadDataTaskAsync(address, "POST", data); // Noncompliant
webclient.UploadFile(address, "filename"); // Noncompliant
webclient.UploadFileAsync(uriAddress, "filename"); // Noncompliant
webclient.UploadFileTaskAsync(uriAddress, "POST", "filename"); // Noncompliant
webclient.UploadString(uriAddress, "data"); // Noncompliant
webclient.UploadStringAsync(uriAddress, "data"); // Noncompliant
webclient.UploadStringTaskAsync(uriAddress, "data"); // Noncompliant
webclient.UploadValues(address, values); // Noncompliant
webclient.UploadValuesAsync(uriAddress, values); // Noncompliant
webclient.UploadValuesTaskAsync(address, "POST", values);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// Should not raise for events
webclient.UploadDataCompleted += Webclient_UploadDataCompleted;
webclient.UploadFileCompleted += Webclient_UploadFileCompleted;
webclient.UploadProgressChanged -= Webclient_UploadProgressChanged;
webclient.UploadStringCompleted -= Webclient_UploadStringCompleted;
webclient.UploadValuesCompleted -= Webclient_UploadValuesCompleted;
}
public async Task Delete(string storageKey)
{
var uri = _uriFormatter.FormatUri(storageKey);
_logger.Debug("Deleting blob {0} from {1}", storageKey, uri);
using (var webClient = new WebClient())
{
await webClient.UploadStringTaskAsync(uri, "DELETE", "");
}
}
private async static Task<string> PostRequest(string url)
{
using (var client = new WebClient())
{
client.Headers.Add("user-agent", "my own code");
client.Headers.Add("content-type", "x-www-form-urlencoded");
return await client.UploadStringTaskAsync(url, "test=value");
}
}
public static async Task<string> ApiProcessAsync(string method, string parameter)
{
using (WebClient wc = new WebClient())
{
wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
wc.Encoding = System.Text.Encoding.UTF8;
return await wc.UploadStringTaskAsync(new Uri(Param.ApiUrl + method), parameter + "&apiKey=" + Param.ApiKey);
}
}
public async Task<string> CallServer(string path, object postData)
{
EnsureInitialized();
string url = $"{BASE_URL}:{BasePort}/{path.ToLowerInvariant()}";
using (WebClient client = new WebClient())
{
return await client.UploadStringTaskAsync(url, JsonConvert.SerializeObject(postData));
}
}
private async Task<string> mput(string topic, IEnumerable<string> messages)
{
var path = string.Format("{0}/mput?topic={1}", baseUriString, topic);
var data = string.Join("\n", messages);
using (var http = new WebClient())
{
var resp = await http.UploadStringTaskAsync(path, "POST", data);
return resp;
}
}
private async Task<string> put(string topic, string message)
{
var path = string.Format("{0}/put?topic={1}", baseUriString, topic);
var data = message;
using (var http = new WebClient())
{
var resp = await http.UploadStringTaskAsync(path, "POST", data);
return resp;
}
}
public async Task Delete(string storageKey)
{
if (storageKey == null) throw new ArgumentNullException("storageKey");
var uri = _uriFormatter.FormatUri(storageKey);
_logger.Debug("Deleting blob {0} from {1}", storageKey, uri);
using (var webClient = new WebClient())
{
await webClient.UploadStringTaskAsync(uri, "DELETE", "");
}
}
public static async Task DoRequest(BaseEvent @event, int port)
{
var url = string.Format("http://localhost:{0}/API/Message/NewMessage", port);
var message = _serializer.Serialize<BaseEvent>(@event);
using (WebClient client = new WebClient())
{
client.Encoding = Encoding.UTF8;
client.Headers["Content-Type"] = "application/json; charset=utf-8";
await client.UploadStringTaskAsync(new Uri(url), "POST", message);
}
}
public static async Task<string> PostJson(string url, string jsonData)
{
using(var wc = new WebClient())
{
wc.Encoding = Encoding.UTF8;
wc.Headers.Add(HttpRequestHeader.ContentType, "application/json");
var response = await wc.UploadStringTaskAsync(new Uri(url), jsonData);
return response;
}
}
internal static async Task<string> DownloadDataAsync(string method, string baseUrl, string data, string contentType, string authHeader)
{
var client = new WebClient();
if (!String.IsNullOrEmpty(contentType)) client.Headers["Content-Type"] = contentType;
if (!String.IsNullOrEmpty(authHeader)) client.Headers["Authorization"] = authHeader;
if (method == "POST")
{
return await client.UploadStringTaskAsync(new Uri(baseUrl), data);
}
return await client.DownloadStringTaskAsync(new Uri(baseUrl));
}
//POST /api/automate HTTP/1.1
//Host: automatewebui.azurewebsites.net
//Cache-Control: no-cache
//Content-Type: application/x-www-form-urlencoded
//
//EmailAddress=jm_aba%40ahoo.com&Location=Lehliu&AgresivityRate=99
public async Task<string> Post(ClientStatistics clientStatistics)
{
try
{
var data = _encoder.Encode(clientStatistics);
var client = new WebClient();
client.Headers[HttpRequestHeader.ContentType] = _encoder.ContentType;
return await client.UploadStringTaskAsync(new Uri(_uri), "POST", data);
}
catch (Exception e)
{
return e.Message;
}
}
public static async Task<string> JsonRequest(string url, string data = null)
{
using(var wc = new WebClient())
{
wc.Encoding = Encoding.UTF8;
wc.Headers.Add(HttpRequestHeader.ContentType, "application/json");
var response = "";
if(string.IsNullOrWhiteSpace(data))
response = await wc.DownloadStringTaskAsync(new Uri(url));
else
response = await wc.UploadStringTaskAsync(new Uri(url), data);
return response;
}
}
public static async Task AlignTimeAsync()
{
long currentTime = Util.GetSystemUnixTime();
WebClient client = new WebClient();
try
{
string response = await client.UploadStringTaskAsync(new Uri(APIEndpoints.TWO_FACTOR_TIME_QUERY), "steamid=0");
TimeQuery query = JsonConvert.DeserializeObject<TimeQuery>(response);
TimeAligner._timeDifference = (int)(query.Response.ServerTime - currentTime);
TimeAligner._aligned = true;
}
catch (WebException)
{
return;
}
}
// Run an asynchronous command to the receiver.
public async Task<string> RunCommandAsync(YamahaDevice device, string request)
{
using (var client = new WebClient())
{
try
{
string url = "http://" + device.Address + CONTROL_URI;
return await client.UploadStringTaskAsync(url, "POST", request);
}
catch (Exception e)
{
Log.Warning("Request failed with error: " + e.Message);
}
return default(string);
}
}
async public Task<JsonValue> SendAsync(string Path, string Method, string Data = "", Tuple<string, string>[] RequestHeaders = null)
{
var WebClient = new WebClient();
WebClient.Proxy = null;
if (RequestHeaders != null)
{
foreach (var Header in RequestHeaders) WebClient.Headers.Add(Header.Item1, Header.Item2);
}
if (Method == "GET" || Method == "HEAD")
{
return JsonObject.Parse(await WebClient.DownloadStringTaskAsync(Client.Base + "/" + Path));
}
else
{
return JsonObject.Parse(await WebClient.UploadStringTaskAsync(Client.Base + "/" + Path, Method, Data));
}
}
private async void GenerateToken_Click(object sender, EventArgs e)
{
using (var webClient = new WebClient())
{
Uri uri;
try
{
uri = new Uri(_url + "auth/github");
}
catch (Exception ex)
{
_log.Error(ex);
MessageBox.Show("Invalid url: " + _url);
return;
}
webClient.Headers.Add("Accept", "application/vnd.travis-ci.2+json");
webClient.Headers.Add("Content-Type", "application/json");
try
{
_loading.Visible = true;
var data = "{\"github_token\":\"" + _githubToken.Text + "\"}";
var result = await webClient.UploadStringTaskAsync(uri, "POST", data);
_loading.Visible = false;
var deserializeObject = JsonConvert.DeserializeAnonymousType(result, new {access_token = ""});
TravisApiAccessToken = deserializeObject.access_token;
Close();
}
catch (WebException ex)
{
MessageBox.Show("Unable to connect: " + ex.Message);
}
catch (Exception ex)
{
_log.Error(ex);
}
finally
{
_loading.Visible = false;
}
}
}
public static void SendEvent(List<Beacon> beacons)
{
var orderedBeaconsInSight = beacons.Where (b => (b.Proximity != CLProximity.Unknown)).OrderBy (b => b.Accuracy).ToList<Beacon> ();
if (orderedBeaconsInSight.Count < 3)
return; // 3 required for trilat
String deviceId = UIDevice.CurrentDevice.IdentifierForVendor.AsString ();
String json = "{\"deviceId\":\""+deviceId+"\",\"beaconsInSight\" : [";
for (int f=0; f<=2; f++){
json += "{\"id\":\"" + orderedBeaconsInSight [f].FriendlyName + "\",\"range\":" + orderedBeaconsInSight [f].Accuracy + "}";
json += (f == 2 ? "" : ",");
}
json += "]}";
using (WebClient client = new WebClient ()) {
client.Headers.Add ("Content-Type", "application/json");
client.UploadStringTaskAsync ("http://" + IP_ADDRESS + ":9000/api/events", json);
}
}
public async Task<string> CallServerAsync(string path, ServerPostData postData)
{
await EnsureInitializedAsync();
string url = $"{BASE_URL}:{BasePort}/{path.ToLowerInvariant()}";
string json = JsonConvert.SerializeObject(postData);
try
{
using (WebClient client = new WebClient())
{
return await client.UploadStringTaskAsync(url, json);
}
}
catch (WebException ex)
{
Telemetry.TrackException(ex);
Down();
return string.Empty;
}
}
public static async Task<DrawingImage> Retrieve(DcrGraph graph)
{
var body = "src=" + graph.ExportToXml();
var tempFilePath = Path.Combine(Path.GetTempPath(), "SaveFile.svg");
using (WebClient wc = new WebClient())
{
wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
//var encodedBody = SharpVectors.HttpUtility.UrlEncode(body);
//if (encodedBody == null)
//{
// return null;
//}
var encodedBody = Regex.Replace(body, @"[^\w\s<>/""=]", "");
//var encodedBody = body.Replace(" & ", "and"); // TODO: Replace all illegal characters...?
if (encodedBody.Contains("_")) encodedBody = encodedBody.Replace("_", "");
var result = await wc.UploadStringTaskAsync("http://dcr.itu.dk:8023/trace/dcr", encodedBody);
//TODO: don't save it as a file
System.IO.File.WriteAllText(tempFilePath, result);
}
//conversion options
WpfDrawingSettings settings = new WpfDrawingSettings();
settings.IncludeRuntime = true;
settings.TextAsGeometry = true;
FileSvgReader converter = new FileSvgReader(settings);
var xamlFile = converter.Read(tempFilePath);
return new DrawingImage(xamlFile);
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
var json = JsonConvert.SerializeObject(viewModel);
WebClient webClient = new WebClient();
webClient.Headers["Content-Type"] = "application/json";
try
{
Save.IsEnabled = false;
await webClient.UploadStringTaskAsync(new Uri("http://hopapiservice.azurewebsites.net/api/Hop", UriKind.Absolute), "POST", json);
}
catch (Exception)
{
MessageBox.Show("An error occured while trying to submit.");
}
finally
{
Save.IsEnabled = true;
}
MessageBox.Show("Added Successfully.");
NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}
public XkcdModule() : base("/xkcd")
{
Post["/", runAsync: true] = async (_, ct) =>
{
var request = this.Bind<SlackRequest>();
if (request.Token != ConfigurationManager.AppSettings["SLACK_SLASH_COMMAND_TOKEN"])
return 403;
if (request.Command != "/xkcd") return 400;
string xkcdUrl;
if (string.IsNullOrWhiteSpace(request.Text))
{
xkcdUrl = await GetRandomComic();
}
else
{
int result;
xkcdUrl = int.TryParse(request.Text, out result) ? $"https://xkcd.com/{result}/" : await SearchGoogle(request.Text);
}
var data = new
{
text = xkcdUrl,
channel = request.Channel_Name == "directmessage" ? "@" + request.User_Name
: "#" + request.Channel_Name,
unfurl_links = true
};
using (var wc = new WebClient())
{
await wc.UploadStringTaskAsync(ConfigurationManager.AppSettings["SLACK_WEBHOOK_URL"], JsonConvert.SerializeObject(data));
}
return 200;
};
}
public async Task <EsiModel> PostAsync(WebHeaderCollection headers, string address, string data, int cacheSeconds = 0)
{
System.Net.WebClient client = new System.Net.WebClient
{
Headers = headers,
CachePolicy = new HttpRequestCachePolicy()
};
client.Headers["UserAgent"] = _userAgent;
CacheModel cachedItem = _cache.Get <CacheModel>(address);
EsiModel esiModel = new EsiModel();
try
{
if (cacheSeconds == 0)
{
esiModel.Model = await client.UploadStringTaskAsync(address, data);
esiModel = BuildHeaders(client.ResponseHeaders, esiModel);
return(esiModel);
}
if (cachedItem != null)
{
if (DateTime.Compare(cachedItem.Expires, DateTime.UtcNow) <= 0)
{
esiModel.Model = cachedItem.Item;
esiModel.Etag = cachedItem.Etag;
esiModel.MaxPages = cachedItem.Page;
return(esiModel);
}
if (!string.IsNullOrEmpty(cachedItem.Etag))
{
client.Headers["If-None-Match"] = cachedItem.Etag;
}
string esiResponse = await client.UploadStringTaskAsync(address, data);
esiModel = BuildHeaders(client.ResponseHeaders, esiModel);
cachedItem = new CacheModel(esiResponse, esiModel.Etag, cacheSeconds, esiModel.MaxPages);
_cache.Remove(address);
_cache.Add(address, cachedItem);
}
else
{
string esiResponse = await client.UploadStringTaskAsync(address, data);
esiModel = BuildHeaders(client.ResponseHeaders, esiModel);
cachedItem = new CacheModel(esiResponse, esiModel.Etag, cacheSeconds, esiModel.MaxPages);
_cache.Add(address, cachedItem);
}
esiModel.Model = cachedItem.Item;
return(esiModel);
}
catch (WebException e)
{
EsiModel returned = BuildException(e, cachedItem, esiModel, address, data);
if (returned != null)
{
return(returned);
}
throw;
}
}
public async void AuthenticateWithWNS()
{
IsRefreshInProgress = true;
var urlEncodedSid = HttpUtility.UrlEncode(WNS_PACKAGE_SECURITY_IDENTIFIER);
var urlEncodedSecret = HttpUtility.UrlEncode(WNS_SECRET_KEY);
var body = String.Format(PayloadFormat, urlEncodedSid, urlEncodedSecret, AccessScope);
string response = null;
Exception exception = null;
using (var client = new WebClient())
{
client.Headers.Add("Content-Type", UrlEncoded);
try
{
response = await client.UploadStringTaskAsync(new Uri(AccessTokenUrl), body);
}
catch (Exception e)
{
exception = e;
Debug.WriteLine(String.Format("Failed WNS authentication. Error: {0}",e.Message));
}
}
if (exception == null && response != null)
{
oAuthToken = GetOAuthTokenFromJson(response);
ScheduleTokenRefreshing();
}
IsRefreshInProgress = false;
OnAuthenticated?.Invoke();
}
public static Task<string> Post(string url, string data, string authToken) {
var client = new WebClient { Encoding = Encoding.UTF8 };
client.Headers.Add("Content-Type:application/x-www-form-urlencoded");
client.Headers.Add(authToken != null ? AuthHeader(authToken) : "Host:www.box.net");
return client.UploadStringTaskAsync(new Uri(url), "POST", data);
}
private async Task<string> RequestRawDataToServerAsync(string date)
{
string rawResult = null;
using (var client = new WebClient())
{
client.Headers.Add("Origin", "http://www.forexfactory.com");
client.Headers.Add("Referer", "http://www.forexfactory.com/index.php");
client.Headers.Add("X-Requested-With", "XMLHttpRequest");
client.Headers.Add("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
client.Headers.Add("User-Agent",
"Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.97 Safari/537.11");
client.Headers.Add("Cookie",
string.Format(
"__gads=ID=4cb0429a709ae2b1:T=1352673378:S=ALNI_MakhgWOmj0BAHVj_fEPqXcQvJsoAA; fftimezoneoffset=7; dstonoff=0; ffdstonoff=0; fftimezoneoffset=7; ffstartofweek=1; fftimeformat=0; ffverifytimes=1; notice_ffBlog=1357014276; flexHeight_flexBox_flex_minicalendar_=155; ffflextime_flex_minicalendar_=1357838496-0; ffcalendar=93bdedb64d9706a2bebaacef9cdeeb68da7c848ca-2-%7Bs-7-.calyear._i-0_s-8-.calmonth._i-0_%7D; __utma=113005075.2089994478.1352727369.1357842901.1357862156.185; __utmc=113005075; __utmz=113005075.1357455362.160.9.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=(not%20provided); ffflex=a%3A1%3A%7Bs%3A16%3A%22Calendar_mainCal%22%3Ba%3A3%3A%7Bs%3A9%3A%22begindate%22%3Bs%3A16%3A%22{0}%22%3Bs%3A7%3A%22enddate%22%3Bs%3A16%3A%22{0}%22%3Bs%3A7%3A%22impacts%22%3Ba%3A1%3A%7Bs%3A4%3A%22high%22%3Bs%3A4%3A%22high%22%3B%7D%7D%7D; ffsessionhash=4e2aacfe2d66b5076c016bf88139ea81; flexHeight_flexBox_flex_calendar_mainCal=227; ffflextime_flex_calendar_mainCal=1357869548-0; fflastvisit=1352673368; fflastactivity=0",
TodayDate));
rawResult = await client.UploadStringTaskAsync("http://www.forexfactory.com/flex.php?",
string.Format(
"s=&securitytoken=guest&do=saveoptions&setdefault=no&ignoreinput=no&flex%5BCalendar_mainCal%5D%5BidSuffix%5D=&flex%5BCalendar_mainCal%5D%5B_flexForm_%5D=flexForm&flex%5BCalendar_mainCal%5D%5BmodelData%5D=YTo3OntzOjEyOiJob21lQ2FsZW5kYXIiO2I6MTtzOjEyOiJ2aWV3aW5nVG9kYXkiO2I6MDtzOjExOiJwcmV2Q2FsTGluayI7czoxNDoiZGF5PWphbjEwLjIwMTMiO3M6MTE6Im5leHRDYWxMaW5rIjtzOjE0OiJkYXk9amFuMTIuMjAxMyI7czo3OiJwcmV2QWx0IjtzOjE3OiJZZXN0ZXJkYXk6IEphbiAxMCI7czo3OiJuZXh0QWx0IjtzOjE2OiJUb21vcnJvdzogSmFuIDEyIjtzOjk6InJpZ2h0TGluayI7YjoxO30%3D&flex%5BCalendar_mainCal%5D%5Bbegindate%5D={0}&flex%5BCalendar_mainCal%5D%5Benddate%5D={0}&flex%5BCalendar_mainCal%5D%5Bimpacts%5D%5Bhigh%5D=high&flex%5BCalendar_mainCal%5D%5B_cbarray_%5D=1&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Baud%5D=aud&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Bcad%5D=cad&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Bchf%5D=chf&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Bcny%5D=cny&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Beur%5D=eur&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Bgbp%5D=gbp&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Bjpy%5D=jpy&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Bnzd%5D=nzd&flex%5BCalendar_mainCal%5D%5Bcurrencies%5D%5Busd%5D=usd&flex%5BCalendar_mainCal%5D%5B_cbarray_%5D=1&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bgrowth%5D=growth&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Binflation%5D=inflation&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bemployment%5D=employment&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bcentralbank%5D=centralbank&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bbonds%5D=bonds&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bhousing%5D=housing&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bsentiment%5D=sentiment&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bpmi%5D=pmi&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bspeeches%5D=speeches&flex%5BCalendar_mainCal%5D%5Beventtypes%5D%5Bmisc%5D=misc&flex%5BCalendar_mainCal%5D%5B_cbarray_%5D=1&false",
date)).ConfigureAwait(false);
}
return rawResult;
}
private async Task<Link[]> ParseTextToLinks(string text, bool deep)
{
Uri uri;
List<Link> links = new List<Link>();
string pattern = @"(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.\-=]*)*\/?";
if (String.IsNullOrWhiteSpace(text) == false)
{
foreach (Match match in Regex.Matches(text, pattern))
{
if (Uri.TryCreate(match.Value, UriKind.Absolute, out uri) == true)
{
if (uri.Authority == "nitroflare.com" || uri.Authority == "www.nitroflare.com")
{
if (uri.Segments.Length >= 3)
{
if (uri.Segments[1].TrimEnd('/').ToLower() == "view")
{
links.Add(new Link
{
Hosting = "nitroflare.com",
Url = new Uri(match.Value.ToLower(), UriKind.Absolute)
});
}
else if (uri.Segments[1].TrimEnd('/').ToLower() == "folder")
{
using (WebClient client = new WebClient())
{
try
{
client.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
string post = String.Format("userId={0}&folder={1}&page=1&perPage=50", uri.Segments[2].Trim('/'), Uri.EscapeDataString(uri.Segments[3].Trim('/')));
string data = await client.UploadStringTaskAsync("http://nitroflare.com/ajax/folder.php", post);
string absolute = data.Replace(@"view\/", @"http://nitroflare.com/view/").Replace(@"\/", "/");
Link[] found = await this.ParseTextToLinks(absolute, false);
links.AddRange(found);
}
catch (WebException)
{
// ignore
}
}
}
}
}
else if (deep == true)
{
using (WebClient client = new WebClient())
{
try
{
string data = await client.DownloadStringTaskAsync(uri);
Link[] found = await this.ParseTextToLinks(data, false);
links.AddRange(found);
}
catch (WebException)
{
// ignore
}
}
}
}
}
}
return links.ToArray();
}
/*
/// <summary>
/// Posts the data async.
/// </summary>
/// <returns>The data async.</returns>
/// <param name="SerializedPostData">Serialized post data.</param>
/// <param name="RestUrl">Rest URL.</param>
/// <param name="APIName">Method name.</param>
public async Task<string> PostDataAsync (string SerializedPostData, string RestUrl, string MethodName = "")
{
//var serializedContent = new StringContent (SerializeContent (json), Encoding.UTF8, "application/json");
var uri = new Uri (string.Format (RestUrl, MethodName));
HttpResponseMessage responsepost = null;
responsepost = await client.PostAsync (uri, SerializedPostData);
var contentpost = await responsepost.Content.ReadAsStringAsync ();
if (responsepost.IsSuccessStatusCode) {
return contentpost;
}
return string.Empty;
}*/
/// <summary>
/// Posts the data async.
/// </summary>
/// <returns>The data async.</returns>
/// <param name="SerializedPostData">Serialized Post Data</param>
/// <param name="RestUrl">Rest URL.</param>
/// <param name="APIName">Method name.</param>
public async Task<string> PostDataAsync (string SerializedPostData, string RestUrl, string APIName)
{
string result = string.Empty;
try {
WebClient webclient = new WebClient();
var uri = new Uri (string.Format (RestUrl, APIName));
webclient.Headers [HttpRequestHeader.ContentType] = "application/json";
result = await webclient.UploadStringTaskAsync (uri, SerializedPostData);
return result;
} catch (System.Exception sysExc) {
Console.WriteLine ("Exception: {0}", sysExc);
//throw;
}
return result;
}
