1048 lines
42 KiB
JavaScript
1048 lines
42 KiB
JavaScript
const path = require('path');
|
|
const HtmlWebpackPlugin = require('html-webpack-plugin');
|
|
const Database = require('better-sqlite3');
|
|
const { config } = require('dotenv');
|
|
const bcrypt = require('bcryptjs');
|
|
const jwt = require('jsonwebtoken');
|
|
const { WebSocketServer } = require('ws');
|
|
|
|
// Load env vars
|
|
config();
|
|
|
|
// Database connection for Dev Server API
|
|
const dbPath = process.env.DB_PATH || path.resolve(__dirname, '../server/data/sensors.db');
|
|
const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret-key-change-me';
|
|
const WS_PORT = process.env.WS_PORT || 3962;
|
|
let db;
|
|
|
|
try {
|
|
db = new Database(dbPath);
|
|
console.log(`[UI Server] Connected to database at ${dbPath}`);
|
|
} catch (err) {
|
|
console.error(`[UI Server] Failed to connect to database at ${dbPath}:`, err.message);
|
|
}
|
|
|
|
// Output bindings: map virtual outputs to physical devices
|
|
// Format: outputChannel -> { device, channel, type }
|
|
const OUTPUT_BINDINGS = {
|
|
'BigDehumid': { device: 'tapo', channel: 'r0', type: 'switch' },
|
|
'CO2Valve': { device: 'tapo', channel: 'c', type: 'switch' },
|
|
};
|
|
|
|
// =============================================
|
|
// WebSocket Server for Agents (port 3962)
|
|
// =============================================
|
|
|
|
// Track authenticated clients by devicePrefix
|
|
const agentClients = new Map(); // devicePrefix -> Set<ws>
|
|
|
|
function validateApiKey(apiKey) {
|
|
if (!db) return null;
|
|
try {
|
|
const stmt = db.prepare('SELECT id, name, device_prefix FROM api_keys WHERE key = ?');
|
|
const result = stmt.get(apiKey);
|
|
|
|
if (result) {
|
|
// Update last_used_at timestamp
|
|
db.prepare("UPDATE api_keys SET last_used_at = datetime('now') WHERE id = ?").run(result.id);
|
|
}
|
|
|
|
return result || null;
|
|
} catch (err) {
|
|
console.error('[WS] Error validating API key:', err.message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function insertReadingsSmart(devicePrefix, readings) {
|
|
if (!db) throw new Error('Database not connected');
|
|
|
|
const isoTimestamp = new Date().toISOString();
|
|
|
|
const stmtLast = db.prepare(`
|
|
SELECT id, value, data, data_type
|
|
FROM sensor_events
|
|
WHERE device = ? AND channel = ?
|
|
ORDER BY timestamp DESC
|
|
LIMIT 1
|
|
`);
|
|
|
|
const stmtUpdate = db.prepare(`
|
|
UPDATE sensor_events SET until = ? WHERE id = ?
|
|
`);
|
|
|
|
const stmtInsert = db.prepare(`
|
|
INSERT INTO sensor_events (timestamp, until, device, channel, value, data, data_type)
|
|
VALUES (?, NULL, ?, ?, ?, ?, ?)
|
|
`);
|
|
|
|
const transaction = db.transaction((items) => {
|
|
let inserted = 0;
|
|
let updated = 0;
|
|
|
|
for (const reading of items) {
|
|
const fullDevice = `${devicePrefix}${reading.device}`;
|
|
const channel = reading.channel;
|
|
|
|
// Determine type and values
|
|
let dataType = 'number';
|
|
let value = null;
|
|
let data = null;
|
|
|
|
if (reading.value !== undefined && reading.value !== null) {
|
|
dataType = 'number';
|
|
value = reading.value;
|
|
} else if (reading.data !== undefined) {
|
|
dataType = 'json';
|
|
data = typeof reading.data === 'string' ? reading.data : JSON.stringify(reading.data);
|
|
} else {
|
|
continue; // Skip invalid
|
|
}
|
|
|
|
// Check last reading for RLE
|
|
const last = stmtLast.get(fullDevice, channel);
|
|
let isDuplicate = false;
|
|
|
|
if (last && last.data_type === dataType) {
|
|
if (dataType === 'number') {
|
|
if (Math.abs(last.value - value) < Number.EPSILON) {
|
|
isDuplicate = true;
|
|
}
|
|
} else {
|
|
// Compare JSON strings
|
|
if (last.data === data) {
|
|
isDuplicate = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isDuplicate) {
|
|
stmtUpdate.run(isoTimestamp, last.id);
|
|
updated++;
|
|
} else {
|
|
stmtInsert.run(isoTimestamp, fullDevice, channel, value, data, dataType);
|
|
inserted++;
|
|
}
|
|
}
|
|
return { inserted, updated };
|
|
});
|
|
|
|
return transaction(readings);
|
|
}
|
|
|
|
function createAgentWebSocketServer() {
|
|
const wss = new WebSocketServer({ port: WS_PORT });
|
|
|
|
wss.on('connection', (ws, req) => {
|
|
const clientId = `${req.socket.remoteAddress}:${req.socket.remotePort}`;
|
|
console.log(`[WS] Client connected: ${clientId}`);
|
|
|
|
const clientState = {
|
|
authenticated: false,
|
|
devicePrefix: null,
|
|
name: null,
|
|
lastPong: Date.now()
|
|
};
|
|
|
|
// Set up ping/pong for keepalive
|
|
ws.isAlive = true;
|
|
ws.on('pong', () => {
|
|
ws.isAlive = true;
|
|
clientState.lastPong = Date.now();
|
|
});
|
|
|
|
ws.on('message', (data) => {
|
|
try {
|
|
const message = JSON.parse(data.toString());
|
|
handleAgentMessage(ws, message, clientState, clientId);
|
|
} catch (err) {
|
|
console.error(`[WS] Error parsing message from ${clientId}:`, err.message);
|
|
ws.send(JSON.stringify({ type: 'error', error: 'Invalid JSON' }));
|
|
}
|
|
});
|
|
|
|
ws.on('close', () => {
|
|
console.log(`[WS] Client disconnected: ${clientId} (${clientState.name || 'unauthenticated'})`);
|
|
if (clientState.devicePrefix && agentClients.has(clientState.devicePrefix)) {
|
|
agentClients.get(clientState.devicePrefix).delete(ws);
|
|
}
|
|
});
|
|
|
|
ws.on('error', (err) => {
|
|
console.error(`[WS] Error for ${clientId}:`, err.message);
|
|
});
|
|
});
|
|
|
|
// Ping interval to detect dead connections
|
|
const pingInterval = setInterval(() => {
|
|
wss.clients.forEach((ws) => {
|
|
if (ws.isAlive === false) {
|
|
console.log('[WS] Terminating unresponsive client');
|
|
return ws.terminate();
|
|
}
|
|
ws.isAlive = false;
|
|
ws.ping();
|
|
});
|
|
}, 30000);
|
|
|
|
wss.on('close', () => {
|
|
clearInterval(pingInterval);
|
|
});
|
|
|
|
console.log(`[WS] WebSocket server listening on port ${WS_PORT}`);
|
|
return wss;
|
|
}
|
|
|
|
function handleAgentMessage(ws, message, clientState, clientId) {
|
|
const { type } = message;
|
|
|
|
switch (type) {
|
|
case 'auth':
|
|
const { apiKey } = message;
|
|
if (!apiKey) {
|
|
ws.send(JSON.stringify({ type: 'auth', success: false, error: 'Missing apiKey' }));
|
|
return;
|
|
}
|
|
|
|
const keyInfo = validateApiKey(apiKey);
|
|
if (!keyInfo) {
|
|
ws.send(JSON.stringify({ type: 'auth', success: false, error: 'Invalid API key' }));
|
|
return;
|
|
}
|
|
|
|
clientState.authenticated = true;
|
|
clientState.devicePrefix = keyInfo.device_prefix;
|
|
clientState.name = keyInfo.name;
|
|
|
|
// Track this connection
|
|
if (!agentClients.has(keyInfo.device_prefix)) {
|
|
agentClients.set(keyInfo.device_prefix, new Set());
|
|
}
|
|
agentClients.get(keyInfo.device_prefix).add(ws);
|
|
|
|
console.log(`[WS] Client authenticated: ${keyInfo.name} (prefix: ${keyInfo.device_prefix})`);
|
|
ws.send(JSON.stringify({ type: 'auth', success: true, devicePrefix: keyInfo.device_prefix, name: keyInfo.name }));
|
|
break;
|
|
|
|
case 'pong':
|
|
// Keepalive from agent - just update timestamp
|
|
clientState.lastPong = Date.now();
|
|
break;
|
|
|
|
case 'data':
|
|
if (!clientState.authenticated) {
|
|
ws.send(JSON.stringify({ type: 'error', error: 'Not authenticated' }));
|
|
return;
|
|
}
|
|
|
|
const { readings } = message;
|
|
if (!Array.isArray(readings) || readings.length === 0) {
|
|
ws.send(JSON.stringify({ type: 'error', error: 'Invalid readings' }));
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const validReadings = readings.filter(r => r.device && r.channel && (r.value !== undefined || r.data !== undefined));
|
|
const result = insertReadingsSmart(clientState.devicePrefix, validReadings);
|
|
ws.send(JSON.stringify({ type: 'ack', count: result.inserted + result.updated }));
|
|
} catch (err) {
|
|
console.error('[WS] Error inserting readings:', err.message);
|
|
ws.send(JSON.stringify({ type: 'error', error: 'Failed to insert readings' }));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ws.send(JSON.stringify({ type: 'error', error: `Unknown message type: ${type}` }));
|
|
}
|
|
}
|
|
|
|
// Send command to all agents with the given device prefix
|
|
function sendCommandToDevicePrefix(devicePrefix, command) {
|
|
const clients = agentClients.get(devicePrefix);
|
|
if (!clients || clients.size === 0) {
|
|
console.log(`[WS] No connected agents for prefix: ${devicePrefix}`);
|
|
return false;
|
|
}
|
|
|
|
const message = JSON.stringify({ type: 'command', ...command });
|
|
let sent = 0;
|
|
|
|
for (const ws of clients) {
|
|
if (ws.readyState === 1) { // OPEN
|
|
ws.send(message);
|
|
sent++;
|
|
}
|
|
}
|
|
|
|
console.log(`[WS] Sent command to ${sent} agent(s) with prefix ${devicePrefix}:`, command);
|
|
return sent > 0;
|
|
}
|
|
|
|
// Periodic sync: push non-zero output states to agents every 60s
|
|
function syncOutputStates() {
|
|
if (!db) return;
|
|
|
|
try {
|
|
// Get current output values
|
|
const stmt = db.prepare(`
|
|
SELECT channel, value FROM output_events
|
|
WHERE id IN (SELECT MAX(id) FROM output_events GROUP BY channel)
|
|
`);
|
|
const rows = stmt.all();
|
|
|
|
for (const row of rows) {
|
|
// Only sync non-zero values
|
|
if (row.value > 0) {
|
|
const binding = OUTPUT_BINDINGS[row.channel];
|
|
if (binding) {
|
|
const success = sendCommandToDevicePrefix(`${binding.device}:`, {
|
|
device: binding.channel,
|
|
action: 'set_state',
|
|
value: 1
|
|
});
|
|
|
|
if (!success) {
|
|
console.error(`[Sync] ERROR: Cannot deliver 'on' command for ${row.channel} -> ${binding.device}:${binding.channel} (no agent connected)`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error('[Sync] Error syncing output states:', err.message);
|
|
}
|
|
}
|
|
|
|
// Start output state sync interval (every 60s)
|
|
setInterval(syncOutputStates, 60000);
|
|
// Also sync immediately on startup after a short delay
|
|
setTimeout(syncOutputStates, 5000);
|
|
|
|
// Start the WebSocket server
|
|
const agentWss = createAgentWebSocketServer();
|
|
|
|
module.exports = {
|
|
entry: './src/index.js',
|
|
output: {
|
|
path: path.join(__dirname, 'dist'),
|
|
filename: 'bundle.js',
|
|
clean: true,
|
|
},
|
|
mode: 'development',
|
|
devtool: 'source-map',
|
|
module: {
|
|
rules: [
|
|
{
|
|
test: /\.(js|jsx)$/,
|
|
exclude: /node_modules/,
|
|
use: {
|
|
loader: 'babel-loader',
|
|
options: {
|
|
presets: ['@babel/preset-env', '@babel/preset-react'],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
test: /\.css$/,
|
|
use: ['style-loader', 'css-loader'],
|
|
},
|
|
],
|
|
},
|
|
resolve: {
|
|
extensions: ['.js', '.jsx'],
|
|
},
|
|
plugins: [
|
|
new HtmlWebpackPlugin({
|
|
template: './public/index.html',
|
|
}),
|
|
],
|
|
devServer: {
|
|
port: 3905,
|
|
historyApiFallback: true,
|
|
hot: true,
|
|
allowedHosts: 'all',
|
|
setupMiddlewares: (middlewares, devServer) => {
|
|
if (!devServer) {
|
|
throw new Error('webpack-dev-server is not defined');
|
|
}
|
|
|
|
// API Endpoints
|
|
const app = devServer.app;
|
|
const bodyParser = require('body-parser');
|
|
app.use(bodyParser.json());
|
|
|
|
// --- Auth API ---
|
|
app.post('/api/login', (req, res) => {
|
|
const { username, password } = req.body;
|
|
try {
|
|
const stmt = db.prepare('SELECT * FROM users WHERE username = ?');
|
|
const user = stmt.get(username);
|
|
|
|
if (!user || !bcrypt.compareSync(password, user.password_hash)) {
|
|
return res.status(401).json({ error: 'Invalid credentials' });
|
|
}
|
|
|
|
const token = jwt.sign({
|
|
id: user.id,
|
|
username: user.username,
|
|
role: user.role
|
|
}, JWT_SECRET, { expiresIn: '24h' });
|
|
|
|
res.json({ token, role: user.role, username: user.username });
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// Middleware to check auth (Optional for read, required for write)
|
|
const checkAuth = (req, res, next) => {
|
|
const authHeader = req.headers.authorization;
|
|
if (authHeader) {
|
|
const token = authHeader.split(' ')[1];
|
|
jwt.verify(token, JWT_SECRET, (err, user) => {
|
|
if (user) req.user = user;
|
|
next();
|
|
});
|
|
} else {
|
|
next();
|
|
}
|
|
};
|
|
|
|
const requireAdmin = (req, res, next) => {
|
|
if (!req.user || req.user.role !== 'admin') {
|
|
return res.status(403).json({ error: 'Admin access required' });
|
|
}
|
|
next();
|
|
};
|
|
|
|
app.use('/api/views', checkAuth);
|
|
|
|
// --- Views API ---
|
|
app.post('/api/views', requireAdmin, (req, res) => {
|
|
const { name, config } = req.body;
|
|
try {
|
|
const stmt = db.prepare('INSERT INTO views (name, config, created_by) VALUES (?, ?, ?)');
|
|
const info = stmt.run(name, JSON.stringify(config), req.user.id);
|
|
res.json({ id: info.lastInsertRowid, name, config });
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// Publicly list views
|
|
app.get('/api/views', (req, res) => {
|
|
try {
|
|
const stmt = db.prepare('SELECT * FROM views ORDER BY position ASC, id ASC');
|
|
const rows = stmt.all();
|
|
const views = rows.map(row => {
|
|
try {
|
|
return { ...row, config: JSON.parse(row.config) };
|
|
} catch (e) {
|
|
return row;
|
|
}
|
|
});
|
|
res.json(views);
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
app.get('/api/views/:id', (req, res) => {
|
|
try {
|
|
const stmt = db.prepare('SELECT * FROM views WHERE id = ?');
|
|
const view = stmt.get(req.params.id);
|
|
if (view) {
|
|
view.config = JSON.parse(view.config);
|
|
res.json(view);
|
|
} else {
|
|
res.status(404).json({ error: 'View not found' });
|
|
}
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// Delete View
|
|
app.delete('/api/views/:id', requireAdmin, (req, res) => {
|
|
try {
|
|
const stmt = db.prepare('DELETE FROM views WHERE id = ?');
|
|
const info = stmt.run(req.params.id);
|
|
if (info.changes > 0) {
|
|
res.json({ success: true });
|
|
} else {
|
|
res.status(404).json({ error: 'View not found' });
|
|
}
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// Update View
|
|
app.put('/api/views/:id', requireAdmin, (req, res) => {
|
|
const { name, config } = req.body;
|
|
try {
|
|
const stmt = db.prepare('UPDATE views SET name = ?, config = ? WHERE id = ?');
|
|
const info = stmt.run(name, JSON.stringify(config), req.params.id);
|
|
if (info.changes > 0) {
|
|
res.json({ id: req.params.id, name, config });
|
|
} else {
|
|
res.status(404).json({ error: 'View not found' });
|
|
}
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// Reorder Views
|
|
app.post('/api/views/reorder', requireAdmin, (req, res) => {
|
|
const { order } = req.body;
|
|
console.log('[API] Reorder request:', order);
|
|
if (!Array.isArray(order)) return res.status(400).json({ error: 'Invalid format' });
|
|
|
|
const updateStmt = db.prepare('UPDATE views SET position = ? WHERE id = ?');
|
|
const updateMany = db.transaction((items) => {
|
|
for (const item of items) {
|
|
console.log('[API] Updating view', item.id, 'to position', item.position);
|
|
updateStmt.run(item.position, item.id);
|
|
}
|
|
});
|
|
|
|
try {
|
|
updateMany(order);
|
|
console.log('[API] Reorder successful');
|
|
res.json({ success: true });
|
|
} catch (err) {
|
|
console.error('[API] Reorder error:', err);
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// =============================================
|
|
// RULES API
|
|
// =============================================
|
|
|
|
// Apply checkAuth middleware to rules API routes
|
|
app.use('/api/rules', checkAuth);
|
|
|
|
// Virtual output channel definitions
|
|
const OUTPUT_CHANNELS = [
|
|
{ channel: 'CircFanLevel', type: 'number', min: 0, max: 10, description: 'Circulation Fan Level' },
|
|
{ channel: 'TentLightLevel', type: 'number', min: 0, max: 10, description: 'Tent Light Level' },
|
|
{ channel: 'TentExhaustLevel', type: 'number', min: 0, max: 10, description: 'Tent Exhaust Fan Level' },
|
|
{ channel: 'RoomExhaustLevel', type: 'number', min: 0, max: 10, description: 'Room Exhaust Fan Level' },
|
|
{ channel: 'CO2Valve', type: 'boolean', min: 0, max: 1, description: 'CO2 Valve' },
|
|
{ channel: 'BigDehumid', type: 'boolean', min: 0, max: 1, description: 'Big Dehumidifier' },
|
|
{ channel: 'TentDehumid', type: 'boolean', min: 0, max: 1, description: 'Tent Dehumidifier' },
|
|
];
|
|
|
|
// GET /api/outputs - List output channel definitions
|
|
app.get('/api/outputs', (req, res) => {
|
|
res.json(OUTPUT_CHANNELS);
|
|
});
|
|
|
|
// GET /api/outputs/values - Get current output values
|
|
app.get('/api/outputs/values', (req, res) => {
|
|
try {
|
|
if (!db) throw new Error('Database not connected');
|
|
const result = {};
|
|
const stmt = db.prepare(`
|
|
SELECT channel, value FROM output_events
|
|
WHERE id IN (
|
|
SELECT MAX(id) FROM output_events GROUP BY channel
|
|
)
|
|
`);
|
|
const rows = stmt.all();
|
|
rows.forEach(row => {
|
|
result[row.channel] = row.value;
|
|
});
|
|
// Fill in defaults for missing channels
|
|
OUTPUT_CHANNELS.forEach(ch => {
|
|
if (result[ch.channel] === undefined) {
|
|
result[ch.channel] = 0;
|
|
}
|
|
});
|
|
res.json(result);
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// GET /api/outputs/commands - Get desired states for bound devices
|
|
// Agents poll this to get commands. Returns { "device:channel": { state: 0|1 } }
|
|
app.get('/api/outputs/commands', (req, res) => {
|
|
try {
|
|
if (!db) throw new Error('Database not connected');
|
|
|
|
// Get current output values
|
|
const stmt = db.prepare(`
|
|
SELECT channel, value FROM output_events
|
|
WHERE id IN (
|
|
SELECT MAX(id) FROM output_events GROUP BY channel
|
|
)
|
|
`);
|
|
const rows = stmt.all();
|
|
const outputValues = {};
|
|
rows.forEach(row => {
|
|
outputValues[row.channel] = row.value;
|
|
});
|
|
|
|
// Map to device commands
|
|
const commands = {};
|
|
for (const [outputChannel, binding] of Object.entries(OUTPUT_BINDINGS)) {
|
|
const value = outputValues[outputChannel] ?? 0;
|
|
const deviceKey = `${binding.device}:${binding.channel}`;
|
|
commands[deviceKey] = {
|
|
state: value > 0 ? 1 : 0,
|
|
source: outputChannel
|
|
};
|
|
}
|
|
|
|
res.json(commands);
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// GET /api/rules - List all rules
|
|
app.get('/api/rules', (req, res) => {
|
|
try {
|
|
if (!db) throw new Error('Database not connected');
|
|
const stmt = db.prepare('SELECT * FROM rules ORDER BY position ASC, id ASC');
|
|
const rows = stmt.all();
|
|
const rules = rows.map(row => ({
|
|
...row,
|
|
conditions: JSON.parse(row.conditions || '{}'),
|
|
action: JSON.parse(row.action || '{}')
|
|
}));
|
|
res.json(rules);
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// POST /api/rules - Create rule (admin only)
|
|
app.post('/api/rules', requireAdmin, (req, res) => {
|
|
const { name, type = 'static', enabled = 1, conditions, action } = req.body;
|
|
if (!name || !conditions || !action) {
|
|
return res.status(400).json({ error: 'Missing required fields: name, conditions, action' });
|
|
}
|
|
try {
|
|
const stmt = db.prepare(`
|
|
INSERT INTO rules (name, type, enabled, conditions, action, created_by)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`);
|
|
const info = stmt.run(
|
|
name,
|
|
type,
|
|
enabled ? 1 : 0,
|
|
JSON.stringify(conditions),
|
|
JSON.stringify(action),
|
|
req.user?.id || null
|
|
);
|
|
res.json({ id: info.lastInsertRowid, name, type, enabled, conditions, action });
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// PUT /api/rules/:id - Update rule (admin only)
|
|
app.put('/api/rules/:id', requireAdmin, (req, res) => {
|
|
const { name, type, enabled, conditions, action } = req.body;
|
|
try {
|
|
const stmt = db.prepare(`
|
|
UPDATE rules SET name = ?, type = ?, enabled = ?, conditions = ?, action = ?, updated_at = datetime('now')
|
|
WHERE id = ?
|
|
`);
|
|
const info = stmt.run(
|
|
name,
|
|
type || 'static',
|
|
enabled ? 1 : 0,
|
|
JSON.stringify(conditions),
|
|
JSON.stringify(action),
|
|
req.params.id
|
|
);
|
|
if (info.changes > 0) {
|
|
res.json({ id: req.params.id, name, type, enabled, conditions, action });
|
|
} else {
|
|
res.status(404).json({ error: 'Rule not found' });
|
|
}
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// DELETE /api/rules/:id - Delete rule (admin only)
|
|
app.delete('/api/rules/:id', requireAdmin, (req, res) => {
|
|
try {
|
|
const stmt = db.prepare('DELETE FROM rules WHERE id = ?');
|
|
const info = stmt.run(req.params.id);
|
|
if (info.changes > 0) {
|
|
res.json({ success: true });
|
|
} else {
|
|
res.status(404).json({ error: 'Rule not found' });
|
|
}
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// POST /api/rules/reorder - Reorder rules (admin only)
|
|
app.post('/api/rules/reorder', requireAdmin, (req, res) => {
|
|
const { order } = req.body;
|
|
if (!Array.isArray(order)) return res.status(400).json({ error: 'Invalid format' });
|
|
|
|
const updateStmt = db.prepare('UPDATE rules SET position = ? WHERE id = ?');
|
|
const updateMany = db.transaction((items) => {
|
|
for (const item of items) {
|
|
updateStmt.run(item.position, item.id);
|
|
}
|
|
});
|
|
|
|
try {
|
|
updateMany(order);
|
|
res.json({ success: true });
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// =============================================
|
|
// RULE RUNNER (Background Job)
|
|
// =============================================
|
|
|
|
// Get current sensor value
|
|
function getSensorValue(channel) {
|
|
// channel format: "device:channel" e.g. "ac:controller:co2"
|
|
const lastColonIndex = channel.lastIndexOf(':');
|
|
if (lastColonIndex === -1) return null;
|
|
const device = channel.substring(0, lastColonIndex);
|
|
const ch = channel.substring(lastColonIndex + 1);
|
|
|
|
const stmt = db.prepare(`
|
|
SELECT value FROM sensor_events
|
|
WHERE device = ? AND channel = ?
|
|
ORDER BY timestamp DESC LIMIT 1
|
|
`);
|
|
const row = stmt.get(device, ch);
|
|
return row ? row.value : null;
|
|
}
|
|
|
|
// Get current output value
|
|
function getOutputValue(channel) {
|
|
const stmt = db.prepare(`
|
|
SELECT value FROM output_events
|
|
WHERE channel = ?
|
|
ORDER BY timestamp DESC LIMIT 1
|
|
`);
|
|
const row = stmt.get(channel);
|
|
return row ? row.value : 0;
|
|
}
|
|
|
|
// Write output value with RLE
|
|
function writeOutputValue(channel, value) {
|
|
const now = new Date().toISOString();
|
|
|
|
// Get last value for this channel
|
|
const lastStmt = db.prepare(`
|
|
SELECT id, value FROM output_events
|
|
WHERE channel = ?
|
|
ORDER BY timestamp DESC LIMIT 1
|
|
`);
|
|
const last = lastStmt.get(channel);
|
|
|
|
const valueChanged = !last || Math.abs(last.value - value) >= Number.EPSILON;
|
|
|
|
if (!valueChanged) {
|
|
// Same value - update the until timestamp (RLE)
|
|
const updateStmt = db.prepare('UPDATE output_events SET until = ? WHERE id = ?');
|
|
updateStmt.run(now, last.id);
|
|
} else {
|
|
// New value - insert new record
|
|
const insertStmt = db.prepare(`
|
|
INSERT INTO output_events (timestamp, until, channel, value, data_type)
|
|
VALUES (?, NULL, ?, ?, 'number')
|
|
`);
|
|
insertStmt.run(now, channel, value);
|
|
console.log(`[RuleRunner] Output changed: ${channel} = ${value}`);
|
|
|
|
// Send command to bound physical device
|
|
const binding = OUTPUT_BINDINGS[channel];
|
|
if (binding) {
|
|
sendCommandToDevicePrefix(`${binding.device}:`, {
|
|
device: binding.channel,
|
|
action: 'set_state',
|
|
value: value > 0 ? 1 : 0
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compare values with operator
|
|
function compareValues(actual, operator, target) {
|
|
if (actual === null || actual === undefined) return false;
|
|
switch (operator) {
|
|
case '=':
|
|
case '==': return actual === target;
|
|
case '!=': return actual !== target;
|
|
case '<': return actual < target;
|
|
case '>': return actual > target;
|
|
case '<=': return actual <= target;
|
|
case '>=': return actual >= target;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
// Evaluate a single condition
|
|
function evaluateCondition(condition) {
|
|
const { type, operator, value, channel } = condition;
|
|
|
|
// Handle AND/OR groups
|
|
if (operator === 'AND' || operator === 'OR') {
|
|
const results = (condition.conditions || []).map(c => evaluateCondition(c));
|
|
return operator === 'AND'
|
|
? results.every(r => r)
|
|
: results.some(r => r);
|
|
}
|
|
|
|
switch (type) {
|
|
case 'time': {
|
|
const now = new Date();
|
|
const currentTime = now.getHours() * 60 + now.getMinutes(); // minutes since midnight
|
|
|
|
if (operator === 'between' && Array.isArray(value)) {
|
|
const [start, end] = value.map(t => {
|
|
const [h, m] = t.split(':').map(Number);
|
|
return h * 60 + m;
|
|
});
|
|
return currentTime >= start && currentTime <= end;
|
|
}
|
|
|
|
const [h, m] = String(value).split(':').map(Number);
|
|
const targetTime = h * 60 + m;
|
|
return compareValues(currentTime, operator, targetTime);
|
|
}
|
|
|
|
case 'date': {
|
|
const now = new Date();
|
|
const today = now.toISOString().split('T')[0];
|
|
|
|
if (operator === 'between' && Array.isArray(value)) {
|
|
return today >= value[0] && today <= value[1];
|
|
}
|
|
if (operator === 'before') return today < value;
|
|
if (operator === 'after') return today > value;
|
|
return today === value;
|
|
}
|
|
|
|
case 'sensor': {
|
|
const sensorValue = getSensorValue(channel);
|
|
return compareValues(sensorValue, operator, value);
|
|
}
|
|
|
|
case 'output': {
|
|
const outputValue = getOutputValue(channel);
|
|
return compareValues(outputValue, operator, value);
|
|
}
|
|
|
|
default:
|
|
console.warn(`[RuleRunner] Unknown condition type: ${type}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Run all rules
|
|
function runRules() {
|
|
if (!db) return;
|
|
|
|
try {
|
|
const rules = db.prepare('SELECT * FROM rules WHERE enabled = 1 ORDER BY position ASC').all();
|
|
const desiredOutputs = {}; // channel -> value
|
|
|
|
for (const rule of rules) {
|
|
try {
|
|
const conditions = JSON.parse(rule.conditions || '{}');
|
|
const action = JSON.parse(rule.action || '{}');
|
|
|
|
if (evaluateCondition(conditions)) {
|
|
// Rule matches - set output (later rules override)
|
|
if (action.channel && action.value !== undefined) {
|
|
desiredOutputs[action.channel] = action.value;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error(`[RuleRunner] Error evaluating rule ${rule.id}:`, err.message);
|
|
}
|
|
}
|
|
|
|
// Write output values
|
|
for (const [channel, value] of Object.entries(desiredOutputs)) {
|
|
writeOutputValue(channel, value);
|
|
}
|
|
} catch (err) {
|
|
console.error('[RuleRunner] Error running rules:', err.message);
|
|
}
|
|
}
|
|
|
|
// Start rule runner (every 10 seconds)
|
|
const ruleRunnerInterval = setInterval(runRules, 10000);
|
|
console.log('[RuleRunner] Started background job (10s interval)');
|
|
|
|
// Clean up on server close
|
|
devServer.server?.on('close', () => {
|
|
clearInterval(ruleRunnerInterval);
|
|
console.log('[RuleRunner] Stopped background job');
|
|
});
|
|
|
|
// GET /api/devices
|
|
// Returns list of unique device/channel pairs (sensors + outputs)
|
|
app.get('/api/devices', (req, res) => {
|
|
try {
|
|
if (!db) throw new Error('Database not connected');
|
|
// Get sensor channels
|
|
const sensorStmt = db.prepare("SELECT DISTINCT device, channel FROM sensor_events WHERE data_type = 'number' ORDER BY device, channel");
|
|
const sensorRows = sensorStmt.all();
|
|
|
|
// Add output channels with 'output' as device
|
|
const outputRows = OUTPUT_CHANNELS.map(ch => ({
|
|
device: 'output',
|
|
channel: ch.channel
|
|
}));
|
|
|
|
res.json([...sensorRows, ...outputRows]);
|
|
} catch (err) {
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
// GET /api/readings
|
|
// Query params: devices (comma sep), channels (comma sep), since (timestamp)
|
|
// Actually, user wants "Last 24h".
|
|
// We can accept `since` or valid ISO string.
|
|
// Expected params: `?device=x&channel=y` (single) or query for multiple?
|
|
// User asked for "chart that is refreshed once a minute... display the last 24 hours with the devices/channels previously selected"
|
|
// Efficient query: select * from sensor_events where timestamp > ? and (device,channel) IN (...)
|
|
// For simplicity, let's allow fetching by multiple devices/channels or just all for last 24h and filter client side?
|
|
// No, database filtering is better.
|
|
// Let's support ?since=ISO_DATE
|
|
|
|
app.get('/api/readings', (req, res) => {
|
|
try {
|
|
if (!db) throw new Error('Database not connected');
|
|
const { since, until } = req.query;
|
|
const startTime = since || new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
|
|
const endTime = until || new Date().toISOString();
|
|
|
|
const requestedSensorChannels = []; // [{device, channel}]
|
|
const requestedOutputChannels = []; // [channel]
|
|
|
|
if (req.query.selection) {
|
|
const selections = req.query.selection.split(',');
|
|
selections.forEach(s => {
|
|
const lastColonIndex = s.lastIndexOf(':');
|
|
if (lastColonIndex !== -1) {
|
|
const d = s.substring(0, lastColonIndex);
|
|
const c = s.substring(lastColonIndex + 1);
|
|
if (d === 'output') {
|
|
requestedOutputChannels.push(c);
|
|
} else {
|
|
requestedSensorChannels.push({ device: d, channel: c });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
const result = {};
|
|
|
|
// 1. Fetch sensor data
|
|
if (requestedSensorChannels.length > 0) {
|
|
let sql = 'SELECT * FROM sensor_events WHERE timestamp > ? AND timestamp <= ? ';
|
|
const params = [startTime, endTime];
|
|
|
|
const placeholders = [];
|
|
requestedSensorChannels.forEach(ch => {
|
|
placeholders.push('(device = ? AND channel = ?)');
|
|
params.push(ch.device, ch.channel);
|
|
});
|
|
if (placeholders.length > 0) {
|
|
sql += `AND (${placeholders.join(' OR ')}) `;
|
|
}
|
|
sql += 'ORDER BY timestamp ASC';
|
|
|
|
const rows = db.prepare(sql).all(...params);
|
|
|
|
// Backfill for sensors
|
|
const backfillStmt = db.prepare(`
|
|
SELECT * FROM sensor_events
|
|
WHERE device = ? AND channel = ?
|
|
AND timestamp <= ?
|
|
AND (until >= ? OR until IS NULL)
|
|
ORDER BY timestamp DESC LIMIT 1
|
|
`);
|
|
|
|
const backfillRows = [];
|
|
requestedSensorChannels.forEach(ch => {
|
|
const prev = backfillStmt.get(ch.device, ch.channel, startTime, startTime);
|
|
if (prev) backfillRows.push(prev);
|
|
});
|
|
|
|
[...backfillRows, ...rows].forEach(row => {
|
|
const key = `${row.device}:${row.channel}`;
|
|
if (!result[key]) result[key] = [];
|
|
const pt = [row.timestamp, row.value];
|
|
if (row.until) pt.push(row.until);
|
|
result[key].push(pt);
|
|
});
|
|
}
|
|
|
|
// 2. Fetch output data
|
|
if (requestedOutputChannels.length > 0) {
|
|
let sql = 'SELECT * FROM output_events WHERE timestamp > ? AND timestamp <= ? ';
|
|
const params = [startTime, endTime];
|
|
|
|
const placeholders = requestedOutputChannels.map(() => 'channel = ?');
|
|
sql += `AND (${placeholders.join(' OR ')}) `;
|
|
params.push(...requestedOutputChannels);
|
|
sql += 'ORDER BY timestamp ASC';
|
|
|
|
const rows = db.prepare(sql).all(...params);
|
|
|
|
// Backfill for outputs
|
|
const backfillStmt = db.prepare(`
|
|
SELECT * FROM output_events
|
|
WHERE channel = ?
|
|
AND timestamp <= ?
|
|
AND (until >= ? OR until IS NULL)
|
|
ORDER BY timestamp DESC LIMIT 1
|
|
`);
|
|
|
|
const backfillRows = [];
|
|
requestedOutputChannels.forEach(ch => {
|
|
const prev = backfillStmt.get(ch, startTime, startTime);
|
|
if (prev) {
|
|
backfillRows.push(prev);
|
|
} else {
|
|
// No data at all - add default 0 value at startTime
|
|
backfillRows.push({ channel: ch, timestamp: startTime, value: 0, until: null });
|
|
}
|
|
});
|
|
|
|
[...backfillRows, ...rows].forEach(row => {
|
|
const key = `output:${row.channel}`;
|
|
if (!result[key]) result[key] = [];
|
|
const pt = [row.timestamp, row.value];
|
|
if (row.until) pt.push(row.until);
|
|
result[key].push(pt);
|
|
});
|
|
}
|
|
|
|
res.json(result);
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).json({ error: err.message });
|
|
}
|
|
});
|
|
|
|
return middlewares;
|
|
},
|
|
},
|
|
};
|