`;
}
function applyRuleFormValues(body, rule) {
const setVal = (field, value) => {
const el = body.querySelector(`[data-field="${field}"]`);
if (el) el.value = value ?? '';
};
setVal('name', rule.name || '');
setVal('enabled', rule.enabled ? '1' : '0');
setVal('logic', rule.logic || 'and');
setVal('tags', (rule.tags || []).join(','));
renderRuleConditions(body, Array.isArray(rule.conditions) ? rule.conditions : []);
}
function ruleFieldOptions() {
const roots = state.rootsList || [];
const options = [];
if (roots.some(r => r.type === 'movie')) options.push({ value: 'movie', label: t('settings.tasks.source.movie', 'Movies') });
if (roots.some(r => r.type === 'series')) options.push({ value: 'series', label: t('settings.tasks.source.series', 'Series') });
if (roots.some(r => r.type === 'staging')) options.push({ value: 'staging', label: t('settings.tasks.source.staging', 'Staging') });
if (state.pluginConfig?.sources?.transmission) options.push({ value: 'transmission', label: t('settings.tasks.source.transmission', 'Transmission') });
return {
source: { label: t('rules.cond.source','Source'), type: 'select', options },
status: { label: t('rules.cond.status','Status'), type: 'select', options: sourceStatusOptions('transmission') },
name_regex: { label: t('rules.cond.name_regex','Name regex'), type: 'regex' },
path_regex: { label: t('rules.cond.path_regex','Path regex'), type: 'regex' },
size_mb: { label: t('rules.cond.size','Size (MB)'), type: 'number' },
container: { label: t('rules.cond.container','Container'), type: 'select', options: [
{ value: 'mkv', label: 'mkv' },
{ value: 'mp4', label: 'mp4' },
{ value: 'avi', label: 'avi' },
]},
lang: { label: t('rules.cond.lang','Language'), type: 'text' },
};
}
function ruleOperatorOptions(field) {
const meta = ruleFieldOptions()[field];
const type = meta?.type || 'text';
if (type === 'number') {
return [
{ value: 'eq', label: '=' },
{ value: 'gt', label: '>' },
{ value: 'lt', label: '<' },
{ value: 'between', label: t('rules.op.between','between') },
];
}
if (type === 'regex') {
return [{ value: 'regex', label: t('rules.op.regex','regex') }];
}
return [
{ value: 'eq', label: '=' },
{ value: 'contains', label: t('rules.op.contains','contains') },
{ value: 'in', label: t('rules.op.in','in') },
{ value: 'not_in', label: t('rules.op.not_in','not in') },
];
}
function renderRuleConditions(body, conditions) {
const wrap = body.querySelector('[data-field="rule_conditions"] .conditions-list');
const addBtn = body.querySelector('[data-action="add_rule_condition"]');
if (!wrap || !addBtn) return;
wrap.innerHTML = '';
(conditions || []).forEach(cond => wrap.appendChild(createRuleConditionRow(cond)));
addBtn.addEventListener('click', () => {
wrap.appendChild(createRuleConditionRow({}));
});
}
function createRuleConditionRow(cond) {
const meta = ruleFieldOptions();
const row = document.createElement('div');
row.className = 'conditions-builder';
const fieldSel = document.createElement('select');
Object.keys(meta).forEach(key => {
const opt = document.createElement('option');
opt.value = key;
opt.textContent = meta[key].label;
fieldSel.appendChild(opt);
});
fieldSel.value = cond.field || 'source';
const opSel = document.createElement('select');
const valueWrap = document.createElement('div');
valueWrap.className = 'cond-value';
const removeBtn = document.createElement('button');
removeBtn.type = 'button';
removeBtn.className = 'btn';
removeBtn.textContent = 'X';
removeBtn.addEventListener('click', () => row.remove());
const updateOps = () => {
opSel.innerHTML = '';
ruleOperatorOptions(fieldSel.value).forEach(opt => {
const o = document.createElement('option');
o.value = opt.value;
o.textContent = opt.label;
opSel.appendChild(o);
});
};
const updateValue = () => {
valueWrap.innerHTML = '';
const field = fieldSel.value;
const op = opSel.value;
const fieldMeta = meta[field];
const type = fieldMeta?.type || 'text';
const value = cond.value;
if (type === 'select') {
const select = document.createElement('select');
if (op === 'in' || op === 'not_in') select.multiple = true;
(fieldMeta.options || []).forEach(opt => {
const o = document.createElement('option');
o.value = opt.value;
o.textContent = opt.label;
const list = Array.isArray(value) ? value : [value];
if (list.includes(opt.value)) o.selected = true;
select.appendChild(o);
});
valueWrap.appendChild(select);
return;
}
if (type === 'number' && op === 'between') {
const min = document.createElement('input');
min.type = 'number';
min.placeholder = 'min';
min.value = Array.isArray(value) ? (value[0] ?? '') : '';
min.dataset.bound = 'min';
const max = document.createElement('input');
max.type = 'number';
max.placeholder = 'max';
max.value = Array.isArray(value) ? (value[1] ?? '') : '';
max.dataset.bound = 'max';
valueWrap.appendChild(min);
valueWrap.appendChild(max);
return;
}
const input = document.createElement('input');
input.type = (type === 'number') ? 'number' : 'text';
input.value = (value ?? '');
if (op === 'in' || op === 'not_in') {
input.placeholder = 'a,b,c';
}
valueWrap.appendChild(input);
};
updateOps();
opSel.value = cond.op || opSel.value || 'eq';
updateValue();
fieldSel.addEventListener('change', () => {
updateOps();
opSel.value = opSel.value || 'eq';
updateValue();
});
opSel.addEventListener('change', updateValue);
row.appendChild(fieldSel);
row.appendChild(opSel);
row.appendChild(valueWrap);
row.appendChild(removeBtn);
return row;
}
function readRuleConditions(body) {
const rows = Array.from(body.querySelectorAll('[data-field="rule_conditions"] .conditions-list .conditions-builder'));
const meta = ruleFieldOptions();
return rows.map(row => {
const selects = row.querySelectorAll('select');
const field = selects[0]?.value || '';
const op = selects[1]?.value || 'eq';
const fieldMeta = meta[field];
const type = fieldMeta?.type || 'text';
let value = '';
const valueWrap = row.querySelector('.cond-value');
if (!valueWrap) return null;
if (type === 'select') {
const select = valueWrap.querySelector('select');
if (select && select.multiple) {
value = Array.from(select.selectedOptions).map(o => o.value);
} else {
value = select?.value || '';
}
} else if (type === 'number' && op === 'between') {
const min = valueWrap.querySelector('[data-bound="min"]')?.value || '';
const max = valueWrap.querySelector('[data-bound="max"]')?.value || '';
value = [Number(min || 0), Number(max || 0)];
} else {
const input = valueWrap.querySelector('input');
value = input?.value ?? '';
if (op === 'in' || op === 'not_in') {
value = String(value).split(',').map(v => v.trim()).filter(Boolean);
} else if (type === 'number') {
value = Number(value || 0);
}
}
return { field, op, value };
}).filter(Boolean);
}
function saveRuleModal() {
const modal = UI.qs('#ruleModal');
const body = UI.qs('#ruleModalBody');
if (!modal || !body) return;
if (state.pluginEditType) {
savePluginModal(body);
setDirty(true);
closeRuleModal();
return;
}
if (state.rootEditId !== null) {
const type = body.querySelector('[data-field="root_type"]')?.value || 'movie';
const path = body.querySelector('[data-field="root_path"]')?.value?.trim() || '';
const enabled = body.querySelector('[data-field="root_enabled"]')?.value === '1';
const current = state.rootsList.find(r => r.id === state.rootEditId);
if (current) {
current.type = type;
current.path = path;
current.enabled = enabled;
} else {
state.rootsList.push({
id: state.rootEditId,
type,
path,
enabled,
});
}
renderRootsList();
setDirty(true);
closeRuleModal();
return;
}
if (state.toolEditType) {
const path = body.querySelector('[data-field="tool_path"]')?.value?.trim() || '';
updateToolPath(state.toolEditType, path);
setDirty(true);
closeRuleModal();
return;
}
const id = state.ruleEditId;
const type = state.ruleEditType;
const current = state.rulesList.find(r => r.id === id) || normalizeRule({ type });
const getVal = (field) => body.querySelector(`[data-field="${field}"]`)?.value ?? '';
const name = getVal('name').trim();
const enabled = getVal('enabled') === '1';
const config = {};
if (type === 'name_map') {
config.pattern = getVal('pattern').trim();
config.canonical = getVal('canonical').trim();
config.mode = getVal('mode') || 'exact';
} else if (type === 'delete_track') {
config.track_type = getVal('track_type').trim();
config.lang = getVal('lang').trim();
config.audio_type = getVal('audio_type').trim();
config.name_contains = getVal('name_contains').trim();
config.except_default = getVal('except_default') === '1';
config.except_forced = getVal('except_forced') === '1';
} else if (type === 'priorities') {
config.languages = commaToList(getVal('languages'));
config.audio_types = commaToList(getVal('audio_types'));
} else if (type === 'lang_fix') {
config.from_lang = getVal('from_lang').trim();
config.to_lang = getVal('to_lang').trim();
config.mode = getVal('mode') || 'exact';
} else if (type === 'source_filter') {
config.source = getVal('source').trim();
config.conditions = readConditionsTable(body);
}
const updated = {
id: current.id,
type,
name,
enabled,
config,
};
const idx = state.rulesList.findIndex(r => r.id === current.id);
if (idx >= 0) {
state.rulesList[idx] = updated;
} else {
state.rulesList.push(updated);
}
renderRulesList();
setDirty(true);
closeRuleModal();
}
function escapeHtml(s) {
return String(s).replace(/[&<>"']/g, c => (
c === '&' ? '&' :
c === '<' ? '<' :
c === '>' ? '>' :
c === '"' ? '"' : '''
));
}
function cellText(value) {
const td = document.createElement('td');
td.textContent = value ?? '';
return td;
}
function initTableControllers() {
if (!window.TableController) return;
const mode = state.ui.table_mode || 'pagination';
const pageSize = state.ui.table_page_size || 50;
const getPrefs = (table) => {
const id = table?.dataset?.tableId || table?.id || '';
const prefs = window.UserPrefs?.getTable?.(id) || {};
return { id, prefs };
};
const rootsTable = UI.qs('#rootsTable');
if (rootsTable) {
const { id, prefs } = getPrefs(rootsTable);
state.tables.roots = new TableController({
table: rootsTable,
mode,
pageSize,
sort: prefs.sort || '',
dir: prefs.dir || 'asc',
onSortChange: (sort, dir) => window.UserPrefs?.setTable?.(id, { sort, dir }),
fetchPage: ({ page, per_page, sort, dir }) => {
const sorted = sortItems(state.rootsList, sort, dir, {
path: r => (r.path || '').toLowerCase(),
});
return Promise.resolve(paginateItems(sorted, page, per_page));
},
renderRow: renderRootRow,
});
}
const toolsTable = UI.qs('#toolsTable');
if (toolsTable) {
const { id, prefs } = getPrefs(toolsTable);
state.tables.tools = new TableController({
table: toolsTable,
mode,
pageSize,
sort: prefs.sort || '',
dir: prefs.dir || 'asc',
onSortChange: (sort, dir) => window.UserPrefs?.setTable?.(id, { sort, dir }),
fetchPage: ({ page, per_page, sort, dir }) => {
const sorted = sortItems(state.toolsList, sort, dir, {
name: t => (t.label || '').toLowerCase(),
});
return Promise.resolve(paginateItems(sorted, page, per_page));
},
renderRow: renderToolRow,
});
}
const rulesTable = UI.qs('#rulesTable');
if (rulesTable) {
const { id, prefs } = getPrefs(rulesTable);
state.tables.rules = new TableController({
table: rulesTable,
mode,
pageSize,
sort: prefs.sort || '',
dir: prefs.dir || 'asc',
onSortChange: (sort, dir) => window.UserPrefs?.setTable?.(id, { sort, dir }),
fetchPage: ({ page, per_page, sort, dir }) => {
const sortKey = sort || 'name';
const sortDir = dir || 'asc';
const sorted = sortItems(state.rulesList, sortKey, sortDir, {
name: r => (r.name || '').toLowerCase(),
type: r => (r.type || '').toLowerCase(),
});
return Promise.resolve(paginateItems(sorted, page, per_page));
},
renderRow: renderRuleRow,
});
}
const pluginsTable = UI.qs('#pluginsTable');
if (pluginsTable) {
const { id, prefs } = getPrefs(pluginsTable);
state.tables.plugins = new TableController({
table: pluginsTable,
mode,
pageSize,
sort: prefs.sort || '',
dir: prefs.dir || 'asc',
onSortChange: (sort, dir) => window.UserPrefs?.setTable?.(id, { sort, dir }),
fetchPage: ({ page, per_page, sort, dir }) => {
const list = buildPluginsList();
const sorted = sortItems(list, sort, dir, {
name: p => (p.label || '').toLowerCase(),
});
return Promise.resolve(paginateItems(sorted, page, per_page));
},
renderRow: renderPluginRow,
});
}
const templatesTable = UI.qs('#templatesTable');
if (templatesTable) {
const { id, prefs } = getPrefs(templatesTable);
state.tables.templates = new TableController({
table: templatesTable,
mode,
pageSize,
sort: prefs.sort || '',
dir: prefs.dir || 'asc',
onSortChange: (sort, dir) => window.UserPrefs?.setTable?.(id, { sort, dir }),
fetchPage: ({ page, per_page, sort, dir }) => {
const sorted = sortItems(state.templatesList, sort, dir, {
name: t => (t.name || '').toLowerCase(),
});
return Promise.resolve(paginateItems(sorted, page, per_page));
},
renderRow: renderTemplateRow,
});
}
const tasksTable = UI.qs('#tasksTable');
if (tasksTable) {
const { id, prefs } = getPrefs(tasksTable);
state.tables.tasks = new TableController({
table: tasksTable,
mode,
pageSize,
sort: prefs.sort || '',
dir: prefs.dir || 'asc',
onSortChange: (sort, dir) => window.UserPrefs?.setTable?.(id, { sort, dir }),
fetchPage: ({ page, per_page, sort, dir }) => {
const sorted = sortItems(state.tasksList, sort, dir, {
name: t => (t.name || '').toLowerCase(),
});
return Promise.resolve(paginateItems(sorted, page, per_page));
},
renderRow: renderTaskRow,
});
}
}
/* ---------------------------
Actions
--------------------------- */
async function doSave() {
const prevRetention = Number(state.settings?.logs?.retention_days ?? 7);
const payload = collectSettingsFromUI();
const newRetention = Number(payload.logs?.retention_days ?? 7);
if (prevRetention > 0 && newRetention > 0 && newRetention < prevRetention) {
if (!confirm(t('settings.logs.retention_warn', 'Older logs will be deleted. Continue?'))) {
return;
}
}
setStatus(t('common.saving', 'Saving…'));
await api('/api/settings', 'POST', payload);
setDirty(false);
await loadSettings();
setStatus(t('common.saved', 'Saved'));
}
async function generatePreview() {
const box = UI.qs('#previewBox');
if (!box) return;
box.textContent = t('common.generating_preview', 'Generating preview…');
try {
const movies = await api('/api/layout/preview', 'POST', { kind: 'movies', mode: 'samples', limit: 10 });
const series = await api('/api/layout/preview', 'POST', { kind: 'series', mode: 'samples', limit: 10 });
let txt = '';
txt += `${t('settings.preview.movies','MOVIES')}\n`;
for (const ex of movies.examples || []) {
txt += `- ${ex.input.title} (${ex.input.year ?? t('common.na','n/a')}) -> ${ex.output_abs}\n`;
}
txt += `\n${t('settings.preview.series','SERIES')}\n`;
for (const ex of series.examples || []) {
txt += `- ${ex.input.title} (${ex.input.year ?? t('common.na','n/a')}) -> ${ex.output_abs}\n`;
}
box.textContent = txt;
} catch (e) {
box.textContent = `${t('common.error','Error')}: ${e.message}`;
}
}
async function loadDebugStats() {
const filesEl = UI.qs('#dbgContentFiles');
if (!filesEl) return;
console.log('[debug] loadDebugStats: start');
try {
const data = await api('/api/debug/stats', 'GET');
console.log('[debug] loadDebugStats: response', data);
const content = data?.content || {};
const db = data?.db || {};
const info = data?.db_info || {};
UI.qs('#dbgContentFiles').textContent = String(content.files ?? 0);
UI.qs('#dbgContentMeta').textContent = String(content.meta ?? 0);
UI.qs('#dbgContentItems').textContent = String(content.items ?? 0);
UI.qs('#dbgDbTables').textContent = String(db.tables ?? 0);
UI.qs('#dbgDbSize').textContent = UI.formatBytes(db.size_bytes ?? 0);
UI.qs('#dbgDbName').textContent = String(info.db_name || '-');
UI.qs('#dbgDbUser').textContent = String(info.current_user || info.user_name || '-');
console.log('[debug] loadDebugStats: db_info', info);
loadDebugTables();
} catch (e) {
console.log('[debug] loadDebugStats: error', e);
UI.qs('#dbgContentFiles').textContent = '-';
UI.qs('#dbgContentMeta').textContent = '-';
UI.qs('#dbgContentItems').textContent = '-';
UI.qs('#dbgDbTables').textContent = '-';
UI.qs('#dbgDbSize').textContent = '-';
UI.qs('#dbgDbName').textContent = '-';
UI.qs('#dbgDbUser').textContent = '-';
const body = UI.qs('#dbgDbTablesList tbody');
if (body) body.innerHTML = '';
const preview = UI.qs('#dbgDbTablePreview');
if (preview) preview.textContent = '';
}
}
async function loadDebugTables() {
const table = UI.qs('#dbgDbTablesList');
if (!table) return;
const body = table.querySelector('tbody');
const status = UI.qs('#dbgDbTablesStatus');
if (body) body.innerHTML = '';
if (status) status.textContent = t('common.loading', 'Loading…');
console.log('[debug] loadDebugTables: start');
try {
const data = await api('/api/debug/db-tables', 'GET');
const items = Array.isArray(data?.items) ? data.items : [];
if (status) status.textContent = `items: ${items.length}`;
console.log('[debug] loadDebugTables: items', items.length, items.slice(0, 3));
if (body) {
if (items.length === 0) {
const row = document.createElement('tr');
const cell = document.createElement('td');
cell.colSpan = 2;
cell.textContent = t('common.empty', 'Empty');
row.appendChild(cell);
body.appendChild(row);
} else {
items.forEach((item) => {
const row = document.createElement('tr');
row.className = 'db-table-row';
row.dataset.tableName = item.name || '';
const name = document.createElement('td');
name.textContent = item.name || '';
const count = document.createElement('td');
count.textContent = String(item.rows ?? 0);
row.appendChild(name);
row.appendChild(count);
body.appendChild(row);
});
}
}
} catch (e) {
if (body) {
body.innerHTML = `
${t('settings.tasks.field_sources', 'Sources')}
${sourceOptions}
${t('settings.tasks.field_rules', 'Rules')}
${ruleOptions}
${t('settings.tasks.hint', 'Sources + rules choose what to process. Template defines the action pipeline.')}
`;
const enabledSel = body.querySelector('[data-field="task_enabled"]');
if (enabledSel) enabledSel.value = current.enabled ? '1' : '0';
modal.style.display = 'flex';
}
function saveTaskModal(body) {
const name = body.querySelector('[data-field="task_name"]')?.value?.trim() || '';
const enabled = body.querySelector('[data-field="task_enabled"]')?.value === '1';
const sources = Array.from(body.querySelectorAll('[data-field="task_source"]')).filter(x => x.checked).map(x => x.value);
const ruleIds = Array.from(body.querySelectorAll('[data-field="task_rule"]')).filter(x => x.checked).map(x => x.value);
const templateId = body.querySelector('[data-field="task_template"]')?.value || '';
const updated = {
id: state.taskEditId || normalizeTask({}).id,
name,
enabled,
sources,
rule_ids: ruleIds,
template_id: templateId,
};
const idx = state.tasksList.findIndex(t => t.id === updated.id);
if (idx >= 0) {
state.tasksList[idx] = updated;
} else {
state.tasksList.push(updated);
}
renderTasksList();
setDirty(true);
closeRuleModal();
}
function buildTaskSourcesOptions(selected) {
const list = Array.isArray(selected) ? selected : [];
const roots = state.rootsList || [];
const options = [];
const hasMovie = roots.some(r => r.type === 'movie');
const hasSeries = roots.some(r => r.type === 'series');
const hasStaging = roots.some(r => r.type === 'staging');
if (hasMovie) options.push({ value: 'movie', label: t('settings.tasks.source.movie', 'Movies') });
if (hasSeries) options.push({ value: 'series', label: t('settings.tasks.source.series', 'Series') });
if (hasStaging) options.push({ value: 'staging', label: t('settings.tasks.source.staging', 'Staging') });
if (state.pluginConfig?.sources?.transmission) {
options.push({ value: 'transmission', label: t('settings.tasks.source.transmission', 'Transmission') });
}
if (options.length === 0) {
options.push({ value: 'staging', label: t('settings.tasks.source.staging', 'Staging') });
}
return options
.map(opt => {
const isChecked = list.includes(opt.value) ? 'checked' : '';
return `
`;
const enabledSel = body.querySelector('[data-field="template_enabled"]');
if (enabledSel) enabledSel.value = current.enabled ? '1' : '0';
modal.style.display = 'flex';
}
function saveTemplateModal(body) {
const name = body.querySelector('[data-field="template_name"]')?.value?.trim() || '';
const action = body.querySelector('[data-field="template_action"]')?.value?.trim() || '';
const enabled = body.querySelector('[data-field="template_enabled"]')?.value === '1';
const updated = {
id: state.templateEditId || normalizeTemplate({}).id,
name,
action,
enabled,
};
const idx = state.templatesList.findIndex(t => t.id === updated.id);
if (idx >= 0) {
state.templatesList[idx] = updated;
} else {
state.templatesList.push(updated);
}
renderTemplatesList();
setDirty(true);
closeRuleModal();
}
function openToolModal(type) {
const modal = UI.qs('#ruleModal');
const body = UI.qs('#ruleModalBody');
const title = UI.qs('#ruleModalTitle');
if (!modal || !body || !title) return;
state.ruleEditId = null;
state.ruleEditType = null;
state.toolEditType = type;
title.textContent = t('settings.tools.modal_title', 'Tool');
const current = toolPathByType(type);
body.innerHTML = `
`;
}
if (type === 'omdb') {
return `
`;
}
if (type === 'kodi' || type === 'jellyfin') {
const enabled = (type === 'kodi') ? exportsCfg.kodi?.enabled : exportsCfg.jellyfin?.enabled;
return `
${type === 'kodi' ? t('settings.plugins.kodi_hint','Writes movie.nfo / tvshow.nfo near files') : t('settings.plugins.jellyfin_hint','Writes movie.nfo / tvshow.nfo near files')}
`;
}
if (type === 'transmission') {
return `
`;
const typeSel = body.querySelector('[data-field="root_type"]');
const enabledSel = body.querySelector('[data-field="root_enabled"]');
if (typeSel) typeSel.value = data.type;
if (enabledSel) enabledSel.value = data.enabled ? '1' : '0';
modal.style.display = 'flex';
}
function buildPathsPayload() {
const roots = state.rootsList || [];
const movie = roots.find(r => r.type === 'movie' && r.enabled);
const series = roots.find(r => r.type === 'series' && r.enabled);
const staging = roots.find(r => r.type === 'staging' && r.enabled);
return {
movies_root: movie?.path || '',
series_root: series?.path || '',
staging_root: staging?.path || '',
roots,
};
}
async function testRootPath(root) {
const hint = UI.qs('#rootsHint');
if (hint) hint.textContent = t('common.testing', 'Testing…');
try {
const data = await api('/api/tools/test-path', 'POST', { path: root.path, checks: ['exists','read','write','rename'] });
const r = data.results || {};
const txt = `${t('common.exists','exists')}=${r.exists} ${t('common.read','read')}=${r.read} ${t('common.write','write')}=${r.write} ${t('common.rename','rename')}=${r.rename} ${(data.notes || []).join('; ')}`;
if (hint) hint.textContent = txt;
} catch (e) {
if (hint) hint.textContent = `${t('common.error','Error')}: ${e.message}`;
}
}