Merge pull request #106 from typescript-community/empty-ongoing

Put channels into dormant after 5 minutes if ongoing channel becomes empty

Author: robertt

.env.example

@@ -22,7 +22,7 @@ ASK_COOLDOWN_ROLE=
 
 CHANNEL_NAMES=list,help,channel,names,here,seperated,by,commas
 
-# In seconds
+# Following variables are in milliseconds
 DORMANT_CHANNEL_TIMEOUT=
-# In milliseconds
 DORMANT_CHANNEL_LOOP=
+ONGOING_EMPTY_TIMEOUT=

src/env.ts

@@ -28,9 +28,13 @@ export const trustedRoleId = process.env.TRUSTED_ROLE_ID!;
 export const askHelpChannelId = process.env.ASK_HELP_CHANNEL!;
 
 export const channelNames = process.env.CHANNEL_NAMES!.split(',');
+
 export const dormantChannelTimeout = parseInt(
 	process.env.DORMANT_CHANNEL_TIMEOUT!,
 );
 export const dormantChannelLoop = parseInt(process.env.DORMANT_CHANNEL_LOOP!);
+
+export const ongoingEmptyTimeout = parseInt(process.env.ONGOING_EMPTY_TIMEOUT!);
+
 export const TS_BLUE = '#007ACC';
 export const GREEN = '#77b155';

src/modules/helpchan.ts

@@ -23,6 +23,7 @@ import {
 	dormantChannelTimeout,
 	dormantChannelLoop,
 	askHelpChannelId,
+	ongoingEmptyTimeout,
 } from '../env';
 import { isTrustedMember } from '../util/inhibitors';
 
@@ -66,6 +67,7 @@ export class HelpChanModule extends Module {
 		.setDescription(DORMANT_MESSAGE);
 
 	busyChannels: Set<string> = new Set(); // a lock to eliminate race conditions
+	ongoingEmptyTimeouts: Map<string, NodeJS.Timeout> = new Map(); // a lock used to prevent multiple timeouts running on the same channel
 
 	private getChannelName(guild: Guild) {
 		const takenChannelNames = guild.channels.cache
@@ -81,13 +83,67 @@ export class HelpChanModule extends Module {
 		return `${this.CHANNEL_PREFIX}${decidedChannel}`;
 	}
 
+	private getOngoingChannels() {
+		return this.client.channels.cache
+			.filter(
+				channel =>
+					(channel as TextChannel).parentID === categories.ongoing,
+			)
+			.array() as TextChannel[];
+	}
+
 	@listener({ event: 'ready' })
 	async startDormantLoop() {
 		setInterval(() => {
 			this.checkDormantPossibilities();
 		}, dormantChannelLoop);
 	}
 
+	@listener({ event: 'ready' })
+	async initialCheckEmptyOngoing() {
+		for (const channel of this.getOngoingChannels()) {
+			if (await this.checkEmptyOngoing(channel)) {
+				await this.startEmptyTimeout(channel);
+			}
+		}
+	}
+
+	// Utility function used to check if there are no messages in an ongoing channel, meaning the bot
+	// is the most recent message. This will be caused if somebody deletes their message after they
+	// claim a channel.
+	async checkEmptyOngoing(channel: TextChannel) {
+		const messages = await channel.messages.fetch();
+
+		return messages.first()?.author.id === this.client.user?.id;
+	}
+
+	async startEmptyTimeout(channel: TextChannel) {
+		const existingTimeout = this.ongoingEmptyTimeouts.get(channel.id);
+		if (existingTimeout) clearTimeout(existingTimeout);
+
+		const timeout = setTimeout(async () => {
+			this.ongoingEmptyTimeouts.delete(channel.id);
+
+			if (await this.checkEmptyOngoing(channel)) {
+				await this.markChannelAsDormant(channel);
+			}
+		}, ongoingEmptyTimeout);
+
+		this.ongoingEmptyTimeouts.set(channel.id, timeout);
+	}
+
+	@listener({ event: 'messageDelete' })
+	async onMessageDeleted(msg: Message) {
+		if (
+			msg.channel.type !== 'text' ||
+			!msg.channel.parentID ||
+			msg.channel.parentID !== categories.ongoing
+		)
+			return;
+
+		await this.startEmptyTimeout(msg.channel);
+	}
+
 	async moveChannel(channel: TextChannel, category: string) {
 		const parent = channel.guild.channels.resolve(category);
 		if (parent == null) return;
@@ -248,20 +304,14 @@ export class HelpChanModule extends Module {
 	}
 
 	private async checkDormantPossibilities() {
-		const ongoingChannels = this.client.channels.cache.filter(channel => {
-			if (channel.type === 'dm') return false;
-
-			return (channel as TextChannel).parentID === categories.ongoing;
-		});
-
-		for (const channel of ongoingChannels.array()) {
-			const messages = await (channel as TextChannel).messages.fetch();
+		for (const channel of this.getOngoingChannels()) {
+			const messages = await channel.messages.fetch();
 
 			const diff =
-				(Date.now() - messages.array()[0].createdAt.getTime()) / 1000;
+				Date.now() - (messages.first()?.createdAt.getTime() ?? 0);
 
 			if (diff > dormantChannelTimeout)
-				await this.markChannelAsDormant(channel as TextChannel);
+				await this.markChannelAsDormant(channel);
 		}
 	}