Added more detectors to DB

frontend/components/model/ModelViewer.tsx

@@ -145,11 +145,11 @@ const ModelViewer: React.FC<ModelViewerProps> = ({
     if (!isInitializedRef.current || isDisposedRef.current) {
       return
     }
-
-    // Check if modelPath is provided
-    if (!modelPath) {
+ 
+    if (!modelPath || modelPath.trim() === '') {
       console.warn('[ModelViewer] No model path provided')
-      onError?.('Путь к 3D модели не задан')
+      // Не вызываем onError для пустого пути - это нормальное состояние при инициализации
+      setIsLoading(false)
       return
     }
 
@@ -158,13 +158,24 @@ const ModelViewer: React.FC<ModelViewerProps> = ({
         return
       }
  
-      const oldMeshes = sceneRef.current.meshes.slice();
-      oldMeshes.forEach(m => m.dispose());
-
+      const currentModelPath = modelPath;
+      console.log('[ModelViewer] Starting model load:', currentModelPath);
+       
       setIsLoading(true)
       setLoadingProgress(0)
       setShowModel(false)
-      console.log('Loading GLTF model:', modelPath)
+      setModelReady(false)
+       
+      const oldMeshes = sceneRef.current.meshes.slice();
+      const activeCameraId = sceneRef.current.activeCamera?.uniqueId;
+      console.log('[ModelViewer] Cleaning up old meshes. Total:', oldMeshes.length);
+      oldMeshes.forEach(m => {
+        if (m.uniqueId !== activeCameraId) {
+          m.dispose();
+        }
+      });
+
+      console.log('[ModelViewer] Loading GLTF model:', currentModelPath)
       
       // UI элемент загрузчика (есть эффект замедленности)
       const progressInterval = setInterval(() => {
@@ -178,15 +189,44 @@ const ModelViewer: React.FC<ModelViewerProps> = ({
       }, 100)
       
       try {
-        const result = await ImportMeshAsync(modelPath, sceneRef.current)
- 
+        console.log('[ModelViewer] Calling ImportMeshAsync with path:', currentModelPath);
+        
+        // Проверим доступность файла через fetch
+        try {
+          const testResponse = await fetch(currentModelPath, { method: 'HEAD' });
+          console.log('[ModelViewer] File availability check:', {
+            url: currentModelPath,
+            status: testResponse.status,
+            statusText: testResponse.statusText,
+            ok: testResponse.ok
+          });
+        } catch (fetchError) {
+          console.error('[ModelViewer] File fetch error:', fetchError);
+        }
+        
+        const result = await ImportMeshAsync(currentModelPath, sceneRef.current)
+        console.log('[ModelViewer] ImportMeshAsync completed successfully');
+        console.log('[ModelViewer] Import result:', {
+          meshesCount: result.meshes.length,
+          particleSystemsCount: result.particleSystems.length,
+          skeletonsCount: result.skeletons.length,
+          animationGroupsCount: result.animationGroups.length
+        });
+  
+        if (isDisposedRef.current || modelPath !== currentModelPath) {
+          console.log('[ModelViewer] Model loading aborted - model changed during load')
+          clearInterval(progressInterval)
+          setIsLoading(false)
+          return;
+        }
+
         importedMeshesRef.current = result.meshes
 
         clearInterval(progressInterval)
         setLoadingProgress(100)
         
-        console.log('GLTF Model loaded successfully!')
-        console.log('ImportMeshAsync result:', result)
+        console.log('[ModelViewer] GLTF Model loaded successfully!', result)
+        
         if (result.meshes.length > 0) {
           
           const boundingBox = result.meshes[0].getHierarchyBoundingVectors()
@@ -210,9 +250,11 @@ const ModelViewer: React.FC<ModelViewerProps> = ({
 
           // Плавное появление модели
           setTimeout(() => {
-            if (!isDisposedRef.current) {
+            if (!isDisposedRef.current && modelPath === currentModelPath) {
               setShowModel(true)
               setIsLoading(false)
+            } else {
+              console.log('Model display aborted - model changed during animation')
             }
           }, 500)
         } else {
@@ -222,9 +264,14 @@ const ModelViewer: React.FC<ModelViewerProps> = ({
         }
       } catch (error) {
         clearInterval(progressInterval)
-        console.error('Error loading GLTF model:', error)
-        const errorMessage = error instanceof Error ? error.message : String(error)
-        onError?.(`Ошибка загрузки модели: ${errorMessage}`)
+        // Only report error if this loading is still relevant
+        if (!isDisposedRef.current && modelPath === currentModelPath) {
+          console.error('Error loading GLTF model:', error)
+          const errorMessage = error instanceof Error ? error.message : String(error)
+          onError?.(`Ошибка загрузки модели: ${errorMessage}`)
+        } else {
+          console.log('Error occurred but loading was aborted - model changed')
+        }
         setIsLoading(false)
       }
     }
@@ -271,9 +318,26 @@ const ModelViewer: React.FC<ModelViewerProps> = ({
       try {
         const meta: any = (m as any)?.metadata
         const extras: any = meta?.gltf?.extras ?? meta?.extras ?? (m as any)?.extras
+         
         const sid = extras?.Sensor_ID ?? extras?.sensor_id ?? extras?.SERIAL_NUMBER ?? extras?.serial_number
-        if (sid == null) return false
-        return String(sid).trim() === sensorId
+        if (sid != null) {
+          return String(sid).trim() === sensorId
+        }
+         
+        const monitoringSensorInstance = extras?.bonsaiPset_ARBM_PSet_MonitoringSensor_Instance
+        if (monitoringSensorInstance && typeof monitoringSensorInstance === 'string') {
+          try {
+            const parsedInstance = JSON.parse(monitoringSensorInstance)
+            const instanceSensorId = parsedInstance?.Sensor_ID
+            if (instanceSensorId != null) {
+              return String(instanceSensorId).trim() === sensorId
+            }
+          } catch (parseError) {
+            console.warn('[ModelViewer] Error parsing MonitoringSensor_Instance JSON:', parseError)
+          }
+        }
+        
+        return false
       } catch (error) {
         console.warn('[ModelViewer] Error matching sensor mesh:', error)
         return false