ani-web 1.5.8

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

@@ -0,0 +1,213 @@
+"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 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')));
+        try {
+            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 });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to update .env file');
+            res.status(500).json({ error: 'Failed to save configuration' });
+        }
+    };
+    getRcloneSettings = async (_req, res) => {
+        try {
+            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,
+            });
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to fetch Rclone settings' });
+        }
+    };
+    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) => {
+        try {
+            const state = await github_sync_1.githubSyncService.startDeviceAuth(req.db, this.runSyncSequence);
+            res.json(state);
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to start GitHub device auth');
+            res.status(500).json({ error: 'Failed to start GitHub authentication' });
+        }
+    };
+    pollGitHubDeviceAuth = (_req, res) => {
+        res.json(github_sync_1.githubSyncService.getDeviceState());
+    };
+    logoutGitHub = async (_req, res) => {
+        try {
+            await github_sync_1.githubSyncService.logout();
+            res.json({ success: true });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to sign out of GitHub');
+            res.status(500).json({ error: 'Failed to sign out of GitHub' });
+        }
+    };
+    updateRcloneSettings = async (req, res) => {
+        const { remote } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        try {
+            await updateEnvFile({
+                RCLONE_REMOTE: remote,
+            });
+            res.json({ success: true });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to update .env for Rclone');
+            res.status(500).json({ error: 'Failed to save Rclone configuration' });
+        }
+    };
+    getAuthUrl = (_req, res) => {
+        try {
+            const url = google_1.googleDriveService.getAuthUrl();
+            res.json({ url });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to generate auth URL');
+            res.status(500).json({ error: 'Auth configuration error' });
+        }
+    };
+    handleCallback = async (req, res) => {
+        const code = req.query.code;
+        if (!code) {
+            return res.status(400).send('No code provided');
+        }
+        try {
+            await google_1.googleDriveService.handleCallback(code);
+            const user = await google_1.googleDriveService.getUserProfile();
+            logger_1.default.info('User logged in. Syncing database (please wait)...');
+            try {
+                await this.runSyncSequence(req.db);
+            }
+            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);
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Auth callback failed');
+            res.status(500).send('Authentication failed');
+        }
+    };
+    getUserProfile = async (_req, res) => {
+        try {
+            const user = await google_1.googleDriveService.getUserProfile();
+            res.json(user);
+        }
+        catch (error) {
+            res.json(null);
+        }
+    };
+    logout = async (_req, res) => {
+        await google_1.googleDriveService.logout();
+        res.json({ success: true });
+    };
+}
+exports.AuthController = AuthController;

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

@@ -0,0 +1,126 @@
+"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();
+        try {
+            const data = await this.getProvider(req).getPopular(timeframe);
+            res.set('Cache-Control', 'public, max-age=300').json(data);
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    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 {
+            res.status(500).send('Error');
+        }
+    };
+    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) {
+            // Return empty array instead of 500 so frontend can stay functional
+            // and allow provider switching.
+            logger_1.default.error({ err: e, provider: req.query.provider }, 'Provider video fetch failed');
+            res.json([]);
+        }
+    };
+    getEpisodes = async (req, res) => {
+        try {
+            res.json(await this.getProvider(req).getEpisodes(req.query.showId, req.query.mode));
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    search = async (req, res) => {
+        try {
+            res.json(await this.getProvider(req).search(req.query));
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    getSeasonal = async (req, res) => {
+        try {
+            const page = parseInt(req.query.page) || 1;
+            res.json(await this.getProvider(req).getSeasonal(page));
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    getLatestReleases = async (req, res) => {
+        try {
+            res.json(await this.getProvider(req).getLatestReleases());
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    getShowMeta = async (req, res) => {
+        try {
+            const [meta, details] = await Promise.all([
+                this.getProvider(req).getShowMeta(req.params.id),
+                this.getProvider(req)
+                    .getShowDetails(req.params.id)
+                    .catch(() => ({})),
+            ]);
+            const merged = { ...meta, ...details };
+            res.json(merged);
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    getShowDetails = async (req, res) => {
+        try {
+            res.json(await this.getProvider(req).getShowDetails(req.params.id));
+        }
+        catch {
+            res.status(404).send('Not found');
+        }
+    };
+    getAllmangaDetails = async (req, res) => {
+        try {
+            res.json(await this.getProvider(req).getAllmangaDetails(req.params.id));
+        }
+        catch {
+            res.status(500).send('Error');
+        }
+    };
+    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,125 @@
+"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;
+        try {
+            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),
+            });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to fetch expanded insights');
+            res.status(500).json({ error: 'Failed to fetch insights' });
+        }
+    };
+}
+exports.InsightsController = InsightsController;