Refactor asset model handling and event data management

- Removed redundant data structure in handleModelLoad function.
- Introduced eventData object to encapsulate event-related information for different asset types (Conveyor, Vehicle, ArmBot, StaticMachine).
- Updated socket emission to include complete data with eventData.
- Enhanced copy-paste and duplication controls to maintain eventData integrity during object duplication.
- Integrated event data updates in move and rotate controls to reflect changes in the simulation state.
- Improved PointsCreator component to handle rotation for event groups.
- Updated handleAddEventToProduct function to support event data management.
- Enhanced product management to fetch existing products from the server and handle new product creation.
- Added new types for eventData in worldTypes and simulationTypes for better type safety.
- Refactored IndexedDB utility functions for cleaner code.

app/src/modules/builder/IntialLoad/loadInitialFloorItems.ts

@@ -156,7 +156,7 @@ function processLoadedModel(
     const model = gltf.clone();
     model.uuid = item.modeluuid;
     model.scale.set(...CONSTANTS.assetConfig.defaultScaleBeforeGsap);
-    model.userData = { name: item.modelname, modelId: item.modelfileID, modeluuid: item.modeluuid };
+    model.userData = { name: item.modelname, modelId: item.modelfileID, modeluuid: item.modeluuid, eventData: item.eventData };
     model.position.set(...item.position);
     model.rotation.set(item.rotation.x, item.rotation.y, item.rotation.z);
 
@@ -170,256 +170,141 @@ function processLoadedModel(
         }
     });
 
-
     itemsGroup?.current?.add(model);
 
-    setFloorItems((prevItems) => [
-        ...(prevItems || []),
-        {
-            modeluuid: item.modeluuid,
-            modelname: item.modelname,
-            position: item.position,
-            rotation: item.rotation,
-            modelfileID: item.modelfileID,
-            isLocked: item.isLocked,
-            isVisible: item.isVisible,
-        },
-    ]);
+    if (item.eventData) {
+        setFloorItems((prevItems) => [
+            ...(prevItems || []),
+            {
+                modeluuid: item.modeluuid,
+                modelname: item.modelname,
+                position: item.position,
+                rotation: item.rotation,
+                modelfileID: item.modelfileID,
+                isLocked: item.isLocked,
+                isVisible: item.isVisible,
+                eventData: item.eventData,
+            },
+        ]);
 
-    if (item.modelfileID === "a1ee92554935007b10b3eb05") {
-        const data = PointsCalculator(
-            'Vehicle',
-            gltf.clone(),
-            new THREE.Vector3(...model.rotation)
-        );
-
-        if (!data || !data.points) return;
-
-        const vehicleEvent: VehicleEventSchema = {
-            modelUuid: item.modeluuid,
-            modelName: item.modelname,
-            position: item.position,
-            rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
-            state: "idle",
-            type: "vehicle",
-            speed: 1,
-            point: {
-                uuid: THREE.MathUtils.generateUUID(),
-                position: [data.points[0].x, data.points[0].y, data.points[0].z],
-                rotation: [0, 0, 0],
-                action: {
-                    actionUuid: THREE.MathUtils.generateUUID(),
-                    actionName: "Vehicle Action",
-                    actionType: "travel",
-                    unLoadDuration: 5,
-                    loadCapacity: 10,
-                    pickUpPoint: null,
-                    unLoadPoint: null,
-                    triggers: []
-                }
-            }
-        };
-        addEvent(vehicleEvent);
-    } else if (item.modelfileID === "7dc04e36882e4debbc1a8e3d") {
-        const data = PointsCalculator(
-            'Conveyor',
-            gltf.clone(),
-            new THREE.Vector3(...model.rotation)
-        );
-
-        if (!data || !data.points) return;
-
-        const ConveyorEvent: ConveyorEventSchema = {
-            modelUuid: item.modeluuid,
-            modelName: item.modelname,
-            position: item.position,
-            rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
-            state: "idle",
-            type: "transfer",
-            speed: 1,
-            points: data.points.map((point: THREE.Vector3, index: number) => ({
-                uuid: THREE.MathUtils.generateUUID(),
-                position: [point.x, point.y, point.z],
-                rotation: [0, 0, 0],
-                action: {
-                    actionUuid: THREE.MathUtils.generateUUID(),
-                    actionName: `Action ${index + 1}`,
-                    actionType: 'default',
-                    material: 'Default material',
-                    delay: 0,
-                    spawnInterval: 5,
-                    spawnCount: 1,
-                    triggers: []
-                }
-            }))
-        };
-        addEvent(ConveyorEvent);
-    } else if (item.modelfileID === "7dc04e36882e4debbc1a8e3d") {
-        // const data = PointsCalculator(
-        //     'Conveyor',
-        //     gltf.clone(),
-        //     new THREE.Vector3(...model.rotation)
-        // );
-
-        // if (!data || !data.points) return;
-
-        // const points: ConveyorPointSchema[] = data.points.map((point: THREE.Vector3, index: number) => {
-        //     const actionUuid = THREE.MathUtils.generateUUID();
-        //     return {
-        //         uuid: THREE.MathUtils.generateUUID(),
-        //         position: [point.x, point.y, point.z],
-        //         rotation: [0, 0, 0],
-        //         action: {
-        //             actionUuid,
-        //             actionName: `Action ${index}`,
-        //             actionType: 'default',
-        //             material: 'inherit',
-        //             delay: 0,
-        //             spawnInterval: 5,
-        //             spawnCount: 1,
-        //             triggers: []
-        //         }
-        //     };
-        // });
-
-        // points.forEach((point, index) => {
-        //     if (index < points.length - 1) {
-        //         const nextPoint = points[index + 1];
-        //         point.action.triggers.push({
-        //             triggerUuid: THREE.MathUtils.generateUUID(),
-        //             triggerName: `Trigger 1`,
-        //             triggerType: "onComplete",
-        //             delay: 0,
-        //             triggeredAsset: {
-        //                 triggeredModel: {
-        //                     modelName: item.modelname,
-        //                     modelUuid: item.modeluuid
-        //                 },
-        //                 triggeredPoint: {
-        //                     pointName: `Point ${index + 1}`,
-        //                     pointUuid: nextPoint.uuid
-        //                 },
-        //                 triggeredAction: {
-        //                     actionName: nextPoint.action.actionName,
-        //                     actionUuid: nextPoint.action.actionUuid
-        //                 }
-        //             }
-        //         });
-        //     }
-        // });
-
-        // const ConveyorEvent: ConveyorEventSchema = {
-        //     modelUuid: item.modeluuid,
-        //     modelName: item.modelname,
-        //     position: item.position,
-        //     rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
-        //     state: "idle",
-        //     type: "transfer",
-        //     speed: 1,
-        //     points
-        // };
-        // addEvent(ConveyorEvent);
-    } else if (item.modelfileID === "7dc04e36882e4debbc1a8e3d") {
-        const data = PointsCalculator(
-            'Conveyor',
-            gltf.clone(),
-            new THREE.Vector3(...model.rotation)
-        );
-
-        if (!data || !data.points) return;
-
-        const ConveyorEvent: ConveyorEventSchema = {
-            modelUuid: item.modeluuid,
-            modelName: item.modelname,
-            position: item.position,
-            rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
-            state: "idle",
-            type: "transfer",
-            speed: 1,
-            points: data.points.map((point: THREE.Vector3, index: number) => ({
-                uuid: THREE.MathUtils.generateUUID(),
-                position: [point.x, point.y, point.z],
-                rotation: [0, 0, 0],
-                action: {
-                    actionUuid: THREE.MathUtils.generateUUID(),
-                    actionName: `Action ${index}`,
-                    actionType: 'default',
-                    material: 'inherit',
-                    delay: 0,
-                    spawnInterval: 5,
-                    spawnCount: 1,
-                    triggers: []
-                }
-            }))
-        };
-        addEvent(ConveyorEvent);
-    } else if (item.modelfileID === "29dee78715ad5b853f5c346d") {
-        const data = PointsCalculator(
-            'StaticMachine',
-            gltf.clone(),
-            new THREE.Vector3(...model.rotation)
-        );
-
-        if (!data || !data.points) return;
-
-        const machineEvent: MachineEventSchema = {
-            modelUuid: item.modeluuid,
-            modelName: item.modelname,
-            position: item.position,
-            rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
-            state: "idle",
-            type: "machine",
-            point: {
-                uuid: THREE.MathUtils.generateUUID(),
-                position: [data.points[0].x, data.points[0].y, data.points[0].z],
-                rotation: [0, 0, 0],
-                action: {
-                    actionUuid: THREE.MathUtils.generateUUID(),
-                    actionName: "Process Action",
-                    actionType: "process",
-                    processTime: 10,
-                    swapMaterial: "material-id",
-                    triggers: []
-                }
-            }
-        };
-        addEvent(machineEvent);
-    } else if (item.modelfileID === "52e6681fbb743a890d96c914") {
-        const data = PointsCalculator(
-            'ArmBot',
-            gltf.clone(),
-            new THREE.Vector3(...model.rotation)
-        );
-
-        if (!data || !data.points) return;
-
-        const roboticArmEvent: RoboticArmEventSchema = {
-            modelUuid: item.modeluuid,
-            modelName: item.modelname,
-            position: item.position,
-            rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
-            state: "idle",
-            type: "roboticArm",
-            speed: 1,
-            point: {
-                uuid: THREE.MathUtils.generateUUID(),
-                position: [data.points[0].x, data.points[0].y, data.points[0].z],
-                rotation: [0, 0, 0],
-                actions: [
-                    {
+        if (item.eventData.type === "vehicle") {
+            const vehicleEvent: VehicleEventSchema = {
+                modelUuid: item.modeluuid,
+                modelName: item.modelname,
+                position: item.position,
+                rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
+                state: "idle",
+                type: "vehicle",
+                speed: 1,
+                point: {
+                    uuid: item.eventData.point?.uuid || THREE.MathUtils.generateUUID(),
+                    position: [item.eventData.point?.position[0] || 0, item.eventData.point?.position[1] || 0, item.eventData.point?.position[2] || 0],
+                    rotation: [item.eventData.point?.rotation[0] || 0, item.eventData.point?.rotation[1] || 0, item.eventData.point?.rotation[2] || 0],
+                    action: {
                         actionUuid: THREE.MathUtils.generateUUID(),
-                        actionName: "Pick and Place",
-                        actionType: "pickAndPlace",
-                        process: {
-                            startPoint: [0, 0, 0],
-                            endPoint: [0, 0, 0]
-                        },
+                        actionName: "Vehicle Action",
+                        actionType: "travel",
+                        unLoadDuration: 5,
+                        loadCapacity: 10,
+                        pickUpPoint: null,
+                        unLoadPoint: null,
                         triggers: []
                     }
-                ]
-            }
-        };
-        addEvent(roboticArmEvent);
+                }
+            };
+            addEvent(vehicleEvent);
+        } else if (item.eventData.type === "Conveyor") {
+            const ConveyorEvent: ConveyorEventSchema = {
+                modelUuid: item.modeluuid,
+                modelName: item.modelname,
+                position: item.position,
+                rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
+                state: "idle",
+                type: "transfer",
+                speed: 1,
+                points: item.eventData.points?.map((point: any, index: number) => ({
+                    uuid: point.uuid || THREE.MathUtils.generateUUID(),
+                    position: [point.position[0], point.position[1], point.position[2]],
+                    rotation: [point.rotation[0], point.rotation[1], point.rotation[2]],
+                    action: {
+                        actionUuid: THREE.MathUtils.generateUUID(),
+                        actionName: `Action ${index + 1}`,
+                        actionType: 'default',
+                        material: 'Default material',
+                        delay: 0,
+                        spawnInterval: 5,
+                        spawnCount: 1,
+                        triggers: []
+                    }
+                })) || [],
+            };
+            addEvent(ConveyorEvent);
+        } else if (item.eventData.type === "StaticMachine") {
+            const machineEvent: MachineEventSchema = {
+                modelUuid: item.modeluuid,
+                modelName: item.modelname,
+                position: item.position,
+                rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
+                state: "idle",
+                type: "machine",
+                point: {
+                    uuid: item.eventData.point?.uuid || THREE.MathUtils.generateUUID(),
+                    position: [item.eventData.point?.position[0] || 0, item.eventData.point?.position[1] || 0, item.eventData.point?.position[2] || 0],
+                    rotation: [item.eventData.point?.rotation[0] || 0, item.eventData.point?.rotation[1] || 0, item.eventData.point?.rotation[2] || 0],
+                    action: {
+                        actionUuid: THREE.MathUtils.generateUUID(),
+                        actionName: "Process Action",
+                        actionType: "process",
+                        processTime: 10,
+                        swapMaterial: "material-id",
+                        triggers: []
+                    }
+                }
+            };
+            addEvent(machineEvent);
+        } else if (item.eventData.type === "ArmBot") {
+            const roboticArmEvent: RoboticArmEventSchema = {
+                modelUuid: item.modeluuid,
+                modelName: item.modelname,
+                position: item.position,
+                rotation: [item.rotation.x, item.rotation.y, item.rotation.z],
+                state: "idle",
+                type: "roboticArm",
+                speed: 1,
+                point: {
+                    uuid: item.eventData.point?.uuid || THREE.MathUtils.generateUUID(),
+                    position: [item.eventData.point?.position[0] || 0, item.eventData.point?.position[1] || 0, item.eventData.point?.position[2] || 0],
+                    rotation: [item.eventData.point?.rotation[0] || 0, item.eventData.point?.rotation[1] || 0, item.eventData.point?.rotation[2] || 0],
+                    actions: [
+                        {
+                            actionUuid: THREE.MathUtils.generateUUID(),
+                            actionName: "Pick and Place",
+                            actionType: "pickAndPlace",
+                            process: {
+                                startPoint: [0, 0, 0],
+                                endPoint: [0, 0, 0]
+                            },
+                            triggers: []
+                        }
+                    ]
+                }
+            };
+            addEvent(roboticArmEvent);
+
+        }
+    } else {
+        setFloorItems((prevItems) => [
+            ...(prevItems || []),
+            {
+                modeluuid: item.modeluuid,
+                modelname: item.modelname,
+                position: item.position,
+                rotation: item.rotation,
+                modelfileID: item.modelfileID,
+                isLocked: item.isLocked,
+                isVisible: item.isVisible,
+            },
+        ]);
     }
 
     gsap.to(model.position, { y: item.position[1], duration: 1.5, ease: 'power2.out' });

app/src/modules/builder/geomentries/assets/addAssetModel.ts

@@ -164,18 +164,6 @@ async function handleModelLoad(
 
     // SOCKET
 
-    const data = {
-        organization,
-        modeluuid: newFloorItem.modeluuid,
-        modelname: newFloorItem.modelname,
-        modelfileID: newFloorItem.modelfileID,
-        position: newFloorItem.position,
-        rotation: { x: model.rotation.x, y: model.rotation.y, z: model.rotation.z },
-        isLocked: false,
-        isVisible: true,
-        socketId: socket.id
-    };
-
     if (selectedItem.type) {
         const data = PointsCalculator(
             selectedItem.type,
@@ -185,6 +173,10 @@ async function handleModelLoad(
 
         if (!data || !data.points) return;
 
+        const eventData: any = {
+            type: selectedItem.type,
+        };
+
         if (selectedItem.type === "Conveyor") {
             const ConveyorEvent: ConveyorEventSchema = {
                 modelUuid: newFloorItem.modeluuid,
@@ -209,8 +201,14 @@ async function handleModelLoad(
                         triggers: []
                     }
                 }))
-            }
+            };
             addEvent(ConveyorEvent);
+            eventData.points = ConveyorEvent.points.map(point => ({
+                uuid: point.uuid,
+                position: point.position,
+                rotation: point.rotation
+            }));
+
         } else if (selectedItem.type === "Vehicle") {
             const vehicleEvent: VehicleEventSchema = {
                 modelUuid: newFloorItem.modeluuid,
@@ -237,6 +235,12 @@ async function handleModelLoad(
                 }
             };
             addEvent(vehicleEvent);
+            eventData.point = {
+                uuid: vehicleEvent.point.uuid,
+                position: vehicleEvent.point.position,
+                rotation: vehicleEvent.point.rotation
+            };
+
         } else if (selectedItem.type === "ArmBot") {
             const roboticArmEvent: RoboticArmEventSchema = {
                 modelUuid: newFloorItem.modeluuid,
@@ -265,6 +269,13 @@ async function handleModelLoad(
                 }
             };
             addEvent(roboticArmEvent);
+            console.log('roboticArmEvent: ', roboticArmEvent);
+            eventData.point = {
+                uuid: roboticArmEvent.point.uuid,
+                position: roboticArmEvent.point.position,
+                rotation: roboticArmEvent.point.rotation
+            };
+
         } else if (selectedItem.type === "StaticMachine") {
             const machineEvent: MachineEventSchema = {
                 modelUuid: newFloorItem.modeluuid,
@@ -288,19 +299,65 @@ async function handleModelLoad(
                 }
             };
             addEvent(machineEvent);
+            eventData.point = {
+                uuid: machineEvent.point.uuid,
+                position: machineEvent.point.position,
+                rotation: machineEvent.point.rotation
+            };
         }
+
+        const completeData = {
+            organization,
+            modeluuid: newFloorItem.modeluuid,
+            modelname: newFloorItem.modelname,
+            modelfileID: newFloorItem.modelfileID,
+            position: newFloorItem.position,
+            rotation: { x: model.rotation.x, y: model.rotation.y, z: model.rotation.z },
+            isLocked: false,
+            isVisible: true,
+            socketId: socket.id,
+            eventData: eventData
+        };
+
+        model.userData.eventData = eventData;
+
+        newFloorItem.eventData = eventData;
+
+        setFloorItems((prevItems) => {
+            const updatedItems = [...(prevItems || []), newFloorItem];
+            localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
+            return updatedItems;
+        });
+
+        socket.emit("v2:model-asset:add", completeData);
+
+        gsap.to(model.position, { y: newFloorItem.position[1], duration: 1.5, ease: "power2.out" });
+        gsap.to(model.scale, { x: 1, y: 1, z: 1, duration: 1.5, ease: "power2.out", onComplete: () => { toast.success("Model Added!"); } });
+    } else {
+
+        const data = {
+            organization,
+            modeluuid: newFloorItem.modeluuid,
+            modelname: newFloorItem.modelname,
+            modelfileID: newFloorItem.modelfileID,
+            position: newFloorItem.position,
+            rotation: { x: model.rotation.x, y: model.rotation.y, z: model.rotation.z },
+            isLocked: false,
+            isVisible: true,
+            socketId: socket.id
+        };
+
+        setFloorItems((prevItems) => {
+            const updatedItems = [...(prevItems || []), newFloorItem];
+            localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
+            return updatedItems;
+        });
+
+        socket.emit("v2:model-asset:add", data);
+
+        gsap.to(model.position, { y: newFloorItem.position[1], duration: 1.5, ease: "power2.out" });
+        gsap.to(model.scale, { x: 1, y: 1, z: 1, duration: 1.5, ease: "power2.out", onComplete: () => { toast.success("Model Added!"); } });
     }
-
-    setFloorItems((prevItems) => {
-        const updatedItems = [...(prevItems || []), newFloorItem];
-        localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
-        return updatedItems;
-    });
-
-    socket.emit("v2:model-asset:add", data);
-
-    gsap.to(model.position, { y: newFloorItem.position[1], duration: 1.5, ease: "power2.out" });
-    gsap.to(model.scale, { x: 1, y: 1, z: 1, duration: 1.5, ease: "power2.out", onComplete: () => { toast.success("Model Added!"); } });
 }
 
 export default addAssetModel;

app/src/modules/builder/groups/floorItemsGroup.tsx

@@ -65,6 +65,7 @@ const FloorItemsGroup = ({ itemsGroup, hoveredDeletableFloorItem, AttachedObject
         };
 
         getFloorAssets(organization).then((data) => {
+            console.log('data: ', data);
             if (data.length > 0) {
                 const uniqueItems = (data as Types.FloorItems).filter((item, index, self) => index === self.findIndex((t) => t.modelfileID === item.modelfileID));
                 totalAssets = uniqueItems.length;