Add ability to disable DM

Author: Taaku18

CHANGELOG.md

@@ -27,6 +27,18 @@ however, insignificant breaking changes does not guarantee a major version bump,
 - `?logs responded [user]` command, it will show all logs that the user has sent an reply. (Thanks to papiersnipper PR#288)
   - `user` when not provided, defaults to the user who ran the command.
 - Open threads in limbo now auto closes if the channel cannot be found. This check is done every time the bot restarts.
+- Ability to disable new threads from getting created.
+  - `?disable`
+- Ability to fully disable Modmail DM.
+  - `?disable all`
+- To re-enable DM: `?enable`, and to see the current status: `?isenable`.
+- This disabled Modmail interface is customizable with the following config vars:
+  - `disabled_new_thread_title`
+  - `disabled_new_thread_response`
+  - `disabled_new_thread_footer`
+  - `disabled_current_thread_title`
+  - `disabled_current_thread_response`
+  - `disabled_current_thread_footer`
 
 ### Changed
 

bot.py

@@ -1,4 +1,4 @@
-__version__ = "3.3.0-dev4"
+__version__ = "3.3.0-dev5"
 
 import asyncio
 import logging
@@ -46,8 +46,10 @@
 
 ch = logging.StreamHandler(stream=sys.stdout)
 ch.setLevel(logging.INFO)
-formatter = logging.Formatter("%(asctime)s %(filename)s[%(lineno)d] - %(levelname)s: %(message)s",
-                              datefmt="%b %d %H:%M:%S")
+formatter = logging.Formatter(
+    "%(asctime)s %(filename)s[%(lineno)d] - %(levelname)s: %(message)s",
+    datefmt="%b %d %H:%M:%S",
+)
 ch.setFormatter(formatter)
 logger.addHandler(ch)
 
@@ -123,7 +125,7 @@ def startup(self):
         logger.info("┴ ┴└─┘─┴┘┴ ┴┴ ┴┴┴─┘")
         logger.info("v%s", __version__)
         logger.info("Authors: kyb3r, fourjr, Taaku18")
-        logger.line('debug')
+        logger.line("debug")
 
         for cog in self.loaded_cogs:
             logger.debug("Loading %s.", cog)
@@ -132,7 +134,7 @@ def startup(self):
                 logger.debug("Successfully loaded %s.", cog)
             except Exception:
                 logger.exception("Failed to load %s.", cog)
-        logger.line('debug')
+        logger.line("debug")
 
     def _configure_logging(self):
         level_text = self.config["log_level"].upper()
@@ -144,9 +146,7 @@ def _configure_logging(self):
             "DEBUG": logging.DEBUG,
         }
 
-        ch_debug = logging.FileHandler(
-            self.log_file_name, mode="a+"
-        )
+        ch_debug = logging.FileHandler(self.log_file_name, mode="a+")
 
         ch_debug.setLevel(logging.DEBUG)
         formatter_debug = FileFormatter(
@@ -460,7 +460,10 @@ async def on_ready(self):
         logger.debug("Client ready.")
         logger.info("Logged in as: %s", self.user)
         logger.info("Bot ID: %s", self.user.id)
-        owners = ", ".join(getattr(self.get_user(owner_id), "name", str(owner_id)) for owner_id in self.owner_ids)
+        owners = ", ".join(
+            getattr(self.get_user(owner_id), "name", str(owner_id))
+            for owner_id in self.owner_ids
+        )
         logger.info("Owners: %s", owners)
         logger.info("Prefix: %s", self.prefix)
         logger.info("Guild Name: %s", self.guild.name)
@@ -504,10 +507,12 @@ async def on_ready(self):
             )
 
         for log in await self.api.get_open_logs():
-            if self.get_channel(int(log['channel_id'])) is None:
-                logger.debug("Unable to resolve thread with channel %s.", log['channel_id'])
+            if self.get_channel(int(log["channel_id"])) is None:
+                logger.debug(
+                    "Unable to resolve thread with channel %s.", log["channel_id"]
+                )
                 log_data = await self.api.post_log(
-                    log['channel_id'],
+                    log["channel_id"],
                     {
                         "open": False,
                         "closed_at": str(datetime.utcnow()),
@@ -522,9 +527,14 @@ async def on_ready(self):
                     },
                 )
                 if log_data:
-                    logger.debug("Successfully closed thread with channel %s.", log['channel_id'])
+                    logger.debug(
+                        "Successfully closed thread with channel %s.", log["channel_id"]
+                    )
                 else:
-                    logger.debug("Failed to close thread with channel %s, skipping.", log['channel_id'])
+                    logger.debug(
+                        "Failed to close thread with channel %s, skipping.",
+                        log["channel_id"],
+                    )
 
         self.metadata_loop = tasks.Loop(
             self.post_metadata,
@@ -573,21 +583,17 @@ async def retrieve_emoji(self) -> typing.Tuple[str, str]:
 
         return sent_emoji, blocked_emoji
 
-    async def _process_blocked(self, message: discord.Message) -> bool:
+    async def _process_blocked(
+        self, message: discord.Message
+    ) -> typing.Tuple[bool, str]:
         sent_emoji, blocked_emoji = await self.retrieve_emoji()
 
         if str(message.author.id) in self.blocked_whitelisted_users:
             if str(message.author.id) in self.blocked_users:
                 self.blocked_users.pop(str(message.author.id))
                 await self.config.update()
 
-            if sent_emoji != "disable":
-                try:
-                    await message.add_reaction(sent_emoji)
-                except (discord.HTTPException, discord.InvalidArgument):
-                    logger.warning("Failed to add sent_emoji.", exc_info=True)
-
-            return False
+            return False, sent_emoji
 
         now = datetime.utcnow()
 
@@ -682,8 +688,10 @@ async def _process_blocked(self, message: discord.Message) -> bool:
                     # backwards compat
                     end_time = re.search(r"%([^%]+?)%", reason)
                     if end_time is not None:
-                        logger.warning(r"Deprecated time message for user %s, block and unblock again to update.",
-                                       message.author)
+                        logger.warning(
+                            r"Deprecated time message for user %s, block and unblock again to update.",
+                            message.author,
+                        )
 
                 if end_time is not None:
                     after = (
@@ -702,19 +710,62 @@ async def _process_blocked(self, message: discord.Message) -> bool:
             reaction = sent_emoji
 
         await self.config.update()
+        return str(message.author.id) in self.blocked_users, reaction
+
+    @staticmethod
+    async def add_reaction(msg, reaction):
         if reaction != "disable":
             try:
-                await message.add_reaction(reaction)
+                await msg.add_reaction(reaction)
             except (discord.HTTPException, discord.InvalidArgument):
                 logger.warning("Failed to add reaction %s.", reaction, exc_info=True)
-        return str(message.author.id) in self.blocked_users
 
     async def process_dm_modmail(self, message: discord.Message) -> None:
         """Processes messages sent to the bot."""
-        blocked = await self._process_blocked(message)
-        if not blocked:
-            thread = await self.threads.find_or_create(message.author)
-            await thread.send(message)
+        blocked, reaction = await self._process_blocked(message)
+        if blocked:
+            return await self.add_reaction(message, reaction)
+        thread = await self.threads.find(recipient=message.author)
+        if thread is None:
+            if self.config["dm_disabled"] >= 1:
+                embed = discord.Embed(
+                    title=self.config["disabled_new_thread_title"],
+                    color=self.error_color,
+                    description=self.config["disabled_new_thread_response"],
+                )
+                embed.set_footer(
+                    text=self.config["disabled_new_thread_footer"],
+                    icon_url=self.guild.icon_url,
+                )
+                logger.info(
+                    "A new thread was blocked from %s due to disabled Modmail.",
+                    message.author,
+                )
+                _, blocked_emoji = await self.retrieve_emoji()
+                await self.add_reaction(message, blocked_emoji)
+                return await message.channel.send(embed=embed)
+            thread = self.threads.create(message.author)
+        else:
+            if self.config["dm_disabled"] == 2:
+                embed = discord.Embed(
+                    title=self.config["disabled_current_thread_title"],
+                    color=self.error_color,
+                    description=self.config["disabled_current_thread_response"],
+                )
+                embed.set_footer(
+                    text=self.config["disabled_current_thread_footer"],
+                    icon_url=self.guild.icon_url,
+                )
+                logger.info(
+                    "A message was blocked from %s due to disabled Modmail.",
+                    message.author,
+                )
+                _, blocked_emoji = await self.retrieve_emoji()
+                await self.add_reaction(message, blocked_emoji)
+                return await message.channel.send(embed=embed)
+
+        await self.add_reaction(message, reaction)
+        await thread.send(message)
 
     async def get_contexts(self, message, *, cls=commands.Context):
         """
@@ -898,13 +949,13 @@ async def _void(*_args, **_kwargs):
 
             thread = await self.threads.find(channel=channel)
             if thread is not None and thread.recipient:
-                if await self._process_blocked(
-                    SimpleNamespace(
-                        author=thread.recipient,
-                        channel=SimpleNamespace(send=_void),
-                        add_reaction=_void,
+                if (
+                    await self._process_blocked(
+                        SimpleNamespace(
+                            author=thread.recipient, channel=SimpleNamespace(send=_void)
+                        )
                     )
-                ):
+                )[0]:
                     return
                 await thread.recipient.trigger_typing()
 
@@ -1111,7 +1162,7 @@ async def validate_database_connection(self):
             raise
         else:
             logger.debug("Successfully connected to the database.")
-        logger.line('debug')
+        logger.line("debug")
 
     async def post_metadata(self):
         owner = (await self.application_info()).owner
@@ -1137,7 +1188,7 @@ async def post_metadata(self):
     async def before_post_metadata(self):
         await self.wait_for_connected()
         logger.debug("Starting metadata loop.")
-        logger.line('debug')
+        logger.line("debug")
         if not self.guild:
             self.metadata_loop.cancel()
 

cogs/modmail.py

@@ -626,9 +626,9 @@ def format_log_embeds(self, logs, avatar_url):
             embed.add_field(
                 name="Created", value=duration(created_at, now=datetime.utcnow())
             )
-            closer = entry.get('closer')
+            closer = entry.get("closer")
             if closer is None:
-                closer_msg = 'Unknown'
+                closer_msg = "Unknown"
             else:
                 closer_msg = f"<@{closer['id']}>"
             embed.add_field(name="Closed By", value=closer_msg)
@@ -916,6 +916,9 @@ async def contact(
             thread = self.bot.threads.create(
                 user, creator=ctx.author, category=category
             )
+            if self.bot.config["dm_disabled"] >= 1:
+                logger.info("Contacting user %s when Modmail DM is disabled.", user)
+
             embed = discord.Embed(
                 title="Created Thread",
                 description=f"Thread started by {ctx.author.mention} "
@@ -1089,7 +1092,7 @@ async def block(
             embed = discord.Embed(
                 title="Success",
                 description=f"{mention} was previously blocked "
-                f'{old_reason}.\n{mention} is now blocked {reason}',
+                f"{old_reason}.\n{mention} is now blocked {reason}",
                 color=self.bot.main_color,
             )
         else:
@@ -1136,7 +1139,7 @@ async def unblock(self, ctx, *, user: User = None):
                 embed = discord.Embed(
                     title="Success",
                     description=f"{mention} was previously blocked internally "
-                    f'{reason}.\n{mention} is no longer blocked.',
+                    f"{reason}.\n{mention} is no longer blocked.",
                     color=self.bot.main_color,
                 )
                 embed.set_footer(
@@ -1197,6 +1200,94 @@ async def delete(self, ctx, message_id: Optional[int] = None):
         except (discord.HTTPException, discord.InvalidArgument):
             pass
 
+    @commands.command()
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    async def enable(self, ctx):
+        """
+        Re-enables DM functionalities of Modmail.
+
+        Undo's the `{prefix}disable` command, all DM will be relayed after running this command.
+        """
+        embed = discord.Embed(
+            title="Success",
+            description=f"Modmail will now accept all DM messages.",
+            color=self.bot.main_color,
+        )
+
+        if self.bot.config["dm_disabled"] != 0:
+            self.bot.config["dm_disabled"] = 0
+            await self.bot.config.update()
+
+        return await ctx.send(embed=embed)
+
+    @commands.group(invoke_without_command=True)
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    async def disable(self, ctx):
+        """
+        Stop accepting new Modmail threads.
+
+        No new threads can be created through DM.
+        To stop all existing threads from DMing Modmail, do `{prefix}disable all`.
+        """
+        embed = discord.Embed(
+            title="Success",
+            description=f"Modmail will not create any new threads.",
+            color=self.bot.main_color,
+        )
+        if self.bot.config["dm_disabled"] < 1:
+            self.bot.config["dm_disabled"] = 1
+            await self.bot.config.update()
+
+        return await ctx.send(embed=embed)
+
+    @disable.command(name="all")
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    async def disable_all(self, ctx):
+        """
+        Disables all DM functionalities of Modmail.
+
+        No new threads can be created through DM nor no further DM messages will be relayed.
+        """
+        embed = discord.Embed(
+            title="Success",
+            description=f"Modmail will not accept any DM messages.",
+            color=self.bot.main_color,
+        )
+
+        if self.bot.config["dm_disabled"] != 2:
+            self.bot.config["dm_disabled"] = 2
+            await self.bot.config.update()
+
+        return await ctx.send(embed=embed)
+
+    @commands.command()
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    async def isenable(self, ctx):
+        """
+        Check if the DM functionalities of Modmail is enabled.
+        """
+
+        if self.bot.config["dm_disabled"] == 1:
+            embed = discord.Embed(
+                title="New Threads Disabled",
+                description=f"Modmail will not create any new threads.",
+                color=self.bot.main_color,
+            )
+        elif self.bot.config["dm_disabled"] == 2:
+            embed = discord.Embed(
+                title="All DM Disabled",
+                description=f"Modmail will accept any DM messages for new and existing threads.",
+                color=self.bot.main_color,
+            )
+        else:
+            embed = discord.Embed(
+                title="Enabled",
+                description=f"Modmail is receiving all DM messages.",
+                color=self.bot.main_color,
+            )
+
+        return await ctx.send(embed=embed)
+
 
 def setup(bot):
     bot.add_cog(Modmail(bot))