rhythia-api 172.0.0 → 174.0.0

package/api/chartPublicStats.ts

@@ -0,0 +1,32 @@
+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({}),
+  output: z.object({}),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  // 30 minutes activity
+  const countOnline = await supabase
+    .from("profileActivities")
+    .select("*", { count: "exact", head: true })
+    .gt("last_activity", Date.now() - 1800000);
+
+  await supabase.from("chartedValues").insert({
+    type: "online_players",
+    value: countOnline.count,
+  });
+  return NextResponse.json({});
+}

package/api/createBeatmap.ts

@@ -73,7 +73,7 @@ export async function handler({
     return NextResponse.json(
       {
         error:
-          "Silenced, restricted or excluded players can't update their profile.",
+          "Silenced, restricted or excluded players can't create beatmaps their profile.",
       },
       { status: 404 }
     );
@@ -86,6 +86,9 @@ export async function handler({
     .single();
 
   if (beatmapPage) {
+    if (beatmapPage?.status !== "UNRANKED")
+      return NextResponse.json({ error: "Only unranked maps can be updated" });
+
     if (!updateFlag) {
       return NextResponse.json({ error: "Already Exists" });
     } else if (beatmapPage.owner !== userData.id) {

package/api/createBeatmapPage.ts

@@ -46,7 +46,7 @@ export async function handler({
     return NextResponse.json(
       {
         error:
-          "Silenced, restricted or excluded players can't update their profile.",
+          "Silenced, restricted or excluded players can't create beatmap pages.",
       },
       { status: 404 }
     );
@@ -59,5 +59,6 @@ export async function handler({
     })
     .select("*")
     .single();
+
   return NextResponse.json({ id: upserted.data?.id });
 }

package/api/editProfile.ts

@@ -5,6 +5,9 @@ import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import validator from "validator";
+import removeZeroWidth from "zero-width";
+
 export const Schema = {
   input: z.strictObject({
     session: z.string(),
@@ -49,6 +52,17 @@ export async function handler(
     );
   }
 
+  if (validator.trim(data.data.username || "") !== (data.data.username || "")) {
+    return NextResponse.json(
+      {
+        error: "Username can't start or end with spaces.",
+      },
+      { status: 404 }
+    );
+  }
+
+  data.data.username = removeZeroWidth(data.data.username || "");
+
   const user = (await getUserBySession(data.session)) as User;
 
   let userData: Database["public"]["Tables"]["profiles"]["Update"];

package/api/getPublicStats.ts

@@ -10,6 +10,12 @@ export const Schema = {
     beatmaps: z.number(),
     scores: z.number(),
     onlineUsers: z.number(),
+    countChart: z.array(
+      z.object({
+        type: z.string(),
+        value: z.number(),
+      })
+    ),
     lastBeatmaps: z.array(
       z.object({
         id: z.number().nullable().optional(),
@@ -127,11 +133,18 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     .select("*", { count: "exact", head: true })
     .gt("last_activity", Date.now() - 1800000);
 
+  const countChart = await supabase
+    .from("chartedValues")
+    .select("*")
+    .eq("type", "online_players")
+    .gt("created_at", new Date(Date.now() - 86400000).toISOString());
+
   return NextResponse.json({
     beatmaps: countBeatmapsQuery.count,
     profiles: countProfilesQuery.count,
     scores: countScoresQuery.count,
     onlineUsers: countOnline.count,
+    countChart: countChart.data,
     lastBeatmaps: beatmapPage?.map((e) => ({
       playcount: e.beatmaps?.playcount,
       created_at: e.created_at,

package/api/getRawStarRating.ts

@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { calculatePerformancePoints, rateMapNotes } from "../utils/star-calc";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    rawMap: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    beatmap: z
+      .object({
+        starRating: z.number().nullable().optional(),
+      })
+      .optional(),
+  }),
+};
+
+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"],
+  req: Request
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const notes = data.rawMap.split(",");
+  notes.shift();
+
+  const rawNotes = notes.map(
+    (e) => e.split("|").map((e) => Number(e)) as [number, number, number]
+  );
+  const starRating = rateMapNotes(rawNotes);
+  return NextResponse.json({
+    beatmap: {
+      starRating,
+      rp: {
+        "S---": calculatePerformancePoints((starRating * 1) / 1.35, 1),
+        "S--": calculatePerformancePoints((starRating * 1) / 1.25, 1),
+        "S-": calculatePerformancePoints((starRating * 1) / 1.15, 1),
+        S: calculatePerformancePoints(starRating * 1, 1),
+        "S+": calculatePerformancePoints(starRating * 1.15, 1),
+        "S++": calculatePerformancePoints(starRating * 1.25, 1),
+        "S+++": calculatePerformancePoints(starRating * 1.35, 1),
+        "S++++": calculatePerformancePoints(starRating * 1.45, 1),
+      },
+    },
+  });
+}

package/api/searchUsers.ts

@@ -30,13 +30,27 @@ export async function POST(request: Request) {
 }
 
 export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const { data: exactUser } = await supabase
+    .from("profiles")
+    .select("id,username")
+    .neq("ban", "excluded")
+    .eq("computedUsername", data.text.toLocaleLowerCase())
+    .single();
+
   const { data: searchData, error } = await supabase
     .from("profiles")
     .select("id,username")
     .neq("ban", "excluded")
     .ilike("username", `%${data.text}%`)
     .limit(10);
+
+  const conjoined = searchData || [];
+
+  if (exactUser && !conjoined.some((user) => user.id === exactUser?.id)) {
+    conjoined.unshift(exactUser);
+  }
+
   return NextResponse.json({
-    results: searchData || [],
+    results: conjoined || [],
   });
 }

package/api/submitScore.ts

@@ -116,6 +116,16 @@ export async function handler({
     );
 
   console.log(userData);
+
+  if (userData.ban == "excluded" || userData.ban == "restricted") {
+    return NextResponse.json(
+      {
+        error: "Silenced, restricted or excluded players can't submit scores.",
+      },
+      { status: 400 }
+    );
+  }
+
   let { data: beatmaps, error } = await supabase
     .from("beatmaps")
     .select("*")
@@ -386,7 +396,10 @@ export async function postToWebhooks({
   mapid: number;
   misses: number;
 }) {
-  const webHooks = await supabase.from("discordWebhooks").select("*");
+  const webHooks = await supabase
+    .from("discordWebhooks")
+    .select("*")
+    .eq("type", "scores");
 
   if (!webHooks.data) return;
 

package/api/updateBeatmapPage.ts

@@ -4,6 +4,7 @@ import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import { calculatePerformancePoints } from "./submitScore";
 
 export const Schema = {
   input: z.strictObject({
@@ -26,7 +27,14 @@ export async function POST(request: Request): Promise<NextResponse> {
     activity: handler,
   });
 }
-
+export function formatTime(milliseconds: number): string {
+  const totalSeconds = Math.floor(milliseconds / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes.toString().padStart(2, "0")}:${seconds
+    .toString()
+    .padStart(2, "0")}`;
+}
 export async function handler({
   session,
   beatmapHash,
@@ -92,5 +100,130 @@ export async function handler({
   if (upserted.error?.message.length) {
     return NextResponse.json({ error: upserted.error.message });
   }
+
+  if (beatmapData?.starRating) {
+    postBeatmapToWebhooks({
+      username: userData.username || "",
+      userid: userData.id,
+      avatar: userData.avatar_url || "",
+      mapimage: beatmapData?.image || "",
+      mapname: beatmapData?.title || "",
+      mapid: upserted.data?.id || 0,
+      mapDownload: beatmapData?.beatmapFile || "",
+      starRating: beatmapData?.starRating || 0,
+      length: beatmapData?.length || 0,
+    });
+  }
+
   return NextResponse.json({});
 }
+
+const beatmapWebhookTemplate: any = {
+  content: null,
+  embeds: [
+    {
+      title: "Captain Lou Albano - Do the Mario",
+      description: "Beatmap Created",
+      url: "https://www.rhythia.com/maps/4469",
+      color: 16775930,
+      fields: [
+        {
+          name: "Star Rating",
+          value: "12.4*",
+          inline: true,
+        },
+        {
+          name: "Length",
+          value: "4:24 minutes",
+          inline: true,
+        },
+        {
+          name: "Max RP",
+          value: "100 RP",
+          inline: true,
+        },
+      ],
+      author: {
+        name: "cunev",
+        url: "https://www.rhythia.com/player/0",
+        icon_url:
+          "https://static.rhythia.com/user-avatar-1735149648551-a2a8cfbe-af5d-46e8-a19a-be2339c1679a",
+      },
+      footer: {
+        text: "Sun, 22 Dec 2024 22:40:17 GMT",
+      },
+      thumbnail: {
+        url: "https://static.rhythia.com/beatmap-img-1735995790136-gen_-_frozy_tomo_-_islands_(kompa_pasi%C3%B3n)large",
+      },
+    },
+    {
+      title: "Direct download",
+      url: "https://www.rhythia.com/maps/4469",
+      color: null,
+    },
+  ],
+  attachments: [],
+};
+
+export async function postBeatmapToWebhooks({
+  username,
+  userid,
+  avatar,
+  mapimage,
+  mapname,
+  mapid,
+  starRating,
+  length,
+  mapDownload,
+}: {
+  username: string;
+  userid: number;
+  avatar: string;
+  mapimage: string;
+  mapname: string;
+  mapid: number;
+  starRating: number;
+  length: number;
+  mapDownload: string;
+}) {
+  // format length in MM:SS with padding 0
+
+  const webHooks = await supabase
+    .from("discordWebhooks")
+    .select("*")
+    .eq("type", "maps");
+
+  if (!webHooks.data) return;
+
+  for (const webhook of webHooks.data) {
+    const webhookUrl = webhook.webhook_link;
+
+    const mainEmbed = beatmapWebhookTemplate.embeds[0];
+    const downloadEmbed = beatmapWebhookTemplate.embeds[1];
+
+    mainEmbed.title = mapname;
+    mainEmbed.url = `https://www.rhythia.com/maps/${mapid}`;
+    mainEmbed.fields[0].value = `${Math.round(starRating * 100) / 100}*`;
+    mainEmbed.fields[1].value = `${formatTime(length)} minutes`;
+    mainEmbed.fields[2].value =
+      calculatePerformancePoints(starRating, 1) + " RP";
+    mainEmbed.author.name = username;
+    mainEmbed.author.url = `https://www.rhythia.com/player/${userid}`;
+    mainEmbed.author.icon_url = avatar;
+    mainEmbed.thumbnail.url = mapimage;
+    if (mapimage.includes("backfill")) {
+      mainEmbed.thumbnail.url = "https://www.rhythia.com/unkimg.png";
+    }
+    mainEmbed.footer.text = new Date().toUTCString();
+
+    downloadEmbed.url = mapDownload;
+
+    await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(beatmapWebhookTemplate),
+    });
+  }
+}

package/index.ts

@@ -16,6 +16,17 @@ import { Schema as ApproveMap } from "./api/approveMap"
 export { Schema as SchemaApproveMap } from "./api/approveMap"
 export const approveMap = handleApi({url:"/api/approveMap",...ApproveMap})
 
+// ./api/chartPublicStats.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({}),
+  output: z.object({}),
+};*/
+import { Schema as ChartPublicStats } from "./api/chartPublicStats"
+export { Schema as SchemaChartPublicStats } from "./api/chartPublicStats"
+export const chartPublicStats = handleApi({url:"/api/chartPublicStats",...ChartPublicStats})
+
 // ./api/createBeatmap.ts API
 
 /*
@@ -540,6 +551,12 @@ export const Schema = {
     beatmaps: z.number(),
     scores: z.number(),
     onlineUsers: z.number(),
+    countChart: z.array(
+      z.object({
+        type: z.string(),
+        value: z.number(),
+      })
+    ),
     lastBeatmaps: z.array(
       z.object({
         id: z.number().nullable().optional(),
@@ -583,6 +600,27 @@ import { Schema as GetPublicStats } from "./api/getPublicStats"
 export { Schema as SchemaGetPublicStats } from "./api/getPublicStats"
 export const getPublicStats = handleApi({url:"/api/getPublicStats",...GetPublicStats})
 
+// ./api/getRawStarRating.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    rawMap: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    beatmap: z
+      .object({
+        starRating: z.number().nullable().optional(),
+      })
+      .optional(),
+  }),
+};*/
+import { Schema as GetRawStarRating } from "./api/getRawStarRating"
+export { Schema as SchemaGetRawStarRating } from "./api/getRawStarRating"
+export const getRawStarRating = handleApi({url:"/api/getRawStarRating",...GetRawStarRating})
+
 // ./api/getScore.ts API
 
 /*