Merge branch 'master' into type-checking

Author: JayFromProgramming

.github/reviewers.yml

@@ -0,0 +1,12 @@
+reviewers:
+  # The default reviewers
+  defaults:
+   - team:DozerDevs
+   - team:SeniorDevs
+
+options:
+  ignore_draft: true
+  ignored_keywords:
+    - DO NOT REVIEW
+  enable_group_assignment: false
+

.github/workflows/main.yml

@@ -8,6 +8,7 @@ jobs:
   lint:
     # The type of runner that the job will run on
     runs-on: ubuntu-latest
+    if: github.event_name == 'push'
 
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
@@ -23,3 +24,15 @@ jobs:
       # Runs a set of commands using the runners shell
       - name: Lint
         run: ci/ci.sh
+    
+  auto-request-review:
+    name: Auto Request Review
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+    steps:
+      - name: Request review based on files changes and/or groups the author belongs to
+        uses: necojackarc/auto-request-review@v0.7.0
+        with:
+          token: ${{ secrets.BOTUSER }}
+          config: .github/reviewers.yml
+          

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

@@ -8,8 +8,8 @@
 import discord
 from discord.ext import commands
 from discord.ext.commands import has_permissions, BadArgument
-
 from dozer.context import DozerContext
+
 from ._utils import *
 from .general import blurple
 from .. import db
@@ -46,38 +46,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):
@@ -88,7 +67,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)
@@ -337,6 +316,8 @@ async def on_message_edit(self, before: discord.Message, after: discord.Message)
         """Logs message edits."""
         if before.author.bot:
             return
+        if isinstance(before.channel, discord.DMChannel):
+            return
         if after.edited_at is not None or before.edited_at is not None:
             # There is a reason for this. That reason is that otherwise, an infinite spam loop occurs
             guild_id = before.guild.id
@@ -429,9 +410,9 @@ async def memberlogconfig(self, ctx: DozerContext):
             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")
@@ -625,7 +606,6 @@ async def get_by(cls, **kwargs):
             result_list.append(obj)
         return result_list
 
-
 class CustomJoinLeaveMessages(db.DatabaseTable):
     """Holds custom join leave messages"""
     __tablename__ = 'memberlogconfig'
@@ -680,7 +660,6 @@ async def version_1(self):
 
     __versions__ = [version_1]
 
-
 class GuildMessageLog(db.DatabaseTable):
     """Holds config info for message logs"""
     __tablename__ = 'messagelogconfig'

dozer/cogs/info.py

@@ -1,7 +1,7 @@
 """Provides commands for pulling certain information."""
 import math
 import typing
-from datetime import timezone, datetime
+from datetime import timezone, datetime, date
 from difflib import SequenceMatcher
 
 import discord
@@ -52,20 +52,22 @@ async def member(self, ctx: DozerContext, *, member: discord.Member = None):
         embed = discord.Embed(title=member.display_name, description=f'{member!s} ({member.id})', color=member.color)
         embed.set_thumbnail(url=member.avatar_url)
         embed.add_field(name='Bot Created' if member.bot else 'Account Created',
-                        value=member.created_at.strftime(datetime_format), inline=True)
+                        value=f"<t:{int(member.created_at.timestamp())}:f>", inline=True)
 
         if not levels_enabled:
             embed.add_field(name="Last Seen Here At", value="Levels Disabled")
         elif len(levels_data):
-            embed.add_field(name="Last Seen Here At", value=levels_data[0].last_given_at.strftime(datetime_format))
+
+            #
+            embed.add_field(name="Last Seen Here", value=f"<t:{int(levels_data[0].last_given_at.timestamp())}:R>")
             footers.append(f"Tracked Messages: {levels_data[0].total_messages}")
         else:
             embed.add_field(name="Last Seen Here At", value="Not available")
             footers.append("Tracked Messages: N/A")
 
-        embed.add_field(name='Member Joined', value=member.joined_at.strftime(datetime_format), inline=True)
+        embed.add_field(name='Member Joined', value=f"<t:{int(member.joined_at.timestamp())}:f>", inline=True)
         if member.premium_since is not None:
-            embed.add_field(name='Member Boosted', value=member.premium_since.strftime(datetime_format), inline=True)
+            embed.add_field(name='Member Boosted', value=f"<t:{int(member.premium_since.timestamp())}:f>", inline=True)
 
         status = 'DND' if member.status is discord.Status.dnd else member.status.name.title()
         if member.status is not discord.Status.offline:
@@ -141,9 +143,8 @@ async def slash_role(self, ctx: SlashContext, role: discord.Role):
     @cooldown(1, 10, BucketType.channel)
     async def role(self, ctx: DozerContext, role: discord.Role):
         """Retrieve info about a role in this guild"""
-        embed = discord.Embed(title=f"Info for role: {role.name}", description=f"{role.mention} ({role.id})",
-                              color=role.color)
-        embed.add_field(name="Created on", value=role.created_at.strftime(datetime_format))
+        embed = discord.Embed(title=f"Info for role: {role.name}", description=f"{role.mention} ({role.id})", color=role.color)
+        embed.add_field(name="Created on", value=f"<t:{int(role.created_at.timestamp())}:f>")
         embed.add_field(name="Position", value=role.position)
         embed.add_field(name="Color", value=str(role.color).upper())
         embed.add_field(name="Assigned members", value=f"{len(role.members)}", inline=False)
@@ -184,7 +185,7 @@ async def guild(self, ctx: DozerContext):
 
         embed.set_thumbnail(url=guild.icon_url)
 
-        embed.add_field(name='Created at', value=guild.created_at.strftime(datetime_format))
+        embed.add_field(name='Created on', value=f"<t:{int(guild.created_at.timestamp())}:f>")
         embed.add_field(name='Owner', value=guild.owner)
         embed.add_field(name='Emoji', value="{} static, {} animated".format(static_emoji, animated_emoji))
         embed.add_field(name='Roles', value=str(len(guild.roles) - 1))  # Remove @everyone

dozer/cogs/levels.py

@@ -346,7 +346,7 @@ async def checkrolelevels(self, ctx: DozerContext):
             roles = sorted(unsorted, key=lambda entry: entry.level)  # Sort roles based on level
             embeds = []
 
-            for page_num, page in enumerate(chunk(roles.__iter__(), 10)):
+            for page_num, page in enumerate(chunk(roles, 10)):
                 e = discord.Embed(title=f"Level roles for {ctx.guild}", color=blurple)
                 e.description = f"This server has {len(roles)} level roles"
                 for level_role in page: