@enervance/insight-cim-model 0.0.140 → 0.0.141

package/dist/converter/integral7/dl-convert/dl-converter-i7-2.js

@@ -0,0 +1,2039 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLConverterI7 = void 0;
+const tslib_1 = require("tslib");
+const constants_1 = require("../model/dl-utils/constants.js");
+const util_functions_1 = require("../model/dl-utils/util-functions.js");
+const DiagramObject_1 = require("../../../model/diagram/DiagramObject.js");
+const convert_graph_keys_1 = require("./dl-graphs/convert-graph-keys.js");
+const Diagram_1 = require("../../../model/diagram/Diagram.js");
+const parser_utils_1 = require("../../../utils2/parser.utils.js");
+const OrientationKind_1 = require("../../../model/diagram/OrientationKind.js");
+const DiagramStyle_1 = require("../../../model/diagram/DiagramStyle.js");
+const common_utils_1 = require("../../../utils2/common.utils.js");
+const cim_constants_1 = require("../../../constants/cim-constants.js");
+const cim_model_graph_1 = require("./dl-graphs/cim-model-graph.js");
+const db_object_graph_1 = require("./dl-graphs/db-object-graph.js");
+const DiagramObjectPoint_1 = require("../../../model/diagram/DiagramObjectPoint.js");
+const utils_schema_1 = require("../utils-schema.js");
+const BusbarSection_1 = require("../../../model/wires/BusbarSection.js");
+class DLConverterI7 {
+    constructor(logger) {
+        this.exportedDiagramObjectsGraph = {};
+        this.logger = logger;
+        this.dbObjectGraph = new db_object_graph_1.DbObjectGraph(convert_graph_keys_1.i7SchemaKeyDefinitions);
+        this.dbObjectKeyCimModelUuidGraph = new cim_model_graph_1.DbObjectKey2CimModelUUIDGraph(convert_graph_keys_1.i7SchemaKeyDefinitions);
+        this.cimModelGraph = new cim_model_graph_1.CimModelGraph();
+        this.exportedTerminalUUIDs = new Set();
+        this.exportedBusbarSectionConnectivityNodeUuidToDiagramObject = new Map();
+    }
+    addExportedDiagramObjectToGraph(variantennr, netzId, diagramObject) {
+        var _a;
+        this.exportedDiagramObjectsGraph[variantennr] = (_a = this.exportedDiagramObjectsGraph[variantennr]) !== null && _a !== void 0 ? _a : {};
+        this.exportedDiagramObjectsGraph[variantennr][netzId] = diagramObject;
+    }
+    setDbObjectGraph(graph) {
+        this.dbObjectGraph = graph;
+    }
+    setCimModelGraph(graph) {
+        this.cimModelGraph = graph;
+    }
+    setDbObjectKeyCimModelUuidGraph(graph) {
+        this.dbObjectKeyCimModelUuidGraph = graph;
+    }
+    addCimObject(uuid, object, typeOfKey, dbKey) {
+        if (typeOfKey !== undefined && dbKey !== undefined)
+            this.dbObjectKeyCimModelUuidGraph.addRelation(typeOfKey, dbKey, uuid);
+        this.cimModelGraph.addUnspecifiedObject(uuid, object);
+    }
+    convertNsgVariante(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const diagram = new Diagram_1.Diagram((0, parser_utils_1.getUUID)(arg.guid), arg.name, String(arg.id));
+            diagram.orientation = OrientationKind_1.OrientationKind.negative;
+            diagram.diagramStyle = new DiagramStyle_1.DiagramStyle(common_utils_1.CommonUtils.generateUUID(), cim_constants_1.DiagramLayoutTypes.NODE_BREAKER);
+            return diagram;
+        });
+    }
+    convertSchemaStandort(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    convertSchemaKnotenStandort(nsgKnotenSo) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKnotenSo.variantennr, id: nsgKnotenSo.nsgso });
+            if (nsgStandort === undefined)
+                return null;
+            const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgKnotenSo.knotenso })) !== null && _b !== void 0 ? _b : undefined;
+            const diagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: nsgStandort.xrel + nsgKnotenSo.xrel + 16,
+                yPosition: nsgStandort.yrel + nsgKnotenSo.yrel + 16,
+                diagramObjectName: 'Abzweig',
+                identifiedObjectUUID: cimObjectUUID
+            });
+            // knotenso must be accesible via knotenzw-id
+            const netzSchlaufen = yield this.dbObjectGraph.findByAttributes(convert_graph_keys_1.i7TableNames.netz_schlaufe, {
+                eknoten: { in: [nsgKnotenSo.knotenso] }
+            });
+            if (netzSchlaufen && netzSchlaufen.length > 0) {
+                for (const netzSchlaufe of netzSchlaufen) {
+                    this.addExportedDiagramObjectToGraph(nsgKnotenSo.variantennr, netzSchlaufe.knotenzw, diagramObject);
+                }
+            }
+            this.addExportedDiagramObjectToGraph(nsgKnotenSo.variantennr, nsgKnotenSo.knotenso, diagramObject);
+            return diagramObject;
+        });
+    }
+    convertSchemaSchaltanlage(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    convertSchemaSchaltanlagenAbschnitte(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // const nsgSchaltanlage: NsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(
+            //   i7TableNames.nsg_nsgschaltanlage,
+            //   i7SchemaKeyNames.VariantenNrIdKey, { variantennr: arg.variantennr, id: arg.nsgsa }
+            // );
+            //
+            // nsgSchaltanlage.nsgSaabschnitt = nsgSchaltanlage.nsgSaabschnitt ?? [];
+            // nsgSchaltanlage.nsgSaabschnitt.push(arg);
+        });
+    }
+    // async convertSchemaSammelschienenAbschnitte(arg: NsgSchaltanlagenabschnitt) {
+    convertSchemaSammelschienenAbschnitte(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const netzSsabs = yield this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+                saabschnitt: arg.saabschnitt
+            });
+            const resultingDiagramObjects = [];
+            for (const netzSsab of netzSsabs) {
+                const diagramObjects = yield this.convertSchemaSammelschienenAbschnitt(arg, netzSsab);
+                if (diagramObjects) {
+                    resultingDiagramObjects.push(...diagramObjects);
+                }
+            }
+            return resultingDiagramObjects;
+        });
+    }
+    convertSchemaSammelschienenAbschnitt(nsgSaabschnitt, netzSsab) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (!nsgSchaltanlage)
+                return;
+            const leftUpperPointOfSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsab, nsgSaabschnitt.variantennr);
+            const length = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnitt);
+            const points = [];
+            let topLeft = new DiagramObjectPoint_1.DiagramObjectPoint();
+            let bottomRight = new DiagramObjectPoint_1.DiagramObjectPoint();
+            topLeft.xPosition = leftUpperPointOfSsab[0];
+            topLeft.yPosition = leftUpperPointOfSsab[1];
+            if (nsgSchaltanlage.ausrichtung % 2 === 0) {
+                bottomRight.xPosition = leftUpperPointOfSsab[0] + length * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                bottomRight.yPosition = leftUpperPointOfSsab[1];
+            }
+            else {
+                bottomRight.xPosition = leftUpperPointOfSsab[0];
+                bottomRight.yPosition = leftUpperPointOfSsab[1] + length * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            }
+            topLeft.sequenceNumber = 1;
+            bottomRight.sequenceNumber = 2;
+            points.push(topLeft, bottomRight);
+            const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: netzSsab.id })) !== null && _b !== void 0 ? _b : undefined;
+            const connectivityNode = this.cimModelGraph.findObjectByUUID(cimObjectUUID);
+            let busbarSection = null;
+            let busbarSectionTerminal = null;
+            for (const terminal of connectivityNode.terminals.values()) {
+                if (terminal.conductingEquipment instanceof BusbarSection_1.BusbarSection) {
+                    busbarSection = terminal.conductingEquipment;
+                    busbarSectionTerminal = terminal;
+                    break;
+                }
+            }
+            // compute the position for the ConnectivityNode (the center of the BusbarSection)
+            const centerPosition = [
+                (topLeft.xPosition + bottomRight.xPosition) / 2,
+                (topLeft.yPosition + bottomRight.yPosition) / 2
+            ];
+            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(centerPosition[0], centerPosition[1], null);
+            doConnectivityNode.name = `NetzSsab CN ${netzSsab.id}`;
+            doConnectivityNode.identifiedObjectUUID = cimObjectUUID;
+            this.addExportedDiagramObjectToGraph(nsgSaabschnitt.variantennr, netzSsab.id, doConnectivityNode);
+            if (busbarSection && busbarSectionTerminal) {
+                const doBusbarSection = new DiagramObject_1.DiagramObject(common_utils_1.CommonUtils.generateUUID(), `NetzSsab ${netzSsab.id}`);
+                doBusbarSection.identifiedObjectUUID = busbarSection.getUUID();
+                doBusbarSection.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                (0, utils_schema_1.copyDiagramObjectPoints)(doBusbarSection, points);
+                this.exportedTerminalUUIDs.add(busbarSectionTerminal.getUUID());
+                const doBusbarSectionTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[topLeft.xPosition, topLeft.yPosition], [...centerPosition]], null);
+                doBusbarSectionTerminal.identifiedObjectUUID = busbarSectionTerminal.getUUID();
+                return [doBusbarSection, doBusbarSectionTerminal, doConnectivityNode];
+            }
+            else {
+                return [doConnectivityNode];
+            }
+        });
+    }
+    convertSchemaSchaltfeldElemente(nsgSchaltfeld) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const resultingDiagramObjects = [];
+            // Es kann vorkommen, dass der Standort einer Sammelschiene bzw. einer Schaltanlage nicht eingeblendet ist.
+            // Dadurch wird die Sammelschiene bzw. die Schaltanlage nicht exportiert und deshalb existiert das Referenz-Objekt nsgSSAB nicht
+            // Das Schaltfeld kann somit ebenfalls nicht exportiert werden und wird übersprungen
+            const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+            if (!nsgSaabschnitt)
+                return;
+            const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (!nsgSchaltanlage)
+                return;
+            const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltanlage.nsgso });
+            if (!nsgStandort)
+                return;
+            const netzSsabs = yield this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+                saabschnitt: nsgSaabschnitt.saabschnitt
+            });
+            let bayOrientation = nsgSchaltanlage.ausrichtung;
+            if (nsgSchaltfeld.deltaausrichtung === 1) {
+                bayOrientation = (bayOrientation + 2) % 4;
+            }
+            const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+            let schaltfeldOffset;
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0:
+                case 1:
+                    schaltfeldOffset = nsgSchaltfeld.slotnummer * 16 + 8;
+                    break;
+                case 2:
+                case 3:
+                    schaltfeldOffset = (nsgSaabschnitt.laenge - nsgSchaltfeld.slotnummer - 1) * 16 + 8;
+                    break;
+            }
+            const schaltfeldNodes = yield this.getNodesOfSchaltfeld(nsgSchaltfeld);
+            const onSsabNodes = schaltfeldNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+            const onlySingleBusbarWithDisconnector = netzSsabs.length === 1 && schaltfeldNodes.length === 1;
+            const nodePointMap = new Map();
+            let lastSsabBeforeStackLeaving;
+            for (const onSsabNode of onSsabNodes) {
+                let position;
+                let netzSsab;
+                if (netzSsabsIds.has(onSsabNode.aknoten)) {
+                    netzSsab = netzSsabs.find(netzSsab => netzSsab.id === onSsabNode.aknoten);
+                    position = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsab, nsgSchaltfeld.variantennr);
+                }
+                else if (netzSsabsIds.has(onSsabNode.eknoten)) {
+                    netzSsab = netzSsabs.find(netzSsab => netzSsab.id === onSsabNode.eknoten);
+                    position = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsab, nsgSchaltfeld.variantennr);
+                }
+                if (lastSsabBeforeStackLeaving === undefined)
+                    lastSsabBeforeStackLeaving = netzSsab;
+                let rotationValue = null;
+                switch (bayOrientation) {
+                    case 0: // TOP
+                        rotationValue = 0;
+                        position[0] += schaltfeldOffset;
+                        if (onlySingleBusbarWithDisconnector)
+                            position[1] -= 8;
+                        break;
+                    case 1: // RIGHT
+                        rotationValue = 90;
+                        position[1] += schaltfeldOffset;
+                        if (onlySingleBusbarWithDisconnector)
+                            position[0] += 8;
+                        break;
+                    case 2: // BOTTOM
+                        rotationValue = 180;
+                        position[0] += schaltfeldOffset;
+                        if (onlySingleBusbarWithDisconnector)
+                            position[1] += 8;
+                        break;
+                    case 3: // LEFT
+                        rotationValue = 270;
+                        position[1] += schaltfeldOffset;
+                        if (onlySingleBusbarWithDisconnector)
+                            position[0] -= 8;
+                        break;
+                }
+                // ConductingEquipment
+                nodePointMap.set(onSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                // nodePointMap.set(
+                //   onSsabNode.aknoten,
+                //   DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], null)
+                // );
+            }
+            const leftUpperCornerOfBay = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+            const maxSsabPos = yield this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+            const startPositionOfStack = [0, 0];
+            switch (bayOrientation) {
+                case 0: // TOP
+                    startPositionOfStack[0] = leftUpperCornerOfBay[0] + 16;
+                    startPositionOfStack[1] = leftUpperCornerOfBay[1] + (nsgSchaltfeld.hoehe - (maxSsabPos + 1) * 8) + 4;
+                    break;
+                case 1: // RIGHT
+                    startPositionOfStack[0] = leftUpperCornerOfBay[0] + ((maxSsabPos + 1) * 8) - 4;
+                    startPositionOfStack[1] = leftUpperCornerOfBay[1] + 16;
+                    break;
+                case 2: // BOTTOM
+                    startPositionOfStack[0] = leftUpperCornerOfBay[0] + 16;
+                    startPositionOfStack[1] = leftUpperCornerOfBay[1] + ((maxSsabPos + 1) * 8) - 4;
+                    break;
+                case 3: // LEFT
+                    startPositionOfStack[0] = leftUpperCornerOfBay[0] + (nsgSchaltfeld.hoehe - (maxSsabPos + 1) * 8) + 4;
+                    startPositionOfStack[1] = leftUpperCornerOfBay[1] + 16;
+                    break;
+            }
+            let prevNode = onSsabNodes[0];
+            let crtNode = schaltfeldNodes.find(arg => arg.aknoten === onSsabNodes[0].eknoten);
+            let position = [...startPositionOfStack];
+            let connectivityNodePosition = [...startPositionOfStack];
+            let rotationValue = null;
+            while (crtNode !== undefined) {
+                switch (bayOrientation) {
+                    case 0: // TOP
+                        rotationValue = 0;
+                        position[1] -= 8;
+                        connectivityNodePosition[1] = position[1] + 4;
+                        break;
+                    case 1: // RIGHT
+                        rotationValue = 90;
+                        position[0] += 8;
+                        connectivityNodePosition[0] = position[0] - 4;
+                        break;
+                    case 2: // BOTTOM
+                        rotationValue = 180;
+                        position[1] += 8;
+                        connectivityNodePosition[1] = position[1] - 4;
+                        break;
+                    case 3: // LEFT
+                        rotationValue = 270;
+                        position[0] -= 8;
+                        connectivityNodePosition[0] = position[0] + 4;
+                        break;
+                }
+                nodePointMap.set(crtNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                nodePointMap.set(crtNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(connectivityNodePosition[0], connectivityNodePosition[1], null));
+                prevNode = crtNode;
+                crtNode = schaltfeldNodes.find(arg => arg.aknoten === crtNode.eknoten);
+            }
+            // BEGIN: Last ConnectivityNode
+            // Exportiere das ConnectivityNode/den Endpunkt des Schaltfeldes
+            if (prevNode !== undefined) {
+                switch (bayOrientation) {
+                    case 0: // TOP
+                        position[1] = leftUpperCornerOfBay[1];
+                        break;
+                    case 1: // RIGHT
+                        position[0] = leftUpperCornerOfBay[0] + nsgSchaltfeld.hoehe;
+                        break;
+                    case 2: // BOTTOM
+                        position[1] = leftUpperCornerOfBay[1] + nsgSchaltfeld.hoehe;
+                        break;
+                    case 3: // LEFT
+                        position[0] = leftUpperCornerOfBay[0];
+                        break;
+                }
+                nodePointMap.set(prevNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], null));
+                // END: Last ConnectivityNode
+            }
+            for (const nodePointEntry of nodePointMap.entries()) {
+                const key = nodePointEntry[0];
+                const value = nodePointEntry[1];
+                const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key })) !== null && _b !== void 0 ? _b : undefined;
+                value.identifiedObjectUUID = cimObjectUUID;
+                resultingDiagramObjects.push(value);
+                this.addExportedDiagramObjectToGraph(nsgSchaltfeld.variantennr, key, value);
+            }
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            for (const schaltfeldNode of schaltfeldNodes) {
+                let doBackwardConnectivityNode = nodePointMap.get(schaltfeldNode.aknoten);
+                if (netzSsabsIds.has(schaltfeldNode.aknoten)) {
+                    doBackwardConnectivityNode = this.exportedDiagramObjectsGraph[nsgSchaltfeld.variantennr][schaltfeldNode.aknoten];
+                }
+                const doConductingEquipment = nodePointMap.get(schaltfeldNode.id);
+                const doForwardConnectivityNode = nodePointMap.get(schaltfeldNode.eknoten);
+                const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                if (netzSsabsIds.has(schaltfeldNode.aknoten)) {
+                    switch (bayOrientation) {
+                        case 0: // TOP
+                        case 2: // BOTTOM
+                            dopBackwardConnectivityNode[0] = dopConductingEquipment[0];
+                            break;
+                        case 1: // RIGHT
+                        case 3: // LEFT
+                            dopBackwardConnectivityNode[1] = dopConductingEquipment[1];
+                            break;
+                    }
+                    const backwardTerminalUUID = this.lookupTerminalUUID(schaltfeldNode.aknoten, schaltfeldNode.id);
+                    if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                        this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                        const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopBackwardConnectivityNode], [...dopConductingEquipment]], null);
+                        terminalDiagramObject.identifiedObjectUUID = backwardTerminalUUID;
+                        resultingDiagramObjects.push(terminalDiagramObject);
+                    }
+                }
+                else {
+                    const backwardTerminalUUID = this.lookupTerminalUUID(schaltfeldNode.aknoten, schaltfeldNode.id);
+                    if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                        this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                        const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopBackwardConnectivityNode], [...dopConductingEquipment]], null);
+                        terminalDiagramObject.identifiedObjectUUID = backwardTerminalUUID;
+                        resultingDiagramObjects.push(terminalDiagramObject);
+                    }
+                }
+                const forwardTerminalUUID = this.lookupTerminalUUID(schaltfeldNode.eknoten, schaltfeldNode.id);
+                if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                    const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopForwardConnectivityNode], [...dopConductingEquipment]], null);
+                    terminalDiagramObject.identifiedObjectUUID = forwardTerminalUUID;
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+            return resultingDiagramObjects;
+        });
+    }
+    convertSchemaTransformer2W(nsgTrafo2w) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgTrafo2w.variantennr, id: nsgTrafo2w.nsgso }, false);
+            if (!nsgStandort)
+                return null;
+            const netzTrafo2W = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_trafo2w, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo2w.trafo2w });
+            if (!netzTrafo2W)
+                return;
+            const powerTransformerUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo2w.trafo2w })) !== null && _b !== void 0 ? _b : undefined;
+            let centerTransformer = [null, null];
+            let positionAnschlussanf = [null, null];
+            let positionAnschlussend = [null, null];
+            switch (nsgTrafo2w.ausrichtung) {
+                case 0: // (left) anschlussend <-00-> anschlussanf (right)
+                    centerTransformer[0] = 24;
+                    centerTransformer[1] = 16;
+                    positionAnschlussanf[0] = 48;
+                    positionAnschlussanf[1] = 16;
+                    positionAnschlussend[0] = 0;
+                    positionAnschlussend[1] = 16;
+                    break;
+                case 1: // (top) anschlussend <-00-> anschlussanf (bottom)
+                    centerTransformer[0] = 16;
+                    centerTransformer[1] = 24;
+                    positionAnschlussanf[0] = 16;
+                    positionAnschlussanf[1] = 48;
+                    positionAnschlussend[0] = 16;
+                    positionAnschlussend[1] = 0;
+                    break;
+                case 2: // (left) anschlussanf <-00-> anschlussend (right)
+                    centerTransformer[0] = 24;
+                    centerTransformer[1] = 16;
+                    positionAnschlussanf[0] = 0;
+                    positionAnschlussanf[1] = 16;
+                    positionAnschlussend[0] = 48;
+                    positionAnschlussend[1] = 16;
+                    break;
+                case 3: // (top) anschlussanf <-00-> anschlussend (bottom)
+                    centerTransformer[0] = 16;
+                    centerTransformer[1] = 24;
+                    positionAnschlussanf[0] = 16;
+                    positionAnschlussanf[1] = 0;
+                    positionAnschlussend[0] = 16;
+                    positionAnschlussend[1] = 48;
+                    break;
+            }
+            // rotation 0 means: <-00->
+            const powerTransformerDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: centerTransformer[0],
+                yPosition: centerTransformer[1],
+                rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnTrafo2W(nsgTrafo2w.ausrichtung),
+                diagramObjectName: `NetzTrafo ${netzTrafo2W.id}`,
+                identifiedObjectUUID: powerTransformerUUID
+            });
+            const createdDiagramObjects = [];
+            createdDiagramObjects.push(powerTransformerDiagramObject);
+            const terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: positionAnschlussanf[0],
+                yPosition: positionAnschlussanf[1],
+                rotation: null,
+                diagramObjectName: 'Terminal 1',
+                identifiedObjectUUID: netzTrafo2W.guid_w1
+            });
+            createdDiagramObjects.push(terminal1DiagramObject);
+            const terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: positionAnschlussend[0],
+                yPosition: positionAnschlussend[1],
+                rotation: null,
+                diagramObjectName: 'Terminal 2',
+                identifiedObjectUUID: netzTrafo2W.guid_w2
+            });
+            createdDiagramObjects.push(terminal2DiagramObject);
+            for (const diagramObject of createdDiagramObjects) {
+                for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                    diagramObjectPoint.xPosition += nsgTrafo2w.xrel;
+                    diagramObjectPoint.yPosition += nsgTrafo2w.yrel;
+                    diagramObjectPoint.xPosition += nsgStandort.xrel;
+                    diagramObjectPoint.yPosition += nsgStandort.yrel;
+                }
+            }
+            const doAKnotenConnectivityNode = this.exportedDiagramObjectsGraph[nsgTrafo2w.variantennr][netzTrafo2W.aknoten];
+            if (doAKnotenConnectivityNode) {
+                const dopAKnotenConnectivityNode = doAKnotenConnectivityNode.diagramObjectPoints[0];
+                util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal1DiagramObject, dopAKnotenConnectivityNode, true);
+            }
+            const doEKnotenConnectivityNode = this.exportedDiagramObjectsGraph[nsgTrafo2w.variantennr][netzTrafo2W.eknoten];
+            if (doEKnotenConnectivityNode) {
+                const dopEKnotenConnectivityNode = doEKnotenConnectivityNode.diagramObjectPoints[0];
+                util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal2DiagramObject, dopEKnotenConnectivityNode, true);
+            }
+            return createdDiagramObjects;
+        });
+    }
+    convertSchemaTransformer3W(nsgTrafo3w) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.nsgso }, false);
+            if (!nsgStandort)
+                return null;
+            const netzTrafo3w = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_trafo3w, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo3w.trafo3w });
+            if (!netzTrafo3w)
+                return null;
+            const powerTransformerUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo3w.trafo3w })) !== null && _b !== void 0 ? _b : undefined;
+            // Der relative Punkt des Transformators ist die linke obere Ecke bezogen auf die Bounding-Box
+            const trafoDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(constants_1.NsgConstants.TRAFO3W_WIDTH / 2, constants_1.NsgConstants.TRAFO3W_HEIGHT / 2);
+            const powerTransformerDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: trafoDiagramObject.diagramObjectPoints[0].xPosition,
+                yPosition: trafoDiagramObject.diagramObjectPoints[0].yPosition,
+                rotation: (360 - (constants_1.NsgConstants.TAFO3W_RotationOrder.indexOf(nsgTrafo3w.ausrichtung) * 30 + 180) % 360) % 360,
+                diagramObjectName: 'PowerTransformer',
+                identifiedObjectUUID: powerTransformerUUID
+            });
+            // Ermittle die Auswechslung der Enden
+            const exchangeGroups = constants_1.NsgConstants.TRAFO3W_ExchangeGroups;
+            let exchangeGroup = undefined;
+            for (const key of Object.keys(exchangeGroups)) {
+                if (exchangeGroups[key].indexOf(nsgTrafo3w.ausrichtung) !== -1) {
+                    exchangeGroup = constants_1.NsgConstants.TRAFO3W_ExchangeMap[key];
+                    break;
+                }
+            }
+            // Ermittle die 'default'-Positionen der Enden ohne Berücksichtigung der Auswechslungen
+            const rotationenGroups = constants_1.NsgConstants.TRAFO3W_RotationGroups;
+            let rotationenGroup = undefined;
+            for (const key of Object.keys(rotationenGroups)) {
+                if (rotationenGroups[key].indexOf(nsgTrafo3w.ausrichtung) !== -1) {
+                    rotationenGroup = constants_1.NsgConstants.TRAFO3W_RotationGroup2Positions[key];
+                    break;
+                }
+            }
+            // Falls eine x-Spiegelung vorliegt, tausche die Werte der Enden 2 und 3 miteinander
+            const xMirroring = nsgTrafo3w.orientierung_cw === 1;
+            const createdDiagramObjects = [];
+            createdDiagramObjects.push(powerTransformerDiagramObject);
+            const terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: rotationenGroup[exchangeGroup[1]][0],
+                yPosition: rotationenGroup[exchangeGroup[1]][1],
+                diagramObjectName: 'Terminal 1',
+                identifiedObjectUUID: netzTrafo3w.guid_w1
+            });
+            createdDiagramObjects.push(terminal1DiagramObject);
+            const terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: rotationenGroup[exchangeGroup[xMirroring ? 3 : 2]][0],
+                yPosition: rotationenGroup[exchangeGroup[xMirroring ? 3 : 2]][1],
+                diagramObjectName: 'Terminal 2',
+                identifiedObjectUUID: netzTrafo3w.guid_w2
+            });
+            createdDiagramObjects.push(terminal2DiagramObject);
+            const terminal3DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: rotationenGroup[exchangeGroup[xMirroring ? 2 : 3]][0],
+                yPosition: rotationenGroup[exchangeGroup[xMirroring ? 2 : 3]][1],
+                diagramObjectName: 'Terminal 3',
+                identifiedObjectUUID: netzTrafo3w.guid_w3
+            });
+            createdDiagramObjects.push(terminal3DiagramObject);
+            for (const diagramObject of createdDiagramObjects) {
+                for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                    diagramObjectPoint.xPosition += nsgTrafo3w.xrel;
+                    diagramObjectPoint.yPosition += nsgTrafo3w.yrel;
+                    diagramObjectPoint.xPosition += nsgStandort.xrel;
+                    diagramObjectPoint.yPosition += nsgStandort.yrel;
+                }
+            }
+            // if (nsgTrafo3w.orientierung_cw === 0) {
+            //   //      w1
+            //   //       0
+            //   // w2 <-0 0-> w3
+            const w1TypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.anschluss_w1
+            });
+            if (w1TypedResult) {
+                const w1ConnectivityNodePosition = yield this.getConnectivityNodePositionFor(w1TypedResult.type, w1TypedResult.object);
+                util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(terminal1DiagramObject, w1ConnectivityNodePosition, true);
+            }
+            const w2TypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.anschluss_w2
+            });
+            if (w2TypedResult) {
+                const w2ConnectivityNodePosition = yield this.getConnectivityNodePositionFor(w2TypedResult.type, w2TypedResult.object);
+                util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(terminal2DiagramObject, w2ConnectivityNodePosition, true);
+            }
+            const w3TypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.anschluss_w3
+            });
+            if (w3TypedResult) {
+                const w3ConnectivityNodePosition = yield this.getConnectivityNodePositionFor(w3TypedResult.type, w3TypedResult.object);
+                util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(terminal3DiagramObject, w3ConnectivityNodePosition, true);
+            }
+            return createdDiagramObjects;
+        });
+    }
+    getConnectivityNodePositionFor(i7ObjectType, object) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const leftUpperCorner = yield this.getLeftUpperCornerOf(i7ObjectType, object);
+            if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+                return [leftUpperCorner[0] + 16, leftUpperCorner[1] + 16];
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+                const nsgSchaltfeld = object;
+                const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+                if (!nsgSaabschnitt)
+                    return;
+                const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+                if (nsgSchaltanlage === undefined)
+                    return;
+                let orientation = nsgSchaltanlage.ausrichtung;
+                if (nsgSchaltfeld.deltaausrichtung === 1) {
+                    orientation = (orientation + 2) % 4;
+                }
+                switch (orientation) {
+                    case 0: // TOP
+                        return [leftUpperCorner[0] + 16, leftUpperCorner[1]];
+                    case 1: // RIGHT
+                        return [leftUpperCorner[0] + nsgSchaltfeld.hoehe, leftUpperCorner[1] + 16];
+                    case 2: // BOTTOM
+                        return [leftUpperCorner[0] + 16, leftUpperCorner[1] + nsgSchaltfeld.hoehe];
+                    case 3: // LEFT
+                        return [leftUpperCorner[0], leftUpperCorner[1] + 16];
+                }
+            }
+            return [null, null];
+        });
+    }
+    convertSchemaLeitung(nsgLeitung, splitLine = true) {
+        var _a, _b, _c, _d;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const netzLeitung = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_leitung, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung });
+            if (!netzLeitung)
+                return;
+            const nsgLtgpunkte = yield this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgltgpunkt, { nsgleitung: nsgLeitung.id });
+            // Manche Leitung beinhalten keine Zwischenpunkte, sondern verlaufen lediglich zwischen dem Start- und Endpunkt
+            // if (nsgLtgpunkte.length === 0) return;
+            const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung })) !== null && _b !== void 0 ? _b : undefined;
+            nsgLtgpunkte.sort((a, b) => a.pos - b.pos);
+            const diagramObject = new DiagramObject_1.DiagramObject();
+            diagramObject.name = `Leitung ${netzLeitung.id}`;
+            diagramObject.identifiedObjectUUID = cimObjectUUID;
+            diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+            diagramObject.rotation = null;
+            const relStartPos = yield this.getRelPos(nsgLeitung, true);
+            if (relStartPos === null)
+                return null;
+            const relEndPos = yield this.getRelPos(nsgLeitung, false);
+            if (relEndPos === null)
+                return null;
+            const leftUpperCornerStartPos = yield this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussanf);
+            const leftUpperCornerEndPos = yield this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussend);
+            for (let a = 0; a < nsgLtgpunkte.length; ++a) {
+                const nsgLtgpunkt = nsgLtgpunkte[a];
+                const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+                diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+                diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+                diagramObjectPoint.diagramObject = diagramObject;
+                if (nsgLtgpunkt.userelpos === 1) {
+                    if (nsgLtgpunkt.reltoanf === 1) {
+                        diagramObjectPoint.xPosition = leftUpperCornerStartPos[0] + nsgLtgpunkt.xrel;
+                        diagramObjectPoint.yPosition = leftUpperCornerStartPos[1] + nsgLtgpunkt.yrel;
+                    }
+                    else if (nsgLtgpunkt.reltoanf === 0) {
+                        diagramObjectPoint.xPosition = leftUpperCornerEndPos[0] + nsgLtgpunkt.xrel;
+                        diagramObjectPoint.yPosition = leftUpperCornerEndPos[1] + nsgLtgpunkt.yrel;
+                    }
+                }
+                else {
+                    diagramObjectPoint.xPosition = nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = nsgLtgpunkt.yrel;
+                }
+            }
+            /*
+            left:
+              m: => x
+              c: => y
+            right:
+              m: => x * (-1)
+              c: => y * (-1)
+            top:
+              m: => y
+              c: => x * (-1)
+            bottom:
+              m: => y * (-1)
+              c: => x
+             */
+            const firstDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+            firstDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+            firstDiagramObjectPoint.xPosition = relStartPos[0]; // + xyOffsetFirstPoint[0];
+            firstDiagramObjectPoint.yPosition = relStartPos[1]; // + xyOffsetFirstPoint[1];
+            firstDiagramObjectPoint.diagramObject = diagramObject;
+            diagramObject.diagramObjectPoints.unshift(firstDiagramObjectPoint);
+            const lastDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+            lastDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+            lastDiagramObjectPoint.xPosition = relEndPos[0]; // + xyOffsetLastPoint[0];
+            lastDiagramObjectPoint.yPosition = relEndPos[1]; // + xyOffsetLastPoint[1];
+            lastDiagramObjectPoint.diagramObject = diagramObject;
+            diagramObject.diagramObjectPoints.push(lastDiagramObjectPoint);
+            for (let a = 0; a < diagramObject.diagramObjectPoints.length; ++a) {
+                diagramObject.diagramObjectPoints[a].xPosition += 2;
+                diagramObject.diagramObjectPoints[a].yPosition += 2;
+                diagramObject.diagramObjectPoints[a].sequenceNumber = a + 1;
+            }
+            const resultingDiagramObjects = [];
+            const uuidsOfPlacedCimObject = new Set();
+            if (splitLine) {
+                /* ---------- ---------- ---------- */
+                // BEGIN: split the line into line segments
+                const netzLeitungsabschnitte = yield this.dbObjectGraph.findAllByAttributes([convert_graph_keys_1.i7TableNames.netz_freileitungabschnitt, convert_graph_keys_1.i7TableNames.netz_kabelabschnitt], { leitung: nsgLeitung.leitung });
+                netzLeitungsabschnitte.sort((a, b) => a.pos - b.pos);
+                const segmentPercentages = [];
+                let completeLength = 0;
+                for (let a = 0; a < netzLeitungsabschnitte.length; ++a) {
+                    completeLength += netzLeitungsabschnitte[a].laenge;
+                }
+                // Berechne die Prozent-Anteile eines Leitungsabschnittes bezogen auf die Gesamtlänge
+                let crtLength = 0;
+                for (let a = 0; a < netzLeitungsabschnitte.length; ++a) {
+                    // todo fix if 'laenge' is null (equals to a not-set length)
+                    crtLength += netzLeitungsabschnitte[a].laenge;
+                    segmentPercentages.push(crtLength / completeLength);
+                }
+                const segments = util_functions_1.DLUtilFunctions.splitLineIntoLineSegments(segmentPercentages, diagramObject.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition]));
+                for (let a = 0; a < segments.length; ++a) {
+                    const thisSegmentUUID = (_d = (_c = this.dbObjectKeyCimModelUuidGraph) === null || _c === void 0 ? void 0 : _c.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: netzLeitungsabschnitte[a].id })) !== null && _d !== void 0 ? _d : undefined;
+                    const thisSegmentCimObject = this.cimModelGraph.findObjectByUUID(thisSegmentUUID);
+                    const diagramObject = new DiagramObject_1.DiagramObject();
+                    diagramObject.name = `Leitung ${netzLeitung.id}`;
+                    diagramObject.identifiedObjectUUID = thisSegmentUUID;
+                    diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+                    diagramObject.rotation = null;
+                    // for (const segment of segments[a]) {
+                    for (const segmentPoint of segments[a]) {
+                        const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+                        diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+                        diagramObjectPoint.xPosition = segmentPoint[0];
+                        diagramObjectPoint.yPosition = segmentPoint[1];
+                        diagramObjectPoint.sequenceNumber = diagramObject.diagramObjectPoints.length + 1;
+                        diagramObjectPoint.diagramObject = diagramObject;
+                        diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+                    }
+                    // }
+                    resultingDiagramObjects.push(diagramObject);
+                    if (a === 0) {
+                        // continue (will be added at the end)
+                    }
+                    else {
+                        if (thisSegmentCimObject) {
+                            // need to get the ConnectivityNode and the Terminal, which connects the current (this) with the prev segment
+                            const prevSegment = netzLeitungsabschnitte[a - 1];
+                            const prevSegmentUUID = this.dbObjectKeyCimModelUuidGraph.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: prevSegment.id });
+                            const prevSegmentCimObject = this.cimModelGraph.findObjectByUUID(prevSegmentUUID);
+                            let connectivityNodeUUIDThisToPrev;
+                            let terminalUUIDThisToPrevConnectivityNode;
+                            for (const thisTerminal of thisSegmentCimObject.terminals.values()) {
+                                for (const prevTerminal of prevSegmentCimObject.terminals.values()) {
+                                    if (prevTerminal.getConnectivityNodeUUID() === thisTerminal.getConnectivityNodeUUID()) {
+                                        connectivityNodeUUIDThisToPrev = prevTerminal.getConnectivityNodeUUID();
+                                        terminalUUIDThisToPrevConnectivityNode = thisTerminal.getUUID();
+                                        break;
+                                    }
+                                }
+                                if (terminalUUIDThisToPrevConnectivityNode) {
+                                    break;
+                                }
+                            }
+                            // place the ConnectivityNode (if not being placed cause => maybe a previous iteration has placed it)
+                            if (!uuidsOfPlacedCimObject.has(connectivityNodeUUIDThisToPrev)) {
+                                const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                    xPosition: segments[a][0][0],
+                                    yPosition: segments[a][0][1],
+                                    diagramObjectName: `CN ${a} - Netz-Leitung ${netzLeitung.id}`,
+                                    identifiedObjectUUID: connectivityNodeUUIDThisToPrev
+                                });
+                                resultingDiagramObjects.push(doConnectivityNode);
+                            }
+                            // place the terminal
+                            const doTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                xPosition: segments[a][0][0],
+                                yPosition: segments[a][0][1],
+                                diagramObjectName: `T (Anf) ${a} - Netz-Leitung ${netzLeitung.id}`,
+                                identifiedObjectUUID: terminalUUIDThisToPrevConnectivityNode
+                            });
+                            resultingDiagramObjects.push(doTerminal);
+                            util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(doTerminal, segments[a][0], true);
+                        }
+                    }
+                    if (a === segments.length - 1) {
+                        // continue (will be added at the end)
+                    }
+                    else {
+                        if (thisSegmentCimObject) {
+                            // need to get the ConnectivityNode and the Terminal, which connects the current (this) with the next segment
+                            const nextSegment = netzLeitungsabschnitte[a + 1];
+                            const nextSegmentUUID = this.dbObjectKeyCimModelUuidGraph.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nextSegment.id });
+                            const nextSegmentCimObject = this.cimModelGraph.findObjectByUUID(nextSegmentUUID);
+                            let connectivityNodeUUIDThisToNext;
+                            let terminalUUIDThisToNextConnectivityNode;
+                            for (const thisTerminal of thisSegmentCimObject.terminals.values()) {
+                                for (const nextTerminal of nextSegmentCimObject.terminals.values()) {
+                                    if (nextTerminal.getConnectivityNodeUUID() === thisTerminal.getConnectivityNodeUUID()) {
+                                        connectivityNodeUUIDThisToNext = nextTerminal.getConnectivityNodeUUID();
+                                        terminalUUIDThisToNextConnectivityNode = thisTerminal.getUUID();
+                                        break;
+                                    }
+                                }
+                                if (terminalUUIDThisToNextConnectivityNode) {
+                                    break;
+                                }
+                            }
+                            // place the ConnectivityNode (if not being placed cause => maybe a previous iteration has placed it)
+                            if (!uuidsOfPlacedCimObject.has(connectivityNodeUUIDThisToNext)) {
+                                const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                    xPosition: segments[a][segments[a].length - 1][0],
+                                    yPosition: segments[a][segments[a].length - 1][1],
+                                    diagramObjectName: `CN ${a} - Netz-Leitung ${netzLeitung.id}`,
+                                    identifiedObjectUUID: connectivityNodeUUIDThisToNext
+                                });
+                                resultingDiagramObjects.push(doConnectivityNode);
+                            }
+                            // place the terminal
+                            const doTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                xPosition: segments[a][segments[a].length - 1][0],
+                                yPosition: segments[a][segments[a].length - 1][1],
+                                diagramObjectName: `T (End) ${a} - Netz-Leitung ${netzLeitung.id}`,
+                                identifiedObjectUUID: terminalUUIDThisToNextConnectivityNode
+                            });
+                            resultingDiagramObjects.push(doTerminal);
+                            util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(doTerminal, segments[a][segments[a].length - 1], true);
+                        }
+                    }
+                }
+                // END: split the line into line segments
+                /* ---------- ---------- ---------- */
+            }
+            else {
+                resultingDiagramObjects.push(diagramObject);
+            }
+            /* ---------- ---------- ---------- */
+            // BEGIN: export the first terminal
+            try {
+                const anschlussanfTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                    variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussanf
+                });
+                const aknotenTerminalUUID = this.lookupTerminalUUID(netzLeitung.aknoten, netzLeitung.id);
+                if (anschlussanfTypedResult && aknotenTerminalUUID) {
+                    const connectivityNodePosition = yield this.getConnectivityNodePositionFor(anschlussanfTypedResult.type, anschlussanfTypedResult.object);
+                    const anfTerminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: connectivityNodePosition[0],
+                        yPosition: connectivityNodePosition[1],
+                        diagramObjectName: 'Terminal Leitung-Anf',
+                        identifiedObjectUUID: aknotenTerminalUUID
+                    });
+                    resultingDiagramObjects.push(anfTerminalDiagramObject);
+                    util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(anfTerminalDiagramObject, connectivityNodePosition, true);
+                }
+                const anschlussendTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                    variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussend
+                });
+                const eknotenTerminalUUID = this.lookupTerminalUUID(netzLeitung.eknoten, netzLeitung.id);
+                if (anschlussendTypedResult && eknotenTerminalUUID) {
+                    const connectivityNodePosition = yield this.getConnectivityNodePositionFor(anschlussendTypedResult.type, anschlussendTypedResult.object);
+                    const endTerminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: connectivityNodePosition[0],
+                        yPosition: connectivityNodePosition[1],
+                        diagramObjectName: 'Terminal Leitung-End',
+                        identifiedObjectUUID: eknotenTerminalUUID
+                    });
+                    resultingDiagramObjects.push(endTerminalDiagramObject);
+                    util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(endTerminalDiagramObject, connectivityNodePosition, true);
+                }
+            }
+            catch (e) {
+                console.log(e);
+            }
+            // END: export the last terminal
+            /* ---------- ---------- ---------- */
+            return resultingDiagramObjects;
+        });
+    }
+    convertSchemaQuerzweig(nsgQuerzweig) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const resultingDiagramObjects = [];
+            const typedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgQuerzweig.variantennr, id: nsgQuerzweig.bezugsobjekt
+            });
+            if (!typedResult)
+                return null;
+            const { type, object } = typedResult;
+            let xPosition = nsgQuerzweig.xrel + 8;
+            let yPosition = nsgQuerzweig.yrel + 8;
+            const querzweigWrapperObject = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, {
+                id: nsgQuerzweig.querzweig
+            });
+            if (!querzweigWrapperObject)
+                return null;
+            const netzQuerzweig = querzweigWrapperObject.object;
+            if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+                const nsgSchaltfeld = object;
+                const leftUpperCornerOfSchaltfeld = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+                xPosition += leftUpperCornerOfSchaltfeld[0];
+                yPosition += leftUpperCornerOfSchaltfeld[1];
+            }
+            else {
+                return null;
+            }
+            const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgQuerzweig.querzweig })) !== null && _b !== void 0 ? _b : undefined;
+            const querzweigDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: xPosition,
+                yPosition: yPosition,
+                rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(nsgQuerzweig.ausrichtung),
+                diagramObjectName: `DiagramObject ${nsgQuerzweig.querzweig}`,
+                identifiedObjectUUID: cimObjectUUID
+            });
+            this.addExportedDiagramObjectToGraph(nsgQuerzweig.variantennr, nsgQuerzweig.querzweig, querzweigDiagramObject);
+            resultingDiagramObjects.push(querzweigDiagramObject);
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            const doBackwardConnectivityNode = this.exportedDiagramObjectsGraph[nsgQuerzweig.variantennr][netzQuerzweig.anschluss];
+            const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const dopConductingEquipment = querzweigDiagramObject.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const backwardTerminalUUID = this.lookupTerminalUUID(netzQuerzweig.anschluss, nsgQuerzweig.querzweig);
+            if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopBackwardConnectivityNode], [...dopConductingEquipment]], null);
+                terminalDiagramObject.identifiedObjectUUID = backwardTerminalUUID;
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+            return resultingDiagramObjects;
+        });
+    }
+    getRelPos(nsgLeitung, aknoten) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const netzLeitung = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_leitung, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung });
+            if (!netzLeitung)
+                return;
+            const idOfNsgKnoten = aknoten ? nsgLeitung.anschlussanf : nsgLeitung.anschlussend;
+            const typedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgLeitung.variantennr, id: idOfNsgKnoten
+            });
+            if (!typedResult)
+                return null;
+            const { type, object } = typedResult;
+            if (type === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+                const relPos = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgknotenso, object);
+                return [relPos[0] + 32 / 2 - 2, relPos[1] + 32 / 2 - 2];
+            }
+            else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+                const nsgSchaltfeld = object;
+                const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+                if (!nsgSaabschnitt)
+                    return;
+                const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+                if (nsgSchaltanlage === undefined)
+                    return;
+                const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltanlage.variantennr, id: nsgSchaltanlage.nsgso });
+                if (!nsgStandort)
+                    return;
+                let orientation = nsgSchaltanlage.ausrichtung;
+                if (nsgSchaltfeld.deltaausrichtung === 1) {
+                    orientation = (orientation + 2) % 4;
+                }
+                const relPos = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+                switch (orientation) {
+                    case 0: // TOP
+                        relPos[0] += 16;
+                        break;
+                    case 1: // RIGHT
+                        relPos[0] += nsgSchaltfeld.hoehe;
+                        relPos[1] += 16;
+                        break;
+                    case 2: // BOTTOM
+                        relPos[0] += 16;
+                        relPos[1] += nsgSchaltfeld.hoehe;
+                        break;
+                    case 3: // LEFT
+                        relPos[1] += 16;
+                        break;
+                }
+                relPos[0] -= 2;
+                relPos[1] -= 2;
+                return relPos;
+            }
+            return [];
+        });
+    }
+    convertSchemaKpfeld(nsgKpfeld) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const resultingDiagramObjects = [];
+            const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKpfeld.variantennr, id: nsgKpfeld.nsgsaa }, false);
+            if (!nsgSaabschnitt)
+                return;
+            const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKpfeld.variantennr, id: nsgSaabschnitt.nsgsa }, false);
+            if (!nsgSchaltanlage)
+                return;
+            const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKpfeld.variantennr, id: nsgSchaltanlage.nsgso }, false);
+            if (!nsgStandort)
+                return;
+            const netzSsabs = yield this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+                saabschnitt: nsgSaabschnitt.saabschnitt
+            });
+            let couplerOrientation = nsgSchaltanlage.ausrichtung;
+            if (nsgKpfeld.deltaausrichtung === 1) {
+                couplerOrientation = (couplerOrientation + 2) % 4;
+            }
+            const leftUpperCornerOfCoupler = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld, nsgKpfeld);
+            const kpfeldNodes = yield this.getNodesOfKpfeld(nsgKpfeld);
+            let containsLeistungsschalter = false;
+            let leistungsschalterNode = null;
+            for (const kpfeldNode of kpfeldNodes) {
+                if (!containsLeistungsschalter) {
+                    leistungsschalterNode = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_leistungsschalter, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: kpfeldNode.id }, false);
+                    if (leistungsschalterNode) {
+                        containsLeistungsschalter = true;
+                    }
+                }
+            }
+            const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+            const maxSsabPos = yield this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+            const nodePointMap = new Map();
+            if (containsLeistungsschalter) {
+                const onSsabNodes = kpfeldNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+                // first: place the disconnectors (and the connectivity nodes) on the busbar sections
+                for (const onSsabNode of onSsabNodes) {
+                    const idOfSsab = netzSsabsIds.has(onSsabNode.aknoten) ? onSsabNode.aknoten : onSsabNode.eknoten;
+                    const leftUpperCornerOfSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === idOfSsab), nsgKpfeld.variantennr);
+                    const nextNode = kpfeldNodes.find(arg => arg.aknoten === onSsabNode.eknoten);
+                    let rotationValue;
+                    let shiftOffset = 4;
+                    // um universalkupplungen korrekt zu platzieren, müssen die Disconnectoren untereinander platziert werden,
+                    // die auf den Leistungsschalter zeigen (bezogen auf aknoten)
+                    if (nextNode && (yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_leistungsschalter, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nextNode.id }, false))) {
+                        // on 'left' side
+                        shiftOffset = 4;
+                    }
+                    else {
+                        // on 'right' side
+                        shiftOffset = 28;
+                    }
+                    const position = [null, null];
+                    switch (couplerOrientation) {
+                        case 0: // TOP
+                            position[0] = leftUpperCornerOfCoupler[0] + shiftOffset;
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 0;
+                            break;
+                        case 1: // RIGHT
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = leftUpperCornerOfCoupler[1] + shiftOffset;
+                            rotationValue = 90;
+                            break;
+                        case 2: // BOTTOM
+                            position[0] = leftUpperCornerOfCoupler[0] + shiftOffset;
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 180;
+                            break;
+                        case 3: // LEFT
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = leftUpperCornerOfCoupler[1] + shiftOffset;
+                            rotationValue = 270;
+                            break;
+                    }
+                    nodePointMap.set(onSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(idOfSsab, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], null));
+                }
+                // Leistungsschalter noch platzieren
+                // const crtNode = leistungsschalterNode; //kpfeldNodes.find(arg => arg.aknoten === onSsabNodes[0].eknoten);
+                let rotationValue = null;
+                const position = [...leftUpperCornerOfCoupler];
+                const cn1Position = [...leftUpperCornerOfCoupler];
+                const cn2Position = [...leftUpperCornerOfCoupler];
+                switch (couplerOrientation) {
+                    case 0: // TOP
+                        position[0] += 16;
+                        position[1] = leftUpperCornerOfCoupler[1] + 4;
+                        rotationValue = 90;
+                        cn1Position[0] = leftUpperCornerOfCoupler[0] + 4;
+                        cn1Position[1] = position[1];
+                        cn2Position[0] = leftUpperCornerOfCoupler[0] + 28;
+                        cn2Position[1] = position[1];
+                        break;
+                    case 1: // RIGHT
+                        position[0] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[0] + 4;
+                        position[1] += 16;
+                        rotationValue = 180;
+                        cn1Position[0] = position[0];
+                        cn1Position[1] = leftUpperCornerOfCoupler[1] + 4;
+                        cn2Position[0] = position[0];
+                        cn2Position[1] = leftUpperCornerOfCoupler[1] + 28;
+                        break;
+                    case 2: // BOTTOM
+                        position[0] += 16;
+                        position[1] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[1] + 4;
+                        rotationValue = 90;
+                        cn1Position[0] = leftUpperCornerOfCoupler[0] + 4;
+                        cn1Position[1] = position[1];
+                        cn2Position[0] = leftUpperCornerOfCoupler[0] + 28;
+                        cn2Position[1] = position[1];
+                        break;
+                    case 3: // LEFT
+                        position[0] = leftUpperCornerOfCoupler[0] + 4;
+                        position[1] += 16;
+                        rotationValue = 180;
+                        cn1Position[0] = position[0];
+                        cn1Position[1] = leftUpperCornerOfCoupler[1] + 4;
+                        cn2Position[0] = position[0];
+                        cn2Position[1] = leftUpperCornerOfCoupler[1] + 28;
+                        break;
+                }
+                nodePointMap.set(leistungsschalterNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                nodePointMap.set(leistungsschalterNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn1Position[0], cn1Position[1], null));
+                nodePointMap.set(leistungsschalterNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn2Position[0], cn2Position[1], null));
+                /* ---------- ---------- ---------- */
+                // BEGIN: Terminal-Export
+                for (const kpfeldNode of kpfeldNodes) {
+                    const doBackwardConnectivityNode = nodePointMap.get(kpfeldNode.aknoten);
+                    const doConductingEquipment = nodePointMap.get(kpfeldNode.id);
+                    const doForwardConnectivityNode = nodePointMap.get(kpfeldNode.eknoten);
+                    const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                    const dopConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                    const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                    const backwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.aknoten, kpfeldNode.id);
+                    if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                        this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                        const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopBackwardConnectivityNode], [...dopConductingEquipment]], null);
+                        terminalDiagramObject.identifiedObjectUUID = backwardTerminalUUID;
+                        resultingDiagramObjects.push(terminalDiagramObject);
+                    }
+                    const forwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.eknoten, kpfeldNode.id);
+                    if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                        this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                        const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopForwardConnectivityNode], [...dopConductingEquipment]], null);
+                        terminalDiagramObject.identifiedObjectUUID = forwardTerminalUUID;
+                        resultingDiagramObjects.push(terminalDiagramObject);
+                    }
+                }
+                // END: Terminal-Export
+                /* ---------- ---------- ---------- */
+            }
+            else {
+                // case: cross-coupling without breaker
+                let prevNode;
+                let crtNode = kpfeldNodes.filter(elem => netzSsabsIds.has(elem.aknoten))[0];
+                const offsetValue = 32 / (kpfeldNodes.length + 1);
+                let rotationValue = null;
+                const positionFirstSsabNode = [0, 0];
+                const leftUpperPosOfAKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === crtNode.aknoten), nsgKpfeld.variantennr);
+                switch (couplerOrientation) {
+                    case 0: // TOP
+                        positionFirstSsabNode[0] = leftUpperCornerOfCoupler[0] + 4;
+                        positionFirstSsabNode[1] = leftUpperPosOfAKnotenSsab[1];
+                        break;
+                    case 1: // RIGHT
+                        positionFirstSsabNode[0] = leftUpperPosOfAKnotenSsab[0];
+                        positionFirstSsabNode[1] = leftUpperCornerOfCoupler[1] + 4;
+                        break;
+                    case 2: // BOTTOM
+                        positionFirstSsabNode[0] = leftUpperCornerOfCoupler[0] + 4;
+                        positionFirstSsabNode[1] = leftUpperPosOfAKnotenSsab[1];
+                        break;
+                    case 3: // LEFT
+                        positionFirstSsabNode[0] = leftUpperPosOfAKnotenSsab[0];
+                        positionFirstSsabNode[1] = leftUpperCornerOfCoupler[1] + 4;
+                        break;
+                }
+                nodePointMap.set(crtNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(positionFirstSsabNode[0], positionFirstSsabNode[1], null));
+                const position = [...leftUpperCornerOfCoupler];
+                while (crtNode !== undefined) {
+                    switch (couplerOrientation) {
+                        case 0: // TOP
+                            position[0] += offsetValue;
+                            position[1] = leftUpperCornerOfCoupler[1] + 4;
+                            rotationValue = 90;
+                            break;
+                        case 1: // RIGHT
+                            position[0] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[0] + 4;
+                            position[1] += offsetValue;
+                            rotationValue = 0;
+                            break;
+                        case 2: // BOTTOM
+                            position[0] += offsetValue;
+                            position[1] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[1] + 4;
+                            rotationValue = 90;
+                            break;
+                        case 3: // LEFT
+                            position[0] = leftUpperCornerOfCoupler[0] + 4;
+                            position[1] += offsetValue;
+                            rotationValue = 0;
+                            break;
+                    }
+                    nodePointMap.set(crtNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    const positionConnectivityNode = [...position];
+                    switch (couplerOrientation) {
+                        case 0: // TOP
+                            positionConnectivityNode[0] += (offsetValue / 2);
+                            break;
+                        case 1: // RIGHT
+                            positionConnectivityNode[1] += (offsetValue / 2);
+                            break;
+                        case 2: // BOTTOM
+                            positionConnectivityNode[0] += (offsetValue / 2);
+                            break;
+                        case 3: // LEFT
+                            positionConnectivityNode[1] += (offsetValue / 2);
+                            break;
+                    }
+                    nodePointMap.set(crtNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(positionConnectivityNode[0], positionConnectivityNode[1], null));
+                    prevNode = crtNode;
+                    crtNode = kpfeldNodes.find(arg => arg.aknoten === crtNode.eknoten);
+                }
+                // replace the last "ConnectivityNode"
+                const positionLastSsabNode = [0, 0];
+                const leftUpperPosOfEKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === prevNode.eknoten), nsgKpfeld.variantennr);
+                switch (couplerOrientation) {
+                    case 0: // TOP
+                        positionLastSsabNode[0] = leftUpperCornerOfCoupler[0] + 28;
+                        positionLastSsabNode[1] = leftUpperPosOfEKnotenSsab[1];
+                        break;
+                    case 1: // RIGHT
+                        positionLastSsabNode[0] = leftUpperPosOfEKnotenSsab[0];
+                        positionLastSsabNode[1] = leftUpperCornerOfCoupler[1] + 28;
+                        break;
+                    case 2: // BOTTOM
+                        positionLastSsabNode[0] = leftUpperCornerOfCoupler[0] + 28;
+                        positionLastSsabNode[1] = leftUpperPosOfEKnotenSsab[1];
+                        break;
+                    case 3: // LEFT
+                        positionLastSsabNode[0] = leftUpperPosOfEKnotenSsab[0];
+                        positionLastSsabNode[1] = leftUpperCornerOfCoupler[1] + 28;
+                        break;
+                }
+                nodePointMap.set(prevNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(positionLastSsabNode[0], positionLastSsabNode[1], null));
+                /* ---------- ---------- ---------- */
+                // BEGIN: Terminal-Export
+                for (const kpfeldNode of kpfeldNodes) {
+                    const doBackwardConnectivityNode = nodePointMap.get(kpfeldNode.aknoten);
+                    const doConductingEquipment = nodePointMap.get(kpfeldNode.id);
+                    const doForwardConnectivityNode = nodePointMap.get(kpfeldNode.eknoten);
+                    const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                    const dopConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                    const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                    let backwardTerminalPoints;
+                    if (netzSsabsIds.has(kpfeldNode.aknoten)) {
+                        // insert a bend node
+                        const bendNode = [null, null];
+                        switch (couplerOrientation) {
+                            case 0: // TOP
+                            case 2: // BOTTOM
+                                bendNode[0] = dopBackwardConnectivityNode[0];
+                                bendNode[1] = dopConductingEquipment[1];
+                                break;
+                            case 1: // RIGHT
+                            case 3: // LEFT
+                                bendNode[0] = dopConductingEquipment[0];
+                                bendNode[1] = dopBackwardConnectivityNode[1];
+                                break;
+                        }
+                        backwardTerminalPoints = [[...dopBackwardConnectivityNode], bendNode, [...dopConductingEquipment]];
+                    }
+                    else {
+                        backwardTerminalPoints = [[...dopBackwardConnectivityNode], [...dopConductingEquipment]];
+                    }
+                    const backwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.aknoten, kpfeldNode.id);
+                    if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                        this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                        const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints(backwardTerminalPoints, null);
+                        terminalDiagramObject.identifiedObjectUUID = backwardTerminalUUID;
+                        resultingDiagramObjects.push(terminalDiagramObject);
+                    }
+                    let forwardTerminalPoints;
+                    if (netzSsabsIds.has(kpfeldNode.eknoten)) {
+                        // insert a bend node
+                        const bendNode = [null, null];
+                        switch (couplerOrientation) {
+                            case 0: // TOP
+                            case 2: // BOTTOM
+                                bendNode[0] = dopForwardConnectivityNode[0];
+                                bendNode[1] = dopConductingEquipment[1];
+                                break;
+                            case 1: // RIGHT
+                            case 3: // LEFT
+                                bendNode[0] = dopConductingEquipment[0];
+                                bendNode[1] = dopForwardConnectivityNode[1];
+                                break;
+                        }
+                        forwardTerminalPoints = [[...dopForwardConnectivityNode], bendNode, [...dopConductingEquipment]];
+                    }
+                    else {
+                        forwardTerminalPoints = [[...dopForwardConnectivityNode], [...dopConductingEquipment]];
+                    }
+                    const forwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.eknoten, kpfeldNode.id);
+                    if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                        this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                        const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints(forwardTerminalPoints, null);
+                        terminalDiagramObject.identifiedObjectUUID = forwardTerminalUUID;
+                        resultingDiagramObjects.push(terminalDiagramObject);
+                    }
+                }
+                // END: Terminal-Export
+                /* ---------- ---------- ---------- */
+            }
+            for (const nodePointEntry of nodePointMap.entries()) {
+                const key = nodePointEntry[0];
+                const value = nodePointEntry[1];
+                const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key })) !== null && _b !== void 0 ? _b : undefined;
+                value.identifiedObjectUUID = cimObjectUUID;
+                resultingDiagramObjects.push(value);
+            }
+            return resultingDiagramObjects;
+        });
+    }
+    convertSchemaLKupplung(nsgLKupplung, netzLKupplung) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const resultingDiagramObjects = [];
+            const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgLKupplung.nsgsaa }, false);
+            if (!nsgSaabschnitt)
+                return;
+            const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgSaabschnitt.nsgsa }, false);
+            if (!nsgSchaltanlage)
+                return;
+            const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgSchaltanlage.nsgso }, false);
+            if (!nsgStandort)
+                return;
+            const nsgSaabschnittAnf = yield this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, { variantennr: nsgLKupplung.variantennr, saabschnitt: netzLKupplung.saa_anf });
+            if (!nsgSaabschnittAnf)
+                return;
+            const nsgSaabschnittEnd = yield this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, { variantennr: nsgLKupplung.variantennr, saabschnitt: netzLKupplung.saa_end });
+            if (!nsgSaabschnittEnd)
+                return;
+            const netzSsabs = yield this.dbObjectGraph.findByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+                saabschnitt: {
+                    in: [nsgSaabschnittAnf.saabschnitt, nsgSaabschnittEnd.saabschnitt]
+                }
+            });
+            const lkupplungNodes = yield this.getNodesOfLKupplung(netzLKupplung);
+            const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+            const ssabConnectedNodes = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+            const nodePointMap = new Map();
+            if (lkupplungNodes.length === 1 && netzSsabsIds.has(lkupplungNodes[0].aknoten) && netzSsabsIds.has(lkupplungNodes[0].eknoten)) {
+                const ssabConnectedNode = ssabConnectedNodes[0];
+                if (yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_sestarr3p, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: ssabConnectedNode.id })) {
+                    const leftUpperCornerOfAKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.aknoten), nsgLKupplung.variantennr);
+                    const sizeOfAKnotenSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                    const leftUpperCornerOfEKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.eknoten), nsgLKupplung.variantennr);
+                    const sizeOfEKnotenSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                    // cause 'starre Verbindungen' are modelled as junctions, there must be two points extracted
+                    // those two points are equals to the connectivity node positions and the rotation value is unnecessary
+                    const aKnotenPosition = [null, null];
+                    const eKnotenPosition = [null, null];
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0] + (sizeOfAKnotenSsab) * 16;
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                            break;
+                        case 1: // top to bottom
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1] + (sizeOfAKnotenSsab) * 16;
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                            break;
+                        case 2: // right to left
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0] + (sizeOfEKnotenSsab) * 16;
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                            break;
+                        case 3: // bottom to top
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1] + (sizeOfEKnotenSsab) * 16;
+                            break;
+                    }
+                    const junctionCoordinates = [[...aKnotenPosition], [...eKnotenPosition]];
+                    nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints(junctionCoordinates, null));
+                    nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                    nodePointMap.set(ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+                }
+                else {
+                    const leftUpperCornerOfAKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.aknoten), nsgLKupplung.variantennr);
+                    const sizeOfAKnotenSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                    const leftUpperCornerOfEKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.eknoten), nsgLKupplung.variantennr);
+                    const sizeOfEKnotenSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                    const aKnotenPosition = [null, null];
+                    const eKnotenPosition = [null, null];
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0] + (sizeOfAKnotenSsab) * 16;
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                            break;
+                        case 1: // top to bottom
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1] + (sizeOfAKnotenSsab) * 16;
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                            break;
+                        case 2: // right to left
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0] + (sizeOfEKnotenSsab) * 16;
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                            break;
+                        case 3: // bottom to top
+                            aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                            eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1] + (sizeOfEKnotenSsab) * 16;
+                            break;
+                    }
+                    const position = [
+                        (aKnotenPosition[0] + eKnotenPosition[0]) / 2,
+                        (aKnotenPosition[1] + eKnotenPosition[1]) / 2
+                    ];
+                    let rotationValue = Math.atan2(eKnotenPosition[1] - aKnotenPosition[1], eKnotenPosition[0] - aKnotenPosition[0]);
+                    rotationValue = ((rotationValue * 180) / Math.PI) + 90;
+                    nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                    nodePointMap.set(ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+                }
+            }
+            else if (lkupplungNodes.length === 2 &&
+                (netzSsabsIds.has(lkupplungNodes[0].aknoten) || netzSsabsIds.has(lkupplungNodes[0].eknoten)) &&
+                (netzSsabsIds.has(lkupplungNodes[1].aknoten) || netzSsabsIds.has(lkupplungNodes[1].eknoten))) {
+                let aKnotenSsabNode;
+                let aKnotenSsabId;
+                let eKnotenSsabNode;
+                let eKnotenSsabId;
+                let inbetweenNodeId;
+                if (netzSsabsIds.has(lkupplungNodes[0].aknoten)) {
+                    aKnotenSsabId = lkupplungNodes[0].aknoten;
+                    aKnotenSsabNode = lkupplungNodes[0];
+                    eKnotenSsabId = lkupplungNodes[1].eknoten;
+                    eKnotenSsabNode = lkupplungNodes[1];
+                    inbetweenNodeId = lkupplungNodes[1].aknoten;
+                }
+                else {
+                    aKnotenSsabId = lkupplungNodes[1].aknoten;
+                    aKnotenSsabNode = lkupplungNodes[1];
+                    eKnotenSsabId = lkupplungNodes[0].eknoten;
+                    eKnotenSsabNode = lkupplungNodes[0];
+                    inbetweenNodeId = lkupplungNodes[0].aknoten;
+                }
+                const leftUpperCornerOfAKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === aKnotenSsabId), nsgLKupplung.variantennr);
+                const sizeOfAKnotenSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                const leftUpperCornerOfEKnotenSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === eKnotenSsabId), nsgLKupplung.variantennr);
+                const sizeOfEKnotenSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                const aKnotenPosition = [null, null];
+                const eKnotenPosition = [null, null];
+                switch (nsgSchaltanlage.ausrichtung) {
+                    case 0: // left to right
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0] + (sizeOfAKnotenSsab) * 16;
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 1: // top to bottom
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1] + (sizeOfAKnotenSsab) * 16;
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 2: // right to left
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0] + (sizeOfEKnotenSsab) * 16;
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 3: // bottom to top
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1] + (sizeOfEKnotenSsab) * 16;
+                        break;
+                }
+                const connectionVector2 = [
+                    eKnotenPosition[0] - aKnotenPosition[0],
+                    eKnotenPosition[1] - aKnotenPosition[1]
+                ];
+                const offsetVector = [
+                    connectionVector2[0] / 4,
+                    connectionVector2[1] / 4
+                ];
+                const ce1Position = [
+                    aKnotenPosition[0] + offsetVector[0],
+                    aKnotenPosition[1] + offsetVector[1]
+                ];
+                const cnCe1Ce2Position = [
+                    aKnotenPosition[0] + offsetVector[0] * 2,
+                    aKnotenPosition[1] + offsetVector[1] * 2
+                ];
+                const ce2Position = [
+                    aKnotenPosition[0] + offsetVector[0] * 3,
+                    aKnotenPosition[1] + offsetVector[1] * 3
+                ];
+                let rotationValue = Math.atan2(connectionVector2[1], connectionVector2[0]);
+                rotationValue = ((rotationValue * 180) / Math.PI) + 90;
+                nodePointMap.set(aKnotenSsabNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                nodePointMap.set(aKnotenSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(ce1Position[0], ce1Position[1], rotationValue));
+                nodePointMap.set(inbetweenNodeId, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cnCe1Ce2Position[0], cnCe1Ce2Position[1], null));
+                nodePointMap.set(eKnotenSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(ce2Position[0], ce2Position[1], rotationValue));
+                nodePointMap.set(eKnotenSsabNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+            }
+            else {
+                for (const ssabConnectedNode of ssabConnectedNodes) {
+                    const idOfSsab = netzSsabsIds.has(ssabConnectedNode.aknoten) ? ssabConnectedNode.aknoten : ssabConnectedNode.eknoten;
+                    const leftUpperCornerOfSsab = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === idOfSsab), nsgLKupplung.variantennr);
+                    // needed to get the correct behaviour for universal couplings
+                    const breakerNode = lkupplungNodes.find(arg => arg.aknoten === ssabConnectedNode.eknoten);
+                    if (netzSsabsIds.has(ssabConnectedNode.aknoten) && breakerNode) {
+                        // place on 'left' side of the coupling-field (but at the end of the busbar)
+                        const sizeOfSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                        let rotationValue;
+                        const position = [null, null];
+                        const aKnotenPosition = [null, null]; // connectivity node to busbar
+                        switch (nsgSchaltanlage.ausrichtung) {
+                            case 0: // left to right
+                                position[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16 + 4;
+                                position[1] = leftUpperCornerOfSsab[1];
+                                rotationValue = 90;
+                                aKnotenPosition[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16;
+                                aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                                break;
+                            case 1: // top to bottom
+                                position[0] = leftUpperCornerOfSsab[0];
+                                position[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16 + 4;
+                                rotationValue = 180;
+                                aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                                aKnotenPosition[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16;
+                                break;
+                            case 2: // right to left
+                                position[0] = leftUpperCornerOfSsab[0] - 4;
+                                position[1] = leftUpperCornerOfSsab[1];
+                                rotationValue = 270;
+                                aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                                aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                                break;
+                            case 3: // bottom to top
+                                position[0] = leftUpperCornerOfSsab[0];
+                                position[1] = leftUpperCornerOfSsab[1] - 4;
+                                rotationValue = 0;
+                                aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                                aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                                break;
+                        }
+                        nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                        nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                    }
+                    else {
+                        // place on 'right' side of the coupling-field (but at the start of the busbar)
+                        const sizeOfSsab = yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                        let rotationValue;
+                        const position = [null, null];
+                        const eKnotenPosition = [null, null]; // connectivity node to busbar
+                        switch (nsgSchaltanlage.ausrichtung) {
+                            case 0: // left to right
+                                position[0] = leftUpperCornerOfSsab[0] - 4;
+                                position[1] = leftUpperCornerOfSsab[1];
+                                rotationValue = 90;
+                                eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                                eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                                break;
+                            case 1: // top to bottom
+                                position[0] = leftUpperCornerOfSsab[0];
+                                position[1] = leftUpperCornerOfSsab[1] - 4;
+                                rotationValue = 180;
+                                eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                                eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                                break;
+                            case 2: // right to left
+                                position[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16 + 4;
+                                position[1] = leftUpperCornerOfSsab[1];
+                                rotationValue = 270;
+                                eKnotenPosition[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16;
+                                eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                                break;
+                            case 3: // bottom to top
+                                position[0] = leftUpperCornerOfSsab[0];
+                                position[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16 + 4;
+                                rotationValue = 0;
+                                eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                                eKnotenPosition[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16;
+                                break;
+                        }
+                        nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                        nodePointMap.set(
+                        // needed to get the correct behaviour for universal couplings
+                        netzSsabsIds.has(ssabConnectedNode.aknoten) ? ssabConnectedNode.aknoten : ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+                    }
+                }
+                if (ssabConnectedNodes.length > 2) {
+                    // universal-coupling ==> breaker must be placed 'on top' of the coupling
+                    const leftUpperCornerOfLKupplung = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsglkupplung, nsgLKupplung);
+                    const startSsabConnectedNode = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten));
+                    // if (startSsabConnectedNode.length === 1 && !nodePointMap.has(startSsabConnectedNode[0].eknoten)) {
+                    const breakerNode = lkupplungNodes.find(arg => arg.aknoten === startSsabConnectedNode[0].eknoten || arg.eknoten === startSsabConnectedNode[0].eknoten);
+                    let rotationValue = null;
+                    const breakerPosition = [...leftUpperCornerOfLKupplung];
+                    let cn1Position;
+                    let cn2Position;
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            rotationValue = 90;
+                            breakerPosition[0] += (nsgLKupplung.laenge / 2) * 16;
+                            breakerPosition[1] -= 4;
+                            cn1Position = [leftUpperCornerOfLKupplung[0] + 4, breakerPosition[1]];
+                            cn2Position = [leftUpperCornerOfLKupplung[0] + nsgLKupplung.laenge * 16 - 4, breakerPosition[1]];
+                            break;
+                        case 1: // top to bottom
+                            rotationValue = 180;
+                            breakerPosition[0] -= 4;
+                            breakerPosition[1] += (nsgLKupplung.laenge / 2) * 16;
+                            cn1Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + 4];
+                            cn2Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + nsgLKupplung.laenge * 16 - 4];
+                            break;
+                        case 2: // right to left
+                            rotationValue = 270;
+                            breakerPosition[0] += (nsgLKupplung.laenge / 2) * 16;
+                            breakerPosition[1] -= 4;
+                            cn1Position = [leftUpperCornerOfLKupplung[0] + nsgLKupplung.laenge * 16 - 4, breakerPosition[1]];
+                            cn2Position = [leftUpperCornerOfLKupplung[0] + 4, breakerPosition[1]];
+                            break;
+                        case 3: // bottom to top
+                            rotationValue = 0;
+                            breakerPosition[0] -= 4;
+                            breakerPosition[1] += (nsgLKupplung.laenge / 2) * 16;
+                            cn1Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + nsgLKupplung.laenge * 16 - 4];
+                            cn2Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + 4];
+                            break;
+                    }
+                    nodePointMap.set(breakerNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(breakerPosition[0], breakerPosition[1], rotationValue));
+                    nodePointMap.set(breakerNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn1Position[0], cn1Position[1], null));
+                    nodePointMap.set(breakerNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn2Position[0], cn2Position[1], null));
+                }
+                else {
+                    const startSsabConnectedNode = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten));
+                    if (startSsabConnectedNode.length === 1 && !nodePointMap.has(startSsabConnectedNode[0].eknoten)) {
+                        const centeredNode = lkupplungNodes.find(arg => arg.aknoten === startSsabConnectedNode[0].eknoten);
+                        const leftNode = startSsabConnectedNode[0];
+                        const rightNode = lkupplungNodes.find(arg => arg.aknoten === centeredNode.eknoten);
+                        const position = [null, null];
+                        let cn1Position;
+                        let cn2Position;
+                        switch (nsgSchaltanlage.ausrichtung) {
+                            case 0: // left to right
+                                cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn1Position[0] += 4;
+                                cn2Position[0] -= 4;
+                                break;
+                            case 1: // top to bottom
+                                cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn1Position[1] += 4;
+                                cn2Position[1] -= 4;
+                                break;
+                            case 2: // right to left
+                                cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn1Position[0] -= 4;
+                                cn2Position[0] += 4;
+                                break;
+                            case 3: // bottom to top
+                                cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                                cn1Position[1] -= 4;
+                                cn2Position[1] += 4;
+                                break;
+                        }
+                        position[0] = (cn1Position[0] + cn2Position[0]) / 2;
+                        position[1] = (cn1Position[1] + cn2Position[1]) / 2;
+                        let rotationValue = Math.atan2(cn2Position[1] - cn1Position[1], cn2Position[0] - cn1Position[0]);
+                        rotationValue = ((rotationValue * 180) / Math.PI) + 90;
+                        nodePointMap.set(centeredNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                        nodePointMap.set(centeredNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn1Position[0], cn1Position[1], null));
+                        nodePointMap.set(centeredNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn2Position[0], cn2Position[1], null));
+                    }
+                }
+            }
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            for (const lkupplungNode of lkupplungNodes) {
+                const doBackwardConnectivityNode = nodePointMap.get(lkupplungNode.aknoten);
+                const doConductingEquipment = nodePointMap.get(lkupplungNode.id);
+                const doForwardConnectivityNode = nodePointMap.get(lkupplungNode.eknoten);
+                const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopsConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition]);
+                const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const backwardTerminalUUID = this.lookupTerminalUUID(lkupplungNode.aknoten, lkupplungNode.id);
+                if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                    const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopBackwardConnectivityNode], [...dopsConductingEquipment[0]]], null);
+                    terminalDiagramObject.identifiedObjectUUID = backwardTerminalUUID;
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+                const forwardTerminalUUID = this.lookupTerminalUUID(lkupplungNode.eknoten, lkupplungNode.id);
+                if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                    const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...dopForwardConnectivityNode], [...dopsConductingEquipment[dopsConductingEquipment.length - 1]]], null);
+                    terminalDiagramObject.identifiedObjectUUID = forwardTerminalUUID;
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+            for (const nodePointEntry of nodePointMap.entries()) {
+                const key = nodePointEntry[0];
+                const value = nodePointEntry[1];
+                const cimObjectUUID = (_b = (_a = this.dbObjectKeyCimModelUuidGraph) === null || _a === void 0 ? void 0 : _a.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key })) !== null && _b !== void 0 ? _b : undefined;
+                value.identifiedObjectUUID = cimObjectUUID;
+                resultingDiagramObjects.push(value);
+            }
+            return resultingDiagramObjects;
+        });
+    }
+    /* ---------- ---------- ---------- ---------- ---------- */
+    //
+    // utility functions
+    //
+    /* ---------- ---------- ---------- ---------- ---------- */
+    getLeftUpperCornerOfUnspecified(variantennr, id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { type, object } = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr, id
+            });
+            if (type === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+                return yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgknotenso, object);
+            }
+            else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+                return yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, object);
+            }
+        });
+    }
+    getLeftUpperCornerOf(i7ObjectType, object, variantennr) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+                const nsgKnotenSo = object;
+                const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKnotenSo.variantennr, id: nsgKnotenSo.nsgso });
+                if (!nsgStandort)
+                    return;
+                return [nsgStandort.xrel + nsgKnotenSo.xrel, nsgStandort.yrel + nsgKnotenSo.yrel];
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgstandort) {
+                /* ---------- ---------- ---------- */
+                /* NsgStandort */
+                /* ---------- ---------- ---------- */
+                const nsgStandort = object;
+                return [nsgStandort.xrel, nsgStandort.yrel];
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage) {
+                /* ---------- ---------- ---------- */
+                /* NsgSchaltanlage */
+                /* ---------- ---------- ---------- */
+                const nsgSchaltanlage = object;
+                const nsgStandort = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltanlage.variantennr, id: nsgSchaltanlage.nsgso });
+                if (!nsgStandort)
+                    return;
+                const coords = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, nsgStandort);
+                coords[0] += nsgSchaltanlage.xrel;
+                coords[1] += nsgSchaltanlage.yrel;
+                return coords;
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt) {
+                /* ---------- ---------- ---------- */
+                /* NsgSaabschnitt */
+                /* ---------- ---------- ---------- */
+                const nsgSaabschnitt = object;
+                const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+                if (!nsgSchaltanlage)
+                    return;
+                // add the i7-offset for a NsgSaabschnitt in x-direction
+                const nsgSaabschnittCoords = [0, 0];
+                nsgSaabschnittCoords[0] += nsgSaabschnitt.nslots * 16;
+                const sizeOfSchaltanlage = yield this.getSizeOfSchaltanlage(nsgSchaltanlage);
+                util_functions_1.DLUtilFunctions.rotatePoint(nsgSaabschnittCoords, -90 * nsgSchaltanlage.ausrichtung);
+                if (nsgSchaltanlage.ausrichtung === 2) {
+                    nsgSaabschnittCoords[0] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                }
+                else if (nsgSchaltanlage.ausrichtung === 3) {
+                    nsgSaabschnittCoords[1] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                }
+                const nsgSchaltanlageCoords = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, nsgSchaltanlage);
+                return util_functions_1.DLUtilFunctions.add(nsgSaabschnittCoords, nsgSchaltanlageCoords, nsgSchaltanlage.ausrichtung % 2 === 0 ? [8, 0] : [0, 8]);
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld || i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) {
+                /* ---------- ---------- ---------- */
+                /* NsgSchaltfeld or NsgKpfeld */
+                /* ---------- ---------- ---------- */
+                // Important! The difference between a bay and a coupler is the slot-number related offset
+                // the slot-number related offset of the bay must be adjusted by an offset of -8 related to the orientation
+                // the slot-number related offset of the coupler matches exactly
+                const nsgSchaltfeld = object;
+                const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+                if (!nsgSaabschnitt)
+                    return;
+                const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+                if (nsgSchaltanlage === undefined)
+                    return;
+                //
+                // const nsgStandort = await this.dbObjectGraph.findObjectByKey(i7TableNames.nsg_nsgstandort,
+                //   i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltanlage.variantennr, id: nsgSchaltanlage.nsgso }
+                // );
+                // if (!nsgStandort) return;
+                const leftUpperCornerOfNsgSaabschnitt = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, nsgSaabschnitt);
+                let orientation = nsgSchaltanlage.ausrichtung;
+                if (nsgSchaltfeld.deltaausrichtung === 1) {
+                    orientation = (orientation + 2) % 4;
+                }
+                let position = [...leftUpperCornerOfNsgSaabschnitt];
+                let schaltfeldOffset;
+                switch (nsgSchaltanlage.ausrichtung) {
+                    case 0:
+                    case 1:
+                        schaltfeldOffset = nsgSchaltfeld.slotnummer * 16;
+                        break;
+                    case 2:
+                    case 3:
+                        schaltfeldOffset = (nsgSaabschnitt.laenge - nsgSchaltfeld.slotnummer - 1) * 16;
+                        if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld)
+                            schaltfeldOffset -= 16;
+                        break;
+                }
+                const maxSsabPos = yield this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                switch (orientation) {
+                    case 0: // TOP
+                        position[0] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                        position[1] -= nsgSchaltfeld.hoehe - ((maxSsabPos + 1) * 8);
+                        break;
+                    case 1: // RIGHT
+                        position[1] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                        break;
+                    case 2: // BOTTOM
+                        position[0] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                        break;
+                    case 3: // LEFT
+                        position[0] -= nsgSchaltfeld.hoehe - ((maxSsabPos + 1) * 8);
+                        position[1] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                        break;
+                }
+                return position;
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsglkupplung) {
+                /* ---------- ---------- ---------- */
+                /* NsgLKupplung */
+                /* ---------- ---------- ---------- */
+                const nsgLKupplung = object;
+                const nsgSaabschnitt = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgLKupplung.nsgsaa });
+                if (!nsgSaabschnitt)
+                    return;
+                const leftUpperCornerOfNsgSaabschnitt = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, nsgSaabschnitt);
+                const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+                if (nsgSchaltanlage === undefined)
+                    return;
+                let position = [...leftUpperCornerOfNsgSaabschnitt];
+                switch (nsgSchaltanlage.ausrichtung) {
+                    case 0: // left-to-right
+                        position[0] -= nsgLKupplung.laenge * 16;
+                        break;
+                    case 1: // top-to-bottom
+                        position[1] -= nsgLKupplung.laenge * 16;
+                        break;
+                    case 2: // right-to-left
+                        position[0] += (yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnitt)) * 16;
+                        break;
+                    case 3: // bottom-to-top
+                        position[1] += (yield this.getLengthOfSammelschienenAbschnitt(nsgSaabschnitt)) * 16;
+                        break;
+                }
+                return position;
+            }
+            else if (i7ObjectType === convert_graph_keys_1.i7TableNames.netz_ssab) {
+                /* ---------- ---------- ---------- */
+                /* NetzSsab */
+                /* ---------- ---------- ---------- */
+                const netzSsab = object;
+                const nsgSaabschnitt = yield this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, { variantennr, saabschnitt: netzSsab.saabschnitt });
+                if (nsgSaabschnitt === undefined)
+                    return;
+                const nsgSchaltanlage = yield this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+                if (!nsgSchaltanlage)
+                    return;
+                // add the i7-offset for a NsgSaabschnitt in x-direction
+                const nsgSaabschnittCoords = [0, 0];
+                nsgSaabschnittCoords[0] += nsgSaabschnitt.nslots * 16;
+                const sizeOfSchaltanlage = yield this.getSizeOfSchaltanlage(nsgSchaltanlage);
+                util_functions_1.DLUtilFunctions.rotatePoint(nsgSaabschnittCoords, -90 * nsgSchaltanlage.ausrichtung);
+                if (nsgSchaltanlage.ausrichtung === 0) {
+                    nsgSaabschnittCoords[1] += 4 + netzSsab.pos * 8;
+                    // const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                    // nsgSaabschnittCoords[0] += 4 + ((maxSsabPos - netzSsab.pos) * 8);
+                }
+                else if (nsgSchaltanlage.ausrichtung === 1) {
+                    const maxSsabPos = yield this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                    nsgSaabschnittCoords[0] += 4 + ((maxSsabPos - netzSsab.pos) * 8);
+                }
+                else if (nsgSchaltanlage.ausrichtung === 2) {
+                    const maxSsabPos = yield this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                    nsgSaabschnittCoords[1] += 4 + ((maxSsabPos - netzSsab.pos) * 8);
+                    nsgSaabschnittCoords[0] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                }
+                else if (nsgSchaltanlage.ausrichtung === 3) {
+                    nsgSaabschnittCoords[0] += 4 + netzSsab.pos * 8;
+                    nsgSaabschnittCoords[1] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                }
+                const nsgSchaltanlageCoords = yield this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, nsgSchaltanlage);
+                return util_functions_1.DLUtilFunctions.add(nsgSaabschnittCoords, nsgSchaltanlageCoords, nsgSchaltanlage.ausrichtung % 2 === 0 ? [8, 0] : [0, 8]);
+            }
+            return [undefined, undefined];
+        });
+    }
+    getNodesOfSchaltfeld(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.dbObjectGraph.findAllByAttributes([
+                convert_graph_keys_1.i7TableNames.netz_leistungsschalter,
+                convert_graph_keys_1.i7TableNames.netz_trenner3p,
+                convert_graph_keys_1.i7TableNames.netz_trennerfi3p,
+                convert_graph_keys_1.i7TableNames.netz_sestarr3p
+            ], { seliste: arg.schaltfeld });
+        });
+    }
+    getNodesOfKpfeld(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.dbObjectGraph.findAllByAttributes([
+                convert_graph_keys_1.i7TableNames.netz_leistungsschalter,
+                convert_graph_keys_1.i7TableNames.netz_trenner3p,
+                convert_graph_keys_1.i7TableNames.netz_trennerfi3p,
+                convert_graph_keys_1.i7TableNames.netz_sestarr3p
+            ], { seliste: arg.kpfeld });
+        });
+    }
+    getNodesOfLKupplung(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.dbObjectGraph.findAllByAttributes([
+                convert_graph_keys_1.i7TableNames.netz_leistungsschalter,
+                convert_graph_keys_1.i7TableNames.netz_trenner3p,
+                convert_graph_keys_1.i7TableNames.netz_trennerfi3p,
+                convert_graph_keys_1.i7TableNames.netz_sestarr3p
+            ], { seliste: arg.id });
+        });
+    }
+    /** */
+    getSizeOfSchaltanlage(arg) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let sizeOfSchaltanlage = 0;
+            const nsgSaabschnitte = yield this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, {
+                variantennr: arg.variantennr, nsgsa: arg.id
+            });
+            for (const tempNsgSaab of nsgSaabschnitte) {
+                sizeOfSchaltanlage = sizeOfSchaltanlage < (tempNsgSaab.nslots + tempNsgSaab.laenge) ? (tempNsgSaab.nslots + tempNsgSaab.laenge) : sizeOfSchaltanlage;
+            }
+            return sizeOfSchaltanlage;
+        });
+    }
+    getMaxPosOfSaabschnitt(nsgSaabschnitt) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const netzSsabs = yield this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+                saabschnitt: nsgSaabschnitt.saabschnitt
+            });
+            let maxSsabPos = netzSsabs[0].pos;
+            for (let a = 1; a < netzSsabs.length; ++a) {
+                if (netzSsabs[a].pos > maxSsabPos)
+                    maxSsabPos = netzSsabs[a].pos;
+            }
+            return maxSsabPos;
+        });
+    }
+    getLengthOfSammelschienenAbschnitt(nsgSaab) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const maxLengthOfKuppelfeld = yield this.getMaxLengthOfKuppelfeld({
+                id: nsgSaab.id,
+                variantennr: nsgSaab.variantennr
+            });
+            const maxLengthOfSchaltfeld = yield this.getMaxLengthOfSchaltfeld({
+                id: nsgSaab.id,
+                variantennr: nsgSaab.variantennr
+            });
+            return Math.max(maxLengthOfKuppelfeld, maxLengthOfSchaltfeld, nsgSaab.laenge);
+        });
+    }
+    getMaxLengthOfKuppelfeld(schaltanlagenabschnittKey) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgKpFelder = (yield this.dbObjectGraph.getAllObjectsOfTable(convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld)).filter(nsgKpFeld => nsgKpFeld.nsgsaa === schaltanlagenabschnittKey.id
+                && nsgKpFeld.variantennr === schaltanlagenabschnittKey.variantennr
+                && (nsgKpFeld.eingeblendet === 1 || (nsgKpFeld.eingeblendet === null && nsgKpFeld.angezeigt === 1)));
+            let nsgKpFeldMaxSlotnummer = nsgKpFelder.length > 0 ? nsgKpFelder[0].slotnummer : undefined;
+            for (let a = 1; a < nsgKpFelder.length; ++a) {
+                const nsgKpFeld = nsgKpFelder[a];
+                if (nsgKpFeldMaxSlotnummer < nsgKpFeld.slotnummer) {
+                    nsgKpFeldMaxSlotnummer = nsgKpFeld.slotnummer;
+                }
+            }
+            return nsgKpFeldMaxSlotnummer ? nsgKpFeldMaxSlotnummer + 1 : 0;
+        });
+    }
+    getMaxLengthOfSchaltfeld(schaltanlagenabschnittKey) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgSchaltfelder = (yield this.dbObjectGraph.getAllObjectsOfTable(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld)).filter(nsgSchaltfeld => nsgSchaltfeld.nsgsaa === schaltanlagenabschnittKey.id
+                && nsgSchaltfeld.variantennr === schaltanlagenabschnittKey.variantennr
+                && (nsgSchaltfeld.eingeblendet === 1 || (nsgSchaltfeld.eingeblendet === null && nsgSchaltfeld.angezeigt === 1)));
+            let nsgSchaltfeldMaxSlotnummer = nsgSchaltfelder.length > 0 ? nsgSchaltfelder[0].slotnummer : undefined;
+            for (let a = 1; a < nsgSchaltfelder.length; ++a) {
+                const nsgSchaltfeld = nsgSchaltfelder[a];
+                if (nsgSchaltfeldMaxSlotnummer < nsgSchaltfeld.slotnummer) {
+                    nsgSchaltfeldMaxSlotnummer = nsgSchaltfeld.slotnummer;
+                }
+            }
+            return nsgSchaltfeldMaxSlotnummer ? nsgSchaltfeldMaxSlotnummer + 1 : 0;
+        });
+    }
+    lookupTerminalUUID(connectivityNodeI7ID, conductingEquipmentI7ID) {
+        if (DLConverterI7.testmode) {
+            return common_utils_1.CommonUtils.generateUUID();
+        }
+        const connectivityNodeUUID = this.dbObjectKeyCimModelUuidGraph.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: connectivityNodeI7ID });
+        const conductingEquipmentUUID = this.dbObjectKeyCimModelUuidGraph.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: conductingEquipmentI7ID });
+        if (!connectivityNodeUUID || !conductingEquipmentUUID) {
+            return null;
+        }
+        const connectivityNode = this.cimModelGraph.findObjectByUUID(connectivityNodeUUID);
+        // const conductingEquipment = this.cimModelGraph.findObjectByUUID(conductingEquipmentUUID) as ConductingEquipment;
+        // if (!connectivityNode || !conductingEquipment) return null;
+        if (!connectivityNode)
+            return null;
+        const cnTerminals = [...connectivityNode.terminals.values()];
+        for (const cnTerminal of cnTerminals) {
+            if (cnTerminal.getConductingEquipmentUUID() === conductingEquipmentUUID) {
+                const terminalUUID = cnTerminal.getUUID();
+                return terminalUUID !== undefined ? terminalUUID : null;
+            }
+        }
+        return null;
+    }
+}
+exports.DLConverterI7 = DLConverterI7;
+DLConverterI7.testmode = false;
+//# sourceMappingURL=dl-converter-i7-2.js.map