Putting email and username modes behind flags

rocketbot/cogs/kickstartercog.py

 	is_email_address,
 )
 
-PERMITTED_GUILD_IDS = [
+_PERMITTED_GUILD_IDS = [
 	405011810937339905,
 	900805482825007104,  # test server
 ]
+_EMAIL_MODE = True
+_USERNAME_MODE = False
 class KickstarterCog(BaseCog):
 	"""
 	Provides a way for Discord users to self-identify the email address they
 		Self = KickstarterCog
 		self.set_guild_setting(role.guild, Self.SETTING_ROLE, role.id)
 
+	async def __misconfigured(self, interaction: Interaction):
+		await interaction.response.send_message(f"{CONFIG['failure_emoji']} Feature misconfigured", ephemeral=True)
+
+
 	# -- Member commands -----
 
 	@command(
-		description='Links your Kickstarter email address to your Discord user'
+		description='Grants you access to Kickstarter backer-only areas'
 	)
 	@guild_only()
-	@guilds(PERMITTED_GUILD_IDS)
-	async def link_email(self, interaction: Interaction):
+	@guilds(*_PERMITTED_GUILD_IDS)
+	async def link(self, interaction: Interaction):
+		if _EMAIL_MODE:
+			await self.__link_email_command(interaction)
+		elif _USERNAME_MODE:
+			await self.__link_username_command(interaction)
+		else:
+			await self.__misconfigured(interaction)
+
+	async def __link_email_command(self, interaction: Interaction):
 		# If possible, try to check if they're already a backer before opening
 		# a modal.
 		guild = interaction.guild
 
 		await interaction.response.send_modal(_LinkModal())
 
-	@command(
-		description='Grants you access to Kickstarter backer-only areas'
-	)
-	@guild_only()
-	@guilds(PERMITTED_GUILD_IDS)
-	async def link_username(self, interaction: Interaction):
+	async def __link_username_command(self, interaction: Interaction):
 		await interaction.response.defer(ephemeral=True, thinking=True)
 		try:
 			backer_role = await self.__fetch_backer_role(interaction.guild)
 			'user and removes the backer role.'
 	)
 	@guild_only()
-	@guilds(PERMITTED_GUILD_IDS)
+	@guilds(*_PERMITTED_GUILD_IDS)
 	async def unlink(self, interaction: Interaction):
 		await interaction.response.defer(ephemeral=True, thinking=True)
 		guild = interaction.guild
 			await member.remove_roles(backer_role)
 		self.__delete_member_link(guild.id, member.id)
 		text = f"{CONFIG['success_emoji']} Unlinked as Kickstarter backer. Use " \
-			"`/link` if you change your mind."
+			"`/link` again if you change your mind."
 		await interaction.followup.send(text, ephemeral=True)
 
+
 	# -- Admin commands -----
 
 	kickstarter = Group(
 		name='kickstarter',
 		description='Manages roles for users identified as Kickstarter backers.',
 		guild_only=True,
-		guild_ids=PERMITTED_GUILD_IDS,
+		guild_ids=_PERMITTED_GUILD_IDS,
 		default_permissions=MOD_PERMISSIONS
 	)
 
 	@kickstarter.command(
 		description='Checks the database for users to assign the backer role to.'
 	)
-	async def sync_emails(self, interaction: Interaction):
+	async def sync(self, interaction: Interaction):
+		if _EMAIL_MODE:
+			await self.__sync_emails_command(interaction)
+		elif _USERNAME_MODE:
+			await self.__sync_usernames_command(interaction)
+		else:
+			await self.__misconfigured(interaction)
+
+	async def __sync_emails_command(self, interaction: Interaction):
 		await interaction.response.defer(ephemeral=True, thinking=True)
 		sync_result: _SyncEmailsResult = await self.__sync_by_email(interaction.guild)
 		text = f"{CONFIG['success_emoji']} Sync complete.\n" + \
 			sync_result.summary_markdown()
 		await interaction.followup.send(text, ephemeral=True)
-
-	@kickstarter.command(
-		description='Checks the database for users to assign the backer role to.'
-	)
-	async def sync_usernames(self, interaction: Interaction):
+	
+	async def __sync_usernames_command(self, interaction: Interaction):
 		await interaction.response.defer(ephemeral=True, thinking=True)
 		sync_result: _SyncUsernamesResult = await self.__sync_by_username(interaction.guild)
 		text = f"{CONFIG['success_emoji']} Sync complete.\n" + \
 		await interaction.followup.send(text, ephemeral=True)
 
 	@kickstarter.command(
-		description='DEV TEST - testing timeout'
-	)
-	async def timeout_test(self, interaction: Interaction):
-		await interaction.response.defer(ephemeral=True, thinking=True)
-		await sleep(300)
-		await interaction.followup.send("5m timer done", ephemeral=True)
-
-	@kickstarter.command(
 		description='Shows info about Kickstarter linked Discord members.'
 	)
 	async def info(self, interaction: Interaction):
 			return
 
 		if backer_role in member.roles:
-			text = f"{CONFIG['info_emoji']} Member {member.name} has `{backer_role.name}` role."
+			text = f"{CONFIG['info_emoji']} Member {member.name} has " \
+				f"`{backer_role.name}` role."
 			await interaction.followup.send(text, ephemeral=True)
 			return
 
+		if _USERNAME_MODE:
+			await self.__find_member_username_mode(interaction, member, backer_role)
+		elif _EMAIL_MODE:
+			await self.__find_member_email_mode(interaction, member, backer_role)
+		else:
+			await self.__misconfigured(interaction)
+
+	async def __find_member_username_mode(self, interaction: Interaction, member: Member, backer_role: Role):
+		guild = interaction.guild
 		username_record = self.__fetch_kickstarter_username(username=member.name)
 		if username_record is not None:
 			await member.add_roles(backer_role)
 			username_record.lookup_status = _LookupStatus.member_found
 			self.__update_kickstarter_username(username_record)
-			text = f"{CONFIG['success_emoji']} Member's username found in Kickstarter export. Assigned `{backer_role.name}` role."
+			text = f"{CONFIG['success_emoji']} Member's username found in " \
+				f"Kickstarter export. The `{backer_role.name}` role has now " \
+				"been assigned to them."
 			await interaction.followup.send(text, ephemeral=True)
 			return
+		stats = self.__fetch_stats(guild.id)
+		text = f"{CONFIG['info_emoji']} Member's username is not in the " \
+			f"Kickstarter export. (Last import <t:{stats.username_last_imported_at}:f>)"
+		await interaction.followup.send(text, ephemeral=True)
 
-		# FIXME: Sorta splitting the difference between email and username model here
-
+	async def __find_member_email_mode(self, interaction: Interaction, member: Member, backer_role: Role):
+		guild = interaction.guild
 		member_link = self.__fetch_member_link_by_member_id(guild.id, member.id)
 		if member_link is None:
-			text = f"No record found for member {member.mention}. Possible reasons:\n" \
+			text = f"{CONFIG['info_emoji']} No record found for member " \
+				f"{member.mention}.\n" \
+				"\n" \
+				"Possible reasons:\n" \
 				"- They haven't used the `/link` command yet to provide their " \
 				"Kickstarter email address\n" \
 				"- They linked using a different Discord account. (You can " \
 				"search by email with `/find_email`)\n" \
-				"- They used the `/unlink` after being linked"
+				"- They used the `/unlink` command after being linked"
 			await interaction.followup.send(text, ephemeral=True)
 			return
 
-		text = f"Member {member.mention} successfully used the `/link` command"
-		if backer_role in member.roles:
-			text += f", and they already have the {backer_role.name} Discord role. " \
-				"They should already have access to backer-only areas. If they " \
-				"still can't see them, some possible reasons:\n" \
-				"- Its channel group is collapsed in the channel list.\n" \
-				"- Some channels are hidden. Direct them to the Browse Channels " \
-				"area in the channel list to see if it's listed and checked visible.\n" \
-				"- Their client may need to be refreshed. Have them restart Discord " \
-				"and see if the channel shows up."
+		text = f"{CONFIG['info_emoji']} Member record found for {member.mention}.\n" \
+			"\n" \
+			"- User provided an email address with the `/link` command.\n"
+		is_backer = self.__is_kickstarter_email_hash(interaction.guild.id, member_link.email_hash)
+		if is_backer:
+			await member.add_roles(backer_role)
+			text += "- Provided email is in the Kickstarter backer list but " \
+				f"we hadn't given them the {backer_role.name} role yet.\n" \
+				f"- Member granted {backer_role.name} role just now."
 		else:
-			is_backer = self.__is_kickstarter_email_hash(interaction.guild.id, member_link.email_hash)
-			if is_backer:
-				await member.add_roles(backer_role)
-				text += f", and their email address is in the Kickstarter backer list, " \
-					f"but they didn't have the {backer_role.name} role yet! **This was " \
-					"just now corrected.** Ask them to check again."
-			else:
-				text += ", but we don't have the address they provided in the " \
-					"Kickstarter backer list yet. Have we refreshed it recently?"
+			stats = self.__fetch_stats(guild.id)
+			text += "- Provided email is _not_ in the Kickstarter backer list.\n" \
+				"   - Did they provide the same email as Kickstarter and " \
+				"spell it correctly?\n" \
+				"   - Have we imported addresses recently? Last import on " \
+				f"<t:{stats.email_last_imported_at}:f>."
 		await interaction.followup.send(text, ephemeral=True)
 
 	@kickstarter.command(
 		await interaction.followup.send(text, ephemeral=True)
 
 	@kickstarter.command(
-		description='Uploads an export of Kickstarter backer email addresses.'
+		description='Uploads an export of Kickstarter backers.'
 	)
-	async def upload_emails(self, interaction: Interaction):
+	async def upload(self, interaction: Interaction):
+		if _EMAIL_MODE:
+			await self.__upload_emails_command(interaction)
+		elif _USERNAME_MODE:
+			await self.__upload_usernames_command(interaction)
+		else:
+			await self.__misconfigured(interaction)
+
+	async def __upload_emails_command(self, interaction: Interaction):
 		await interaction.response.send_modal(_UploadEmailsModal())
 
-	@kickstarter.command(
-		description='Uploads an export of backer Discord usernames.'
-	)
-	async def upload_usernames(self, interaction: Interaction):
+	async def __upload_usernames_command(self, interaction: Interaction):
 		await interaction.response.send_modal(_UploadUsernamesModal())
 
 	async def interaction_check(self, interaction: Interaction) -> bool:
 			self.__trace(interaction.guild, f"@{interaction.user.name} used /{interaction.command.qualified_name}")
 		return True
 
+
+	# -- UI callbacks -----
+
 	async def on_email_upload_submit(self, interaction: Interaction, attachment: Attachment):
 		"""Callback for email upload modal."""
 		await interaction.response.defer(ephemeral=True, thinking=True)
 
 		await interaction.followup.send(text, ephemeral=True)
 
+
+	# -- Operations -----
+
 	async def __link_member(self, guild: Guild, member: Member, email: str) -> '_LinkResult':
 		if not is_email_address(email.strip()):
 			return _LinkResult(_LinkResultStatus.malformed_address)