@enervance/insight-cim-model 0.0.60 → 0.0.62

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

@@ -0,0 +1,1280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLConverterI7 = void 0;
+const tslib_1 = require("tslib");
+const integral_sql_1 = require("../sql/integral.sql");
+const Diagram_1 = require("../../../model/diagram/Diagram");
+const utils_1 = require("../../../util/utils");
+const OrientationKind_1 = require("../../../model/diagram/OrientationKind");
+const cim_constants_1 = require("../../../constants/cim-constants");
+const DiagramStyle_1 = require("../../../model/diagram/DiagramStyle");
+const perf_hooks_1 = require("perf_hooks");
+const util_functions_1 = require("../model/dl-utils/util-functions");
+const constants_1 = require("../model/dl-utils/constants");
+const DiagramObject_1 = require("../../../model/diagram/DiagramObject");
+const DiagramObjectPoint_1 = require("../../../model/diagram/DiagramObjectPoint");
+const utils_schema_1 = require("../utils-schema");
+const data_types_1 = require("./db/data.types");
+const Model_1 = require("../../../model/model/Model");
+const ConnectivityNode_1 = require("../../../model/core/ConnectivityNode");
+const ConductingEquipment_1 = require("../../../model/core/ConductingEquipment");
+const BusbarSection_1 = require("../../../model/wires/BusbarSection");
+const ACLineSegment_1 = require("../../../model/wires/ACLineSegment");
+class DLConverterI7 {
+    constructor() {
+    }
+    static addCimObjects(...objs) {
+        for (const obj of objs) {
+            DLConverterI7.cimUUID2Object.set(obj.getUUID(), obj);
+            if (obj instanceof DiagramObject_1.DiagramObject) {
+                DLConverterI7.cimUUID2Object.set(obj.getIdentifiedObjectUUID(), obj);
+                DLConverterI7.cimUUID2DiagramObject.set(obj.getUUID(), obj);
+                DLConverterI7.cimUUID2DiagramObject.set(obj.getIdentifiedObjectUUID(), obj);
+            }
+        }
+    }
+    static getCimObjectByUUID(uuid) {
+        return DLConverterI7.cimUUID2Object.get(uuid);
+    }
+    static getDiagramObjectByUUID(uuid) {
+        return DLConverterI7.cimUUID2DiagramObject.get(uuid);
+    }
+    static createSchemaKeyObject(arg) {
+        return JSON.stringify(arg);
+    }
+    static parseSchemaKeyObject(key) {
+        return JSON.parse(key);
+    }
+    static addIDsRelationMapping(i7ID, cimUUIDs) {
+        DLConverterI7.i7ID2cimUUIDs.set(i7ID, cimUUIDs);
+        if (cimUUIDs.identifiedObjectUUID) {
+            DLConverterI7.cimUUID2i7ID.set(cimUUIDs.identifiedObjectUUID, i7ID);
+        }
+        if (cimUUIDs.diagramObjectUUID) {
+            DLConverterI7.cimUUID2i7ID.set(cimUUIDs.diagramObjectUUID, i7ID);
+        }
+    }
+    static addID2TypeMapping(i7ID, tpe) {
+        DLConverterI7.i7ID2Type.set(i7ID, tpe);
+        if (!DLConverterI7.type2i7IDs.has(tpe)) {
+            DLConverterI7.type2i7IDs.set(tpe, []);
+        }
+        DLConverterI7.type2i7IDs.get(tpe).push(i7ID);
+    }
+    static addID2DbNsgObjectMapping(i7ID, dbNsgObject) {
+        DLConverterI7.i7ID2DbNsgObject.set(i7ID, dbNsgObject);
+        DLConverterI7.i7ID2DbNsgObjectInFrame.set(i7ID, dbNsgObject);
+    }
+    static getDbNsgObjectByID(i7ID) {
+        return DLConverterI7.i7ID2DbNsgObject.get(i7ID);
+    }
+    cleanUp() {
+        DLConverterI7.i7ID2DbNsgObjectInFrame.clear();
+        DLConverterI7.variantenNr2Diagram.clear();
+        if (!DLConverterI7.purgeData)
+            return;
+        DLConverterI7.type2i7IDs.clear();
+        DLConverterI7.cimUUID2i7ID.clear();
+        DLConverterI7.cimUUID2Object.clear();
+    }
+    prepare(mysqlController, logger) {
+        this.mysqlController = mysqlController;
+        this.logger = logger;
+    }
+    static getI7ID2DiagramObjectMap() {
+        const i7ID2DiagramObjectMap = new Map();
+        for (const i7ID2cimUUIDsEntry of DLConverterI7.i7ID2cimUUIDs.entries()) {
+            const diagramObject = DLConverterI7.cimUUID2DiagramObject.get(i7ID2cimUUIDsEntry[1].diagramObjectUUID);
+            i7ID2DiagramObjectMap.set(i7ID2cimUUIDsEntry[0], diagramObject);
+        }
+        return i7ID2DiagramObjectMap;
+    }
+    addCimObjects2Model(cimModel) {
+        for (const entry of DLConverterI7.cimUUID2Object.entries()) {
+            if (entry[1] instanceof Diagram_1.Diagram) {
+                cimModel.addDiagram(entry[1]);
+            }
+            else if (entry[1] instanceof DiagramObject_1.DiagramObject) {
+                cimModel.addDiagramObject(entry[1]);
+            }
+        }
+    }
+    convert(availableTablesWithColumnNames, onlyEingeblendet, args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.inputArgs = args;
+            this.inputArgs.objects.forEach((value, key) => DLConverterI7.cimModelObjects.objects.set(key, value));
+            this.i7TableName2Table = new Map();
+            availableTablesWithColumnNames.forEach((value, key) => {
+                this.i7TableName2Table.set(key, { tableName: key, columnNames: value });
+            });
+            yield this.runAndLogPerformance(this.convertNsgVarianten);
+            let a = 0;
+            for (const entry of DLConverterI7.variantenNr2Diagram.entries()) {
+                ++a;
+                const variantenNr = entry[0];
+                this.activeDiagram = entry[1];
+                this.logger.debug(`Starte Konvertierung von Schema ${variantenNr} [${a}/${DLConverterI7.variantenNr2Diagram.size}]`);
+                console.log(`Starte Konvertierung von Schema ${variantenNr} [${a}/${DLConverterI7.variantenNr2Diagram.size}]`);
+                const startTime = perf_hooks_1.performance.now();
+                const ret_val = yield this.convertSchemaStandorte(variantenNr, onlyEingeblendet, args.standortIDs);
+                this.logger.debug(`convertSchemaStandorte ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+                console.log(`convertSchemaStandorte ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+                if (ret_val) {
+                    yield this.runAndLogPerformance(this.convertSchemaStandorte, variantenNr, onlyEingeblendet, args.standortIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaKnotenSo, variantenNr, onlyEingeblendet, args.knotenSoIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaSchaltanlage, variantenNr, onlyEingeblendet, args.schaltanlagenIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaSchaltanlagenAbschnitte, variantenNr, onlyEingeblendet, args.schaltanlagenAbschnittIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaSammelschienenAbschnitte, variantenNr, onlyEingeblendet, args.schaltanlagenAbschnittIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaSchaltfeldElemente, variantenNr, onlyEingeblendet, args.schaltfeldIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaQuerkupplungen, variantenNr, onlyEingeblendet, args.querkupplungIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaLaengskupplungen, variantenNr, onlyEingeblendet, args.laengskupplungIDs);
+                    yield this.runAndLogPerformance(this.convertSchemaTransformatoren2W, variantenNr, onlyEingeblendet, args.powerTransformers);
+                    yield this.runAndLogPerformance(this.convertSchemaTransformatoren3W, variantenNr, onlyEingeblendet, args.powerTransformers);
+                    yield this.runAndLogPerformance(this.convertSchemaLeitungen, variantenNr, onlyEingeblendet);
+                    yield this.runAndLogPerformance(this.convertSchemaQuerzweige, variantenNr, onlyEingeblendet);
+                    yield this.runAndLogPerformance(this.convertSchemaTerminals);
+                }
+            }
+        });
+    }
+    convertNsgVarianten() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NETZVARIANTEN)) {
+                const result = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NETZVARIANTEN, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NETZVARIANTEN), [2]));
+                for (const i7Data of result) {
+                    const diagram = new Diagram_1.Diagram((0, utils_1.getUUID)(i7Data.guid), i7Data.name, String(i7Data.id));
+                    diagram.orientation = OrientationKind_1.OrientationKind.negative;
+                    diagram.diagramStyle = new DiagramStyle_1.DiagramStyle((0, utils_1.generateUUID)(), cim_constants_1.DIAGRAM_LAYOUT_TYPES.NODE_BREAKER);
+                    DLConverterI7.addCimObjects(diagram);
+                    DLConverterI7.variantenNr2Diagram.set(i7Data.id, diagram);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NETZVARIANTEN} ist nicht vorhanden.`);
+            }
+        });
+    }
+    static registerNsgObjectAndGetSchemaKay(i7Data, type, keyObject) {
+        const schemaObjKey = DLConverterI7.createSchemaKeyObject(keyObject === undefined ?
+            { i7ID: i7Data.id, variantenNr: i7Data.variantennr }
+            : keyObject);
+        DLConverterI7.addID2TypeMapping(schemaObjKey, type);
+        DLConverterI7.addID2DbNsgObjectMapping(schemaObjKey, i7Data);
+        return schemaObjKey;
+    }
+    convertSchemaStandorte(variantenNr, onlyEingeblendet, standortIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_STANDORT) && standortIDs.length > 0) {
+                const result = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_STANDORT, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_STANDORT), standortIDs));
+                const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResults) {
+                    DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_STANDORT);
+                }
+                return filteredResults.length > 0;
+            }
+            return false;
+        });
+    }
+    convertSchemaKnotenSo(variantenNr, onlyEingeblendet, knotenSoIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO) && knotenSoIDs.length > 0) {
+                const result = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_KNOTEN_SO, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO), knotenSoIDs));
+                const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResults) {
+                    const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO);
+                    const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgso, variantenNr });
+                    const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                    if (nsgStandort === undefined) {
+                        continue;
+                    }
+                    const cimObjectUUID = this.inputArgs.integralID2UUID.get(i7Data.knotenso);
+                    const width = constants_1.NsgConstants.KNOTENSO_WIDTH;
+                    const height = constants_1.NsgConstants.KNOTENSO_HEIGHT;
+                    const xParentRel = nsgStandort.xrel;
+                    const yParentRel = nsgStandort.yrel;
+                    const diagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: xParentRel + i7Data.xrel + (width / 2),
+                        yPosition: yParentRel + i7Data.yrel + (height / 2),
+                        diagramObjectName: 'Abzweig',
+                        identifiedObjectUUID: cimObjectUUID,
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: cimObjectUUID,
+                        diagramObjectUUID: diagramObject.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(diagramObject);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaSchaltanlage(variantenNr, onlyEingeblendet, schaltanlagenIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE) && schaltanlagenIDs.length > 0) {
+                const result = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_SCHALTANLAGE, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE), schaltanlagenIDs));
+                const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResults) {
+                    DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaSchaltanlagenAbschnitte(variantenNr, onlyEingeblendet, schaltanlagenabschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT) && schaltanlagenabschnittIDs.length > 0) {
+                const result = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_SCHALTANLAGENABSCHNITT, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT), schaltanlagenabschnittIDs));
+                const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResults) {
+                    const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT);
+                    const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsa, variantenNr });
+                    const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                    if (nsgSchaltanlage) {
+                        if (nsgSchaltanlage.saabschnittIDs === undefined) {
+                            nsgSchaltanlage.saabschnittIDs = [];
+                        }
+                        nsgSchaltanlage.saabschnittIDs.push(schemaObjKey);
+                        if (nsgSchaltanlage.nsgSaabs === undefined) {
+                            nsgSchaltanlage.nsgSaabs = [];
+                        }
+                        nsgSchaltanlage.nsgSaabs.push(i7Data);
+                    }
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaSammelschienenAbschnitte(variantenNr, onlyEingeblendet, schaltanlagenabschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (schaltanlagenabschnittIDs.length <= 0)
+                return;
+            const isEingeblendet = 1;
+            let sqlSelectGroupedMaxSlotSf = `SELECT nsgsaa AS nsgsaa, max(slotnummer) + 1 AS laenge
+                                     FROM nsg_nsgschaltfeld
+                                     WHERE ((${(0, integral_sql_1.getWhereIDs)('nsgsaa', schaltanlagenabschnittIDs).join(' OR ')}))`;
+            if (onlyEingeblendet) {
+                sqlSelectGroupedMaxSlotSf += ` AND (eingeblendet = ${isEingeblendet} OR (eingeblendet IS NULL AND angezeigt = ${isEingeblendet}))`;
+            }
+            sqlSelectGroupedMaxSlotSf += ` GROUP BY nsgsaa`;
+            const resultsMaxSlotsSf = yield this.mysqlController.execQuery(sqlSelectGroupedMaxSlotSf);
+            const mappedResultsMaxSlotsSf = new Map(resultsMaxSlotsSf.map(value => [value.nsgsaa, value.laenge]));
+            let sqlSelectGroupedMaxSlotKpF = `SELECT nsgsaa AS nsgsaa, max(slotnummer) + 1 AS laenge
+                                      FROM nsg_nsgkpfeld
+                                      WHERE ((${(0, integral_sql_1.getWhereIDs)('nsgsaa', schaltanlagenabschnittIDs).join(' OR ')}))`;
+            if (onlyEingeblendet) {
+                sqlSelectGroupedMaxSlotKpF += ` AND (eingeblendet = ${isEingeblendet} OR (eingeblendet IS NULL AND angezeigt = ${isEingeblendet}))`;
+            }
+            sqlSelectGroupedMaxSlotKpF += ` GROUP BY nsgsaa`;
+            const resultsMaxSlotsKpF = yield this.mysqlController.execQuery(sqlSelectGroupedMaxSlotKpF);
+            const mappedResultsMaxSlotsKpF = new Map(resultsMaxSlotsKpF.map(value => [value.nsgsaa, value.laenge]));
+            const sqlStatement = `SELECT nsg_nsgsaab.variantennr,
+              nsg_nsgsaab.id,
+              nsg_nsgsaab.laenge AS laenge,
+              nsg_nsgsaab.nslots,
+              nsg_nsgsaab.saabschnitt,
+              nsg_nsgsaab.nsgsa,
+              nsg_nsgsaab.angezeigt,
+              nsg_nsgsaab.eingeblendet,
+              nsg_nsgsaab.nsglkp,
+              netz_ssab.pos      AS posSSAB,
+              netz_ssab.id       AS idSSAB
+       FROM netz_ssab
+                LEFT JOIN nsg_nsgsaabschnitt AS nsg_nsgsaab ON nsg_nsgsaab.saabschnitt = netz_ssab.saabschnitt
+       WHERE (${(0, integral_sql_1.getWhereIDs)('nsg_nsgsaab.saabschnitt', schaltanlagenabschnittIDs).join(' OR ')});`;
+            const queryResults = yield this.mysqlController.execQuery(sqlStatement);
+            queryResults.forEach(value => {
+                value.laenge = Math.max((mappedResultsMaxSlotsSf.get(value.id) || 0), (mappedResultsMaxSlotsKpF.get(value.id) || 0), value.laenge);
+            });
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(queryResults, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_SSAB, { i7ID: i7Data.idSSAB, variantenNr, additionalIDs: [i7Data.nsgsa] });
+                const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsa, variantenNr });
+                const nsgSa = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                if (nsgSa === undefined)
+                    continue;
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSa.nsgso, variantenNr });
+                const nsgSo = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgSo === undefined)
+                    continue;
+                const leftOffset = i7Data.nslots * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                const topOffset = i7Data.posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET;
+                const ssabLength = i7Data.laenge * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                let pointTopLeft = new DiagramObjectPoint_1.DiagramObjectPoint(leftOffset, topOffset, 1);
+                let pointBottomRight = new DiagramObjectPoint_1.DiagramObjectPoint(leftOffset + ssabLength, topOffset, 2);
+                let saabShiftOffset = 0;
+                for (const tempNsgSaab of nsgSa.nsgSaabs) {
+                    saabShiftOffset = saabShiftOffset < (tempNsgSaab.nslots + tempNsgSaab.laenge) ? (tempNsgSaab.nslots + tempNsgSaab.laenge) : saabShiftOffset;
+                }
+                const points = [];
+                points.push(pointTopLeft, pointBottomRight);
+                for (const p of points) {
+                    util_functions_1.DLUtilFunctions.rotateDiagramObjectPoint(p, -90 * nsgSa.ausrichtung);
+                    p.xPosition += nsgSo.xrel + nsgSa.xrel + (nsgSa.ausrichtung === 2 ? saabShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
+                    p.yPosition += nsgSo.yrel + nsgSa.yrel + (nsgSa.ausrichtung === 3 ? saabShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
+                }
+                const cimObjectUUID = this.inputArgs.integralID2UUID.get(i7Data.idSSAB);
+                const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)(), 'SSAB Diagram');
+                diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                diagramObject.identifiedObjectUUID = cimObjectUUID;
+                diagramObject.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSa.ausrichtung);
+                (0, utils_schema_1.copyDiagramObjectPoints)(diagramObject, points);
+                DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                    identifiedObjectUUID: cimObjectUUID,
+                    diagramObjectUUID: diagramObject.getUUID()
+                });
+                DLConverterI7.addCimObjects(diagramObject);
+                const nsgSAABObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.id, variantenNr });
+                const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSAABObjKey);
+                if (nsgSAAB.nsgSsabs === undefined) {
+                    nsgSAAB.nsgSsabs = [];
+                }
+                nsgSAAB.nsgSsabs.push(i7Data);
+            }
+        });
+    }
+    convertSchemaSchaltfeldElemente(variantenNr, onlyEingeblendet, schaltfeldIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) && schaltfeldIDs.length > 0) {
+                const i7relevantTables = [
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNER_3P],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNERFI_3P],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_STARR]
+                ];
+                const i7checkedTables = this.filterTablesByAvailability(i7relevantTables);
+                const i7knotenBeziehungen = yield this.mysqlController.execQuery((0, integral_sql_1.getI7KnotenBeziehungenQuery)(i7checkedTables, schaltfeldIDs));
+                const queryStr = (0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_SCHALTFELD, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_SCHALTFELD), schaltfeldIDs);
+                const resultsNsgSchaltfeld = yield this.mysqlController.execQuery(queryStr);
+                const filteredResultsNsgSchaltfeld = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(resultsNsgSchaltfeld, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResultsNsgSchaltfeld) {
+                    DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_SCHALTFELD);
+                    const nsgSaabObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsaa, variantenNr });
+                    const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSaabObjKey);
+                    if (nsgSAAB === undefined)
+                        continue;
+                    const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSAAB.nsgsa, variantenNr });
+                    const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                    if (nsgSchaltanlage === undefined)
+                        continue;
+                    const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSchaltanlage.nsgso, variantenNr });
+                    const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                    if (nsgStandort === undefined)
+                        continue;
+                    const nodePointMap = new Map();
+                    const schaltfeldLeftOffset = i7Data.slotnummer * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                    const schaltfeldDeltaausrichtung = i7Data.deltaausrichtung;
+                    const schaltfeldI7KnotenBeziehungen = i7knotenBeziehungen.filter(elem => elem.seliste === i7Data.schaltfeld);
+                    let shiftFromBusbar = false;
+                    if (schaltfeldI7KnotenBeziehungen.length == 1) {
+                        shiftFromBusbar = true;
+                    }
+                    const ssabs = this.inputArgs.integralSchaltfelder.get(i7Data.schaltfeld).saabschnitt.ssab;
+                    const maxSSabPos = Math.max(...ssabs.map(ssab => ssab.pos));
+                    const onSSabNodes = schaltfeldI7KnotenBeziehungen.filter(elem => ssabs.find(ssab => ssab.id === elem.aknoten) !== undefined);
+                    const xPos = schaltfeldLeftOffset + (constants_1.NsgConstants.HORIZONTAL_OFFSET / 2);
+                    let lastNode = undefined;
+                    for (const node of onSSabNodes) {
+                        const nsgSSABObjKey = DLConverterI7.createSchemaKeyObject({
+                            i7ID: node.aknoten,
+                            variantenNr,
+                            additionalIDs: [nsgSAAB.nsgsa]
+                        });
+                        const nsgSsab = DLConverterI7.getDbNsgObjectByID(nsgSSABObjKey);
+                        const ssabYPos = nsgSsab.posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET;
+                        let yStackPos = 1;
+                        let prevNode = null;
+                        let crtNode = node;
+                        while (crtNode) {
+                            if (nodePointMap.get(crtNode.id) === undefined) {
+                                let yPos = ssabYPos;
+                                if (crtNode === node) {
+                                    yPos += shiftFromBusbar ? (schaltfeldDeltaausrichtung === 0 ? -1 : 1) * constants_1.NsgConstants.VERTICAL_OFFSET : 0;
+                                }
+                                else {
+                                    const ssabOffset = schaltfeldDeltaausrichtung === 0 ? 0 : maxSSabPos;
+                                    yPos = ((schaltfeldDeltaausrichtung === 0 ? -1 : 1) * (yStackPos) + ssabOffset) * constants_1.NsgConstants.VERTICAL_OFFSET;
+                                    yStackPos += 1;
+                                }
+                                nodePointMap.set(crtNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPos, schaltfeldDeltaausrichtung * 180));
+                                const aKnotenUUID = this.inputArgs.integralID2UUID.get(crtNode.aknoten);
+                                if (!DLConverterI7.cimUUID2Object.has(aKnotenUUID) && !nodePointMap.has(crtNode.aknoten)) {
+                                    let prevNodeY = (prevNode !== null && nodePointMap.get(prevNode.id) !== undefined) ? nodePointMap.get(prevNode.id).diagramObjectPoints[0].yPosition : 0;
+                                    let yPosAKnoten;
+                                    if (prevNode === node) {
+                                        yPosAKnoten = yPos - ((schaltfeldDeltaausrichtung === 0 ? -1 : 1) * constants_1.NsgConstants.VERTICAL_OFFSET) / 2;
+                                    }
+                                    else {
+                                        yPosAKnoten = (yPos - prevNodeY) / 2 + prevNodeY;
+                                    }
+                                    nodePointMap.set(crtNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPosAKnoten));
+                                }
+                            }
+                            lastNode = crtNode;
+                            prevNode = crtNode;
+                            crtNode = schaltfeldI7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
+                        }
+                    }
+                    const lastEKnotenUUID = this.inputArgs.integralID2UUID.get(lastNode.eknoten);
+                    if (!DLConverterI7.cimUUID2Object.has(lastEKnotenUUID) && !nodePointMap.has(lastNode.eknoten)) {
+                        const yPos = (schaltfeldDeltaausrichtung === 0 ? -1 : 1) * (i7Data.hoehe);
+                        const heightAdjustement = schaltfeldDeltaausrichtung === 0 ? (constants_1.NsgConstants.VERTICAL_OFFSET * (maxSSabPos + 1)) : 0;
+                        nodePointMap.set(lastNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPos + heightAdjustement));
+                    }
+                    i7Data.lastNodeID = lastNode.eknoten;
+                    i7Data.lastNodeCimUUID = lastEKnotenUUID;
+                    i7Data.orientation = nsgSchaltanlage.ausrichtung;
+                    if (i7Data.deltaausrichtung === 1) {
+                        i7Data.orientation = (i7Data.orientation + 2) % 4;
+                    }
+                    for (const nodePointEntry of nodePointMap.entries()) {
+                        const i7ID = nodePointEntry[0];
+                        const diagramObject = nodePointEntry[1];
+                        if (DLConverterI7.cimUUID2Object.has(diagramObject.getUUID()))
+                            continue;
+                        const cimObjectUUID = this.inputArgs.integralID2UUID.get(i7ID);
+                        diagramObject.identifiedObjectUUID = cimObjectUUID;
+                        diagramObject.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSaNsgSf(nsgSchaltanlage.ausrichtung, schaltfeldDeltaausrichtung);
+                        diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                        const schemaObjKey = DLConverterI7.createSchemaKeyObject({ i7ID, variantenNr, additionalIDs: [i7Data.id] });
+                        DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_NODE);
+                        DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                            identifiedObjectUUID: cimObjectUUID,
+                            diagramObjectUUID: diagramObject.getUUID()
+                        });
+                        DLConverterI7.addCimObjects(diagramObject);
+                    }
+                    util_functions_1.DLUtilFunctions.rotateAndShiftBasedOnNsgSAA(nsgStandort, nsgSchaltanlage, nsgSAAB, [...nodePointMap.values()], true);
+                }
+            }
+        });
+    }
+    convertSchemaQuerkupplungen(variantenNr, onlyEingeblendet, querkupplungIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_QUERKUPPLUNG) && querkupplungIDs.length > 0) {
+                const i7relevantTables = [
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNER_3P],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNERFI_3P],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_STARR]
+                ];
+                const i7checkedTables = this.filterTablesByAvailability(i7relevantTables);
+                const i7knotenBeziehungen = yield this.mysqlController.execQuery((0, integral_sql_1.getI7KnotenBeziehungenQuery)(i7checkedTables, querkupplungIDs));
+                const resultsNsgKpFeld = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_QUERKUPPLUNG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_QUERKUPPLUNG), querkupplungIDs));
+                const filteredResultsNsgKpFeld = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(resultsNsgKpFeld, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResultsNsgKpFeld) {
+                    DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_QUERKUPPLUNG);
+                    const kpFeldLeftOffset = i7Data.slotnummer * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                    const kpFeldDeltaausrichtung = i7Data.deltaausrichtung;
+                    const kpFeldI7KnotenBeziehungen = i7knotenBeziehungen.filter(elem => elem.seliste === i7Data.kpfeld);
+                    const nsgSAABObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsaa, variantenNr });
+                    const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSAABObjKey);
+                    if (nsgSAAB === undefined)
+                        continue;
+                    const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSAAB.nsgsa, variantenNr });
+                    const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                    if (nsgSchaltanlage === undefined)
+                        continue;
+                    const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSchaltanlage.nsgso, variantenNr });
+                    const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                    if (nsgStandort === undefined)
+                        continue;
+                    const relevantSSabIDs = new Set();
+                    nsgSAAB.nsgSsabs.forEach(arg => relevantSSabIDs.add(arg.idSSAB));
+                    const ssabKeyIDs = DLConverterI7.type2i7IDs.get(data_types_1.DataTypes.NSG_SSAB);
+                    const nsgSSABs = new Map();
+                    for (const ssabKeyID of ssabKeyIDs) {
+                        const nsgSSAB = DLConverterI7.i7ID2DbNsgObject.get(ssabKeyID);
+                        nsgSSABs.set(nsgSSAB.idSSAB, nsgSSAB);
+                    }
+                    const placedCIMObjectUUIDs = new Set(DLConverterI7.cimUUID2Object.keys());
+                    const nodePointMap = util_functions_1.DLUtilFunctions.placeKupplung(kpFeldI7KnotenBeziehungen, relevantSSabIDs, nsgSSABs, this.inputArgs.integralID2UUID, placedCIMObjectUUIDs, kpFeldDeltaausrichtung, kpFeldLeftOffset, false, this.inputArgs.objects);
+                    for (const nodePointEntry of nodePointMap.entries()) {
+                        const key = nodePointEntry[0];
+                        const value = nodePointEntry[1];
+                        if (DLConverterI7.cimUUID2Object.has(value.getUUID()))
+                            continue;
+                        const cimObjectUUID = this.inputArgs.integralID2UUID.get(key);
+                        value.identifiedObjectUUID = cimObjectUUID;
+                        value.rotation += (util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung) - 90 + 720);
+                        value.rotation = value.rotation % 360;
+                        value.diagramUUID = this.activeDiagram.getUUID();
+                        const schemaObjKey = DLConverterI7.createSchemaKeyObject({
+                            i7ID: key,
+                            variantenNr,
+                            additionalIDs: [i7Data.id]
+                        });
+                        DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_NODE);
+                        DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                            identifiedObjectUUID: cimObjectUUID,
+                            diagramObjectUUID: value.getUUID()
+                        });
+                        DLConverterI7.addCimObjects(value);
+                    }
+                    util_functions_1.DLUtilFunctions.rotateAndShiftBasedOnNsgSAA(nsgStandort, nsgSchaltanlage, nsgSAAB, [...nodePointMap.values()], true);
+                }
+            }
+        });
+    }
+    convertSchemaLaengskupplungen(variantenNr, onlyEingeblendet, laengskupplungIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const saabKeyIDs = DLConverterI7.type2i7IDs.get(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT);
+            if (saabKeyIDs === undefined) {
+                return;
+            }
+            const nsgSAABIDs = new Set();
+            for (const saabKeyID of saabKeyIDs) {
+                const nsgSAAB = DLConverterI7.i7ID2DbNsgObject.get(saabKeyID);
+                nsgSAABIDs.add(nsgSAAB.id);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_LAENGSKUPPLUNG) && laengskupplungIDs.length > 0 && saabKeyIDs.length > 0) {
+                const i7relevantTables = [
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNER_3P],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNERFI_3P],
+                    integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_STARR]
+                ];
+                const i7checkedTables = this.filterTablesByAvailability(i7relevantTables);
+                const i7knotenBeziehungen = yield this.mysqlController.execQuery((0, integral_sql_1.getI7KnotenBeziehungenQuery)(i7checkedTables, laengskupplungIDs));
+                const resultsNsgLKupplung = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_LAENGSKUPPLUNG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_LAENGSKUPPLUNG), [...nsgSAABIDs.values()]));
+                const filteredResultsNsgLKupplung = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(resultsNsgLKupplung, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResultsNsgLKupplung) {
+                    DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_LAENGSKUPPLUNG);
+                    const nsgSAABObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsaa, variantenNr });
+                    const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSAABObjKey);
+                    if (nsgSAAB === undefined)
+                        continue;
+                    const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSAAB.nsgsa, variantenNr });
+                    const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                    if (nsgSchaltanlage === undefined)
+                        continue;
+                    const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSchaltanlage.nsgso, variantenNr });
+                    const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                    if (nsgStandort === undefined)
+                        continue;
+                    const nodePointMap = new Map();
+                    const netzLaengskupplungsObjs = [...this.inputArgs.integralLaengskupplungen.values()].filter(elem => elem.schaltanlagenID === nsgSchaltanlage.schaltanlage);
+                    for (const netzLaengskupplungObj of netzLaengskupplungsObjs) {
+                        const lKupplungI7KnotenBeziehungen = i7knotenBeziehungen.filter(elem => elem.seliste === netzLaengskupplungObj.id);
+                        const relevantSsabIDs = new Set();
+                        const nsgSSABs = new Map();
+                        nsgSchaltanlage.nsgSaabs.forEach(iNsgSAAB => iNsgSAAB.nsgSsabs.forEach(iNsgSsab => {
+                            relevantSsabIDs.add(iNsgSsab.idSSAB);
+                            nsgSSABs.set(iNsgSsab.idSSAB, iNsgSsab);
+                        }));
+                        const placedCIMObjectUUIDs = new Set(DLConverterI7.cimUUID2Object.keys());
+                        const tempNodePointMap = util_functions_1.DLUtilFunctions.placeKupplung(lKupplungI7KnotenBeziehungen, relevantSsabIDs, nsgSSABs, this.inputArgs.integralID2UUID, placedCIMObjectUUIDs, 0, 0, true, this.inputArgs.objects);
+                        tempNodePointMap.forEach((value, key) => nodePointMap.set(key, value));
+                    }
+                    for (const nodePointEntry of nodePointMap.entries()) {
+                        const key = nodePointEntry[0];
+                        const value = nodePointEntry[1];
+                        if (DLConverterI7.cimUUID2Object.has(value.getUUID()))
+                            continue;
+                        const cimObjectUUID = this.inputArgs.integralID2UUID.get(key);
+                        value.identifiedObjectUUID = cimObjectUUID;
+                        if (value.rotation === undefined) {
+                            value.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                        }
+                        else {
+                            value.rotation += util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                        }
+                        value.diagramUUID = this.activeDiagram.getUUID();
+                        const schemaObjKey = DLConverterI7.createSchemaKeyObject({
+                            i7ID: key,
+                            variantenNr,
+                            additionalIDs: [i7Data.id]
+                        });
+                        DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_NODE);
+                        DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                            identifiedObjectUUID: cimObjectUUID,
+                            diagramObjectUUID: value.getUUID()
+                        });
+                        DLConverterI7.addCimObjects(value);
+                    }
+                    util_functions_1.DLUtilFunctions.rotateAndShiftBasedOnNsgSAA(nsgStandort, nsgSchaltanlage, nsgSAAB, [...nodePointMap.values()]);
+                }
+            }
+        });
+    }
+    convertSchemaTransformatoren2W(variantenNr, onlyEingeblendet, powerTransformers) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgStandortKeyIDs = DLConverterI7.type2i7IDs.get(data_types_1.DataTypes.NSG_STANDORT);
+            if (nsgStandortKeyIDs === undefined) {
+                return;
+            }
+            const nsgStandortIDs = new Set();
+            for (const nsgStandortKeyID of nsgStandortKeyIDs) {
+                const nsgStandort = DLConverterI7.i7ID2DbNsgObject.get(nsgStandortKeyID);
+                nsgStandortIDs.add(nsgStandort.id);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_TRAFO2W) && nsgStandortIDs.size > 0) {
+                const results = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_TRAFO2W, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_TRAFO2W), [...nsgStandortIDs.values()]));
+                const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(results, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResults) {
+                    const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_TRAFO2W);
+                    const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgso, variantenNr });
+                    const nsgSo = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                    if (nsgSo === undefined)
+                        continue;
+                    const powerTransformerUUID = this.inputArgs.integralID2UUID.get(i7Data.trafo2w);
+                    const powerTransformer = powerTransformers.get(powerTransformerUUID);
+                    if (powerTransformer === undefined)
+                        continue;
+                    const terminal1 = (_a = powerTransformer.powerTransformerEnds[0]) === null || _a === void 0 ? void 0 : _a.terminal;
+                    const terminal2 = (_b = powerTransformer.powerTransformerEnds[1]) === null || _b === void 0 ? void 0 : _b.terminal;
+                    const powerTransformerDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: constants_1.NsgConstants.TRAFO2W_WIDTH / 2,
+                        yPosition: constants_1.NsgConstants.TRAFO2W_HEIGHT / 2,
+                        rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnTrafo2W(i7Data.ausrichtung),
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: powerTransformerUUID,
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    const createdDiagramObjects = [];
+                    createdDiagramObjects.push(powerTransformerDiagramObject);
+                    let terminal1DiagramObject;
+                    if (terminal1 !== undefined) {
+                        terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: 0,
+                            yPosition: constants_1.NsgConstants.TRAFO2W_HEIGHT / 2,
+                            diagramObjectName: 'DiagramObject',
+                            identifiedObjectUUID: terminal1.getUUID(),
+                            diagramUUID: this.activeDiagram.getUUID()
+                        });
+                        createdDiagramObjects.push(terminal1DiagramObject);
+                    }
+                    let terminal2DiagramObject;
+                    if (terminal2 !== undefined) {
+                        terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: constants_1.NsgConstants.TRAFO2W_WIDTH,
+                            yPosition: constants_1.NsgConstants.TRAFO2W_HEIGHT / 2,
+                            diagramObjectName: 'DiagramObject',
+                            identifiedObjectUUID: terminal2.getUUID(),
+                            diagramUUID: this.activeDiagram.getUUID()
+                        });
+                        createdDiagramObjects.push(terminal2DiagramObject);
+                    }
+                    for (const diagramObject of createdDiagramObjects) {
+                        for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                            util_functions_1.DLUtilFunctions.rotateDiagramObjectPoint(diagramObjectPoint, 90 * i7Data.ausrichtung);
+                            diagramObjectPoint.xPosition = Math.abs(diagramObjectPoint.xPosition);
+                            diagramObjectPoint.yPosition = Math.abs(diagramObjectPoint.yPosition);
+                            diagramObjectPoint.xPosition += i7Data.xrel;
+                            diagramObjectPoint.yPosition += i7Data.yrel;
+                            diagramObjectPoint.xPosition += nsgSo.xrel;
+                            diagramObjectPoint.yPosition += nsgSo.yrel;
+                        }
+                    }
+                    if (terminal1 !== undefined) {
+                        const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(terminal1.getConnectivityNodeUUID());
+                        if (connectivityNodeDiagramObject !== undefined) {
+                            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal1DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                        }
+                    }
+                    if (terminal2 !== undefined) {
+                        const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(terminal2.getConnectivityNodeUUID());
+                        if (connectivityNodeDiagramObject !== undefined) {
+                            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal2DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                        }
+                    }
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: powerTransformerUUID,
+                        diagramObjectUUID: powerTransformerDiagramObject.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(powerTransformerDiagramObject);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_TRAFO2W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaTransformatoren3W(variantenNr, onlyEingeblendet, powerTransformers) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const nsgStandortKeyIDs = DLConverterI7.type2i7IDs.get(data_types_1.DataTypes.NSG_STANDORT);
+            if (nsgStandortKeyIDs === undefined) {
+                return;
+            }
+            const nsgStandortIDs = new Set();
+            const netzStandortIDs = new Set();
+            for (const nsgStandortKeyID of nsgStandortKeyIDs) {
+                const nsgStandort = DLConverterI7.i7ID2DbNsgObject.get(nsgStandortKeyID);
+                nsgStandortIDs.add(nsgStandort.id);
+                netzStandortIDs.add(nsgStandort.standort);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_TRAFO3W) && nsgStandortIDs.size > 0) {
+                const results = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_TRAFO3W, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_TRAFO3W), [...nsgStandortIDs.values()]));
+                const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(results, variantenNr, onlyEingeblendet);
+                const netzTrafoResults = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.TRAFO3W, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.TRAFO3W), [...netzStandortIDs.values()]));
+                const netzTrafos = new Map(netzTrafoResults.map(obj => [obj.id, obj]));
+                for (const i7Data of filteredResults) {
+                    const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_TRAFO3W);
+                    const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgso, variantenNr });
+                    const nsgSo = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                    if (nsgSo === undefined)
+                        continue;
+                    const powerTransformerUUID = this.inputArgs.integralID2UUID.get(i7Data.trafo3w);
+                    const powerTransformer = powerTransformers.get(powerTransformerUUID);
+                    if (powerTransformer === undefined)
+                        continue;
+                    const trafo3wNetz = netzTrafos.get(i7Data.trafo3w);
+                    if (trafo3wNetz === undefined)
+                        continue;
+                    const pteW1 = this.inputArgs.powerTransformerEnds.get(this.inputArgs.integralID2UUID.get(trafo3wNetz.trafowicklung3w1));
+                    const pteW2 = this.inputArgs.powerTransformerEnds.get(this.inputArgs.integralID2UUID.get(trafo3wNetz.trafowicklung3w2));
+                    const pteW3 = this.inputArgs.powerTransformerEnds.get(this.inputArgs.integralID2UUID.get(trafo3wNetz.trafowicklung3w3));
+                    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(i7Data.ausrichtung) * 30 + 180) % 360) % 360,
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: powerTransformerUUID,
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    const exchangeGroups = constants_1.NsgConstants.TRAFO3W_ExchangeGroups;
+                    let exchangeGroup = undefined;
+                    for (const key of Object.keys(exchangeGroups)) {
+                        if (exchangeGroups[key].indexOf(i7Data.ausrichtung) !== -1) {
+                            exchangeGroup = constants_1.NsgConstants.TRAFO3W_ExchangeMap[key];
+                            break;
+                        }
+                    }
+                    const rotationenGroups = constants_1.NsgConstants.TRAFO3W_RotationGroups;
+                    let rotationenGroup = undefined;
+                    for (const key of Object.keys(rotationenGroups)) {
+                        if (rotationenGroups[key].indexOf(i7Data.ausrichtung) !== -1) {
+                            rotationenGroup = constants_1.NsgConstants.TRAFO3W_RotationGroup2Positions[key];
+                            break;
+                        }
+                    }
+                    const xMirroring = i7Data.orientierung_cw === 1;
+                    const createdDiagramObjects = [];
+                    createdDiagramObjects.push(powerTransformerDiagramObject);
+                    let terminal1DiagramObject;
+                    if ((pteW1 === null || pteW1 === void 0 ? void 0 : pteW1.terminal) !== undefined) {
+                        const coords = rotationenGroup[exchangeGroup[1]];
+                        terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: coords[0],
+                            yPosition: coords[1],
+                            diagramObjectName: 'DiagramObject',
+                            identifiedObjectUUID: pteW1.terminal.getUUID(),
+                            diagramUUID: this.activeDiagram.getUUID()
+                        });
+                        createdDiagramObjects.push(terminal1DiagramObject);
+                    }
+                    let terminal2DiagramObject;
+                    if ((pteW2 === null || pteW2 === void 0 ? void 0 : pteW2.terminal) !== undefined) {
+                        const coords = rotationenGroup[exchangeGroup[xMirroring ? 3 : 2]];
+                        terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: coords[0],
+                            yPosition: coords[1],
+                            diagramObjectName: 'DiagramObject',
+                            identifiedObjectUUID: pteW2.terminal.getUUID(),
+                            diagramUUID: this.activeDiagram.getUUID()
+                        });
+                        createdDiagramObjects.push(terminal2DiagramObject);
+                    }
+                    let terminal3DiagramObject;
+                    if ((pteW3 === null || pteW3 === void 0 ? void 0 : pteW3.terminal) !== undefined) {
+                        const coords = rotationenGroup[exchangeGroup[xMirroring ? 2 : 3]];
+                        terminal3DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: coords[0],
+                            yPosition: coords[1],
+                            diagramObjectName: 'DiagramObject',
+                            identifiedObjectUUID: pteW3.terminal.getUUID(),
+                            diagramUUID: this.activeDiagram.getUUID()
+                        });
+                        createdDiagramObjects.push(terminal3DiagramObject);
+                    }
+                    for (const diagramObject of createdDiagramObjects) {
+                        for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                            diagramObjectPoint.xPosition += i7Data.xrel;
+                            diagramObjectPoint.yPosition += i7Data.yrel;
+                            diagramObjectPoint.xPosition += nsgSo.xrel;
+                            diagramObjectPoint.yPosition += nsgSo.yrel;
+                        }
+                    }
+                    if ((pteW1 === null || pteW1 === void 0 ? void 0 : pteW1.terminal) !== undefined) {
+                        const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(pteW1.terminal.getConnectivityNodeUUID());
+                        if (connectivityNodeDiagramObject !== undefined) {
+                            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal1DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                        }
+                    }
+                    if ((pteW2 === null || pteW2 === void 0 ? void 0 : pteW2.terminal) !== undefined) {
+                        const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(pteW2.terminal.getConnectivityNodeUUID());
+                        if (connectivityNodeDiagramObject !== undefined) {
+                            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal2DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                        }
+                    }
+                    if ((pteW3 === null || pteW3 === void 0 ? void 0 : pteW3.terminal) !== undefined) {
+                        const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(pteW3.terminal.getConnectivityNodeUUID());
+                        if (connectivityNodeDiagramObject !== undefined) {
+                            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal3DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                        }
+                    }
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: powerTransformerUUID,
+                        diagramObjectUUID: powerTransformerDiagramObject.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(powerTransformerDiagramObject);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_TRAFO3W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaLeitungen(variantenNr, onlyEingeblendet) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.inputArgs.integralLeitungen === undefined) {
+                this.inputArgs.integralLeitungen = new Map();
+            }
+            if (this.inputArgs.integralHgueLeitungen === undefined) {
+                this.inputArgs.integralHgueLeitungen = new Map();
+            }
+            const leitungIDs = [...this.inputArgs.integralLeitungen.keys(), ...this.inputArgs.integralHgueLeitungen.keys()];
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_LEITUNG) && this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_LEITUNGSPUNKT) && leitungIDs.length > 0) {
+                const leitungResults = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_LEITUNG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_LEITUNG), leitungIDs));
+                let filteredLeitungResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(leitungResults, variantenNr, onlyEingeblendet);
+                const nsgLeitungIDs = filteredLeitungResults.map(elem => elem.id);
+                if (nsgLeitungIDs.length > 0) {
+                    const leitungspktResults = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_LEITUNGSPUNKT, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_LEITUNGSPUNKT), nsgLeitungIDs));
+                    let filteredLeitungspktResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(leitungspktResults, variantenNr, onlyEingeblendet);
+                    for (const i7Data of filteredLeitungResults) {
+                        const schemaObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.id, variantenNr });
+                        DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_LEITUNG);
+                        const isACLine = this.inputArgs.integralLeitungen.get(i7Data.leitung);
+                        const isErsatzlaengszweig = false;
+                        let netzLeitungsObject;
+                        if (isACLine) {
+                            const netzLeitung = this.inputArgs.integralLeitungen.get(i7Data.leitung);
+                            if (netzLeitung !== undefined) {
+                                netzLeitungsObject = {
+                                    id: netzLeitung.id,
+                                    aknotenid: netzLeitung.aknotenid,
+                                    eknotenid: netzLeitung.eknotenid
+                                };
+                            }
+                        }
+                        else {
+                            const netzHgueLeitung = this.inputArgs.integralHgueLeitungen.get(i7Data.leitung);
+                            if (netzHgueLeitung !== undefined) {
+                                netzLeitungsObject = {
+                                    id: netzHgueLeitung.id,
+                                    aknotenid: netzHgueLeitung.anetzobjekt,
+                                    eknotenid: netzHgueLeitung.enetzobjekt
+                                };
+                            }
+                        }
+                        if (netzLeitungsObject === undefined)
+                            continue;
+                        const anfSchemaTypeObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.anschlussanf, variantenNr });
+                        let anfNsgObject = DLConverterI7.getDbNsgObjectByID(anfSchemaTypeObjKey);
+                        let anfSchemaType = DLConverterI7.i7ID2Type.get(anfSchemaTypeObjKey);
+                        let anfDiagramObject;
+                        if (anfSchemaType === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+                            const nsgSchaltfeld = anfNsgObject;
+                            if (nsgSchaltfeld === undefined)
+                                continue;
+                            anfDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(nsgSchaltfeld.lastNodeCimUUID);
+                        }
+                        else if (anfSchemaType === data_types_1.DataTypes.NSG_NODE) {
+                            const aKnotenCimObjectUUID = this.inputArgs.integralID2UUID.get(netzLeitungsObject.aknotenid);
+                            anfDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(aKnotenCimObjectUUID);
+                        }
+                        else {
+                            let anfUUIDEntry = DLConverterI7.i7ID2cimUUIDs.get(anfSchemaTypeObjKey);
+                            if (anfUUIDEntry === undefined)
+                                continue;
+                            anfDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(anfUUIDEntry.identifiedObjectUUID);
+                        }
+                        const endSchemaTypeObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.anschlussend, variantenNr });
+                        let endNsgObject = DLConverterI7.getDbNsgObjectByID(endSchemaTypeObjKey);
+                        let endSchemaType = DLConverterI7.i7ID2Type.get(endSchemaTypeObjKey);
+                        let endDiagramObject;
+                        if (endSchemaType === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+                            const nsgSchaltfeld = endNsgObject;
+                            if (nsgSchaltfeld === undefined)
+                                continue;
+                            endDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(nsgSchaltfeld.lastNodeCimUUID);
+                        }
+                        else if (endSchemaType === data_types_1.DataTypes.NSG_NODE) {
+                            const eKnotenCimObjectUUID = this.inputArgs.integralID2UUID.get(netzLeitungsObject.eknotenid);
+                            endDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(eKnotenCimObjectUUID);
+                        }
+                        else {
+                            let endUUIDEntry = DLConverterI7.i7ID2cimUUIDs.get(endSchemaTypeObjKey);
+                            if (endUUIDEntry === undefined)
+                                continue;
+                            endDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(endUUIDEntry.identifiedObjectUUID);
+                        }
+                        let tempDiagramObjectPoints = [];
+                        let tempAnfDiagramObject = anfDiagramObject;
+                        let tempEndDiagramObject = endDiagramObject;
+                        if (tempAnfDiagramObject === undefined || tempEndDiagramObject === undefined)
+                            continue;
+                        tempDiagramObjectPoints.push({
+                            xPosition: tempAnfDiagramObject.diagramObjectPoints[0].xPosition,
+                            yPosition: tempAnfDiagramObject.diagramObjectPoints[0].yPosition
+                        });
+                        const relevantLeitungspkts = filteredLeitungspktResults.filter(elem => elem.nsgleitung === i7Data.id).sort((a, b) => a.pos - b.pos);
+                        for (let a = 0; a < relevantLeitungspkts.length; a++) {
+                            const nsgLeitungspkt = relevantLeitungspkts[a];
+                            if (nsgLeitungspkt.userelpos === 1 && nsgLeitungspkt.reltoanf === 1) {
+                                const tempDiagramObjectPoint = {
+                                    xPosition: tempAnfDiagramObject.diagramObjectPoints[0].xPosition,
+                                    yPosition: tempAnfDiagramObject.diagramObjectPoints[0].yPosition
+                                };
+                                const tempOffsetArray = util_functions_1.DLUtilFunctions.getXYOffsetFromRelCM(anfSchemaType, anfNsgObject, i7Data.anschlussanf, nsgLeitungspkt);
+                                tempDiagramObjectPoint.xPosition += tempOffsetArray[0];
+                                tempDiagramObjectPoint.yPosition += tempOffsetArray[1];
+                                tempDiagramObjectPoints.push(tempDiagramObjectPoint);
+                            }
+                            else if (nsgLeitungspkt.userelpos === 1 && nsgLeitungspkt.reltoanf === 0) {
+                                const tempDiagramObjectPoint = {
+                                    xPosition: tempEndDiagramObject.diagramObjectPoints[0].xPosition,
+                                    yPosition: tempEndDiagramObject.diagramObjectPoints[0].yPosition
+                                };
+                                const tempOffsetArray = util_functions_1.DLUtilFunctions.getXYOffsetFromRelCM(endSchemaType, endNsgObject, i7Data.anschlussend, nsgLeitungspkt);
+                                tempDiagramObjectPoint.xPosition += tempOffsetArray[0];
+                                tempDiagramObjectPoint.yPosition += tempOffsetArray[1];
+                                tempDiagramObjectPoints.push(tempDiagramObjectPoint);
+                            }
+                            else {
+                                tempDiagramObjectPoints.push({ xPosition: nsgLeitungspkt.xrel, yPosition: nsgLeitungspkt.yrel });
+                            }
+                        }
+                        tempDiagramObjectPoints.push({
+                            xPosition: tempEndDiagramObject.diagramObjectPoints[0].xPosition,
+                            yPosition: tempEndDiagramObject.diagramObjectPoints[0].yPosition
+                        });
+                        if (isACLine) {
+                            const netzLeitungCimObj = this.inputArgs.lines.get(this.inputArgs.integralID2UUID.get(netzLeitungsObject.id));
+                            const cableAvailable = this.isTableAvailable(integral_sql_1.Integral7TableNames.KABEL);
+                            const overheadAvailable = this.isTableAvailable(integral_sql_1.Integral7TableNames.FREILEITUNG);
+                            let type = integral_sql_1.I7Objects.STROMKREISABSCHNITT;
+                            if (cableAvailable && overheadAvailable) {
+                                type = integral_sql_1.I7Objects.STROMKREISABSCHNITT_KABEL_FREILEITUNG;
+                            }
+                            else if (cableAvailable) {
+                                type = integral_sql_1.I7Objects.STROMKREISABSCHNITT_KABEL;
+                            }
+                            else if (overheadAvailable) {
+                                type = integral_sql_1.I7Objects.STROMKREISABSCHNITT_FREILEITUNG;
+                            }
+                            const leitungStromkreisabschnitt = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(type, ['leitung', 'laenge', 'pos', 'typ'], [netzLeitungsObject.id]));
+                            leitungStromkreisabschnitt.sort((a, b) => a.pos - b.pos);
+                            const acSegmentPercentages = [];
+                            let completeLength = 0;
+                            for (let a = 0; a < leitungStromkreisabschnitt.length; ++a) {
+                                completeLength += leitungStromkreisabschnitt[a].laenge;
+                            }
+                            let crtLength = 0;
+                            for (let a = 0; a < leitungStromkreisabschnitt.length; ++a) {
+                                crtLength += leitungStromkreisabschnitt[a].laenge;
+                                acSegmentPercentages.push(crtLength / completeLength);
+                            }
+                            const eqUUIDs = netzLeitungCimObj.equipments.map(value => value.getUUID());
+                            const resultingDiagramObjects = util_functions_1.DLUtilFunctions.convertACLineSegment(completeLength, acSegmentPercentages, eqUUIDs, tempDiagramObjectPoints);
+                            for (const diagramObject of resultingDiagramObjects) {
+                                diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                            }
+                            DLConverterI7.addCimObjects(...resultingDiagramObjects);
+                        }
+                        else if (isErsatzlaengszweig) {
+                        }
+                        else {
+                            const netzLeitungCimObj = this.inputArgs.objects.get(this.inputArgs.integralID2UUID.get(netzLeitungsObject.id));
+                            const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)());
+                            diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                            diagramObject.identifiedObjectUUID = this.inputArgs.integralID2UUID.get(netzLeitungsObject.id);
+                            if (netzLeitungCimObj !== undefined) {
+                                diagramObject.name = 'DiagramObj ' + ((_a = netzLeitungCimObj.shortName) !== null && _a !== void 0 ? _a : '');
+                            }
+                            else {
+                                diagramObject.name = 'DiagramObj HGUE-Leitung';
+                            }
+                            for (let idx = 0; idx < tempDiagramObjectPoints.length; ++idx) {
+                                const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(tempDiagramObjectPoints[idx].xPosition, tempDiagramObjectPoints[idx].yPosition, idx + 1);
+                                diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+                                diagramObjectPoint.diagramObject = diagramObject;
+                                diagramObject.addDiagramObjectPoint(diagramObjectPoint);
+                            }
+                            DLConverterI7.addCimObjects(diagramObject);
+                        }
+                        const clonedAnfDiagramObject = util_functions_1.DLUtilFunctions.cloneDiagramObject(anfDiagramObject);
+                        clonedAnfDiagramObject.diagramUUID = this.activeDiagram.getUUID();
+                        const clonedEndDiagramObject = util_functions_1.DLUtilFunctions.cloneDiagramObject(endDiagramObject);
+                        clonedEndDiagramObject.diagramUUID = this.activeDiagram.getUUID();
+                        DLConverterI7.addCimObjects(clonedAnfDiagramObject, clonedEndDiagramObject);
+                    }
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_LEITUNG} oder ${integral_sql_1.Integral7TableNames.NSG_LEITUNGSPUNKT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaQuerzweige(variantenNr, onlyEingeblendet) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const whereIDs = [...DLConverterI7.i7ID2DbNsgObjectInFrame.keys()].map(arg => DLConverterI7.parseSchemaKeyObject(arg).i7ID);
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_QUERZWEIG) && whereIDs.length > 0) {
+                const results = yield this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_QUERZWEIG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_QUERZWEIG), whereIDs));
+                let filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(results, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredResults) {
+                    const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_QUERZWEIG);
+                    const referenceObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.bezugsobjekt, variantenNr });
+                    const referenceObjType = DLConverterI7.i7ID2Type.get(referenceObjKey);
+                    const referenceObj = DLConverterI7.getDbNsgObjectByID(referenceObjKey);
+                    let refXPos = 0;
+                    let refYPos = 0;
+                    let xPos = i7Data.xrel;
+                    let yPos = i7Data.yrel;
+                    let refCNNodeUUID = undefined;
+                    let nsgQuerzweigWidth;
+                    let nsgQuerzweigHeight;
+                    nsgQuerzweigWidth = constants_1.NsgConstants.QUERZWEIG_OBJ_WIDTH;
+                    nsgQuerzweigHeight = constants_1.NsgConstants.QUERZWEIG_OBJ_HEIGHT;
+                    if (referenceObjType === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+                        const nsgSchaltfeld = referenceObj;
+                        refCNNodeUUID = nsgSchaltfeld.lastNodeCimUUID;
+                        const referenceDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(nsgSchaltfeld.lastNodeCimUUID);
+                        if (referenceDiagramObject === undefined)
+                            continue;
+                        refXPos = referenceDiagramObject.diagramObjectPoints[0].xPosition;
+                        refYPos = referenceDiagramObject.diagramObjectPoints[0].yPosition;
+                        xPos += refXPos;
+                        yPos += refYPos;
+                        switch (nsgSchaltfeld.orientation) {
+                            case 3:
+                                xPos += nsgQuerzweigWidth / 2;
+                                yPos -= nsgQuerzweigHeight / 2;
+                                break;
+                            case 0:
+                                xPos -= nsgQuerzweigWidth / 2;
+                                yPos += nsgQuerzweigHeight / 2;
+                                break;
+                            case 1:
+                                xPos += nsgQuerzweigWidth / 2;
+                                yPos -= nsgQuerzweigHeight / 2;
+                                xPos -= nsgSchaltfeld.hoehe;
+                                break;
+                            case 2:
+                                xPos -= nsgQuerzweigWidth / 2;
+                                yPos += nsgQuerzweigHeight / 2;
+                                yPos -= nsgSchaltfeld.hoehe;
+                                break;
+                        }
+                    }
+                    else if (referenceObjType === integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO) {
+                        refCNNodeUUID = DLConverterI7.i7ID2cimUUIDs.get(referenceObjKey).identifiedObjectUUID;
+                        const referenceDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(refCNNodeUUID);
+                        if (referenceDiagramObject === undefined)
+                            continue;
+                        refXPos = referenceDiagramObject.diagramObjectPoints[0].xPosition;
+                        refYPos = referenceDiagramObject.diagramObjectPoints[0].yPosition;
+                        xPos += refXPos;
+                        yPos += refYPos;
+                        xPos -= nsgQuerzweigWidth / 2;
+                        yPos -= nsgQuerzweigHeight / 2;
+                    }
+                    else {
+                        this.logger.info(`unhandled reference type '${referenceObjType}' for id ${i7Data.bezugsobjekt} (nsg_nsgquerzweig.id ${i7Data.id})!`);
+                        continue;
+                    }
+                    const querzweigObjectUUID = this.inputArgs.integralID2UUID.get(i7Data.querzweig);
+                    const querzweigDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: xPos,
+                        yPosition: yPos,
+                        rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(i7Data.ausrichtung),
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: querzweigObjectUUID,
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: querzweigObjectUUID,
+                        diagramObjectUUID: querzweigDiagramObject.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(querzweigDiagramObject);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_QUERZWEIG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaTerminals() {
+        const exportedTerminals = new Set();
+        for (const diagramObject of DLConverterI7.cimUUID2DiagramObject.values()) {
+            const identifiedObject = this.inputArgs.objects.get(diagramObject.getIdentifiedObjectUUID());
+            if (identifiedObject instanceof ConnectivityNode_1.ConnectivityNode) {
+                identifiedObject.terminals.forEach(terminal => this.convertTerminal(terminal, exportedTerminals));
+            }
+            else if (identifiedObject instanceof ConductingEquipment_1.ConductingEquipment) {
+                identifiedObject.terminals.forEach(terminal => this.convertTerminal(terminal, exportedTerminals));
+            }
+        }
+    }
+    convertTerminal(terminal, exportedTerminals) {
+        if (exportedTerminals.has(terminal.getUUID()))
+            return;
+        exportedTerminals.add(terminal.getUUID());
+        const connectivityNodeUUID = terminal.getConnectivityNodeUUID();
+        const connectivityNode = this.inputArgs.objects.get(connectivityNodeUUID);
+        const conductingEquipmentUUID = terminal.getConductingEquipmentUUID();
+        const conductingEquipment = this.inputArgs.objects.get(conductingEquipmentUUID);
+        if (connectivityNode === undefined || conductingEquipment === undefined)
+            return;
+        const cnDiagramObject = DLConverterI7.getDiagramObjectByUUID(connectivityNodeUUID);
+        const ceDiagramObject = DLConverterI7.getDiagramObjectByUUID(conductingEquipmentUUID);
+        if (cnDiagramObject === undefined || ceDiagramObject === undefined)
+            return;
+        const terminalDiagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)());
+        terminalDiagramObject.identifiedObjectUUID = terminal.getUUID();
+        terminalDiagramObject.diagramUUID = this.activeDiagram.getUUID();
+        const cnTerminals = [...connectivityNode.terminals.values()];
+        let isBusbarSectionConnectivityNode = false;
+        for (let a = 0; a < cnTerminals.length && !isBusbarSectionConnectivityNode; ++a) {
+            const possibleBusbarSectionObject = this.inputArgs.objects.get(cnTerminals[a].getConductingEquipmentUUID());
+            if (possibleBusbarSectionObject instanceof BusbarSection_1.BusbarSection) {
+                isBusbarSectionConnectivityNode = true;
+            }
+        }
+        const ceDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        ceDiagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+        if (conductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
+            const cnCenterPoint = util_functions_1.DLUtilFunctions.getCenterOfPoints(cnDiagramObject.diagramObjectPoints);
+            let closestDiagramObjectPoint = ceDiagramObject.diagramObjectPoints[0];
+            let dist = util_functions_1.DLUtilFunctions.lengthOfVector([
+                closestDiagramObjectPoint.xPosition - cnCenterPoint[0],
+                closestDiagramObjectPoint.yPosition - cnCenterPoint[1]
+            ]);
+            for (let a = 1; a < ceDiagramObject.diagramObjectPoints.length; ++a) {
+                const distToCheck = util_functions_1.DLUtilFunctions.lengthOfVector([
+                    ceDiagramObject.diagramObjectPoints[a].xPosition - cnCenterPoint[0],
+                    ceDiagramObject.diagramObjectPoints[a].yPosition - cnCenterPoint[1]
+                ]);
+                if (distToCheck < dist) {
+                    closestDiagramObjectPoint = ceDiagramObject.diagramObjectPoints[a];
+                    dist = distToCheck;
+                }
+            }
+            ceDiagramObjectPoint.xPosition = closestDiagramObjectPoint.xPosition;
+            ceDiagramObjectPoint.yPosition = closestDiagramObjectPoint.yPosition;
+        }
+        else {
+            ceDiagramObjectPoint.xPosition = ceDiagramObject.diagramObjectPoints[0].xPosition;
+            ceDiagramObjectPoint.yPosition = ceDiagramObject.diagramObjectPoints[0].yPosition;
+        }
+        if (isBusbarSectionConnectivityNode) {
+            this.convertBusbarSectionCNTerminal(terminalDiagramObject, cnDiagramObject, ceDiagramObjectPoint);
+        }
+        else {
+            ceDiagramObjectPoint.diagramObject = terminalDiagramObject;
+            terminalDiagramObject.diagramObjectPoints.push(ceDiagramObjectPoint);
+            const diagramObjectPoint2 = new DiagramObjectPoint_1.DiagramObjectPoint();
+            diagramObjectPoint2.mrid = (0, utils_1.generateUUID)();
+            diagramObjectPoint2.xPosition = cnDiagramObject.diagramObjectPoints[0].xPosition;
+            diagramObjectPoint2.yPosition = cnDiagramObject.diagramObjectPoints[0].yPosition;
+            diagramObjectPoint2.diagramObject = terminalDiagramObject;
+            terminalDiagramObject.diagramObjectPoints.push(diagramObjectPoint2);
+        }
+        for (let a = 0; a < terminalDiagramObject.diagramObjectPoints.length; ++a) {
+            terminalDiagramObject.diagramObjectPoints[a].sequenceNumber = (a + 1);
+        }
+        DLConverterI7.addCimObjects(terminalDiagramObject);
+    }
+    convertBusbarSectionCNTerminal(terminalDiagramObject, cnDiagramObject, ceDiagramObjectPoint) {
+        const dopCE = ceDiagramObjectPoint;
+        const dop1BusbarSection = new DiagramObjectPoint_1.DiagramObjectPoint();
+        dop1BusbarSection.mrid = (0, utils_1.generateUUID)();
+        dop1BusbarSection.xPosition = cnDiagramObject.diagramObjectPoints[0].xPosition;
+        dop1BusbarSection.yPosition = cnDiagramObject.diagramObjectPoints[0].yPosition;
+        const dop2BusbarSection = new DiagramObjectPoint_1.DiagramObjectPoint();
+        dop2BusbarSection.mrid = (0, utils_1.generateUUID)();
+        dop2BusbarSection.xPosition = cnDiagramObject.diagramObjectPoints[1].xPosition;
+        dop2BusbarSection.yPosition = cnDiagramObject.diagramObjectPoints[1].yPosition;
+        const tempVec = util_functions_1.DLUtilFunctions.vec2([dop1BusbarSection.xPosition, dop1BusbarSection.yPosition], [dop2BusbarSection.xPosition, dop2BusbarSection.yPosition], [dopCE.xPosition, dopCE.yPosition]);
+        const dist1 = util_functions_1.DLUtilFunctions.distanceVector2Line(tempVec, [dopCE.xPosition, dopCE.yPosition], [dop1BusbarSection.xPosition, dop1BusbarSection.yPosition]);
+        const dist2 = util_functions_1.DLUtilFunctions.distanceVector2Line(tempVec, [dopCE.xPosition, dopCE.yPosition], [dop2BusbarSection.xPosition, dop2BusbarSection.yPosition]);
+        terminalDiagramObject.diagramObjectPoints.push(dopCE);
+        dopCE.diagramObject = terminalDiagramObject;
+        if (util_functions_1.DLUtilFunctions.isNegativeOrZero(dist1) === util_functions_1.DLUtilFunctions.isNegativeOrZero(dist2)) {
+            const distDopCEdop1BS = util_functions_1.DLUtilFunctions.lengthOfVector([dopCE.xPosition - dop1BusbarSection.xPosition, dopCE.yPosition - dop1BusbarSection.yPosition]);
+            const distDopCEdop2BS = util_functions_1.DLUtilFunctions.lengthOfVector([dopCE.xPosition - dop2BusbarSection.xPosition, dopCE.yPosition - dop2BusbarSection.yPosition]);
+            const distDop1BSdop2BS = util_functions_1.DLUtilFunctions.lengthOfVector([dop1BusbarSection.xPosition - dop2BusbarSection.xPosition, dop1BusbarSection.yPosition - dop2BusbarSection.yPosition]);
+            if (Math.abs(distDopCEdop1BS + distDopCEdop2BS - distDop1BSdop2BS) < util_functions_1.DLUtilFunctions.EPSILON) {
+                const dopIntersection = new DiagramObjectPoint_1.DiagramObjectPoint();
+                dopIntersection.mrid = (0, utils_1.generateUUID)();
+                dopIntersection.xPosition = dopCE.xPosition;
+                dopIntersection.yPosition = dopCE.yPosition;
+                terminalDiagramObject.diagramObjectPoints.push(dopIntersection);
+                dopIntersection.diagramObject = terminalDiagramObject;
+            }
+            else {
+                if (distDopCEdop1BS < distDopCEdop2BS) {
+                    terminalDiagramObject.diagramObjectPoints.push(dop1BusbarSection);
+                    dop1BusbarSection.diagramObject = terminalDiagramObject;
+                }
+                else {
+                    terminalDiagramObject.diagramObjectPoints.push(dop2BusbarSection);
+                    dop2BusbarSection.diagramObject = terminalDiagramObject;
+                }
+            }
+        }
+        else {
+            const dopIntersection = new DiagramObjectPoint_1.DiagramObjectPoint();
+            dopIntersection.mrid = (0, utils_1.generateUUID)();
+            dopIntersection.xPosition = tempVec[0];
+            dopIntersection.yPosition = tempVec[1];
+            terminalDiagramObject.diagramObjectPoints.push(dopIntersection);
+            dopIntersection.diagramObject = terminalDiagramObject;
+        }
+    }
+    filterTablesByAvailability(relevantTables) {
+        let filteredRelevantTables = [];
+        for (const relevantTable of relevantTables) {
+            if (this.isTableAvailable(relevantTable)) {
+                filteredRelevantTables.push(relevantTable);
+            }
+        }
+        return filteredRelevantTables;
+    }
+    isTableAvailable(tableName) {
+        return this.i7TableName2Table.has(tableName);
+    }
+    getAvailableColumnNames(tableName) {
+        return this.i7TableName2Table.get(tableName).columnNames;
+    }
+    runAndLogPerformance(func, ...args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const startTime = perf_hooks_1.performance.now();
+            yield func.apply(this, args);
+            this.logger.debug(`${func.name} ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+            console.log(`${func.name} ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+        });
+    }
+}
+exports.DLConverterI7 = DLConverterI7;
+DLConverterI7.variantenNr2Diagram = new Map();
+DLConverterI7.type2i7IDs = new Map();
+DLConverterI7.i7ID2cimUUIDs = new Map();
+DLConverterI7.i7ID2Type = new Map();
+DLConverterI7.i7ID2DbNsgObject = new Map();
+DLConverterI7.cimUUID2i7ID = new Map();
+DLConverterI7.cimUUID2Object = new Map();
+DLConverterI7.cimUUID2DiagramObject = new Map();
+DLConverterI7.i7ID2DbNsgObjectInFrame = new Map();
+DLConverterI7.purgeData = true;
+DLConverterI7.cimModelObjects = new Model_1.Model();
+//# sourceMappingURL=dl-converter-i7.js.map