@serifpersia/dango 3.3.4

package/server/dist/controllers/insights.controller.js

@@ -0,0 +1,198 @@
+import logger from '../logger.js';
+import { InsightsRepository } from '../repositories/insights.repository.js';
+import { computeDiscordSyncStats } from '../lib/discord-roles-sync.service.js';
+export class InsightsController {
+    getWatchInsights = async (req, res) => {
+        const db = req.db;
+        const [core, activityGrid, hourlyDist, seasonality, allWatches, watchedShows, droppedWarning, velocities,] = (await Promise.all([
+            InsightsRepository.getCoreStats(db),
+            InsightsRepository.getActivityGrid(db),
+            InsightsRepository.getHourlyDist(db),
+            InsightsRepository.getSeasonality(db),
+            InsightsRepository.getAllWatches(db),
+            InsightsRepository.getWatchedShowsMeta(db),
+            InsightsRepository.getDroppedShows(db),
+            InsightsRepository.getCompletionVelocities(db),
+        ]));
+        const bingeFactor = activityGrid.length > 0 ? Math.max(...activityGrid.map((a) => a.count)) : 0;
+        const sessions = [];
+        if (allWatches.length > 0) {
+            let currentSessionSeconds = allWatches[0].effectiveSeconds ?? allWatches[0].currentTime;
+            for (let i = 1; i < allWatches.length; i++) {
+                const prev = new Date(allWatches[i - 1].watchedAt).getTime();
+                const curr = new Date(allWatches[i].watchedAt).getTime();
+                if (curr - prev < 3600000) {
+                    currentSessionSeconds += allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
+                }
+                else {
+                    sessions.push(currentSessionSeconds);
+                    currentSessionSeconds = allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
+                }
+            }
+            sessions.push(currentSessionSeconds);
+        }
+        const avgSessionMinutes = sessions.length > 0
+            ? Math.round(sessions.reduce((a, b) => a + b, 0) / sessions.length / 60)
+            : 0;
+        const genreCounts = {};
+        let totalPopScore = 0;
+        let popCount = 0;
+        for (const show of watchedShows) {
+            let genres = [];
+            if (show.genres) {
+                try {
+                    if (show.genres.startsWith('[')) {
+                        genres = JSON.parse(show.genres);
+                    }
+                    else {
+                        genres = show.genres.split(',').map((g) => g.trim());
+                    }
+                }
+                catch (e) {
+                    logger.warn({ err: e, showId: show.id }, 'Failed to parse genres for insights');
+                }
+            }
+            for (const g of genres) {
+                genreCounts[g] = (genreCounts[g] || 0) + 1;
+            }
+            if (show.popularityScore) {
+                let score = show.popularityScore;
+                if (score > 10)
+                    score = score / 10;
+                totalPopScore += score;
+                popCount++;
+            }
+        }
+        const topGenre = Object.entries(genreCounts).sort((a, b) => b[1] - a[1])[0]?.[0];
+        const personaMap = {
+            Action: 'Shonen Warrior',
+            Romance: 'Hopeless Romantic',
+            Comedy: 'Chaos Enjoyer',
+            'Slice of Life': 'Vibe Seeker',
+            Horror: 'Fearless Watcher',
+            Fantasy: 'Isekai Traveller',
+            'Sci-Fi': 'Future Scientist',
+            Drama: 'Feels Collector',
+        };
+        const persona = personaMap[topGenre || ''] || 'Anime Enthusiast';
+        const avgCompletionDays = velocities.length > 0
+            ? Math.round(velocities.reduce((a, b) => a + b.daysToFinish, 0) / velocities.length)
+            : 0;
+        res.json({
+            totalHours: Math.round((core?.totalSeconds || 0) / 3600),
+            totalEpisodes: core?.totalEpisodes || 0,
+            totalAnime: core?.totalAnime || 0,
+            completedAnime: core?.completedCount || 0,
+            completionRate: core?.totalWatchlist > 0
+                ? Math.round((core.completedCount / core.totalWatchlist) * 100)
+                : 0,
+            persona,
+            bingeFactor,
+            avgSessionMinutes,
+            avgCompletionDays,
+            popularityScore: popCount > 0 ? Math.round(totalPopScore / popCount) : 0,
+            genreSplit: Object.entries(genreCounts)
+                .map(([name, count]) => ({ name, count }))
+                .sort((a, b) => b.count - a.count)
+                .slice(0, 8) || [],
+            activityGrid: activityGrid || [],
+            hourlyDist: Array.from({ length: 24 }, (_, i) => {
+                const hour = i.toString().padStart(2, '0');
+                return { hour, count: hourlyDist?.find((d) => d.hour === hour)?.count || 0 };
+            }) || [],
+            seasonality: Array.from({ length: 12 }, (_, i) => {
+                const month = (i + 1).toString().padStart(2, '0');
+                return {
+                    month,
+                    seconds: seasonality?.find((s) => s.month === month)?.seconds || 0,
+                };
+            }) || [],
+            droppedShows: (droppedWarning || []).slice(0, 5),
+        });
+    };
+    formatTime(seconds) {
+        const days = Math.floor(seconds / 86400);
+        const hours = Math.floor((seconds % 86400) / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        if (days > 0) {
+            return `${days} days ${hours > 0 ? `${hours} hours` : ''}`;
+        }
+        if (hours > 0) {
+            return `${hours} hours${minutes > 0 ? ` ${minutes} mins` : ''}`;
+        }
+        return `${minutes} mins`;
+    }
+    getGenreCards = async (req, res) => {
+        const db = req.db;
+        const rows = await InsightsRepository.getWatchedEpisodesWithMeta(db);
+        const genreData = {};
+        for (const row of rows) {
+            let genres = [];
+            if (row.genres) {
+                try {
+                    if (row.genres.startsWith('[')) {
+                        genres = JSON.parse(row.genres);
+                    }
+                    else {
+                        genres = row.genres.split(',').map((g) => g.trim());
+                    }
+                }
+                catch (e) {
+                    logger.warn({ err: e, showId: row.showId }, 'Failed to parse genres for genre cards');
+                }
+            }
+            const timeWatched = (row.effectiveSeconds ?? row.currentTime) || 0;
+            let score = row.popularityScore || 0;
+            if (score > 10)
+                score = score / 10;
+            for (const genre of genres) {
+                if (!genreData[genre]) {
+                    genreData[genre] = { count: 0, totalTime: 0, scores: [], showWatches: {}, showMeta: {} };
+                }
+                genreData[genre].count++;
+                genreData[genre].totalTime += timeWatched;
+                if (score > 0)
+                    genreData[genre].scores.push(score);
+                genreData[genre].showWatches[row.showId] =
+                    (genreData[genre].showWatches[row.showId] || 0) + 1;
+                if (row.name && row.thumbnail) {
+                    genreData[genre].showMeta[row.showId] = {
+                        name: row.name,
+                        nativeName: row.nativeName,
+                        englishName: row.englishName,
+                        thumbnail: row.thumbnail,
+                    };
+                }
+            }
+        }
+        const genreCards = Object.entries(genreData).map(([name, data]) => {
+            const topShows = Object.entries(data.showWatches)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 4)
+                .map(([showId]) => ({
+                id: showId,
+                name: data.showMeta[showId]?.name || '',
+                nativeName: data.showMeta[showId]?.nativeName,
+                englishName: data.showMeta[showId]?.englishName,
+                thumbnail: data.showMeta[showId]?.thumbnail || '',
+            }));
+            return {
+                rank: 0,
+                name,
+                count: data.count,
+                meanScore: data.scores.length > 0 ? data.scores.reduce((a, b) => a + b, 0) / data.scores.length : 0,
+                timeWatched: this.formatTime(data.totalTime),
+                topShows,
+            };
+        });
+        genreCards.sort((a, b) => b.count - a.count);
+        genreCards.forEach((card, i) => {
+            card.rank = i + 1;
+        });
+        res.json(genreCards);
+    };
+    getDiscordSyncStats = async (req, res) => {
+        const db = req.db;
+        res.json(await computeDiscordSyncStats(db));
+    };
+}

package/server/dist/controllers/manga-library.controller.js

@@ -0,0 +1,296 @@
+import logger from '../logger.js';
+import { performMangaWriteTransaction } from '../sync.js';
+import { dbAll } from '../utils/db-utils.js';
+import { SettingsRepository } from '../repositories/settings.repository.js';
+import { buildMangaId, MANGA_STATUSES, MangaLibraryRepository, MangaProgressRepository, } from '../repositories/manga.repository.js';
+const MANGA_ADULT_RATINGS = ['erotica', 'pornographic'];
+const isMangaContinueAdult = (row) => !!row.contentRating && MANGA_ADULT_RATINGS.includes(row.contentRating);
+function mangaDb(req) {
+    const db = req.mangaDb;
+    if (!db || db.isClosedCheck())
+        throw new Error('Manga database is not ready');
+    return db;
+}
+function normalizeId(provider, mangaId, idRaw) {
+    if (idRaw && idRaw.includes(':'))
+        return idRaw;
+    return buildMangaId(provider, mangaId || idRaw || '');
+}
+export class MangaLibraryController {
+    getLibrary = async (req, res) => {
+        try {
+            const { status, page: pageStr, limit: limitStr } = req.query;
+            const page = Math.max(parseInt(pageStr) || 1, 1);
+            const limit = Math.min(Math.max(parseInt(limitStr) || 24, 1), 100);
+            const offset = (page - 1) * limit;
+            const db = mangaDb(req);
+            const rows = MangaLibraryRepository.getAll(db, status, limit, offset);
+            const total = MangaLibraryRepository.getCount(db, status);
+            res.json({ data: rows, total, page, limit });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to get manga library');
+            res.status(500).json({ error: 'Failed to load manga library' });
+        }
+    };
+    checkLibrary = async (req, res) => {
+        try {
+            const item = MangaLibraryRepository.getById(mangaDb(req), req.params.id);
+            res.json({ inLibrary: !!item, status: item?.status ?? null });
+        }
+        catch {
+            res.json({ inLibrary: false, status: null });
+        }
+    };
+    getLibraryIds = async (req, res) => {
+        try {
+            res.json({ ids: MangaLibraryRepository.getIds(mangaDb(req)) });
+        }
+        catch {
+            res.json({ ids: [] });
+        }
+    };
+    addToLibrary = async (req, res) => {
+        const { provider, mangaId, id: idRaw, title, cover, status, author, altTitle, contentRating, } = req.body ?? {};
+        if (!provider || (!mangaId && !idRaw)) {
+            return res.status(400).json({ error: 'provider and mangaId are required' });
+        }
+        const id = normalizeId(String(provider), String(mangaId || ''), idRaw ? String(idRaw) : undefined);
+        const cleanStatus = typeof status === 'string' && MANGA_STATUSES.includes(status)
+            ? status
+            : 'Reading';
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaLibraryRepository.upsert(tx, {
+                    id,
+                    provider: String(provider).toLowerCase(),
+                    mangaId: String(mangaId || idRaw || ''),
+                    title: String(title || ''),
+                    cover: String(cover || ''),
+                    status: cleanStatus,
+                    author: author ? String(author) : undefined,
+                    altTitle: altTitle ? String(altTitle) : undefined,
+                    contentRating: contentRating ? String(contentRating) : undefined,
+                });
+            });
+            res.json({ success: true, id });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to add manga to library');
+            res.status(500).json({ error: 'Failed to bookmark manga' });
+        }
+    };
+    removeFromLibrary = async (req, res) => {
+        const { id } = req.body ?? {};
+        if (!id)
+            return res.status(400).json({ error: 'id is required' });
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaLibraryRepository.delete(tx, String(id));
+                MangaProgressRepository.deleteByManga(tx, String(id));
+            });
+            res.json({ success: true });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to remove manga from library');
+            res.status(500).json({ error: 'Failed to remove bookmark' });
+        }
+    };
+    updateStatus = async (req, res) => {
+        const { id, status } = req.body ?? {};
+        if (!id || !MANGA_STATUSES.includes(status)) {
+            return res.status(400).json({ error: 'id and a valid status are required' });
+        }
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaLibraryRepository.updateStatus(tx, String(id), String(status));
+            });
+            res.json({ success: true });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to update manga status');
+            res.status(500).json({ error: 'Failed to update status' });
+        }
+    };
+    getProgress = async (req, res) => {
+        try {
+            const rows = MangaProgressRepository.getByManga(mangaDb(req), req.params.mangaId);
+            res.json({ progress: rows });
+        }
+        catch {
+            res.json({ progress: [] });
+        }
+    };
+    getLatestProgress = async (req, res) => {
+        try {
+            const row = MangaProgressRepository.getLatest(mangaDb(req), req.params.mangaId);
+            res.json(row || { page: 0, pageCount: 0 });
+        }
+        catch {
+            res.json({ page: 0, pageCount: 0 });
+        }
+    };
+    saveProgress = async (req, res) => {
+        const { mangaId, chapterId, chapterNumber, page, pageCount, title, cover, provider, altTitle, contentRating, } = req.body ?? {};
+        if (!mangaId || !chapterId) {
+            return res.status(400).json({ error: 'mangaId and chapterId are required' });
+        }
+        const pageNum = Math.max(Number(page) || 0, 0);
+        const pageCountNum = Math.max(Number(pageCount) || 0, 0);
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaProgressRepository.upsert(tx, {
+                    mangaId: String(mangaId),
+                    chapterId: String(chapterId),
+                    chapterNumber: String(chapterNumber || ''),
+                    page: pageNum,
+                    pageCount: pageCountNum,
+                    title: title ?? null,
+                    cover: cover ?? null,
+                    provider: provider ?? null,
+                    altTitle: altTitle ?? null,
+                    contentRating: contentRating ?? null,
+                });
+                MangaLibraryRepository.touchProgress(tx, String(mangaId), {
+                    chapterId: String(chapterId),
+                    chapterNumber: String(chapterNumber || ''),
+                    page: pageNum,
+                });
+            });
+            res.json({ success: true });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to save manga progress');
+            res.status(500).json({ error: 'Failed to save progress' });
+        }
+    };
+    getContinueReading = async (req, res) => {
+        try {
+            const limit = Math.min(Math.max(parseInt(req.query.limit) || 24, 1), 100);
+            const ignoreAdultRow = await SettingsRepository.getByKey(req.db, 'mangaIgnoreAdultContent');
+            const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
+            const listOnlyRow = await SettingsRepository.getByKey(req.db, 'mangaCwWatchlistOnly');
+            const listOnly = listOnlyRow
+                ? listOnlyRow.value === 'true' || listOnlyRow.value === '1'
+                : false;
+            const rows = MangaProgressRepository.getContinueReading(mangaDb(req), limit).filter((row) => {
+                if (ignoreAdult && isMangaContinueAdult(row))
+                    return false;
+                if (listOnly && row.watchlistStatus !== 'Reading')
+                    return false;
+                return true;
+            });
+            res.json({ data: rows, total: rows.length });
+        }
+        catch {
+            res.json({ data: [], total: 0 });
+        }
+    };
+    async getAdultNonListMangaIds(db) {
+        const rows = await dbAll(db, `SELECT DISTINCT p.mangaId as mangaId
+       FROM manga_progress p
+       LEFT JOIN manga_library l ON l.id = p.mangaId
+       WHERE COALESCE(l.contentRating, p.contentRating) IN ('erotica', 'pornographic')
+         AND l.id IS NULL`);
+        return rows.map((r) => r.mangaId);
+    }
+    getAdultContinueReadingCount = async (req, res) => {
+        try {
+            const ids = await this.getAdultNonListMangaIds(mangaDb(req));
+            res.json({ count: ids.length });
+        }
+        catch {
+            res.json({ count: 0 });
+        }
+    };
+    purgeAdultContinueReading = async (req, res) => {
+        try {
+            const ids = await this.getAdultNonListMangaIds(mangaDb(req));
+            if (ids.length > 0) {
+                await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                    MangaProgressRepository.deleteMany(tx, ids);
+                });
+            }
+            res.json({ success: true, removed: ids.length });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to purge adult manga progress');
+            res.status(500).json({ error: 'Failed to purge adult entries' });
+        }
+    };
+    removeProgress = async (req, res) => {
+        const { mangaId, chapterId } = req.body ?? {};
+        if (!mangaId)
+            return res.status(400).json({ error: 'mangaId is required' });
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                if (chapterId) {
+                    MangaProgressRepository.deleteChapter(tx, String(mangaId), String(chapterId));
+                }
+                else {
+                    MangaProgressRepository.deleteByManga(tx, String(mangaId));
+                }
+            });
+            res.json({ success: true });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to remove manga progress');
+            res.status(500).json({ error: 'Failed to reset progress' });
+        }
+    };
+    batchUpdateStatus = async (req, res) => {
+        const { ids: idsRaw, status } = req.body ?? {};
+        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
+            return res.status(400).json({ error: 'ids must be a non-empty array' });
+        }
+        if (!status || !MANGA_STATUSES.includes(status)) {
+            return res.status(400).json({ error: 'a valid status is required' });
+        }
+        const ids = idsRaw.map((id) => String(id));
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaLibraryRepository.updateStatusMany(tx, ids, String(status));
+            });
+            res.json({ success: true, updated: ids.length });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to batch update manga status');
+            res.status(500).json({ error: 'Failed to update statuses' });
+        }
+    };
+    batchRemove = async (req, res) => {
+        const { ids: idsRaw } = req.body ?? {};
+        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
+            return res.status(400).json({ error: 'ids must be a non-empty array' });
+        }
+        const ids = idsRaw.map((id) => String(id));
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaLibraryRepository.deleteMany(tx, ids);
+                MangaProgressRepository.deleteMany(tx, ids);
+            });
+            res.json({ success: true, removed: ids.length });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to batch remove manga');
+            res.status(500).json({ error: 'Failed to remove bookmarks' });
+        }
+    };
+    batchRemoveProgress = async (req, res) => {
+        const { ids: idsRaw } = req.body ?? {};
+        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
+            return res.status(400).json({ error: 'ids must be a non-empty array' });
+        }
+        const ids = idsRaw.map((id) => String(id));
+        try {
+            await performMangaWriteTransaction(mangaDb(req), (tx) => {
+                MangaProgressRepository.deleteMany(tx, ids);
+            });
+            res.json({ success: true, removed: ids.length });
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to batch remove manga progress');
+            res.status(500).json({ error: 'Failed to reset progress' });
+        }
+    };
+}