Merge branch 'master' into fix_dm_actionlogs

Author: JayFromProgramming

dozer/Components/CustomJoinLeaveMessages.py

@@ -0,0 +1,93 @@
+"""Holder for the custom join/leave messages database class and the associated methods"""
+from dozer import db
+import discord
+from logging import getLogger
+
+DOZER_LOGGER = getLogger(__name__)
+
+
+async def send_log(member):
+    """Sends the message for when a user joins or leave a guild"""
+    config = await CustomJoinLeaveMessages.get_by(guild_id=member.guild.id)
+    if len(config):
+        channel = member.guild.get_channel(config[0].channel_id)
+        if channel:
+            embed = discord.Embed(color=0x00FF00)
+            embed.set_author(name='Member Joined', icon_url=member.avatar_url_as(format='png', size=32))
+            embed.description = format_join_leave(config[0].join_message, member)
+            embed.set_footer(text="{} | {} members".format(member.guild.name, member.guild.member_count))
+            try:
+                await channel.send(content=member.mention if config[0].ping else None, embed=embed)
+            except discord.Forbidden:
+                DOZER_LOGGER.warning(
+                    f"Guild {member.guild}({member.guild.id}) has invalid permissions for join/leave logs")
+
+
+def format_join_leave(template: str, member: discord.Member):
+    """Formats join leave message templates
+    {guild} = guild name
+    {user} = user's name plus discriminator ex. SnowPlow#5196
+    {user_name} = user's name without discriminator
+    {user_mention} = user's mention
+    {user_id} = user's ID
+    """
+    if template:
+        return template.format(guild=member.guild, user=str(member), user_name=member.name,
+                               user_mention=member.mention, user_id=member.id)
+    else:
+        return "{user_mention}\n{user} ({user_id})".format(user=str(member), user_mention=member.mention,
+                                                           user_id=member.id)
+
+
+class CustomJoinLeaveMessages(db.DatabaseTable):
+    """Holds custom join leave messages"""
+    __tablename__ = 'memberlogconfig'
+    __uniques__ = 'guild_id'
+
+    @classmethod
+    async def initial_create(cls):
+        """Create the table in the database"""
+        async with db.Pool.acquire() as conn:
+            await conn.execute(f"""
+            CREATE TABLE {cls.__tablename__} (
+            guild_id bigint PRIMARY KEY NOT NULL,	            
+            memberlog_channel bigint NOT NULL,	   
+            name varchar NOT NULL
+            )""")
+
+    def __init__(self, guild_id, channel_id=None, ping=None, join_message=None, leave_message=None):
+        super().__init__()
+        self.guild_id = guild_id
+        self.channel_id = channel_id
+        self.ping = ping
+        self.join_message = join_message
+        self.leave_message = leave_message
+
+    @classmethod
+    async def get_by(cls, **kwargs):
+        results = await super().get_by(**kwargs)
+        result_list = []
+        for result in results:
+            obj = CustomJoinLeaveMessages(guild_id=result.get("guild_id"), channel_id=result.get("channel_id"),
+                                          ping=result.get("ping"),
+                                          join_message=result.get("join_message"),
+                                          leave_message=result.get("leave_message"))
+            result_list.append(obj)
+        return result_list
+
+    async def version_1(self):
+        """DB migration v1"""
+        async with db.Pool.acquire() as conn:
+            await conn.execute(f"""
+            alter table memberlogconfig rename column memberlog_channel to channel_id;
+            alter table memberlogconfig alter column channel_id drop not null;
+            alter table {self.__tablename__} drop column IF EXISTS name;
+            alter table {self.__tablename__}
+                add IF NOT EXISTS ping boolean default False;
+            alter table {self.__tablename__}
+                add IF NOT EXISTS join_message text default null;
+            alter table {self.__tablename__}
+                add IF NOT EXISTS leave_message text default null;
+            """)
+
+    __versions__ = [version_1]

dozer/Components/TeamNumbers.py

@@ -0,0 +1,67 @@
+from dozer import db
+
+
+class TeamNumbers(db.DatabaseTable):
+    """Database operations for tracking team associations."""
+    __tablename__ = 'team_numbers'
+    __uniques__ = 'user_id, team_number, team_type'
+
+    @classmethod
+    async def initial_create(cls):
+        """Create the table in the database"""
+        async with db.Pool.acquire() as conn:
+            await conn.execute(f"""
+            CREATE TABLE {cls.__tablename__} (
+            user_id bigint NOT NULL,
+            team_number bigint NOT NULL,
+            team_type VARCHAR NOT NULL,
+            PRIMARY KEY (user_id, team_number, team_type)
+            )""")
+
+    def __init__(self, user_id, team_number, team_type):
+        super().__init__()
+        self.user_id = user_id
+        self.team_number = team_number
+        self.team_type = team_type
+
+    async def update_or_add(self):
+        """Assign the attribute to this object, then call this method to either insert the object if it doesn't exist in
+        the DB or update it if it does exist. It will update every column not specified in __uniques__."""
+        # This is its own functions because all columns must be unique, which breaks the syntax of the other one
+        keys = []
+        values = []
+        for var, value in self.__dict__.items():
+            # Done so that the two are guaranteed to be in the same order, which isn't true of keys() and values()
+            if value is not None:
+                keys.append(var)
+                values.append(value)
+        async with db.Pool.acquire() as conn:
+            statement = f"""
+            INSERT INTO {self.__tablename__} ({", ".join(keys)})
+            VALUES({','.join(f'${i+1}' for i in range(len(values)))}) 
+            """
+            await conn.execute(statement, *values)
+
+    @classmethod
+    async def get_by(cls, **kwargs):
+        results = await super().get_by(**kwargs)
+        result_list = []
+        for result in results:
+            obj = TeamNumbers(user_id=result.get("user_id"),
+                              team_number=result.get("team_number"),
+                              team_type=result.get("team_type"))
+            result_list.append(obj)
+        return result_list
+
+    # noinspection SqlResolve
+    @classmethod
+    async def top10(cls, user_ids):
+        """Returns the top 10 team entries"""
+        query = f"""SELECT team_type, team_number, count(*)
+                FROM {cls.__tablename__}
+                WHERE user_id = ANY($1) --first param: list of user IDs
+                GROUP BY team_type, team_number
+                ORDER BY count DESC, team_type, team_number
+                LIMIT 10"""
+        async with db.Pool.acquire() as conn:
+            return await conn.fetch(query, user_ids)

dozer/cogs/actionlogs.py

@@ -7,7 +7,8 @@
 
 import discord
 from discord.ext.commands import has_permissions, BadArgument
-
+from ..Components.CustomJoinLeaveMessages import CustomJoinLeaveMessages, format_join_leave, send_log
+from .moderation import GuildNewMember
 from ._utils import *
 from .general import blurple
 from .. import db
@@ -21,7 +22,8 @@ async def embed_paginatorinator(content_name, embed, text):
     c_embed = embed.copy()
     c_embed.add_field(name=content_name, value=text[0:1023], inline=False)
     for n in range(1, required_chunks):
-        c_embed.add_field(name=f"{content_name} Continued ({n})", value=text[1024*n:(1024*(n+1))-1], inline=False)
+        c_embed.add_field(name=f"{content_name} Continued ({n})", value=text[1024 * n:(1024 * (n + 1)) - 1],
+                          inline=False)
     return c_embed
 
 
@@ -43,38 +45,17 @@ async def check_audit(guild, event_type, event_time=None):
         except discord.Forbidden:
             return None
 
-    @staticmethod
-    def format_join_leave(template: str, member: discord.Member):
-        """Formats join leave message templates
-        {guild} = guild name
-        {user} = user's name plus discriminator ex. SnowPlow#5196
-        {user_name} = user's name without discriminator
-        {user_mention} = user's mention
-        {user_id} = user's ID
-        """
-        if template:
-            return template.format(guild=member.guild, user=str(member), user_name=member.name,
-                                   user_mention=member.mention, user_id=member.id)
-        else:
-            return "{user_mention}\n{user} ({user_id})".format(user=str(member), user_mention=member.mention,
-                                                               user_id=member.id)
-
     @Cog.listener('on_member_join')
     async def on_member_join(self, member):
         """Logs that a member joined, with optional custom message"""
-        config = await CustomJoinLeaveMessages.get_by(guild_id=member.guild.id)
-        if len(config):
-            channel = member.guild.get_channel(config[0].channel_id)
-            if channel:
-                embed = discord.Embed(color=0x00FF00)
-                embed.set_author(name='Member Joined', icon_url=member.avatar_url_as(format='png', size=32))
-                embed.description = self.format_join_leave(config[0].join_message, member)
-                embed.set_footer(text="{} | {} members".format(member.guild.name, member.guild.member_count))
-                try:
-                    await channel.send(content=member.mention if config[0].ping else None, embed=embed)
-                except discord.Forbidden:
-                    DOZER_LOGGER.warning(
-                        f"Guild {member.guild}({member.guild.id}) has invalid permissions for join/leave logs")
+        nm_config = await GuildNewMember.get_by(guild_id=member.guild.id)
+        if len(nm_config) == 0:
+            await send_log(member)
+        else:
+            if nm_config[0].require_team:
+                return
+            else:
+                await send_log(member)
 
     @Cog.listener('on_member_remove')
     async def on_member_remove(self, member):
@@ -85,7 +66,7 @@ async def on_member_remove(self, member):
             if channel:
                 embed = discord.Embed(color=0xFF0000)
                 embed.set_author(name='Member Left', icon_url=member.avatar_url_as(format='png', size=32))
-                embed.description = self.format_join_leave(config[0].leave_message, member)
+                embed.description = format_join_leave(config[0].leave_message, member)
                 embed.set_footer(text="{} | {} members".format(member.guild.name, member.guild.member_count))
                 try:
                     await channel.send(embed=embed)
@@ -367,11 +348,13 @@ async def on_message_edit(self, before, after):
                     first_message = await channel.send(embed=first_embed)
                     if second_embed:
                         second_message = await channel.send(embed=second_embed)
-                        first_embed.add_field(name="Edited", value=f"[CONTINUED](https://discordapp.com/channels/{guild_id}"
-                                                                   f"/{second_message.channel.id}/{second_message.id})", inline=False)
+                        first_embed.add_field(name="Edited",
+                                              value=f"[CONTINUED](https://discordapp.com/channels/{guild_id}"
+                                                    f"/{second_message.channel.id}/{second_message.id})", inline=False)
                         await first_message.edit(embed=first_embed)
-                        embed.set_field_at(0, name="Original", value=f"[CONTINUED](https://discordapp.com/channels/{guild_id}"
-                                                                     f"/{first_message.channel.id}/{first_message.id})", inline=False)
+                        embed.set_field_at(0, name="Original",
+                                           value=f"[CONTINUED](https://discordapp.com/channels/{guild_id}"
+                                                 f"/{first_message.channel.id}/{first_message.id})", inline=False)
                         await second_message.edit(embed=second_embed)
 
     @Cog.listener('on_member_ban')
@@ -426,9 +409,9 @@ async def memberlogconfig(self, ctx):
             embed.add_field(name="Message Channel", value=channel.mention if channel else "None")
             embed.add_field(name="Ping on join", value=config[0].ping)
             embed.add_field(name="Join template", value=config[0].join_message, inline=False)
-            embed.add_field(name="Join Example", value=self.format_join_leave(config[0].join_message, ctx.author))
+            embed.add_field(name="Join Example", value=format_join_leave(config[0].join_message, ctx.author))
             embed.add_field(name="Leave template", value=config[0].leave_message, inline=False)
-            embed.add_field(name="Leave Example", value=self.format_join_leave(config[0].leave_message, ctx.author))
+            embed.add_field(name="Leave Example", value=format_join_leave(config[0].leave_message, ctx.author))
             await ctx.send(embed=embed)
         else:
             await ctx.send("This guild has no member log configured")
@@ -623,60 +606,6 @@ async def get_by(cls, **kwargs):
         return result_list
 
 
-class CustomJoinLeaveMessages(db.DatabaseTable):
-    """Holds custom join leave messages"""
-    __tablename__ = 'memberlogconfig'
-    __uniques__ = 'guild_id'
-
-    @classmethod
-    async def initial_create(cls):
-        """Create the table in the database"""
-        async with db.Pool.acquire() as conn:
-            await conn.execute(f"""
-            CREATE TABLE {cls.__tablename__} (
-            guild_id bigint PRIMARY KEY NOT NULL,	            
-            memberlog_channel bigint NOT NULL,	   
-            name varchar NOT NULL
-            )""")
-
-    def __init__(self, guild_id, channel_id=None, ping=None, join_message=None, leave_message=None):
-        super().__init__()
-        self.guild_id = guild_id
-        self.channel_id = channel_id
-        self.ping = ping
-        self.join_message = join_message
-        self.leave_message = leave_message
-
-    @classmethod
-    async def get_by(cls, **kwargs):
-        results = await super().get_by(**kwargs)
-        result_list = []
-        for result in results:
-            obj = CustomJoinLeaveMessages(guild_id=result.get("guild_id"), channel_id=result.get("channel_id"),
-                                          ping=result.get("ping"),
-                                          join_message=result.get("join_message"),
-                                          leave_message=result.get("leave_message"))
-            result_list.append(obj)
-        return result_list
-
-    async def version_1(self):
-        """DB migration v1"""
-        async with db.Pool.acquire() as conn:
-            await conn.execute(f"""
-            alter table memberlogconfig rename column memberlog_channel to channel_id;
-            alter table memberlogconfig alter column channel_id drop not null;
-            alter table {self.__tablename__} drop column IF EXISTS name;
-            alter table {self.__tablename__}
-                add IF NOT EXISTS ping boolean default False;
-            alter table {self.__tablename__}
-                add IF NOT EXISTS join_message text default null;
-            alter table {self.__tablename__}
-                add IF NOT EXISTS leave_message text default null;
-            """)
-
-    __versions__ = [version_1]
-
-
 class GuildMessageLog(db.DatabaseTable):
     """Holds config info for message logs"""
     __tablename__ = 'messagelogconfig'