Adding factory method for standard BotMessageReactions. Adding bot check to avoid exceptions. Adding more logging.

cogs/basecog.py

 from discord.ext import commands
 from datetime import datetime, timedelta
 
+from abc import ABC, abstractmethod
 from config import CONFIG
 from rscollections import AgeBoundDict
 from storage import ConfigKey, Storage
 			other.is_enabled == self.is_enabled and \
 			other.description == self.description
 
+	@classmethod
+	def standard_set(cls,
+			did_delete: bool = None,
+			message_count: int = 1,
+			did_kick: bool = None,
+			did_ban: bool = None,
+			user_count: int = 1) -> list:
+		"""
+		Convenience factory for generating any of the three most common
+		commands: delete message(s), kick user(s), and ban user(s). All
+		arguments are optional. Resulting list can be passed directly to
+		`BotMessage.set_reactions()`.
+
+		Params
+		- did_delete     Whether the message(s) have been deleted. Pass True or
+		                 False if this applies, omit to leave out delete action.
+		- message_count  How many messages there are. Used for pluralizing
+		                 description. Defaults to 1. Omit if n/a.
+		- did_kick       Whether the user(s) have been kicked. Pass True or
+		                 False if this applies, omit to leave out kick action.
+		- did_ban        Whether the user(s) have been banned. Pass True or
+		                 False if this applies, omit to leave out ban action.
+		- user_count     How many users there are. Used for pluralizing
+		                 description. Defaults to 1. Omit if n/a.
+		"""
+		reactions = []
+		if did_delete is not None:
+			if did_delete:
+				reactions.append(BotMessageReaction(
+					CONFIG['trash_emoji'],
+					False,
+					'Message deleted' if message_count == 1 else 'Messages deleted'))
+			else:
+				reactions.append(BotMessageReaction(
+					CONFIG['trash_emoji'],
+					True,
+					'Delete message' if message_count == 1 else 'Delete messages'))
+		if did_kick is not None:
+			if did_ban is not None and did_ban:
+				# Don't show kick option at all if we also banned
+				pass
+			elif did_kick:
+				reactions.append(BotMessageReaction(
+					CONFIG['kick_emoji'],
+					False,
+					'User kicked' if user_count == 1 else 'Users kicked'))
+			else:
+				reactions.append(BotMessageReaction(
+					CONFIG['kick_emoji'],
+					True,
+					'Kick user' if user_count == 1 else 'Kick users'))
+		if did_ban is not None:
+			if did_ban:
+				reactions.append(BotMessageReaction(
+					CONFIG['ban_emoji'],
+					False,
+					'User banned' if user_count == 1 else 'Users banned'))
+			else:
+				reactions.append(BotMessageReaction(
+					CONFIG['ban_emoji'],
+					True,
+					'Ban user' if user_count == 1 else 'Ban users'))
+		return reactions
+
 class BotMessage:
 	"""
 	Holds state for a bot-generated message. A message is composed, sent via
 		self.type = type
 		self.context = context
 		self.quote = None
+		self.source_cog = None  # Set by `BaseCog.post_message()`
 		self.__posted_text = None  # last text posted, to test for changes
 		self.__posted_emoji = set()
 		self.__message = None  # Message
 			else:
 				channel_id = Storage.get_config_value(self.guild, ConfigKey.WARNING_CHANNEL_ID)
 				if channel_id is None:
-					BaseCog.guild_trace(self.guild, 'No warning channel set! No warning issued.')
+					BaseCog.log(self.guild, '\u0007No warning channel set! No warning issued.')
 					return
 				channel: TextChannel = self.guild.get_channel(channel_id)
 				if channel is None:
-					BaseCog.guild_trace(self.guild, 'Configured warning channel does not exist!')
+					BaseCog.log(self.guild, '\u0007Configured warning channel does not exist!')
 					return
 				self.__message = await channel.send(content=content)
 				self.__posted_text = content
 			s += '\n\nAvailable actions:'
 			for reaction in self.__reactions:
 				if reaction.is_enabled:
-					s += f'\n   {reaction.emoji} {reaction.description}'
+					s += f'\n     {reaction.emoji} {reaction.description}'
 				else:
-					s += f'\n   {reaction.description}'
+					s += f'\n     {reaction.description}'
 
 		return s
 
 			Storage.set_state_value(guild, 'bot_messages', bm)
 		return bm
 
-	@classmethod
-	async def post_message(cls, message: BotMessage) -> bool:
+	async def post_message(self, message: BotMessage) -> bool:
+		message.source_cog = self
 		await message._update()
-		guild_messages = cls.__bot_messages(message.guild)
+		guild_messages = self.__bot_messages(message.guild)
 		if message.is_sent():
 			guild_messages[message.message_id()] = message
 			return True
 		if bot_message is None:
 			# Unknown message (expired or was never tracked)
 			return
+		if self is not bot_message.source_cog:
+			# Belongs to a different cog
+			return
 		reaction = bot_message.reaction_for_emoji(payload.emoji)
 		if reaction is None or not reaction.is_enabled:
 			# Can't use this reaction with this message
 		"""
 		pass
 
+	# Helpers
+
 	@classmethod
 	async def validate_param(cls, context: commands.Context, param_name: str, value,
 		allowed_types: tuple = None,
 	@classmethod
 	async def warn(cls, guild: Guild, message: str) -> Message:
 		"""
+		DEPRECATED. Use post_message.
+
 		Sends a warning message to the configured warning channel for the
 		given guild. If no warning channel is configured no action is taken.
 		Returns the Message if successful or None if not.
 		"""
 		channel_id = Storage.get_config_value(guild, ConfigKey.WARNING_CHANNEL_ID)
 		if channel_id is None:
-			cls.guild_trace(guild, 'No warning channel set! No warning issued.')
+			cls.log(guild, '\u0007No warning channel set! No warning issued.')
 			return None
 		channel: TextChannel = guild.get_channel(channel_id)
 		if channel is None:
-			cls.guild_trace(guild, 'Configured warning channel does not exist!')
+			cls.log(guild, '\u0007Configured warning channel does not exist!')
 			return None
 		mention: str = Storage.get_config_value(guild, ConfigKey.WARNING_MENTION)
 		text: str = message
 	@classmethod
 	async def update_warn(cls, warn_message: Message, new_text: str) -> None:
 		"""
+		DEPRECATED. Use post_message.
+
 		Updates the text of a previously posted `warn`. Includes configured
 		mentions if necessary.
 		"""
 		await warn_message.edit(content=text)
 
 	@classmethod
-	def guild_trace(cls, guild: Guild, message: str) -> None:
+	def log(cls, guild: Guild, message) -> None:
+		now = datetime.now()
+		print(f'[{now.strftime("%Y-%m-%dT%H:%M:%S")}|{cls.__name__}|{guild.name}] {message}')
+
+	@classmethod
+	def deprecated_guild_trace(cls, guild: Guild, message: str) -> None:
 		print(f'[guild {guild.id}|{guild.name}] {message}')

cogs/crosspostcog.py

 				context.is_banned = True
 				context.is_autobanned = True
 				context.deleted_messages |= context.spam_messages
+				self.log(context.member.guild, f'Bot autobanned {context.member.name} ({context.member.id}) for spamming')
 			else:
 				# Already banned. Nothing to update in the message.
 				return
 		else:
 			await message.set_text(f'User {context.member.mention} posted ' +
 				f'the same message {spam_count} times.')
-			can_delete = spam_count > deleted_count
-			can_kick = not context.is_kicked
-			can_ban = not context.is_banned
-			await message.add_reaction(
-				BotMessageReaction(
-					CONFIG['trash_emoji'],
-					can_delete,
-					'Delete messages' if can_delete else f'Deleted {deleted_count} messages'))
-			if can_ban:
-				# Only show kick info if they can also be banned. Otherwise we say
-				# dumb stuff like "user was kicked, user was banned".
-				await message.add_reaction(
-					BotMessageReaction(
-						CONFIG['kick_emoji'],
-						can_kick,
-						'Kick user' if can_kick else 'User kicked'))
-			else:
-				await message.remove_reaction(CONFIG['kick_emoji'])
-			await message.add_reaction(
-				BotMessageReaction(
-					CONFIG['ban_emoji'], 
-					can_ban,
-					'Ban user' if can_ban else 'User banned'))
+			await message.set_reactions(BotMessageReaction.standard_set(
+				did_delete = deleted_count >= spam_count,
+				message_count = spam_count,
+				did_kick = context.is_kicked,
+				did_ban = context.is_banned))
 		if context.bot_message is None:
 			await self.post_message(message)
 			context.bot_message = message
 			await message.delete()
 			context.deleted_messages.add(message)
 		await self.__update_from_context(context)
+		self.log(context.member.guild, f'Mod deleted messages from {context.member.name} ({context.member.id})')
 
 	async def __kick(self, context: SpamContext) -> None:
 		await context.member.kick(reason='Posting same message repeatedly')
 		context.is_kicked = True
 		await self.__update_from_context(context)
+		self.log(context.member.guild, f'Mod kicked user {context.member.name} ({context.member.id})')
 
 	async def __ban(self, context: SpamContext) -> None:
 		await context.member.ban(reason='Posting same message repeatedly', delete_message_days=1)
 		context.is_kicked = True
 		context.is_banned = True
 		await self.__update_from_context(context)
+		self.log(context.member.guild, f'Mod banned user {context.member.name} ({context.member.id})')
 
 	async def on_mod_react(self,
 			bot_message: BotMessage,
 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message):
-		if message.author is None or message.channel is None or message.guild is None:
+		if message.author is None or \
+				message.author.bot or \
+				message.channel is None or \
+				message.guild is None or \
+				message.content is None or \
+				message.content == '':
 			return
 		await self.__record_message(message)
 

cogs/generalcog.py

 			await self.warn(context.guild,
 				f'Test warning message (requested by {context.author.name})')
 
-	@commands.command()
+	@commands.command(
+		brief='Simple test reply',
+	)
 	async def hello(self, context):
 		await context.message.reply(
 			f'Hey, {context.author.name}!',
 		 	mention_author=False)
+
+	@commands.command(
+		brief='Shuts down the bot (admin only)',
+	)
+	@commands.has_permissions(administrator=True)
+	@commands.guild_only()
+	async def shutdown(self, context):
+		await self.bot.close()

cogs/joinraidcog.py

 			if self.phase == RaidPhase.NONE:
 				self.phase = RaidPhase.JUST_STARTED
 				self.raid_start_time = now
-				print('\u0007Join raid started!')
 			elif self.phase == RaidPhase.JUST_STARTED:
 				self.phase = RaidPhase.CONTINUING
-				print(f'\u0007Join raid up to {recent_count} people')
 		elif self.phase == self.phase in (RaidPhase.JUST_STARTED, RaidPhase.CONTINUING):
 			self.phase = RaidPhase.ENDED
-			print('Previous join raid ended')
 
 		# Undo join add if the raid is over
 		if self.phase == RaidPhase.ENDED and len(self.joins) > 0:
 		who were newly kicked.
 		"""
 		kicks = []
+		guild = None
 		for join in self.joins:
+			guild = join.member.guild
 			if join.is_kicked or join.is_banned:
 				continue
 			await join.member.kick(reason=reason)
 			kicks.append(join.member)
 		self.phase = RaidPhase.ENDED
 		if len(kicks) > 0:
-			print(f'Kicked {len(kicks)} people')
+			self.log(guild, f'Mod kicked {len(kicks)} people')
 		return kicks
 
 	async def ban_all(self,
 		still be banned. Returns a List of Members who were newly banned.
 		"""
 		bans = []
+		guild = None
 		for join in self.joins:
+			guild = join.member.guild
 			if join.is_banned:
 				continue
 			await join.member.ban(
 			bans.append(join.member)
 		self.phase = RaidPhase.ENDED
 		if len(bans) > 0:
-			print(f'Banned {len(bans)} people')
+			self.log(guild, f'Mod banned {len(bans)} people')
 		return bans
 
 class GuildContext:
 			await raid.warning_message.add_reaction(CONFIG['kick_emoji'])
 		if can_ban:
 			await raid.warning_message.add_reaction(CONFIG['ban_emoji'])
+		self.log(guild, f'New join raid detected!')
 
 	async def __update_raid_warning(self, guild: Guild, raid: JoinRaidRecord) -> None:
 		"""

cogs/patterncog.py

 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message) -> None:
-		if message.guild is None or message.content is None or message.channel is None:
-			return
-		if message.author.id == self.bot.user.id:
-			# Ignore self
+		if message.author is None or \
+				message.author.bot or \
+				message.channel is None or \
+				message.guild is None or \
+				message.content is None or \
+				message.content == '':
 			return
 		if message.author.permissions_in(message.channel).ban_members:
 			# Ignore mods
 		patterns = self.__patterns(message.guild)
 		for pattern in patterns:
 			if pattern.matches(message):
-				msg = None
+				text = None
 				if pattern.action == 'delete':
 					await message.delete()
-					msg = f'Message from {message.author.mention} matched ' + \
+					text = f'Message from {message.author.mention} matched ' + \
 						'banned pattern. Deleted.'
+					self.log(message.guild, 'Message matched pattern. Deleted.')
 				elif pattern.action == 'kick':
 					await message.delete()
 					await message.author.kick(reason='Rocketbot: Message matched banned pattern')
-					msg = f'Message from {message.author.mention} matched ' + \
+					text = f'Message from {message.author.mention} matched ' + \
 						'banned pattern. Message deleted and user kicked.'
+					self.log(message.guild, 'Message matched pattern. Kicked user.')
 				elif pattern.action == 'ban':
 					await message.delete()
 					await message.author.ban(reason='Rocketbot: Message matched banned pattern')
-					msg = f'Message from {message.author.mention} matched ' + \
+					text = f'Message from {message.author.mention} matched ' + \
 						'banned pattern. Message deleted and user banned.'
-				if msg:
+					self.log(message.guild, 'Message matched pattern. Banned user.')
+				if text:
 					m = BotMessage(message.guild,
 						text = msg,
 						type = BotMessage.TYPE_MOD_WARNING)

cogs/urlspamcog.py

-from discord import Guild, Message
+from discord import Guild, Member, Message
 from discord.ext import commands
 import re
 from datetime import timedelta
 
-from cogs.basecog import BaseCog
+from cogs.basecog import BaseCog, BotMessage, BotMessageReaction
 from config import CONFIG
 from storage import Storage
 
+class URLSpamContext:
+	def __init__(self, spam_message: Message):
+		self.spam_message = spam_message
+		self.is_deleted = False
+		self.is_kicked = False
+		self.is_banned = False
+
 class URLSpamCog(BaseCog):
 	CONFIG_KEY_EARLY_URL_TIMEOUT = "urlspam_early_url_timeout"
 	CONFIG_KEY_EARLY_URL_ACTION = "urlspam_early_url_action"
 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message):
-		if message.guild is None or message.channel is None:
-			# DM or something
+		if message.author is None or \
+				message.author.bot or \
+				message.guild is None or \
+				message.channel is None or \
+				message.content is None:
 			return
+
 		action = self.__early_url_action(message.guild)
 		if action == 'nothing':
 			return
-		if message.author.permissions_in(message.channel).ban_members:
-			# Mods are exempt
-			return
 		if not self.__contains_url(message.content):
 			return
 		join_age = message.created_at - message.author.joined_at
 		join_age_str = self.__format_timedelta(join_age)
 		if join_age.total_seconds() < self.__early_url_timeout(message.guild):
 			if action == 'modwarn':
-				await self.warn(message.guild, f'User {message.author.mention} ' +
-					f'posted a URL {join_age_str} after joining.\n\n> {message.content}')
-				# TODO: Emoji actions
+				bm = BotMessage(
+					message.guild,
+					f'User {message.author.mention} posted a URL ' + \
+					f'{join_age_str} after joining.',
+					type = BotMessage.TYPE_MOD_WARNING,
+					context = URLSpamContext(message))
+				bm.quote = message.content
+				await bm.add_reaction(BotMessageReaction(CONFIG['trash_emoji'], True, 'Delete message'))
+				await bm.add_reaction(BotMessageReaction(CONFIG['kick_emoji'], True, 'Kick user'))
+				await bm.add_reaction(BotMessageReaction(CONFIG['ban_emoji'], True, 'Ban user'))
+				await self.post_message(bm)
+				self.log(message.guild, f'New user {message.author.name} ' + \
+					f'({message.author.id}) posted URL. Mods alerted.')
 			elif action == 'delete':
 				await message.delete()
-				# TODO: Info to mods
+				bm = BotMessage(
+					message.guild,
+					f'User {message.author.mention} posted a URL ' + \
+					f'{join_age_str} after joining. Message deleted.',
+					type = BotMessage.TYPE_INFO,
+					context = URLSpamContext(message))
+				bm.quote = message.content
+				await bm.add_reaction(BotMessageReaction(CONFIG['kick_emoji'], True, 'Kick user'))
+				await bm.add_reaction(BotMessageReaction(CONFIG['ban_emoji'], True, 'Ban user'))
+				await self.post_message(bm)
+				self.log(message.guild, f'New user {message.author.name} ' + \
+					f'({message.author.id}) posted URL. Message deleted.')
 			elif action == 'kick':
-				await message.author.kick(reason=f'User posted a link {join_age_str} after joining')
-				# TODO: Info to mods
+				await message.author.kick(reason='User posted a link ' + \
+					f'{join_age_str} after joining')
+				bm = BotMessage(
+					message.guild,
+					f'User {message.author.mention} posted a URL ' + \
+					f'{join_age_str} after joining. Kicked by bot.',
+					type = BotMessage.TYPE_INFO,
+					context = URLSpamContext(message))
+				bm.quote = message.content
+				await bm.add_reaction(BotMessageReaction(CONFIG['ban_emoji'], True, 'Ban user'))
+				await self.post_message(bm)
+				self.log(message.guild, f'New user {message.author.name} ' + \
+					f'({message.author.id}) posted URL. User kicked.')
 			elif action == 'ban':
-				await message.author.ban(reason=f'User posted a link {join_age_str} after joining', delete_message_days=1)
-				# TODO: Info to mods
+				await message.author.ban(reason='User posted a link ' + \
+					f'{join_age_str} after joining', delete_message_days=1)
+				bm = BotMessage(
+					message.guild,
+					f'User {message.author.mention} posted a URL ' + \
+					f'{join_age_str} after joining. Banned by bot.',
+					type = BotMessage.TYPE_INFO,
+					context = URLSpamContext(message))
+				bm.quote = message.content
+				await self.post_message(bm)
+				self.log(message.guild, f'New user {message.author.name} ' + \
+					f'({message.author.id}) posted URL. User banned.')
+
+	async def on_mod_react(self,
+			bot_message: BotMessage,
+			reaction: BotMessageReaction,
+			reacted_by: Member) -> None:
+		context: URLSpamContext = bot_message.context
+		if context is None:
+			return
+		sm: Message = context.spam_message
+		if reaction.emoji == CONFIG['trash_emoji']:
+			if not context.is_deleted:
+				await sm.delete()
+				context.is_deleted = True
+				self.log(sm.guild, f'URL spam by {sm.author.name} deleted by {reacted_by.name}')
+		elif reaction.emoji == CONFIG['kick_emoji']:
+			if not context.is_deleted:
+				await sm.delete()
+				context.is_deleted = True
+			if not context.is_kicked:
+				await sm.author.kick(reason=f'Rocketbot: Kicked for URL spam by {reacted_by.name}')
+				context.is_kicked = True
+				self.log(sm.guild, f'URL spammer {sm.author.name} kicked by {reacted_by.name}')
+		elif reaction.emoji == CONFIG['ban_emoji']:
+			if not context.is_banned:
+				await sm.author.ban(reason=f'Rocketbot: Banned for URL spam by {reacted_by.name}', delete_message_days=1)
+				context.is_deleted = True
+				context.is_kicked = True
+				context.is_banned = True
+				self.log(sm.guild, f'URL spammer {sm.author.name} banned by {reacted_by.name}')
+		else:
+			return
+		await bot_message.set_reactions(BotMessageReaction.standard_set(
+			did_delete=context.is_deleted,
+			did_kick=context.is_kicked,
+			did_ban=context.is_banned))
 
 	def __contains_url(self, text: str) -> bool:
 		p = re.compile(r'http(?:s)?://[^\s]+')

rocketbot.py

 from cogs.generalcog import GeneralCog
 from cogs.joinraidcog import JoinRaidCog
 from cogs.patterncog import PatternCog
-# from cogs.urlspamcog import URLSpamCog
+from cogs.urlspamcog import URLSpamCog
 
 CURRENT_CONFIG_VERSION = 1
 if (CONFIG.get('__config_version') or 0) < CURRENT_CONFIG_VERSION:
 bot.add_cog(JoinRaidCog(bot))
 bot.add_cog(CrossPostCog(bot))
 bot.add_cog(PatternCog(bot))
-# bot.add_cog(URLSpamCog(bot))
+bot.add_cog(URLSpamCog(bot))
 bot.run(CONFIG['client_token'], bot=True, reconnect=True)
 print('\nBot aborted')