Priority Button

apps/scouting/backend/src/routes/index.ts

@@ -12,6 +12,7 @@ import { compareRouter } from "./compare-router";
 import { tinderRouter } from "./tinder-router";
 import { bpsRouter } from "./bps-router";
 import { superScoutRouter } from "./super-scout-router";
+import { priorityRouter } from "./priority-router";
 
 export const apiRouter = Router();
 
@@ -26,6 +27,7 @@ apiRouter.use("/compare", compareRouter);
 apiRouter.use("/tinder", tinderRouter);
 apiRouter.use("/bps", bpsRouter);
 apiRouter.use("/super", superScoutRouter);
+apiRouter.use("/priority", priorityRouter)
 
 apiRouter.get("/health", (req, res) => {
   res.status(StatusCodes.OK).send({ message: "Healthy!" });

apps/scouting/backend/src/routes/priority-router.ts

@@ -0,0 +1,147 @@
+import { Router } from "express";
+import { StatusCodes } from "http-status-codes";
+import { flow, pipe } from "fp-ts/lib/function";
+import { flatMap, fold, map, tryCatch, fromEither } from "fp-ts/lib/TaskEither";
+import { right as rightEither } from "fp-ts/lib/Either";
+import { map as mapTask } from "fp-ts/lib/Task";
+import * as t from "io-ts";
+
+import {
+  createBodyVerificationPipe,
+  createTypeCheckingEndpointFlow,
+} from "../middleware/verification";
+import type { EndpointError } from "../middleware/verification";
+import type { TaskEither } from "fp-ts/lib/TaskEither";
+import { getDb } from "../middleware/db";
+import { left } from "fp-ts/lib/TaskEither";
+import { flatTryCatch, foldResponse } from "../../../../../packages/flow-utils";
+
+export const teamPriorityCodec = t.type({
+  teamNumber: t.number,
+  priority: t.number,
+});
+
+export const teamPriorityArrayCodec = t.array(teamPriorityCodec);
+
+export type TeamPriority = t.TypeOf<typeof teamPriorityCodec>;
+
+export const priorityRouter = Router();
+
+const getPriorityCollection = flow(
+  getDb,
+  map((db) => db.collection<TeamPriority>("teamPriorities")),
+);
+
+export const readAllPriorities = (): TaskEither<
+  EndpointError,
+  TeamPriority[]
+> =>
+  pipe(
+    getPriorityCollection(),
+    flatTryCatch(
+      (collection) => collection.find({}).toArray(),
+      (error) => ({
+        status: StatusCodes.INTERNAL_SERVER_ERROR,
+        reason: `Error reading priorities: ${error}`,
+      }),
+    ),
+    mapTask(
+      createTypeCheckingEndpointFlow(teamPriorityArrayCodec, (errors) => ({
+        status: StatusCodes.INTERNAL_SERVER_ERROR,
+        reason: `Invalid priorities data format. error: ${errors}`,
+      })),
+    ),
+  );
+
+export const readPriorityByTeamNumber = (
+  teamNumber: number,
+): TaskEither<EndpointError, TeamPriority> =>
+  pipe(
+    getPriorityCollection(),
+    flatTryCatch(
+      (collection) => collection.findOne({ teamNumber }),
+      (error): EndpointError => ({
+        status: StatusCodes.INTERNAL_SERVER_ERROR,
+        reason: `Error reading priority for team ${teamNumber}: ${String(error)}`,
+      }),
+    ),
+    flatMap((result) =>
+      result
+        ? pipe(
+            rightEither(result),
+            createTypeCheckingEndpointFlow(teamPriorityCodec, (errors) => ({
+              status: StatusCodes.INTERNAL_SERVER_ERROR,
+              reason: `Invalid team priority format. error: ${errors}`,
+            })),
+            fromEither,
+          )
+        : left({
+            status: StatusCodes.NOT_FOUND,
+            reason: `Priority for team ${teamNumber} not found`,
+          }),
+    ),
+  );
+
+export const upsertPriority = (
+  teamPriority: TeamPriority,
+): TaskEither<EndpointError, void> =>
+  pipe(
+    getPriorityCollection(),
+    flatTryCatch(
+      (collection) =>
+        collection.updateOne(
+          { teamNumber: teamPriority.teamNumber },
+          { $set: { priority: teamPriority.priority } },
+          { upsert: true },
+        ),
+      (error) => ({
+        status: StatusCodes.INTERNAL_SERVER_ERROR,
+        reason: `Error writing priority: ${error}`,
+      }),
+    ),
+    map(() => undefined),
+  );
+
+priorityRouter.get("/", async (_req, res) => {
+  await pipe(
+    readAllPriorities(),
+    map((priorities) => ({ priorities })),
+    foldResponse(res),
+  )();
+});
+
+priorityRouter.get("/:teamNumber", async (req, res) => {
+  const teamNumber = Number(req.params.teamNumber);
+
+  if (Number.isNaN(teamNumber)) {
+    res
+      .status(StatusCodes.BAD_REQUEST)
+      .send("teamNumber must be a valid number");
+    return;
+  }
+
+  await pipe(
+    readPriorityByTeamNumber(teamNumber),
+    map((teamPriority) => ({ teamPriority })),
+    foldResponse(res),
+  )();
+});
+
+priorityRouter.post("/", async (req, res) => {
+  await pipe(
+    rightEither(req),
+    createBodyVerificationPipe(teamPriorityCodec),
+    fromEither,
+    flatMap((teamPriority) => upsertPriority(teamPriority)),
+    fold(
+      (error) => () =>
+        Promise.resolve(res.status(error.status).send(error.reason)),
+      () => () =>
+        Promise.resolve(
+          res
+            .status(StatusCodes.OK)
+            .json({ message: "Priority written successfully" }),
+        ),
+    ),
+  )();
+});

apps/scouting/frontend/src/strategy/components/priority/DisplayPriority.tsx

@@ -0,0 +1,53 @@
+import React, { useEffect, useState } from "react";
+import { fetchATeamPriority, type TeamPriority } from "./EditPriority";
+import { useTeamPriority } from "../../hooks/useTeamPriority";
+
+interface DisplayPriorityProps {
+  teamNumber: number;
+}
+
+export const DisplayPriority: React.FC<DisplayPriorityProps> = ({
+  teamNumber,
+}) => {
+  const { teamPriority, isLoading, feedbackMessage } =
+  useTeamPriority(teamNumber);
+
+  return (
+    <div
+      className="
+        w-52 p-4
+        flex flex-col gap-3
+        items-center
+        bg-slate-900/40 backdrop-blur-md
+        border border-white/10
+        rounded-3xl shadow-2xl
+      "
+    >
+      <span className="text-xs font-black tracking-[0.2em] uppercase text-slate-400">
+        Team Priority
+      </span>
+
+      <div
+        className="
+          w-full min-h-[72px]
+          flex items-center justify-center
+          rounded-2xl
+          border border-white/10
+          bg-slate-950/70
+          text-3xl font-black text-white
+          shadow-inner
+        "
+      >
+        {isLoading ? "..." : teamPriority ? teamPriority.priority : "--"}
+      </div>
+
+      {feedbackMessage ? (
+        <p className="text-xs text-red-300 text-center">{feedbackMessage}</p>
+      ) : (
+        <p className="text-[11px] text-slate-500 text-center">
+          Current saved value
+        </p>
+      )}
+    </div>
+  );
+};

apps/scouting/frontend/src/strategy/components/priority/DisplayPriorityCell.tsx

@@ -0,0 +1,27 @@
+import React, { useEffect, useState } from "react";
+import { fetchATeamPriority, type TeamPriority } from "./EditPriority";
+import { useTeamPriority } from "../../hooks/useTeamPriority";
+
+interface DisplayPriorityCellProps {
+  teamNumber: number;
+}
+
+export const DisplayPriorityCell: React.FC<DisplayPriorityCellProps> = ({
+  teamNumber,
+}) => {
+  const { teamPriority, isLoading } =
+  useTeamPriority(teamNumber);
+
+  return (
+    <span
+      className="
+        inline-flex min-w-[3rem] items-center justify-center
+        rounded-lg border border-emerald-500/20
+        bg-slate-800/70 px-2.5 py-1
+        text-xs font-black text-emerald-400
+      "
+    >
+      {isLoading ? "..." : teamPriority ? teamPriority.priority : "--"}
+    </span>
+  );
+};