rhythia-api 192.0.0 → 194.0.0

package/api/createSupporter.ts

@@ -0,0 +1,145 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    type: z.enum([
+      "membership.started",
+      "membership.ended",
+      "membership.updated",
+    ]),
+    live_mode: z.boolean(),
+    attempt: z.number().nullable(),
+    created: z.number().nullable(),
+    event_id: z.number().nullable(),
+    data: z.object({
+      id: z.number().nullable(),
+      amount: z.number().nullable(),
+      object: z.enum(["membership"]).nullable(),
+      paused: z.enum(["true", "false"]).nullable(),
+      status: z.enum(["active", "inactive"]).nullable(),
+      canceled: z.enum(["true", "false"]).nullable(),
+      currency: z.string().nullable(),
+      psp_id: z.string().nullable(),
+      duration_type: z.enum(["month", "year"]).nullable(),
+      membership_level_id: z.number().nullable(),
+      membership_level_name: z.string().nullable(),
+      started_at: z.number().nullable(),
+      canceled_at: z.string().nullable(),
+      note_hidden: z.boolean().nullable(),
+      support_note: z.string().nullable(),
+      supporter_name: z.string().nullable(),
+      supporter_id: z.number().nullable(),
+      supporter_email: z.string().nullable(),
+      current_period_end: z.number().nullable(),
+      current_period_start: z.number().nullable(),
+      supporter_feedback: z.any(),
+    }),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  const sig = request.url.split("key=")[1];
+  if (process.env.BUY_SECRET !== sig) {
+    return NextResponse.json({
+      error: "Invalid Signature",
+    });
+  }
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"],
+  request: Request
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  let user: any;
+  if (
+    !(data.type === "membership.started" || data.type === "membership.updated")
+  ) {
+    return NextResponse.json({
+      error: "Invalid type",
+    });
+  }
+
+  if (data.data.status !== "active") {
+    return NextResponse.json({
+      error: "Inactive",
+    });
+  }
+
+  if (data.data.supporter_email) {
+    const emlRes = await supabase.rpc("get_user_by_email", {
+      email_address: data.data.supporter_email,
+    });
+
+    if (emlRes.data) {
+      let { data: queryData, error } = await supabase
+        .from("profiles")
+        .select("*")
+        .eq("uid", (emlRes.data as any).id)
+        .single();
+      if (queryData) {
+        user = queryData;
+      }
+    }
+  }
+
+  if (data.data.support_note) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("computedUsername", data.data.support_note)
+      .single();
+
+    if (queryData) {
+      user = queryData;
+    }
+  }
+
+  if (data.data.supporter_name) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("computedUsername", data.data.supporter_name)
+      .single();
+
+    if (queryData) {
+      user = queryData;
+    }
+  }
+
+  if (data.data.membership_level_name !== "Supporter") {
+    return NextResponse.json({
+      error: "Invalid membership",
+    });
+  }
+
+  const endDate = (data.data.current_period_end || 0) * 1000;
+
+  if (!user) {
+    return NextResponse.json({
+      error: "No such player",
+    });
+  }
+
+  const upsertResult = await supabase
+    .from("profiles")
+    .upsert({
+      id: user.id,
+      verificationDeadline: endDate,
+      verified: true,
+    })
+    .select();
+
+  return NextResponse.json({});
+}

package/api/getBeatmapPage.ts

@@ -120,6 +120,7 @@ export async function handler(
       userId: score.userid,
       username: score.username,
       avatar_url: score.avatar_url,
+      accuracy: score.accuracy,
     })),
     beatmap: {
       playcount: beatmapPage.beatmaps?.playcount,

package/api/getBeatmaps.ts

@@ -72,15 +72,14 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
     .from("beatmapPages")
     .select("id", { count: "exact", head: true });
 
-  let qry = supabase
-    .from("beatmapPages")
-    .select(
-      `
+  let qry = supabase.from("beatmapPages").select(
+    `
         owner,
         created_at,
         id,
         status,
         tags,
+        ranked_at,
         beatmaps!inner(
           playcount,
           ranked,
@@ -94,8 +93,13 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
         profiles!inner(
           username
         )`
-    )
-    .order("created_at", { ascending: false });
+  );
+
+  if (data.status == "RANKED") {
+    qry = qry.order("ranked_at", { ascending: false });
+  } else {
+    qry = qry.order("created_at", { ascending: false });
+  }
 
   if (data.textFilter) {
     qry = qry.ilike("beatmaps.title", `%${data.textFilter}%`);

package/api/getProfile.ts

@@ -27,6 +27,7 @@ export const Schema = {
         ban: z.string().nullable(),
         username: z.string().nullable(),
         verified: z.boolean().nullable(),
+        verificationDeadline: z.number().nullable(),
         play_count: z.number().nullable(),
         skill_points: z.number().nullable(),
         squares_hit: z.number().nullable(),
@@ -136,6 +137,16 @@ export async function handler(
     .neq("ban", "excluded")
     .gt("skill_points", user.skill_points);
 
+  if (user.verificationDeadline < Date.now()) {
+    await supabase
+      .from("profiles")
+      .upsert({
+        id: user.id,
+        verified: false,
+      })
+      .select();
+  }
+
   return NextResponse.json({
     user: {
       ...user,

package/api/getUserScores.ts

@@ -45,6 +45,7 @@ export const Schema = {
           beatmapHash: z.string().nullable(), // Add beatmapHash to the schema
           beatmapTitle: z.string().nullable(),
           difficulty: z.number().nullable(),
+          beatmapNotes: z.number().optional().nullable(),
         })
       )
       .optional(),
@@ -190,6 +191,7 @@ export async function handler(
       spin: s.spin,
       beatmapHash: s.beatmaphash,
       beatmapTitle: s.beatmaptitle,
+      beatmapNotes: s.notes,
       difficulty: s.difficulty,
     })),
     top: vals?.map((s) => ({

package/api/rankMapsArchive.ts

@@ -38,15 +38,21 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
 
   const tags = (queryUserData?.badges || []) as string[];
 
-  if (!tags.includes("Bot")) {
-    return NextResponse.json({ error: "Only Bots can force-rank maps!" });
+  if (
+    !(
+      tags.includes("Bot") ||
+      tags.includes("Admin") ||
+      tags.includes("MMT") ||
+      tags.includes("Developer")
+    )
+  ) {
+    return NextResponse.json({ error: "Only management can force-rank maps!" });
   }
 
   const { data: mapData, error } = await supabase
     .from("beatmapPages")
     .select("id,nominations,owner,status")
-    .eq("owner", user.id)
-    .eq("status", "UNRANKED");
+    .eq("id", data.mapId);
 
   if (!mapData) {
     return NextResponse.json({ error: "Bad map" });
@@ -57,6 +63,7 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
       id: element.id,
       nominations: [queryUserData.id, queryUserData.id],
       status: "RANKED",
+      ranked_at: Date.now(),
     });
   }
 

package/index.ts

@@ -136,6 +136,52 @@ import { Schema as CreateInvite } from "./api/createInvite"
 export { Schema as SchemaCreateInvite } from "./api/createInvite"
 export const createInvite = handleApi({url:"/api/createInvite",...CreateInvite})
 
+// ./api/createSupporter.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    type: z.enum([
+      "membership.started",
+      "membership.ended",
+      "membership.updated",
+    ]),
+    live_mode: z.boolean(),
+    attempt: z.number().nullable(),
+    created: z.number().nullable(),
+    event_id: z.number().nullable(),
+    data: z.object({
+      id: z.number().nullable(),
+      amount: z.number().nullable(),
+      object: z.enum(["membership"]).nullable(),
+      paused: z.enum(["true", "false"]).nullable(),
+      status: z.enum(["active", "inactive"]).nullable(),
+      canceled: z.enum(["true", "false"]).nullable(),
+      currency: z.string().nullable(),
+      psp_id: z.string().nullable(),
+      duration_type: z.enum(["month", "year"]).nullable(),
+      membership_level_id: z.number().nullable(),
+      membership_level_name: z.string().nullable(),
+      started_at: z.number().nullable(),
+      canceled_at: z.string().nullable(),
+      note_hidden: z.boolean().nullable(),
+      support_note: z.string().nullable(),
+      supporter_name: z.string().nullable(),
+      supporter_id: z.number().nullable(),
+      supporter_email: z.string().nullable(),
+      current_period_end: z.number().nullable(),
+      current_period_start: z.number().nullable(),
+      supporter_feedback: z.any(),
+    }),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as CreateSupporter } from "./api/createSupporter"
+export { Schema as SchemaCreateSupporter } from "./api/createSupporter"
+export const createSupporter = handleApi({url:"/api/createSupporter",...CreateSupporter})
+
 // ./api/deleteBeatmapPage.ts API
 
 /*
@@ -776,6 +822,7 @@ export const Schema = {
         ban: z.string().nullable(),
         username: z.string().nullable(),
         verified: z.boolean().nullable(),
+        verificationDeadline: z.number().nullable(),
         play_count: z.number().nullable(),
         skill_points: z.number().nullable(),
         squares_hit: z.number().nullable(),
@@ -969,6 +1016,7 @@ export const Schema = {
           beatmapHash: z.string().nullable(), // Add beatmapHash to the schema
           beatmapTitle: z.string().nullable(),
           difficulty: z.number().nullable(),
+          beatmapNotes: z.number().optional().nullable(),
         })
       )
       .optional(),

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "rhythia-api",
-  "version": "192.0.0",
+  "version": "194.0.0",
   "main": "index.ts",
-  "author": "online-contributors",
+  "author": "online-contributors-cunev",
   "scripts": {
     "update": "bun ./scripts/update.ts",
     "ci-deploy": "tsx ./scripts/ci-deploy.ts",
@@ -43,12 +43,12 @@
     "sharp": "^0.33.5",
     "short-uuid": "^5.2.0",
     "simple-git": "^3.25.0",
-    "supabase": "^2.15.8",
+    "supabase": "^2.19.7",
     "tsx": "^4.17.0",
     "utf-8-validate": "^6.0.4",
     "uuid": "^11.1.0",
     "validator": "^13.12.0",
     "zero-width": "^1.0.29",
-    "zod": "^3.23.8"
+    "zod": "^3.24.2"
   }
 }

package/types/database.ts

@@ -412,6 +412,7 @@ export type Database = {
           total_score: number | null
           uid: string | null
           username: string | null
+          verificationDeadline: number
           verified: boolean | null
         }
         Insert: {
@@ -435,6 +436,7 @@ export type Database = {
           total_score?: number | null
           uid?: string | null
           username?: string | null
+          verificationDeadline?: number
           verified?: boolean | null
         }
         Update: {
@@ -458,6 +460,7 @@ export type Database = {
           total_score?: number | null
           uid?: string | null
           username?: string | null
+          verificationDeadline?: number
           verified?: boolean | null
         }
         Relationships: [
@@ -754,6 +757,33 @@ export type Database = {
           avatar_url: string
         }[]
       }
+      get_top_scores_for_beatmap2: {
+        Args: {
+          beatmap_hash: string
+        }
+        Returns: {
+          id: number
+          awarded_sp: number
+          created_at: string
+          misses: number
+          mods: Json
+          passed: boolean
+          replayhwid: string
+          songid: string
+          speed: number
+          spin: boolean
+          userid: number
+          username: string
+          avatar_url: string
+          accuracy: number
+        }[]
+      }
+      get_user_by_email: {
+        Args: {
+          email_address: string
+        }
+        Returns: Json
+      }
       get_user_reigning_scores:
         | {
             Args: {
@@ -792,6 +822,7 @@ export type Database = {
               beatmaphash: string
               beatmaptitle: string
               difficulty: number
+              notes: number
             }[]
           }
     }