Display of scraped elo results

app/server/procedures/fetchTournamentResults.ts

@@ -1,19 +1,156 @@
+import { z } from "zod";
+
 import { fetchTournamentResultsSchema } from "@/schemas";
 import { errorLog } from "@/utils/logger";
 
 import { publicProcedure } from "../trpc";
 
+const scrapedSchema = z.array(
+  z.object({
+    id: z.string(),
+    name: z.string(),
+    elo: z.string(),
+    results: z.array(
+      z.object({
+        colour: z.enum(["B", "N", ""]),
+        result: z.string(),
+        opponent_name: z.string().nullable(),
+        opponent_elo: z.string().nullable(),
+      }),
+    ),
+  }),
+);
+
+const outputSchema = z.array(
+  z.object({
+    id: z.string(),
+    name: z.string(),
+    elo: z.number(),
+    estimated: z.boolean(),
+    national: z.boolean(),
+    results: z.array(
+      z.object({
+        colour: z.enum(["white", "black", ""]),
+        result: z.number().nullable(),
+        lostByForfeit: z.boolean(),
+        wonByForfeit: z.boolean(),
+        opponent: z.string().nullable(),
+        elo: z.number().nullable(),
+        estimated: z.boolean(),
+        national: z.boolean(),
+      }),
+    ),
+  }),
+);
+
+const getEloDetails = (elo: string | null) => {
+  if (elo === null || elo === "") {
+    return { elo: 0, estimated: false, national: false };
+  }
+  return {
+    elo: parseInt(elo),
+    estimated: elo.endsWith("E"),
+    national: elo.endsWith("N"),
+  };
+};
+
+const getResultDetails = (
+  results: z.infer<typeof scrapedSchema>[number]["results"][number],
+) => {
+  if (results.opponent_name === null) {
+    return { result: 0, lostByForfeit: true, wonByForfeit: false };
+  }
+
+  if (results.result === "<") {
+    return { result: 0, lostByForfeit: true, wonByForfeit: false };
+  }
+
+  if (results.result === ">") {
+    return { result: 1, lostByForfeit: false, wonByForfeit: true };
+  }
+
+  return {
+    result: parseFloat(results.result),
+    lostByForfeit: false,
+    wonByForfeit: false,
+  };
+};
+
+const reportFetchError = async (url: string, error: any) => {
+  if (typeof process.env.DISCORD_WEBHOOK_URL === "string") {
+    await fetch(process.env.DISCORD_WEBHOOK_URL as string, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        embeds: [
+          {
+            title: "Error Fetching Tournament Results",
+            fields: [
+              { name: "url", value: url },
+              {
+                name: "error.message",
+                value: "message" in error ? error.message : "",
+              },
+              { name: "error", value: JSON.stringify(error, null, 2) },
+            ],
+          },
+        ],
+      }),
+    });
+  }
+};
+
 export const fetchTournamentResults = publicProcedure
   .input(fetchTournamentResultsSchema)
-  .mutation(async ({ input }) => {
+  .output(outputSchema)
+  .query(async ({ input }) => {
     try {
-      console.log(input.url);
+      // Depending on which page the user copied the URL from, we need to extract the tournament ID
 
-      // Fetch the tournament results using Python
+      // http://echecs.asso.fr/FicheTournoi.aspx?Ref=59975
+      // http://echecs.asso.fr/Resultats.aspx?URL=Tournois/Id/59975/59975&Action=Ls
 
-      return true;
+      const tournamentId =
+        input.url.match(/Ref=(\d+)/)?.[1] ?? input.url.match(/Id\/(\d+)/)?.[1];
+
+      if (!tournamentId) {
+        throw new Error("ERR_NO_TOURNAMENT_ID");
+      }
+
+      const rawResults = await fetch(
+        `${process.env.RESULTS_SCRAPER_URL}${tournamentId}`,
+      );
+
+      const results = await rawResults.json();
+
+      if ("detail" in results && results.detail === "Not found") {
+        throw new Error("ERR_TOURNAMENT_NOT_FOUND");
+      }
+
+      const parsedResults = scrapedSchema.parse(results);
+      return parsedResults.map<z.infer<typeof outputSchema>[number]>(
+        (player) => ({
+          id: player.id,
+          name: player.name,
+          ...getEloDetails(player.elo),
+          results: player.results.map((result) => ({
+            colour:
+              result.colour === "B"
+                ? "white"
+                : result.colour === "N"
+                ? "black"
+                : "",
+            opponent: result.opponent_name,
+            ...getResultDetails(result),
+            ...getEloDetails(result.opponent_elo),
+          })),
+        }),
+      );
     } catch (error) {
-      errorLog(error);
+      reportFetchError(input.url, error);
+      errorLog(JSON.stringify(error, null, 2));
       throw error;
     }
   });