rhythia-api 236.0.0 → 238.0.0

package/api/executeAdminOperation.ts

@@ -7,6 +7,56 @@ import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
 import { invalidateCache, invalidateCachePrefix } from "../utils/cache";
 
+type AdminProfileSummary = Pick<
+  Database["public"]["Tables"]["profiles"]["Row"],
+  "id" | "username" | "avatar_url" | "flag" | "badges" | "ban"
+>;
+
+type InvestigationDateRange = {
+  firstSeenAt: string | null;
+  lastSeenAt: string | null;
+};
+
+type LinkedAccountAggregate = AdminProfileSummary &
+  InvestigationDateRange & {
+    occurrences: number;
+    sharedHwids: Set<string>;
+  };
+
+type LinkedProfileAggregate = AdminProfileSummary &
+  InvestigationDateRange & {
+    occurrences: number;
+  };
+
+const MULTIACCOUNT_PROFILE_SELECT =
+  "id, username, avatar_url, flag, badges, ban";
+
+const SCORE_CACHE_READ_OPERATIONS = new Set([
+  "getScoresPaginated",
+  "getMultiaccountInvestigation",
+]);
+
+function timestampOrZero(value: string | null) {
+  return value ? new Date(value).getTime() : 0;
+}
+
+function updateDateRange(
+  range: InvestigationDateRange,
+  createdAt: string | null
+) {
+  if (!createdAt) {
+    return;
+  }
+
+  if (!range.firstSeenAt || createdAt < range.firstSeenAt) {
+    range.firstSeenAt = createdAt;
+  }
+
+  if (!range.lastSeenAt || createdAt > range.lastSeenAt) {
+    range.lastSeenAt = createdAt;
+  }
+}
+
 // Define supported admin operations and their parameter types
 const adminOperations = {
   deleteUser: z.object({ userId: z.number() }),
@@ -28,6 +78,7 @@ const adminOperations = {
     userId: z.number().optional(),
     includeAdditionalData: z.boolean().default(true),
   }),
+  getMultiaccountInvestigation: z.object({ userId: z.number() }),
 } as const;
 
 // Create a discriminated union type for operation parameters
@@ -88,6 +139,10 @@ const OperationParam = z.discriminatedUnion("operation", [
     operation: z.literal("getScoresPaginated"),
     params: adminOperations.getScoresPaginated,
   }),
+  z.object({
+    operation: z.literal("getMultiaccountInvestigation"),
+    params: adminOperations.getMultiaccountInvestigation,
+  }),
 ]);
 
 export const Schema = {
@@ -346,6 +401,242 @@ export async function handler(
           };
         }
         break;
+
+      case "getMultiaccountInvestigation":
+        const { data: investigatedUser, error: investigatedUserError } =
+          await supabase
+            .from("profiles")
+            .select(MULTIACCOUNT_PROFILE_SELECT)
+            .eq("id", params.userId)
+            .maybeSingle();
+
+        if (investigatedUserError) {
+          result = { error: investigatedUserError, data: null };
+          break;
+        }
+
+        if (!investigatedUser) {
+          result = {
+            error: { message: "User not found" },
+            data: null,
+          };
+          break;
+        }
+
+        const { data: investigatedUserHwids, error: investigatedUserHwidsError } =
+          await supabase
+            .from("user_hwids")
+            .select("id, hwid, created_at")
+            .eq("id", params.userId)
+            .order("created_at", { ascending: false });
+
+        if (investigatedUserHwidsError) {
+          result = { error: investigatedUserHwidsError, data: null };
+          break;
+        }
+
+        const targetRows = investigatedUserHwids || [];
+        const uniqueHwids = Array.from(
+          new Set(targetRows.map((row) => row.hwid).filter(Boolean))
+        );
+
+        const dateRange: InvestigationDateRange = {
+          firstSeenAt: null,
+          lastSeenAt: null,
+        };
+
+        const hwidAggregates = new Map<
+          string,
+          InvestigationDateRange & {
+            hwid: string;
+            occurrences: number;
+            linkedProfiles: Map<number, LinkedProfileAggregate>;
+          }
+        >();
+
+        for (const row of targetRows) {
+          updateDateRange(dateRange, row.created_at);
+
+          const existing = hwidAggregates.get(row.hwid) || {
+            hwid: row.hwid,
+            occurrences: 0,
+            firstSeenAt: null,
+            lastSeenAt: null,
+            linkedProfiles: new Map<number, LinkedProfileAggregate>(),
+          };
+
+          existing.occurrences += 1;
+          updateDateRange(existing, row.created_at);
+          hwidAggregates.set(row.hwid, existing);
+        }
+
+        if (uniqueHwids.length === 0) {
+          result = {
+            data: {
+              user: investigatedUser,
+              summary: {
+                totalRows: 0,
+                uniqueHwids: 0,
+                sharedHwids: 0,
+                linkedAccounts: 0,
+                firstSeenAt: null,
+                lastSeenAt: null,
+              },
+              accounts: [],
+              hwids: [],
+            },
+            error: null,
+          };
+          break;
+        }
+
+        const { data: relatedRows, error: relatedRowsError } = await supabase
+          .from("user_hwids")
+          .select("id, hwid, created_at")
+          .in("hwid", uniqueHwids)
+          .order("created_at", { ascending: false });
+
+        if (relatedRowsError) {
+          result = { error: relatedRowsError, data: null };
+          break;
+        }
+
+        const relatedProfileIds = Array.from(
+          new Set(
+            (relatedRows || [])
+              .map((row) => row.id)
+              .filter((id) => id !== params.userId)
+          )
+        );
+
+        const { data: relatedProfiles, error: relatedProfilesError } =
+          relatedProfileIds.length > 0
+            ? await supabase
+                .from("profiles")
+                .select(MULTIACCOUNT_PROFILE_SELECT)
+                .in("id", relatedProfileIds)
+            : { data: [], error: null };
+
+        if (relatedProfilesError) {
+          result = { error: relatedProfilesError, data: null };
+          break;
+        }
+
+        const profileMap = new Map<number, AdminProfileSummary>([
+          [investigatedUser.id, investigatedUser],
+          ...((relatedProfiles || []) as AdminProfileSummary[]).map((profile) => [
+            profile.id,
+            profile,
+          ]),
+        ]);
+
+        const linkedAccountAggregates = new Map<number, LinkedAccountAggregate>();
+
+        for (const row of relatedRows || []) {
+          if (row.id === params.userId) {
+            continue;
+          }
+
+          const hwidAggregate = hwidAggregates.get(row.hwid);
+          const relatedProfile = profileMap.get(row.id);
+
+          if (!hwidAggregate || !relatedProfile) {
+            continue;
+          }
+
+          const linkedProfile =
+            hwidAggregate.linkedProfiles.get(row.id) || {
+              ...relatedProfile,
+              occurrences: 0,
+              firstSeenAt: null,
+              lastSeenAt: null,
+            };
+
+          linkedProfile.occurrences += 1;
+          updateDateRange(linkedProfile, row.created_at);
+          hwidAggregate.linkedProfiles.set(row.id, linkedProfile);
+
+          const linkedAccount = linkedAccountAggregates.get(row.id) || {
+            ...relatedProfile,
+            occurrences: 0,
+            sharedHwids: new Set<string>(),
+            firstSeenAt: null,
+            lastSeenAt: null,
+          };
+
+          linkedAccount.occurrences += 1;
+          linkedAccount.sharedHwids.add(row.hwid);
+          updateDateRange(linkedAccount, row.created_at);
+          linkedAccountAggregates.set(row.id, linkedAccount);
+        }
+
+        const accounts = Array.from(linkedAccountAggregates.values())
+          .map((account) => ({
+            ...account,
+            sharedHwids: Array.from(account.sharedHwids).sort(),
+            sharedHwidCount: account.sharedHwids.size,
+          }))
+          .sort((a, b) => {
+            if (b.sharedHwidCount !== a.sharedHwidCount) {
+              return b.sharedHwidCount - a.sharedHwidCount;
+            }
+
+            if (b.occurrences !== a.occurrences) {
+              return b.occurrences - a.occurrences;
+            }
+
+            return timestampOrZero(b.lastSeenAt) - timestampOrZero(a.lastSeenAt);
+          });
+
+        const hwids = Array.from(hwidAggregates.values())
+          .map((aggregate) => ({
+            hwid: aggregate.hwid,
+            occurrences: aggregate.occurrences,
+            firstSeenAt: aggregate.firstSeenAt,
+            lastSeenAt: aggregate.lastSeenAt,
+            linkedAccountCount: aggregate.linkedProfiles.size,
+            linkedProfiles: Array.from(aggregate.linkedProfiles.values()).sort(
+              (a, b) => {
+                if (b.occurrences !== a.occurrences) {
+                  return b.occurrences - a.occurrences;
+                }
+
+                return (
+                  timestampOrZero(b.lastSeenAt) - timestampOrZero(a.lastSeenAt)
+                );
+              }
+            ),
+          }))
+          .sort((a, b) => {
+            if (b.linkedAccountCount !== a.linkedAccountCount) {
+              return b.linkedAccountCount - a.linkedAccountCount;
+            }
+
+            if (b.occurrences !== a.occurrences) {
+              return b.occurrences - a.occurrences;
+            }
+
+            return timestampOrZero(b.lastSeenAt) - timestampOrZero(a.lastSeenAt);
+          });
+
+        result = {
+          data: {
+            user: investigatedUser,
+            summary: {
+              totalRows: targetRows.length,
+              uniqueHwids: uniqueHwids.length,
+              sharedHwids: hwids.filter((hwid) => hwid.linkedAccountCount > 0)
+                .length,
+              linkedAccounts: accounts.length,
+              firstSeenAt: dateRange.firstSeenAt,
+              lastSeenAt: dateRange.lastSeenAt,
+            },
+            accounts,
+            hwids,
+          },
+          error: null,
+        };
+        break;
     }
 
     // Log the admin action
@@ -366,7 +657,11 @@ export async function handler(
       );
     }
 
-    if (targetUserId !== null && !result?.error) {
+    if (
+      targetUserId !== null &&
+      !result?.error &&
+      !SCORE_CACHE_READ_OPERATIONS.has(operation)
+    ) {
       await invalidateCachePrefix(`userscore:${targetUserId}`);
     }
 

package/api/getCollection.ts

@@ -9,16 +9,17 @@ export const Schema = {
     collection: z.number(),
   }),
   output: z.object({
-    collection: z.object({
-      title: z.string(),
-      description: z.string(),
-      owner: z.object({
-        id: z.number(),
-        username: z.string(),
-      }),
-      isList: z.boolean(),
-      beatmaps: z.array(
-        z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      owner: z.object({
+        id: z.number(),
+        username: z.string(),
+        avatar_url: z.string().nullable(),
+      }),
+      isList: z.boolean(),
+      beatmaps: z.array(
+        z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
@@ -54,13 +55,14 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     .from("beatmapCollections")
     .select(
       `
-      *,
-      profiles!inner(
-        id,
-        username
-      )
-      `
-    )
+      *,
+      profiles!inner(
+        id,
+        username,
+        avatar_url
+      )
+      `
+    )
     .eq("id", data.collection)
     .single();
 
@@ -117,12 +119,13 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
 
   return NextResponse.json({
     collection: {
-      owner: {
-        username: queryCollectionData.profiles.username,
-        id: queryCollectionData.profiles.id,
-      },
-      isList: queryCollectionData.is_list,
-      title: queryCollectionData.title,
+      owner: {
+        username: queryCollectionData.profiles.username,
+        id: queryCollectionData.profiles.id,
+        avatar_url: queryCollectionData.profiles.avatar_url,
+      },
+      isList: queryCollectionData.is_list,
+      title: queryCollectionData.title,
       description: queryCollectionData.description,
       beatmaps: formattedBeatmaps,
     },

package/api/getProfile.ts

@@ -40,11 +40,12 @@ export const Schema = {
         country_position: z.number().nullable(),
         activity_status: z.enum(["active", "inactive"]),
         is_online: z.boolean(),
+        last_active_timestamp: z.number().nullable(),
         clans: z
           .object({
             id: z.number(),
-            acronym: z.string(),
-          })
+            acronym: z.string(),
+          })
           .optional()
           .nullable(),
       })
@@ -122,11 +123,11 @@ export async function handler(
 
   const activityStatus = await getActivityStatusForUserId(user.id);
 
-  const { data: activityData } = await supabase
-    .from("profileActivities")
-    .select("*")
-    .eq("uid", user.uid || "")
-    .single();
+  const { data: activityData } = await supabase
+    .from("profileActivities")
+    .select("last_activity")
+    .eq("uid", user.uid || "")
+    .single();
 
   //last 30 minutes
   if (activityData && activityData.last_activity) {
@@ -181,6 +182,7 @@ export async function handler(
       country_position: countryPosition,
       activity_status: activityStatus,
       is_online: isOnline,
+      last_active_timestamp: activityData?.last_activity ?? null,
     },
   });
 }

package/api/reportProfile.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 { postProfileReportWebhook } from "../utils/profileReportWebhook";
 
 const MAX_DESCRIPTION_LENGTH = 1000;
 
@@ -50,7 +51,7 @@ export async function handler({
   const user = (await getUserBySession(session)) as User;
   const { data: reporterProfile } = await supabase
     .from("profiles")
-    .select("id,ban")
+    .select("id,ban,username,computedUsername,avatar_url")
     .eq("uid", user.id)
     .single();
 
@@ -68,7 +69,7 @@ export async function handler({
 
   const { data: reportedProfile } = await supabase
     .from("profiles")
-    .select("id")
+    .select("id,username,computedUsername,avatar_url")
     .eq("id", profileId)
     .single();
 
@@ -83,12 +84,20 @@ export async function handler({
       reported: reportedProfile.id,
       description: trimmedDescription,
     })
-    .select("id")
+    .select("id,created_at")
     .single();
 
   if (insertResult.error) {
     return NextResponse.json({ error: insertResult.error.message });
   }
 
+  await postProfileReportWebhook({
+    reportId: insertResult.data.id,
+    reporter: reporterProfile,
+    reported: reportedProfile,
+    description: trimmedDescription,
+    createdAt: insertResult.data.created_at,
+  });
+
   return NextResponse.json({ id: insertResult.data?.id });
 }

package/index.ts

@@ -362,17 +362,7 @@ export const enhancedSearch = handleApi({url:"/api/enhancedSearch",...EnhancedSe
 // ./api/executeAdminOperation.ts API
 
 /*
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    data: OperationParam,
-  }),
-  output: z.object({
-    success: z.boolean(),
-    result: z.any().optional(),
-    error: z.string().optional(),
-  }),
-};*/
+*/
 import { Schema as ExecuteAdminOperation } from "./api/executeAdminOperation"
 export { Schema as SchemaExecuteAdminOperation } from "./api/executeAdminOperation"
 export const executeAdminOperation = handleApi({url:"/api/executeAdminOperation",...ExecuteAdminOperation})
@@ -773,16 +763,17 @@ export const Schema = {
     collection: z.number(),
   }),
   output: z.object({
-    collection: z.object({
-      title: z.string(),
-      description: z.string(),
-      owner: z.object({
-        id: z.number(),
-        username: z.string(),
-      }),
-      isList: z.boolean(),
-      beatmaps: z.array(
-        z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      owner: z.object({
+        id: z.number(),
+        username: z.string(),
+        avatar_url: z.string().nullable(),
+      }),
+      isList: z.boolean(),
+      beatmaps: z.array(
+        z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
@@ -1000,11 +991,12 @@ export const Schema = {
         country_position: z.number().nullable(),
         activity_status: z.enum(["active", "inactive"]),
         is_online: z.boolean(),
+        last_active_timestamp: z.number().nullable(),
         clans: z
           .object({
             id: z.number(),
-            acronym: z.string(),
-          })
+            acronym: z.string(),
+          })
           .optional()
           .nullable(),
       })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "236.0.0",
+  "version": "238.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {