230 lines
11 KiB
TypeScript
230 lines
11 KiB
TypeScript
import { Router } from 'express'
|
|
import path from 'path'
|
|
import fs from 'fs'
|
|
import { requireAuth } from '../auth.js'
|
|
import { logger, readLogs, clearLogs, logsFileSize } from '../logger.js'
|
|
import { DATA_DIR, BASE_DIR } from '../config.js'
|
|
import { readSettings } from '../settings.js'
|
|
import { systemInfo, checkPaths } from '../system.js'
|
|
import { scanMediaPath, syncFilenameChanges, migrateOrganizedEpisodeIds, dedupeOrganizedEpisodes } from '../organize.js'
|
|
import { readAvailable, cacheClear } from '../lib/github-cache.js'
|
|
import { loadCatalog } from '../lib/serie-helpers.js'
|
|
import { cacheSize, cacheFetchedAt } from '../lib/github-cache.js'
|
|
import { recentOrganized } from '../lib/notifs.js'
|
|
import { workerRunning, lastScan } from '../organize.js'
|
|
|
|
const router = Router()
|
|
|
|
const UNEXPECTED_ERROR = 'Erreur inattendue, consultez les journaux'
|
|
|
|
function readDirError(dirPath: string, err: unknown): string {
|
|
const code = (err as NodeJS.ErrnoException)?.code
|
|
if (code === 'ENOENT') return `Dossier introuvable : ${dirPath}`
|
|
if (code === 'EACCES' || code === 'EPERM') return `Accès refusé au dossier : ${dirPath}`
|
|
if (code === 'ENOTDIR') return `Ce chemin n'est pas un dossier : ${dirPath}`
|
|
return `Dossier inaccessible : ${dirPath}`
|
|
}
|
|
|
|
// ── Journaux ───────────────────────────────────────────────────
|
|
router.get('/logs', requireAuth, (req, res) => {
|
|
const limit = Number(req.query.limit) || 100
|
|
const level = (req.query.level as string) || 'all'
|
|
const source = (req.query.source as string) || undefined
|
|
res.json({ entries: readLogs({ limit, level: level as any, source }), size: logsFileSize() })
|
|
})
|
|
|
|
router.post('/logs/clear', requireAuth, (_req, res) => {
|
|
clearLogs()
|
|
logger.info('api', 'Journaux effacés')
|
|
res.json({ ok: true })
|
|
})
|
|
|
|
// ── Système ────────────────────────────────────────────────────
|
|
router.get('/system/info', systemInfo)
|
|
|
|
router.get('/system', requireAuth, (_req, res) => {
|
|
res.json({ isDocker: fs.existsSync('/.dockerenv') })
|
|
})
|
|
|
|
router.post('/system/check-paths', requireAuth, (req, res) => {
|
|
const { mediaPath, completePath } = req.body ?? {}
|
|
if (typeof mediaPath !== 'string' || (completePath !== undefined && typeof completePath !== 'string')) {
|
|
res.status(400).json({ error: 'Chemin de la médiathèque requis' }); return
|
|
}
|
|
res.json(checkPaths(mediaPath, completePath))
|
|
})
|
|
|
|
router.get('/version', (_req, res) => {
|
|
try {
|
|
const versionPath = path.join(BASE_DIR, 'version.txt')
|
|
const version = fs.existsSync(versionPath) ? fs.readFileSync(versionPath, 'utf-8').trim() : 'dev'
|
|
res.json({ version })
|
|
} catch {
|
|
res.json({ version: 'dev' })
|
|
}
|
|
})
|
|
|
|
// ── Parcours des dossiers ──────────────────────────────────────
|
|
router.get('/browse', requireAuth, (req, res) => {
|
|
const isWindows = process.platform === 'win32'
|
|
const dirPath = (req.query.path as string) || '/'
|
|
|
|
// ── Racine virtuelle Windows : liste les lecteurs disponibles ──
|
|
if (isWindows && dirPath === '/') {
|
|
const drives: string[] = []
|
|
for (const letter of 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') {
|
|
const d = `${letter}:\\`
|
|
try { fs.readdirSync(d); drives.push(d) } catch {}
|
|
}
|
|
res.json({ path: '/', parent: null, dirs: drives, drivesRoot: true })
|
|
return
|
|
}
|
|
|
|
try {
|
|
const entries = fs.readdirSync(dirPath, { withFileTypes: true })
|
|
const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).filter(n => !n.startsWith('.')).sort((a, b) => a.localeCompare(b))
|
|
|
|
// Sous Windows, remonter à '/' depuis la racine d'un lecteur (ex. C:\)
|
|
let parent: string | null
|
|
if (dirPath === '/') {
|
|
parent = null
|
|
} else if (isWindows && /^[A-Za-z]:\\?$/.test(dirPath)) {
|
|
parent = '/'
|
|
} else {
|
|
const up = path.dirname(dirPath)
|
|
parent = up === dirPath ? null : up // dirname de C:\ renvoie C:\ : pas de parent
|
|
}
|
|
|
|
res.json({ path: dirPath, parent, dirs })
|
|
} catch (err) {
|
|
logger.warn('api', `Lecture du dossier « ${dirPath} » impossible : ${err instanceof Error ? err.message : err}`)
|
|
res.status(400).json({ error: readDirError(dirPath, err) })
|
|
}
|
|
})
|
|
|
|
router.get('/browse-files', requireAuth, (req, res) => {
|
|
const dirPath = (req.query.path as string) || '/'
|
|
const VIDEO_EXTS = new Set(['.mkv', '.mp4', '.avi', '.m4v', '.mov', '.wmv'])
|
|
try {
|
|
// Lecture seule : le dossier est créé au moment de l'import
|
|
if (!fs.existsSync(dirPath)) { res.json({ path: dirPath, files: [], exists: false }); return }
|
|
const files: { name: string; path: string; size: number }[] = []
|
|
function walk(dir: string) {
|
|
let entries: fs.Dirent[]
|
|
try { entries = fs.readdirSync(dir, { withFileTypes: true }) }
|
|
catch { return }
|
|
for (const entry of entries) {
|
|
if (entry.name.startsWith('.')) continue
|
|
const full = path.join(dir, entry.name)
|
|
if (entry.isDirectory()) {
|
|
walk(full)
|
|
} else if (entry.isFile() && VIDEO_EXTS.has(path.extname(entry.name).toLowerCase())) {
|
|
try {
|
|
const stat = fs.statSync(full)
|
|
files.push({ name: entry.name, path: full, size: stat.size })
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
walk(dirPath)
|
|
files.sort((a, b) => a.name.localeCompare(b.name, 'fr'))
|
|
res.json({ path: dirPath, files, exists: true })
|
|
} catch (err) {
|
|
logger.warn('api', `Lecture du dossier « ${dirPath} » impossible : ${err instanceof Error ? err.message : err}`)
|
|
res.status(400).json({ error: readDirError(dirPath, err) })
|
|
}
|
|
})
|
|
|
|
// ── Catalogue ──────────────────────────────────────────────────
|
|
router.get('/torrents/status', requireAuth, async (_req, res) => {
|
|
try {
|
|
const available = await readAvailable()
|
|
res.json({ exists: available.length > 0, count: available.length, empty: available.length === 0, syncedAt: cacheFetchedAt('available.json') })
|
|
} catch { res.json({ exists: false, count: 0, empty: true }) }
|
|
})
|
|
|
|
router.post('/update', requireAuth, async (req, res) => {
|
|
const force = req.body?.force === true
|
|
const organizedPath = path.join(DATA_DIR, 'organized.json')
|
|
try {
|
|
cacheClear()
|
|
logger.info('api', force
|
|
? 'Resynchronisation complète du catalogue (caches ignorés), noms de fichiers recalculés'
|
|
: 'Cache GitHub vidé : rechargement du catalogue')
|
|
|
|
const availableIds = await readAvailable(force)
|
|
if (!Array.isArray(availableIds)) throw new Error('Catalogue GitHub invalide (available.json)')
|
|
logger.info('api', `Catalogue rechargé : ${availableIds.length} séries disponibles`)
|
|
|
|
if (force) {
|
|
const seriesData = await loadCatalog(true)
|
|
const { updated } = await migrateOrganizedEpisodeIds(organizedPath, seriesData)
|
|
const { removed } = dedupeOrganizedEpisodes(organizedPath)
|
|
const { renamed, errors } = await syncFilenameChanges(seriesData, organizedPath)
|
|
logger.info('api', `Resynchronisation terminée : ${updated} ID(s) migré(s), ${removed} doublon(s) retiré(s), ${renamed} fichier(s) renommé(s)${errors > 0 ? `, ${errors} erreur(s)` : ''}`)
|
|
res.json({ ok: true, count: availableIds.length, migrated: updated, deduped: removed, renamed, errors })
|
|
return
|
|
}
|
|
|
|
res.json({ ok: true, count: availableIds.length })
|
|
;(async () => {
|
|
try {
|
|
const seriesData = await loadCatalog()
|
|
const { renamed } = await syncFilenameChanges(seriesData, organizedPath)
|
|
if (renamed > 0)
|
|
logger.info('api', `Renommage après synchronisation : ${renamed} fichier(s) renommé(s)`)
|
|
} catch (err) {
|
|
logger.warn('api', `Échec du renommage après synchronisation : ${err instanceof Error ? err.message : err}`)
|
|
}
|
|
})()
|
|
} catch (err) {
|
|
logger.error('api', `Échec de la synchronisation du catalogue : ${err instanceof Error ? err.message : err}`)
|
|
res.status(500).json({ error: err instanceof Error ? err.message : UNEXPECTED_ERROR })
|
|
}
|
|
})
|
|
|
|
router.get('/scan', requireAuth, (_req, res) => {
|
|
res.json({ lastScan })
|
|
})
|
|
|
|
router.post('/scan', requireAuth, async (_req, res) => {
|
|
try {
|
|
const { mediaPath } = readSettings()
|
|
logger.info('api', 'Analyse manuelle de la médiathèque lancée')
|
|
const seriesData = await loadCatalog()
|
|
const result = await scanMediaPath(mediaPath, path.join(DATA_DIR, 'organized.json'), seriesData)
|
|
res.json({ ok: true, ...result })
|
|
} catch (err) {
|
|
logger.error('api', `Échec de l'analyse de la médiathèque : ${err instanceof Error ? err.message : err}`)
|
|
res.status(500).json({ error: err instanceof Error ? err.message : UNEXPECTED_ERROR })
|
|
}
|
|
})
|
|
|
|
// ── Diagnostic ─────────────────────────────────────────────────
|
|
router.get('/debug/stats', requireAuth, (req, res) => {
|
|
const mem = process.memoryUsage()
|
|
const uptimeS = Math.floor(process.uptime())
|
|
const h = Math.floor(uptimeS / 3600)
|
|
const m = Math.floor((uptimeS % 3600) / 60)
|
|
const s = uptimeS % 60
|
|
let organizedCount = 0
|
|
try {
|
|
const orgPath = path.join(DATA_DIR, 'organized.json')
|
|
if (fs.existsSync(orgPath)) {
|
|
const org = JSON.parse(fs.readFileSync(orgPath, 'utf-8'))
|
|
organizedCount = Object.values(org).reduce((acc: number, episodes: any) => acc + Object.keys(episodes).length, 0)
|
|
}
|
|
} catch {}
|
|
res.json({
|
|
memory : { heapUsed: Math.round(mem.heapUsed / 1024 / 1024), heapTotal: Math.round(mem.heapTotal / 1024 / 1024), rss: Math.round(mem.rss / 1024 / 1024) },
|
|
cache : { entries: cacheSize(), ttlHours: 1 },
|
|
uptime : `${h}h ${m}m ${s}s`,
|
|
uptimeSeconds: uptimeS,
|
|
worker : { running: workerRunning },
|
|
organized: { trackedFiles: organizedCount },
|
|
requests : { notifs: recentOrganized.length },
|
|
})
|
|
})
|
|
|
|
export default router
|