API creation for Product EventDatas and updating asset files

.env

@@ -8,4 +8,6 @@ MONGO_PASSWORD=admin321
 MONGO_AUTH_DB=admin
 MONGO_URI=mongodb://mongo/
 API_PORT=5000
-SOCKET_PORT=8000
+SOCKET_PORT=8000
+NODE_ENV=development
+FRONTEND_ORIGIN_PROD=http://185.100.212.76:8200

src/api-server/Routes/flooritem-Routes.ts

@@ -1,10 +1,12 @@
 import express from 'express';
 import { floorItems } from '../controller/assets/flooritem-Services.ts';
+import { assetsFloorservice } from '../controller/simulation/assetsFloorservice.ts';
 
 const router = express.Router();
 router.post('/setfloorItems',floorItems.setFloorItems)
 router.get('/findfloorItems/:organization',floorItems.getFloorItems)
-router.delete('/deletefloorItem',floorItems.deleteFloorItems)
+// router.delete('/deletefloorItem',floorItems.deleteFloorItems)
+router.delete('/deletefloorItem',assetsFloorservice.deleteFloorItems)
 
 
 export default router;

src/api-server/Routes/productRoutes.ts

@@ -0,0 +1,11 @@
+import * as express from "express";
+import { productFlowservice } from "../controller/simulation/productService.ts";
+const productRouter = express.Router();
+productRouter.post("/UpsertProductOrEvent", productFlowservice.productAdd);
+productRouter.get("/productData", productFlowservice.getProductDatas);
+productRouter.patch("/EventDataDelete", productFlowservice.EventDataDelete);
+productRouter.patch("/productDataDelete", productFlowservice.productDataDelete);
+productRouter.get("/AllProducts/:organization", productFlowservice.AllProductDatas);
+productRouter.patch("/productRename", productFlowservice.productRename);
+export default productRouter;
+

src/api-server/app.ts

@@ -18,10 +18,40 @@ import assetfloorRoutes from "./Routes/assetfloorRoutes.ts";
 import floadWidgetRoutes from "./Routes/floadWidgetRoute.ts";
 import templateRoutes from "./Routes/templateRoutes.ts";
 import widget3dRoutes from "./Routes/widget3dRoutes.ts";
+import productRouter from "./Routes/productRoutes.ts";
 // import productFlowRoutes from "./Routes/productFlowRouts.ts";
 
 const app = express();
 app.use(cors());
+// const allowedOriginsDev = [ 
+//   "http://localhost:3000",
+//   "http://192.168.0.183:8200",
+//   "http://192.168.0.101:8200",
+//   "http://192.168.0.105:8200",
+//   "http://192.168.0.134:8200"
+// ];
+// const allowedOrigin =
+//   process.env.NODE_ENV === "production"
+//     ? process.env.FRONTEND_ORIGIN_PROD
+//     : allowedOriginsDev;
+//     app.use(cors({
+//       origin: (origin, callback) => {
+//         if (!origin) return callback(null, true);
+//         if (
+//           Array.isArray(allowedOrigin) &&
+//           allowedOrigin.includes(origin)
+//         ) {
+//           return callback(null, true);
+//         }
+    
+//         if (typeof allowedOrigin === "string" && origin === allowedOrigin) {
+//           return callback(null, true);
+//         }
+    
+//         return callback(new Error("Not allowed by CORS"));
+//       },
+//       credentials: true
+//     }));
 app.use(express.json());
 dotenv.config();
 app.get("/", (req, res) => {
@@ -48,5 +78,6 @@ app.use("/api/v2", assetfloorRoutes);
 app.use("/api/v2", floadWidgetRoutes);
 app.use("/api/v2", templateRoutes);
 app.use("/api/v2", widget3dRoutes);
+app.use("/api/v2", productRouter);
 // app.use("/api/v2", productFlowRoutes);
 export default app;

src/api-server/controller/assets/flooritem-Services.ts

@@ -5,8 +5,8 @@ export class floorItems {
   static async setFloorItems(req: Request, res: Response) {
     try {
       const {
-        modeluuid,
+        modelUuid,
-        modelname,
+        modelName,
         position,
         modelfileID,
         rotation,
@@ -16,15 +16,15 @@ export class floorItems {
       } = req.body;
 
       const findvalue = await floorItemsModel(organization).findOne({
-        modeluuid: modeluuid,
+        modelUuid: modelUuid,
-        modelname: modelname,
+        modelName: modelName,
       });
 
       if (findvalue) {
         const updatevalue = await floorItemsModel(
           organization
         ).findOneAndUpdate(
-          { modeluuid: modeluuid, modelname: modelname },
+          { modelUuid: modelUuid, modelName: modelName },
           {
             position: position,
             rotation: rotation,
@@ -36,9 +36,9 @@ export class floorItems {
         res.status(201).json(updatevalue);
       } else {
         const newValue = await floorItemsModel(organization).create({
-          modeluuid,
+          modelUuid,
           modelfileID,
-          modelname,
+          modelName,
           position,
           rotation,
           isLocked,
@@ -72,11 +72,11 @@ export class floorItems {
   }
   static async deleteFloorItems(req: Request, res: Response) {
     try {
-      const { modeluuid, modelname, organization } = req.body;
+      const { modelUuid, modelName, organization } = req.body;
 
       const findValue = await floorItemsModel(organization).findOneAndDelete({
-        modeluuid: modeluuid,
+        modelUuid: modelUuid,
-        modelname: modelname,
+        modelName: modelName,
       });
       if (!findValue) {
         res.status(200).json("user not found");

src/api-server/controller/assets/wallitem-Services.ts

@@ -5,16 +5,16 @@ import wallItenmModel from "../../../shared/model/assets/wallitems-Model.ts";
 export class wallItems {
     static async setWallItems(req: Request, res: Response) {
         try {
-            const { modeluuid, modelname, position, type, csgposition,csgscale,quaternion,scale,organization } = req.body
+            const { modelUuid, modelName, position, type, csgposition,csgscale,quaternion,scale,organization } = req.body
     
 
-            const findvalue = await wallItenmModel(organization).findOne({ modeluuid: modeluuid})
+            const findvalue = await wallItenmModel(organization).findOne({ modelUuid: modelUuid})
             
             if (findvalue) {
                 const updatevalue = await wallItenmModel(organization).findOneAndUpdate(
-                    { modeluuid: modeluuid },
+                    { modelUuid: modelUuid },
                     {
-                        modelname,
+                        modelName,
                         position,
                         type,
                         csgposition,
@@ -28,7 +28,7 @@ export class wallItems {
    
 
             } else {
-                const newValue = await wallItenmModel(organization).create({ modeluuid,modelname, position, type, csgposition,csgscale,quaternion,scale });
+                const newValue = await wallItenmModel(organization).create({ modelUuid,modelName, position, type, csgposition,csgscale,quaternion,scale });
 
             
                 res.status(201).json(newValue);
@@ -61,11 +61,11 @@ export class wallItems {
     }
     static async deleteWallItems(req: Request, res: Response) {
         try {
-            const { modeluuid,modelname,organization } = req.body;
+            const { modelUuid,modelName,organization } = req.body;
             
 
             const findValue = await wallItenmModel
-(organization).findOneAndDelete({modeluuid:modeluuid,modelname:modelname})
+(organization).findOneAndDelete({modelUuid:modelUuid,modelName:modelName})
             if (!findValue) {
                 res.status(200).json("user not found");
             } else {

src/api-server/controller/simulation/assetsFloorservice.ts

@@ -3,13 +3,253 @@ 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";
 import pointModel from "../../../shared/model/builder/assets/assetPoint-Model.ts";
+import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.ts";
 
 export class assetsFloorservice {
+  // static async setFloorassets(req: Request, res: Response): Promise<any> {
+  //   try {
+  //     const {
+  //       modelUuid,
+  //       modelName,
+  //       position,
+  //       modelfileID,
+  //       rotation,
+  //       isLocked,
+  //       isVisible,
+  //       organization,
+  //       eventData,
+  //     } = req.body;
+  //     console.log("req.body: ", req.body);
+
+  //     const findvalue = await assetModel(organization).findOne({
+  //       modelUuid,
+  //       // modelName,
+  //       isArchive: false,
+  //     });
+  //     const checkpointType = await pointModel(organization).findOne({
+  //       modelfileID: modelfileID,
+  //       isArchive: false,
+  //     });
+
+  //     if (findvalue) {
+  //       const updatevalue = await assetModel(organization).findOneAndUpdate(
+  //         { modelUuid, isArchive: false },
+  //         {
+  //           modelName: modelName,
+  //           position,
+  //           rotation,
+  //           isVisible,
+  //           isLocked,
+  //         },
+  //         { new: true }
+  //       );
+  //       return res.status(201).json(updatevalue);
+  //     } else {
+  //       let assetData: any = {
+  //         modelUuid,
+  //         modelName,
+  //         position,
+  //         modelfileID,
+  //         rotation,
+  //         isLocked,
+  //         isVisible,
+  //       };
+
+  //       console.log("eventData: ", eventData);
+  //       if (eventData) {
+  //         if (eventData.type === "Conveyor") {
+  //           assetData.speed = eventData.speed;
+  //         } else if (eventData.type === "Vehicle") {
+  //           assetData.speed = eventData.points.speed;
+  //           if (!eventData.points) {
+  //             return res
+  //               .status(400)
+  //               .json({ message: "Vehicle points must be a single object" });
+  //           }
+  //           // if (eventData.points.rotation) {
+  //           //   return res.status(400).json({
+  //           //     message: "Rotation is not allowed for Vehicle points",
+  //           //   });
+  //           // }
+
+  //           if (eventData.points.triggers) {
+  //             return res.status(400).json({
+  //               message: "triggers is not allowed for Vehicle points",
+  //             });
+  //           }
+  //         }
+  //         // else if(eventData.type === "ArmBot"){
+  //         //   assetData.speed = eventData.position;
+  //         // }else if(eventData.type === "StaticMachine"){
+  //         //   assetData.speed = eventData.position;
+  //         // }
+
+  //         assetData.points = eventData.points;
+  //         assetData.type = eventData.type;
+  //       }
+  //       const assetDoc = await assetModel(organization).create(assetData);
+  //       await assetDoc.save();
+
+  //       return res.status(201).json({
+  //         message: "Model stored successfully",
+  //         modelId: assetDoc._id,
+  //       });
+  //     }
+  //   } catch (error) {
+  //     console.error("Error creating flooritems:", error);
+  //     res.status(500).json({ message: "Failed to create flooritems" });
+  //   }
+  // }
+  // static async getFloorItems(req: Request, res: Response): Promise<any> {
+  //   try {
+  //     const { organization } = req.params;
+  //     const findValues = await assetModel(organization)
+  //       .find({ isArchive: false })
+  //       .select("-_id -isArchive");
+
+  //     if (!findValues || findValues.length === 0) {
+  //       return res.status(200).json({ message: "floorItems not found" });
+  //     }
+
+  //     const response = findValues.map((item) => {
+  //       // console.log("item: ", item);
+  //       // console.log("item: ", item.type);
+  //       // console.log('findValues: ', findValues);
+  //       // console.log("item.points: ", item.points);
+  //       const responseItem: any = {
+  //         modelUuid: item.modelUuid,
+  //         modelName: item.modelName,
+  //         position: item.position,
+  //         rotation: item.rotation,
+  //         modelfileID: item.modelfileID,
+  //         isLocked: item.isLocked,
+  //         isVisible: item.isVisible,
+  //       };
+  //       if (item.type === "Conveyor" && item.points.length > 0) {
+  //         responseItem.eventData = {
+  //           speed: item.speed,
+  //           points: item.points,
+  //           type: item.type,
+  //         };
+  //       }
+
+  //       if (item.type === "Vehicle" && item.points) {
+  //         responseItem.eventData = {
+  //           type: item.type,
+  //           points: item.points,
+  //         };
+  //       }
+  //       if (item.type === "ArmBot" && item.points) {
+  //         responseItem.eventData = {
+  //           type: item.type,
+  //           points: item.points,
+  //         };
+  //       }
+  //       if (item.type === "StaticMachine" && item.points) {
+  //         responseItem.eventData = {
+  //           type: item.type,
+  //           points: item.points,
+  //         };
+  //       }
+  //       return responseItem;
+  //     });
+
+  //     return res.status(200).json(response);
+  //   } catch (error) {
+  //     res.status(500).json({ error: "Failed to get flooritems" });
+  //   }
+  // }
+  // static async deleteFloorItems(req: Request, res: Response): Promise<any> {
+  //   try {
+  //     const { modelUuid, modelName, organization } = req.body;
+
+  //     const findValue = await assetModel(organization).findOneAndDelete({
+  //       modelUuid: modelUuid,
+  //       modelName: modelName,
+  //       isArchive: false,
+  //     });
+  //     if (!findValue) {
+  //       res.status(200).json("user not found");
+  //     } else {
+  //       res.status(201).json(findValue);
+  //     }
+  //   } catch (error) {
+  //     res.status(500).json({ error: "Failed to get flooritems" });
+  //   }
+  // }
+  static async updateAssetPositionRotation(
+    req: Request,
+    res: Response
+  ): Promise<any> {
+    try {
+      const {
+        modelUuid,
+        modelName,
+        position,
+        modelfileID,
+        rotation,
+        isLocked,
+        isVisible,
+        organization,
+        // eventData, // Optional
+      } = req.body;
+
+      const existingAsset = await assetModel(organization).findOne({
+        modelUuid: modelUuid,
+        isArchive: false,
+      });
+      if (!existingAsset) return res.send("Asset not found");
+      const updateAsset = await assetModel(organization).updateMany(
+        { modelUuid: modelUuid, modelName: modelName, isArchive: false },
+        {
+          position: position,
+          rotation: rotation,
+          isVisible: isVisible,
+          isLocked: isLocked,
+        }
+      );
+      if (updateAsset)
+        return res.status(200).json({ message: "Asset updated successfully" });
+    } catch (error: any) {
+      return res.send(error.message);
+    }
+  }
+  static async replaceEventDatas(req: Request, res: Response): Promise<any> {
+    const { organization, modelUuid, eventData } = req.body;
+    try {
+      const existingModel = await assetModel(organization).findOne({
+        modelUuid: modelUuid,
+        isArchive: false,
+      });
+      if (!existingModel)
+        return res.json({ message: "Model not for this UUID" });
+      else {
+        let speed;
+        if (existingModel.type === "Conveyor") {
+          speed = eventData?.speed;
+        }
+        const updatedModel = await assetModel(organization).findOneAndUpdate(
+          { modelUuid, isArchive: false },
+          {
+            points: eventData?.points,
+            type: eventData?.type || existingModel?.type,
+          },
+          { new: true }
+        );
+
+        if (updatedModel)
+          return res.status(200).json({ message: "Data updated successfully" });
+      }
+    } catch (error: any) {
+      return res.status(500).send(error.message);
+    }
+  }
+  //update setfoolrassets//getFloorItems//deleteFloorItems.........
   static async setFloorassets(req: Request, res: Response): Promise<any> {
     try {
       const {
-        modeluuid,
+        modelUuid,
-        modelname,
+        modelName,
         position,
         modelfileID,
         rotation,
@@ -21,8 +261,8 @@ export class assetsFloorservice {
       console.log("req.body: ", req.body);
 
       const findvalue = await assetModel(organization).findOne({
-        modeluuid,
+        modelUuid,
-        // modelname,
+        // modelName,
         isArchive: false,
       });
       const checkpointType = await pointModel(organization).findOne({
@@ -32,9 +272,9 @@ export class assetsFloorservice {
 
       if (findvalue) {
         const updatevalue = await assetModel(organization).findOneAndUpdate(
-          { modeluuid, isArchive: false },
+          { modelUuid, isArchive: false },
           {
-            modelname: modelname,
+            modelName: modelName,
             position,
             rotation,
             isVisible,
@@ -45,13 +285,14 @@ export class assetsFloorservice {
         return res.status(201).json(updatevalue);
       } else {
         let assetData: any = {
-          modeluuid,
+          modelUuid,
-          modelname,
+          modelName,
           position,
           modelfileID,
           rotation,
           isLocked,
           isVisible,
+          eventData
         };
 
         console.log("eventData: ", eventData);
@@ -116,43 +357,45 @@ export class assetsFloorservice {
         // console.log('findValues: ', findValues);
         // console.log("item.points: ", item.points);
         const responseItem: any = {
-          modeluuid: item.modeluuid,
+          modelUuid: item.modelUuid,
-          modelname: item.modelname,
+          modelName: item.modelName,
           position: item.position,
           rotation: item.rotation,
           modelfileID: item.modelfileID,
           isLocked: item.isLocked,
           isVisible: item.isVisible,
+          eventData: item.eventData,
         };
-        if (item.type === "Conveyor" && item.points.length > 0) {
+        // if (item.type === "Conveyor" && item.points.length > 0) {
-          responseItem.eventData = {
+        //   responseItem.eventData = {
-            speed: item.speed,
+        //     speed: item.speed,
-            points: item.points,
+        //     points: item.points,
-            type: item.type,
+        //     type: item.type,
-          };
+        //   };
-        }
+        // }
 
-        if (item.type === "Vehicle" && item.points) {
+        // if (item.type === "Vehicle" && item.points) {
-          responseItem.eventData = {
+        //   responseItem.eventData = {
-            type: item.type,
+        //     type: item.type,
-            points: item.points,
+        //     points: item.points,
-          };
+        //   };
-        }
+        // }
-        if (item.type === "ArmBot" && item.points) {
+        // if (item.type === "ArmBot" && item.points) {
-          responseItem.eventData = {
+        //   responseItem.eventData = {
-            type: item.type,
+        //     type: item.type,
-            points: item.points,
+        //     points: item.points,
-          };
+        //   };
-        }
+        // }
-        if (item.type === "StaticMachine" && item.points) {
+        // if (item.type === "StaticMachine" && item.points) {
-          responseItem.eventData = {
+        //   responseItem.eventData = {
-            type: item.type,
+        //     type: item.type,
-            points: item.points,
+        //     points: item.points,
-          };
+        //   };
-        }
+        // }
         return responseItem;
       });
 
+      // console.log('response: ', response);
       return res.status(200).json(response);
     } catch (error) {
       res.status(500).json({ error: "Failed to get flooritems" });
@@ -160,87 +403,41 @@ export class assetsFloorservice {
   }
   static async deleteFloorItems(req: Request, res: Response): Promise<any> {
     try {
-      const { modeluuid, modelname, organization } = req.body;
+      const { modelUuid, modelName, organization } = req.body;
-
+      console.log('req.body:', req.body);
-      const findValue = await assetModel(organization).findOneAndDelete({
+  
-        modeluuid: modeluuid,
+      const asset = await assetModel(organization).findOne({
-        modelname: modelname,
+        modelUuid,
+        modelName,
         isArchive: false,
       });
-      if (!findValue) {
+  
-        res.status(200).json("user not found");
+      if (!asset) {
-      } else {
+        return res.status(404).json({ message: "Model not found" });
-        res.status(201).json(findValue);
       }
-    } catch (error) {
+  
-      res.status(500).json({ error: "Failed to get flooritems" });
+      const archivedAsset = await assetModel(organization).findOneAndUpdate(
-    }
+        { modelUuid, modelName },
-  }
+        { $set: { isArchive: true } },
-  static async updateAssetPositionRotation(
+        { new: true }
-    req: Request,
-    res: Response
-  ): Promise<any> {
-    try {
-      const {
-        modeluuid,
-        modelname,
-        position,
-        modelfileID,
-        rotation,
-        isLocked,
-        isVisible,
-        organization,
-        // eventData, // Optional
-      } = req.body;
-
-      const existingAsset = await assetModel(organization).findOne({
-        modeluuid: modeluuid,
-        isArchive: false,
-      });
-      if (!existingAsset) return res.send("Asset not found");
-      const updateAsset = await assetModel(organization).updateMany(
-        { modeluuid: modeluuid, modelname: modelname, isArchive: false },
-        {
-          position: position,
-          rotation: rotation,
-          isVisible: isVisible,
-          isLocked: isLocked,
-        }
       );
-      if (updateAsset)
+  
-        return res.status(200).json({ message: "Asset updated successfully" });
+      if (!archivedAsset) {
-    } catch (error: any) {
+        return res.status(500).json({ message: "Failed to archive asset" });
-      return res.send(error.message);
-    }
-  }
-  static async replaceEventDatas(req: Request, res: Response): Promise<any> {
-    const { organization, modeluuid, eventData } = req.body;
-    try {
-      const existingModel = await assetModel(organization).findOne({
-        modeluuid: modeluuid,
-        isArchive: false,
-      });
-      if (!existingModel)
-        return res.json({ message: "Model not for this UUID" });
-      else {
-        let speed;
-        if (existingModel.type === "Conveyor") {
-          speed = eventData?.speed;
-        }
-        const updatedModel = await assetModel(organization).findOneAndUpdate(
-          { modeluuid, isArchive: false },
-          {
-            points: eventData?.points,
-            type: eventData?.type || existingModel?.type,
-          },
-          { new: true }
-        );
-
-        if (updatedModel)
-          return res.status(200).json({ message: "Data updated successfully" });
       }
-    } catch (error: any) {
+  
-      return res.status(500).send(error.message);
+      const updatedEvents = await EventsDataModel(organization).updateMany(
+        { modelUuid },
+        { $set: { isArchive: true } }
+      );
+  
+      console.log("Archived asset:", archivedAsset);
+      console.log("Updated events:", updatedEvents.modifiedCount);
+  
+      return res.status(200).json({ message: "delete Asset successfully" });
+    } catch (error) {
+      console.error("Error deleting floor items:", error);
+      return res.status(500).json({ error: "Failed to delete floor items" });
     }
   }
 }

src/api-server/controller/simulation/productFlowservice.ts

@@ -10,21 +10,21 @@
 //     try {
 //       const {
 //         productName,
-//         modeluuid,
+//         modelUuid,
-//         modelname,
+//         modelName,
 //         eventData,
 //         organization,
 //         productID,
 //       } = req.body;
 
 //       // Validate required fields
-//       if (!modeluuid || !modelname || !organization) {
+//       if (!modelUuid || !modelName || !organization) {
 //         return res.status(400).json({ message: "Missing required fields" });
 //       }
 
 //       // Check if asset exists
 //       const existingAsset = await assetModel(organization).findOne({
-//         modeluuid: modeluuid,
+//         modelUuid: modelUuid,
 //         isArchive: false,
 //       });
 //       if (!existingAsset) {
@@ -100,8 +100,8 @@
 //           {
 //             $push: {
 //               ProductData: {
-//                 AssetName: modelname,
+//                 AssetName: modelName,
-//                 Assetuuid: modeluuid,
+//                 Assetuuid: modelUuid,
 //                 paths: {
 //                   Points: pointRefs,
 //                 },
@@ -118,8 +118,8 @@
 //           productName: productName,
 //           ProductData: [
 //             {
-//               AssetName: modelname,
+//               AssetName: modelName,
-//               Assetuuid: modeluuid,
+//               Assetuuid: modelUuid,
 //               paths: {
 //                 Points: pointRefs,
 //               },
@@ -191,11 +191,11 @@
 //   }
 //   //   static async deleteFloorItems(req: Request, res: Response): Promise<any> {
 //   //     try {
-//   //       const { modeluuid, modelname, organization } = req.body;
+//   //       const { modelUuid, modelName, organization } = req.body;
 
 //   //       const findValue = await assetModel(organization).findOneAndDelete({
-//   //         modeluuid: modeluuid,
+//   //         modelUuid: modelUuid,
-//   //         modelname: modelname,
+//   //         modelName: modelName,
 //   //         isArchive: false,
 //   //       });
 //   //       if (!findValue) {
@@ -214,8 +214,8 @@
 //   //   ): Promise<any> {
 //   //     try {
 //   //       const {
-//   //         modeluuid,
+//   //         modelUuid,
-//   //         modelname,
+//   //         modelName,
 //   //         position,
 //   //         modelfileID,
 //   //         rotation,
@@ -226,12 +226,12 @@
 //   //       } = req.body;
 
 //   //       const existingAsset = await assetModel(organization).findOne({
-//   //         modeluuid: modeluuid,
+//   //         modelUuid: modelUuid,
 //   //         isArchive: false,
 //   //       });
 //   //       if (!existingAsset) return res.send("Asset not found");
 //   //       const updateAsset = await assetModel(organization).updateMany(
-//   //         { modeluuid: modeluuid, modelname: modelname, isArchive: false },
+//   //         { modelUuid: modelUuid, modelName: modelName, isArchive: false },
 //   //         {
 //   //           position: position,
 //   //           rotation: rotation,

src/api-server/controller/simulation/productService.ts

@@ -0,0 +1,259 @@
+import { Request, Response } from "express";
+import ProductModel from "../../../shared/model/simulation/productModel.ts";
+import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.ts";
+
+export class productFlowservice {
+
+    static async productAdd(req: Request, res: Response): Promise<any> {
+        try {
+            const { productName, productId, eventDatas, organization } = req.body;
+            if (!organization) {
+                return res
+                    .json({ message: "organization not found" });
+            }
+            const existingProduct = await ProductModel(organization).findOne({
+                productId: productId,
+                isArchive: false,
+            })
+            if (existingProduct) {
+                const existingEventData = await EventsDataModel(organization).findOne(
+                    {
+                        productId: productId,
+                        modelUuid: eventDatas.modelUuid,
+                        isArchive: false,
+                    })
+                if (existingEventData) {
+                    const updateEventData = await EventsDataModel(organization).findOneAndUpdate(
+                        {
+                            modelUuid: eventDatas.modelUuid,
+                            isArchive: false,
+                        }
+                        , {
+                            modelUuid: eventDatas?.modelUuid,
+                            modelName: eventDatas?.modelName,
+                            position: eventDatas?.position,
+                            rotation: eventDatas?.rotation,
+                            type: eventDatas?.type,
+                            speed: eventDatas?.speed,
+                            point: eventDatas?.point,
+                            points: eventDatas?.points,
+                        })
+                    return res
+                        .status(200)
+                        .json({ message: "EventData updated successfully" });
+                } else {
+                    const addEventData = await EventsDataModel(organization).create({
+                        productId: productId,
+                        modelUuid: eventDatas?.modelUuid,
+                        modelName: eventDatas?.modelName,
+                        position: eventDatas?.position,
+                        rotation: eventDatas?.rotation,
+                        type: eventDatas?.type,
+                        speed: eventDatas?.speed,
+                        point: eventDatas?.point,
+                        points: eventDatas?.points
+                    })
+                    return res
+                        .status(201)
+                        .json({ message: "EventData add successfully" });
+                }
+            } else {
+                const newProduct = await ProductModel(organization).create({
+                    productId: productId,
+                    productName: productName
+
+                })
+                if (newProduct) {
+
+                    if (!eventDatas) {
+                        return res.status(404).json({ message: "eventData not found" });
+
+                    } else {
+                        const addEventData = await EventsDataModel(organization).create({
+                            productId: productId,
+                            modelUuid: eventDatas?.modelUuid,
+                            modelName: eventDatas?.modelName,
+                            position: eventDatas?.position,
+                            rotation: eventDatas?.rotation,
+                            type: eventDatas?.type,
+                            speed: eventDatas?.speed,
+                            point: eventDatas?.point,
+                            points: eventDatas?.points,
+                        })
+
+                    }
+                }
+                return res
+                    .status(201)
+                    .json({ message: "Product created successfully" });
+
+            }
+        } catch (error) {
+            res.status(500).json({ message: "Failed to create product" });
+        }
+    }
+    static async getProductDatas(req: Request, res: Response): Promise<any> {
+        try {
+            const { productId, organization } = req.query
+            if (typeof productId !== "string" || typeof organization !== "string") {
+                return res.status(400).json({ message: "Missing or invalid query parameters" });
+            }
+            const existingProduct = await ProductModel(organization).findOne({
+                productId: productId,
+                isArchive: false,
+            })
+
+            if (!existingProduct)
+                return res.status(404).json({ message: "Product not found" });
+
+
+            const existingEventDatas = await EventsDataModel(organization).find({ productId: productId }).select("-productId")
+
+            return res
+                .status(200)
+                .json(existingEventDatas);
+        } catch (error) {
+
+            res.status(500).json({ message: "Failed to get product" });
+        }
+
+    }
+    static async productDataDelete(req: Request, res: Response): Promise<any> {
+        try {
+            const { productId, organization } = req.query
+            if (typeof productId !== "string" || typeof organization !== "string") {
+                return res.status(400).json({ message: "Missing or invalid query parameters" });
+            }
+            const existingProduct = await ProductModel(organization).findOne({
+                productId: productId,
+                isArchive: false,
+            })
+
+            if (!existingProduct)
+                return res.status(404).json({ message: "Product not found" });
+
+            const productDelete = await ProductModel(organization).findOneAndUpdate(
+                { productId: productId },
+                {
+                    isArchive: true,
+                }, { new: true }
+
+            )
+            const existingEventDatas = await EventsDataModel(organization).find({ productId: productId })
+            if (existingEventDatas) {
+                for (const event of existingEventDatas) {
+
+                    await EventsDataModel(organization).updateMany(
+                        { productId },
+                        { $set: { isArchive: true } }
+                    );
+
+                }
+            }
+            return res.status(201).json({ message: "product deleted successfully" });
+
+        } catch (error) {
+            res.status(500).json({ message: "Failed to delete product" });
+        }
+
+    }
+    static async EventDataDelete(req: Request, res: Response): Promise<any> {
+        try {
+            const { productId, organization, modelUuid } = req.body
+
+            const existingProduct = await ProductModel(organization).findOne({
+                productId: productId,
+                isArchive: false,
+            })
+
+            if (!existingProduct)
+                return res.status(404).json({ message: "Product not found" });
+
+
+            const existingEventDatas = await EventsDataModel(organization).findOneAndUpdate(
+                { productId: productId, modelUuid: modelUuid }, {
+                isArchive: true,
+            }, { new: true }
+
+            )
+
+            return res.status(201).json({ message: "EventData deleted successfully" });
+        } catch (error) {
+            res.status(500).json({ message: "Failed to delete Eventdata" });
+        }
+
+    }
+    static async AllProductDatas(req: Request, res: Response): Promise<any> {
+        try {
+            const { organization } = req.params
+
+            if (!organization) {
+                return res
+                    .json({ message: "organization not found" });
+            }
+
+            const existingProduct = await ProductModel(organization).find({
+                isArchive: false,
+            })
+            if (!existingProduct) {
+                return res.status(404).json({ message: 'No products found' });
+            }
+            const result = [];
+
+            for (const product of existingProduct) {
+
+
+                // Fetch events data for each product, excluding productId field
+                const eventDatas = await EventsDataModel(organization)
+                    .find({ productId: product.productId, isArchive: false })
+                    .select("-productId -isArchive -createdAt -updatedAt -__v -_id");
+
+
+
+                // Combine product and event data
+                result.push({
+                    // product: {
+                    productName: product.productName,
+                    productId: product.productId,
+                    eventDatas,
+                    //   },
+                });
+            }
+
+            // Return combined data
+            return res.status(200).json(result);
+
+        } catch (error) {
+            res.status(500).json({ message: "Failed to get Allproduct" });
+        }
+
+    }
+    static async productRename(req: Request, res: Response): Promise<any> {
+
+        try {
+            const { productId, productName, organization } = req.body
+
+
+            const existingProduct = await ProductModel(organization).findOne({
+                productId: productId,
+                isArchive: false,
+            })
+
+            if (!existingProduct)
+                return res.status(404).json({ message: "Product not found" });
+
+            const productDelete = await ProductModel(organization).findOneAndUpdate(
+                { productId: productId },
+                {
+                    productName: productName,
+                }, { new: true }
+
+            )
+
+            return res.status(201).json({ message: "product Rename successfully" });
+        } catch (error) {
+            res.status(500).json({ message: "Failed to product Rename" });
+        }
+
+    }
+}

src/shared/model/assets/flooritems-Model.ts

@@ -3,9 +3,9 @@ import MainModel from '../../connect/mongoose.ts';
 
 // Interface for TypeScript with PascalCase
 export interface floorItenms extends Document {
-  modeluuid: string;
+  modelUuid: string;
   modelfileID: string;
-  modelname: string
+  modelName: string
   isLocked:boolean
   isVisible:boolean
   position: []
@@ -20,9 +20,9 @@ export interface floorItenms extends Document {
 
 // Define the Mongoose Schema
 const floorItemsSchema: Schema = new Schema({
-  modeluuid: { type: String },
+  modelUuid: { type: String },
   modelfileID: { type: String },
-  modelname: { type: String },
+  modelName: { type: String },
   position: { type: Array},
   isLocked:{type:Boolean},
   isVisible:{type:Boolean},

src/shared/model/assets/wallitems-Model.ts

@@ -2,8 +2,8 @@ import mongoose, { Document, Schema } from 'mongoose';
 import MainModel from '../../connect/mongoose.ts';
 // Interface for TypeScript with PascalCase
 export interface wallitems extends Document {
-    modeluuid: string;
+    modelUuid: string;
-    modelname: string
+    modelName: string
     type: string
     csgposition: []
     csgscale: []
@@ -16,8 +16,8 @@ export interface wallitems extends Document {
 
 // Define the Mongoose Schema
 const wallItemsSchema: Schema = new Schema({
-    modeluuid: { type: String,unique:true },
+    modelUuid: { type: String,unique:true },
-    modelname: { type: String},
+    modelName: { type: String},
     type: { type: String },
     csgposition: { type: Array},
     csgscale: { type: Array,},

src/shared/model/builder/assets/asset-Model.ts

@@ -1,15 +1,32 @@
 import mongoose, { Document, Schema } from "mongoose";
 import MainModel from "../../../connect/mongoose.ts";
 
+interface ICommonBase{
+  type: string;
+}
+interface IPointsConveyor extends ICommonBase{
+  points?: {
+    Uuid:string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+  }[];
+}
+interface IPoint extends ICommonBase{
+  point?: {
+    Uuid:string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+  };
+}
 export interface assetData extends Document {
-  modeluuid: string;
+  modelUuid: string;
   modelfileID: string;
-  modelname: string;
+  modelName: string;
   isLocked: boolean;
   type: string;
   isVisible: boolean;
   isArchive: false;
-  points: [] | {};
+  // points: [] | {};
   position: [];
   rotation: {
     x: number;
@@ -17,15 +34,17 @@ export interface assetData extends Document {
     z: number;
   };
   speed: number | string;
+  eventData: IPoint|IPointsConveyor
 }
 
+
 const assetDataSchema: Schema = new Schema({
   isArchive: { type: Boolean, default: false },
-  modeluuid: { type: String },
+  modelUuid: { type: String },
   modelfileID: { type: String },
-  modelname: { type: String },
+  modelName: { type: String },
   type: { type: String },
-  points: { type: Schema.Types.Mixed },
+  // points: { type: Schema.Types.Mixed },
   position: { type: Array },
   rotation: {
     x: { type: Number },
@@ -35,6 +54,10 @@ const assetDataSchema: Schema = new Schema({
   speed: { type: Schema.Types.Mixed },
   isLocked: { type: Boolean },
   isVisible: { type: Boolean },
+  eventData: {
+    type: Schema.Types.Mixed,
+      required: true,
+  },
 });
 
 // export default floorItemsModel;
@@ -47,9 +70,9 @@ export default assetModel;
 // import MainModel from "../../../connect/mongoose.ts";
 
 // export interface assetData extends Document {
-//   modeluuid: string;
+//   modelUuid: string;
 //   modelfileID: string;
-//   modelname: string;
+//   modelName: string;
 //   isLocked: boolean;
 //   type: string;
 //   isVisible: boolean;
@@ -92,9 +115,9 @@ export default assetModel;
 // // Define the Mongoose Schema
 // const assetDataSchema: Schema = new Schema({
 //   isArchive: { type: Boolean, default: false },
-//   modeluuid: { type: String },
+//   modelUuid: { type: String },
 //   modelfileID: { type: String },
-//   modelname: { type: String },
+//   modelName: { type: String },
 //   type: { type: String },
 //   // assetPosition: { type: Array },
 //   points: [

src/shared/model/builder/assets/wallitems-Model.ts

@@ -2,8 +2,8 @@ import mongoose, { Document, Schema } from "mongoose";
 import MainModel from "../../../connect/mongoose.ts";
 // Interface for TypeScript with PascalCase
 export interface wallitems extends Document {
-  modeluuid: string;
+  modelUuid: string;
-  modelname: string;
+  modelName: string;
   type: string;
   csgposition: [];
   csgscale: [];
@@ -14,8 +14,8 @@ export interface wallitems extends Document {
 
 // Define the Mongoose Schema
 const wallItemsSchema: Schema = new Schema({
-  modeluuid: { type: String, unique: true },
+  modelUuid: { type: String, unique: true },
-  modelname: { type: String },
+  modelName: { type: String },
   type: { type: String },
   csgposition: { type: Array },
   csgscale: { type: Array },

src/shared/model/simulation/eventsDataModel.ts

@@ -0,0 +1,179 @@
+// models/Product.ts
+import mongoose, { Schema, Document, Types } from "mongoose";
+import MainModel from "../../connect/mongoose.ts";
+
+interface AssetEventSchema {
+    modelUuid: string;
+    modelName: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    state: "idle" | "running" | "stopped" | "disabled" | "error";
+};
+
+interface TriggerSchema {
+    triggerUuid: string;
+    triggerName: string;
+    triggerType: "onComplete" | "onStart" | "onStop" | "delay" | "onError";
+    delay: number;
+    triggeredAsset: {
+        triggeredModel: { modelName: string, modelUuid: string };
+        triggeredPoint: { pointName: string, pointUuid: string };
+        triggeredAction: { actionName: string, actionUuid: string };
+    } | null;
+}
+
+interface ConveyorPointSchema {
+    uuid: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    action: {
+        actionUuid: string;
+        actionName: string;
+        actionType: "default" | "spawn" | "swap" | "despawn";
+        material: string;
+        delay: number | "inherit";
+        spawnInterval: number | "inherit";
+        spawnCount: number | "inherit";
+        triggers: TriggerSchema[];
+    };
+}
+
+interface VehiclePointSchema {
+    uuid: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    action: {
+        actionUuid: string;
+        actionName: string;
+        actionType: "travel";
+        material: string | null;
+        unLoadDuration: number;
+        loadCapacity: number;
+        pickUpPoint: { x: number; y: number, z: number } | null;
+        unLoadPoint: { x: number; y: number, z: number } | null;
+        triggers: TriggerSchema[];
+    };
+}
+
+interface RoboticArmPointSchema {
+    uuid: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    actions: {
+        actionUuid: string;
+        actionName: string;
+        actionType: "pickAndPlace";
+        process: { startPoint: [number, number, number]; endPoint: [number, number, number] };
+        triggers: TriggerSchema[];
+    }[];
+}
+
+interface MachinePointSchema {
+    uuid: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    action: {
+        actionUuid: string;
+        actionName: string;
+        actionType: "process";
+        processTime: number;
+        swapMaterial: string;
+        triggers: TriggerSchema[];
+    };
+}
+
+interface StoragePointSchema {
+    uuid: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    action: {
+        actionUuid: string;
+        actionName: string;
+        actionType: "storage";
+        materials: { materialName: string; materialId: string; }[];
+        storageCapacity: number;
+    };
+}
+
+interface ConveyorEventSchema extends AssetEventSchema {
+    type: "transfer";
+    speed: number;
+    points: ConveyorPointSchema[];
+}
+
+interface VehicleEventSchema extends AssetEventSchema {
+    type: "vehicle";
+    speed: number;
+    point: VehiclePointSchema;
+}
+
+interface RoboticArmEventSchema extends AssetEventSchema {
+    type: "roboticArm";
+    speed: number;
+    point: RoboticArmPointSchema;
+}
+
+interface MachineEventSchema extends AssetEventSchema {
+    type: "machine";
+    // speed: number;
+    point: MachinePointSchema;
+}
+
+interface StorageEventSchema extends AssetEventSchema {
+    type: "storageUnit";
+    // speed: number;
+    point: StoragePointSchema;
+}
+interface IPointModel extends Document {
+    modelUuid:String,
+    modelName:String,
+    position:String,
+    rotation:String,
+    state:String,
+    productId:String,
+    isArchive:boolean,
+  type: "transfer" | "vehicle" | "roboticArm" | "machine" |"storageUnit";
+  speed: number;
+  point: VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema
+  points: ConveyorEventSchema[]
+
+}
+// type EventsSchema = ConveyorEventSchema | VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema;
+
+
+const BaseEventSchema = new Schema<IPointModel>(
+    {
+      modelUuid: { type: String, required: true },
+      modelName: { type: String, required: true },
+      position: { type: [Number], required: true },
+      rotation: { type: [Number], required: true },
+      speed: { type: Number,},
+      state: {
+        type: String,
+        enum: ["idle", "running", "stopped", "disabled", "error"],
+        default: "idle"
+      },
+      type: {
+        type: String,
+        required: true,
+        enum: ["transfer", "vehicle", "roboticArm", "machine", "storageUnit"]
+      },
+      point:{
+        type:Schema.Types.Mixed,
+
+      },
+      points:{
+        type:Schema.Types.Mixed,
+
+      },
+      productId: { type:String,required: true },
+      isArchive: { type: Boolean, default: false }
+    },
+    { discriminatorKey: "type", timestamps: true }
+  );
+  
+  const EventsDataModel = (db: string) => {
+    return MainModel(db, "EventDatas", BaseEventSchema, "EventDatas");
+  };
+  
+  export default EventsDataModel;

src/shared/model/simulation/productModel.ts

@@ -0,0 +1,24 @@
+import mongoose, { Schema, Document, model } from "mongoose";
+import MainModel from "../../connect/mongoose.ts";
+export interface product extends Document {
+  productName: string;
+  productId: string;
+  eventsData: [];
+  isArchive: boolean;
+
+}
+
+
+// Product Schema
+const ProductSchema = new Schema({
+  productName: { type: String, required: true },
+  productId: { type: String, required: true },
+  isArchive: { type: Boolean, default: false },
+});
+
+
+const ProductModel = (db: string) => {
+  return MainModel(db, "Product", ProductSchema, "Product");
+};
+
+export default ProductModel;

src/socket-server/services/assets/asset-Controller.ts

@@ -1,11 +1,212 @@
 import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
 import actionModel from "../../../shared/model/simulation/actionmodel.ts";
+import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.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;
+//   try {
+//     const findvalue = await assetModel(organization).findOne({
+//       modelUuid: modelUuid,
+//       // modelName: modelName,
+//       isArchive: false,
+//     });
+
+//     if (findvalue) {
+//       const updatevalue = await assetModel(organization).findOneAndUpdate(
+//         { modelUuid: modelUuid, isArchive: false },
+//         {
+//           modelName: modelName,
+//           position: position,
+//           rotation: rotation,
+//           isVisible: isVisible,
+//           isLocked: isLocked,
+//         },
+//         { new: true }
+//       );
+//       return {
+//         success: true,
+//         message: "Model updated successfully",
+//         data: updatevalue,
+//         organization: organization,
+//       };
+//     } else {
+//       let assetData: any = {
+//         modelUuid,
+//         modelName,
+//         position,
+//         modelfileID,
+//         rotation,
+//         isLocked,
+//         isVisible,
+//       };
+
+//       if (eventData) {
+//         if (eventData.type === "Conveyor") {
+//           assetData.speed = eventData.speed;
+//         } else if (eventData.type === "Vehicle") {
+//           assetData.speed = eventData.points.speed;
+//           if (!eventData.points) {
+//             return {
+//               success: false,
+//               message: "Vehicle points must be a single object",
+//               organization: organization,
+//             };
+//           }
+//           // if (eventData.points.rotation) {
+//           //   return {
+//           //     success: false,
+//           //     message: "Rotation is not allowed for Vehicle points",
+//           //     organization: organization,
+//           //   };
+//           // }
+//           if (eventData.points.triggers) {
+//             return {
+//               success: false,
+//               message: "triggers is not allowed for Vehicle points",
+//               organization: organization,
+//             };
+//           }
+//         }
+//         assetData.points = eventData.points;
+//         assetData.type = eventData.type;
+//       }
+//       const assetDoc = await assetModel(organization).create(assetData);
+//       await assetDoc.save();
+//       let assetDatas;
+//       if (assetDoc.type === "Conveyor") {
+//         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,
+//           },
+//         };
+//       } else if (assetDoc.type === "Vehicle") {
+//         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,
+//           },
+//         };
+//       } else if (assetDoc.type === "ArmBot") {
+//         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,
+//           },
+//         };
+//       } else if (assetDoc.type === "StaticMachine") {
+//         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,
+//           },
+//         };
+//       } else {
+//         assetDatas = {
+//           modelUuid: assetDoc.modelUuid,
+//           modelName: assetDoc.modelName,
+//           modelfileID: assetDoc.modelfileID,
+//           position: assetDoc.position,
+//           rotation: assetDoc.rotation,
+//           isLocked: assetDoc.isLocked,
+//           isVisible: assetDoc.isVisible,
+//         };
+//       }
+//       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,
+//       isArchive: false,
+//     });
+//     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,
+//     };
+//   }
+// };
+//update 30/4..//setAssetModel//deleteAssetModel...........
 export const setAssetModel = async (data: any) => {
   const {
-    modeluuid,
+    modelUuid,
-    modelname,
+    modelName,
     position,
     rotation,
     eventData,
@@ -16,20 +217,21 @@ export const setAssetModel = async (data: any) => {
   } = data;
   try {
     const findvalue = await assetModel(organization).findOne({
-      modeluuid: modeluuid,
+      modelUuid: modelUuid,
-      // modelname: modelname,
+      // modelName: modelName,
       isArchive: false,
     });
 
     if (findvalue) {
       const updatevalue = await assetModel(organization).findOneAndUpdate(
-        { modeluuid: modeluuid, isArchive: false },
+        { modelUuid: modelUuid, isArchive: false },
         {
-          modelname: modelname,
+          modelName: modelName,
           position: position,
           rotation: rotation,
           isVisible: isVisible,
           isLocked: isLocked,
+          eventData: eventData
         },
         { new: true }
       );
@@ -41,8 +243,8 @@ export const setAssetModel = async (data: any) => {
       };
     } else {
       let assetData: any = {
-        modeluuid,
+        modelUuid,
-        modelname,
+        modelName,
         position,
         modelfileID,
         rotation,
@@ -50,107 +252,119 @@ export const setAssetModel = async (data: any) => {
         isVisible,
       };
 
-      if (eventData) {
+      if (eventData?.type === 'Conveyor') {
-        if (eventData.type === "Conveyor") {
+        assetData.eventData = {
-          assetData.speed = eventData.speed;
+          type: eventData.type,
-        } else if (eventData.type === "Vehicle") {
+          // point:undefined,
-          assetData.speed = eventData.points.speed;
+          points: eventData.points,
-          if (!eventData.points) {
+        };
-            return {
+      } else {
-              success: false,
+
-              message: "Vehicle points must be a single object",
+        assetData.eventData = {
-              organization: organization,
+          type: eventData.type,
-            };
+          point: eventData.point,
-          }
+          // points: undefined
-          // if (eventData.points.rotation) {
+        };
-          //   return {
-          //     success: false,
-          //     message: "Rotation is not allowed for Vehicle points",
-          //     organization: organization,
-          //   };
-          // }
-          if (eventData.points.triggers) {
-            return {
-              success: false,
-              message: "triggers is not allowed for Vehicle points",
-              organization: organization,
-            };
-          }
-        }
-        assetData.points = eventData.points;
-        assetData.type = eventData.type;
       }
+
+      // if (eventData) {
+
+      //   if (eventData.type === "Conveyor") {
+      //     assetData.speed = eventData.speed;
+      //   } else if (eventData.type === "Vehicle") {
+      //     assetData.speed = eventData.points.speed;
+      //     if (!eventData.points) {
+      //       return {
+      //         success: false,
+      //         message: "Vehicle points must be a single object",
+      //         organization: organization,
+      //       };
+      //     }
+      //     // if (eventData.points.rotation) {
+      //     //   return {
+      //     //     success: false,
+      //     //     message: "Rotation is not allowed for Vehicle points",
+      //     //     organization: organization,
+      //     //   };
+      //     // }
+      //     if (eventData.points.triggers) {
+      //       return {
+      //         success: false,
+      //         message: "triggers is not allowed for Vehicle points",
+      //         organization: organization,
+      //       };
+      //     }
+      //   }
+      //   assetData.points = eventData.points;
+      //   assetData.type = eventData.type;
+      // }
       const assetDoc = await assetModel(organization).create(assetData);
       await assetDoc.save();
       let assetDatas;
-      if (assetDoc.type === "Conveyor") {
+      // if (eventData.type === "Conveyor") {
-        assetDatas = {
+      //   assetDatas = {
-          modeluuid: assetDoc.modeluuid,
+      //     modelUuid: assetDoc.modelUuid,
-          modelname: assetDoc.modelname,
+      //     modelName: assetDoc.modelName,
-          modelfileID: assetDoc.modelfileID,
+      //     modelfileID: assetDoc.modelfileID,
-          position: assetDoc.position,
+      //     position: assetDoc.position,
-          rotation: assetDoc.rotation,
+      //     rotation: assetDoc.rotation,
-          isLocked: assetDoc.isLocked,
+      //     isLocked: assetDoc.isLocked,
-          isVisible: assetDoc.isVisible,
+      //     isVisible: assetDoc.isVisible,
-          eventData: {
+      //     eventData:eventData
-            points: assetDoc.points,
+      //   };
-            type: assetDoc.type,
+      // } else if (assetDoc.type === "Vehicle") {
-            speed: assetDoc.speed,
+      //   assetDatas = {
-          },
+      //     modelUuid: assetDoc.modelUuid,
-        };
+      //     modelName: assetDoc.modelName,
-      } else if (assetDoc.type === "Vehicle") {
+      //     modelfileID: assetDoc.modelfileID,
-        assetDatas = {
+      //     position: assetDoc.position,
-          modeluuid: assetDoc.modeluuid,
+      //     rotation: assetDoc.rotation,
-          modelname: assetDoc.modelname,
+      //     isLocked: assetDoc.isLocked,
-          modelfileID: assetDoc.modelfileID,
+      //     isVisible: assetDoc.isVisible,
-          position: assetDoc.position,
+      //     eventData: {
-          rotation: assetDoc.rotation,
+      //       points: assetDoc.points,
-          isLocked: assetDoc.isLocked,
+      //       type: assetDoc.type,
-          isVisible: assetDoc.isVisible,
+      //     },
-          eventData: {
+      //   };
-            points: assetDoc.points,
+      // } else if (assetDoc.type === "ArmBot") {
-            type: assetDoc.type,
+      //   assetDatas = {
-          },
+      //     modelUuid: assetDoc.modelUuid,
-        };
+      //     modelName: assetDoc.modelName,
-      } else if (assetDoc.type === "ArmBot") {
+      //     modelfileID: assetDoc.modelfileID,
-        assetDatas = {
+      //     position: assetDoc.position,
-          modeluuid: assetDoc.modeluuid,
+      //     rotation: assetDoc.rotation,
-          modelname: assetDoc.modelname,
+      //     isLocked: assetDoc.isLocked,
-          modelfileID: assetDoc.modelfileID,
+      //     isVisible: assetDoc.isVisible,
-          position: assetDoc.position,
+      //     eventData: {
-          rotation: assetDoc.rotation,
+      //       points: assetDoc.points,
-          isLocked: assetDoc.isLocked,
+      //       type: assetDoc.type,
-          isVisible: assetDoc.isVisible,
+      //     },
-          eventData: {
+      //   };
-            points: assetDoc.points,
+      // } else if (assetDoc.type === "StaticMachine") {
-            type: assetDoc.type,
+      //   assetDatas = {
-          },
+      //     modelUuid: assetDoc.modelUuid,
-        };
+      //     modelName: assetDoc.modelName,
-      } else if (assetDoc.type === "StaticMachine") {
+      //     modelfileID: assetDoc.modelfileID,
-        assetDatas = {
+      //     position: assetDoc.position,
-          modeluuid: assetDoc.modeluuid,
+      //     rotation: assetDoc.rotation,
-          modelname: assetDoc.modelname,
+      //     isLocked: assetDoc.isLocked,
-          modelfileID: assetDoc.modelfileID,
+      //     isVisible: assetDoc.isVisible,
-          position: assetDoc.position,
+      //     eventData: {
-          rotation: assetDoc.rotation,
+      //       points: assetDoc.points,
-          isLocked: assetDoc.isLocked,
+      //       type: assetDoc.type,
-          isVisible: assetDoc.isVisible,
+      //     },
-          eventData: {
+      //   };
-            points: assetDoc.points,
+      // } else {
-            type: assetDoc.type,
+      //   assetDatas = {
-          },
+      //     modelUuid: assetDoc.modelUuid,
-        };
+      //     modelName: assetDoc.modelName,
-      } else {
+      //     modelfileID: assetDoc.modelfileID,
-        assetDatas = {
+      //     position: assetDoc.position,
-          modeluuid: assetDoc.modeluuid,
+      //     rotation: assetDoc.rotation,
-          modelname: assetDoc.modelname,
+      //     isLocked: assetDoc.isLocked,
-          modelfileID: assetDoc.modelfileID,
+      //     isVisible: assetDoc.isVisible,
-          position: assetDoc.position,
+      //   };
-          rotation: assetDoc.rotation,
+      // }
-          isLocked: assetDoc.isLocked,
-          isVisible: assetDoc.isVisible,
-        };
-      }
       return {
         success: true,
         message: "Model created successfully",
@@ -170,27 +384,61 @@ export const setAssetModel = async (data: any) => {
 };
 
 export const deleteAssetModel = async (data: any) => {
-  const { modeluuid, modelname, organization } = data;
+  const { modelUuid, modelName, organization } = data;
   try {
-    const findValue = await assetModel(organization).findOneAndDelete({
+    const asset = await assetModel(organization).findOne({
-      modeluuid: modeluuid,
+      modelUuid,
-      modelname: modelname,
+      modelName,
       isArchive: false,
     });
-    if (!findValue) {
+    // const findmodelValue = await assetModel(organization).findOne({
+    //   modelUuid: modelUuid,
+    //   modelName: modelName,
+    //   isArchive: false,
+    // });
+    if (!asset) {
       return {
         success: false,
         message: "model not found",
         organization: organization,
       };
-    } else {
+    }
+    const archivedAsset = await assetModel(organization).findOneAndUpdate(
+      { modelUuid, modelName },
+      { $set: { isArchive: true } },
+      { new: true }
+    );
+    if (!archivedAsset) {
       return {
-        success: true,
+        success: false,
-        message: "Model deleted successfully",
+        message: "Failed to archive asset",
-        data: findValue,
         organization: organization,
       };
+
     }
+    const updatedEvents = await EventsDataModel(organization).updateMany(
+      { modelUuid },
+      { $set: { isArchive: true } }
+    );
+    // const findProductEventData = await EventsDataModel(organization).find(modelUuid)
+    // console.log('findProductEventData: ', findProductEventData);
+    // if (findProductEventData) {
+    //   for (const event of findProductEventData) {
+    //     console.log("Event ID:", event);
+    //     await EventsDataModel(organization).updateMany(
+    //       { modelUuid },
+    //       { $set: { isArchive: true } }
+    //     );
+
+    //   }
+    // }
+    return {
+      success: true,
+      message: "Model deleted successfully",
+      data: archivedAsset,
+      organization: organization,
+    };
+
   } catch (error) {
     // console.error('Error get flooritems:', error);
     return {
@@ -202,10 +450,10 @@ export const deleteAssetModel = async (data: any) => {
   }
 };
 export const replaceEventDatas = async (data: any) => {
-  const { organization, modeluuid, eventData } = data;
+  const { organization, modelUuid, eventData } = data;
   try {
     const existingModel = await assetModel(organization).findOne({
-      modeluuid: modeluuid,
+      modelUuid: modelUuid,
       isArchive: false,
     });
     if (!existingModel)
@@ -223,7 +471,7 @@ export const replaceEventDatas = async (data: any) => {
       //   speed = eventData?.points?.speed;
       // }
       const updatedModel = await assetModel(organization).findOneAndUpdate(
-        { modeluuid, isArchive: false },
+        { modelUuid, isArchive: false },
         {
           points: eventData?.points,
           // speed: speed,

src/socket-server/services/assets/flooritem-Controller.ts

@@ -3,22 +3,22 @@ import floorItemsModel from "../../../shared/model/assets/flooritems-Model.ts";
 
 export const setFloorItems = async (data: any) => {
     try {
-        const { modelfileID,modeluuid, modelname, position, rotation,isLocked,isVisible, organization } = data
+        const { modelfileID,modelUuid, modelName, position, rotation,isLocked,isVisible, organization } = data
     
 
 
-        const findvalue = await floorItemsModel(organization).findOne({ modeluuid: modeluuid, modelname: modelname })
+        const findvalue = await floorItemsModel(organization).findOne({ modelUuid: modelUuid, modelName: modelName })
       
         if (findvalue) {
 
             const updatevalue = await floorItemsModel(organization).findOneAndUpdate(
-                { modeluuid: modeluuid, modelname: modelname }, { position: position, rotation: rotation ,isVisible:isVisible,isLocked:isLocked}, { new: true });
+                { modelUuid: modelUuid, modelName: modelName }, { position: position, rotation: rotation ,isVisible:isVisible,isLocked:isLocked}, { new: true });
             return { success: true, message: 'flooritems updated', data: updatevalue,organization:organization }
             
 
         } else {
 
-            const newValue = await floorItemsModel(organization).create({ modeluuid, modelname, modelfileID,position, rotation,isLocked,isVisible });
+            const newValue = await floorItemsModel(organization).create({ modelUuid, modelName, modelfileID,position, rotation,isLocked,isVisible });
 
          
             return { success: true, message: 'flooritem created', data: newValue,organization:organization }
@@ -34,9 +34,9 @@ export const setFloorItems = async (data: any) => {
    
     export const deleteFloorItems = async (data: any)=>{
         try {
-            const { modeluuid,modelname,organization } = data;
+            const { modelUuid,modelName,organization } = data;
 
-            const findValue = await floorItemsModel(organization).findOneAndDelete({modeluuid:modeluuid,modelname:modelname})
+            const findValue = await floorItemsModel(organization).findOneAndDelete({modelUuid:modelUuid,modelName:modelName})
             if (!findValue) {
                 return { success: false, message: 'model not found',organization:organization }
 

src/socket-server/services/assets/wallitem-Controller.ts

@@ -4,16 +4,16 @@ import wallItenmModel from "../../../shared/model/assets/wallitems-Model.ts";
 
 export const setWallItems = async (data: any) => {
     try {
-        const { modeluuid, modelname, position, type, csgposition, csgscale, quaternion, scale, organization } = data
+        const { modelUuid, modelName, position, type, csgposition, csgscale, quaternion, scale, organization } = data
 
 
-        const findvalue = await wallItenmModel(organization).findOne({ modeluuid: modeluuid })
+        const findvalue = await wallItenmModel(organization).findOne({ modelUuid: modelUuid })
         if (findvalue) {
 
             const updatevalue = await wallItenmModel(organization).findOneAndUpdate(
-                { modeluuid: modeluuid },
+                { modelUuid: modelUuid },
                 {
-                    modelname,
+                    modelName,
                     position,
                     type,
                     csgposition,
@@ -28,7 +28,7 @@ export const setWallItems = async (data: any) => {
 
         } else {
 
-            const newValue = await wallItenmModel(organization).create({ modeluuid, modelname, position, type, csgposition, csgscale, quaternion, scale });
+            const newValue = await wallItenmModel(organization).create({ modelUuid, modelName, position, type, csgposition, csgscale, quaternion, scale });
             return { success: true, message: 'wallIitem created', data: newValue, organization: organization }
         }
 
@@ -41,10 +41,10 @@ export const setWallItems = async (data: any) => {
 
 export const deleteWallItems = async (data: any) => {
     try {
-        const { modeluuid, modelname, organization } = data;
+        const { modelUuid, modelName, organization } = data;
 
 
-        const findValue = await wallItenmModel(organization).findOneAndDelete({ modeluuid: modeluuid, modelname: modelname })
+        const findValue = await wallItenmModel(organization).findOneAndDelete({ modelUuid: modelUuid, modelName: modelName })
         if (!findValue) {
             return { success: false, message: 'model not found', organization: organization }
 

swagger-output.json

@@ -311,10 +311,10 @@
             "schema": {
               "type": "object",
               "properties": {
-                "modeluuid": {
+                "modelUuid": {
                   "example": "any"
                 },
-                "modelname": {
+                "modelName": {
                   "example": "any"
                 },
                 "position": {
@@ -385,10 +385,10 @@
             "schema": {
               "type": "object",
               "properties": {
-                "modeluuid": {
+                "modelUuid": {
                   "example": "any"
                 },
-                "modelname": {
+                "modelName": {
                   "example": "any"
                 },
                 "organization": {
@@ -693,10 +693,10 @@
             "schema": {
               "type": "object",
               "properties": {
-                "modeluuid": {
+                "modelUuid": {
                   "example": "any"
                 },
-                "modelname": {
+                "modelName": {
                   "example": "any"
                 },
                 "position": {
@@ -770,10 +770,10 @@
             "schema": {
               "type": "object",
               "properties": {
-                "modeluuid": {
+                "modelUuid": {
                   "example": "any"
                 },
-                "modelname": {
+                "modelName": {
                   "example": "any"
                 },
                 "organization": {