Organized the differences between server and docker versions.
We are launching a docker version (server version) today so we want to just organize the repo so its easier to navigate.
This commit is contained in:
564
desktop/src/api/anilist/anilist.service.ts
Normal file
564
desktop/src/api/anilist/anilist.service.ts
Normal file
@@ -0,0 +1,564 @@
|
||||
import { queryOne } from '../../shared/database';
|
||||
|
||||
const USER_DB = 'userdata';
|
||||
|
||||
// Configuración de reintentos
|
||||
const RETRY_CONFIG = {
|
||||
maxRetries: 3,
|
||||
initialDelay: 1000,
|
||||
maxDelay: 5000,
|
||||
backoffMultiplier: 2
|
||||
};
|
||||
|
||||
// Helper para hacer requests con reintentos y manejo de errores
|
||||
async function fetchWithRetry(
|
||||
url: string,
|
||||
options: RequestInit,
|
||||
retries = RETRY_CONFIG.maxRetries
|
||||
): Promise<Response> {
|
||||
let lastError: Error | null = null;
|
||||
let delay = RETRY_CONFIG.initialDelay;
|
||||
|
||||
for (let attempt = 0; attempt <= retries; attempt++) {
|
||||
try {
|
||||
const controller = new AbortController();
|
||||
const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
|
||||
|
||||
const response = await fetch(url, {
|
||||
...options,
|
||||
signal: controller.signal
|
||||
});
|
||||
|
||||
clearTimeout(timeoutId);
|
||||
|
||||
// Si es rate limit (429), esperamos más tiempo
|
||||
if (response.status === 429) {
|
||||
const retryAfter = response.headers.get('Retry-After');
|
||||
const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : delay;
|
||||
|
||||
if (attempt < retries) {
|
||||
console.warn(`Rate limited. Esperando ${waitTime}ms antes de reintentar...`);
|
||||
await new Promise(resolve => setTimeout(resolve, waitTime));
|
||||
delay = Math.min(delay * RETRY_CONFIG.backoffMultiplier, RETRY_CONFIG.maxDelay);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Si es un error de servidor (5xx), reintentamos
|
||||
if (response.status >= 500 && attempt < retries) {
|
||||
console.warn(`Error del servidor (${response.status}). Reintentando en ${delay}ms...`);
|
||||
await new Promise(resolve => setTimeout(resolve, delay));
|
||||
delay = Math.min(delay * RETRY_CONFIG.backoffMultiplier, RETRY_CONFIG.maxDelay);
|
||||
continue;
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
lastError = error as Error;
|
||||
|
||||
if (attempt < retries && (
|
||||
error instanceof Error && (
|
||||
error.name === 'AbortError' ||
|
||||
error.message.includes('fetch') ||
|
||||
error.message.includes('network')
|
||||
)
|
||||
)) {
|
||||
console.warn(`Error de conexión (intento ${attempt + 1}/${retries + 1}). Reintentando en ${delay}ms...`);
|
||||
await new Promise(resolve => setTimeout(resolve, delay));
|
||||
delay = Math.min(delay * RETRY_CONFIG.backoffMultiplier, RETRY_CONFIG.maxDelay);
|
||||
continue;
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
throw lastError || new Error('Request failed after all retries');
|
||||
}
|
||||
|
||||
export async function getUserAniList(appUserId: number) {
|
||||
try {
|
||||
const sql = `
|
||||
SELECT access_token, anilist_user_id
|
||||
FROM UserIntegration
|
||||
WHERE user_id = ? AND platform = 'AniList';
|
||||
`;
|
||||
|
||||
const integration = await queryOne(sql, [appUserId], USER_DB) as any;
|
||||
if (!integration) return [];
|
||||
|
||||
const { access_token, anilist_user_id } = integration;
|
||||
if (!access_token || !anilist_user_id) return [];
|
||||
|
||||
const query = `
|
||||
query ($userId: Int) {
|
||||
anime: MediaListCollection(userId: $userId, type: ANIME) {
|
||||
lists {
|
||||
entries {
|
||||
media {
|
||||
id
|
||||
title { romaji english userPreferred }
|
||||
coverImage { extraLarge }
|
||||
episodes
|
||||
nextAiringEpisode { episode }
|
||||
}
|
||||
status
|
||||
progress
|
||||
score
|
||||
repeat
|
||||
notes
|
||||
private
|
||||
startedAt { year month day }
|
||||
completedAt { year month day }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
manga: MediaListCollection(userId: $userId, type: MANGA) {
|
||||
lists {
|
||||
entries {
|
||||
media {
|
||||
id
|
||||
type
|
||||
format
|
||||
title { romaji english userPreferred }
|
||||
coverImage { extraLarge }
|
||||
chapters
|
||||
volumes
|
||||
}
|
||||
status
|
||||
progress
|
||||
score
|
||||
repeat
|
||||
notes
|
||||
private
|
||||
startedAt { year month day }
|
||||
completedAt { year month day }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const res = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${access_token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query,
|
||||
variables: { userId: anilist_user_id }
|
||||
}),
|
||||
});
|
||||
|
||||
if (!res.ok) throw new Error(`AniList API error: ${res.status}`);
|
||||
|
||||
const json = await res.json();
|
||||
if (json?.errors?.length) throw new Error(json.errors[0].message);
|
||||
|
||||
const fromFuzzy = (d: any) => {
|
||||
if (!d?.year) return null;
|
||||
const m = String(d.month || 1).padStart(2, '0');
|
||||
const day = String(d.day || 1).padStart(2, '0');
|
||||
return `${d.year}-${m}-${day}`;
|
||||
};
|
||||
|
||||
const normalize = (lists: any[], type: 'ANIME' | 'MANGA') => {
|
||||
const result: any[] = [];
|
||||
|
||||
for (const list of lists || []) {
|
||||
for (const entry of list.entries || []) {
|
||||
const media = entry.media;
|
||||
|
||||
const totalEpisodes =
|
||||
media?.episodes ||
|
||||
(media?.nextAiringEpisode?.episode
|
||||
? media.nextAiringEpisode.episode - 1
|
||||
: 0);
|
||||
|
||||
const totalChapters =
|
||||
media?.chapters ||
|
||||
(media?.volumes ? media.volumes * 10 : 0);
|
||||
|
||||
const resolvedType =
|
||||
type === 'MANGA' &&
|
||||
(media?.format === 'LIGHT_NOVEL' || media?.format === 'NOVEL')
|
||||
? 'NOVEL'
|
||||
: type;
|
||||
|
||||
|
||||
result.push({
|
||||
user_id: appUserId,
|
||||
|
||||
entry_id: media.id,
|
||||
source: 'anilist',
|
||||
|
||||
// ✅ AHORA TU FRONT RECIBE NOVEL
|
||||
entry_type: resolvedType,
|
||||
|
||||
status: entry.status,
|
||||
progress: entry.progress || 0,
|
||||
score: entry.score || null,
|
||||
start_date: fromFuzzy(entry.startedAt),
|
||||
end_date: fromFuzzy(entry.completedAt),
|
||||
repeat_count: entry.repeat || 0,
|
||||
notes: entry.notes || null,
|
||||
is_private: entry.private ? 1 : 0,
|
||||
|
||||
title: media?.title?.userPreferred
|
||||
|| media?.title?.english
|
||||
|| media?.title?.romaji
|
||||
|| 'Unknown Title',
|
||||
|
||||
poster: media?.coverImage?.extraLarge
|
||||
|| 'https://placehold.co/400x600?text=No+Cover',
|
||||
|
||||
total_episodes: resolvedType === 'ANIME' ? totalEpisodes : undefined,
|
||||
total_chapters: resolvedType !== 'ANIME' ? totalChapters : undefined,
|
||||
|
||||
updated_at: new Date().toISOString()
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
return [
|
||||
...normalize(json?.data?.anime?.lists, 'ANIME'),
|
||||
...normalize(json?.data?.manga?.lists, 'MANGA')
|
||||
];
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error fetching AniList data:', error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
export async function updateAniListEntry(token: string, params: {
|
||||
mediaId: number | string;
|
||||
status?: string | null;
|
||||
progress?: number | null;
|
||||
score?: number | null;
|
||||
start_date?: string | null; // YYYY-MM-DD
|
||||
end_date?: string | null; // YYYY-MM-DD
|
||||
repeat_count?: number | null;
|
||||
notes?: string | null;
|
||||
is_private?: boolean | number | null;
|
||||
}) {
|
||||
try {
|
||||
if (!token) throw new Error('AniList token is required');
|
||||
|
||||
const mutation = `
|
||||
mutation (
|
||||
$mediaId: Int,
|
||||
$status: MediaListStatus,
|
||||
$progress: Int,
|
||||
$score: Float,
|
||||
$startedAt: FuzzyDateInput,
|
||||
$completedAt: FuzzyDateInput,
|
||||
$repeat: Int,
|
||||
$notes: String,
|
||||
$private: Boolean
|
||||
) {
|
||||
SaveMediaListEntry (
|
||||
mediaId: $mediaId,
|
||||
status: $status,
|
||||
progress: $progress,
|
||||
score: $score,
|
||||
startedAt: $startedAt,
|
||||
completedAt: $completedAt,
|
||||
repeat: $repeat,
|
||||
notes: $notes,
|
||||
private: $private
|
||||
) {
|
||||
id
|
||||
status
|
||||
progress
|
||||
score
|
||||
startedAt { year month day }
|
||||
completedAt { year month day }
|
||||
repeat
|
||||
notes
|
||||
private
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const toFuzzyDate = (dateStr?: string | null) => {
|
||||
if (!dateStr) return null;
|
||||
const [year, month, day] = dateStr.split('-').map(Number);
|
||||
return { year, month, day };
|
||||
};
|
||||
|
||||
const variables: any = {
|
||||
mediaId: Number(params.mediaId),
|
||||
status: params.status ?? undefined,
|
||||
progress: params.progress ?? undefined,
|
||||
score: params.score ?? undefined,
|
||||
startedAt: toFuzzyDate(params.start_date),
|
||||
completedAt: toFuzzyDate(params.end_date),
|
||||
repeat: params.repeat_count ?? undefined,
|
||||
notes: params.notes ?? undefined,
|
||||
private: typeof params.is_private === 'boolean'
|
||||
? params.is_private
|
||||
: params.is_private === 1
|
||||
};
|
||||
|
||||
const res = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({ query: mutation, variables }),
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
const errorText = await res.text();
|
||||
throw new Error(`AniList update failed: ${res.status} - ${errorText}`);
|
||||
}
|
||||
|
||||
const json = await res.json();
|
||||
|
||||
if (json?.errors?.length) {
|
||||
throw new Error(`AniList GraphQL error: ${json.errors[0].message}`);
|
||||
}
|
||||
|
||||
return json.data?.SaveMediaListEntry || null;
|
||||
} catch (error) {
|
||||
console.error('Error updating AniList entry:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
export async function deleteAniListEntry(token: string, mediaId: number) {
|
||||
if (!token) throw new Error("AniList token required");
|
||||
|
||||
try {
|
||||
// 1️⃣ OBTENER VIEWER
|
||||
const viewerQuery = `query { Viewer { id name } }`;
|
||||
|
||||
const vRes = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({ query: viewerQuery }),
|
||||
});
|
||||
|
||||
const vJson = await vRes.json();
|
||||
const userId = vJson?.data?.Viewer?.id;
|
||||
|
||||
if (!userId) throw new Error("Invalid AniList token");
|
||||
|
||||
// 2️⃣ DETECTAR TIPO REAL DEL MEDIA
|
||||
const mediaQuery = `
|
||||
query ($id: Int) {
|
||||
Media(id: $id) {
|
||||
id
|
||||
type
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const mTypeRes = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query: mediaQuery,
|
||||
variables: { id: mediaId }
|
||||
}),
|
||||
});
|
||||
|
||||
const mTypeJson = await mTypeRes.json();
|
||||
const mediaType = mTypeJson?.data?.Media?.type;
|
||||
|
||||
if (!mediaType) {
|
||||
throw new Error("Media not found in AniList");
|
||||
}
|
||||
|
||||
// 3️⃣ BUSCAR ENTRY CON TIPO REAL
|
||||
const listQuery = `
|
||||
query ($userId: Int, $mediaId: Int, $type: MediaType) {
|
||||
MediaList(userId: $userId, mediaId: $mediaId, type: $type) {
|
||||
id
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const qRes = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query: listQuery,
|
||||
variables: {
|
||||
userId,
|
||||
mediaId,
|
||||
type: mediaType
|
||||
}
|
||||
}),
|
||||
});
|
||||
|
||||
const qJson = await qRes.json();
|
||||
const listEntryId = qJson?.data?.MediaList?.id;
|
||||
|
||||
if (!listEntryId) {
|
||||
throw new Error("Entry not found in user's AniList");
|
||||
}
|
||||
|
||||
// 4️⃣ BORRAR
|
||||
const mutation = `
|
||||
mutation ($id: Int) {
|
||||
DeleteMediaListEntry(id: $id) {
|
||||
deleted
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const delRes = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query: mutation,
|
||||
variables: { id: listEntryId }
|
||||
}),
|
||||
});
|
||||
|
||||
const delJson = await delRes.json();
|
||||
|
||||
if (delJson?.errors?.length) {
|
||||
throw new Error(delJson.errors[0].message);
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
} catch (err) {
|
||||
console.error("AniList DELETE failed:", err);
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
export async function getSingleAniListEntry(
|
||||
token: string,
|
||||
mediaId: number,
|
||||
type: 'ANIME' | 'MANGA'
|
||||
) {
|
||||
try {
|
||||
if (!token) {
|
||||
throw new Error('AniList token is required');
|
||||
}
|
||||
|
||||
// 1️⃣ Obtener userId desde el token
|
||||
const viewerRes = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query: `query { Viewer { id } }`
|
||||
})
|
||||
});
|
||||
|
||||
const viewerJson = await viewerRes.json();
|
||||
const userId = viewerJson?.data?.Viewer?.id;
|
||||
|
||||
if (!userId) {
|
||||
throw new Error('Failed to get AniList userId');
|
||||
}
|
||||
|
||||
// 2️⃣ Query correcta con userId
|
||||
const query = `
|
||||
query ($mediaId: Int, $type: MediaType, $userId: Int) {
|
||||
MediaList(mediaId: $mediaId, type: $type, userId: $userId) {
|
||||
id
|
||||
status
|
||||
progress
|
||||
score
|
||||
repeat
|
||||
private
|
||||
notes
|
||||
startedAt { year month day }
|
||||
completedAt { year month day }
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const res = await fetchWithRetry('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query,
|
||||
variables: { mediaId, type, userId }
|
||||
})
|
||||
});
|
||||
|
||||
if (res.status === 404) {
|
||||
return null; // ✅ No existe entry todavía → es totalmente válido
|
||||
}
|
||||
|
||||
if (!res.ok) {
|
||||
const errorText = await res.text();
|
||||
throw new Error(`AniList fetch failed: ${res.status} - ${errorText}`);
|
||||
}
|
||||
|
||||
const json = await res.json();
|
||||
|
||||
if (json?.errors?.length) {
|
||||
if (json.errors[0].status === 404) return null;
|
||||
throw new Error(`GraphQL error: ${json.errors[0].message}`);
|
||||
}
|
||||
|
||||
const entry = json?.data?.MediaList;
|
||||
if (!entry) return null;
|
||||
|
||||
return {
|
||||
entry_id: mediaId,
|
||||
source: 'anilist',
|
||||
entry_type: type,
|
||||
status: entry.status,
|
||||
progress: entry.progress || 0,
|
||||
score: entry.score ?? null,
|
||||
|
||||
start_date: entry.startedAt?.year
|
||||
? `${entry.startedAt.year}-${String(entry.startedAt.month).padStart(2, '0')}-${String(entry.startedAt.day).padStart(2, '0')}`
|
||||
: null,
|
||||
|
||||
end_date: entry.completedAt?.year
|
||||
? `${entry.completedAt.year}-${String(entry.completedAt.month).padStart(2, '0')}-${String(entry.completedAt.day).padStart(2, '0')}`
|
||||
: null,
|
||||
|
||||
repeat_count: entry.repeat || 0,
|
||||
notes: entry.notes || null,
|
||||
is_private: entry.private ? 1 : 0,
|
||||
};
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error fetching single AniList entry:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
91
desktop/src/api/anilist/anilist.ts
Normal file
91
desktop/src/api/anilist/anilist.ts
Normal file
@@ -0,0 +1,91 @@
|
||||
import { FastifyInstance } from "fastify";
|
||||
import { run } from "../../shared/database";
|
||||
|
||||
async function anilist(fastify: FastifyInstance) {
|
||||
fastify.get("/anilist", async (request, reply) => {
|
||||
try {
|
||||
const { code, state } = request.query as { code?: string; state?: string };
|
||||
|
||||
if (!code) return reply.status(400).send("No code");
|
||||
if (!state) return reply.status(400).send("No user state");
|
||||
|
||||
const userId = Number(state);
|
||||
if (!userId || isNaN(userId)) {
|
||||
return reply.status(400).send("Invalid user id");
|
||||
}
|
||||
|
||||
const tokenRes = await fetch("https://anilist.co/api/v2/oauth/token", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({
|
||||
grant_type: "authorization_code",
|
||||
client_id: process.env.ANILIST_CLIENT_ID,
|
||||
client_secret: process.env.ANILIST_CLIENT_SECRET,
|
||||
redirect_uri: "http://localhost:54322/api/anilist",
|
||||
code
|
||||
})
|
||||
});
|
||||
|
||||
const tokenData = await tokenRes.json();
|
||||
|
||||
if (!tokenData.access_token) {
|
||||
console.error("AniList token error:", tokenData);
|
||||
return reply.status(500).send("Failed to get AniList token");
|
||||
}
|
||||
|
||||
const userRes = await fetch("https://graphql.anilist.co", {
|
||||
method: "POST",
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
Authorization: `${tokenData.token_type} ${tokenData.access_token}`
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query: `query { Viewer { id } }`
|
||||
})
|
||||
});
|
||||
|
||||
const userData = await userRes.json();
|
||||
const anilistUserId = userData?.data?.Viewer?.id;
|
||||
|
||||
if (!anilistUserId) {
|
||||
console.error("AniList Viewer error:", userData);
|
||||
return reply.status(500).send("Failed to fetch AniList user");
|
||||
}
|
||||
|
||||
const expiresAt = new Date(
|
||||
Date.now() + tokenData.expires_in * 1000
|
||||
).toISOString();
|
||||
|
||||
await run(
|
||||
`
|
||||
INSERT INTO UserIntegration
|
||||
(user_id, platform, access_token, refresh_token, token_type, anilist_user_id, expires_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(user_id) DO UPDATE SET
|
||||
access_token = excluded.access_token,
|
||||
refresh_token = excluded.refresh_token,
|
||||
token_type = excluded.token_type,
|
||||
anilist_user_id = excluded.anilist_user_id,
|
||||
expires_at = excluded.expires_at
|
||||
`,
|
||||
[
|
||||
userId,
|
||||
"AniList",
|
||||
tokenData.access_token,
|
||||
tokenData.refresh_token,
|
||||
tokenData.token_type,
|
||||
anilistUserId,
|
||||
expiresAt
|
||||
],
|
||||
"userdata"
|
||||
);
|
||||
|
||||
return reply.redirect("http://localhost:54322/?anilist=success");
|
||||
} catch (e) {
|
||||
console.error("AniList error:", e);
|
||||
return reply.redirect("http://localhost:54322/?anilist=error");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
export default anilist;
|
||||
107
desktop/src/api/anime/anime.controller.ts
Normal file
107
desktop/src/api/anime/anime.controller.ts
Normal file
@@ -0,0 +1,107 @@
|
||||
import {FastifyReply, FastifyRequest} from 'fastify';
|
||||
import * as animeService from './anime.service';
|
||||
import {getExtension} from '../../shared/extensions';
|
||||
import {Anime, AnimeRequest, SearchRequest, WatchStreamRequest} from '../types';
|
||||
|
||||
export async function getAnime(req: AnimeRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const source = req.query.source;
|
||||
|
||||
let anime: Anime | { error: string };
|
||||
if (source === 'anilist') {
|
||||
anime = await animeService.getAnimeById(id);
|
||||
} else {
|
||||
const ext = getExtension(source);
|
||||
anime = await animeService.getAnimeInfoExtension(ext, id)
|
||||
}
|
||||
|
||||
return anime;
|
||||
} catch (err) {
|
||||
return { error: "Database error" };
|
||||
}
|
||||
}
|
||||
|
||||
export async function getAnimeEpisodes(req: AnimeRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const source = req.query.source || 'anilist';
|
||||
const ext = getExtension(source);
|
||||
|
||||
return await animeService.searchEpisodesInExtension(
|
||||
ext,
|
||||
source,
|
||||
id
|
||||
);
|
||||
} catch (err) {
|
||||
return { error: "Database error" };
|
||||
}
|
||||
}
|
||||
|
||||
export async function getTrending(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const results = await animeService.getTrendingAnime();
|
||||
return { results };
|
||||
} catch (err) {
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function getTopAiring(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const results = await animeService.getTopAiringAnime();
|
||||
return { results };
|
||||
} catch (err) {
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function search(req: SearchRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const query = req.query.q;
|
||||
const results = await animeService.searchAnimeLocal(query);
|
||||
|
||||
if (results.length > 0) {
|
||||
return { results: results };
|
||||
}
|
||||
|
||||
} catch (err) {
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function searchInExtension(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const extensionName = req.params.extension;
|
||||
const query = req.query.q;
|
||||
|
||||
const ext = getExtension(extensionName);
|
||||
if (!ext) return { results: [] };
|
||||
|
||||
const results = await animeService.searchAnimeInExtension(ext, extensionName, query);
|
||||
return { results };
|
||||
} catch {
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function getWatchStream(req: WatchStreamRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { animeId, episode, server, category, ext, source } = req.query;
|
||||
|
||||
const extension = getExtension(ext);
|
||||
if (!extension) return { error: "Extension not found" };
|
||||
|
||||
return await animeService.getStreamData(
|
||||
extension,
|
||||
episode,
|
||||
animeId,
|
||||
source,
|
||||
server,
|
||||
category
|
||||
);
|
||||
} catch (err) {
|
||||
const error = err as Error;
|
||||
return { error: error.message };
|
||||
}
|
||||
}
|
||||
14
desktop/src/api/anime/anime.routes.ts
Normal file
14
desktop/src/api/anime/anime.routes.ts
Normal file
@@ -0,0 +1,14 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import * as controller from './anime.controller';
|
||||
|
||||
async function animeRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/anime/:id', controller.getAnime);
|
||||
fastify.get('/anime/:id/:episodes', controller.getAnimeEpisodes);
|
||||
fastify.get('/trending', controller.getTrending);
|
||||
fastify.get('/top-airing', controller.getTopAiring);
|
||||
fastify.get('/search', controller.search);
|
||||
fastify.get('/search/:extension', controller.searchInExtension);
|
||||
fastify.get('/watch/stream', controller.getWatchStream);
|
||||
}
|
||||
|
||||
export default animeRoutes;
|
||||
450
desktop/src/api/anime/anime.service.ts
Normal file
450
desktop/src/api/anime/anime.service.ts
Normal file
@@ -0,0 +1,450 @@
|
||||
import { getCache, setCache, getCachedExtension, cacheExtension, getExtensionTitle } from '../../shared/queries';
|
||||
import { queryAll, queryOne } from '../../shared/database';
|
||||
import {Anime, Episode, Extension, StreamData} from '../types';
|
||||
|
||||
const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
|
||||
const TTL = 60 * 60 * 6;
|
||||
|
||||
const ANILIST_URL = "https://graphql.anilist.co";
|
||||
|
||||
const MEDIA_FIELDS = `
|
||||
id
|
||||
idMal
|
||||
title { romaji english native userPreferred }
|
||||
type
|
||||
format
|
||||
status
|
||||
description
|
||||
startDate { year month day }
|
||||
endDate { year month day }
|
||||
season
|
||||
seasonYear
|
||||
episodes
|
||||
duration
|
||||
chapters
|
||||
volumes
|
||||
countryOfOrigin
|
||||
isLicensed
|
||||
source
|
||||
hashtag
|
||||
trailer { id site thumbnail }
|
||||
updatedAt
|
||||
coverImage { extraLarge large medium color }
|
||||
bannerImage
|
||||
genres
|
||||
synonyms
|
||||
averageScore
|
||||
popularity
|
||||
isLocked
|
||||
trending
|
||||
favourites
|
||||
isAdult
|
||||
siteUrl
|
||||
tags { id name description category rank isGeneralSpoiler isMediaSpoiler isAdult }
|
||||
relations {
|
||||
edges {
|
||||
relationType
|
||||
node {
|
||||
id
|
||||
title { romaji }
|
||||
type
|
||||
format
|
||||
status
|
||||
}
|
||||
}
|
||||
}
|
||||
studios {
|
||||
edges {
|
||||
isMain
|
||||
node { id name isAnimationStudio }
|
||||
}
|
||||
}
|
||||
nextAiringEpisode { airingAt timeUntilAiring episode }
|
||||
externalLinks { id url site type language color icon notes }
|
||||
rankings { id rank type format year season allTime context }
|
||||
stats {
|
||||
scoreDistribution { score amount }
|
||||
statusDistribution { status amount }
|
||||
}
|
||||
recommendations(perPage: 7, sort: RATING_DESC) {
|
||||
nodes {
|
||||
mediaRecommendation {
|
||||
id
|
||||
title { romaji }
|
||||
coverImage { medium }
|
||||
format
|
||||
type
|
||||
}
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
async function fetchAniList(query: string, variables: any) {
|
||||
const res = await fetch(ANILIST_URL, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ query, variables })
|
||||
});
|
||||
|
||||
const json = await res.json();
|
||||
return json?.data;
|
||||
}
|
||||
|
||||
export async function getAnimeById(id: string | number): Promise<Anime | { error: string }> {
|
||||
const row = await queryOne("SELECT full_data FROM anime WHERE id = ?", [id]);
|
||||
|
||||
if (row) return JSON.parse(row.full_data);
|
||||
|
||||
const query = `
|
||||
query ($id: Int) {
|
||||
Media(id: $id, type: ANIME) { ${MEDIA_FIELDS} }
|
||||
}
|
||||
`;
|
||||
|
||||
const data = await fetchAniList(query, { id: Number(id) });
|
||||
if (!data?.Media) return { error: "Anime not found" };
|
||||
|
||||
await queryOne(
|
||||
"INSERT INTO anime (id, title, updatedAt, full_data) VALUES (?, ?, ?, ?)",
|
||||
[
|
||||
data.Media.id,
|
||||
data.Media.title?.english || data.Media.title?.romaji,
|
||||
data.Media.updatedAt || 0,
|
||||
JSON.stringify(data.Media)
|
||||
]
|
||||
);
|
||||
|
||||
return data.Media;
|
||||
}
|
||||
|
||||
export async function getTrendingAnime(): Promise<Anime[]> {
|
||||
const rows = await queryAll(
|
||||
"SELECT full_data, updated_at FROM trending ORDER BY rank ASC LIMIT 10"
|
||||
);
|
||||
|
||||
if (rows.length) {
|
||||
const expired = (Date.now() / 1000 - rows[0].updated_at) > TTL;
|
||||
if (!expired) {
|
||||
return rows.map((r: { full_data: string }) => JSON.parse(r.full_data));
|
||||
}
|
||||
}
|
||||
|
||||
const query = `
|
||||
query {
|
||||
Page(page: 1, perPage: 10) {
|
||||
media(type: ANIME, sort: TRENDING_DESC) { ${MEDIA_FIELDS} }
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const data = await fetchAniList(query, {});
|
||||
const list = data?.Page?.media || [];
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
|
||||
await queryOne("DELETE FROM trending");
|
||||
let rank = 1;
|
||||
|
||||
for (const anime of list) {
|
||||
await queryOne(
|
||||
"INSERT INTO trending (rank, id, full_data, updated_at) VALUES (?, ?, ?, ?)",
|
||||
[rank++, anime.id, JSON.stringify(anime), now]
|
||||
);
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
export async function getTopAiringAnime(): Promise<Anime[]> {
|
||||
const rows = await queryAll(
|
||||
"SELECT full_data, updated_at FROM top_airing ORDER BY rank ASC LIMIT 10"
|
||||
);
|
||||
|
||||
if (rows.length) {
|
||||
const expired = (Date.now() / 1000 - rows[0].updated_at) > TTL;
|
||||
if (!expired) {
|
||||
return rows.map((r: { full_data: string }) => JSON.parse(r.full_data));
|
||||
}
|
||||
}
|
||||
|
||||
const query = `
|
||||
query {
|
||||
Page(page: 1, perPage: 10) {
|
||||
media(type: ANIME, status: RELEASING, sort: SCORE_DESC) { ${MEDIA_FIELDS} }
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const data = await fetchAniList(query, {});
|
||||
const list = data?.Page?.media || [];
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
|
||||
await queryOne("DELETE FROM top_airing");
|
||||
let rank = 1;
|
||||
|
||||
for (const anime of list) {
|
||||
await queryOne(
|
||||
"INSERT INTO top_airing (rank, id, full_data, updated_at) VALUES (?, ?, ?, ?)",
|
||||
[rank++, anime.id, JSON.stringify(anime), now]
|
||||
);
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
export async function searchAnimeLocal(query: string): Promise<Anime[]> {
|
||||
if (!query || query.length < 2) return [];
|
||||
|
||||
const sql = `SELECT full_data FROM anime WHERE full_data LIKE ? LIMIT 50`;
|
||||
const rows = await queryAll(sql, [`%${query}%`]);
|
||||
|
||||
const localResults: Anime[] = rows
|
||||
.map((r: { full_data: string }) => JSON.parse(r.full_data))
|
||||
.filter((anime: { title: { english: any; romaji: any; native: any; }; synonyms: any; }) => {
|
||||
const q = query.toLowerCase();
|
||||
const titles = [
|
||||
anime.title?.english,
|
||||
anime.title?.romaji,
|
||||
anime.title?.native,
|
||||
...(anime.synonyms || [])
|
||||
]
|
||||
.filter(Boolean)
|
||||
.map(t => t!.toLowerCase());
|
||||
|
||||
return titles.some(t => t.includes(q));
|
||||
})
|
||||
.slice(0, 10);
|
||||
|
||||
if (localResults.length >= 5) {
|
||||
return localResults;
|
||||
}
|
||||
|
||||
const gql = `
|
||||
query ($search: String) {
|
||||
Page(page: 1, perPage: 10) {
|
||||
media(type: ANIME, search: $search) { ${MEDIA_FIELDS} }
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const data = await fetchAniList(gql, { search: query });
|
||||
const remoteResults: Anime[] = data?.Page?.media || [];
|
||||
|
||||
for (const anime of remoteResults) {
|
||||
await queryOne(
|
||||
"INSERT OR IGNORE INTO anime (id, title, updatedAt, full_data) VALUES (?, ?, ?, ?)",
|
||||
[
|
||||
anime.id,
|
||||
anime.title?.english || anime.title?.romaji,
|
||||
anime.updatedAt || 0,
|
||||
JSON.stringify(anime)
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
const merged = [...localResults];
|
||||
|
||||
for (const anime of remoteResults) {
|
||||
if (!merged.find(a => a.id === anime.id)) {
|
||||
merged.push(anime);
|
||||
}
|
||||
if (merged.length >= 10) break;
|
||||
}
|
||||
|
||||
return merged;
|
||||
}
|
||||
|
||||
export async function getAnimeInfoExtension(ext: Extension | null, id: string): Promise<Anime | { error: string }> {
|
||||
if (!ext) return { error: "not found" };
|
||||
|
||||
const extName = ext.constructor.name;
|
||||
|
||||
const cached = await getCachedExtension(extName, id);
|
||||
if (cached) {
|
||||
try {
|
||||
console.log(`[${extName}] Metadata cache hit for ID: ${id}`);
|
||||
return JSON.parse(cached.metadata) as Anime;
|
||||
} catch {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if ((ext.type === 'anime-board') && ext.getMetadata) {
|
||||
try {
|
||||
const match = await ext.getMetadata(id);
|
||||
|
||||
if (match) {
|
||||
const normalized: any = {
|
||||
title: match.title ?? "Unknown",
|
||||
summary: match.summary ?? "No summary available",
|
||||
episodes: Number(match.episodes) || 0,
|
||||
characters: Array.isArray(match.characters) ? match.characters : [],
|
||||
season: match.season ?? null,
|
||||
status: match.status ?? "Unknown",
|
||||
studio: match.studio ?? "Unknown",
|
||||
score: Number(match.score) || 0,
|
||||
year: match.year ?? null,
|
||||
genres: Array.isArray(match.genres) ? match.genres : [],
|
||||
image: match.image ?? ""
|
||||
};
|
||||
|
||||
await cacheExtension(extName, id, normalized.title, normalized);
|
||||
return normalized;
|
||||
}
|
||||
} catch (e) {
|
||||
console.error(`Extension getMetadata failed:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
return { error: "not found" };
|
||||
}
|
||||
|
||||
export async function searchAnimeInExtension(ext: Extension | null, name: string, query: string) {
|
||||
if (!ext) return [];
|
||||
|
||||
if (ext.type === 'anime-board' && ext.search) {
|
||||
try {
|
||||
console.log(`[${name}] Searching for anime: ${query}`);
|
||||
const matches = await ext.search({
|
||||
query: query,
|
||||
media: {
|
||||
romajiTitle: query,
|
||||
englishTitle: query,
|
||||
startDate: { year: 0, month: 0, day: 0 }
|
||||
}
|
||||
});
|
||||
|
||||
if (matches && matches.length > 0) {
|
||||
return matches.map(m => ({
|
||||
id: m.id,
|
||||
extensionName: name,
|
||||
title: { romaji: m.title, english: m.title, native: null },
|
||||
coverImage: { large: m.image || '' },
|
||||
averageScore: m.rating || m.score || null,
|
||||
format: 'ANIME',
|
||||
seasonYear: null,
|
||||
isExtensionResult: true,
|
||||
}));
|
||||
}
|
||||
} catch (e) {
|
||||
console.error(`Extension search failed for ${name}:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
export async function searchEpisodesInExtension(ext: Extension | null, name: string, query: string): Promise<Episode[]> {
|
||||
if (!ext) return [];
|
||||
|
||||
const cacheKey = `anime:episodes:${name}:${query}`;
|
||||
const cached = await getCache(cacheKey);
|
||||
|
||||
if (cached) {
|
||||
const isExpired = Date.now() - cached.created_at > CACHE_TTL_MS;
|
||||
|
||||
if (!isExpired) {
|
||||
console.log(`[${name}] Episodes cache hit for: ${query}`);
|
||||
try {
|
||||
return JSON.parse(cached.result) as Episode[];
|
||||
} catch (e) {
|
||||
console.error(`[${name}] Error parsing cached episodes:`, e);
|
||||
}
|
||||
} else {
|
||||
console.log(`[${name}] Episodes cache expired for: ${query}`);
|
||||
}
|
||||
}
|
||||
|
||||
if (ext.type === "anime-board" && ext.search && typeof ext.findEpisodes === "function") {
|
||||
try {
|
||||
const title = await getExtensionTitle(name, query);
|
||||
let mediaId: string;
|
||||
|
||||
if (!title) {
|
||||
const matches = await ext.search({
|
||||
query,
|
||||
media: {
|
||||
romajiTitle: query,
|
||||
englishTitle: query,
|
||||
startDate: { year: 0, month: 0, day: 0 }
|
||||
}
|
||||
});
|
||||
|
||||
if (!matches || matches.length === 0) return [];
|
||||
|
||||
const res = matches[0];
|
||||
if (!res?.id) return [];
|
||||
|
||||
mediaId = res.id;
|
||||
|
||||
} else {
|
||||
mediaId = query;
|
||||
}
|
||||
|
||||
const chapterList = await ext.findEpisodes(mediaId);
|
||||
|
||||
if (!Array.isArray(chapterList)) return [];
|
||||
|
||||
const result: Episode[] = chapterList.map(ep => ({
|
||||
id: ep.id,
|
||||
number: ep.number,
|
||||
url: ep.url,
|
||||
title: ep.title
|
||||
}));
|
||||
|
||||
await setCache(cacheKey, result, CACHE_TTL_MS);
|
||||
|
||||
return result;
|
||||
} catch (e) {
|
||||
console.error(`Extension search failed for ${name}:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
export async function getStreamData(extension: Extension, episode: string, id: string, source: string, server?: string, category?: string): Promise<StreamData> {
|
||||
const providerName = extension.constructor.name;
|
||||
|
||||
const cacheKey = `anime:stream:${providerName}:${id}:${episode}:${server || 'default'}:${category || 'sub'}`;
|
||||
|
||||
const cached = await getCache(cacheKey);
|
||||
|
||||
if (cached) {
|
||||
const isExpired = Date.now() - cached.created_at > CACHE_TTL_MS;
|
||||
|
||||
if (!isExpired) {
|
||||
console.log(`[${providerName}] Stream data cache hit for episode ${episode}`);
|
||||
try {
|
||||
return JSON.parse(cached.result) as StreamData;
|
||||
} catch (e) {
|
||||
console.error(`[${providerName}] Error parsing cached stream data:`, e);
|
||||
}
|
||||
} else {
|
||||
console.log(`[${providerName}] Stream data cache expired for episode ${episode}`);
|
||||
}
|
||||
}
|
||||
|
||||
if (!extension.findEpisodes || !extension.findEpisodeServer) {
|
||||
throw new Error("Extension doesn't support required methods");
|
||||
}
|
||||
let episodes;
|
||||
|
||||
if (source === "anilist"){
|
||||
const anime: any = await getAnimeById(id)
|
||||
episodes = await searchEpisodesInExtension(extension, extension.constructor.name, anime.title.romaji);
|
||||
}
|
||||
else{
|
||||
episodes = await extension.findEpisodes(id);
|
||||
}
|
||||
const targetEp = episodes.find(e => e.number === parseInt(episode));
|
||||
|
||||
if (!targetEp) {
|
||||
throw new Error("Episode not found");
|
||||
}
|
||||
|
||||
const serverName = server || "default";
|
||||
const streamData = await extension.findEpisodeServer(targetEp, serverName);
|
||||
|
||||
await setCache(cacheKey, streamData, CACHE_TTL_MS);
|
||||
return streamData;
|
||||
}
|
||||
116
desktop/src/api/books/books.controller.ts
Normal file
116
desktop/src/api/books/books.controller.ts
Normal file
@@ -0,0 +1,116 @@
|
||||
import {FastifyReply, FastifyRequest} from 'fastify';
|
||||
import * as booksService from './books.service';
|
||||
import {getExtension} from '../../shared/extensions';
|
||||
import {BookRequest, ChapterRequest, SearchRequest} from '../types';
|
||||
|
||||
export async function getBook(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const source = req.query.source;
|
||||
|
||||
let book;
|
||||
if (source === 'anilist') {
|
||||
book = await booksService.getBookById(id);
|
||||
} else {
|
||||
const ext = getExtension(source);
|
||||
const result = await booksService.getBookInfoExtension(ext, id);
|
||||
book = result || null;
|
||||
}
|
||||
|
||||
return book;
|
||||
} catch (err) {
|
||||
return { error: (err as Error).message };
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
export async function getTrending(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const results = await booksService.getTrendingBooks();
|
||||
return { results };
|
||||
} catch (err) {
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function getPopular(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const results = await booksService.getPopularBooks();
|
||||
return { results };
|
||||
} catch (err) {
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function searchBooks(req: SearchRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const query = req.query.q;
|
||||
|
||||
const dbResults = await booksService.searchBooksLocal(query);
|
||||
if (dbResults.length > 0) {
|
||||
return { results: dbResults };
|
||||
}
|
||||
|
||||
console.log(`[Books] Local DB miss for "${query}", fetching live...`);
|
||||
const anilistResults = await booksService.searchBooksAniList(query);
|
||||
if (anilistResults.length > 0) {
|
||||
return { results: anilistResults };
|
||||
}
|
||||
|
||||
return { results: [] };
|
||||
|
||||
} catch (e) {
|
||||
const error = e as Error;
|
||||
console.error("Search Error:", error.message);
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function searchBooksInExtension(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const extensionName = req.params.extension;
|
||||
const query = req.query.q;
|
||||
|
||||
const ext = getExtension(extensionName);
|
||||
if (!ext) return { results: [] };
|
||||
|
||||
const results = await booksService.searchBooksInExtension(ext, extensionName, query);
|
||||
return { results };
|
||||
} catch (e) {
|
||||
const error = e as Error;
|
||||
console.error("Search Error:", error.message);
|
||||
return { results: [] };
|
||||
}
|
||||
}
|
||||
|
||||
export async function getChapters(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const source = req.query.source || 'anilist';
|
||||
|
||||
const isExternal = source !== 'anilist';
|
||||
return await booksService.getChaptersForBook(id, isExternal);
|
||||
} catch {
|
||||
return { chapters: [] };
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
export async function getChapterContent(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const { bookId, chapter, provider } = req.params;
|
||||
const source = req.query.source || 'anilist';
|
||||
|
||||
const content = await booksService.getChapterContent(
|
||||
bookId,
|
||||
chapter,
|
||||
provider,
|
||||
source
|
||||
);
|
||||
|
||||
return reply.send(content);
|
||||
} catch (err) {
|
||||
console.error("getChapterContent error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Error loading chapter" });
|
||||
}
|
||||
}
|
||||
14
desktop/src/api/books/books.routes.ts
Normal file
14
desktop/src/api/books/books.routes.ts
Normal file
@@ -0,0 +1,14 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import * as controller from './books.controller';
|
||||
|
||||
async function booksRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/book/:id', controller.getBook);
|
||||
fastify.get('/books/trending', controller.getTrending);
|
||||
fastify.get('/books/popular', controller.getPopular);
|
||||
fastify.get('/search/books', controller.searchBooks);
|
||||
fastify.get('/search/books/:extension', controller.searchBooksInExtension);
|
||||
fastify.get('/book/:id/chapters', controller.getChapters);
|
||||
fastify.get('/book/:bookId/:chapter/:provider', controller.getChapterContent);
|
||||
}
|
||||
|
||||
export default booksRoutes;
|
||||
572
desktop/src/api/books/books.service.ts
Normal file
572
desktop/src/api/books/books.service.ts
Normal file
@@ -0,0 +1,572 @@
|
||||
import { getCachedExtension, cacheExtension, getCache, setCache, getExtensionTitle } from '../../shared/queries';
|
||||
import { queryOne, queryAll, run } from '../../shared/database';
|
||||
import { getAllExtensions, getBookExtensionsMap } from '../../shared/extensions';
|
||||
import { Book, Extension, ChapterWithProvider, ChapterContent } from '../types';
|
||||
|
||||
const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
|
||||
const TTL = 60 * 60 * 6;
|
||||
const ANILIST_URL = "https://graphql.anilist.co";
|
||||
|
||||
async function fetchAniList(query: string, variables: any) {
|
||||
const res = await fetch(ANILIST_URL, {
|
||||
method: "POST",
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"Accept": "application/json"
|
||||
},
|
||||
body: JSON.stringify({ query, variables })
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
throw new Error(`AniList error ${res.status}`);
|
||||
}
|
||||
|
||||
const json = await res.json();
|
||||
return json?.data;
|
||||
}
|
||||
const MEDIA_FIELDS = `
|
||||
id
|
||||
title {
|
||||
romaji
|
||||
english
|
||||
native
|
||||
userPreferred
|
||||
}
|
||||
type
|
||||
format
|
||||
status
|
||||
description
|
||||
startDate { year month day }
|
||||
endDate { year month day }
|
||||
season
|
||||
seasonYear
|
||||
episodes
|
||||
chapters
|
||||
volumes
|
||||
duration
|
||||
genres
|
||||
synonyms
|
||||
averageScore
|
||||
popularity
|
||||
favourites
|
||||
isAdult
|
||||
siteUrl
|
||||
coverImage {
|
||||
extraLarge
|
||||
large
|
||||
medium
|
||||
color
|
||||
}
|
||||
bannerImage
|
||||
updatedAt
|
||||
`;
|
||||
|
||||
export async function getBookById(id: string | number): Promise<Book | { error: string }> {
|
||||
const row = await queryOne(
|
||||
"SELECT full_data FROM books WHERE id = ?",
|
||||
[id]
|
||||
);
|
||||
|
||||
if (row) {
|
||||
return JSON.parse(row.full_data);
|
||||
}
|
||||
|
||||
try {
|
||||
console.log(`[Book] Local miss for ID ${id}, fetching live...`);
|
||||
|
||||
const query = `
|
||||
query ($id: Int) {
|
||||
Media(id: $id, type: MANGA) {
|
||||
id idMal title { romaji english native userPreferred } type format status description
|
||||
startDate { year month day } endDate { year month day } season seasonYear seasonInt
|
||||
episodes duration chapters volumes countryOfOrigin isLicensed source hashtag
|
||||
trailer { id site thumbnail } updatedAt coverImage { extraLarge large medium color }
|
||||
bannerImage genres synonyms averageScore meanScore popularity isLocked trending favourites
|
||||
tags { id name description category rank isGeneralSpoiler isMediaSpoiler isAdult userId }
|
||||
relations { edges { relationType node { id title { romaji } } } }
|
||||
characters(page: 1, perPage: 10) { nodes { id name { full } } }
|
||||
studios { nodes { id name isAnimationStudio } }
|
||||
isAdult nextAiringEpisode { airingAt timeUntilAiring episode }
|
||||
externalLinks { url site }
|
||||
rankings { id rank type format year season allTime context }
|
||||
}
|
||||
}`;
|
||||
|
||||
const response = await fetch('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json'
|
||||
},
|
||||
body: JSON.stringify({
|
||||
query,
|
||||
variables: { id: parseInt(id.toString()) }
|
||||
})
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
if (data?.data?.Media) {
|
||||
const media = data.data.Media;
|
||||
|
||||
const insertSql = `
|
||||
INSERT INTO books (id, title, updatedAt, full_data)
|
||||
VALUES (?, ?, ?, ?)
|
||||
ON CONFLICT(id) DO UPDATE SET
|
||||
title = EXCLUDED.title,
|
||||
updatedAt = EXCLUDED.updatedAt,
|
||||
full_data = EXCLUDED.full_data;
|
||||
`;
|
||||
|
||||
await run(insertSql, [
|
||||
media.id,
|
||||
media.title?.userPreferred || media.title?.romaji || media.title?.english || null,
|
||||
media.updatedAt || Math.floor(Date.now() / 1000),
|
||||
JSON.stringify(media)
|
||||
]);
|
||||
|
||||
return media;
|
||||
}
|
||||
} catch (e) {
|
||||
console.error("Fetch error:", e);
|
||||
}
|
||||
|
||||
return { error: "Book not found" };
|
||||
}
|
||||
|
||||
export async function getTrendingBooks(): Promise<Book[]> {
|
||||
const rows = await queryAll(
|
||||
"SELECT full_data, updated_at FROM trending_books ORDER BY rank ASC LIMIT 10"
|
||||
);
|
||||
|
||||
if (rows.length) {
|
||||
const expired = (Date.now() / 1000 - rows[0].updated_at) > TTL;
|
||||
if (!expired) {
|
||||
return rows.map((r: { full_data: string }) => JSON.parse(r.full_data));
|
||||
}
|
||||
}
|
||||
|
||||
const query = `
|
||||
query {
|
||||
Page(page: 1, perPage: 10) {
|
||||
media(type: MANGA, sort: TRENDING_DESC) { ${MEDIA_FIELDS} }
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const data = await fetchAniList(query, {});
|
||||
const list = data?.Page?.media || [];
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
|
||||
await queryOne("DELETE FROM trending_books");
|
||||
|
||||
let rank = 1;
|
||||
for (const book of list) {
|
||||
await queryOne(
|
||||
"INSERT INTO trending_books (rank, id, full_data, updated_at) VALUES (?, ?, ?, ?)",
|
||||
[rank++, book.id, JSON.stringify(book), now]
|
||||
);
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
|
||||
export async function getPopularBooks(): Promise<Book[]> {
|
||||
const rows = await queryAll(
|
||||
"SELECT full_data, updated_at FROM popular_books ORDER BY rank ASC LIMIT 10"
|
||||
);
|
||||
|
||||
if (rows.length) {
|
||||
const expired = (Date.now() / 1000 - rows[0].updated_at) > TTL;
|
||||
if (!expired) {
|
||||
return rows.map((r: { full_data: string }) => JSON.parse(r.full_data));
|
||||
}
|
||||
}
|
||||
|
||||
const query = `
|
||||
query {
|
||||
Page(page: 1, perPage: 10) {
|
||||
media(type: MANGA, sort: POPULARITY_DESC) { ${MEDIA_FIELDS} }
|
||||
}
|
||||
}
|
||||
`;
|
||||
|
||||
const data = await fetchAniList(query, {});
|
||||
const list = data?.Page?.media || [];
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
|
||||
await queryOne("DELETE FROM popular_books");
|
||||
|
||||
let rank = 1;
|
||||
for (const book of list) {
|
||||
await queryOne(
|
||||
"INSERT INTO popular_books (rank, id, full_data, updated_at) VALUES (?, ?, ?, ?)",
|
||||
[rank++, book.id, JSON.stringify(book), now]
|
||||
);
|
||||
}
|
||||
|
||||
return list;
|
||||
}
|
||||
|
||||
|
||||
export async function searchBooksLocal(query: string): Promise<Book[]> {
|
||||
if (!query || query.length < 2) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const sql = `SELECT full_data FROM books WHERE full_data LIKE ? LIMIT 50`;
|
||||
const rows = await queryAll(sql, [`%${query}%`]);
|
||||
|
||||
const results: Book[] = rows.map((row: { full_data: string; }) => JSON.parse(row.full_data));
|
||||
|
||||
const clean = results.filter(book => {
|
||||
const searchTerms = [
|
||||
book.title.english,
|
||||
book.title.romaji,
|
||||
book.title.native,
|
||||
...(book.synonyms || [])
|
||||
].filter(Boolean).map(t => t!.toLowerCase());
|
||||
|
||||
return searchTerms.some(term => term.includes(query.toLowerCase()));
|
||||
});
|
||||
|
||||
return clean.slice(0, 10);
|
||||
}
|
||||
|
||||
export async function searchBooksAniList(query: string): Promise<Book[]> {
|
||||
const gql = `
|
||||
query ($search: String) {
|
||||
Page(page: 1, perPage: 5) {
|
||||
media(search: $search, type: MANGA, isAdult: false) {
|
||||
id title { romaji english native }
|
||||
coverImage { extraLarge large }
|
||||
bannerImage description averageScore format
|
||||
seasonYear startDate { year }
|
||||
}
|
||||
}
|
||||
}`;
|
||||
|
||||
const response = await fetch('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
|
||||
body: JSON.stringify({ query: gql, variables: { search: query } })
|
||||
});
|
||||
|
||||
const liveData = await response.json();
|
||||
|
||||
if (liveData.data && liveData.data.Page.media.length > 0) {
|
||||
return liveData.data.Page.media;
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
export async function getBookInfoExtension(ext: Extension | null, id: string): Promise<any[]> {
|
||||
if (!ext) return [];
|
||||
|
||||
const extName = ext.constructor.name;
|
||||
|
||||
const cached = await getCachedExtension(extName, id);
|
||||
if (cached) {
|
||||
try {
|
||||
return JSON.parse(cached.metadata);
|
||||
} catch {}
|
||||
}
|
||||
|
||||
if (ext.type === 'book-board' && ext.getMetadata) {
|
||||
try {
|
||||
const info = await ext.getMetadata(id);
|
||||
|
||||
if (info) {
|
||||
const normalized = {
|
||||
id: info.id ?? id,
|
||||
title: info.title ?? "",
|
||||
format: info.format ?? "",
|
||||
score: typeof info.score === "number" ? info.score : null,
|
||||
genres: Array.isArray(info.genres) ? info.genres : [],
|
||||
status: info.status ?? "",
|
||||
published: info.published ?? "",
|
||||
summary: info.summary ?? "",
|
||||
chapters: Number.isFinite(info.chapters) ? info.chapters : 1,
|
||||
image: typeof info.image === "string" ? info.image : ""
|
||||
};
|
||||
|
||||
await cacheExtension(extName, id, normalized.title, normalized);
|
||||
return [normalized];
|
||||
}
|
||||
} catch (e) {
|
||||
console.error(`Extension getInfo failed:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
export async function searchBooksInExtension(ext: Extension | null, name: string, query: string): Promise<Book[]> {
|
||||
if (!ext) return [];
|
||||
|
||||
if ((ext.type === 'book-board') && ext.search) {
|
||||
|
||||
try {
|
||||
console.log(`[${name}] Searching for book: ${query}`);
|
||||
|
||||
const matches = await ext.search({
|
||||
query: query,
|
||||
media: {
|
||||
romajiTitle: query,
|
||||
englishTitle: query,
|
||||
startDate: { year: 0, month: 0, day: 0 }
|
||||
}
|
||||
});
|
||||
|
||||
if (matches?.length) {
|
||||
return matches.map(m => ({
|
||||
id: m.id,
|
||||
extensionName: name,
|
||||
title: { romaji: m.title, english: m.title, native: null },
|
||||
coverImage: { large: m.image || '' },
|
||||
averageScore: m.rating || m.score || null,
|
||||
format: m.format,
|
||||
seasonYear: null,
|
||||
isExtensionResult: true
|
||||
}));
|
||||
}
|
||||
|
||||
} catch (e) {
|
||||
console.error(`Extension search failed for ${name}:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
async function fetchBookMetadata(id: string): Promise<Book | null> {
|
||||
try {
|
||||
const query = `query ($id: Int) {
|
||||
Media(id: $id, type: MANGA) {
|
||||
title { romaji english }
|
||||
startDate { year month day }
|
||||
}
|
||||
}`;
|
||||
|
||||
const res = await fetch('https://graphql.anilist.co', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ query, variables: { id: parseInt(id) } })
|
||||
});
|
||||
|
||||
const d = await res.json();
|
||||
return d.data?.Media || null;
|
||||
} catch (e) {
|
||||
console.error("Failed to fetch book metadata:", e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
async function searchChaptersInExtension(ext: Extension, name: string, searchTitle: string, search: boolean, origin: string): Promise<ChapterWithProvider[]> {
|
||||
const cacheKey = `chapters:${name}:${origin}:${search ? "search" : "id"}:${searchTitle}`;
|
||||
const cached = await getCache(cacheKey);
|
||||
|
||||
if (cached) {
|
||||
const isExpired = Date.now() - cached.created_at > CACHE_TTL_MS;
|
||||
|
||||
if (!isExpired) {
|
||||
console.log(`[${name}] Chapters cache hit for: ${searchTitle}`);
|
||||
try {
|
||||
return JSON.parse(cached.result) as ChapterWithProvider[];
|
||||
} catch (e) {
|
||||
console.error(`[${name}] Error parsing cached chapters:`, e);
|
||||
}
|
||||
} else {
|
||||
console.log(`[${name}] Chapters cache expired for: ${searchTitle}`);
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
console.log(`[${name}] Searching chapters for: ${searchTitle}`);
|
||||
|
||||
let mediaId: string;
|
||||
if (search) {
|
||||
const matches = await ext.search!({
|
||||
query: searchTitle,
|
||||
media: {
|
||||
romajiTitle: searchTitle,
|
||||
englishTitle: searchTitle,
|
||||
startDate: { year: 0, month: 0, day: 0 }
|
||||
}
|
||||
});
|
||||
|
||||
const best = matches?.[0];
|
||||
|
||||
if (!best) { return [] }
|
||||
|
||||
mediaId = best.id;
|
||||
|
||||
} else {
|
||||
const match = await ext.getMetadata(searchTitle);
|
||||
mediaId = match.id;
|
||||
}
|
||||
|
||||
const chaps = await ext.findChapters!(mediaId);
|
||||
|
||||
if (!chaps?.length){
|
||||
return [];
|
||||
}
|
||||
|
||||
console.log(`[${name}] Found ${chaps.length} chapters.`);
|
||||
const result: ChapterWithProvider[] = chaps.map((ch) => ({
|
||||
id: ch.id,
|
||||
number: parseFloat(ch.number.toString()),
|
||||
title: ch.title,
|
||||
date: ch.releaseDate,
|
||||
provider: name,
|
||||
index: ch.index
|
||||
}));
|
||||
|
||||
await setCache(cacheKey, result, CACHE_TTL_MS);
|
||||
return result;
|
||||
|
||||
} catch (e) {
|
||||
const error = e as Error;
|
||||
console.error(`Failed to fetch chapters from ${name}:`, error.message);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
export async function getChaptersForBook(id: string, ext: Boolean, onlyProvider?: string): Promise<{ chapters: ChapterWithProvider[] }> {
|
||||
let bookData: Book | null = null;
|
||||
let searchTitle: string = "";
|
||||
|
||||
if (!ext) {
|
||||
const result = await getBookById(id);
|
||||
if (!result || "error" in result) return { chapters: [] }
|
||||
bookData = result;
|
||||
const titles = [bookData.title.english, bookData.title.romaji].filter(Boolean) as string[];
|
||||
searchTitle = titles[0];
|
||||
}
|
||||
const bookExtensions = getBookExtensionsMap();
|
||||
|
||||
let extension;
|
||||
if (!searchTitle) {
|
||||
for (const [name, ext] of bookExtensions) {
|
||||
const title = await getExtensionTitle(name, id)
|
||||
if (title){
|
||||
searchTitle = title;
|
||||
extension = name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const allChapters: any[] = [];
|
||||
let exts = "anilist";
|
||||
if (ext) exts = "ext";
|
||||
|
||||
for (const [name, ext] of bookExtensions) {
|
||||
if (onlyProvider && name !== onlyProvider) continue;
|
||||
if (name == extension) {
|
||||
const chapters = await searchChaptersInExtension(ext, name, id, false, exts);
|
||||
allChapters.push(...chapters);
|
||||
} else {
|
||||
const chapters = await searchChaptersInExtension(ext, name, searchTitle, true, exts);
|
||||
allChapters.push(...chapters);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
chapters: allChapters.sort((a, b) => Number(a.number) - Number(b.number))
|
||||
};
|
||||
}
|
||||
|
||||
export async function getChapterContent(bookId: string, chapterIndex: string, providerName: string, source: string): Promise<ChapterContent> {
|
||||
const extensions = getAllExtensions();
|
||||
const ext = extensions.get(providerName);
|
||||
|
||||
if (!ext) {
|
||||
throw new Error("Provider not found");
|
||||
}
|
||||
|
||||
const contentCacheKey = `content:${providerName}:${source}:${bookId}:${chapterIndex}`;
|
||||
const cachedContent = await getCache(contentCacheKey);
|
||||
|
||||
if (cachedContent) {
|
||||
const isExpired = Date.now() - cachedContent.created_at > CACHE_TTL_MS;
|
||||
|
||||
if (!isExpired) {
|
||||
console.log(`[${providerName}] Content cache hit for Book ID ${bookId}, Index ${chapterIndex}`);
|
||||
try {
|
||||
return JSON.parse(cachedContent.result) as ChapterContent;
|
||||
} catch (e) {
|
||||
console.error(`[${providerName}] Error parsing cached content:`, e);
|
||||
|
||||
}
|
||||
} else {
|
||||
console.log(`[${providerName}] Content cache expired for Book ID ${bookId}, Index ${chapterIndex}`);
|
||||
}
|
||||
}
|
||||
|
||||
const isExternal = source !== 'anilist';
|
||||
const chapterList = await getChaptersForBook(bookId, isExternal, providerName);
|
||||
|
||||
if (!chapterList?.chapters || chapterList.chapters.length === 0) {
|
||||
throw new Error("Chapters not found");
|
||||
}
|
||||
|
||||
const providerChapters = chapterList.chapters.filter(c => c.provider === providerName);
|
||||
const index = parseInt(chapterIndex, 10);
|
||||
|
||||
if (Number.isNaN(index)) {
|
||||
throw new Error("Invalid chapter index");
|
||||
}
|
||||
|
||||
if (!providerChapters[index]) {
|
||||
throw new Error("Chapter index out of range");
|
||||
}
|
||||
|
||||
const selectedChapter = providerChapters[index];
|
||||
|
||||
const chapterId = selectedChapter.id;
|
||||
const chapterTitle = selectedChapter.title || null;
|
||||
const chapterNumber = typeof selectedChapter.number === 'number' ? selectedChapter.number : index;
|
||||
|
||||
try {
|
||||
if (!ext.findChapterPages) {
|
||||
throw new Error("Extension doesn't support findChapterPages");
|
||||
}
|
||||
|
||||
let contentResult: ChapterContent;
|
||||
|
||||
if (ext.mediaType === "manga") {
|
||||
const pages = await ext.findChapterPages(chapterId);
|
||||
contentResult = {
|
||||
type: "manga",
|
||||
chapterId,
|
||||
title: chapterTitle,
|
||||
number: chapterNumber,
|
||||
provider: providerName,
|
||||
pages
|
||||
};
|
||||
} else if (ext.mediaType === "ln") {
|
||||
const content = await ext.findChapterPages(chapterId);
|
||||
contentResult = {
|
||||
type: "ln",
|
||||
chapterId,
|
||||
title: chapterTitle,
|
||||
number: chapterNumber,
|
||||
provider: providerName,
|
||||
content
|
||||
};
|
||||
} else {
|
||||
throw new Error("Unknown mediaType");
|
||||
}
|
||||
|
||||
await setCache(contentCacheKey, contentResult, CACHE_TTL_MS);
|
||||
|
||||
return contentResult;
|
||||
|
||||
} catch (err) {
|
||||
const error = err as Error;
|
||||
console.error(`[Chapter] Error loading from ${providerName}:`, error.message);
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
85
desktop/src/api/extensions/extensions.controller.ts
Normal file
85
desktop/src/api/extensions/extensions.controller.ts
Normal file
@@ -0,0 +1,85 @@
|
||||
import { FastifyReply, FastifyRequest } from 'fastify';
|
||||
import { getExtension, getExtensionsList, getGalleryExtensionsMap, getBookExtensionsMap, getAnimeExtensionsMap, saveExtensionFile, deleteExtensionFile } from '../../shared/extensions';
|
||||
import { ExtensionNameRequest } from '../types';
|
||||
|
||||
export async function getExtensions(req: FastifyRequest, reply: FastifyReply) {
|
||||
return { extensions: getExtensionsList() };
|
||||
}
|
||||
|
||||
export async function getAnimeExtensions(req: FastifyRequest, reply: FastifyReply) {
|
||||
const animeExtensions = getAnimeExtensionsMap();
|
||||
return { extensions: Array.from(animeExtensions.keys()) };
|
||||
}
|
||||
|
||||
export async function getBookExtensions(req: FastifyRequest, reply: FastifyReply) {
|
||||
const bookExtensions = getBookExtensionsMap();
|
||||
return { extensions: Array.from(bookExtensions.keys()) };
|
||||
}
|
||||
|
||||
export async function getGalleryExtensions(req: FastifyRequest, reply: FastifyReply) {
|
||||
const galleryExtensions = getGalleryExtensionsMap();
|
||||
return { extensions: Array.from(galleryExtensions.keys()) };
|
||||
}
|
||||
|
||||
export async function getExtensionSettings(req: ExtensionNameRequest, reply: FastifyReply) {
|
||||
const { name } = req.params;
|
||||
const ext = getExtension(name);
|
||||
|
||||
if (!ext) {
|
||||
return { error: "Extension not found" };
|
||||
}
|
||||
|
||||
if (!ext.getSettings) {
|
||||
return { episodeServers: ["default"], supportsDub: false };
|
||||
}
|
||||
|
||||
return ext.getSettings();
|
||||
}
|
||||
|
||||
export async function installExtension(req: any, reply: FastifyReply) {
|
||||
const { fileName } = req.body;
|
||||
|
||||
if (!fileName || !fileName.endsWith('.js')) {
|
||||
return reply.code(400).send({ error: "Invalid extension fileName provided" });
|
||||
}
|
||||
|
||||
try {
|
||||
|
||||
const downloadUrl = `https://git.waifuboard.app/ItsSkaiya/WaifuBoard-Extensions/raw/branch/main/${fileName}`
|
||||
|
||||
await saveExtensionFile(fileName, downloadUrl);
|
||||
|
||||
req.server.log.info(`Extension installed: ${fileName}`);
|
||||
return reply.code(200).send({ success: true, message: `Extension ${fileName} installed successfully.` });
|
||||
|
||||
} catch (error) {
|
||||
req.server.log.error(`Failed to install extension ${fileName}:`, error);
|
||||
return reply.code(500).send({ success: false, error: `Failed to install extension ${fileName}.` });
|
||||
}
|
||||
}
|
||||
|
||||
export async function uninstallExtension(req: any, reply: FastifyReply) {
|
||||
const { fileName } = req.body;
|
||||
|
||||
if (!fileName || !fileName.endsWith('.js')) {
|
||||
return reply.code(400).send({ error: "Invalid extension fileName provided" });
|
||||
}
|
||||
|
||||
try {
|
||||
|
||||
await deleteExtensionFile(fileName);
|
||||
|
||||
req.server.log.info(`Extension uninstalled: ${fileName}`);
|
||||
return reply.code(200).send({ success: true, message: `Extension ${fileName} uninstalled successfully.` });
|
||||
|
||||
} catch (error) {
|
||||
|
||||
// @ts-ignore
|
||||
if (error.code === 'ENOENT') {
|
||||
return reply.code(200).send({ success: true, message: `Extension ${fileName} already uninstalled (file not found).` });
|
||||
}
|
||||
|
||||
req.server.log.error(`Failed to uninstall extension ${fileName}:`, error);
|
||||
return reply.code(500).send({ success: false, error: `Failed to uninstall extension ${fileName}.` });
|
||||
}
|
||||
}
|
||||
14
desktop/src/api/extensions/extensions.routes.ts
Normal file
14
desktop/src/api/extensions/extensions.routes.ts
Normal file
@@ -0,0 +1,14 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import * as controller from './extensions.controller';
|
||||
|
||||
async function extensionsRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/extensions', controller.getExtensions);
|
||||
fastify.get('/extensions/anime', controller.getAnimeExtensions);
|
||||
fastify.get('/extensions/book', controller.getBookExtensions);
|
||||
fastify.get('/extensions/gallery', controller.getGalleryExtensions);
|
||||
fastify.get('/extensions/:name/settings', controller.getExtensionSettings);
|
||||
fastify.post('/extensions/install', controller.installExtension);
|
||||
fastify.post('/extensions/uninstall', controller.uninstallExtension);
|
||||
}
|
||||
|
||||
export default extensionsRoutes;
|
||||
126
desktop/src/api/gallery/gallery.controller.ts
Normal file
126
desktop/src/api/gallery/gallery.controller.ts
Normal file
@@ -0,0 +1,126 @@
|
||||
import {FastifyReply, FastifyRequest} from 'fastify';
|
||||
import * as galleryService from './gallery.service';
|
||||
|
||||
export async function searchInExtension(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const provider = req.query.provider;
|
||||
const query = req.query.q || '';
|
||||
const page = parseInt(req.query.page as string) || 1;
|
||||
const perPage = parseInt(req.query.perPage as string) || 48;
|
||||
|
||||
if (!provider) {
|
||||
return reply.code(400).send({ error: "Missing provider" });
|
||||
}
|
||||
|
||||
return await galleryService.searchInExtension(provider, query, page, perPage);
|
||||
|
||||
} catch (err) {
|
||||
console.error("Gallery SearchInExtension Error:", (err as Error).message);
|
||||
|
||||
return {
|
||||
results: [],
|
||||
total: 0,
|
||||
page: 1,
|
||||
hasNextPage: false
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export async function getInfo(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const provider = req.query.provider;
|
||||
|
||||
return await galleryService.getGalleryInfo(id, provider);
|
||||
} catch (err) {
|
||||
const error = err as Error;
|
||||
console.error("Gallery Info Error:", error.message);
|
||||
return reply.code(404).send({ error: "Gallery item not found" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function getFavorites(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
if (!req.user) return reply.code(401).send({ error: "Unauthorized" });
|
||||
|
||||
const favorites = await galleryService.getFavorites(req.user.id);
|
||||
return { favorites };
|
||||
} catch (err) {
|
||||
console.error("Get Favorites Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to retrieve favorites" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function getFavoriteById(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
if (!req.user) return reply.code(401).send({ error: "Unauthorized" });
|
||||
|
||||
const { id } = req.params as { id: string };
|
||||
|
||||
const favorite = await galleryService.getFavoriteById(id, req.user.id);
|
||||
|
||||
if (!favorite) {
|
||||
return reply.code(404).send({ error: "Favorite not found" });
|
||||
}
|
||||
|
||||
return { favorite };
|
||||
|
||||
} catch (err) {
|
||||
console.error("Get Favorite By ID Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to retrieve favorite" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function addFavorite(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
if (!req.user) return reply.code(401).send({ error: "Unauthorized" });
|
||||
|
||||
const { id, title, image_url, thumbnail_url, tags, provider, headers } = req.body;
|
||||
|
||||
if (!id || !title || !image_url || !thumbnail_url) {
|
||||
return reply.code(400).send({
|
||||
error: "Missing required fields"
|
||||
});
|
||||
}
|
||||
|
||||
const result = await galleryService.addFavorite({
|
||||
id,
|
||||
user_id: req.user.id,
|
||||
title,
|
||||
image_url,
|
||||
thumbnail_url,
|
||||
tags: tags || '',
|
||||
provider: provider || "",
|
||||
headers: headers || ""
|
||||
});
|
||||
|
||||
if (result.success) {
|
||||
return reply.code(201).send(result);
|
||||
} else {
|
||||
return reply.code(409).send(result);
|
||||
}
|
||||
|
||||
} catch (err) {
|
||||
console.error("Add Favorite Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to add favorite" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function removeFavorite(req: any, reply: FastifyReply) {
|
||||
try {
|
||||
if (!req.user) return reply.code(401).send({ error: "Unauthorized" });
|
||||
|
||||
const { id } = req.params;
|
||||
|
||||
const result = await galleryService.removeFavorite(id, req.user.id);
|
||||
|
||||
if (result.success) {
|
||||
return { success: true, message: "Favorite removed successfully" };
|
||||
} else {
|
||||
return reply.code(404).send({ error: "Favorite not found" });
|
||||
}
|
||||
} catch (err) {
|
||||
console.error("Remove Favorite Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to remove favorite" });
|
||||
}
|
||||
}
|
||||
13
desktop/src/api/gallery/gallery.routes.ts
Normal file
13
desktop/src/api/gallery/gallery.routes.ts
Normal file
@@ -0,0 +1,13 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import * as controller from './gallery.controller';
|
||||
|
||||
async function galleryRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/gallery/fetch/:id', controller.getInfo);
|
||||
fastify.get('/gallery/search/provider', controller.searchInExtension);
|
||||
fastify.get('/gallery/favorites', controller.getFavorites);
|
||||
fastify.get('/gallery/favorites/:id', controller.getFavoriteById);
|
||||
fastify.post('/gallery/favorites', controller.addFavorite);
|
||||
fastify.delete('/gallery/favorites/:id', controller.removeFavorite);
|
||||
}
|
||||
|
||||
export default galleryRoutes;
|
||||
178
desktop/src/api/gallery/gallery.service.ts
Normal file
178
desktop/src/api/gallery/gallery.service.ts
Normal file
@@ -0,0 +1,178 @@
|
||||
import { getAllExtensions, getExtension } from '../../shared/extensions';
|
||||
import { GallerySearchResult, GalleryInfo, Favorite, FavoriteResult } from '../types';
|
||||
import { getDatabase } from '../../shared/database';
|
||||
|
||||
export async function getGalleryInfo(id: string, providerName?: string): Promise<any> {
|
||||
const extensions = getAllExtensions();
|
||||
|
||||
if (providerName) {
|
||||
const ext = extensions.get(providerName);
|
||||
if (ext && ext.type === 'image-board' && ext.getInfo) {
|
||||
try {
|
||||
console.log(`[Gallery] Getting info from ${providerName} for: ${id}`);
|
||||
const info = await ext.getInfo(id);
|
||||
return {
|
||||
id: info.id ?? id,
|
||||
provider: providerName,
|
||||
image: info.image,
|
||||
tags: info.tags,
|
||||
title: info.title,
|
||||
headers: info.headers
|
||||
};
|
||||
} catch (e) {
|
||||
const error = e as Error;
|
||||
console.error(`[Gallery] Failed to get info from ${providerName}:`, error.message);
|
||||
throw new Error(`Failed to get gallery info from ${providerName}`);
|
||||
}
|
||||
}
|
||||
throw new Error("Provider not found or doesn't support getInfo");
|
||||
}
|
||||
|
||||
for (const [name, ext] of extensions) {
|
||||
if (ext.type === 'gallery' && ext.getInfo) {
|
||||
try {
|
||||
console.log(`[Gallery] Trying to get info from ${name} for: ${id}`);
|
||||
const info = await ext.getInfo(id);
|
||||
return {
|
||||
...info,
|
||||
provider: name
|
||||
};
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error("Gallery item not found in any extension");
|
||||
}
|
||||
|
||||
export async function searchInExtension(providerName: string, query: string, page: number = 1, perPage: number = 48): Promise<any> {
|
||||
const ext = getExtension(providerName);
|
||||
|
||||
try {
|
||||
console.log(`[Gallery] Searching ONLY in ${providerName} for: ${query}`);
|
||||
const results = await ext.search(query, page, perPage);
|
||||
|
||||
const normalizedResults = (results?.results ?? []).map((r: any) => ({
|
||||
id: r.id,
|
||||
image: r.image,
|
||||
tags: r.tags,
|
||||
title: r.title,
|
||||
headers: r.headers,
|
||||
provider: providerName
|
||||
}));
|
||||
|
||||
return {
|
||||
page: results.page ?? page,
|
||||
hasNextPage: !!results.hasNextPage,
|
||||
results: normalizedResults
|
||||
};
|
||||
|
||||
} catch (e) {
|
||||
const error = e as Error;
|
||||
console.error(`[Gallery] Search failed in ${providerName}:`, error.message);
|
||||
|
||||
return {
|
||||
total: 0,
|
||||
next: 0,
|
||||
previous: 0,
|
||||
pages: 0,
|
||||
page,
|
||||
hasNextPage: false,
|
||||
results: []
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export async function getFavorites(userId: number): Promise<Favorite[]> {
|
||||
const db = getDatabase("favorites");
|
||||
|
||||
return new Promise((resolve) => {
|
||||
db.all(
|
||||
'SELECT * FROM favorites WHERE user_id = ?',
|
||||
[userId],
|
||||
(err: Error | null, rows: Favorite[]) => {
|
||||
if (err) {
|
||||
console.error('Error getting favorites:', err.message);
|
||||
resolve([]);
|
||||
} else {
|
||||
resolve(rows);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
export async function getFavoriteById(id: string, userId: number): Promise<Favorite | null> {
|
||||
const db = getDatabase("favorites");
|
||||
|
||||
return new Promise((resolve) => {
|
||||
db.get(
|
||||
'SELECT * FROM favorites WHERE id = ? AND user_id = ?',
|
||||
[id, userId],
|
||||
(err: Error | null, row: Favorite | undefined) => {
|
||||
if (err) {
|
||||
console.error('Error getting favorite by id:', err.message);
|
||||
resolve(null);
|
||||
} else {
|
||||
resolve(row || null);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
export async function addFavorite(fav: Favorite & { user_id: number }): Promise<FavoriteResult> {
|
||||
const db = getDatabase("favorites");
|
||||
|
||||
return new Promise((resolve) => {
|
||||
const stmt = `
|
||||
INSERT INTO favorites (id, user_id, title, image_url, thumbnail_url, tags, headers, provider)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`;
|
||||
|
||||
db.run(
|
||||
stmt,
|
||||
[
|
||||
fav.id,
|
||||
fav.user_id,
|
||||
fav.title,
|
||||
fav.image_url,
|
||||
fav.thumbnail_url,
|
||||
fav.tags || "",
|
||||
fav.headers || "",
|
||||
fav.provider || ""
|
||||
],
|
||||
function (err: any) {
|
||||
if (err) {
|
||||
if (err.code && err.code.includes('SQLITE_CONSTRAINT')) {
|
||||
resolve({ success: false, error: 'Item is already a favorite.' });
|
||||
} else {
|
||||
console.error('Error adding favorite:', err.message);
|
||||
resolve({ success: false, error: err.message });
|
||||
}
|
||||
} else {
|
||||
resolve({ success: true, id: fav.id });
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
export async function removeFavorite(id: string, userId: number): Promise<FavoriteResult> {
|
||||
const db = getDatabase("favorites");
|
||||
|
||||
return new Promise((resolve) => {
|
||||
const stmt = 'DELETE FROM favorites WHERE id = ? AND user_id = ?';
|
||||
|
||||
db.run(stmt, [id, userId], function (err: Error | null) {
|
||||
if (err) {
|
||||
console.error('Error removing favorite:', err.message);
|
||||
resolve({ success: false, error: err.message });
|
||||
} else {
|
||||
// @ts-ignore
|
||||
resolve({ success: this.changes > 0 });
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
166
desktop/src/api/list/list.controller.ts
Normal file
166
desktop/src/api/list/list.controller.ts
Normal file
@@ -0,0 +1,166 @@
|
||||
import {FastifyReply, FastifyRequest} from 'fastify';
|
||||
import * as listService from './list.service';
|
||||
|
||||
interface UserRequest extends FastifyRequest {
|
||||
user?: { id: number };
|
||||
}
|
||||
|
||||
interface EntryParams {
|
||||
entryId: string;
|
||||
|
||||
}
|
||||
|
||||
interface SingleEntryQuery {
|
||||
source: string;
|
||||
entry_type: string;
|
||||
}
|
||||
|
||||
export async function getList(req: UserRequest, reply: FastifyReply) {
|
||||
const userId = req.user?.id;
|
||||
if (!userId) {
|
||||
return reply.code(401).send({ error: "Unauthorized" });
|
||||
}
|
||||
|
||||
try {
|
||||
const results = await listService.getUserList(userId);
|
||||
return { results };
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return reply.code(500).send({ error: "Failed to retrieve list" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function getSingleEntry(req: UserRequest, reply: FastifyReply) {
|
||||
const userId = req.user?.id;
|
||||
const { entryId } = req.params as EntryParams;
|
||||
const { source, entry_type } = req.query as SingleEntryQuery;
|
||||
|
||||
if (!userId) {
|
||||
return reply.code(401).send({ error: "Unauthorized" });
|
||||
}
|
||||
|
||||
if (!entryId || !source || !entry_type) {
|
||||
return reply.code(400).send({ error: "Missing required identifier: entryId, source, or entry_type." });
|
||||
}
|
||||
|
||||
try {
|
||||
|
||||
const entry = await listService.getSingleListEntry(
|
||||
userId,
|
||||
entryId,
|
||||
source,
|
||||
entry_type
|
||||
);
|
||||
|
||||
if (!entry) {
|
||||
|
||||
return reply.code(404).send({ found: false, message: "Entry not found in user list." });
|
||||
}
|
||||
|
||||
return { found: true, entry: entry };
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return reply.code(500).send({ error: "Failed to retrieve list entry" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function upsertEntry(req: UserRequest, reply: FastifyReply) {
|
||||
const userId = req.user?.id;
|
||||
const body = req.body as any;
|
||||
|
||||
if (!userId) {
|
||||
return reply.code(401).send({ error: "Unauthorized" });
|
||||
}
|
||||
|
||||
if (!body.entry_id || !body.source || !body.status || !body.entry_type) {
|
||||
return reply.code(400).send({
|
||||
error: "Missing required fields (entry_id, source, status, entry_type)."
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
const entryData = {
|
||||
user_id: userId,
|
||||
entry_id: body.entry_id,
|
||||
external_id: body.external_id,
|
||||
source: body.source,
|
||||
entry_type: body.entry_type,
|
||||
status: body.status,
|
||||
progress: body.progress || 0,
|
||||
score: body.score || null,
|
||||
start_date: body.start_date || null,
|
||||
end_date: body.end_date || null,
|
||||
repeat_count: body.repeat_count ?? 0,
|
||||
notes: body.notes || null,
|
||||
is_private: body.is_private ?? 0
|
||||
};
|
||||
|
||||
const result = await listService.upsertListEntry(entryData);
|
||||
|
||||
return { success: true, changes: result.changes };
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return reply.code(500).send({ error: "Failed to save list entry" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function deleteEntry(req: UserRequest, reply: FastifyReply) {
|
||||
const userId = req.user?.id;
|
||||
const { entryId } = req.params as EntryParams;
|
||||
const { source } = req.query as { source?: string }; // ✅ VIENE DEL FRONT
|
||||
|
||||
if (!userId) {
|
||||
return reply.code(401).send({ error: "Unauthorized" });
|
||||
}
|
||||
|
||||
if (!entryId || !source) {
|
||||
return reply.code(400).send({ error: "Missing entryId or source." });
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await listService.deleteListEntry(
|
||||
userId,
|
||||
entryId,
|
||||
source
|
||||
);
|
||||
|
||||
if (result.success) {
|
||||
return { success: true, external: result.external };
|
||||
} else {
|
||||
return reply.code(404).send({
|
||||
error: "Entry not found or unauthorized to delete."
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return reply.code(500).send({ error: "Failed to delete list entry" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function getListByFilter(req: UserRequest, reply: FastifyReply) {
|
||||
const userId = req.user?.id;
|
||||
const { status, entry_type } = req.query as any;
|
||||
|
||||
if (!userId) {
|
||||
return reply.code(401).send({ error: "Unauthorized" });
|
||||
}
|
||||
|
||||
if (!status && !entry_type) {
|
||||
return reply.code(400).send({
|
||||
error: "At least one filter is required (status or entry_type)."
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
const results = await listService.getUserListByFilter(
|
||||
userId,
|
||||
status,
|
||||
entry_type
|
||||
);
|
||||
|
||||
return { results };
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return reply.code(500).send({ error: "Failed to retrieve filtered list" });
|
||||
}
|
||||
}
|
||||
12
desktop/src/api/list/list.routes.ts
Normal file
12
desktop/src/api/list/list.routes.ts
Normal file
@@ -0,0 +1,12 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import * as controller from './list.controller';
|
||||
|
||||
async function listRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/list', controller.getList);
|
||||
fastify.get('/list/entry/:entryId', controller.getSingleEntry);
|
||||
fastify.post('/list/entry', controller.upsertEntry);
|
||||
fastify.delete('/list/entry/:entryId', controller.deleteEntry);
|
||||
fastify.get('/list/filter', controller.getListByFilter);
|
||||
}
|
||||
|
||||
export default listRoutes;
|
||||
584
desktop/src/api/list/list.service.ts
Normal file
584
desktop/src/api/list/list.service.ts
Normal file
@@ -0,0 +1,584 @@
|
||||
import {queryAll, run, queryOne} from '../../shared/database';
|
||||
import {getExtension} from '../../shared/extensions';
|
||||
import * as animeService from '../anime/anime.service';
|
||||
import * as booksService from '../books/books.service';
|
||||
import * as aniListService from '../anilist/anilist.service';
|
||||
|
||||
interface ListEntryData {
|
||||
entry_type: any;
|
||||
user_id: number;
|
||||
entry_id: number;
|
||||
|
||||
source: string;
|
||||
|
||||
status: string;
|
||||
|
||||
progress: number;
|
||||
score: number | null;
|
||||
}
|
||||
|
||||
const USER_DB = 'userdata';
|
||||
|
||||
export async function upsertListEntry(entry: any) {
|
||||
const {
|
||||
user_id,
|
||||
entry_id,
|
||||
source,
|
||||
entry_type,
|
||||
status,
|
||||
progress,
|
||||
score,
|
||||
start_date,
|
||||
end_date,
|
||||
repeat_count,
|
||||
notes,
|
||||
is_private
|
||||
} = entry;
|
||||
|
||||
let prev: any = null;
|
||||
|
||||
try {
|
||||
prev = await getSingleListEntry(user_id, entry_id, source, entry_type);
|
||||
} catch {
|
||||
prev = null;
|
||||
|
||||
}
|
||||
|
||||
const isNew = !prev;
|
||||
if (!isNew && prev?.progress != null && progress < prev.progress) {
|
||||
return { changes: 0, ignored: true };
|
||||
}
|
||||
|
||||
const today = new Date().toISOString().slice(0, 10);
|
||||
|
||||
if (prev?.start_date && !entry.start_date) {
|
||||
entry.start_date = prev.start_date;
|
||||
}
|
||||
|
||||
if (!prev?.start_date && progress === 1) {
|
||||
entry.start_date = today;
|
||||
}
|
||||
|
||||
const total =
|
||||
prev?.total_episodes ??
|
||||
prev?.total_chapters ??
|
||||
null;
|
||||
|
||||
if (total && progress >= total) {
|
||||
entry.status = 'COMPLETED';
|
||||
entry.end_date = today;
|
||||
}
|
||||
|
||||
if (source === 'anilist') {
|
||||
const token = await getActiveAccessToken(user_id);
|
||||
|
||||
if (token) {
|
||||
try {
|
||||
const result = await aniListService.updateAniListEntry(token, {
|
||||
mediaId: entry.entry_id,
|
||||
status: entry.status,
|
||||
progress: entry.progress,
|
||||
score: entry.score,
|
||||
start_date: entry.start_date,
|
||||
end_date: entry.end_date,
|
||||
repeat_count: entry.repeat_count,
|
||||
notes: entry.notes,
|
||||
is_private: entry.is_private
|
||||
});
|
||||
|
||||
return { changes: 0, external: true, anilistResult: result };
|
||||
} catch (err) {
|
||||
console.error("Error actualizando AniList:", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const sql = `
|
||||
INSERT INTO ListEntry
|
||||
(
|
||||
user_id, entry_id, source, entry_type, status,
|
||||
progress, score,
|
||||
start_date, end_date, repeat_count, notes, is_private,
|
||||
updated_at
|
||||
)
|
||||
VALUES
|
||||
(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
|
||||
ON CONFLICT(user_id, entry_id) DO UPDATE SET
|
||||
source = EXCLUDED.source,
|
||||
entry_type = EXCLUDED.entry_type,
|
||||
status = EXCLUDED.status,
|
||||
progress = EXCLUDED.progress,
|
||||
score = EXCLUDED.score,
|
||||
start_date = EXCLUDED.start_date,
|
||||
end_date = EXCLUDED.end_date,
|
||||
repeat_count = EXCLUDED.repeat_count,
|
||||
notes = EXCLUDED.notes,
|
||||
is_private = EXCLUDED.is_private,
|
||||
updated_at = CURRENT_TIMESTAMP;
|
||||
`;
|
||||
|
||||
const params = [
|
||||
entry.user_id,
|
||||
entry.entry_id,
|
||||
entry.source,
|
||||
entry.entry_type,
|
||||
entry.status,
|
||||
entry.progress,
|
||||
entry.score ?? null,
|
||||
entry.start_date || null,
|
||||
entry.end_date || null,
|
||||
entry.repeat_count ?? 0,
|
||||
entry.notes || null,
|
||||
entry.is_private ?? 0
|
||||
];
|
||||
|
||||
try {
|
||||
const result = await run(sql, params, USER_DB);
|
||||
return { changes: result.changes, lastID: result.lastID, external: false };
|
||||
} catch (error) {
|
||||
console.error("Error al guardar la entrada de lista:", error);
|
||||
throw new Error("Error en la base de datos al guardar la entrada.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function getUserList(userId: number): Promise<any> {
|
||||
const sql = `
|
||||
SELECT * FROM ListEntry
|
||||
WHERE user_id = ?
|
||||
ORDER BY updated_at DESC;
|
||||
`;
|
||||
|
||||
try {
|
||||
const dbList = await queryAll(sql, [userId], USER_DB) as ListEntryData[];
|
||||
const connected = await isConnected(userId);
|
||||
|
||||
let finalList: any[] = [...dbList];
|
||||
|
||||
if (connected) {
|
||||
const anilistEntries = await aniListService.getUserAniList(userId);
|
||||
const localWithoutAnilist = dbList.filter(
|
||||
entry => entry.source !== 'anilist'
|
||||
);
|
||||
|
||||
finalList = [...anilistEntries, ...localWithoutAnilist];
|
||||
}
|
||||
|
||||
const enrichedListPromises = finalList.map(async (entry) => {
|
||||
if (entry.source === 'anilist' && connected) {
|
||||
let finalTitle = entry.title;
|
||||
if (typeof finalTitle === 'object' && finalTitle !== null) {
|
||||
finalTitle =
|
||||
finalTitle.userPreferred ||
|
||||
finalTitle.english ||
|
||||
finalTitle.romaji ||
|
||||
'Unknown Title';
|
||||
}
|
||||
|
||||
return {
|
||||
...entry,
|
||||
title: finalTitle,
|
||||
poster: entry.poster || 'https://placehold.co/400x600?text=No+Cover',
|
||||
};
|
||||
}
|
||||
|
||||
let contentDetails: any | null = null;
|
||||
const id = entry.entry_id;
|
||||
const type = entry.entry_type;
|
||||
const ext = getExtension(entry.source);
|
||||
|
||||
try {
|
||||
if (type === 'ANIME') {
|
||||
if(entry.source === 'anilist') {
|
||||
const anime: any = await animeService.getAnimeById(id);
|
||||
contentDetails = {
|
||||
title: anime?.title.english || 'Unknown Anime Title',
|
||||
poster: anime?.coverImage?.extraLarge || '',
|
||||
total_episodes: anime?.episodes || 0,
|
||||
};
|
||||
}
|
||||
else{
|
||||
const anime: any = await animeService.getAnimeInfoExtension(ext, id.toString());
|
||||
|
||||
contentDetails = {
|
||||
title: anime?.title || 'Unknown Anime Title',
|
||||
poster: anime?.image || 'https://placehold.co/400x600?text=No+Cover',
|
||||
total_episodes: anime?.episodes || 0,
|
||||
};
|
||||
}
|
||||
|
||||
} else if (type === 'MANGA' || type === 'NOVEL') {
|
||||
if(entry.source === 'anilist') {
|
||||
const book: any = await booksService.getBookById(id);
|
||||
|
||||
contentDetails = {
|
||||
title: book?.title.english || 'Unknown Book Title',
|
||||
poster: book?.coverImage?.extraLarge || 'https://placehold.co/400x600?text=No+Cover',
|
||||
total_chapters: book?.chapters || book?.volumes * 10 || 0,
|
||||
};
|
||||
}
|
||||
else{
|
||||
const book: any = await booksService.getBookInfoExtension(ext, id.toString());
|
||||
|
||||
contentDetails = {
|
||||
title: book?.title || 'Unknown Book Title',
|
||||
poster: book?.image || '',
|
||||
total_chapters: book?.chapters || book?.volumes * 10 || 0,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
} catch {
|
||||
contentDetails = {
|
||||
title: 'Error Loading Details',
|
||||
poster: 'https://placehold.co/400x600?text=No+Cover',
|
||||
};
|
||||
}
|
||||
|
||||
let finalTitle = contentDetails?.title || 'Unknown Title';
|
||||
let finalPoster = contentDetails?.poster || 'https://placehold.co/400x600?text=No+Cover';
|
||||
|
||||
if (typeof finalTitle === 'object' && finalTitle !== null) {
|
||||
finalTitle =
|
||||
finalTitle.userPreferred ||
|
||||
finalTitle.english ||
|
||||
finalTitle.romaji ||
|
||||
'Unknown Title';
|
||||
}
|
||||
|
||||
return {
|
||||
...entry,
|
||||
title: finalTitle,
|
||||
poster: finalPoster,
|
||||
total_episodes: contentDetails?.total_episodes,
|
||||
total_chapters: contentDetails?.total_chapters,
|
||||
};
|
||||
});
|
||||
|
||||
return await Promise.all(enrichedListPromises);
|
||||
|
||||
} catch (error) {
|
||||
console.error("Error al obtener la lista del usuario:", error);
|
||||
throw new Error("Error getting list.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function deleteListEntry(
|
||||
userId: number,
|
||||
entryId: string | number,
|
||||
source: string
|
||||
) {
|
||||
|
||||
if (source === 'anilist') {
|
||||
const token = await getActiveAccessToken(userId);
|
||||
|
||||
if (token) {
|
||||
try {
|
||||
await aniListService.deleteAniListEntry(
|
||||
token,
|
||||
Number(entryId),
|
||||
);
|
||||
|
||||
return { success: true, external: true };
|
||||
} catch (err) {
|
||||
console.error("Error borrando en AniList:", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const sql = `
|
||||
DELETE FROM ListEntry
|
||||
WHERE user_id = ? AND entry_id = ?;
|
||||
`;
|
||||
|
||||
const result = await run(sql, [userId, entryId], USER_DB);
|
||||
return { success: result.changes > 0, changes: result.changes, external: false };
|
||||
}
|
||||
|
||||
export async function getSingleListEntry(
|
||||
userId: number,
|
||||
entryId: string | number,
|
||||
source: string,
|
||||
entryType: string
|
||||
): Promise<any> {
|
||||
|
||||
const localSql = `
|
||||
SELECT * FROM ListEntry
|
||||
WHERE user_id = ? AND entry_id = ? AND source = ? AND entry_type = ?;
|
||||
`;
|
||||
|
||||
const localResult = await queryAll(
|
||||
localSql,
|
||||
[userId, entryId, source, entryType],
|
||||
USER_DB
|
||||
) as any[];
|
||||
|
||||
if (localResult.length > 0) {
|
||||
const entry = localResult[0];
|
||||
|
||||
const contentDetails: any =
|
||||
entryType === 'ANIME'
|
||||
? await animeService.getAnimeById(entryId).catch(() => null)
|
||||
: await booksService.getBookById(entryId).catch(() => null);
|
||||
|
||||
let finalTitle = contentDetails?.title || 'Unknown';
|
||||
let finalPoster = contentDetails?.coverImage?.extraLarge ||
|
||||
contentDetails?.image ||
|
||||
'https://placehold.co/400x600?text=No+Cover';
|
||||
|
||||
if (typeof finalTitle === 'object') {
|
||||
finalTitle =
|
||||
finalTitle.userPreferred ||
|
||||
finalTitle.english ||
|
||||
finalTitle.romaji ||
|
||||
'Unknown';
|
||||
}
|
||||
|
||||
return {
|
||||
...entry,
|
||||
title: finalTitle,
|
||||
poster: finalPoster,
|
||||
total_episodes: contentDetails?.episodes,
|
||||
total_chapters: contentDetails?.chapters,
|
||||
};
|
||||
}
|
||||
|
||||
if (source === 'anilist') {
|
||||
|
||||
const connected = await isConnected(userId);
|
||||
if (!connected) return null;
|
||||
|
||||
const sql = `
|
||||
SELECT access_token
|
||||
FROM UserIntegration
|
||||
WHERE user_id = ? AND platform = 'AniList';
|
||||
`;
|
||||
|
||||
const integration = await queryOne(sql, [userId], USER_DB) as any;
|
||||
if (!integration?.access_token) return null;
|
||||
if (entryType === 'NOVEL') {entryType = 'MANGA'}
|
||||
|
||||
const aniEntry = await aniListService.getSingleAniListEntry(
|
||||
integration.access_token,
|
||||
Number(entryId),
|
||||
entryType as any
|
||||
);
|
||||
|
||||
if (!aniEntry) return null;
|
||||
|
||||
const contentDetails: any =
|
||||
entryType === 'ANIME'
|
||||
? await animeService.getAnimeById(entryId).catch(() => null)
|
||||
: await booksService.getBookById(entryId).catch(() => null);
|
||||
|
||||
let finalTitle = contentDetails?.title || 'Unknown';
|
||||
let finalPoster = contentDetails?.coverImage?.extraLarge ||
|
||||
contentDetails?.image ||
|
||||
'https://placehold.co/400x600?text=No+Cover';
|
||||
|
||||
if (typeof finalTitle === 'object') {
|
||||
finalTitle =
|
||||
finalTitle.userPreferred ||
|
||||
finalTitle.english ||
|
||||
finalTitle.romaji ||
|
||||
'Unknown';
|
||||
}
|
||||
|
||||
return {
|
||||
user_id: userId,
|
||||
...aniEntry,
|
||||
title: finalTitle,
|
||||
poster: finalPoster,
|
||||
total_episodes: contentDetails?.episodes,
|
||||
total_chapters: contentDetails?.chapters,
|
||||
};
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
export async function getActiveAccessToken(userId: number): Promise<string | null> {
|
||||
const sql = `
|
||||
SELECT access_token, expires_at
|
||||
FROM UserIntegration
|
||||
WHERE user_id = ? AND platform = 'AniList';
|
||||
`;
|
||||
|
||||
try {
|
||||
const integration = await queryOne(sql, [userId], USER_DB) as any | null;
|
||||
|
||||
if (!integration) {
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
const expiryDate = new Date(integration.expires_at);
|
||||
const now = new Date();
|
||||
|
||||
const fiveMinutes = 5 * 60 * 1000;
|
||||
|
||||
if (expiryDate.getTime() < (now.getTime() + fiveMinutes)) {
|
||||
|
||||
console.log(`AniList token for user ${userId} expired or near expiry.`);
|
||||
return null;
|
||||
}
|
||||
|
||||
return integration.access_token;
|
||||
|
||||
} catch (error) {
|
||||
console.error("Error al verificar la integración de AniList:", error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export async function isConnected(userId: number): Promise<boolean> {
|
||||
const token = await getActiveAccessToken(userId);
|
||||
return !!token;
|
||||
}
|
||||
|
||||
export async function getUserListByFilter(
|
||||
userId: number,
|
||||
status?: string,
|
||||
entryType?: string
|
||||
): Promise<any> {
|
||||
|
||||
let sql = `
|
||||
SELECT * FROM ListEntry
|
||||
WHERE user_id = ?
|
||||
ORDER BY updated_at DESC;
|
||||
`;
|
||||
|
||||
const params: any[] = [userId];
|
||||
|
||||
try {
|
||||
const dbList = await queryAll(sql, params, USER_DB) as ListEntryData[];
|
||||
const connected = await isConnected(userId);
|
||||
|
||||
const statusMap: any = {
|
||||
watching: 'CURRENT',
|
||||
reading: 'CURRENT',
|
||||
completed: 'COMPLETED',
|
||||
paused: 'PAUSED',
|
||||
dropped: 'DROPPED',
|
||||
planning: 'PLANNING'
|
||||
};
|
||||
|
||||
const mappedStatus = status ? statusMap[status.toLowerCase()] : null;
|
||||
|
||||
let finalList: any[] = [];
|
||||
|
||||
const filteredLocal = dbList.filter((entry) => {
|
||||
if (mappedStatus && entry.status !== mappedStatus) return false;
|
||||
|
||||
if (entryType) {
|
||||
if (entryType === 'MANGA') {
|
||||
|
||||
if (!['MANGA', 'NOVEL'].includes(entry.entry_type)) return false;
|
||||
} else {
|
||||
if (entry.entry_type !== entryType) return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
|
||||
let filteredAniList: any[] = [];
|
||||
|
||||
if (connected) {
|
||||
const anilistEntries = await aniListService.getUserAniList(userId);
|
||||
|
||||
filteredAniList = anilistEntries.filter((entry: any) => {
|
||||
if (mappedStatus && entry.status !== mappedStatus) return false;
|
||||
|
||||
if (entryType) {
|
||||
if (entryType === 'MANGA') {
|
||||
if (!['MANGA', 'NOVEL'].includes(entry.entry_type)) return false;
|
||||
} else {
|
||||
if (entry.entry_type !== entryType) return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
finalList = [...filteredAniList, ...filteredLocal];
|
||||
|
||||
const enrichedListPromises = finalList.map(async (entry) => {
|
||||
|
||||
if (entry.source === 'anilist') {
|
||||
let finalTitle = entry.title;
|
||||
|
||||
if (typeof finalTitle === 'object' && finalTitle !== null) {
|
||||
finalTitle =
|
||||
finalTitle.userPreferred ||
|
||||
finalTitle.english ||
|
||||
finalTitle.romaji ||
|
||||
'Unknown Title';
|
||||
}
|
||||
|
||||
return {
|
||||
...entry,
|
||||
title: finalTitle,
|
||||
poster: entry.poster || 'https://placehold.co/400x600?text=No+Cover',
|
||||
};
|
||||
}
|
||||
|
||||
let contentDetails: any | null = null;
|
||||
const id = entry.entry_id;
|
||||
const type = entry.entry_type;
|
||||
const ext = getExtension(entry.source);
|
||||
|
||||
try {
|
||||
if (type === 'ANIME') {
|
||||
const anime: any = await animeService.getAnimeInfoExtension(ext, id.toString());
|
||||
|
||||
contentDetails = {
|
||||
title: anime?.title || 'Unknown Anime Title',
|
||||
poster: anime?.image || '',
|
||||
total_episodes: anime?.episodes || 0,
|
||||
};
|
||||
|
||||
} else if (type === 'MANGA' || type === 'NOVEL') {
|
||||
const book: any = await booksService.getBookInfoExtension(ext, id.toString());
|
||||
|
||||
contentDetails = {
|
||||
title: book?.title || 'Unknown Book Title',
|
||||
poster: book?.image || '',
|
||||
total_chapters: book?.chapters || book?.volumes * 10 || 0,
|
||||
};
|
||||
}
|
||||
|
||||
} catch {
|
||||
contentDetails = {
|
||||
title: 'Error Loading Details',
|
||||
poster: 'https://placehold.co/400x600?text=No+Cover',
|
||||
};
|
||||
}
|
||||
|
||||
let finalTitle = contentDetails?.title || 'Unknown Title';
|
||||
let finalPoster = contentDetails?.poster || 'https://placehold.co/400x600?text=No+Cover';
|
||||
|
||||
if (typeof finalTitle === 'object' && finalTitle !== null) {
|
||||
finalTitle =
|
||||
finalTitle.userPreferred ||
|
||||
finalTitle.english ||
|
||||
finalTitle.romaji ||
|
||||
'Unknown Title';
|
||||
}
|
||||
|
||||
return {
|
||||
...entry,
|
||||
title: finalTitle,
|
||||
poster: finalPoster,
|
||||
total_episodes: contentDetails?.total_episodes,
|
||||
total_chapters: contentDetails?.total_chapters,
|
||||
};
|
||||
});
|
||||
|
||||
return await Promise.all(enrichedListPromises);
|
||||
|
||||
} catch (error) {
|
||||
console.error("Error al filtrar la lista del usuario:", error);
|
||||
throw new Error("Error en la base de datos al obtener la lista filtrada.");
|
||||
}
|
||||
}
|
||||
60
desktop/src/api/proxy/proxy.controller.ts
Normal file
60
desktop/src/api/proxy/proxy.controller.ts
Normal file
@@ -0,0 +1,60 @@
|
||||
import {FastifyReply} from 'fastify';
|
||||
import {processM3U8Content, proxyRequest, streamToReadable} from './proxy.service';
|
||||
import {ProxyRequest} from '../types';
|
||||
|
||||
export async function handleProxy(req: ProxyRequest, reply: FastifyReply) {
|
||||
const { url, referer, origin, userAgent } = req.query;
|
||||
|
||||
if (!url) {
|
||||
return reply.code(400).send({ error: "No URL provided" });
|
||||
}
|
||||
|
||||
try {
|
||||
const { response, contentType, isM3U8, contentLength } = await proxyRequest(url, {
|
||||
referer,
|
||||
origin,
|
||||
userAgent
|
||||
});
|
||||
|
||||
reply.header('Access-Control-Allow-Origin', '*');
|
||||
reply.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
|
||||
reply.header('Access-Control-Allow-Headers', 'Content-Type, Range');
|
||||
reply.header('Access-Control-Expose-Headers', 'Content-Length, Content-Range, Accept-Ranges');
|
||||
|
||||
if (contentType) {
|
||||
reply.header('Content-Type', contentType);
|
||||
}
|
||||
|
||||
if (contentLength) {
|
||||
reply.header('Content-Length', contentLength);
|
||||
}
|
||||
|
||||
if (contentType?.startsWith('image/') || contentType?.startsWith('video/')) {
|
||||
reply.header('Cache-Control', 'public, max-age=31536000, immutable');
|
||||
}
|
||||
|
||||
reply.header('Accept-Ranges', 'bytes');
|
||||
|
||||
if (isM3U8) {
|
||||
const text = await response.text();
|
||||
const baseUrl = new URL(response.url);
|
||||
|
||||
const processedContent = processM3U8Content(text, baseUrl, {
|
||||
referer,
|
||||
origin,
|
||||
userAgent
|
||||
});
|
||||
|
||||
return reply.send(processedContent);
|
||||
}
|
||||
|
||||
return reply.send(streamToReadable(response.body!));
|
||||
|
||||
} catch (err) {
|
||||
req.server.log.error(err);
|
||||
|
||||
if (!reply.sent) {
|
||||
return reply.code(500).send({ error: "Internal Server Error" });
|
||||
}
|
||||
}
|
||||
}
|
||||
8
desktop/src/api/proxy/proxy.routes.ts
Normal file
8
desktop/src/api/proxy/proxy.routes.ts
Normal file
@@ -0,0 +1,8 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import { handleProxy } from './proxy.controller';
|
||||
|
||||
async function proxyRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/proxy', handleProxy);
|
||||
}
|
||||
|
||||
export default proxyRoutes;
|
||||
138
desktop/src/api/proxy/proxy.service.ts
Normal file
138
desktop/src/api/proxy/proxy.service.ts
Normal file
@@ -0,0 +1,138 @@
|
||||
import { Readable } from 'stream';
|
||||
|
||||
interface ProxyHeaders {
|
||||
referer?: string;
|
||||
origin?: string;
|
||||
userAgent?: string;
|
||||
}
|
||||
|
||||
interface ProxyResponse {
|
||||
response: Response;
|
||||
contentType: string | null;
|
||||
isM3U8: boolean;
|
||||
contentLength: string | null;
|
||||
}
|
||||
|
||||
export async function proxyRequest(url: string, { referer, origin, userAgent }: ProxyHeaders): Promise<ProxyResponse> {
|
||||
const headers: Record<string, string> = {
|
||||
'User-Agent': userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
|
||||
'Accept': '*/*',
|
||||
'Accept-Language': 'en-US,en;q=0.9',
|
||||
'Accept-Encoding': 'identity',
|
||||
|
||||
'Connection': 'keep-alive'
|
||||
};
|
||||
|
||||
if (referer) headers['Referer'] = referer;
|
||||
if (origin) headers['Origin'] = origin;
|
||||
|
||||
let lastError: Error | null = null;
|
||||
const maxRetries = 2;
|
||||
|
||||
for (let attempt = 0; attempt < maxRetries; attempt++) {
|
||||
try {
|
||||
|
||||
const controller = new AbortController();
|
||||
const timeoutId = setTimeout(() => controller.abort(), 60000);
|
||||
|
||||
const response = await fetch(url, {
|
||||
headers,
|
||||
redirect: 'follow',
|
||||
signal: controller.signal
|
||||
});
|
||||
|
||||
clearTimeout(timeoutId);
|
||||
|
||||
if (!response.ok) {
|
||||
|
||||
if (response.status === 404 || response.status === 403) {
|
||||
throw new Error(`Proxy Error: ${response.status} ${response.statusText}`);
|
||||
}
|
||||
|
||||
if (attempt < maxRetries - 1) {
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
continue;
|
||||
}
|
||||
|
||||
throw new Error(`Proxy Error: ${response.status} ${response.statusText}`);
|
||||
}
|
||||
|
||||
const contentType = response.headers.get('content-type');
|
||||
const contentLength = response.headers.get('content-length');
|
||||
const isM3U8 = (contentType && contentType.includes('mpegurl')) || url.includes('.m3u8');
|
||||
|
||||
return {
|
||||
response,
|
||||
contentType,
|
||||
isM3U8,
|
||||
contentLength
|
||||
};
|
||||
|
||||
} catch (error) {
|
||||
lastError = error as Error;
|
||||
|
||||
if (attempt === maxRetries - 1) {
|
||||
throw lastError;
|
||||
}
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
}
|
||||
}
|
||||
|
||||
throw lastError || new Error('Unknown error in proxyRequest');
|
||||
}
|
||||
|
||||
export function processM3U8Content(text: string, baseUrl: URL, { referer, origin, userAgent }: ProxyHeaders): string {
|
||||
return text.replace(/^(?!#)(?!\s*$).+/gm, (line) => {
|
||||
line = line.trim();
|
||||
let absoluteUrl: string;
|
||||
|
||||
try {
|
||||
absoluteUrl = new URL(line, baseUrl).href;
|
||||
} catch (e) {
|
||||
return line;
|
||||
}
|
||||
|
||||
const proxyParams = new URLSearchParams();
|
||||
proxyParams.set('url', absoluteUrl);
|
||||
if (referer) proxyParams.set('referer', referer);
|
||||
if (origin) proxyParams.set('origin', origin);
|
||||
if (userAgent) proxyParams.set('userAgent', userAgent);
|
||||
|
||||
return `/api/proxy?${proxyParams.toString()}`;
|
||||
});
|
||||
}
|
||||
|
||||
export function streamToReadable(webStream: ReadableStream): Readable {
|
||||
const reader = webStream.getReader();
|
||||
let readTimeout: NodeJS.Timeout;
|
||||
|
||||
return new Readable({
|
||||
async read() {
|
||||
try {
|
||||
|
||||
const timeoutPromise = new Promise((_, reject) => {
|
||||
readTimeout = setTimeout(() => reject(new Error('Stream read timeout')), 10000);
|
||||
});
|
||||
|
||||
const readPromise = reader.read();
|
||||
const { done, value } = await Promise.race([readPromise, timeoutPromise]) as any;
|
||||
|
||||
clearTimeout(readTimeout);
|
||||
|
||||
if (done) {
|
||||
this.push(null);
|
||||
} else {
|
||||
this.push(Buffer.from(value));
|
||||
}
|
||||
} catch (error) {
|
||||
clearTimeout(readTimeout);
|
||||
this.destroy(error as Error);
|
||||
}
|
||||
},
|
||||
destroy(error, callback) {
|
||||
clearTimeout(readTimeout);
|
||||
reader.cancel().then(() => callback(error)).catch(callback);
|
||||
}
|
||||
});
|
||||
}
|
||||
120
desktop/src/api/rpc/rp.service.ts
Normal file
120
desktop/src/api/rpc/rp.service.ts
Normal file
@@ -0,0 +1,120 @@
|
||||
// @ts-ignore
|
||||
import { DiscordRPCClient } from "@ryuziii/discord-rpc";
|
||||
|
||||
let rpcClient: DiscordRPCClient | null = null;
|
||||
let reconnectTimer: NodeJS.Timeout | null = null;
|
||||
let connected: boolean = false;
|
||||
|
||||
type RPCMode = "watching" | "reading" | string;
|
||||
|
||||
interface RPCData {
|
||||
details?: string;
|
||||
state?: string;
|
||||
mode?: RPCMode;
|
||||
version?: string;
|
||||
}
|
||||
|
||||
function attemptReconnect(clientId: string) {
|
||||
connected = false;
|
||||
|
||||
if (reconnectTimer) {
|
||||
clearTimeout(reconnectTimer);
|
||||
reconnectTimer = null;
|
||||
}
|
||||
|
||||
console.log('Discord RPC: Trying to reconnect...');
|
||||
|
||||
reconnectTimer = setTimeout(() => {
|
||||
initRPC(clientId);
|
||||
}, 10000);
|
||||
}
|
||||
|
||||
export function initRPC(clientId: string) {
|
||||
|
||||
if (rpcClient) {
|
||||
try { rpcClient.destroy(); } catch (e) {}
|
||||
rpcClient = null;
|
||||
}
|
||||
if (reconnectTimer) {
|
||||
clearTimeout(reconnectTimer);
|
||||
reconnectTimer = null;
|
||||
}
|
||||
|
||||
console.log(`Discord RPC: Starting with id ...${clientId.slice(-4)}`);
|
||||
|
||||
try {
|
||||
|
||||
rpcClient = new DiscordRPCClient({
|
||||
clientId: clientId,
|
||||
transport: 'ipc'
|
||||
});
|
||||
} catch (err) {
|
||||
console.error('Discord RPC:', err);
|
||||
return;
|
||||
}
|
||||
|
||||
rpcClient.on("ready", () => {
|
||||
connected = true;
|
||||
const user = rpcClient?.user ? rpcClient.user.username : 'User';
|
||||
console.log(`Discord RPC: Authenticated for: ${user}`);
|
||||
|
||||
setTimeout(() => {
|
||||
setActivity({ details: "Browsing", state: "In App", mode: "idle" });
|
||||
}, 1000);
|
||||
});
|
||||
|
||||
rpcClient.on('disconnected', () => {
|
||||
console.log('Discord RPC: Desconexión detectada.');
|
||||
attemptReconnect(clientId);
|
||||
});
|
||||
|
||||
rpcClient.on('error', (err: { message: any; }) => {
|
||||
console.error('[Discord RPC] Error:', err.message);
|
||||
|
||||
if (connected) {
|
||||
attemptReconnect(clientId);
|
||||
}
|
||||
});
|
||||
|
||||
try {
|
||||
rpcClient.connect().catch((err: { message: any; }) => {
|
||||
console.error('Discord RPC: Error al conectar', err.message);
|
||||
|
||||
attemptReconnect(clientId);
|
||||
});
|
||||
} catch (err) {
|
||||
console.error('Discord RPC: Error al iniciar la conexión', err);
|
||||
attemptReconnect(clientId);
|
||||
}
|
||||
}
|
||||
|
||||
export function setActivity(data: RPCData = {}) {
|
||||
if (!rpcClient || !connected) return;
|
||||
|
||||
let type;
|
||||
let state = data.state;
|
||||
let details = data.details;
|
||||
|
||||
if (data.mode === "watching") {
|
||||
type = 3
|
||||
} else if (data.mode === "reading") {
|
||||
type = 0
|
||||
} else {
|
||||
type = 0
|
||||
}
|
||||
|
||||
|
||||
try {
|
||||
rpcClient.setActivity({
|
||||
details: details,
|
||||
state: state,
|
||||
type: type,
|
||||
startTimestamp: new Date(),
|
||||
largeImageKey: "bigpicture",
|
||||
largeImageText: "v2.0.0",
|
||||
instance: false
|
||||
});
|
||||
} catch (error) {
|
||||
console.error("Discord RPC: Failed to set activity", error);
|
||||
}
|
||||
}
|
||||
27
desktop/src/api/rpc/rpc.controller.ts
Normal file
27
desktop/src/api/rpc/rpc.controller.ts
Normal file
@@ -0,0 +1,27 @@
|
||||
import { FastifyRequest, FastifyReply } from "fastify";
|
||||
import { setActivity, initRPC } from "./rp.service";
|
||||
|
||||
let initialized = false;
|
||||
|
||||
export function init() {
|
||||
if (!initialized) {
|
||||
initRPC(process.env.DISCORD_CLIENT_ID!);
|
||||
initialized = true;
|
||||
}
|
||||
}
|
||||
|
||||
export async function setRPC(request: FastifyRequest, reply: FastifyReply) {
|
||||
const { details, state, mode } = request.body as {
|
||||
details?: string;
|
||||
state?: string;
|
||||
mode?: "watching" | "reading" | string;
|
||||
};
|
||||
|
||||
setActivity({
|
||||
details,
|
||||
state,
|
||||
mode
|
||||
});
|
||||
|
||||
return reply.send({ ok: true });
|
||||
}
|
||||
8
desktop/src/api/rpc/rpc.routes.ts
Normal file
8
desktop/src/api/rpc/rpc.routes.ts
Normal file
@@ -0,0 +1,8 @@
|
||||
import { FastifyInstance } from "fastify";
|
||||
import * as controller from "./rpc.controller";
|
||||
|
||||
async function rpcRoutes(fastify: FastifyInstance) {
|
||||
fastify.post("/rpc", controller.setRPC);
|
||||
}
|
||||
|
||||
export default rpcRoutes;
|
||||
294
desktop/src/api/types.ts
Normal file
294
desktop/src/api/types.ts
Normal file
@@ -0,0 +1,294 @@
|
||||
import { FastifyRequest, FastifyReply } from 'fastify';
|
||||
|
||||
export interface AnimeTitle {
|
||||
romaji: string;
|
||||
english: string | null;
|
||||
native: string | null;
|
||||
userPreferred?: string;
|
||||
}
|
||||
|
||||
export interface CoverImage {
|
||||
extraLarge?: string;
|
||||
large: string;
|
||||
medium?: string;
|
||||
color?: string;
|
||||
}
|
||||
|
||||
export interface StartDate {
|
||||
year: number;
|
||||
month: number;
|
||||
day: number;
|
||||
}
|
||||
|
||||
export interface Anime {
|
||||
updatedAt: any;
|
||||
id: number | string;
|
||||
title: AnimeTitle;
|
||||
coverImage: CoverImage;
|
||||
bannerImage?: string;
|
||||
description?: string;
|
||||
averageScore: number | null;
|
||||
format: string;
|
||||
seasonYear: number | null;
|
||||
startDate?: StartDate;
|
||||
synonyms?: string[];
|
||||
extensionName?: string;
|
||||
isExtensionResult?: boolean;
|
||||
}
|
||||
|
||||
export interface Book {
|
||||
id: number | string;
|
||||
title: AnimeTitle;
|
||||
coverImage: CoverImage;
|
||||
bannerImage?: string;
|
||||
description?: string;
|
||||
averageScore: number | null;
|
||||
format: string;
|
||||
seasonYear: number | null;
|
||||
startDate?: StartDate;
|
||||
synonyms?: string[];
|
||||
extensionName?: string;
|
||||
isExtensionResult?: boolean;
|
||||
}
|
||||
|
||||
export interface ExtensionSearchOptions {
|
||||
query: string;
|
||||
dub?: boolean;
|
||||
media?: {
|
||||
romajiTitle: string;
|
||||
englishTitle: string;
|
||||
startDate: StartDate;
|
||||
};
|
||||
}
|
||||
|
||||
export interface ExtensionSearchResult {
|
||||
format: string;
|
||||
headers: any;
|
||||
id: string;
|
||||
title: string;
|
||||
image?: string;
|
||||
rating?: number;
|
||||
score?: number;
|
||||
}
|
||||
|
||||
export interface Episode {
|
||||
url: string;
|
||||
id: string;
|
||||
number: number;
|
||||
title?: string;
|
||||
}
|
||||
|
||||
export interface Chapter {
|
||||
index: number;
|
||||
id: string;
|
||||
number: string | number;
|
||||
title?: string;
|
||||
releaseDate?: string;
|
||||
}
|
||||
|
||||
export interface ChapterWithProvider extends Chapter {
|
||||
provider: string;
|
||||
date?: string;
|
||||
}
|
||||
|
||||
export interface Extension {
|
||||
getMetadata: any;
|
||||
type: 'anime-board' | 'book-board' | 'manga-board';
|
||||
mediaType?: 'manga' | 'ln';
|
||||
search?: (options: ExtensionSearchOptions) => Promise<ExtensionSearchResult[]>;
|
||||
findEpisodes?: (id: string) => Promise<Episode[]>;
|
||||
findEpisodeServer?: (episode: Episode, server: string) => Promise<any>;
|
||||
findChapters?: (id: string) => Promise<Chapter[]>;
|
||||
findChapterPages?: (chapterId: string) => Promise<any>;
|
||||
getSettings?: () => ExtensionSettings;
|
||||
}
|
||||
|
||||
export interface ExtensionSettings {
|
||||
episodeServers: string[];
|
||||
supportsDub: boolean;
|
||||
}
|
||||
|
||||
export interface StreamData {
|
||||
url?: string;
|
||||
sources?: any[];
|
||||
subtitles?: any[];
|
||||
}
|
||||
|
||||
export interface MangaChapterContent {
|
||||
type: 'manga';
|
||||
chapterId: string;
|
||||
title: string | null;
|
||||
number: number;
|
||||
provider: string;
|
||||
pages: any[];
|
||||
}
|
||||
|
||||
export interface LightNovelChapterContent {
|
||||
type: 'ln';
|
||||
chapterId: string;
|
||||
title: string | null;
|
||||
number: number;
|
||||
provider: string;
|
||||
content: any;
|
||||
}
|
||||
|
||||
export type ChapterContent = MangaChapterContent | LightNovelChapterContent;
|
||||
|
||||
export interface AnimeParams {
|
||||
id: string;
|
||||
}
|
||||
|
||||
export interface AnimeQuery {
|
||||
source?: string;
|
||||
}
|
||||
|
||||
export interface SearchQuery {
|
||||
q: string;
|
||||
}
|
||||
|
||||
export interface ExtensionNameParams {
|
||||
name: string;
|
||||
}
|
||||
|
||||
export interface WatchStreamQuery {
|
||||
source: string;
|
||||
animeId: string;
|
||||
episode: string;
|
||||
server?: string;
|
||||
category?: string;
|
||||
ext: string;
|
||||
}
|
||||
|
||||
export interface BookParams {
|
||||
id: string;
|
||||
}
|
||||
|
||||
export interface BookQuery {
|
||||
ext?: string;
|
||||
}
|
||||
|
||||
export interface ChapterParams {
|
||||
bookId: string;
|
||||
chapter: string;
|
||||
provider: string;
|
||||
}
|
||||
|
||||
export interface ProxyQuery {
|
||||
url: string;
|
||||
referer?: string;
|
||||
origin?: string;
|
||||
userAgent?: string;
|
||||
}
|
||||
|
||||
export type AnimeRequest = FastifyRequest<{
|
||||
Params: AnimeParams;
|
||||
Querystring: AnimeQuery;
|
||||
}>;
|
||||
|
||||
export type SearchRequest = FastifyRequest<{
|
||||
Querystring: SearchQuery;
|
||||
}>;
|
||||
|
||||
export type ExtensionNameRequest = FastifyRequest<{
|
||||
Params: ExtensionNameParams;
|
||||
}>;
|
||||
|
||||
export type WatchStreamRequest = FastifyRequest<{
|
||||
Querystring: WatchStreamQuery;
|
||||
}>;
|
||||
|
||||
export type BookRequest = FastifyRequest<{
|
||||
Params: BookParams;
|
||||
Querystring: BookQuery;
|
||||
}>;
|
||||
|
||||
export type ChapterRequest = FastifyRequest<{
|
||||
Params: ChapterParams;
|
||||
}>;
|
||||
|
||||
export type ProxyRequest = FastifyRequest<{
|
||||
Querystring: ProxyQuery;
|
||||
}>;
|
||||
|
||||
export interface GalleryItemPreview {
|
||||
id: string;
|
||||
image: string;
|
||||
tags: string[];
|
||||
type: 'preview';
|
||||
provider?: string;
|
||||
}
|
||||
|
||||
export interface GallerySearchResult {
|
||||
total: number;
|
||||
next: number;
|
||||
previous: number;
|
||||
pages: number;
|
||||
page: number;
|
||||
hasNextPage: boolean;
|
||||
results: GalleryItemPreview[];
|
||||
}
|
||||
|
||||
export interface GalleryInfo {
|
||||
id: string;
|
||||
fullImage: string;
|
||||
resizedImageUrl: string;
|
||||
tags: string[];
|
||||
createdAt: string | null;
|
||||
publishedBy: string;
|
||||
rating: string;
|
||||
comments: any[];
|
||||
provider?: string;
|
||||
}
|
||||
|
||||
export interface GalleryExtension {
|
||||
type: 'gallery';
|
||||
search: (query: string, page: number, perPage: number) => Promise<GallerySearchResult>;
|
||||
getInfo: (id: string) => Promise<Omit<GalleryInfo, 'provider'>>;
|
||||
}
|
||||
|
||||
export interface GallerySearchRequest extends FastifyRequest {
|
||||
query: {
|
||||
q?: string;
|
||||
page?: string;
|
||||
perPage?: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface GalleryInfoRequest extends FastifyRequest {
|
||||
params: {
|
||||
id: string;
|
||||
};
|
||||
query: {
|
||||
provider?: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface AddFavoriteBody {
|
||||
id: string;
|
||||
title: string;
|
||||
image_url: string;
|
||||
thumbnail_url: string;
|
||||
tags?: string;
|
||||
provider: string;
|
||||
headers: string;
|
||||
}
|
||||
|
||||
export interface RemoveFavoriteParams {
|
||||
id: string;
|
||||
}
|
||||
|
||||
export interface Favorite {
|
||||
id: string;
|
||||
title: string;
|
||||
image_url: string;
|
||||
thumbnail_url: string;
|
||||
tags: string;
|
||||
provider: string;
|
||||
headers: string;
|
||||
}
|
||||
|
||||
export interface FavoriteResult {
|
||||
success: boolean;
|
||||
error?: string;
|
||||
id?: string;
|
||||
}
|
||||
269
desktop/src/api/user/user.controller.ts
Normal file
269
desktop/src/api/user/user.controller.ts
Normal file
@@ -0,0 +1,269 @@
|
||||
import { FastifyReply, FastifyRequest } from 'fastify';
|
||||
import * as userService from './user.service';
|
||||
import {queryOne} from '../../shared/database';
|
||||
import jwt from "jsonwebtoken";
|
||||
|
||||
interface UserIdParams { id: string; }
|
||||
interface CreateUserBody {
|
||||
username: string;
|
||||
profilePictureUrl?: string;
|
||||
password?: string;
|
||||
}
|
||||
interface UpdateUserBody {
|
||||
username?: string;
|
||||
profilePictureUrl?: string | null;
|
||||
password?: string | null;
|
||||
}
|
||||
interface LoginBody {
|
||||
userId: number;
|
||||
password?: string;
|
||||
}
|
||||
|
||||
interface DBRunResult { changes: number; lastID: number; }
|
||||
|
||||
export async function getMe(req: any, reply: any) {
|
||||
const userId = req.user?.id;
|
||||
|
||||
if (!userId) {
|
||||
return reply.code(401).send({ error: "Unauthorized" });
|
||||
}
|
||||
|
||||
const user = await queryOne(
|
||||
`SELECT username, profile_picture_url FROM User WHERE id = ?`,
|
||||
[userId],
|
||||
'userdata'
|
||||
);
|
||||
|
||||
if (!user) {
|
||||
return reply.code(404).send({ error: "User not found" });
|
||||
}
|
||||
|
||||
return reply.send({
|
||||
username: user.username,
|
||||
avatar: user.profile_picture_url
|
||||
});
|
||||
}
|
||||
|
||||
export async function login(req: FastifyRequest, reply: FastifyReply) {
|
||||
const { userId, password } = req.body as LoginBody;
|
||||
|
||||
if (!userId || typeof userId !== "number" || userId <= 0) {
|
||||
return reply.code(400).send({ error: "Invalid userId provided" });
|
||||
}
|
||||
|
||||
const user = await userService.getUserById(userId);
|
||||
|
||||
if (!user) {
|
||||
return reply.code(404).send({ error: "User not found in local database" });
|
||||
}
|
||||
|
||||
// Si el usuario tiene contraseña, debe proporcionarla
|
||||
if (user.has_password) {
|
||||
if (!password) {
|
||||
return reply.code(401).send({
|
||||
error: "Password required",
|
||||
requiresPassword: true
|
||||
});
|
||||
}
|
||||
|
||||
const isValid = await userService.verifyPassword(userId, password);
|
||||
|
||||
if (!isValid) {
|
||||
return reply.code(401).send({ error: "Incorrect password" });
|
||||
}
|
||||
}
|
||||
|
||||
const token = jwt.sign(
|
||||
{ id: userId },
|
||||
process.env.JWT_SECRET!,
|
||||
{ expiresIn: "7d" }
|
||||
);
|
||||
|
||||
return reply.code(200).send({
|
||||
success: true,
|
||||
token
|
||||
});
|
||||
}
|
||||
|
||||
export async function getAllUsers(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const users: any = await userService.getAllUsers();
|
||||
return { users };
|
||||
} catch (err) {
|
||||
console.error("Get All Users Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to retrieve user list" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function createUser(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { username, profilePictureUrl, password } = req.body as CreateUserBody;
|
||||
|
||||
if (!username) {
|
||||
return reply.code(400).send({ error: "Missing required field: username" });
|
||||
}
|
||||
|
||||
const result: any = await userService.createUser(username, profilePictureUrl, password);
|
||||
|
||||
return reply.code(201).send({
|
||||
success: true,
|
||||
userId: result.lastID,
|
||||
username
|
||||
});
|
||||
} catch (err) {
|
||||
if ((err as Error).message.includes('SQLITE_CONSTRAINT')) {
|
||||
return reply.code(409).send({ error: "Username already exists." });
|
||||
}
|
||||
console.error("Create User Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to create user" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function getUser(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params as UserIdParams;
|
||||
const userId = parseInt(id, 10);
|
||||
|
||||
const user: any = await userService.getUserById(userId);
|
||||
|
||||
if (!user) {
|
||||
return reply.code(404).send({ error: "User not found" });
|
||||
}
|
||||
|
||||
return { user };
|
||||
} catch (err) {
|
||||
console.error("Get User Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to retrieve user" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function updateUser(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params as UserIdParams;
|
||||
const userId = parseInt(id, 10);
|
||||
const updates = req.body as UpdateUserBody;
|
||||
|
||||
if (Object.keys(updates).length === 0) {
|
||||
return reply.code(400).send({ error: "No update fields provided" });
|
||||
}
|
||||
|
||||
const result: DBRunResult = await userService.updateUser(userId, updates);
|
||||
|
||||
if (result && result.changes > 0) {
|
||||
return { success: true, message: "User updated successfully" };
|
||||
} else {
|
||||
return reply.code(404).send({ error: "User not found or nothing to update" });
|
||||
}
|
||||
} catch (err) {
|
||||
if ((err as Error).message.includes('SQLITE_CONSTRAINT')) {
|
||||
return reply.code(409).send({ error: "Username already exists or is invalid." });
|
||||
}
|
||||
console.error("Update User Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to update user" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function deleteUser(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params as { id: string };
|
||||
const userId = parseInt(id, 10);
|
||||
|
||||
if (!userId || isNaN(userId)) {
|
||||
return reply.code(400).send({ error: "Invalid user id" });
|
||||
}
|
||||
|
||||
const result = await userService.deleteUser(userId);
|
||||
|
||||
if (result && result.changes > 0) {
|
||||
return { success: true, message: "User deleted successfully" };
|
||||
} else {
|
||||
return reply.code(404).send({ error: "User not found" });
|
||||
}
|
||||
|
||||
} catch (err) {
|
||||
console.error("Delete User Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to delete user" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function getIntegrationStatus(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params as { id: string };
|
||||
const userId = parseInt(id, 10);
|
||||
|
||||
if (!userId || isNaN(userId)) {
|
||||
return reply.code(400).send({ error: "Invalid user id" });
|
||||
}
|
||||
|
||||
const integration = await userService.getAniListIntegration(userId);
|
||||
|
||||
return reply.code(200).send(integration);
|
||||
|
||||
} catch (err) {
|
||||
console.error("Get Integration Status Error:", (err as Error).message);
|
||||
return reply.code(500).send({ error: "Failed to check integration status" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function disconnectAniList(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params as { id: string };
|
||||
const userId = parseInt(id, 10);
|
||||
|
||||
if (!userId || isNaN(userId)) {
|
||||
return reply.code(400).send({ error: "Invalid user id" });
|
||||
}
|
||||
|
||||
const result = await userService.removeAniListIntegration(userId);
|
||||
|
||||
if (result.changes === 0) {
|
||||
return reply.code(404).send({ error: "AniList integration not found" });
|
||||
}
|
||||
|
||||
return reply.send({ success: true });
|
||||
} catch (err) {
|
||||
console.error("Disconnect AniList Error:", err);
|
||||
return reply.code(500).send({ error: "Failed to disconnect AniList" });
|
||||
}
|
||||
}
|
||||
|
||||
export async function changePassword(req: FastifyRequest, reply: FastifyReply) {
|
||||
try {
|
||||
const { id } = req.params as { id: string };
|
||||
const { currentPassword, newPassword } = req.body as {
|
||||
currentPassword?: string;
|
||||
newPassword: string | null;
|
||||
};
|
||||
const userId = parseInt(id, 10);
|
||||
|
||||
if (!userId || isNaN(userId)) {
|
||||
return reply.code(400).send({ error: "Invalid user id" });
|
||||
}
|
||||
|
||||
const user = await userService.getUserById(userId);
|
||||
|
||||
if (!user) {
|
||||
return reply.code(404).send({ error: "User not found" });
|
||||
}
|
||||
|
||||
// Si el usuario tiene contraseña actual, debe proporcionar la contraseña actual
|
||||
if (user.has_password && currentPassword) {
|
||||
const isValid = await userService.verifyPassword(userId, currentPassword);
|
||||
|
||||
if (!isValid) {
|
||||
return reply.code(401).send({ error: "Current password is incorrect" });
|
||||
}
|
||||
}
|
||||
|
||||
// Actualizar la contraseña (null para eliminarla, string para establecerla)
|
||||
await userService.updateUser(userId, { password: newPassword });
|
||||
|
||||
return reply.send({
|
||||
success: true,
|
||||
message: newPassword ? "Password updated successfully" : "Password removed successfully"
|
||||
});
|
||||
} catch (err) {
|
||||
console.error("Change Password Error:", err);
|
||||
return reply.code(500).send({ error: "Failed to change password" });
|
||||
}
|
||||
}
|
||||
17
desktop/src/api/user/user.routes.ts
Normal file
17
desktop/src/api/user/user.routes.ts
Normal file
@@ -0,0 +1,17 @@
|
||||
import { FastifyInstance } from 'fastify';
|
||||
import * as controller from './user.controller';
|
||||
|
||||
async function userRoutes(fastify: FastifyInstance) {
|
||||
fastify.get('/me',controller.getMe);
|
||||
fastify.post("/login", controller.login);
|
||||
fastify.get('/users', controller.getAllUsers);
|
||||
fastify.post('/users', { bodyLimit: 1024 * 1024 * 50 }, controller.createUser);
|
||||
fastify.get('/users/:id', controller.getUser);
|
||||
fastify.put('/users/:id', { bodyLimit: 1024 * 1024 * 50 }, controller.updateUser);
|
||||
fastify.delete('/users/:id', controller.deleteUser);
|
||||
fastify.get('/users/:id/integration', controller.getIntegrationStatus);
|
||||
fastify.delete('/users/:id/integration', controller.disconnectAniList);
|
||||
fastify.put('/users/:id/password', controller.changePassword);
|
||||
}
|
||||
|
||||
export default userRoutes;
|
||||
186
desktop/src/api/user/user.service.ts
Normal file
186
desktop/src/api/user/user.service.ts
Normal file
@@ -0,0 +1,186 @@
|
||||
import {queryAll, queryOne, run} from '../../shared/database';
|
||||
import bcrypt from 'bcrypt';
|
||||
|
||||
const USER_DB_NAME = 'userdata';
|
||||
const SALT_ROUNDS = 10;
|
||||
|
||||
interface User {
|
||||
id: number;
|
||||
username: string;
|
||||
profile_picture_url: string | null;
|
||||
has_password: boolean;
|
||||
}
|
||||
|
||||
export async function userExists(id: number): Promise<boolean> {
|
||||
const sql = 'SELECT 1 FROM User WHERE id = ?';
|
||||
const row = await queryOne(sql, [id], USER_DB_NAME);
|
||||
return !!row;
|
||||
}
|
||||
|
||||
export async function createUser(username: string, profilePictureUrl?: string, password?: string): Promise<{ lastID: number }> {
|
||||
let passwordHash = null;
|
||||
|
||||
if (password && password.trim()) {
|
||||
passwordHash = await bcrypt.hash(password.trim(), SALT_ROUNDS);
|
||||
}
|
||||
|
||||
const sql = `
|
||||
INSERT INTO User (username, profile_picture_url, password_hash)
|
||||
VALUES (?, ?, ?)
|
||||
`;
|
||||
const params = [username, profilePictureUrl || null, passwordHash];
|
||||
|
||||
const result = await run(sql, params, USER_DB_NAME);
|
||||
|
||||
return { lastID: result.lastID };
|
||||
}
|
||||
|
||||
export async function updateUser(userId: number, updates: any): Promise<any> {
|
||||
const fields: string[] = [];
|
||||
const values: (string | number | null)[] = [];
|
||||
|
||||
if (updates.username !== undefined) {
|
||||
fields.push('username = ?');
|
||||
values.push(updates.username);
|
||||
}
|
||||
|
||||
if (updates.profilePictureUrl !== undefined) {
|
||||
fields.push('profile_picture_url = ?');
|
||||
values.push(updates.profilePictureUrl);
|
||||
}
|
||||
|
||||
if (updates.password !== undefined) {
|
||||
if (updates.password === null || updates.password === '') {
|
||||
// Eliminar contraseña
|
||||
fields.push('password_hash = ?');
|
||||
values.push(null);
|
||||
} else {
|
||||
// Actualizar contraseña
|
||||
const hash = await bcrypt.hash(updates.password.trim(), SALT_ROUNDS);
|
||||
fields.push('password_hash = ?');
|
||||
values.push(hash);
|
||||
}
|
||||
}
|
||||
|
||||
if (fields.length === 0) {
|
||||
return { changes: 0, lastID: userId };
|
||||
}
|
||||
|
||||
const setClause = fields.join(', ');
|
||||
const sql = `UPDATE User SET ${setClause} WHERE id = ?`;
|
||||
values.push(userId);
|
||||
|
||||
return await run(sql, values, USER_DB_NAME);
|
||||
}
|
||||
|
||||
export async function deleteUser(userId: number): Promise<any> {
|
||||
await run(
|
||||
`DELETE FROM ListEntry WHERE user_id = ?`,
|
||||
[userId],
|
||||
USER_DB_NAME
|
||||
);
|
||||
|
||||
await run(
|
||||
`DELETE FROM UserIntegration WHERE user_id = ?`,
|
||||
[userId],
|
||||
USER_DB_NAME
|
||||
);
|
||||
|
||||
await run(
|
||||
`DELETE FROM favorites WHERE user_id = ?`,
|
||||
[userId],
|
||||
'favorites'
|
||||
);
|
||||
|
||||
const result = await run(
|
||||
`DELETE FROM User WHERE id = ?`,
|
||||
[userId],
|
||||
USER_DB_NAME
|
||||
);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
export async function getAllUsers(): Promise<User[]> {
|
||||
const sql = `
|
||||
SELECT
|
||||
id,
|
||||
username,
|
||||
profile_picture_url,
|
||||
CASE WHEN password_hash IS NOT NULL THEN 1 ELSE 0 END as has_password
|
||||
FROM User
|
||||
ORDER BY id
|
||||
`;
|
||||
|
||||
const users = await queryAll(sql, [], USER_DB_NAME);
|
||||
|
||||
return users.map((user: any) => ({
|
||||
id: user.id,
|
||||
username: user.username,
|
||||
profile_picture_url: user.profile_picture_url || null,
|
||||
has_password: !!user.has_password
|
||||
})) as User[];
|
||||
}
|
||||
|
||||
export async function getUserById(id: number): Promise<User | null> {
|
||||
const sql = `
|
||||
SELECT
|
||||
id,
|
||||
username,
|
||||
profile_picture_url,
|
||||
CASE WHEN password_hash IS NOT NULL THEN 1 ELSE 0 END as has_password
|
||||
FROM User
|
||||
WHERE id = ?
|
||||
`;
|
||||
|
||||
const user = await queryOne(sql, [id], USER_DB_NAME);
|
||||
|
||||
if (!user) return null;
|
||||
|
||||
return {
|
||||
id: user.id,
|
||||
username: user.username,
|
||||
profile_picture_url: user.profile_picture_url || null,
|
||||
has_password: !!user.has_password
|
||||
};
|
||||
}
|
||||
|
||||
export async function verifyPassword(userId: number, password: string): Promise<boolean> {
|
||||
const sql = 'SELECT password_hash FROM User WHERE id = ?';
|
||||
const user = await queryOne(sql, [userId], USER_DB_NAME);
|
||||
|
||||
if (!user || !user.password_hash) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return await bcrypt.compare(password, user.password_hash);
|
||||
}
|
||||
|
||||
export async function getAniListIntegration(userId: number) {
|
||||
const sql = `
|
||||
SELECT anilist_user_id, expires_at
|
||||
FROM UserIntegration
|
||||
WHERE user_id = ? AND platform = ?
|
||||
`;
|
||||
|
||||
const row = await queryOne(sql, [userId, "AniList"], USER_DB_NAME);
|
||||
|
||||
if (!row) {
|
||||
return { connected: false };
|
||||
}
|
||||
|
||||
return {
|
||||
connected: true,
|
||||
anilistUserId: row.anilist_user_id,
|
||||
expiresAt: row.expires_at
|
||||
};
|
||||
}
|
||||
|
||||
export async function removeAniListIntegration(userId: number) {
|
||||
const sql = `
|
||||
DELETE FROM UserIntegration
|
||||
WHERE user_id = ? AND platform = ?
|
||||
`;
|
||||
|
||||
return run(sql, [userId, "AniList"], USER_DB_NAME);
|
||||
}
|
||||
Reference in New Issue
Block a user