feat: initialize microservice architecture with auth, api, realtime, copernicus, ml, and console modules

realtime/src/routes/connect.js

@@ -0,0 +1,74 @@
+const express = require('express');
+const db = require('../helper/authdb');
+const tokenStore = require('../helper/tokenStore');
+const redis = require('../helper/redis');
+const router = express.Router();
+
+/**
+ * POST /connect
+ * Il sensore invia il suo codice segreto (token) e metadati opzionali.
+ * Se autentica, riceve un token effimero per la connessione WebSocket.
+ */
+router.post('/', async (req, res) => {
+    try {
+        const { token, metadata } = req.body;
+
+        if (!token) {
+            return res.status(400).send({ error: 'Token is required' });
+        }
+        
+        const sensor = await db.getSensor(token);
+        
+        if (!sensor) {
+            return res.status(401).send({ error: 'token not valid' });
+        }
+        if (!sensor.is_active) {
+            return res.status(403).send({ error: 'token not valid' });
+        }
+
+        // Genera il token effimero valido per max 5 secondi
+        const socketToken = await tokenStore.setToken(sensor.id, metadata, 5);
+
+        return res.status(200).send({
+            socketToken,
+            sensorId: sensor.id,
+            expiresIn: 5
+        });
+    } catch (error) {
+        return res.status(500).send({ error: `${error}` });
+    }
+});
+
+/**
+ * DELETE /connect/:sensorId
+ * Disconnette forzatamente un sensore rimuovendo la sua sessione da Redis.
+ */
+router.delete('/:sensorId', async (req, res) => {
+    const { sensorId } = req.params;
+    
+    try {
+        await redis.deleteSession(sensorId);
+        return res.status(200).send({ result: 'disconnected' });
+    } catch (error) {
+        return res.status(500).send({ error: `${error}` });
+    }
+});
+
+/**
+ * POST /connect/new
+ * Crea un nuovo sensore nel database.
+ */
+router.post('/new', async (req, res) => {
+    const { name, code } = req.body;
+    if (!name || !code) {
+        return res.status(400).send({ error: 'Name and code are required' });
+    }
+    try {
+        await db.createSensor(name, code);
+        return res.status(200).send({ result: 'created' });
+    } catch (error) {
+        return res.status(500).send({ error: `${error}` });
+    }
+});
+
+module.exports = router;

realtime/src/routes/sensors.js

@@ -0,0 +1,36 @@
+const express = require('express');
+const db = require('../helper/authdb');
+
+router = express.Router();
+
+router.get('/', async (req, res) => {
+    const sensors = await db.getSensors();
+    res.status(200).json(sensors);
+});
+
+router.post('/:id/:activity', async (req, res) => {
+    const { id, activity } = req.params;
+    
+    let isActive;
+    if (activity === 'active') {
+        isActive = true;
+    } else if (activity === 'inactive') {
+        isActive = false;
+    } else {
+        return res.status(400).json({ error: 'Invalid activity' });
+    }
+
+    try {
+        const exists = await db.sensorsExists(id);
+        if (!exists) {
+            return res.status(404).json({ error: `Sensor with id ${id} not found` });
+        }
+        await db.setSensorActivity(id, isActive);
+        res.status(200).json({ status: `Sensor ${activity}` });
+    } catch (error) {
+        console.error('Error updating sensor ID:', id, error);
+        res.status(500).json({ error: 'Database error' });
+    }
+})
+
+module.exports = router

realtime/src/routes/sessions.js

@@ -0,0 +1,36 @@
+const express = require('express');
+const redis = require('../helper/redis');
+
+const router = express.Router();
+
+/**
+ * GET /sessions
+ * Ritorna tutti i sensori attualmente connessi con i loro metadati.
+ * Se viene passato un parametro ?sensor=ID, restituisce solo quello.
+ */
+router.get('/', async (req, res) => {
+    const { sensor } = req.query;
+
+    // Se viene passato un parametro ?sensor=ID, restituiamo solo quello
+    if (sensor) {
+        try {
+            const session = await redis.getSession(sensor);
+            if (!session) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            return res.status(200).json(JSON.parse(session));
+        } catch (error) {
+            return res.status(500).json({ error: `${error}` });
+        }
+    }
+
+    // Altrimenti restituiamo tutta la lista
+    try {
+        const sessions = await redis.getSessions();
+        res.status(200).json(sessions);
+    } catch (error) {
+        res.status(500).json({ error: `${error}` });
+    }
+});
+
+module.exports = router;