Upload 3 files

Dockerfile

@@ -0,0 +1,32 @@
+FROM node:18-slim
+
+# Switch to the node user
+USER node
+
+# Set environment variables for the user
+ENV HOME=/home/node \
+    PATH=/home/node/.local/bin:$PATH
+
+# Set the working directory
+WORKDIR $HOME/app
+
+# Copy the package.json and package-lock.json files to the working directory
+COPY --chown=node:node package*.json ./
+
+# Install Node.js dependencies
+RUN npm install
+
+# Copy the application code to the working directory
+COPY --chown=node:node . .
+
+# Ensure the ownership of the directory to the node user
+RUN chown -R node:node .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+RUN echo $SERVICE_ACC_JSON > serviceAcc.json
+
+
+# Command to run the Node.js server
+CMD ["node", "index.js"]

index.js

@@ -0,0 +1,188 @@
+// server.js (Node.js with Express and ws)
+
+const express = require('express');
+const { WebSocketServer } = require('ws');
+const cors = require('cors'); // Import CORS
+
+const { initializeApp, cert } = require('firebase-admin/app');
+const { getFirestore } = require('firebase-admin/firestore');
+
+var admin = require("firebase-admin");
+
+const serviceAccount = require("./serviceAcc.json");
+
+initializeApp({
+  credential: cert(serviceAccount)
+});
+
+
+const db = getFirestore();
+const app = express();
+const port = process.env.PORT || 8080;
+
+const wss = new WebSocketServer({ noServer: true });
+
+app.use(cors());
+
+var initialData = {};
+let currentDeviceStates = {}; 
+
+const fetchInitialData = async () => {
+    const devices = [];
+    const rooms = [];
+    const users = [];
+
+    try {
+        const deviceSnapshot = await db.collection('Devices').get();
+        deviceSnapshot.forEach(doc => devices.push({ id: doc.id, ...doc.data() }));
+
+        const roomsSnapshot = await db.collectionGroup('Rooms').get(); // Get all rooms across hostels
+        roomsSnapshot.forEach(doc => rooms.push({ id: doc.id, ...doc.data(), hostelId: doc.ref.parent.parent.id })); // Include hostelId
+
+        const usersSnapshot = await db.collection('Users').get();
+        usersSnapshot.forEach(doc => users.push({ id: doc.id, ...doc.data() }));
+
+        initialData = { devices, rooms, users };
+
+        // console.log("Initial data fetched:", initialData);
+        //for each hostel id mantain a list of rooms with devices pertaining to that hostel
+        
+        //setall to off
+
+        initialData.devices.forEach(device => {
+            device.state = false;
+        }  ); 
+
+        initialData.rooms.forEach(room => {
+            if (!currentDeviceStates[room.id]) {
+                currentDeviceStates[room.id] = [];
+            }
+            
+            const roomDevices = initialData.devices.filter(device => device.hostelId === room.hostelId);
+            currentDeviceStates[room.id] = { ...room, devices: roomDevices };
+        });
+
+
+
+
+    } catch (error) {
+        console.error("Error fetching initial data:", error);
+        // return { devices: [], rooms: [], users: [] };
+        initialData = { devices, rooms, users };
+    }
+};
+
+
+
+fetchInitialData();
+
+
+
+const connectedClients = {}; // Store connected clients per room
+
+wss.on('connection', (ws) => {
+    ws.on('message', async (message) => {
+      try {
+        const parsedMessage = JSON.parse(message);
+        const { roomId, userId, apiKey } = parsedMessage;
+  
+        // Helper function to check authorization
+        const isAuthorized = (roomId, userId, apiKey) => {
+          return initialData.users.some(user => user.id === userId && user.roomId === roomId) || apiKey === "masterPassword@tiet@123";
+        };
+  
+        switch (parsedMessage.type) {
+          case 'joinRoom':
+            if (!roomId || !userId) {
+              ws.send(JSON.stringify({ error: 'Invalid room or user ID' }));
+              return;
+            }
+  
+            if (!isAuthorized(roomId, userId, apiKey)) {
+              console.log("Unauthorized joinRoom attempt.");
+              ws.send(JSON.stringify({ error: 'Unauthorized' }));
+              return;
+            }
+
+            // Store the connected client
+            if (!connectedClients[roomId]) {
+                connectedClients[roomId] = [];
+              }
+              connectedClients[roomId].push(ws);
+
+  
+            ws.send(JSON.stringify({ type: 'roomData', roomData: currentDeviceStates[roomId], roomId: roomId }));
+            break;
+  
+          case 'updateDeviceState':
+            const { deviceId, state } = parsedMessage;
+            if (!deviceId || state === undefined || !roomId || (!userId && !apiKey)) { // Check for undefined state or missing userId/apiKey
+              ws.send(JSON.stringify({ error: 'Invalid device ID, state, room ID, user ID, or API key' }));
+              return;
+            }
+  
+            if (!isAuthorized(roomId, userId, apiKey)) {
+              console.log("Unauthorized updateDeviceState attempt.");
+              ws.send(JSON.stringify({ error: 'Unauthorized' }));
+              return;
+            }
+  
+  
+            const room = currentDeviceStates[roomId];
+            if (room) { // Check if the room exists
+              const device = room.devices.find(dev => dev.id === deviceId);
+              if (device) { // Check if the device exists
+                device.state = state;
+
+                // Broadcast to all clients in the room
+                if (connectedClients[roomId]) {
+                    connectedClients[roomId].forEach(client => {
+                        client.send(JSON.stringify({ type: 'deviceUpdate', deviceId, state, roomId: roomId }));
+                    });
+                  }
+
+
+              } else {
+                ws.send(JSON.stringify({ error: 'Device not found' }));
+              }
+            } else {
+              ws.send(JSON.stringify({ error: 'Room not found' }));
+            }
+  
+            break;
+  
+          default:
+            console.log('Unknown message type:', parsedMessage.type);
+        }
+  
+      } catch (error) {
+        console.error('Error handling message:', error);
+        ws.send(JSON.stringify({ error: 'Invalid message format' })); // Send error back to client
+      }
+    });
+  
+    ws.on('close', () => {
+      for (const roomId in connectedClients) {
+        connectedClients[roomId] = connectedClients[roomId].filter(client => client !== ws);
+      }
+    });
+
+    ws.on('error', (error) => {
+        console.error('WebSocket error:', error);
+      });
+  });
+
+
+console.log('WebSocket server started on port 8080');
+
+
+
+
+
+const server = app.listen(port, () => console.log(`Listening on port ${port}`));
+
+server.on('upgrade', (request, socket, head) => {
+    wss.handleUpgrade(request, socket, head, ws => {
+        wss.emit('connection', ws, request);
+    });
+});

package.json

@@ -0,0 +1,19 @@
+{
+  "name": "room_sync_sockets",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.21.1",
+    "firebase-admin": "^12.6.0",
+    "ws": "^8.18.0"
+  }
+}