diff --git a/src/api-server/Routes/widget3dRoutes.ts b/src/api-server/Routes/widget3dRoutes.ts
index 31a169f..d5af64a 100644
--- a/src/api-server/Routes/widget3dRoutes.ts
+++ b/src/api-server/Routes/widget3dRoutes.ts
@@ -1,6 +1,6 @@
-import * as express from "express";
-import { widget3dService } from "../controller/visualization/3dWidgetService.ts";
-const router = express.Router();
-router.post("/3dwidget/save", widget3dService.add3Dwidget);
-router.get("/3dwidgetData/:zoneId/:organization", widget3dService.get3Dwiget);
-export default router;
+import * as express from "express";
+import { widget3dService } from "../controller/visualization/3dWidgetService.ts";
+const router = express.Router();
+router.post("/3dwidget/save", widget3dService.add3Dwidget);
+router.get("/3dwidgetData/:zoneId/:organization", widget3dService.get3Dwiget);
+export default router;
diff --git a/src/api-server/controller/visualization/3dWidgetService.ts b/src/api-server/controller/visualization/3dWidgetService.ts
index c00687a..a6d12a9 100644
--- a/src/api-server/controller/visualization/3dWidgetService.ts
+++ b/src/api-server/controller/visualization/3dWidgetService.ts
@@ -1,106 +1,106 @@
-import { Request, Response } from "express";
-import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
-import widget3dModel from "../../../shared/model/vizualization/3dwidget.ts";
-export class widget3dService {
-  static async add3Dwidget(req: Request, res: Response): Promise<any> {
-    try {
-      const { organization, widget, zoneId } = req.body;
-      const existingZone = await zoneSchema(organization).findOne({
-        zoneId: zoneId,
-        isArchive: false,
-      });
-      if (!existingZone)
-        return res.status(404).json({ message: "Zone not found" });
-      const existing3Dwidget = await widget3dModel(organization).findOne({
-        widgetID: widget.id,
-        isArchive: false,
-      });
-      if (existing3Dwidget) {
-        const update3dwidget = await widget3dModel(
-          organization
-        ).findOneAndUpdate(
-          {
-            widgetID: widget.id,
-            zoneId: zoneId,
-            isArchive: false,
-          },
-          { position: widget.position },
-          { upsert: true, new: true }
-        );
-        if (update3dwidget)
-          return res
-            .status(200)
-            .json({ message: "widget update successfully" });
-        else return res.send("Widget not updated");
-      }
-      const newWidget3d = await widget3dModel(organization).create({
-        widgetName: widget.type,
-        widgetID: widget.id,
-        position: widget.position,
-        zoneId,
-      });
-      if (newWidget3d)
-        return res.status(201).json({ message: "Widget created successfully" });
-    } catch (error: any) {
-      return res.status(500).send(error.message);
-    }
-  }
-  static async get3Dwiget(req: Request, res: Response): Promise<any> {
-    try {
-      const { organization, zoneId } = req.params;
-      const existingZone = await zoneSchema(organization).findOne({
-        zoneId: zoneId,
-        isArchive: false,
-      });
-      if (!existingZone) return res.send("Zone not found");
-      const widgetData = await widget3dModel(organization).find({
-        zoneId: zoneId,
-        isArchive: false,
-      });
-      if (!widgetData || widgetData.length === 0) {
-        return res.json([]);
-      }
-
-      const zonebasedWidget = widgetData.map((widget) => ({
-        Data: {
-          measurements: widget.Data?.measurements || {},
-          duration: widget.Data?.duration || "1h",
-        },
-        type: widget.widgetName,
-        id: widget.widgetID,
-        position: widget.position,
-      }));
-      return res.status(200).json(zonebasedWidget);
-    } catch (error: any) {
-      return res.status(500).send(error.message);
-    }
-  }
-  // static async update3Dposition(req: Request, res: Response): Promise<any> {
-  //   try {
-  //     const { organization, id, position, zoneId } = req.body;
-  //     const existing3Dwidget = await widget3dModel(organization).findOne({
-  //       widgetID: id,
-  //       isArchive: false,
-  //     });
-  //     if (existing3Dwidget) {
-  //       const update3dwidget = await widget3dModel(
-  //         organization
-  //       ).findOneAndUpdate(
-  //         {
-  //           widgetID: id,
-  //           zoneId: zoneId,
-  //           isArchive: false,
-  //         },
-  //         { position: position },
-  //         { upsert: true, new: true }
-  //       );
-  //       if (update3dwidget)
-  //         return res.status(200).send("widget update successfully");
-  //     } else {
-  //       return res.status(404).send("widget not found");
-  //     }
-  //   } catch (error: any) {
-  //     return res.status(500).send(error.message);
-  //   }
-  // }
-}
+import { Request, Response } from "express";
+import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
+import widget3dModel from "../../../shared/model/vizualization/3dwidget.ts";
+export class widget3dService {
+  static async add3Dwidget(req: Request, res: Response): Promise<any> {
+    try {
+      const { organization, widget, zoneId } = req.body;
+      const existingZone = await zoneSchema(organization).findOne({
+        zoneId: zoneId,
+        isArchive: false,
+      });
+      if (!existingZone)
+        return res.status(404).json({ message: "Zone not found" });
+      const existing3Dwidget = await widget3dModel(organization).findOne({
+        widgetID: widget.id,
+        isArchive: false,
+      });
+      if (existing3Dwidget) {
+        const update3dwidget = await widget3dModel(
+          organization
+        ).findOneAndUpdate(
+          {
+            widgetID: widget.id,
+            zoneId: zoneId,
+            isArchive: false,
+          },
+          { position: widget.position },
+          { upsert: true, new: true }
+        );
+        if (update3dwidget)
+          return res
+            .status(200)
+            .json({ message: "widget update successfully" });
+        else return res.send("Widget not updated");
+      }
+      const newWidget3d = await widget3dModel(organization).create({
+        widgetName: widget.type,
+        widgetID: widget.id,
+        position: widget.position,
+        zoneId,
+      });
+      if (newWidget3d)
+        return res.status(201).json({ message: "Widget created successfully" });
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+  static async get3Dwiget(req: Request, res: Response): Promise<any> {
+    try {
+      const { organization, zoneId } = req.params;
+      const existingZone = await zoneSchema(organization).findOne({
+        zoneId: zoneId,
+        isArchive: false,
+      });
+      if (!existingZone) return res.send("Zone not found");
+      const widgetData = await widget3dModel(organization).find({
+        zoneId: zoneId,
+        isArchive: false,
+      });
+      if (!widgetData || widgetData.length === 0) {
+        return res.json([]);
+      }
+
+      const zonebasedWidget = widgetData.map((widget) => ({
+        Data: {
+          measurements: widget.Data?.measurements || {},
+          duration: widget.Data?.duration || "1h",
+        },
+        type: widget.widgetName,
+        id: widget.widgetID,
+        position: widget.position,
+      }));
+      return res.status(200).json(zonebasedWidget);
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+  // static async update3Dposition(req: Request, res: Response): Promise<any> {
+  //   try {
+  //     const { organization, id, position, zoneId } = req.body;
+  //     const existing3Dwidget = await widget3dModel(organization).findOne({
+  //       widgetID: id,
+  //       isArchive: false,
+  //     });
+  //     if (existing3Dwidget) {
+  //       const update3dwidget = await widget3dModel(
+  //         organization
+  //       ).findOneAndUpdate(
+  //         {
+  //           widgetID: id,
+  //           zoneId: zoneId,
+  //           isArchive: false,
+  //         },
+  //         { position: position },
+  //         { upsert: true, new: true }
+  //       );
+  //       if (update3dwidget)
+  //         return res.status(200).send("widget update successfully");
+  //     } else {
+  //       return res.status(404).send("widget not found");
+  //     }
+  //   } catch (error: any) {
+  //     return res.status(500).send(error.message);
+  //   }
+  // }
+}
diff --git a/src/shared/model/builder/assets/asset-Model.ts b/src/shared/model/builder/assets/asset-Model.ts
index 68c890a..d2adb3a 100644
--- a/src/shared/model/builder/assets/asset-Model.ts
+++ b/src/shared/model/builder/assets/asset-Model.ts
@@ -35,7 +35,7 @@ export interface assetData extends Document {
   }[];
   position: [];
   // rotation: [];
-    rotation: {
+   rotation: {
     x: number;
     y: number;
     z: number;
@@ -72,7 +72,7 @@ const assetDataSchema: Schema = new Schema({
     },
   ],
   position: { type: Array},
-  // rotation: { type: Array },
+  // rotation: { type:  Array},
   rotation: {
     x: { type: Number },
     y: { type: Number },
diff --git a/src/shared/model/vizualization/floatWidget.ts b/src/shared/model/vizualization/floatWidget.ts
index 2222d40..12ef653 100644
--- a/src/shared/model/vizualization/floatWidget.ts
+++ b/src/shared/model/vizualization/floatWidget.ts
@@ -1,44 +1,44 @@
-import mongoose, { Schema, Document, model } from "mongoose";
-import MainModel from "../../connect/mongoose.ts";
-
-export interface floatingWidget extends Document {
-  className: string;
-  header: string;
-  floatWidgetID: string;
-  position: {};
-  per: string;
-  value: string;
-  isArchive: boolean;
-  zoneId: string;
-  Data: {
-    measurements: {};
-    duration: string;
-  };
-}
-const floatingWidgetSchema: Schema = new Schema(
-  {
-    className: { type: String },
-    header: { type: String },
-    floatWidgetID: { type: String },
-    position: { type: Object },
-    per: { type: String },
-    value: { type: String },
-    zoneId: { type: String },
-    Data: {
-      measurements: { type: Object, default: {} },
-      duration: { type: String, default: "1h" },
-    },
-    isArchive: { type: Boolean, default: false },
-  },
-  { timestamps: true }
-);
-
-const floatWidgetModel = (db: any) => {
-  return MainModel(
-    db,
-    "FloatingWidget",
-    floatingWidgetSchema,
-    "FloatingWidget"
-  );
-};
-export default floatWidgetModel;
+import mongoose, { Schema, Document, model } from "mongoose";
+import MainModel from "../../connect/mongoose.ts";
+
+export interface floatingWidget extends Document {
+  className: string;
+  header: string;
+  floatWidgetID: string;
+  position: {};
+  per: string;
+  value: string;
+  isArchive: boolean;
+  zoneId: string;
+  Data: {
+    measurements: {};
+    duration: string;
+  };
+}
+const floatingWidgetSchema: Schema = new Schema(
+  {
+    className: { type: String },
+    header: { type: String },
+    floatWidgetID: { type: String },
+    position: { type: Object },
+    per: { type: String },
+    value: { type: String },
+    zoneId: { type: String },
+    Data: {
+      measurements: { type: Object, default: {} },
+      duration: { type: String, default: "1h" },
+    },
+    isArchive: { type: Boolean, default: false },
+  },
+  { timestamps: true }
+);
+
+const floatWidgetModel = (db: any) => {
+  return MainModel(
+    db,
+    "FloatingWidget",
+    floatingWidgetSchema,
+    "FloatingWidget"
+  );
+};
+export default floatWidgetModel;
diff --git a/src/socket-server/services/assets/asset-Controller.ts b/src/socket-server/services/assets/asset-Controller.ts
new file mode 100644
index 0000000..905cfcb
--- /dev/null
+++ b/src/socket-server/services/assets/asset-Controller.ts
@@ -0,0 +1,127 @@
+import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
+import actionModel from "../../../shared/model/simulation/actionmodel.ts";
+import triggerModel from "../../../shared/model/simulation/triggersmodel.ts";
+
+export const setAssetModel = async (data: any) => {
+    const {modeluuid, modelname,position,rotation, eventData,modelfileID,isLocked,isVisible,organization, }= data
+    console.log('data: ', data);
+      // const position=data.position
+      // const rotation=data.rotation
+    try {
+        const findvalue = await assetModel(organization).findOne({
+          modeluuid: modeluuid,
+          modelname: modelname,
+        });
+  
+        if (findvalue) {
+          console.log('findvalue: ', findvalue);
+          const updatevalue = await assetModel(organization).findOneAndUpdate(
+            { modeluuid: modeluuid, modelname: modelname },
+            {
+              position: position,
+              rotation: rotation,
+              isVisible: isVisible,
+              isLocked: isLocked,
+            },
+            { new: true }
+          );
+          console.log('updatevalue: ', updatevalue);
+          return { success: true, message: 'Model updated successfully', data: updatevalue, organization: organization }
+        } else {
+            let assetData: any = {
+                modeluuid,
+                modelname,
+                position,
+                modelfileID,
+                rotation,
+                isLocked,
+                isVisible,
+              };
+              if (eventData) {
+                let pointRefs: any[] = [];
+      
+                if (Array.isArray(eventData.points)) {
+                  for (const point of eventData.points) {
+                    let actionRefs: any[] = [];
+                    let triggerRefs: any[] = [];
+      
+                    if (Array.isArray(point.actions)) {
+                      for (const action of point.actions) {
+                        const actionDoc = await actionModel(organization).create({
+                          pointsUUID: point.uuid,
+                          isArchive: false,
+                          uuid: action.uuid,
+                          name: action.name,
+                          type: action.type,
+                          material: action.material,
+                          delay: action.delay,
+                          spawn_Interval: action.spawn_Interval,
+                        });
+                        await actionDoc.save();
+                        actionRefs.push(actionDoc._id);
+                      }
+                    }
+      
+                    if (Array.isArray(point.triggers)) {
+                      for (const trigger of point.triggers) {
+                        const triggerDoc = await triggerModel(organization).create({
+                          pointsUUID: point.uuid,
+                          isArchive: false,
+                          uuid: trigger.uuid,
+                          name: trigger.name,
+                          type: trigger.type,
+                          bufferTime: trigger.bufferTime,
+                        });
+                        await triggerDoc.save();
+                        triggerRefs.push(triggerDoc._id);
+                      }
+                    }
+      
+                    pointRefs.push({
+                      uuid: point.uuid,
+                      position: point.position || [],
+                      rotation: point.rotation || [],
+                      actions: actionRefs,
+                      triggers: triggerRefs,
+                    });
+                  }
+                }
+      
+                assetData.speed = eventData.speed;
+                assetData.type = eventData.type;
+                assetData.points = pointRefs;
+              }
+      
+              const assetDoc = await assetModel(organization).create(assetData);
+              await assetDoc.save();
+        //   await assetDoc.save();
+  // if(assetDoc.)
+         const assetDatas={
+          modeluuid:assetDoc.modeluuid,modelname:assetDoc.modelname,modelfileID:assetDoc.modelfileID,position:assetDoc.position,rotation:assetDoc.rotation,isLocked:assetDoc.isLocked,isVisible:assetDoc.isVisible
+          ,eventData:{points:assetDoc.points,type:assetDoc.type,speed:assetDoc.speed}
+        } 
+          return { success: true, message:"Model created successfully", data: assetDatas, organization: organization }
+        }
+      } catch (error:any) {
+        // console.error("Error creating flooritems:", error);
+        return { success: false, message: error?.message || "Error occurred while ModelAsset", error, organization: organization }
+      }
+}
+ export const deleteAssetModel = async (data: any)=>{
+   const { modeluuid,modelname,organization } = data;
+        try {
+
+            const findValue = await assetModel(organization).findOneAndDelete({modeluuid:modeluuid,modelname:modelname})
+            if (!findValue) {
+                return { success: false, message: 'model not found',organization:organization }
+
+            } else {
+
+                return { success: true, message: 'Model deleted successfully', data: findValue,organization:organization }
+            }
+        } catch (error) {
+            // console.error('Error get flooritems:', error);
+            return { success: false, message: 'Failed to delete asset', error,organization:organization }
+
+        }
+    }
\ No newline at end of file
diff --git a/src/socket-server/services/camera/camera-Controller.ts b/src/socket-server/services/camera/camera-Controller.ts
index 3d60233..b36c4c5 100644
--- a/src/socket-server/services/camera/camera-Controller.ts
+++ b/src/socket-server/services/camera/camera-Controller.ts
@@ -3,9 +3,9 @@ import { Socket } from "socket.io";
 import cameraModel from "../../../shared/model/camera/camera-Model.ts";
 
 export const createCamera = async (data: any,) => {
+    const { userId, position, target, organization,rotation } = data
     try {
 
-        const { userId, position, target, organization,rotation } = data
 
         const findCamera = await cameraModel(organization).findOne({ userId: userId })
         if (findCamera) {
@@ -18,14 +18,14 @@ export const createCamera = async (data: any,) => {
         else {
             const newCamera = await cameraModel(organization).create({ userId, position, target,rotation })
 
-            return { success: false, message: 'Camera created' ,data:newCamera,organization:organization}
+            return { success: true, message: 'Camera created' ,data:newCamera,organization:organization}
            
         }
 
         // Send response with the created document
     } catch (error) {
         console.error('Error creating camera:', error);
-        return { success: false, message: 'Error creating or updating camera', error, }
+        return { success: false, message: 'Error creating or updating camera', error, organization:organization}
     }
 }
 
diff --git a/src/socket-server/services/environments/environments-controller.ts b/src/socket-server/services/environments/environments-controller.ts
index 08b148c..8137bdf 100644
--- a/src/socket-server/services/environments/environments-controller.ts
+++ b/src/socket-server/services/environments/environments-controller.ts
@@ -4,8 +4,8 @@ import environmentModel from "../../../shared/model/environments/environments-Mo
 
 
 export const setEnvironment = async (data: any,) => {
+    const { userId,roofVisibility,wallVisibility,shadowVisibility, organization } = data
     try {
-        const { userId,roofVisibility,wallVisibility,shadowVisibility, organization } = data
 
         const findvalue = await environmentModel(organization).findOne({ userId: userId })
         if (findvalue) {
@@ -27,7 +27,7 @@ export const setEnvironment = async (data: any,) => {
         // Send response with the created document
     } catch (error) {
         console.error('Error creating evironments:', error);
-        return { success: false, message: 'Error creating or updating evironments', error }
+        return { success: false, message: 'Error creating or updating evironments', error ,organization:organization}
     }
 }
 
diff --git a/src/socket-server/services/lines/line-Controller.ts b/src/socket-server/services/lines/line-Controller.ts
index d3156a4..6497bea 100644
--- a/src/socket-server/services/lines/line-Controller.ts
+++ b/src/socket-server/services/lines/line-Controller.ts
@@ -3,21 +3,21 @@ import lineModel from "../../../shared/model/lines/lines-Model.ts";
 
 
 export const createLineItems = async (data: any)=>{
+    const {organization,layer,line,type}=data
         try {
-            const {organization,layer,line,type}=data
             const newLine = await lineModel(organization).create({ layer,line,type });
             return  { success: true, message: 'line create', data: newLine,organization:organization }
     
             // Send response with the created document
         } catch (error) {
  
-            return { success: false, message: 'Error  create line', error }
+            return { success: false, message: 'Error  create line', error,organization:organization }
   
         }
     }
 export const updateLineItems = async (data: any)=>{
+    const {organization,uuid,position,}=data
         try {
-            const {organization,uuid,position,}=data
             // const findLine = await lineModel(organization).find({ 'line.uuid': uuid });
             // Update the position of the line matching the uuid
         const updateResult = await lineModel(organization).updateMany(
@@ -29,13 +29,13 @@ export const updateLineItems = async (data: any)=>{
             // Send response with the created document
         } catch (error) {
             console.error('Error creating Lines:', error);
-            return { success: false, message: 'Error  updating line', error }
+            return { success: false, message: 'Error  updating line', error,organization:organization }
         }
     }
 
     export const deleteLineItems = async (data: any)=>{
+        const {organization,line}=data
         try {
-            const {organization,line}=data
 
             const inputUuids = line.map((item: any) => item.uuid);
       
@@ -54,12 +54,12 @@ export const updateLineItems = async (data: any)=>{
             }
         } catch (error) {
             console.error('Error delete Lines:', error);
-            return { success: false, message: 'Failed to delete line', error }
+            return { success: false, message: 'Failed to delete line', error ,organization:organization}
         }
     }
     export const deleteLayer = async (data: any)=>{
+        const {organization,layer}=data
         try {
-            const {organization,layer}=data
 
             const findValue = await lineModel(organization).find({ layer: layer });
        
@@ -77,12 +77,12 @@ export const updateLineItems = async (data: any)=>{
             }
         } catch (error) {
             console.error('Error delete layer:', error);
-            return { success: false, message: 'Failed to delete layer', error }
+            return { success: false, message: 'Failed to delete layer', error ,organization:organization}
         }
     }
     export const deleteLinPoiteItems = async (data: any)=>{
+        const {organization,uuid}=data
         try {
-            const {organization,uuid}=data
         
      
             const findValue = await lineModel(organization).deleteMany({ 'line.uuid': uuid })
@@ -95,6 +95,6 @@ export const updateLineItems = async (data: any)=>{
             }
         } catch (error) {
             console.error('Error delete Lines:', error);
-            return { success: false, message: 'Failed to delete point', error }
+            return { success: false, message: 'Failed to delete point', error ,organization:organization}
         }
     }
diff --git a/src/socket-server/services/lines/zone-controller.ts b/src/socket-server/services/lines/zone-controller.ts
index 1a8a8b5..af3fab5 100644
--- a/src/socket-server/services/lines/zone-controller.ts
+++ b/src/socket-server/services/lines/zone-controller.ts
@@ -1,9 +1,7 @@
-import zoneModel from "../../../shared/model/lines/zone-Model.ts";
-
+import zoneModel from "../../../shared/model/builder/lines/zone-Model.ts";
 export const setZone = async (data: any) => {
+    const { organization, userId, zoneData } = data
     try {
-        const { organization, userId, zoneData } = data
-        console.log('data: ', data);
         const zoneId = zoneData.zoneId
         const points = zoneData.points
         const zoneName = zoneData.zoneName
@@ -18,7 +16,7 @@ export const setZone = async (data: any) => {
             return { success: true, message: 'zone updated', data: updateZone, organization: organization }
         } else {
             const zoneCreate = await zoneModel(organization).create({
-                zoneId, createBy: userId, zoneName: zoneName, points, layer, viewPortCenter, viewPortposition
+                zoneId, createdBy: userId, zoneName: zoneName, points, layer, viewPortCenter, viewPortposition
             })
             const createdZone = await zoneModel(organization)
                 .findById(zoneCreate._id)
@@ -28,18 +26,18 @@ export const setZone = async (data: any) => {
         }
     } catch (error) {
         console.log('error: ', error);
-        return { success: false, message: 'Zone not found', error }
+        return { success: false, message: 'Zone not found', error , organization: organization}
     }
 }
 
 export const deleteZone = async (data: any) => {
+    const { organization, userId, zoneId } = data
     try {
-        const { organization, userId, zoneId } = data
 
         const findZoneId = await zoneModel(organization).findOne({ zoneId: zoneId })
         if (findZoneId) {
             const deleteZone = await zoneModel(organization).findOneAndDelete(
-                { zoneId: zoneId, createBy: userId }
+                { zoneId: zoneId, createdBy: userId }
             ).select("-_id -__v")
             return { success: true, message: 'zone deleted', data: deleteZone, organization: organization }
         } else {
@@ -48,6 +46,6 @@ export const deleteZone = async (data: any) => {
         }
     } catch (error) {
         console.log('error: ', error);
-        return { success: false, message: 'Zone not found', error }
+        return { success: false, message: 'Zone not found', error, organization: organization }
     }
 }
\ No newline at end of file
diff --git a/src/socket-server/services/users/user-controller.ts b/src/socket-server/services/users/user-controller.ts
index cc6040e..79cd857 100644
--- a/src/socket-server/services/users/user-controller.ts
+++ b/src/socket-server/services/users/user-controller.ts
@@ -2,6 +2,8 @@ import cameraModel from "../../../shared/model/camera/camera-Model.ts"
 import userModel from "../../../shared/model/user-Model.ts"
 
 export const activeUsers = async (data: any) => {
+    const {organization}=data
+    // console.log('data: ', data);
     try {
         if (data && data.email) {
          
@@ -42,23 +44,25 @@ export const activeUsers = async (data: any) => {
             // Handle the error or return a default value
             // Example: Return an error response if the email is invalid
             
-            return  { success: false, message: 'Email is missing or invalid',  }
+            return  { success: false, message: 'Email is missing or invalid', organization:organization }
             // return res.status(400).send({ message: 'Email is missing or invalid' });
         }
         
     
         // // return [];
-    } catch (error) {
-      
-        return  { success: false, message:error}
+    } catch (error:any) {
+        return { success: false, message: error?.message || "Error occurred while activeUser", error, organization: organization }
+
+        // return  { success: false, message:error}
     }
 }
 
 export const activeUserOffline = async (data: any) => {
+    
+    
+       const email = data.email
+       const organization = email.split("@")[1].split(".")[0]
     try {
-     
-        const email = data.email
-        const organization = email.split("@")[1].split(".")[0]
 
         const findUsers = await userModel(organization).findOne({email})
         // console.log('findUsers: ', findUsers);
@@ -90,8 +94,44 @@ export const activeUserOffline = async (data: any) => {
             }
         }
         // // return [];
-    } catch (error) {
-      
-        return  { success: false, message: error}
+    } catch (error:any) {
+        return { success: false, message: error?.message || "Error occurred while activeUser", error, organization: organization }
+
+        // return  { success: false, message: error}
     }
 }
+type OnlineUsersMap = Map<string, Set<string>>;
+
+// export const addUserToOnlineList = async (
+//   organization: string,
+//   email: string,
+//   onlineUsers: OnlineUsersMap,
+//   socket: any,
+//   namespace: string
+// ) => {
+//   if (!organization || !email) return;
+//   console.log('organization: ', organization);
+
+//   // Ensure the organization entry exists
+//   if (!onlineUsers.has(organization)) {
+//     onlineUsers.set(organization, new Set());
+//   }
+//   const findUser = await userModel(organization).findOne({email})
+//   if (!findUser) {
+//       return { success: false, message: "User not found", organization };
+//     }
+//     const userId = findUser._id;
+//     console.log(`🔍 Found user with ID: ${userId}`);
+//   // Add user to the online set
+//   onlineUsers.get(organization)!.add(userId);
+
+//   console.log(`✅ User ${userId} is online (Org: ${organization})`);
+
+//   // Emit updated online users list
+//   socket.emit("users:online", {
+//     organization,
+//     users: [...onlineUsers.get(organization)!],
+//   });
+// };
+
+  
\ No newline at end of file
diff --git a/src/socket-server/services/visualization/floatWidgetService.ts b/src/socket-server/services/visualization/floatWidgetService.ts
new file mode 100644
index 0000000..63f49df
--- /dev/null
+++ b/src/socket-server/services/visualization/floatWidgetService.ts
@@ -0,0 +1,58 @@
+import floatWidgetModel from "../../../shared/model/vizualization/3dwidget.ts";
+import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
+
+export const addfloat = async (data: any) => {
+    const { organization, widget, zoneId } = data;
+    console.log('data: ', data);
+    try {
+        const existingZone = await zoneSchema(organization).findOne({
+            zoneId: zoneId,
+            isArchive: false,
+        });
+        if (!existingZone)
+            return { success: false, message: "Zone not found for the zoneId", organization: organization }
+
+        const existingFloatWidget = await floatWidgetModel(organization).findOne({
+            floatWidgetID: widget.id,
+            isArchive: false,
+        });
+        if (existingFloatWidget) {
+            const updateFloatWidget = await floatWidgetModel(organization).findOneAndUpdate(
+                {
+                    floatWidgetID: widget.id,
+                    isArchive: false,
+                },
+                {
+                    $set: {
+                        // Data: {
+                        //   // measurements: widget.Data.measurements || {},
+                        //   duration: widget.Data.duration || "1h",
+                        // },
+                        position: widget.position,
+                    },
+                },
+                {
+                    upsert: true,
+                    new: true,
+                }
+            );
+            return { success: true, message: "Widget updated successfully", data: updateFloatWidget, organization: organization }
+        }
+
+        const newFloadWidget = await floatWidgetModel(organization).create({
+            className: widget.className,
+            header: widget.header,
+            floatWidgetID: widget.id,
+            position: widget.position,
+            per: widget.per,
+            value: widget.value,
+            zoneId: zoneId,
+        });
+        if (newFloadWidget) {
+            return { success: true, message: "FloatWidget created successfully", data: newFloadWidget, organization: organization }
+        }
+    } catch (error: any) {
+        return { success: false, message: error?.message || "Error occurred while float", error, organization: organization }
+    }
+
+}
diff --git a/src/socket-server/services/visualization/templateServices.ts b/src/socket-server/services/visualization/templateServices.ts
new file mode 100644
index 0000000..51326f1
--- /dev/null
+++ b/src/socket-server/services/visualization/templateServices.ts
@@ -0,0 +1,26 @@
+import templateModel from "../../../shared/model/vizualization/templatemodel.ts";
+export const addTemplate = async (data: any) => {
+    const { organization, templateID, name, panelOrder, widgets, snapshot } =data;
+    console.log('data: ', data);
+    try {
+   
+        const existingTemplate = await templateModel(organization).findOne({
+          templateID: templateID,
+          isArchive: false,
+        });
+        if (existingTemplate)
+            return { success: false, message: "TemplateID alreay exists", organization: organization }
+        const newTemplate = await templateModel(organization).create({
+          templateID,
+          name,
+          panelOrder,
+          widgets,
+          snapshot,
+        });
+        if (newTemplate)
+            return { success: false, message: "Template saved successfully", data: newTemplate, organization: organization }
+      } catch (error: any) {
+        return { success: false, message: error?.message || "Error occurred while template", error, organization: organization }
+      }
+
+}
\ No newline at end of file
diff --git a/src/socket-server/services/visualization/widget-Services.ts b/src/socket-server/services/visualization/widget-Services.ts
index 697fe4b..043fafc 100644
--- a/src/socket-server/services/visualization/widget-Services.ts
+++ b/src/socket-server/services/visualization/widget-Services.ts
@@ -1,119 +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}
-  }
+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}
+  }
 }  
\ No newline at end of file
diff --git a/src/socket-server/socket/events.ts b/src/socket-server/socket/events.ts
index d8e4273..0e90c92 100644
--- a/src/socket-server/socket/events.ts
+++ b/src/socket-server/socket/events.ts
@@ -2,8 +2,8 @@ export const EVENTS = {
    connection: "connection",
    disconnect:"disconnect",
    //userActiveStatus
-   userConnect:"userConnectRespones",
-   userDisConnect:"userDisConnectRespones",
+   userConnect:"userConnectResponse",
+   userDisConnect:"userDisConnectResponse",
    // Room management events
    joinRoom: 'joinRoom',
    createroom: "createRoom",                   // When a client joins a room
@@ -59,4 +59,22 @@ export const EVENTS = {
    widgetUpdateRespones:"viz-widget:response:updates", 
    deleteWidget:"v2:viz-widget:delete", 
    widgetDeleteRespones:"viz-widget:response:delete", 
+
+   //float
+   addFloat: "v2:viz-float:add",
+   floatUpdateRespones: "viz-float:response:updates",
+   deleteFloat: "v2:viz-float:delete",
+   floatDeleteRespones: "viz-float:response:delete",
+
+   //template
+   addTemplate:"v2:viz-template:add",
+   templateUpdateRespones:"viz-template:response:updates",
+
+   //model-asset
+   setAssetModel: "v2:model-asset:add",
+   assetUpdateRespones: "model-asset:response:updates",
+   deleteAssetModel:"v2:model-asset:delete",
+   assetDeleteRespones: "model-asset:response:updates",
+
+
 }
\ No newline at end of file
diff --git a/src/socket-server/socket/socketManager.ts b/src/socket-server/socket/socketManager.ts
index 213f1b2..628d2b2 100644
--- a/src/socket-server/socket/socketManager.ts
+++ b/src/socket-server/socket/socketManager.ts
@@ -4,263 +4,151 @@ import { createCamera } from '../services/camera/camera-Controller.ts';
 import { setEnvironment } from '../services/environments/environments-controller.ts';
 import { deleteFloorItems, setFloorItems } from '../services/assets/flooritem-Controller.ts';
 import { deleteWallItems, setWallItems } from '../services/assets/wallitem-Controller.ts';
-import { deleteLineItems, deleteLinPoiteItems, updateLineItems ,createLineItems, deleteLayer} from '../services/lines/line-Controller.ts';
-import { activeUserOffline, activeUsers } from '../services/users/user-controller.ts';
+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, panelDelete } from '../services/visualization/panel-Services.ts';
 import { addWidget, Widgetdelete } from '../services/visualization/widget-Services.ts';
+import { addfloat } from '../services/visualization/floatWidgetService.ts';
+import { addTemplate } from '../services/visualization/templateServices.ts';
+import { deleteAssetModel, setAssetModel } from '../services/assets/asset-Controller.ts';
 
 
 
 
+const cameraHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
 
-const cameraHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
+  let result;
   switch (event) {
+    case EVENTS.setCamera: {
+      result = await createCamera(data);
 
-    case EVENTS.setCamera:
-      const result = await createCamera(data,);
-      // console.log('result: ', result);
-      if (result.success) {
-        // console.log('result.success: ', result.success);
-        // if (result.message === 'Camera updated') {
-            // Emit update response
-            
-            io.emit(EVENTS.cameraUpdateResponse, {
-                success: true,
-                message: result.message,
-                data: result.data,
-              socketId: socket.id,
-                organization:result.organization
-              });
-        } else if (result.message === 'Camera created') {
-            // Emit create response
-            io.emit(EVENTS.cameraCreateResponse, {
-                success: true,  
-                message: result.message,
-                data: result.data,
-              socketId: socket.id,
-            organization:result.organization
-            });
-        // }
-    } else {
-        // Emit error response
-        socket.emit(EVENTS.cameraError, {
-            success: false,
+      if (result) {
+        const responseEvent = EVENTS.cameraUpdateResponse
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        if (organization) {
+          socket.to(organization).emit(responseEvent, {
+            success: result.success,
             message: result.message,
-            error: result.error,
-          socketId: socket.id,
-                organization:result.organization
-        });
+            data: result.data,
+            error: result.error || null,
+            socketId: socket.id,
+            organization,
+          });
+        } else {
+          console.warn(`Organization missing in response for event: ${event}`);
+        }
+      }
+      break
     }
-      break;
-    // case EVENTS.updataControlle_iot:
-      // updateControlle(data);
-      break;
-    // case EVENTS.deleteControlle_iot:
-      // deleteControlle(data);
-      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:
-      // console.error(`Unhandled event type: ${event}`);
   }
 }
-const EnvironmentHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
+const EnvironmentHandleEvent = async (event: string, socket: Socket, data: any, io: any) => {
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
+
+  let result;
   switch (event) {
+    case EVENTS.setenvironment: {
+      result = await setEnvironment(data);
 
-    case EVENTS.setenvironment:
-      const result = await setEnvironment(data,);
-      // console.log('result: ', result);
-      if (result.success) {
-        // if (result.message === 'Camera updated') {
-            // Emit update response
-            
-            io.emit(EVENTS.EnvironmentUpdateResponse, {
-                success: true,
-                message: result.message,
-                data: result.data,
-              socketId: socket.id,
-                organization:result.organization
-              });
-        // } else if (result.message === 'evironments created') {
-        //     // Emit create response
-        //     io.emit(EVENTS.cameraCreateResponse, {
-        //         success: true,  
-        //         message: result.message,
-        //         data: result.data,
-        //     });
-        // }
-    } else {
-        // Emit error response
-        socket.emit(EVENTS.cameraError, {
-            success: false,
+      if (result) {
+        const responseEvent = EVENTS.EnvironmentUpdateResponse
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        if (organization) {
+          socket.emit(responseEvent, {
+            success: result.success,
             message: result.message,
-            error: result.error,
-          socketId: socket.id,
-                organization:result.organization
-        });
+            data: result.data,
+            error: result.error || null,
+            socketId: socket.id,
+            organization,
+          });
+        } else {
+          console.warn(`Organization missing in response for event: ${event}`);
+        }
+      }
+      break
     }
-      break;
-    // case EVENTS.updataControlle_iot:
-      // updateControlle(data);
-      break;
-    // case EVENTS.deleteControlle_iot:
-      // deleteControlle(data);
-      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:
-//      console.error(`Unhandled event type: ${event}`);
+      return;
   }
+
+
 }
-const floorItemsHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
+const floorItemsHandleEvent = async (event: string, socket: Socket, data: any, io: any) => {
   switch (event) {
 
-    case EVENTS.setFloorItems:{
+    case EVENTS.setFloorItems: {
       const result = await setFloorItems(data);
       // console.log('result: ', result);
       if (result.success) {
-            io.emit(EVENTS.FloorItemsUpdateResponse, {
-                success: true || false,
-                message: result.message,
-                data: result.data,
-              socketId: socket.id,
-                organization:result.organization
-                
-              });
-
-    } else {
-        // Emit error response
-        socket.emit(EVENTS.floorItemError, {
-            success: false,
-            message: result.message,
-            error: result.error,
-          socketId: socket.id,
-                organization:result.organization
-        });
-    }
-      break;}
-      case EVENTS.deleteFloorItems:{
-        const result = await deleteFloorItems(data);
-        // console.log('result: ', result);
-        if (result.success) {
-        
-              
-              io.emit(EVENTS.FloorItemsDeleteResponse, {
-                  success: true || false,
-                  message: result.message,
-                  data: result.data,
-                socketId: socket.id,
-                organization:result.organization
-                  
-                });
-  
-      } else {
-          // Emit error response
-          socket.emit(EVENTS.floorItemError, {
-              success: false,
-              message: result.message,
-              error: result.error,
-            socketId: socket.id,
-                organization:result.organization
-          });
-      }
-        break;}
-
-    default:
-//      console.error(`Unhandled event type: ${event}`);
-  }
-}
-const wallItemsHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
-  switch (event) {
-
-    case EVENTS.setWallItems:{
-      const result = await setWallItems(data);
-      // console.log('result: ', result);
-      if (result.success) {   
-         io.emit(EVENTS.wallItemsUpdateResponse, {
-                success: true,
-                message: result.message,
-                data: result.data,
-              socketId: socket.id,
-                organization:result.organization
-                
-              });
-
-    } else {
-        // Emit error response
-        socket.emit(EVENTS.wallItemError, {
-            success: false,
-            message: result.message,
-            error: result.error,
-        });
-    }
-      break;
-  }
-  case EVENTS.deleteWallItems:{
-    const result = await deleteWallItems(data);
-    // console.log('result: ', result);
-    if (result.success) {
-
-          
-          io.emit(EVENTS.wallItemsDeleteResponse, {
-              success: true || false,
-              message: result.message,
-              data: result.data,
-            socketId: socket.id,
-                organization:result.organization
-              
-            });
-
-  } else {
-      // Emit error response
-      socket.emit(EVENTS.wallItemError, {
-          success: false,
-          message: result.message,
-          error: result.error,
-      });
-  }
-    break;
-}
-
-    default:
-//      console.error(`Unhandled event type: ${event}`);
-  }
-}
-const lineHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
-  switch (event) {
-    case EVENTS.createLine:{
-      const result = await createLineItems(data);
-      // console.log('result: ', result);
-      if (result.success) {
-
-            
-            io.emit(EVENTS.createLineResponse, {
-                success: true || false,
-                message: result.message,
-                data: result.data,
-              socketId: socket.id,
-                organization:result.organization
-                
-              });
-
-    } else {
-        // Emit error response
-        // socket.emit(EVENTS.wallItemError, {
-        //     success: false,
-        //     message: result.message,
-        //     error: result.error,
-        // });
-    }
-      break;
-  }
-    case EVENTS.updateLine: {
-      const result = await updateLineItems(data);
-      // console.log('result: ', result);
-      if (result.success) {
-
-
-        io.emit(EVENTS.updateLineResponse, {
+        io.emit(EVENTS.FloorItemsUpdateResponse, {
           success: true || false,
           message: result.message,
           data: result.data,
@@ -269,184 +157,372 @@ const lineHandleEvent =async (event: string, socket: Socket, data: any,io:any) =
 
         });
 
+      } else {
+        // Emit error response
+        socket.emit(EVENTS.floorItemError, {
+          success: false,
+          message: result.message,
+          error: result.error,
+          socketId: socket.id,
+          organization: result.organization
+        });
       }
       break;
     }
-  case EVENTS.deleteLine:{
-    const result = await deleteLineItems(data);
-    // console.log('result: ', result);
-    if (result.success) {
- 
-          
-          io.emit(EVENTS.deleteLineResponse, {
-              success: true || false,
-              message: result.message,
-              data: result.data,
-            socketId: socket.id,
-                organization:result.organization
-              
-            });
+    case EVENTS.deleteFloorItems: {
+      const result = await deleteFloorItems(data);
+      // console.log('result: ', result);
+      if (result.success) {
 
-  } else {
-      // Emit error response
-      // socket.emit(EVENTS.wallItemError, {
-      //     success: false,
-      //     message: result.message,
-      //     error: result.error,
-      // });
-  }
-    break;
-}
-case EVENTS.deletePoint:{
-  const result = await deleteLinPoiteItems(data);
-  // console.log('result: ', result);
-  if (result.success) {
-      
-        io.emit(EVENTS.deletePointResponse, {
-            success: true || false,
-            message: result.message,
-            data: result.data,
-          socketId: socket.id,
-                organization:result.organization
-            
-          });
 
-} else {
-    // Emit error response
-    // socket.emit(EVENTS.wallItemError, {
-    //     success: false,
-    //     message: result.message,
-    //     error: result.error,
-    // });
-}
-  break;
-}
-case EVENTS.deleteLineLayer:{
-  const result = await deleteLayer(data);
-  // console.log('result: ', result);
-  if (result.success) {
-      
-        io.emit(EVENTS.deleteLineLayerResponse, {
-            success: true || false,
-            message: result.message,
-            data: result.data,
-          socketId: socket.id,
-                organization:result.organization
-            
-          });
-
-} else {
-    // Emit error response
-    // socket.emit(EVENTS.wallItemError, {
-    //     success: false,
-    //     message: result.message,
-    //     error: result.error,
-    // });
-}
-  break;
-}
-
-    default:
-//      console.error(`Unhandled event type: ${event}`);
-  }
-}
-const userStatus =async (event: string, socket: Socket, data: any,io:any) => {
-  switch (event) {
-    case EVENTS.connection: {
-      // console.log('EVENTS.connection: ', EVENTS.connection);
-      // console.log('event: ', event);
-      const result = await activeUsers(data);
-      if (result?.success) {
-        // console.log('result.success: ', result.success)
-            
-            io.emit(EVENTS.userConnect, {
-                success: true || false,
-                message: result.message,
-                data: result.data,
-               socketId: socket.id,
-                organization:result.organization
-                
-              });}
-      break;
-    }
-    case EVENTS.disconnect: {
-      // console.log('EVENTS.disconnect: ', EVENTS.connection);
-      // console.log('event: ', event);
-      const result = await activeUserOffline(data);
-      if (result?.success) {
-        // console.log('result.success: ', result.success)
-            
-            io.emit(EVENTS.userDisConnect, {
-                success: true || false,
-                message: result.message,
-                data: result.data,
-               socketId: socket.id,
-                organization:result.organization
-                
-              });}
-      break;
-    }
-  }
-}
-const zoneHandleEvent =async (event: string, socket: Socket, data: any,io:any)=>{
-switch (event) {
-  case EVENTS.setZone:{
-    const result=await setZone(data)
-    if (result?.success) {
-      io.emit(EVENTS.zoneUpdateRespones, {
-        success: true || false,
-        message: result.message,
-        data: result.data,
-        error: result.error,
-        socketId: socket.id,
-        organization:result.organization
-        
-      });
-      
-    }
-    break}
-    case EVENTS.deleteZone:{
-      const result=await deleteZone(data)
-      if (result?.success) {
-        io.emit(EVENTS.ZoneDeleteRespones, {
+        io.emit(EVENTS.FloorItemsDeleteResponse, {
           success: true || false,
           message: result.message,
           data: result.data,
+          socketId: socket.id,
+          organization: result.organization
+
+        });
+
+      } else {
+        // Emit error response
+        socket.emit(EVENTS.floorItemError, {
+          success: false,
+          message: result.message,
           error: result.error,
           socketId: socket.id,
-          organization:result.organization
-          
+          organization: result.organization
         });
-        
       }
-      break}
+      break;
+    }
 
-  default:
-    break;
+    default:
+    //      console.error(`Unhandled event type: ${event}`);
+  }
 }
-}
-const panelHandleEvent=async(event: string, socket: Socket, data: any,namespace: any, notifySender: boolean = false)=>{
+const wallItemsHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
   if (!data?.organization) {
     console.warn(`Missing organization for event: ${event}`);
     return;
   }
-  
+
   let result;
   switch (event) {
-    case EVENTS.addPanel:{
-      result = await addPanel(data);
-      console.log('result: ', result);
-      
+    case EVENTS.setWallItems: {
+      result = await setWallItems(data);
+
       if (result) {
-        console.log('result?.success: ', result.organization);
-        const responseEvent = EVENTS.panelUpdateRespones 
-        console.log('responseEvent: ', responseEvent);
-        const organization=result?.organization
-        console.log('organization: ', organization);
+        const responseEvent = EVENTS.wallItemsUpdateResponse
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        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.deleteWallItems: {
+      const result = await deleteWallItems(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.wallItemsDeleteResponse
+        // 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
+    }
+
+    default:
+      return;
+  }
+
+}
+const lineHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
+
+  let result;
+  switch (event) {
+    case EVENTS.createLine: {
+      result = await createLineItems(data);
+
+      if (result) {
+        const responseEvent = EVENTS.createLineResponse
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        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.updateLine: {
+      const result = await updateLineItems(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.updateLineResponse
+        // 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.deleteLine: {
+      const result = await deleteLineItems(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.deleteLineResponse
+        // 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.deletePoint: {
+      const result = await deleteLinPoiteItems(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.deletePointResponse
+        // 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
+    }
+    default:
+      return;
+  }
+
+
+}
+const userStatus =async (event: string, socket: Socket, data: any,io:any) => {
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
+
+  let result;
+  switch (event) {
+    case EVENTS.connection: {
+      result = await activeUsers(data);
+      // console.log('result: ', result);
+
+      if (result) {
+        const responseEvent = EVENTS.userConnect
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        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.disconnect: {
+      const result = await activeUserOffline(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.userDisConnect
+        // 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 || "disconnectError",
+            socketId: socket.id,
+            organization,
+          });
+        } else {
+          console.warn(`Organization missing in response for event: ${event}`);
+        }
+      }
+      break
+    }
+
+    default:
+      return;
+  }
+
+}
+const zoneHandleEvent = async (event: string, socket: Socket, data: any, io: any) => {
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
+
+  let result;
+  switch (event) {
+    case EVENTS.setZone: {
+      result = await setZone(data);
+
+      if (result) {
+        const responseEvent = EVENTS.zoneUpdateRespones
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        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.deleteZone: {
+      const result = await deleteZone(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.ZoneDeleteRespones
+        // 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
+    }
+
+
+  }
+ 
+
+}
+const panelHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
+  if (!data?.organization) {
+    console.warn(`Missing organization for event: ${event}`);
+    return;
+  }
+
+  let result;
+  switch (event) {
+    case EVENTS.addPanel: {
+      result = await addPanel(data);
+      if (result) {
+        const responseEvent = EVENTS.panelUpdateRespones
+        const organization = result?.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);
+
         socket.to(organization).emit(responseEvent, {
           success: result.success,
           message: result.message,
@@ -456,41 +532,42 @@ const panelHandleEvent=async(event: string, socket: Socket, data: any,namespace:
           organization: result.organization,
         });
       }
-      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;
-      }
-      
-      
+      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;
+  }
+
+
+}
 const widgetHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
   // console.log('data: ', data);
   if (!data?.organization) {
@@ -560,7 +637,203 @@ const widgetHandleEvent = async (event: string, socket: Socket, data: any, names
   }
 
 }
+const floatHandleEvent = 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.addFloat: {
+      result = await addfloat(data);
+      // console.log('result: ', result);
+
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.floatUpdateRespones
+        // 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
+    }
+    // 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;
+  }
+
+}
+const templateHandleEvent = 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.addTemplate: {
+      result = await addTemplate(data);
+
+      if (result) {
+        const responseEvent = EVENTS.templateUpdateRespones
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        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;
+  }
+
+}
+const modelAssetHandleEvent = 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.setAssetModel: {
+      result = await setAssetModel(data);
+
+      if (result) {
+        const responseEvent = EVENTS.assetUpdateRespones
+        const organization = result?.organization
+        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
+        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
+        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.deleteAssetModel: {
+      const result = await deleteAssetModel(data)
+      if (result) {
+        // console.log('result?.success: ', result.organization);
+        const responseEvent = EVENTS.assetDeleteRespones
+        // 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
+    }
+
+    default:
+      return;
+  }
+
+}
 
 export const initSocketServer = (httpServer: any) => {
   const io = new Server(httpServer, {
@@ -574,28 +847,27 @@ export const initSocketServer = (httpServer: any) => {
   // Listen for new connections
   io.on(EVENTS.connection, (socket: Socket) => {
     // console.log(`New client connected: ${socket.id}`);
-// console.log(socket.handshake.auth);
-userStatus(EVENTS.connection, socket, socket.handshake.auth,io);
+    // console.log(socket.handshake.auth);
+    userStatus(EVENTS.connection, socket, socket.handshake.auth, io);
 
     // Handle all incoming events with the handleEvent function
     socket.onAny((event: string, data: any,) => {
-      cameraHandleEvent(event, socket, data,io);
-      EnvironmentHandleEvent(event, socket, data,io);
-      floorItemsHandleEvent(event, socket, data,io);
-      wallItemsHandleEvent(event, socket, data,io);
-      lineHandleEvent(event, socket, data,io);
-      zoneHandleEvent(event, socket, data,io);
+      cameraHandleEvent(event, socket, data, io);
+      EnvironmentHandleEvent(event, socket, data, io);
+      floorItemsHandleEvent(event, socket, data, io);
+      wallItemsHandleEvent(event, socket, data, io);
+      lineHandleEvent(event, socket, data, io);
+      zoneHandleEvent(event, socket, data, io);
+
 
-  
     });
     socket.on(EVENTS.disconnect, (reason: string) => {
       // console.log(`Client disconnected: ${socket.id}, Reason: ${reason}`); 
       // console.log(socket.handshake.auth); 
-      userStatus(EVENTS.disconnect, socket, socket.handshake.auth,io);
+      userStatus(EVENTS.disconnect, socket, socket.handshake.auth, io);
       // Perform cleanup or other necessary actions
     });
   });
-
   // 🔹 Create different namespaces
   const namespaces = {
     camera: io.of("/camera"),
@@ -604,51 +876,97 @@ userStatus(EVENTS.connection, socket, socket.handshake.auth,io);
     wallItems: io.of("/wallItems"),
     line: io.of("/line"),
     zone: io.of("/zone"),
+    Builder: io.of('/Builder'),
     visualization: io.of('/visualization'),
     // widget:io.of('/widget')
   };
   // 🔹 Function to handle connections in a namespace
+  // 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;
+  //     const organization = socket.handshake.auth.organization as string;
+  //     console.log(`🔍 Received organization: ${organization}`);
+
+  //     if (organization) {
+  //       socket.join(organization);
+  //       // console.log(`🔹 Socket ${socket.id} joined room: ${organization}`);
+
+  //       // Debug: Check 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)}`);
+  //       eventHandlers.forEach(handler => handler(event, socket, data, namespace));
+  //       // eventHandler(event, socket, data, namespace); // Pass `namespace` instead of `io`
+  //     });
+
+  //     socket.on("disconnect", (reason: string) => {
+  //       console.log(`❌ Client disconnected from ${namespaceName}: ${socket.id}, Reason: ${reason}`);
+  //     });
+  //   });
+  // };
+  const onlineUsers = new Map<string, Set<string>>();
+
   const handleNamespace = (namespaceName: string, namespace: any, ...eventHandlers: Function[]) => {
+  
     namespace.on("connection", (socket: Socket) => {
-      console.log(`✅ Client connected to ${namespaceName}: ${socket.id}`);
-
+      // 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}`);
-
+      
+      // const organization = socket.handshake.query.organization as string;
+      const {organization,email} = socket.handshake.auth
+      console.log(`🔍 Received organization: ${organization}`);
+  
       if (organization) {
         socket.join(organization);
         // console.log(`🔹 Socket ${socket.id} joined room: ${organization}`);
-
-        // Debug: Check rooms
-        // console.log(`🛠️ Current rooms for ${socket.id}:`, socket.rooms);
       } else {
-        console.warn(`⚠️ Warning: Socket ${socket.id} did not provide an organization`);
+        // console.warn(`⚠️ Warning: Socket ${socket.id} did not provide an organization`);
       }
+      // addUserToOnlineList(organization, socket.id, onlineUsers, socket, namespaceName);
+      // Handle all events
+      userStatus(EVENTS.connection, socket, socket.handshake.auth, socket);
 
       socket.onAny((event: string, data: any) => {
-        // 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`
+        eventHandlers.forEach(handler => handler(event, socket, data, namespace,io));
       });
-
+  
+      // Handle disconnection
       socket.on("disconnect", (reason: string) => {
-        console.log(`❌ Client disconnected from ${namespaceName}: ${socket.id}, Reason: ${reason}`);
+        userStatus(EVENTS.disconnect, socket, socket.handshake.auth, socket);
+
+        // console.log(`❌ Client disconnected from ${namespaceName}: ${socket.id}, Reason: ${reason}`);
+      });
+  
+      // Handle reconnection (Auto rejoin)
+      socket.on("reconnect", (attempt: number) => {
+        // console.log(`🔄 Socket ${socket.id} reconnected to ${namespaceName} (Attempt ${attempt})`);
+        if (organization) {
+          socket.join(organization);
+          // console.log(`♻️ Rejoined room: ${organization}`);
+        }
       });
     });
   };
+  
 
-    // 🔹 Apply namespace handlers
-    handleNamespace("camera", namespaces.camera, cameraHandleEvent);
-    handleNamespace("environment", namespaces.environment, EnvironmentHandleEvent);
-    handleNamespace("floorItems", namespaces.floorItems, floorItemsHandleEvent);
-    handleNamespace("wallItems", namespaces.wallItems, wallItemsHandleEvent);
-    handleNamespace("line", namespaces.line, lineHandleEvent);
-    handleNamespace("zone", namespaces.zone, zoneHandleEvent);
-    // handleNamespace("visualization", namespaces.panel, panelHandleEvent);
-    // handleNamespace("widget", namespaces.visualization, widgetHandleEvent);
-    handleNamespace("visualization", namespaces.visualization, panelHandleEvent, widgetHandleEvent);
-
+  // 🔹 Apply namespace handlers
+  // handleNamespace("camera", namespaces.camera, cameraHandleEvent);
+  // handleNamespace("environment", namespaces.environment, EnvironmentHandleEvent);
+  // handleNamespace("floorItems", namespaces.floorItems, floorItemsHandleEvent);
+  // handleNamespace("wallItems", namespaces.wallItems, wallItemsHandleEvent);
+  // handleNamespace("line", namespaces.line, lineHandleEvent);
+  // handleNamespace("zone", namespaces.zone, zoneHandleEvent);
+  // handleNamespace("visualization", namespaces.panel, panelHandleEvent);
+  // handleNamespace("widget", namespaces.visualization, widgetHandleEvent);
+  handleNamespace("Builder", namespaces.Builder, userStatus,modelAssetHandleEvent, cameraHandleEvent, EnvironmentHandleEvent, wallItemsHandleEvent, lineHandleEvent,zoneHandleEvent);
+  handleNamespace("visualization", namespaces.visualization, panelHandleEvent, widgetHandleEvent, floatHandleEvent, templateHandleEvent);
 
   return io;
 };