13 starboard

README.md

@@ -174,7 +174,7 @@ ADMINISTRATORS=COMMA,SEPARATED,ID,LIST
 
 ### Invite your bot to your server
 
-Go to https://discordapi.com/permissions.html#378091424832 and paste in your bot's client ID to get an invite link.
+Go to https://discordapi.com/permissions.html#379165174848 and paste in your bot's client ID to get an invite link.
 
 ### Setting up Docker
 

prisma/migrations/20230411151150_reactboard/migration.sql

@@ -0,0 +1,11 @@
+-- CreateTable
+CREATE TABLE "reactboard" (
+    "id" SERIAL NOT NULL,
+    "guildId" TEXT NOT NULL,
+    "channelId" TEXT NOT NULL,
+    "react" TEXT NOT NULL,
+    "isCustomReact" BOOLEAN NOT NULL,
+    "threshold" INTEGER NOT NULL,
+
+    CONSTRAINT "reactboard_pkey" PRIMARY KEY ("id")
+);

prisma/migrations/20230411152017_reactboard_unique_location/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[guildId,channelId]` on the table `reactboard` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- CreateIndex
+CREATE UNIQUE INDEX "reactboard_guildId_channelId_key" ON "reactboard"("guildId", "channelId");

prisma/migrations/20230411182041_reactboard_posts/migration.sql

@@ -0,0 +1,12 @@
+-- CreateTable
+CREATE TABLE "reactboardPost" (
+    "id" SERIAL NOT NULL,
+    "reactboardId" INTEGER NOT NULL,
+    "originalMessageId" TEXT NOT NULL,
+    "reactboardMessageId" TEXT NOT NULL,
+
+    CONSTRAINT "reactboardPost_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "reactboardPost" ADD CONSTRAINT "reactboardPost_reactboardId_fkey" FOREIGN KEY ("reactboardId") REFERENCES "reactboard"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/schema.prisma

@@ -10,6 +10,27 @@ datasource db {
   url      = env("DATABASE_URL")
 }
 
+model reactboard {
+	id Int @id @default(autoincrement())
+	guildId String
+	channelId String
+	react String
+	isCustomReact Boolean
+	threshold Int
+
+	@@unique([guildId, channelId], name: "location")
+
+	reactboardPosts reactboardPost[]
+}
+
+model reactboardPost {
+	id Int @id @default(autoincrement())
+	reactboardId Int
+	reactboard reactboard @relation(fields: [reactboardId], references: [id])
+	originalMessageId String
+	reactboardMessageId String
+}
+
 model Scoreboard {
 	id Int @id @default(autoincrement())
 	userId String
@@ -18,23 +39,6 @@ model Scoreboard {
 	score Float
 }
 
-// All our Models will be defined here
-// Below is an example of what one would look like in our usecase
-// NOTE NOTHING HERE IS FINAL, THIS IS JUST AN EXAMPLE
-// Idk what I am doing
-
-// model Emoteboard {
-//     id        Int      @id @default(autoincrement())
-//     createdAt DateTime @default(now())
-//     author    String
-//     postId    String   @unique
-//     count     Int
-//     emote     Emote    @default(STAR)
-//     channel   String
-//     guild     String
-//     userId    String
-// }
-
 // model Tag {
 // 	id        Int      @id @default(autoincrement())
 // 	createdAt DateTime @default(now())
@@ -49,16 +53,3 @@ model Scoreboard {
 //  starredCount   Int
 //  leaderboards   Leaderboard[]
 // }
-
-// model Leaderboard {
-// 	id         Int      @id @default(autoincrement())
-// 	createdAt  DateTime @default(now())
-//  name       String
-//  users	   User[]
-//  userCounts Int[]
-// }
-
-// enum Emote {
-//     STAR
-//     BASED
-// }

src/@types/ReactionHandler.d.ts

@@ -0,0 +1,12 @@
+import { MessageReaction, PartialMessageReaction, PartialUser, User } from 'discord.js';
+
+declare global {
+	interface ReactionHandler {
+		execute: (context: ReactionHandlerContext) => void | Promise<void>;
+	}
+
+	interface ReactionHandlerContext {
+		reaction: MessageReaction | PartialMessageReaction;
+		user: User | PartialUser;
+	}
+}

src/commands/index.ts

@@ -41,6 +41,7 @@ import { update } from './update';
 import { findRoom } from './findRoom';
 import { stats } from './stats';
 import { emoji } from './emoji';
+import { setReactboard } from './setReactboard';
 
 _add(help);
 _add(xkcd);
@@ -54,3 +55,4 @@ _add(toTheGallows);
 _add(update);
 _add(stats);
 _add(emoji);
+_add(setReactboard);

src/commands/setReactboard.test.ts

@@ -0,0 +1,121 @@
+import type { PrismaClient } from '@prisma/client';
+import { DeepMockProxy, mockDeep } from 'jest-mock-extended';
+import type { TextChannel } from 'discord.js';
+
+jest.mock('../database', () => ({
+	db: mockDeep<PrismaClient>(),
+}));
+
+import { setReactboard } from './setReactboard';
+import { db } from '../database';
+import { UserMessageError } from '../helpers/UserMessageError';
+
+describe('setReactboard', () => {
+	const dbMock = db as unknown as DeepMockProxy<PrismaClient>;
+	/* eslint-disable @typescript-eslint/unbound-method */
+	const mockUpsert = dbMock.reactboard.upsert;
+	/* eslint-enable @typescript-eslint/unbound-method */
+
+	const mockGuildId = 'test-guild-id';
+	const mockChannel = {
+		id: 'test-channel-id',
+	};
+	const mockThreshold = 5;
+	const mockReact = '⭐';
+
+	const mockReplyPrivately = jest.fn();
+	const mockGetString = jest.fn<string | null, [name: string]>();
+	const mockGetInteger = jest.fn<number, [name: string]>();
+	const mockGetChannel = jest.fn<TextChannel | null, [name: string]>();
+	const mockGetEmoji = jest.fn();
+	let context: GuildedCommandContext;
+
+	beforeEach(() => {
+		context = {
+			replyPrivately: mockReplyPrivately,
+			options: {
+				getString: mockGetString,
+				getInteger: mockGetInteger,
+				getChannel: mockGetChannel,
+			},
+			client: {
+				emojis: {
+					cache: {
+						get: mockGetEmoji,
+					},
+				},
+			},
+			guild: {
+				id: mockGuildId,
+			},
+		} as unknown as GuildedCommandContext;
+
+		mockGetChannel.mockReturnValue(mockChannel as unknown as TextChannel);
+		mockGetInteger.mockReturnValue(mockThreshold);
+		mockGetString.mockReturnValue(mockReact);
+	});
+
+	test('upserts a reactboard', async () => {
+		await expect(setReactboard.execute(context)).resolves.toBeUndefined();
+		expect(mockUpsert).toHaveBeenCalledTimes(1);
+		expect(mockUpsert).toHaveBeenCalledWith({
+			where: {
+				location: {
+					channelId: mockChannel.id,
+					guildId: mockGuildId,
+				},
+			},
+			update: {
+				threshold: mockThreshold,
+				react: mockReact,
+				isCustomReact: false,
+			},
+			create: {
+				channelId: mockChannel.id,
+				guildId: mockGuildId,
+				threshold: mockThreshold,
+				react: mockReact,
+				isCustomReact: false,
+			},
+		});
+		expect(mockReplyPrivately).toHaveBeenCalledTimes(1);
+	});
+
+	test('upserts a reactboard with a custom emoji', async () => {
+		const customEmojiId = '1234567890';
+		mockGetString.mockReturnValue(`<:abcdef:${customEmojiId}>`);
+		mockGetEmoji.mockReturnValue({
+			id: customEmojiId,
+		});
+
+		await expect(setReactboard.execute(context)).resolves.toBeUndefined();
+		expect(mockUpsert).toHaveBeenCalledTimes(1);
+		expect(mockUpsert).toHaveBeenCalledWith({
+			where: {
+				location: {
+					channelId: mockChannel.id,
+					guildId: mockGuildId,
+				},
+			},
+			update: {
+				threshold: mockThreshold,
+				react: customEmojiId,
+				isCustomReact: true,
+			},
+			create: {
+				channelId: mockChannel.id,
+				guildId: mockGuildId,
+				threshold: mockThreshold,
+				react: customEmojiId,
+				isCustomReact: true,
+			},
+		});
+		expect(mockReplyPrivately).toHaveBeenCalledTimes(1);
+	});
+
+	test('fails with UserMessageError when threshold is below 1', async () => {
+		mockGetInteger.mockReturnValue(0);
+
+		await expect(setReactboard.execute(context)).rejects.toThrow(UserMessageError);
+	});
+});

src/commands/setReactboard.ts

@@ -0,0 +1,97 @@
+import { Client, GuildEmoji, SlashCommandBuilder } from 'discord.js';
+import { UserMessageError } from '../helpers/UserMessageError';
+import { db } from '../database';
+
+const channelOption = 'channel';
+const thresholdOption = 'threshold';
+const reactOption = 'react';
+
+const builder = new SlashCommandBuilder()
+	.setName('setreactboard')
+	.setDescription('Creates or modifies reaction board in this server')
+	.addChannelOption(option =>
+		option
+			.setName(channelOption)
+			.setDescription('The channel where reactboard posts will be posted')
+			.setRequired(true)
+	)
+	.addIntegerOption(option =>
+		option
+			.setName(thresholdOption)
+			.setDescription(
+				'The minimum number of reacts a message should receive before being put on the board'
+			)
+			.setRequired(true)
+	)
+	.addStringOption(option =>
+		option.setName(reactOption).setDescription('The react to be tracked (defaults to ⭐)')
+	);
+
+interface ReactboardReactInfo {
+	react: string;
+	isCustomReact: boolean;
+}
+
+export const setReactboard: GuildedCommand = {
+	info: builder,
+	requiresGuild: true,
+	async execute({ guild, client, options, replyPrivately }) {
+		const channel = options.getChannel(channelOption, true);
+		const threshold = options.getInteger(thresholdOption, true);
+		const react = options.getString(reactOption) ?? '⭐';
+
+		if (threshold < 1) {
+			throw new UserMessageError('Threshold must be at least one');
+		}
+
+		let reactboardInfo: ReactboardReactInfo;
+		if (isUnicodeEmoji(react)) {
+			reactboardInfo = {
+				react,
+				isCustomReact: false,
+			};
+		} else {
+			const customReact = getCustomReact(client, react);
+			if (customReact === undefined) {
+				throw new UserMessageError('React option must be a valid reaction');
+			}
+			reactboardInfo = {
+				react: customReact.id,
+				isCustomReact: true,
+			};
+		}
+
+		await db.reactboard.upsert({
+			where: {
+				location: {
+					channelId: channel.id,
+					guildId: guild.id,
+				},
+			},
+			update: {
+				threshold,
+				...reactboardInfo,
+			},
+			create: {
+				channelId: channel.id,
+				guildId: guild.id,
+				threshold,
+				...reactboardInfo,
+			},
+		});
+
+		await replyPrivately('Reactboard created!');
+	},
+};
+
+function isUnicodeEmoji(str: string): boolean {
+	return Boolean(str.match(/^\p{Extended_Pictographic}$/u));
+}
+
+function getCustomReact(client: Client<true>, str: string): GuildEmoji | undefined {
+	const reactId = str.match(/^<a?:.+?:(\d+?)>$/u)?.[1];
+	if (reactId === undefined) {
+		return undefined;
+	}
+	return client.emojis.cache.get(reactId);
+}

src/events/index.ts

@@ -59,9 +59,11 @@ import { error } from './error';
 import { interactionCreate } from './interactionCreate';
 import { messageReactionAdd } from './messageReactionAdd';
 import { ready } from './ready';
+import { messageReactionRemove } from './messageReactionRemove';
 
 _add(error as EventHandler);
 _add(interactionCreate as EventHandler);
 _add(messageReactionAdd as EventHandler);
+_add(messageReactionRemove as EventHandler);
 _add(ready as EventHandler);
 // Not sure why these type casts are necessary, but they seem sound. We can remove them when TS gets smarter, or we learn what I did wrong