rhythia-api 138.0.0 → 139.0.0

package/api/createBeatmap.ts

@@ -77,14 +77,15 @@ export async function handler({
   });
 
   await s3Client.send(command);
-  parsedData.markers.sort((a, b) => a.position - b.position);
+  const markers = parsedData.markers.sort((a, b) => a.position - b.position);
+
   const upserted = await supabase.from("beatmaps").upsert({
     beatmapHash: digested,
     title: parsedData.strings.mapName,
     playcount: 0,
     difficulty: parsedData.metadata.difficulty,
     noteCount: parsedData.metadata.noteCount,
-    length: parsedData.pointers.audioLength,
+    length: markers[markers.length - 1].position,
     beatmapFile: url,
     image: `https://static.rhythia.com/${imgkey}`,
     starRating: rateMap(parsedData),

package/api/deleteBeatmapPage.ts

@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  session,
+  id,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await supabase.auth.getUser(session)).data.user!;
+  let { data: userData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  let { data: pageData, error: pageError } = await supabase
+    .from("beatmapPages")
+    .select("*")
+    .eq("id", id)
+    .single();
+
+  if (!pageData) return NextResponse.json({ error: "No beatmap." });
+
+  let { data: beatmapData, error: bmPageError } = await supabase
+    .from("beatmaps")
+    .select("*")
+    .eq("beatmapHash", pageData.id)
+    .single();
+
+  if (!userData) return NextResponse.json({ error: "No user." });
+  if (!beatmapData) return NextResponse.json({ error: "No beatmap." });
+
+  if (userData.id !== pageData.owner)
+    return NextResponse.json({ error: "Non-authz user." });
+
+  if (pageData.status !== "UNRANKED")
+    return NextResponse.json({ error: "Only unranked maps can be updated" });
+
+  await supabase.from("beatmapPageComments").delete().eq("beatmapPage", id);
+  await supabase.from("beatmapPages").delete().eq("id", id);
+  await supabase
+    .from("beatmaps")
+    .delete()
+    .eq("beatmapHash", beatmapData.beatmapHash);
+
+  return NextResponse.json({});
+}

package/api/submitScore.ts

@@ -60,7 +60,7 @@ export async function handler({
   console.log(userData);
   let { data: beatmaps, error } = await supabase
     .from("beatmaps")
-    .select("playcount")
+    .select("*")
     .eq("beatmapHash", data.mapHash)
     .single();
 
@@ -81,10 +81,33 @@ export async function handler({
 
   let newPlaycount = 1;
 
-  if (beatmaps) {
-    newPlaycount = (beatmaps.playcount || 1) + 1;
+  if (!beatmaps) {
+    return NextResponse.json(
+      {
+        error: "Map not submitted",
+      },
+      { status: 500 }
+    );
+  }
+
+  if (beatmaps.noteCount !== data.mapNoteCount) {
+    return NextResponse.json(
+      {
+        error: "Wrong map",
+      },
+      { status: 500 }
+    );
+  }
+  if (beatmaps.noteCount !== data.mapNoteCount) {
+    return NextResponse.json(
+      {
+        error: "Wrong map",
+      },
+      { status: 500 }
+    );
   }
 
+  newPlaycount = (beatmaps.playcount || 1) + 1;
   await supabase.from("beatmaps").upsert({
     beatmapHash: data.mapHash,
     title: data.mapTitle,

package/api/updateBeatmapPage.ts

@@ -59,6 +59,9 @@ export async function handler({
   if (userData.id !== pageData?.owner)
     return NextResponse.json({ error: "Non-authz user." });
 
+  if (pageData?.status !== "UNRANKED")
+    return NextResponse.json({ error: "Only unranked maps can be updated" });
+
   const upserted = await supabase
     .from("beatmapPages")
     .upsert({

package/index.ts

@@ -15,6 +15,11 @@ import { Schema as CreateBeatmapPage } from "./api/createBeatmapPage"
 export { Schema as SchemaCreateBeatmapPage } from "./api/createBeatmapPage"
 export const createBeatmapPage = handleApi({url:"/api/createBeatmapPage",...CreateBeatmapPage})
 
+// ./api/deleteBeatmapPage.ts API
+import { Schema as DeleteBeatmapPage } from "./api/deleteBeatmapPage"
+export { Schema as SchemaDeleteBeatmapPage } from "./api/deleteBeatmapPage"
+export const deleteBeatmapPage = handleApi({url:"/api/deleteBeatmapPage",...DeleteBeatmapPage})
+
 // ./api/editAboutMe.ts API
 import { Schema as EditAboutMe } from "./api/editAboutMe"
 export { Schema as SchemaEditAboutMe } from "./api/editAboutMe"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "138.0.0",
+  "version": "139.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",