async def snipe(self, ctx):

        with open("./data/sniper.json") as f:
            self.sniper = json.load(f)

            if not ctx.author.guild_permissions.manage_messages:
                return await ctx.send(embed=func.NoPerm(self, ctx.guild.id),
                                      delete_after=15)
            if not str(ctx.guild.id) in self.sniper:
                return await ctx.send(embed=func.BadResponseEmbed(
                    self, ctx.guild.id,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Errors", "NoSnipeMessage")))
            if not str(ctx.channel.id) in self.sniper[str(ctx.guild.id)]:
                return await ctx.send(embed=func.BadResponseEmbed(
                    self, ctx.guild.id,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Errors", "NoSnipeMessage")))

            user = await self.bot.fetch_user(self.sniper[str(
                ctx.guild.id)][str(ctx.channel.id)]["AuthorID"])

            embed = discord.Embed(colour=discord.Colour(0x27b1db),
                                  description=self.sniper[str(
                                      ctx.guild.id)][str(
                                          ctx.channel.id)]["Message"])

            embed.set_author(name=user.name, icon_url=user.avatar_url)

            await ctx.send(embed=embed)

            del self.sniper[str(ctx.guild.id)]
            with open("./data/sniper.json", "w") as f:
                json.dump(self.sniper, f, indent=4)
示例#2
0
    async def remove(self, ctx, member: discord.Member = None, id=None):

        if not ctx.author.guild_permissions.manage_messages:
            return await ctx.send(embed=func.NoPerm(self, ctx.guild.id),
                                  delete_after=15)

        if not member:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Errors", "NoInfractionsUser")),
                                  delete_after=15)

        if not id:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id, "{} {}{}".format(
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Errors", "NeedID"), ctx.prefix,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Errors", "NeedIDEnd"))),
                                  delete_after=15)

        rm = sql.RemoveInfraction(id, ctx.guild.id, member.id)
        channel = await self.bot.fetch_channel(
            self.bot.cache[ctx.guild.id]["Logs"])

        if not rm:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id, "{} {}: {}".format(
                    member.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Errors", "DoesntHave"), id)),
                                  delete_after=15)

        await ctx.send(embed=func.GoodResponseEmbed(
            self, ctx.guild.id, "{} {} {}".format(
                member.mention,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "InfractionRemoved"), id)))

        if channel:
            await channel.send(embed=func.GoodResponseEmbed(
                self, ctx.guild.id, "{} {} {}".format(
                    member.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "InfractionRemoved"), id)))

        sql.LogMe(
            ctx.guild.id, 5, "{} ({}) {}: {} {} {}".format(
                ctx.author.display_name, ctx.author.name,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "UnWarned"), id,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "From"), member.name))
    async def on_guild_join(self, guild):
        activeServers = self.bot.guilds
        sum = 0
        for s in activeServers:
            sum += len(s.members)
        people = format(sum, ",")
        watch = discord.Activity(type=discord.ActivityType.watching,
                                 name=f"{people} people | w!help")
        await self.bot.change_presence(activity=watch)

        sql.AddData(guild.id)

        sql.LogMe(
            guild.id, 1, "{} {}".format(
                Language.get(guild.id, self.bot.cache, "Events", "Added"),
                guild.name))

        muted_role = discord.utils.get(guild.roles, name="muted")

        if not muted_role:
            try:
                role = await guild.create_role(name="muted")
            except:
                try:
                    return await guild.owner.send(embed=func.BadResponseEmbed(
                        self, guild.id, "{} {}setup @ {}".format(
                            Language.get(guild.id, self.bot.cache, "Core",
                                         "Error", "CantCreateMutedRole"), "w!",
                            guild.name)))
                except:
                    return

        Failed = []
        for channel in guild.channels:
            if channel.type != "voice":
                if not channel.overwrites_for(muted_role):
                    try:
                        await channel.set_permissions(role,
                                                      send_messages=False,
                                                      add_reactions=False)
                    except:
                        Failed.append(channel.name)
                        pass

        if len(Failed) > 0:
            try:
                return await guild.owner.send(embed=func.BadResponseEmbed(
                    self, guild.id, "{}\n\n {}".format(
                        Language.get(guild.id, self.bot.cache, "Errors",
                                     "CantSetOverwrite"), "\n".join(Failed))))
            except:
                return
示例#4
0
    async def infractions(self, ctx, member: discord.Member = None):

        if not ctx.author.guild_permissions.manage_messages:
            return await ctx.send(embed=func.NoPerm(self, ctx.guild.id),
                                  delete_after=15)

        if not member:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Errors", "NoInfractionsUser")),
                                  delete_after=15)

        infr = sql.GetInfractions(ctx.guild.id, member.id)

        if not infr:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id, "{} {}".format(
                    member.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Errors", "HasNoInfractions"))),
                                  delete_after=15)

        embed = discord.Embed(colour=0x27b1db)

        for i in infr:
            u = await self.bot.fetch_user(i[3])
            desc = "{} {} {} @ {} | {}: {}".format(
                member.mention,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "WarnedBy"), u.mention, i[5],
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Reason"), i[4])
            embed.add_field(name="{}: {}".format(
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "InfractID"), i[0]),
                            value=desc,
                            inline=False)

        await ctx.send(embed=embed)
示例#5
0
    async def setup(self, ctx):
        muted_role = discord.utils.get(ctx.guild.roles, name="muted")

        if not muted_role:
            try:
                role = await ctx.guild.create_role(name="muted")
            except:
                return await ctx.author.send(embed=func.BadResponseEmbed(self, ctx.guild.id, "{} {}setup @ {}".format(Language.get(ctx.guild.id, self.bot.cache, "Core", "Error", "CantCreateMutedRole"), ctx.prefix, ctx.guild.name)))

        Failed = []
        for channel in ctx.guild.channels:
            if channel.type != "voice":
                if not channel.overwrites_for(muted_role):
                    try:
                        await channel.set_permissions(role, send_messages=False, add_reactions=False)
                    except:
                        Failed.append(channel.name)
                        pass

        if len(Failed) > 0:
            return await ctx.author.send(embed=func.BadResponseEmbed(self, ctx.guild.id, "{}\n\n {}".format(Language.get(ctx.guild.id, self.bot.cache, "Errors", "CantSetOverwrite"), "\n".join(Failed))))

        await ctx.author.send(embed=func.GoodResponseEmbed(self, ctx.guild.id, "{} {}!".format(Language.get(ctx.guild.id, self.bot.cache, "Core", "SetupComplete"), ctx.guild.name)))
示例#6
0
    async def warn(self, ctx, member: discord.Member = None, reason=None):

        if not ctx.author.guild_permissions.manage_messages:
            return await ctx.send(embed=func.NoPerm(self, ctx.guild.id),
                                  delete_after=15)

        if not member:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Errors", "WarnNoUser")),
                                  delete_after=15)

        if not reason:
            reason = Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                  "NoReason")

        channel = await self.bot.fetch_channel(
            self.bot.cache[ctx.guild.id]["Logs"])

        sql.Warn(ctx.guild.id, member.id, ctx.author.id, reason)

        await member.send(embed=func.Alert(
            self, member, ctx.guild,
            Language.get(ctx.guild.id, self.bot.cache, "Moderator", "Warned"),
            ctx.author, reason))
        await ctx.send(embed=func.GoodResponseEmbed(
            self, ctx.guild.id, "{} {} {} | {}: {}".format(
                member.mention,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "WasWarned"), ctx.author.mention,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Reason"), reason)))
        await Rules.DoRule(self, member, ctx.guild, self.bot.tobemuted,
                           self.bot.tobekicked, self.bot.tobebanned)
        if channel:
            await channel.send(embed=func.GoodResponseEmbed(
                self, ctx.guild.id, "{} {} {} | {}: {}".format(
                    member.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "WasWarned"), ctx.author.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Reason"), reason)))
        sql.LogMe(
            ctx.guild.id, 5, "{} ({}) {} {}. {}: {}".format(
                ctx.author.display_name, ctx.author.name,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Warned"), member.name,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Reason"), reason))
示例#7
0
    async def roleinfo(self, ctx, name=None):
        role = discord.utils.get(ctx.guild.roles, name=name)

        if not role:
            return await ctx.send(embed=func.BadResponseEmbed(self, ctx.guild.id, Language.get(ctx.guild.id, self.bot.cache, "Info", "Errors", "NoRole")))

        embed = discord.Embed(colour = 0x27b1db)
        embed.add_field(name=Language.get(ctx.guild.id, self.bot.cache, "Info", "Rolename"), value=role.mention, inline=True)
        embed.add_field(name=Language.get(ctx.guild.id, self.bot.cache, "Info", "RoleID"), value=role.id, inline=True)
        embed.add_field(name=Language.get(ctx.guild.id, self.bot.cache, "Info", "UsersWRole"), value=len(role.members), inline=True)
        embed.add_field(name=Language.get(ctx.guild.id, self.bot.cache, "Info", "Mentionable"), value=role.mentionable, inline=True)
        embed.add_field(name=Language.get(ctx.guild.id, self.bot.cache, "Info", "DisplayedSep"), value=role.hoist, inline=True)
        embed.add_field(name=Language.get(ctx.guild.id, self.bot.cache, "Info", "Colour"), value=role.colour, inline=True)
        embed.set_footer(text="{} - {}".format(Language.get(ctx.guild.id, self.bot.cache, "Info", "RoleCreated"), role.created_at.strftime("%d/%m/%Y at %H:%M:%S")))
        await ctx.send(embed=embed)
    async def ban(self, ctx, user: discord.User = None, *args):

        if not ctx.author.guild_permissions.ban_members:
            return await ctx.send(embed=func.NoPerm(self, ctx.guild.id),
                                  delete_after=15)

        if not user:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Errors", "BanNoUser")),
                                  delete_after=15)

        reason = ' '.join(args)
        channel = await self.bot.fetch_channel(
            self.bot.cache[ctx.guild.id]["Logs"])

        if reason == "":
            reason = Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                  "NoReason")

        await user.send(embed=func.Alert(
            self, user, ctx.guild,
            Language.get(ctx.guild.id, self.bot.cache, "Moderator", "Banned"),
            ctx.author.name, reason))
        await ctx.send(embed=func.GoodResponseEmbed(
            self, ctx.guild.id, "{} {} {} | {}: {}".format(
                user.mention,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "WasBanned"), ctx.author.mention,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Reason"), reason)))
        if channel:
            await channel.send(embed=func.GoodResponseEmbed(
                self, ctx.guild.id, "{} {} {} | {}: {}".format(
                    user.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "WasBanned"), ctx.author.mention,
                    Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                                 "Reason"), reason)))
        await ctx.guild.ban(user, reason=reason, delete_message_days=7)
        sql.LogMe(
            ctx.guild.id, 8, "{} ({}) {} {}. {}: {}".format(
                ctx.author.display_name, ctx.author.name,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Banned"), user.name,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Reason"), reason))
    async def clear(self, ctx, amount: int = None):

        if not ctx.author.guild_permissions.manage_messages:
            return await ctx.send(embed=func.NoPerm(self, ctx.guild.id),
                                  delete_after=15)

        await ctx.message.delete()

        if not amount or amount > 100 or amount < 1:
            return await ctx.send(embed=func.BadResponseEmbed(
                self, ctx.guild.id,
                Language.get(ctx.guild.id, self.bot.cache, "Moderator",
                             "Errors", "Upto100")),
                                  delete_after=15)

        dela = await ctx.channel.purge(limit=amount)
        await ctx.send("{}: {}".format(
            Language.get(ctx.guild.id, self.bot.cache, "Moderator", "Deleted"),
            len(dela)),
                       delete_after=15)
示例#10
0
    async def on_guild_channel_create(self, channel):
        role = discord.utils.get(channel.guild.roles, name="muted")

        if not role:
            return

        if channel.guild.id in self.bot.cache:
            if self.bot.cache[channel.guild.id]["Logs"]:
                channel = await self.bot.fetch_channel(
                    self.bot.cache[channel.guild.id]["Logs"])

        try:
            await channel.set_permissions(role,
                                          send_messages=False,
                                          add_reactions=False)
        except:
            if channel:
                await channel.send(embed=func.BadResponseEmbed(
                    self, channel.guild.id, "{} {}".format(
                        Language.get(channel.guild.id, self.bot.cache,
                                     "Errors", "CantSetOverwrite"),
                        channel.name)))