all claiming of time-limited flags

Author: PssbleTrngle

migrations/004-add-flags-to-links.sql

@@ -0,0 +1,10 @@
+--------------------------------------------------------------------------------
+-- Up
+--------------------------------------------------------------------------------
+ALTER TABLE Link ADD flags INT NOT NULL DEFAULT 0;
+
+--------------------------------------------------------------------------------
+-- Down
+--------------------------------------------------------------------------------
+ALTER TABLE Link
+DROP COLUMN flags;

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "herald",
+  "name": "@teamgalena/bot",
   "module": "src/app.ts",
   "type": "module",
   "scripts": {

src/commands/claimFlag.ts

@@ -0,0 +1,45 @@
+import { ChatInputCommandInteraction, SlashCommandBuilder } from "discord.js";
+import { addFlag } from "../database";
+import { UserError } from "../error";
+import { type Flag } from "../flags";
+
+type DatePredicate = (date: Date) => boolean;
+
+function inMonth(month: number): DatePredicate {
+  if (month < 1 || month > 12) throw new Error("months are between 1-12");
+  const utcMonth = month - 1;
+  return (date) => {
+    return date.getUTCMonth() === utcMonth;
+  };
+}
+
+const timeRanges: Partial<Record<Flag, DatePredicate>> = {
+  pride: inMonth(6),
+};
+
+export const command = new SlashCommandBuilder()
+  .setName("claim")
+  .setDescription("claim a special time-limited tophat");
+
+function availableFlag(date: Date) {
+  return Object.entries(timeRanges).find(([, test]) => test(date))?.[0] as
+    | Flag
+    | undefined;
+}
+
+export async function execute(interaction: ChatInputCommandInteraction) {
+  await interaction.deferReply();
+
+  const now = new Date();
+  const flag = availableFlag(now);
+
+  if (!flag) {
+    throw new UserError("there is no special tophat available right now");
+  }
+
+  await addFlag(interaction.user.id, flag);
+
+  if (interaction.isRepliable()) {
+    await interaction.editReply(`You claimed the ${flag} tophat!`);
+  }
+}

src/commands/register.ts

@@ -11,7 +11,8 @@ import {
 import { config } from "../config";
 import { UserError } from "../error";
 import logger from "../logger";
-import * as makeAnnouncement from "./linkMinecraft";
+import * as claimFlag from "./claimFlag";
+import * as linkMinecraft from "./linkMinecraft";
 
 type CommandHandler = (
   interaction: ChatInputCommandInteraction
@@ -31,7 +32,8 @@ function addCommand({
   handlers.set(command.name, execute);
 }
 
-addCommand(makeAnnouncement);
+addCommand(linkMinecraft);
+addCommand(claimFlag);
 
 const rest = new REST().setToken(config.botToken);
 

src/database.ts

@@ -1,6 +1,7 @@
 import { open } from "sqlite";
 import sqlite3 from "sqlite3";
 import { UserError } from "./error";
+import { flagQuery, withFlag, type Flag } from "./flags";
 import logger from "./logger";
 
 const db = await open({
@@ -15,8 +16,11 @@ export type LinkEntry = {
   discordId: string;
   uuid: string;
   rank: number;
+  flags: number;
 };
 
+type InputLinkEntry = Omit<LinkEntry, "flags"> & Partial<LinkEntry>;
+
 export type RoleEntry = {
   id: string;
   rank: number;
@@ -37,24 +41,29 @@ async function getLinkByDiscordId(discordId: string) {
   ]);
 }
 
-async function updateLink(existing: LinkEntry, values: LinkEntry) {
-  if (values.rank === existing.rank && values.uuid === existing.uuid) {
+async function updateLink(existing: LinkEntry, values: InputLinkEntry) {
+  const next = { ...existing, ...values };
+  if (
+    next.rank === existing.rank &&
+    next.uuid === existing.uuid &&
+    next.flags === existing.flags
+  ) {
     logger.debug("skipped linking, all values are the same");
     return;
   }
 
-  await db.run("UPDATE Link SET uuid = ?, rank = ? WHERE discordId = ?", [
-    values.uuid,
-    values.rank,
-    values.discordId,
-  ]);
+  await db.run(
+    "UPDATE Link SET uuid = ?, rank = ?, flags = ? WHERE discordId = ?",
+    [next.uuid, next.rank, next.flags, next.discordId]
+  );
 
+  const prettyFlags = next.flags.toString(2).padStart(8, "0");
   logger.debug(
-    `updated ${values.discordId} <-> ${values.uuid} (${values.rank})`
+    `updated ${next.discordId} <-> ${next.uuid} (${next.rank}/${prettyFlags})`
   );
 }
 
-export async function persistLink(link: LinkEntry) {
+export async function persistLink(link: InputLinkEntry) {
   const existing = await getLinkByDiscordId(link.discordId);
 
   if (existing) {
@@ -73,11 +82,19 @@ export async function persistLink(link: LinkEntry) {
   }
 }
 
-export async function updateRank(discordId: string, rank: number) {
+async function requireLink(discordId: string) {
   const link = await getLinkByDiscordId(discordId);
-  if (!link)
-    throw new UserError("you have not linked your minecraft account yet");
+  if (link) return link;
+  throw new UserError("you have not linked your minecraft account yet");
+}
+
+export async function addFlag(discordId: string, flag: Flag) {
+  const link = await requireLink(discordId);
+  await updateLink(link, withFlag(link, flag));
+}
 
+export async function updateRank(discordId: string, rank: number) {
+  const link = await requireLink(discordId);
   await updateLink(link, { ...link, rank });
 }
 
@@ -89,6 +106,13 @@ export async function loadSupporterUuids(aboveRank: number) {
   return entries.map((it) => it.uuid);
 }
 
+export async function loadFlaggedUuids(flag: Flag) {
+  const entries = await db.all<LinkEntry[]>(
+    `SELECT uuid FROM Link WHERE ${flagQuery(flag)}`
+  );
+  return entries.map((it) => it.uuid);
+}
+
 export async function loadSupporterRoles() {
   return await db.all<RoleEntry[]>("SELECT * FROM Role ORDER BY rank DESC");
 }

src/flags.ts

@@ -0,0 +1,24 @@
+import type { LinkEntry } from "./database";
+
+const Flags = {
+  pride: 0,
+  anniversary: 1,
+};
+
+export type Flag = keyof typeof Flags;
+
+export function withFlag(link: LinkEntry, flag: Flag): LinkEntry {
+  const mask = 1 << Flags[flag];
+  const flags = link.flags | mask;
+  return { ...link, flags };
+}
+
+export function isFlag(flag: string): flag is Flag {
+  return flag in Flags;
+}
+
+export function flagQuery(flag: Flag) {
+  if (!isFlag(flag)) throw new Error(`unknown flag ${flag}`);
+  const mask = 1 << Flags[flag];
+  return `(flags & ${mask} != 0)`;
+}

src/server.ts

@@ -1,5 +1,6 @@
 import { server as createServer } from "@hapi/hapi";
-import { loadSupporterUuids } from "./database";
+import { loadFlaggedUuids, loadSupporterUuids } from "./database";
+import { isFlag } from "./flags";
 import logger from "./logger";
 
 const server = createServer({ port: 3000 });
@@ -21,5 +22,22 @@ server.route({
   },
 });
 
+server.route({
+  method: "GET",
+  path: "/api/flagged/{flag}",
+  handler: async (req, tools) => {
+    const { flag } = req.params;
+    if (!isFlag(flag)) {
+      return tools
+        .response({
+          message: `unknown flag '${flag}'`,
+        })
+        .code(400);
+    }
+
+    return await loadFlaggedUuids(flag);
+  },
+});
+
 await server.start();
 logger.debug(`server accepting responses at ${server.info.uri}`);