import {APIButton} from "../Common"; import {Button, Header, Icon, IconButton, Loader, Loading, Modal, Placeholder, Table, Tooltip} from "../ui"; import React, {useEffect, useState} from "react"; import {getConfigText, getConfigBackups, postConfigBackupImport, postConfigBackupPreview} from "../../api"; function WarningIcon({ok}) { // null is empty, true is valid, false is invalid. const content = ok === true ? 'Valid and can be imported.' : ok === false ? 'Invalid, can be overwritten.' : 'Empty config, can be overwritten.'; return } const TYPE_LABELS = { tag: 'Tags', tag_file: 'Tag Files', tag_zim: 'Tag Zims', channel: 'Channels', domain: 'Domains', download: 'Downloads', inventory: 'Inventories', playlist: 'Playlists', }; const TYPE_COLUMNS = { tag: [{key: 'name', header: 'Name'}], tag_file: [{key: 'tag', header: 'Tag'}, {key: 'path', header: 'Path'}], tag_zim: [{key: 'tag', header: 'Tag'}, {key: 'zim', header: 'Zim'}, {key: 'entry', header: 'Entry'}], channel: [{key: 'name', header: 'Name'}, {key: 'directory', header: 'Directory'}], domain: [{key: 'name', header: 'Name'}, {key: 'directory', header: 'Directory'}], download: [{key: 'url', header: 'URL'}, {key: 'downloader', header: 'Downloader'}], inventory: [{key: 'name', header: 'Name'}], playlist: [{key: 'name', header: 'Name'}, {key: 'items', header: 'Items'}], }; function groupItemsByType(items) { const groups = {}; for (const item of items) { if (!groups[item.type]) { groups[item.type] = []; } groups[item.type].push(item); } return Object.entries(groups).map(([type, items]) => ({ type, label: TYPE_LABELS[type] || type, items, })); } function PreviewItemTable({items, negative}) { if (!items.length) return null; const columns = TYPE_COLUMNS[items[0].type] || [{key: 'type', header: 'Item'}]; return {columns.map(col => {col.header})} {/* Items being removed take the failed treatment: dashed, in every theme. */} {items.map((item, i) => {columns.map(col => {item[col.key] || ''} )} )}
; } const formatDate = (d) => d ? `${d.substring(0, 4)}-${d.substring(4, 6)}-${d.substring(6, 8)}` : ''; function BackupDateRow({date, previews, previewsLoaded, onSelect}) { const mergeLoaded = previewsLoaded?.merge; const overwriteLoaded = previewsLoaded?.overwrite; const mergePreview = previews?.merge; const overwritePreview = previews?.overwrite; const hasChanges = (p) => p && (p.add.length > 0 || p.remove.length > 0); const mergeHasChanges = hasChanges(mergePreview); const overwriteHasChanges = hasChanges(overwritePreview); const noChanges = No changes; const previewFailed = ; let mergeCell; if (!mergeLoaded) { mergeCell = ; } else if (mergePreview === null) { mergeCell = previewFailed; } else if (mergeHasChanges) { mergeCell = ; } else { mergeCell = noChanges; } let overwriteCell; if (!overwriteLoaded) { overwriteCell = ; } else if (overwritePreview === null) { overwriteCell = previewFailed; } else if (overwriteHasChanges) { // Overwrite discards whatever is in the database, so it warns rather than saves. overwriteCell = ; } else { overwriteCell = noChanges; } return {formatDate(date)} {mergeCell} {overwriteCell} ; } function BackupsModal({open, onClose, fileName, fetchConfigs}) { const [dates, setDates] = useState([]); const [datesLoading, setDatesLoading] = useState(true); const [previews, setPreviews] = useState({}); const [previewsLoaded, setPreviewsLoaded] = useState({}); const [selectedAction, setSelectedAction] = useState(null); // {date, mode, preview} const [applying, setApplying] = useState(false); // Fetch backup dates on open. useEffect(() => { if (!open) return; let cancelled = false; setDatesLoading(true); setDates([]); setPreviews({}); setPreviewsLoaded({}); setSelectedAction(null); setApplying(false); getConfigBackups(fileName).then(result => { if (cancelled) return; setDates(result?.dates || []); setDatesLoading(false); }); return () => { cancelled = true; }; }, [open, fileName]); // Progressively fetch previews for each date, newest first. useEffect(() => { if (!open || dates.length === 0) return; let cancelled = false; const loadPreviews = async () => { for (const date of dates) { if (cancelled) break; const [mergeResult, overwriteResult] = await Promise.all([ postConfigBackupPreview(fileName, date, 'merge'), postConfigBackupPreview(fileName, date, 'overwrite'), ]); if (cancelled) break; setPreviews(prev => ({ ...prev, [date]: {merge: mergeResult?.preview || null, overwrite: overwriteResult?.preview || null} })); setPreviewsLoaded(prev => ({...prev, [date]: {merge: true, overwrite: true}})); } }; loadPreviews(); return () => { cancelled = true; }; }, [open, dates, fileName]); const handleSelect = (date, mode, preview) => { setSelectedAction({date, mode, preview}); }; const handleApply = async () => { if (!selectedAction) return; setApplying(true); await postConfigBackupImport(fileName, selectedAction.date, selectedAction.mode); await fetchConfigs(); setApplying(false); handleClose(); }; const handleBack = () => { setSelectedAction(null); }; const handleClose = () => { onClose(); }; // Confirmation view: show the diff for the selected action. if (selectedAction) { const {date, mode, preview} = selectedAction; const modeLabel = mode === 'merge' ? 'Merge' : 'Overwrite'; return {modeLabel}: {fileName} ({formatDate(date)}) {applying ? Applying backup... : <> {preview.add.length > 0 && <>
{preview.add.length} item{preview.add.length !== 1 ? 's' : ''} to add
{groupItemsByType(preview.add).map(group =>
{group.label}
)}
} {preview.remove.length > 0 && <>
{preview.remove.length} item{preview.remove.length !== 1 ? 's' : ''} to remove
{groupItemsByType(preview.remove).map(group =>
{group.label}
)}
}

{preview.unchanged} unchanged item{preview.unchanged !== 1 ? 's' : ''}

}
{!applying && <> }
; } // Backups list view. return Restore Backup: {fileName} {datesLoading ? Loading backups... : dates.length === 0 ?

No backups available for this config.

:
Date Merge Overwrite {dates.map(date => )}
}
; } function ConfigContentModal({open, onClose, fileName}) { const [content, setContent] = useState(null); const [loading, setLoading] = useState(true); useEffect(() => { if (!open) return; let cancelled = false; setLoading(true); setContent(null); getConfigText(fileName).then(result => { if (cancelled) return; setContent(result); setLoading(false); }).catch(() => { if (cancelled) return; setContent(null); setLoading(false); }); return () => { cancelled = true; }; }, [open, fileName]); return {fileName} {loading ? : content ?
{content}
:

Failed to load config contents.

}
; } function ConfigTableRow({config, importConfig, saveConfig, fetchConfigs}) { const {file_name, valid, successful_import, has_backup_import} = config; const [backupsModalOpen, setBackupsModalOpen] = useState(false); const [contentModalOpen, setContentModalOpen] = useState(false); const localImportConfig = async () => { await importConfig(file_name); await fetchConfigs(); } const localSaveConfig = async () => { await saveConfig(file_name); await fetchConfigs(); } const importButton = ; let saveButton; if (successful_import) { saveButton = ; } else { // Warn the user they may overwrite because import was not successful. saveButton = ; } return setContentModalOpen(true)}>{file_name} {has_backup_import ? setBackupsModalOpen(true)}/> : null } {importButton} {saveButton} {backupsModalOpen && setBackupsModalOpen(false)} fileName={file_name} fetchConfigs={fetchConfigs} />} {contentModalOpen && setContentModalOpen(false)} fileName={file_name} />} } export function ConfigsTable({configs, loading, importConfig, saveConfig, fetchConfigs}) { let body = if (loading) { // Configs are being fetched again. } else if (configs === undefined) { body = Failed to fetch configs ; } else if (configs && Object.keys(configs).length === 0) { body = No configs exist. Try tagging some files. ; } else if (configs) { body = Object.entries(configs).map(([key, value]) => ); } return File Name Imported Valid Restore Import Save {body}
}