Automate dFunk roles

package.json

@@ -40,6 +40,7 @@
 		"@types/node": "^17.0.45",
 		"@typescript-eslint/eslint-plugin": "^6.7.4",
 		"@typescript-eslint/parser": "^6.7.4",
+		"cron": "^4.3.0",
 		"dotenv": "^16.0.3",
 		"eslint": "^8.24.0",
 		"eslint-config-prettier": "^8.5.0",

src/commands/commands.names.ts

@@ -11,5 +11,7 @@ export enum CommandNames {
 	CLUB = "club",
 	KTHID = "kthid",
 	NOLLEGRUPP = "nollegrupp",
+	DFUNK = "dfunk",
+	KILLMOTTAGNINGEN = "killmottagningen",
 	MOTTAGNINGEN = "mottagningen",
 }

src/commands/commands.ts

@@ -10,6 +10,7 @@ import { translateMsgCommand } from "./translate/translateMsg.command";
 import { clubCommand } from "./club/club.command";
 import { messageCommand } from "./message/message.command";
 import { ContextMenuCommandBuilder, SlashCommandBuilder } from "discord.js";
+import { dfunkCommand } from "./dfunk/dfunk.command";
 import { kthIdCommand } from "./kthid/kthid.command";
 import { mottagningenCommand } from "./mottagningen/mottagningen.command";
 
@@ -30,6 +31,7 @@ export const getOfficialBotCommands = async (): Promise<
 	translateMsgCommand,
 	clubCommand,
 	messageCommand,
+	dfunkCommand,
 	kthIdCommand,
 	nollegruppCommand,
 	mottagningenCommand,

src/commands/dfunk/dfunk-subcommands.ts

@@ -0,0 +1,6 @@
+export enum DfunkSubcommands {
+	UPDATE = "update",
+	TEST = "test",
+	STATUS = "status",
+	TOGGLE = "toggle",
+}

src/commands/dfunk/dfunk.command.ts

@@ -0,0 +1,36 @@
+import { SlashCommandBuilder, PermissionFlagsBits } from "discord.js";
+import { CommandNames } from "../commands.names";
+import { DfunkSubcommands } from "./dfunk-subcommands";
+
+const command = new SlashCommandBuilder()
+	.setName(CommandNames.DFUNK)
+	.setDescription("Command related to the dfunk automatic update.")
+	.setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild);
+
+command.addSubcommand((subCommand) =>
+	subCommand
+		.setName(DfunkSubcommands.UPDATE)
+		.setDescription("Manually start the dfunk role update routine.")
+);
+
+command.addSubcommand((subCommand) =>
+	subCommand
+		.setName(DfunkSubcommands.TEST)
+		.setDescription("Start the dfunk role update test routine.")
+);
+
+command.addSubcommand((subCommand) =>
+	subCommand
+		.setName(DfunkSubcommands.TOGGLE)
+		.setDescription("Toggles the automatic dfunk role update routine.")
+);
+
+command.addSubcommand((subCommand) =>
+	subCommand
+		.setName(DfunkSubcommands.STATUS)
+		.setDescription(
+			"Reveals the current status of the automatic dfunk role update."
+		)
+);
+
+export const dfunkCommand = command;

src/commands/dfunk/dfunk.handler.ts

@@ -0,0 +1,26 @@
+import { CommandNotFoundError } from "../../shared/errors/command-not-founder.error";
+import { GuildChatInputCommandInteraction } from "../../shared/types/GuildChatInputCommandType";
+import { DfunkSubcommands } from "./dfunk-subcommands";
+import { handleDfunkTest } from "./subcommands/test/dfunk-test.handler";
+import { handleDfunkUpdate } from "./subcommands/update/dfunk-update.handler";
+import { handleDfunkToggle } from "./subcommands/toggle/dfunk-toggle.handler";
+import { handleDfunkStatus } from "./subcommands/status/dfunk-status.handler";
+
+export async function handleDfunk(
+	interaction: GuildChatInputCommandInteraction
+): Promise<void> {
+	const subcommandName = interaction.options.getSubcommand(true);
+
+	switch (subcommandName) {
+		case DfunkSubcommands.UPDATE:
+			return await handleDfunkUpdate(interaction);
+		case DfunkSubcommands.TEST:
+			return await handleDfunkTest(interaction);
+		case DfunkSubcommands.STATUS:
+			return await handleDfunkStatus(interaction);
+		case DfunkSubcommands.TOGGLE:
+			return await handleDfunkToggle(interaction);
+		default:
+			throw new CommandNotFoundError(interaction.commandName);
+	}
+}

src/commands/dfunk/subcommands/status/dfunk-status.handler.ts

@@ -0,0 +1,30 @@
+import { MessageFlags } from "discord.js";
+import { jobs } from "../../../../index";
+import { GuildChatInputCommandInteraction } from "../../../../shared/types/GuildChatInputCommandType";
+
+export const handleDfunkStatus = async (
+	interaction: GuildChatInputCommandInteraction
+): Promise<void> => {
+	// We assume that this job is loaded
+	const dfunkUpdateJob = jobs.get("updateDfunkRoles")!;
+	const jobStatus = dfunkUpdateJob.job.isActive;
+	if (jobStatus) {
+		await interaction.reply({
+			content: `The automatic dfunk role update is active.
+            The automatic update was last executed ${
+				dfunkUpdateJob.job.lastExecution
+			}.
+            The next automatic update will be executed ${dfunkUpdateJob.job.nextDate()}
+            To toggle this functionality on/off, use the \`/dfunk toggle\` command.
+            `,
+			flags: MessageFlags.Ephemeral,
+		});
+	} else {
+		await interaction.reply({
+			content: `The automatic dfunk role update is inactive.
+            The automatic update was last executed ${dfunkUpdateJob.job.lastExecution}.
+            To toggle this functionality on/off, use the \`/dfunk toggle\` command.`,
+			flags: MessageFlags.Ephemeral,
+		});
+	}
+};

src/commands/dfunk/subcommands/test/dfunk-test.handler.ts

@@ -0,0 +1,123 @@
+import { testCases } from "../../../../tests/dfunk-roles-update/test_cases";
+import { executeTestCase } from "../../../../tests/dfunk-roles-update/tests";
+import { GuildChatInputCommandInteraction } from "../../../../shared/types/GuildChatInputCommandType";
+import {
+	Role as DiscordRole,
+	Collection,
+	GuildMember as DiscordGuildMember,
+} from "discord.js";
+import {
+	createDfunkDiscordRoles /*removeDfunkDiscordRoles,*/,
+} from "../../../../jobs/update-dfunk-roles";
+import * as log from "../../../../shared/utils/log";
+export const handleDfunkTest = async (
+	interaction: GuildChatInputCommandInteraction
+): Promise<void> => {
+	// Create dfunk roles in case these are missing
+	await createDfunkDiscordRoles(interaction.guild);
+	const failedData: Map<
+		number,
+		{
+			processedDfunkData: {
+				currentGroups: Map<string, string[]>;
+				specialRoles: [
+					{
+						roleName: string;
+						specialRoleLegibles: Set<string>;
+					}
+				];
+			};
+			dbUsers: Map<string, string>;
+			discordData: {
+				guildRoles: Collection<string, DiscordRole>;
+				guildMembers: Collection<string, DiscordGuildMember>;
+			};
+		}
+	> = new Map();
+	for (let index = 0; index < testCases.length; index++) {
+		const testResult = await executeTestCase(
+			interaction.guild,
+			"1013769549398671542",
+			testCases[index],
+			index + 1
+		);
+		if (!testResult.result) {
+			failedData.set(index + 1, {
+				processedDfunkData: testResult.processedDfunkData,
+				dbUsers: testResult.dbUsers,
+				discordData: testResult.discordData,
+			});
+			break;
+		}
+	}
+	log.error("Failed test cases: " + Array.from(failedData.keys()).join(", "));
+	failedData.forEach(
+		(
+			caseData: {
+				processedDfunkData: {
+					currentGroups: Map<string, string[]>;
+					specialRoles: [
+						{
+							roleName: string;
+							specialRoleLegibles: Set<string>;
+						}
+					];
+				};
+				dbUsers: Map<string, string>;
+				discordData: {
+					guildRoles: Collection<string, DiscordRole>;
+					guildMembers: Collection<string, DiscordGuildMember>;
+				};
+			},
+			caseNumber: number
+		) => {
+			log.info("Test case " + caseNumber + ": ");
+			caseData.processedDfunkData.currentGroups.forEach(
+				(users: string[], group: string) => {
+					log.info(
+						"The group " +
+							group +
+							" should have users: " +
+							users.join(", ")
+					);
+				}
+			);
+
+			log.info(
+				"Users fetched from database: " +
+					Array.from(caseData.dbUsers.keys()).join(", ")
+			);
+			log.info("Fetched Discord Data: ");
+			log.info(
+				"Roles fetched:" +
+					caseData.discordData.guildRoles
+						.map((role) => role.name)
+						.join(", ")
+			);
+			caseData.discordData.guildRoles.each((role) =>
+				log.info(
+					"Users having " +
+						role.name +
+						": " +
+						role.members
+							.map((member) => member.displayName)
+							.join(", ")
+				)
+			);
+			log.info(
+				"Users fetched: " +
+					caseData.discordData.guildMembers
+						.map((member) => member.displayName)
+						.join(", ")
+			);
+			caseData.discordData.guildMembers.each((member) =>
+				log.info(
+					"(Cached) Roles of user " +
+						member.displayName +
+						": " +
+						member.roles.cache.map((role) => role.name).join(", ")
+				)
+			);
+		}
+	);
+};

src/commands/dfunk/subcommands/toggle/dfunk-toggle.handler.ts

@@ -0,0 +1,28 @@
+import { GuildChatInputCommandInteraction } from "../../../../shared/types/GuildChatInputCommandType";
+import { jobs } from "../../../../index";
+import { MessageFlags } from "discord.js";
+
+export const handleDfunkToggle = async (
+	interaction: GuildChatInputCommandInteraction
+): Promise<void> => {
+	// We assume that this job is loaded
+	const dfunkUpdateJob = jobs.get("updateDfunkRoles")!;
+	const jobStatus = dfunkUpdateJob.job.isActive;
+	if (jobStatus) {
+		await dfunkUpdateJob.job.stop();
+		await interaction.reply({
+			content: `
+            The automatic dfunk role update has been turned off.
+            Use this same command (\`/dfunk toggle\`) to turn on this functionality.`,
+			flags: MessageFlags.Ephemeral,
+		});
+	} else {
+		await dfunkUpdateJob.job.start();
+		await interaction.reply({
+			content: `The automatic dfunk role update has been turned on.
+            The next automatic update will be executed ${dfunkUpdateJob.job.nextDate()}.
+            Use this same command (\`/dfunk toggle\`) to turn off this functionality.`,
+			flags: MessageFlags.Ephemeral,
+		});
+	}
+};

src/commands/dfunk/subcommands/update/dfunk-update.handler.ts

@@ -0,0 +1,8 @@
+import { updateDiscordDfunkRoles } from "../../../../jobs/update-dfunk-roles";
+import { GuildChatInputCommandInteraction } from "../../../../shared/types/GuildChatInputCommandType";
+
+export const handleDfunkUpdate = async (
+	interaction: GuildChatInputCommandInteraction
+): Promise<void> => {
+	await updateDiscordDfunkRoles(interaction.guild);
+};

src/commands/handle-commands.ts

@@ -20,6 +20,7 @@ import {
 import { handleTranslateMsg } from "./translate/translateMsg.handler";
 import { handleClub } from "./club/club.handler";
 import { handleMessage } from "./message/message.handler";
+import { handleDfunk } from "./dfunk/dfunk.handler";
 import { BaseInteraction, MessageFlags, Interaction } from "discord.js";
 import { handleKthId } from "./kthid/kthid.handler";
 import {
@@ -166,11 +167,14 @@ const handleChatInputCommand = async (
 				case CommandNames.MESSAGE:
 					await handleMessage(guildInteraction);
 					return;
+				case CommandNames.DFUNK:
+					await handleDfunk(guildInteraction);
+					return;
 				case CommandNames.KTHID:
 					await handleKthId(guildInteraction);
 					return;
 				case CommandNames.NOLLEGRUPP:
-					handleNollegrupp(guildInteraction);
+					await handleNollegrupp(guildInteraction);
 					return;
 				case CommandNames.MOTTAGNINGEN:
 					handleMottagningen(guildInteraction);