RT-Vis 2d and floating widget API collaboration completed, template Save and get API completed. SOCKET 2d panel and widgets events completed

.env

@@ -7,6 +7,9 @@
 MONGO_USER=admin
 MONGO_PASSWORD=admin321
 MONGO_AUTH_DB=admin
+# MONGO_USER=admin
+# MONGO_PASSWORD=admin321
+# MONGO_AUTH_DB=admin
 MONGO_URI=mongodb://mongo/
 API_PORT=5000
 SOCKET_PORT=8000

src/socket-server/services/visualization/panel-Services.ts

@@ -59,8 +59,9 @@ try {
 }
 
 }
-export const deletePanel = async (data: any) => {
-    const { organization, panelID, zoneId } = data;
+export const panelDelete = async (data: any) => {
+    const { organization, panelName, zoneId } = data;
+    console.log('data: ', data);
     try {
         const existingZone = await zoneSchema(organization).findOne({
           zoneId: zoneId,
@@ -71,17 +72,17 @@ export const deletePanel = async (data: any) => {
 
         const existingPanel = await panelSchema(organization).findOne({
           zoneId: zoneId,
-          _id: panelID,
+          panelName: panelName,
           isArchive: false,
         });
         if (!existingPanel)
             return { success: false, message: 'Panel Already Deleted',organization: organization}
         const updatePanel = await panelSchema(organization).updateOne(
-          { _id: panelID, isArchive: false },
+          { _id: existingPanel._id,  isArchive: false },
           { $set: { isArchive: true } }
         );
         const existingWidgets = await widgetSchema(organization).find({
-          panelID: panelID,
+          panelID:existingPanel._id, 
           isArchive: false,
         });
   
@@ -90,14 +91,13 @@ export const deletePanel = async (data: any) => {
           await widgetData.save();
         }
   
-        if (existingZone.panelOrder.includes(existingPanel.panelName)) {
-          existingZone.panelOrder = existingZone.panelOrder.filter(
-            (panel: any) => panel !== existingPanel.panelName
-          );
+        if (existingZone.panelOrder.includes(existingPanel.panelName))  {
+          const index1 = existingZone.panelOrder.indexOf(existingPanel.panelName);
+          existingZone.panelOrder.splice(index1, 1);
   
-          await existingZone.save();
+        const panelDeleteDatas=  await existingZone.save();
+          return { success: true, message: 'Panel deleted successfully',data:panelDeleteDatas,organization: organization}
         }
-        return { success: true, message: 'Panel deleted successfully',organization: organization}
 
       } catch (error) {
         return { success: false, message: 'Panel not found', error,organization: organization }      }

src/socket-server/services/visualization/widge-Services.ts

@@ -1,5 +0,0 @@
-import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
-import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
-export const addPanel = async (data: any) => {
-
-}  

src/socket-server/services/visualization/widget-Services.ts

@@ -0,0 +1,119 @@
+import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
+import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
+export const addWidget = async (data: any) => {
+    const { organization,panel,zoneId,widget,} = data
+    console.log('data: ', data);
+    try {
+        const existingPanel = await panelSchema(organization).findOne({
+          panelName: widget.panel,
+          zoneId: zoneId,
+          isArchive: false,
+        });
+        if (!existingPanel)
+
+        return { success: false, message: "panelName not found",organization: organization}
+
+  
+        if (existingPanel.panelName === widget.panel) {
+          const existingWidget = await widgetSchema(organization).findOne({
+            panelID: existingPanel._id,
+            widgetID: widget.id,
+            isArchive: false,
+            // widgetOrder: widget.widgetOrder,
+          });
+          if (existingWidget) {
+            const updateWidget = await widgetSchema(
+              organization
+            ).findOneAndUpdate(
+              {
+                panelID: existingPanel._id,
+                widgetID: widget.id,
+                isArchive: false,
+              },
+              {
+                $set: {
+                  panelID: existingPanel._id,
+                  widgetID: widget.id,
+                  Data: {
+                    measurements: widget.Data.measurements,
+                    duration: widget.Data.duration,
+                  },
+                  isArchive: false,
+                },
+              },
+              { upsert: true, new: true } // Upsert: create if not exists, new: return updated document
+            );
+       
+            return { success: false, message: "Widget updated successfully",data:updateWidget,organization: organization}
+
+          }
+          const newWidget = await widgetSchema(organization).create({
+            widgetID: widget.id,
+            elementType: widget.type,
+            // widgetOrder: widgetOrder,
+            widgetName: widget.widgetName,
+            panelID: existingPanel._id,
+            widgetside: widget.panel,
+            // Data: {
+            //   measurements: widget.Data.measurements || {},
+            //   duration: widget.Data.duration || "1hr",
+            // },
+          });
+          if (newWidget) {
+            existingPanel.widgets.push(newWidget._id);
+            await existingPanel.save();
+               return { success: true, message: "Widget already exist for the widgetID",data:existingPanel,organization: organization}
+          }
+        }
+        return { success: false, message:  "Type mismatch",organization: organization}
+     
+      } catch (error: any) {
+        return { success: false, message: 'widge not found', error,organization: organization }
+    }
+}  
+export const Widgetdelete = async (data: any) => {
+  const { widgetID, organization } = data
+  console.log('data: ', data);
+  try {
+    const findWidget = await widgetSchema(organization).findOne({
+      widgetID: widgetID,
+      isArchive: false,
+    });
+    if (!findWidget)
+      return { success: false, message: "Widget not found",organization: organization}
+    const widgetData = await widgetSchema(organization).updateOne(
+      { _id: findWidget._id, isArchive: false },
+      { $set: { isArchive: true } }
+    );
+
+    if (widgetData) {
+      // Find all widgets in the same panel and sort them by widgetOrder
+      const widgets = await widgetSchema(organization).find({
+        panelID: findWidget.panelID,
+        isArchive: false,
+      });
+      // .sort({ widgetOrder: 1 });
+
+      // Reassign widgetOrder values
+      // for (let i = 0; i < widgets.length; i++) {
+      //   widgets[i].widgetOrder = (i + 1).toString(); // Convert to string
+      //   await widgets[i].save();
+      // }
+      const panelData = await panelSchema(organization).findOne({
+        _id: findWidget.panelID,
+        isArchive: false,
+      });
+      if (panelData.widgets.includes(findWidget._id)) {
+        const index1 = panelData.widgets.indexOf(findWidget._id);
+        panelData.widgets.splice(index1, 1);
+      }
+     const panelDeletedata = await panelData.save();
+     console.log('Widget deleted successfully: ');
+     return { success: false, message: "Widget deleted successfully",data:panelDeletedata,organization: organization}
+
+    }
+    
+  } catch (error: any) {
+    return { success: false,  message: error?.message || "An unknown error occurred.", error ,organization: organization}
+  }
+}  

src/socket-server/socket/events.ts

@@ -53,4 +53,10 @@ export const EVENTS = {
    panelUpdateRespones:"viz-panel:response:updates", 
    deletePanel:"v2:viz-panel:delete", 
    PanelDeleteRespones:"viz-panel:response:delete", 
+
+   //widget
+   addWidget:"v2:viz-widget:add",
+   widgetUpdateRespones:"viz-widget:response:updates", 
+   deleteWidget:"v2:viz-widget:delete", 
+   widgetDeleteRespones:"viz-widget:response:delete", 
 }

src/socket-server/socket/socketManager.ts

@@ -7,7 +7,8 @@ import { deleteWallItems, setWallItems } from '../services/assets/wallitem-Contr
 import { deleteLineItems, deleteLinPoiteItems, updateLineItems ,createLineItems, deleteLayer} from '../services/lines/line-Controller.ts';
 import { activeUserOffline, activeUsers } from '../services/users/user-controller.ts';
 import { deleteZone, setZone } from '../services/lines/zone-controller.ts';
-import { addPanel } from '../services/visualization/panel-Services.ts';
+import { addPanel, panelDelete } from '../services/visualization/panel-Services.ts';
+import { addWidget, Widgetdelete } from '../services/visualization/widget-Services.ts';
 
 
 
@@ -432,7 +433,7 @@ const panelHandleEvent=async(event: string, socket: Socket, data: any,namespace:
   
   let result;
   switch (event) {
-    case EVENTS.addPanel:
+    case EVENTS.addPanel:{
       result = await addPanel(data);
       console.log('result: ', result);
       
@@ -443,7 +444,7 @@ const panelHandleEvent=async(event: string, socket: Socket, data: any,namespace:
         const organization=result?.organization
         console.log('organization: ', organization);
         // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
-        console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
         // console.log('emitTarget: ', emitTarget);
         
         socket.to(organization).emit(responseEvent, {
@@ -455,7 +456,34 @@ const panelHandleEvent=async(event: string, socket: Socket, data: any,namespace:
           organization: result.organization,
         });
       }
-      break;
+      break;}
+      case EVENTS.deletePanel: {
+        const result = await panelDelete(data)
+        if (result) {
+          // console.log('result?.success: ', result.organization);
+          const responseEvent = EVENTS.PanelDeleteRespones
+          // console.log('responseEvent: ', responseEvent);
+          const organization = result?.organization
+          // console.log('organization: ', organization);
+          // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+          // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+          // console.log('emitTarget: ', emitTarget);
+          if (organization) {
+            socket.emit(responseEvent, {
+              success: result.success,
+              message: result.message,
+              data: result.data,
+              error: result.error || null,
+              socketId: socket.id,
+              organization,
+            });
+          } else {
+            console.warn(`Organization missing in response for event: ${event}`);
+          }
+        }
+        break
+      }
+  
       
       default:
         return;
@@ -463,6 +491,77 @@ const panelHandleEvent=async(event: string, socket: Socket, data: any,namespace:
       
       
     }
+const widgetHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
+  // console.log('data: ', data);
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
+
+  let result;
+  switch (event) {
+    case EVENTS.addWidget: {
+      result = await addWidget(data);
+      // console.log('result: ', result);
+
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.widgetUpdateRespones
+        // console.log('responseEvent: ', responseEvent);
+        const organization = result?.organization
+        // console.log('organization: ', organization);
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        // console.log('emitTarget: ', emitTarget);
+        if (organization) {
+          socket.to(organization).emit(responseEvent, {
+            success: result.success,
+            message: result.message,
+            data: result.data,
+            error: result.error || null,
+            socketId: socket.id,
+            organization,
+          });
+        } else {
+          console.warn(`Organization missing in response for event: ${event}`);
+        }
+      }
+      break
+    }
+    case EVENTS.deleteWidget: {
+      const result = await Widgetdelete(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.widgetDeleteRespones
+        // console.log('responseEvent: ', responseEvent);
+        const organization = result?.organization
+        // console.log('organization: ', organization);
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        // console.log('emitTarget: ', emitTarget);
+        if (organization) {
+          socket.emit(responseEvent, {
+            success: result.success,
+            message: result.message,
+            data: result.data,
+            error: result.error || null,
+            socketId: socket.id,
+            organization,
+          });
+        } else {
+          console.warn(`Organization missing in response for event: ${event}`);
+        }
+      }
+      break
+    }
+
+    default:
+      return;
+  }
+
+}
+
+
 export const initSocketServer = (httpServer: any) => {
   const io = new Server(httpServer, {
     cors: {
@@ -497,38 +596,40 @@ userStatus(EVENTS.connection, socket, socket.handshake.auth,io);
     });
   });
 
-      // 🔹 Create different namespaces
-      const namespaces = {
-        camera: io.of("/camera"),
-        environment: io.of("/environment"),
-        floorItems: io.of("/floorItems"),
-        wallItems: io.of("/wallItems"),
-        line: io.of("/line"),
-        zone: io.of("/zone"),
-        panel:io.of('/panel')
-      };
+  // 🔹 Create different namespaces
+  const namespaces = {
+    camera: io.of("/camera"),
+    environment: io.of("/environment"),
+    floorItems: io.of("/floorItems"),
+    wallItems: io.of("/wallItems"),
+    line: io.of("/line"),
+    zone: io.of("/zone"),
+    visualization: io.of('/visualization'),
+    // widget:io.of('/widget')
+  };
   // 🔹 Function to handle connections in a namespace
-  const handleNamespace = (namespaceName: string, namespace: any, eventHandler: Function) => {
+  const handleNamespace = (namespaceName: string, namespace: any, ...eventHandlers: Function[]) => {
     namespace.on("connection", (socket: Socket) => {
       console.log(`✅ Client connected to ${namespaceName}: ${socket.id}`);
 
       // Extract organization from query parameters
       const organization = socket.handshake.query.organization as string;
-      console.log(`🔍 Received organization: ${organization}`);
+      // console.log(`🔍 Received organization: ${organization}`);
 
       if (organization) {
         socket.join(organization);
-        console.log(`🔹 Socket ${socket.id} joined room: ${organization}`);
+        // console.log(`🔹 Socket ${socket.id} joined room: ${organization}`);
 
         // Debug: Check rooms
-        console.log(`🛠️ Current rooms for ${socket.id}:`, socket.rooms);
+        // console.log(`🛠️ Current rooms for ${socket.id}:`, socket.rooms);
       } else {
         console.warn(`⚠️ Warning: Socket ${socket.id} did not provide an organization`);
       }
 
       socket.onAny((event: string, data: any) => {
-        console.log(`📩 Event received: ${event}, Data: ${JSON.stringify(data)}`);
-        eventHandler(event, socket, data, namespace); // Pass `namespace` instead of `io`
+        // console.log(`📩 Event received: ${event}, Data: ${JSON.stringify(data)}`);
+        eventHandlers.forEach(handler => handler(event, socket, data, namespace));
+        // eventHandler(event, socket, data, namespace); // Pass `namespace` instead of `io`
       });
 
       socket.on("disconnect", (reason: string) => {
@@ -544,21 +645,10 @@ userStatus(EVENTS.connection, socket, socket.handshake.auth,io);
     handleNamespace("wallItems", namespaces.wallItems, wallItemsHandleEvent);
     handleNamespace("line", namespaces.line, lineHandleEvent);
     handleNamespace("zone", namespaces.zone, zoneHandleEvent);
-    handleNamespace("panel", namespaces.panel, panelHandleEvent);
-  // 📌 **Create a separate namespace for panels**
-  // const panelNamespace = io.of('/panel');
+    // handleNamespace("visualization", namespaces.panel, panelHandleEvent);
+    // handleNamespace("widget", namespaces.visualization, widgetHandleEvent);
+    handleNamespace("visualization", namespaces.visualization, panelHandleEvent, widgetHandleEvent);
 
-  // panelNamespace.on(EVENTS.connection, (socket: Socket) => {
-  //   console.log(`New client connected to /panel namespace: ${socket.id}`);
-
-  //   socket.onAny((event: string, data: any) => {
-  //     panelHandleEvent(event, socket, data);
-  //   });
-
-  //   socket.on(EVENTS.disconnect, (reason: string) => {
-  //     console.log(`Client disconnected from /panel namespace: ${socket.id}, Reason: ${reason}`);
-  //   });
-  // })
 
   return io;
 };