renamed recents to userratingbase

components/userRatingBase/action.ts

@@ -0,0 +1,121 @@
+"use server";
+import { getAuth } from "@/auth/queries/getauth";
+import { supportedVersionNumber } from "@/lib/helpers";
+import { artemis } from "@/lib/prisma";
+
+export async function getUserRatingBaseList() {
+  const { user } = await getAuth();
+
+  if (!user || !user.accessCode) {
+    throw new Error("User is not authenticated or accessCode is missing");
+  }
+
+  try {
+    const userRatingBaseList = await artemis.chuni_profile_rating.findMany({
+      where: {
+        user: user.UserId,
+        type: "userRatingBaseList",
+        version: supportedVersionNumber,
+      },
+      select: {
+        musicId: true,
+        score: true,
+        difficultId: true,
+        version: true,
+        index: true,
+      },
+      orderBy: {
+        index: "asc",
+      },
+    });
+
+    const staticMusicInfo = await artemis.chuni_static_music.findMany({
+      where: {
+        songId: {
+          in: userRatingBaseList.map((entry) => entry.musicId!),
+        },
+        version: supportedVersionNumber,
+      },
+      select: {
+        songId: true,
+        title: true,
+        artist: true,
+        chartId: true,
+        level: true,
+        genre: true,
+        jacketPath: true,
+      },
+    });
+
+    // chartId is the difficutly i.e
+    // easy, hard, expert, master, ultima, worlds end
+
+    // msuicId is the id of the specific song in the rating table
+    // we are mapping that to songId in chuni static music
+    //  so we can get name and jacket path etc
+    // then we are mapping the difficultId to the chartId to get the proper difficutly from above
+    // this is very confusing and my brain hurts
+    // if someone could make this cleaner id highly appreciate it
+
+    // Create a map
+    const songIdtoChartId = new Map<string, (typeof staticMusicInfo)[0]>(
+      staticMusicInfo.map((music) => [
+        `${music.songId}-${music.chartId}`,
+        music,
+      ]),
+    );
+
+    const musicIdToDifficltId = userRatingBaseList.map((rating) => {
+      const staticMusic = songIdtoChartId.get(
+        `${rating.musicId}-${rating.difficultId}`,
+      );
+
+      const level = staticMusic?.level ?? 0;
+      const score = rating.score ?? 0;
+
+      const perSongRating = calculateRating(level, score);
+
+      return {
+        ...rating,
+        chartId: staticMusic?.chartId || "Unknown chartId",
+        title: staticMusic?.title || "Unknown Title",
+        artist: staticMusic?.artist || "Unknown Artist",
+        genre: staticMusic?.genre || "Unknown Genre",
+        level: staticMusic?.level || "Unknown Level",
+        jacketPath: staticMusic?.jacketPath || "",
+        rating: perSongRating,
+      };
+    });
+
+    return musicIdToDifficltId;
+  } catch (error) {
+    console.error("Error fetching songs with titles:", error);
+    throw error;
+  }
+}
+
+// calculate the rating
+function calculateRating(level: number, score: number): number {
+  if (score >= 1009000) {
+    return level * 100 + 215;
+  } else if (score >= 1007500) {
+    return level * 100 + 200 + (score - 1007500) / 100;
+  } else if (score >= 1005000) {
+    return level * 100 + 150 + (score - 1005000) / 50;
+  } else if (score >= 1000000) {
+    return level * 100 + 100 + (score - 1000000) / 100;
+  } else if (score >= 975000) {
+    return level * 100 + (score - 975000) / 250;
+  } else if (score >= 925000) {
+    return level * 100 - 300 + ((score - 925000) * 3) / 500;
+  } else if (score >= 900000) {
+    return level * 100 - 500 + ((score - 900000) * 4) / 500;
+  } else if (score >= 800000) {
+    return (
+      (level * 100 - 500) / 2 +
+      ((score - 800000) * ((level - 500) / 2)) / 100000
+    );
+  } else {
+    return 0;
+  }
+}

components/userRatingBase/page.tsx

@@ -0,0 +1,77 @@
+import React, { FC } from "react";
+import {
+  chuni_profile_rating,
+  chuni_static_music,
+} from "@/prisma/schemas/artemis/generated/artemis";
+import { getDifficultyText } from "@/lib/helpers";
+
+type userRatingBaseList = {
+  title: string;
+  artist: string;
+  genre: string;
+  chartId: string | number;
+  level: string | number;
+  jacketPath: string;
+  rating: number;
+  version: number;
+  index: number;
+  musicId: number | null;
+  difficultId: number | null;
+  score: number | null;
+};
+
+type ChunithmProfileRecentPlays = {
+  chuniProfileRecentPlays: {
+    recentRating: userRatingBaseList[];
+  };
+};
+export const ChunithmRecentPlays: FC<ChunithmProfileRecentPlays> = ({
+  chuniProfileRecentPlays,
+}) => {
+  return (
+    <div>
+      {chuniProfileRecentPlays.recentRating.map(
+        (playersRecentRatingList, index) => {
+          const jacketPath = playersRecentRatingList.jacketPath?.replace(
+            ".dds",
+            ".png",
+          );
+          return (
+            <div key={index} className="center flex p-2">
+              <div className="m-4 font-bold">{index + 1}.</div>
+              {jacketPath && (
+                <img
+                  src={`/JacketArt/${jacketPath}`}
+                  alt="Jacket"
+                  style={{ width: "120px", height: "120px" }}
+                />
+              )}
+              <div>
+                <ul className="pl-2">
+                  <li>
+                    <strong>Title: </strong> {playersRecentRatingList.title}
+                  </li>
+                  <li>
+                    <strong>Level: </strong> {playersRecentRatingList.level}
+                  </li>
+                  <li>
+                    <strong>Difficulty: </strong>
+                    {getDifficultyText(Number(playersRecentRatingList.chartId))}
+                  </li>
+                  <li>
+                    <strong>Score: </strong>{" "}
+                    {playersRecentRatingList.score?.toLocaleString()}
+                  </li>
+                  <li>
+                    <strong>Rating: </strong>{" "}
+                    {(playersRecentRatingList.rating / 100).toFixed(2)}
+                  </li>
+                </ul>
+              </div>
+            </div>
+          );
+        },
+      )}
+    </div>
+  );
+};