Refaction all files into component based folders

Geekbot.net/Commands/Randomness/Cat/Cat.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using Newtonsoft.Json;
+
+namespace Geekbot.net.Commands.Randomness.Cat
+{
+    public class Cat : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+
+        public Cat(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+
+        [Command("cat", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Return a random image of a cat.")]
+        public async Task Say()
+        {
+            try
+            {
+                using (var client = new HttpClient())
+                {
+                    try
+                    {
+                        client.BaseAddress = new Uri("https://aws.random.cat");
+                        var response = await client.GetAsync("/meow");
+                        response.EnsureSuccessStatusCode();
+
+                        var stringResponse = await response.Content.ReadAsStringAsync();
+                        var catFile = JsonConvert.DeserializeObject<CatResponseDto>(stringResponse);
+                        var eb = new EmbedBuilder();
+                        eb.ImageUrl = catFile.File;
+                        await ReplyAsync("", false, eb.Build());
+                    }
+                    catch
+                    {
+                        await ReplyAsync("Seems like the dog cought the cat (error occured)");
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Cat/CatResponseDto.cs

@@ -0,0 +1,7 @@
+namespace Geekbot.net.Commands.Randomness.Cat
+{
+    internal class CatResponseDto
+    {
+        public string File { get; set; }
+    }
+}

Geekbot.net/Commands/Randomness/CheckEm.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using Geekbot.net.Lib.Media;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class CheckEm : ModuleBase
+    {
+        private readonly IMediaProvider _checkEmImages;
+        private readonly IErrorHandler _errorHandler;
+
+        public CheckEm(IMediaProvider mediaProvider, IErrorHandler errorHandler)
+        {
+            _checkEmImages = mediaProvider;
+            _errorHandler = errorHandler;
+        }
+
+        [Command("checkem", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Check for dubs")]
+        public async Task MuhDubs()
+        {
+            try
+            {
+                var number = new Random().Next(10000000, 99999999);
+                var dubtriqua = "";
+
+                var ns = GetIntArray(number);
+                if (ns[7] == ns[6])
+                {
+                    dubtriqua = "DUBS";
+                    if (ns[6] == ns[5])
+                    {
+                        dubtriqua = "TRIPS";
+                        if (ns[5] == ns[4])
+                            dubtriqua = "QUADS";
+                    }
+                }
+
+                var sb = new StringBuilder();
+                sb.AppendLine($"Check em {Context.User.Mention}");
+                sb.AppendLine($"**{number}**");
+                if (!string.IsNullOrEmpty(dubtriqua))
+                    sb.AppendLine($":tada: {dubtriqua} :tada:");
+                sb.AppendLine(_checkEmImages.GetCheckem());
+
+                await ReplyAsync(sb.ToString());
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+
+        private int[] GetIntArray(int num)
+        {
+            var listOfInts = new List<int>();
+            while (num > 0)
+            {
+                listOfInts.Add(num % 10);
+                num = num / 10;
+            }
+
+            listOfInts.Reverse();
+            return listOfInts.ToArray();
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Chuck/ChuckNorrisJokeResponseDto.cs

@@ -0,0 +1,7 @@
+namespace Geekbot.net.Commands.Randomness.Chuck
+{
+    internal class ChuckNorrisJokeResponseDto
+    {
+        public string Value { get; set; }
+    }
+}

Geekbot.net/Commands/Randomness/Chuck/ChuckNorrisJokes.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using Newtonsoft.Json;
+
+namespace Geekbot.net.Commands.Randomness.Chuck
+{
+    public class ChuckNorrisJokes : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+
+        public ChuckNorrisJokes(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+        
+        [Command("chuck", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("A random chuck norris joke")]
+        public async Task Say()
+        {
+            try
+            {
+                using (var client = new HttpClient())
+                {
+                    try
+                    {
+                        client.DefaultRequestHeaders.Accept.Clear();
+                        client.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
+                        var response = await client.GetAsync("https://api.chucknorris.io/jokes/random");
+                        response.EnsureSuccessStatusCode();
+
+                        var stringResponse = await response.Content.ReadAsStringAsync();
+                        var data = JsonConvert.DeserializeObject<ChuckNorrisJokeResponseDto>(stringResponse);
+                        await ReplyAsync(data.Value);
+                    }
+                    catch (HttpRequestException)
+                    {
+                        await ReplyAsync("Api down...");
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Dad/DadJokeResponseDto.cs

@@ -0,0 +1,7 @@
+namespace Geekbot.net.Commands.Randomness.Dad
+{
+    internal class DadJokeResponseDto
+    {
+        public string Joke { get; set; }
+    }
+}

Geekbot.net/Commands/Randomness/Dad/DadJokes.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using Newtonsoft.Json;
+
+namespace Geekbot.net.Commands.Randomness.Dad
+{
+    public class DadJokes : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+
+        public DadJokes(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+        
+        [Command("dad", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("A random dad joke")]
+        public async Task Say()
+        {
+            try
+            {
+                using (var client = new HttpClient())
+                {
+                    try
+                    {
+                        client.DefaultRequestHeaders.Accept.Clear();
+                        client.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
+                        var response = await client.GetAsync("https://icanhazdadjoke.com/");
+                        response.EnsureSuccessStatusCode();
+
+                        var stringResponse = await response.Content.ReadAsStringAsync();
+                        var data = JsonConvert.DeserializeObject<DadJokeResponseDto>(stringResponse);
+                        await ReplyAsync(data.Joke);
+                    }
+                    catch (HttpRequestException)
+                    {
+                        await ReplyAsync("Api down...");
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Dog/Dog.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using Newtonsoft.Json;
+
+namespace Geekbot.net.Commands.Randomness.Dog
+{
+    public class Dog : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+
+        public Dog(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+
+        [Command("dog", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Return a random image of a dog.")]
+        public async Task Say()
+        {
+            try
+            {
+                using (var client = new HttpClient())
+                {
+                    try
+                    {
+                        client.BaseAddress = new Uri("http://random.dog");
+                        var response = await client.GetAsync("/woof.json");
+                        response.EnsureSuccessStatusCode();
+
+                        var stringResponse = await response.Content.ReadAsStringAsync();
+                        var dogFile = JsonConvert.DeserializeObject<DogResponseDto>(stringResponse);
+                        var eb = new EmbedBuilder();
+                        eb.ImageUrl = dogFile.Url;
+                        await ReplyAsync("", false, eb.Build());
+                    }
+                    catch (HttpRequestException e)
+                    {
+                        await ReplyAsync($"Seems like the dog got lost (error occured)\r\n{e.Message}");
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Dog/DogResponseDto.cs

@@ -0,0 +1,7 @@
+namespace Geekbot.net.Commands.Randomness.Dog
+{
+    internal class DogResponseDto
+    {
+        public string Url { get; set; }
+    }
+}

Geekbot.net/Commands/Randomness/EightBall.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class EightBall : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+
+        public EightBall(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+
+        [Command("8ball", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Ask 8Ball a Question.")]
+        public async Task Ball([Remainder] [Summary("Question")] string echo)
+        {
+            try
+            {
+                var replies = new List<string>
+                {
+                    "It is certain",
+                    "It is decidedly so",
+                    "Without a doubt",
+                    "Yes, definitely",
+                    "You may rely on it",
+                    "As I see it, yes",
+                    "Most likely",
+                    "Outlook good",
+                    "Yes",
+                    "Signs point to yes",
+                    "Reply hazy try again",
+                    "Ask again later",
+                    "Better not tell you now",
+                    "Cannot predict now",
+                    "Concentrate and ask again",
+                    "Don't count on it",
+                    "My reply is no",
+                    "My sources say no",
+                    "Outlook not so good",
+                    "Very doubtful"
+                };
+
+                var answer = new Random().Next(replies.Count);
+                await ReplyAsync(replies[answer]);
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Fortune.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.Media;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class Fortune : ModuleBase
+    {
+        private readonly IFortunesProvider _fortunes;
+
+        public Fortune(IFortunesProvider fortunes)
+        {
+            _fortunes = fortunes;
+        }
+
+        [Command("fortune", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random fortune")]
+        public async Task GetAFortune()
+        {
+            await ReplyAsync(_fortunes.GetRandomFortune());
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Gdq.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class Gdq : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        
+        public Gdq(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+
+        [Command("gdq", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Games)]
+        [Summary("Get a quote from the GDQ donation generator.")]
+        public async Task GetQuote()
+        {
+            try
+            {
+                using (var client = new WebClient())
+                {
+                    var url = new Uri("http://taskinoz.com/gdq/api/");
+                    var response = client.DownloadString(url);
+                    
+                    await ReplyAsync(response);
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Randomness/RandomAnimals.cs

@@ -0,0 +1,83 @@
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.Media;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class RandomAnimals : ModuleBase
+    {
+        private readonly IMediaProvider _mediaProvider;
+
+        public RandomAnimals(IMediaProvider mediaProvider)
+        {
+            _mediaProvider = mediaProvider;
+        }
+
+        [Command("panda", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random panda image")]
+        public async Task Panda()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetPanda()));
+        }
+
+        [Command("croissant", RunMode = RunMode.Async)]
+        [Alias("gipfeli")]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random croissant image")]
+        public async Task Croissant()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetCrossant()));
+        }
+
+        [Command("pumpkin", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random pumpkin image")]
+        public async Task Pumpkin()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetPumpkin()));
+        }
+
+        [Command("squirrel", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random squirrel image")]
+        public async Task Squirrel()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetSquirrel()));
+        }
+
+        [Command("turtle", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random turtle image")]
+        public async Task Turtle()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetTurtle()));
+        }
+        
+        [Command("pinguin", RunMode = RunMode.Async)]
+        [Alias("pingu")]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random pinguin image")]
+        public async Task Pinguin()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetPinguin()));
+        }
+        
+        [Command("fox", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Randomness)]
+        [Summary("Get a random fox image")]
+        public async Task Fox()
+        {
+            await ReplyAsync("", false, Eb(_mediaProvider.GetFox()));
+        }
+
+        private EmbedBuilder Eb(string image)
+        {
+            var eb = new EmbedBuilder();
+            eb.ImageUrl = image;
+            return eb;
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Ship.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using StackExchange.Redis;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class Ship : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IDatabase _redis;
+
+        public Ship(IDatabase redis, IErrorHandler errorHandler)
+        {
+            _redis = redis;
+            _errorHandler = errorHandler;
+        }
+
+        [Command("Ship", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Fun)]
+        [Summary("Ask the Shipping meter")]
+        public async Task Command([Summary("@User1")] IUser user1, [Summary("@User2")] IUser user2)
+        {
+            try
+            {
+                var dbstring = "";
+                if (user1.Id > user2.Id)
+                    dbstring = $"{user1.Id}-{user2.Id}";
+                else
+                    dbstring = $"{user2.Id}-{user1.Id}";
+
+                var dbval = _redis.HashGet($"{Context.Guild.Id}:Ships", dbstring);
+                var shippingRate = 0;
+                if (dbval.IsNullOrEmpty)
+                {
+                    shippingRate = new Random().Next(1, 100);
+                    _redis.HashSet($"{Context.Guild.Id}:Ships", dbstring, shippingRate);
+                }
+                else
+                {
+                    shippingRate = int.Parse(dbval.ToString());
+                }
+
+                var reply = ":heartpulse: **Matchmaking** :heartpulse:\r\n";
+                reply = reply + $":two_hearts: {user1.Mention} :heart: {user2.Mention} :two_hearts:\r\n";
+                reply = reply + $"0% [{BlockCounter(shippingRate)}] 100% - {DeterminateSuccess(shippingRate)}";
+                await ReplyAsync(reply);
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+
+        private string DeterminateSuccess(int rate)
+        {
+            if (rate < 20)
+                return "Not gonna happen";
+            if (rate >= 20 && rate < 40)
+                return "Not such a good idea";
+            if (rate >= 40 && rate < 60)
+                return "There might be a chance";
+            if (rate >= 60 && rate < 80)
+                return "Almost a match, but could work";
+            return rate >= 80 ? "It's a match" : "a";
+        }
+
+        private string BlockCounter(int rate)
+        {
+            var amount = Math.Floor(decimal.Floor(rate / 10));
+            Console.WriteLine(amount);
+            var blocks = "";
+            for (var i = 1; i <= 10; i++)
+                if (i <= amount)
+                {
+                    blocks = blocks + ":white_medium_small_square:";
+                    if (i == amount)
+                        blocks = blocks + $" {rate}% ";
+                }
+                else
+                {
+                    blocks = blocks + ":black_medium_small_square:";
+                }
+
+            return blocks;
+        }
+    }
+}

Geekbot.net/Commands/Randomness/Slap.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using StackExchange.Redis;
+
+namespace Geekbot.net.Commands.Randomness
+{
+    public class Slap : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IDatabase _redis;
+
+        public Slap(IErrorHandler errorHandler, IDatabase redis)
+        {
+            _errorHandler = errorHandler;
+            _redis = redis;
+        }
+
+        [Command("slap", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Fun)]
+        [Summary("slap someone")]
+        public async Task Slapper([Summary("@user")] IUser user)
+        {
+            try
+            {
+                if (user.Id == Context.User.Id)
+                {
+                    await ReplyAsync("Why would you slap yourself?");
+                    return;
+                }
+                
+                var things = new List<string>
+                {
+                    "thing",
+                    "rubber chicken",
+                    "leek stick",
+                    "large trout",
+                    "flat hand",
+                    "strip of bacon",
+                    "feather",
+                    "piece of pizza",
+                    "moldy banana",
+                    "sharp retort",
+                    "printed version of wikipedia",
+                    "panda paw",
+                    "spiked sledgehammer",
+                    "monstertruck",
+                    "dirty toilet brush",
+                    "sleeping seagull",
+                    "sunflower",
+                    "mousepad",
+                    "lolipop",
+                    "bottle of rum",
+                    "cheese slice",
+                    "critical 1",
+                    "natural 20",
+                    "mjölnir (aka mewmew)",
+                    "kamehameha",
+                    "copy of Twilight",
+                    "med pack (get ready for the end boss)",
+                    "derp",
+                    "condom (used)",
+                    "gremlin fed after midnight",
+                    "wet baguette",
+                    "exploding kitten",
+                    "shiny piece of shit",
+                    "mismatched pair of socks",
+                    "horcrux",
+                    "tuna",
+                    "suggestion",
+                    "teapot",
+                    "candle",
+                    "dictionary",
+                    "powerless banhammer"
+                };
+                
+                _redis.HashIncrement($"{Context.Guild.Id}:SlapsRecieved", user.Id.ToString());
+                _redis.HashIncrement($"{Context.Guild.Id}:SlapsGiven", Context.User.Id.ToString());
+                
+                await ReplyAsync($"{Context.User.Username} slapped {user.Username} with a {things[new Random().Next(things.Count - 1)]}");
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}