fix : calc without temporal dto changes + avoid manual handroll

Author: Math-R

src/app/services/data/trainrun.service.ts

@@ -17,7 +17,11 @@ import {DataService} from "./data.service";
 import {Node} from "../../models/node.model";
 import {TrainrunSection} from "../../models/trainrunsection.model";
 import {GeneralViewFunctions} from "../../view/util/generalViewFunctions";
-import {NonStopTrainrunIterator, TrainrunIterator} from "../util/trainrun.iterator";
+import {
+  NonStopTrainrunIterator,
+  TrainrunIterator,
+  ExpandedTrainrunIterator,
+} from "../util/trainrun.iterator";
 import {LogService} from "../../logger/log.service";
 import {LabelService} from "./label.service";
 import {FilterService} from "../ui/filter.service";
@@ -760,6 +764,10 @@ export class TrainrunService {
     return new NonStopTrainrunIterator(this.logService, node, trainrunSection);
   }
 
+  public getExpandedIterator(node: Node, trainrunSection: TrainrunSection) {
+    return new ExpandedTrainrunIterator(this.logService, node, trainrunSection);
+  }
+
   // For each trainrun, get iterator from the smallest consecutiveTime.
   public getRootIterators(): Map<number, TrainrunIterator> {
     const trainrunSections = this.trainrunSectionService.getTrainrunSections();

src/app/services/data/trainrunsection.service.ts

@@ -1472,19 +1472,16 @@ export class TrainrunSectionService implements OnDestroy {
 
   /**
    * Groups consecutive TrainrunSections that have collapsed nodes between them
-   * into chains with start and end nodes. Each chain starts and ends with a non-collapsed node.
+   * into chains. Each chain starts and ends with a non-collapsed node.
+   * Start and end nodes can be accessed via: sections[0].getSourceNode() and sections[sections.length - 1].getTargetNode()
    * @param trainrunSections List of TrainrunSections to group
-   * @returns Array of section groups with start/end nodes
+   * @returns Array of section chains
    */
   groupTrainrunSectionsIntoChains(trainrunSections: TrainrunSection[]): Array<{
     sections: TrainrunSection[];
-    startNode: Node;
-    endNode: Node;
   }> {
     const groups: Array<{
       sections: TrainrunSection[];
-      startNode: Node;
-      endNode: Node;
     }> = [];
     const visitedSections = new Set<number>();
 
@@ -1493,46 +1490,33 @@ export class TrainrunSectionService implements OnDestroy {
         return;
       }
 
-      // Start a new group from this section
+      // Build chain using TrainrunIterator to leverage existing graph traversal
       const chain: TrainrunSection[] = [];
-      let currentSection = section;
-
-      // Add the first section
-      chain.push(currentSection);
-      visitedSections.add(currentSection.getId());
-
-      // Look for consecutive sections with collapsed intermediate nodes
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        const targetNode = this.nodeService.getNodeFromId(currentSection.getTargetNodeId());
-        if (!targetNode || !targetNode.getIsCollapsed()) {
-          break; // End of chain if target node is not collapsed
+      const startNode = section.getSourceNode();
+      const iterator = this.trainrunService.getIterator(startNode, section);
+
+      // Traverse the trainrun and collect sections with collapsed intermediate nodes
+      while (iterator.hasNext()) {
+        const pair = iterator.next();
+
+        if (visitedSections.has(pair.trainrunSection.getId())) {
+          break; // Already processed this section
         }
 
-        // Find next section starting from this collapsed node
-        const nextSection = trainrunSections.find(
-          (ts) =>
-            ts.getSourceNodeId() === currentSection.getTargetNodeId() &&
-            ts.getTrainrunId() === currentSection.getTrainrunId() &&
-            !visitedSections.has(ts.getId()),
-        );
-        if (!nextSection) {
-          break; // No further section found, end of chain
+        chain.push(pair.trainrunSection);
+        visitedSections.add(pair.trainrunSection.getId());
+
+        // Stop if we reach a non-collapsed node (end of collapsed chain)
+        if (!pair.node.getIsCollapsed()) {
+          break;
         }
-        chain.push(nextSection);
-        visitedSections.add(nextSection.getId());
-        currentSection = nextSection;
       }
 
-      // Create group with start and end nodes
-      const startNode = this.nodeService.getNodeFromId(chain[0].getSourceNodeId());
-      const endNode = this.nodeService.getNodeFromId(chain[chain.length - 1].getTargetNodeId());
-
-      groups.push({
-        sections: chain,
-        startNode: startNode,
-        endNode: endNode,
-      });
+      if (chain.length > 0) {
+        groups.push({
+          sections: chain,
+        });
+      }
     });
 
     return groups;

src/app/services/util/trainrun.iterator.ts

@@ -84,3 +84,17 @@ export class NonStopTrainrunIterator extends TrainrunIterator {
     return super.next();
   }
 }
+
+export class ExpandedTrainrunIterator extends TrainrunIterator {
+  public next(): TrainrunSectionNodePair {
+    // Continue traversing only if the current node is collapsed
+    // Stop when we reach an expanded (non-collapsed) node
+    if (!this.pointerElement.node.getIsCollapsed()) {
+      // The trainrun has reached an expanded (non-collapsed) node and break the forward iteration
+      this.currentElement = Object.assign({}, this.pointerElement);
+      this.pointerElement = new TrainrunSectionNodePair(undefined, undefined);
+      return this.currentElement;
+    }
+    return super.next();
+  }
+}

src/app/view/editor-main-view/data-views/trainrunSectionViewObject.ts

@@ -156,6 +156,17 @@ export class TrainrunSectionViewObject {
     d.getPath().forEach((p) => {
       key += p.toString();
     });
+
+    // Include source and target node positions to detect when they move
+    key += "_SRC_" + d.getSourceNode().getPositionX() + "_" + d.getSourceNode().getPositionY();
+    key += "_TRG_" + d.getTargetNode().getPositionX() + "_" + d.getTargetNode().getPositionY();
+
+    // Disable cache for collapsed chains to ensure proper recalculation
+    // TODO: Optimize by including only relevant node positions
+    if (d.getSourceNode().getIsCollapsed() || d.getTargetNode().getIsCollapsed()) {
+      key += "_NOCACHE_" + Date.now();
+    }
+
     return key;
   }
 }