@enervance/insight-cim-model 0.0.12 → 0.0.14

package/src/converter/integral7/utils.ts

@@ -1,693 +0,0 @@
-import { BaseClass, Belastung, Wicklung } from './model/interfaces';
-import {
-  BaseVoltage,
-  Bay,
-  ConductingEquipment, ConnectivityNode, createBaseVoltageIfNotExists,
-  createRatioTapChangerTablePoint,
-  EquipmentContainer,
-  FossilFuel,
-  FuelType,
-  generateUUID,
-  IdentifiedObject,
-  IIdentifiedObject,
-  Line,
-  Model,
-  PowerTransformerEnd,
-  PowerTransformerInfo,
-  PSRType,
-  RatioTapChanger,
-  RatioTapChangerTable,
-  RegulatingControlModeKind, Substation,
-  SvTapStep,
-  TapChangerControl,
-  Terminal,
-  ThermalGeneratingUnit,
-  TransformerControlMode, VoltageLevel,
-  WindingConnection
-} from '../..';
-import fs from "fs";
-import JSZip from 'jszip';
-import path from "path";
-import { ConverterStatus } from './config/db-config';
-
-
-export function ueberpruefeZeichenkette(str: string) {
-  if (str)
-    return str;
-  else
-    return '';
-}
-
-export function getName(object: BaseClass): string {
-  if (object.bezeichner) {
-    return object.bezeichner;
-  } else if (object.name) {
-    return object.name;
-  } else if (object.langname) {
-    return object.langname;
-  } else if (object.kurzname) {
-    return object.kurzname;
-  }
-  return 'kein Name vorhanden ';
-}
-
-export function getLineByAttribute(cimModel: Model, lineAttribute: string, attributeInstance: string): Line | undefined {
-  for (const stromkreis of cimModel.lines.values()) {
-    if (stromkreis[lineAttribute] === attributeInstance) {
-      return stromkreis;
-    }
-  }
-  return;
-}
-
-export function getLine(cimModel: Model, bezeichner: string, kurzname: string): Line {
-
-  let line;
-  for (const stromkreis of cimModel.lines.values()) {
-    if (stromkreis.name === bezeichner || stromkreis.shortName === kurzname) {
-      return line = stromkreis;
-    }
-  }
-  /*  if(!line) {
-      line = new Line(generateUUID());
-      line[lineAttribute] = attributeInstance;
-      line.name = 'Stromkreis';
-      line.shortName = kurzname;
-      cimModel.addLine(line);
-    }
-    return line;*/
-  return;
-}
-
-export function getU(un: any, deafultUn: number): number {
-  return (isNaN(un) || un === null) ? deafultUn : +un;
-}
-
-/** Wenn die Objektreferenzen nicht vorhanden sind, wird das BV-Objekt über die UUID bestimmt. */
-export function getTerminalUn(cimModel: Model, ce: ConductingEquipment): BaseVoltage | undefined {
-  const terminals = ce.terminals.size > 0 ? [...ce.terminals.keys()] : ce.terminalsUUIDs;
-  for (const terminalUUID of terminals) {
-    const terminal = cimModel.getTerminal(terminalUUID);
-    if (terminal) {
-      if (terminal.connectivityNode) {
-        return terminal.connectivityNode.getBaseVoltage();
-      } else if (terminal.connectivityNodeUUID) {
-        const cn = cimModel.getObject(terminal.connectivityNodeUUID);
-        const cnContainerUUID = (cn as ConnectivityNode)?.getConnectivityNodeContainerUUID();
-        if (cnContainerUUID) {
-          const cnContainer = cimModel.getObject(cnContainerUUID);
-          let voltageLevel;
-          if (cnContainer instanceof Bay) {
-            voltageLevel = cimModel.getVoltageLevel((cnContainer as Bay).voltageLevelUUID);
-          } else if (cnContainer instanceof VoltageLevel) {
-            voltageLevel = cnContainer as VoltageLevel;
-          }
-          if (voltageLevel?.baseVoltage) {
-            return voltageLevel.getBaseVoltage();
-          } else if (voltageLevel?.baseVoltageUUID) {
-            return cimModel.getBaseVoltage(voltageLevel.baseVoltageUUID);
-          }
-        }
-      }
-    }
-  }
-  return;
-}
-
-export function convertToBooleanI7(value: any): boolean {
-  switch (value) {
-    case true:
-      return true;
-    case 'true':
-      return true;
-    case 'on':
-      return true;
-    case 'ja':
-      return true;
-    case 'yes':
-      return true;
-    case 1:
-      return true;
-
-    case false:
-      return false;
-    case 'false':
-      return false;
-    case 'off':
-      return false;
-    case '0':
-      return false;
-    case 0:
-      return false;
-    case 'nein':
-      return false;
-    case 'no':
-      return false;
-    default:
-      return undefined;
-  }
-}
-
-export function getSchaltgruppe(schaltgr: string, endNumber: number): WindingConnection {
-  switch (schaltgr) {
-    case 'DY5' :
-      if (endNumber === 1) {
-        return WindingConnection.D;
-      } else {
-        return WindingConnection.Yn;
-      }
-    case 'DY7' :
-      if (endNumber === 1) {
-        return WindingConnection.D;
-      } else {
-        return WindingConnection.Yn;
-      }
-    case 'YD5' :
-      if (endNumber === 1) {
-        return WindingConnection.Y;
-      } else {
-        return WindingConnection.D;
-      }
-    case 'YY0' :
-      if (endNumber === 1) {
-        return WindingConnection.Y;
-      } else {
-        return WindingConnection.Y;
-      }
-    case 'YNd5' :
-      if (endNumber === 1) {
-        return WindingConnection.Yn;
-      } else {
-        return WindingConnection.D;
-      }
-      break;
-    case 'Y0' :
-      if (endNumber === 1) {
-        return WindingConnection.Yn;
-      }
-      break;
-    case 'YY0D5' :
-      if (endNumber === 1 || endNumber === 2) {
-        return WindingConnection.Yn;
-      } else {
-        return WindingConnection.D;
-      }
-      break;
-    case 'YD5D5' :
-      if (endNumber === 1) {
-        return WindingConnection.Yn;
-      } else if (endNumber === 2 || endNumber === 3) {
-        return WindingConnection.D;
-      }
-      break;
-    default:
-      return ;
-  }
-}
-
-export function getSchaltgruppeAngleClock(schaltgr: string, endNumber: number): number {
-  switch (schaltgr) {
-    case 'DY5' :
-      if (endNumber === 1) {
-        return 0;
-      } else {
-        return 5;
-      }
-      break;
-    case 'YD5' :
-      if (endNumber === 1) {
-        return 0;
-      } else {
-        return 5;
-      }
-      break;
-    case 'YY0' :
-      return 0;
-      break;
-    case 'YNd5' :
-      if (endNumber === 1) {
-        return 0;
-      } else {
-        return 5;
-      }
-      break;
-    case 'Y0' :
-      if (endNumber === 1) {
-        return 0;
-      }
-      break;
-    case 'YY0D5' :
-      if (endNumber === 3) {
-        return 5;
-      }
-      break;
-    case 'YD5D5' :
-      if (endNumber === 2 || endNumber === 3) {
-        return 5;
-      }
-      break;
-    default:
-      return 0;
-  }
-}
-
-export function getPkrTrafo(i7Data: any, powerTransformerInfo: PowerTransformerInfo, pkr: string): number {
-  const prop = `pkr${pkr}`;
-  if (i7Data[prop] && i7Data[prop] !== 0) {
-    return i7Data[prop];
-  } else if (powerTransformerInfo && powerTransformerInfo[prop] && powerTransformerInfo[prop] !== 0) {
-    return powerTransformerInfo[prop];
-  }
-  return 0;
-}
-
-export function getUkrTrafo(i7Data: any, powerTransformerInfo: PowerTransformerInfo, ukr: string): number {
-  const prop = `ukr${ukr}`;
-  if (i7Data[prop] && i7Data[prop] !== 0) {
-    return i7Data[prop];
-  } else if (powerTransformerInfo && powerTransformerInfo[prop] && powerTransformerInfo[prop] !== 0) {
-    return powerTransformerInfo[prop];
-  }
-  return 0;
-}
-
-
-export function getSrTrafo(i7Data: any, powerTransformerInfo: PowerTransformerInfo, endNumber: number, isTrafo3W: boolean): number {
-  const prop = `sr${isTrafo3W ? endNumber : ''}`; // fix für 2W Trafos
-  if (i7Data[prop] && i7Data[prop] !== 0) {
-    return i7Data[prop];
-  } else if (powerTransformerInfo) {
-    const transformerEndInfo = powerTransformerInfo.transformerEndInfo.find(element => element.endNumber === endNumber);
-    if (transformerEndInfo && transformerEndInfo.ratedS) {
-      if (transformerEndInfo.ratedS.value && transformerEndInfo.ratedS.value !== 0) {
-        return transformerEndInfo.ratedS.value;
-      }
-    }
-  }
-  return 0;
-}
-
-export function getUrTrafo(i7Data: any, powerTransformerInfo: PowerTransformerInfo, endNumber: number): number {
-  const prop = `ur${endNumber}`;
-  if (i7Data[prop] && i7Data[prop] !== 0) {
-    return i7Data[prop];
-  } else if (powerTransformerInfo) {
-    const transformerEndInfo = powerTransformerInfo.transformerEndInfo.find(element => element.endNumber === endNumber);
-    if (transformerEndInfo && transformerEndInfo.ratedU) {
-      if (transformerEndInfo.ratedU && transformerEndInfo.ratedU.value !== 0) {
-        return transformerEndInfo.ratedU.value;
-      }
-    }
-  }
-  return 0;
-}
-
-/**
- * @param un Nennspannung in kV
- * @param pkr Kurzschlussverluste im Bemessungsbetrieb kW
- * @param sr Bemessungsscheinleistung in MVA  */
-export function calculateR(un: number, pkr: number, sr: number): number {
-  try {
-    return pkr * Math.pow(un, 2) / Math.pow(sr, 2) / 1000;
-  } catch (e) {
-  }
-  return 0;
-}
-
-/**
- * @param un Nennspannung in kV
- * @param ukr Kurzschlussspannung in %
- * @param sr Bemessungsscheinleistung in MVA
- * @param r Wiederstand in Ohm */
-export function calculateX(un: number, ukr: number, sr: number, r: number): number {
-  try {
-    return Math.sqrt(Math.pow(ukr, 2) * Math.pow(un, 4) / Math.pow(sr, 2) - Math.pow(r, 2));
-  } catch (e) {
-  }
-  return 0;
-}
-
-/**
- * @param un Nennspannung in kV
- * @param pLeer P0 Leerlaufverluste in kW */
-export function calculateG(un: number, pLeer: number): number {
-  try {
-    return 1000 * pLeer / Math.pow(un, 2);
-  } catch (e) {
-  }
-  return 0;
-}
-
-/**
- * @param un Nennspannung in kV
- * @param iLeer eerlaufstrom bezogen auf Wicklung mit dem grössten Sr in %
- * @param pLeer P0 Leerlaufverluste in kW*/
-export function calculateB(un: number, sr: number, iLeer: number, pLeer: number): number {
-  try {
-    return 1000 * Math.sqrt(Math.pow(sr * 1000, 2) * Math.pow(iLeer, 2) - Math.pow(pLeer, 2) / Math.pow(un, 2));
-  } catch (e) {
-  }
-  return 0;
-}
-
-// Leerlaufverluste
-export function getTrafoPleer(i7Data: any, powerTransformerInfo: PowerTransformerInfo): number {
-  if (i7Data['p_leer'] && i7Data['p_leer'] !== 0) {
-    return i7Data['p_leer'];
-  } else if (powerTransformerInfo && powerTransformerInfo['p_leer'] && powerTransformerInfo['p_leer'] !== 0) {
-    return powerTransformerInfo['p_leer'];
-  }
-  return 0;
-}
-
-// Leerlaufstrom bezogen auf Wicklung mit dem grössten Sr in %
-export function getTrafoIleer(i7Data: any, powerTransformerInfo: PowerTransformerInfo): number {
-  if (i7Data['i_leer'] && i7Data['i_leer'] !== 0) {
-    return i7Data['i_leer'];
-  } else if (powerTransformerInfo && powerTransformerInfo['i_leer'] && powerTransformerInfo['i_leer'] !== 0) {
-    return powerTransformerInfo['i_leer'];
-  }
-  return 0;
-}
-
-export function getConductingEquipmentTerminalBySecNumber(conductingEquipment: ConductingEquipment, sequenceNumber: number): Terminal | undefined {
-  for (const terminal of conductingEquipment.terminals.values()) {
-    if (terminal.sequenceNumber === sequenceNumber) {
-      return terminal as Terminal;
-    }
-  }
-  return;
-}
-
-export function createTapChanger(i7Data: Wicklung, transformerEnd: PowerTransformerEnd, cimModel: Model, neutralU: number) {
-  // ist ein Stufenschalter vorhanden?
-  if (i7Data[`regelung_s${transformerEnd.endNumber}`]) {
-    const terminalUUID = transformerEnd.terminalUUID;
-    const tapChangerControl = new TapChangerControl(generateUUID(), `TapChangerControl ${transformerEnd.name} W${transformerEnd.endNumber}`);
-    tapChangerControl.mode = RegulatingControlModeKind.voltage;
-    tapChangerControl.terminalUUID = terminalUUID;
-    // terminal.addRegulatingControl(tapChangerControl);
-
-    const lowStep = i7Data[`minstufe_s${transformerEnd.endNumber}`]
-    const highStep = i7Data[`maxstufe_s${transformerEnd.endNumber}`]
-
-    const neutralStep = i7Data[`mittelstufe_s${transformerEnd.endNumber}`];
-    const currentStep = i7Data[`aktstufe_s${transformerEnd.endNumber}`]
-
-    /** die Stufenpositionen werden auf 1..n normiert
-     * Zu Betimmung der aktuellen Stufe, wird ein Array mit den i7 Stufennummern angelegt.
-     * Der Index wird später die verwendet, um die normierte Stufenposition zu bestimmen */
-    const i7TapArray = getTapChangerStepArray(lowStep, highStep);
-
-    const lowerVoltageStepCount = getTapChangerStepCount(lowStep, neutralStep); // 9
-    const increaseVoltageStepCount = getTapChangerStepCount(neutralStep, highStep);
-
-    const lowerVoltageStepIncrement = Math.abs(i7Data[`umin_s${transformerEnd.endNumber}`]) /*/ 100*/ / lowerVoltageStepCount * -1; // -0.01778 => -1.78%
-    let increaseVoltageStepIncrement = Math.abs(i7Data[`umax_s${transformerEnd.endNumber}`]) /*/ 100*/ / lowerVoltageStepCount;// 0.01778 => 1.78%
-    increaseVoltageStepIncrement = isNaN(increaseVoltageStepIncrement) ? 1 : increaseVoltageStepIncrement;
-    const ratioTapChangerTable = new RatioTapChangerTable(generateUUID(), `Tabelle ${transformerEnd.name} W${transformerEnd.endNumber}`);
-
-    // Spannung verringern
-    for (let i = 0; i < lowerVoltageStepCount; i++) {
-      createRatioTapChangerTablePoint(ratioTapChangerTable,
-        i + 1,
-        1 + (lowerVoltageStepIncrement * (lowerVoltageStepCount - i)));
-    }
-    // neutral Step
-    createRatioTapChangerTablePoint(ratioTapChangerTable, lowerVoltageStepCount + 1, 1);
-
-    // Spannung erhoehen
-    for (let i = 0; i < increaseVoltageStepCount; i++) {
-      const step = (lowerVoltageStepCount + 1) + (i + 1);
-      createRatioTapChangerTablePoint(ratioTapChangerTable,
-        step,
-        1 + (increaseVoltageStepIncrement * (i + 1)));
-    }
-
-    const ratioTapChanger = new RatioTapChanger(generateUUID(), `Stufenschalter ${transformerEnd.name} W${transformerEnd.endNumber}`);
-
-    // Attribute
-    ratioTapChanger.stepVoltageIncrement = increaseVoltageStepIncrement;
-    ratioTapChanger.tculControlMode = TransformerControlMode.volt;
-    ratioTapChanger.ltcFlag = false;
-
-    ratioTapChanger.lowStep = 1
-    ratioTapChanger.highStep = ratioTapChangerTable.ratioTapChangerTablePoints.length;
-
-    ratioTapChanger.neutralStep = i7TapArray.indexOf(neutralStep) + 1;
-    ratioTapChanger.normalStep = ratioTapChanger.neutralStep;
-
-    // Assoziationen
-    ratioTapChanger.tapChangerControlUUID = tapChangerControl.mrid;
-    // tapChangerControl.addTapChanger(ratioTapChanger);
-
-    ratioTapChanger.transformerEndUUID = transformerEnd.mrid;
-    // transformerEnd.ratioTapChanger = ratioTapChanger;
-
-    ratioTapChanger.ratioTapChangerTableUUID = ratioTapChangerTable.mrid;
-    // ratioTapChangerTable.ratioTapChanger = ratioTapChanger;
-
-    try {
-      ratioTapChanger.neutralU = neutralU;
-    } catch (e) {
-    }
-
-
-    //SV Profil: Aktuelle Stufenstellung
-    /*    const svTapStep = new SvTapStep(generateUUID(), i7TapArray.indexOf(currentStep) + 1, ratioTapChanger);
-        ratioTapChanger.svTapStepUUID = svTapStep.mrid;
-        cimModel.addSvTapStep(svTapStep);*/
-
-
-    cimModel.addTapChangerControl(tapChangerControl);
-    cimModel.addRatioTapChanger(ratioTapChanger);
-    cimModel.addRatioTapChangerTable(ratioTapChangerTable);
-  }
-}
-
-export function getTapChangerStepCount(min: number, max: number): number {
-  let counter = 0;
-  for (let i = min; i < max; i++) {
-    counter++;
-  }
-  return counter;
-}
-
-export function getTapChangerStepArray(min: number, max: number): number[] {
-  const array = [];
-  for (let i = min; i <= max; i++) {
-    array.push(i);
-  }
-  return array;
-}
-
-export function getActiveReactivePower(i7Data: Belastung): number[] {
-  const data = [];
-  const s0 = i7Data.s0;
-  const p0 = i7Data.p0;
-  const cosPhi = i7Data.cos_phi;
-  if (s0 && s0 !== null && s0 !== 0) {
-    data.push(s0 * (cosPhi ? cosPhi : 1));
-    data.push(s0 - data[0]);
-    data.push(s0);
-  } else if (p0 && p0 !== null && p0 !== 0) {
-    data.push(p0);
-    data.push((p0 / (cosPhi ? cosPhi : 1)) - p0);
-    data.push(Math.sqrt(Math.pow(p0, 2) + Math.pow(data[1], 2)));
-  }
-  return data;
-}
-
-export function getDescription(obejct: IdentifiedObject) {
-  if (obejct)
-    return ueberpruefeZeichenkette(obejct.description);
-  else
-    return '';
-}
-
-export function getNumber(value: any): number {
-  const numberValue = parseFloat(value);
-  if (!isNaN(numberValue)) {
-    return value;
-  }
-  return 0;
-}
-
-export function generateFuelType(name: string, type: String, generatingUnit: ThermalGeneratingUnit, cimModel: Model,) {
-  const fossilFuel = new FossilFuel(generateUUID(), name);
-  switch (type) {
-    case 'coal' :
-      fossilFuel.fossilFuelType = FuelType.coal;
-      break;
-    case 'oil' :
-      fossilFuel.fossilFuelType = FuelType.oil;
-      break;
-    case 'lignite' :
-      fossilFuel.fossilFuelType = FuelType.lignite;
-      break;
-    case 'hardCoal' :
-      fossilFuel.fossilFuelType = FuelType.hardCoal;
-      break;
-    case 'oilShale' :
-      fossilFuel.fossilFuelType = FuelType.oilShale;
-      break;
-    case 'gas' :
-      fossilFuel.fossilFuelType = FuelType.gas;
-      break;
-  }
-  // generatingUnit.addFossilFuel(fossilFuel);
-  fossilFuel.thermalGeneratingUnit = generatingUnit;
-  cimModel.addFossilFuel(fossilFuel);
-}
-
-export function writeFile(filePath: string, data: any) {
-
-  fs.writeFile(filePath, (typeof data === 'string') ? data : JSON.stringify(data), function (err) {
-    if (err) {
-      console.log(err);
-    }
-  });
-}
-
-export function generateNodeStream(zip: JSZip): Promise<ConverterStatus> {
-  return new Promise((resolve, reject) => {
-    try {
-      resolve({status: 'successful', message: 'ok', data: zip.generateNodeStream({type: 'nodebuffer',
-                                                                                              streamFiles: true,
-                                                                                              compression: "DEFLATE",
-                                                                                              compressionOptions: {
-                                                                                                level: 5
-                                                                                              }
-                                                                                            }
-                                                                                            )
-                  });
-    } catch (e) {
-      reject({status: 'error', message: e.toString()});
-    }
-  });
-}
-
-export function writeZipFile(data: NodeJS.ReadableStream, path: string): Promise<any> {
-  return new Promise((resolve, reject) => {
-    try {
-      data.pipe(fs.createWriteStream(path))
-        .on('finish', function () {
-          // JSZip generates a readable stream with a "end" event,
-          // but is piped here in a writable stream which emits a "finish" event.
-          resolve({status: 'successful', message: 'ok'});
-        });
-    } catch (e) {
-      reject({status: 'error', message: e.toString()});
-    }
-  });
-}
-
-/*export function writeZipFile(zip: JSZip, path: string): Promise<any> {
-  return new Promise((resolve, reject) => {
-    try {
-      zip
-        .generateNodeStream({type: 'nodebuffer', streamFiles: true})
-        .pipe(fs.createWriteStream(path))
-        .on('finish', function () {
-          // JSZip generates a readable stream with a "end" event,
-          // but is piped here in a writable stream which emits a "finish" event.
-          resolve();
-        });
-    } catch (e) {
-
-    }
-
-  });
-}*/
-/** Integral 7 Exporter */
-export function determineEquipmentContainer(equipmentContainerType: string, cimModel: Model, equipmentContainer: EquipmentContainer): EquipmentContainer | undefined {
-  switch (equipmentContainerType)  {
-    case ('Bay'): {
-      return equipmentContainer;
-    }
-    case ('VoltageLevel'): {
-      if (equipmentContainer instanceof Bay) {
-        return cimModel.getObject((equipmentContainer as Bay).voltageLevelUUID) as VoltageLevel;
-      }
-      return equipmentContainer;
-    }
-    case ('Substation'): {
-      if (equipmentContainer instanceof Bay) {
-        const voltageLevel = cimModel.getObject((equipmentContainer as Bay).voltageLevelUUID) as VoltageLevel;
-        return cimModel.getObject(voltageLevel?.substationUUID) as EquipmentContainer;
-      } else if (equipmentContainer instanceof VoltageLevel) {
-        return cimModel.getObject((equipmentContainer as VoltageLevel)?.substationUUID) as EquipmentContainer;
-      } else {
-        return equipmentContainer;
-      }
-    }
-    default: {
-      return equipmentContainer;
-    }
-
-  }
-  if (equipmentContainer instanceof Bay) {
-    return cimModel.getObject((equipmentContainer as Bay).voltageLevelUUID) as VoltageLevel;
-  }
-  return equipmentContainer;
-}
-
-export async function createTempDirPath() {
-  const fs = require('fs');
-  const os = require('os');
-  const path = require('path');
-
-  return new Promise((resolve, reject) => {
-    const tempPath = path.join(os.tmpdir(), 'i7-');
-    fs.mkdtemp(tempPath, (err, folder) => {
-      if (err)
-        return reject(err)
-
-      // const file_name = path.join(folder, name);
-      resolve(folder);
-      /*   fs.writeFile(file_name, data, encoding, error_file => {
-           if (error_file)
-             return reject(error_file);
-
-           resolve(file_name)
-         })*/
-    })
-  })
-}
-
-export function getIntegral7IDs(cimObjects: Map<string, IIdentifiedObject>, UUID2IntegralID: Map<string, number[]>): number[] {
-  const ids = [];
-  for (const key of cimObjects.keys()) {
-    if (UUID2IntegralID.has(key)) {
-      ids.push(...UUID2IntegralID.get(key));
-    }
-  }
-  return ids;
-}
-
-export function putUUIDtoI7Ids(uuid: string, i7ID: number, UUID2IntegralID: Map<string, number[]>) {
-  if (UUID2IntegralID.has(uuid)) {
-    UUID2IntegralID.get(uuid).push(i7ID);
-  } else {
-    UUID2IntegralID.set(uuid, [i7ID]);
-  }
-}
-
-export function getPSRType(cimModel: Model, name: string): PSRType {
-
-  let psrType = cimModel.getPsrTypeAtName(name);
-  if (!psrType) {
-    psrType = new PSRType(generateUUID(), name);
-    cimModel.addPsrType(psrType);
-  }
-  return psrType;
-}
-
-
-export async function createWriteStreamPromise(writeStream: any): Promise<ConverterStatus> {
-  return new Promise((resolve, reject) => {
-    writeStream.on('close', async () => {
-      resolve({status: 'successful', message: 'ok'});
-    });
-  })
-}