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 =>
)}
>}
{preview.remove.length > 0 && <>
{preview.remove.length} item{preview.remove.length !== 1 ? 's' : ''} to remove
{groupItemsByType(preview.remove).map(group =>
)}
>}
{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}
}