rhythia-api 168.0.0 → 170.0.0

package/api/createClan.ts

@@ -0,0 +1,70 @@
+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(),
+    name: z.string(),
+    acronym: z.string(),
+  }),
+  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" });
+  }
+
+  if (queryUserData.clan !== null) {
+    return NextResponse.json({
+      error: "You can't create clans while in a clan.",
+    });
+  }
+
+  if (queryUserData.ban !== "cool") {
+    return NextResponse.json({
+      error: "You are have an active ban, can't create a clan.",
+    });
+  }
+
+  if (data.name.length < 3 || data.name.length > 32) {
+    return NextResponse.json({
+      error: "Clan name must be between 3 and 32 characters.",
+    });
+  }
+  if (data.acronym.length < 3 || data.acronym.length > 6) {
+    return NextResponse.json({
+      error: "Acronyms must be of length between 3 and 6",
+    });
+  }
+
+  await supabase.from("clans").upsert({
+    name: data.name,
+    owner: queryUserData.id,
+    acronym: data.acronym.toUpperCase(),
+  });
+
+  return NextResponse.json({});
+}

package/api/editClan.ts

@@ -0,0 +1,90 @@
+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(),
+    id: z.number(),
+    name: z.string(),
+    avatar_url: z.string(),
+    description: z.string(),
+    acronym: z.string(),
+  }),
+  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" });
+  }
+
+  let { data: queryClanData, error: clanError } = await supabase
+    .from("clans")
+    .select("*")
+    .eq("id", data.id)
+    .single();
+
+  if (!queryClanData) {
+    return NextResponse.json({ error: "No such clan ID" });
+  }
+
+  if (queryClanData.owner !== queryUserData.id) {
+    return NextResponse.json({ error: "You are not the owner" });
+  }
+
+  if (queryUserData.ban !== "cool") {
+    return NextResponse.json({
+      error: "You are have an active ban, can't edit a clan.",
+    });
+  }
+
+  if (data.name.length < 3 || data.name.length > 32) {
+    return NextResponse.json({
+      error: "Clan name must be between 3 and 32 characters.",
+    });
+  }
+
+  if (data.acronym.length < 3 || data.acronym.length > 6) {
+    return NextResponse.json({
+      error: "Acronyms must be of length between 3 and 6",
+    });
+  }
+
+  if (data.description.length > 24000) {
+    return NextResponse.json({
+      error: "Description length exceeds 24000 characters",
+    });
+  }
+
+  await supabase.from("clans").upsert({
+    id: data.id,
+    name: data.name,
+    avatar_url: data.avatar_url,
+    description: data.description,
+    acronym: data.acronym.toUpperCase(),
+  });
+
+  return NextResponse.json({});
+}

package/api/editProfile.ts

@@ -10,6 +10,7 @@ export const Schema = {
     session: z.string(),
     data: z.object({
       avatar_url: z.string().optional(),
+      profile_image: z.string().optional(),
       username: z.string().optional(),
     }),
   }),

package/api/getClan.ts

@@ -0,0 +1,79 @@
+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.object({
+    error: z.string().optional(),
+    acronym: z.string(),
+    avatar_url: z.string(),
+    created_at: z.number(),
+    description: z.string(),
+    id: z.number(),
+    name: z.string(),
+    owner: z.number(),
+    users: z.array(
+      z.object({
+        about_me: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        profile_image: z.string().nullable(),
+        badges: z.any().nullable(),
+        created_at: z.number().nullable(),
+        flag: z.string().nullable(),
+        id: z.number(),
+        uid: z.string().nullable(),
+        ban: z.string().nullable(),
+        username: z.string().nullable(),
+        verified: z.boolean().nullable(),
+        play_count: z.number().nullable(),
+        skill_points: z.number().nullable(),
+        squares_hit: z.number().nullable(),
+        total_score: z.number().nullable(),
+        position: z.number().nullable(),
+        is_online: z.boolean(),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  let { data: queryClanData, error: clanError } = await supabase
+    .from("clans")
+    .select("*")
+    .eq("id", data.id)
+    .single();
+
+  if (!queryClanData) {
+    return NextResponse.json({ error: "No such clan ID" });
+  }
+
+  let { data: queryUsers, error: usersError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("clan", queryClanData.id);
+
+  return NextResponse.json({
+    acronym: queryClanData.acronym,
+    avatar_url: queryClanData.avatar_url,
+    created_at: queryClanData.created_at,
+    description: queryClanData.description,
+    id: queryClanData.id,
+    name: queryClanData.name,
+    owner: queryClanData.owner,
+    users: queryUsers,
+  });
+}

package/api/submitScore.ts

@@ -89,6 +89,18 @@ export async function handler({
 
   const user = (await getUserBySession(session)) as User;
 
+  let { data: leversData } = await supabase
+    .from("levers")
+    .select("*")
+    .eq("id", 1)
+    .single();
+
+  if (leversData && leversData.disable_scores) {
+    return NextResponse.json({
+      error: "Scores are temporarily disabled",
+    });
+  }
+
   let { data: userData, error: userError } = await supabase
     .from("profiles")
     .select("*")
@@ -174,7 +186,10 @@ export async function handler({
     multiplierMod *= Math.pow(0.95, data.misses);
   }
 
-  if (beatmaps.starRating && beatmaps.starRating == data.virtualStars) {
+  if (
+    beatmaps.starRating &&
+    Math.abs(beatmaps.starRating - data.virtualStars) < 0.01
+  ) {
     awarded_sp = calculatePerformancePoints(
       data.speed * beatmaps.starRating * multiplierMod,
       accurracy
@@ -252,7 +267,7 @@ export async function handler({
   });
   console.log("p3");
 
-  if (awarded_sp > 99) {
+  if (awarded_sp > 99 && userData.ban == "cool") {
     await postToWebhooks({
       rp: Math.round(awarded_sp * 100) / 100,
       username: userData.username || "",
@@ -268,6 +283,12 @@ export async function handler({
     });
   }
 
+  if (Math.abs((beatmaps.starRating || 0) - data.virtualStars) > 0.01) {
+    return NextResponse.json({
+      error: "Map mismatch, no RP points were awarded, please report the bug.",
+    });
+  }
+
   return NextResponse.json({});
 }
 

package/index.ts

@@ -50,6 +50,23 @@ import { Schema as CreateBeatmapPage } from "./api/createBeatmapPage"
 export { Schema as SchemaCreateBeatmapPage } from "./api/createBeatmapPage"
 export const createBeatmapPage = handleApi({url:"/api/createBeatmapPage",...CreateBeatmapPage})
 
+// ./api/createClan.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    name: z.string(),
+    acronym: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as CreateClan } from "./api/createClan"
+export { Schema as SchemaCreateClan } from "./api/createClan"
+export const createClan = handleApi({url:"/api/createClan",...CreateClan})
+
 // ./api/deleteBeatmapPage.ts API
 
 /*
@@ -84,6 +101,26 @@ import { Schema as EditAboutMe } from "./api/editAboutMe"
 export { Schema as SchemaEditAboutMe } from "./api/editAboutMe"
 export const editAboutMe = handleApi({url:"/api/editAboutMe",...EditAboutMe})
 
+// ./api/editClan.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+    name: z.string(),
+    avatar_url: z.string(),
+    description: z.string(),
+    acronym: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as EditClan } from "./api/editClan"
+export { Schema as SchemaEditClan } from "./api/editClan"
+export const editClan = handleApi({url:"/api/editClan",...EditClan})
+
 // ./api/editProfile.ts API
 
 /*
@@ -92,6 +129,7 @@ export const Schema = {
     session: z.string(),
     data: z.object({
       avatar_url: z.string().optional(),
+      profile_image: z.string().optional(),
       username: z.string().optional(),
     }),
   }),
@@ -323,6 +361,50 @@ import { Schema as GetBeatmapStarRating } from "./api/getBeatmapStarRating"
 export { Schema as SchemaGetBeatmapStarRating } from "./api/getBeatmapStarRating"
 export const getBeatmapStarRating = handleApi({url:"/api/getBeatmapStarRating",...GetBeatmapStarRating})
 
+// ./api/getClan.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    acronym: z.string(),
+    avatar_url: z.string(),
+    created_at: z.number(),
+    description: z.string(),
+    id: z.number(),
+    name: z.string(),
+    owner: z.number(),
+    users: z.array(
+      z.object({
+        about_me: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        profile_image: z.string().nullable(),
+        badges: z.any().nullable(),
+        created_at: z.number().nullable(),
+        flag: z.string().nullable(),
+        id: z.number(),
+        uid: z.string().nullable(),
+        ban: z.string().nullable(),
+        username: z.string().nullable(),
+        verified: z.boolean().nullable(),
+        play_count: z.number().nullable(),
+        skill_points: z.number().nullable(),
+        squares_hit: z.number().nullable(),
+        total_score: z.number().nullable(),
+        position: z.number().nullable(),
+        is_online: z.boolean(),
+      })
+    ),
+  }),
+};*/
+import { Schema as GetClan } from "./api/getClan"
+export { Schema as SchemaGetClan } from "./api/getClan"
+export const getClan = handleApi({url:"/api/getClan",...GetClan})
+
 // ./api/getLeaderboard.ts API
 
 /*

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "rhythia-api",
-  "version": "168.0.0",
+  "version": "170.0.0",
   "main": "index.ts",
+  "author": "online-contributors",
   "scripts": {
     "update": "bun ./scripts/update.ts",
     "ci-deploy": "tsx ./scripts/ci-deploy.ts",

package/types/database.ts

@@ -153,6 +153,44 @@ export type Database = {
         }
         Relationships: []
       }
+      clans: {
+        Row: {
+          acronym: string | null
+          avatar_url: string | null
+          created_at: string
+          description: string | null
+          id: number
+          name: string
+          owner: number | null
+        }
+        Insert: {
+          acronym?: string | null
+          avatar_url?: string | null
+          created_at?: string
+          description?: string | null
+          id?: number
+          name?: string
+          owner?: number | null
+        }
+        Update: {
+          acronym?: string | null
+          avatar_url?: string | null
+          created_at?: string
+          description?: string | null
+          id?: number
+          name?: string
+          owner?: number | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "clans_owner_fkey"
+            columns: ["owner"]
+            isOneToOne: false
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       discordWebhooks: {
         Row: {
           id: number
@@ -168,6 +206,21 @@ export type Database = {
         }
         Relationships: []
       }
+      levers: {
+        Row: {
+          disable_scores: boolean
+          id: number
+        }
+        Insert: {
+          disable_scores?: boolean
+          id?: number
+        }
+        Update: {
+          disable_scores?: boolean
+          id?: number
+        }
+        Relationships: []
+      }
       passkeys: {
         Row: {
           email: string
@@ -216,6 +269,7 @@ export type Database = {
           badges: Json | null
           ban: Database["public"]["Enums"]["banTypes"] | null
           bannedAt: number | null
+          clan: number | null
           computedUsername: string | null
           created_at: number | null
           flag: string | null
@@ -238,6 +292,7 @@ export type Database = {
           badges?: Json | null
           ban?: Database["public"]["Enums"]["banTypes"] | null
           bannedAt?: number | null
+          clan?: number | null
           computedUsername?: string | null
           created_at?: number | null
           flag?: string | null
@@ -260,6 +315,7 @@ export type Database = {
           badges?: Json | null
           ban?: Database["public"]["Enums"]["banTypes"] | null
           bannedAt?: number | null
+          clan?: number | null
           computedUsername?: string | null
           created_at?: number | null
           flag?: string | null
@@ -276,7 +332,15 @@ export type Database = {
           username?: string | null
           verified?: boolean | null
         }
-        Relationships: []
+        Relationships: [
+          {
+            foreignKeyName: "profiles_clan_fkey"
+            columns: ["clan"]
+            isOneToOne: false
+            referencedRelation: "clans"
+            referencedColumns: ["id"]
+          },
+        ]
       }
       scores: {
         Row: {

package/utils/requestUtils.ts

@@ -23,7 +23,22 @@ export async function protectedApi({
     const toParse = await request.json();
     const data = schema.input.parse(toParse);
 
-    console.log({ ...data, session: undefined });
+    const dataClone = structuredClone(data);
+    if (dataClone) {
+      if (dataClone["token"]) {
+        dataClone["token"] = "********";
+      }
+      Object.keys(dataClone).forEach((key) => {
+        console.log("KEY: ", key, dataClone[key]);
+        if (key == "data") {
+          try {
+            Object.keys(dataClone[key]).forEach((key2) => {
+              console.log("KEY2: ", key2, dataClone[key][key2]);
+            });
+          } catch (error) {}
+        }
+      });
+    }
 
     setActivity(data);
     if (authorization) {

package/utils/validateToken.ts

@@ -1,6 +1,7 @@
 export function validateIntrinsicToken(token: string) {
-  if (!process.env.validationCode) return true;
-  const generatedValidationCode = eval(process.env.validationCode);
-  console.log(generatedValidationCode, token);
-  return generatedValidationCode == token;
+  return true;
+  // if (!process.env.validationCode) return true;
+  // const generatedValidationCode = eval(process.env.validationCode);
+  // console.log(generatedValidationCode, token);
+  // return generatedValidationCode == token;
 }