cleanup

app/(authenticated)/chunithm/page.tsx

@@ -2,10 +2,10 @@
 //https://github.com/vercel/next.js/discussions/63862
 
 import React from "react";
-import { getAllAvatarParts } from "@/lib/api";
 import { AvatarCustomization } from "@/components/avatarcustomization/page";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import ChunithmScorePlaylog from "@/components/scoreplaylog/page";
+import { getAllAvatarParts } from "@/components/avatarcustomization/actions";
 
 // the number is the category id for the specific part
 

app/(sharing)/[token]/[id]/actions.ts

@@ -0,0 +1,154 @@
+
+"use server";
+
+
+import { artemis, daphnis } from "@/lib/prisma";
+import type * as Prisma from "@prisma/client";
+
+ type ChuniScorePlaylog = Prisma.PrismaClient;
+ type ChuniStaticMusic = Prisma.PrismaClient;
+
+type LinkSharingToken = {
+    playlogId: number;
+  };
+
+
+export async function getSongsWithTitles(userId: number) {
+    try {
+      const songs: ChuniScorePlaylog[] = await artemis.chuni_score_playlog.findMany({
+        where: {
+          user: userId,
+        },
+        orderBy: {
+          userPlayDate: "desc",
+        },
+        select: {
+          id: true,
+          maxCombo: true,
+          userPlayDate: true,
+          isFullCombo: true,
+          playerRating: true,
+          isAllJustice: true,
+          score: true,
+          judgeHeaven: true,
+          judgeGuilty: true,
+          judgeJustice: true,
+          judgeAttack: true,
+          judgeCritical: true,
+          isClear: true,
+          skillId: true,
+          skillEffect: true,
+          skillLevel: true,
+          isNewRecord: true,
+          musicId: true,
+          level: true,
+          rateAir: true,
+          rateHold: true,
+          rateFlick: true,
+          rateSlide: true,
+          rateTap: true,
+          romVersion: true,
+          eventId: true,
+          characterId: true,
+          charaIllustId: true,
+          track: true,
+          isContinue: true,
+          isFreeToPlay: true,
+          playKind: true,
+          playDate: true,
+          orderId: true,
+          sortNumber: true,
+          user: true,
+          placeId: true,
+          ticketId: true,
+        },
+      });
+  
+      const chuniScorePlaylogMusicId = songs
+        .map((song) => song.musicId)
+        .filter((id): id is number => id !== null);
+  
+      const staticMusicInfo: ChuniStaticMusic[] = await artemis.chuni_static_music.findMany({
+        where: {
+          songId: {
+            in: chuniScorePlaylogMusicId,
+          },
+        },
+        select: {
+          songId: true,
+          title: true,
+          artist: true,
+          chartId: true,
+          level: true,
+          genre: true,
+          worldsEndTag: true,
+          jacketPath: true, 
+        },
+      });
+  
+      const playCounts = await artemis.chuni_score_playlog.groupBy({
+        by: ['musicId'],
+        _count: {
+          musicId: true,
+        },
+        where: {
+          user: userId,
+          musicId: {
+            in: chuniScorePlaylogMusicId,
+          },
+        },
+      });
+  
+      const playCountMap = playCounts.reduce((map, item) => {
+        if (item.musicId !== null) {
+          map[item.musicId] = item._count.musicId;
+        }
+        return map;
+      }, {} as Record<number, number>);
+  
+      const songsWithTitles = songs.map((song) => {
+        const staticInfo = staticMusicInfo.find(
+          (chuniStaticMusic) =>
+            chuniStaticMusic.songId === song.musicId &&
+            chuniStaticMusic.chartId === song.level
+        );
+  
+        return {
+          ...song,
+          title: staticInfo?.title || "Unknown Title",
+          artist: staticInfo?.artist || "Unknown Artist",
+          genre: staticInfo?.genre || "Unknown Genre",
+          level: staticInfo?.level || "Unknown Level",
+          chartlevel: song.level || "Unknown Level",
+          playCount: song.musicId !== null ? playCountMap[song.musicId] || 0 : 0,
+          jacketPath: staticInfo?.jacketPath || "",
+        };
+      });
+  
+      return songsWithTitles;
+    } catch (error) {
+      console.error("Error fetching songs with titles:", error);
+      throw error;
+    }
+  }
+
+  
+export async function generatePlaylogId(playlogid: number) {
+    try {
+      const tokens = (await daphnis.linkSharingToken.findMany({
+        where: {
+          playlogId: playlogid,
+        },
+        select: {
+          playlogId: true,
+        },
+      })) as LinkSharingToken[];
+  
+      const playlogIds: number[] = tokens.map((token) => token.playlogId);
+  
+      return playlogIds;
+    } catch (error) {
+      console.error("Error fetching playlogIds:", error);
+      throw error;
+    }
+  }

app/(sharing)/[token]/[id]/page.tsx

@@ -1,11 +1,11 @@
 import { getAuth } from "@/auth/queries/getauth";
-import { generatePlaylogId, getSongsWithTitles } from "@/lib/api";
 import { shareScore } from "../token";
 import { getDifficultyClass, getDifficultyText, getGrade } from "@/lib/helpers";
 import {
   type chuni_score_playlog,
   chuni_static_music,
 } from "@/prisma/schemas/artemis/generated/artemis";
+import { generatePlaylogId, getSongsWithTitles } from "./actions";
 
 type chunithm = chuni_score_playlog &
   chuni_static_music & { playCount: number };