IT IS DONE

celluj34 · celluj34 · commit 68624c9bf62a · 2016-02-20T02:38:28.000-06:00
diff --git a/DeepBotPointFucker/DeepBotPointFucker.csproj b/DeepBotPointFucker/DeepBotPointFucker.csproj
@@ -39,7 +39,6 @@
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
-    <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -48,11 +47,13 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="CommandResult.cs" />
+    <Compile Include="Models\CommandResult.cs" />
+    <Compile Include="Models\RegisterResult.cs" />
+    <Compile Include="Models\User.cs" />
     <Compile Include="PointDownloader.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="UserResult.cs" />
+    <Compile Include="Models\UserResult.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
diff --git a/DeepBotPointFucker/Models/CommandResult.cs b/DeepBotPointFucker/Models/CommandResult.cs
@@ -1,18 +1,13 @@
 ﻿using Newtonsoft.Json;
 
-namespace DeepBotPointFucker
+namespace DeepBotPointFucker.Models
 {
     public class CommandResult
     {
-        /*
         [JsonProperty(PropertyName = "function")]
         public string Function {get;set;}
 
         [JsonProperty(PropertyName = "param")]
         public string Parameter {get;set;}
-        */
-
-        [JsonProperty(PropertyName = "msg")]
-        public string Message {get;set;}
     }
 }
diff --git a/DeepBotPointFucker/Models/RegisterResult.cs b/DeepBotPointFucker/Models/RegisterResult.cs
@@ -0,0 +1,10 @@
+﻿using Newtonsoft.Json;
+
+namespace DeepBotPointFucker.Models
+{
+    public class RegisterResult : CommandResult
+    {
+        [JsonProperty(PropertyName = "msg")]
+        public string Message {get;set;}
+    }
+}
diff --git a/DeepBotPointFucker/Models/User.cs b/DeepBotPointFucker/Models/User.cs
@@ -1,18 +1,18 @@
-﻿using Newtonsoft.Json;
+using System;
+using Newtonsoft.Json;
 
-namespace DeepBotPointFucker
+namespace DeepBotPointFucker.Models
 {
-    public class UserResult
+    public class User
     {
         [JsonProperty(PropertyName = "user")]
-        public string User {get;set;}
+        public string Name {get;set;}
 
         [JsonProperty(PropertyName = "points")]
         public decimal Points {get;set;}
 
-        /*
         [JsonProperty(PropertyName = "watch_time")]
-        public int WatchTime {get;set;}
+        public decimal WatchTime {get;set;}
 
         [JsonProperty(PropertyName = "vip")]
         public int Vip {get;set;}
@@ -28,6 +28,5 @@ public class UserResult
 
         [JsonProperty(PropertyName = "vip_expiry")]
         public DateTime VipExpiry {get;set;}
-        */
     }
 }
diff --git a/DeepBotPointFucker/Models/UserResult.cs b/DeepBotPointFucker/Models/UserResult.cs
@@ -0,0 +1,11 @@
+﻿using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace DeepBotPointFucker.Models
+{
+    public class UserResult : CommandResult
+    {
+        [JsonProperty(PropertyName = "msg")]
+        public List<User> Message {get;set;}
+    }
+}
diff --git a/DeepBotPointFucker/PointDownloader.cs b/DeepBotPointFucker/PointDownloader.cs
@@ -6,7 +6,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Windows.Forms;
+using DeepBotPointFucker.Models;
 using Newtonsoft.Json;
 
 namespace DeepBotPointFucker
@@ -45,7 +45,7 @@ public async Task<bool> Connect(string apiKey)
 
                 Log($"Sending command `{command}`.");
 
-                await SendMessage(command);
+                await SendCommand(command);
             }
             catch
             {
@@ -56,11 +56,11 @@ public async Task<bool> Connect(string apiKey)
 
             try
             {
-                var registerResult = await ReceiveMessage();
+                var registerResult = await ReceiveMessage<RegisterResult>();
 
                 Log("Response received.");
 
-                if (registerResult?.Message == "success")
+                if(registerResult?.Message == "success")
                 {
                     Log("Registering with DeepBot's API was successful.");
 
@@ -77,55 +77,58 @@ public async Task<bool> Connect(string apiKey)
             return false;
         }
 
-        public async Task<List<UserResult>> Download()
+        public async Task<List<User>> Download()
         {
-            var allUsers = new List<UserResult>();
+            Log("Beginning download.");
+            var allUsers = new List<User>();
             var currentOffset = 0;
             const int limit = 100;
 
-            var command = $"api|get_users|{currentOffset}|{limit}";
-
-            List<UserResult> users;
             do
             {
-                users = await GetUsers(command);
+                string command = $"api|get_users|{currentOffset}|{limit}";
+
+                var users = await GetUsers(command);
 
                 allUsers.AddRange(users);
 
                 currentOffset += users.Count;
-            } while(users.Any());
+            } while(currentOffset % limit == 0);
 
+            Log("Finished download.");
             return allUsers;
         }
 
-        private async Task<List<UserResult>> GetUsers(string command)
+        private async Task<List<User>> GetUsers(string command)
         {
             try
             {
                 Log($"Sending command `{command}`.");
 
-                await SendMessage(command);
+                await SendCommand(command);
             }
             catch
             {
                 Log("Command failed.");
 
-                return new List<UserResult>();
+                return new List<User>();
             }
 
             try
             {
-                var result = await ReceiveMessage();
+                var result = await ReceiveMessage<UserResult>();
 
                 Log("Response received.");
 
-                return JsonConvert.DeserializeObject<List<UserResult>>(result.Message);
+                return result.Message;
             }
-            catch
+            catch(Exception e)
             {
+                Log(e.Message);
+
                 Log("There was an error receiving the response.");
 
-                return new List<UserResult>();
+                return new List<User>();
             }
         }
 
@@ -134,22 +137,15 @@ private void Log(string message)
             Console.WriteLine(message);
         }
 
-        private async Task SendMessage(string message)
+        private async Task SendCommand(string command)
         {
-            using(var memoryStream = new MemoryStream())
-            {
-                using(var writer = new StreamWriter(memoryStream, Encoding.UTF8))
-                {
-                    await writer.WriteLineAsync(message);
-                }
-
-                var arraySegment = new ArraySegment<byte>(memoryStream.ToArray());
+            var buffer = Encoding.UTF8.GetBytes(command);
+            var arraySegment = new ArraySegment<byte>(buffer);
 
-                await _socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);
-            }
+            await _socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);
         }
 
-        private async Task<CommandResult> ReceiveMessage()
+        private async Task<T> ReceiveMessage<T>()
         {
             using(var memoryStream = new MemoryStream())
             {
@@ -165,32 +161,39 @@ private async Task<CommandResult> ReceiveMessage()
 
                 if(result.MessageType != WebSocketMessageType.Text)
                 {
-                    return null;
+                    return default(T);
                 }
 
                 using(var reader = new StreamReader(memoryStream, Encoding.UTF8))
                 {
                     var message = await reader.ReadToEndAsync();
 
-                    return JsonConvert.DeserializeObject<CommandResult>(message);
+                    return JsonConvert.DeserializeObject<T>(message);
                 }
             }
         }
 
-        public void WriteResultsToFile(List<UserResult> results)
+        public void WriteResultsToFile(List<User> results)
         {
-            var ofd = new OpenFileDialog();
-            if(ofd.ShowDialog() != DialogResult.OK)
-            {
-                return;
-            }
-            
+            Log("Beginning writing results to file.");
+
             var stringBuilder = new StringBuilder();
             stringBuilder.AppendLine("User,Points");
 
-            var text = results.Aggregate(stringBuilder, (builder, result) => builder.AppendLine($"{result.User},{result.Points}"), builder => builder.ToString());
+            var text = results.Where(x => x.Points > 100)
+                              .OrderByDescending(x => x.Points)
+                              .Aggregate(stringBuilder, (builder, result) => builder.AppendLine($"{result.Name},{result.Points}"), builder => builder.ToString());
+
+            var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "results.txt");
+
+            if(!File.Exists(filePath))
+            {
+                File.Create(filePath);
+            }
+
+            File.WriteAllText(filePath, text);
 
-            File.WriteAllText(ofd.FileName, text);
+            Log("Completed writing results to file.");
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,13 @@`
`1`	`1`	`using Newtonsoft.Json;`
`2`	`2`
`3`		`-namespace DeepBotPointFucker`
	`3`	`+namespace DeepBotPointFucker.Models`
`4`	`4`	`{`
`5`	`5`	`public class CommandResult`
`6`	`6`	`{`
`7`		`- /*`
`8`	`7`	`[JsonProperty(PropertyName = "function")]`
`9`	`8`	`public string Function {get;set;}`
`10`	`9`
`11`	`10`	`[JsonProperty(PropertyName = "param")]`
`12`	`11`	`public string Parameter {get;set;}`
`13`		`- */`
`14`		`-`
`15`		`- [JsonProperty(PropertyName = "msg")]`
`16`		`- public string Message {get;set;}`
`17`	`12`	`}`
`18`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`using System.Text;`
`7`	`7`	`using System.Threading;`
`8`	`8`	`using System.Threading.Tasks;`
`9`		`-using System.Windows.Forms;`
	`9`	`+using DeepBotPointFucker.Models;`
`10`	`10`	`using Newtonsoft.Json;`
`11`	`11`
`12`	`12`	`namespace DeepBotPointFucker`
`@@ -45,7 +45,7 @@ public async Task<bool> Connect(string apiKey)`
`45`	`45`
`46`	`46`	Log($"Sending command `{command}`.");
`47`	`47`
`48`		`- await SendMessage(command);`
	`48`	`+ await SendCommand(command);`
`49`	`49`	`}`
`50`	`50`	`catch`
`51`	`51`	`{`
`@@ -56,11 +56,11 @@ public async Task<bool> Connect(string apiKey)`
`56`	`56`
`57`	`57`	`try`
`58`	`58`	`{`
`59`		`- var registerResult = await ReceiveMessage();`
	`59`	`+ var registerResult = await ReceiveMessage<RegisterResult>();`
`60`	`60`
`61`	`61`	`Log("Response received.");`
`62`	`62`
`63`		`- if (registerResult?.Message == "success")`
	`63`	`+ if(registerResult?.Message == "success")`
`64`	`64`	`{`
`65`	`65`	`Log("Registering with DeepBot's API was successful.");`
`66`	`66`
`@@ -77,55 +77,58 @@ public async Task<bool> Connect(string apiKey)`
`77`	`77`	`return false;`
`78`	`78`	`}`
`79`	`79`
`80`		`- public async Task<List<UserResult>> Download()`
	`80`	`+ public async Task<List<User>> Download()`
`81`	`81`	`{`
`82`		`- var allUsers = new List<UserResult>();`
	`82`	`+ Log("Beginning download.");`
	`83`	`+ var allUsers = new List<User>();`
`83`	`84`	`var currentOffset = 0;`
`84`	`85`	`const int limit = 100;`
`85`	`86`
`86`		`- var command = $"api\|get_users\|{currentOffset}\|{limit}";`
`87`		`-`
`88`		`- List<UserResult> users;`
`89`	`87`	`do`
`90`	`88`	`{`
`91`		`- users = await GetUsers(command);`
	`89`	`+ string command = $"api\|get_users\|{currentOffset}\|{limit}";`
	`90`	`+`
	`91`	`+ var users = await GetUsers(command);`
`92`	`92`
`93`	`93`	`allUsers.AddRange(users);`
`94`	`94`
`95`	`95`	`currentOffset += users.Count;`
`96`		`- } while(users.Any());`
	`96`	`+ } while(currentOffset % limit == 0);`
`97`	`97`
	`98`	`+ Log("Finished download.");`
`98`	`99`	`return allUsers;`
`99`	`100`	`}`
`100`	`101`
`101`		`- private async Task<List<UserResult>> GetUsers(string command)`
	`102`	`+ private async Task<List<User>> GetUsers(string command)`
`102`	`103`	`{`
`103`	`104`	`try`
`104`	`105`	`{`
`105`	`106`	Log($"Sending command `{command}`.");
`106`	`107`
`107`		`- await SendMessage(command);`
	`108`	`+ await SendCommand(command);`
`108`	`109`	`}`
`109`	`110`	`catch`
`110`	`111`	`{`
`111`	`112`	`Log("Command failed.");`
`112`	`113`
`113`		`- return new List<UserResult>();`
	`114`	`+ return new List<User>();`
`114`	`115`	`}`
`115`	`116`
`116`	`117`	`try`
`117`	`118`	`{`
`118`		`- var result = await ReceiveMessage();`
	`119`	`+ var result = await ReceiveMessage<UserResult>();`
`119`	`120`
`120`	`121`	`Log("Response received.");`
`121`	`122`
`122`		`- return JsonConvert.DeserializeObject<List<UserResult>>(result.Message);`
	`123`	`+ return result.Message;`
`123`	`124`	`}`
`124`		`- catch`
	`125`	`+ catch(Exception e)`
`125`	`126`	`{`
	`127`	`+ Log(e.Message);`
	`128`	`+`
`126`	`129`	`Log("There was an error receiving the response.");`
`127`	`130`
`128`		`- return new List<UserResult>();`
	`131`	`+ return new List<User>();`
`129`	`132`	`}`
`130`	`133`	`}`
`131`	`134`
`@@ -134,22 +137,15 @@ private void Log(string message)`
`134`	`137`	`Console.WriteLine(message);`
`135`	`138`	`}`
`136`	`139`
`137`		`- private async Task SendMessage(string message)`
	`140`	`+ private async Task SendCommand(string command)`
`138`	`141`	`{`
`139`		`- using(var memoryStream = new MemoryStream())`
`140`		`- {`
`141`		`- using(var writer = new StreamWriter(memoryStream, Encoding.UTF8))`
`142`		`- {`
`143`		`- await writer.WriteLineAsync(message);`
`144`		`- }`
`145`		`-`
`146`		`- var arraySegment = new ArraySegment<byte>(memoryStream.ToArray());`
	`142`	`+ var buffer = Encoding.UTF8.GetBytes(command);`
	`143`	`+ var arraySegment = new ArraySegment<byte>(buffer);`
`147`	`144`
`148`		`- await _socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);`
`149`		`- }`
	`145`	`+ await _socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);`
`150`	`146`	`}`
`151`	`147`
`152`		`- private async Task<CommandResult> ReceiveMessage()`
	`148`	`+ private async Task<T> ReceiveMessage<T>()`
`153`	`149`	`{`
`154`	`150`	`using(var memoryStream = new MemoryStream())`
`155`	`151`	`{`
`@@ -165,32 +161,39 @@ private async Task<CommandResult> ReceiveMessage()`
`165`	`161`
`166`	`162`	`if(result.MessageType != WebSocketMessageType.Text)`
`167`	`163`	`{`
`168`		`- return null;`
	`164`	`+ return default(T);`
`169`	`165`	`}`
`170`	`166`
`171`	`167`	`using(var reader = new StreamReader(memoryStream, Encoding.UTF8))`
`172`	`168`	`{`
`173`	`169`	`var message = await reader.ReadToEndAsync();`
`174`	`170`
`175`		`- return JsonConvert.DeserializeObject<CommandResult>(message);`
	`171`	`+ return JsonConvert.DeserializeObject<T>(message);`
`176`	`172`	`}`
`177`	`173`	`}`
`178`	`174`	`}`
`179`	`175`
`180`		`- public void WriteResultsToFile(List<UserResult> results)`
	`176`	`+ public void WriteResultsToFile(List<User> results)`
`181`	`177`	`{`
`182`		`- var ofd = new OpenFileDialog();`
`183`		`- if(ofd.ShowDialog() != DialogResult.OK)`
`184`		`- {`
`185`		`- return;`
`186`		`- }`
`187`		`-`
	`178`	`+ Log("Beginning writing results to file.");`
	`179`	`+`
`188`	`180`	`var stringBuilder = new StringBuilder();`
`189`	`181`	`stringBuilder.AppendLine("User,Points");`
`190`	`182`
`191`		`- var text = results.Aggregate(stringBuilder, (builder, result) => builder.AppendLine($"{result.User},{result.Points}"), builder => builder.ToString());`
	`183`	`+ var text = results.Where(x => x.Points > 100)`
	`184`	`+ .OrderByDescending(x => x.Points)`
	`185`	`+ .Aggregate(stringBuilder, (builder, result) => builder.AppendLine($"{result.Name},{result.Points}"), builder => builder.ToString());`
	`186`	`+`
	`187`	`+ var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "results.txt");`
	`188`	`+`
	`189`	`+ if(!File.Exists(filePath))`
	`190`	`+ {`
	`191`	`+ File.Create(filePath);`
	`192`	`+ }`
	`193`	`+`
	`194`	`+ File.WriteAllText(filePath, text);`
`192`	`195`
`193`		`- File.WriteAllText(ofd.FileName, text);`
	`196`	`+ Log("Completed writing results to file.");`
`194`	`197`	`}`
`195`	`198`	`}`
`196`	`199`	`}`