rhythia-api 131.0.0 → 132.0.0

package/api/approveMap.ts

@@ -56,7 +56,7 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
 
   if ((mapData.nominations as number[])!.length < 2) {
     return NextResponse.json({
-      error: "Maps can get approved only if they have 2 approvals",
+      error: "Maps can get approved only if they have 2 nominations",
     });
   }
 

package/api/getBeatmapComments.ts

@@ -0,0 +1,42 @@
+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({
+    page: z.number(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    comments: z.array(
+      z.object({
+        beatmapPage: z.number(),
+        content: z.string().nullable(),
+        owner: z.number(),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler({
+  page,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  let { data: userData, error: userError } = await supabase
+    .from("beatmapPageComments")
+    .select("*")
+    .eq("beatmapPage", page);
+
+  return NextResponse.json({ comments: userData! });
+}

package/api/postBeatmapComment.ts

@@ -0,0 +1,56 @@
+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(),
+    page: z.number(),
+    content: z.string(),
+  }),
+  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,
+  page,
+  content,
+}: (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();
+
+  if (!userData) return NextResponse.json({ error: "No user." });
+
+  const upserted = await supabase
+    .from("beatmapPageComments")
+    .upsert({
+      beatmapPage: page,
+      owner: userData.id,
+      content,
+    })
+    .select("*")
+    .single();
+
+  if (upserted.error?.message.length) {
+    return NextResponse.json({ error: upserted.error.message });
+  }
+  return NextResponse.json({});
+}

package/index.ts

@@ -35,6 +35,11 @@ import { Schema as GetBadgedUsers } from "./api/getBadgedUsers"
 export { Schema as SchemaGetBadgedUsers } from "./api/getBadgedUsers"
 export const getBadgedUsers = handleApi({url:"/api/getBadgedUsers",...GetBadgedUsers})
 
+// ./api/getBeatmapComments.ts API
+import { Schema as GetBeatmapComments } from "./api/getBeatmapComments"
+export { Schema as SchemaGetBeatmapComments } from "./api/getBeatmapComments"
+export const getBeatmapComments = handleApi({url:"/api/getBeatmapComments",...GetBeatmapComments})
+
 // ./api/getBeatmapPage.ts API
 import { Schema as GetBeatmapPage } from "./api/getBeatmapPage"
 export { Schema as SchemaGetBeatmapPage } from "./api/getBeatmapPage"
@@ -80,6 +85,11 @@ import { Schema as NominateMap } from "./api/nominateMap"
 export { Schema as SchemaNominateMap } from "./api/nominateMap"
 export const nominateMap = handleApi({url:"/api/nominateMap",...NominateMap})
 
+// ./api/postBeatmapComment.ts API
+import { Schema as PostBeatmapComment } from "./api/postBeatmapComment"
+export { Schema as SchemaPostBeatmapComment } from "./api/postBeatmapComment"
+export const postBeatmapComment = handleApi({url:"/api/postBeatmapComment",...PostBeatmapComment})
+
 // ./api/rankMapsArchive.ts API
 import { Schema as RankMapsArchive } from "./api/rankMapsArchive"
 export { Schema as SchemaRankMapsArchive } from "./api/rankMapsArchive"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "131.0.0",
+  "version": "132.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",
@@ -32,6 +32,7 @@
     "isomorphic-git": "^1.27.1",
     "lodash": "^4.17.21",
     "next": "^14.2.5",
+    "osu-classes": "^3.1.0",
     "osu-parsers": "^4.1.7",
     "osu-standard-stable": "^5.0.0",
     "sharp": "^0.33.5",

package/scripts/test.ts

@@ -1,5 +1,8 @@
 import { createClient } from "@supabase/supabase-js";
 import { Database } from "../types/database";
+import { SSPMParser } from "../utils/star-calc/sspmParser";
+import { rateMap, rateMapOld } from "../utils/star-calc";
+import { V1SSPMParser } from "../utils/star-calc/sspmv1Parser";
 
 export const supabase = createClient<Database>(
   `https://pfkajngbllcbdzoylrvp.supabase.co`,
@@ -13,24 +16,52 @@ export const supabase = createClient<Database>(
 );
 
 async function main() {
-  const { data: mapData, error } = await supabase
-    .from("beatmapPages")
-    .select("id,nominations,owner,status")
-    .eq("owner", 10)
-    .eq("status", "RANKED");
-
-  if (!mapData) {
-    throw "lolz";
-  }
+  const req = await fetch(`https://cdn.rhythia.net/index.json`);
+  const json = Object.values(await req.json()) as any[];
+  console.log(json[0]);
+
+  let count = 0;
+  for (const map of json) {
+    const request = await fetch(map.download);
+    const bytes = await request.arrayBuffer();
+    const parser = new SSPMParser(Buffer.from(bytes));
+    let rate = 0;
+    try {
+      const data = parser.parse();
+      rate = rateMap(data);
+    } catch (error) {
+      const parserOld = new V1SSPMParser(Buffer.from(bytes));
+      const data = parserOld.parse();
 
-  for (const element of mapData) {
-    let data = await supabase.from("beatmapPages").upsert({
-      id: element.id,
-      nominations: [10, 10],
-      status: "APPROVED",
+      rate = rateMapOld(data);
+    }
+    await supabase.from("beatmaps").upsert({
+      beatmapHash: map.id,
+      starRating: rate,
     });
-    console.log(data.error);
+    count++;
+    console.log(count, json.length, map.id, rate);
   }
+  // for (const map of json) {
+  //   const reqMap = await fetch(map.link);
+  //   const buff = await reqMap.arrayBuffer();
+  //   writeFileSync("./toSubmit/" + map.id + ".sspm", Buffer.from(buff));
+  // }
+
+  // const { data: mapData, error } = await supabase
+  //   .from("beatmapPages")
+  //   .select("id,nominations,owner,status")
+  //   .eq("owner", 10)
+  //   .eq("status", "RANKED");
+
+  // if (!mapData) {
+  //   throw "lolz";
+  // }
+
+  // for (const element of mapData) {
+
+  //   console.log(data.error);
+  // }
 }
 
 main();

package/types/database.ts

@@ -9,6 +9,45 @@ export type Json =
 export type Database = {
   public: {
     Tables: {
+      beatmapPageComments: {
+        Row: {
+          beatmapPage: number
+          content: string | null
+          created_at: string
+          id: number
+          owner: number
+        }
+        Insert: {
+          beatmapPage: number
+          content?: string | null
+          created_at?: string
+          id?: number
+          owner: number
+        }
+        Update: {
+          beatmapPage?: number
+          content?: string | null
+          created_at?: string
+          id?: number
+          owner?: number
+        }
+        Relationships: [
+          {
+            foreignKeyName: "beatmapPageComments_beatmapPage_fkey"
+            columns: ["beatmapPage"]
+            isOneToOne: false
+            referencedRelation: "beatmapPages"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "beatmapPageComments_owner_fkey"
+            columns: ["owner"]
+            isOneToOne: false
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       beatmapPages: {
         Row: {
           created_at: string

package/utils/star-calc/index.ts

@@ -2,6 +2,7 @@ import { BeatmapDecoder } from "osu-parsers";
 import { StandardRuleset } from "osu-standard-stable";
 import { sampleMap } from "./osuUtils";
 import { SSPMParsedMap } from "./sspmParser";
+import { SSPMMap, V1SSPMParser } from "./sspmv1Parser";
 
 function easeInExpoDeq(x: number) {
   return x === 0 ? 0 : Math.pow(2, 35 * x - 35);
@@ -20,7 +21,7 @@ export function rateMap(map: SSPMParsedMap) {
   const decoder = new BeatmapDecoder();
   const beatmap1 = decoder.decodeFromString(sampleMap);
 
-  const notes = map.markers
+  let notes = map.markers
     .filter((marker) => marker.type === 0)
     .map((marker) => ({
       time: marker.position,
@@ -28,6 +29,34 @@ export function rateMap(map: SSPMParsedMap) {
       y: marker.data["field0"].y,
     }));
 
+  notes = notes.sort((a, b) => a.time - b.time);
+
+  for (const note of notes) {
+    const hittable = beatmap1.hitObjects[0].clone();
+    hittable.startX = Math.round((note.x / 2) * 100);
+    hittable.startY = Math.round((note.y / 2) * 100);
+    hittable.startTime = note.time;
+    beatmap1.hitObjects.push(hittable);
+  }
+  const ruleset = new StandardRuleset();
+  const mods = ruleset.createModCombination("RX");
+  const difficultyCalculator = ruleset.createDifficultyCalculator(beatmap1);
+  const difficultyAttributes = difficultyCalculator.calculateWithMods(mods);
+  return difficultyAttributes.starRating;
+}
+
+export function rateMapOld(map: SSPMMap) {
+  const decoder = new BeatmapDecoder();
+  const beatmap1 = decoder.decodeFromString(sampleMap);
+
+  let notes = map.notes.map((marker) => ({
+    time: marker.position,
+    x: marker.x,
+    y: marker.y,
+  }));
+
+  notes = notes.sort((a, b) => a.time - b.time);
+
   for (const note of notes) {
     const hittable = beatmap1.hitObjects[0].clone();
     hittable.startX = Math.round((note.x / 2) * 100);

package/utils/star-calc/sspmParser.ts

@@ -233,6 +233,9 @@ export class SSPMParser {
       version: this.readUInt16(),
       reserved: this.readBytes(4),
     };
+    if (header.version == 1) {
+      throw "Can't parse";
+    }
 
     // Static Metadata
     const metadata: StaticMetadata = {
@@ -278,7 +281,8 @@ export class SSPMParser {
       mapID: this.readString(),
       mapName: this.readString(),
       songName: this.readString(),
-      mappers: this.readStringList(this.readUInt16()),
+      mappers: [],
+      // mappers: this.readStringList(this.readUInt16()),
     };
 
     let customData: CustomData = { fields: [] };

package/utils/star-calc/sspmv1Parser.ts

@@ -0,0 +1,165 @@
+enum Difficulty {
+  NA = 0x00,
+  Easy = 0x01,
+  Medium = 0x02,
+  Hard = 0x03,
+  Logic = 0x04,
+  Tasukete = 0x05,
+}
+
+enum CoverStorageType {
+  None = 0x00,
+  PNG = 0x02,
+}
+
+enum AudioStorageType {
+  None = 0x00,
+  StoredAudioFile = 0x01,
+}
+
+enum NoteStorageType {
+  Integer = 0x00,
+  Quantum = 0x01,
+}
+
+interface Note {
+  position: number;
+  x: number;
+  y: number;
+}
+
+export interface SSPMMap {
+  id: string;
+  name: string;
+  creator: string;
+  lastNotePosition: number;
+  noteCount: number;
+  difficulty: Difficulty;
+  cover: Buffer | null;
+  audio: Buffer | null;
+  notes: Note[];
+}
+
+export class V1SSPMParser {
+  private buffer: Buffer;
+  private offset: number = 0;
+
+  constructor(buffer: Buffer) {
+    this.buffer = buffer;
+  }
+
+  parse(): SSPMMap {
+    this.validateHeader();
+    const metadata = this.parseMetadata();
+    const cover = this.parseCover();
+    const audio = this.parseAudio();
+    const notes = this.parseNotes(metadata.noteCount);
+
+    return {
+      ...metadata,
+      cover,
+      audio,
+      notes,
+    };
+  }
+
+  private validateHeader() {
+    const signature = this.buffer.slice(0, 4).toString("hex");
+    if (signature !== "53532b6d") {
+      throw new Error("Invalid SSPM file signature");
+    }
+
+    const version = this.buffer.readUInt16LE(4);
+    if (version !== 1) {
+      throw new Error(`Unsupported SSPM version: ${version}`);
+    }
+
+    this.offset = 8; // Skip reserved space
+  }
+
+  private parseMetadata(): Omit<SSPMMap, "cover" | "audio" | "notes"> {
+    const id = this.readString();
+    const name = this.readString();
+    const creator = this.readString();
+    const lastNotePosition = this.buffer.readUInt32LE(this.offset);
+    this.offset += 4;
+    const noteCount = this.buffer.readUInt32LE(this.offset);
+    this.offset += 4;
+    const difficulty = this.buffer.readUInt8(this.offset++) as Difficulty;
+
+    return { id, name, creator, lastNotePosition, noteCount, difficulty };
+  }
+
+  private parseCover(): Buffer | null {
+    const coverType = this.buffer.readUInt8(this.offset++) as CoverStorageType;
+    if (coverType === CoverStorageType.None) {
+      return null;
+    } else if (coverType === CoverStorageType.PNG) {
+      const length = this.buffer.readBigUInt64LE(this.offset);
+      this.offset += 8;
+      const cover = this.buffer.slice(
+        this.offset,
+        this.offset + Number(length)
+      );
+      this.offset += Number(length);
+      return cover;
+    } else {
+      throw new Error(`Unsupported cover storage type: ${coverType}`);
+    }
+  }
+
+  private parseAudio(): Buffer | null {
+    const audioType = this.buffer.readUInt8(this.offset++) as AudioStorageType;
+    if (audioType === AudioStorageType.None) {
+      return null;
+    } else if (audioType === AudioStorageType.StoredAudioFile) {
+      const length = this.buffer.readBigUInt64LE(this.offset);
+      this.offset += 8;
+      const audio = this.buffer.slice(
+        this.offset,
+        this.offset + Number(length)
+      );
+      this.offset += Number(length);
+      return audio;
+    } else {
+      throw new Error(`Unsupported audio storage type: ${audioType}`);
+    }
+  }
+
+  private parseNotes(count: number): Note[] {
+    const notes: Note[] = [];
+    for (let i = 0; i < count; i++) {
+      const position = this.buffer.readUInt32LE(this.offset);
+      this.offset += 4;
+      const storageType = this.buffer.readUInt8(
+        this.offset++
+      ) as NoteStorageType;
+
+      let x: number, y: number;
+      if (storageType === NoteStorageType.Integer) {
+        x = this.buffer.readUInt8(this.offset++);
+        y = this.buffer.readUInt8(this.offset++);
+      } else if (storageType === NoteStorageType.Quantum) {
+        x = this.buffer.readFloatLE(this.offset);
+        this.offset += 4;
+        y = this.buffer.readFloatLE(this.offset);
+        this.offset += 4;
+      } else {
+        throw new Error(`Unsupported note storage type: ${storageType}`);
+      }
+
+      notes.push({ position, x, y });
+    }
+    return notes;
+  }
+
+  private readString(): string {
+    let end = this.offset;
+    while (this.buffer[end] !== 0x0a) {
+      end++;
+    }
+    const str = this.buffer.slice(this.offset, end).toString("utf-8");
+    this.offset = end + 1;
+    return str;
+  }
+}