Adding username pattern cog

bot.py

 from rocketbot.cogs.joinraidcog import JoinRaidCog
 from rocketbot.cogs.patterncog import PatternCog
 from rocketbot.cogs.urlspamcog import URLSpamCog
+from rocketbot.cogs.usernamecog import UsernamePatternCog
 
 CURRENT_CONFIG_VERSION = 3
 if (CONFIG.get('__config_version') or 0) < CURRENT_CONFIG_VERSION:
 bot.add_cog(JoinRaidCog(bot))
 bot.add_cog(PatternCog(bot))
 bot.add_cog(URLSpamCog(bot))
+bot.add_cog(UsernamePatternCog(bot))
 
 bot.run(CONFIG['client_token'], bot=True, reconnect=True)
 print('\nBot aborted')

config.py.sample

 	'failure_emoji': '❌',
 	'warning_emoji': '⚠️',
 	'info_emoji': 'ℹ️',
+	'ignore_emoji': '👍',
 	'config_path': 'config/',
 	'cog_defaults': {
 		'CrossPostCog': {

rocketbot/cogs/usernamecog.py

+"""
+Cog for detecting username patterns.
+"""
+from discord import Guild, Member
+from discord.ext import commands
+
+from config import CONFIG
+from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
+from rocketbot.storage import Storage
+
+class UsernamePatternContext:
+	"""
+	BotMessage context for a flagged username
+	"""
+	def __init__(self, member: Member) -> None:
+		self.member: Member = member
+		self.kicked_by: Member = None
+		self.banned_by: Member = None
+		self.ignored_by: Member = None
+
+	def reactions(self) -> list[BotMessageReaction]:
+		"""
+		Generates updated BotMessageReactions based on context state.
+		"""
+		r: list[BotMessageReaction] = []
+		if self.ignored_by:
+			r.append(BotMessageReaction(CONFIG['ignore_emoji'], False, f'Ignored by {self.ignored_by.name}'))
+		elif self.banned_by:
+			r.append(BotMessageReaction(CONFIG['ban_emoji'], False, f'Banned by {self.banned_by.name}'))
+		elif self.kicked_by:
+			r.append(BotMessageReaction(CONFIG['kick_emoji'], False, f'Kicked by {self.kicked_by.name}'))
+			r.append(BotMessageReaction(CONFIG['ban_emoji'], True, 'Ban user'))
+		else:
+			r.append(BotMessageReaction(CONFIG['kick_emoji'], True, 'Kick user'))
+			r.append(BotMessageReaction(CONFIG['ban_emoji'], True, 'Ban user'))
+			r.append(BotMessageReaction(CONFIG['ignore_emoji'], True, 'Ignore warning'))
+		return r
+
+class UsernamePatternCog(BaseCog, name='Username Pattern'):
+	"""
+	Detects usernames that match certain flagged patterns. Posts a mod warning
+	message on a match.
+	"""
+
+	SETTING_ENABLED = CogSetting('enabled', bool,
+			brief='username pattern detection',
+			description='Whether new users are checked for common patterns.')
+
+	SETTING_PATTERNS = CogSetting('patterns', None)
+
+	def __init__(self, bot):
+		super().__init__(bot)
+		self.add_setting(UsernamePatternCog.SETTING_ENABLED)
+
+	def __get_patterns(self, guild: Guild) -> list[str]:
+		"""
+		Returns an array of username patterns.
+		"""
+		patterns: list[str] = self.get_guild_setting(guild, self.SETTING_PATTERNS)
+		if patterns is None:
+			patterns = []
+			Storage.set_config_value(guild, 'UsernamePatternCog.patterns', patterns)
+		return patterns
+
+	@classmethod
+	def __save_patterns(cls,
+			guild: Guild,
+			patterns: list[str]) -> None:
+		"""
+		Saves username pattern array.
+		"""
+		cls.set_guild_setting(guild, cls.SETTING_PATTERNS, patterns)
+
+	@commands.group(
+		brief='Manages username pattern detection'
+	)
+	@commands.has_permissions(ban_members=True)
+	@commands.guild_only()
+	async def username(self, context: commands.Context):
+		'Username pattern command group'
+		if context.invoked_subcommand is None:
+			await context.send_help()
+
+	@username.command(
+		brief='Adds a username pattern',
+		description='Adds a username pattern.',
+		usage='<pattern>'
+	)
+	async def add(self, context: commands.Context, pattern: str) -> None:
+		'Command handler'
+		norm_pattern = pattern.lower()
+		patterns: list[str] = self.__get_patterns(context.guild)
+		if norm_pattern in patterns:
+			await context.reply(f'Pattern `{norm_pattern}` already added.', mention_author=False)
+			return
+		patterns.append(norm_pattern)
+		self.__save_patterns(context.guild, patterns)
+		await context.reply(f'Pattern `{norm_pattern}` added.', mention_author=False)
+
+	@username.command(
+		brief='Removes a username pattern',
+		description='Removes an existing username pattern',
+		usage='<pattern>'
+	)
+	async def remove(self, context: commands.Context, pattern: str) -> None:
+		'Command handler'
+		norm_pattern = pattern.lower()
+		guild: Guild = context.guild
+		patterns: list[str] = self.__get_patterns(guild)
+		len_before = len(patterns)
+		patterns = list(filter(lambda p: p != norm_pattern, patterns))
+		if len(patterns) == len_before:
+			await context.reply(f'Pattern `{norm_pattern}` not found.', mention_author=False)
+			return
+		self.__save_patterns(guild, patterns)
+		await context.reply(f'Pattern `{norm_pattern}` removed.', mention_author=False)
+
+	@username.command(
+		brief='Lists username patterns'
+	)
+	async def list(self, context: commands.Context) -> None:
+		'Command handler'
+		guild: Guild = context.guild
+		patterns: list[str] = self.__get_patterns(guild)
+		if len(patterns) == 0:
+			await context.reply('No patterns defined', mention_author=False)
+		else:
+			msg = 'Patterns:\n\n> `' + '`\n> `'.join(patterns) + '`'
+			await context.reply(msg, mention_author=False)
+
+	@commands.Cog.listener()
+	async def on_member_join(self, member: Member) -> None:
+		'Event handler'
+		for pattern in self.__get_patterns(member.guild):
+			if self.matches(pattern, member.name):
+				await self.handle_match(member, pattern)
+			elif self.matches(pattern, member.display_name):
+				await self.handle_match(member, pattern)
+
+	def matches(self, pattern: str, subject: str) -> bool:
+		'Checks if a username matches a given pattern'
+		if pattern is None:
+			return False
+		if subject is None:
+			return False
+		return pattern.lower() in subject.lower()
+
+	async def handle_match(self, member: Member, pattern: str) -> None:
+		"""
+		Handles a username match.
+		"""
+		# TODO: Prevent double handling?
+		self.log(member.guild, f'User {member.id} {member.display_name} matches pattern "{pattern}"')
+		context = UsernamePatternContext(member)
+		bm = BotMessage(
+			member.guild,
+			f'User {member.mention} ({str(member.id)}, {member.display_name}) has ' +
+			f'username matching pattern `{pattern}`.',
+			BotMessage.TYPE_MOD_WARNING,
+			context)
+		await bm.set_reactions(context.reactions())
+		await self.post_message(bm)
+
+	async def on_mod_react(self,
+			bot_message: BotMessage,
+			reaction: BotMessageReaction,
+			reacted_by: Member) -> None:
+		context: UsernamePatternContext = bot_message.context
+		if reaction.emoji == CONFIG['kick_emoji']:
+			await context.member.kick(
+				reason=f'Rocketbot: Flagged username pattern. Kicked by {reacted_by.name}.')
+			context.kicked_by = reacted_by
+			self.log(context.member.guild, f'User {context.member.name} kicked by {reacted_by.name}')
+			await bot_message.set_reactions(context.reactions())
+		elif reaction.emoji == CONFIG['ban_emoji']:
+			await context.member.ban(
+				reason=f'Rocketbot: Flagged username pattern. Banned by {reacted_by.name}.',
+				delete_message_days=0)
+			context.banned_by = reacted_by
+			self.log(context.member.guild, f'User {context.member.name} banned by {reacted_by.name}')
+			await bot_message.set_reactions(context.reactions())
+		elif reaction.emoji == CONFIG['ignore_emoji']:
+			context.ignored_by = reacted_by
+			self.log(context.member.guild, f'Warning ignored by {reacted_by.name}')
+			await bot_message.set_reactions(context.reactions())