示例#1
0
文件: Unmute.cs 项目: mmattbtw/Kaguya
        public async Task UnmuteUser(SocketGuildUser user, [Remainder] string reason = null)
        {
            Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);

            var mutedObject = await DatabaseQueries.GetFirstMatchAsync <MutedUser>(x => x.UserId == user.Id && x.ServerId == server.ServerId);

            reason ??= "<No reason provided>";

            if (mutedObject != null)
            {
                await DatabaseQueries.DeleteAsync(mutedObject);
            }

            if (server.IsPremium)
            {
                await DatabaseQueries.UpdateAsync(server);
            }

            try
            {
                SocketRole muteRole = Context.Guild.Roles.FirstOrDefault(x => x.Name.ToLower() == "kaguya-mute");

                if (!user.Roles.Contains(muteRole))
                {
                    await ReplyAsync($"{Context.User.Mention} **{user}** is not muted.");

                    return;
                }

                await user.RemoveRoleAsync(muteRole);
                await ReplyAsync($"{Context.User.Mention} Successfully unmuted **{user}**.");


                KaguyaEvents.TriggerUnmute(new ModeratorEventArgs(server, Context.Guild, user, (SocketGuildUser)Context.User, reason, null));
            }
            catch (NullReferenceException)
            {
                var errorEmbed = new KaguyaEmbedBuilder
                {
                    Description = "User was never muted because the mute role doesn't exist.",
                    Footer      = new EmbedFooterBuilder
                    {
                        Text = "Use the mute command to generate the mute role."
                    }
                };

                errorEmbed.SetColor(EmbedColor.RED);

                await ReplyAsync(embed : errorEmbed.Build());
            }
            catch (Exception e)
            {
                throw new KaguyaSupportException($"An unexpected error occurred.\n\nError Log: {e}");
            }
        }
示例#2
0
        public static Task Initialize()
        {
            var timer = new Timer(5000)
            {
                AutoReset = true,
                Enabled   = true
            };

            timer.Elapsed += async(_, _) =>
            {
                List <MutedUser> curMutedUsers = await DatabaseQueries.GetAllAsync <MutedUser>(x => x.ExpiresAt < DateTime.Now.ToOADate());

                foreach (MutedUser mutedUser in curMutedUsers)
                {
                    SocketGuild guild = ConfigProperties.Client.GetGuild(mutedUser.ServerId);

                    if (guild == null)
                    {
                        goto RemoveFromDB;
                    }

                    Server server = await DatabaseQueries.GetOrCreateServerAsync(guild.Id);

                    SocketGuildUser user     = guild.GetUser(mutedUser.UserId);
                    SocketGuildUser selfUser = guild.GetUser(ConfigProperties.Client.CurrentUser.Id);

                    try
                    {
                        SocketRole muteRole = guild.Roles.FirstOrDefault(x => x.Name == "kaguya-mute");
                        await user.RemoveRoleAsync(muteRole);

                        KaguyaEvents.TriggerUnmute(new ModeratorEventArgs(server, guild, user, selfUser,
                                                                          "Automatic unmute (timed mute has expired)", null));
                    }
                    catch (Exception)
                    {
                        await ConsoleLogger.LogAsync($"Exception handled when unmuting a user in guild [Name: {guild.Name} | ID: {guild.Id}]",
                                                     LogLvl.WARN);
                    }

                    await DatabaseQueries.UpdateAsync(server);

RemoveFromDB:
                    await DatabaseQueries.DeleteAsync(mutedUser);

                    await ConsoleLogger.LogAsync($"User [ID: {mutedUser.UserId}] has been automatically unmuted.",
                                                 LogLvl.DEBUG);
                }
            };

            return(Task.CompletedTask);
        }