geekbot/Geekbot.net/Commands/Utils/Poll.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Discord;
using Discord.Commands;
using Geekbot.net.Database;
using Geekbot.net.Database.Models;
using Geekbot.net.Lib.Converters;
using Geekbot.net.Lib.ErrorHandling;
using Geekbot.net.Lib.Extensions;
using Geekbot.net.Lib.UserRepository;

namespace Geekbot.net.Commands.Utils
{
    [Group("poll")]
    public class Poll : ModuleBase
    {
        private readonly IEmojiConverter _emojiConverter;
        private readonly IErrorHandler _errorHandler;
        private readonly DatabaseContext _database;
        private readonly IUserRepository _userRepository;

        public Poll(IErrorHandler errorHandler, DatabaseContext database, IEmojiConverter emojiConverter, IUserRepository userRepository)
        {
            _errorHandler = errorHandler;
            _database = database;
            _emojiConverter = emojiConverter;
            _userRepository = userRepository;
        }

        [Command(RunMode = RunMode.Async)]
        [Summary("Check status of the current poll")]
        public async Task Dflt()
        {
            try
            {
                var currentPoll = GetCurrentPoll();
                if (currentPoll.Question == null)
                {
                    await ReplyAsync(
                        "There is no poll in this channel ongoing at the moment\r\nYou can create one with `!poll create question;option1;option2;option3`");
                    return;
                }

                await ReplyAsync("There is a poll running at the moment");
            }
            catch (Exception e)
            {
                await _errorHandler.HandleCommandException(e, Context);
            }
        }

        [Command("create", RunMode = RunMode.Async)]
        [Summary("Create a poll")]
        public async Task Create([Remainder] [Summary("question;option1;option2")]
            string rawPollString)
        {
            try
            {
                await ReplyAsync("Poll creation currently disabled");
                return;
                
                var currentPoll = GetCurrentPoll();
                if (currentPoll.Question != null && !currentPoll.IsFinshed)
                {
                    await ReplyAsync("You have not finished you last poll yet. To finish it use `!poll end`");
                    return;
                }

                var pollList = rawPollString.Split(';').ToList();
                if (pollList.Count <= 2)
                {
                    await ReplyAsync(
                        "You need a question with atleast 2 options, a valid creation would look like this `question;option1;option2`");
                    return;
                }

                var question = pollList[0];
                pollList.RemoveAt(0);
                
                var eb = new EmbedBuilder
                {
                    Title = $"Poll by {Context.User.Username}",
                    Description = question
                };

                var options = new List<PollQuestionModel>();
                var i = 1;
                pollList.ForEach(option =>
                {
                    options.Add(new PollQuestionModel()
                    {
                        OptionId = i,
                        OptionText = option
                    });
                    eb.AddInlineField($"Option {_emojiConverter.NumberToEmoji(i)}", option);
                    i++;
                });
                var pollMessage = await ReplyAsync("", false, eb.Build());
                
                var poll = new PollModel()
                {
                    Creator = Context.User.Id.AsLong(),
                    MessageId = pollMessage.Id.AsLong(),
                    IsFinshed = false,
                    Question = question,
                    Options = options
                };
                _database.Polls.Add(poll);

                i = 1;
                pollList.ForEach(option =>
                {
                    pollMessage.AddReactionAsync(new Emoji(_emojiConverter.NumberToEmoji(i)));
                    Task.Delay(500);
                    i++;
                });
            }
            catch (Exception e)
            {
                await _errorHandler.HandleCommandException(e, Context);
            }
        }

        [Command("end", RunMode = RunMode.Async)]
        [Summary("End the current poll")]
        public async Task End()
        {
            try
            {
                var currentPoll = GetCurrentPoll();
                if (currentPoll.Question == null || currentPoll.IsFinshed)
                {
                    await ReplyAsync("There is no ongoing poll at the moment");
                    return;
                }

                currentPoll = await GetPollResults(currentPoll);
                var sb = new StringBuilder();
                sb.AppendLine("**Poll Results**");
                sb.AppendLine(currentPoll.Question);
                foreach (var result in currentPoll.Options) sb.AppendLine($"{result.Votes} - {result.OptionText}");
                await ReplyAsync(sb.ToString());
                currentPoll.IsFinshed = true;
                _database.Polls.Update(currentPoll);
            }
            catch (Exception e)
            {
                await _errorHandler.HandleCommandException(e, Context);
            }
        }

        private PollModel GetCurrentPoll()
        {
            try
            {
                var currentPoll = _database.Polls.FirstOrDefault(poll =>
                    poll.ChannelId.Equals(Context.Channel.Id.AsLong()) &&
                    poll.GuildId.Equals(Context.Guild.Id.AsLong())
                );
                return currentPoll ?? new PollModel();

            }
            catch
            {
                return new PollModel();
            }
        }

        private async Task<PollModel> GetPollResults(PollModel poll)
        {
            var message = (IUserMessage) await Context.Channel.GetMessageAsync(poll.MessageId.AsUlong());
            
            var results = new Dictionary<int, int>();
            foreach (var r in message.Reactions)
            {
                try
                {
                    results.Add(r.Key.Name.ToCharArray()[0], r.Value.ReactionCount);
                }
                catch
                {
                    // ignored
                }
            }
            
            foreach (var q in poll.Options)
            {
                q.Votes = results.FirstOrDefault(e => e.Key.Equals(q.OptionId)).Value;
            }

            return poll;

//            var sortedValues = results.OrderBy(e => e.Value);
//            return sortedValues;
        }
    }
}