wip: fis ts chain ports assignation

Signed-off-by: Louis Greiner <[email protected]>

Author: louisgreiner

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

@@ -178,15 +178,16 @@ export class NodeService implements OnDestroy {
   initPortOrdering() {
     this.nodesStore.nodes.forEach((node) => {
       node.getPorts().forEach((port) => {
-        const oppositeNode = node.getOppositeNode(port.getTrainrunSection());
+        const oppositeExpandedNode = this.getOppositeExpandedNode(port.getTrainrunSection(), node);
         const portAlignments = VisAVisPortPlacement.placePortsOnSourceAndTargetNode(
           node,
-          oppositeNode,
+          oppositeExpandedNode,
         );
+        console.log(port, portAlignments);
         port.setPositionAlignment(portAlignments.sourcePortPlacement);
-        oppositeNode
+        oppositeExpandedNode
           .getPortOfTrainrunSection(port.getTrainrunSection().getId())
-          .setPositionAlignment(portAlignments.targetPortPlacement);
+          ?.setPositionAlignment(portAlignments.targetPortPlacement);
       });
 
       node.updateTransitionsAndConnections();
@@ -479,8 +480,15 @@ export class NodeService implements OnDestroy {
   }
 
   addPortsToNodes(sourceNodeId: number, targetNodeId: number, trainrunSection: TrainrunSection) {
-    const sourceNode = this.getNodeFromId(sourceNodeId);
-    const targetNode = this.getNodeFromId(targetNodeId);
+    const sourceNode = this.getOppositeExpandedNode(
+      trainrunSection,
+      this.getNodeFromId(targetNodeId),
+    );
+    const targetNode = this.getOppositeExpandedNode(
+      trainrunSection,
+      this.getNodeFromId(sourceNodeId),
+    );
+    // console.log(trainrunSection, sourceNode, targetNode);
     const portAlignments = VisAVisPortPlacement.placePortsOnSourceAndTargetNode(
       sourceNode,
       targetNode,
@@ -1128,6 +1136,30 @@ export class NodeService implements OnDestroy {
     return {minCoordX: minX, minCoordY: minY, maxCoordX: maxX, maxCoordY: maxY};
   }
 
+  getOppositeExpandedNode(trainrunSection: TrainrunSection, currentNode: Node): Node | undefined {
+    const groups = this.trainrunSectionService.groupTrainrunSectionsIntoChains(
+      this.trainrunSectionService.getAllTrainrunSectionsForTrainrun(
+        trainrunSection.getTrainrunId(),
+      ),
+    );
+    // keep only the groups which contain the given trainrun section
+    const filteredGroup = groups.find(
+      (group) => group.find((trs) => trs.getId() === trainrunSection.getId()) !== undefined,
+    );
+    if (filteredGroup === undefined) {
+      return undefined;
+    }
+    if (currentNode.getId() === trainrunSection.getSourceNodeId()) {
+      // get target node of the last trainrun section in the group
+      const lastTrainrunSection = filteredGroup.at(-1);
+      return this.getNodeFromId(lastTrainrunSection.getTargetNodeId());
+    } else {
+      // get source node of the first trainrun section in the group
+      const firstTrainrunSection = filteredGroup.at(0);
+      return this.getNodeFromId(firstTrainrunSection.getSourceNodeId());
+    }
+  }
+
   private deleteNodeWithoutUpdate(nodeId: number, enforceUpdate = true) {
     const node = this.getNodeFromId(nodeId);
     const connectedTrainrunSections = node.getConnectedTrainrunSections();
@@ -1152,17 +1184,20 @@ export class NodeService implements OnDestroy {
     node.setPosition(newPositionX, newPositionY);
     if (dragEnd) {
       node.getPorts().forEach((port) => {
-        const oppositeNode = node.getOppositeNode(port.getTrainrunSection());
+        const oppositeExpandedNode = this.getOppositeExpandedNode(port.getTrainrunSection(), node);
         const portAlignments = VisAVisPortPlacement.placePortsOnSourceAndTargetNode(
           node,
-          oppositeNode,
+          oppositeExpandedNode,
         );
         port.setPositionAlignment(portAlignments.sourcePortPlacement);
-        oppositeNode
+        oppositeExpandedNode
           .getPortOfTrainrunSection(port.getTrainrunSection().getId())
-          .setPositionAlignment(portAlignments.targetPortPlacement);
-        oppositeNode.updateTransitionsAndConnections();
-        this.trainrunSectionService.updateTrainrunSectionRouting(oppositeNode, enforceUpdate);
+          ?.setPositionAlignment(portAlignments.targetPortPlacement);
+        oppositeExpandedNode.updateTransitionsAndConnections();
+        this.trainrunSectionService.updateTrainrunSectionRouting(
+          oppositeExpandedNode,
+          enforceUpdate,
+        );
       });
       node.reorderAllPorts();
       this.operation.emit(new NodeOperation(OperationType.update, node));

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

@@ -976,14 +976,18 @@ export class TrainrunSectionService implements OnDestroy {
 
     node2.replaceTrainrunSectionOnPort(trainrunSection1, trainrunSection2);
 
+    const sourceExpandedNode = this.nodeService.getOppositeExpandedNode(trainrunSection1, node2);
+    const targetExpandedNode = this.nodeService.getOppositeExpandedNode(trainrunSection1, node1);
+
     trainrunSection1.setTargetNode(nodeIntermediate);
-    nodeIntermediate.addPortWithRespectToOppositeNode(node1, trainrunSection1);
-    node1.reAlignPortWithRespectToOppositeNode(nodeIntermediate, trainrunSection1);
+    node2.addPortWithRespectToOppositeNode(sourceExpandedNode, trainrunSection1);
+    node1.reAlignPortWithRespectToOppositeNode(targetExpandedNode, trainrunSection1);
+    // console.log(node1, node2);
 
     trainrunSection2.setSourceNode(nodeIntermediate);
     trainrunSection2.setTargetNode(node2);
-    nodeIntermediate.addPortWithRespectToOppositeNode(node2, trainrunSection2);
-    node2.reAlignPortWithRespectToOppositeNode(nodeIntermediate, trainrunSection2);
+    node1.addPortWithRespectToOppositeNode(targetExpandedNode, trainrunSection2);
+    node2.reAlignPortWithRespectToOppositeNode(sourceExpandedNode, trainrunSection2);
 
     this.reRouteAffectedTrainrunSections(node1.getId(), nodeIntermediate.getId());
     this.reRouteAffectedTrainrunSections(node2.getId(), nodeIntermediate.getId());