Merge branch 'v2' into simulation-armbot-v2

app/src/components/layout/sidebarRight/properties/eventProperties/components/ActionsList.tsx

@@ -6,104 +6,44 @@ import {
 } from "../../../../../icons/ExportCommonIcons";
 import RenameInput from "../../../../../ui/inputs/RenameInput";
 import { handleResize } from "../../../../../../functions/handleResizePannel";
-import {
+import { useSelectedAction, useSelectedProduct } from "../../../../../../store/simulation/useSimulationStore";
-  useSelectedAction,
-  useSelectedEventData,
-  useSelectedProduct,
-} from "../../../../../../store/simulation/useSimulationStore";
-import { MathUtils } from "three";
 import { useProductStore } from "../../../../../../store/simulation/useProductStore";
+import { upsertProductOrEventApi } from "../../../../../../services/simulation/UpsertProductOrEventApi";
 
 interface ActionsListProps {
-  setSelectedPointData: (data: any) => void; // You can replace `any` with a more specific type if you have one
+    selectedPointData: any;
-  selectedPointData: any; // You can replace `any` with a more specific type if you have one
-  // ui control props
     multipleAction?: boolean;
+    handleAddAction?: () => void;
+    handleDeleteAction?: (actionUuid: string) => void;
 }
 
 const ActionsList: React.FC<ActionsListProps> = ({
-  setSelectedPointData,
     selectedPointData,
     multipleAction = false,
+    handleAddAction,
+    handleDeleteAction,
 }) => {
     const actionsContainerRef = useRef<HTMLDivElement>(null);
 
+    const email = localStorage.getItem('email')
+    const organization = (email!.split("@")[1]).split(".")[0];
+
     // store
-  const { selectedEventData } = useSelectedEventData();
+    const { renameAction } = useProductStore();
-  const { updateAction, addAction, removeAction } = useProductStore();
     const { selectedProduct } = useSelectedProduct();
-  const { selectedAction, setSelectedAction, clearSelectedAction } =
+    const { selectedAction, setSelectedAction } = useSelectedAction();
-    useSelectedAction();
-
-  const handleAddAction = () => {
-    if (!selectedEventData || !selectedPointData) return;
-
-    const newAction = {
-      actionUuid: MathUtils.generateUUID(),
-      actionName: `Action ${selectedPointData.actions.length + 1}`,
-      actionType: "pickAndPlace" as const,
-      process: {
-        startPoint: null,
-        endPoint: null,
-      },
-      triggers: [] as TriggerSchema[],
-    };
-
-    addAction(
-      selectedProduct.productId,
-      selectedEventData.data.modelUuid,
-      selectedEventData.selectedPoint,
-      newAction
-    );
-
-    const updatedPoint = {
-      ...selectedPointData,
-      actions: [...selectedPointData.actions, newAction],
-    };
-    setSelectedPointData(updatedPoint);
-    setSelectedAction(newAction.actionUuid, newAction.actionName);
-  };
-
-  const handleDeleteAction = (actionUuid: string) => {
-    if (!selectedPointData) return;
-
-    removeAction(actionUuid);
-    const newActions = selectedPointData.actions.filter(
-      (a: any) => a.actionUuid !== actionUuid
-    );
-
-    const updatedPoint = {
-      ...selectedPointData,
-      actions: newActions,
-    };
-    setSelectedPointData(updatedPoint);
-
-    if (selectedAction.actionId === actionUuid) {
-      if (newActions.length > 0) {
-        setSelectedAction(newActions[0].actionUuid, newActions[0].actionName);
-      } else {
-        clearSelectedAction();
-      }
-    }
-  };
 
     const handleRenameAction = (newName: string) => {
         if (!selectedAction.actionId) return;
-    updateAction(selectedAction.actionId, { actionName: newName });
+        const event = renameAction(selectedAction.actionId, newName);
 
-    if (selectedPointData?.actions) {
+        if (event) {
-      const updatedActions = selectedPointData.actions.map((action: any) =>
+            upsertProductOrEventApi({
-        action.actionUuid === selectedAction.actionId
+                productName: selectedProduct.productName,
-          ? { ...action, actionName: newName }
+                productId: selectedProduct.productId,
-          : action
+                organization: organization,
-      );
+                eventDatas: event
-      setSelectedPointData({
+            })
-        ...selectedPointData,
-        actions: updatedActions,
-      });
-    } else {
-      // write logic for single action
-      return;
         }
     };
 
@@ -119,7 +59,11 @@ const ActionsList: React.FC<ActionsListProps> = ({
 
                     <button
                         className="add-button"
-            onClick={() => handleAddAction()}
+                        onClick={() => {
+                            if (handleAddAction) {
+                                handleAddAction();
+                            }
+                        }}
                         disabled={!multipleAction}
                     >
                         <AddIcon /> Add
@@ -131,12 +75,11 @@ const ActionsList: React.FC<ActionsListProps> = ({
                     style={{ height: "120px" }}
                 >
                     <div className="list-container">
-            {multipleAction &&
+                        {multipleAction && selectedPointData &&
                             selectedPointData.actions.map((action: any) => (
                                 <div
                                     key={action.actionUuid}
-                  className={`list-item ${
+                                    className={`list-item ${selectedAction.actionId === action.actionUuid
-                    selectedAction.actionId === action.actionUuid
                                         ? "active"
                                         : ""
                                         }`}
@@ -149,13 +92,17 @@ const ActionsList: React.FC<ActionsListProps> = ({
                                     >
                                         <RenameInput
                                             value={action.actionName}
-                      onRename={handleRenameAction}
+                                            onRename={(value) => handleRenameAction(value)}
                                         />
                                     </button>
                                     {selectedPointData.actions.length > 1 && (
                                         <button
                                             className="remove-button"
-                      onClick={() => handleDeleteAction(action.actionUuid)}
+                                            onClick={() => {
+                                                if (handleDeleteAction) {
+                                                    handleDeleteAction(action.actionUuid);
+                                                }
+                                            }}
                                         >
                                             <RemoveIcon />
                                         </button>

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/conveyorMechanics.tsx

@@ -11,14 +11,18 @@ import Trigger from "../trigger/Trigger";
 import { useSelectedEventData, useSelectedProduct } from "../../../../../../store/simulation/useSimulationStore";
 import { useProductStore } from "../../../../../../store/simulation/useProductStore";
 import ActionsList from "../components/ActionsList";
+import { upsertProductOrEventApi } from "../../../../../../services/simulation/UpsertProductOrEventApi";
 
 function ConveyorMechanics() {
     const [activeOption, setActiveOption] = useState<"default" | "spawn" | "swap" | "delay" | "despawn">("default");
     const [selectedPointData, setSelectedPointData] = useState<ConveyorPointSchema | undefined>();
     const { selectedEventData } = useSelectedEventData();
-    const { getPointByUuid, updateEvent, updateAction } = useProductStore();
+    const { getPointByUuid, getEventByModelUuid, updateEvent, updateAction } = useProductStore();
     const { selectedProduct } = useSelectedProduct();
 
+    const email = localStorage.getItem('email')
+    const organization = (email!.split("@")[1]).split(".")[0];
+
     useEffect(() => {
         if (selectedEventData) {
             const point = getPointByUuid(
@@ -33,11 +37,34 @@ function ConveyorMechanics() {
         }
     }, [selectedProduct, selectedEventData, getPointByUuid]);
 
+    const updateBackend = (
+        productName: string,
+        productId: string,
+        organization: string,
+        eventData: EventsSchema
+    ) => {
+        upsertProductOrEventApi({
+            productName: productName,
+            productId: productId,
+            organization: organization,
+            eventDatas: eventData
+        })
+    }
+
     const handleSpeedChange = (value: string) => {
         if (!selectedEventData) return;
-        updateEvent(selectedProduct.productId, selectedEventData.data.modelUuid, {
+        const event = updateEvent(selectedProduct.productId, selectedEventData.data.modelUuid, {
             speed: parseFloat(value),
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleActionTypeChange = (option: string) => {
@@ -45,40 +72,94 @@ function ConveyorMechanics() {
         const validOption = option as | "default" | "spawn" | "swap" | "delay" | "despawn";
         setActiveOption(validOption);
 
-        updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedPointData.action.actionUuid, {
             actionType: validOption,
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleRenameAction = (newName: string) => {
-        if (!selectedPointData) return;
+        if (!selectedEventData || !selectedPointData) return;
-        updateAction(selectedPointData.action.actionUuid, { actionName: newName });
+        const event = updateAction(selectedPointData.action.actionUuid, { actionName: newName });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleSpawnCountChange = (value: string) => {
-        if (!selectedPointData) return;
+        if (!selectedEventData || !selectedPointData) return;
-        updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedPointData.action.actionUuid, {
             spawnCount: value === "inherit" ? "inherit" : parseFloat(value),
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleSpawnIntervalChange = (value: string) => {
-        if (!selectedPointData) return;
+        if (!selectedEventData || !selectedPointData) return;
-        updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedPointData.action.actionUuid, {
             spawnInterval: value === "inherit" ? "inherit" : parseFloat(value),
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleMaterialSelect = (material: string) => {
-        if (!selectedPointData) return;
+        if (!selectedEventData || !selectedPointData) return;
-        updateAction(selectedPointData.action.actionUuid, { material });
+        const event = updateAction(selectedPointData.action.actionUuid, { material });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleDelayChange = (value: string) => {
-        if (!selectedPointData) return;
+        if (!selectedEventData || !selectedPointData) return;
-        updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedPointData.action.actionUuid, {
             delay: value === "inherit" ? "inherit" : parseFloat(value),
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const availableActions = {
@@ -87,9 +168,9 @@ function ConveyorMechanics() {
     };
 
     // Get current values from store
-    const currentSpeed = selectedEventData?.data.type === "transfer"
+    const currentSpeed = (getEventByModelUuid(
-        ? selectedEventData.data.speed.toString()
+        selectedProduct.productId, selectedEventData?.data.modelUuid || ""
-        : "0.5";
+    ) as ConveyorEventSchema | undefined)?.speed?.toString() || "0.5";
 
     const currentActionName = selectedPointData
         ? selectedPointData.action.actionName
@@ -132,7 +213,6 @@ function ConveyorMechanics() {
             </div>
             <section>
                 <ActionsList
-                    setSelectedPointData={setSelectedPointData}
                     selectedPointData={selectedPointData}
                 />
 

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/machineMechanics.tsx

@@ -87,7 +87,6 @@ function MachineMechanics() {
                             />
                         </div>
                         <ActionsList
-                            setSelectedPointData={setSelectedPointData}
                             selectedPointData={selectedPointData}
                         />
                         <div className="selected-actions-list">

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/roboticArmMechanics.tsx

@@ -1,4 +1,5 @@
 import { useEffect, useState } from "react";
+import { MathUtils } from "three";
 import InputWithDropDown from "../../../../../ui/inputs/InputWithDropDown";
 import RenameInput from "../../../../../ui/inputs/RenameInput";
 import LabledDropdown from "../../../../../ui/inputs/LabledDropdown";
@@ -7,15 +8,19 @@ import { useSelectedEventData, useSelectedProduct, useSelectedAction } from "../
 import { useProductStore } from "../../../../../../store/simulation/useProductStore";
 import PickAndPlaceAction from "../actions/PickAndPlaceAction";
 import ActionsList from "../components/ActionsList";
+import { upsertProductOrEventApi } from "../../../../../../services/simulation/UpsertProductOrEventApi";
 
 function RoboticArmMechanics() {
     const [activeOption, setActiveOption] = useState<"default" | "pickAndPlace">("default");
     const [selectedPointData, setSelectedPointData] = useState<RoboticArmPointSchema | undefined>();
     const { selectedEventData } = useSelectedEventData();
-    const { getPointByUuid, updateEvent, updateAction } = useProductStore();
+    const { getPointByUuid, getEventByModelUuid, updateEvent, updateAction, addAction, removeAction } = useProductStore();
     const { selectedProduct } = useSelectedProduct();
     const { selectedAction, setSelectedAction, clearSelectedAction } = useSelectedAction();
 
+    const email = localStorage.getItem('email')
+    const organization = (email!.split("@")[1]).split(".")[0];
+
     useEffect(() => {
         if (selectedEventData) {
             const point = getPointByUuid(
@@ -38,9 +43,23 @@ function RoboticArmMechanics() {
         }
     }, [clearSelectedAction, getPointByUuid, selectedAction.actionId, selectedEventData, selectedProduct, setSelectedAction,]);
 
+    const updateBackend = (
+        productName: string,
+        productId: string,
+        organization: string,
+        eventData: EventsSchema
+    ) => {
+        upsertProductOrEventApi({
+            productName: productName,
+            productId: productId,
+            organization: organization,
+            eventDatas: eventData
+        })
+    }
+
     const handleRenameAction = (newName: string) => {
         if (!selectedAction.actionId) return;
-        updateAction(selectedAction.actionId, { actionName: newName });
+        const event = updateAction(selectedAction.actionId, { actionName: newName });
 
         if (selectedPointData) {
             const updatedActions = selectedPointData.actions.map((action) =>
@@ -51,37 +70,145 @@ function RoboticArmMechanics() {
                 actions: updatedActions,
             });
         }
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handleSpeedChange = (value: string) => {
         if (!selectedEventData) return;
-        updateEvent(selectedProduct.productId, selectedEventData.data.modelUuid, {
+        const event = updateEvent(selectedProduct.productId, selectedEventData.data.modelUuid, {
             speed: parseFloat(value),
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handlePickPointChange = (value: string) => {
         if (!selectedAction.actionId || !selectedPointData) return;
         const [x, y, z] = value.split(",").map(Number);
 
-        updateAction(selectedAction.actionId, {
+        const event = updateAction(selectedAction.actionId, {
             process: {
                 startPoint: [x, y, z] as [number, number, number],
                 endPoint: selectedPointData.actions.find((a) => a.actionUuid === selectedAction.actionId)?.process.endPoint || null,
             },
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
     };
 
     const handlePlacePointChange = (value: string) => {
         if (!selectedAction.actionId || !selectedPointData) return;
         const [x, y, z] = value.split(",").map(Number);
 
-        updateAction(selectedAction.actionId, {
+        const event = updateAction(selectedAction.actionId, {
             process: {
                 startPoint: selectedPointData.actions.find((a) => a.actionUuid === selectedAction.actionId)?.process.startPoint || null,
                 endPoint: [x, y, z] as [number, number, number],
             },
         });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+    };
+
+
+    const handleAddAction = () => {
+        if (!selectedEventData || !selectedPointData) return;
+
+        const newAction = {
+            actionUuid: MathUtils.generateUUID(),
+            actionName: `Action ${selectedPointData.actions.length + 1}`,
+            actionType: "pickAndPlace" as const,
+            process: {
+                startPoint: null,
+                endPoint: null,
+            },
+            triggers: [] as TriggerSchema[],
+        };
+
+        const event = addAction(
+            selectedProduct.productId,
+            selectedEventData.data.modelUuid,
+            selectedEventData.selectedPoint,
+            newAction
+        );
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+
+        const updatedPoint = {
+            ...selectedPointData,
+            actions: [...selectedPointData.actions, newAction],
+        };
+        setSelectedPointData(updatedPoint);
+        setSelectedAction(newAction.actionUuid, newAction.actionName);
+    };
+
+    const handleDeleteAction = (actionUuid: string) => {
+        if (!selectedPointData) return;
+
+        const event = removeAction(actionUuid);
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+
+        const newActions = selectedPointData.actions.filter(
+            (a: any) => a.actionUuid !== actionUuid
+        );
+
+        const updatedPoint = {
+            ...selectedPointData,
+            actions: newActions,
+        };
+        setSelectedPointData(updatedPoint);
+
+        if (selectedAction.actionId === actionUuid) {
+            if (newActions.length > 0) {
+                setSelectedAction(newActions[0].actionUuid, newActions[0].actionName);
+            } else {
+                clearSelectedAction();
+            }
+        }
     };
 
     const availableActions = {
@@ -89,9 +216,9 @@ function RoboticArmMechanics() {
         options: ["pickAndPlace"],
     };
 
-    const currentSpeed = selectedEventData?.data.type === "roboticArm"
+    const currentSpeed = (getEventByModelUuid(
-        ? selectedEventData.data.speed.toString()
+        selectedProduct.productId, selectedEventData?.data.modelUuid || ""
-        : "0.5";
+    ) as RoboticArmEventSchema | undefined)?.speed?.toString() || "0.5";
 
     const currentAction = selectedPointData?.actions.find((a) => a.actionUuid === selectedAction.actionId);
 
@@ -122,10 +249,12 @@ function RoboticArmMechanics() {
                 </div>
             </div>
             <section>
+
                 <ActionsList
-                    setSelectedPointData={setSelectedPointData}
                     selectedPointData={selectedPointData}
                     multipleAction
+                    handleAddAction={handleAddAction}
+                    handleDeleteAction={handleDeleteAction}
                 />
 
                 {selectedAction.actionId && currentAction && (

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/storageMechanics.tsx

@@ -69,7 +69,6 @@ function StorageMechanics() {
             {selectedEventData && (
                 <section>
                     <ActionsList
-                        setSelectedPointData={setSelectedPointData}
                         selectedPointData={selectedPointData}
                     />
                     <div className="selected-actions-details">

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/vehicleMechanics.tsx

@@ -12,14 +12,10 @@ import TravelAction from "../actions/TravelAction";
 import ActionsList from "../components/ActionsList";
 
 function VehicleMechanics() {
-  const [activeOption, setActiveOption] = useState<"default" | "travel">(
+    const [activeOption, setActiveOption] = useState<"default" | "travel">("default");
-    "default"
+    const [selectedPointData, setSelectedPointData] = useState<VehiclePointSchema | undefined>();
-  );
-  const [selectedPointData, setSelectedPointData] = useState<
-    VehiclePointSchema | undefined
-  >();
     const { selectedEventData } = useSelectedEventData();
-  const { getPointByUuid, updateEvent, updateAction } = useProductStore();
+    const { getPointByUuid, getEventByModelUuid, updateEvent, updateAction } = useProductStore();
     const { selectedProduct } = useSelectedProduct();
 
     useEffect(() => {
@@ -82,10 +78,10 @@ function VehicleMechanics() {
     };
 
     // Get current values from store
-  const currentSpeed =
+
-    selectedEventData?.data.type === "vehicle"
+    const currentSpeed = (getEventByModelUuid(
-      ? selectedEventData.data.speed.toString()
+        selectedProduct.productId, selectedEventData?.data.modelUuid || ""
-      : "0.5";
+    ) as VehicleEventSchema | undefined)?.speed?.toString() || "0.5";
 
     const currentActionName = selectedPointData
         ? selectedPointData.action.actionName
@@ -131,7 +127,6 @@ function VehicleMechanics() {
                     </div>
                     <section>
                         <ActionsList
-              setSelectedPointData={setSelectedPointData}
                             selectedPointData={selectedPointData}
                         />
                         <div className="selected-actions-details">

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

@@ -270,7 +270,6 @@ async function handleModelLoad(
                 }
             };
             addEvent(roboticArmEvent);
-            console.log('roboticArmEvent: ', roboticArmEvent);
             eventData.point = {
                 uuid: roboticArmEvent.point.uuid,
                 position: roboticArmEvent.point.position,

app/src/modules/scene/controls/selectionControls/copyPasteControls.tsx

@@ -6,6 +6,7 @@ import { toast } from "react-toastify";
 // import { setFloorItemApi } from '../../../../services/factoryBuilder/assest/floorAsset/setFloorItemApi';
 import * as Types from "../../../../types/world/worldTypes";
 import { detectModifierKeys } from "../../../../utils/shortcutkeys/detectModifierKeys";
+import { useEventsStore } from "../../../../store/simulation/useEventsStore";
 
 const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pastedObjects, setpastedObjects, selectionGroup, setDuplicatedObjects, movedObjects, setMovedObjects, rotatedObjects, setRotatedObjects, boundingBoxRef }: any) => {
     const { camera, controls, gl, scene, pointer, raycaster } = useThree();
@@ -13,7 +14,8 @@ const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pas
     const { selectedAssets, setSelectedAssets } = useSelectedAssets();
     const plane = useMemo(() => new THREE.Plane(new THREE.Vector3(0, 1, 0), 0), []);
     const { floorItems, setFloorItems } = useFloorItems();
-    const { socket } = useSocketStore()
+    const { socket } = useSocketStore();
+    const { addEvent } = useEventsStore();
 
     useEffect(() => {
         if (!camera || !scene || toggleView) return;
@@ -137,38 +139,6 @@ const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pas
 
             if (itemsGroupRef.current) {
 
-                let updatedEventData = null;
-                if (obj.userData.eventData) {
-                    updatedEventData = JSON.parse(JSON.stringify(obj.userData.eventData));
-
-                    updatedEventData.modelUuid = THREE.MathUtils.generateUUID();
-
-                    if (updatedEventData.type === "Conveyor" && updatedEventData.points) {
-                        updatedEventData.points = updatedEventData.points.map((point: any) => ({
-                            ...point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        }));
-                    }
-                    else if (updatedEventData.type === "Vehicle" && updatedEventData.point) {
-                        updatedEventData.point = {
-                            ...updatedEventData.point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        };
-                    }
-                    else if (updatedEventData.type === "ArmBot" && updatedEventData.point) {
-                        updatedEventData.point = {
-                            ...updatedEventData.point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        };
-                    }
-                    else if (updatedEventData.type === "StaticMachine" && updatedEventData.point) {
-                        updatedEventData.point = {
-                            ...updatedEventData.point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        };
-                    }
-                }
-
                 const newFloorItem: Types.FloorItemType = {
                     modelUuid: obj.uuid,
                     modelName: obj.userData.name,
@@ -177,9 +147,151 @@ const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pas
                     rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z, },
                     isLocked: false,
                     isVisible: true,
-                    eventData: updatedEventData
                 };
 
+                let updatedEventData = null;
+                if (obj.userData.eventData) {
+                    updatedEventData = JSON.parse(JSON.stringify(obj.userData.eventData));
+                    updatedEventData.modelUuid = newFloorItem.modelUuid;
+
+                    const eventData: any = {
+                        type: obj.userData.eventData.type,
+                    };
+
+                    if (obj.userData.eventData.type === "Conveyor") {
+                        const ConveyorEvent: ConveyorEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: 'transfer',
+                            speed: 1,
+                            points: updatedEventData.points.map((point: any, index: number) => ({
+                                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}`,
+                                    actionType: 'default',
+                                    material: 'Default Material',
+                                    delay: 0,
+                                    spawnInterval: 5,
+                                    spawnCount: 1,
+                                    triggers: []
+                                }
+                            }))
+                        };
+                        addEvent(ConveyorEvent);
+                        eventData.points = ConveyorEvent.points.map(point => ({
+                            uuid: point.uuid,
+                            position: point.position,
+                            rotation: point.rotation
+                        }));
+
+                    } else if (obj.userData.eventData.type === "Vehicle") {
+                        const vehicleEvent: VehicleEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: "vehicle",
+                            speed: 1,
+                            point: {
+                                uuid: THREE.MathUtils.generateUUID(),
+                                position: [updatedEventData.point.position[0], updatedEventData.point.position[1], updatedEventData.point.position[2]],
+                                rotation: [updatedEventData.point.rotation[0], updatedEventData.point.rotation[1], updatedEventData.point.rotation[2]],
+                                action: {
+                                    actionUuid: THREE.MathUtils.generateUUID(),
+                                    actionName: "Action 1",
+                                    actionType: "travel",
+                                    unLoadDuration: 5,
+                                    loadCapacity: 10,
+                                    steeringAngle: 0,
+                                    pickUpPoint: null,
+                                    unLoadPoint: null,
+                                    triggers: []
+                                }
+                            }
+                        };
+                        addEvent(vehicleEvent);
+                        eventData.point = {
+                            uuid: vehicleEvent.point.uuid,
+                            position: vehicleEvent.point.position,
+                            rotation: vehicleEvent.point.rotation
+                        };
+
+                    } else if (obj.userData.eventData.type === "ArmBot") {
+                        const roboticArmEvent: RoboticArmEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: "roboticArm",
+                            speed: 1,
+                            point: {
+                                uuid: THREE.MathUtils.generateUUID(),
+                                position: [updatedEventData.point.position[0], updatedEventData.point.position[1], updatedEventData.point.position[2]],
+                                rotation: [updatedEventData.point.rotation[0], updatedEventData.point.rotation[1], updatedEventData.point.rotation[2]],
+                                actions: [
+                                    {
+                                        actionUuid: THREE.MathUtils.generateUUID(),
+                                        actionName: "Action 1",
+                                        actionType: "pickAndPlace",
+                                        process: {
+                                            startPoint: null,
+                                            endPoint: null
+                                        },
+                                        triggers: []
+                                    }
+                                ]
+                            }
+                        };
+                        addEvent(roboticArmEvent);
+                        eventData.point = {
+                            uuid: roboticArmEvent.point.uuid,
+                            position: roboticArmEvent.point.position,
+                            rotation: roboticArmEvent.point.rotation
+                        };
+
+                    } else if (obj.userData.eventData.type === "StaticMachine") {
+                        const machineEvent: MachineEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: "machine",
+                            point: {
+                                uuid: THREE.MathUtils.generateUUID(),
+                                position: [updatedEventData.point.position[0], updatedEventData.point.position[1], updatedEventData.point.position[2]],
+                                rotation: [updatedEventData.point.rotation[0], updatedEventData.point.rotation[1], updatedEventData.point.rotation[2]],
+                                action: {
+                                    actionUuid: THREE.MathUtils.generateUUID(),
+                                    actionName: "Action 1",
+                                    actionType: "process",
+                                    processTime: 10,
+                                    swapMaterial: "Default Material",
+                                    triggers: []
+                                }
+                            }
+                        };
+                        addEvent(machineEvent);
+                        eventData.point = {
+                            uuid: machineEvent.point.uuid,
+                            position: machineEvent.point.position,
+                            rotation: machineEvent.point.rotation
+                        };
+                    }
+
+                    obj.userData.eventData = eventData;
+
+                    newFloorItem.eventData = eventData;
+
+
                     setFloorItems((prevItems: Types.FloorItems) => {
                         const updatedItems = [...(prevItems || []), newFloorItem];
                         localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
@@ -214,7 +326,7 @@ const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pas
                         isLocked: false,
                         isVisible: true,
                         socketId: socket.id,
-                    eventData: updatedEventData
+                        eventData: eventData,
                     };
 
                     socket.emit("v2:model-asset:add", data);
@@ -223,10 +335,57 @@ const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pas
                         name: newFloorItem.modelName,
                         modelId: newFloorItem.modelfileID,
                         modelUuid: newFloorItem.modelUuid,
-                    eventData: updatedEventData
                     };
 
                     itemsGroupRef.current.add(obj);
+
+                } else {
+                    setFloorItems((prevItems: Types.FloorItems) => {
+                        const updatedItems = [...(prevItems || []), newFloorItem];
+                        localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
+                        return updatedItems;
+                    });
+
+                    const email = localStorage.getItem("email");
+                    const organization = email ? email.split("@")[1].split(".")[0] : "default";
+
+                    //REST
+
+                    // await setFloorItemApi(
+                    //     organization,
+                    //     obj.uuid,
+                    //     obj.userData.name,
+                    //     [worldPosition.x, worldPosition.y, worldPosition.z],
+                    //     { "x": obj.rotation.x, "y": obj.rotation.y, "z": obj.rotation.z },
+                    //     obj.userData.modelId,
+                    //     false,
+                    //     true,
+                    // );
+
+                    //SOCKET
+
+                    const data = {
+                        organization,
+                        modelUuid: newFloorItem.modelUuid,
+                        modelName: newFloorItem.modelName,
+                        modelfileID: newFloorItem.modelfileID,
+                        position: newFloorItem.position,
+                        rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z },
+                        isLocked: false,
+                        isVisible: true,
+                        socketId: socket.id,
+                    };
+
+                    socket.emit("v2:model-asset:add", data);
+
+                    obj.userData = {
+                        name: newFloorItem.modelName,
+                        modelId: newFloorItem.modelfileID,
+                        modelUuid: newFloorItem.modelUuid,
+                    };
+
+                    itemsGroupRef.current.add(obj);
+                }
             }
         });
 

app/src/modules/scene/controls/selectionControls/duplicationControls.tsx

@@ -7,6 +7,7 @@ import { toast } from "react-toastify";
 import * as Types from "../../../../types/world/worldTypes";
 import { setFloorItemApi } from "../../../../services/factoryBuilder/assest/floorAsset/setFloorItemApi";
 import { detectModifierKeys } from "../../../../utils/shortcutkeys/detectModifierKeys";
+import { useEventsStore } from "../../../../store/simulation/useEventsStore";
 
 const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedObjects, setpastedObjects, selectionGroup, movedObjects, setMovedObjects, rotatedObjects, setRotatedObjects, boundingBoxRef }: any) => {
     const { camera, controls, gl, scene, pointer, raycaster } = useThree();
@@ -15,6 +16,7 @@ const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedOb
     const plane = useMemo(() => new THREE.Plane(new THREE.Vector3(0, 1, 0), 0), []);
     const { floorItems, setFloorItems } = useFloorItems();
     const { socket } = useSocketStore();
+    const { addEvent } = useEventsStore();
 
     useEffect(() => {
         if (!camera || !scene || toggleView) return;
@@ -115,38 +117,6 @@ const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedOb
 
             if (itemsGroupRef.current) {
 
-                let updatedEventData = null;
-                if (obj.userData.eventData) {
-                    updatedEventData = JSON.parse(JSON.stringify(obj.userData.eventData));
-
-                    updatedEventData.modelUuid = THREE.MathUtils.generateUUID();
-
-                    if (updatedEventData.type === "Conveyor" && updatedEventData.points) {
-                        updatedEventData.points = updatedEventData.points.map((point: any) => ({
-                            ...point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        }));
-                    }
-                    else if (updatedEventData.type === "Vehicle" && updatedEventData.point) {
-                        updatedEventData.point = {
-                            ...updatedEventData.point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        };
-                    }
-                    else if (updatedEventData.type === "ArmBot" && updatedEventData.point) {
-                        updatedEventData.point = {
-                            ...updatedEventData.point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        };
-                    }
-                    else if (updatedEventData.type === "StaticMachine" && updatedEventData.point) {
-                        updatedEventData.point = {
-                            ...updatedEventData.point,
-                            uuid: THREE.MathUtils.generateUUID()
-                        };
-                    }
-                }
-
                 const newFloorItem: Types.FloorItemType = {
                     modelUuid: obj.uuid,
                     modelName: obj.userData.name,
@@ -155,9 +125,151 @@ const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedOb
                     rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z, },
                     isLocked: false,
                     isVisible: true,
-                    eventData: updatedEventData
                 };
 
+                let updatedEventData = null;
+                if (obj.userData.eventData) {
+                    updatedEventData = JSON.parse(JSON.stringify(obj.userData.eventData));
+                    updatedEventData.modelUuid = newFloorItem.modelUuid;
+
+                    const eventData: any = {
+                        type: obj.userData.eventData.type,
+                    };
+
+                    if (obj.userData.eventData.type === "Conveyor") {
+                        const ConveyorEvent: ConveyorEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: 'transfer',
+                            speed: 1,
+                            points: updatedEventData.points.map((point: any, index: number) => ({
+                                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}`,
+                                    actionType: 'default',
+                                    material: 'Default Material',
+                                    delay: 0,
+                                    spawnInterval: 5,
+                                    spawnCount: 1,
+                                    triggers: []
+                                }
+                            }))
+                        };
+                        addEvent(ConveyorEvent);
+                        eventData.points = ConveyorEvent.points.map(point => ({
+                            uuid: point.uuid,
+                            position: point.position,
+                            rotation: point.rotation
+                        }));
+
+                    } else if (obj.userData.eventData.type === "Vehicle") {
+                        const vehicleEvent: VehicleEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: "vehicle",
+                            speed: 1,
+                            point: {
+                                uuid: THREE.MathUtils.generateUUID(),
+                                position: [updatedEventData.point.position[0], updatedEventData.point.position[1], updatedEventData.point.position[2]],
+                                rotation: [updatedEventData.point.rotation[0], updatedEventData.point.rotation[1], updatedEventData.point.rotation[2]],
+                                action: {
+                                    actionUuid: THREE.MathUtils.generateUUID(),
+                                    actionName: "Action 1",
+                                    actionType: "travel",
+                                    unLoadDuration: 5,
+                                    loadCapacity: 10,
+                                    steeringAngle: 0,
+                                    pickUpPoint: null,
+                                    unLoadPoint: null,
+                                    triggers: []
+                                }
+                            }
+                        };
+                        addEvent(vehicleEvent);
+                        eventData.point = {
+                            uuid: vehicleEvent.point.uuid,
+                            position: vehicleEvent.point.position,
+                            rotation: vehicleEvent.point.rotation
+                        };
+
+                    } else if (obj.userData.eventData.type === "ArmBot") {
+                        const roboticArmEvent: RoboticArmEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: "roboticArm",
+                            speed: 1,
+                            point: {
+                                uuid: THREE.MathUtils.generateUUID(),
+                                position: [updatedEventData.point.position[0], updatedEventData.point.position[1], updatedEventData.point.position[2]],
+                                rotation: [updatedEventData.point.rotation[0], updatedEventData.point.rotation[1], updatedEventData.point.rotation[2]],
+                                actions: [
+                                    {
+                                        actionUuid: THREE.MathUtils.generateUUID(),
+                                        actionName: "Action 1",
+                                        actionType: "pickAndPlace",
+                                        process: {
+                                            startPoint: null,
+                                            endPoint: null
+                                        },
+                                        triggers: []
+                                    }
+                                ]
+                            }
+                        };
+                        addEvent(roboticArmEvent);
+                        eventData.point = {
+                            uuid: roboticArmEvent.point.uuid,
+                            position: roboticArmEvent.point.position,
+                            rotation: roboticArmEvent.point.rotation
+                        };
+
+                    } else if (obj.userData.eventData.type === "StaticMachine") {
+                        const machineEvent: MachineEventSchema = {
+                            modelUuid: newFloorItem.modelUuid,
+                            modelName: newFloorItem.modelName,
+                            position: newFloorItem.position,
+                            rotation: [newFloorItem.rotation.x, newFloorItem.rotation.y, newFloorItem.rotation.z],
+                            state: "idle",
+                            type: "machine",
+                            point: {
+                                uuid: THREE.MathUtils.generateUUID(),
+                                position: [updatedEventData.point.position[0], updatedEventData.point.position[1], updatedEventData.point.position[2]],
+                                rotation: [updatedEventData.point.rotation[0], updatedEventData.point.rotation[1], updatedEventData.point.rotation[2]],
+                                action: {
+                                    actionUuid: THREE.MathUtils.generateUUID(),
+                                    actionName: "Action 1",
+                                    actionType: "process",
+                                    processTime: 10,
+                                    swapMaterial: "Default Material",
+                                    triggers: []
+                                }
+                            }
+                        };
+                        addEvent(machineEvent);
+                        eventData.point = {
+                            uuid: machineEvent.point.uuid,
+                            position: machineEvent.point.position,
+                            rotation: machineEvent.point.rotation
+                        };
+                    }
+
+                    obj.userData.eventData = eventData;
+
+                    newFloorItem.eventData = eventData;
+
+
                     setFloorItems((prevItems: Types.FloorItems) => {
                         const updatedItems = [...(prevItems || []), newFloorItem];
                         localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
@@ -192,7 +304,7 @@ const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedOb
                         isLocked: false,
                         isVisible: true,
                         socketId: socket.id,
-                    eventData: updatedEventData
+                        eventData: eventData,
                     };
 
                     socket.emit("v2:model-asset:add", data);
@@ -201,10 +313,57 @@ const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedOb
                         name: newFloorItem.modelName,
                         modelId: newFloorItem.modelfileID,
                         modelUuid: newFloorItem.modelUuid,
-                    eventData: updatedEventData
                     };
 
                     itemsGroupRef.current.add(obj);
+
+                } else {
+                    setFloorItems((prevItems: Types.FloorItems) => {
+                        const updatedItems = [...(prevItems || []), newFloorItem];
+                        localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
+                        return updatedItems;
+                    });
+
+                    const email = localStorage.getItem("email");
+                    const organization = email ? email.split("@")[1].split(".")[0] : "default";
+
+                    //REST
+
+                    // await setFloorItemApi(
+                    //     organization,
+                    //     obj.uuid,
+                    //     obj.userData.name,
+                    //     [worldPosition.x, worldPosition.y, worldPosition.z],
+                    //     { "x": obj.rotation.x, "y": obj.rotation.y, "z": obj.rotation.z },
+                    //     obj.userData.modelId,
+                    //     false,
+                    //     true,
+                    // );
+
+                    //SOCKET
+
+                    const data = {
+                        organization,
+                        modelUuid: newFloorItem.modelUuid,
+                        modelName: newFloorItem.modelName,
+                        modelfileID: newFloorItem.modelfileID,
+                        position: newFloorItem.position,
+                        rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z },
+                        isLocked: false,
+                        isVisible: true,
+                        socketId: socket.id,
+                    };
+
+                    socket.emit("v2:model-asset:add", data);
+
+                    obj.userData = {
+                        name: newFloorItem.modelName,
+                        modelId: newFloorItem.modelfileID,
+                        modelUuid: newFloorItem.modelUuid,
+                    };
+
+                    itemsGroupRef.current.add(obj);
+                }
             }
         });
 

app/src/modules/simulation/events/points/creator/pointsCreator.tsx

@@ -94,7 +94,7 @@ function PointsCreator() {
                                                 }}
                                                 onPointerMissed={() => {
                                                     if (selectedEventData?.data.type !== 'vehicle') {
-                                                        // clearSelectedEventSphere();
+                                                        clearSelectedEventSphere();
                                                     }
                                                     setTransformMode(null);
                                                 }}
@@ -123,7 +123,7 @@ function PointsCreator() {
                                                 );
                                             }}
                                             onPointerMissed={() => {
-                                                // clearSelectedEventSphere();
+                                                clearSelectedEventSphere();
                                                 setTransformMode(null);
                                             }}
                                             position={new THREE.Vector3(...event.point.position)}
@@ -149,7 +149,7 @@ function PointsCreator() {
                                                 );
                                             }}
                                             onPointerMissed={() => {
-                                                // clearSelectedEventSphere();
+                                                clearSelectedEventSphere();
                                                 setTransformMode(null);
                                             }}
                                             position={new THREE.Vector3(...event.point.position)}
@@ -175,7 +175,7 @@ function PointsCreator() {
                                                 );
                                             }}
                                             onPointerMissed={() => {
-                                                // clearSelectedEventSphere();
+                                                clearSelectedEventSphere();
                                                 setTransformMode(null);
                                             }}
                                             position={new THREE.Vector3(...event.point.position)}

app/src/store/simulation/useProductStore.ts

@@ -14,7 +14,7 @@ type ProductsStore = {
     addEvent: (productId: string, event: EventsSchema) => void;
     removeEvent: (productId: string, modelUuid: string) => void;
     deleteEvent: (modelUuid: string) => void;
-    updateEvent: (productId: string, modelUuid: string, updates: Partial<EventsSchema>) => void;
+    updateEvent: (productId: string, modelUuid: string, updates: Partial<EventsSchema>) => EventsSchema | undefined;
 
     // Point-level actions
     addPoint: (productId: string, modelUuid: string, point: ConveyorPointSchema | VehiclePointSchema | RoboticArmPointSchema | MachinePointSchema | StoragePointSchema) => void;
@@ -32,12 +32,12 @@ type ProductsStore = {
         modelUuid: string,
         pointUuid: string,
         action: ConveyorPointSchema['action'] | VehiclePointSchema['action'] | RoboticArmPointSchema['actions'][0] | MachinePointSchema['action'] | StoragePointSchema['action']
-    ) => void;
+    ) => EventsSchema | undefined;
-    removeAction: (actionUuid: string) => void;
+    removeAction: (actionUuid: string) => EventsSchema | undefined;
     updateAction: (
         actionUuid: string,
         updates: Partial<ConveyorPointSchema['action'] | VehiclePointSchema['action'] | RoboticArmPointSchema['actions'][0] | MachinePointSchema['action'] | StoragePointSchema['action']>
-    ) => void;
+    ) => EventsSchema | undefined;
 
     // Trigger-level actions
     addTrigger: (
@@ -52,7 +52,7 @@ type ProductsStore = {
 
     // Renaming functions
     renameProduct: (productId: string, newName: string) => void;
-    renameAction: (actionUuid: string, newName: string) => void;
+    renameAction: (actionUuid: string, newName: string) => EventsSchema | undefined;
     renameTrigger: (triggerUuid: string, newName: string) => void;
 
     // Helper functions
@@ -129,15 +129,18 @@ export const useProductStore = create<ProductsStore>()(
         },
 
         updateEvent: (productId, modelUuid, updates) => {
+            let updatedEvent: EventsSchema | undefined;
             set((state) => {
                 const product = state.products.find(p => p.productId === productId);
                 if (product) {
                     const event = product.eventDatas.find(e => 'modelUuid' in e && e.modelUuid === modelUuid);
                     if (event) {
                         Object.assign(event, updates);
+                        updatedEvent = JSON.parse(JSON.stringify(event));
                     }
                 }
             });
+            return updatedEvent;
         },
 
         // Point-level actions
@@ -188,6 +191,7 @@ export const useProductStore = create<ProductsStore>()(
 
         // Action-level actions
         addAction: (productId, modelUuid, pointUuid, action) => {
+            let updatedEvent: EventsSchema | undefined;
             set((state) => {
                 const product = state.products.find(p => p.productId === productId);
                 if (product) {
@@ -196,19 +200,24 @@ export const useProductStore = create<ProductsStore>()(
                         const point = (event as ConveyorEventSchema).points.find(p => p.uuid === pointUuid);
                         if (point) {
                             point.action = action as any;
+                            updatedEvent = JSON.parse(JSON.stringify(event));
                         }
                     } else if (event && 'point' in event && (event as any).point.uuid === pointUuid) {
                         if ('action' in (event as any).point) {
                             (event as any).point.action = action;
+                            updatedEvent = JSON.parse(JSON.stringify(event));
                         } else if ('actions' in (event as any).point) {
                             (event as any).point.actions.push(action);
+                            updatedEvent = JSON.parse(JSON.stringify(event));
                         }
                     }
                 }
             });
+            return updatedEvent;
         },
 
         removeAction: (actionUuid: string) => {
+            let updatedEvent: EventsSchema | undefined;
             set((state) => {
                 for (const product of state.products) {
                     for (const event of product.eventDatas) {
@@ -219,20 +228,28 @@ export const useProductStore = create<ProductsStore>()(
                         } else if ('point' in event) {
                             const point = (event as any).point;
                             if (event.type === "roboticArm") {
-                                // Handle RoboticArmEventSchema
                                 if ('actions' in point) {
-                                    point.actions = point.actions.filter((a: any) => a.actionUuid !== actionUuid);
+                                    const index = point.actions.findIndex((a: any) => a.actionUuid === actionUuid);
+                                    if (index !== -1) {
+                                        point.actions.splice(index, 1);
+                                        updatedEvent = JSON.parse(JSON.stringify(event));
+                                        return;
+                                    }
                                 }
                             } else if ('action' in point && point.action?.actionUuid === actionUuid) {
-                                // For other schemas with a single 'action'
+                                point.action = undefined;
+                                updatedEvent = JSON.parse(JSON.stringify(event));
+                                return;
                             }
                         }
                     }
                 }
             });
+            return updatedEvent;
         },
 
         updateAction: (actionUuid, updates) => {
+            let updatedEvent: EventsSchema | undefined;
             set((state) => {
                 for (const product of state.products) {
                     for (const event of product.eventDatas) {
@@ -240,6 +257,7 @@ export const useProductStore = create<ProductsStore>()(
                             for (const point of (event as ConveyorEventSchema).points) {
                                 if (point.action && point.action.actionUuid === actionUuid) {
                                     Object.assign(point.action, updates);
+                                    updatedEvent = JSON.parse(JSON.stringify(event));
                                     return;
                                 }
                             }
@@ -247,11 +265,13 @@ export const useProductStore = create<ProductsStore>()(
                             const point = (event as any).point;
                             if ('action' in point && point.action.actionUuid === actionUuid) {
                                 Object.assign(point.action, updates);
+                                updatedEvent = JSON.parse(JSON.stringify(event));
                                 return;
                             } else if ('actions' in point) {
                                 const action = point.actions.find((a: any) => a.actionUuid === actionUuid);
                                 if (action) {
                                     Object.assign(action, updates);
+                                    updatedEvent = JSON.parse(JSON.stringify(event));
                                     return;
                                 }
                             }
@@ -259,6 +279,7 @@ export const useProductStore = create<ProductsStore>()(
                     }
                 }
             });
+            return updatedEvent;
         },
 
         // Trigger-level actions
@@ -368,6 +389,7 @@ export const useProductStore = create<ProductsStore>()(
         },
 
         renameAction: (actionUuid, newName) => {
+            let updatedEvent: EventsSchema | undefined;
             set((state) => {
                 for (const product of state.products) {
                     for (const event of product.eventDatas) {
@@ -375,6 +397,7 @@ export const useProductStore = create<ProductsStore>()(
                             for (const point of (event as ConveyorEventSchema).points) {
                                 if (point.action && point.action.actionUuid === actionUuid) {
                                     point.action.actionName = newName;
+                                    updatedEvent = JSON.parse(JSON.stringify(event));
                                     return;
                                 }
                             }
@@ -382,11 +405,13 @@ export const useProductStore = create<ProductsStore>()(
                             const point = (event as any).point;
                             if ('action' in point && point.action.actionUuid === actionUuid) {
                                 point.action.actionName = newName;
+                                updatedEvent = JSON.parse(JSON.stringify(event));
                                 return;
                             } else if ('actions' in point) {
                                 const action = point.actions.find((a: any) => a.actionUuid === actionUuid);
                                 if (action) {
                                     action.actionName = newName;
+                                    updatedEvent = JSON.parse(JSON.stringify(event));
                                     return;
                                 }
                             }
@@ -394,6 +419,7 @@ export const useProductStore = create<ProductsStore>()(
                     }
                 }
             });
+            return updatedEvent;
         },
 
         renameTrigger: (triggerUuid, newName) => {