示例#1
0
    //delete number of messages
    public static async Task RoutineDelete(SocketCommandContext context, SocketUserMessage msg)
    {
        //get number of messages to delete
        int del_num = 0;

        String[] msg_array = msg.ToString().Split(' ');
        if (msg_array.Length < 3)
        {
            //use default number
            del_num = 1;
        }
        else if (!(int.TryParse(msg_array[2], out del_num) && del_num >= 0 && del_num <= 1000))
        {
            //failed to get specified number
            throw new CommandException("invalid number of messages");
        }

        var messages_pages = context.Channel.GetMessagesAsync(msg, Direction.Before, del_num);
        var messages       = await AsyncEnumerableExtensions.FlattenAsync <IMessage>(messages_pages);

        var i = 0;

        foreach (var message in messages)
        {
            await context.Channel.DeleteMessageAsync(message);

            //don't send more than 1 request per second
            await Task.Delay(1000);

            i += 1;
        }

        await context.Channel.SendMessageAsync(i.ToString() + " message(s) deleted.");
    }
示例#2
0
        async Task ValidateAllReactionsAndRolesForGuild(TownGuild guildSettings)
        {
            try
            {
                SocketGuild guild = client.GetGuild(guildSettings.GuildId);

                foreach (var messageSettings in guildSettings.RoleGrantingSettings.MessageSettings)
                {
                    var channel = guild.GetChannel(messageSettings.Channel);

                    var message = await(channel as ISocketMessageChannel).GetMessageAsync(messageSettings.MessageToMonitor) as IUserMessage;

                    foreach (var reaction in message.Reactions)
                    {
                        if (messageSettings.ReactionsToRoles.TryGetValue(reaction.Key.Name, out GrantingRoleSettings grantingSettings))
                        {
                            var reactedUsers = message.GetReactionUsersAsync(reaction.Key, 1000);

                            var flattenedUsers = await AsyncEnumerableExtensions.FlattenAsync(reactedUsers);

                            foreach (var reactedUser in flattenedUsers)
                            {
                                if (client.CurrentUser.Id == reactedUser.Id)
                                {
                                    continue;
                                }

                                await GrantUserRoleBasedOnReaction(reaction.Key, message, guild, guildSettings, guild.GetUser(reactedUser.Id));
                            }
                        }
                    }

                    await message.RemoveAllReactionsAsync();

                    Emoji[] emojis = messageSettings.ReactionsToRoles.Select(item => new Emoji(item.Key)).ToArray();

                    await message.AddReactionsAsync(emojis);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Failed validating all emotes on startup");
            }
        }
示例#3
0
        public async Task PurgeAsync(int count, bool self = true, bool silent = false)
        {
            var channel = Context.Channel as ITextChannel;

            var request = await AsyncEnumerableExtensions.FlattenAsync(
                channel.GetMessagesAsync(Context.Message.Id, Direction.Before, count)
                );

            if (!request.Any())
            {
                await Context.Message.AddReactionAsync(new Emoji("❌"));

                return;
            }

            var messageCount = 0;
            var filtered     = request
                               .Where(m =>
            {
                if (!self)
                {
                    return(false);
                }

                try
                {
                    return(m is IUserMessage && (DateTimeOffset.UtcNow - m.CreatedAt).TotalDays < 14);
                }
                finally
                {
                    messageCount++;
                }
            });
            var messages = filtered as IMessage[] ?? filtered.ToArray();

            if (self)
            {
                await Context.Message.DeleteAsync();
            }

            await channel.DeleteMessagesAsync(messages).ConfigureAwait(false);

            if (silent)
            {
                return;
            }

            var sb = new StringBuilder();

            sb.AppendLine($"Deleted `{messageCount}` messages.");
            sb.AppendLine();

            foreach (var author in messages.GroupBy(b => b.Author.Id))
            {
                var u = Context.Guild.GetUser(author.Key);
                sb.AppendLine($"**{u?.ToString() ?? author.Key.ToString()}**: {author.Count()} messages");
            }

            var ok = await EmbedResponseAsync(ResponseFormat.Success, description : sb.ToString());

            await Task.Delay(3000);

            await ok.DeleteAsync();
        }