AssetData connections added, 3dWidget update and get added

2025-04-01 17:55:44 +05:30
parent 7fb05e579a
commit fc83d72c51
6 changed files with 207 additions and 125 deletions
--- a/src/api-server/Routes/widget3dRoutes.ts
+++ b/src/api-server/Routes/widget3dRoutes.ts
@@ -3,4 +3,5 @@ import { widget3dService } from "../controller/visualization/3dWidgetService.ts"
 const router = express.Router();
 router.post("/3dwidget/save", widget3dService.add3Dwidget);
 router.get("/3dwidgetData/:zoneId/:organization", widget3dService.get3Dwiget);
+router.get("/widget3D/:id/:organization", widget3dService.getSingle3Dwidget);
 export default router;
--- a/src/api-server/controller/simulation/assetsFloorservice.ts
+++ b/src/api-server/controller/simulation/assetsFloorservice.ts
@@ -87,13 +87,18 @@ export class assetsFloorservice {
                  triggerRefs.push(triggerDoc._id);
                }
              }
+              // point.connections{
+              //   source:{

+              //   }
+              // }
              pointRefs.push({
                uuid: point.uuid,
                position: point.position || [],
                rotation: point.rotation || [],
                actions: actionRefs,
                triggers: triggerRefs,
+                connections: point.connections,
              });
            }
          }
--- a/src/api-server/controller/visualization/3dWidgetService.ts
+++ b/src/api-server/controller/visualization/3dWidgetService.ts
@@ -24,7 +24,14 @@ export class widget3dService {
            zoneId: zoneId,
            isArchive: false,
          },
-          { position: widget.position },
+          {
+            position: widget?.position,
+            Data: {
+              measurements: widget?.Data.measurements,
+              duration: widget?.Data.duration,
+            },
+            widgetName: widget?.widgetName,
+          },
          { upsert: true, new: true }
        );
        if (update3dwidget)
@@ -34,7 +41,7 @@ export class widget3dService {
        else return res.send("Widget not updated");
      }
      const newWidget3d = await widget3dModel(organization).create({
-        widgetName: widget.type,
+        type: widget.type,
        widgetID: widget.id,
        position: widget.position,
        zoneId,
@@ -66,7 +73,7 @@ export class widget3dService {
          measurements: widget.Data?.measurements || {},
          duration: widget.Data?.duration || "1h",
        },
-        type: widget.widgetName,
+        type: widget.type,
        id: widget.widgetID,
        position: widget.position,
      }));
@@ -103,4 +110,22 @@ export class widget3dService {
  //     return res.status(500).send(error.message);
  //   }
  // }
+  static async getSingle3Dwidget(req: Request, res: Response): Promise<any> {
+    const { organization, id } = req.params;
+    try {
+      const widgetData = await widget3dModel(organization).findOne({
+        widgetID: id,
+        isArchive: false,
+      });
+      if (!widgetData) return res.send("WidgetID not found");
+      const structureData = {
+        measurements: widgetData?.Data.measurements,
+        duration: widgetData?.Data.duration,
+      };
+      const widgetName = widgetData.widgetName;
+      return res.status(200).json({ Data: structureData, widgetName });
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
 }
--- a/src/api-server/controller/visualization/widgetService.ts
+++ b/src/api-server/controller/visualization/widgetService.ts
@@ -47,7 +47,7 @@ export class widgetService {
              $set: {
                // panelID: existingPanel._id,
                // widgetID: widget.id,
-                widgetName: widget.widgetName,
+                widgetName: widget?.widgetName,
                Data: {
                  measurements: widget.Data?.measurements || {},
                  duration: widget.Data?.duration || "1h",
@@ -69,7 +69,7 @@ export class widgetService {
          widgetID: widget.id,
          elementType: widget.type,
          // widgetOrder: widgetOrder,
-          widgetName: widget.widgetName,
+          widgetName: widget.title,
          panelID: existingPanel._id,
          widgetside: widget.panel,
          // Data: {
--- a/src/shared/model/vizualization/3dwidget.ts
+++ b/src/shared/model/vizualization/3dwidget.ts
@@ -2,8 +2,9 @@ import mongoose, { Schema, Document, model } from "mongoose";
 import MainModel from "../../connect/mongoose.ts";

 export interface Widget3d extends Document {
-  widgetName: string;
+  type: string;
  widgetID: string;
+  widgetName: string;
  position: [];
  isArchive: boolean;
  zoneId: string;
@@ -14,8 +15,9 @@ export interface Widget3d extends Document {
 }
 const Widget3dSchema: Schema = new Schema(
  {
-    widgetName: { type: String },
+    type: { type: String },
    widgetID: { type: String },
+    widgetName: { type: String, default: "Widget3D" },
    position: { type: Array },
    zoneId: { type: String },
    Data: {
--- a/src/socket-server/services/assets/asset-Controller.ts
+++ b/src/socket-server/services/assets/asset-Controller.ts
@@ -3,125 +3,174 @@ 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 {
+    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);
              }
-      
-              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 }

+            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,
+              connections: point.connections,
+            });
+          }
        }
-    }
+
+        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,
+    };
+  }
+};