daphnis/lib/api.ts
2024-07-23 14:35:30 -04:00

266 lines
6.1 KiB
TypeScript

"use server";
import { getAuth } from "@/auth/queries/getauth";
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, // Add jacketPath to the selection
},
});
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;
}
}
export const getUsername = async () => {
const { user } = await getAuth();
if (user) {
return await daphnis.user.findFirst({
where: {
id: user.id,
username: user.username,
},
});
}
return null;
};
export async function getAllAimeCards() {
const { user } = await getAuth();
if (!user || !user.accessCode) {
throw new Error("User is not authenticated or accessCode is missing");
}
const aimeUser = await daphnis.user.findMany({
where: {
accessCode: user.accessCode,
},
});
return aimeUser;
}
export async function getAllAvatarParts() {
const { user } = await getAuth();
if (!user || !user.accessCode) {
throw new Error("User is not authenticated or accessCode is missing");
}
const avatarParts = await artemis.chuni_static_avatar.findMany({
where: {
category: 1
},
select: {
id: true,
name: true,
avatarAccessoryId: true,
category: true,
version: true,
iconPath: true,
texturePath: true,
}
});
return avatarParts;
}
export async function GetSpecificAvatarParts(category: number) {
const { user } = await getAuth();
if (!user || !user.accessCode) {
throw new Error("User is not authenticated or accessCode is missing");
}
const avatarParts = await artemis.chuni_static_avatar.findMany({
where: { category },
select: {
name: true,
category: true,
version: true,
iconPath: true,
texturePath: true,
},
});
return avatarParts;
}
export async function getCurrentPlayerAvatarParts() {
const { user } = await getAuth();
if (!user || !user.accessCode) {
throw new Error("User is not authenticated or accessCode is missing");
}
const avatarParts = await artemis.chuni_profile_data.findMany({
select: {
avatarBack: true,
avatarFace: true,
avatarItem: true,
avatarHead: true,
avatarWear: true,
},
});
return avatarParts;
}
export async function verifyAimeCodeAgainstArtemis() {
const { user } = await getAuth();
if (!user || !user.accessCode) {
throw new Error("User is not authenticated or accessCode is missing");
}
const aimeUser = await artemis.aime_card.findFirst({
where: {
access_code: user.accessCode,
},
});
return aimeUser;
}