Ejemplo n.º 1
0
        public override async Task Start(IUserMessage umsg, ICommandContext context)
        {
            StartingMessage         = umsg;
            _client.MessageDeleted += MessageDeletedEventHandler;

            var iemote = Emote.TryParse(_bc.CurrencySign, out var emote) ? emote : new Emoji(_bc.CurrencySign) as IEmote;

            try { await StartingMessage.AddReactionAsync(iemote).ConfigureAwait(false); }
            catch
            {
                try { await StartingMessage.AddReactionAsync(new Emoji("🌸")).ConfigureAwait(false); }
                catch
                {
                    try { await StartingMessage.DeleteAsync().ConfigureAwait(false); }
                    catch { return; }
                }
            }
            using (StartingMessage.OnReaction(_client, r =>
            {
                try
                {
                    if (r.UserId == _botUser.Id)
                    {
                        return;
                    }

                    if (string.Equals(r.Emote.Name, iemote.Name, StringComparison.Ordinal) && r.User.IsSpecified && (DateTime.UtcNow - r.User.Value.CreatedAt).TotalDays > 5 && _reactionAwardedUsers.Add(r.User.Value.Id))
                    {
                        _toGiveTo.Enqueue(r.UserId);
                    }
                }
                catch
                {
                    // ignored
                }
            }))
            {
                try
                {
                    await Task.Delay(TimeSpan.FromHours(24), CancelToken).ConfigureAwait(false);
                }
                catch (OperationCanceledException)
                {
                }
                if (CancelToken.IsCancellationRequested)
                {
                    return;
                }

                _log.Warn("Stopping reaction event because it expired.");
                await End();
            }
        }
Ejemplo n.º 2
0
        public override async Task Start(IUserMessage umsg, ICommandContext context)
        {
            StartingMessage         = umsg;
            _client.MessageDeleted += MessageDeletedEventHandler;

            try { await StartingMessage.AddReactionAsync(new Emoji("🌸")).ConfigureAwait(false); }
            catch
            {
                try { await StartingMessage.AddReactionAsync(new Emoji("🌸")).ConfigureAwait(false); }
                catch
                {
                    try { await StartingMessage.DeleteAsync().ConfigureAwait(false); }
                    catch { return; }
                }
            }
            using (StartingMessage.OnReaction(_client, (r) =>
            {
                try
                {
                    if (r.UserId == _botUser.Id)
                    {
                        return;
                    }

                    if (r.Emote.Name == "🌸" && r.User.IsSpecified && ((DateTime.UtcNow - r.User.Value.CreatedAt).TotalDays > 5) && _flowerReactionAwardedUsers.Add(r.User.Value.Id))
                    {
                        _toGiveTo.Enqueue(r.UserId);
                    }
                }
                catch
                {
                    // ignored
                }
            }))
            {
                try
                {
                    await Task.Delay(TimeSpan.FromHours(24), CancelToken).ConfigureAwait(false);
                }
                catch (OperationCanceledException)
                {
                }
                if (CancelToken.IsCancellationRequested)
                {
                    return;
                }

                _log.Warn("Stopping flower reaction event because it expired.");
                await End();
            }
        }
Ejemplo n.º 3
0
        public override async Task Start(IUserMessage umsg, CommandContext context, int amount)
        {
            msg = umsg;
            NadekoBot.Client.MessageDeleted += MessageDeletedEventHandler;

            try { await msg.AddReactionAsync("🌸").ConfigureAwait(false); }
            catch
            {
                try { await msg.AddReactionAsync("🌸").ConfigureAwait(false); }
                catch
                {
                    try { await msg.DeleteAsync().ConfigureAwait(false); }
                    catch { return; }
                }
            }
            using (msg.OnReaction(async(r) =>
            {
                try
                {
                    if (r.Emoji.Name == "🌸" && r.User.IsSpecified && ((DateTime.UtcNow - r.User.Value.CreatedAt).TotalDays > 5) && _flowerReactionAwardedUsers.Add(r.User.Value.Id))
                    {
                        await CurrencyHandler.AddCurrencyAsync(r.User.Value, "Flower Reaction Event", amount, false)
                        .ConfigureAwait(false);
                    }
                }
                catch
                {
                    // ignored
                }
            }))
            {
                try
                {
                    await Task.Delay(TimeSpan.FromHours(24), cancelToken).ConfigureAwait(false);
                }
                catch (OperationCanceledException)
                {
                }
                if (cancelToken.IsCancellationRequested)
                {
                    return;
                }

                _log.Warn("Stopping flower reaction event because it expired.");
                await End();
            }
        }
Ejemplo n.º 4
0
        private static async Task SendPaginatedMessageAsync(this ICommandContext ctx, int currentPage,
                                                            Func <int, Task <EmbedBuilder> > pageFunc, int totalElements, int itemsPerPage, bool addPaginatedFooter = true)
        {
            EmbedBuilder embed = await pageFunc(currentPage).ConfigureAwait(false);

            int lastPage = (totalElements - 1) / itemsPerPage;

            if (addPaginatedFooter)
            {
                embed.AddPaginatedFooter(currentPage, lastPage);
            }

            IUserMessage message = await ctx.Channel.EmbedAsync(embed).ConfigureAwait(false);

            if (lastPage == 0)
            {
                return;
            }

            await message.AddReactionAsync(First).ConfigureAwait(false);

            await message.AddReactionAsync(ArrowLeft).ConfigureAwait(false);

            await message.AddReactionAsync(ArrowRight).ConfigureAwait(false);

            await message.AddReactionAsync(Last).ConfigureAwait(false);

            await Task.Delay(2000).ConfigureAwait(false);

            var lastPageChange = DateTime.MinValue;

            async Task ChangePage(SocketReaction r)
            {
                try
                {
                    if (r.UserId != ctx.User.Id)
                    {
                        return;
                    }

                    if (DateTime.UtcNow - lastPageChange < TimeSpan.FromMilliseconds(500))
                    {
                        return;
                    }

                    EmbedBuilder updatedEmbed;
                    if (r.Emote.Name == ArrowLeft.Name)
                    {
                        if (currentPage == 0)
                        {
                            return;
                        }

                        lastPageChange = DateTime.UtcNow;
                        updatedEmbed   = await pageFunc(--currentPage).ConfigureAwait(false);

                        await message.RemoveReactionAsync(ArrowLeft, ctx.User).ConfigureAwait(false);
                    }
                    else if (r.Emote.Name == ArrowRight.Name)
                    {
                        if (currentPage == lastPage)
                        {
                            return;
                        }

                        lastPageChange = DateTime.UtcNow;
                        updatedEmbed   = await pageFunc(++currentPage).ConfigureAwait(false);

                        await message.RemoveReactionAsync(ArrowRight, ctx.User).ConfigureAwait(false);
                    }
                    else if (r.Emote.Name == First.Name)
                    {
                        if (currentPage == 0)
                        {
                            return;
                        }

                        lastPageChange = DateTime.UtcNow;
                        updatedEmbed   = await pageFunc(0).ConfigureAwait(false);

                        await message.RemoveReactionAsync(First, ctx.User).ConfigureAwait(false);
                    }
                    else if (r.Emote.Name == Last.Name)
                    {
                        if (currentPage == lastPage)
                        {
                            return;
                        }

                        lastPageChange = DateTime.UtcNow;
                        updatedEmbed   = await pageFunc(lastPage).ConfigureAwait(false);

                        await message.RemoveReactionAsync(First, ctx.User).ConfigureAwait(false);
                    }
                    else
                    {
                        return;
                    }

                    if (addPaginatedFooter)
                    {
                        updatedEmbed.AddPaginatedFooter(currentPage, lastPage);
                    }

                    await message.ModifyAsync(x => x.Embed = updatedEmbed.Build()).ConfigureAwait(false);
                }
                catch (Exception)
                {
                    //ignored
                }
            }

            using (message.OnReaction((DiscordSocketClient)ctx.Client, ChangePage))
            {
                await Task.Delay(TimeSpan.FromMinutes(5)).ConfigureAwait(false);
            }

            try
            {
                if (message.Channel is ITextChannel && ((SocketGuild)ctx.Guild).CurrentUser.GuildPermissions.ManageMessages)
                {
                    await message.RemoveAllReactionsAsync().ConfigureAwait(false);
                }
                else
                {
                    await Task.WhenAll(message.Reactions.Where(x => x.Value.IsMe)
                                       .Select(x => message.RemoveReactionAsync(x.Key, ctx.Client.CurrentUser)));
                }
            }
            catch
            {
                // ignored
            }
        }