Add public competition pages and scouting analytics

apps/server/src/handler/tournaments/getDistrict.ts

@@ -0,0 +1,64 @@
+import type { Request, Response } from "express";
+import prismaClient from "../../prismaClient.js";
+
+export async function getDistrict(req: Request, res: Response): Promise<void> {
+  const key = req.params.key;
+
+  if (typeof key !== "string" || !/^[0-9]{4}[a-z0-9]+$/.test(key)) {
+    res.status(400).json({ error: "Invalid district key" });
+    return;
+  }
+
+  try {
+    const district = await prismaClient.districtSeason.findUnique({
+      where: { key },
+      select: {
+        key: true,
+        seasonYear: true,
+        name: true,
+        abbreviation: true,
+        tournaments: {
+          orderBy: [{ startDate: "asc" }, { key: "asc" }],
+          select: {
+            key: true,
+            parentTournamentKey: true,
+            week: true,
+            eventType: true,
+            name: true,
+            location: true,
+            startDate: true,
+            endDate: true,
+          },
+        },
+        teamSeasons: {
+          orderBy: { teamNumber: "asc" },
+          select: {
+            teamNumber: true,
+            team: {
+              select: { registeredTeam: { select: { teamApproved: true } } },
+            },
+            name: true,
+            city: true,
+            stateProvince: true,
+          },
+        },
+      },
+    });
+
+    if (!district) {
+      res.status(404).json({ error: "District not imported yet" });
+      return;
+    }
+
+    res.set("Cache-Control", "public, max-age=300");
+    res.json({
+      ...district,
+      teamSeasons: district.teamSeasons.map(({ team, ...season }) => ({
+        ...season,
+        usesLovat: team.registeredTeam?.teamApproved === true,
+      })),
+    });
+  } catch {
+    res.status(503).json({ error: "District data is temporarily unavailable" });
+  }
+}

apps/server/src/handler/tournaments/getMatch.ts

@@ -0,0 +1,40 @@
+import type { Request, Response } from "express";
+import prismaClient from "../../prismaClient.js";
+import { matchVideos } from "./matchVideos.js";
+
+export async function getMatch(req: Request, res: Response): Promise<void> {
+  const key = req.params.key;
+
+  if (
+    typeof key !== "string" ||
+    !/^[0-9]{4}[a-z0-9]+_(?:qm[1-9]\d*|(?:ef|qf|sf|f)[1-9]\d*m[1-9]\d*)$/.test(
+      key,
+    )
+  ) {
+    res.status(400).json({ error: "Invalid match key" });
+    return;
+  }
+
+  try {
+    const match = await prismaClient.match.findUnique({
+      where: { key },
+      select: {
+        key: true,
+        alliances: {
+          orderBy: { color: "asc" },
+          select: { color: true, scoreBreakdown: true },
+        },
+      },
+    });
+
+    if (!match) {
+      res.status(404).json({ error: "Match not imported yet" });
+      return;
+    }
+
+    res.set("Cache-Control", "public, max-age=30");
+    res.json({ ...match, videos: await matchVideos(key) });
+  } catch {
+    res.status(503).json({ error: "Match data is temporarily unavailable" });
+  }
+}

apps/server/src/handler/tournaments/getRobotPhoto.ts

@@ -0,0 +1,113 @@
+import type { Request, Response } from "express";
+import { z } from "zod";
+import { publicCache } from "../../lib/publicCache.js";
+
+const mediaSchema = z.array(
+  z.object({
+    type: z.string(),
+    preferred: z.boolean().optional(),
+    direct_url: z.string().optional(),
+    details: z
+      .object({
+        image_url_med: z.string().optional(),
+        image_url: z.string().optional(),
+      })
+      .nullish(),
+  }),
+);
+
+export function chooseRobotPhoto(input: unknown): string | null {
+  const media = mediaSchema
+    .parse(input)
+    .filter((item) => ["imgur", "smugmug-photo"].includes(item.type));
+
+  media.sort(
+    (a, b) => Number(Boolean(b.preferred)) - Number(Boolean(a.preferred)),
+  );
+
+  for (const item of media) {
+    const value =
+      item.details?.image_url_med || item.direct_url || item.details?.image_url;
+
+    if (!value) continue;
+
+    try {
+      const url = new URL(value);
+      const allowed =
+        url.hostname === "i.imgur.com" ||
+        url.hostname === "photos.smugmug.com" ||
+        url.hostname.endsWith(".smugmug.com");
+
+      if (
+        url.protocol === "https:" &&
+        !url.username &&
+        !url.password &&
+        allowed &&
+        /\.(?:jpe?g|png|webp)$/i.test(url.pathname)
+      )
+        return url.href;
+    } catch {
+      // Skip unsupported or malformed provider links.
+    }
+  }
+
+  return null;
+}
+
+export async function getRobotPhoto(
+  req: Request,
+  res: Response,
+): Promise<void> {
+  const number = Number(req.params.number);
+  const year = Number(req.params.year);
+
+  if (
+    !Number.isInteger(number) ||
+    number <= 0 ||
+    number > 2_147_483_647 ||
+    !Number.isInteger(year) ||
+    year < 1992 ||
+    year > 9999
+  ) {
+    res.status(400).json({ error: "Invalid team or year" });
+    return;
+  }
+
+  try {
+    const photo = await publicCache(
+      `robot-photo:${number}:${year}`,
+      async () => {
+        if (!process.env.TBA_KEY) return null;
+
+        const response = await fetch(
+          `https://www.thebluealliance.com/api/v3/team/frc${number}/media/${year}`,
+          {
+            headers: {
+              "X-TBA-Auth-Key": process.env.TBA_KEY,
+              "User-Agent": "Lovat/26.0",
+            },
+            signal: AbortSignal.timeout(10_000),
+          },
+        );
+
+        if (response.status === 404) return null;
+        if (!response.ok) throw new Error("Robot media unavailable");
+
+        const image = chooseRobotPhoto(await response.json());
+
+        return image
+          ? {
+              image,
+              source: `https://www.thebluealliance.com/team/${number}/${year}`,
+            }
+          : null;
+      },
+      86400,
+    );
+
+    res.set("Cache-Control", "public, max-age=3600");
+    res.json({ photo });
+  } catch {
+    res.status(503).json({ error: "Robot photo unavailable" });
+  }
+}

apps/server/src/handler/tournaments/getSearch.ts

@@ -0,0 +1,61 @@
+import type { Request, Response } from "express";
+import prisma from "../../prismaClient.js";
+import { publicCache } from "../../lib/publicCache.js";
+
+export async function getSearch(req: Request, res: Response): Promise<void> {
+  const query = typeof req.query.q === "string" ? req.query.q.trim() : "";
+  const year = Number(req.query.year);
+
+  if (
+    !query ||
+    query.length > 80 ||
+    !Number.isInteger(year) ||
+    year < 1992 ||
+    year > 9999
+  ) {
+    res.status(400).json({ error: "Invalid search" });
+    return;
+  }
+
+  try {
+    const results = await publicCache(
+      `search:${year}:${encodeURIComponent(query.toLowerCase())}`,
+      async () => {
+        const numeric = /^\d{1,9}$/.test(query) ? Number(query) : undefined;
+        const [events, teams] = await Promise.all([
+          prisma.tournament.findMany({
+            where: {
+              seasonYear: year,
+              OR: ["name", "key", "location"].map((field) => ({
+                [field]: { contains: query, mode: "insensitive" },
+              })),
+            },
+            orderBy: [{ startDate: "asc" }, { key: "asc" }],
+            take: 20,
+            select: { key: true, name: true, location: true },
+          }),
+          prisma.teamSeason.findMany({
+            where: {
+              seasonYear: year,
+              OR: [
+                { name: { contains: query, mode: "insensitive" } },
+                ...(numeric ? [{ teamNumber: numeric }] : []),
+              ],
+            },
+            orderBy: { teamNumber: "asc" },
+            take: 20,
+            select: { teamNumber: true, name: true, city: true },
+          }),
+        ]);
+
+        return { year, events, teams };
+      },
+      60,
+    );
+
+    res.set("Cache-Control", "public, max-age=60");
+    res.json(results);
+  } catch {
+    res.status(503).json({ error: "Search unavailable" });
+  }
+}

apps/server/src/handler/tournaments/getSeason.ts

@@ -0,0 +1,58 @@
+import type { Request, Response } from "express";
+import prismaClient from "../../prismaClient.js";
+
+export async function getSeason(req: Request, res: Response): Promise<void> {
+  const value = req.params.year;
+
+  if (
+    typeof value !== "string" ||
+    !/^\d{4}$/.test(value) ||
+    Number(value) < 1992
+  ) {
+    res.status(400).json({ error: "Invalid season year" });
+    return;
+  }
+
+  try {
+    const season = await prismaClient.season.findUnique({
+      where: { year: Number(value) },
+      select: {
+        year: true,
+        gameName: true,
+        districtSeasons: {
+          orderBy: { name: "asc" },
+          select: { key: true, abbreviation: true, name: true },
+        },
+        tournaments: {
+          where: { districtSeasonKey: null },
+          orderBy: [{ startDate: "asc" }, { key: "asc" }],
+          select: {
+            key: true,
+            parentTournamentKey: true,
+            name: true,
+            location: true,
+            startDate: true,
+            endDate: true,
+            week: true,
+            eventType: true,
+          },
+        },
+      },
+    });
+
+    if (!season) {
+      res.status(404).json({ error: "Season not imported yet" });
+      return;
+    }
+
+    const seasons = await prismaClient.season.findMany({
+      orderBy: { year: "desc" },
+      select: { year: true },
+    });
+
+    res.set("Cache-Control", "public, max-age=300");
+    res.json({ ...season, seasonYears: seasons.map(({ year }) => year) });
+  } catch {
+    res.status(503).json({ error: "Season data is temporarily unavailable" });
+  }
+}

apps/server/src/handler/tournaments/getTeamAvatar.ts

@@ -0,0 +1,44 @@
+import type { Request, Response } from "express";
+import prismaClient from "../../prismaClient.js";
+
+export async function getTeamAvatar(
+  req: Request,
+  res: Response,
+): Promise<void> {
+  const teamNumber = Number(req.params.number);
+  const seasonYear = Number(req.params.year);
+
+  if (
+    !Number.isSafeInteger(teamNumber) ||
+    teamNumber <= 0 ||
+    teamNumber > 2_147_483_647 ||
+    !Number.isSafeInteger(seasonYear) ||
+    seasonYear < 1992 ||
+    seasonYear > 9999
+  ) {
+    res.status(400).end();
+    return;
+  }
+
+  try {
+    const team = await prismaClient.teamSeason.findUnique({
+      where: { teamNumber_seasonYear: { teamNumber, seasonYear } },
+      select: { avatar: true },
+    });
+    const image = team?.avatar?.match(
+      /^data:(image\/(?:png|jpeg|gif|webp));base64,([A-Za-z0-9+/=]+)$/,
+    );
+
+    if (!image) {
+      res.status(404).end();
+      return;
+    }
+
+    res.set("Cache-Control", "public, max-age=86400");
+    res.set("Content-Type", image[1]!);
+    res.set("X-Content-Type-Options", "nosniff");
+    res.send(Buffer.from(image[2]!, "base64"));
+  } catch {
+    res.status(503).end();
+  }
+}