import React from "react";
import {SettingsContext, StatusContext} from "../../contexts/contexts";
import {checkUpgrade, postRestart, postShutdown, saveSettings as saveSettingsApi, triggerUpgrade} from "../../api";
import {getServices, startService, stopService} from "../../api/controller";
import {Button, Divider, Form, Header, Loader, Modal, Segment} from "../Theme";
import {
ButtonGroup,
Container,
Dimmer,
Dropdown,
FormDropdown,
GridColumn,
GridRow,
Icon,
Input
} from "semantic-ui-react";
import {
APIButton,
ErrorMessage,
HelpHeader,
InfoPopup,
RefreshHeader,
Toggle,
useMessageDismissal,
WROLModeMessage
} from "../Common";
import QRCode from "react-qr-code";
import {useConfigs, useDockerized} from "../../hooks/customHooks";
import {toast} from "react-semantic-toasts-2";
import Grid from "semantic-ui-react/dist/commonjs/collections/Grid";
import {ConfigsTable} from "./Configs";
import {semanticUIColorMap} from "../Vars";
export function ShutdownButton() {
const dockerized = useDockerized();
const handleShutdown = async () => {
try {
const response = await postShutdown();
if (response && response['code'] === 'SHUTDOWN_FAILED') {
toast({
title: 'Shutdown Failed',
description: response['error'],
time: 5000,
type: "error",
})
} else if (response && response['code'] === 'NATIVE_ONLY') {
toast({
title: 'Shutdown Failed',
description: 'Cannot shutdown while running in Docker',
time: 5000,
type: "error",
})
} else if (response !== null) {
toast({
title: 'Shutdown Failed',
description: 'Unknown error when attempting shutdown',
time: 5000,
type: "error",
})
}
} catch (e) {
toast({
title: 'Shutdown Failed',
description: 'Failed to request WROLPi shutdown',
time: 5000,
type: "error",
})
throw e;
}
}
return
Shutdown
}
function UpgradeSegment() {
const {status, fetchStatus} = React.useContext(StatusContext);
const dockerized = useDockerized();
const [upgrading, setUpgrading] = React.useState(false);
const [checking, setChecking] = React.useState(false);
const handleCheckUpgrade = async () => {
setChecking(true);
try {
await checkUpgrade(true); // Force a fresh check
toast({
type: 'info',
title: 'Update Check Complete',
description: 'Checked for updates from git remote.',
time: 3000,
});
} finally {
setChecking(false);
await fetchStatus();
}
};
const handleUpgrade = async () => {
setUpgrading(true);
try {
const response = await triggerUpgrade();
if (response.ok) {
// Redirect to Controller UI for upgrade status
window.location.href = '/controller/?upgrade=true';
}
} catch (e) {
setUpgrading(false);
}
};
// Not available in Docker
if (dockerized) {
return
Upgrades are not available in Docker environments. Please upgrade your Docker images manually.
;
}
// No update available
if (!status?.update_available) {
return
Your WROLPi is up to date.
Version: v{status?.version} on branch {status?.git_branch || 'unknown'}
{checking ? 'Checking...' : 'Check for Upgrades'}
;
}
// Update available
return
Branch: {status?.git_branch}
Current commit: {status?.current_commit}
Latest commit: {status?.latest_commit}
{status?.commits_behind} commit(s) behind
{upgrading ? 'Starting Upgrade...' : 'Upgrade Now'}
;
}
export function RestartButton() {
const dockerized = useDockerized();
const handleRestart = async () => {
try {
const response = await postRestart();
if (response && response['code'] === 'SHUTDOWN_FAILED') {
toast({
title: 'Restart Failed',
description: response['error'],
time: 5000,
type: "error",
})
} else if (response && response['code'] === 'NATIVE_ONLY') {
toast({
title: 'Restart Failed',
description: 'Cannot restart while running in Docker',
time: 5000,
type: "error",
})
} else if (response !== null) {
toast({
title: 'Restart Failed',
description: 'Unknown error when attempting restart',
time: 5000,
type: "error",
})
}
} catch (e) {
toast({
title: 'Restart Failed',
description: 'Failed to request WROLPi restart',
time: 5000,
type: "error",
})
throw e;
}
}
return
Restart
}
const levelNameMap = {
5: 'Trace',
4: 'Debug',
3: 'Info',
2: 'Warning',
1: 'Critical'
}
function logLevelToName(logLevel) {
// Convert app log level to name.
return levelNameMap[logLevel]
}
function fromApiLogLevel(logLevel) {
// Python API uses levels on the left. App uses levels on the right to display direction correctly.
return {
40: 1,
30: 2,
20: 3,
10: 4,
5: 5,
}[logLevel]
}
function toApiLogLevel(logLevel) {
// Reverse the above levels.
return {
5: 5,
4: 10,
3: 20,
2: 30,
1: 40,
}[logLevel]
}
function WROLModeSection() {
const {settings, fetchSettings} = React.useContext(SettingsContext);
const wrolMode = settings?.wrol_mode || false;
const toggleWROLMode = async (checked) => {
try {
await saveSettingsApi({wrol_mode: checked});
await fetchSettings(); // Refresh context immediately
} catch (e) {
toast({
type: 'error',
title: 'Failed to toggle WROL Mode',
description: e.message,
time: 5000,
});
}
};
return (
Enable read-only mode. No content can be deleted or modified.
Enable this when the SHTF and you want to prevent any potential loss of data.
Note: User settings and tags can still be modified.
);
}
export function SettingsPage() {
const [disabled, setDisabled] = React.useState(false);
const [editSpecialDirectories, setEditSpecialDirectories] = React.useState(false);
const [qrCodeValue, setQrCodeValue] = React.useState('');
const [qrOpen, setQrOpen] = React.useState(false);
const [ready, setReady] = React.useState(false);
const [pendingSave, setPendingSave] = React.useState(false);
const {clearAll} = useMessageDismissal();
const dockerized = useDockerized();
// Trace level modal state
const [traceModalOpen, setTraceModalOpen] = React.useState(false);
const [traceCountdown, setTraceCountdown] = React.useState(5);
const [traceSwitching, setTraceSwitching] = React.useState(false);
const [isDevMode, setIsDevMode] = React.useState(false);
// Get current settings from the API.
const {settings, saveSettings, fetchSettings} = React.useContext(SettingsContext);
const {status} = React.useContext(StatusContext);
// Used to track changes to the settings form between saves/loads.
const [state, setState] = React.useState({});
const {configs, loading, importConfig, saveConfig, fetchConfigs} = useConfigs();
React.useEffect(() => {
fetchConfigs();
}, []);
// Check if we're running in dev mode (wrolpi-api-dev service)
React.useEffect(() => {
if (!dockerized) {
const checkDevMode = async () => {
try {
const services = await getServices();
const apiDevService = services.find(s => s.name === 'wrolpi-api-dev');
setIsDevMode(apiDevService?.status === 'running');
} catch (e) {
console.error('Failed to check dev mode status:', e);
}
};
checkDevMode();
}
}, [dockerized]);
const localFetchSettings = async () => {
console.debug('fetching settings...');
try {
await fetchSettings();
console.debug('successfully fetched settings');
} catch (e) {
console.error('failed to fetch settings!');
throw e;
}
}
const localSaveSettings = async (newSettings) => {
// Check if trace level is selected (5 = trace in frontend)
const isTraceLevel = newSettings.log_level === 5;
// In native mode, if trace is selected and not already in dev mode, show confirmation modal
if (isTraceLevel && !dockerized && !isDevMode) {
setTraceModalOpen(true);
return;
}
// Otherwise, save normally
await doSaveSettings(newSettings);
}
const doSaveSettings = async (newSettings) => {
setDisabled(true);
setPendingSave(true);
newSettings.download_timeout = parseInt(newSettings.download_timeout);
newSettings.download_wait = parseInt(newSettings.download_wait);
newSettings.log_level = toApiLogLevel(newSettings.log_level);
try {
await saveSettings(newSettings);
await localFetchSettings();
} finally {
setDisabled(false);
setPendingSave(false);
}
}
const handleTraceModalConfirm = async () => {
setTraceSwitching(true);
setTraceCountdown(5);
// Start countdown
const countdownInterval = setInterval(() => {
setTraceCountdown(prev => {
if (prev <= 1) {
clearInterval(countdownInterval);
return 0;
}
return prev - 1;
});
}, 1000);
// Wait for countdown
await new Promise(resolve => setTimeout(resolve, 5000));
try {
// Save settings first
await doSaveSettings({...state});
// Switch to dev mode: stop wrolpi-api, start wrolpi-api-dev
toast({
type: 'info',
title: 'Switching to Debug Mode',
description: 'Stopping production API and starting debug API...',
time: 3000,
});
await stopService('wrolpi-api');
await startService('wrolpi-api-dev');
toast({
type: 'success',
title: 'Debug Mode Enabled',
description: 'API is now running in debug mode with trace logging enabled.',
time: 5000,
});
setIsDevMode(true);
} catch (e) {
console.error('Failed to switch to dev mode:', e);
toast({
type: 'error',
title: 'Service Switch Failed',
description: `Failed to switch API services: ${e.message}. You may need to manually restart services.`,
time: 10000,
});
} finally {
setTraceSwitching(false);
setTraceModalOpen(false);
setTraceCountdown(5);
}
}
const handleTraceModalCancel = () => {
// Reset log level to previous value and close modal
setState({...state, log_level: fromApiLogLevel(settings.log_level)});
setTraceModalOpen(false);
}
const handleHotspotChange = async () => {
let {hotspot_ssid, hotspot_encryption, hotspot_password} = state;
// Special string which allows a mobile device to connect to a specific Wi-Fi.
setQrCodeValue(`WIFI:S:${hotspot_ssid};T:${hotspot_encryption};P:${hotspot_password};;`);
}
React.useEffect(() => {
console.debug('settings changed, replacing state...');
setReady(settings ? true : undefined);
setState({
// Only these settings can be changed on the SettingsPage.
archive_destination: settings.archive_destination,
download_on_startup: settings.download_on_startup,
download_timeout: settings.download_timeout,
download_wait: settings.download_wait,
download_window_start: settings.download_window_start || '',
download_window_end: settings.download_window_end || '',
timezone: settings.timezone || '',
hotspot_device: settings.hotspot_device,
hotspot_on_startup: settings.hotspot_on_startup,
hotspot_password: settings.hotspot_password,
hotspot_ssid: settings.hotspot_ssid,
check_for_upgrades: settings.check_for_upgrades,
ignore_outdated_zims: settings.ignore_outdated_zims,
log_level: fromApiLogLevel(settings.log_level),
map_destination: settings.map_destination,
nav_color: settings.nav_color,
media_directory: settings.media_directory,
tags_directory: settings.tags_directory,
throttle_on_startup: settings.throttle_on_startup,
videos_destination: settings.videos_destination,
zims_destination: settings.zims_destination,
save_ffprobe_json: settings.save_ffprobe_json,
});
}, [JSON.stringify(settings)]);
React.useEffect(() => {
handleHotspotChange();
}, [state.hotspot_ssid, state.hotspot_password, state.hotspot_device]);
const handleInputChange = async (e, name, value) => {
if (e) {
e.preventDefault()
}
setState({...state, [name]: value});
}
const handleTimeoutChange = async (e, name, value) => {
if (e) {
e.preventDefault()
}
// Restrict timeout to numbers.
value = value.replace(/[^\d]/, '');
setState({...state, [name]: value});
}
const handleQrOpen = async (e) => {
e.preventDefault();
setQrOpen(true);
}
const qrButton =
;
const timezoneOptions = Intl.supportedValuesOf('timeZone').map(tz => (
{key: tz, value: tz, text: tz}
));
const navColorOptions = Object.keys(semanticUIColorMap).map(i => {
return {key: i, value: i, text: i.charAt(0).toUpperCase() + i.slice(1)}
});
const mediaDirectoryLabel = `${settings.media_directory}/`;
let body;
if (ready === true) {
// Settings have been fetched, display form.
body = <>
Any changes will be written to {settings.media_directory}/config/wrolpi.yaml .
Wait Between Downloads
>}
value={state.download_wait}
disabled={disabled || state.download_wait === null}
onChange={(e, i) => handleTimeoutChange(e, 'download_wait', i.value)}
/>
Download Timeout
>}
value={state.download_timeout}
disabled={disabled || state.download_timeout === null}
onChange={(e, i) => handleTimeoutChange(e, 'download_timeout', i.value)}
/>
Download Window Start
>}
type='time'
value={state.download_window_start}
disabled={disabled}
onChange={(e, i) => handleInputChange(e, 'download_window_start', i.value)}
/>
Download Window End
>}
type='time'
value={state.download_window_end}
disabled={disabled}
onChange={(e, i) => handleInputChange(e, 'download_window_end', i.value)}
/>
Timezone
setState({...state, timezone: value || ''})}
/>
{status && status.local_time &&
Current local time: {status.local_time.slice(0, 16).replace('T', ' ')}
}
WROLPi will save files to these directories (any video files will be saved to
the videos by default, etc.).
Archive Directory
Variables:
%(domain)s - Domain name (e.g., "example.com")
%(domain_tag)s - Tag name for the domain (empty if no
tag)
%(tag)s - Alias for the tag name
%(name)s - Alias for the domain name
>}
position='top left'
/>
handleInputChange(e, 'archive_destination', d.value)}
/>
Videos Directory
Variables:
%(channel_name)s - Channel name
%(channel_tag)s - Tag name for the channel (empty if no
tag)
%(channel_domain)s - Domain from the channel URL
%(tag)s - Alias for the tag name
%(name)s - Alias for the channel name
>}
position='top left'
/>
handleInputChange(e, 'videos_destination', d.value)}
/>
Map Directory
handleInputChange(e, 'map_destination', d.value)}
/>
Zims Directory
handleInputChange(e, 'zims_destination', d.value)}
/>
setEditSpecialDirectories(checked)}
/>
localSaveSettings(state)}
obeyWROLMode={true}
disabled={disabled}
>Save
>
} else if (ready === false) {
body =
} else {
body = Unable to fetch settings
}
const configsSegment =
These configs control this WROLPi; they are the source of truth. Any changes to configs will be applied to
the database when imported (typically at startup).
Install the WROLPi Root CA certificate on your devices to trust all HTTPS connections to this WROLPi.
You only need to do this once per device.
Download Root CA Certificate
;
return
{body}
{configsSegment}
Show All Hints
{/* Trace Level Modal - shown when user selects trace level in native mode */}
!traceSwitching && handleTraceModalCancel()}
size='small'
>
Enable Debug Mode for Trace Logging
{traceSwitching ? (
<>
{traceCountdown > 0
? `Switching to debug mode in ${traceCountdown} seconds...`
: 'Switching API services...'}
The API will restart. This page may temporarily lose connection.
>
) : (
<>
Trace logging requires running the API in debug mode, which has slightly reduced
performance (2 workers instead of 5).
This will save your settings and restart the API service. The page may temporarily
lose connection during the switch.
You can switch back to production mode later from the Controller page.
>
)}
Cancel
Enable Debug Mode
;
}