Add a verification system

config/main.yml

@@ -114,3 +114,10 @@ versionFeeds:
       - released
       - unreleased
       - renamed
+
+verification:
+  verificationTicket: '' # Add a Mojira ticket ID here!
+  pendingVerificationChannel: '' # Add a pending channel here!
+  verificationLogChannel: '' # Add a log channel here!
+  verifiedRole: '' # Add a role here!
+  verificationInvalidationTime: 900000

config/template.yml

@@ -222,3 +222,20 @@ versionFeeds:
 
   - <see above>
   - ...
+
+# Settings for user verification on Jira.
+verification:
+  # The ticket ID in which users can leave a special token on to verify and link their Discord and Jira accounts.
+  verificationTicket: <string>
+
+  # The channel that holds the pending verification request information.
+  pendingVerificationChannel: <string>
+
+  # The channel that holds the linked account information after accounts have been linked.
+  verificationLogChannel: <string>
+
+  # The role that is given to verified users.
+  verifiedRole: <string>
+
+  # The amount of time that a verification request can remain open until it expires, in milliseconds.
+  verificationInvalidationTime: <number>

src/BotConfig.ts

@@ -61,6 +61,22 @@ export class RequestConfig {
 	}
 }
 
+export class VerificationConfig {
+	public verificationTicket: string;
+	public pendingVerificationChannel: string;
+	public verificationLogChannel: string;
+	public verifiedRole: string;
+	public verificationInvalidationTime: number;
+
+	constructor() {
+		this.verificationTicket = config.get( 'verification.verificationTicket' );
+		this.pendingVerificationChannel = config.get( 'verification.pendingVerificationChannel' );
+		this.verificationLogChannel = config.get( 'verification.verificationLogChannel' )
+		this.verifiedRole = config.get( 'verification.verifiedRole' )
+		this.verificationInvalidationTime = config.get( 'verification.verificationInvalidationTime' )
+	}
+}
+
 export interface RoleConfig {
 	emoji: string;
 	title: string;
@@ -121,6 +137,8 @@ export default class BotConfig {
 
 	public static request: RequestConfig;
 
+	public static verification: VerificationConfig;
+
 	public static roleGroups: RoleGroupConfig[];
 
 	public static filterFeeds: FilterFeedConfig[];
@@ -144,6 +162,8 @@ export default class BotConfig {
 
 		this.maxSearchResults = config.get( 'maxSearchResults' );
 
+		this.verification = new VerificationConfig();
+
 		this.projects = config.get( 'projects' );
 
 		this.request = new RequestConfig();

src/MojiraBot.ts

@@ -86,6 +86,30 @@ export default class MojiraBot {
 			const requestChannels: TextChannel[] = [];
 			const internalChannels = new Map<string, string>();
 
+			if ( BotConfig.verification.pendingVerificationChannel ) {
+				const pendingChannel = await DiscordUtil.getChannel( BotConfig.verification.pendingVerificationChannel );
+				if ( pendingChannel instanceof TextChannel ) {
+					// https://stackoverflow.com/questions/55153125/fetch-more-than-100-messages
+					const allMessages: Message[] = [];
+					let lastId: string | undefined;
+					let continueSearch = true;
+
+					while ( continueSearch ) {
+						const options: ChannelLogsQueryOptions = { limit: 50 };
+						if ( lastId ) {
+							options.before = lastId;
+						}
+						const messages = await pendingChannel.messages.fetch( options );
+						allMessages.push( ...messages.array() );
+						lastId = messages.last()?.id;
+						if ( messages.size !== 50 || !lastId ) {
+							continueSearch = false;
+						}
+					}
+					this.logger.info( `Fetched ${ allMessages.length } messages from "${ pendingChannel.name }"` );
+				}
+			}
+
 			if ( BotConfig.request.channels ) {
 				for ( let i = 0; i < BotConfig.request.channels.length; i++ ) {
 					const requestChannelId = BotConfig.request.channels[i];

src/commands/CommandRegistry.ts

@@ -8,6 +8,8 @@ import SendCommand from './SendCommand';
 import SearchCommand from './SearchCommand';
 import ShutdownCommand from './ShutdownCommand';
 import TipsCommand from './TipsCommand';
+import VerifyCommand from './VerifyCommand';
+import WhoisCommand from './WhoisCommand';
 
 export default class CommandRegistry {
 	public static BUG_COMMAND = new BugCommand();
@@ -20,4 +22,6 @@ export default class CommandRegistry {
 	public static SEARCH_COMMAND = new SearchCommand();
 	public static SHUTDOWN_COMMAND = new ShutdownCommand();
 	public static TIPS_COMMAND = new TipsCommand();
+	public static VERIFY_COMMAND = new VerifyCommand();
+	public static WHOIS_COMMAND = new WhoisCommand();
 }

src/commands/VerifyCommand.ts

@@ -0,0 +1,101 @@
+import { Message, MessageEmbed, TextChannel } from 'discord.js';
+import PrefixCommand from './PrefixCommand';
+import BotConfig from '../BotConfig';
+import Command from './Command';
+import DiscordUtil from '../util/DiscordUtil';
+import TaskScheduler from '../tasks/TaskScheduler';
+import RemovePendingVerificationTask from '../tasks/RemovePendingVerificationTask';
+
+export default class VerifyCommand extends PrefixCommand {
+	public readonly aliases = ['verify'];
+
+	public async run( message: Message, args: string ): Promise<boolean> {
+		if ( args.length ) {
+			return false;
+		}
+
+		const pendingChannel = await DiscordUtil.getChannel( BotConfig.verification.pendingVerificationChannel );
+
+		if ( pendingChannel instanceof TextChannel ) {
+
+			let foundUser = false;
+
+			const allMessages = pendingChannel.messages.cache;
+
+			allMessages.forEach( async thisMessage => {
+				if ( thisMessage.embeds === undefined ) return undefined;
+				if ( thisMessage.embeds[0].fields[0].value.replace( /[<>@!]/g, '' ) == message.author.id ) {
+					foundUser = true;
+				}
+			} );
+
+			try {
+				const role = await pendingChannel.guild.roles.fetch( BotConfig.verification.verifiedRole );
+				const targetUser = await message.guild.members.fetch( message.author.id );
+
+				if ( targetUser.roles.cache.has( role.id ) ) {
+					await message.channel.send( `${ message.author }, your account has already been verified!` );
+					await message.react( '❌' );
+					return false;
+				}
+			} catch ( error ) {
+				Command.logger.error( error );
+			}
+
+			if ( foundUser ) {
+				await message.channel.send( `${ message.author }, you already have a pending verification request!` );
+				await message.react( '❌' );
+				return false;
+			}
+
+		}
+
+		try {
+			const token = this.randomString( 15, '23456789abcdeghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ' );
+
+			const userEmbed = new MessageEmbed()
+				.setDescription( `In order to verify, please comment the following token on the ticket [${ BotConfig.verification.verificationTicket }](https://bugs.mojang.com/browse/${ BotConfig.verification.verificationTicket }) using your Jira account. Make sure you only have added one comment to the ticket!\nAfter you are done, please send \`link <jira-username>\` here and I will verify the account!\n\nToken: **${ token }**` );
+
+			await message.author.send( userEmbed );
+
+			if ( pendingChannel instanceof TextChannel ) {
+
+				const pendingEmbed = new MessageEmbed()
+					.setColor( 'YELLOW' )
+					.setAuthor( message.author.tag, message.author.avatarURL() )
+					.addField( 'User', message.author, true )
+					.addField( 'Token', token, true )
+					.setTimestamp( new Date() );
+
+				const internalEmbed = await pendingChannel.send( pendingEmbed );
+
+				try {
+					TaskScheduler.addOneTimeMessageTask(
+						internalEmbed,
+						new RemovePendingVerificationTask(),
+						BotConfig.verification.verificationInvalidationTime
+					);
+				} catch ( error ) {
+					Command.logger.error( error );
+				}
+			}
+
+			await message.react( '✅' );
+
+		} catch ( error ) {
+			Command.logger.error( error );
+		}
+		return true;
+	}
+
+	// https://stackoverflow.com/questions/10726909/random-alpha-numeric-string-in-javascript
+	private randomString( length: number, chars: string ): string {
+		let result = '';
+		for ( let i = length; i > 0; --i ) result += chars[Math.floor( Math.random() * chars.length )];
+		return result;
+	}
+
+	public asString(): string {
+		return '!jira verify';
+	}
+}

src/commands/WhoisCommand.ts

@@ -0,0 +1,93 @@
+import { ChannelLogsQueryOptions, Message, MessageEmbed, TextChannel } from 'discord.js';
+import BotConfig from '../BotConfig';
+import DiscordUtil from '../util/DiscordUtil';
+import PrefixCommand from './PrefixCommand';
+import Command from './Command';
+
+export default class WhoisCommand extends PrefixCommand {
+	public readonly aliases = ['who', 'whois'];
+
+	public async run( message: Message, args: string ): Promise<boolean> {
+		if ( !args.length ) {
+			return false;
+		}
+
+		let fromDiscordWhois = false;
+		if ( args.startsWith( '<@' ) ) {
+			fromDiscordWhois = true;
+		}
+
+		if ( message.deletable ) {
+			try {
+				await message.delete();
+			} catch ( error ) {
+				Command.logger.error( error );
+			}
+		} else {
+			Command.logger.log( 'Message not deletable' );
+		}
+
+
+		const logChannel = await DiscordUtil.getChannel( BotConfig.verification.verificationLogChannel );
+		const allMessages: Message[] = [];
+		let lastId: string | undefined;
+		let continueSearch = true;
+
+		try {
+			while ( continueSearch ) {
+				const options: ChannelLogsQueryOptions = { limit: 50 };
+				if ( lastId ) {
+					options.before = lastId;
+				}
+				if ( logChannel instanceof TextChannel ) {
+
+					const messages = await logChannel.messages.fetch( options );
+					allMessages.push( ...messages.array() );
+					lastId = messages.last()?.id;
+					if ( messages.size !== 50 || !lastId ) {
+						continueSearch = false;
+
+						for ( let i = 0; i < allMessages.length; i++ ) {
+							const content = allMessages[i].embeds;
+							if ( content === undefined ) continue;
+
+							const discordId = content[0].fields[0].value;
+							const discordMember = await DiscordUtil.getMember( logChannel.guild, discordId.replace( /[<>!@]/g, '' ) );
+							const mojiraMember = content[0].fields[1].value;
+
+							if ( fromDiscordWhois ) {
+								if ( discordId.replace( /[<>!@]/g, '' ) != args.replace( /[<>!@]/g, '' ) ) continue;
+
+								const embed = new MessageEmbed()
+									.setTitle( 'User information' )
+									.setDescription( `${ discordMember.user }'s Mojira account is ${ mojiraMember } ` )
+									.setFooter( message.author.tag, message.author.avatarURL() );
+								await message.channel.send( embed );
+
+								return true;
+							} else {
+								if ( mojiraMember.split( '?name=' )[1].split( ')' )[0] != args ) continue;
+
+								const embed = new MessageEmbed()
+									.setTitle( 'User information' )
+									.setDescription( `${ mojiraMember }'s Discord account is ${ discordId }` )
+									.setFooter( message.author.tag, message.author.avatarURL() );
+								await message.channel.send( embed );
+
+								return true;
+							}
+						}
+						await message.channel.send( `${ args } has not been verified!` );
+					}
+				}
+			}
+		} catch {
+			return false;
+		}
+		return true;
+	}
+
+	public asString( args: string ): string {
+		return `!jira whois ${ args }`;
+	}
+}

src/events/message/MessageEventHandler.ts

@@ -1,11 +1,12 @@
-import { Message } from 'discord.js';
+import { DMChannel, Message } from 'discord.js';
 import BotConfig from '../../BotConfig';
 import CommandExecutor from '../../commands/CommandExecutor';
 import DiscordUtil from '../../util/DiscordUtil';
 import EventHandler from '../EventHandler';
 import RequestEventHandler from '../request/RequestEventHandler';
 import TestingRequestEventHandler from '../request/TestingRequestEventHandler';
 import InternalProgressEventHandler from '../internal/InternalProgressEventHandler';
+import VerificationMessageEventHandler from '../verification/VerificationMessageEventHandler';
 
 export default class MessageEventHandler implements EventHandler<'message'> {
 	public readonly eventName = 'message';
@@ -15,13 +16,15 @@ export default class MessageEventHandler implements EventHandler<'message'> {
 	private readonly requestEventHandler: RequestEventHandler;
 	private readonly testingRequestEventHandler: TestingRequestEventHandler;
 	private readonly internalProgressEventHandler: InternalProgressEventHandler;
+	private readonly verificationMessageEventHandler: VerificationMessageEventHandler;
 
 	constructor( botUserId: string, internalChannels: Map<string, string> ) {
 		this.botUserId = botUserId;
 
 		this.requestEventHandler = new RequestEventHandler( internalChannels );
 		this.testingRequestEventHandler = new TestingRequestEventHandler();
 		this.internalProgressEventHandler = new InternalProgressEventHandler();
+		this.verificationMessageEventHandler = new VerificationMessageEventHandler();
 	}
 
 	// This syntax is used to ensure that `this` refers to the `MessageEventHandler` object
@@ -56,6 +59,11 @@ export default class MessageEventHandler implements EventHandler<'message'> {
 			await this.internalProgressEventHandler.onEvent( message );
 
 			// Don't reply in internal request channels
+			return;
+		} else if ( message.channel.type === "dm" ) {
+			// This message is a direct message
+			await this.verificationMessageEventHandler.onEvent( message );
+
 			return;
 		}