rhythia-api 230.0.0 → 233.0.0

package/api/checkQualified.ts

@@ -0,0 +1,93 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
+
+const INTERNAL_SECRET = "testing-1";
+const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
+
+export const Schema = {
+  input: z.strictObject({
+    secret: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    updated: z.number(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler({
+  secret,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  if (secret !== INTERNAL_SECRET) {
+    return NextResponse.json({ error: "Internal usage only", updated: 0 });
+  }
+
+  const { data: qualifiedMaps, error: qualifiedMapsError } = await supabase
+    .from("beatmapPages")
+    .select("id,status,qualifiedAt")
+    .eq("qualified", true)
+    .not("qualifiedAt", "is", null);
+
+  if (qualifiedMapsError) {
+    return NextResponse.json({ error: qualifiedMapsError.message, updated: 0 });
+  }
+
+  const cutoffTimestamp = Date.now() - THREE_DAYS_MS;
+  const mapsToRank = (qualifiedMaps || []).filter((mapData) => {
+    if (mapData.status === "RANKED") {
+      return false;
+    }
+
+    const qualifiedAt = Date.parse(mapData.qualifiedAt || "");
+    if (!Number.isFinite(qualifiedAt)) {
+      return false;
+    }
+
+    return qualifiedAt <= cutoffTimestamp;
+  });
+
+  if (mapsToRank.length === 0) {
+    return NextResponse.json({ updated: 0 });
+  }
+
+  const { error: updateError } = await supabase
+    .from("beatmapPages")
+    .update({
+      status: "RANKED",
+      ranked_at: Date.now(),
+      qualified: false,
+      qualifiedAt: null,
+    })
+    .in(
+      "id",
+      mapsToRank.map((mapData) => mapData.id)
+    );
+
+  if (updateError) {
+    return NextResponse.json({ error: updateError.message, updated: 0 });
+  }
+
+  await Promise.allSettled(
+    mapsToRank.map((mapData) =>
+      postMapLifecycleWebhook({
+        mapId: mapData.id,
+        event: "ranked",
+      })
+    )
+  );
+
+  return NextResponse.json({ updated: mapsToRank.length });
+}

package/api/enhancedSearch.ts

@@ -0,0 +1,113 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+type EnhancedSearchRow =
+  Database["public"]["Functions"]["enhanced_search"]["Returns"][number];
+
+export const Schema = {
+  input: z.strictObject({
+    text: z.string().trim().min(1),
+    limit: z.number().int().min(1).max(25).default(10),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    users: z.array(
+      z.object({
+        id: z.number(),
+        username: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        about_me: z.string().nullable(),
+        flag: z.string().nullable(),
+      })
+    ),
+    beatmaps: z.array(
+      z.object({
+        id: z.number(),
+        mapId: z.string().nullable(),
+        title: z.string().nullable(),
+        description: z.string().nullable(),
+        image: z.string().nullable(),
+        starRating: z.number().nullable(),
+        length: z.number().nullable(),
+        status: z.string().nullable(),
+        tags: z.string().nullable(),
+        owner: z.number().nullable(),
+        ownerUsername: z.string().nullable(),
+        ownerAvatar: z.string().nullable(),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const { data: results, error } = await supabase.rpc("enhanced_search", {
+    search_text: data.text,
+    result_limit: data.limit,
+  });
+
+  if (error) {
+    return NextResponse.json(
+      {
+        error: JSON.stringify(error),
+        users: [],
+        beatmaps: [],
+      },
+      { status: 500 }
+    );
+  }
+
+  const users: (typeof Schema)["output"]["_type"]["users"] = [];
+  const beatmaps: (typeof Schema)["output"]["_type"]["beatmaps"] = [];
+
+  for (const result of (results || []) as EnhancedSearchRow[]) {
+    if (result.result_type === "user" && result.user_id !== null) {
+      users.push({
+        id: result.user_id,
+        username: result.user_username,
+        avatar_url: result.user_avatar_url,
+        about_me: result.user_about_me,
+        flag: result.user_flag,
+      });
+      continue;
+    }
+
+    if (
+      result.result_type === "beatmap" &&
+      result.beatmap_page_id !== null
+    ) {
+      beatmaps.push({
+        id: result.beatmap_page_id,
+        mapId: result.beatmap_map_id,
+        title: result.beatmap_title,
+        description: result.beatmap_description,
+        image: result.beatmap_image,
+        starRating: result.beatmap_star_rating,
+        length: result.beatmap_length,
+        status: result.beatmap_status,
+        tags: result.beatmap_tags,
+        owner: result.beatmap_owner,
+        ownerUsername: result.beatmap_owner_username,
+        ownerAvatar: result.beatmap_owner_avatar,
+      });
+    }
+  }
+
+  return NextResponse.json({
+    users,
+    beatmaps,
+  });
+}

package/api/getBeatmapPage.ts

@@ -47,17 +47,31 @@ export const Schema = {
         image: z.string().nullable().optional(),
         imageLarge: z.string().nullable().optional(),
         starRating: z.number().nullable().optional(),
-        owner: z.number().nullable().optional(),
-        ownerUsername: z.string().nullable().optional(),
-        ownerAvatar: z.string().nullable().optional(),
-        status: z.string().nullable().optional(),
-        description: z.string().nullable().optional(),
-        tags: z.string().nullable().optional(),
-        videoUrl: z.string().nullable().optional(),
-      })
-      .optional(),
-  }),
-};
+        owner: z.number().nullable().optional(),
+        ownerUsername: z.string().nullable().optional(),
+        ownerAvatar: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+        qualified: z.boolean().nullable().optional(),
+        qualifiedAt: z.string().nullable().optional(),
+        description: z.string().nullable().optional(),
+        tags: z.string().nullable().optional(),
+        videoUrl: z.string().nullable().optional(),
+        vetos: z
+          .array(
+            z.object({
+              id: z.number(),
+              userId: z.number().nullable().optional(),
+              username: z.string().nullable().optional(),
+              avatar_url: z.string().nullable().optional(),
+              veto_reason: z.string().nullable().optional(),
+              created_at: z.string().nullable().optional(),
+            })
+          )
+          .optional(),
+      })
+      .optional(),
+  }),
+};
 
 export async function POST(request: Request): Promise<NextResponse> {
   return protectedApi({
@@ -92,12 +106,23 @@ export async function handler(
         noteCount,
         title
       ),
-      profiles (
-        username,
-        avatar_url
-      )
-    `
-    )
+      profiles (
+        username,
+        avatar_url
+      ),
+      vetos (
+        id,
+        user,
+        veto_reason,
+        created_at,
+        profiles (
+          id,
+          username,
+          avatar_url
+        )
+      )
+    `
+    )
     .eq("id", data.id)
     .single();
 
@@ -131,7 +156,16 @@ export async function handler(
   //   }
   // }
 
-  return NextResponse.json({
+  const mappedVetos = ((beatmapPage as any).vetos || []).map((veto: any) => ({
+    id: veto.id,
+    userId: veto.user,
+    username: veto.profiles?.username,
+    avatar_url: veto.profiles?.avatar_url,
+    veto_reason: veto.veto_reason,
+    created_at: veto.created_at,
+  }));
+
+  return NextResponse.json({
     scores: [].map((score: any) => ({
       id: score.id,
       awarded_sp: score.awarded_sp,
@@ -162,13 +196,16 @@ export async function handler(
       starRating: beatmapPage.beatmaps?.starRating,
       owner: beatmapPage.owner,
       ownerUsername: beatmapPage.profiles?.username,
-      ownerAvatar: beatmapPage.profiles?.avatar_url,
-      id: beatmapPage.id,
-      status: beatmapPage.status,
-      nominations: beatmapPage.nominations as number[],
-      description: beatmapPage.description,
-      tags: beatmapPage.tags,
-      videoUrl: beatmapPage.video_url,
-    },
-  });
-}
+      ownerAvatar: beatmapPage.profiles?.avatar_url,
+      id: beatmapPage.id,
+      status: beatmapPage.status,
+      qualified: beatmapPage.qualified,
+      qualifiedAt: beatmapPage.qualifiedAt,
+      nominations: beatmapPage.nominations as number[],
+      description: beatmapPage.description,
+      tags: beatmapPage.tags,
+      videoUrl: beatmapPage.video_url,
+      vetos: mappedVetos.length > 0 ? mappedVetos : undefined,
+    },
+  });
+}

package/api/getBeatmapPageById.ts

@@ -46,15 +46,29 @@ export const Schema = {
         beatmapFile: z.string().nullable().optional(),
         image: z.string().nullable().optional(),
         starRating: z.number().nullable().optional(),
-        owner: z.number().nullable().optional(),
-        ownerUsername: z.string().nullable().optional(),
-        ownerAvatar: z.string().nullable().optional(),
-        status: z.string().nullable().optional(),
-        videoUrl: z.string().nullable(),
-      })
-      .optional(),
-  }),
-};
+        owner: z.number().nullable().optional(),
+        ownerUsername: z.string().nullable().optional(),
+        ownerAvatar: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+        qualified: z.boolean().nullable().optional(),
+        qualifiedAt: z.string().nullable().optional(),
+        videoUrl: z.string().nullable(),
+        vetos: z
+          .array(
+            z.object({
+              id: z.number(),
+              userId: z.number().nullable().optional(),
+              username: z.string().nullable().optional(),
+              avatar_url: z.string().nullable().optional(),
+              veto_reason: z.string().nullable().optional(),
+              created_at: z.string().nullable().optional(),
+            })
+          )
+          .optional(),
+      })
+      .optional(),
+  }),
+};
 
 export async function POST(request: Request): Promise<NextResponse> {
   return protectedApi({
@@ -88,12 +102,23 @@ export async function handler(
         noteCount,
         title
       ),
-      profiles (
-        username,
-        avatar_url
-      )
-    `
-    )
+      profiles (
+        username,
+        avatar_url
+      ),
+      vetos (
+        id,
+        user,
+        veto_reason,
+        created_at,
+        profiles (
+          id,
+          username,
+          avatar_url
+        )
+      )
+    `
+    )
     .eq("latestBeatmapHash", data.mapId)
     .single();
 
@@ -135,7 +160,16 @@ export async function handler(
     .filter((score) => activeUserIds.has(score.userid))
     .slice(0, limit);
 
-  return NextResponse.json({
+  const mappedVetos = ((beatmapPage as any).vetos || []).map((veto: any) => ({
+    id: veto.id,
+    userId: veto.user,
+    username: veto.profiles?.username,
+    avatar_url: veto.profiles?.avatar_url,
+    veto_reason: veto.veto_reason,
+    created_at: veto.created_at,
+  }));
+
+  return NextResponse.json({
     scores: visibleScores.map((score: any) => ({
       id: score.id,
       awarded_sp: score.awarded_sp,
@@ -164,11 +198,14 @@ export async function handler(
       starRating: beatmapPage.beatmaps?.starRating,
       owner: beatmapPage.owner,
       ownerUsername: beatmapPage.profiles?.username,
-      ownerAvatar: beatmapPage.profiles?.avatar_url,
-      id: beatmapPage.id,
-      status: beatmapPage.status,
-      nominations: beatmapPage.nominations as number[],
-      videoUrl: beatmapPage.video_url,
-    },
-  });
-}
+      ownerAvatar: beatmapPage.profiles?.avatar_url,
+      id: beatmapPage.id,
+      status: beatmapPage.status,
+      qualified: beatmapPage.qualified,
+      qualifiedAt: beatmapPage.qualifiedAt,
+      nominations: beatmapPage.nominations as number[],
+      videoUrl: beatmapPage.video_url,
+      vetos: mappedVetos.length > 0 ? mappedVetos : undefined,
+    },
+  });
+}

package/api/{approveMap.ts → qualifyMap.ts}

@@ -1,78 +1,92 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  const tags = (queryUserData?.badges || []) as string[];
-
-  if (!tags.includes("MMT")) {
-    return NextResponse.json({ error: "Only MMTs can approve maps!" });
-  }
-
-  const { data: mapData, error } = await supabase
-    .from("beatmapPages")
-    .select("id,nominations,owner")
-    .eq("id", data.mapId)
-    .single();
-
-  if (!mapData) {
-    return NextResponse.json({ error: "Bad map" });
-  }
-
-  if (mapData.owner == queryUserData.id) {
-    return NextResponse.json({ error: "Can't approve own map" });
-  }
-
-  if ((mapData.nominations as number[])!.length < 2) {
-    return NextResponse.json({
-      error: "Maps can get approved only if they have 2 nominations",
-    });
-  }
-
-  if ((mapData.nominations as number[]).includes(queryUserData.id)) {
-    return NextResponse.json({
-      error: "Can't nominate and approve",
-    });
-  }
-
-  await supabase.from("beatmapPages").upsert({
-    id: data.mapId,
-    status: "RANKED",
-    ranked_at: Date.now(),
-  });
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
+
+const QUALIFY_BADGES = ["Team Ranked"];
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    qualifiedAt: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  const { data: queryUserData } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  const tags = (queryUserData?.badges || []) as string[];
+  const hasQualifyAccess = QUALIFY_BADGES.some((badge) => tags.includes(badge));
+
+  if (!hasQualifyAccess) {
+    return NextResponse.json({ error: "Only management can qualify maps!" });
+  }
+
+  const { data: mapData } = await supabase
+    .from("beatmapPages")
+    .select("id,owner,status,qualified,qualifiedAt")
+    .eq("id", data.mapId)
+    .single();
+
+  if (!mapData) {
+    return NextResponse.json({ error: "Bad map" });
+  }
+
+  if (mapData.owner === queryUserData.id) {
+    return NextResponse.json({ error: "Can't qualify own map" });
+  }
+
+  if (mapData.status === "RANKED") {
+    return NextResponse.json({ error: "Map is already ranked" });
+  }
+
+  if (mapData.qualified) {
+    return NextResponse.json({
+      error: "Map is already qualified",
+      qualifiedAt: mapData.qualifiedAt || undefined,
+    });
+  }
+
+  const qualifiedAt = new Date().toISOString();
+  const { error: updateError } = await supabase.from("beatmapPages").upsert({
+    id: data.mapId,
+    qualified: true,
+    qualifiedAt,
+  });
+
+  if (updateError) {
+    return NextResponse.json({ error: updateError.message });
+  }
+
+  await postMapLifecycleWebhook({
+    mapId: data.mapId,
+    event: "qualified",
+  });
+
+  return NextResponse.json({ qualifiedAt });
+}

package/api/rankMapsArchive.ts

@@ -1,9 +1,10 @@
 import { NextResponse } from "next/server";
 import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
 
 export const Schema = {
   input: z.strictObject({
@@ -58,14 +59,20 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     return NextResponse.json({ error: "Bad map" });
   }
 
-  for (const element of mapData) {
-    await supabase.from("beatmapPages").upsert({
-      id: element.id,
-      nominations: [queryUserData.id, queryUserData.id],
-      status: "RANKED",
-      ranked_at: Date.now(),
-    });
-  }
+  for (const element of mapData) {
+    await supabase.from("beatmapPages").upsert({
+      id: element.id,
+      nominations: [queryUserData.id, queryUserData.id],
+      status: "RANKED",
+      ranked_at: Date.now(),
+      qualified: false,
+      qualifiedAt: null,
+    });
+    await postMapLifecycleWebhook({
+      mapId: element.id,
+      event: "ranked",
+    });
+  }
 
   return NextResponse.json({});
 }