Version 1.10.0: Add kiosk mode features and fix UPS card updates

Author: blink-zero

API.md

@@ -806,7 +806,44 @@ Endpoints for managing UPS systems.
 GET /api/ups-systems
 ```
 
-Returns a list of all UPS systems with their current status.
+Returns a list of all UPS systems with their current status. Requires authentication.
+
+**Response:**
+```json
+[
+  {
+    "id": 1,
+    "name": "ups1",
+    "nickname": "Server Room UPS",
+    "displayName": "Server Room UPS",
+    "upsName": "ups1",
+    "nutServerId": 1,
+    "model": "APC Smart-UPS 1500",
+    "status": "Online",
+    "batteryCharge": 100,
+    "batteryVoltage": 27.3,
+    "inputVoltage": 230.1,
+    "outputVoltage": 230.0,
+    "runtimeRemaining": 120,
+    "load": 30,
+    "temperature": 25.5,
+    "batteryDetails": { ... },
+    "deviceDetails": { ... },
+    "driverDetails": { ... },
+    "inputDetails": { ... },
+    "outputDetails": { ... },
+    "upsDetails": { ... }
+  }
+]
+```
+
+### Get UPS Systems for Kiosk Mode
+
+```
+GET /api/ups-systems/kiosk
+```
+
+Returns a list of all UPS systems with their current status for kiosk mode. This endpoint does not require authentication and is specifically designed for public displays.
 
 **Response:**
 ```json

CHANGELOG.md

@@ -19,6 +19,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Added toggle button to switch between single and multi-view modes
   - Created compact UPS cards for multi-view display
   - Added URL parameters to control view mode and UPS selection
+  - Disabled inactivity timer for kiosk mode to prevent automatic logout
+  - Created dedicated API endpoint for kiosk mode that doesn't require authentication
 
 ## [1.9.1] - 2025-03-02
 

README.md

@@ -1,7 +1,7 @@
 # PowerPulse
 
 ![PowerPulse Logo](https://img.shields.io/badge/PowerPulse-UPS%20Monitoring-blue)
-![Version](https://img.shields.io/badge/version-1.9.1-green)
+![Version](https://img.shields.io/badge/version-1.10.0-green)
 ![License](https://img.shields.io/badge/license-MIT-lightgrey)
 
 PowerPulse is a modern UPS (Uninterruptible Power Supply) monitoring dashboard integrated with Network UPS Tools (NUT). It provides a clean, responsive interface for monitoring and managing your UPS systems.
@@ -21,6 +21,7 @@ PowerPulse is a modern UPS (Uninterruptible Power Supply) monitoring dashboard i
 ## Features
 
 - **UPS Monitoring Dashboard**: View all your UPS systems in a clean, modern interface
+- **Kiosk Mode**: Dedicated full-screen view for public displays without authentication.
 - **UPS System Nicknaming**: Assign custom nicknames to your UPS systems for easier identification
 - **Detailed UPS Information**: Access comprehensive details about each UPS system
 - **Battery History Tracking**: Monitor battery performance over time

client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "powerpulse-client",
   "private": true,
-  "version": "1.9.1",
+  "version": "1.10.0",
   "author": "blink-zero",
   "repository": {
     "type": "git",

client/src/pages/KioskMode.jsx

@@ -4,6 +4,27 @@ import { FiBattery, FiAlertCircle, FiClock, FiZap, FiActivity, FiThermometer, Fi
 import { useSettings } from '../context/SettingsContext';
 import { useLocation, useNavigate } from 'react-router-dom';
 
+// Disable inactivity timer for kiosk mode
+const disableInactivityTimer = () => {
+  // Clear any existing inactivity timer
+  const existingTimer = localStorage.getItem('lastActivityTimestamp');
+  if (existingTimer) {
+    // Set the timestamp to the current time and keep updating it
+    const updateTimestamp = () => {
+      localStorage.setItem('lastActivityTimestamp', Date.now().toString());
+    };
+    
+    // Update immediately and then every minute
+    updateTimestamp();
+    const intervalId = setInterval(updateTimestamp, 60000);
+    
+    // Return cleanup function
+    return () => clearInterval(intervalId);
+  }
+  
+  return () => {}; // No cleanup needed if no timer exists
+};
+
 // Dashboard reducer for state management
 const initialState = {
   upsSystems: [],
@@ -98,14 +119,15 @@ const KioskMode = () => {
     const fetchUpsSystems = async () => {
       try {
         dispatch({ type: 'SET_LOADING', payload: true });
-        const response = await axios.get('/api/ups/systems');
+        // Use the non-authenticated kiosk endpoint
+        const response = await axios.get('/api/ups/systems/kiosk');
         dispatch({ type: 'SET_UPS_SYSTEMS', payload: response.data });
       } catch (err) {
         dispatch({ 
           type: 'SET_ERROR', 
           payload: 'Failed to fetch UPS systems. Please check your connection to the NUT server.' 
         });
-        console.error('Error fetching UPS systems:', err);
+        console.error('Error fetching UPS systems for kiosk mode:', err);
       } finally {
         dispatch({ type: 'SET_LOADING', payload: false });
       }
@@ -119,6 +141,13 @@ const KioskMode = () => {
     return () => clearInterval(dataInterval);
   }, [getPollIntervalMs]);
 
+  // Disable inactivity timer for kiosk mode
+  useEffect(() => {
+    // This will keep updating the lastActivityTimestamp to prevent auto-logout
+    const cleanup = disableInactivityTimer();
+    return cleanup;
+  }, []);
+
   // Auto-rotate between UPS systems every 10 seconds if there are multiple and not in multi-view mode
   useEffect(() => {
     if (upsSystems.length <= 1 || multiView) return;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "powerpulse",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Modern UPS monitoring dashboard integrated with Network UPS Tools (NUT)",
   "main": "index.js",
   "scripts": {

server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powerpulse-server",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Backend server for PowerPulse - A modern UPS monitoring dashboard",
   "author": "blink-zero",
   "repository": {

server/routes/upsSystems.js

@@ -5,6 +5,130 @@ const { getNutUpsData } = require('../utils/nutClient');
 
 const router = express.Router();
 
+// Get all UPS systems for kiosk mode (no authentication required)
+router.get('/kiosk', async (req, res) => {
+  try {
+    // First check if we have any UPS systems in the database
+    db.all('SELECT * FROM ups_systems', async (err, dbSystems) => {
+      if (err) {
+        console.error('Database error:', err.message);
+        return res.status(500).json({ message: 'Database error', error: err.message });
+      }
+      
+      // Get all NUT servers from database
+      db.all('SELECT id, host, port, username, password FROM nut_servers', async (err, servers) => {
+        if (err) {
+          console.error('Database error:', err.message);
+          return res.status(500).json({ message: 'Database error', error: err.message });
+        }
+        
+        if (servers.length === 0) {
+          return res.status(404).json({ message: 'No NUT servers configured' });
+        }
+        
+        try {
+          // Get UPS data from all NUT servers
+          const allUpsData = [];
+          
+          // Process each server
+          for (const server of servers) {
+            try {
+              const nutHost = server.host;
+              const nutPort = server.port || 3493;
+              const nutUsername = server.username;
+              const nutPassword = server.password;
+              
+              console.log(`Connecting to NUT server at ${nutHost}:${nutPort} for kiosk mode`);
+              
+              const upsData = await getNutUpsData(nutHost, nutPort, nutUsername, nutPassword);
+              
+              // Map UPS data to include server ID
+              const mappedUpsData = upsData.map(ups => ({
+                ...ups,
+                nutServerId: server.id
+              }));
+              
+              allUpsData.push(...mappedUpsData);
+            } catch (serverErr) {
+              console.error(`Error connecting to NUT server ${server.host}:${server.port}:`, serverErr);
+              // Continue with other servers even if one fails
+            }
+          }
+          
+          // If we have database systems, combine with live data
+          if (dbSystems.length > 0) {
+            const combinedData = dbSystems.map(dbSystem => {
+              // Find matching UPS in live data
+              const liveUps = allUpsData.find(ups => 
+                ups.name === dbSystem.ups_name && 
+                ups.nutServerId === dbSystem.nut_server_id
+              );
+              
+              if (liveUps) {
+                // Combine database and live data
+                return {
+                  id: dbSystem.id,
+                  name: dbSystem.name,
+                  nickname: dbSystem.nickname,
+                  displayName: dbSystem.nickname || liveUps.displayName || dbSystem.name,
+                  upsName: dbSystem.ups_name,
+                  nutServerId: dbSystem.nut_server_id,
+                  model: liveUps.model,
+                  status: liveUps.status,
+                  batteryCharge: liveUps.batteryCharge,
+                  batteryVoltage: liveUps.batteryVoltage,
+                  inputVoltage: liveUps.inputVoltage,
+                  outputVoltage: liveUps.outputVoltage,
+                  runtimeRemaining: liveUps.runtimeRemaining,
+                  load: liveUps.load,
+                  temperature: liveUps.temperature,
+                  // Include extended details
+                  batteryDetails: liveUps.batteryDetails,
+                  deviceDetails: liveUps.deviceDetails,
+                  driverDetails: liveUps.driverDetails,
+                  inputDetails: liveUps.inputDetails,
+                  outputDetails: liveUps.outputDetails,
+                  upsDetails: liveUps.upsDetails,
+                  rawVariables: liveUps.rawVariables
+                };
+              } else {
+                // Return basic info if live data not available
+                return {
+                  id: dbSystem.id,
+                  name: dbSystem.name,
+                  nickname: dbSystem.nickname,
+                  displayName: dbSystem.nickname || dbSystem.name,
+                  upsName: dbSystem.ups_name,
+                  nutServerId: dbSystem.nut_server_id,
+                  status: 'Unknown',
+                  batteryCharge: null,
+                  runtimeRemaining: null,
+                  load: null
+                };
+              }
+            });
+            
+            return res.json(combinedData);
+          } else if (allUpsData.length > 0) {
+            // If no database systems but we have live data, return that
+            return res.json(allUpsData);
+          } else {
+            // If no UPS systems are found, return empty array
+            console.log('No UPS systems found for kiosk mode');
+            return res.json([]);
+          }
+        } catch (nutErr) {
+          console.error('NUT server error:', nutErr);
+          return res.status(500).json({ message: 'Error connecting to NUT servers', error: nutErr.message });
+        }
+      });
+    });
+  } catch (error) {
+    console.error('Error in /api/ups/systems/kiosk:', error);
+    res.status(500).json({ message: 'Server error', error: error.message });
+  }
+});
+
 // Get all UPS systems from database
 router.get('/', authenticateToken, async (req, res) => {
   try {