ani-web 2.0.7

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

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthController = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const google_1 = require("../google");
+const github_sync_1 = require("../github-sync");
+const sync_1 = require("../sync");
+const config_1 = require("../config");
+const rclone_1 = require("../rclone");
+class AuthController {
+    runSyncSequence;
+    constructor(runSyncSequence) {
+        this.runSyncSequence = runSyncSequence;
+    }
+    getConfigStatus = (_req, res) => {
+        const hasConfig = !!process.env.GOOGLE_CLIENT_ID && !!process.env.GOOGLE_CLIENT_SECRET;
+        res.json({ hasConfig });
+    };
+    getGoogleAuthSettings = (_req, res) => {
+        res.json({
+            clientId: process.env.GOOGLE_CLIENT_ID || '',
+            hasClientSecret: !!process.env.GOOGLE_CLIENT_SECRET,
+        });
+    };
+    updateGoogleAuthSettings = async (req, res) => {
+        const { clientId, clientSecret } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        const updates = {};
+        if (typeof clientId === 'string') {
+            updates.GOOGLE_CLIENT_ID = clientId;
+        }
+        if (typeof clientSecret === 'string') {
+            updates.GOOGLE_CLIENT_SECRET = clientSecret;
+        }
+        await updateEnvFile(updates);
+        res.json({ success: true });
+    };
+    getRcloneSettings = async (_req, res) => {
+        const remotes = await rclone_1.rcloneService.listRemotes();
+        res.json({
+            remote: config_1.CONFIG.RCLONE_REMOTE || '',
+            availableRemotes: remotes,
+            activeRemote: rclone_1.rcloneService.isActive() ? rclone_1.rcloneService.getRemoteName() : null,
+        });
+    };
+    getSyncSettings = async (_req, res) => {
+        const { getActiveProvider } = await Promise.resolve().then(() => __importStar(require('../sync')));
+        res.json({
+            activeProvider: process.env.SYNC_PROVIDER || 'default',
+            actualActiveProvider: getActiveProvider(),
+            authenticatedProviders: {
+                github: github_sync_1.githubSyncService.isAuthenticated(),
+                google: google_1.googleDriveService.isAuthenticated(),
+                rclone: rclone_1.rcloneService.isActive(),
+            },
+        });
+    };
+    updateSyncProvider = async (req, res) => {
+        const { provider } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        const value = provider === 'default' ? '' : provider;
+        await updateEnvFile({ SYNC_PROVIDER: value });
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true, activeProvider: process.env.SYNC_PROVIDER || 'default' });
+    };
+    getGitHubAuthStatus = async (_req, res) => {
+        try {
+            const user = await github_sync_1.githubSyncService.getUserProfile();
+            res.json({
+                authenticated: !!user,
+                user,
+                device: github_sync_1.githubSyncService.getDeviceState(),
+                clientId: process.env.GITHUB_CLIENT_ID || '',
+                usingDefaultClientId: !process.env.GITHUB_CLIENT_ID,
+            });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to fetch GitHub auth status');
+            res.json({
+                authenticated: false,
+                user: null,
+                device: github_sync_1.githubSyncService.getDeviceState(),
+                clientId: process.env.GITHUB_CLIENT_ID || '',
+                usingDefaultClientId: !process.env.GITHUB_CLIENT_ID,
+            });
+        }
+    };
+    startGitHubDeviceAuth = async (req, res) => {
+        const state = await github_sync_1.githubSyncService.startDeviceAuth(req.db, this.runSyncSequence);
+        res.json(state);
+    };
+    pollGitHubDeviceAuth = (_req, res) => {
+        res.json(github_sync_1.githubSyncService.getDeviceState());
+    };
+    logoutGitHub = async (_req, res) => {
+        await github_sync_1.githubSyncService.logout();
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({ SYNC_PROVIDER: '' });
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true });
+    };
+    updateRcloneSettings = async (req, res) => {
+        const { remote } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({
+            RCLONE_REMOTE: remote,
+            SYNC_PROVIDER: 'rclone',
+        });
+        await this.runSyncSequence(req.db, 'rclone');
+        res.json({ success: true });
+    };
+    getAuthUrl = async (_req, res) => {
+        const url = google_1.googleDriveService.getAuthUrl();
+        res.json({ url });
+    };
+    loginGoogle = async (req, res) => {
+        if (google_1.googleDriveService.isAuthenticated()) {
+            const user = await google_1.googleDriveService.getUserProfile();
+            if (user) {
+                const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+                await updateEnvFile({ SYNC_PROVIDER: 'google' });
+                await this.runSyncSequence(req.db, 'google');
+                return res.json({ url: null, authenticated: true });
+            }
+            else {
+                logger_1.default.warn('Google tokens found but invalid. Clearing and requesting new auth.');
+                await google_1.googleDriveService.logout();
+            }
+        }
+        const url = google_1.googleDriveService.getAuthUrl();
+        res.json({ url, authenticated: false });
+    };
+    handleCallback = async (req, res) => {
+        const code = req.query.code;
+        if (!code) {
+            return res.status(400).send('No code provided');
+        }
+        await google_1.googleDriveService.handleCallback(code);
+        const user = await google_1.googleDriveService.getUserProfile();
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({ SYNC_PROVIDER: 'google' });
+        logger_1.default.info('User logged in. Syncing database (please wait)...');
+        try {
+            await this.runSyncSequence(req.db, 'google');
+        }
+        catch (err) {
+            logger_1.default.error({ err }, 'Post-login sync failed');
+        }
+        const responseHtml = `
+            <html>
+            <body>
+            <h1>Authentication Successful</h1>
+            <p>Database synced. Closing window...</p>
+            <script>
+            if (window.opener) {
+                window.opener.postMessage({ type: 'GOOGLE_AUTH_SUCCESS', user: ${JSON.stringify(user)} }, '*');
+                window.close();
+            } else {
+                window.location.href = '/';
+            }
+            </script>
+            </body>
+            </html>
+            `;
+        res.send(responseHtml);
+    };
+    getUserProfile = async (_req, res) => {
+        const user = await google_1.googleDriveService.getUserProfile();
+        res.json(user);
+    };
+    logout = async (_req, res) => {
+        await google_1.googleDriveService.logout();
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({ SYNC_PROVIDER: '' });
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true });
+    };
+}
+exports.AuthController = AuthController;

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

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataController = void 0;
+const constants_json_1 = require("../constants.json");
+const logger_1 = __importDefault(require("../logger"));
+class DataController {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    getProvider(req) {
+        const providerName = req.query.provider || 'allanime';
+        return this.providers[providerName.toLowerCase()] || this.providers['allanime'];
+    }
+    getPopular = async (req, res) => {
+        const timeframe = req.params.timeframe.toLowerCase();
+        const page = parseInt(req.query.page) || 1;
+        const size = parseInt(req.query.size) || 10;
+        try {
+            const data = await this.getProvider(req).getPopular(timeframe, page, size);
+            res.set('Cache-Control', 'public, max-age=300').json(data);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    getSchedule = async (req, res) => {
+        try {
+            const data = await this.getProvider(req).getSchedule(new Date(req.params.date + 'T00:00:00.000Z'));
+            res.set('Cache-Control', 'public, max-age=300').json(data);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    getSkipTimes = async (req, res) => {
+        try {
+            const data = await this.getProvider(req).getSkipTimes(req.params.showId, req.params.episodeNumber);
+            res.json(data);
+        }
+        catch {
+            res.json({ found: false, results: [] });
+        }
+    };
+    getVideo = async (req, res) => {
+        try {
+            const urls = await this.getProvider(req).getStreamUrls(req.query.showId, req.query.episodeNumber, req.query.mode);
+            res.json(urls || []);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            logger_1.default.error({ err: e, provider: req.query.provider }, 'Provider video fetch failed');
+            res.json([]);
+        }
+    };
+    getEpisodes = async (req, res) => {
+        try {
+            let showId = req.query.showId;
+            const provider = this.getProvider(req);
+            const providerName = (req.query.provider || 'allanime').toLowerCase();
+            if (providerName === 'animepahe') {
+                const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(showId);
+                if (!isUuid) {
+                    let animeName = '';
+                    try {
+                        const allAnimeProvider = this.providers['allanime'];
+                        if (allAnimeProvider) {
+                            const meta = await allAnimeProvider.getShowMeta(showId);
+                            if (meta) {
+                                animeName = meta.name || meta.englishName || '';
+                            }
+                        }
+                    }
+                    catch (e) {
+                        logger_1.default.warn({ showId, error: e.message }, 'Failed to resolve AllAnime metadata for AnimePahe name resolution');
+                    }
+                    const searchFor = animeName || showId;
+                    const results = await provider.search({ query: searchFor });
+                    if (results.length > 0) {
+                        showId = results[0].session || results[0].id || results[0]._id;
+                    }
+                }
+            }
+            const data = await provider.getEpisodes(showId, req.query.mode);
+            res.json(data);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    search = async (req, res) => {
+        try {
+            const data = await this.getProvider(req).search(req.query);
+            res.json(data);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    getSeasonal = async (req, res) => {
+        const page = parseInt(req.query.page) || 1;
+        try {
+            const data = await this.getProvider(req).getSeasonal(page);
+            res.json(data);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    getLatestReleases = async (req, res) => {
+        const page = parseInt(req.query.page) || 1;
+        const size = parseInt(req.query.size) || 14;
+        try {
+            const data = await this.getProvider(req).getLatestReleases(page, size);
+            res.json(data);
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    getShowMeta = async (req, res) => {
+        try {
+            const id = req.params.id;
+            const providerQuery = req.query.provider;
+            if (providerQuery) {
+                let meta = null;
+                const provider = this.getProvider(req);
+                const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+                if (isUuid) {
+                    meta = await provider.getShowMeta(id);
+                }
+                else {
+                    if (providerQuery.toLowerCase() === 'allanime') {
+                        meta = await provider.getShowMeta(id);
+                    }
+                    else {
+                        let animeName = '';
+                        try {
+                            const allAnimeProvider = this.providers['allanime'];
+                            if (allAnimeProvider) {
+                                const localMeta = await allAnimeProvider.getShowMeta(id);
+                                if (localMeta) {
+                                    animeName = localMeta.name || localMeta.englishName || '';
+                                }
+                            }
+                        }
+                        catch (e) {
+                            logger_1.default.warn({ id, error: e.message }, 'Failed to resolve AllAnime name in getShowMeta');
+                        }
+                        const searchFor = animeName || id;
+                        const results = await provider.search({ query: searchFor });
+                        if (results.length > 0) {
+                            const targetId = results[0].session || results[0].id || results[0]._id;
+                            meta = await provider.getShowMeta(targetId);
+                        }
+                    }
+                }
+                return res.json(meta || {});
+            }
+            const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+            let meta = null;
+            if (isUuid) {
+                try {
+                    if (this.providers['animepahe']) {
+                        meta = await this.providers['animepahe'].getShowMeta(id);
+                    }
+                }
+                catch (e) {
+                    if (e.message === 'AUTH_REQUIRED') {
+                        return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+                    }
+                    logger_1.default.warn({ id, error: e.message }, 'AnimePahe getShowMeta failed for UUID');
+                }
+            }
+            else {
+                try {
+                    meta = await this.providers['allanime'].getShowMeta(id);
+                }
+                catch (e) {
+                    logger_1.default.warn({ id, error: e.message }, 'AllAnime getShowMeta failed, trying fallback');
+                }
+                if (!meta || !meta.name) {
+                    try {
+                        if (this.providers['animepahe']) {
+                            meta = await this.providers['animepahe'].getShowMeta(id);
+                        }
+                    }
+                    catch (e) {
+                        if (e.message === 'AUTH_REQUIRED') {
+                            return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+                        }
+                        logger_1.default.warn({ id, error: e.message }, 'AnimePahe fallback getShowMeta failed');
+                    }
+                }
+            }
+            res.json(meta || {});
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'animepahe' });
+            }
+            throw e;
+        }
+    };
+    getGenresAndTags = (_req, res) => {
+        res.json({ genres: constants_json_1.genres, tags: constants_json_1.tags, studios: constants_json_1.studios });
+    };
+}
+exports.DataController = DataController;

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

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightsController = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const insights_repository_1 = require("../repositories/insights.repository");
+class InsightsController {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    getWatchInsights = async (req, res) => {
+        const db = req.db;
+        const [core, activityGrid, hourlyDist, seasonality, allWatches, watchedShows, droppedWarning, velocities,] = (await Promise.all([
+            insights_repository_1.InsightsRepository.getCoreStats(db),
+            insights_repository_1.InsightsRepository.getActivityGrid(db),
+            insights_repository_1.InsightsRepository.getHourlyDist(db),
+            insights_repository_1.InsightsRepository.getSeasonality(db),
+            insights_repository_1.InsightsRepository.getAllWatches(db),
+            insights_repository_1.InsightsRepository.getWatchedShowsMeta(db),
+            insights_repository_1.InsightsRepository.getDroppedShows(db),
+            insights_repository_1.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].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].currentTime;
+                }
+                else {
+                    sessions.push(currentSessionSeconds);
+                    currentSessionSeconds = 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_1.default.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) {
+                totalPopScore += show.popularityScore;
+                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,
+            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 insights_repository_1.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_1.default.warn({ err: e, showId: row.showId }, 'Failed to parse genres for genre cards');
+                }
+            }
+            const timeWatched = (row.currentTime || 0) + (row.duration || 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);
+    };
+}
+exports.InsightsController = InsightsController;