Merge remote-tracking branch 'origin/tills-branch' into tills-branch

static/mindmap.js

@@ -477,6 +477,9 @@ class MindMapVisualization {
       this.nodes = processed.nodes;
       this.links = processed.links;
       
+      // Verbindungszählungen aktualisieren
+      this.updateConnectionCounts();
+      
       // Visualisierung aktualisieren
       this.updateVisualization();
       
@@ -492,6 +495,9 @@ class MindMapVisualization {
       this.nodes = this.defaultNodes;
       this.links = this.defaultLinks;
       
+      // Verbindungszählungen auch für Fallback-Daten aktualisieren
+      this.updateConnectionCounts();
+      
       // Fehler anzeigen
       this.showError('Mindmap-Daten konnten nicht geladen werden. Verwende Standarddaten.');
       this.showFlash('Fehler beim Laden der Mindmap-Daten. Standarddaten werden angezeigt.', 'error');
@@ -936,7 +942,7 @@ class MindMapVisualization {
     // Highlights für verbundene Nodes und Links hinzufügen
     if (this.g) {
       // Verbundene Nodes identifizieren
-      const connectedNodes = this.getConnectedNodes(d);
+      const connectedNodes = this.getConnectedNodesById(d.id);
       const connectedNodeIds = connectedNodes.map(node => node.id);
       
       // Alle Nodes etwas transparenter machen
@@ -1035,7 +1041,7 @@ class MindMapVisualization {
     }
     // Falls ein Node ausgewählt ist, den Highlight-Status für diesen beibehalten
     else if (this.selectedNode && this.g) {
-      const connectedNodes = this.getConnectedNodes(this.selectedNode);
+      const connectedNodes = this.getConnectedNodesById(this.selectedNode.id);
       const connectedNodeIds = connectedNodes.map(node => node.id);
       
       // Alle Nodes auf den richtigen Highlight-Status setzen
@@ -1101,23 +1107,87 @@ class MindMapVisualization {
   
   // Findet alle verbundenen Knoten zu einem gegebenen Knoten
   getConnectedNodes(node) {
-    if (!this.links || !this.nodes) return [];
+    if (!this.links || !this.nodes || !node) return [];
+    
+    // Sicherstellen, dass der Knoten eine ID hat
+    const nodeId = node.id || node;
     
     return this.nodes.filter(n => 
-      this.links.some(link => 
-        (link.source.id === node.id && link.target.id === n.id) || 
-        (link.target.id === node.id && link.source.id === n.id)
-      )
+      this.links.some(link => {
+        const sourceId = link.source?.id || link.source;
+        const targetId = link.target?.id || link.target;
+        return (sourceId === nodeId && targetId === n.id) || 
+               (targetId === nodeId && sourceId === n.id);
+      })
     );
   }
   
   // Prüft, ob zwei Knoten verbunden sind
   isConnected(a, b) {
-    return this.links.some(link => 
-      (link.source.id === a.id && link.target.id === b.id) || 
-      (link.target.id === a.id && link.source.id === b.id)
+    if (!this.links || !a || !b) return false;
+    
+    // Sicherstellen, dass die Knoten IDs haben
+    const aId = a.id || a;
+    const bId = b.id || b;
+    
+    return this.links.some(link => {
+      const sourceId = link.source?.id || link.source;
+      const targetId = link.target?.id || link.target;
+      return (sourceId === aId && targetId === bId) || 
+             (targetId === aId && sourceId === bId);
+    });
+  }
+  
+  // Überprüft, ob ein Link zwischen zwei Knoten existiert
+  hasLink(source, target) {
+    if (!this.links || !source || !target) return false;
+    
+    // Sicherstellen, dass die Knoten IDs haben
+    const sourceId = source.id || source;
+    const targetId = target.id || target;
+    
+    return this.links.some(link => {
+      const linkSourceId = link.source?.id || link.source;
+      const linkTargetId = link.target?.id || link.target;
+      return (linkSourceId === sourceId && linkTargetId === targetId) || 
+             (linkTargetId === sourceId && linkSourceId === targetId);
+    });
+  }
+  
+  // Sicherere Methode zum Abrufen verbundener Knoten, die Prüfungen enthält
+  getConnectedNodesById(nodeId) {
+    if (!this.links || !this.nodes || !nodeId) return [];
+    
+    return this.nodes.filter(n => 
+      this.links.some(link => {
+        const sourceId = link.source.id || link.source;
+        const targetId = link.target.id || link.target;
+        return (sourceId === nodeId && targetId === n.id) || 
+               (targetId === nodeId && sourceId === n.id);
+      })
     );
   }
+
+  // Aktualisiert die Verbindungszählungen für alle Knoten
+  updateConnectionCounts() {
+    if (!this.nodes || !this.links) return;
+    
+    // Für jeden Knoten die Anzahl der Verbindungen berechnen
+    this.nodes.forEach(node => {
+      // Sichere Methode, um verbundene Knoten zu zählen
+      const connectedNodes = this.nodes.filter(n => 
+        n.id !== node.id && this.links.some(link => {
+          const sourceId = link.source.id || link.source;
+          const targetId = link.target.id || link.target;
+          return (sourceId === node.id && targetId === n.id) || 
+                 (targetId === node.id && sourceId === n.id);
+        })
+      );
+      
+      // Speichere die Anzahl als Eigenschaft des Knotens
+      node.connectionCount = connectedNodes.length;
+    });
+  }
   
   // Klick-Handler für Knoten
   nodeClicked(event, d) {