示例#1
0
        private async Task <string> FetchMedicationAsync(string url)
        {
            //Create HTTP request using the URL
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(new Uri(url));
            request.ContentType = "application/json";
            request.Method      = "GET";

            //Send the request ot the server and wait for the response
            //TODO: Add exception handling to web queries and Json parsing
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                //Get a stream representation of the HTTP web response
                using (System.IO.Stream stream = response.GetResponseStream())
                {
                    using (StreamReader streamReader = new StreamReader(stream))
                    {
                        string json = await Task.Run(() => streamReader.ReadToEnd());

                        //string json = await Task.Run(() => JsonConvert.ToString(streamText));

                        Console.Out.WriteLine("Result: {0}", json);

                        //Return the JSON document
                        return(json);
                    }
                }
            }
        }
示例#2
0
        public static async System.Threading.Tasks.Task <Boolean> FetchCompanyHistoryAsync(Models.HistoryU obj)
        {
            Uri u = new Uri(url1 + "insertHistoryC?Search=" + obj.Wyszukiwanie + "&Description=" + obj.Description + "&Companyid=" + obj.User + "&Expoid=" + obj.Expo);

            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(u);
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());
                    if (Boolean.Parse(jsonDoc["saved"].ToString()) == true)
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            return(false);
        }
示例#3
0
        public static async System.Threading.Tasks.Task <Models.Company> FetchCompanyAsync(string email)
        {
            // Create an HTTP web request using the URL:
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(new Uri(url1 + "/company?Email=" + email));
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            try
            {
                using (System.Net.WebResponse response = await request.GetResponseAsync())
                {
                    // Get a stream representation of the HTTP web response:
                    using (Stream stream = response.GetResponseStream())
                    {
                        // Use this stream to build a JSON document object:
                        System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                        Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());

                        // Return the JSON document:
                        return(Droid.Modules.Parsers.Company(jsonDoc));
                    }
                }
            }
            catch (System.Net.WebException ex)
            {
            }
            return(null);
        }
示例#4
0
        public static async System.Threading.Tasks.Task <Boolean> FetchUserEditAsync(Models.User obj)
        {
            Uri u = new Uri(url1 + "EditProfileUser?Email=" + obj.Email + "&ForName=" + obj.ForName + "&SurName=" + obj.SurName + "&Phone=" + obj.Phone + "&Nationality=" + obj.Nationality);

            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(u);
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());
                    if (Boolean.Parse(jsonDoc["AccountChanged"].ToString()) == true)
                    {
                        return(true);
                    }
                    else if (Boolean.Parse(jsonDoc["Unactual"].ToString()) == true)
                    {
                        LDbConnection.InsertUser(await DbConnection.FetchUserAsync(obj.Email));
                        return(true);
                    }
                }
            }
            return(false);
        }
示例#5
0
        public static async System.Threading.Tasks.Task <Boolean> FetchCompanyJoinExpoAsync(Models.Company us, Models.Expo e)
        {
            Uri u = new Uri(url1 + "insertCExpo?Expoid=" + e.Id + "&Companyid=" + us.Id);

            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(u);
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());
                    if (Boolean.Parse(jsonDoc["JoinedC"].ToString()) == true)
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            return(false);
        }
示例#6
0
 public static void GetHomePage(Action <ResponseDataJson> callback)
 {
     System.Net.HttpWebRequest request = System.Net.HttpWebRequest.CreateHttp(SERVER_URL + "/AppHome/GetJson");
     request.ContentType = "text/json";
     request.Accept      = "text/json";
     request.Method      = "GET";
     request.GetResponseAsync().ContinueWith(t =>
     {
         var isOk = false;
         try
         {
             var responseStream = t.Result.GetResponseStream();
             var jsonStr        = new System.IO.StreamReader(responseStream).ReadToEnd();
             responseStream.Dispose();
             isOk = true;
             callback.Invoke(new ResponseDataJson(ResponseCode.OK, jsonStr));
         }
         catch (Exception e)
         {
             if (!isOk)
             {
                 callback.Invoke(new ResponseDataJson(ResponseCode.Fail, null, e));
             }
         }
     });
 }
        public async Task <bool> QueryHost(Uri InHost)
        {
            // Send GET request to host
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(InHost + TestFile);
            request.Method = "GET";

            //Default to "not found"
            System.Net.HttpStatusCode response = System.Net.HttpStatusCode.NotFound;
            try
            {
                response = ((System.Net.HttpWebResponse) await request.GetResponseAsync()).StatusCode;
            }
            catch
            {
                Trace.WriteLine(string.Format("<!><!><!>The host: {0} is down.", InHost));
            }

            // Push host to queue if valid
            if (response == System.Net.HttpStatusCode.OK)
            {
                lock (Hosts)
                    Hosts.Enqueue(InHost);

                Trace.WriteLine("Added: " + InHost);

                return(true);
            }

            return(false);
        }
示例#8
0
        public static async System.Threading.Tasks.Task <Boolean> FetchCompanyEditAsync(Models.Company obj)
        {
            Uri u = new Uri(url1 + "EditProfileCompany?Email=" + obj.Email + "&CompanyName=" + obj.CompanyName +
                            "&CompanyFullName=" + obj.CompanyFullName + "&CompanyAbout=" + obj.CompanyAbout + "&ProductsAbout=" + obj.ProductsAbout + "&Facebook=" + obj.Facebook
                            + "&Instagram=" + obj.Instagram + "&Snapchat=" + obj.Snapchat + "&Youtube=" + obj.Youtube + "&Phone=" + obj.Phone + "&UserPhone=" + obj.UserPhone
                            + "&ContactEmail=" + obj.ContactEmail + "&www=" + obj.www + "&Adress=" + obj.www + "&NIP=" + obj.NIP + "&Forname_And_Surname=" + obj.ForName_And_SurName);

            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(u);
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());
                    if (Boolean.Parse(jsonDoc["AccountChanged"].ToString()) == true)
                    {
                        return(true);
                    }
                    else if (Boolean.Parse(jsonDoc["Unactual"].ToString()) == true)
                    {
                        LDbConnection.InsertCompany(await DbConnection.FetchCompanyAsync(obj.Email));
                        return(true);
                    }
                }
            }
            return(false);
        }
示例#9
0
        private async void RadioPoll(Object state)
        {
            string PollingUrl = "https://hive365.co.uk/streaminfo/info.php";

            System.Net.HttpWebRequest WebRequest = System.Net.WebRequest.CreateHttp(PollingUrl);
            using (var resp = await WebRequest.GetResponseAsync())
            {
                using (var streamreader = new System.IO.StreamReader(resp.GetResponseStream()))
                {
                    dynamic JsonValue = Newtonsoft.Json.JsonConvert.DeserializeObject(await streamreader.ReadToEndAsync());
                    try
                    {
                        string SongName = JsonValue.info.artist_song;
                        if (CurrentSong != SongName)
                        {
                            var MessagesToDelete = MessageClient.GetMessagesAsync().Cast <Discord.IMessage>().Where(x => x.Content.Contains("via Hive365 Radio!"));
                            await MessageClient.DeleteMessagesAsync(await MessagesToDelete.ToList());

                            SendMessage_Raised("Now playing " + SongName + " on Spagbot via Hive365 Radio!", MessageClient);
                            CurrentSong = SongName;
                        }
                    }
                    catch
                    {
                        //RuntimeBinder exception probably :)
                    }
                }
            }
            WebRequest = null;
        }
示例#10
0
        public static T GetWebResponse <T>(string url)
        {
            System.Text.Encoding      encode  = System.Text.Encoding.GetEncoding("utf-8");
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(url);

            using (System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponseAsync().GetAwaiter().GetResult())
            {
                using (System.IO.StreamReader readStream = new System.IO.StreamReader(response.GetResponseStream(), encode))
                {
                    string responseText = readStream.ReadToEnd();
                    return(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(responseText));
                }
            }
        }
        public static async Task AddImageFromUrl(string url, string imageName)
        {
            System.Net.HttpWebRequest request = null;


            byte[] b = null;

            name = imageName;



            request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(url);

            request.Method = "GET";

            using (var response = (System.Net.HttpWebResponse) await request.GetResponseAsync())
            {
                if (request.HaveResponse)
                {
                    if (response.StatusCode == System.Net.HttpStatusCode.OK)
                    {
                        System.IO.Stream receiveStream = response.GetResponseStream();
                        using (System.IO.BinaryReader br = new System.IO.BinaryReader(receiveStream))
                        {
                            b = br.ReadBytes(500000);
                            if (b != null)
                            {
                                if (!Images.ContainsKey(name))
                                {
                                    // hold image

                                    byte[] image = new byte[b.Length];

                                    image = b;

                                    Images.Add(imageName, b);

                                    // Debug.WriteLine("MAP SIZE: " + getImages.Count);

                                    b = null;
                                }
                            }
                            br.Dispose();
                        }
                    }
                }
            }
        }
示例#12
0
        async Task <DTOs.Response.BootstrapResponse> scrapeFromUrl(string url)
        {
            System.Net.HttpWebRequest r = System.Net.HttpWebRequest.CreateHttp(url);
            var response = await r.GetResponseAsync();

            try
            {
                string s = (new System.IO.StreamReader(response.GetResponseStream())).ReadToEnd();
                return(Newtonsoft.Json.JsonConvert.DeserializeObject <DTOs.Response.BootstrapResponse>(s));
            }
            catch
            {
                return(new DTOs.Response.BootstrapResponse());
            }
            throw new NotImplementedException();
        }
示例#13
0
 /// <summary>
 /// Helper method to work around annoying exceptions thrown by System.Net.WebRequest
 /// when the server returns a non-success status code
 /// </summary>
 /// <param name="req">The request to get the response from</param>
 /// <returns>The web response</returns>
 private static async Task <System.Net.HttpWebResponse> GetResponseWithoutExceptionAsync(System.Net.HttpWebRequest req)
 {
     try
     {
         return((System.Net.HttpWebResponse) await req.GetResponseAsync());
     }
     catch (System.Net.WebException we)
     {
         var resp = we.Response as System.Net.HttpWebResponse;
         if (resp == null)
         {
             throw;
         }
         return(resp);
     }
 }
示例#14
0
        public static async System.Threading.Tasks.Task <System.Collections.Generic.List <Models.Expo> > FetchUserExposAsync(Models.User u)
        {
            // Create an HTTP web request using the URL:
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(new Uri(url1 + "UserExpos?email=" + u.Email));
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());

                    // Return the JSON document:
                    System.Collections.Generic.List <Models.Expo> lista = new System.Collections.Generic.List <Models.Expo>();
                    for (int i = 0; i != jsonDoc.Count; i++)
                    {
                        Models.Expo e = new Models.Expo
                        {
                            Name_Expo   = jsonDoc[i]["Name_Expo"],
                            Id          = Int32.Parse(jsonDoc[i]["Id"].ToString()),
                            Photo       = jsonDoc[i]["Photo"],
                            MapPhoto    = jsonDoc[i]["MapPhoto"],
                            Adres       = jsonDoc[i]["Adres"],
                            Description = jsonDoc[i]["Description"]
                        };
                        var      start     = double.Parse(jsonDoc[i]["ExpoStartData"].ToString().Replace('/', ' ').Replace('"', ' ').Replace(')', ' ').Replace("Date(", "").Trim());
                        TimeSpan time      = TimeSpan.FromMilliseconds(start);
                        DateTime startdate = new DateTime(1970, 1, 1) + time;

                        e.DataTargowStart = startdate;
                        var      end     = double.Parse(jsonDoc[i]["ExpoEndData"].ToString().Replace('/', ' ').Replace('"', ' ').Replace(')', ' ').Replace("Date(", "").Trim());
                        TimeSpan time1   = TimeSpan.FromMilliseconds(end);
                        DateTime enddate = new DateTime(1970, 1, 1) + time1;

                        e.DataTargowEnd = enddate;
                        lista.Add(e);
                    }
                    return(lista);
                }
            }
        }
示例#15
0
        public async void StartDownload()
        {
            Log.Debug("starting download: " + this);

            string directory = Path.GetDirectoryName(filePath.Value);

            Directory.CreateDirectory(directory);
            fileStream = new FileStream(filePath.Value, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);

            request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(uri);
            using (response = (System.Net.HttpWebResponse) await request.GetResponseAsync())
            {
                using (stream = response.GetResponseStream())
                {
                    await System.Threading.Tasks.Task.Run(() =>
                    {
                        DownloadedSize = 0;
                        FileSize       = response.ContentLength;
                        downloadStart  = DateTime.Now;

                        // update the download-state.
                        DownloadState = DownloadState.Downloading;
                        StateChanged.Invoke(this, DownloadState.Downloading);

                        while (DownloadState == DownloadState.Downloading && ((bufferBytesRead = stream.Read(buffer, 0, buffer.Length)) > 0))
                        {
                            fileStream.Write(buffer, 0, bufferBytesRead);
                            DownloadedSize += bufferBytesRead;
                            CurrentSize    += bufferBytesRead;
                            DownloadSpeed   = CurrentSize / 1024 / (DateTime.Now - downloadStart).TotalSeconds;
                        }
                    });
                }
            }

            fileStream.Close();
            fileStream.Dispose();

            if (DownloadedSize == FileSize)
            {
                Log.Debug("finished download: " + this);
                DownloadState = DownloadState.Completed;
            }

            DownloadSpeed = 0;
            StateChanged?.Invoke(this, DownloadState);
        }
示例#16
0
        public void MapRoute(IApplicationBuilder app)
        {
            string address = "http://localhost:5010";

            app.Map("/LoadTest", builder =>
            {
                builder.Run(async context =>
                {
                    await context.Response.WriteAsync("OK");
                });
            });


            app.Map("/HttpClient", builder =>
            {
                builder.Run(async context =>
                {
                    HttpClient client = new HttpClient();
                    var response      = client.GetStringAsync("http://www.baidu.com").Result;

                    await context.Response.WriteAsync("OK");
                });
            });


            app.Map("/Trace", builder =>
            {
                builder.Run(async context =>
                {
                    //System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    //HttpClient client = new HttpClient();
                    //var response = await client.GetStringAsync(address +"/Test1");
                    //await context.Response.WriteAsync(response);

                    System.Net.HttpWebRequest req = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(address + "/Test1");

                    req.Timeout = 5000000;

                    using (System.Net.WebResponse wr = await req.GetResponseAsync())
                    {
                        await context.Response.WriteAsync("ok");
                    }
                });
            });
        }
示例#17
0
        public static void Main(string[] args)
        {
            Byte[] bytes = System.IO.File.ReadAllBytes(fileName);
            String file  = Convert.ToBase64String(bytes);

            JsonData data = new JsonData();

            data.model    = "cvlizer_3_0";
            data.language = "de";
            data.filename = fileName;
            data.data     = file;

            string json = JsonConvert.SerializeObject(data);

            byte[] jsonBytes = System.Text.Encoding.UTF8.GetBytes(json);

            System.Net.HttpWebRequest req = System.Net.WebRequest.Create("https://cvlizer.joinvision.com/cvlizer/rest/v1/extract/xml/")
                                            as System.Net.HttpWebRequest;

            req.Method      = "POST";
            req.ContentType = "application/json";
            req.Headers[System.Net.HttpRequestHeader.ContentLength] = jsonBytes.Length.ToString();
            req.Headers[System.Net.HttpRequestHeader.Authorization] = "Bearer " + productToken;

            //req.Headers.Add("Authorization", "Bearer " + < Product - Token >);
            //req.ContentLength = jsonBytes.Length;

            using (System.IO.Stream post = req.GetRequestStreamAsync().Result) // todo please don't block the tread
            {
                post.Write(jsonBytes, 0, jsonBytes.Length);
            }

            string result = null;

            using (System.Net.HttpWebResponse resp = req.GetResponseAsync().Result
                                                     as System.Net.HttpWebResponse)
            {
                System.IO.StreamReader reader =
                    new System.IO.StreamReader(resp.GetResponseStream());
                result = reader.ReadToEnd();
            }
            Console.Write(result);
            File.WriteAllText("cvlizer.xml", result);
            Console.ReadLine();
        }
示例#18
0
        /// <summary>
        /// Main download method.
        /// </summary>
        private async void download()
        {
            dlTimer.Start();
            dsTimer.Start();
            // Set 'cancelDownload' to false, so that method can stop again.
            cancelDownload = false;

            req = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(uri);
            // check if downloaded-length!=0 and !overwrite so the user want to resume.
            if (dLength > 0 && !overwrite)
            {
                req.AddRange(dLength);      // add range to the 'req' to change the point of start download.
            }
            isDownloading = true;
            using (res = (System.Net.HttpWebResponse) await req.GetResponseAsync())
            {
                fLength = res.ContentLength + dLength;                                                 // get the total-size of the file.
                eSize.Invoke(null, Unkdevt.StringHelpers.GetLengthString(FileSize));                   // update the total-size.
                eDownloadedSize.Invoke(null, Unkdevt.StringHelpers.GetLengthString(DownloadedLength)); // update the downloaded-length.
                dt = System.DateTime.Now;                                                              // get the current time ( point of start downloading ).
                using (stream = res.GetResponseStream())
                {
                    await System.Threading.Tasks.Task.Run(() =>     // await task so the winform don't freezing.
                    {
                        // update the download-state.
                        eDownloadState.Invoke(null, "Downloading");
                        // while not 'cancelDownload' and file doesn't end do:
                        while (!cancelDownload && ((bufferReader = stream.Read(buffer, 0, buffer.Length)) > 0))
                        {
                            fStream.Write(buffer, 0, bufferReader); // write byte to the file on harddisk.
                            dLength += bufferReader;                // update downloaded-length value.
                            cLength += bufferReader;                // update current-downloaded-length value.
                        }
                    });
                }
            }
            dlTimer.Stop();
            dsTimer.Stop();
            isDownloading = false;
            // eSpeed.Invoke(null, "0.0 Kb/s");    // update downloading-speed to 0.0 kb/s.
            eDownloadedSize.Invoke(null, Unkdevt.StringHelpers.GetLengthString(DownloadedLength)); // update downloaded-size.
            eDownloadState.Invoke(null, DownloadState);                                            // update download-state.
            fStream.Dispose();                                                                     // free file on harddisk by dispose 'fStream'.
        }
示例#19
0
        public T ProcessRequest(string token, string logOn, string password, System.Net.Cookie cookie)
        {
            Uri uri = ToUrl(token);

            System.Net.HttpWebRequest wr = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(uri);
            wr.Credentials     = new System.Net.NetworkCredential(logOn, password);
            wr.CookieContainer = new System.Net.CookieContainer();
            if (cookie != null)
            {
                var cookiUri = cookie.Domain != null ? new Uri(cookie.Domain) : BaseUrl;
                wr.CookieContainer.SetCookies(uri, cookie.ToString());
            }

            OnProcessingRequest(wr);

#if !PORTABLE
            using (var response = wr.GetResponse())
#else
            using (var response = wr.GetResponseAsync().Result)
#endif
                using (var stream = response.GetResponseStream())
                {
                    if (stream == null)
                    {
                        throw new InvalidOperationException("Response stream is null");
                    }

                    var sr         = new System.IO.StreamReader(stream);
                    var jsonResult = sr.ReadToEnd();

                    var result = JsonParser.ParseJsonResult(jsonResult);

                    if (result != null && result.CacheId != 0)
                    {
                        this.CacheId = result.CacheId;
                    }

                    var ret = new T {
                        Result = result
                    };
                    OnProcessedRequest(ret);
                    return(ret);
                }
        }
        private async Task <string> FetchMedicationAsync(string url)
        {
            //Create HTTP request using the URL
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(new Uri(url));
            request.ContentType = "application/json";
            request.Method      = "GET";

            //Send the request to the server and wait for the response
            //TODO: Add exception handling to web queries and Json parsing
            try
            {
                using (System.Net.WebResponse response = await request.GetResponseAsync())
                {
                    //Get a stream representation of the HTTP web response
                    using (System.IO.Stream stream = response.GetResponseStream())
                    {
                        using (StreamReader streamReader = new StreamReader(stream))
                        {
                            string json = await Task.Run(() => streamReader.ReadToEnd());

                            //Return the JSON string
                            return(json);
                        }

                        //Use this stream to build a JSON document object:
                        //JsonValue jsonDoc = await Task.Run(() => JsonObject.Load(stream));

                        //Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());

                        //Return the JSON document
                        //return jsonDoc.ToString();
                    }
                }
            }
            catch (Exception e)
            {
                Console.Out.WriteLine("{0}. Exception caught", e);
                return("");
            }
        }
示例#21
0
        public async Task <bool> QueryHost(UpdateServerEntry hostObject)
        {
            RxLogger.Logger.Instance.Write($"Attempting to contact host {hostObject.Uri.AbsoluteUri}");

            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(hostObject.Uri.AbsoluteUri + TestFile);
            request.Method = "GET";

            //Default to "not found"
            System.Net.HttpStatusCode response = System.Net.HttpStatusCode.NotFound;
            try
            {
                response = ((System.Net.HttpWebResponse) await request.GetResponseAsync()).StatusCode;
            }
            catch
            {
                hostObject.HasErrored = true;
                RxLogger.Logger.Instance.Write($"The host {hostObject.Uri.AbsoluteUri} seems to be offline");
            }

            // Push host to queue if valid
            if (response == System.Net.HttpStatusCode.OK)
            {
                lock (Hosts)
                {
                    Hosts.Enqueue(hostObject);

                    // Only add the top 4 hosts into this list
                    if (CurrentHostsList.Count < 4)
                    {
                        CurrentHostsList.Add(new UpdateServerSelectorObject(hostObject));
                    }
                }

                RxLogger.Logger.Instance.Write($"Added host {hostObject.Uri.AbsoluteUri} to the hosts queue");

                return(true);
            }

            return(false);
        }
示例#22
0
        public static async System.Threading.Tasks.Task <Models.MobileLogin> FetchLoginAsync(String email, String password)
        {
            Uri u = new Uri(url1 + "Login?Email=" + email + "&Password="******"application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());
                    return(Droid.Modules.Parsers.Login(jsonDoc));
                }
            }
            return(null);
        }
        public async Task <Client> RequestGetAsync()
        {
            this
            .Method("GET")
            //.Headers()            // default headers
            //.Parameters()         // Data/Parameters
            ;


            foreach
            (
                KeyValuePair <Uri, ClientRequestImplementation <ImplementationRequest> > kvp
                in this.RequestImplementationObjects
            )
            {
                Uri uri = kvp.Key;
                ImplementationRequest request = kvp.Value.ImplementationObject;

                RequestSetup(request);

                #if NETSTANDARD1_0
                ImplementationResponse response = (ImplementationResponse)await request.GetResponseAsync();

                this.ResponseImplementationObjects.Add(uri, response);
                #else
                using (System.Net.Http.HttpClient http_client = new System.Net.Http.HttpClient())
                {
                    ImplementationResponse response = await http_client.SendAsync(request);

                    this.ResponseImplementationObjects.Add(uri, response);
                }
                #endif
            }

            return(this);
        }
示例#24
0
        public static async System.Threading.Tasks.Task <System.Collections.Generic.List <Models.HistoryU> > FetchHistory(Models.Company u)
        {
            // Create an HTTP web request using the URL:
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(new Uri(url1 + "History?email=" + u.Email));
            request.ContentType = "application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (System.Net.WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    System.Json.JsonValue jsonDoc = await System.Threading.Tasks.Task.Run(() => System.Json.JsonObject.Load(stream));

                    Console.Out.WriteLine("Response: {0}", jsonDoc.ToString());

                    // Return the JSON document:
                    System.Collections.Generic.List <Models.HistoryU> lista = new System.Collections.Generic.List <Models.HistoryU>();
                    for (int i = 0; i != jsonDoc.Count; i++)
                    {
                        Models.HistoryU h = new Models.HistoryU
                        {
                            ID           = Int32.Parse(jsonDoc[i]["ID"].ToString()),
                            Description  = jsonDoc[i]["Description"],
                            Wyszukiwanie = jsonDoc[i]["Wyszukiwanie"],
                            User         = Int32.Parse(jsonDoc[i]["User"].ToString()),
                            Expo         = Int32.Parse(jsonDoc[i]["Expo"].ToString())
                        };
                        lista.Add(h);
                    }
                    return(lista);
                }
            }
        }
示例#25
0
        public void RequestWork(object state)
        {
            try
            {
#if NETFX_CORE
                System.Net.HttpWebRequest req = System.Net.HttpWebRequest.CreateHttp(new Uri(_Url));
#else
#if (UNITY_5 || UNITY_5_3_OR_NEWER)
                System.Net.HttpWebRequest req = System.Net.HttpWebRequest.Create(new Uri(_Url)) as System.Net.HttpWebRequest;
#else
                System.Net.HttpWebRequest req = new System.Net.HttpWebRequest(new Uri(_Url));
#endif
                req.KeepAlive = false;
#endif

                try
                {
                    lock (_CloseLock)
                    {
                        if (_Closed)
                        {
#if !HTTP_REQ_DONOT_ABORT
                            req.Abort();
#endif
                            if (_Status != RequestStatus.Finished)
                            {
                                _Error  = "Request Error (Cancelled)";
                                _Status = RequestStatus.Finished;
                            }
                            return;
                        }
                        _InnerReq = req;
                    }

#if !NETFX_CORE
                    req.Timeout          = int.MaxValue;
                    req.ReadWriteTimeout = int.MaxValue;
#if !HTTP_REQ_DONOT_ABORT
                    if (_Timeout > 0)
                    {
                        req.Timeout          = _Timeout;
                        req.ReadWriteTimeout = _Timeout;
                    }
#endif
#endif
                    if (_Headers != null)
                    {
                        foreach (var kvp in _Headers.Data)
                        {
                            var key = kvp.Key;
                            var val = (kvp.Value ?? "").ToString();
                            if (key.IndexOfAny(new[] { '\r', '\n', ':', }) >= 0)
                            {
                                continue; // it is dangerous, may be attacking.
                            }
                            if (val.IndexOfAny(new[] { '\r', '\n', }) >= 0)
                            {
                                continue; // it is dangerous, may be attacking.
                            }
                            else
                            {
                                req.Headers[key] = val;
                            }
                        }
                    }
                    if (_RangeEnabled)
                    {
                        long filepos = 0;
                        if (_Dest != null)
                        {
                            using (var stream = PlatExt.PlatDependant.OpenRead(_Dest))
                            {
                                if (stream != null)
                                {
                                    try
                                    {
                                        filepos = stream.Length;
                                    }
                                    catch (Exception e)
                                    {
                                        if (GLog.IsLogErrorEnabled)
                                        {
                                            GLog.LogException(e);
                                        }
                                    }
                                }
                            }
                        }
                        if (filepos <= 0)
                        {
                            if (_DestStream != null)
                            {
                                try
                                {
                                    if (_DestStream.CanSeek)
                                    {
                                        filepos = _DestStream.Length;
                                    }
                                }
                                catch (Exception e)
                                {
                                    if (GLog.IsLogErrorEnabled)
                                    {
                                        GLog.LogException(e);
                                    }
                                }
                            }
                        }
                        if (filepos > 0)
                        {
                            if (filepos > int.MaxValue)
                            {
                                _RangeEnabled = false;
                            }
                            else
                            {
                                req.AddRange((int)filepos);
                            }
                        }
                        else
                        {
                            _RangeEnabled = false;
                        }
                    }
                    if (_Data != null && (_Data.Count > 0 || _Data.Encoded != null))
                    {
                        req.Method = "POST";
                        var data = _Data.Encoded;
                        if (data == null)
                        {
                            req.ContentType = _Data.ContentType;
                            data            = _Data.Encode();
                        }
                        else
                        {
                            req.ContentType = "application/octet-stream";
                        }

#if NETFX_CORE
                        var tstream = req.GetRequestStreamAsync();
                        if (_Timeout > 0)
                        {
                            if (!tstream.Wait(_Timeout))
                            {
                                throw new TimeoutException();
                            }
                        }
                        else
                        {
                            tstream.Wait();
                        }
                        var stream = tstream.Result;
#else
                        req.ContentLength = data.Length;
                        var stream = req.GetRequestStream();
#endif

                        lock (_CloseLock)
                        {
                            if (_Closed)
                            {
#if !HTTP_REQ_DONOT_ABORT
                                req.Abort();
#endif
                                if (_Status != RequestStatus.Finished)
                                {
                                    _Error  = "Request Error (Cancelled)";
                                    _Status = RequestStatus.Finished;
                                }
                                return;
                            }
                        }
                        if (stream != null)
                        {
#if NETFX_CORE
                            if (_Timeout > 0)
                            {
                                stream.WriteTimeout = _Timeout;
                            }
                            else
                            {
                                stream.WriteTimeout = int.MaxValue;
                            }
#endif

                            try
                            {
                                stream.Write(data, 0, data.Length);
                                stream.Flush();
                            }
                            finally
                            {
                                stream.Dispose();
                            }
                        }
                    }
                    else
                    {
                    }
                    lock (_CloseLock)
                    {
                        if (_Closed)
                        {
#if !HTTP_REQ_DONOT_ABORT
                            req.Abort();
#endif
                            if (_Status != RequestStatus.Finished)
                            {
                                _Error  = "Request Error (Cancelled)";
                                _Status = RequestStatus.Finished;
                            }
                            return;
                        }
                    }
#if NETFX_CORE
                    var tresp = req.GetResponseAsync();
                    if (_Timeout > 0)
                    {
                        if (!tresp.Wait(_Timeout))
                        {
                            throw new TimeoutException();
                        }
                    }
                    else
                    {
                        tresp.Wait();
                    }
                    var resp = tresp.Result;
#else
                    var resp = req.GetResponse();
#endif
                    lock (_CloseLock)
                    {
                        if (_Closed)
                        {
#if !HTTP_REQ_DONOT_ABORT
                            req.Abort();
#endif
                            if (_Status != RequestStatus.Finished)
                            {
                                _Error  = "Request Error (Cancelled)";
                                _Status = RequestStatus.Finished;
                            }
                            return;
                        }
                    }
                    if (resp != null)
                    {
                        try
                        {
                            _Total = (ulong)resp.ContentLength;
                        }
                        catch
                        {
                        }
                        try
                        {
                            _RespHeaders = new HttpRequestData();
                            foreach (var key in resp.Headers.AllKeys)
                            {
                                _RespHeaders.Add(key, resp.Headers[key]);
                            }

                            if (_RangeEnabled)
                            {
                                bool rangeRespFound = false;
                                foreach (var key in resp.Headers.AllKeys)
                                {
                                    if (key.ToLower() == "content-range")
                                    {
                                        rangeRespFound = true;
                                    }
                                }
                                if (!rangeRespFound)
                                {
                                    _RangeEnabled = false;
                                }
                            }

                            var stream = resp.GetResponseStream();
                            lock (_CloseLock)
                            {
                                if (_Closed)
                                {
#if !HTTP_REQ_DONOT_ABORT
                                    req.Abort();
#endif
                                    if (_Status != RequestStatus.Finished)
                                    {
                                        _Error  = "Request Error (Cancelled)";
                                        _Status = RequestStatus.Finished;
                                    }
                                    return;
                                }
                            }
                            if (stream != null)
                            {
#if NETFX_CORE
                                if (_Timeout > 0)
                                {
                                    stream.ReadTimeout = _Timeout;
                                }
                                else
                                {
                                    stream.ReadTimeout = int.MaxValue;
                                }
#endif
                                Stream streamd = null;
                                try
                                {
                                    byte[] buffer   = new byte[1024 * 1024];
                                    ulong  totalcnt = 0;
                                    int    readcnt  = 0;

                                    bool mem = false;
                                    if (_Dest != null)
                                    {
                                        if (_RangeEnabled)
                                        {
                                            streamd  = Capstones.PlatExt.PlatDependant.OpenAppend(_Dest);
                                            totalcnt = (ulong)streamd.Length;
                                        }
                                        else
                                        {
                                            streamd = Capstones.PlatExt.PlatDependant.OpenWrite(_Dest);
                                        }
#if HTTP_REQ_DONOT_ABORT
                                        if (streamd != null)
                                        {
                                            _CloseList.Add(streamd);
                                        }
#endif
                                    }
                                    if (streamd == null)
                                    {
                                        if (_DestStream != null)
                                        {
                                            if (_RangeEnabled)
                                            {
                                                _DestStream.Seek(0, SeekOrigin.End);
                                                totalcnt = (ulong)_DestStream.Length;
                                            }
                                            streamd = _DestStream;
                                        }
                                        else
                                        {
                                            mem     = true;
                                            streamd = new MemoryStream();
#if HTTP_REQ_DONOT_ABORT
                                            _CloseList.Add(streamd);
#endif
                                        }
                                    }

                                    if (_Total > 0)
                                    {
                                        _Total += totalcnt;
                                    }

                                    do
                                    {
                                        lock (_CloseLock)
                                        {
                                            if (_Closed)
                                            {
#if !HTTP_REQ_DONOT_ABORT
                                                req.Abort();
#endif
                                                if (_Status != RequestStatus.Finished)
                                                {
                                                    _Error  = "Request Error (Cancelled)";
                                                    _Status = RequestStatus.Finished;
                                                }
                                                return;
                                            }
                                        }
                                        try
                                        {
                                            readcnt = 0;
                                            readcnt = stream.Read(buffer, 0, 1024 * 1024);
                                            if (readcnt <= 0)
                                            {
                                                stream.ReadByte(); // when it is closed, we need read to raise exception.
                                                break;
                                            }

                                            streamd.Write(buffer, 0, readcnt);
                                            streamd.Flush();
                                        }
                                        catch (TimeoutException te)
                                        {
                                            if (GLog.IsLogErrorEnabled)
                                            {
                                                GLog.LogException(te);
                                            }
                                            _Error = "timedout";
                                        }
                                        catch (System.Net.WebException we)
                                        {
                                            if (GLog.IsLogErrorEnabled)
                                            {
                                                GLog.LogException(we);
                                            }
#if NETFX_CORE
                                            if (we.Status.ToString() == "Timeout")
#else
                                            if (we.Status == System.Net.WebExceptionStatus.Timeout)
#endif
                                            {
                                                _Error = "timedout";
                                            }
                                            else
                                            {
                                                _Error = "Request Error (Exception):\n" + we.ToString();
                                            }
                                        }
                                        catch (Exception e)
                                        {
                                            if (GLog.IsLogErrorEnabled)
                                            {
                                                GLog.LogException(e);
                                            }
                                            _Error = "Request Error (Exception):\n" + e.ToString();
                                        }
                                        lock (_CloseLock)
                                        {
                                            if (_Closed)
                                            {
#if !HTTP_REQ_DONOT_ABORT
                                                req.Abort();
#endif
                                                if (_Status != RequestStatus.Finished)
                                                {
                                                    _Error  = "Request Error (Cancelled)";
                                                    _Status = RequestStatus.Finished;
                                                }
                                                return;
                                            }
                                        }
                                        totalcnt += (ulong)readcnt;
                                        _Length   = totalcnt;
                                        //Capstones.PlatExt.PlatDependant.LogInfo(readcnt);
                                    } while (readcnt > 0);

                                    if (mem)
                                    {
                                        _Resp = ((MemoryStream)streamd).ToArray();
                                    }
                                }
                                finally
                                {
                                    stream.Dispose();
                                    if (streamd != null)
                                    {
                                        if (streamd != _DestStream)
                                        {
                                            streamd.Dispose();
                                        }
                                    }
                                }
                            }
                        }
                        finally
                        {
#if NETFX_CORE
                            resp.Dispose();
#else
                            resp.Close();
#endif
                        }
                    }
                }
                catch (TimeoutException te)
                {
                    if (GLog.IsLogErrorEnabled)
                    {
                        GLog.LogException(te);
                    }
                    _Error = "timedout";
                }
                catch (System.Net.WebException we)
                {
                    if (GLog.IsLogErrorEnabled)
                    {
                        GLog.LogException(we);
                    }
#if NETFX_CORE
                    if (we.Status.ToString() == "Timeout")
#else
                    if (we.Status == System.Net.WebExceptionStatus.Timeout)
#endif
                    {
                        _Error = "timedout";
                    }
                    else
                    {
                        if (we.Response is System.Net.HttpWebResponse && ((System.Net.HttpWebResponse)we.Response).StatusCode == System.Net.HttpStatusCode.RequestedRangeNotSatisfiable)
                        {
                        }
                        else
                        {
                            _Error = "Request Error (Exception):\n" + we.ToString();
                        }
                    }
                }
                catch (Exception e)
                {
                    if (GLog.IsLogErrorEnabled)
                    {
                        GLog.LogException(e);
                    }
                    _Error = "Request Error (Exception):\n" + e.ToString();
                }
                finally
                {
                    if (_Error == null)
                    {
                        lock (_CloseLock)
                        {
                            _Closed   = true;
                            _InnerReq = null;
                        }
                    }
                    else
                    {
                        StopRequest();
                    }
                }
            }
            catch (TimeoutException te)
            {
                if (GLog.IsLogErrorEnabled)
                {
                    GLog.LogException(te);
                }
                _Error = "timedout";
            }
            catch (System.Net.WebException we)
            {
                if (GLog.IsLogErrorEnabled)
                {
                    GLog.LogException(we);
                }
#if NETFX_CORE
                if (we.Status.ToString() == "Timeout")
#else
                if (we.Status == System.Net.WebExceptionStatus.Timeout)
#endif
                {
                    _Error = "timedout";
                }
                else
                {
                    _Error = "Request Error (Exception):\n" + we.ToString();
                }
            }
            catch (Exception e)
            {
                if (GLog.IsLogErrorEnabled)
                {
                    GLog.LogException(e);
                }
                _Error = "Request Error (Exception):\n" + e.ToString();
            }
            finally
            {
                lock (_CloseLock)
                {
                    _Status = RequestStatus.Finished;
                    if (_OnDone != null)
                    {
                        var ondone = _OnDone;
                        _OnDone = null;
                        ondone();
                    }
                }
            }
        }
示例#26
0
        public async System.Threading.Tasks.Task <System.Text.Json.JsonElement> SendAsync()
        {
            if (System.String.IsNullOrWhiteSpace(this.URL))
            {
                throw new System.Exception(SoftmakeAll.SDK.Communication.REST.EmptyURLErrorMessage);
            }

            this.HasRequestErrors = false;

            if (System.String.IsNullOrWhiteSpace(this.Method))
            {
                this.Method = SoftmakeAll.SDK.Communication.REST.DefaultMethod;
            }

            System.Text.Json.JsonElement Result = new System.Text.Json.JsonElement();
            try
            {
                System.Net.HttpWebRequest HttpWebRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(this.URL);
                HttpWebRequest.Method = this.Method;

                if (this.Headers.Count > 0)
                {
                    foreach (System.Collections.Generic.KeyValuePair <System.String, System.String> Header in this.Headers)
                    {
                        if (Header.Key != "Content-Type")
                        {
                            HttpWebRequest.Headers.Add(Header.Key, Header.Value);
                        }
                        else
                        {
                            HttpWebRequest.ContentType = Header.Value;
                        }
                    }
                }
                this.AddAuthorizationHeader(HttpWebRequest);

                if (this.Body.ValueKind == System.Text.Json.JsonValueKind.Undefined)
                {
                    HttpWebRequest.ContentLength = 0;
                }
                else
                {
                    System.Byte[] BodyBytes = new System.Text.UTF8Encoding().GetBytes(Body.ToString());
                    HttpWebRequest.ContentType   = SoftmakeAll.SDK.Communication.REST.DefaultContentType;
                    HttpWebRequest.ContentLength = BodyBytes.Length;
                    await(await HttpWebRequest.GetRequestStreamAsync()).WriteAsync(BodyBytes, 0, BodyBytes.Length);
                }

                if (this.Timeout > 0)
                {
                    HttpWebRequest.Timeout = this.Timeout;
                }

                using (System.Net.HttpWebResponse HttpWebResponse = (System.Net.HttpWebResponse) await HttpWebRequest.GetResponseAsync())
                {
                    this._StatusCode = HttpWebResponse.StatusCode;
                    Result           = await this.ReadResponseStreamAsync(HttpWebResponse);
                }
            }
            catch (System.Net.WebException ex)
            {
                this.HasRequestErrors = true;
                System.Net.HttpWebResponse HttpWebResponse = ex.Response as System.Net.HttpWebResponse;
                if (HttpWebResponse == null)
                {
                    this._StatusCode = System.Net.HttpStatusCode.InternalServerError;
                    Result           = new { Error = true, Message = ex.Message }.ToJsonElement();
                    return(Result);
                }
                this._StatusCode = HttpWebResponse.StatusCode;
                Result           = await this.ReadResponseStreamAsync(HttpWebResponse);
            }
            catch (System.Exception ex)
            {
                this.HasRequestErrors = true;
                this._StatusCode      = System.Net.HttpStatusCode.InternalServerError;
                Result = new { Error = true, Message = ex.Message }.ToJsonElement();
            }

            return(Result);
        }
示例#27
0
        public async System.Threading.Tasks.Task <SoftmakeAll.SDK.Communication.REST.File> DownloadFileAsync()
        {
            if (System.String.IsNullOrWhiteSpace(this.URL))
            {
                throw new System.Exception(SoftmakeAll.SDK.Communication.REST.EmptyURLErrorMessage);
            }

            this.HasRequestErrors = false;

            this.Method = SoftmakeAll.SDK.Communication.REST.DefaultMethod;

            SoftmakeAll.SDK.Communication.REST.File Result = null;
            try
            {
                System.Net.HttpWebRequest HttpWebRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(this.URL);
                HttpWebRequest.Method = this.Method;

                if (this.Headers.Count > 0)
                {
                    foreach (System.Collections.Generic.KeyValuePair <System.String, System.String> Header in this.Headers)
                    {
                        HttpWebRequest.Headers.Add(Header.Key, Header.Value);
                    }
                }
                this.AddAuthorizationHeader(HttpWebRequest);

                if (this.Body.ValueKind == System.Text.Json.JsonValueKind.Undefined)
                {
                    HttpWebRequest.ContentLength = 0;
                }
                else
                {
                    System.Byte[] BodyBytes = new System.Text.UTF8Encoding().GetBytes(Body.ToString());
                    HttpWebRequest.ContentType   = SoftmakeAll.SDK.Communication.REST.DefaultContentType;
                    HttpWebRequest.ContentLength = BodyBytes.Length;
                    System.IO.Stream RequestStream = await HttpWebRequest.GetRequestStreamAsync();

                    await RequestStream.WriteAsync(BodyBytes, 0, BodyBytes.Length);
                }

                if (this.Timeout > 0)
                {
                    HttpWebRequest.Timeout = this.Timeout;
                }

                using (System.Net.HttpWebResponse HttpWebResponse = (System.Net.HttpWebResponse) await HttpWebRequest.GetResponseAsync())
                {
                    this._StatusCode = HttpWebResponse.StatusCode;

                    System.Net.WebClient WebClient = new System.Net.WebClient();
                    foreach (System.Collections.Generic.KeyValuePair <System.String, System.String> Header in this.Headers)
                    {
                        WebClient.Headers.Add(Header.Key, Header.Value);
                    }
                    this.AddAuthorizationHeader(WebClient);
                    System.Byte[] FileContents = WebClient.DownloadData(this.URL);

                    if ((FileContents == null) || (FileContents.Length == 0))
                    {
                        return(null);
                    }

                    System.String FileName = "";

                    try
                    {
                        const System.String Key = "filename=";
                        FileName = HttpWebResponse.Headers.Get("Content-Disposition");
                        FileName = FileName.Substring(FileName.IndexOf(Key) + Key.Length);
                        FileName = FileName.Substring(0, FileName.IndexOf(';'));
                    }
                    catch
                    {
                        FileName = "";
                    }

                    return(new SoftmakeAll.SDK.Communication.REST.File()
                    {
                        Name = FileName, Contents = FileContents
                    });
                }
            }
            catch (System.Net.WebException ex)
            {
                this.HasRequestErrors = true;
                System.Net.HttpWebResponse HttpWebResponse = ex.Response as System.Net.HttpWebResponse;
                if (HttpWebResponse == null)
                {
                    this._StatusCode = System.Net.HttpStatusCode.InternalServerError;
                    Result           = null;
                    return(Result);
                }
                this._StatusCode = HttpWebResponse.StatusCode;
                Result           = null;
            }
            catch
            {
                this.HasRequestErrors = true;
                this._StatusCode      = System.Net.HttpStatusCode.InternalServerError;
                Result = null;
            }

            return(Result);
        }
        //Use the ArcGIS REST API to create a profile line based on the input geometry
        public async Task <Polyline> GetProfileLine(Geometry geometry)
        {
            try
            {
                string requestUrlBase = @"http://elevation.arcgis.com/arcgis/rest/services/Tools/Elevation/GPServer/Profile/";

                //Create the token to use
                TokenService elevationServices = new TokenService();
                _token = await elevationServices.GenerateTokenAsync();

                #region Submit a profile task to be executed asynchronously. A unique job ID will be assigned for the transaction.
                string oidField          = "OID";
                string lengthField       = "Shape_Length";
                string InputLineFeatures = CreateInputLineFeaturesJson(geometry, oidField, lengthField);
                string additonalParams   = "&ProfileIDField=" + oidField + "&DEMResolution=FINEST&MaximumSampleDistance=10&MaximumSampleDistanceUnits=Kilometers&returnZ=true&returnM=true&env%3AoutSR=102100&env%3AprocessSR=102100&f=json";
                string profileServiceUrl = string.Format("{0}submitJob?token={1}&InputLineFeatures={2}{3}", requestUrlBase, _token.AccessToken, InputLineFeatures, additonalParams);

                System.Net.HttpWebRequest webRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(profileServiceUrl);
                webRequest.Timeout = 0xea60;
                System.Net.WebResponse response = await webRequest.GetResponseAsync();

                #endregion

                #region Use the jobId to check the status of the job. Keep checking if the jobStatus is not "Succeeded"
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(JobStatus));
                _jobStatus = (JobStatus)serializer.ReadObject(response.GetResponseStream() as Stream);
                while (_jobStatus.Status.Contains("Executing") || _jobStatus.Status.Contains("esriJobWaiting") || _jobStatus.Status.Contains("Submitted"))
                {
                    string statusUrl = string.Format("{0}jobs/{1}?f=pjson&token={2}", requestUrlBase, _jobStatus.Id, _token.AccessToken);
                    webRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(statusUrl);
                    response   = await webRequest.GetResponseAsync();

                    _jobStatus = (JobStatus)serializer.ReadObject(response.GetResponseStream());
                }
                #endregion

                #region The job has successfully completed. Use the jobId to retrieve the result, then use the result to create a profile line
                if (_jobStatus.Status.Contains("Succeeded"))
                {
                    string resultsUrl = string.Format("{0}jobs/{1}/results/OutputProfile?returnZ=true&returnM=true&f=pjson&token={2}", requestUrlBase, _jobStatus.Id, _token.AccessToken);
                    webRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(resultsUrl);
                    response   = await webRequest.GetResponseAsync();

                    serializer = new DataContractJsonSerializer(typeof(OutputProfile));

                    //Parse the result as the output profile line
                    _outputProfileLine = (OutputProfile)serializer.ReadObject(response.GetResponseStream());
                    _outputProfileLine.FeatureSet.HasM = true;
                    _outputProfileLine.FeatureSet.HasZ = true;

                    //Create a polyline (profile) from the geometry of the output profile line
                    Polyline profile = new Polyline();
                    foreach (var points in _outputProfileLine.FeatureSet.Features.FirstOrDefault().Geometry.Paths)
                    {
                        PointCollection collection = new PointCollection();
                        foreach (var point in points)
                        {
                            collection.Add(
                                new MapPoint(
                                    Convert.ToDouble(point[0]), //[0] is x
                                    Convert.ToDouble(point[1]), //[1] is x
                                    Convert.ToDouble(point[2]), //[2] is z
                                    Convert.ToDouble(point[3]), //[3] is m
                                    new ESRI.ArcGIS.Client.Geometry.SpatialReference(102100)));
                        }
                        profile.Paths.Add(collection);
                    }

                    return(profile);
                }
                return(null);

                #endregion
            }
            catch (Exception)
            {
                return(null);
            }
        }
示例#29
0
        public void MapRoute(IApplicationBuilder app)
        {
            string address = "http://moa.hengyinfs.com";

            //string address = "http://localhost:5010";


            app.Map("/SqlClient", builder => {
                builder.Run(async context =>
                {
                    SqlConnection connection = new SqlConnection("Max Pool Size = 512;server=localhost;uid=sa;pwd=123456;database=HttpReports;");
                    var count = await connection.QueryFirstOrDefaultAsync <dynamic>("select * from requestinfo");

                    await context.Response.WriteAsync("ok");
                });
            });


            app.Map("/MySql", builder => {
                builder.Run(async context =>
                {
                    MySqlConnection connection = new MySqlConnection("DataBase=HttpReports;Data Source=localhost;User Id=root;Password=123456;");
                    var count = await connection.QueryFirstOrDefaultAsync <dynamic>("select * from requestinfo");

                    await context.Response.WriteAsync("ok");
                });
            });


            app.Map("/HttpClient", builder =>
            {
                builder.Run(async context =>
                {
                    HttpClient client = new HttpClient();
                    var response      = client.GetStringAsync("http://www.baidu.com").Result;

                    await context.Response.WriteAsync("OK");
                });
            });



            app.Map("/Trace", builder =>
            {
                builder.Run(async context =>
                {
                    //System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    //HttpClient client = new HttpClient();
                    //var response = await client.GetStringAsync(address +"/Test1");
                    //await context.Response.WriteAsync(response);

                    System.Net.HttpWebRequest req = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(address + "/Test1");

                    req.Timeout = 5000000;

                    using (System.Net.WebResponse wr = await req.GetResponseAsync())
                    {
                        await context.Response.WriteAsync("ok");
                    }
                });
            });

            app.Map("/Test1", builder =>
            {
                builder.Run(async context =>
                {
                    System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    HttpClient client = new HttpClient();
                    var response      = await client.GetStringAsync(address + "/Test2");
                    await context.Response.WriteAsync(response);
                });
            });

            app.Map("/Test2", builder =>
            {
                builder.Run(async context =>
                {
                    System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    HttpClient client = new HttpClient();
                    var response      = await client.GetStringAsync(address + "/Test3");
                    await context.Response.WriteAsync(response);
                });
            });

            app.Map("/Test3", builder =>
            {
                builder.Run(async context =>
                {
                    System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    HttpClient client = new HttpClient();
                    var response      = await client.GetStringAsync(address + "/Test4");
                    await context.Response.WriteAsync(response);
                });
            });


            app.Map("/Test4", builder =>
            {
                builder.Run(async context =>
                {
                    System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    HttpClient client = new HttpClient();
                    var response      = await client.GetStringAsync(address + "/Test5");
                    await context.Response.WriteAsync(response);
                });
            });


            app.Map("/Test5", builder => {
                builder.Run(async context => {
                    System.Threading.Thread.Sleep(new Random().Next(111, 5555));

                    await context.Response.WriteAsync("ok");

                    return;
                });
            });
        }
示例#30
0
        public override void Install(ModuleManager manager)
        {
            manager.CreateCommands("", cgb => {
                cgb.AddCheck(Classes.Permissions.PermissionChecker.Instance);

                var client = manager.Client;

                commands.ForEach(cmd => cmd.Init(cgb));

                cgb.CreateCommand(".sr").Alias(".setrole")
                .Description("Sets a role for a given user.\n**Usage**: .sr @User Guest")
                .Parameter("user_name", ParameterType.Required)
                .Parameter("role_name", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.ManageRoles)
                    {
                        return;
                    }
                    var usr = e.Server.FindUsers(e.GetArg("user_name")).FirstOrDefault();
                    if (usr == null)
                    {
                        await e.Send("You failed to supply a valid username");
                        return;
                    }

                    var role = e.Server.FindRoles(e.GetArg("role_name")).FirstOrDefault();
                    if (role == null)
                    {
                        await e.Send("You failed to supply a valid role");
                        return;
                    }

                    try {
                        await usr.AddRoles(new Role[] { role });
                        await e.Send($"Successfully added role **{role.Name}** to user **{usr.Name}**");
                    } catch (Exception ex) {
                        await e.Send("Failed to add roles. Most likely reason: Insufficient permissions.\n");
                        Console.WriteLine(ex.ToString());
                    }
                });

                cgb.CreateCommand(".rr").Alias(".removerole")
                .Description("Removes a role from a given user.\n**Usage**: .rr @User Admin")
                .Parameter("user_name", ParameterType.Required)
                .Parameter("role_name", ParameterType.Required)
                .Do(async e => {
                    if (!e.User.ServerPermissions.ManageRoles)
                    {
                        return;
                    }

                    var usr = e.Server.FindUsers(e.GetArg("user_name")).FirstOrDefault();
                    if (usr == null)
                    {
                        await e.Send("You failed to supply a valid username");
                        return;
                    }
                    var role = e.Server.FindRoles(e.GetArg("role_name")).FirstOrDefault();
                    if (role == null)
                    {
                        await e.Send("You failed to supply a valid role");
                        return;
                    }

                    try {
                        await usr.RemoveRoles(new Role[] { role });
                        await e.Send($"Successfully removed role **{role.Name}** from user **{usr.Name}**");
                    } catch (InvalidOperationException) {
                    } catch  {
                        await e.Send("Failed to remove roles. Most likely reason: Insufficient permissions.");
                    }
                });

                cgb.CreateCommand(".r").Alias(".role").Alias(".cr")
                .Description("Creates a role with a given name.**Usage**: .r Awesome Role")
                .Parameter("role_name", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.ManageRoles)
                    {
                        return;
                    }
                    if (string.IsNullOrWhiteSpace(e.GetArg("role_name")))
                    {
                        return;
                    }
                    try {
                        var r = await e.Server.CreateRole(e.GetArg("role_name"));
                        await e.Send($"Successfully created role **{r.Name}**.");
                    } catch (Exception ex) {
                        await e.Send(":warning: Unspecified error.");
                    }
                });

                cgb.CreateCommand(".rolecolor").Alias(".rc")
                .Parameter("Rolename", ParameterType.Required)
                .Parameter("r", ParameterType.Optional)
                .Parameter("g", ParameterType.Optional)
                .Parameter("b", ParameterType.Optional)
                .Description("Set a role's color to the hex or 0-255 color value provided.\n**Usage**: .color Admin 255 200 100 or .color Admin ffba55")
                .Do(async e => {
                    if (!e.User.ServerPermissions.ManageRoles)
                    {
                        await e.Channel.SendMessage("You don't have permission to use this!");
                        return;
                    }

                    var args = e.Args.Where(s => s != String.Empty);

                    if (args.Count() != 2 && args.Count() != 4)
                    {
                        await e.Send("The parameters are invalid.");
                        return;
                    }

                    Role role = e.Server.FindRoles(e.Args[0]).FirstOrDefault();

                    if (role == null)
                    {
                        await e.Send("That role does not exist.");
                        return;
                    }
                    try {
                        bool rgb = args.Count() == 4;

                        byte red   = Convert.ToByte(rgb ? int.Parse(e.Args[1]) : Convert.ToInt32(e.Args[1].Substring(0, 2), 16));
                        byte green = Convert.ToByte(rgb ? int.Parse(e.Args[2]) : Convert.ToInt32(e.Args[1].Substring(2, 2), 16));
                        byte blue  = Convert.ToByte(rgb ? int.Parse(e.Args[3]) : Convert.ToInt32(e.Args[1].Substring(4, 2), 16));

                        await role.Edit(color: new Color(red, green, blue));
                        await e.Channel.SendMessage($"Role {role.Name}'s color has been changed.");
                    } catch (Exception ex) {
                        await e.Send(":warning: Unspecified error, please report this.");
                        Console.WriteLine($".rolecolor error: {ex}");
                    }
                });

                cgb.CreateCommand(".roles")
                .Description("List all roles on this server or a single user if specified.")
                .Parameter("user", ParameterType.Unparsed)
                .Do(async e => {
                    if (!string.IsNullOrWhiteSpace(e.GetArg("user")))
                    {
                        var usr = e.Server.FindUsers(e.GetArg("user")).FirstOrDefault();
                        if (usr != null)
                        {
                            await e.Send($"`List of roles for **{usr.Name}**:` \n• " + string.Join("\n• ", usr.Roles).Replace("@everyone", "මeveryone"));
                            return;
                        }
                    }
                    await e.Send("`List of roles:` \n• " + string.Join("\n• ", e.Server.Roles).Replace("@everyone", "මeveryone"));
                });

                cgb.CreateCommand(".modules")
                .Description("List all bot modules")
                .Do(async e => {
                    await e.Send("`List of modules:` \n• " + string.Join("\n• ", NadekoBot.client.Modules().Modules.Select(m => m.Name)));
                });

                cgb.CreateCommand(".commands")
                .Description("List all of the bot's commands from a certain module.")
                .Parameter("module", ParameterType.Unparsed)
                .Do(async e => {
                    var commands = NadekoBot.client.Services.Get <CommandService>().AllCommands
                                   .Where(c => c.Category.ToLower() == e.GetArg("module").Trim().ToLower());
                    if (commands == null || commands.Count() == 0)
                    {
                        await e.Send("That module does not exist.");
                        return;
                    }
                    await e.Send("`List of commands:` \n• " + string.Join("\n• ", commands.Select(c => c.Text)));
                });

                cgb.CreateCommand(".b").Alias(".ban")
                .Parameter("everything", ParameterType.Unparsed)
                .Description("Bans a mentioned user")
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.BanMembers && e.Message.MentionedUsers.Any())
                        {
                            var usr = e.Message.MentionedUsers.First();
                            await usr.Server.Ban(usr);
                            await e.Send("Banned user " + usr.Name + " Id: " + usr.Id);
                        }
                    } catch (Exception ex) { }
                });

                cgb.CreateCommand(".ub").Alias(".unban")
                .Parameter("everything", ParameterType.Unparsed)
                .Description("Unbans a mentioned user")
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.BanMembers && e.Message.MentionedUsers.Any())
                        {
                            var usr = e.Message.MentionedUsers.First();
                            await usr.Server.Unban(usr);
                            await e.Send("Unbanned user " + usr.Name + " Id: " + usr.Id);
                        }
                    } catch  { }
                });

                cgb.CreateCommand(".k").Alias(".kick")
                .Parameter("user")
                .Description("Kicks a mentioned user.")
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.KickMembers && e.Message.MentionedUsers.Any())
                        {
                            var usr = e.Message.MentionedUsers.First();
                            await e.Message.MentionedUsers.First().Kick();
                            await e.Send("Kicked user " + usr.Name + " Id: " + usr.Id);
                        }
                    } catch  {
                        await e.Send("No sufficient permissions.");
                    }
                });
                cgb.CreateCommand(".mute")
                .Description("Mutes mentioned user or users")
                .Parameter("throwaway", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.MuteMembers)
                    {
                        await e.Send("You do not have permission to do that.");
                        return;
                    }
                    if (e.Message.MentionedUsers.Count() == 0)
                    {
                        return;
                    }
                    try {
                        foreach (var u in e.Message.MentionedUsers)
                        {
                            await u.Edit(isMuted: true);
                        }
                        await e.Send("Mute successful");
                    } catch  {
                        await e.Send("I do not have permission to do that most likely.");
                    }
                });

                cgb.CreateCommand(".unmute")
                .Description("Unmutes mentioned user or users")
                .Parameter("throwaway", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.MuteMembers)
                    {
                        await e.Send("You do not have permission to do that.");
                        return;
                    }
                    if (e.Message.MentionedUsers.Count() == 0)
                    {
                        return;
                    }
                    try {
                        foreach (var u in e.Message.MentionedUsers)
                        {
                            await u.Edit(isMuted: false);
                        }
                        await e.Send("Unmute successful");
                    } catch  {
                        await e.Send("I do not have permission to do that most likely.");
                    }
                });

                cgb.CreateCommand(".deafen")
                .Alias(".deaf")
                .Description("Deafens mentioned user or users")
                .Parameter("throwaway", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.DeafenMembers)
                    {
                        await e.Send("You do not have permission to do that.");
                        return;
                    }
                    if (e.Message.MentionedUsers.Count() == 0)
                    {
                        return;
                    }
                    try {
                        foreach (var u in e.Message.MentionedUsers)
                        {
                            await u.Edit(isDeafened: true);
                        }
                        await e.Send("Deafen successful");
                    } catch  {
                        await e.Send("I do not have permission to do that most likely.");
                    }
                });

                cgb.CreateCommand(".undeafen")
                .Alias(".undeaf")
                .Description("Undeafens mentioned user or users")
                .Parameter("throwaway", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.DeafenMembers)
                    {
                        await e.Send("You do not have permission to do that.");
                        return;
                    }
                    if (e.Message.MentionedUsers.Count() == 0)
                    {
                        return;
                    }
                    try {
                        foreach (var u in e.Message.MentionedUsers)
                        {
                            await u.Edit(isDeafened: false);
                        }
                        await e.Send("Undeafen successful");
                    } catch  {
                        await e.Send("I do not have permission to do that most likely.");
                    }
                });

                cgb.CreateCommand(".rvch")
                .Description("Removes a voice channel with a given name.")
                .Parameter("channel_name", ParameterType.Required)
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.ManageChannels)
                        {
                            await e.Server.FindChannels(e.GetArg("channel_name"), ChannelType.Voice).FirstOrDefault()?.Delete();
                            await e.Send($"Removed channel **{e.GetArg("channel_name")}**.");
                        }
                    } catch  {
                        await e.Send("No sufficient permissions.");
                    }
                });

                cgb.CreateCommand(".vch").Alias(".cvch")
                .Description("Creates a new voice channel with a given name.")
                .Parameter("channel_name", ParameterType.Required)
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.ManageChannels)
                        {
                            await e.Server.CreateChannel(e.GetArg("channel_name"), ChannelType.Voice);
                            await e.Send($"Created voice channel **{e.GetArg("channel_name")}**.");
                        }
                    } catch  {
                        await e.Send("No sufficient permissions.");
                    }
                });

                cgb.CreateCommand(".rch").Alias(".rtch")
                .Description("Removes a text channel with a given name.")
                .Parameter("channel_name", ParameterType.Required)
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.ManageChannels)
                        {
                            await e.Server.FindChannels(e.GetArg("channel_name"), ChannelType.Text).FirstOrDefault()?.Delete();
                            await e.Send($"Removed text channel **{e.GetArg("channel_name")}**.");
                        }
                    } catch  {
                        await e.Send("No sufficient permissions.");
                    }
                });

                cgb.CreateCommand(".ch").Alias(".tch")
                .Description("Creates a new text channel with a given name.")
                .Parameter("channel_name", ParameterType.Required)
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.ManageChannels)
                        {
                            await e.Server.CreateChannel(e.GetArg("channel_name"), ChannelType.Text);
                            await e.Send($"Added text channel **{e.GetArg("channel_name")}**.");
                        }
                    } catch  {
                        await e.Send("No sufficient permissions.");
                    }
                });

                cgb.CreateCommand(".st").Alias(".settopic")
                .Description("Sets a topic on the current channel.")
                .Parameter("topic", ParameterType.Unparsed)
                .Do(async e => {
                    try {
                        if (e.User.ServerPermissions.ManageChannels)
                        {
                            await e.Channel.Edit(topic: e.GetArg("topic"));
                        }
                    } catch  { }
                });

                cgb.CreateCommand(".uid").Alias(".userid")
                .Description("Shows user id")
                .Parameter("user", ParameterType.Optional)
                .Do(async e => {
                    var usr = e.User;
                    if (e.GetArg("user") != null)
                    {
                        usr = e.Channel.FindUsers(e.GetArg("user")).FirstOrDefault();
                    }
                    await e.Send($"Id of the user { usr.Name } is { usr.Id }");
                });

                cgb.CreateCommand(".cid").Alias(".channelid")
                .Description("Shows current channel id")
                .Do(async e => await e.Send("This channel's id is " + e.Channel.Id));

                cgb.CreateCommand(".sid").Alias(".serverid")
                .Description("Shows current server id")
                .Do(async e => await e.Send("This server's id is " + e.Server.Id));

                cgb.CreateCommand(".stats")
                .Description("Shows some basic stats for nadeko")
                .Do(async e => {
                    var t = Task.Run(() => {
                        return(NadekoStats.Instance.GetStats() + "`" + Music.GetMusicStats() + "`");
                    });

                    await e.Send(await t);
                });

                cgb.CreateCommand(".leaveall")
                .Description("Nadeko leaves all servers **OWNER ONLY**")
                .Do(e => {
                    if (e.User.Id == NadekoBot.OwnerID)
                    {
                        NadekoBot.client.Servers.ForEach(async s => { if (s.Name == e.Server.Name)
                                                                      {
                                                                          return;
                                                                      }
                                                                      await s.Leave(); });
                    }
                });

                cgb.CreateCommand(".prune")
                .Parameter("num", ParameterType.Required)
                .Description("Prunes a number of messages from the current channel.\n**Usage**: .prune 5")
                .Do(async e => {
                    if (!e.User.ServerPermissions.ManageMessages)
                    {
                        return;
                    }
                    int val;
                    if (string.IsNullOrWhiteSpace(e.GetArg("num")) || !int.TryParse(e.GetArg("num"), out val) || val < 0)
                    {
                        return;
                    }

                    foreach (var msg in await e.Channel.DownloadMessages(val))
                    {
                        await msg.Delete();
                        await Task.Delay(100);
                    }
                });

                cgb.CreateCommand(".die")
                .Alias(".graceful")
                .Description("Works only for the owner. Shuts the bot down and notifies users about the restart.")
                .Do(async e => {
                    if (e.User.Id == NadekoBot.OwnerID)
                    {
                        Timer t    = new Timer();
                        t.Interval = 2000;
                        t.Elapsed += (s, ev) => { Environment.Exit(0); };
                        t.Start();
                        await e.Send("`Shutting down.`");
                    }
                });

                ConcurrentDictionary <Server, bool> clearDictionary = new ConcurrentDictionary <Server, bool>();
                cgb.CreateCommand(".clr")
                .Description("Clears some of nadeko's messages from the current channel.")
                .Do(async e => {
                    await Task.Run(async() => {
                        var msgs = (await e.Channel.DownloadMessages(100)).Where(m => m.User.Id == NadekoBot.client.CurrentUser.Id);
                        foreach (var m in msgs)
                        {
                            await m.Delete();
                        }
                    });
                });

                cgb.CreateCommand(".newname")
                .Alias(".setname")
                .Description("Give the bot a new name.")
                .Parameter("new_name", ParameterType.Unparsed)
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID || e.GetArg("new_name") == null)
                    {
                        return;
                    }

                    await client.CurrentUser.Edit(NadekoBot.password, e.GetArg("new_name"));
                });

                cgb.CreateCommand(".newavatar")
                .Alias(".setavatar")
                .Description("Sets a new avatar image for the NadekoBot.")
                .Parameter("img", ParameterType.Unparsed)
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID || string.IsNullOrWhiteSpace(e.GetArg("img")))
                    {
                        return;
                    }
                    // Gather user provided URL.
                    string avatarAddress = e.GetArg("img");
                    // Creates an HTTPWebRequest object, which references the URL given by the user.
                    System.Net.HttpWebRequest webRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(Uri.EscapeUriString(avatarAddress));
                    // Discard the response if image isnt downloaded in 5 s as to not lock Nadeko. Prevents loading from faulty links.
                    webRequest.Timeout = 5000;
                    // Gathers the webRequest response as a Stream object.
                    System.Net.WebResponse webResponse = await webRequest.GetResponseAsync();
                    // Create image object from the response we got from the webRequest stream. This is because there is no "GetResponseStream".
                    System.Drawing.Image image = System.Drawing.Image.FromStream(webResponse.GetResponseStream());
                    // Save the image to disk.
                    image.Save("data/avatar.png", System.Drawing.Imaging.ImageFormat.Png);
                    await client.CurrentUser.Edit(NadekoBot.password, avatar: image.ToStream());
                    // Send confirm.
                    await e.Send("New avatar set.");
                });

                cgb.CreateCommand(".setgame")
                .Description("Sets the bots game.")
                .Parameter("set_game", ParameterType.Unparsed)
                .Do(e => {
                    if (e.User.Id != NadekoBot.OwnerID || e.GetArg("set_game") == null)
                    {
                        return;
                    }

                    client.SetGame(e.GetArg("set_game"));
                });

                cgb.CreateCommand(".checkmyperms")
                .Description("Checks your userspecific permissions on this channel.")
                .Do(async e => {
                    string output = "```\n";
                    foreach (var p in e.User.ServerPermissions.GetType().GetProperties().Where(p => p.GetGetMethod().GetParameters().Count() == 0))
                    {
                        output += p.Name + ": " + p.GetValue(e.User.ServerPermissions, null).ToString() + "\n";
                    }
                    output += "```";
                    await e.User.SendMessage(output);
                });

                Server commsServer   = null;
                User commsUser       = null;
                Channel commsChannel = null;

                cgb.CreateCommand(".commsuser")
                .Description("Sets a user for through-bot communication. Only works if server is set. Resets commschannel.**Owner only**.")
                .Parameter("name", ParameterType.Unparsed)
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID)
                    {
                        return;
                    }
                    commsUser = commsServer?.FindUsers(e.GetArg("name")).FirstOrDefault();
                    if (commsUser != null)
                    {
                        commsChannel = null;
                        await e.Send("User for comms set.");
                    }
                    else
                    {
                        await e.Send("No server specified or user.");
                    }
                });

                cgb.CreateCommand(".commsserver")
                .Description("Sets a server for through-bot communication.**Owner only**.")
                .Parameter("server", ParameterType.Unparsed)
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID)
                    {
                        return;
                    }
                    commsServer = client.FindServers(e.GetArg("server")).FirstOrDefault();
                    if (commsServer != null)
                    {
                        await e.Send("Server for comms set.");
                    }
                    else
                    {
                        await e.Send("No such server.");
                    }
                });

                cgb.CreateCommand(".commschannel")
                .Description("Sets a channel for through-bot communication. Only works if server is set. Resets commsuser.**Owner only**.")
                .Parameter("ch", ParameterType.Unparsed)
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID)
                    {
                        return;
                    }
                    commsChannel = commsServer?.FindChannels(e.GetArg("ch"), ChannelType.Text).FirstOrDefault();
                    if (commsChannel != null)
                    {
                        commsUser = null;
                        await e.Send("Server for comms set.");
                    }
                    else
                    {
                        await e.Send("No server specified or channel is invalid.");
                    }
                });

                cgb.CreateCommand(".send")
                .Description("Send a message to someone on a different server through the bot.**Owner only.**\n **Usage**: .send Message text multi word!")
                .Parameter("msg", ParameterType.Unparsed)
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID)
                    {
                        return;
                    }
                    if (commsUser != null)
                    {
                        await commsUser.SendMessage(e.GetArg("msg"));
                    }
                    else if (commsChannel != null)
                    {
                        await commsChannel.SendMessage(e.GetArg("msg"));
                    }
                    else
                    {
                        await e.Send("Failed. Make sure you've specified server and [channel or user]");
                    }
                });

                cgb.CreateCommand(".menrole")
                .Alias(".mentionrole")
                .Description("Mentions every person from the provided role or roles (separated by a ',') on this server. Requires you to have mention everyone permission.")
                .Parameter("roles", ParameterType.Unparsed)
                .Do(async e => {
                    if (!e.User.ServerPermissions.MentionEveryone)
                    {
                        return;
                    }
                    var arg     = e.GetArg("roles").Split(',').Select(r => r.Trim());
                    string send = $"--{e.User.Mention} has invoked a mention on the following roles--";
                    foreach (var roleStr in arg)
                    {
                        if (string.IsNullOrWhiteSpace(roleStr))
                        {
                            continue;
                        }
                        var role = e.Server.FindRoles(roleStr).FirstOrDefault();
                        if (role == null)
                        {
                            continue;
                        }
                        send += $"\n`{role.Name}`\n";
                        send += string.Join(", ", role.Members.Select(r => r.Mention));
                    }

                    while (send.Length > 2000)
                    {
                        var curstr = send.Substring(0, 2000);
                        await e.Channel.Send(curstr.Substring(0, curstr.LastIndexOf(", ") + 1));
                        send = curstr.Substring(curstr.LastIndexOf(", ") + 1) + send.Substring(2000);
                    }
                    await e.Channel.Send(send);
                });

                cgb.CreateCommand(".parsetosql")
                .Description("Loads exported parsedata from /data/parsedata/ into sqlite database.")
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID)
                    {
                        return;
                    }
                    await Task.Run(() => {
                        SaveParseToDb <Announcement>("data/parsedata/Announcements.json");
                        SaveParseToDb <Classes._DataModels.Command>("data/parsedata/CommandsRan.json");
                        SaveParseToDb <Request>("data/parsedata/Requests.json");
                        SaveParseToDb <Stats>("data/parsedata/Stats.json");
                        SaveParseToDb <TypingArticle>("data/parsedata/TypingArticles.json");
                    });
                });

                cgb.CreateCommand(".unstuck")
                .Description("Clears the message queue. **OWNER ONLY**")
                .Do(async e => {
                    if (e.User.Id != NadekoBot.OwnerID)
                    {
                        return;
                    }
                    await Task.Run(() => NadekoBot.client.MessageQueue.Clear());
                });

                cgb.CreateCommand(".donators")
                .Description("List of lovely people who donated to keep this project alive.")
                .Do(async e => {
                    await Task.Run(async() => {
                        var rows            = Classes.DBHandler.Instance.GetAllRows <Donator>();
                        var donatorsOrdered = rows.OrderByDescending(d => d.Amount);
                        string str          = $"`Total number of people who donated is {donatorsOrdered.Count()}`\n";

                        await e.Channel.SendMessage(str + string.Join(", ", donatorsOrdered.Select(d => d.UserName)));
                    });
                });

                //THIS IS INTENTED TO BE USED ONLY BY THE ORIGINAL BOT OWNER
                cgb.CreateCommand(".adddon")
                .Alias(".donadd")
                .Description("Add a donator to the database.")
                .Parameter("donator")
                .Parameter("amount")
                .Do(e => {
                    try {
                        if (NadekoBot.OwnerID != e.User.Id)
                        {
                            return;
                        }
                        var donator = e.Server.FindUsers(e.GetArg("donator")).FirstOrDefault();
                        var amount  = int.Parse(e.GetArg("amount"));
                        Classes.DBHandler.Instance.InsertData(new Donator {
                            Amount   = amount,
                            UserName = donator.Name,
                            UserId   = (long)e.User.Id
                        });
                        e.Channel.SendMessage("Successfuly added a new donator. 👑");
                    } catch (Exception ex) {
                        Console.WriteLine(ex);
                        Console.WriteLine("---------------\nInner error:\n" + ex.InnerException);
                    }
                });
            });
        }