Feat/scoring (#5)

* poc: scoring

* use scoring in postOrUpdate

* add tsc to build

Author: karl-run

.github/workflows/docker-image.yaml

@@ -20,6 +20,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: oven-sh/setup-bun@v1
       - run: bun install --frozen-lockfile
+      - run: bun run tsc
       - run: bun run build
       - name: Log in to the Container registry
         uses: docker/login-action@v2

bun.lockb

@@ -15,7 +15,7 @@
     "date-fns-tz": "^2.0.0",
     "dotenv": "^16.0.3",
     "pg": "^8.11.3",
-    "remeda": "^1.18.1"
+    "remeda": "^1.27.0"
   },
   "devDependencies": {
     "@types/node": "^20.2.3",

package.json

@@ -69,6 +69,20 @@ export async function getTodaysLeets(channelId: string) {
   return queryResult.rows as UserLeetRow[];
 }
 
+export async function getLeetForDay(channelId: string, day: Date) {
+  const queryResult = await client.query(
+    `
+        SELECT *
+        FROM public.leet_messages
+        WHERE channel = $1
+          AND date(ts_as_date) = $2::date;
+    `,
+    [channelId, day],
+  );
+
+  return queryResult.rows as UserLeetRow[];
+}
+
 export async function getAllLeets(channelId: string): Promise<UserLeetRow[]> {
   const queryResult = await client.query(
     `

src/db/queries.ts

@@ -1,16 +1,16 @@
 import * as R from "remeda";
-import { rowToStatus } from "./row-utils";
 import { toCategoryMarkdown } from "./message-formatters";
-import { getTodaysLeets } from "../../db/queries";
 import { formatHoursWithSeconds } from "../../utils/date-utils";
+import { ScoredDay } from "../score-engine";
 
-export function leetsToBlocks(
-  hour: number,
-  minutes: number,
-  seconds: number,
-  todaysLeets: Awaited<ReturnType<typeof getTodaysLeets>>,
-) {
-  if (todaysLeets.length === 0) {
+export function scoredDayToBlocks(scoredDay: ScoredDay) {
+  const leetCount = R.pipe(
+    scoredDay,
+    R.toPairs,
+    R.flatMap(([, messages]) => messages),
+  ).length;
+
+  if (leetCount === 0) {
     return [
       {
         type: "section",
@@ -53,10 +53,8 @@ export function leetsToBlocks(
       text: {
         type: "mrkdwn",
         text: R.pipe(
-          todaysLeets,
-          R.sortBy((row) => row.ts),
-          R.groupBy(rowToStatus),
-          R.toPairs,
+          scoredDay,
+          R.toPairs.strict,
           R.map(toCategoryMarkdown),
           R.join("\n"),
         ),
@@ -67,9 +65,9 @@ export function leetsToBlocks(
       elements: [
         {
           type: "mrkdwn",
-          text: `:leetoo: ${
-            todaysLeets.length
-          } leets i dag, sist oppdatert ${formatHoursWithSeconds(new Date())}`,
+          text: `:leetoo: ${leetCount} leets i dag, sist oppdatert ${formatHoursWithSeconds(
+            new Date(),
+          )}`,
         },
       ],
     },

src/handlers/daily-leet/block-builder.ts

@@ -6,48 +6,52 @@ import {
 } from "../../utils/date-utils";
 import { formatDistanceStrict, set } from "date-fns";
 import { nb } from "date-fns/locale";
+import { LeetStatus } from "./row-utils";
+import { ScoredMessage } from "../score-engine";
 
-function formatLeetos(rows: Awaited<ReturnType<typeof getTodaysLeets>>) {
+type StatusScoredMessageTuple = [key: LeetStatus, rows: ScoredMessage[]];
+
+function formatLeetos(rows: ScoredMessage[]) {
   return rows
     .map((row) => {
-      const { ms } = getTimeParts(slackTsToDate(row.ts));
-      return `:letopet: <@${row.message.user}>: ${ms}ms`;
+      const { ms } = getTimeParts(slackTsToDate(row.message.ts));
+      return `:letopet: <@${row.message.message.user}>: ${ms}ms (+${row.points})`;
     })
     .join("\n");
 }
 
-function formatLeets(rows: Awaited<ReturnType<typeof getTodaysLeets>>) {
+function formatLeets(rows: ScoredMessage[]) {
   return rows
     .map((row) => {
-      const { seconds, ms } = getTimeParts(slackTsToDate(row.ts));
-      return `:letojam: <@${row.message.user}>: ${seconds}s ${ms}ms`;
+      const { seconds, ms } = getTimeParts(slackTsToDate(row.message.ts));
+      return `:letojam: <@${row.message.message.user}>: ${seconds}s ${ms}ms (+${row.points})`;
     })
     .join("\n");
 }
 
-function formatPrematureRows(rows: Awaited<ReturnType<typeof getTodaysLeets>>) {
+function formatPrematureRows(rows: ScoredMessage[]) {
   return rows
     .map((row) => {
-      const { seconds, ms } = getTimeParts(slackTsToDate(row.ts));
+      const { seconds, ms } = getTimeParts(slackTsToDate(row.message.ts));
       const negativeOffset = 1000 - ms;
-      return `:letogun: <@${row.message.user}>: -${negativeOffset}ms for tidlig :hot_face:`;
+      return `:letogun: <@${row.message.message.user}>: -${negativeOffset}ms for tidlig :hot_face: (${row.points})`;
     })
     .join("\n");
 }
 
-function formatLateRows(rows: Awaited<ReturnType<typeof getTodaysLeets>>) {
+function formatLateRows(rows: ScoredMessage[]) {
   return rows
     .map((row) => {
-      const date = slackTsToDate(row.ts);
+      const date = slackTsToDate(row.message.ts);
       const { minutes, seconds } = getTimeParts(date);
       return `:letoint: <@${
-        row.message.user
-      }>: ${minutes}m ${seconds}s (${formatHours(date)})`;
+        row.message.message.user
+      }>: ${minutes}m ${seconds}s (${formatHours(date)}) (+${row.points})`;
     })
     .join("\n");
 }
 
-function messageFormatters(rows: Awaited<ReturnType<typeof getTodaysLeets>>) {
+function messageFormatters(rows: ScoredMessage[]) {
   return rows
     .map((row) => {
       const leet = set(new Date(), {
@@ -57,19 +61,19 @@ function messageFormatters(rows: Awaited<ReturnType<typeof getTodaysLeets>>) {
         milliseconds: 0,
       });
 
-      const date = slackTsToDate(row.ts);
-      return `:letoshake: <@${row.message.user}>: ${formatDistanceStrict(
+      const date = slackTsToDate(row.message.ts);
+      return `:letoshake: <@${row.message.message.user}>: ${formatDistanceStrict(
         leet,
         date,
         {
           locale: nb,
         },
-      )} bom :roflrofl: (${formatHours(date)})`;
+      )} bom :roflrofl: (${formatHours(date)}) (+${row.points})`;
     })
     .join("\n");
 }
 
-export function toCategoryMarkdown([key, rows]) {
+export function toCategoryMarkdown([key, rows]: StatusScoredMessageTuple) {
   switch (key) {
     case "leetos":
       return `*Ekte leetos*:\n${formatLeetos(rows)}`;

src/handlers/daily-leet/message-formatters.ts

@@ -1,9 +1,11 @@
 import { getTimeParts, slackTsToDate } from "../../utils/date-utils";
 import { getTodaysLeets } from "../../db/queries";
 
+export type LeetStatus = "leetos" | "leet" | "premature" | "late" | "garbage";
+
 export function rowToStatus(
   row: Awaited<ReturnType<typeof getTodaysLeets>>[number],
-) {
+): LeetStatus {
   const timeParts = getTimeParts(slackTsToDate(row.ts));
 
   if (timeParts.minutes === 37 && timeParts.seconds === 0) {

src/handlers/daily-leet/row-utils.ts

@@ -9,7 +9,8 @@ import {
   insertNewBotMessage,
 } from "../db/queries";
 
-import { leetsToBlocks } from "./daily-leet/block-builder";
+import { scoredDayToBlocks } from "./daily-leet/block-builder";
+import { scoreDay } from "./score-engine";
 
 export function configureLeetHandlers(app: App) {
   app.message("1337", async ({ message, say, event, client }) => {
@@ -72,12 +73,10 @@ export function configureLeetHandlers(app: App) {
 }
 
 export async function postOrUpdate(client: WebClient, channelId: string) {
-  const { hour, minutes, seconds } = getTimeParts(new Date());
-
   console.log("Posting or updating");
   const existingTS = await getCurrentBotMessageTS(channelId);
-  const todaysLeets = await getTodaysLeets(channelId);
-  const blocks = leetsToBlocks(hour, minutes, seconds, todaysLeets);
+  const scoredDay = await scoreDay(new Date(), channelId);
+  const blocks = scoredDayToBlocks(scoredDay);
 
   if (existingTS) {
     console.log(`Found existing ts: ${existingTS}`);

src/handlers/leet-handlers.ts

@@ -0,0 +1,106 @@
+import * as R from "remeda";
+import { getLeetForDay } from "../../db/queries";
+import { rowToStatus, LeetStatus } from "../daily-leet/row-utils";
+import { UserLeetRow } from "../../db/types";
+import { slackTsToMs, slackTsToSeconds } from "../../utils/date-utils";
+
+export type ScoredMessage = {
+  points: number;
+  message: UserLeetRow;
+};
+
+export type ScoredDay = Record<LeetStatus, ScoredMessage[]>;
+
+export async function scoreDay(
+  day: Date,
+  channelId: string,
+): Promise<ScoredDay> {
+  const leetsForDay: UserLeetRow[] = await getLeetForDay(channelId, day);
+  const result: Record<LeetStatus, ScoredMessage[]> = R.pipe(
+    leetsForDay,
+    R.sortBy((row) => row.ts),
+    R.groupBy(rowToStatus),
+    (it) =>
+      R.merge(
+        {
+          premature: [],
+          leetos: [],
+          leet: [],
+          late: [],
+          garbage: [],
+        } satisfies Record<LeetStatus, UserLeetRow[]>,
+        it,
+      ),
+    scoreLeetos,
+    scorePrematures,
+    scoreLeets,
+    zeroTheRest,
+  );
+
+  return result;
+}
+
+function scoreLeetos(
+  day: Record<LeetStatus, UserLeetRow[]>,
+): Record<LeetStatus, (UserLeetRow | ScoredMessage)[]> {
+  return {
+    ...day,
+    leetos: day.leetos.map((leet): ScoredMessage => {
+      const firstBonus = leet.ts === day.leetos[0].ts ? 500 : 0;
+      const points = firstBonus + 1000 + (1000 - slackTsToMs(leet.ts));
+
+      return {
+        points,
+        message: leet,
+      };
+    }),
+  };
+}
+
+function scorePrematures(
+  day: Record<LeetStatus, UserLeetRow[]>,
+): Record<LeetStatus, (UserLeetRow | ScoredMessage)[]> {
+  return {
+    ...day,
+    premature: day.premature.map((it): ScoredMessage => {
+      return {
+        points: -5000,
+        message: it,
+      };
+    }),
+  };
+}
+
+function scoreLeets(
+  day: Record<LeetStatus, UserLeetRow[]>,
+): Record<LeetStatus, (UserLeetRow | ScoredMessage)[]> {
+  return {
+    ...day,
+    leet: day.leet.map((it): ScoredMessage => {
+      const firstBonus = day.leetos.length === 0 ? 500 : 0;
+      const within3SecondsPoints = slackTsToSeconds(it.ts) <= 3 ? 250 : 0;
+
+      return {
+        points: firstBonus + within3SecondsPoints,
+        message: it,
+      };
+    }),
+  };
+}
+
+function zeroTheRest(
+  day: Record<LeetStatus, UserLeetRow[]>,
+): Record<LeetStatus, ScoredMessage[]> {
+  const zeroMessage = (it: UserLeetRow): ScoredMessage => {
+    return {
+      points: 0,
+      message: it,
+    };
+  };
+
+  return {
+    ...day,
+    late: day.late.map(zeroMessage),
+    garbage: day.garbage.map(zeroMessage),
+  } as unknown as Record<LeetStatus, ScoredMessage[]>;
+}

src/handlers/score-engine/index.ts

@@ -1,3 +1,4 @@
+import * as R from "remeda";
 import { format, utcToZonedTime } from "date-fns-tz";
 import {
   getDate,
@@ -31,6 +32,16 @@ export function getTimeParts(time: Date): {
   };
 }
 
+export const slackTsToMs: (ts: string) => number = R.createPipe(
+  slackTsToDate,
+  getMilliseconds,
+);
+
+export const slackTsToSeconds: (ts: string) => number = R.createPipe(
+  slackTsToDate,
+  getSeconds,
+);
+
 export function formatHours(time: Date) {
   return format(time, "HH:mm", { timeZone: OSLO_TZ });
 }

src/utils/date-utils.ts

@@ -2,6 +2,9 @@
   "compilerOptions": {
     "target": "es2015",
     "moduleResolution": "node",
-    "outDir": "dist"
-  }
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
 }