Polls persist restarts now.

NadekoBot.Core/Modules/Games/Common/Poll.cs

@@ -1,129 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Discord;
-using Discord.WebSocket;
-using NadekoBot.Extensions;
-using NadekoBot.Core.Services.Impl;
-
-namespace NadekoBot.Modules.Games.Common
-{
-    public class Poll
-    {
-        private readonly IUserMessage _originalMessage;
-        private readonly IGuild _guild;
-        private readonly string[] answers;
-        private readonly ConcurrentDictionary<ulong, int> _participants = new ConcurrentDictionary<ulong, int>();
-        private readonly string _question;
-        private readonly DiscordSocketClient _client;
-        private readonly NadekoStrings _strings;
-        private bool running = false;
-
-        public event Action<ulong> OnEnded = delegate { };
-
-        public Poll(DiscordSocketClient client, NadekoStrings strings, IUserMessage umsg, string question, IEnumerable<string> enumerable)
-        {
-            _client = client;
-            _strings = strings;
-
-            _originalMessage = umsg;
-            _guild = ((ITextChannel)umsg.Channel).Guild;
-            _question = question;
-            answers = enumerable as string[] ?? enumerable.ToArray();
-        }
-
-        public EmbedBuilder GetStats(string title)
-        {
-            var results = _participants.GroupBy(kvp => kvp.Value)
-                                .ToDictionary(x => x.Key, x => x.Sum(kvp => 1))
-                                .OrderByDescending(kvp => kvp.Value)
-                                .ToArray();
-
-            var eb = new EmbedBuilder().WithTitle(title);
-
-            var sb = new StringBuilder()
-                .AppendLine(Format.Bold(_question))
-                .AppendLine();
-
-            var totalVotesCast = 0;
-            if (results.Length == 0)
-            {
-                sb.AppendLine(GetText("no_votes_cast"));
-            }
-            else
-            {
-                for (int i = 0; i < results.Length; i++)
-                {
-                    var result = results[i];
-                    sb.AppendLine(GetText("poll_result",
-                        result.Key,
-                        Format.Bold(answers[result.Key - 1]),
-                        Format.Bold(result.Value.ToString())));
-                    totalVotesCast += result.Value;
-                }
-            }
-
-
-            eb.WithDescription(sb.ToString())
-              .WithFooter(efb => efb.WithText(GetText("x_votes_cast", totalVotesCast)));
-
-            return eb;
-        }
-
-        public async Task StartPoll()
-        {
-            var msgToSend = GetText("poll_created", Format.Bold(_originalMessage.Author.Username)) + "\n\n" + Format.Bold(_question) + "\n";
-            var num = 1;
-            msgToSend = answers.Aggregate(msgToSend, (current, answ) => current + $"`{num++}.` **{answ}**\n");
-            msgToSend += "\n" + Format.Bold(GetText("poll_vote_public"));
-
-            await _originalMessage.Channel.SendConfirmAsync(msgToSend).ConfigureAwait(false);
-            running = true;
-        }
-
-        public async Task StopPoll()
-        {
-            running = false;
-            OnEnded(_guild.Id);
-            await _originalMessage.Channel.EmbedAsync(GetStats("POLL CLOSED")).ConfigureAwait(false);
-        }
-
-        public async Task<bool> TryVote(IUserMessage msg)
-        {
-            // has to be a user message
-            if (msg == null || msg.Author.IsBot || !running)
-                return false;
-
-            // has to be an integer
-            if (!int.TryParse(msg.Content, out int vote))
-                return false;
-            if (vote < 1 || vote > answers.Length)
-                return false;
-
-            IMessageChannel ch;
-            //if public, channel must be the same the poll started in
-            if (_originalMessage.Channel.Id != msg.Channel.Id)
-                return false;
-            ch = msg.Channel;
-
-            //user can vote only once
-            if (_participants.TryAdd(msg.Author.Id, vote))
-            {
-                var toDelete = await ch.SendConfirmAsync(GetText("poll_voted", Format.Bold(msg.Author.ToString()))).ConfigureAwait(false);
-                toDelete.DeleteAfter(5);
-                try { await msg.DeleteAsync().ConfigureAwait(false); } catch { }
-                return true;
-            }
-            return false;
-        }
-
-        private string GetText(string key, params object[] replacements)
-            => _strings.GetText(key,
-                _guild.Id,
-                "Games".ToLowerInvariant(),
-                replacements);
-    }
-}

NadekoBot.Core/Modules/Games/Common/PollRunner.cs

@@ -0,0 +1,72 @@
+using System.Threading.Tasks;
+using Discord;
+using NadekoBot.Core.Services.Database.Models;
+using NadekoBot.Core.Services;
+using System;
+using System.Threading;
+
+namespace NadekoBot.Modules.Games.Common
+{
+    public class PollRunner
+    {
+        public Poll Poll { get; }
+        private readonly DbService _db;
+
+        public event Func<IUserMessage, IGuildUser, Task> OnVoted;
+
+        private readonly SemaphoreSlim _locker = new SemaphoreSlim(1, 1);
+
+        public PollRunner(DbService db, Poll poll)
+        {
+            _db = db;
+            Poll = poll;
+        }
+
+        public async Task<bool> TryVote(IUserMessage msg)
+        {
+            PollVote voteObj;
+            await _locker.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                // has to be a user message
+                // channel must be the same the poll started in
+                if (msg == null || msg.Author.IsBot || msg.Channel.Id != Poll.ChannelId)
+                    return false;
+
+                // has to be an integer
+                if (!int.TryParse(msg.Content, out int vote))
+                    return false;
+                --vote;
+                if (vote < 0 || vote >= Poll.Answers.Count)
+                    return false;
+
+                var usr = msg.Author as IGuildUser;
+                if (usr == null)
+                    return false;
+
+                voteObj = new PollVote()
+                {
+                    UserId = msg.Author.Id,
+                    VoteIndex = vote,
+                };
+                if (!Poll.Votes.Add(voteObj))
+                    return false;
+
+                var _ = OnVoted?.Invoke(msg, usr);
+            }
+            finally { _locker.Release(); }
+            using (var uow = _db.UnitOfWork)
+            {
+                var trackedPoll = uow.Polls.Get(Poll.Id);
+                trackedPoll.Votes.Add(voteObj);
+                uow.Complete();
+            }
+            return true;
+        }
+
+        public void End()
+        {
+            OnVoted = null;
+        }
+    }
+}

NadekoBot.Core/Modules/Games/PollCommands.cs

@@ -5,6 +5,9 @@ using NadekoBot.Extensions;
 using System.Threading.Tasks;
 using NadekoBot.Common.Attributes;
 using NadekoBot.Modules.Games.Services;
+using NadekoBot.Core.Services.Database.Models;
+using System.Text;
+using System.Linq;
 
 namespace NadekoBot.Modules.Games
 {
@@ -23,24 +26,33 @@ namespace NadekoBot.Modules.Games
             [NadekoCommand, Usage, Description, Aliases]
             [RequireUserPermission(GuildPermission.ManageMessages)]
             [RequireContext(ContextType.Guild)]
-            public Task Poll([Remainder] string arg = null)
-                => InternalStartPoll(arg);
+            public async Task Poll([Remainder] string arg)
+            {
+                if (string.IsNullOrWhiteSpace(arg))
+                    return;
+
+                var poll = _service.CreatePoll(Context.Guild.Id,
+                    Context.Channel.Id, arg);
+                if (_service.StartPoll(poll))
+                    await Context.Channel
+                        .EmbedAsync(new EmbedBuilder()
+                            .WithTitle(GetText("poll_created", Context.User.ToString()))
+                            .WithDescription(string.Join("\n", poll.Answers
+                                .Select(x => $"`{x.Index + 1}.` {Format.Bold(x.Text)}"))))
+                        .ConfigureAwait(false);
+                else
+                    await ReplyErrorLocalized("poll_already_running").ConfigureAwait(false);
+            }
 
             [NadekoCommand, Usage, Description, Aliases]
             [RequireUserPermission(GuildPermission.ManageMessages)]
             [RequireContext(ContextType.Guild)]
             public async Task PollStats()
             {
-                if (!_service.ActivePolls.TryGetValue(Context.Guild.Id, out var poll))
+                if (!_service.ActivePolls.TryGetValue(Context.Guild.Id, out var pr))
                     return;
 
-                await Context.Channel.EmbedAsync(poll.GetStats(GetText("current_poll_results")));
-            }
-
-            private async Task InternalStartPoll(string arg)
-            {
-                if(await _service.StartPoll(Context.Guild.Id, Context.Message, arg) == false)
-                    await ReplyErrorLocalized("poll_already_running").ConfigureAwait(false);
+                await Context.Channel.EmbedAsync(GetStats(pr.Poll, GetText("current_poll_results")));
             }
 
             [NadekoCommand, Usage, Description, Aliases]
@@ -50,9 +62,50 @@ namespace NadekoBot.Modules.Games
             {
                 var channel = (ITextChannel)Context.Channel;
 
-                if(_service.ActivePolls.TryRemove(channel.Guild.Id, out var poll))
-                    await poll.StopPoll().ConfigureAwait(false);
+                Poll p;
+                if ((p = _service.StopPoll(Context.Guild.Id)) == null)
+                    return;
+
+                var embed = GetStats(p, GetText("poll_closed"));
+                await Context.Channel.EmbedAsync(embed)
+                    .ConfigureAwait(false);
             }
-        }        
+
+            public EmbedBuilder GetStats(Poll poll, string title)
+            {
+                var results = poll.Votes.GroupBy(kvp => kvp.VoteIndex)
+                                    .ToDictionary(x => x.Key, x => x.Sum(kvp => 1))
+                                    .OrderByDescending(kvp => kvp.Value)
+                                    .ToArray();
+
+                var eb = new EmbedBuilder().WithTitle(title);
+
+                var sb = new StringBuilder()
+                    .AppendLine(Format.Bold(poll.Question))
+                    .AppendLine();
+
+                var totalVotesCast = 0;
+                if (results.Length == 0)
+                {
+                    sb.AppendLine(GetText("no_votes_cast"));
+                }
+                else
+                {
+                    for (int i = 0; i < results.Length; i++)
+                    {
+                        var result = results[i];
+                        sb.AppendLine(GetText("poll_result",
+                            result.Key + 1,
+                            Format.Bold(poll.Answers[result.Key].Text),
+                            Format.Bold(result.Value.ToString())));
+                        totalVotesCast += result.Value;
+                    }
+                }
+
+                return eb.WithDescription(sb.ToString())
+                    .WithFooter(efb => efb.WithText(GetText("x_votes_cast", totalVotesCast)))
+                    .WithOkColor();
+            }
+        }
     }
 }

NadekoBot.Core/Modules/Games/Services/PollService.cs

@@ -9,45 +9,102 @@ using NadekoBot.Modules.Games.Common;
 using NadekoBot.Core.Services;
 using NadekoBot.Core.Services.Impl;
 using NLog;
+using NadekoBot.Core.Services.Database.Models;
+using NadekoBot.Common.Collections;
+using NadekoBot.Extensions;
+using NadekoBot.Core.Services.Database;
 
 namespace NadekoBot.Modules.Games.Services
 {
     public class PollService : IEarlyBlockingExecutor, INService
     {
-        public ConcurrentDictionary<ulong, Poll> ActivePolls = new ConcurrentDictionary<ulong, Poll>();
+        public ConcurrentDictionary<ulong, PollRunner> ActivePolls { get; } = new ConcurrentDictionary<ulong, PollRunner>();
         private readonly Logger _log;
         private readonly DiscordSocketClient _client;
         private readonly NadekoStrings _strings;
+        private readonly DbService _db;
+        private readonly NadekoStrings _strs;
 
-        public PollService(DiscordSocketClient client, NadekoStrings strings)
+        public PollService(DiscordSocketClient client, NadekoStrings strings, DbService db,
+            NadekoStrings strs, IUnitOfWork uow)
         {
             _log = LogManager.GetCurrentClassLogger();
             _client = client;
             _strings = strings;
+            _db = db;
+            _strs = strs;
+
+            ActivePolls = uow.Polls.GetAllPolls()
+                .ToDictionary(x => x.GuildId, x =>
+                {
+                    var pr = new PollRunner(db, x);
+                    pr.OnVoted += Pr_OnVoted;
+                    return pr;
+                })
+                .ToConcurrent();
         }
 
-        public async Task<bool?> StartPoll(ulong guildId, IUserMessage msg, string arg)
+        public Poll CreatePoll(ulong guildId, ulong channelId, string input)
         {
-            if (string.IsNullOrWhiteSpace(arg) || !arg.Contains(";"))
+            if (string.IsNullOrWhiteSpace(input) || !input.Contains(";"))
                 return null;
-            var data = arg.Split(';');
+            var data = input.Split(';');
             if (data.Length < 3)
                 return null;
 
-            var poll = new Poll(_client, _strings, msg, data[0], data.Skip(1));
-            if (ActivePolls.TryAdd(guildId, poll))
-            {
-                poll.OnEnded += (gid) =>
-                {
-                    ActivePolls.TryRemove(gid, out _);
-                };
+            var col = new IndexedCollection<PollAnswer>(data.Skip(1)
+                .Select(x => new PollAnswer() { Text = x }));
 
-                await poll.StartPoll().ConfigureAwait(false);
+            return new Poll()
+            {
+                Answers = col,
+                Question = data[0],
+                ChannelId = channelId,
+                GuildId = guildId,
+                Votes = new System.Collections.Generic.HashSet<PollVote>()
+            };
+        }
+
+        public bool StartPoll(Poll p)
+        {
+            var pr = new PollRunner(_db,  p);
+            if (ActivePolls.TryAdd(p.GuildId, pr))
+            {
+                using (var uow = _db.UnitOfWork)
+                {
+                    uow.Polls.Add(p);
+                    uow.Complete();
+                }
+
+                pr.OnVoted += Pr_OnVoted;
                 return true;
             }
             return false;
         }
 
+        public Poll StopPoll(ulong guildId)
+        {
+            if (ActivePolls.TryRemove(guildId, out var pr))
+            {
+                pr.OnVoted -= Pr_OnVoted;
+                using (var uow = _db.UnitOfWork)
+                {
+                    uow.Polls.RemovePoll(pr.Poll.Id);
+                    uow.Complete();
+                }
+                return pr.Poll;
+            }
+            return null;
+        }
+
+        private async Task Pr_OnVoted(IUserMessage msg, IGuildUser usr)
+        {
+            var toDelete = await msg.Channel.SendConfirmAsync(_strs.GetText("poll_voted", usr.Guild.Id, "Games".ToLowerInvariant(), Format.Bold(usr.ToString())))
+                .ConfigureAwait(false);
+            toDelete.DeleteAfter(5);
+            try { await msg.DeleteAsync().ConfigureAwait(false); } catch { }
+        }
+
         public async Task<bool> TryExecuteEarly(DiscordSocketClient client, IGuild guild, IUserMessage msg)
         {
             if (guild == null)