OE6DXD
d8d1b891fd
Place a dedicated Logout button at the top of the Benutzer-Einstellungen page and wire it to the existing logout flow. Keep button state in sync with login status like the header menu logout action.
4895 lines
162 KiB
JavaScript
4895 lines
162 KiB
JavaScript
const OPENWEBRX_TX_POLL_MS_DEFAULT = 3000;
|
|
const SWR_EXPECTED_DURATION_SEC_DEFAULT = 40;
|
|
const SWR_DETAIL_REFRESH_MS = 20000;
|
|
const DEFAULT_UI_LANGUAGE = "de";
|
|
const SUPPORTED_UI_LANGUAGES = ["de", "en"];
|
|
const LANGUAGE_STORAGE_KEY = "rms-lang";
|
|
|
|
let activationWatchTimer = null;
|
|
let activationWatchInFlight = false;
|
|
let activationPending = false;
|
|
let remainingUsageTimer = null;
|
|
let resumeRefreshInFlight = false;
|
|
|
|
const state = {
|
|
user: null,
|
|
status: null,
|
|
system: {
|
|
maintenanceMode: false,
|
|
maintenanceMessage: "",
|
|
updatedAt: null,
|
|
branding: {
|
|
logoLightUrl: null,
|
|
logoDarkUrl: null
|
|
}
|
|
},
|
|
accessToken: localStorage.getItem("rms-access-token") || "",
|
|
refreshToken: localStorage.getItem("rms-refresh-token") || "",
|
|
controls: [],
|
|
plugins: [],
|
|
providers: {},
|
|
capabilities: [],
|
|
authMethods: [],
|
|
users: [],
|
|
helpContent: null,
|
|
swrReport: null,
|
|
activityEntries: [],
|
|
activityFilter: {
|
|
query: "",
|
|
type: "all"
|
|
},
|
|
approvals: [],
|
|
approvalsFilter: {
|
|
mode: "open",
|
|
query: "",
|
|
status: "all"
|
|
},
|
|
usersFilter: {
|
|
query: "",
|
|
role: "all",
|
|
status: "all"
|
|
},
|
|
openWebRx: {
|
|
sessionUrl: "",
|
|
sessionTicket: "",
|
|
expiresAt: null,
|
|
bands: [],
|
|
selectedBand: "",
|
|
txActive: null,
|
|
powerCommandConfigured: true,
|
|
pttCommandConfigured: true,
|
|
rotor: {
|
|
azimuth: null,
|
|
rawAzimuth: null,
|
|
moving: false,
|
|
stale: false,
|
|
updatedAt: null,
|
|
min: 0,
|
|
max: 360
|
|
},
|
|
busy: false,
|
|
pollMs: OPENWEBRX_TX_POLL_MS_DEFAULT,
|
|
pttPressed: false
|
|
},
|
|
i18n: {
|
|
language: localStorage.getItem(LANGUAGE_STORAGE_KEY) || DEFAULT_UI_LANGUAGE,
|
|
dictionaries: {}
|
|
}
|
|
};
|
|
|
|
const els = {
|
|
authForm: document.getElementById("authForm"),
|
|
email: document.getElementById("email"),
|
|
loginBtn: document.getElementById("loginBtn"),
|
|
authMethodSelect: document.getElementById("authMethodSelect"),
|
|
otpWrap: document.getElementById("otpWrap"),
|
|
otpCode: document.getElementById("otpCode"),
|
|
verifyOtpBtn: document.getElementById("verifyOtpBtn"),
|
|
authMessage: document.getElementById("authMessage"),
|
|
brandLogo: document.getElementById("brandLogo"),
|
|
brandFallback: document.getElementById("brandFallback"),
|
|
maintenanceBanner: document.getElementById("maintenanceBanner"),
|
|
stationName: document.getElementById("stationName"),
|
|
usageStatus: document.getElementById("usageStatus"),
|
|
activeBy: document.getElementById("activeBy"),
|
|
startedAt: document.getElementById("startedAt"),
|
|
endsAt: document.getElementById("endsAt"),
|
|
remainingUsage: document.getElementById("remainingUsage"),
|
|
stationOnlinePill: document.getElementById("stationOnlinePill"),
|
|
activateBtn: document.getElementById("activateBtn"),
|
|
deactivateBtn: document.getElementById("deactivateBtn"),
|
|
refreshBtn: document.getElementById("refreshBtn"),
|
|
reservationPanel: document.getElementById("reservationPanel"),
|
|
reserveNextBtn: document.getElementById("reserveNextBtn"),
|
|
reservationList: document.getElementById("reservationList"),
|
|
reservationMessage: document.getElementById("reservationMessage"),
|
|
logoutBtn: document.getElementById("logoutBtn"),
|
|
settingsLogoutTopBtn: document.getElementById("settingsLogoutTopBtn"),
|
|
activationProgress: document.getElementById("activationProgress"),
|
|
progressText: document.getElementById("progressText"),
|
|
progressFill: document.getElementById("progressFill"),
|
|
progressEta: document.getElementById("progressEta"),
|
|
activationProgressSwr: document.getElementById("activationProgressSwr"),
|
|
progressTextSwr: document.getElementById("progressTextSwr"),
|
|
progressFillSwr: document.getElementById("progressFillSwr"),
|
|
progressEtaSwr: document.getElementById("progressEtaSwr"),
|
|
stationLinks: document.getElementById("stationLinks"),
|
|
swrLink: document.getElementById("swrLink"),
|
|
openwebrxLink: document.getElementById("openwebrxLink"),
|
|
websdrLink: document.getElementById("websdrLink"),
|
|
rotorLink: document.getElementById("rotorLink"),
|
|
openwebrxPanel: document.getElementById("openwebrxPanel"),
|
|
controlsPanel: document.getElementById("controlsPanel"),
|
|
openwebrxOpenBtn: document.getElementById("openwebrxOpenBtn"),
|
|
openwebrxBandSelect: document.getElementById("openwebrxBandSelect"),
|
|
openwebrxBandSetBtn: document.getElementById("openwebrxBandSetBtn"),
|
|
openwebrxEnableTxBtn: document.getElementById("openwebrxEnableTxBtn"),
|
|
openwebrxCloseBtn: document.getElementById("openwebrxCloseBtn"),
|
|
openwebrxMessage: document.getElementById("openwebrxMessage"),
|
|
openwebrxSessionAccess: document.getElementById("openwebrxSessionAccess"),
|
|
openwebrxSessionLink: document.getElementById("openwebrxSessionLink"),
|
|
openwebrxCopyLinkBtn: document.getElementById("openwebrxCopyLinkBtn"),
|
|
openwebrxSessionTicket: document.getElementById("openwebrxSessionTicket"),
|
|
openwebrxTxStatePill: document.getElementById("openwebrxTxStatePill"),
|
|
rotorCurrent: document.getElementById("rotorCurrent"),
|
|
rotorCompass: document.getElementById("rotorCompass"),
|
|
rotorCompassArrow: document.getElementById("rotorCompassArrow"),
|
|
rotorTarget: document.getElementById("rotorTarget"),
|
|
rotorSetBtn: document.getElementById("rotorSetBtn"),
|
|
rotorPresets: document.getElementById("rotorPresets"),
|
|
controlsMessage: document.getElementById("controlsMessage"),
|
|
statusMessage: document.getElementById("statusMessage"),
|
|
swrSummaryGeneratedAt: document.getElementById("swrSummaryGeneratedAt"),
|
|
swrSummaryOverall: document.getElementById("swrSummaryOverall"),
|
|
swrSummaryBands: document.getElementById("swrSummaryBands"),
|
|
swrSummaryMessage: document.getElementById("swrSummaryMessage"),
|
|
refreshSwrBtn: document.getElementById("refreshSwrBtn"),
|
|
runSwrCheckBtn: document.getElementById("runSwrCheckBtn"),
|
|
swrPageGeneratedAt: document.getElementById("swrPageGeneratedAt"),
|
|
swrPageOverall: document.getElementById("swrPageOverall"),
|
|
swrPageBands: document.getElementById("swrPageBands"),
|
|
swrPageMessage: document.getElementById("swrPageMessage"),
|
|
refreshSwrPageBtn: document.getElementById("refreshSwrPageBtn"),
|
|
runSwrCheckPageBtn: document.getElementById("runSwrCheckPageBtn"),
|
|
themeToggle: document.getElementById("themeToggle"),
|
|
authView: document.getElementById("authView"),
|
|
rmsView: document.getElementById("rmsView"),
|
|
pageRms: document.getElementById("pageRms"),
|
|
pageSwr: document.getElementById("pageSwr"),
|
|
pageUser: document.getElementById("pageUser"),
|
|
pageHelp: document.getElementById("pageHelp"),
|
|
pagePlugins: document.getElementById("pagePlugins"),
|
|
pagePluginConfig: document.getElementById("pagePluginConfig"),
|
|
pageProviders: document.getElementById("pageProviders"),
|
|
pageAdmin: document.getElementById("pageAdmin"),
|
|
pageUsers: document.getElementById("pageUsers"),
|
|
pageApprovals: document.getElementById("pageApprovals"),
|
|
pageActivity: document.getElementById("pageActivity"),
|
|
userMenuButton: document.getElementById("userMenuButton"),
|
|
userMenu: document.getElementById("userMenu"),
|
|
menuRms: document.getElementById("menuRms"),
|
|
menuSwr: document.getElementById("menuSwr"),
|
|
menuUser: document.getElementById("menuUser"),
|
|
menuHelp: document.getElementById("menuHelp"),
|
|
menuPlugins: document.getElementById("menuPlugins"),
|
|
menuPluginConfig: document.getElementById("menuPluginConfig"),
|
|
menuProviders: document.getElementById("menuProviders"),
|
|
menuUsers: document.getElementById("menuUsers"),
|
|
menuApprovals: document.getElementById("menuApprovals"),
|
|
menuActivity: document.getElementById("menuActivity"),
|
|
menuAdmin: document.getElementById("menuAdmin"),
|
|
languageMenuButton: document.getElementById("languageMenuButton"),
|
|
languageMenu: document.getElementById("languageMenu"),
|
|
menuLanguageSelect: document.getElementById("menuLanguageSelect"),
|
|
settingsEmail: document.getElementById("settingsEmail"),
|
|
settingsRole: document.getElementById("settingsRole"),
|
|
settingsAuthMethodSelect: document.getElementById("settingsAuthMethodSelect"),
|
|
settingsLanguageSelect: document.getElementById("settingsLanguageSelect"),
|
|
settingsSaveAuthMethodBtn: document.getElementById("settingsSaveAuthMethodBtn"),
|
|
settingsSaveLanguageBtn: document.getElementById("settingsSaveLanguageBtn"),
|
|
settingsThemeBtn: document.getElementById("settingsThemeBtn"),
|
|
settingsRefreshBtn: document.getElementById("settingsRefreshBtn"),
|
|
pageTitle: document.getElementById("pageTitle"),
|
|
pageHint: document.getElementById("pageHint"),
|
|
pageCrumb: document.getElementById("pageCrumb"),
|
|
currentUserLink: document.getElementById("currentUserLink"),
|
|
mobileNav: document.getElementById("mobileNav"),
|
|
mobileNavRms: document.getElementById("mobileNavRms"),
|
|
mobileNavSwr: document.getElementById("mobileNavSwr"),
|
|
mobileNavUser: document.getElementById("mobileNavUser"),
|
|
mobileNavHelp: document.getElementById("mobileNavHelp"),
|
|
mobileNavPlugins: document.getElementById("mobileNavPlugins"),
|
|
mobileNavPluginConfig: document.getElementById("mobileNavPluginConfig"),
|
|
mobileNavUsers: document.getElementById("mobileNavUsers"),
|
|
mobileNavApprovals: document.getElementById("mobileNavApprovals"),
|
|
mobileNavActivity: document.getElementById("mobileNavActivity"),
|
|
mobileNavAdmin: document.getElementById("mobileNavAdmin"),
|
|
adminCard: document.getElementById("adminCard"),
|
|
setOnlineBtn: document.getElementById("setOnlineBtn"),
|
|
setOfflineBtn: document.getElementById("setOfflineBtn"),
|
|
forceReleaseBtn: document.getElementById("forceReleaseBtn"),
|
|
refreshAuditBtn: document.getElementById("refreshAuditBtn"),
|
|
roleEmail: document.getElementById("roleEmail"),
|
|
setRoleAdminBtn: document.getElementById("setRoleAdminBtn"),
|
|
setRoleOperatorBtn: document.getElementById("setRoleOperatorBtn"),
|
|
adminMessage: document.getElementById("adminMessage"),
|
|
auditLog: document.getElementById("auditLog"),
|
|
pluginControls: document.getElementById("pluginControls"),
|
|
pluginMessage: document.getElementById("pluginMessage"),
|
|
pluginsConfigCard: document.getElementById("pluginsConfigCard"),
|
|
pluginsAdminConfig: document.getElementById("pluginsAdminConfig"),
|
|
refreshPluginsPageBtn: document.getElementById("refreshPluginsPageBtn"),
|
|
providersCapabilityMatrix: document.getElementById("providersCapabilityMatrix"),
|
|
providersAdminConfig: document.getElementById("providersAdminConfig"),
|
|
providersMessage: document.getElementById("providersMessage"),
|
|
refreshProvidersBtn: document.getElementById("refreshProvidersBtn"),
|
|
usersAdmin: document.getElementById("usersAdmin"),
|
|
usersMessage: document.getElementById("usersMessage"),
|
|
usersFilterQuery: document.getElementById("usersFilterQuery"),
|
|
usersFilterRole: document.getElementById("usersFilterRole"),
|
|
usersFilterStatus: document.getElementById("usersFilterStatus"),
|
|
refreshUsersBtn: document.getElementById("refreshUsersBtn"),
|
|
approvalsList: document.getElementById("approvalsList"),
|
|
approvalsMessage: document.getElementById("approvalsMessage"),
|
|
approvalsFilterQuery: document.getElementById("approvalsFilterQuery"),
|
|
approvalsFilterStatus: document.getElementById("approvalsFilterStatus"),
|
|
approvalsFilterOpenBtn: document.getElementById("approvalsFilterOpenBtn"),
|
|
approvalsFilterAllBtn: document.getElementById("approvalsFilterAllBtn"),
|
|
refreshApprovalsBtn: document.getElementById("refreshApprovalsBtn"),
|
|
activityLogList: document.getElementById("activityLogList"),
|
|
activityMessage: document.getElementById("activityMessage"),
|
|
activityFilterQuery: document.getElementById("activityFilterQuery"),
|
|
activityFilterType: document.getElementById("activityFilterType"),
|
|
refreshActivityBtn: document.getElementById("refreshActivityBtn"),
|
|
helpTitle: document.getElementById("helpTitle"),
|
|
helpQuickStartTitle: document.getElementById("helpQuickStartTitle"),
|
|
helpQuickStartSteps: document.getElementById("helpQuickStartSteps"),
|
|
helpSections: document.getElementById("helpSections"),
|
|
helpMessage: document.getElementById("helpMessage"),
|
|
refreshHelpBtn: document.getElementById("refreshHelpBtn"),
|
|
maintenanceStatePill: document.getElementById("maintenanceStatePill"),
|
|
maintenanceMessageInput: document.getElementById("maintenanceMessageInput"),
|
|
maintenanceEnableBtn: document.getElementById("maintenanceEnableBtn"),
|
|
maintenanceDisableBtn: document.getElementById("maintenanceDisableBtn"),
|
|
logoLightFile: document.getElementById("logoLightFile"),
|
|
logoDarkFile: document.getElementById("logoDarkFile"),
|
|
uploadLogoLightBtn: document.getElementById("uploadLogoLightBtn"),
|
|
uploadLogoDarkBtn: document.getElementById("uploadLogoDarkBtn"),
|
|
removeLogoLightBtn: document.getElementById("removeLogoLightBtn"),
|
|
removeLogoDarkBtn: document.getElementById("removeLogoDarkBtn")
|
|
};
|
|
|
|
init().catch((error) => {
|
|
renderMessage(els.authMessage, error.message || "Initialisierung fehlgeschlagen", true);
|
|
});
|
|
|
|
async function init() {
|
|
await initI18n();
|
|
loadTheme();
|
|
hydrateFilterStateFromUrl();
|
|
bindEvents();
|
|
await refreshPublicSystemStatus();
|
|
await refreshPublicAuthMethods();
|
|
await handleEmailTokenFromUrl();
|
|
await refreshCurrentUser();
|
|
await ensureLanguageFromUserPreference();
|
|
applyRoute(true);
|
|
if (state.user) {
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
await refreshControls();
|
|
await refreshPlugins();
|
|
await refreshUsers();
|
|
await refreshApprovals();
|
|
await refreshActivityLog();
|
|
await refreshHelpContent();
|
|
connectEvents();
|
|
}
|
|
|
|
setInterval(() => {
|
|
if (!state.user) {
|
|
refreshPublicSystemStatus().catch(() => {});
|
|
return;
|
|
}
|
|
const route = currentRoute();
|
|
if (route === "/rms/swr" || route === "/rms") {
|
|
refreshStatus().catch(() => {});
|
|
}
|
|
}, SWR_DETAIL_REFRESH_MS);
|
|
}
|
|
|
|
async function initI18n() {
|
|
const initial = normalizeLanguage(state.i18n.language);
|
|
state.i18n.language = initial;
|
|
await ensureLanguageDictionary("de");
|
|
if (initial !== "de") {
|
|
await ensureLanguageDictionary(initial);
|
|
}
|
|
applyI18n();
|
|
}
|
|
|
|
function normalizeLanguage(value) {
|
|
const next = String(value || "").trim().toLowerCase();
|
|
return SUPPORTED_UI_LANGUAGES.includes(next) ? next : DEFAULT_UI_LANGUAGE;
|
|
}
|
|
|
|
async function ensureLanguageDictionary(language) {
|
|
const normalized = normalizeLanguage(language);
|
|
if (state.i18n.dictionaries[normalized]) {
|
|
return state.i18n.dictionaries[normalized];
|
|
}
|
|
try {
|
|
const response = await fetch(`/i18n/${encodeURIComponent(normalized)}.json`, { cache: "no-store" });
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to load language ${normalized}`);
|
|
}
|
|
const parsed = await response.json();
|
|
state.i18n.dictionaries[normalized] = parsed && typeof parsed === "object" ? parsed : {};
|
|
} catch {
|
|
state.i18n.dictionaries[normalized] = {};
|
|
}
|
|
return state.i18n.dictionaries[normalized];
|
|
}
|
|
|
|
function languageDictionary(language) {
|
|
return state.i18n.dictionaries[normalizeLanguage(language)] || {};
|
|
}
|
|
|
|
function translateLiteral(text) {
|
|
const source = String(text || "");
|
|
if (!source) {
|
|
return source;
|
|
}
|
|
const current = languageDictionary(state.i18n.language);
|
|
const currentLiterals = current && current.literals && typeof current.literals === "object" ? current.literals : {};
|
|
if (Object.prototype.hasOwnProperty.call(currentLiterals, source)) {
|
|
return String(currentLiterals[source]);
|
|
}
|
|
const de = languageDictionary("de");
|
|
const deLiterals = de && de.literals && typeof de.literals === "object" ? de.literals : {};
|
|
if (Object.prototype.hasOwnProperty.call(deLiterals, source)) {
|
|
return String(deLiterals[source]);
|
|
}
|
|
return source;
|
|
}
|
|
|
|
const originalTextNodes = new WeakMap();
|
|
const originalElementAttributes = new WeakMap();
|
|
|
|
function applyI18n(root = document.body) {
|
|
if (!root) {
|
|
return;
|
|
}
|
|
const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
|
|
acceptNode(node) {
|
|
if (!node || !node.nodeValue || !node.nodeValue.trim()) {
|
|
return NodeFilter.FILTER_REJECT;
|
|
}
|
|
const parent = node.parentElement;
|
|
if (!parent) {
|
|
return NodeFilter.FILTER_REJECT;
|
|
}
|
|
if (["SCRIPT", "STYLE", "CODE", "PRE"].includes(parent.tagName)) {
|
|
return NodeFilter.FILTER_REJECT;
|
|
}
|
|
return NodeFilter.FILTER_ACCEPT;
|
|
}
|
|
});
|
|
const textNodes = [];
|
|
let node = walker.nextNode();
|
|
while (node) {
|
|
textNodes.push(node);
|
|
node = walker.nextNode();
|
|
}
|
|
for (const textNode of textNodes) {
|
|
const original = originalTextNodes.has(textNode)
|
|
? originalTextNodes.get(textNode)
|
|
: String(textNode.nodeValue);
|
|
if (!originalTextNodes.has(textNode)) {
|
|
originalTextNodes.set(textNode, original);
|
|
}
|
|
const leading = original.match(/^\s*/)?.[0] || "";
|
|
const trailing = original.match(/\s*$/)?.[0] || "";
|
|
const trimmed = original.trim();
|
|
textNode.nodeValue = trimmed ? `${leading}${translateLiteral(trimmed)}${trailing}` : original;
|
|
}
|
|
const attrNames = ["placeholder", "title", "aria-label"];
|
|
const elements = root.querySelectorAll("*");
|
|
for (const el of elements) {
|
|
if (!originalElementAttributes.has(el)) {
|
|
originalElementAttributes.set(el, {});
|
|
}
|
|
const originalAttrs = originalElementAttributes.get(el);
|
|
for (const attr of attrNames) {
|
|
const value = el.getAttribute(attr);
|
|
if (!value) {
|
|
continue;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(originalAttrs, attr)) {
|
|
originalAttrs[attr] = value;
|
|
}
|
|
el.setAttribute(attr, translateLiteral(originalAttrs[attr]));
|
|
}
|
|
}
|
|
renderLanguageSelectors();
|
|
}
|
|
|
|
function localeForDate() {
|
|
return state.i18n.language === "en" ? "en-GB" : "de-AT";
|
|
}
|
|
|
|
async function setLanguage(language, options = {}) {
|
|
const normalized = normalizeLanguage(language);
|
|
await ensureLanguageDictionary(normalized);
|
|
state.i18n.language = normalized;
|
|
if (options.persist !== false) {
|
|
localStorage.setItem(LANGUAGE_STORAGE_KEY, normalized);
|
|
}
|
|
applyI18n();
|
|
renderStatus();
|
|
renderSwrPanels();
|
|
renderHelpContent();
|
|
if (options.saveUserDefault) {
|
|
await savePreferredLanguage();
|
|
}
|
|
}
|
|
|
|
async function ensureLanguageFromUserPreference() {
|
|
if (!state.user || !state.user.preferredLanguage) {
|
|
return;
|
|
}
|
|
const preferred = normalizeLanguage(state.user.preferredLanguage);
|
|
if (preferred === normalizeLanguage(state.i18n.language)) {
|
|
renderLanguageSelectors();
|
|
return;
|
|
}
|
|
await setLanguage(preferred, { persist: true, saveUserDefault: false });
|
|
}
|
|
|
|
function renderLanguageSelectors() {
|
|
const dictionary = languageDictionary(state.i18n.language);
|
|
const locales = dictionary && dictionary.locales && typeof dictionary.locales === "object"
|
|
? dictionary.locales
|
|
: { de: "Deutsch", en: "English" };
|
|
const options = SUPPORTED_UI_LANGUAGES.map((lang) => ({
|
|
value: lang,
|
|
label: locales[lang] || lang.toUpperCase()
|
|
}));
|
|
for (const select of [els.menuLanguageSelect, els.settingsLanguageSelect]) {
|
|
if (!select) {
|
|
continue;
|
|
}
|
|
const currentValue = select.value;
|
|
select.innerHTML = "";
|
|
for (const optionData of options) {
|
|
const option = document.createElement("option");
|
|
option.value = optionData.value;
|
|
option.textContent = optionData.label;
|
|
select.appendChild(option);
|
|
}
|
|
select.value = normalizeLanguage(state.i18n.language || currentValue || DEFAULT_UI_LANGUAGE);
|
|
}
|
|
}
|
|
|
|
function bindEvents() {
|
|
const on = (el, event, handler) => {
|
|
if (el) {
|
|
el.addEventListener(event, handler);
|
|
}
|
|
};
|
|
|
|
els.authForm.addEventListener("submit", async (event) => {
|
|
event.preventDefault();
|
|
await requestAccess();
|
|
});
|
|
|
|
els.activateBtn.addEventListener("click", async () => {
|
|
await activateStation();
|
|
});
|
|
|
|
els.deactivateBtn.addEventListener("click", async () => {
|
|
await releaseStation();
|
|
});
|
|
|
|
els.refreshBtn.addEventListener("click", async () => {
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
await refreshControls();
|
|
});
|
|
|
|
if (els.reserveNextBtn) {
|
|
els.reserveNextBtn.addEventListener("click", async () => {
|
|
await reserveNextSlot();
|
|
});
|
|
}
|
|
|
|
els.logoutBtn.addEventListener("click", async () => {
|
|
await logout();
|
|
});
|
|
if (els.settingsLogoutTopBtn) {
|
|
els.settingsLogoutTopBtn.addEventListener("click", async () => {
|
|
await logout();
|
|
});
|
|
}
|
|
|
|
els.themeToggle.addEventListener("click", () => {
|
|
toggleTheme();
|
|
});
|
|
|
|
els.settingsThemeBtn.addEventListener("click", () => {
|
|
toggleTheme();
|
|
});
|
|
|
|
if (els.settingsSaveAuthMethodBtn) {
|
|
els.settingsSaveAuthMethodBtn.addEventListener("click", async () => {
|
|
await savePreferredAuthMethod();
|
|
});
|
|
}
|
|
|
|
if (els.settingsSaveLanguageBtn) {
|
|
els.settingsSaveLanguageBtn.addEventListener("click", async () => {
|
|
await savePreferredLanguage();
|
|
});
|
|
}
|
|
|
|
if (els.menuLanguageSelect) {
|
|
els.menuLanguageSelect.addEventListener("change", async () => {
|
|
await setLanguage(els.menuLanguageSelect.value, { persist: true, saveUserDefault: false });
|
|
setLanguageMenuOpen(false);
|
|
});
|
|
}
|
|
|
|
if (els.settingsLanguageSelect) {
|
|
els.settingsLanguageSelect.addEventListener("change", async () => {
|
|
await setLanguage(els.settingsLanguageSelect.value, { persist: true, saveUserDefault: false });
|
|
});
|
|
}
|
|
|
|
els.settingsRefreshBtn.addEventListener("click", async () => {
|
|
await refreshPublicSystemStatus();
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
await refreshControls();
|
|
if (isAdmin()) {
|
|
await refreshPlugins();
|
|
await refreshUsers();
|
|
}
|
|
if (canSeeApprovals()) {
|
|
await refreshApprovals();
|
|
}
|
|
if (canSeeActivityLog()) {
|
|
await refreshActivityLog();
|
|
}
|
|
await refreshHelpContent();
|
|
});
|
|
|
|
els.userMenuButton.addEventListener("click", (event) => {
|
|
if (!state.user) {
|
|
return;
|
|
}
|
|
event.stopPropagation();
|
|
setLanguageMenuOpen(false);
|
|
setUserMenuOpen(els.userMenu.hidden);
|
|
});
|
|
if (els.languageMenuButton) {
|
|
els.languageMenuButton.addEventListener("click", (event) => {
|
|
event.stopPropagation();
|
|
setUserMenuOpen(false);
|
|
setLanguageMenuOpen(els.languageMenu ? els.languageMenu.hidden : false);
|
|
});
|
|
}
|
|
if (els.languageMenu) {
|
|
els.languageMenu.addEventListener("click", (event) => {
|
|
event.stopPropagation();
|
|
});
|
|
}
|
|
on(els.menuRms, "click", () => navigateRmsPage("rms"));
|
|
on(els.menuSwr, "click", () => navigateRmsPage("swr"));
|
|
on(els.menuUser, "click", () => navigateRmsPage("user"));
|
|
on(els.menuHelp, "click", () => navigateRmsPage("help"));
|
|
on(els.menuPlugins, "click", () => navigateRmsPage("plugins"));
|
|
on(els.menuPluginConfig, "click", () => navigateRmsPage("plugin-config"));
|
|
on(els.menuProviders, "click", () => navigateRmsPage("providers"));
|
|
on(els.menuUsers, "click", () => navigateRmsPage("users"));
|
|
on(els.menuApprovals, "click", () => navigateRmsPage("approvals"));
|
|
on(els.menuActivity, "click", () => navigateRmsPage("activity"));
|
|
on(els.menuAdmin, "click", () => navigateRmsPage("admin"));
|
|
on(els.mobileNavRms, "click", () => navigateRmsPage("rms"));
|
|
on(els.mobileNavSwr, "click", () => navigateRmsPage("swr"));
|
|
on(els.mobileNavUser, "click", () => navigateRmsPage("user"));
|
|
on(els.mobileNavHelp, "click", () => navigateRmsPage("help"));
|
|
on(els.mobileNavPlugins, "click", () => navigateRmsPage("plugins"));
|
|
on(els.mobileNavPluginConfig, "click", () => navigateRmsPage("plugin-config"));
|
|
on(els.mobileNavUsers, "click", () => navigateRmsPage("users"));
|
|
on(els.mobileNavApprovals, "click", () => navigateRmsPage("approvals"));
|
|
on(els.mobileNavActivity, "click", () => navigateRmsPage("activity"));
|
|
on(els.mobileNavAdmin, "click", () => navigateRmsPage("admin"));
|
|
if (els.currentUserLink) {
|
|
els.currentUserLink.addEventListener("click", (event) => {
|
|
event.preventDefault();
|
|
navigateRmsPage("user");
|
|
});
|
|
}
|
|
document.addEventListener("click", () => {
|
|
setUserMenuOpen(false);
|
|
setLanguageMenuOpen(false);
|
|
});
|
|
document.addEventListener("keydown", (event) => {
|
|
if (event.key === "Escape") {
|
|
setUserMenuOpen(false);
|
|
setLanguageMenuOpen(false);
|
|
}
|
|
});
|
|
|
|
window.addEventListener("popstate", () => {
|
|
hydrateFilterStateFromUrl();
|
|
applyRoute(true);
|
|
});
|
|
|
|
window.addEventListener("pageshow", () => {
|
|
void refreshFrontendOnResume();
|
|
});
|
|
document.addEventListener("visibilitychange", () => {
|
|
if (!document.hidden) {
|
|
void refreshFrontendOnResume();
|
|
}
|
|
});
|
|
|
|
if (els.refreshProvidersBtn) {
|
|
els.refreshProvidersBtn.addEventListener("click", async () => {
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
});
|
|
}
|
|
if (els.refreshSwrBtn) {
|
|
els.refreshSwrBtn.addEventListener("click", async () => {
|
|
await refreshSwrReport();
|
|
});
|
|
}
|
|
if (els.refreshSwrPageBtn) {
|
|
els.refreshSwrPageBtn.addEventListener("click", async () => {
|
|
await refreshSwrReport();
|
|
});
|
|
}
|
|
if (els.runSwrCheckBtn) {
|
|
els.runSwrCheckBtn.addEventListener("click", async () => {
|
|
await runManualSwrCheck();
|
|
});
|
|
}
|
|
if (els.runSwrCheckPageBtn) {
|
|
els.runSwrCheckPageBtn.addEventListener("click", async () => {
|
|
await runManualSwrCheck();
|
|
});
|
|
}
|
|
if (els.openwebrxOpenBtn) {
|
|
els.openwebrxOpenBtn.addEventListener("click", async () => {
|
|
await openOpenWebRxSession();
|
|
});
|
|
}
|
|
if (els.openwebrxLink) {
|
|
els.openwebrxLink.addEventListener("click", async (event) => {
|
|
event.preventDefault();
|
|
await openOpenWebRxExternal();
|
|
});
|
|
}
|
|
if (els.openwebrxCopyLinkBtn) {
|
|
els.openwebrxCopyLinkBtn.addEventListener("click", async () => {
|
|
await copyOpenWebRxLink();
|
|
});
|
|
}
|
|
if (els.openwebrxEnableTxBtn) {
|
|
els.openwebrxEnableTxBtn.addEventListener("click", async (event) => {
|
|
if (event) {
|
|
event.preventDefault();
|
|
}
|
|
await toggleOpenWebRxTxPower();
|
|
});
|
|
}
|
|
if (els.rotorSetBtn) {
|
|
els.rotorSetBtn.addEventListener("click", async () => {
|
|
await setOpenWebRxRotor();
|
|
});
|
|
}
|
|
if (els.rotorPresets) {
|
|
els.rotorPresets.addEventListener("click", async (event) => {
|
|
const target = event && event.target ? event.target.closest("button[data-azimuth]") : null;
|
|
if (!target || !els.rotorTarget) {
|
|
return;
|
|
}
|
|
const azimuth = Number(target.getAttribute("data-azimuth"));
|
|
if (!Number.isFinite(azimuth)) {
|
|
return;
|
|
}
|
|
els.rotorTarget.value = String(Math.round(azimuth));
|
|
await setOpenWebRxRotor();
|
|
});
|
|
}
|
|
if (els.openwebrxBandSetBtn) {
|
|
els.openwebrxBandSetBtn.addEventListener("click", async () => {
|
|
await setOpenWebRxBand();
|
|
});
|
|
}
|
|
if (els.openwebrxCloseBtn) {
|
|
els.openwebrxCloseBtn.addEventListener("click", async () => {
|
|
await closeOpenWebRxSession();
|
|
await refreshStatus();
|
|
});
|
|
}
|
|
if (els.refreshPluginsPageBtn) {
|
|
els.refreshPluginsPageBtn.addEventListener("click", async () => {
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
});
|
|
}
|
|
|
|
if (els.refreshUsersBtn) {
|
|
els.refreshUsersBtn.addEventListener("click", async () => {
|
|
await refreshUsers();
|
|
});
|
|
}
|
|
if (els.usersFilterQuery) {
|
|
els.usersFilterQuery.addEventListener("input", () => {
|
|
state.usersFilter.query = els.usersFilterQuery.value.trim().toLowerCase();
|
|
renderUsersAdmin();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.usersFilterRole) {
|
|
els.usersFilterRole.addEventListener("change", () => {
|
|
state.usersFilter.role = els.usersFilterRole.value;
|
|
renderUsersAdmin();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.usersFilterStatus) {
|
|
els.usersFilterStatus.addEventListener("change", () => {
|
|
state.usersFilter.status = els.usersFilterStatus.value;
|
|
renderUsersAdmin();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
|
|
if (els.refreshApprovalsBtn) {
|
|
els.refreshApprovalsBtn.addEventListener("click", async () => {
|
|
await refreshApprovals();
|
|
});
|
|
}
|
|
if (els.refreshActivityBtn) {
|
|
els.refreshActivityBtn.addEventListener("click", async () => {
|
|
await refreshActivityLog();
|
|
});
|
|
}
|
|
if (els.refreshHelpBtn) {
|
|
els.refreshHelpBtn.addEventListener("click", async () => {
|
|
await refreshHelpContent();
|
|
});
|
|
}
|
|
if (els.activityFilterQuery) {
|
|
els.activityFilterQuery.addEventListener("input", () => {
|
|
state.activityFilter.query = els.activityFilterQuery.value.trim().toLowerCase();
|
|
renderActivityLog();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.activityFilterType) {
|
|
els.activityFilterType.addEventListener("change", () => {
|
|
state.activityFilter.type = els.activityFilterType.value;
|
|
renderActivityLog();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.approvalsFilterOpenBtn) {
|
|
els.approvalsFilterOpenBtn.addEventListener("click", () => {
|
|
state.approvalsFilter.mode = "open";
|
|
renderApprovals();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.approvalsFilterAllBtn) {
|
|
els.approvalsFilterAllBtn.addEventListener("click", () => {
|
|
state.approvalsFilter.mode = "all";
|
|
renderApprovals();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.approvalsFilterQuery) {
|
|
els.approvalsFilterQuery.addEventListener("input", () => {
|
|
state.approvalsFilter.query = els.approvalsFilterQuery.value.trim().toLowerCase();
|
|
renderApprovals();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
if (els.approvalsFilterStatus) {
|
|
els.approvalsFilterStatus.addEventListener("change", () => {
|
|
state.approvalsFilter.status = els.approvalsFilterStatus.value;
|
|
renderApprovals();
|
|
updateRouteQueryForCurrentPage();
|
|
});
|
|
}
|
|
|
|
if (els.maintenanceEnableBtn) {
|
|
els.maintenanceEnableBtn.addEventListener("click", async () => {
|
|
await setMaintenanceMode(true);
|
|
});
|
|
}
|
|
if (els.maintenanceDisableBtn) {
|
|
els.maintenanceDisableBtn.addEventListener("click", async () => {
|
|
await setMaintenanceMode(false);
|
|
});
|
|
}
|
|
if (els.uploadLogoLightBtn) {
|
|
els.uploadLogoLightBtn.addEventListener("click", async () => {
|
|
await uploadBrandLogo("light", els.logoLightFile);
|
|
});
|
|
}
|
|
if (els.uploadLogoDarkBtn) {
|
|
els.uploadLogoDarkBtn.addEventListener("click", async () => {
|
|
await uploadBrandLogo("dark", els.logoDarkFile);
|
|
});
|
|
}
|
|
if (els.removeLogoLightBtn) {
|
|
els.removeLogoLightBtn.addEventListener("click", async () => {
|
|
await removeBrandLogo("light");
|
|
});
|
|
}
|
|
if (els.removeLogoDarkBtn) {
|
|
els.removeLogoDarkBtn.addEventListener("click", async () => {
|
|
await removeBrandLogo("dark");
|
|
});
|
|
}
|
|
|
|
if (els.verifyOtpBtn) {
|
|
els.verifyOtpBtn.addEventListener("click", async () => {
|
|
await verifyOtpCode();
|
|
});
|
|
}
|
|
|
|
const adminUnsupported = [
|
|
els.setOnlineBtn,
|
|
els.setOfflineBtn,
|
|
els.forceReleaseBtn,
|
|
els.refreshAuditBtn,
|
|
els.setRoleAdminBtn,
|
|
els.setRoleOperatorBtn
|
|
];
|
|
for (const btn of adminUnsupported) {
|
|
on(btn, "click", () => {
|
|
renderMessage(els.adminMessage, "Dieser Admin-Bereich wird auf die neue Plugin-Admin-API migriert.", true);
|
|
});
|
|
}
|
|
}
|
|
|
|
async function refreshFrontendOnResume() {
|
|
if (resumeRefreshInFlight) {
|
|
return;
|
|
}
|
|
resumeRefreshInFlight = true;
|
|
try {
|
|
await refreshPublicSystemStatus();
|
|
await refreshPublicAuthMethods();
|
|
await refreshCurrentUser();
|
|
applyRoute(true);
|
|
if (!state.user) {
|
|
return;
|
|
}
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
await refreshControls();
|
|
const route = currentRoute();
|
|
if (route === "/rms/plugins" || route === "/rms/plugin-konfig" || route === "/rms/providers") {
|
|
await refreshPlugins();
|
|
}
|
|
if (route === "/rms/users") {
|
|
await refreshUsers();
|
|
}
|
|
if (route === "/rms/freigaben") {
|
|
await refreshApprovals();
|
|
}
|
|
if (route === "/rms/aktivitaet") {
|
|
await refreshActivityLog();
|
|
}
|
|
if (route === "/rms/hilfe") {
|
|
await refreshHelpContent();
|
|
}
|
|
connectEvents();
|
|
} catch {
|
|
// best effort resume refresh
|
|
} finally {
|
|
resumeRefreshInFlight = false;
|
|
}
|
|
}
|
|
|
|
async function requestAccess() {
|
|
clearMessages("auth");
|
|
const email = els.email.value.trim();
|
|
const method = els.authMethodSelect.value;
|
|
try {
|
|
const result = await api("/v1/auth/request-access", {
|
|
method: "POST",
|
|
body: { email, method },
|
|
authRequired: false
|
|
});
|
|
if (result && result.challengeType === "oauth" && result.authorizeUrl) {
|
|
window.location.assign(String(result.authorizeUrl));
|
|
return;
|
|
}
|
|
els.otpWrap.hidden = result.challengeType !== "otp";
|
|
renderMessage(els.authMessage, result.message || "Bitte E-Mail pruefen.", false, true);
|
|
} catch (error) {
|
|
if (error && error.status === 404) {
|
|
try {
|
|
const fallback = await api("/v1/auth/login", {
|
|
method: "POST",
|
|
body: { email, method },
|
|
authRequired: false
|
|
});
|
|
els.otpWrap.hidden = fallback.challengeType !== "otp";
|
|
renderMessage(els.authMessage, fallback.message || "Bitte E-Mail pruefen.", false, true);
|
|
return;
|
|
} catch {
|
|
renderMessage(els.authMessage, "Login-Endpunkt nicht gefunden. Bitte Backend/Server neu starten.", true);
|
|
return;
|
|
}
|
|
}
|
|
renderMessage(els.authMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function verifyOtpCode() {
|
|
clearMessages("auth");
|
|
try {
|
|
const result = await api("/v1/auth/verify-email", {
|
|
method: "POST",
|
|
body: {
|
|
email: els.email.value.trim(),
|
|
code: els.otpCode.value.trim()
|
|
},
|
|
authRequired: false
|
|
});
|
|
if (result.accessToken) {
|
|
setTokens(result.accessToken, result.refreshToken);
|
|
state.user = result.user;
|
|
await ensureLanguageFromUserPreference();
|
|
els.otpCode.value = "";
|
|
els.otpWrap.hidden = true;
|
|
applyRoute();
|
|
updateUserUi();
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
await refreshControls();
|
|
await refreshPlugins();
|
|
await refreshUsers();
|
|
await refreshApprovals();
|
|
await refreshActivityLog();
|
|
connectEvents();
|
|
renderMessage(els.authMessage, `Willkommen ${result.user.email}`, false, true);
|
|
return;
|
|
}
|
|
renderMessage(els.authMessage, result.message || "Code bestaetigt.", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.authMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function handleEmailTokenFromUrl() {
|
|
const url = new URL(window.location.href);
|
|
if (url.searchParams.get("requestApproval") === "1") {
|
|
const email = (url.searchParams.get("email") || "").trim();
|
|
if (email) {
|
|
els.email.value = email;
|
|
try {
|
|
const result = await api("/v1/auth/request-approval", {
|
|
method: "POST",
|
|
body: { email },
|
|
authRequired: false
|
|
});
|
|
renderMessage(els.authMessage, result.message || "Freigabe angefordert.", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.authMessage, error.message, true);
|
|
}
|
|
}
|
|
url.searchParams.delete("requestApproval");
|
|
url.searchParams.delete("email");
|
|
window.history.replaceState({}, "", `${url.pathname}${url.search}`);
|
|
}
|
|
|
|
const token = url.searchParams.get("verifyToken") || url.searchParams.get("loginToken");
|
|
const authError = url.searchParams.get("authError");
|
|
if (authError) {
|
|
const authMessage = url.searchParams.get("authMessage") || "OAuth Anmeldung fehlgeschlagen.";
|
|
renderMessage(els.authMessage, authMessage, true);
|
|
url.searchParams.delete("authError");
|
|
url.searchParams.delete("authMessage");
|
|
window.history.replaceState({}, "", `${url.pathname}${url.search}`);
|
|
return;
|
|
}
|
|
if (!token) {
|
|
return;
|
|
}
|
|
clearMessages("auth");
|
|
try {
|
|
const result = await api("/v1/auth/verify-email", {
|
|
method: "POST",
|
|
body: { token },
|
|
authRequired: false
|
|
});
|
|
if (result.accessToken) {
|
|
setTokens(result.accessToken, result.refreshToken);
|
|
state.user = result.user;
|
|
await ensureLanguageFromUserPreference();
|
|
renderMessage(els.authMessage, `Willkommen ${result.user.email}`, false, true);
|
|
url.searchParams.delete("verifyToken");
|
|
url.searchParams.delete("loginToken");
|
|
window.history.replaceState({}, "", `${url.pathname}${url.search}`);
|
|
} else {
|
|
renderMessage(els.authMessage, result.message || "Link verarbeitet.", false, true);
|
|
}
|
|
} catch (error) {
|
|
renderMessage(els.authMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshPublicSystemStatus() {
|
|
try {
|
|
const result = await api("/v1/public/system", { authRequired: false });
|
|
state.system = {
|
|
maintenanceMode: Boolean(result.maintenanceMode),
|
|
maintenanceMessage: result.maintenanceMessage || "",
|
|
updatedAt: result.updatedAt || null,
|
|
branding: normalizeBranding(result.branding)
|
|
};
|
|
} catch {
|
|
state.system = {
|
|
maintenanceMode: false,
|
|
maintenanceMessage: "",
|
|
updatedAt: null,
|
|
branding: normalizeBranding(null)
|
|
};
|
|
}
|
|
renderMaintenanceBanner();
|
|
renderBranding();
|
|
}
|
|
|
|
async function refreshPublicAuthMethods() {
|
|
try {
|
|
const result = await api("/v1/public/auth-methods", { authRequired: false });
|
|
state.authMethods = Array.isArray(result.methods) ? result.methods : [];
|
|
} catch {
|
|
state.authMethods = [];
|
|
}
|
|
renderAuthMethods();
|
|
}
|
|
|
|
function renderAuthMethods() {
|
|
if (!els.authMethodSelect) {
|
|
return;
|
|
}
|
|
els.authMethodSelect.innerHTML = "";
|
|
if (!state.authMethods.length) {
|
|
const option = document.createElement("option");
|
|
option.value = "smtp-link";
|
|
option.textContent = "per Mail";
|
|
els.authMethodSelect.appendChild(option);
|
|
els.authMethodSelect.value = "smtp-link";
|
|
renderUserSettingsAuthMethods();
|
|
return;
|
|
}
|
|
for (const method of state.authMethods) {
|
|
const option = document.createElement("option");
|
|
option.value = method.id;
|
|
option.textContent = method.label;
|
|
els.authMethodSelect.appendChild(option);
|
|
}
|
|
if (state.authMethods.some((method) => method.id === "smtp-link")) {
|
|
els.authMethodSelect.value = "smtp-link";
|
|
}
|
|
renderUserSettingsAuthMethods();
|
|
}
|
|
|
|
function renderUserSettingsAuthMethods() {
|
|
if (!els.settingsAuthMethodSelect || !els.settingsSaveAuthMethodBtn) {
|
|
return;
|
|
}
|
|
const select = els.settingsAuthMethodSelect;
|
|
select.innerHTML = "";
|
|
const userMethods = new Set(Array.isArray(state.user && state.user.enabledAuthMethods) ? state.user.enabledAuthMethods : []);
|
|
const methods = state.authMethods.filter((method) => userMethods.has(method.id));
|
|
if (!methods.length) {
|
|
const option = document.createElement("option");
|
|
option.value = "";
|
|
option.textContent = "Keine Methode verfuegbar";
|
|
select.appendChild(option);
|
|
select.disabled = true;
|
|
els.settingsSaveAuthMethodBtn.disabled = true;
|
|
return;
|
|
}
|
|
for (const method of methods) {
|
|
const option = document.createElement("option");
|
|
option.value = method.id;
|
|
option.textContent = method.label;
|
|
select.appendChild(option);
|
|
}
|
|
if (state.user && methods.some((method) => method.id === state.user.primaryAuthMethod)) {
|
|
select.value = state.user.primaryAuthMethod;
|
|
} else if (methods.some((method) => method.id === "smtp-link")) {
|
|
select.value = "smtp-link";
|
|
}
|
|
select.disabled = false;
|
|
els.settingsSaveAuthMethodBtn.disabled = false;
|
|
}
|
|
|
|
async function savePreferredAuthMethod() {
|
|
const primaryMethod = els.settingsAuthMethodSelect ? els.settingsAuthMethodSelect.value : "";
|
|
if (!primaryMethod) return;
|
|
try {
|
|
const result = await api("/v1/me/auth-method", {
|
|
method: "PUT",
|
|
body: { primaryMethod }
|
|
});
|
|
state.user = result.user;
|
|
renderUserSettingsAuthMethods();
|
|
renderMessage(els.authMessage, "Praeferierte Authentifizierung gespeichert.", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.authMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function savePreferredLanguage() {
|
|
if (!state.user) {
|
|
return;
|
|
}
|
|
const preferredLanguage = normalizeLanguage(els.settingsLanguageSelect ? els.settingsLanguageSelect.value : state.i18n.language);
|
|
try {
|
|
const result = await api("/v1/me/language", {
|
|
method: "PUT",
|
|
body: { preferredLanguage }
|
|
});
|
|
state.user = result.user;
|
|
await setLanguage(preferredLanguage, { persist: true, saveUserDefault: false });
|
|
renderMessage(els.authMessage, translateLiteral("Praeferierte Sprache gespeichert."), false, true);
|
|
} catch (error) {
|
|
renderMessage(els.authMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
function renderMaintenanceBanner() {
|
|
const active = Boolean(state.system.maintenanceMode);
|
|
els.maintenanceBanner.hidden = !active;
|
|
els.maintenanceBanner.textContent = active ? (state.system.maintenanceMessage || translateLiteral("Wartungsmodus aktiv")) : "";
|
|
els.maintenanceBanner.className = active ? "message error" : "message";
|
|
if (els.maintenanceStatePill) {
|
|
els.maintenanceStatePill.textContent = active ? translateLiteral("Aktiv") : translateLiteral("Inaktiv");
|
|
els.maintenanceStatePill.classList.toggle("offline", active);
|
|
els.maintenanceStatePill.classList.toggle("ok", !active);
|
|
}
|
|
if (els.maintenanceMessageInput && !els.maintenanceMessageInput.value) {
|
|
els.maintenanceMessageInput.value = state.system.maintenanceMessage || "";
|
|
}
|
|
}
|
|
|
|
function renderBranding() {
|
|
if (!els.brandLogo || !els.brandFallback) {
|
|
return;
|
|
}
|
|
const theme = document.documentElement.dataset.theme === "light" ? "light" : "dark";
|
|
const branding = normalizeBranding(state.system && state.system.branding);
|
|
const logoUrl = theme === "light" ? branding.logoLightUrl : branding.logoDarkUrl;
|
|
if (logoUrl) {
|
|
const sep = logoUrl.includes("?") ? "&" : "?";
|
|
els.brandLogo.src = `${logoUrl}${sep}v=${encodeURIComponent(String(state.system.updatedAt || ""))}`;
|
|
els.brandLogo.hidden = false;
|
|
els.brandFallback.hidden = true;
|
|
} else {
|
|
els.brandLogo.hidden = true;
|
|
els.brandLogo.removeAttribute("src");
|
|
els.brandFallback.hidden = false;
|
|
}
|
|
}
|
|
|
|
function normalizeBranding(value) {
|
|
const branding = value && typeof value === "object" ? value : {};
|
|
return {
|
|
logoLightUrl: typeof branding.logoLightUrl === "string" && branding.logoLightUrl.trim() ? branding.logoLightUrl : null,
|
|
logoDarkUrl: typeof branding.logoDarkUrl === "string" && branding.logoDarkUrl.trim() ? branding.logoDarkUrl : null
|
|
};
|
|
}
|
|
|
|
async function uploadBrandLogo(theme, inputEl) {
|
|
clearMessages("admin");
|
|
try {
|
|
const file = inputEl && inputEl.files && inputEl.files[0];
|
|
if (!file) {
|
|
renderMessage(els.adminMessage, "Bitte zuerst ein Bild auswaehlen.", true);
|
|
return;
|
|
}
|
|
const dataUrl = await fileToDataUrl(file);
|
|
const result = await api("/v1/admin/branding/logo", {
|
|
method: "PUT",
|
|
body: {
|
|
theme,
|
|
dataUrl,
|
|
fileName: file.name
|
|
}
|
|
});
|
|
state.system.branding = normalizeBranding(result.branding);
|
|
state.system.updatedAt = result.updatedAt || new Date().toISOString();
|
|
renderBranding();
|
|
if (inputEl) {
|
|
inputEl.value = "";
|
|
}
|
|
renderMessage(els.adminMessage, `${theme === "light" ? "Light" : "Dark"}-Logo gespeichert.`, false, true);
|
|
} catch (error) {
|
|
renderMessage(els.adminMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function removeBrandLogo(theme) {
|
|
clearMessages("admin");
|
|
try {
|
|
const result = await api(`/v1/admin/branding/logo?theme=${encodeURIComponent(theme)}`, {
|
|
method: "DELETE"
|
|
});
|
|
state.system.branding = normalizeBranding(result.branding);
|
|
state.system.updatedAt = result.updatedAt || new Date().toISOString();
|
|
renderBranding();
|
|
renderMessage(els.adminMessage, `${theme === "light" ? "Light" : "Dark"}-Logo entfernt.`, false, true);
|
|
} catch (error) {
|
|
renderMessage(els.adminMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
function fileToDataUrl(file) {
|
|
return new Promise((resolve, reject) => {
|
|
const reader = new FileReader();
|
|
reader.onerror = () => reject(new Error("Datei konnte nicht gelesen werden"));
|
|
reader.onload = () => resolve(String(reader.result || ""));
|
|
reader.readAsDataURL(file);
|
|
});
|
|
}
|
|
|
|
async function setMaintenanceMode(enabled) {
|
|
clearMessages("admin");
|
|
try {
|
|
const result = await api("/v1/admin/maintenance", {
|
|
method: "PUT",
|
|
body: {
|
|
enabled,
|
|
message: els.maintenanceMessageInput.value.trim()
|
|
}
|
|
});
|
|
state.system.maintenanceMode = Boolean(result.maintenanceMode);
|
|
state.system.maintenanceMessage = result.maintenanceMessage || "";
|
|
renderMaintenanceBanner();
|
|
renderMessage(els.adminMessage, enabled ? "Wartungsmodus aktiviert" : "Wartungsmodus deaktiviert", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.adminMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshCurrentUser() {
|
|
if (!state.accessToken) {
|
|
state.user = null;
|
|
updateUserUi();
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const result = await api("/v1/me", { authRequired: true });
|
|
state.user = result.user;
|
|
renderUserSettingsAuthMethods();
|
|
await ensureLanguageFromUserPreference();
|
|
} catch {
|
|
state.user = null;
|
|
clearTokens();
|
|
}
|
|
updateUserUi();
|
|
}
|
|
|
|
async function logout(maintenanceRedirect = false, skipServerLogout = false) {
|
|
stopOpenWebRxTxPolling();
|
|
stopActivationWatch();
|
|
stopRemainingUsageWatch();
|
|
activationPending = false;
|
|
if (eventSource) {
|
|
eventSource.close();
|
|
eventSource = null;
|
|
}
|
|
if (!skipServerLogout) {
|
|
try {
|
|
await api("/v1/auth/logout", {
|
|
method: "POST",
|
|
body: { refreshToken: state.refreshToken },
|
|
authRequired: false
|
|
});
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}
|
|
clearTokens();
|
|
state.user = null;
|
|
state.status = null;
|
|
state.swrReport = null;
|
|
state.controls = [];
|
|
state.plugins = [];
|
|
state.providers = {};
|
|
state.capabilities = [];
|
|
state.users = [];
|
|
state.helpContent = null;
|
|
state.activityEntries = [];
|
|
state.approvals = [];
|
|
state.openWebRx = {
|
|
sessionUrl: "",
|
|
sessionTicket: "",
|
|
expiresAt: null,
|
|
bands: [],
|
|
selectedBand: "",
|
|
txActive: null,
|
|
powerCommandConfigured: true,
|
|
pttCommandConfigured: true,
|
|
rotor: {
|
|
azimuth: null,
|
|
moving: false,
|
|
min: 0,
|
|
max: 360
|
|
},
|
|
busy: false,
|
|
pollMs: OPENWEBRX_TX_POLL_MS_DEFAULT,
|
|
pttPressed: false
|
|
};
|
|
syncOpenWebRxTicketCookie("");
|
|
renderOpenWebRxSessionAccess();
|
|
if (els.openwebrxPanel) {
|
|
els.openwebrxPanel.hidden = true;
|
|
}
|
|
if (els.controlsPanel) {
|
|
els.controlsPanel.hidden = true;
|
|
}
|
|
renderOpenWebRxBandOptions();
|
|
renderOpenWebRxTxState();
|
|
renderRotorState();
|
|
setOpenWebRxBusy(false);
|
|
renderPluginControls();
|
|
renderPluginAdmin();
|
|
renderUsersAdmin();
|
|
renderApprovals();
|
|
renderActivityLog();
|
|
renderHelpContent();
|
|
renderStatus();
|
|
renderSwrPanels();
|
|
if (maintenanceRedirect) {
|
|
await refreshPublicSystemStatus();
|
|
}
|
|
applyRoute();
|
|
updateUserUi();
|
|
renderMessage(
|
|
els.authMessage,
|
|
maintenanceRedirect
|
|
? (state.system.maintenanceMessage || "Wartungsmodus aktiv. Bitte spaeter erneut versuchen.")
|
|
: "Abgemeldet.",
|
|
maintenanceRedirect,
|
|
!maintenanceRedirect
|
|
);
|
|
}
|
|
|
|
async function activateStation() {
|
|
clearMessages("status");
|
|
try {
|
|
const result = await api("/v1/station/activation-jobs", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
if (result.pending) {
|
|
activationPending = true;
|
|
const text = "Aktivierung gestartet...";
|
|
renderMessage(els.swrSummaryMessage, text, false, true);
|
|
renderMessage(els.swrPageMessage, text, false, true);
|
|
startActivationWatch();
|
|
}
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
} catch (error) {
|
|
renderMessage(els.statusMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function releaseStation() {
|
|
clearMessages("status");
|
|
try {
|
|
await api("/v1/station/release", { method: "POST", body: {} });
|
|
state.openWebRx.sessionUrl = "";
|
|
state.openWebRx.sessionTicket = "";
|
|
state.openWebRx.expiresAt = null;
|
|
state.openWebRx.bands = [];
|
|
state.openWebRx.selectedBand = "";
|
|
state.openWebRx.txActive = false;
|
|
state.openWebRx.rotor = {
|
|
azimuth: null,
|
|
rawAzimuth: null,
|
|
moving: false,
|
|
stale: false,
|
|
updatedAt: null,
|
|
min: 0,
|
|
max: 360
|
|
};
|
|
state.openWebRx.busy = false;
|
|
state.openWebRx.pttPressed = false;
|
|
syncOpenWebRxTicketCookie("");
|
|
renderOpenWebRxBandOptions();
|
|
renderOpenWebRxTxState();
|
|
renderRotorState();
|
|
setOpenWebRxBusy(false);
|
|
renderOpenWebRxSessionAccess();
|
|
renderMessage(els.statusMessage, "Station freigegeben", false, true);
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
} catch (error) {
|
|
renderMessage(els.statusMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function reserveNextSlot() {
|
|
clearMessages("status");
|
|
try {
|
|
await api("/v1/station/reservations/next", { method: "POST", body: {} });
|
|
renderMessage(els.reservationMessage, "Reservierung gespeichert", false, true);
|
|
await refreshStatus();
|
|
} catch (error) {
|
|
renderMessage(els.reservationMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function cancelOwnReservation() {
|
|
clearMessages("status");
|
|
try {
|
|
await api("/v1/station/reservations/next", { method: "DELETE" });
|
|
renderMessage(els.reservationMessage, "Reservierung entfernt", false, true);
|
|
await refreshStatus();
|
|
} catch (error) {
|
|
renderMessage(els.reservationMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function cancelReservationByUserId(userId) {
|
|
const normalized = String(userId || "").trim();
|
|
if (!normalized) {
|
|
return;
|
|
}
|
|
clearMessages("status");
|
|
try {
|
|
await api(`/v1/station/reservations/${encodeURIComponent(normalized)}`, { method: "DELETE" });
|
|
renderMessage(els.reservationMessage, "Reservierung geloescht", false, true);
|
|
await refreshStatus();
|
|
} catch (error) {
|
|
renderMessage(els.reservationMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function openOpenWebRxSession() {
|
|
clearMessages("status");
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
const result = await requestOpenWebRxSessionWithRetry();
|
|
const session = result && result.session ? result.session : null;
|
|
state.openWebRx.sessionUrl = session && session.iframeUrl ? session.iframeUrl : "";
|
|
state.openWebRx.sessionTicket = session && session.ticket ? String(session.ticket) : "";
|
|
state.openWebRx.expiresAt = session && session.expiresAt ? session.expiresAt : null;
|
|
syncOpenWebRxTicketCookie(state.openWebRx.sessionTicket, state.openWebRx.expiresAt);
|
|
renderOpenWebRxSessionAccess();
|
|
await refreshOpenWebRxBands();
|
|
await refreshOpenWebRxTxStatus();
|
|
await refreshOpenWebRxRotorStatus();
|
|
renderMessage(els.openwebrxMessage, "", false);
|
|
} catch (error) {
|
|
renderMessage(els.openwebrxMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
async function openOpenWebRxExternal() {
|
|
if (!state.user) {
|
|
return;
|
|
}
|
|
clearMessages("status");
|
|
try {
|
|
const result = await requestOpenWebRxSessionWithRetry();
|
|
const session = result && result.session ? result.session : null;
|
|
const sessionUrl = session && session.iframeUrl ? String(session.iframeUrl) : "";
|
|
if (!sessionUrl) {
|
|
throw new Error("OpenWebRX Session konnte nicht erstellt werden");
|
|
}
|
|
state.openWebRx.sessionUrl = sessionUrl;
|
|
state.openWebRx.sessionTicket = session && session.ticket ? String(session.ticket) : "";
|
|
state.openWebRx.expiresAt = session && session.expiresAt ? session.expiresAt : null;
|
|
syncOpenWebRxTicketCookie(state.openWebRx.sessionTicket, state.openWebRx.expiresAt);
|
|
renderOpenWebRxSessionAccess();
|
|
window.open(sessionUrl, "_blank", "noopener,noreferrer");
|
|
await refreshStatus();
|
|
renderMessage(els.openwebrxMessage, "OpenWebRX in neuem Tab geoeffnet. Session-Link und Ticket aktualisiert.", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.statusMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function requestOpenWebRxSessionWithRetry() {
|
|
const attempts = [0, 700, 1400, 2200];
|
|
let lastError = null;
|
|
for (let i = 0; i < attempts.length; i += 1) {
|
|
const waitMs = attempts[i];
|
|
if (waitMs > 0) {
|
|
await new Promise((resolve) => setTimeout(resolve, waitMs));
|
|
}
|
|
try {
|
|
return await api("/v1/openwebrx/session", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
} catch (error) {
|
|
lastError = error;
|
|
const status = Number(error && error.status);
|
|
const msg = String(error && error.message ? error.message : "").toLowerCase();
|
|
const retryable = status === 502 || status === 503 || status === 504
|
|
|| msg.includes("bad gateway")
|
|
|| msg.includes("upstream")
|
|
|| msg.includes("connection refused")
|
|
|| msg.includes("gateway");
|
|
if (!retryable || i >= attempts.length - 1) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
throw lastError || new Error("OpenWebRX Session konnte nicht erstellt werden");
|
|
}
|
|
|
|
async function refreshOpenWebRxBands() {
|
|
if (!state.user || !state.status || !state.status.isInUse || state.status.activeByUserId !== state.user.id) {
|
|
state.openWebRx.bands = [];
|
|
state.openWebRx.selectedBand = "";
|
|
renderOpenWebRxBandOptions();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/openwebrx/bands");
|
|
state.openWebRx.bands = Array.isArray(result.bands) ? result.bands : [];
|
|
state.openWebRx.selectedBand = result.selectedBand ? String(result.selectedBand) : "";
|
|
renderOpenWebRxBandOptions();
|
|
} catch {
|
|
state.openWebRx.bands = [];
|
|
state.openWebRx.selectedBand = "";
|
|
renderOpenWebRxBandOptions();
|
|
}
|
|
}
|
|
|
|
async function refreshOpenWebRxTxStatus() {
|
|
if (!state.user || !state.status || !state.status.isInUse || state.status.activeByUserId !== state.user.id) {
|
|
state.openWebRx.txActive = null;
|
|
state.openWebRx.powerCommandConfigured = true;
|
|
state.openWebRx.pttCommandConfigured = true;
|
|
renderOpenWebRxTxState();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/openwebrx/tx/status");
|
|
state.openWebRx.txActive = Boolean(result && result.txActive);
|
|
state.openWebRx.powerCommandConfigured = result && result.powerCommandConfigured !== false;
|
|
state.openWebRx.pttCommandConfigured = result && result.pttCommandConfigured !== false;
|
|
} catch {
|
|
state.openWebRx.txActive = null;
|
|
state.openWebRx.powerCommandConfigured = true;
|
|
state.openWebRx.pttCommandConfigured = true;
|
|
}
|
|
renderOpenWebRxTxState();
|
|
}
|
|
|
|
async function refreshOpenWebRxRotorStatus() {
|
|
if (!state.user || !state.status || !state.status.isInUse || state.status.activeByUserId !== state.user.id) {
|
|
state.openWebRx.rotor = {
|
|
azimuth: null,
|
|
rawAzimuth: null,
|
|
moving: false,
|
|
stale: false,
|
|
updatedAt: null,
|
|
min: 0,
|
|
max: 360
|
|
};
|
|
renderRotorState();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/openwebrx/rotor/status");
|
|
const rotor = result && result.rotor && typeof result.rotor === "object" ? result.rotor : {};
|
|
const hasAzimuth = rotor.azimuth !== null && rotor.azimuth !== undefined && rotor.azimuth !== "";
|
|
const hasRawAzimuth = rotor.rawAzimuth !== null && rotor.rawAzimuth !== undefined && rotor.rawAzimuth !== "";
|
|
state.openWebRx.rotor = {
|
|
azimuth: hasAzimuth && Number.isFinite(Number(rotor.azimuth)) ? Number(rotor.azimuth) : null,
|
|
rawAzimuth: hasRawAzimuth && Number.isFinite(Number(rotor.rawAzimuth)) ? Number(rotor.rawAzimuth) : null,
|
|
moving: Boolean(rotor.moving),
|
|
stale: Boolean(rotor.stale),
|
|
updatedAt: rotor.updatedAt ? String(rotor.updatedAt) : null,
|
|
min: Number.isFinite(Number(rotor.min)) ? Number(rotor.min) : 0,
|
|
max: Number.isFinite(Number(rotor.max)) ? Number(rotor.max) : 360
|
|
};
|
|
} catch {
|
|
state.openWebRx.rotor = {
|
|
azimuth: null,
|
|
rawAzimuth: null,
|
|
moving: false,
|
|
stale: false,
|
|
updatedAt: null,
|
|
min: 0,
|
|
max: 360
|
|
};
|
|
}
|
|
renderRotorState();
|
|
}
|
|
|
|
function startOpenWebRxTxPolling() {
|
|
const pollMs = normalizeOpenWebRxPollMs(state.openWebRx.pollMs);
|
|
if (openWebRxTxPollTimer && openWebRxTxPollIntervalMs === pollMs) {
|
|
return;
|
|
}
|
|
stopOpenWebRxTxPolling();
|
|
openWebRxTxPollIntervalMs = pollMs;
|
|
openWebRxTxPollTimer = setInterval(async () => {
|
|
if (openWebRxTxPollInFlight) {
|
|
return;
|
|
}
|
|
if (!state.user || !state.status || !state.status.isInUse || state.status.activeByUserId !== state.user.id) {
|
|
return;
|
|
}
|
|
openWebRxTxPollInFlight = true;
|
|
try {
|
|
await refreshOpenWebRxTxStatus();
|
|
await refreshOpenWebRxRotorStatus();
|
|
} finally {
|
|
openWebRxTxPollInFlight = false;
|
|
}
|
|
}, pollMs);
|
|
}
|
|
|
|
function stopOpenWebRxTxPolling() {
|
|
if (openWebRxTxPollTimer) {
|
|
clearInterval(openWebRxTxPollTimer);
|
|
openWebRxTxPollTimer = null;
|
|
}
|
|
openWebRxTxPollInFlight = false;
|
|
openWebRxTxPollIntervalMs = null;
|
|
}
|
|
|
|
function applyOpenWebRxPollingConfig(status) {
|
|
const nextMs = normalizeOpenWebRxPollMs(status && status.openWebRxTxPollMs);
|
|
const changed = nextMs !== state.openWebRx.pollMs;
|
|
state.openWebRx.pollMs = nextMs;
|
|
if (changed && openWebRxTxPollTimer) {
|
|
startOpenWebRxTxPolling();
|
|
}
|
|
}
|
|
|
|
function normalizeOpenWebRxPollMs(value) {
|
|
const n = Number(value);
|
|
if (!Number.isFinite(n)) {
|
|
return OPENWEBRX_TX_POLL_MS_DEFAULT;
|
|
}
|
|
return Math.max(1000, Math.min(60000, Math.trunc(n)));
|
|
}
|
|
|
|
function renderOpenWebRxTxState() {
|
|
if (!els.openwebrxTxStatePill) {
|
|
return;
|
|
}
|
|
els.openwebrxTxStatePill.className = "pill";
|
|
if (els.openwebrxEnableTxBtn) {
|
|
els.openwebrxEnableTxBtn.textContent = "RIG einschalten";
|
|
els.openwebrxEnableTxBtn.disabled = state.openWebRx.busy || state.openWebRx.powerCommandConfigured === false;
|
|
}
|
|
if (state.openWebRx.powerCommandConfigured === false) {
|
|
els.openwebrxTxStatePill.textContent = "RIG: nicht konfiguriert";
|
|
return;
|
|
}
|
|
if (state.openWebRx.txActive === true) {
|
|
els.openwebrxTxStatePill.textContent = "RIG: an";
|
|
if (els.openwebrxEnableTxBtn) {
|
|
els.openwebrxEnableTxBtn.textContent = "RIG ausschalten";
|
|
}
|
|
return;
|
|
}
|
|
if (state.openWebRx.txActive === false) {
|
|
els.openwebrxTxStatePill.textContent = "RIG: aus";
|
|
if (els.openwebrxEnableTxBtn) {
|
|
els.openwebrxEnableTxBtn.textContent = "RIG einschalten";
|
|
}
|
|
return;
|
|
}
|
|
els.openwebrxTxStatePill.textContent = "RIG: unbekannt";
|
|
}
|
|
|
|
async function toggleOpenWebRxTxPower() {
|
|
if (state.openWebRx.powerCommandConfigured === false) {
|
|
renderMessage(els.controlsMessage, "RIG ON/OFF ist nicht konfiguriert (RFROUTE_CMD_ON/RFROUTE_CMD_OFF)", true);
|
|
return;
|
|
}
|
|
if (state.openWebRx.txActive === true) {
|
|
await disableOpenWebRxTx();
|
|
return;
|
|
}
|
|
await enableOpenWebRxTx();
|
|
}
|
|
|
|
function renderOpenWebRxBandOptions() {
|
|
if (!els.openwebrxBandSelect) {
|
|
return;
|
|
}
|
|
els.openwebrxBandSelect.innerHTML = "";
|
|
const bands = state.openWebRx.bands || [];
|
|
if (!bands.length) {
|
|
const option = document.createElement("option");
|
|
option.value = "";
|
|
option.textContent = "Keine Baender";
|
|
els.openwebrxBandSelect.appendChild(option);
|
|
els.openwebrxBandSelect.disabled = true;
|
|
if (els.openwebrxBandSetBtn) {
|
|
els.openwebrxBandSetBtn.disabled = true;
|
|
}
|
|
setOpenWebRxBusy(state.openWebRx.busy);
|
|
return;
|
|
}
|
|
for (const band of bands) {
|
|
const option = document.createElement("option");
|
|
option.value = String(band.band || "");
|
|
option.textContent = String(band.label || band.band || "Band");
|
|
if (state.openWebRx.selectedBand && option.value === state.openWebRx.selectedBand) {
|
|
option.selected = true;
|
|
}
|
|
els.openwebrxBandSelect.appendChild(option);
|
|
}
|
|
els.openwebrxBandSelect.disabled = false;
|
|
if (els.openwebrxBandSetBtn) {
|
|
els.openwebrxBandSetBtn.disabled = false;
|
|
}
|
|
setOpenWebRxBusy(state.openWebRx.busy);
|
|
}
|
|
|
|
async function setOpenWebRxBand() {
|
|
const band = els.openwebrxBandSelect ? String(els.openwebrxBandSelect.value || "").trim() : "";
|
|
if (!band) {
|
|
renderMessage(els.openwebrxMessage, "Bitte Band auswaehlen", true);
|
|
return;
|
|
}
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
const result = await api("/v1/openwebrx/bands/select", {
|
|
method: "POST",
|
|
body: { band }
|
|
});
|
|
state.openWebRx.selectedBand = band;
|
|
renderMessage(els.openwebrxMessage, result && result.result && result.result.message ? result.result.message : "Band gesetzt", false, true);
|
|
await refreshOpenWebRxBands();
|
|
} catch (error) {
|
|
renderMessage(els.openwebrxMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
async function enableOpenWebRxTx() {
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
await api("/v1/openwebrx/tx/enable", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
state.openWebRx.txActive = true;
|
|
renderOpenWebRxTxState();
|
|
renderMessage(els.controlsMessage, "RIG eingeschaltet", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.controlsMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
async function disableOpenWebRxTx() {
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
await api("/v1/openwebrx/tx/disable", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
state.openWebRx.txActive = false;
|
|
renderOpenWebRxTxState();
|
|
renderMessage(els.controlsMessage, "RIG ausgeschaltet", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.controlsMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
async function setOpenWebRxRotor() {
|
|
if (!els.rotorTarget) {
|
|
return;
|
|
}
|
|
const raw = String(els.rotorTarget.value || "").trim();
|
|
if (!raw) {
|
|
renderMessage(els.controlsMessage, "Bitte Rotor-Ziel eingeben", true);
|
|
return;
|
|
}
|
|
const target = Number(raw.replace(",", "."));
|
|
if (!Number.isFinite(target) || target < 0 || target > 360) {
|
|
renderMessage(els.controlsMessage, "Rotor-Ziel muss zwischen 0 und 360 liegen", true);
|
|
return;
|
|
}
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
const result = await api("/v1/openwebrx/rotor/set", {
|
|
method: "POST",
|
|
body: { target, trigger: "user" }
|
|
});
|
|
renderMessage(
|
|
els.controlsMessage,
|
|
result && result.result && result.result.message ? result.result.message : `Rotor auf ${Math.round(target)}° gesetzt`,
|
|
false,
|
|
true
|
|
);
|
|
await refreshOpenWebRxRotorStatus();
|
|
} catch (error) {
|
|
renderMessage(els.controlsMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
function renderRotorState() {
|
|
if (!els.rotorCurrent) {
|
|
return;
|
|
}
|
|
const rotor = state.openWebRx && state.openWebRx.rotor ? state.openWebRx.rotor : null;
|
|
const hasAzimuth = rotor && rotor.azimuth !== null && rotor.azimuth !== undefined && rotor.azimuth !== "";
|
|
const azimuth = hasAzimuth && Number.isFinite(Number(rotor.azimuth)) ? Math.round(Number(rotor.azimuth)) : null;
|
|
if (azimuth === null) {
|
|
els.rotorCurrent.textContent = "Rotor: -";
|
|
if (els.rotorCompass) {
|
|
els.rotorCompass.style.opacity = "0.45";
|
|
}
|
|
if (els.rotorCompassArrow) {
|
|
els.rotorCompassArrow.style.transform = "translate(-50%, -100%) rotate(0deg)";
|
|
}
|
|
} else {
|
|
const stale = Boolean(rotor && rotor.stale);
|
|
const moving = Boolean(rotor && rotor.moving);
|
|
let suffix = "";
|
|
if (moving) {
|
|
suffix = " (dreht)";
|
|
} else if (stale) {
|
|
suffix = " (letzter Wert)";
|
|
}
|
|
els.rotorCurrent.textContent = `Rotor: ${azimuth}°${suffix}`;
|
|
if (els.rotorCompass) {
|
|
els.rotorCompass.style.opacity = "1";
|
|
}
|
|
if (els.rotorCompassArrow) {
|
|
const normalized = ((Number(azimuth) % 360) + 360) % 360;
|
|
els.rotorCompassArrow.style.transform = `translate(-50%, -100%) rotate(${normalized}deg)`;
|
|
}
|
|
}
|
|
|
|
if (els.rotorTarget) {
|
|
const min = rotor && Number.isFinite(Number(rotor.min)) ? Number(rotor.min) : 0;
|
|
const max = rotor && Number.isFinite(Number(rotor.max)) ? Number(rotor.max) : 360;
|
|
els.rotorTarget.min = String(min);
|
|
els.rotorTarget.max = String(max);
|
|
if (!String(els.rotorTarget.value || "").trim() && azimuth !== null) {
|
|
els.rotorTarget.value = String(azimuth);
|
|
}
|
|
}
|
|
|
|
if (els.rotorPresets) {
|
|
for (const button of els.rotorPresets.querySelectorAll("button[data-azimuth]")) {
|
|
const preset = Number(button.getAttribute("data-azimuth"));
|
|
const active = azimuth !== null && Number.isFinite(preset) && Math.abs(preset - azimuth) <= 5;
|
|
button.classList.toggle("primary-btn", active);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function startOpenWebRxPtt() {
|
|
if (state.openWebRx.pttPressed) {
|
|
return;
|
|
}
|
|
state.openWebRx.pttPressed = true;
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
await api("/v1/openwebrx/ptt/down", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
renderMessage(els.openwebrxMessage, "PTT gedrueckt: Antenne auf TX", false, true);
|
|
} catch (error) {
|
|
state.openWebRx.pttPressed = false;
|
|
renderMessage(els.openwebrxMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
async function stopOpenWebRxPtt() {
|
|
if (!state.openWebRx.pttPressed) {
|
|
return;
|
|
}
|
|
state.openWebRx.pttPressed = false;
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
await api("/v1/openwebrx/ptt/up", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
renderMessage(els.openwebrxMessage, "PTT losgelassen: Antenne auf RX", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.openwebrxMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
async function closeOpenWebRxSession() {
|
|
setOpenWebRxBusy(true);
|
|
try {
|
|
await api("/v1/openwebrx/session/close", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
state.openWebRx.sessionUrl = "";
|
|
state.openWebRx.sessionTicket = "";
|
|
state.openWebRx.expiresAt = null;
|
|
state.openWebRx.bands = [];
|
|
state.openWebRx.selectedBand = "";
|
|
state.openWebRx.txActive = false;
|
|
state.openWebRx.rotor = {
|
|
azimuth: null,
|
|
rawAzimuth: null,
|
|
moving: false,
|
|
stale: false,
|
|
updatedAt: null,
|
|
min: 0,
|
|
max: 360
|
|
};
|
|
state.openWebRx.pttPressed = false;
|
|
syncOpenWebRxTicketCookie("");
|
|
renderOpenWebRxBandOptions();
|
|
renderOpenWebRxTxState();
|
|
renderRotorState();
|
|
renderOpenWebRxSessionAccess();
|
|
renderMessage(els.openwebrxMessage, "RIG ausgeschaltet, OpenWebRX Session geschlossen", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.openwebrxMessage, error.message, true);
|
|
} finally {
|
|
setOpenWebRxBusy(false);
|
|
}
|
|
}
|
|
|
|
function setOpenWebRxBusy(busy) {
|
|
state.openWebRx.busy = Boolean(busy);
|
|
const disabled = state.openWebRx.busy;
|
|
if (els.openwebrxOpenBtn) els.openwebrxOpenBtn.disabled = disabled;
|
|
if (els.openwebrxBandSetBtn) els.openwebrxBandSetBtn.disabled = disabled || (state.openWebRx.bands || []).length === 0;
|
|
if (els.openwebrxBandSelect) els.openwebrxBandSelect.disabled = disabled || (state.openWebRx.bands || []).length === 0;
|
|
if (els.openwebrxEnableTxBtn) {
|
|
els.openwebrxEnableTxBtn.disabled = disabled || state.openWebRx.powerCommandConfigured === false;
|
|
}
|
|
if (els.rotorSetBtn) els.rotorSetBtn.disabled = disabled;
|
|
if (els.rotorTarget) els.rotorTarget.disabled = disabled;
|
|
if (els.rotorPresets) {
|
|
for (const button of els.rotorPresets.querySelectorAll("button[data-azimuth]")) {
|
|
button.disabled = disabled;
|
|
}
|
|
}
|
|
if (els.openwebrxCloseBtn) els.openwebrxCloseBtn.disabled = disabled;
|
|
if (els.openwebrxCopyLinkBtn) {
|
|
els.openwebrxCopyLinkBtn.disabled = disabled || !String(state.openWebRx.sessionUrl || "").trim();
|
|
}
|
|
}
|
|
|
|
async function copyOpenWebRxLink() {
|
|
const sessionUrl = String(state.openWebRx.sessionUrl || "").trim();
|
|
if (!sessionUrl) {
|
|
renderMessage(els.openwebrxMessage, "Kein OpenWebRX Link vorhanden", true);
|
|
return;
|
|
}
|
|
try {
|
|
await copyTextToClipboard(sessionUrl);
|
|
renderMessage(els.openwebrxMessage, "OpenWebRX Link in Zwischenablage kopiert", false, true);
|
|
} catch {
|
|
renderMessage(els.openwebrxMessage, "Link konnte nicht kopiert werden", true);
|
|
}
|
|
}
|
|
|
|
async function copyTextToClipboard(value) {
|
|
if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
|
|
await navigator.clipboard.writeText(value);
|
|
return;
|
|
}
|
|
const helper = document.createElement("textarea");
|
|
helper.value = value;
|
|
helper.setAttribute("readonly", "readonly");
|
|
helper.style.position = "absolute";
|
|
helper.style.left = "-9999px";
|
|
document.body.appendChild(helper);
|
|
helper.select();
|
|
const copied = document.execCommand("copy");
|
|
document.body.removeChild(helper);
|
|
if (!copied) {
|
|
throw new Error("copy-failed");
|
|
}
|
|
}
|
|
|
|
function renderOpenWebRxSessionAccess() {
|
|
if (!els.openwebrxSessionAccess || !els.openwebrxSessionLink || !els.openwebrxSessionTicket) {
|
|
return;
|
|
}
|
|
const sessionUrl = String(state.openWebRx.sessionUrl || "").trim();
|
|
const ticket = String(state.openWebRx.sessionTicket || "").trim();
|
|
const visible = Boolean(sessionUrl);
|
|
els.openwebrxSessionAccess.hidden = !visible;
|
|
els.openwebrxSessionLink.hidden = !visible;
|
|
if (!visible) {
|
|
els.openwebrxSessionLink.removeAttribute("href");
|
|
els.openwebrxSessionTicket.textContent = "-";
|
|
if (els.openwebrxCopyLinkBtn) {
|
|
els.openwebrxCopyLinkBtn.disabled = true;
|
|
}
|
|
return;
|
|
}
|
|
els.openwebrxSessionLink.href = sessionUrl;
|
|
els.openwebrxSessionTicket.textContent = ticket || "(nicht geliefert)";
|
|
if (els.openwebrxCopyLinkBtn) {
|
|
els.openwebrxCopyLinkBtn.disabled = state.openWebRx.busy;
|
|
}
|
|
}
|
|
|
|
function syncOpenWebRxTicketCookie(ticket, expiresAtIso) {
|
|
const value = String(ticket || "").trim();
|
|
const baseRoot = "path=/; SameSite=Lax";
|
|
const baseOpenWebRx = "path=/openwebrx/; SameSite=Lax";
|
|
const secure = window && window.location && window.location.protocol === "https:" ? "; Secure" : "";
|
|
if (!value) {
|
|
document.cookie = `rms_owrx_ticket=; Max-Age=0; ${baseRoot}${secure}`;
|
|
document.cookie = `rms_owrx_ticket=; Max-Age=0; ${baseOpenWebRx}${secure}`;
|
|
return;
|
|
}
|
|
let maxAge = 600;
|
|
if (expiresAtIso) {
|
|
const expiresMs = Date.parse(String(expiresAtIso));
|
|
if (Number.isFinite(expiresMs)) {
|
|
const remainingSec = Math.floor((expiresMs - Date.now()) / 1000);
|
|
if (remainingSec > 0) {
|
|
maxAge = Math.max(10, Math.min(remainingSec, 86400));
|
|
}
|
|
}
|
|
}
|
|
document.cookie = `rms_owrx_ticket=${encodeURIComponent(value)}; Max-Age=${maxAge}; ${baseRoot}${secure}`;
|
|
document.cookie = `rms_owrx_ticket=; Max-Age=0; ${baseOpenWebRx}${secure}`;
|
|
}
|
|
|
|
async function refreshStatus() {
|
|
try {
|
|
const status = await api("/v1/station/status");
|
|
state.status = status;
|
|
applyOpenWebRxPollingConfig(status);
|
|
renderStatus();
|
|
await refreshOpenWebRxBands();
|
|
await refreshOpenWebRxTxStatus();
|
|
await refreshOpenWebRxRotorStatus();
|
|
} catch (error) {
|
|
renderMessage(els.statusMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshSwrReport() {
|
|
if (!canOperateStation()) {
|
|
state.swrReport = null;
|
|
renderSwrPanels();
|
|
return;
|
|
}
|
|
try {
|
|
const report = await api("/v1/swr/report");
|
|
state.swrReport = report;
|
|
renderSwrPanels();
|
|
} catch (error) {
|
|
renderMessage(els.swrSummaryMessage, error.message, true);
|
|
renderMessage(els.swrPageMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function runManualSwrCheck() {
|
|
if (state.status && state.status.swrRun && state.status.swrRun.running) {
|
|
const text = "SWR-Check laeuft bereits.";
|
|
renderMessage(els.swrSummaryMessage, text, true);
|
|
renderMessage(els.swrPageMessage, text, true);
|
|
return;
|
|
}
|
|
if (state.status && state.status.isInUse) {
|
|
const text = "SWR-Check gesperrt solange die Station aktiv ist.";
|
|
renderMessage(els.swrSummaryMessage, text, true);
|
|
renderMessage(els.swrPageMessage, text, true);
|
|
return;
|
|
}
|
|
|
|
const startedAt = Date.now();
|
|
const expectedSec = SWR_EXPECTED_DURATION_SEC_DEFAULT;
|
|
const previousReport = state.swrReport;
|
|
|
|
const runningBands = Array.isArray(previousReport && previousReport.bands)
|
|
? previousReport.bands.map((entry) => ({ ...entry, status: "RUNNING" }))
|
|
: [];
|
|
state.swrReport = {
|
|
source: previousReport && previousReport.source ? previousReport.source : "native-controller",
|
|
generatedAt: new Date(startedAt).toISOString(),
|
|
overallStatus: "RUNNING",
|
|
overviewUrl: previousReport && Object.prototype.hasOwnProperty.call(previousReport, "overviewUrl")
|
|
? previousReport.overviewUrl
|
|
: null,
|
|
bands: runningBands
|
|
};
|
|
renderSwrPanels();
|
|
|
|
setSwrRunButtonsBusy(true);
|
|
|
|
const updateProgressMessage = () => {
|
|
const elapsedSec = Math.max(0, Math.floor((Date.now() - startedAt) / 1000));
|
|
const remainingSec = Math.max(0, expectedSec - elapsedSec);
|
|
const text = `SWR-Messung laeuft... ${elapsedSec}s vergangen, ca. ${remainingSec}s verbleibend.`;
|
|
renderMessage(els.swrSummaryMessage, text, false, true);
|
|
renderMessage(els.swrPageMessage, text, false, true);
|
|
};
|
|
|
|
updateProgressMessage();
|
|
|
|
try {
|
|
const payload = await api("/v1/swr/run-check", {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
const reportFromRun = payload && payload.result && payload.result.report ? payload.result.report : null;
|
|
const reportFromView = payload && payload.report ? payload.report : null;
|
|
if (reportFromRun) {
|
|
state.swrReport = reportFromRun;
|
|
renderSwrPanels();
|
|
} else if (reportFromView) {
|
|
state.swrReport = reportFromView;
|
|
renderSwrPanels();
|
|
} else {
|
|
await refreshSwrReport();
|
|
}
|
|
const finishedSec = Math.max(1, Math.floor((Date.now() - startedAt) / 1000));
|
|
const overall = state.swrReport && state.swrReport.overallStatus ? state.swrReport.overallStatus : "UNKNOWN";
|
|
const doneText = `SWR-Check ERFOLGREICH abgeschlossen nach ${finishedSec}s. Ergebnis: ${overall}.`;
|
|
renderMessage(els.swrSummaryMessage, doneText, false, true);
|
|
renderMessage(els.swrPageMessage, doneText, false, true);
|
|
} catch (error) {
|
|
state.swrReport = previousReport;
|
|
renderSwrPanels();
|
|
renderMessage(els.swrSummaryMessage, error.message, true);
|
|
renderMessage(els.swrPageMessage, error.message, true);
|
|
} finally {
|
|
setSwrRunButtonsBusy(false);
|
|
}
|
|
}
|
|
|
|
function setSwrRunButtonsBusy(isBusy) {
|
|
const swrRunning = Boolean(state.status && state.status.swrRun && state.status.swrRun.running);
|
|
const disabled = Boolean(isBusy) || swrRunning;
|
|
if (els.runSwrCheckBtn) {
|
|
els.runSwrCheckBtn.disabled = disabled;
|
|
}
|
|
if (els.runSwrCheckPageBtn) {
|
|
els.runSwrCheckPageBtn.disabled = disabled;
|
|
}
|
|
}
|
|
|
|
function renderSwrPanels() {
|
|
const report = state.swrReport;
|
|
const generatedAtText = report && report.generatedAt
|
|
? `Stand: ${new Date(report.generatedAt).toLocaleString(localeForDate())}`
|
|
: "Stand: -";
|
|
const overallText = `Gesamt: ${report && report.overallStatus ? report.overallStatus : "UNKNOWN"}`;
|
|
|
|
if (els.swrSummaryGeneratedAt) {
|
|
els.swrSummaryGeneratedAt.textContent = generatedAtText;
|
|
}
|
|
if (els.swrSummaryOverall) {
|
|
els.swrSummaryOverall.textContent = overallText;
|
|
}
|
|
if (els.swrPageGeneratedAt) {
|
|
els.swrPageGeneratedAt.textContent = generatedAtText;
|
|
}
|
|
if (els.swrPageOverall) {
|
|
els.swrPageOverall.textContent = overallText;
|
|
}
|
|
|
|
renderSwrBandsInto(els.swrSummaryBands, report, { withImages: false, compact: true });
|
|
renderSwrBandsInto(els.swrPageBands, report, { withImages: true, compact: false });
|
|
}
|
|
|
|
function renderSwrBandsInto(container, report, options = {}) {
|
|
if (!container) return;
|
|
container.innerHTML = "";
|
|
const bands = report && Array.isArray(report.bands) ? report.bands : [];
|
|
if (!bands.length) {
|
|
container.textContent = "Keine SWR Daten vorhanden.";
|
|
return;
|
|
}
|
|
if (options.compact) {
|
|
container.classList.add("swr-summary-list");
|
|
for (const band of bands) {
|
|
const row = document.createElement("button");
|
|
row.type = "button";
|
|
row.className = "swr-summary-row swr-summary-link";
|
|
row.title = `${band.band} in SWR-Detailseite anzeigen`;
|
|
row.addEventListener("click", () => {
|
|
navigateRmsPage("swr");
|
|
setTimeout(() => {
|
|
scrollToSwrBand(band.band);
|
|
}, 0);
|
|
});
|
|
|
|
const bandText = document.createElement("strong");
|
|
bandText.textContent = band.band;
|
|
row.appendChild(bandText);
|
|
|
|
const status = document.createElement("span");
|
|
status.className = "pill";
|
|
status.textContent = band.status || "UNKNOWN";
|
|
row.appendChild(status);
|
|
|
|
container.appendChild(row);
|
|
}
|
|
return;
|
|
}
|
|
|
|
container.classList.remove("swr-summary-list");
|
|
for (const band of bands) {
|
|
const imageVersion = band.updatedAt || "";
|
|
const imageUrl = withCacheVersion(band.imageUrl, imageVersion);
|
|
const block = document.createElement("div");
|
|
block.className = "plugin-block";
|
|
block.id = swrBandAnchorId(band.band);
|
|
block.dataset.swrBand = String(band.band || "").toLowerCase();
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("strong");
|
|
title.textContent = band.band;
|
|
head.appendChild(title);
|
|
const status = document.createElement("span");
|
|
status.className = "pill";
|
|
status.textContent = band.status || "UNKNOWN";
|
|
head.appendChild(status);
|
|
block.appendChild(head);
|
|
|
|
if (band.updatedAt) {
|
|
const updated = document.createElement("p");
|
|
updated.className = "muted";
|
|
updated.textContent = `Bildstand: ${new Date(band.updatedAt).toLocaleString(localeForDate())}`;
|
|
block.appendChild(updated);
|
|
}
|
|
|
|
if (options.withImages && imageUrl) {
|
|
const img = document.createElement("img");
|
|
img.src = imageUrl;
|
|
img.alt = `SWR ${band.band}`;
|
|
img.className = "swr-band-image";
|
|
block.appendChild(img);
|
|
}
|
|
|
|
if (!options.withImages && imageUrl) {
|
|
const link = document.createElement("a");
|
|
link.href = imageUrl;
|
|
link.target = "_blank";
|
|
link.rel = "noopener";
|
|
link.className = "ghost-btn";
|
|
link.textContent = `${band.band} Grafik`;
|
|
block.appendChild(link);
|
|
}
|
|
|
|
container.appendChild(block);
|
|
}
|
|
}
|
|
|
|
function swrBandAnchorId(band) {
|
|
const normalized = String(band || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
|
|
return `swr-band-${normalized || "unknown"}`;
|
|
}
|
|
|
|
function scrollToSwrBand(band) {
|
|
const id = swrBandAnchorId(band);
|
|
const target = document.getElementById(id);
|
|
if (!target) {
|
|
return;
|
|
}
|
|
target.scrollIntoView({ behavior: "smooth", block: "start" });
|
|
}
|
|
|
|
async function refreshControls() {
|
|
try {
|
|
const response = await api("/v1/ui/controls");
|
|
state.controls = response.controls || [];
|
|
renderPluginControls();
|
|
} catch (error) {
|
|
renderMessage(els.pluginMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshPlugins() {
|
|
if (!isAdmin()) {
|
|
state.plugins = [];
|
|
state.providers = {};
|
|
state.capabilities = [];
|
|
renderPluginAdmin();
|
|
renderProviderAdmin();
|
|
renderCapabilityMatrix();
|
|
await refreshPublicAuthMethods();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/plugins");
|
|
state.plugins = result.plugins || [];
|
|
state.providers = result.providers || {};
|
|
state.capabilities = result.capabilities || [];
|
|
renderPluginAdmin();
|
|
renderProviderAdmin();
|
|
renderCapabilityMatrix();
|
|
await refreshPublicAuthMethods();
|
|
} catch (error) {
|
|
renderMessage(els.adminMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshUsers() {
|
|
if (!canSeeUsersList()) {
|
|
state.users = [];
|
|
renderUsersAdmin();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/admin/users");
|
|
state.users = result.users || [];
|
|
renderUsersAdmin();
|
|
} catch (error) {
|
|
renderMessage(els.usersMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshApprovals() {
|
|
if (!canSeeApprovals()) {
|
|
state.approvals = [];
|
|
renderApprovals();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/approvals");
|
|
state.approvals = result.approvals || [];
|
|
renderApprovals();
|
|
} catch (error) {
|
|
renderMessage(els.approvalsMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshActivityLog() {
|
|
if (!canSeeActivityLog()) {
|
|
state.activityEntries = [];
|
|
renderActivityLog();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/activity-log?limit=300");
|
|
state.activityEntries = Array.isArray(result.entries) ? result.entries : [];
|
|
renderActivityLog();
|
|
} catch (error) {
|
|
renderMessage(els.activityMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function refreshHelpContent() {
|
|
if (!state.user) {
|
|
state.helpContent = null;
|
|
renderHelpContent();
|
|
return;
|
|
}
|
|
try {
|
|
const result = await api("/v1/help/content");
|
|
state.helpContent = result && result.content ? result.content : null;
|
|
renderHelpContent();
|
|
} catch (error) {
|
|
state.helpContent = null;
|
|
renderHelpContent();
|
|
if (els.helpMessage) {
|
|
renderMessage(els.helpMessage, error.message, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
function renderHelpContent() {
|
|
if (!els.helpSections || !els.helpQuickStartSteps) {
|
|
return;
|
|
}
|
|
els.helpSections.innerHTML = "";
|
|
els.helpQuickStartSteps.innerHTML = "";
|
|
|
|
const content = state.helpContent;
|
|
if (!content) {
|
|
if (els.helpTitle) {
|
|
els.helpTitle.textContent = "Hilfe";
|
|
}
|
|
if (els.helpQuickStartTitle) {
|
|
els.helpQuickStartTitle.textContent = "Schnellstart";
|
|
}
|
|
const li = document.createElement("li");
|
|
li.className = "muted";
|
|
li.textContent = "Keine Hilfedaten geladen.";
|
|
els.helpQuickStartSteps.appendChild(li);
|
|
return;
|
|
}
|
|
|
|
if (els.helpTitle) {
|
|
els.helpTitle.textContent = content.title || "Hilfe";
|
|
}
|
|
if (els.helpQuickStartTitle) {
|
|
els.helpQuickStartTitle.textContent = content.quickStart && content.quickStart.title
|
|
? content.quickStart.title
|
|
: "Schnellstart";
|
|
}
|
|
|
|
const quickSteps = content.quickStart && Array.isArray(content.quickStart.steps)
|
|
? content.quickStart.steps
|
|
: [];
|
|
for (const step of quickSteps) {
|
|
const li = document.createElement("li");
|
|
li.textContent = String(step);
|
|
els.helpQuickStartSteps.appendChild(li);
|
|
}
|
|
if (!quickSteps.length) {
|
|
const li = document.createElement("li");
|
|
li.className = "muted";
|
|
li.textContent = "Keine Schnellstart-Schritte hinterlegt.";
|
|
els.helpQuickStartSteps.appendChild(li);
|
|
}
|
|
|
|
const sections = Array.isArray(content.sections) ? content.sections : [];
|
|
for (const section of sections) {
|
|
const block = document.createElement("section");
|
|
block.className = "plugin-block";
|
|
|
|
const title = document.createElement("h3");
|
|
title.textContent = String(section && section.title ? section.title : "Hinweis");
|
|
block.appendChild(title);
|
|
|
|
const lines = Array.isArray(section && section.body) ? section.body : [];
|
|
for (const line of lines) {
|
|
const p = document.createElement("p");
|
|
p.textContent = String(line);
|
|
block.appendChild(p);
|
|
}
|
|
|
|
els.helpSections.appendChild(block);
|
|
}
|
|
}
|
|
|
|
function renderActivityLog() {
|
|
if (!els.activityLogList) return;
|
|
els.activityLogList.innerHTML = "";
|
|
if (!canSeeActivityLog()) return;
|
|
const sourceEntries = state.activityEntries.filter((entry) => {
|
|
if (state.activityFilter.type !== "all" && entry.action !== state.activityFilter.type) {
|
|
return false;
|
|
}
|
|
if (state.activityFilter.query) {
|
|
const haystack = `${String(entry.email || "")} ${String(entry.message || "")} ${String(entry.action || "")}`.toLowerCase();
|
|
if (!haystack.includes(state.activityFilter.query)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
if (!sourceEntries.length) {
|
|
els.activityLogList.textContent = "Keine Aktivitaetsdaten vorhanden.";
|
|
return;
|
|
}
|
|
for (const entry of sourceEntries) {
|
|
const block = document.createElement("div");
|
|
block.className = "plugin-block";
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("strong");
|
|
title.textContent = new Date(entry.at).toLocaleString(localeForDate());
|
|
head.appendChild(title);
|
|
const pill = document.createElement("span");
|
|
pill.className = "pill";
|
|
pill.textContent = entry.action;
|
|
head.appendChild(pill);
|
|
block.appendChild(head);
|
|
|
|
const text = document.createElement("p");
|
|
text.textContent = entry.message || entry.action;
|
|
block.appendChild(text);
|
|
|
|
if (entry.details) {
|
|
const details = document.createElement("pre");
|
|
details.className = "audit-log";
|
|
details.textContent = JSON.stringify(entry.details, null, 2);
|
|
block.appendChild(details);
|
|
}
|
|
els.activityLogList.appendChild(block);
|
|
}
|
|
}
|
|
|
|
function renderUsersAdmin() {
|
|
if (!els.usersAdmin) return;
|
|
els.usersAdmin.innerHTML = "";
|
|
if (!canSeeUsersList()) return;
|
|
const readOnly = !isAdmin();
|
|
if (readOnly) {
|
|
const hint = document.createElement("p");
|
|
hint.className = "muted";
|
|
hint.textContent = "Read-only Ansicht: Rollen und Methoden koennen nur von Admin bearbeitet werden.";
|
|
els.usersAdmin.appendChild(hint);
|
|
}
|
|
if (!state.users.length) {
|
|
const empty = document.createElement("p");
|
|
empty.className = "muted";
|
|
empty.textContent = "Keine Benutzer gefunden.";
|
|
els.usersAdmin.appendChild(empty);
|
|
return;
|
|
}
|
|
const filteredUsers = state.users.filter((user) => {
|
|
const query = state.usersFilter.query;
|
|
const role = state.usersFilter.role;
|
|
const status = state.usersFilter.status;
|
|
if (query && !String(user.email || "").toLowerCase().includes(query)) {
|
|
return false;
|
|
}
|
|
if (role !== "all" && user.role !== role) {
|
|
return false;
|
|
}
|
|
if (status !== "all" && user.status !== status) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
const sortedUsers = [...filteredUsers].sort((a, b) => {
|
|
const roleWeight = { admin: 0, approver: 1, operator: 2 };
|
|
const aWeight = roleWeight[a.role] ?? 9;
|
|
const bWeight = roleWeight[b.role] ?? 9;
|
|
if (aWeight !== bWeight) {
|
|
return aWeight - bWeight;
|
|
}
|
|
return String(a.email || "").localeCompare(String(b.email || ""));
|
|
});
|
|
|
|
if (!sortedUsers.length) {
|
|
const emptyFiltered = document.createElement("p");
|
|
emptyFiltered.className = "muted";
|
|
emptyFiltered.textContent = "Keine Benutzer fuer den aktuellen Filter gefunden.";
|
|
els.usersAdmin.appendChild(emptyFiltered);
|
|
return;
|
|
}
|
|
|
|
for (const user of sortedUsers) {
|
|
const block = document.createElement("div");
|
|
block.className = "plugin-block";
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("h3");
|
|
title.textContent = user.email;
|
|
head.appendChild(title);
|
|
const status = document.createElement("span");
|
|
status.className = "pill";
|
|
status.textContent = `${user.role} | ${user.status}`;
|
|
head.appendChild(status);
|
|
block.appendChild(head);
|
|
|
|
if (!readOnly) {
|
|
const controls = document.createElement("div");
|
|
controls.className = "actions";
|
|
for (const role of ["operator", "approver", "admin"]) {
|
|
const btn = document.createElement("button");
|
|
btn.type = "button";
|
|
btn.className = role === user.role ? "ghost-btn" : "";
|
|
btn.textContent = role;
|
|
btn.disabled = role === user.role;
|
|
btn.addEventListener("click", async () => {
|
|
await updateUserRole(user.id, role);
|
|
});
|
|
controls.appendChild(btn);
|
|
}
|
|
block.appendChild(controls);
|
|
}
|
|
|
|
if (state.authMethods.length) {
|
|
const methodsWrap = document.createElement("div");
|
|
methodsWrap.className = "stack";
|
|
const hint = document.createElement("span");
|
|
hint.className = "muted";
|
|
hint.textContent = "Bestaetigungsarten";
|
|
methodsWrap.appendChild(hint);
|
|
|
|
const enabledMethods = new Set(Array.isArray(user.enabledAuthMethods) ? user.enabledAuthMethods : []);
|
|
const methodChecks = [];
|
|
for (const method of state.authMethods) {
|
|
const label = document.createElement("label");
|
|
label.className = "field";
|
|
const caption = document.createElement("span");
|
|
caption.textContent = `${method.label} (${method.type})`;
|
|
const checkbox = document.createElement("input");
|
|
checkbox.type = "checkbox";
|
|
checkbox.checked = enabledMethods.has(method.id);
|
|
label.appendChild(caption);
|
|
label.appendChild(checkbox);
|
|
methodsWrap.appendChild(label);
|
|
methodChecks.push({ methodId: method.id, checkbox });
|
|
}
|
|
|
|
const primarySelect = document.createElement("select");
|
|
for (const method of state.authMethods) {
|
|
const option = document.createElement("option");
|
|
option.value = method.id;
|
|
option.textContent = `${method.label}`;
|
|
option.selected = method.id === user.primaryAuthMethod;
|
|
primarySelect.appendChild(option);
|
|
}
|
|
methodsWrap.appendChild(primarySelect);
|
|
|
|
if (readOnly) {
|
|
for (const entry of methodChecks) {
|
|
entry.checkbox.disabled = true;
|
|
}
|
|
primarySelect.disabled = true;
|
|
} else {
|
|
const saveBtn = document.createElement("button");
|
|
saveBtn.type = "button";
|
|
saveBtn.textContent = "Auth-Methoden speichern";
|
|
saveBtn.addEventListener("click", async () => {
|
|
const enabled = methodChecks.filter((entry) => entry.checkbox.checked).map((entry) => entry.methodId);
|
|
await updateUserAuthMethods(user.id, enabled, primarySelect.value);
|
|
});
|
|
methodsWrap.appendChild(saveBtn);
|
|
}
|
|
block.appendChild(methodsWrap);
|
|
}
|
|
|
|
els.usersAdmin.appendChild(block);
|
|
}
|
|
}
|
|
|
|
function renderApprovals() {
|
|
if (!els.approvalsList) return;
|
|
els.approvalsList.innerHTML = "";
|
|
if (!canSeeApprovals()) return;
|
|
const showOpenOnly = state.approvalsFilter.mode !== "all";
|
|
els.approvalsFilterOpenBtn.classList.toggle("active", showOpenOnly);
|
|
els.approvalsFilterAllBtn.classList.toggle("active", !showOpenOnly);
|
|
|
|
const sourceApprovals = state.approvals.filter((entry) => {
|
|
if (showOpenOnly && entry.status !== "pending") {
|
|
return false;
|
|
}
|
|
if (state.approvalsFilter.status !== "all" && entry.status !== state.approvalsFilter.status) {
|
|
return false;
|
|
}
|
|
if (state.approvalsFilter.query) {
|
|
const email = String(entry.email || "").toLowerCase();
|
|
if (!email.includes(state.approvalsFilter.query)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
if (!sourceApprovals.length) {
|
|
els.approvalsList.textContent = "Keine Freigabe-Anfragen vorhanden.";
|
|
return;
|
|
}
|
|
const statusWeight = { pending: 0, approved: 1, rejected: 2 };
|
|
const sortedApprovals = [...sourceApprovals].sort((a, b) => {
|
|
const aWeight = statusWeight[a.status] ?? 9;
|
|
const bWeight = statusWeight[b.status] ?? 9;
|
|
if (aWeight !== bWeight) {
|
|
return aWeight - bWeight;
|
|
}
|
|
return new Date(b.updatedAt || b.createdAt || 0).getTime() - new Date(a.updatedAt || a.createdAt || 0).getTime();
|
|
});
|
|
|
|
for (const entry of sortedApprovals) {
|
|
const block = document.createElement("div");
|
|
block.className = "plugin-block";
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("h3");
|
|
title.textContent = entry.email;
|
|
head.appendChild(title);
|
|
const status = document.createElement("span");
|
|
status.className = "pill";
|
|
status.classList.add(`approval-${entry.status}`);
|
|
status.textContent = entry.status;
|
|
head.appendChild(status);
|
|
block.appendChild(head);
|
|
|
|
const meta = document.createElement("p");
|
|
meta.className = "muted";
|
|
meta.textContent = `Erstellt: ${new Date(entry.createdAt).toLocaleString(localeForDate())} | Account: ${entry.userStatus || "-"} (${entry.userRole || "-"}) | Zuletzt: ${entry.updatedBy || "-"}`;
|
|
block.appendChild(meta);
|
|
|
|
const actions = document.createElement("div");
|
|
actions.className = "actions";
|
|
const approveBtn = document.createElement("button");
|
|
approveBtn.type = "button";
|
|
approveBtn.textContent = entry.status === "approved" ? "Erneut freigeben" : "Freigeben";
|
|
approveBtn.addEventListener("click", async () => {
|
|
await decideApproval(entry.id, true);
|
|
});
|
|
actions.appendChild(approveBtn);
|
|
|
|
const rejectBtn = document.createElement("button");
|
|
rejectBtn.type = "button";
|
|
rejectBtn.className = "danger";
|
|
rejectBtn.textContent = entry.status === "rejected" ? "Erneut ablehnen" : "Ablehnen";
|
|
rejectBtn.addEventListener("click", async () => {
|
|
await decideApproval(entry.id, false);
|
|
});
|
|
actions.appendChild(rejectBtn);
|
|
block.appendChild(actions);
|
|
|
|
els.approvalsList.appendChild(block);
|
|
}
|
|
}
|
|
|
|
async function updateUserRole(userId, role) {
|
|
clearMessages("users");
|
|
try {
|
|
await api(`/v1/admin/users/${encodeURIComponent(userId)}/role`, {
|
|
method: "PUT",
|
|
body: { role }
|
|
});
|
|
await refreshUsers();
|
|
await refreshApprovals();
|
|
renderMessage(els.usersMessage, `Rolle auf ${role} gesetzt`, false, true);
|
|
} catch (error) {
|
|
renderMessage(els.usersMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function updateUserAuthMethods(userId, enabledMethods, primaryMethod) {
|
|
clearMessages("users");
|
|
try {
|
|
await api(`/v1/admin/users/${encodeURIComponent(userId)}/auth-methods`, {
|
|
method: "PUT",
|
|
body: { enabledMethods, primaryMethod }
|
|
});
|
|
await refreshUsers();
|
|
renderMessage(els.usersMessage, "Bestaetigungsarten gespeichert", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.usersMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function decideApproval(id, approve) {
|
|
clearMessages("approvals");
|
|
try {
|
|
await api(`/v1/approvals/${encodeURIComponent(id)}/${approve ? "approve" : "reject"}`, {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
await refreshApprovals();
|
|
await refreshUsers();
|
|
renderMessage(els.approvalsMessage, approve ? "Freigabe bestaetigt" : "Freigabe abgelehnt", false, true);
|
|
} catch (error) {
|
|
renderMessage(els.approvalsMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
function renderStatus() {
|
|
const status = state.status;
|
|
if (!status) {
|
|
stopRemainingUsageWatch();
|
|
if (els.remainingUsage) {
|
|
els.remainingUsage.textContent = "-";
|
|
}
|
|
return;
|
|
}
|
|
|
|
const activationRunning = Boolean(status.activation && status.activation.running);
|
|
|
|
els.stationName.textContent = status.stationName || "-";
|
|
els.usageStatus.textContent = status.isInUse
|
|
? translateLiteral("In Benutzung")
|
|
: (activationRunning ? translateLiteral("Aktivierung laeuft") : translateLiteral("Frei"));
|
|
els.activeBy.textContent = status.activeByEmail || "-";
|
|
els.startedAt.textContent = status.startedAt ? new Date(status.startedAt).toLocaleString(localeForDate()) : "-";
|
|
els.endsAt.textContent = status.endsAt ? new Date(status.endsAt).toLocaleString(localeForDate()) : "-";
|
|
renderRemainingUsage();
|
|
if (status.isInUse || activationRunning) {
|
|
startRemainingUsageWatch();
|
|
} else {
|
|
stopRemainingUsageWatch();
|
|
}
|
|
els.stationOnlinePill.textContent = status.stationOnline ? "Online" : "Offline";
|
|
els.stationOnlinePill.classList.toggle("ok", Boolean(status.stationOnline));
|
|
els.stationOnlinePill.classList.toggle("offline", !status.stationOnline);
|
|
|
|
if (status.maintenanceMode) {
|
|
renderMessage(els.statusMessage, status.maintenanceMessage || "Wartungsmodus aktiv", true);
|
|
}
|
|
|
|
const swrRun = status.swrRun || status.activation;
|
|
renderActivationProgress(swrRun);
|
|
renderReservationQueue(status);
|
|
renderStationLinks(status);
|
|
renderOpenWebRx(status);
|
|
|
|
const loggedIn = Boolean(state.user);
|
|
const swrRunning = Boolean(swrRun && swrRun.running);
|
|
const isOwner = loggedIn && state.user.email === status.activeByEmail;
|
|
const activeReservation = status.reservationQueue && status.reservationQueue.activeEntry
|
|
? status.reservationQueue.activeEntry
|
|
: null;
|
|
const slotLockActive = Boolean(status.reservationQueue && status.reservationQueue.slotLockActive && activeReservation);
|
|
const isSlotOwner = loggedIn
|
|
&& activeReservation
|
|
&& state.user
|
|
&& state.user.id
|
|
&& String(state.user.id) === String(activeReservation.userId || "");
|
|
const slotDenied = slotLockActive && !isSlotOwner && !isAdmin();
|
|
const canOperate = canOperateStation();
|
|
els.activateBtn.disabled = !loggedIn || !canOperate || activationRunning || swrRunning || !status.stationOnline || Boolean(status.isInUse) || Boolean(status.maintenanceMode) || slotDenied;
|
|
els.deactivateBtn.disabled = !loggedIn || !status.isInUse || (!isOwner && !isAdmin()) || slotDenied;
|
|
setSwrRunButtonsBusy(false);
|
|
}
|
|
|
|
function startRemainingUsageWatch() {
|
|
if (remainingUsageTimer) {
|
|
return;
|
|
}
|
|
remainingUsageTimer = setInterval(() => {
|
|
renderRemainingUsage();
|
|
}, 1000);
|
|
}
|
|
|
|
function stopRemainingUsageWatch() {
|
|
if (!remainingUsageTimer) {
|
|
return;
|
|
}
|
|
clearInterval(remainingUsageTimer);
|
|
remainingUsageTimer = null;
|
|
}
|
|
|
|
function renderRemainingUsage() {
|
|
if (!els.remainingUsage) {
|
|
return;
|
|
}
|
|
const status = state.status;
|
|
const activationRunning = Boolean(status && status.activation && status.activation.running);
|
|
if (!status || (!status.isInUse && !activationRunning)) {
|
|
els.remainingUsage.textContent = "-";
|
|
return;
|
|
}
|
|
|
|
const endsAtMs = Date.parse(String(status.endsAt || ""));
|
|
if (Number.isFinite(endsAtMs)) {
|
|
const remainingSec = Math.max(0, Math.ceil((endsAtMs - Date.now()) / 1000));
|
|
els.remainingUsage.textContent = formatRemainingUsage(remainingSec);
|
|
return;
|
|
}
|
|
|
|
els.remainingUsage.textContent = formatRemainingUsage(Math.max(0, Number(status.remainingUsageSec || 0)));
|
|
}
|
|
|
|
function renderReservationQueue(status) {
|
|
if (!els.reservationPanel || !els.reserveNextBtn || !els.reservationList) {
|
|
return;
|
|
}
|
|
const queue = status && status.reservationQueue && typeof status.reservationQueue === "object"
|
|
? status.reservationQueue
|
|
: { entries: [], canReserve: false };
|
|
const entries = Array.isArray(queue.entries) ? queue.entries : [];
|
|
const visible = Boolean(queue.visible);
|
|
const loggedIn = Boolean(state.user);
|
|
const canOperate = canOperateStation();
|
|
const isOwner = loggedIn && status && state.user && state.user.id && String(state.user.id) === String(status.activeByUserId || "");
|
|
const hasOwnReservation = loggedIn
|
|
&& state.user
|
|
&& entries.some((entry) => String(entry && entry.userId ? entry.userId : "") === String(state.user.id || ""));
|
|
|
|
els.reservationPanel.hidden = !visible;
|
|
els.reserveNextBtn.disabled = !loggedIn || !canOperate || !queue.canReserve || isOwner || hasOwnReservation;
|
|
|
|
els.reservationList.innerHTML = "";
|
|
if (!visible) {
|
|
return;
|
|
}
|
|
if (!entries.length) {
|
|
const empty = document.createElement("p");
|
|
empty.className = "muted";
|
|
empty.textContent = translateLiteral("Noch keine Reservierungen vorhanden.");
|
|
els.reservationList.appendChild(empty);
|
|
return;
|
|
}
|
|
|
|
const list = document.createElement("div");
|
|
list.className = "swr-summary-list";
|
|
let hasMineEntry = false;
|
|
entries.forEach((entry) => {
|
|
const row = document.createElement("div");
|
|
row.className = `swr-summary-row reservation-row${entry.active ? " reservation-row-active" : ""}`;
|
|
|
|
const left = document.createElement("div");
|
|
left.className = "stack";
|
|
|
|
const title = document.createElement("strong");
|
|
title.textContent = `#${Number(entry.position || 0)} ${entry.email || "-"}`;
|
|
|
|
const details = document.createElement("small");
|
|
details.className = "muted";
|
|
const fromText = entry.from
|
|
? new Date(entry.from).toLocaleString(localeForDate(), {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit",
|
|
hour: "2-digit",
|
|
minute: "2-digit"
|
|
})
|
|
: "-";
|
|
const toText = entry.to
|
|
? new Date(entry.to).toLocaleString(localeForDate(), {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit",
|
|
hour: "2-digit",
|
|
minute: "2-digit"
|
|
})
|
|
: "-";
|
|
details.textContent = `${fromText} - ${toText}`;
|
|
|
|
const pill = document.createElement("span");
|
|
pill.className = `pill${entry.active ? " ok" : ""}`;
|
|
if (entry.active) {
|
|
pill.textContent = translateLiteral("Aktiv");
|
|
} else {
|
|
const fromLabel = entry.from
|
|
? new Date(entry.from).toLocaleTimeString(localeForDate(), { hour: "2-digit", minute: "2-digit" })
|
|
: "-";
|
|
const toLabel = entry.to
|
|
? new Date(entry.to).toLocaleTimeString(localeForDate(), { hour: "2-digit", minute: "2-digit" })
|
|
: "-";
|
|
pill.textContent = `${fromLabel} - ${toLabel}`;
|
|
}
|
|
|
|
left.appendChild(title);
|
|
left.appendChild(details);
|
|
const right = document.createElement("div");
|
|
right.className = "actions";
|
|
right.appendChild(pill);
|
|
if (isAdmin() && entry && entry.userId) {
|
|
const adminDeleteBtn = document.createElement("button");
|
|
adminDeleteBtn.type = "button";
|
|
adminDeleteBtn.className = "ghost-btn danger";
|
|
adminDeleteBtn.textContent = translateLiteral("Reservierung loeschen");
|
|
adminDeleteBtn.title = translateLiteral("Reservierung dieses Benutzers loeschen");
|
|
adminDeleteBtn.addEventListener("click", async () => {
|
|
await cancelReservationByUserId(entry.userId);
|
|
});
|
|
right.appendChild(adminDeleteBtn);
|
|
}
|
|
|
|
row.appendChild(left);
|
|
row.appendChild(right);
|
|
list.appendChild(row);
|
|
|
|
const isMine = loggedIn
|
|
&& state.user
|
|
&& String(entry.userId || "") === String(state.user.id || "");
|
|
hasMineEntry = hasMineEntry || isMine;
|
|
});
|
|
els.reservationList.appendChild(list);
|
|
|
|
if (hasMineEntry) {
|
|
const removeWrap = document.createElement("div");
|
|
removeWrap.className = "actions";
|
|
const removeBtn = document.createElement("button");
|
|
removeBtn.type = "button";
|
|
removeBtn.className = "ghost-btn danger";
|
|
removeBtn.textContent = translateLiteral("Meine Reservierung loeschen");
|
|
removeBtn.addEventListener("click", async () => {
|
|
await cancelOwnReservation();
|
|
});
|
|
removeWrap.appendChild(removeBtn);
|
|
els.reservationList.appendChild(removeWrap);
|
|
}
|
|
}
|
|
|
|
function renderOpenWebRx(status) {
|
|
if (!els.openwebrxPanel) {
|
|
return;
|
|
}
|
|
const loggedIn = Boolean(state.user);
|
|
const isOwner = loggedIn && status && status.isInUse && state.user.id && state.user.id === status.activeByUserId;
|
|
els.openwebrxPanel.hidden = !isOwner;
|
|
if (els.controlsPanel) {
|
|
els.controlsPanel.hidden = !isOwner;
|
|
}
|
|
if (!isOwner) {
|
|
stopOpenWebRxTxPolling();
|
|
state.openWebRx.sessionUrl = "";
|
|
state.openWebRx.sessionTicket = "";
|
|
state.openWebRx.expiresAt = null;
|
|
state.openWebRx.bands = [];
|
|
state.openWebRx.selectedBand = "";
|
|
state.openWebRx.txActive = null;
|
|
state.openWebRx.rotor = {
|
|
azimuth: null,
|
|
moving: false,
|
|
min: 0,
|
|
max: 360
|
|
};
|
|
syncOpenWebRxTicketCookie("");
|
|
renderOpenWebRxBandOptions();
|
|
renderOpenWebRxTxState();
|
|
renderRotorState();
|
|
renderOpenWebRxSessionAccess();
|
|
return;
|
|
}
|
|
startOpenWebRxTxPolling();
|
|
if (els.openwebrxOpenBtn) {
|
|
els.openwebrxOpenBtn.disabled = Boolean(status.activation && status.activation.running) || state.openWebRx.busy;
|
|
}
|
|
setOpenWebRxBusy(state.openWebRx.busy);
|
|
}
|
|
|
|
function renderActivationProgress(activation) {
|
|
const running = Boolean(activation && activation.running);
|
|
renderSingleActivationProgress({
|
|
box: els.activationProgress,
|
|
fill: els.progressFill,
|
|
text: els.progressText,
|
|
eta: els.progressEta
|
|
}, activation, running);
|
|
renderSingleActivationProgress({
|
|
box: els.activationProgressSwr,
|
|
fill: els.progressFillSwr,
|
|
text: els.progressTextSwr,
|
|
eta: els.progressEtaSwr
|
|
}, activation, running);
|
|
if (!running) {
|
|
stopActivationWatch();
|
|
return;
|
|
}
|
|
startActivationWatch();
|
|
}
|
|
|
|
function renderSingleActivationProgress(target, activation, running) {
|
|
if (!target || !target.box || !target.fill || !target.text || !target.eta) {
|
|
return;
|
|
}
|
|
target.box.hidden = !running;
|
|
if (!running) {
|
|
target.fill.style.width = "0%";
|
|
target.text.textContent = "-";
|
|
target.eta.textContent = "Geschaetzte Restzeit: -";
|
|
return;
|
|
}
|
|
const percent = Number(activation.percent || 0);
|
|
const elapsedSec = Number(activation.elapsedSec || 0);
|
|
const remainingSec = Number(activation.remainingSec || 0);
|
|
const phase = String(activation.phase || "swr-check");
|
|
target.fill.style.width = `${Math.max(0, Math.min(100, percent))}%`;
|
|
target.text.textContent = `${elapsedSec}s`;
|
|
target.eta.textContent = `SWR-Status: ${phase}${remainingSec > 0 ? `, noch ca. ${remainingSec}s` : ""}`;
|
|
}
|
|
|
|
function startActivationWatch() {
|
|
if (activationWatchTimer) {
|
|
return;
|
|
}
|
|
activationWatchTimer = setInterval(async () => {
|
|
if (activationWatchInFlight || !state.user) {
|
|
return;
|
|
}
|
|
activationWatchInFlight = true;
|
|
try {
|
|
await refreshStatus();
|
|
const activation = state.status && state.status.activation ? state.status.activation : null;
|
|
const swrRun = state.status && state.status.swrRun ? state.status.swrRun : null;
|
|
if (activation && activation.running && String(activation.phase || "") !== "swr-check") {
|
|
clearActivationSwrWaitingMessages();
|
|
}
|
|
await refreshSwrReport();
|
|
if (!(swrRun && swrRun.running)) {
|
|
if (activationPending && !(state.status && state.status.isInUse)) {
|
|
const activation = state.status && state.status.activation ? state.status.activation : null;
|
|
const reason = activation && activation.lastStatus === "failed" && activation.lastError
|
|
? `: ${activation.lastError}`
|
|
: ". Bitte Logs pruefen.";
|
|
const failText = `SWR-Check fertig, Aktivierung fehlgeschlagen${reason}`;
|
|
renderMessage(els.swrSummaryMessage, failText, true);
|
|
renderMessage(els.swrPageMessage, failText, true);
|
|
}
|
|
activationPending = false;
|
|
stopActivationWatch();
|
|
await refreshControls();
|
|
}
|
|
} catch {
|
|
// ignore watch errors
|
|
} finally {
|
|
activationWatchInFlight = false;
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
function stopActivationWatch() {
|
|
if (!activationWatchTimer) {
|
|
return;
|
|
}
|
|
clearInterval(activationWatchTimer);
|
|
activationWatchTimer = null;
|
|
}
|
|
|
|
function clearActivationSwrWaitingMessages() {
|
|
const waitingPrefix = "SWR-Messung laeuft";
|
|
const targets = [els.swrSummaryMessage, els.swrPageMessage];
|
|
for (const target of targets) {
|
|
if (!target || typeof target.textContent !== "string") {
|
|
continue;
|
|
}
|
|
if (target.textContent.trim().startsWith(waitingPrefix)) {
|
|
target.textContent = "";
|
|
target.className = "message";
|
|
}
|
|
}
|
|
}
|
|
|
|
function renderStationLinks(status) {
|
|
if (!els.stationLinks) {
|
|
return;
|
|
}
|
|
const links = status && status.links ? status.links : {};
|
|
const ready = Boolean(status && status.linksReady);
|
|
const hasAny = Boolean(links.swrOverview || links.openWebRxPath || links.webSdr || links.rotorControl);
|
|
els.stationLinks.hidden = !(ready && hasAny);
|
|
setLink(els.swrLink, links.swrOverview);
|
|
setLink(els.openwebrxLink, links.openWebRxPath || null);
|
|
setLink(els.websdrLink, links.webSdr);
|
|
setLink(els.rotorLink, links.rotorControl);
|
|
}
|
|
|
|
function setLink(el, href) {
|
|
if (!el) {
|
|
return;
|
|
}
|
|
if (!href) {
|
|
el.hidden = true;
|
|
el.removeAttribute("href");
|
|
return;
|
|
}
|
|
el.hidden = false;
|
|
el.href = href;
|
|
}
|
|
|
|
function renderPluginControls() {
|
|
els.pluginControls.innerHTML = "";
|
|
if (!state.controls.length) {
|
|
els.pluginControls.textContent = "Keine dynamischen Controls verfuegbar.";
|
|
return;
|
|
}
|
|
|
|
for (const control of state.controls) {
|
|
if (control.controlId === "station-main") {
|
|
continue;
|
|
}
|
|
const wrapper = document.createElement("div");
|
|
wrapper.className = "card";
|
|
wrapper.style.padding = "0.8rem";
|
|
|
|
const title = document.createElement("h3");
|
|
title.textContent = control.title;
|
|
wrapper.appendChild(title);
|
|
|
|
const status = document.createElement("p");
|
|
status.className = "muted";
|
|
status.textContent = JSON.stringify(control.status || {});
|
|
wrapper.appendChild(status);
|
|
|
|
const actions = document.createElement("div");
|
|
actions.className = "schema-form";
|
|
for (const action of control.actions || []) {
|
|
const form = document.createElement("form");
|
|
form.className = "schema-form";
|
|
const formFields = renderActionFields(form, action.inputSchema || {});
|
|
|
|
const submit = document.createElement("button");
|
|
submit.type = "submit";
|
|
submit.textContent = action.name;
|
|
form.appendChild(submit);
|
|
|
|
form.addEventListener("submit", async (event) => {
|
|
event.preventDefault();
|
|
const input = readActionInput(formFields);
|
|
await executePluginAction(control, action, input);
|
|
});
|
|
|
|
actions.appendChild(form);
|
|
}
|
|
wrapper.appendChild(actions);
|
|
els.pluginControls.appendChild(wrapper);
|
|
}
|
|
}
|
|
|
|
function renderActionFields(form, schema) {
|
|
const fields = [];
|
|
const properties = schema && schema.properties ? schema.properties : {};
|
|
for (const [name, fieldSchema] of Object.entries(properties)) {
|
|
const label = document.createElement("label");
|
|
label.className = "field";
|
|
const caption = document.createElement("span");
|
|
caption.textContent = name;
|
|
label.appendChild(caption);
|
|
|
|
const required = Array.isArray(schema.required) && schema.required.includes(name);
|
|
|
|
if (Array.isArray(fieldSchema.enum)) {
|
|
const select = document.createElement("select");
|
|
select.name = name;
|
|
select.required = required;
|
|
for (const optionValue of fieldSchema.enum) {
|
|
const option = document.createElement("option");
|
|
option.value = String(optionValue);
|
|
option.textContent = String(optionValue);
|
|
select.appendChild(option);
|
|
}
|
|
label.appendChild(select);
|
|
fields.push({ name, type: fieldSchema.type || "string", element: select });
|
|
} else {
|
|
const input = document.createElement("input");
|
|
input.name = name;
|
|
input.required = required;
|
|
if (fieldSchema.type === "number" || fieldSchema.type === "integer") {
|
|
input.type = "number";
|
|
if (fieldSchema.type === "integer") input.step = "1";
|
|
if (fieldSchema.minimum !== undefined) input.min = String(fieldSchema.minimum);
|
|
if (fieldSchema.maximum !== undefined) input.max = String(fieldSchema.maximum);
|
|
} else if (fieldSchema.type === "boolean") {
|
|
input.type = "checkbox";
|
|
} else {
|
|
input.type = "text";
|
|
}
|
|
if (fieldSchema.default !== undefined) {
|
|
if (fieldSchema.type === "boolean") {
|
|
input.checked = Boolean(fieldSchema.default);
|
|
} else {
|
|
input.value = String(fieldSchema.default);
|
|
}
|
|
}
|
|
label.appendChild(input);
|
|
fields.push({ name, type: fieldSchema.type || "string", element: input });
|
|
}
|
|
|
|
form.appendChild(label);
|
|
}
|
|
return fields;
|
|
}
|
|
|
|
function readActionInput(fields) {
|
|
const input = {};
|
|
for (const field of fields) {
|
|
if (!field || !field.element) {
|
|
continue;
|
|
}
|
|
if (field.type === "boolean" && !field.hasSavedValue && !field.dirty && !field.element.checked) {
|
|
continue;
|
|
}
|
|
const raw = field.type === "boolean" ? String(field.element.checked) : field.element.value;
|
|
if (raw === "") {
|
|
if (field.dirty && (field.type === "string" || !field.type)) {
|
|
input[field.name] = "";
|
|
}
|
|
continue;
|
|
}
|
|
if (field.type === "number" || field.type === "integer") {
|
|
const parsed = Number(raw);
|
|
input[field.name] = field.type === "integer" ? Math.trunc(parsed) : parsed;
|
|
} else if (field.type === "boolean") {
|
|
input[field.name] = field.element.checked;
|
|
} else {
|
|
input[field.name] = raw;
|
|
}
|
|
}
|
|
return input;
|
|
}
|
|
|
|
async function executePluginAction(control, action, input) {
|
|
clearMessages("plugin");
|
|
try {
|
|
await api(`/v1/ui/controls/${encodeURIComponent(control.controlId)}/actions/${encodeURIComponent(action.name)}`, {
|
|
method: "POST",
|
|
body: { input }
|
|
});
|
|
renderMessage(els.pluginMessage, `${control.title}: ${action.name} ausgefuehrt`, false, true);
|
|
await refreshStatus();
|
|
await refreshControls();
|
|
} catch (error) {
|
|
renderMessage(els.pluginMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
function renderPluginAdmin() {
|
|
renderPluginAdminInto(els.pluginsAdminConfig);
|
|
}
|
|
|
|
function renderPluginAdminInto(container) {
|
|
if (!container) {
|
|
return;
|
|
}
|
|
container.innerHTML = "";
|
|
if (!isAdmin()) {
|
|
return;
|
|
}
|
|
if (!state.plugins.length) {
|
|
container.textContent = "Keine Plugins gefunden.";
|
|
return;
|
|
}
|
|
|
|
for (const plugin of state.plugins) {
|
|
const block = document.createElement("div");
|
|
block.className = "plugin-block";
|
|
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("h3");
|
|
title.textContent = `${plugin.name} (${plugin.id})`;
|
|
head.appendChild(title);
|
|
|
|
const toggle = document.createElement("button");
|
|
toggle.type = "button";
|
|
toggle.className = plugin.enabled ? "danger" : "";
|
|
toggle.textContent = plugin.enabled ? "Deaktivieren" : "Aktivieren";
|
|
toggle.addEventListener("click", async () => {
|
|
await togglePlugin(plugin.id, plugin.enabled);
|
|
});
|
|
head.appendChild(toggle);
|
|
block.appendChild(head);
|
|
|
|
const caps = document.createElement("p");
|
|
caps.className = "muted";
|
|
caps.textContent = `Capabilities: ${(plugin.capabilities || []).join(", ") || "-"}`;
|
|
block.appendChild(caps);
|
|
|
|
const settingsSchema = plugin.settingsSchema || { type: "object", properties: {} };
|
|
const hasSettings = settingsSchema && settingsSchema.properties && Object.keys(settingsSchema.properties).length > 0;
|
|
if (hasSettings) {
|
|
const settingsTitle = document.createElement("span");
|
|
settingsTitle.className = "muted";
|
|
settingsTitle.textContent = "Plugin Settings";
|
|
block.appendChild(settingsTitle);
|
|
|
|
const settingsForm = document.createElement("form");
|
|
settingsForm.className = "schema-form";
|
|
const settingFields = renderSchemaForm(settingsForm, settingsSchema, plugin.settings || {});
|
|
maybeAttachMicrohamEqBuilder(settingsForm, settingFields, plugin);
|
|
|
|
const save = document.createElement("button");
|
|
save.type = "submit";
|
|
save.textContent = "Settings speichern";
|
|
settingsForm.appendChild(save);
|
|
|
|
settingsForm.addEventListener("submit", async (event) => {
|
|
event.preventDefault();
|
|
await savePluginSettings(plugin.id, settingFields);
|
|
});
|
|
|
|
block.appendChild(settingsForm);
|
|
}
|
|
|
|
container.appendChild(block);
|
|
}
|
|
}
|
|
|
|
function maybeAttachMicrohamEqBuilder(settingsForm, settingFields, plugin) {
|
|
if (!settingsForm || !Array.isArray(settingFields) || !plugin || plugin.id !== "rms.microham") {
|
|
return;
|
|
}
|
|
const extraArgsField = settingFields.find((field) => field && field.name === "audioFfmpegExtraArgs" && field.element);
|
|
if (!extraArgsField || !extraArgsField.element) {
|
|
return;
|
|
}
|
|
|
|
const presets = {
|
|
flat: {
|
|
hp: 250,
|
|
lp: 2800,
|
|
mids: 0,
|
|
presence: 0,
|
|
deesserEnabled: false,
|
|
deesserFreq: 5200,
|
|
deesserCut: 0,
|
|
compressorEnabled: false,
|
|
compressorThreshold: -18,
|
|
compressorRatio: 2.5,
|
|
gateEnabled: false,
|
|
gateThreshold: -52,
|
|
gateRelease: 180,
|
|
limiter: true
|
|
},
|
|
dx: {
|
|
hp: 360,
|
|
lp: 2500,
|
|
mids: 1.0,
|
|
presence: 1.8,
|
|
deesserEnabled: true,
|
|
deesserFreq: 5200,
|
|
deesserCut: 2.0,
|
|
compressorEnabled: true,
|
|
compressorThreshold: -20,
|
|
compressorRatio: 3.0,
|
|
gateEnabled: false,
|
|
gateThreshold: -50,
|
|
gateRelease: 160,
|
|
limiter: true
|
|
},
|
|
ragchew: {
|
|
hp: 300,
|
|
lp: 2800,
|
|
mids: 0.5,
|
|
presence: 1.0,
|
|
deesserEnabled: true,
|
|
deesserFreq: 5000,
|
|
deesserCut: 1.2,
|
|
compressorEnabled: true,
|
|
compressorThreshold: -22,
|
|
compressorRatio: 2.2,
|
|
gateEnabled: true,
|
|
gateThreshold: -55,
|
|
gateRelease: 220,
|
|
limiter: true
|
|
}
|
|
};
|
|
|
|
const parsed = parseMicrohamEqArgs(extraArgsField.element.value);
|
|
const initial = parsed || presets.flat;
|
|
|
|
const wrap = document.createElement("div");
|
|
wrap.className = "plugin-eq-builder";
|
|
|
|
const title = document.createElement("strong");
|
|
title.textContent = "TX Audio EQ";
|
|
wrap.appendChild(title);
|
|
|
|
const hint = document.createElement("small");
|
|
hint.className = "muted";
|
|
hint.textContent = parsed
|
|
? "EQ aus aktuellen Extra-Args geladen"
|
|
: "Preset/Regler schreiben den FFmpeg-EQ in audioFfmpegExtraArgs";
|
|
wrap.appendChild(hint);
|
|
|
|
const presetRow = document.createElement("div");
|
|
presetRow.className = "plugin-eq-row";
|
|
|
|
const presetLabel = document.createElement("span");
|
|
presetLabel.className = "muted";
|
|
presetLabel.textContent = "Preset";
|
|
presetRow.appendChild(presetLabel);
|
|
|
|
const presetSelect = document.createElement("select");
|
|
presetSelect.innerHTML = [
|
|
'<option value="flat">Flat - neutral</option>',
|
|
'<option value="dx">DX - durchsetzungsstark</option>',
|
|
'<option value="ragchew">Ragchew - angenehmer Klang</option>'
|
|
].join("");
|
|
presetRow.appendChild(presetSelect);
|
|
|
|
const presetBtn = document.createElement("button");
|
|
presetBtn.type = "button";
|
|
presetBtn.className = "ghost-btn";
|
|
presetBtn.textContent = "Preset anwenden";
|
|
presetRow.appendChild(presetBtn);
|
|
|
|
wrap.appendChild(presetRow);
|
|
|
|
const presetInfo = document.createElement("small");
|
|
presetInfo.className = "muted";
|
|
wrap.appendChild(presetInfo);
|
|
|
|
const hpControl = createEqSliderControl("Highpass (Hz)", 80, 600, 10, initial.hp);
|
|
const lpControl = createEqSliderControl("Lowpass (Hz)", 1800, 4000, 10, initial.lp);
|
|
const midsControl = createEqSliderControl("Mitten (dB)", -8, 12, 0.5, initial.mids);
|
|
const presenceControl = createEqSliderControl("Presence (dB)", -8, 12, 0.5, initial.presence);
|
|
const deesserFreqControl = createEqSliderControl("De-Esser (Hz)", 3500, 8000, 100, initial.deesserFreq);
|
|
const deesserCutControl = createEqSliderControl("De-Esser Cut (dB)", 0, 8, 0.5, initial.deesserCut);
|
|
const compThresholdControl = createEqSliderControl("Compressor Threshold (dB)", -40, -6, 1, initial.compressorThreshold);
|
|
const compRatioControl = createEqSliderControl("Compressor Ratio", 1.2, 6, 0.1, initial.compressorRatio);
|
|
const gateThresholdControl = createEqSliderControl("Gate Threshold (dB)", -70, -20, 1, initial.gateThreshold);
|
|
const gateReleaseControl = createEqSliderControl("Gate Release (ms)", 60, 500, 10, initial.gateRelease);
|
|
wrap.appendChild(hpControl.row);
|
|
wrap.appendChild(lpControl.row);
|
|
wrap.appendChild(midsControl.row);
|
|
wrap.appendChild(presenceControl.row);
|
|
const deesserEnabledRow = createEqCheckboxRow("De-Esser aktivieren", initial.deesserEnabled);
|
|
wrap.appendChild(deesserEnabledRow.row);
|
|
wrap.appendChild(deesserFreqControl.row);
|
|
wrap.appendChild(deesserCutControl.row);
|
|
const compressorEnabledRow = createEqCheckboxRow("Compressor aktivieren", initial.compressorEnabled);
|
|
wrap.appendChild(compressorEnabledRow.row);
|
|
wrap.appendChild(compThresholdControl.row);
|
|
wrap.appendChild(compRatioControl.row);
|
|
const gateEnabledRow = createEqCheckboxRow("Noise Gate aktivieren", initial.gateEnabled);
|
|
wrap.appendChild(gateEnabledRow.row);
|
|
wrap.appendChild(gateThresholdControl.row);
|
|
wrap.appendChild(gateReleaseControl.row);
|
|
|
|
const limiterRow = document.createElement("label");
|
|
limiterRow.className = "plugin-eq-checkbox";
|
|
const limiterInput = document.createElement("input");
|
|
limiterInput.type = "checkbox";
|
|
limiterInput.checked = Boolean(initial.limiter);
|
|
limiterRow.appendChild(limiterInput);
|
|
const limiterText = document.createElement("span");
|
|
limiterText.textContent = "Limiter aktivieren (alimiter=0.95)";
|
|
limiterRow.appendChild(limiterText);
|
|
wrap.appendChild(limiterRow);
|
|
|
|
const preview = document.createElement("small");
|
|
preview.className = "muted";
|
|
wrap.appendChild(preview);
|
|
|
|
const saveButton = settingsForm.querySelector('button[type="submit"]');
|
|
if (saveButton && saveButton.parentNode === settingsForm) {
|
|
settingsForm.insertBefore(wrap, saveButton);
|
|
} else {
|
|
settingsForm.appendChild(wrap);
|
|
}
|
|
|
|
const applyControlsToExtraArgs = () => {
|
|
const hp = Number(hpControl.number.value);
|
|
const lp = Number(lpControl.number.value);
|
|
const mids = Number(midsControl.number.value);
|
|
const presence = Number(presenceControl.number.value);
|
|
const deesserEnabled = Boolean(deesserEnabledRow.input.checked);
|
|
const deesserFreq = Number(deesserFreqControl.number.value);
|
|
const deesserCut = Number(deesserCutControl.number.value);
|
|
const compressorEnabled = Boolean(compressorEnabledRow.input.checked);
|
|
const compressorThreshold = Number(compThresholdControl.number.value);
|
|
const compressorRatio = Number(compRatioControl.number.value);
|
|
const gateEnabled = Boolean(gateEnabledRow.input.checked);
|
|
const gateThreshold = Number(gateThresholdControl.number.value);
|
|
const gateRelease = Number(gateReleaseControl.number.value);
|
|
const limiter = Boolean(limiterInput.checked);
|
|
const args = buildMicrohamEqExtraArgs({
|
|
hp,
|
|
lp,
|
|
mids,
|
|
presence,
|
|
deesserEnabled,
|
|
deesserFreq,
|
|
deesserCut,
|
|
compressorEnabled,
|
|
compressorThreshold,
|
|
compressorRatio,
|
|
gateEnabled,
|
|
gateThreshold,
|
|
gateRelease,
|
|
limiter
|
|
});
|
|
extraArgsField.element.value = args;
|
|
preview.textContent = `Generierte Extra-Args: ${args}`;
|
|
};
|
|
|
|
const updatePresetInfo = () => {
|
|
const selected = String(presetSelect.value || "flat");
|
|
if (selected === "dx") {
|
|
presetInfo.textContent = "DX: sprachfokussiert mit reduziertem Bass und moderater Praesenz, weniger kuenstlich abgestimmt.";
|
|
return;
|
|
}
|
|
if (selected === "ragchew") {
|
|
presetInfo.textContent = "Ragchew: natuerlicher Sprachklang mit leicht reduziertem Bass und sanfter Mitten/Praesenz-Anhebung.";
|
|
return;
|
|
}
|
|
presetInfo.textContent = "Flat: neutrale Basis mit wenig Klangfaerbung, gut fuer Vergleich und Feintuning.";
|
|
};
|
|
|
|
const bindControlUpdate = (control) => {
|
|
control.range.addEventListener("input", () => {
|
|
control.number.value = control.range.value;
|
|
applyControlsToExtraArgs();
|
|
});
|
|
control.number.addEventListener("input", () => {
|
|
control.range.value = control.number.value;
|
|
applyControlsToExtraArgs();
|
|
});
|
|
};
|
|
|
|
bindControlUpdate(hpControl);
|
|
bindControlUpdate(lpControl);
|
|
bindControlUpdate(midsControl);
|
|
bindControlUpdate(presenceControl);
|
|
bindControlUpdate(deesserFreqControl);
|
|
bindControlUpdate(deesserCutControl);
|
|
bindControlUpdate(compThresholdControl);
|
|
bindControlUpdate(compRatioControl);
|
|
bindControlUpdate(gateThresholdControl);
|
|
bindControlUpdate(gateReleaseControl);
|
|
limiterInput.addEventListener("change", applyControlsToExtraArgs);
|
|
deesserEnabledRow.input.addEventListener("change", applyControlsToExtraArgs);
|
|
compressorEnabledRow.input.addEventListener("change", applyControlsToExtraArgs);
|
|
gateEnabledRow.input.addEventListener("change", applyControlsToExtraArgs);
|
|
|
|
presetBtn.addEventListener("click", () => {
|
|
const selected = presets[presetSelect.value] || presets.flat;
|
|
hpControl.range.value = String(selected.hp);
|
|
hpControl.number.value = String(selected.hp);
|
|
lpControl.range.value = String(selected.lp);
|
|
lpControl.number.value = String(selected.lp);
|
|
midsControl.range.value = String(selected.mids);
|
|
midsControl.number.value = String(selected.mids);
|
|
presenceControl.range.value = String(selected.presence);
|
|
presenceControl.number.value = String(selected.presence);
|
|
deesserEnabledRow.input.checked = Boolean(selected.deesserEnabled);
|
|
deesserFreqControl.range.value = String(selected.deesserFreq);
|
|
deesserFreqControl.number.value = String(selected.deesserFreq);
|
|
deesserCutControl.range.value = String(selected.deesserCut);
|
|
deesserCutControl.number.value = String(selected.deesserCut);
|
|
compressorEnabledRow.input.checked = Boolean(selected.compressorEnabled);
|
|
compThresholdControl.range.value = String(selected.compressorThreshold);
|
|
compThresholdControl.number.value = String(selected.compressorThreshold);
|
|
compRatioControl.range.value = String(selected.compressorRatio);
|
|
compRatioControl.number.value = String(selected.compressorRatio);
|
|
gateEnabledRow.input.checked = Boolean(selected.gateEnabled);
|
|
gateThresholdControl.range.value = String(selected.gateThreshold);
|
|
gateThresholdControl.number.value = String(selected.gateThreshold);
|
|
gateReleaseControl.range.value = String(selected.gateRelease);
|
|
gateReleaseControl.number.value = String(selected.gateRelease);
|
|
limiterInput.checked = Boolean(selected.limiter);
|
|
applyControlsToExtraArgs();
|
|
});
|
|
|
|
presetSelect.addEventListener("change", updatePresetInfo);
|
|
|
|
preview.textContent = `Aktuelle Extra-Args: ${extraArgsField.element.value || "<leer>"}`;
|
|
updatePresetInfo();
|
|
}
|
|
|
|
function createEqSliderControl(labelText, min, max, step, value) {
|
|
const row = document.createElement("div");
|
|
row.className = "plugin-eq-row";
|
|
|
|
const label = document.createElement("span");
|
|
label.className = "muted";
|
|
label.textContent = labelText;
|
|
row.appendChild(label);
|
|
|
|
const range = document.createElement("input");
|
|
range.type = "range";
|
|
range.min = String(min);
|
|
range.max = String(max);
|
|
range.step = String(step);
|
|
range.value = String(value);
|
|
row.appendChild(range);
|
|
|
|
const number = document.createElement("input");
|
|
number.type = "number";
|
|
number.min = String(min);
|
|
number.max = String(max);
|
|
number.step = String(step);
|
|
number.value = String(value);
|
|
row.appendChild(number);
|
|
|
|
return { row, range, number };
|
|
}
|
|
|
|
function createEqCheckboxRow(labelText, checked) {
|
|
const row = document.createElement("label");
|
|
row.className = "plugin-eq-checkbox";
|
|
const input = document.createElement("input");
|
|
input.type = "checkbox";
|
|
input.checked = Boolean(checked);
|
|
row.appendChild(input);
|
|
const label = document.createElement("span");
|
|
label.textContent = labelText;
|
|
row.appendChild(label);
|
|
return { row, input };
|
|
}
|
|
|
|
function buildMicrohamEqExtraArgs({
|
|
hp,
|
|
lp,
|
|
mids,
|
|
presence,
|
|
deesserEnabled,
|
|
deesserFreq,
|
|
deesserCut,
|
|
compressorEnabled,
|
|
compressorThreshold,
|
|
compressorRatio,
|
|
gateEnabled,
|
|
gateThreshold,
|
|
gateRelease,
|
|
limiter
|
|
}) {
|
|
const filters = [
|
|
`highpass=f=${Math.round(Number(hp) || 0)}`,
|
|
`lowpass=f=${Math.round(Number(lp) || 0)}`,
|
|
`equalizer=f=1200:t=q:w=0.8:g=${Number(Number(mids || 0).toFixed(1))}`,
|
|
`equalizer=f=2100:t=q:w=0.9:g=${Number(Number(presence || 0).toFixed(1))}`
|
|
];
|
|
if (deesserEnabled && Number(deesserCut || 0) > 0) {
|
|
const freq = Math.round(Number(deesserFreq) || 5200);
|
|
const cut = Number(Number(-Math.abs(Number(deesserCut || 0))).toFixed(1));
|
|
filters.push(`equalizer=f=${freq}:t=q:w=1.1:g=${cut}`);
|
|
}
|
|
if (compressorEnabled) {
|
|
const thresholdDb = Number(Number(compressorThreshold || -20).toFixed(1));
|
|
const ratio = Number(Number(compressorRatio || 3).toFixed(2));
|
|
const thresholdLinear = Number(Math.pow(10, thresholdDb / 20).toFixed(6));
|
|
filters.push(`acompressor=threshold=${thresholdLinear}:ratio=${ratio}:attack=5:release=120:makeup=1.2`);
|
|
}
|
|
if (gateEnabled) {
|
|
const gateThresholdDb = Number(Number(gateThreshold || -55).toFixed(1));
|
|
const gateThresholdLinear = Number(Math.pow(10, gateThresholdDb / 20).toFixed(6));
|
|
const release = Math.round(Number(gateRelease || 180));
|
|
filters.push(`agate=threshold=${gateThresholdLinear}:release=${release}`);
|
|
}
|
|
if (limiter) {
|
|
filters.push("alimiter=limit=0.95");
|
|
}
|
|
return `-af "${filters.join(",")}"`;
|
|
}
|
|
|
|
function parseMicrohamEqArgs(value) {
|
|
const text = String(value || "").trim();
|
|
if (!text) {
|
|
return null;
|
|
}
|
|
const hpMatch = text.match(/highpass\s*=\s*f\s*=\s*(-?[0-9]+(?:\.[0-9]+)?)/i);
|
|
const lpMatch = text.match(/lowpass\s*=\s*f\s*=\s*(-?[0-9]+(?:\.[0-9]+)?)/i);
|
|
const midsMatch = text.match(/equalizer\s*=\s*f\s*=\s*1200\s*:\s*t\s*=\s*q\s*:\s*w\s*=\s*0\.8\s*:\s*g\s*=\s*(-?[0-9]+(?:\.[0-9]+)?)/i);
|
|
const presenceMatch = text.match(/equalizer\s*=\s*f\s*=\s*2100\s*:\s*t\s*=\s*q\s*:\s*w\s*=\s*0\.9\s*:\s*g\s*=\s*(-?[0-9]+(?:\.[0-9]+)?)/i);
|
|
if (!hpMatch || !lpMatch || !presenceMatch) {
|
|
return null;
|
|
}
|
|
const hp = Number(hpMatch[1]);
|
|
const lp = Number(lpMatch[1]);
|
|
const mids = midsMatch ? Number(midsMatch[1]) : 0;
|
|
const presence = Number(presenceMatch[1]);
|
|
if (!Number.isFinite(hp) || !Number.isFinite(lp) || !Number.isFinite(mids) || !Number.isFinite(presence)) {
|
|
return null;
|
|
}
|
|
const deesserMatch = text.match(/equalizer\s*=\s*f\s*=\s*([0-9]+)\s*:\s*t\s*=\s*q\s*:\s*w\s*=\s*1\.1\s*:\s*g\s*=\s*(-?[0-9]+(?:\.[0-9]+)?)/i);
|
|
const deesserEnabled = Boolean(deesserMatch);
|
|
const deesserFreq = deesserMatch ? Number(deesserMatch[1]) : 5200;
|
|
const deesserCut = deesserMatch ? Math.abs(Number(deesserMatch[2])) : 0;
|
|
const compMatch = text.match(/acompressor\s*=\s*threshold\s*=\s*([0-9]+(?:\.[0-9]+)?)\s*:\s*ratio\s*=\s*([0-9]+(?:\.[0-9]+)?)/i);
|
|
const compressorEnabled = Boolean(compMatch);
|
|
const compressorThreshold = compMatch ? Number((20 * Math.log10(Number(compMatch[1]))).toFixed(1)) : -20;
|
|
const compressorRatio = compMatch ? Number(compMatch[2]) : 3;
|
|
const gateMatch = text.match(/agate\s*=\s*threshold\s*=\s*([0-9]+(?:\.[0-9]+)?)\s*:\s*release\s*=\s*([0-9]+(?:\.[0-9]+)?)/i);
|
|
const gateEnabled = Boolean(gateMatch);
|
|
const gateThreshold = gateMatch ? Number((20 * Math.log10(Number(gateMatch[1]))).toFixed(1)) : -55;
|
|
const gateRelease = gateMatch ? Number(gateMatch[2]) : 180;
|
|
const limiter = /alimiter\s*=\s*limit\s*=\s*0\.95/i.test(text);
|
|
return {
|
|
hp,
|
|
lp,
|
|
mids,
|
|
presence,
|
|
deesserEnabled,
|
|
deesserFreq,
|
|
deesserCut,
|
|
compressorEnabled,
|
|
compressorThreshold,
|
|
compressorRatio,
|
|
gateEnabled,
|
|
gateThreshold,
|
|
gateRelease,
|
|
limiter
|
|
};
|
|
}
|
|
|
|
function renderProviderAdmin() {
|
|
renderProviderAdminInto(els.providersAdminConfig);
|
|
}
|
|
|
|
function renderProviderAdminInto(container) {
|
|
if (!container) {
|
|
return;
|
|
}
|
|
container.innerHTML = "";
|
|
if (!isAdmin()) {
|
|
return;
|
|
}
|
|
if (!state.capabilities.length) {
|
|
container.textContent = "Keine Provider-Daten verfuegbar.";
|
|
return;
|
|
}
|
|
|
|
for (const entry of state.capabilities) {
|
|
const block = document.createElement("div");
|
|
block.className = "plugin-block";
|
|
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("h3");
|
|
title.textContent = entry.capability;
|
|
head.appendChild(title);
|
|
block.appendChild(head);
|
|
|
|
const row = document.createElement("label");
|
|
row.className = "field";
|
|
const label = document.createElement("span");
|
|
label.textContent = "Aktiver Provider";
|
|
row.appendChild(label);
|
|
|
|
const select = document.createElement("select");
|
|
for (const provider of entry.providers || []) {
|
|
const opt = document.createElement("option");
|
|
opt.value = provider.pluginId;
|
|
opt.textContent = provider.pluginId;
|
|
if (entry.activePluginId === provider.pluginId) {
|
|
opt.selected = true;
|
|
}
|
|
select.appendChild(opt);
|
|
}
|
|
select.addEventListener("change", async () => {
|
|
await switchProvider(entry.capability, select.value);
|
|
});
|
|
row.appendChild(select);
|
|
block.appendChild(row);
|
|
|
|
const providers = document.createElement("div");
|
|
providers.className = "actions";
|
|
for (const provider of entry.providers || []) {
|
|
const badge = document.createElement("span");
|
|
badge.className = `health-badge health-${provider.health}`;
|
|
badge.textContent = `${provider.pluginId} (${provider.enabled ? "on" : "off"}, ${provider.health})`;
|
|
providers.appendChild(badge);
|
|
}
|
|
block.appendChild(providers);
|
|
container.appendChild(block);
|
|
}
|
|
}
|
|
|
|
function renderCapabilityMatrix() {
|
|
renderCapabilityMatrixInto(els.providersCapabilityMatrix);
|
|
}
|
|
|
|
function renderCapabilityMatrixInto(container) {
|
|
if (!container) {
|
|
return;
|
|
}
|
|
container.innerHTML = "";
|
|
if (!isAdmin()) {
|
|
return;
|
|
}
|
|
if (!state.capabilities.length) {
|
|
container.textContent = "Keine Capability Daten verfuegbar.";
|
|
return;
|
|
}
|
|
|
|
for (const entry of state.capabilities) {
|
|
const row = document.createElement("div");
|
|
row.className = "matrix-row";
|
|
|
|
const head = document.createElement("div");
|
|
head.className = "section-head";
|
|
const title = document.createElement("strong");
|
|
title.textContent = entry.capability;
|
|
head.appendChild(title);
|
|
|
|
const active = document.createElement("span");
|
|
active.className = "pill";
|
|
active.textContent = `Aktiv: ${entry.activePluginId || "-"}`;
|
|
head.appendChild(active);
|
|
row.appendChild(head);
|
|
|
|
const providers = document.createElement("div");
|
|
providers.className = "actions";
|
|
for (const provider of entry.providers || []) {
|
|
const badge = document.createElement("span");
|
|
badge.className = `health-badge health-${provider.health}`;
|
|
badge.textContent = `${provider.pluginId} (${provider.enabled ? "on" : "off"}, ${provider.health})`;
|
|
providers.appendChild(badge);
|
|
}
|
|
row.appendChild(providers);
|
|
|
|
container.appendChild(row);
|
|
}
|
|
}
|
|
|
|
function renderSchemaForm(form, schema, values) {
|
|
const fields = [];
|
|
const properties = schema.properties || {};
|
|
const required = Array.isArray(schema.required) ? schema.required : [];
|
|
|
|
for (const [name, fieldSchema] of Object.entries(properties)) {
|
|
const label = document.createElement("label");
|
|
label.className = "field";
|
|
const caption = document.createElement("span");
|
|
caption.textContent = name;
|
|
label.appendChild(caption);
|
|
|
|
const hasSavedValue = values && values[name] !== undefined;
|
|
const rawCurrentValue = hasSavedValue ? values[name] : fieldSchema.default;
|
|
const currentValue = coerceSchemaValue(fieldSchema, rawCurrentValue);
|
|
const sourceLabel = hasSavedValue ? "gespeichert" : (fieldSchema.default !== undefined ? "default" : "nicht gesetzt");
|
|
|
|
if (Array.isArray(fieldSchema.enum)) {
|
|
const select = document.createElement("select");
|
|
select.name = name;
|
|
select.required = required.includes(name);
|
|
for (const enumValue of fieldSchema.enum) {
|
|
const option = document.createElement("option");
|
|
option.value = String(enumValue);
|
|
option.textContent = String(enumValue);
|
|
if (currentValue === enumValue) {
|
|
option.selected = true;
|
|
}
|
|
select.appendChild(option);
|
|
}
|
|
label.appendChild(select);
|
|
const field = { name, type: fieldSchema.type || "string", element: select, hasSavedValue, dirty: false };
|
|
select.addEventListener("change", () => {
|
|
field.dirty = true;
|
|
});
|
|
fields.push(field);
|
|
} else {
|
|
const input = document.createElement("input");
|
|
input.name = name;
|
|
input.required = required.includes(name);
|
|
if (fieldSchema.type === "number" || fieldSchema.type === "integer") {
|
|
input.type = "number";
|
|
if (fieldSchema.type === "integer") input.step = "1";
|
|
if (fieldSchema.minimum !== undefined) input.min = String(fieldSchema.minimum);
|
|
if (fieldSchema.maximum !== undefined) input.max = String(fieldSchema.maximum);
|
|
} else if (fieldSchema.type === "boolean") {
|
|
input.type = "checkbox";
|
|
} else {
|
|
input.type = "text";
|
|
}
|
|
|
|
const value = currentValue;
|
|
if (value !== undefined) {
|
|
if (fieldSchema.type === "boolean") {
|
|
input.checked = Boolean(value);
|
|
} else {
|
|
input.value = String(value);
|
|
}
|
|
}
|
|
label.appendChild(input);
|
|
const field = { name, type: fieldSchema.type || "string", element: input, hasSavedValue, dirty: false };
|
|
input.addEventListener("change", () => {
|
|
field.dirty = true;
|
|
});
|
|
fields.push(field);
|
|
}
|
|
|
|
const currentInfo = document.createElement("small");
|
|
currentInfo.className = "muted";
|
|
currentInfo.textContent = `Aktuell in Verwendung: ${formatSettingValue(currentValue)} (${sourceLabel})`;
|
|
label.appendChild(currentInfo);
|
|
|
|
form.appendChild(label);
|
|
}
|
|
return fields;
|
|
}
|
|
|
|
function formatSettingValue(value) {
|
|
if (value === undefined || value === null || value === "") {
|
|
return "<leer>";
|
|
}
|
|
if (typeof value === "boolean") {
|
|
return value ? "true" : "false";
|
|
}
|
|
return String(value);
|
|
}
|
|
|
|
function coerceSchemaValue(fieldSchema, value) {
|
|
if (!fieldSchema || value === undefined || value === null) {
|
|
return value;
|
|
}
|
|
const type = String(fieldSchema.type || "").toLowerCase();
|
|
if (type === "boolean") {
|
|
if (typeof value === "boolean") {
|
|
return value;
|
|
}
|
|
const normalized = String(value).trim().toLowerCase();
|
|
if (["1", "true", "yes", "on"].includes(normalized)) {
|
|
return true;
|
|
}
|
|
if (["0", "false", "no", "off", ""].includes(normalized)) {
|
|
return false;
|
|
}
|
|
return Boolean(value);
|
|
}
|
|
if (type === "number" || type === "integer") {
|
|
const numeric = Number(value);
|
|
if (!Number.isFinite(numeric)) {
|
|
return value;
|
|
}
|
|
return type === "integer" ? Math.trunc(numeric) : numeric;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
async function savePluginSettings(pluginId, fields) {
|
|
clearMessages("admin");
|
|
try {
|
|
const settings = readActionInput(fields);
|
|
await api(`/v1/plugins/${encodeURIComponent(pluginId)}/settings`, {
|
|
method: "PUT",
|
|
body: { settings }
|
|
});
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
renderMessage(els.adminMessage, `Settings fuer ${pluginId} gespeichert`, false, true);
|
|
} catch (error) {
|
|
renderMessage(els.adminMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function togglePlugin(pluginId, currentlyEnabled) {
|
|
clearMessages("admin");
|
|
try {
|
|
const route = currentlyEnabled ? "disable" : "enable";
|
|
await api(`/v1/plugins/${encodeURIComponent(pluginId)}/${route}`, {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
renderMessage(els.adminMessage, `${pluginId} ${currentlyEnabled ? "deaktiviert" : "aktiviert"}`, false, true);
|
|
} catch (error) {
|
|
renderMessage(els.adminMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
async function switchProvider(capability, pluginId) {
|
|
clearMessages("provider");
|
|
try {
|
|
await api(`/v1/admin/capabilities/${encodeURIComponent(capability)}/provider`, {
|
|
method: "PUT",
|
|
body: { pluginId }
|
|
});
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
renderMessage(els.providersMessage, `Provider fuer ${capability} auf ${pluginId} gesetzt`, false, true);
|
|
} catch (error) {
|
|
renderMessage(els.providersMessage, error.message, true);
|
|
}
|
|
}
|
|
|
|
function updateUserUi() {
|
|
const setHidden = (el, value) => {
|
|
if (el) {
|
|
el.hidden = value;
|
|
}
|
|
};
|
|
const setDisabled = (el, value) => {
|
|
if (el) {
|
|
el.disabled = value;
|
|
}
|
|
};
|
|
const loggedIn = Boolean(state.user);
|
|
const rmsVisible = loggedIn && window.location.pathname.startsWith("/rms");
|
|
const rawPage = currentRmsPage();
|
|
const page = normalizedRmsPage(rawPage);
|
|
|
|
if (rmsVisible && page !== rawPage) {
|
|
window.history.replaceState({}, "", pageToPath(page));
|
|
}
|
|
|
|
setHidden(els.authView, rmsVisible);
|
|
setHidden(els.rmsView, !rmsVisible);
|
|
setHidden(els.pageRms, !rmsVisible || page !== "rms");
|
|
setHidden(els.pageSwr, !rmsVisible || page !== "swr");
|
|
setHidden(els.pageUser, !rmsVisible || page !== "user");
|
|
setHidden(els.pageHelp, !rmsVisible || page !== "help");
|
|
setHidden(els.pagePlugins, !rmsVisible || page !== "plugins" || !isAdmin());
|
|
setHidden(els.pagePluginConfig, !rmsVisible || page !== "plugin-config" || !isAdmin());
|
|
setHidden(els.pageProviders, !rmsVisible || page !== "providers" || !isAdmin());
|
|
setHidden(els.pageAdmin, !rmsVisible || page !== "admin");
|
|
setHidden(els.pageUsers, !rmsVisible || page !== "users");
|
|
setHidden(els.pageApprovals, !rmsVisible || page !== "approvals");
|
|
setHidden(els.pageActivity, !rmsVisible || page !== "activity");
|
|
setDisabled(els.loginBtn, loggedIn);
|
|
setDisabled(els.logoutBtn, !loggedIn);
|
|
setDisabled(els.settingsLogoutTopBtn, !loggedIn);
|
|
setDisabled(els.userMenuButton, !loggedIn);
|
|
setDisabled(els.email, loggedIn);
|
|
if (els.userMenuButton) {
|
|
els.userMenuButton.textContent = "☰";
|
|
els.userMenuButton.setAttribute("aria-label", loggedIn ? `Menue (${state.user.email})` : "Menue");
|
|
}
|
|
setHidden(els.currentUserLink, !loggedIn);
|
|
if (els.currentUserLink) {
|
|
els.currentUserLink.textContent = loggedIn ? `👤 ${state.user.email}` : "👤 -";
|
|
}
|
|
setHidden(els.adminCard, !isAdmin());
|
|
if (els.pluginsConfigCard) {
|
|
els.pluginsConfigCard.hidden = !isAdmin();
|
|
}
|
|
setHidden(els.menuAdmin, !isAdmin());
|
|
setHidden(els.menuSwr, !canOperateStation());
|
|
setHidden(els.menuHelp, !loggedIn);
|
|
setHidden(els.menuPlugins, !isAdmin());
|
|
setHidden(els.menuPluginConfig, !isAdmin());
|
|
setHidden(els.menuProviders, !isAdmin());
|
|
setHidden(els.menuUsers, !canSeeUsersList());
|
|
setHidden(els.menuApprovals, !canSeeApprovals());
|
|
setHidden(els.menuActivity, !canSeeActivityLog());
|
|
setHidden(els.mobileNavUsers, !canSeeUsersList());
|
|
setHidden(els.mobileNavPlugins, !isAdmin());
|
|
setHidden(els.mobileNavPluginConfig, !isAdmin());
|
|
setHidden(els.mobileNavSwr, !canOperateStation());
|
|
setHidden(els.mobileNavHelp, !loggedIn);
|
|
setHidden(els.mobileNavAdmin, !isAdmin());
|
|
setHidden(els.mobileNavApprovals, !canSeeApprovals());
|
|
setHidden(els.mobileNavActivity, !canSeeActivityLog());
|
|
if (els.mobileNav) {
|
|
els.mobileNav.classList.toggle("admin-visible", isAdmin());
|
|
els.mobileNav.classList.toggle("swr-visible", canOperateStation());
|
|
els.mobileNav.classList.toggle("users-visible", canSeeUsersList());
|
|
els.mobileNav.classList.toggle("approvals-visible", canSeeApprovals());
|
|
els.mobileNav.classList.toggle("activity-visible", canSeeActivityLog());
|
|
}
|
|
if (els.settingsEmail) {
|
|
els.settingsEmail.textContent = loggedIn ? state.user.email : "-";
|
|
}
|
|
if (els.settingsRole) {
|
|
els.settingsRole.textContent = loggedIn ? state.user.role : "-";
|
|
}
|
|
renderLanguageSelectors();
|
|
if (els.settingsLanguageSelect) {
|
|
const userPreferred = normalizeLanguage(loggedIn && state.user && state.user.preferredLanguage
|
|
? state.user.preferredLanguage
|
|
: state.i18n.language);
|
|
els.settingsLanguageSelect.value = userPreferred;
|
|
}
|
|
if (els.menuLanguageSelect) {
|
|
els.menuLanguageSelect.value = normalizeLanguage(state.i18n.language);
|
|
}
|
|
renderUserSettingsAuthMethods();
|
|
renderMaintenanceBanner();
|
|
updateMenuState(page, loggedIn);
|
|
updatePageMeta(loggedIn, page);
|
|
applyI18n();
|
|
setHidden(els.mobileNav, !rmsVisible);
|
|
setUserMenuOpen(false);
|
|
setLanguageMenuOpen(false);
|
|
if (rmsVisible) {
|
|
animateCurrentPage(page);
|
|
}
|
|
}
|
|
|
|
function animateCurrentPage(page) {
|
|
const target = page === "user"
|
|
? els.pageUser
|
|
: page === "swr"
|
|
? els.pageSwr
|
|
: page === "help"
|
|
? els.pageHelp
|
|
: page === "plugins"
|
|
? els.pagePlugins
|
|
: page === "plugin-config"
|
|
? els.pagePluginConfig
|
|
: page === "providers"
|
|
? els.pageProviders
|
|
: page === "users"
|
|
? els.pageUsers
|
|
: page === "approvals"
|
|
? els.pageApprovals
|
|
: page === "activity"
|
|
? els.pageActivity
|
|
: page === "admin"
|
|
? els.pageAdmin
|
|
: els.pageRms;
|
|
if (!target) {
|
|
return;
|
|
}
|
|
target.classList.remove("page-enter");
|
|
void target.offsetWidth;
|
|
target.classList.add("page-enter");
|
|
}
|
|
|
|
function updatePageMeta(loggedIn, page) {
|
|
if (!loggedIn) {
|
|
els.pageTitle.textContent = "RMS Status";
|
|
els.pageHint.textContent = "Bitte anmelden";
|
|
els.pageCrumb.textContent = "LOGIN";
|
|
return;
|
|
}
|
|
if (page === "user") {
|
|
els.pageTitle.textContent = "Einstellungen";
|
|
els.pageHint.textContent = "Persoenliche Einstellungen";
|
|
els.pageCrumb.textContent = "RMS / EINSTELLUNGEN";
|
|
return;
|
|
}
|
|
if (page === "help") {
|
|
els.pageTitle.textContent = "Hilfe";
|
|
els.pageHint.textContent = "Grundablaeufe fuer den Stationsbetrieb";
|
|
els.pageCrumb.textContent = "RMS / HILFE";
|
|
return;
|
|
}
|
|
if (page === "plugins") {
|
|
els.pageTitle.textContent = "Plugin Controls";
|
|
els.pageHint.textContent = "Dynamische Geraetesteuerung";
|
|
els.pageCrumb.textContent = "RMS / PLUGIN CONTROLS";
|
|
return;
|
|
}
|
|
if (page === "plugin-config") {
|
|
els.pageTitle.textContent = "Plugin Konfiguration";
|
|
els.pageHint.textContent = "Einstellungen und Aktivierung";
|
|
els.pageCrumb.textContent = "RMS / PLUGIN KONFIG";
|
|
return;
|
|
}
|
|
if (page === "providers") {
|
|
els.pageTitle.textContent = "Provider";
|
|
els.pageHint.textContent = "Capability-Zuordnung";
|
|
els.pageCrumb.textContent = "RMS / PROVIDER";
|
|
return;
|
|
}
|
|
if (page === "swr") {
|
|
els.pageTitle.textContent = "SWR Test-Daten";
|
|
els.pageHint.textContent = "Bandauswertung und Grafiken";
|
|
els.pageCrumb.textContent = "RMS / SWR";
|
|
return;
|
|
}
|
|
if (page === "admin") {
|
|
els.pageTitle.textContent = "Admin";
|
|
els.pageHint.textContent = "System- und Plugin-Verwaltung";
|
|
els.pageCrumb.textContent = "RMS / ADMIN";
|
|
return;
|
|
}
|
|
if (page === "users") {
|
|
els.pageTitle.textContent = "Benutzerverwaltung";
|
|
els.pageHint.textContent = "Rollen und Accountstatus";
|
|
els.pageCrumb.textContent = "RMS / USERS";
|
|
return;
|
|
}
|
|
if (page === "approvals") {
|
|
els.pageTitle.textContent = "Freigaben";
|
|
els.pageHint.textContent = "Externe Domain-Anfragen";
|
|
els.pageCrumb.textContent = "RMS / FREIGABEN";
|
|
return;
|
|
}
|
|
if (page === "activity") {
|
|
els.pageTitle.textContent = "Aktivitaetslog";
|
|
els.pageHint.textContent = "Bedienung und Stationsnutzung";
|
|
els.pageCrumb.textContent = "RMS / AKTIVITAET";
|
|
return;
|
|
}
|
|
els.pageTitle.textContent = "RMS Status";
|
|
els.pageHint.textContent = "Station steuern";
|
|
els.pageCrumb.textContent = "RMS / STATUS";
|
|
}
|
|
|
|
function updateMenuState(page, loggedIn) {
|
|
const map = {
|
|
rms: els.menuRms,
|
|
swr: els.menuSwr,
|
|
user: els.menuUser,
|
|
help: els.menuHelp,
|
|
plugins: els.menuPlugins,
|
|
"plugin-config": els.menuPluginConfig,
|
|
providers: els.menuProviders,
|
|
users: els.menuUsers,
|
|
approvals: els.menuApprovals,
|
|
activity: els.menuActivity,
|
|
admin: els.menuAdmin
|
|
};
|
|
for (const [name, el] of Object.entries(map)) {
|
|
if (el) {
|
|
el.classList.toggle("active", loggedIn && page === name);
|
|
}
|
|
}
|
|
const mobileMap = {
|
|
rms: els.mobileNavRms,
|
|
swr: els.mobileNavSwr,
|
|
user: els.mobileNavUser,
|
|
help: els.mobileNavHelp,
|
|
plugins: els.mobileNavPlugins,
|
|
"plugin-config": els.mobileNavPluginConfig,
|
|
users: els.mobileNavUsers,
|
|
approvals: els.mobileNavApprovals,
|
|
activity: els.mobileNavActivity,
|
|
admin: els.mobileNavAdmin
|
|
};
|
|
for (const [name, el] of Object.entries(mobileMap)) {
|
|
if (el) {
|
|
el.classList.toggle("active", loggedIn && page === name);
|
|
}
|
|
}
|
|
if (!loggedIn) {
|
|
const clearActive = [
|
|
els.menuRms,
|
|
els.menuSwr,
|
|
els.menuUser,
|
|
els.menuHelp,
|
|
els.menuPlugins,
|
|
els.menuPluginConfig,
|
|
els.menuProviders,
|
|
els.menuUsers,
|
|
els.menuApprovals,
|
|
els.menuActivity,
|
|
els.menuAdmin,
|
|
els.mobileNavRms,
|
|
els.mobileNavSwr,
|
|
els.mobileNavUser,
|
|
els.mobileNavHelp,
|
|
els.mobileNavPlugins,
|
|
els.mobileNavPluginConfig,
|
|
els.mobileNavUsers,
|
|
els.mobileNavApprovals,
|
|
els.mobileNavActivity,
|
|
els.mobileNavAdmin
|
|
];
|
|
for (const el of clearActive) {
|
|
if (el) {
|
|
el.classList.remove("active");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearMessages(scope = "all") {
|
|
if (scope === "all" || scope === "auth") {
|
|
els.authMessage.textContent = "";
|
|
els.authMessage.className = "message";
|
|
}
|
|
if (scope === "all" || scope === "status") {
|
|
els.statusMessage.textContent = "";
|
|
els.statusMessage.className = "message";
|
|
if (els.reservationMessage) {
|
|
els.reservationMessage.textContent = "";
|
|
els.reservationMessage.className = "message";
|
|
}
|
|
if (els.openwebrxMessage) {
|
|
els.openwebrxMessage.textContent = "";
|
|
els.openwebrxMessage.className = "message";
|
|
}
|
|
}
|
|
if (scope === "all" || scope === "swr") {
|
|
if (els.swrSummaryMessage) {
|
|
els.swrSummaryMessage.textContent = "";
|
|
els.swrSummaryMessage.className = "message";
|
|
}
|
|
if (els.swrPageMessage) {
|
|
els.swrPageMessage.textContent = "";
|
|
els.swrPageMessage.className = "message";
|
|
}
|
|
}
|
|
if (scope === "all" || scope === "admin") {
|
|
els.adminMessage.textContent = "";
|
|
els.adminMessage.className = "message";
|
|
}
|
|
if (scope === "all" || scope === "provider") {
|
|
if (els.providersMessage) {
|
|
els.providersMessage.textContent = "";
|
|
els.providersMessage.className = "message";
|
|
}
|
|
}
|
|
if (scope === "all" || scope === "plugin") {
|
|
els.pluginMessage.textContent = "";
|
|
els.pluginMessage.className = "message";
|
|
}
|
|
if (scope === "all" || scope === "users") {
|
|
els.usersMessage.textContent = "";
|
|
els.usersMessage.className = "message";
|
|
}
|
|
if (scope === "all" || scope === "approvals") {
|
|
els.approvalsMessage.textContent = "";
|
|
els.approvalsMessage.className = "message";
|
|
}
|
|
if (scope === "all" || scope === "activity") {
|
|
els.activityMessage.textContent = "";
|
|
els.activityMessage.className = "message";
|
|
}
|
|
if (scope === "all" || scope === "help") {
|
|
if (els.helpMessage) {
|
|
els.helpMessage.textContent = "";
|
|
els.helpMessage.className = "message";
|
|
}
|
|
}
|
|
}
|
|
|
|
function renderMessage(el, text, isError = false, isOk = false) {
|
|
if (!el) return;
|
|
el.textContent = translateLiteral(String(text || ""));
|
|
el.className = "message";
|
|
if (isError) {
|
|
el.classList.add("error");
|
|
}
|
|
if (isOk) {
|
|
el.classList.add("ok");
|
|
}
|
|
}
|
|
|
|
function currentRoute() {
|
|
const path = window.location.pathname;
|
|
if (
|
|
path === "/rms" ||
|
|
path === "/rms/swr" ||
|
|
path === "/rms/user" ||
|
|
path === "/rms/hilfe" ||
|
|
path === "/rms/plugins" ||
|
|
path === "/rms/plugin-konfig" ||
|
|
path === "/rms/providers" ||
|
|
path === "/rms/users" ||
|
|
path === "/rms/freigaben" ||
|
|
path === "/rms/aktivitaet" ||
|
|
path === "/rms/admin"
|
|
) {
|
|
return path;
|
|
}
|
|
return "/login";
|
|
}
|
|
|
|
function applyRoute(replace = false) {
|
|
const desired = state.user ? pageToPath(normalizedRmsPage(currentRmsPage())) : "/login";
|
|
const desiredUrl = state.user
|
|
? `${desired}${routeQueryForPage(normalizedRmsPage(currentRmsPage()))}`
|
|
: "/login";
|
|
const currentUrl = `${window.location.pathname}${window.location.search}`;
|
|
if (currentUrl !== desiredUrl) {
|
|
window.history[replace ? "replaceState" : "pushState"]({}, "", desiredUrl);
|
|
}
|
|
updateUserUi();
|
|
}
|
|
|
|
function currentRmsPage() {
|
|
const path = window.location.pathname;
|
|
if (path === "/rms/user") return "user";
|
|
if (path === "/rms/swr") return "swr";
|
|
if (path === "/rms/hilfe") return "help";
|
|
if (path === "/rms/plugins") return "plugins";
|
|
if (path === "/rms/plugin-konfig") return "plugin-config";
|
|
if (path === "/rms/providers") return "providers";
|
|
if (path === "/rms/users") return "users";
|
|
if (path === "/rms/freigaben") return "approvals";
|
|
if (path === "/rms/aktivitaet") return "activity";
|
|
if (path === "/rms/admin") return "admin";
|
|
return "rms";
|
|
}
|
|
|
|
function normalizedRmsPage(page) {
|
|
if (page === "admin" && !isAdmin()) {
|
|
return "rms";
|
|
}
|
|
if (page === "swr" && !canOperateStation()) {
|
|
return "rms";
|
|
}
|
|
if (page === "users" && !canSeeUsersList()) {
|
|
return "rms";
|
|
}
|
|
if (page === "plugins" && !isAdmin()) {
|
|
return "rms";
|
|
}
|
|
if (page === "plugin-config" && !isAdmin()) {
|
|
return "rms";
|
|
}
|
|
if (page === "providers" && !isAdmin()) {
|
|
return "rms";
|
|
}
|
|
if (page === "approvals" && !canSeeApprovals()) {
|
|
return "rms";
|
|
}
|
|
if (page === "activity" && !canSeeActivityLog()) {
|
|
return "rms";
|
|
}
|
|
return page;
|
|
}
|
|
|
|
function navigateRmsPage(page) {
|
|
if (!state.user) {
|
|
return;
|
|
}
|
|
setUserMenuOpen(false);
|
|
setLanguageMenuOpen(false);
|
|
const safePage = normalizedRmsPage(["rms", "swr", "user", "help", "plugins", "plugin-config", "providers", "users", "approvals", "activity", "admin"].includes(page) ? page : "rms");
|
|
window.history.pushState({}, "", `${pageToPath(safePage)}${routeQueryForPage(safePage)}`);
|
|
updateUserUi();
|
|
}
|
|
|
|
function pageToPath(page) {
|
|
if (page === "swr") return "/rms/swr";
|
|
if (page === "user") return "/rms/user";
|
|
if (page === "help") return "/rms/hilfe";
|
|
if (page === "plugins") return "/rms/plugins";
|
|
if (page === "plugin-config") return "/rms/plugin-konfig";
|
|
if (page === "providers") return "/rms/providers";
|
|
if (page === "users") return "/rms/users";
|
|
if (page === "approvals") return "/rms/freigaben";
|
|
if (page === "activity") return "/rms/aktivitaet";
|
|
if (page === "admin") return "/rms/admin";
|
|
return "/rms";
|
|
}
|
|
|
|
function routeQueryForPage(page) {
|
|
const params = new URLSearchParams();
|
|
if (page === "users") {
|
|
if (state.usersFilter.query) params.set("uq", state.usersFilter.query);
|
|
if (state.usersFilter.role !== "all") params.set("ur", state.usersFilter.role);
|
|
if (state.usersFilter.status !== "all") params.set("us", state.usersFilter.status);
|
|
}
|
|
if (page === "approvals") {
|
|
if (state.approvalsFilter.mode !== "open") params.set("am", state.approvalsFilter.mode);
|
|
if (state.approvalsFilter.query) params.set("aq", state.approvalsFilter.query);
|
|
if (state.approvalsFilter.status !== "all") params.set("as", state.approvalsFilter.status);
|
|
}
|
|
if (page === "activity") {
|
|
if (state.activityFilter.query) params.set("lq", state.activityFilter.query);
|
|
if (state.activityFilter.type !== "all") params.set("lt", state.activityFilter.type);
|
|
}
|
|
const query = params.toString();
|
|
return query ? `?${query}` : "";
|
|
}
|
|
|
|
function updateRouteQueryForCurrentPage() {
|
|
if (!state.user) {
|
|
return;
|
|
}
|
|
const page = normalizedRmsPage(currentRmsPage());
|
|
const next = `${pageToPath(page)}${routeQueryForPage(page)}`;
|
|
const current = `${window.location.pathname}${window.location.search}`;
|
|
if (current !== next) {
|
|
window.history.replaceState({}, "", next);
|
|
}
|
|
}
|
|
|
|
function hydrateFilterStateFromUrl() {
|
|
const params = new URLSearchParams(window.location.search);
|
|
state.usersFilter.query = String(params.get("uq") || "").trim().toLowerCase();
|
|
state.usersFilter.role = normalizeFilterValue(params.get("ur"), ["all", "admin", "approver", "operator"], "all");
|
|
state.usersFilter.status = normalizeFilterValue(
|
|
params.get("us"),
|
|
["all", "active", "pending_approval", "pending_verification", "denied"],
|
|
"all"
|
|
);
|
|
|
|
state.approvalsFilter.mode = normalizeFilterValue(params.get("am"), ["open", "all"], "open");
|
|
state.approvalsFilter.query = String(params.get("aq") || "").trim().toLowerCase();
|
|
state.approvalsFilter.status = normalizeFilterValue(params.get("as"), ["all", "pending", "approved", "rejected"], "all");
|
|
|
|
state.activityFilter.query = String(params.get("lq") || "").trim().toLowerCase();
|
|
state.activityFilter.type = normalizeFilterValue(
|
|
params.get("lt"),
|
|
[
|
|
"all",
|
|
"auth.request_access",
|
|
"station.activate.start",
|
|
"station.activate.done",
|
|
"station.activate.failed",
|
|
"station.deactivate",
|
|
"station.deactivate.timeout"
|
|
],
|
|
"all"
|
|
);
|
|
|
|
syncFilterInputsFromState();
|
|
}
|
|
|
|
function syncFilterInputsFromState() {
|
|
if (els.usersFilterQuery) els.usersFilterQuery.value = state.usersFilter.query;
|
|
if (els.usersFilterRole) els.usersFilterRole.value = state.usersFilter.role;
|
|
if (els.usersFilterStatus) els.usersFilterStatus.value = state.usersFilter.status;
|
|
if (els.approvalsFilterQuery) els.approvalsFilterQuery.value = state.approvalsFilter.query;
|
|
if (els.approvalsFilterStatus) els.approvalsFilterStatus.value = state.approvalsFilter.status;
|
|
if (els.activityFilterQuery) els.activityFilterQuery.value = state.activityFilter.query;
|
|
if (els.activityFilterType) els.activityFilterType.value = state.activityFilter.type;
|
|
}
|
|
|
|
function normalizeFilterValue(value, allowed, fallback) {
|
|
return allowed.includes(value) ? value : fallback;
|
|
}
|
|
|
|
function formatRemainingUsage(totalSec) {
|
|
const sec = Math.max(0, Math.floor(Number(totalSec || 0)));
|
|
const hours = Math.floor(sec / 3600);
|
|
const minutes = Math.floor((sec % 3600) / 60);
|
|
const seconds = sec % 60;
|
|
if (hours > 0) {
|
|
return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
|
|
}
|
|
return `${minutes}:${String(seconds).padStart(2, "0")}`;
|
|
}
|
|
|
|
function withCacheVersion(url, version) {
|
|
const rawUrl = String(url || "").trim();
|
|
if (!rawUrl) {
|
|
return "";
|
|
}
|
|
const rawVersion = String(version || "").trim();
|
|
if (!rawVersion) {
|
|
return rawUrl;
|
|
}
|
|
const separator = rawUrl.includes("?") ? "&" : "?";
|
|
return `${rawUrl}${separator}v=${encodeURIComponent(rawVersion)}`;
|
|
}
|
|
|
|
function setUserMenuOpen(open) {
|
|
const effective = Boolean(open && state.user);
|
|
els.userMenu.hidden = !effective;
|
|
els.userMenuButton.setAttribute("aria-expanded", effective ? "true" : "false");
|
|
els.userMenuButton.textContent = "☰";
|
|
if (state.user) {
|
|
els.userMenuButton.setAttribute("aria-label", effective ? `Menue schliessen (${state.user.email})` : `Menue oeffnen (${state.user.email})`);
|
|
} else {
|
|
els.userMenuButton.setAttribute("aria-label", effective ? "Menue schliessen" : "Menue oeffnen");
|
|
}
|
|
}
|
|
|
|
function setLanguageMenuOpen(open) {
|
|
if (!els.languageMenu || !els.languageMenuButton) {
|
|
return;
|
|
}
|
|
const effective = Boolean(open);
|
|
els.languageMenu.hidden = !effective;
|
|
els.languageMenuButton.setAttribute("aria-expanded", effective ? "true" : "false");
|
|
}
|
|
|
|
function toggleTheme() {
|
|
const current = document.documentElement.dataset.theme || "dark";
|
|
const next = current === "dark" ? "light" : "dark";
|
|
document.documentElement.dataset.theme = next;
|
|
localStorage.setItem("arcg-theme", next);
|
|
updateThemeToggleIcon();
|
|
renderBranding();
|
|
}
|
|
|
|
function loadTheme() {
|
|
const saved = localStorage.getItem("arcg-theme");
|
|
document.documentElement.dataset.theme = saved === "light" ? "light" : "dark";
|
|
updateThemeToggleIcon();
|
|
renderBranding();
|
|
}
|
|
|
|
function updateThemeToggleIcon() {
|
|
if (!els.themeToggle) {
|
|
return;
|
|
}
|
|
const theme = document.documentElement.dataset.theme || "dark";
|
|
if (theme === "dark") {
|
|
els.themeToggle.textContent = "☀";
|
|
els.themeToggle.setAttribute("aria-label", "Zu Light Mode wechseln");
|
|
return;
|
|
}
|
|
els.themeToggle.textContent = "☾";
|
|
els.themeToggle.setAttribute("aria-label", "Zu Dark Mode wechseln");
|
|
}
|
|
|
|
function isAdmin() {
|
|
return Boolean(state.user && state.user.role === "admin");
|
|
}
|
|
|
|
function canOperateStation() {
|
|
return Boolean(state.user && (state.user.role === "admin" || state.user.role === "approver" || state.user.role === "operator"));
|
|
}
|
|
|
|
function canSeeApprovals() {
|
|
return Boolean(state.user && (state.user.role === "admin" || state.user.role === "approver"));
|
|
}
|
|
|
|
function canSeeUsersList() {
|
|
return Boolean(state.user && (state.user.role === "admin" || state.user.role === "approver"));
|
|
}
|
|
|
|
function canSeeActivityLog() {
|
|
return Boolean(state.user && (state.user.role === "admin" || state.user.role === "approver"));
|
|
}
|
|
|
|
function setTokens(accessToken, refreshToken) {
|
|
state.accessToken = accessToken || "";
|
|
state.refreshToken = refreshToken || "";
|
|
if (state.accessToken) {
|
|
localStorage.setItem("rms-access-token", state.accessToken);
|
|
}
|
|
if (state.refreshToken) {
|
|
localStorage.setItem("rms-refresh-token", state.refreshToken);
|
|
}
|
|
}
|
|
|
|
function clearTokens() {
|
|
state.accessToken = "";
|
|
state.refreshToken = "";
|
|
localStorage.removeItem("rms-access-token");
|
|
localStorage.removeItem("rms-refresh-token");
|
|
}
|
|
|
|
let eventSource = null;
|
|
let eventReconnectTimer = null;
|
|
let openWebRxTxPollTimer = null;
|
|
let openWebRxTxPollInFlight = false;
|
|
let openWebRxTxPollIntervalMs = null;
|
|
|
|
function connectEvents() {
|
|
if (!state.accessToken) {
|
|
return;
|
|
}
|
|
if (eventSource) {
|
|
eventSource.close();
|
|
}
|
|
if (eventReconnectTimer) {
|
|
clearTimeout(eventReconnectTimer);
|
|
eventReconnectTimer = null;
|
|
}
|
|
eventSource = new EventSource(`/v1/events/stream?accessToken=${encodeURIComponent(state.accessToken)}`);
|
|
eventSource.onmessage = () => {};
|
|
eventSource.onerror = async () => {
|
|
if (eventSource) {
|
|
eventSource.close();
|
|
eventSource = null;
|
|
}
|
|
const refreshed = await tryRefreshToken({ reason: "sse" });
|
|
if (!state.user || (!state.accessToken && !refreshed)) {
|
|
return;
|
|
}
|
|
if (eventReconnectTimer) {
|
|
clearTimeout(eventReconnectTimer);
|
|
}
|
|
eventReconnectTimer = setTimeout(() => {
|
|
connectEvents();
|
|
}, 2000);
|
|
};
|
|
eventSource.addEventListener("station.status.changed", async () => {
|
|
await refreshStatus();
|
|
if (canSeeActivityLog()) {
|
|
await refreshActivityLog();
|
|
}
|
|
});
|
|
eventSource.addEventListener("station.activation.progress", async () => {
|
|
await refreshStatus();
|
|
});
|
|
eventSource.addEventListener("station.activation.completed", async (event) => {
|
|
activationPending = false;
|
|
stopActivationWatch();
|
|
let reportFromEvent = null;
|
|
try {
|
|
const payload = JSON.parse(event.data || "{}");
|
|
if (payload && payload.swrReport && typeof payload.swrReport === "object") {
|
|
reportFromEvent = payload.swrReport;
|
|
}
|
|
} catch {
|
|
// ignore malformed payload
|
|
}
|
|
if (reportFromEvent) {
|
|
state.swrReport = reportFromEvent;
|
|
renderSwrPanels();
|
|
}
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
const overall = state.swrReport && state.swrReport.overallStatus ? state.swrReport.overallStatus : "UNKNOWN";
|
|
const doneText = `SWR-Check ERFOLGREICH abgeschlossen. Ergebnis: ${overall}.`;
|
|
renderMessage(els.swrSummaryMessage, doneText, false, true);
|
|
renderMessage(els.swrPageMessage, doneText, false, true);
|
|
await refreshControls();
|
|
if (canSeeActivityLog()) {
|
|
await refreshActivityLog();
|
|
}
|
|
});
|
|
eventSource.addEventListener("station.activation.failed", async (event) => {
|
|
activationPending = false;
|
|
stopActivationWatch();
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
let errorText = "Unbekannter Fehler";
|
|
try {
|
|
const payload = JSON.parse(event.data || "{}");
|
|
if (payload && payload.error) {
|
|
errorText = String(payload.error);
|
|
}
|
|
} catch {
|
|
// ignore parse issues
|
|
}
|
|
const failText = `SWR-Check fertig, Aktivierung fehlgeschlagen: ${errorText}`;
|
|
renderMessage(els.swrSummaryMessage, failText, true);
|
|
renderMessage(els.swrPageMessage, failText, true);
|
|
await refreshControls();
|
|
});
|
|
eventSource.addEventListener("swr.run.started", async () => {
|
|
await refreshStatus();
|
|
});
|
|
eventSource.addEventListener("swr.run.finished", async () => {
|
|
await refreshStatus();
|
|
await refreshSwrReport();
|
|
});
|
|
eventSource.addEventListener("swr.report.changed", async () => {
|
|
await refreshSwrReport();
|
|
});
|
|
eventSource.addEventListener("plugin.provider.changed", async () => {
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
});
|
|
eventSource.addEventListener("plugin.enabled.changed", async () => {
|
|
await refreshPlugins();
|
|
await refreshControls();
|
|
});
|
|
eventSource.addEventListener("plugin.health.changed", async () => {
|
|
await refreshPlugins();
|
|
});
|
|
eventSource.addEventListener("approval.status.changed", async () => {
|
|
await refreshApprovals();
|
|
await refreshUsers();
|
|
if (canSeeActivityLog()) {
|
|
await refreshActivityLog();
|
|
}
|
|
});
|
|
eventSource.addEventListener("system.maintenance.enabled", async (event) => {
|
|
const payload = JSON.parse(event.data || "{}");
|
|
state.system.maintenanceMode = true;
|
|
state.system.maintenanceMessage = payload.message || state.system.maintenanceMessage;
|
|
if (!isAdmin()) {
|
|
await logout(true, true);
|
|
return;
|
|
}
|
|
renderMaintenanceBanner();
|
|
});
|
|
eventSource.addEventListener("system.maintenance.disabled", async () => {
|
|
state.system.maintenanceMode = false;
|
|
await refreshPublicSystemStatus();
|
|
});
|
|
eventSource.addEventListener("branding.updated", async () => {
|
|
await refreshPublicSystemStatus();
|
|
});
|
|
}
|
|
|
|
async function api(path, options = {}, triedRefresh = false) {
|
|
const headers = {
|
|
"Content-Type": "application/json"
|
|
};
|
|
const authRequired = options.authRequired !== false;
|
|
if (authRequired && state.accessToken) {
|
|
headers.Authorization = `Bearer ${state.accessToken}`;
|
|
}
|
|
|
|
const response = await fetch(path, {
|
|
method: options.method || "GET",
|
|
headers,
|
|
body: options.body ? JSON.stringify(options.body) : undefined
|
|
});
|
|
|
|
const payload = await response.json().catch(() => ({}));
|
|
if (response.status === 401 && authRequired && !triedRefresh && state.refreshToken) {
|
|
const refreshed = await tryRefreshToken();
|
|
if (refreshed) {
|
|
return api(path, options, true);
|
|
}
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const err = new Error((payload.error && payload.error.message) || `Request failed: ${response.status}`);
|
|
err.status = response.status;
|
|
err.code = payload && payload.error ? payload.error.code : undefined;
|
|
throw err;
|
|
}
|
|
return payload;
|
|
}
|
|
|
|
async function tryRefreshToken(options = {}) {
|
|
const reason = String(options.reason || "api");
|
|
if (!state.refreshToken) {
|
|
return false;
|
|
}
|
|
try {
|
|
const result = await api("/v1/auth/refresh", {
|
|
method: "POST",
|
|
body: { refreshToken: state.refreshToken },
|
|
authRequired: false
|
|
}, true);
|
|
setTokens(result.accessToken, result.refreshToken);
|
|
state.user = result.user;
|
|
updateUserUi();
|
|
return true;
|
|
} catch {
|
|
if (reason !== "sse") {
|
|
clearTokens();
|
|
state.user = null;
|
|
updateUserUi();
|
|
}
|
|
return false;
|
|
}
|
|
}
|