Refaction all files into component based folders

Geekbot.net/Commands/Integrations/Google/Google.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using StackExchange.Redis;
+using Utf8Json;
+
+namespace Geekbot.net.Commands.Integrations.Google
+{
+    public class Google : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IDatabase _redis;
+
+        public Google(IErrorHandler errorHandler, IDatabase redis)
+        {
+            _errorHandler = errorHandler;
+            _redis = redis;
+        }
+        
+        [Command("google", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Helpers)]
+        [Summary("Google Something.")]
+        public async Task AskGoogle([Remainder, Summary("SearchText")] string searchText)
+        {
+            try
+            {
+                using (var client = new WebClient())
+                {
+                    var apiKey = _redis.StringGet("googleGraphKey");
+                    if (!apiKey.HasValue)
+                    {
+                        await ReplyAsync("No Google API key has been set, please contact my owner");
+                        return;
+                    } 
+                    
+                    var url = new Uri($"https://kgsearch.googleapis.com/v1/entities:search?languages=en&limit=1&query={searchText}&key={apiKey}");
+                    var responseString = client.DownloadString(url);
+                    var response = JsonSerializer.Deserialize<GoogleKgApiResponseDto>(responseString);
+
+                    if (!response.ItemListElement.Any())
+                    {
+                        await ReplyAsync("No results were found...");
+                        return;
+                    }
+
+                    var data = response.ItemListElement.First().ResultDto;
+                    var eb = new EmbedBuilder();
+                    eb.Title = data.Name;
+                    if(!string.IsNullOrEmpty(data.Description)) eb.WithDescription(data.Description);
+                    if(!string.IsNullOrEmpty(data.DetailedDtoDescription?.Url)) eb.WithUrl(data.DetailedDtoDescription.Url);
+                    if(!string.IsNullOrEmpty(data.DetailedDtoDescription?.ArticleBody)) eb.AddField("Details", data.DetailedDtoDescription.ArticleBody);
+                    if(!string.IsNullOrEmpty(data.ImageDto?.ContentUrl)) eb.WithThumbnailUrl(data.ImageDto.ContentUrl);
+                    
+                    await ReplyAsync("", false, eb.Build());
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Integrations/Google/GoogleKgApiDetailedDto.cs

@@ -0,0 +1,9 @@
+namespace Geekbot.net.Commands.Integrations.Google
+{
+    public class GoogleKgApiDetailedDto
+    {
+        public string ArticleBody { get; set; }
+        public string Url { get; set; }
+        public string License { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/Google/GoogleKgApiElementDto.cs

@@ -0,0 +1,8 @@
+namespace Geekbot.net.Commands.Integrations.Google
+{
+    public class GoogleKgApiElementDto
+    {
+        public GoogleKgApiResultDto ResultDto { get; set; }
+        public double ResultScore { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/Google/GoogleKgApiImageDto.cs

@@ -0,0 +1,8 @@
+namespace Geekbot.net.Commands.Integrations.Google
+{
+    public class GoogleKgApiImageDto
+    {
+        public string ContentUrl { get; set; }
+        public string Url { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/Google/GoogleKgApiResponseDto.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Geekbot.net.Commands.Integrations.Google
+{
+    public class GoogleKgApiResponseDto
+    {
+        public List<GoogleKgApiElementDto> ItemListElement { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/Google/GoogleKgApiResultDto.cs

@@ -0,0 +1,10 @@
+namespace Geekbot.net.Commands.Integrations.Google
+{
+    public class GoogleKgApiResultDto
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public GoogleKgApiImageDto ImageDto { get; set; }
+        public GoogleKgApiDetailedDto DetailedDtoDescription { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/MagicTheGathering.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.Converters;
+using Geekbot.net.Lib.ErrorHandling;
+using MtgApiManager.Lib.Service;
+
+namespace Geekbot.net.Commands.Integrations
+{
+    public class Magicthegathering : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IMtgManaConverter _manaConverter;
+
+        public Magicthegathering(IErrorHandler errorHandler, IMtgManaConverter manaConverter)
+        {
+            _errorHandler = errorHandler;
+            _manaConverter = manaConverter;
+        }
+
+        [Command("mtg", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Games)]
+        [Summary("Find a Magic The Gathering Card.")]
+        public async Task GetCard([Remainder] [Summary("name")] string cardName)
+        {
+            try
+            {
+                var service = new CardService();
+                var result = service.Where(x => x.Name, cardName);
+
+                var card = result.All().Value.FirstOrDefault();
+                if (card == null)
+                {
+                    await ReplyAsync("I couldn't find that card...");
+                    return;
+                }
+
+                var eb = new EmbedBuilder();
+                eb.Title = card.Name;
+                eb.Description = card.Type;
+
+                if (card.Colors != null) eb.WithColor(GetColor(card.Colors));
+
+                if (card.ImageUrl != null) eb.ImageUrl = card.ImageUrl.ToString();
+
+                if (!string.IsNullOrEmpty(card.Text)) eb.AddField("Text", _manaConverter.ConvertMana(card.Text));
+
+                if (!string.IsNullOrEmpty(card.Flavor)) eb.AddField("Flavor", card.Flavor);
+                if (!string.IsNullOrEmpty(card.SetName)) eb.AddInlineField("Set", card.SetName);
+                if (!string.IsNullOrEmpty(card.Power)) eb.AddInlineField("Power", card.Power);
+                if (!string.IsNullOrEmpty(card.Loyalty)) eb.AddInlineField("Loyality", card.Loyalty);
+                if (!string.IsNullOrEmpty(card.Toughness)) eb.AddInlineField("Thoughness", card.Toughness);
+
+                if (!string.IsNullOrEmpty(card.ManaCost)) eb.AddInlineField("Cost", _manaConverter.ConvertMana(card.ManaCost));
+                if (!string.IsNullOrEmpty(card.Rarity)) eb.AddInlineField("Rarity", card.Rarity);
+
+                if (card.Legalities != null)
+                    eb.AddField("Legality", string.Join(", ", card.Legalities.Select(e => e.Format)));
+
+                await ReplyAsync("", false, eb.Build());
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+
+        private Color GetColor(IEnumerable<string> colors)
+        {
+            var color = colors.FirstOrDefault();
+            switch (color)
+            {
+                case "Black":
+                    return new Color(203, 194, 191);
+                case "White":
+                    return new Color(255, 251, 213);
+                case "Blue":
+                    return new Color(170, 224, 250);
+                case "Red":
+                    return new Color(250, 170, 143);
+                case "Green":
+                    return new Color(155, 211, 174);
+                default:
+                    return new Color(204, 194, 212);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Integrations/Mal.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Threading.Tasks;
+using System.Web;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.Clients;
+using Geekbot.net.Lib.ErrorHandling;
+
+namespace Geekbot.net.Commands.Integrations
+{
+    public class Mal : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IMalClient _malClient;
+
+        public Mal(IMalClient malClient, IErrorHandler errorHandler)
+        {
+            _malClient = malClient;
+            _errorHandler = errorHandler;
+        }
+
+        [Command("anime", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Helpers)]
+        [Summary("Show Info about an Anime.")]
+        public async Task SearchAnime([Remainder] [Summary("AnimeName")] string animeName)
+        {
+            try
+            {
+                if (_malClient.IsLoggedIn())
+                {
+                    var anime = await _malClient.GetAnime(animeName);
+                    if (anime != null)
+                    {
+                        var eb = new EmbedBuilder();
+
+                        var description = HttpUtility.HtmlDecode(anime.Synopsis)
+                            .Replace("<br />", "")
+                            .Replace("[i]", "*")
+                            .Replace("[/i]", "*");
+
+                        eb.Title = anime.Title;
+                        eb.Description = description;
+                        eb.ImageUrl = anime.Image;
+                        eb.AddInlineField("Premiered", $"{anime.StartDate}");
+                        eb.AddInlineField("Ended", anime.EndDate == "0000-00-00" ? "???" : anime.EndDate);
+                        eb.AddInlineField("Status", anime.Status);
+                        eb.AddInlineField("Episodes", anime.Episodes);
+                        eb.AddInlineField("MAL Score", anime.Score);
+                        eb.AddInlineField("Type", anime.Type);
+                        eb.AddField("MAL Link", $"https://myanimelist.net/anime/{anime.Id}");
+
+                        await ReplyAsync("", false, eb.Build());
+                    }
+                    else
+                    {
+                        await ReplyAsync("No anime found with that name...");
+                    }
+                }
+                else
+                {
+                    await ReplyAsync(
+                        "Unfortunally i'm not connected to MyAnimeList.net, please tell my senpai to connect me");
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+
+        [Command("manga", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Helpers)]
+        [Summary("Show Info about a Manga.")]
+        public async Task SearchManga([Remainder] [Summary("MangaName")] string mangaName)
+        {
+            try
+            {
+                if (_malClient.IsLoggedIn())
+                {
+                    var manga = await _malClient.GetManga(mangaName);
+                    if (manga != null)
+                    {
+                        var eb = new EmbedBuilder();
+
+                        var description = HttpUtility.HtmlDecode(manga.Synopsis)
+                            .Replace("<br />", "")
+                            .Replace("[i]", "*")
+                            .Replace("[/i]", "*");
+
+                        eb.Title = manga.Title;
+                        eb.Description = description;
+                        eb.ImageUrl = manga.Image;
+                        eb.AddInlineField("Premiered", $"{manga.StartDate}");
+                        eb.AddInlineField("Ended", manga.EndDate == "0000-00-00" ? "???" : manga.EndDate);
+                        eb.AddInlineField("Status", manga.Status);
+                        eb.AddInlineField("Volumes", manga.Volumes);
+                        eb.AddInlineField("Chapters", manga.Chapters);
+                        eb.AddInlineField("MAL Score", manga.Score);
+                        eb.AddField("MAL Link", $"https://myanimelist.net/manga/{manga.Id}");
+
+                        await ReplyAsync("", false, eb.Build());
+                    }
+                    else
+                    {
+                        await ReplyAsync("No manga found with that name...");
+                    }
+                }
+                else
+                {
+                    await ReplyAsync(
+                        "Unfortunally i'm not connected to MyAnimeList.net, please tell my senpai to connect me");
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Integrations/UbranDictionary/UrbanDictListItemDto.cs

@@ -0,0 +1,12 @@
+namespace Geekbot.net.Commands.Integrations.UbranDictionary
+{
+    internal class UrbanListItemDto
+    {
+        public string Definition { get; set; }
+        public string Permalink { get; set; }
+        public string ThumbsUp { get; set; }
+        public string Word { get; set; }
+        public string Example { get; set; }
+        public string ThumbsDown { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/UbranDictionary/UrbanDictResponseDto.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace Geekbot.net.Commands.Integrations.UbranDictionary
+{
+    internal class UrbanResponseDto
+    {
+        public string[] Tags { get; set; }
+        public List<UrbanListItemDto> List { get; set; }
+    }
+}

Geekbot.net/Commands/Integrations/UbranDictionary/UrbanDictionary.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+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.Integrations.UbranDictionary
+{
+    public class UrbanDictionary : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+
+        public UrbanDictionary(IErrorHandler errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+
+        [Command("urban", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Helpers)]
+        [Summary("Lookup something on urban dictionary")]
+        public async Task UrbanDefine([Remainder] [Summary("word")] string word)
+        {
+            try
+            {
+                using (var client = new HttpClient())
+                {
+                    client.BaseAddress = new Uri("https://api.urbandictionary.com");
+                    var response = await client.GetAsync($"/v0/define?term={word}");
+                    response.EnsureSuccessStatusCode();
+
+                    var stringResponse = await response.Content.ReadAsStringAsync();
+                    var definitions = JsonConvert.DeserializeObject<UrbanResponseDto>(stringResponse);
+                    if (definitions.List.Count == 0)
+                    {
+                        await ReplyAsync("That word hasn't been defined...");
+                        return;
+                    }
+
+                    var definition = definitions.List.First(e => !string.IsNullOrWhiteSpace(e.Example));
+
+                    var eb = new EmbedBuilder();
+                    eb.WithAuthor(new EmbedAuthorBuilder
+                    {
+                        Name = definition.Word,
+                        Url = definition.Permalink
+                    });
+                    eb.WithColor(new Color(239, 255, 0));
+                    if (!string.IsNullOrEmpty(definition.Definition)) eb.Description = definition.Definition;
+                    if (!string.IsNullOrEmpty(definition.Example)) eb.AddField("Example", definition.Example ?? "(no example given...)");
+                    if (!string.IsNullOrEmpty(definition.ThumbsUp)) eb.AddInlineField("Upvotes", definition.ThumbsUp);
+                    if (!string.IsNullOrEmpty(definition.ThumbsDown)) eb.AddInlineField("Downvotes", definition.ThumbsDown);
+                    if (definitions.Tags.Length > 0) eb.AddField("Tags", string.Join(", ", definitions.Tags));
+
+                    await ReplyAsync("", false, eb.Build());
+                }
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}

Geekbot.net/Commands/Integrations/Wikipedia.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using HtmlAgilityPack;
+using StackExchange.Redis;
+using WikipediaApi;
+using WikipediaApi.Page;
+
+namespace Geekbot.net.Commands.Integrations
+{
+    public class Wikipedia : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IWikipediaClient _wikipediaClient;
+        private readonly IDatabase _redis;
+
+        public Wikipedia(IErrorHandler errorHandler, IWikipediaClient wikipediaClient, IDatabase redis)
+        {
+            _errorHandler = errorHandler;
+            _wikipediaClient = wikipediaClient;
+            _redis = redis;
+        }
+
+        [Command("wiki", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Helpers)]
+        [Summary("Get an article from wikipedia.")]
+        public async Task GetPreview([Remainder] [Summary("Article")] string articleName)
+        {
+            try
+            {
+                var wikiLang = _redis.HashGet($"{Context.Guild.Id}:Settings", "WikiLang").ToString();
+                if (string.IsNullOrEmpty(wikiLang))
+                {
+                    wikiLang = "en";
+                }
+                var article = await _wikipediaClient.GetPreview(articleName.Replace(" ", "_"), wikiLang);
+                
+                if (article.Type != PageTypes.Standard)
+                {
+                    switch (article.Type)
+                    {
+                        case PageTypes.Disambiguation:
+                            await ReplyAsync($"**__Disambiguation__**\r\n{DisambiguationExtractor(article.ExtractHtml)}");
+                            break;
+                        case PageTypes.MainPage:
+                            await ReplyAsync("The main page is not supported");
+                            break;
+                        case PageTypes.NoExtract:
+                            await ReplyAsync($"This page has no summary, here is the link: {article.ContentUrls.Desktop.Page}");
+                            break;
+                        case PageTypes.Standard:
+                            break;
+                        default:
+                            await ReplyAsync($"This page type is currently not supported, here is the link: {article.ContentUrls.Desktop.Page}");
+                            break;
+                    }
+                    return;
+                }
+
+                var eb = new EmbedBuilder
+                {
+                    Title = article.Title,
+                    Description = article.Description,
+                    ImageUrl = article.Thumbnail?.Source.ToString(),
+                    Url = article.ContentUrls.Desktop.Page.ToString(),
+                    Color = new Color(246,246,246),
+                    Timestamp = article.Timestamp,
+                    Footer = new EmbedFooterBuilder
+                    {
+                        Text = "Last Edit",
+                        IconUrl = "http://icons.iconarchive.com/icons/sykonist/popular-sites/256/Wikipedia-icon.png"
+                    }
+                };
+                
+                eb.AddField("Description", article.Extract);
+                if (article.Coordinates != null) eb.AddField("Coordinates", $"{article.Coordinates.Lat} Lat {article.Coordinates.Lon} Lon");
+                await ReplyAsync("", false, eb.Build());
+            }
+            catch (HttpRequestException)
+            {
+                await ReplyAsync("I couldn't find that article");
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+
+        private string DisambiguationExtractor(string extractHtml)
+        {
+            var doc = new HtmlDocument();
+            doc.LoadHtml(extractHtml);
+            var nodes = doc.DocumentNode.SelectNodes("//li");
+            if (nodes == null) return "(List is to long to show)";
+            var sb = new StringBuilder();
+            foreach (var node in nodes)
+            {
+                var split = node.InnerText.Split(',');
+                var title = split.First();
+                var desc = string.Join(",", split.Skip(1));
+                sb.AppendLine($"• **{title}** -{desc}");
+            }
+
+            return sb.ToString();
+        }
+    }
+}

Geekbot.net/Commands/Integrations/Youtube.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Geekbot.net.Lib;
+using Geekbot.net.Lib.ErrorHandling;
+using Google.Apis.Services;
+using Google.Apis.YouTube.v3;
+using StackExchange.Redis;
+
+namespace Geekbot.net.Commands.Integrations
+{
+    public class Youtube : ModuleBase
+    {
+        private readonly IErrorHandler _errorHandler;
+        private readonly IDatabase _redis;
+
+        public Youtube(IDatabase redis, IErrorHandler errorHandler)
+        {
+            _redis = redis;
+            _errorHandler = errorHandler;
+        }
+
+        [Command("yt", RunMode = RunMode.Async)]
+        [Remarks(CommandCategories.Helpers)]
+        [Summary("Search for something on youtube.")]
+        public async Task Yt([Remainder] [Summary("Title")] string searchQuery)
+        {
+            var key = _redis.StringGet("youtubeKey");
+            if (key.IsNullOrEmpty)
+            {
+                await ReplyAsync("No youtube key set, please tell my senpai to set one");
+                return;
+            }
+
+            try
+            {
+                var youtubeService = new YouTubeService(new BaseClientService.Initializer
+                {
+                    ApiKey = key.ToString(),
+                    ApplicationName = GetType().ToString()
+                });
+
+                var searchListRequest = youtubeService.Search.List("snippet");
+                searchListRequest.Q = searchQuery;
+                searchListRequest.MaxResults = 2;
+
+                var searchListResponse = await searchListRequest.ExecuteAsync();
+
+                var result = searchListResponse.Items[0];
+
+                await ReplyAsync(
+                    $"\"{result.Snippet.Title}\" from \"{result.Snippet.ChannelTitle}\" https://youtu.be/{result.Id.VideoId}");
+            }
+            catch (Exception e)
+            {
+                _errorHandler.HandleCommandException(e, Context);
+            }
+        }
+    }
+}