@serifpersia/dango 3.0.3

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

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsController = void 0;
+const sync_1 = require("../sync");
+const anilist_1 = require("../lib/anilist");
+const kitsu_1 = require("../lib/kitsu");
+const xml2js_1 = require("xml2js");
+const logger_1 = __importDefault(require("../logger"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../config");
+const settings_repository_1 = require("../repositories/settings.repository");
+const shows_meta_repository_1 = require("../repositories/shows-meta.repository");
+const machine_id_1 = require("../utils/machine-id");
+const discord_rpc_1 = require("../discord-rpc");
+function mapMalStatus(malStatus) {
+    switch (malStatus) {
+        case 'Plan to Watch':
+            return 'Planned';
+        case 'On Hold':
+            return 'On-Hold';
+        default:
+            return malStatus;
+    }
+}
+async function searchByTitleForMal(title) {
+    const result = await (0, anilist_1.searchAnilistByTitle)(title);
+    if (result)
+        return { ...result, source: 'anilist' };
+    if ((0, anilist_1.isAnilistRateLimited)()) {
+        logger_1.default.debug({ title }, 'AniList rate limited, trying Kitsu fallback for MAL import');
+        const fb = await (0, kitsu_1.kitsuSearchAnime)({ query: title, page: 1, perPage: 5 });
+        if (fb.length > 0) {
+            const lowerTitle = title.toLowerCase();
+            const exactMatch = fb.find((m) => m.title?.romaji?.toLowerCase() === lowerTitle ||
+                m.title?.english?.toLowerCase() === lowerTitle);
+            const best = exactMatch || fb[0];
+            if (best.id > 0) {
+                return { id: best.id, title: best.title ?? {}, source: 'kitsu' };
+            }
+        }
+    }
+    return null;
+}
+class SettingsController {
+    getSettings = async (req, res) => {
+        try {
+            const row = await settings_repository_1.SettingsRepository.getByKey(req.db, req.query.key);
+            let value = row ? row.value : null;
+            if (value === null && req.query.key === 'discordRPCEnabled') {
+                value = 'true';
+            }
+            if (value === null && req.query.key === 'discordRPCHideMature') {
+                value = 'true';
+            }
+            if (value === null && req.query.key === 'ignoreAdultContent') {
+                value = 'true';
+            }
+            res.json({ value: value });
+        }
+        catch {
+            res.status(500).json({ error: 'DB error' });
+        }
+    };
+    updateSettings = async (req, res) => {
+        try {
+            const key = String(req.body.key);
+            const value = String(req.body.value ?? '');
+            const shouldDelete = value === '' && key === 'tracker_anilist_client_id';
+            await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                if (shouldDelete)
+                    settings_repository_1.SettingsRepository.deleteByKey(tx, key);
+                else
+                    settings_repository_1.SettingsRepository.upsert(tx, key, value);
+            });
+            if (req.body.key === 'discordRPCEnabled') {
+                discord_rpc_1.discordRPCService.setEnabled(req.body.value === 'true' || req.body.value === true);
+            }
+            if (req.body.key === 'discordRPCHideMature') {
+                discord_rpc_1.discordRPCService.setHideMature(req.body.value === 'true' || req.body.value === true);
+            }
+            res.json({ success: true });
+        }
+        catch {
+            res.status(500).json({ error: 'DB error' });
+        }
+    };
+    backupDatabase = (req, res) => {
+        const backupPath = path_1.default.join(config_1.CONFIG.ROOT, 'dango-backup.db');
+        try {
+            req.db.backup(backupPath);
+            res.download(backupPath, 'dango-backup.db', (err) => {
+                if (err) {
+                    logger_1.default.error({ err }, 'res.download failed during database backup');
+                    if (!res.headersSent) {
+                        res.status(500).json({ error: 'Download failed' });
+                    }
+                }
+                fs_1.default.unlink(backupPath, () => { });
+            });
+        }
+        catch (err) {
+            logger_1.default.error({ err }, 'Manual backup failed');
+            return res.status(500).json({ error: 'Backup failed' });
+        }
+    };
+    restoreDatabase = (req, res, db, initializeDatabase, setDb) => {
+        if (!req.file)
+            return res.status(400).json({ error: 'No file uploaded.' });
+        const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+        const tempPath = path_1.default.join(config_1.CONFIG.ROOT, `restore_temp.db`);
+        const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+        db.close((closeErr) => {
+            if (closeErr)
+                return res.status(500).json({ error: 'Failed to close database.' });
+            try {
+                req.db.checkpoint();
+            }
+            catch (checkpointErr) {
+                logger_1.default.warn({ err: checkpointErr }, 'WAL checkpoint failed');
+            }
+            try {
+                if (fs_1.default.existsSync(`${dbPath}-wal`))
+                    fs_1.default.unlinkSync(`${dbPath}-wal`);
+                if (fs_1.default.existsSync(`${dbPath}-shm`))
+                    fs_1.default.unlinkSync(`${dbPath}-shm`);
+            }
+            catch (cleanupErr) {
+                logger_1.default.warn({ err: cleanupErr }, 'Failed to clean up WAL files');
+            }
+            fs_1.default.rename(tempPath, dbPath, async (renameErr) => {
+                if (renameErr) {
+                    try {
+                        const reopenedDb = await initializeDatabase(dbPath);
+                        setDb(reopenedDb);
+                        req.db = reopenedDb;
+                    }
+                    catch (e) {
+                        logger_1.default.error({ err: e }, 'Failed to reopen DB after rename failure');
+                    }
+                    return res.status(500).json({ error: 'Failed to replace database file.' });
+                }
+                try {
+                    const newDb = await initializeDatabase(dbPath);
+                    setDb(newDb);
+                    req.db = newDb;
+                    res.json({ success: true, message: 'Database restored.' });
+                }
+                catch (e) {
+                    logger_1.default.error({ err: e }, 'Failed to initialize restored database');
+                    res.status(500).json({ error: 'Failed to initialize restored database.' });
+                }
+            });
+        });
+    };
+    importMalXml = async (req, res) => {
+        if (!req.file)
+            return res.status(400).json({ error: 'No file' });
+        const { erase } = req.body;
+        let result;
+        try {
+            result = await (0, xml2js_1.parseStringPromise)(req.file.buffer.toString());
+        }
+        catch {
+            return res.status(400).json({ error: 'Invalid XML' });
+        }
+        const animeList = result?.myanimelist?.anime || [];
+        if (animeList.length === 0) {
+            return res.status(400).json({ error: 'No anime found in XML' });
+        }
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders();
+        const sendEvent = (event, data) => {
+            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            if (typeof res.flush === 'function')
+                res.flush();
+        };
+        let skippedCount = 0;
+        const showsToInsert = [];
+        const metaToSave = [];
+        const BATCH_SIZE = 5;
+        const total = animeList.length;
+        for (let i = 0; i < animeList.length; i += BATCH_SIZE) {
+            const batch = animeList.slice(i, i + BATCH_SIZE);
+            const batchResults = await Promise.allSettled(batch.map((item) => searchByTitleForMal(item.series_title[0])));
+            const metaPromises = [];
+            batchResults.forEach((r, idx) => {
+                const malTitle = batch[idx].series_title[0];
+                const currentIdx = i + idx + 1;
+                if (r.status === 'fulfilled' && r.value) {
+                    const show = r.value;
+                    const title = show.title?.english || show.title?.romaji || malTitle;
+                    const status = mapMalStatus(batch[idx].my_status[0]);
+                    showsToInsert.push({
+                        id: String(show.id),
+                        name: title,
+                        status,
+                    });
+                    sendEvent('progress', {
+                        current: currentIdx,
+                        total,
+                        title: malTitle,
+                        matchedTitle: title,
+                        status,
+                        source: show.source,
+                        found: true,
+                    });
+                    metaPromises.push((0, anilist_1.getShowMetaById)(String(show.id))
+                        .then((meta) => {
+                        if (meta) {
+                            metaToSave.push({
+                                id: String(show.id),
+                                thumbnail: meta.thumbnail || undefined,
+                                type: meta.type || undefined,
+                            });
+                        }
+                    })
+                        .catch(() => { }));
+                }
+                else {
+                    skippedCount++;
+                    sendEvent('progress', {
+                        current: currentIdx,
+                        total,
+                        title: malTitle,
+                        matchedTitle: null,
+                        status: mapMalStatus(batch[idx].my_status[0]),
+                        source: null,
+                        found: false,
+                    });
+                }
+            });
+            await Promise.allSettled(metaPromises);
+        }
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            if (erase)
+                settings_repository_1.SettingsRepository.clearWatchlist(tx);
+            settings_repository_1.SettingsRepository.upsertWatchlistBatch(tx, showsToInsert);
+            for (const meta of metaToSave) {
+                if (meta.thumbnail) {
+                    shows_meta_repository_1.ShowsMetaRepository.upsert(tx, {
+                        id: meta.id,
+                        thumbnail: meta.thumbnail,
+                        type: meta.type,
+                    });
+                }
+            }
+        });
+        sendEvent('complete', { imported: showsToInsert.length, skipped: skippedCount });
+        res.end();
+    };
+    getInstallationId = (_req, res) => {
+        try {
+            res.json({ id: (0, machine_id_1.getMachineId)() });
+        }
+        catch (err) {
+            logger_1.default.error({ err }, 'Failed to get machine ID');
+            res.status(500).json({ error: 'Failed to get machine ID' });
+        }
+    };
+}
+exports.SettingsController = SettingsController;