Merge remote-tracking branch 'origin/feature/layout-comparison-version' into dev-heatmap

app/src/modules/simulation/simulator/SimulationHandler.tsx

@@ -0,0 +1,177 @@
+import React, { useEffect } from 'react';
+import { useSceneContext } from '../../scene/sceneContext';
+import { determineExecutionMachineSequences } from './functions/determineExecutionMachineSequences';
+import { usePlayButtonStore } from '../../../store/ui/usePlayButtonStore';
+import { useSimulationManager } from '../../../store/rough/useSimulationManagerStore';
+import { useParams } from 'react-router-dom';
+
+interface SimulationUsageRecord {
+    activeTime: number;
+    isActive: boolean;
+    idleTime: number;
+    type:
+    | "roboticArm"
+    | "vehicle"
+    | "transfer"
+    | "storageUnit"
+    | "crane"
+    | "human"
+    | "machine";
+}
+
+// Product → holds multiple usage records
+interface ProductSimulation {
+    productId: string;
+    data: SimulationUsageRecord[];
+}
+
+// Version → holds multiple products
+interface VersionSimulation {
+    versionId: string;
+    products: ProductSimulation[];
+}
+
+// Project → holds multiple versions
+interface ProjectSimulation {
+    projectId: string | undefined;
+    versions: VersionSimulation[];
+}
+const SimulationHandler = () => {
+    const { materialStore, armBotStore, machineStore, conveyorStore, vehicleStore, storageUnitStore, productStore, craneStore, humanStore, versionStore } = useSceneContext();
+    const { armBots, getArmBotById } = armBotStore();
+    const { vehicles, getVehicleById } = vehicleStore();
+    const { getConveyorById } = conveyorStore();
+    const { materialHistory, materials } = materialStore();
+    const { getProductById, selectedProduct } = productStore();
+    const { machines, getMachineById } = machineStore();
+    const { getHumanById } = humanStore();
+    const { getCraneById, } = craneStore();
+    const { getStorageUnitById } = storageUnitStore();
+    const { isPlaying, setIsPlaying } = usePlayButtonStore();
+    const { simulationData, addData } = useSimulationManager();
+    const { projectId } = useParams();
+    const { selectedVersion } = versionStore();
+
+
+
+
+    useEffect(() => {
+        let checkTimer: ReturnType<typeof setTimeout>;
+        if (!projectId) return;
+        async function checkActiveMachines() {
+            const currentProduct = getProductById(selectedProduct.productUuid);
+            let hasActiveEntity = false;
+
+            if (currentProduct) {
+                const executionSequences = await determineExecutionMachineSequences([currentProduct]);
+                if (executionSequences?.length > 0) {
+                    executionSequences.forEach(sequence => {
+                        sequence.forEach(entity => {
+                            if (entity.type === 'roboticArm') {
+                                const roboticArm = getArmBotById(entity.modelUuid);
+                                if (roboticArm?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                            if (entity.type === 'vehicle') {
+                                const vehicle = getVehicleById(entity.modelUuid);
+                                if (vehicle?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                            if (entity.type === 'machine') {
+                                const machine = getMachineById(entity.modelUuid);
+                                if (machine?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                            if (entity.type === 'human') {
+                                const human = getHumanById(entity.modelUuid);
+                                if (human?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                            if (entity.type === 'crane') {
+                                const crane = getCraneById(entity.modelUuid);
+                                if (crane?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                            if (entity.type === 'storageUnit') {
+                                const storageUnit = getStorageUnitById(entity.modelUuid);
+                                if (storageUnit?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                            if (entity.type === "transfer") {
+                                const storageUnit = getConveyorById(entity.modelUuid);
+                                if (storageUnit?.isActive) {
+                                    hasActiveEntity = true;
+                                }
+                            }
+                        });
+                    });
+                }
+
+                if (materials.length === 0 && materialHistory.length >= 0 && !hasActiveEntity) {
+
+                    if (executionSequences?.length > 0) {
+                        executionSequences.forEach((sequence) => {
+                            sequence.forEach((entity) => {
+                                const typeToGetter: Record<string, (id: string) => any> = {
+                                    roboticArm: getArmBotById,
+                                    vehicle: getVehicleById,
+                                    machine: getMachineById,
+                                    human: getHumanById,
+                                    crane: getCraneById,
+                                    storageUnit: getStorageUnitById,
+                                    transfer: getConveyorById,
+                                };
+
+                                const getter = typeToGetter[entity.type];
+                                if (!getter) return; // skip unknown entity types
+
+                                const obj = getter(entity.modelUuid);
+                                if (!obj) return; // skip if not found
+
+                                addData(
+                                    projectId,
+                                    selectedVersion?.versionId || "",
+                                    selectedProduct?.productUuid,
+                                    {
+                                        activeTime: obj.activeTime ?? 0,
+                                        isActive: obj.isActive ?? false,
+                                        idleTime: obj.idleTime ?? 0,
+                                        type: entity.type as
+                                            | "roboticArm"
+                                            | "vehicle"
+                                            | "machine"
+                                            | "human"
+                                            | "crane"
+                                            | "storageUnit"
+                                            | "transfer",
+                                    }
+                                );
+                            });
+                        });
+                    }
+                    setIsPlaying(false);
+                }
+            }
+        }
+
+        if (isPlaying) {
+            checkTimer = setTimeout(() => {
+                checkActiveMachines();
+            }, 1500);
+        }
+
+        return () => {
+            if (checkTimer) clearTimeout(checkTimer);
+        };
+    }, [materials, materialHistory, selectedVersion, selectedProduct?.productUuid, isPlaying, armBots, vehicles, machines]);
+
+    return null;
+}
+
+export default SimulationHandler;

app/src/modules/simulation/simulator/simulator.tsx

@@ -3,6 +3,7 @@ import { useActionHandler } from "../actions/useActionHandler";
 import { usePlayButtonStore, useResetButtonStore } from "../../../store/ui/usePlayButtonStore";
 import { determineExecutionOrder } from "./functions/determineExecutionOrder";
 import { useSceneContext } from "../../scene/sceneContext";
+import SimulationHandler from "./SimulationHandler";
 
 function Simulator() {
     const { productStore } = useSceneContext();
@@ -24,7 +25,17 @@ function Simulator() {
         });
     }, [products, isPlaying, isReset, selectedProduct]);
 
-    return <></>;
+
+    return (
+
+        <>
+
+            {/* <simulationHandler/> */}
+            <SimulationHandler />
+
+        </>
+
+    );
 }
 
 export default Simulator;