src/charging-station/ChargingStation.ts

   1 // Partial Copyright Jerome Benoit. 2021-2024. All Rights Reserved.
   2
   3 import { createHash } from 'node:crypto'
   4 import { EventEmitter } from 'node:events'
   5 import { type FSWatcher, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
   6 import { dirname, join, parse } from 'node:path'
   7 import { URL } from 'node:url'
   8 import { parentPort } from 'node:worker_threads'
   9
  10 import { millisecondsToSeconds, secondsToMilliseconds } from 'date-fns'
  11 import merge from 'just-merge'
  12 import { type RawData, WebSocket } from 'ws'
  13
  14 import { AutomaticTransactionGenerator } from './AutomaticTransactionGenerator.js'
  15 import { ChargingStationWorkerBroadcastChannel } from './broadcast-channel/ChargingStationWorkerBroadcastChannel.js'
  16 import {
  17   addConfigurationKey,
  18   deleteConfigurationKey,
  19   getConfigurationKey,
  20   setConfigurationKeyValue
  21 } from './ConfigurationKeyUtils.js'
  22 import {
  23   buildConnectorsMap,
  24   checkChargingStation,
  25   checkConfiguration,
  26   checkConnectorsConfiguration,
  27   checkStationInfoConnectorStatus,
  28   checkTemplate,
  29   createBootNotificationRequest,
  30   createSerialNumber,
  31   getAmperageLimitationUnitDivider,
  32   getBootConnectorStatus,
  33   getChargingStationConnectorChargingProfilesPowerLimit,
  34   getChargingStationId,
  35   getDefaultVoltageOut,
  36   getHashId,
  37   getIdTagsFile,
  38   getMaxNumberOfEvses,
  39   getNumberOfReservableConnectors,
  40   getPhaseRotationValue,
  41   hasFeatureProfile,
  42   hasReservationExpired,
  43   initializeConnectorsMapStatus,
  44   propagateSerialNumber,
  45   setChargingStationOptions,
  46   stationTemplateToStationInfo,
  47   warnTemplateKeysDeprecation
  48 } from './Helpers.js'
  49 import { IdTagsCache } from './IdTagsCache.js'
  50 import {
  51   OCPP16IncomingRequestService,
  52   OCPP16RequestService,
  53   OCPP16ResponseService,
  54   OCPP20IncomingRequestService,
  55   OCPP20RequestService,
  56   OCPP20ResponseService,
  57   type OCPPIncomingRequestService,
  58   type OCPPRequestService,
  59   buildMeterValue,
  60   buildTransactionEndMeterValue,
  61   getMessageTypeString,
  62   sendAndSetConnectorStatus
  63 } from './ocpp/index.js'
  64 import { SharedLRUCache } from './SharedLRUCache.js'
  65 import { BaseError, OCPPError } from '../exception/index.js'
  66 import { PerformanceStatistics } from '../performance/index.js'
  67 import {
  68   type AutomaticTransactionGeneratorConfiguration,
  69   AvailabilityType,
  70   type BootNotificationRequest,
  71   type BootNotificationResponse,
  72   type CachedRequest,
  73   type ChargingStationConfiguration,
  74   ChargingStationEvents,
  75   type ChargingStationInfo,
  76   type ChargingStationOcppConfiguration,
  77   type ChargingStationOptions,
  78   type ChargingStationTemplate,
  79   type ConnectorStatus,
  80   ConnectorStatusEnum,
  81   CurrentType,
  82   type ErrorCallback,
  83   type ErrorResponse,
  84   ErrorType,
  85   type EvseStatus,
  86   type EvseStatusConfiguration,
  87   FileType,
  88   FirmwareStatus,
  89   type FirmwareStatusNotificationRequest,
  90   type FirmwareStatusNotificationResponse,
  91   type FirmwareUpgrade,
  92   type HeartbeatRequest,
  93   type HeartbeatResponse,
  94   type IncomingRequest,
  95   type IncomingRequestCommand,
  96   MessageType,
  97   MeterValueMeasurand,
  98   type MeterValuesRequest,
  99   type MeterValuesResponse,
 100   OCPPVersion,
 101   type OutgoingRequest,
 102   PowerUnits,
 103   RegistrationStatusEnumType,
 104   RequestCommand,
 105   type Reservation,
 106   type ReservationKey,
 107   ReservationTerminationReason,
 108   type Response,
 109   StandardParametersKey,
 110   type Status,
 111   type StopTransactionReason,
 112   type StopTransactionRequest,
 113   type StopTransactionResponse,
 114   SupervisionUrlDistribution,
 115   SupportedFeatureProfiles,
 116   type Voltage,
 117   type WSError,
 118   WebSocketCloseEventStatusCode,
 119   type WsOptions
 120 } from '../types/index.js'
 121 import {
 122   ACElectricUtils,
 123   AsyncLock,
 124   AsyncLockType,
 125   Configuration,
 126   Constants,
 127   DCElectricUtils,
 128   buildAddedMessage,
 129   buildChargingStationAutomaticTransactionGeneratorConfiguration,
 130   buildConnectorsStatus,
 131   buildDeletedMessage,
 132   buildEvsesStatus,
 133   buildStartedMessage,
 134   buildStoppedMessage,
 135   buildUpdatedMessage,
 136   clone,
 137   convertToBoolean,
 138   convertToDate,
 139   convertToInt,
 140   exponentialDelay,
 141   formatDurationMilliSeconds,
 142   formatDurationSeconds,
 143   getRandomInteger,
 144   getWebSocketCloseEventStatusString,
 145   handleFileException,
 146   isNotEmptyArray,
 147   isNotEmptyString,
 148   logPrefix,
 149   logger,
 150   min,
 151   once,
 152   roundTo,
 153   secureRandom,
 154   sleep,
 155   watchJsonFile
 156 } from '../utils/index.js'
 157
 158 export class ChargingStation extends EventEmitter {
 159   public readonly index: number
 160   public readonly templateFile: string
 161   public stationInfo?: ChargingStationInfo
 162   public started: boolean
 163   public starting: boolean
 164   public idTagsCache: IdTagsCache
 165   public automaticTransactionGenerator!: AutomaticTransactionGenerator | undefined
 166   public ocppConfiguration!: ChargingStationOcppConfiguration | undefined
 167   public wsConnection: WebSocket | null
 168   public readonly connectors: Map<number, ConnectorStatus>
 169   public readonly evses: Map<number, EvseStatus>
 170   public readonly requests: Map<string, CachedRequest>
 171   public performanceStatistics: PerformanceStatistics | undefined
 172   public heartbeatSetInterval?: NodeJS.Timeout
 173   public ocppRequestService!: OCPPRequestService
 174   public bootNotificationRequest?: BootNotificationRequest
 175   public bootNotificationResponse?: BootNotificationResponse
 176   public powerDivider?: number
 177   private stopping: boolean
 178   private configurationFile!: string
 179   private configurationFileHash!: string
 180   private connectorsConfigurationHash!: string
 181   private evsesConfigurationHash!: string
 182   private automaticTransactionGeneratorConfiguration?: AutomaticTransactionGeneratorConfiguration
 183   private ocppIncomingRequestService!: OCPPIncomingRequestService
 184   private readonly messageBuffer: Set<string>
 185   private configuredSupervisionUrl!: URL
 186   private wsConnectionRetried: boolean
 187   private wsConnectionRetryCount: number
 188   private templateFileWatcher: FSWatcher | undefined
 189   private templateFileHash!: string
 190   private readonly sharedLRUCache: SharedLRUCache
 191   private wsPingSetInterval?: NodeJS.Timeout
 192   private readonly chargingStationWorkerBroadcastChannel: ChargingStationWorkerBroadcastChannel
 193   private flushMessageBufferSetInterval?: NodeJS.Timeout
 194
 195   constructor (index: number, templateFile: string, options?: ChargingStationOptions) {
 196     super()
 197     this.started = false
 198     this.starting = false
 199     this.stopping = false
 200     this.wsConnection = null
 201     this.wsConnectionRetried = false
 202     this.wsConnectionRetryCount = 0
 203     this.index = index
 204     this.templateFile = templateFile
 205     this.connectors = new Map<number, ConnectorStatus>()
 206     this.evses = new Map<number, EvseStatus>()
 207     this.requests = new Map<string, CachedRequest>()
 208     this.messageBuffer = new Set<string>()
 209     this.sharedLRUCache = SharedLRUCache.getInstance()
 210     this.idTagsCache = IdTagsCache.getInstance()
 211     this.chargingStationWorkerBroadcastChannel = new ChargingStationWorkerBroadcastChannel(this)
 212
 213     this.on(ChargingStationEvents.added, () => {
 214       parentPort?.postMessage(buildAddedMessage(this))
 215     })
 216     this.on(ChargingStationEvents.deleted, () => {
 217       parentPort?.postMessage(buildDeletedMessage(this))
 218     })
 219     this.on(ChargingStationEvents.started, () => {
 220       parentPort?.postMessage(buildStartedMessage(this))
 221     })
 222     this.on(ChargingStationEvents.stopped, () => {
 223       parentPort?.postMessage(buildStoppedMessage(this))
 224     })
 225     this.on(ChargingStationEvents.updated, () => {
 226       parentPort?.postMessage(buildUpdatedMessage(this))
 227     })
 228     this.on(ChargingStationEvents.accepted, () => {
 229       this.startMessageSequence(
 230         this.wsConnectionRetried
 231           ? true
 232           : this.getAutomaticTransactionGeneratorConfiguration()?.stopAbsoluteDuration
 233       ).catch(error => {
 234         logger.error(`${this.logPrefix()} Error while starting the message sequence:`, error)
 235       })
 236       this.wsConnectionRetried = false
 237     })
 238     this.on(ChargingStationEvents.rejected, () => {
 239       this.wsConnectionRetried = false
 240     })
 241     this.on(ChargingStationEvents.disconnected, () => {
 242       try {
 243         this.internalStopMessageSequence()
 244       } catch (error) {
 245         logger.error(
 246           `${this.logPrefix()} Error while stopping the internal message sequence:`,
 247           error
 248         )
 249       }
 250     })
 251
 252     this.initialize(options)
 253
 254     this.add()
 255
 256     if (options?.autoStart != null) {
 257       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 258       this.stationInfo!.autoStart = options.autoStart
 259     }
 260
 261     if (this.stationInfo?.autoStart === true) {
 262       this.start()
 263     }
 264   }
 265
 266   public get hasEvses (): boolean {
 267     return this.connectors.size === 0 && this.evses.size > 0
 268   }
 269
 270   public get wsConnectionUrl (): URL {
 271     return new URL(
 272       `${
 273         this.stationInfo?.supervisionUrlOcppConfiguration === true &&
 274         isNotEmptyString(this.stationInfo.supervisionUrlOcppKey) &&
 275         isNotEmptyString(getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey)?.value)
 276           ? getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey)?.value
 277           : this.configuredSupervisionUrl.href
 278       }/${this.stationInfo?.chargingStationId}`
 279     )
 280   }
 281
 282   public logPrefix = (): string => {
 283     if (
 284       this instanceof ChargingStation &&
 285       this.stationInfo != null &&
 286       isNotEmptyString(this.stationInfo.chargingStationId)
 287     ) {
 288       return logPrefix(` ${this.stationInfo.chargingStationId} |`)
 289     }
 290     let stationTemplate: ChargingStationTemplate | undefined
 291     try {
 292       stationTemplate = JSON.parse(
 293         readFileSync(this.templateFile, 'utf8')
 294       ) as ChargingStationTemplate
 295     } catch {
 296       stationTemplate = undefined
 297     }
 298     return logPrefix(` ${getChargingStationId(this.index, stationTemplate)} |`)
 299   }
 300
 301   public hasIdTags (): boolean {
 302     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 303     return isNotEmptyArray(this.idTagsCache.getIdTags(getIdTagsFile(this.stationInfo!)!))
 304   }
 305
 306   public getNumberOfPhases (stationInfo?: ChargingStationInfo): number {
 307     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 308     const localStationInfo = stationInfo ?? this.stationInfo!
 309     switch (this.getCurrentOutType(stationInfo)) {
 310       case CurrentType.AC:
 311         return localStationInfo.numberOfPhases ?? 3
 312       case CurrentType.DC:
 313         return 0
 314     }
 315   }
 316
 317   public isWebSocketConnectionOpened (): boolean {
 318     return this.wsConnection?.readyState === WebSocket.OPEN
 319   }
 320
 321   public inUnknownState (): boolean {
 322     return this.bootNotificationResponse?.status == null
 323   }
 324
 325   public inPendingState (): boolean {
 326     return this.bootNotificationResponse?.status === RegistrationStatusEnumType.PENDING
 327   }
 328
 329   public inAcceptedState (): boolean {
 330     return this.bootNotificationResponse?.status === RegistrationStatusEnumType.ACCEPTED
 331   }
 332
 333   public inRejectedState (): boolean {
 334     return this.bootNotificationResponse?.status === RegistrationStatusEnumType.REJECTED
 335   }
 336
 337   public isRegistered (): boolean {
 338     return !this.inUnknownState() && (this.inAcceptedState() || this.inPendingState())
 339   }
 340
 341   public isChargingStationAvailable (): boolean {
 342     return this.getConnectorStatus(0)?.availability === AvailabilityType.Operative
 343   }
 344
 345   public hasConnector (connectorId: number): boolean {
 346     if (this.hasEvses) {
 347       for (const evseStatus of this.evses.values()) {
 348         if (evseStatus.connectors.has(connectorId)) {
 349           return true
 350         }
 351       }
 352       return false
 353     }
 354     return this.connectors.has(connectorId)
 355   }
 356
 357   public isConnectorAvailable (connectorId: number): boolean {
 358     return (
 359       connectorId > 0 &&
 360       this.getConnectorStatus(connectorId)?.availability === AvailabilityType.Operative
 361     )
 362   }
 363
 364   public getNumberOfConnectors (): number {
 365     if (this.hasEvses) {
 366       let numberOfConnectors = 0
 367       for (const [evseId, evseStatus] of this.evses) {
 368         if (evseId > 0) {
 369           numberOfConnectors += evseStatus.connectors.size
 370         }
 371       }
 372       return numberOfConnectors
 373     }
 374     return this.connectors.has(0) ? this.connectors.size - 1 : this.connectors.size
 375   }
 376
 377   public getNumberOfEvses (): number {
 378     return this.evses.has(0) ? this.evses.size - 1 : this.evses.size
 379   }
 380
 381   public getConnectorStatus (connectorId: number): ConnectorStatus | undefined {
 382     if (this.hasEvses) {
 383       for (const evseStatus of this.evses.values()) {
 384         if (evseStatus.connectors.has(connectorId)) {
 385           return evseStatus.connectors.get(connectorId)
 386         }
 387       }
 388       return undefined
 389     }
 390     return this.connectors.get(connectorId)
 391   }
 392
 393   public getConnectorMaximumAvailablePower (connectorId: number): number {
 394     let connectorAmperageLimitationPowerLimit: number | undefined
 395     const amperageLimitation = this.getAmperageLimitation()
 396     if (
 397       amperageLimitation != null &&
 398       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 399       amperageLimitation < this.stationInfo!.maximumAmperage!
 400     ) {
 401       connectorAmperageLimitationPowerLimit =
 402         (this.stationInfo?.currentOutType === CurrentType.AC
 403           ? ACElectricUtils.powerTotal(
 404             this.getNumberOfPhases(),
 405             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 406             this.stationInfo.voltageOut!,
 407             amperageLimitation *
 408                 (this.hasEvses ? this.getNumberOfEvses() : this.getNumberOfConnectors())
 409           )
 410           : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 411           DCElectricUtils.power(this.stationInfo!.voltageOut!, amperageLimitation)) /
 412         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 413         this.powerDivider!
 414     }
 415     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 416     const connectorMaximumPower = this.stationInfo!.maximumPower! / this.powerDivider!
 417     const connectorChargingProfilesPowerLimit =
 418       getChargingStationConnectorChargingProfilesPowerLimit(this, connectorId)
 419     return min(
 420       isNaN(connectorMaximumPower) ? Infinity : connectorMaximumPower,
 421       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 422       isNaN(connectorAmperageLimitationPowerLimit!)
 423         ? Infinity
 424         : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 425         connectorAmperageLimitationPowerLimit!,
 426       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 427       isNaN(connectorChargingProfilesPowerLimit!) ? Infinity : connectorChargingProfilesPowerLimit!
 428     )
 429   }
 430
 431   public getTransactionIdTag (transactionId: number): string | undefined {
 432     if (this.hasEvses) {
 433       for (const evseStatus of this.evses.values()) {
 434         for (const connectorStatus of evseStatus.connectors.values()) {
 435           if (connectorStatus.transactionId === transactionId) {
 436             return connectorStatus.transactionIdTag
 437           }
 438         }
 439       }
 440     } else {
 441       for (const connectorId of this.connectors.keys()) {
 442         if (this.getConnectorStatus(connectorId)?.transactionId === transactionId) {
 443           return this.getConnectorStatus(connectorId)?.transactionIdTag
 444         }
 445       }
 446     }
 447   }
 448
 449   public getNumberOfRunningTransactions (): number {
 450     let numberOfRunningTransactions = 0
 451     if (this.hasEvses) {
 452       for (const [evseId, evseStatus] of this.evses) {
 453         if (evseId === 0) {
 454           continue
 455         }
 456         for (const connectorStatus of evseStatus.connectors.values()) {
 457           if (connectorStatus.transactionStarted === true) {
 458             ++numberOfRunningTransactions
 459           }
 460         }
 461       }
 462     } else {
 463       for (const connectorId of this.connectors.keys()) {
 464         if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted === true) {
 465           ++numberOfRunningTransactions
 466         }
 467       }
 468     }
 469     return numberOfRunningTransactions
 470   }
 471
 472   public getConnectorIdByTransactionId (transactionId: number | undefined): number | undefined {
 473     if (transactionId == null) {
 474       return undefined
 475     } else if (this.hasEvses) {
 476       for (const evseStatus of this.evses.values()) {
 477         for (const [connectorId, connectorStatus] of evseStatus.connectors) {
 478           if (connectorStatus.transactionId === transactionId) {
 479             return connectorId
 480           }
 481         }
 482       }
 483     } else {
 484       for (const connectorId of this.connectors.keys()) {
 485         if (this.getConnectorStatus(connectorId)?.transactionId === transactionId) {
 486           return connectorId
 487         }
 488       }
 489     }
 490   }
 491
 492   public getEnergyActiveImportRegisterByTransactionId (
 493     transactionId: number | undefined,
 494     rounded = false
 495   ): number {
 496     return this.getEnergyActiveImportRegister(
 497       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 498       this.getConnectorStatus(this.getConnectorIdByTransactionId(transactionId)!),
 499       rounded
 500     )
 501   }
 502
 503   public getEnergyActiveImportRegisterByConnectorId (connectorId: number, rounded = false): number {
 504     return this.getEnergyActiveImportRegister(this.getConnectorStatus(connectorId), rounded)
 505   }
 506
 507   public getAuthorizeRemoteTxRequests (): boolean {
 508     const authorizeRemoteTxRequests = getConfigurationKey(
 509       this,
 510       StandardParametersKey.AuthorizeRemoteTxRequests
 511     )
 512     return authorizeRemoteTxRequests != null
 513       ? convertToBoolean(authorizeRemoteTxRequests.value)
 514       : false
 515   }
 516
 517   public getLocalAuthListEnabled (): boolean {
 518     const localAuthListEnabled = getConfigurationKey(
 519       this,
 520       StandardParametersKey.LocalAuthListEnabled
 521     )
 522     return localAuthListEnabled != null ? convertToBoolean(localAuthListEnabled.value) : false
 523   }
 524
 525   public getHeartbeatInterval (): number {
 526     const HeartbeatInterval = getConfigurationKey(this, StandardParametersKey.HeartbeatInterval)
 527     if (HeartbeatInterval != null) {
 528       return secondsToMilliseconds(convertToInt(HeartbeatInterval.value))
 529     }
 530     const HeartBeatInterval = getConfigurationKey(this, StandardParametersKey.HeartBeatInterval)
 531     if (HeartBeatInterval != null) {
 532       return secondsToMilliseconds(convertToInt(HeartBeatInterval.value))
 533     }
 534     this.stationInfo?.autoRegister === false &&
 535       logger.warn(
 536         `${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${
 537           Constants.DEFAULT_HEARTBEAT_INTERVAL
 538         }`
 539       )
 540     return Constants.DEFAULT_HEARTBEAT_INTERVAL
 541   }
 542
 543   public setSupervisionUrl (url: string): void {
 544     if (
 545       this.stationInfo?.supervisionUrlOcppConfiguration === true &&
 546       isNotEmptyString(this.stationInfo.supervisionUrlOcppKey)
 547     ) {
 548       setConfigurationKeyValue(this, this.stationInfo.supervisionUrlOcppKey, url)
 549     } else {
 550       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 551       this.stationInfo!.supervisionUrls = url
 552       this.saveStationInfo()
 553       this.configuredSupervisionUrl = this.getConfiguredSupervisionUrl()
 554     }
 555   }
 556
 557   public startHeartbeat (): void {
 558     if (this.getHeartbeatInterval() > 0 && this.heartbeatSetInterval == null) {
 559       this.heartbeatSetInterval = setInterval(() => {
 560         this.ocppRequestService
 561           .requestHandler<HeartbeatRequest, HeartbeatResponse>(this, RequestCommand.HEARTBEAT)
 562           .catch(error => {
 563             logger.error(
 564               `${this.logPrefix()} Error while sending '${RequestCommand.HEARTBEAT}':`,
 565               error
 566             )
 567           })
 568       }, this.getHeartbeatInterval())
 569       logger.info(
 570         `${this.logPrefix()} Heartbeat started every ${formatDurationMilliSeconds(
 571           this.getHeartbeatInterval()
 572         )}`
 573       )
 574     } else if (this.heartbeatSetInterval != null) {
 575       logger.info(
 576         `${this.logPrefix()} Heartbeat already started every ${formatDurationMilliSeconds(
 577           this.getHeartbeatInterval()
 578         )}`
 579       )
 580     } else {
 581       logger.error(
 582         `${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval()}, not starting the heartbeat`
 583       )
 584     }
 585   }
 586
 587   public restartHeartbeat (): void {
 588     // Stop heartbeat
 589     this.stopHeartbeat()
 590     // Start heartbeat
 591     this.startHeartbeat()
 592   }
 593
 594   public restartWebSocketPing (): void {
 595     // Stop WebSocket ping
 596     this.stopWebSocketPing()
 597     // Start WebSocket ping
 598     this.startWebSocketPing()
 599   }
 600
 601   public startMeterValues (connectorId: number, interval: number): void {
 602     if (connectorId === 0) {
 603       logger.error(`${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId}`)
 604       return
 605     }
 606     const connectorStatus = this.getConnectorStatus(connectorId)
 607     if (connectorStatus == null) {
 608       logger.error(
 609         `${this.logPrefix()} Trying to start MeterValues on non existing connector id
 610           ${connectorId}`
 611       )
 612       return
 613     }
 614     if (connectorStatus.transactionStarted === false) {
 615       logger.error(
 616         `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId} with no transaction started`
 617       )
 618       return
 619     } else if (
 620       connectorStatus.transactionStarted === true &&
 621       connectorStatus.transactionId == null
 622     ) {
 623       logger.error(
 624         `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId} with no transaction id`
 625       )
 626       return
 627     }
 628     if (interval > 0) {
 629       connectorStatus.transactionSetInterval = setInterval(() => {
 630         const meterValue = buildMeterValue(
 631           this,
 632           connectorId,
 633           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 634           connectorStatus.transactionId!,
 635           interval
 636         )
 637         this.ocppRequestService
 638           .requestHandler<MeterValuesRequest, MeterValuesResponse>(
 639           this,
 640           RequestCommand.METER_VALUES,
 641           {
 642             connectorId,
 643             transactionId: connectorStatus.transactionId,
 644             meterValue: [meterValue]
 645           }
 646         )
 647           .catch(error => {
 648             logger.error(
 649               `${this.logPrefix()} Error while sending '${RequestCommand.METER_VALUES}':`,
 650               error
 651             )
 652           })
 653       }, interval)
 654     } else {
 655       logger.error(
 656         `${this.logPrefix()} Charging station ${
 657           StandardParametersKey.MeterValueSampleInterval
 658         } configuration set to ${interval}, not sending MeterValues`
 659       )
 660     }
 661   }
 662
 663   public stopMeterValues (connectorId: number): void {
 664     const connectorStatus = this.getConnectorStatus(connectorId)
 665     if (connectorStatus?.transactionSetInterval != null) {
 666       clearInterval(connectorStatus.transactionSetInterval)
 667     }
 668   }
 669
 670   private add (): void {
 671     this.emit(ChargingStationEvents.added)
 672   }
 673
 674   public async delete (deleteConfiguration = true): Promise<void> {
 675     if (this.started) {
 676       await this.stop()
 677     }
 678     AutomaticTransactionGenerator.deleteInstance(this)
 679     PerformanceStatistics.deleteInstance(this.stationInfo?.hashId)
 680     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 681     this.idTagsCache.deleteIdTags(getIdTagsFile(this.stationInfo!)!)
 682     this.requests.clear()
 683     this.connectors.clear()
 684     this.evses.clear()
 685     this.templateFileWatcher?.unref()
 686     deleteConfiguration && rmSync(this.configurationFile, { force: true })
 687     this.chargingStationWorkerBroadcastChannel.unref()
 688     this.emit(ChargingStationEvents.deleted)
 689   }
 690
 691   public start (): void {
 692     if (!this.started) {
 693       if (!this.starting) {
 694         this.starting = true
 695         if (this.stationInfo?.enableStatistics === true) {
 696           this.performanceStatistics?.start()
 697         }
 698         this.openWSConnection()
 699         // Monitor charging station template file
 700         this.templateFileWatcher = watchJsonFile(
 701           this.templateFile,
 702           FileType.ChargingStationTemplate,
 703           this.logPrefix(),
 704           undefined,
 705           (event, filename): void => {
 706             if (isNotEmptyString(filename) && event === 'change') {
 707               try {
 708                 logger.debug(
 709                   `${this.logPrefix()} ${FileType.ChargingStationTemplate} ${
 710                     this.templateFile
 711                   } file have changed, reload`
 712                 )
 713                 this.sharedLRUCache.deleteChargingStationTemplate(this.templateFileHash)
 714                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 715                 this.idTagsCache.deleteIdTags(getIdTagsFile(this.stationInfo!)!)
 716                 // Initialize
 717                 this.initialize()
 718                 // Restart the ATG
 719                 const ATGStarted = this.automaticTransactionGenerator?.started
 720                 if (ATGStarted === true) {
 721                   this.stopAutomaticTransactionGenerator()
 722                 }
 723                 delete this.automaticTransactionGeneratorConfiguration
 724                 if (
 725                   this.getAutomaticTransactionGeneratorConfiguration()?.enable === true &&
 726                   ATGStarted === true
 727                 ) {
 728                   this.startAutomaticTransactionGenerator(undefined, true)
 729                 }
 730                 if (this.stationInfo?.enableStatistics === true) {
 731                   this.performanceStatistics?.restart()
 732                 } else {
 733                   this.performanceStatistics?.stop()
 734                 }
 735                 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
 736               } catch (error) {
 737                 logger.error(
 738                   `${this.logPrefix()} ${FileType.ChargingStationTemplate} file monitoring error:`,
 739                   error
 740                 )
 741               }
 742             }
 743           }
 744         )
 745         this.started = true
 746         this.emit(ChargingStationEvents.started)
 747         this.starting = false
 748       } else {
 749         logger.warn(`${this.logPrefix()} Charging station is already starting...`)
 750       }
 751     } else {
 752       logger.warn(`${this.logPrefix()} Charging station is already started...`)
 753     }
 754   }
 755
 756   public async stop (
 757     reason?: StopTransactionReason,
 758     stopTransactions = this.stationInfo?.stopTransactionsOnStopped
 759   ): Promise<void> {
 760     if (this.started) {
 761       if (!this.stopping) {
 762         this.stopping = true
 763         await this.stopMessageSequence(reason, stopTransactions)
 764         this.closeWSConnection()
 765         if (this.stationInfo?.enableStatistics === true) {
 766           this.performanceStatistics?.stop()
 767         }
 768         this.templateFileWatcher?.close()
 769         delete this.bootNotificationResponse
 770         this.started = false
 771         this.saveConfiguration()
 772         this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash)
 773         this.emit(ChargingStationEvents.stopped)
 774         this.stopping = false
 775       } else {
 776         logger.warn(`${this.logPrefix()} Charging station is already stopping...`)
 777       }
 778     } else {
 779       logger.warn(`${this.logPrefix()} Charging station is already stopped...`)
 780     }
 781   }
 782
 783   public async reset (reason?: StopTransactionReason): Promise<void> {
 784     await this.stop(reason)
 785     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 786     await sleep(this.stationInfo!.resetTime!)
 787     this.initialize()
 788     this.start()
 789   }
 790
 791   public saveOcppConfiguration (): void {
 792     if (this.stationInfo?.ocppPersistentConfiguration === true) {
 793       this.saveConfiguration()
 794     }
 795   }
 796
 797   public bufferMessage (message: string): void {
 798     this.messageBuffer.add(message)
 799     this.setIntervalFlushMessageBuffer()
 800   }
 801
 802   public openWSConnection (
 803     options?: WsOptions,
 804     params?: { closeOpened?: boolean, terminateOpened?: boolean }
 805   ): void {
 806     options = {
 807       handshakeTimeout: secondsToMilliseconds(this.getConnectionTimeout()),
 808       ...this.stationInfo?.wsOptions,
 809       ...options
 810     }
 811     params = { ...{ closeOpened: false, terminateOpened: false }, ...params }
 812     if (!checkChargingStation(this, this.logPrefix())) {
 813       return
 814     }
 815     if (this.stationInfo?.supervisionUser != null && this.stationInfo.supervisionPassword != null) {
 816       options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`
 817     }
 818     if (params.closeOpened === true) {
 819       this.closeWSConnection()
 820     }
 821     if (params.terminateOpened === true) {
 822       this.terminateWSConnection()
 823     }
 824
 825     if (this.isWebSocketConnectionOpened()) {
 826       logger.warn(
 827         `${this.logPrefix()} OCPP connection to URL ${this.wsConnectionUrl.href} is already opened`
 828       )
 829       return
 830     }
 831
 832     logger.info(`${this.logPrefix()} Open OCPP connection to URL ${this.wsConnectionUrl.href}`)
 833
 834     this.wsConnection = new WebSocket(
 835       this.wsConnectionUrl,
 836       `ocpp${this.stationInfo?.ocppVersion}`,
 837       options
 838     )
 839
 840     // Handle WebSocket message
 841     this.wsConnection.on('message', data => {
 842       this.onMessage(data).catch(Constants.EMPTY_FUNCTION)
 843     })
 844     // Handle WebSocket error
 845     this.wsConnection.on('error', this.onError.bind(this))
 846     // Handle WebSocket close
 847     this.wsConnection.on('close', this.onClose.bind(this))
 848     // Handle WebSocket open
 849     this.wsConnection.on('open', () => {
 850       this.onOpen().catch(error =>
 851         logger.error(`${this.logPrefix()} Error while opening WebSocket connection:`, error)
 852       )
 853     })
 854     // Handle WebSocket ping
 855     this.wsConnection.on('ping', this.onPing.bind(this))
 856     // Handle WebSocket pong
 857     this.wsConnection.on('pong', this.onPong.bind(this))
 858   }
 859
 860   public closeWSConnection (): void {
 861     if (this.isWebSocketConnectionOpened()) {
 862       this.wsConnection?.close()
 863       this.wsConnection = null
 864     }
 865   }
 866
 867   public getAutomaticTransactionGeneratorConfiguration ():
 868   | AutomaticTransactionGeneratorConfiguration
 869   | undefined {
 870     if (this.automaticTransactionGeneratorConfiguration == null) {
 871       let automaticTransactionGeneratorConfiguration:
 872       | AutomaticTransactionGeneratorConfiguration
 873       | undefined
 874       const stationTemplate = this.getTemplateFromFile()
 875       const stationConfiguration = this.getConfigurationFromFile()
 876       if (
 877         this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration === true &&
 878         stationConfiguration?.stationInfo?.templateHash === stationTemplate?.templateHash &&
 879         stationConfiguration?.automaticTransactionGenerator != null
 880       ) {
 881         automaticTransactionGeneratorConfiguration =
 882           stationConfiguration.automaticTransactionGenerator
 883       } else {
 884         automaticTransactionGeneratorConfiguration = stationTemplate?.AutomaticTransactionGenerator
 885       }
 886       this.automaticTransactionGeneratorConfiguration = {
 887         ...Constants.DEFAULT_ATG_CONFIGURATION,
 888         ...automaticTransactionGeneratorConfiguration
 889       }
 890     }
 891     return this.automaticTransactionGeneratorConfiguration
 892   }
 893
 894   public getAutomaticTransactionGeneratorStatuses (): Status[] | undefined {
 895     return this.getConfigurationFromFile()?.automaticTransactionGeneratorStatuses
 896   }
 897
 898   public startAutomaticTransactionGenerator (
 899     connectorIds?: number[],
 900     stopAbsoluteDuration?: boolean
 901   ): void {
 902     this.automaticTransactionGenerator = AutomaticTransactionGenerator.getInstance(this)
 903     if (isNotEmptyArray(connectorIds)) {
 904       for (const connectorId of connectorIds) {
 905         this.automaticTransactionGenerator?.startConnector(connectorId, stopAbsoluteDuration)
 906       }
 907     } else {
 908       this.automaticTransactionGenerator?.start(stopAbsoluteDuration)
 909     }
 910     this.saveAutomaticTransactionGeneratorConfiguration()
 911     this.emit(ChargingStationEvents.updated)
 912   }
 913
 914   public stopAutomaticTransactionGenerator (connectorIds?: number[]): void {
 915     if (isNotEmptyArray(connectorIds)) {
 916       for (const connectorId of connectorIds) {
 917         this.automaticTransactionGenerator?.stopConnector(connectorId)
 918       }
 919     } else {
 920       this.automaticTransactionGenerator?.stop()
 921     }
 922     this.saveAutomaticTransactionGeneratorConfiguration()
 923     this.emit(ChargingStationEvents.updated)
 924   }
 925
 926   public async stopTransactionOnConnector (
 927     connectorId: number,
 928     reason?: StopTransactionReason
 929   ): Promise<StopTransactionResponse> {
 930     const transactionId = this.getConnectorStatus(connectorId)?.transactionId
 931     if (
 932       this.stationInfo?.beginEndMeterValues === true &&
 933       this.stationInfo.ocppStrictCompliance === true &&
 934       this.stationInfo.outOfOrderEndMeterValues === false
 935     ) {
 936       const transactionEndMeterValue = buildTransactionEndMeterValue(
 937         this,
 938         connectorId,
 939         this.getEnergyActiveImportRegisterByTransactionId(transactionId)
 940       )
 941       await this.ocppRequestService.requestHandler<MeterValuesRequest, MeterValuesResponse>(
 942         this,
 943         RequestCommand.METER_VALUES,
 944         {
 945           connectorId,
 946           transactionId,
 947           meterValue: [transactionEndMeterValue]
 948         }
 949       )
 950     }
 951     return await this.ocppRequestService.requestHandler<
 952     StopTransactionRequest,
 953     StopTransactionResponse
 954     >(this, RequestCommand.STOP_TRANSACTION, {
 955       transactionId,
 956       meterStop: this.getEnergyActiveImportRegisterByTransactionId(transactionId, true),
 957       ...(reason != null && { reason })
 958     })
 959   }
 960
 961   public getReserveConnectorZeroSupported (): boolean {
 962     return convertToBoolean(
 963       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 964       getConfigurationKey(this, StandardParametersKey.ReserveConnectorZeroSupported)!.value
 965     )
 966   }
 967
 968   public async addReservation (reservation: Reservation): Promise<void> {
 969     const reservationFound = this.getReservationBy('reservationId', reservation.reservationId)
 970     if (reservationFound != null) {
 971       await this.removeReservation(reservationFound, ReservationTerminationReason.REPLACE_EXISTING)
 972     }
 973     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 974     this.getConnectorStatus(reservation.connectorId)!.reservation = reservation
 975     await sendAndSetConnectorStatus(
 976       this,
 977       reservation.connectorId,
 978       ConnectorStatusEnum.Reserved,
 979       undefined,
 980       { send: reservation.connectorId !== 0 }
 981     )
 982   }
 983
 984   public async removeReservation (
 985     reservation: Reservation,
 986     reason: ReservationTerminationReason
 987   ): Promise<void> {
 988     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 989     const connector = this.getConnectorStatus(reservation.connectorId)!
 990     switch (reason) {
 991       case ReservationTerminationReason.CONNECTOR_STATE_CHANGED:
 992       case ReservationTerminationReason.TRANSACTION_STARTED:
 993         delete connector.reservation
 994         break
 995       case ReservationTerminationReason.RESERVATION_CANCELED:
 996       case ReservationTerminationReason.REPLACE_EXISTING:
 997       case ReservationTerminationReason.EXPIRED:
 998         await sendAndSetConnectorStatus(
 999           this,
1000           reservation.connectorId,
1001           ConnectorStatusEnum.Available,
1002           undefined,
1003           { send: reservation.connectorId !== 0 }
1004         )
1005         delete connector.reservation
1006         break
1007       default:
1008         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
1009         throw new BaseError(`Unknown reservation termination reason '${reason}'`)
1010     }
1011   }
1012
1013   public getReservationBy (
1014     filterKey: ReservationKey,
1015     value: number | string
1016   ): Reservation | undefined {
1017     if (this.hasEvses) {
1018       for (const evseStatus of this.evses.values()) {
1019         for (const connectorStatus of evseStatus.connectors.values()) {
1020           if (connectorStatus.reservation?.[filterKey] === value) {
1021             return connectorStatus.reservation
1022           }
1023         }
1024       }
1025     } else {
1026       for (const connectorStatus of this.connectors.values()) {
1027         if (connectorStatus.reservation?.[filterKey] === value) {
1028           return connectorStatus.reservation
1029         }
1030       }
1031     }
1032   }
1033
1034   public isConnectorReservable (
1035     reservationId: number,
1036     idTag?: string,
1037     connectorId?: number
1038   ): boolean {
1039     const reservation = this.getReservationBy('reservationId', reservationId)
1040     const reservationExists = reservation !== undefined && !hasReservationExpired(reservation)
1041     if (arguments.length === 1) {
1042       return !reservationExists
1043     } else if (arguments.length > 1) {
1044       const userReservation =
1045         idTag !== undefined ? this.getReservationBy('idTag', idTag) : undefined
1046       const userReservationExists =
1047         userReservation !== undefined && !hasReservationExpired(userReservation)
1048       const notConnectorZero = connectorId === undefined ? true : connectorId > 0
1049       const freeConnectorsAvailable = this.getNumberOfReservableConnectors() > 0
1050       return (
1051         !reservationExists && !userReservationExists && notConnectorZero && freeConnectorsAvailable
1052       )
1053     }
1054     return false
1055   }
1056
1057   private setIntervalFlushMessageBuffer (): void {
1058     if (this.flushMessageBufferSetInterval == null) {
1059       this.flushMessageBufferSetInterval = setInterval(() => {
1060         if (this.isWebSocketConnectionOpened() && this.inAcceptedState()) {
1061           this.flushMessageBuffer()
1062         }
1063         if (this.messageBuffer.size === 0) {
1064           this.clearIntervalFlushMessageBuffer()
1065         }
1066       }, Constants.DEFAULT_MESSAGE_BUFFER_FLUSH_INTERVAL)
1067     }
1068   }
1069
1070   private clearIntervalFlushMessageBuffer (): void {
1071     if (this.flushMessageBufferSetInterval != null) {
1072       clearInterval(this.flushMessageBufferSetInterval)
1073       delete this.flushMessageBufferSetInterval
1074     }
1075   }
1076
1077   private getNumberOfReservableConnectors (): number {
1078     let numberOfReservableConnectors = 0
1079     if (this.hasEvses) {
1080       for (const evseStatus of this.evses.values()) {
1081         numberOfReservableConnectors += getNumberOfReservableConnectors(evseStatus.connectors)
1082       }
1083     } else {
1084       numberOfReservableConnectors = getNumberOfReservableConnectors(this.connectors)
1085     }
1086     return numberOfReservableConnectors - this.getNumberOfReservationsOnConnectorZero()
1087   }
1088
1089   private getNumberOfReservationsOnConnectorZero (): number {
1090     if (
1091       (this.hasEvses && this.evses.get(0)?.connectors.get(0)?.reservation != null) ||
1092       (!this.hasEvses && this.connectors.get(0)?.reservation != null)
1093     ) {
1094       return 1
1095     }
1096     return 0
1097   }
1098
1099   private flushMessageBuffer (): void {
1100     if (this.messageBuffer.size > 0) {
1101       for (const message of this.messageBuffer.values()) {
1102         let beginId: string | undefined
1103         let commandName: RequestCommand | undefined
1104         const [messageType] = JSON.parse(message) as OutgoingRequest | Response | ErrorResponse
1105         const isRequest = messageType === MessageType.CALL_MESSAGE
1106         if (isRequest) {
1107           [, , commandName] = JSON.parse(message) as OutgoingRequest
1108           beginId = PerformanceStatistics.beginMeasure(commandName)
1109         }
1110         this.wsConnection?.send(message, (error?: Error) => {
1111           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1112           isRequest && PerformanceStatistics.endMeasure(commandName!, beginId!)
1113           if (error == null) {
1114             logger.debug(
1115               `${this.logPrefix()} >> Buffered ${getMessageTypeString(
1116                 messageType
1117               )} OCPP message sent '${JSON.stringify(message)}'`
1118             )
1119             this.messageBuffer.delete(message)
1120           } else {
1121             logger.debug(
1122               `${this.logPrefix()} >> Buffered ${getMessageTypeString(
1123                 messageType
1124               )} OCPP message '${JSON.stringify(message)}' send failed:`,
1125               error
1126             )
1127           }
1128         })
1129       }
1130     }
1131   }
1132
1133   private getTemplateFromFile (): ChargingStationTemplate | undefined {
1134     let template: ChargingStationTemplate | undefined
1135     try {
1136       if (this.sharedLRUCache.hasChargingStationTemplate(this.templateFileHash)) {
1137         template = this.sharedLRUCache.getChargingStationTemplate(this.templateFileHash)
1138       } else {
1139         const measureId = `${FileType.ChargingStationTemplate} read`
1140         const beginId = PerformanceStatistics.beginMeasure(measureId)
1141         template = JSON.parse(readFileSync(this.templateFile, 'utf8')) as ChargingStationTemplate
1142         PerformanceStatistics.endMeasure(measureId, beginId)
1143         template.templateHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1144           .update(JSON.stringify(template))
1145           .digest('hex')
1146         this.sharedLRUCache.setChargingStationTemplate(template)
1147         this.templateFileHash = template.templateHash
1148       }
1149     } catch (error) {
1150       handleFileException(
1151         this.templateFile,
1152         FileType.ChargingStationTemplate,
1153         error as NodeJS.ErrnoException,
1154         this.logPrefix()
1155       )
1156     }
1157     return template
1158   }
1159
1160   private getStationInfoFromTemplate (): ChargingStationInfo {
1161     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1162     const stationTemplate = this.getTemplateFromFile()!
1163     checkTemplate(stationTemplate, this.logPrefix(), this.templateFile)
1164     const warnTemplateKeysDeprecationOnce = once(warnTemplateKeysDeprecation, this)
1165     warnTemplateKeysDeprecationOnce(stationTemplate, this.logPrefix(), this.templateFile)
1166     if (stationTemplate.Connectors != null) {
1167       checkConnectorsConfiguration(stationTemplate, this.logPrefix(), this.templateFile)
1168     }
1169     const stationInfo = stationTemplateToStationInfo(stationTemplate)
1170     stationInfo.hashId = getHashId(this.index, stationTemplate)
1171     stationInfo.templateName = parse(this.templateFile).name
1172     stationInfo.chargingStationId = getChargingStationId(this.index, stationTemplate)
1173     createSerialNumber(stationTemplate, stationInfo)
1174     stationInfo.voltageOut = this.getVoltageOut(stationInfo)
1175     if (isNotEmptyArray(stationTemplate.power)) {
1176       const powerArrayRandomIndex = Math.floor(secureRandom() * stationTemplate.power.length)
1177       stationInfo.maximumPower =
1178         stationTemplate.powerUnit === PowerUnits.KILO_WATT
1179           ? stationTemplate.power[powerArrayRandomIndex] * 1000
1180           : stationTemplate.power[powerArrayRandomIndex]
1181     } else {
1182       stationInfo.maximumPower =
1183         stationTemplate.powerUnit === PowerUnits.KILO_WATT
1184           ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1185           stationTemplate.power! * 1000
1186           : stationTemplate.power
1187     }
1188     stationInfo.maximumAmperage = this.getMaximumAmperage(stationInfo)
1189     if (
1190       isNotEmptyString(stationInfo.firmwareVersionPattern) &&
1191       isNotEmptyString(stationInfo.firmwareVersion) &&
1192       !new RegExp(stationInfo.firmwareVersionPattern).test(stationInfo.firmwareVersion)
1193     ) {
1194       logger.warn(
1195         `${this.logPrefix()} Firmware version '${stationInfo.firmwareVersion}' in template file ${
1196           this.templateFile
1197         } does not match firmware version pattern '${stationInfo.firmwareVersionPattern}'`
1198       )
1199     }
1200     stationInfo.firmwareUpgrade = merge<FirmwareUpgrade>(
1201       {
1202         versionUpgrade: {
1203           step: 1
1204         },
1205         reset: true
1206       },
1207       stationTemplate.firmwareUpgrade ?? {}
1208     )
1209     if (stationTemplate.resetTime != null) {
1210       stationInfo.resetTime = secondsToMilliseconds(stationTemplate.resetTime)
1211     }
1212     return stationInfo
1213   }
1214
1215   private getStationInfoFromFile (
1216     stationInfoPersistentConfiguration: boolean | undefined = Constants.DEFAULT_STATION_INFO
1217       .stationInfoPersistentConfiguration
1218   ): ChargingStationInfo | undefined {
1219     let stationInfo: ChargingStationInfo | undefined
1220     if (stationInfoPersistentConfiguration === true) {
1221       stationInfo = this.getConfigurationFromFile()?.stationInfo
1222       if (stationInfo != null) {
1223         delete stationInfo.infoHash
1224         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1225         if (stationInfo.templateName == null) {
1226           stationInfo.templateName = parse(this.templateFile).name
1227         }
1228       }
1229     }
1230     return stationInfo
1231   }
1232
1233   private getStationInfo (options?: ChargingStationOptions): ChargingStationInfo {
1234     const stationInfoFromTemplate = this.getStationInfoFromTemplate()
1235     options?.persistentConfiguration != null &&
1236       (stationInfoFromTemplate.stationInfoPersistentConfiguration = options.persistentConfiguration)
1237     const stationInfoFromFile = this.getStationInfoFromFile(
1238       stationInfoFromTemplate.stationInfoPersistentConfiguration
1239     )
1240     // Priority:
1241     // 1. charging station info from template
1242     // 2. charging station info from configuration file
1243     if (
1244       stationInfoFromFile != null &&
1245       stationInfoFromFile.templateHash === stationInfoFromTemplate.templateHash
1246     ) {
1247       return setChargingStationOptions(
1248         { ...Constants.DEFAULT_STATION_INFO, ...stationInfoFromFile },
1249         options
1250       )
1251     }
1252     stationInfoFromFile != null &&
1253       propagateSerialNumber(
1254         this.getTemplateFromFile(),
1255         stationInfoFromFile,
1256         stationInfoFromTemplate
1257       )
1258     return setChargingStationOptions(
1259       { ...Constants.DEFAULT_STATION_INFO, ...stationInfoFromTemplate },
1260       options
1261     )
1262   }
1263
1264   private saveStationInfo (): void {
1265     if (this.stationInfo?.stationInfoPersistentConfiguration === true) {
1266       this.saveConfiguration()
1267     }
1268   }
1269
1270   private handleUnsupportedVersion (version: OCPPVersion | undefined): void {
1271     const errorMsg = `Unsupported protocol version '${version}' configured in template file ${this.templateFile}`
1272     logger.error(`${this.logPrefix()} ${errorMsg}`)
1273     throw new BaseError(errorMsg)
1274   }
1275
1276   private initialize (options?: ChargingStationOptions): void {
1277     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1278     const stationTemplate = this.getTemplateFromFile()!
1279     checkTemplate(stationTemplate, this.logPrefix(), this.templateFile)
1280     this.configurationFile = join(
1281       dirname(this.templateFile.replace('station-templates', 'configurations')),
1282       `${getHashId(this.index, stationTemplate)}.json`
1283     )
1284     const stationConfiguration = this.getConfigurationFromFile()
1285     if (
1286       stationConfiguration?.stationInfo?.templateHash === stationTemplate.templateHash &&
1287       (stationConfiguration?.connectorsStatus != null || stationConfiguration?.evsesStatus != null)
1288     ) {
1289       checkConfiguration(stationConfiguration, this.logPrefix(), this.configurationFile)
1290       this.initializeConnectorsOrEvsesFromFile(stationConfiguration)
1291     } else {
1292       this.initializeConnectorsOrEvsesFromTemplate(stationTemplate)
1293     }
1294     this.stationInfo = this.getStationInfo(options)
1295     if (
1296       this.stationInfo.firmwareStatus === FirmwareStatus.Installing &&
1297       isNotEmptyString(this.stationInfo.firmwareVersionPattern) &&
1298       isNotEmptyString(this.stationInfo.firmwareVersion)
1299     ) {
1300       const patternGroup =
1301         this.stationInfo.firmwareUpgrade?.versionUpgrade?.patternGroup ??
1302         this.stationInfo.firmwareVersion.split('.').length
1303       const match = new RegExp(this.stationInfo.firmwareVersionPattern)
1304         .exec(this.stationInfo.firmwareVersion)
1305         ?.slice(1, patternGroup + 1)
1306       if (match != null) {
1307         const patchLevelIndex = match.length - 1
1308         match[patchLevelIndex] = (
1309           convertToInt(match[patchLevelIndex]) +
1310           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1311           this.stationInfo.firmwareUpgrade!.versionUpgrade!.step!
1312         ).toString()
1313         this.stationInfo.firmwareVersion = match.join('.')
1314       }
1315     }
1316     this.saveStationInfo()
1317     this.configuredSupervisionUrl = this.getConfiguredSupervisionUrl()
1318     if (this.stationInfo.enableStatistics === true) {
1319       this.performanceStatistics = PerformanceStatistics.getInstance(
1320         this.stationInfo.hashId,
1321         this.stationInfo.chargingStationId,
1322         this.configuredSupervisionUrl
1323       )
1324     }
1325     const bootNotificationRequest = createBootNotificationRequest(this.stationInfo)
1326     if (bootNotificationRequest == null) {
1327       const errorMsg = 'Error while creating boot notification request'
1328       logger.error(`${this.logPrefix()} ${errorMsg}`)
1329       throw new BaseError(errorMsg)
1330     }
1331     this.bootNotificationRequest = bootNotificationRequest
1332     this.powerDivider = this.getPowerDivider()
1333     // OCPP configuration
1334     this.ocppConfiguration = this.getOcppConfiguration(options?.persistentConfiguration)
1335     this.initializeOcppConfiguration()
1336     this.initializeOcppServices()
1337     if (this.stationInfo.autoRegister === true) {
1338       this.bootNotificationResponse = {
1339         currentTime: new Date(),
1340         interval: millisecondsToSeconds(this.getHeartbeatInterval()),
1341         status: RegistrationStatusEnumType.ACCEPTED
1342       }
1343     }
1344   }
1345
1346   private initializeOcppServices (): void {
1347     const ocppVersion = this.stationInfo?.ocppVersion
1348     switch (ocppVersion) {
1349       case OCPPVersion.VERSION_16:
1350         this.ocppIncomingRequestService =
1351           OCPP16IncomingRequestService.getInstance<OCPP16IncomingRequestService>()
1352         this.ocppRequestService = OCPP16RequestService.getInstance<OCPP16RequestService>(
1353           OCPP16ResponseService.getInstance<OCPP16ResponseService>()
1354         )
1355         break
1356       case OCPPVersion.VERSION_20:
1357       case OCPPVersion.VERSION_201:
1358         this.ocppIncomingRequestService =
1359           OCPP20IncomingRequestService.getInstance<OCPP20IncomingRequestService>()
1360         this.ocppRequestService = OCPP20RequestService.getInstance<OCPP20RequestService>(
1361           OCPP20ResponseService.getInstance<OCPP20ResponseService>()
1362         )
1363         break
1364       default:
1365         this.handleUnsupportedVersion(ocppVersion)
1366         break
1367     }
1368   }
1369
1370   private initializeOcppConfiguration (): void {
1371     if (getConfigurationKey(this, StandardParametersKey.HeartbeatInterval) == null) {
1372       addConfigurationKey(this, StandardParametersKey.HeartbeatInterval, '0')
1373     }
1374     if (getConfigurationKey(this, StandardParametersKey.HeartBeatInterval) == null) {
1375       addConfigurationKey(this, StandardParametersKey.HeartBeatInterval, '0', { visible: false })
1376     }
1377     if (
1378       this.stationInfo?.supervisionUrlOcppConfiguration === true &&
1379       isNotEmptyString(this.stationInfo.supervisionUrlOcppKey) &&
1380       getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey) == null
1381     ) {
1382       addConfigurationKey(
1383         this,
1384         this.stationInfo.supervisionUrlOcppKey,
1385         this.configuredSupervisionUrl.href,
1386         { reboot: true }
1387       )
1388     } else if (
1389       this.stationInfo?.supervisionUrlOcppConfiguration === false &&
1390       isNotEmptyString(this.stationInfo.supervisionUrlOcppKey) &&
1391       getConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey) != null
1392     ) {
1393       deleteConfigurationKey(this, this.stationInfo.supervisionUrlOcppKey, { save: false })
1394     }
1395     if (
1396       isNotEmptyString(this.stationInfo?.amperageLimitationOcppKey) &&
1397       getConfigurationKey(this, this.stationInfo.amperageLimitationOcppKey) == null
1398     ) {
1399       addConfigurationKey(
1400         this,
1401         this.stationInfo.amperageLimitationOcppKey,
1402         // prettier-ignore
1403         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1404         (this.stationInfo.maximumAmperage! * getAmperageLimitationUnitDivider(this.stationInfo)).toString()
1405       )
1406     }
1407     if (getConfigurationKey(this, StandardParametersKey.SupportedFeatureProfiles) == null) {
1408       addConfigurationKey(
1409         this,
1410         StandardParametersKey.SupportedFeatureProfiles,
1411         `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.FirmwareManagement},${SupportedFeatureProfiles.LocalAuthListManagement},${SupportedFeatureProfiles.SmartCharging},${SupportedFeatureProfiles.RemoteTrigger}`
1412       )
1413     }
1414     addConfigurationKey(
1415       this,
1416       StandardParametersKey.NumberOfConnectors,
1417       this.getNumberOfConnectors().toString(),
1418       { readonly: true },
1419       { overwrite: true }
1420     )
1421     if (getConfigurationKey(this, StandardParametersKey.MeterValuesSampledData) == null) {
1422       addConfigurationKey(
1423         this,
1424         StandardParametersKey.MeterValuesSampledData,
1425         MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
1426       )
1427     }
1428     if (getConfigurationKey(this, StandardParametersKey.ConnectorPhaseRotation) == null) {
1429       const connectorsPhaseRotation: string[] = []
1430       if (this.hasEvses) {
1431         for (const evseStatus of this.evses.values()) {
1432           for (const connectorId of evseStatus.connectors.keys()) {
1433             connectorsPhaseRotation.push(
1434               // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1435               getPhaseRotationValue(connectorId, this.getNumberOfPhases())!
1436             )
1437           }
1438         }
1439       } else {
1440         for (const connectorId of this.connectors.keys()) {
1441           connectorsPhaseRotation.push(
1442             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1443             getPhaseRotationValue(connectorId, this.getNumberOfPhases())!
1444           )
1445         }
1446       }
1447       addConfigurationKey(
1448         this,
1449         StandardParametersKey.ConnectorPhaseRotation,
1450         connectorsPhaseRotation.toString()
1451       )
1452     }
1453     if (getConfigurationKey(this, StandardParametersKey.AuthorizeRemoteTxRequests) == null) {
1454       addConfigurationKey(this, StandardParametersKey.AuthorizeRemoteTxRequests, 'true')
1455     }
1456     if (
1457       getConfigurationKey(this, StandardParametersKey.LocalAuthListEnabled) == null &&
1458       hasFeatureProfile(this, SupportedFeatureProfiles.LocalAuthListManagement) === true
1459     ) {
1460       addConfigurationKey(this, StandardParametersKey.LocalAuthListEnabled, 'false')
1461     }
1462     if (getConfigurationKey(this, StandardParametersKey.ConnectionTimeOut) == null) {
1463       addConfigurationKey(
1464         this,
1465         StandardParametersKey.ConnectionTimeOut,
1466         Constants.DEFAULT_CONNECTION_TIMEOUT.toString()
1467       )
1468     }
1469     this.saveOcppConfiguration()
1470   }
1471
1472   private initializeConnectorsOrEvsesFromFile (configuration: ChargingStationConfiguration): void {
1473     if (configuration.connectorsStatus != null && configuration.evsesStatus == null) {
1474       for (const [connectorId, connectorStatus] of configuration.connectorsStatus.entries()) {
1475         this.connectors.set(connectorId, clone<ConnectorStatus>(connectorStatus))
1476       }
1477     } else if (configuration.evsesStatus != null && configuration.connectorsStatus == null) {
1478       for (const [evseId, evseStatusConfiguration] of configuration.evsesStatus.entries()) {
1479         const evseStatus = clone<EvseStatusConfiguration>(evseStatusConfiguration)
1480         delete evseStatus.connectorsStatus
1481         this.evses.set(evseId, {
1482           ...(evseStatus as EvseStatus),
1483           connectors: new Map<number, ConnectorStatus>(
1484             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1485             evseStatusConfiguration.connectorsStatus!.map((connectorStatus, connectorId) => [
1486               connectorId,
1487               connectorStatus
1488             ])
1489           )
1490         })
1491       }
1492     } else if (configuration.evsesStatus != null && configuration.connectorsStatus != null) {
1493       const errorMsg = `Connectors and evses defined at the same time in configuration file ${this.configurationFile}`
1494       logger.error(`${this.logPrefix()} ${errorMsg}`)
1495       throw new BaseError(errorMsg)
1496     } else {
1497       const errorMsg = `No connectors or evses defined in configuration file ${this.configurationFile}`
1498       logger.error(`${this.logPrefix()} ${errorMsg}`)
1499       throw new BaseError(errorMsg)
1500     }
1501   }
1502
1503   private initializeConnectorsOrEvsesFromTemplate (stationTemplate: ChargingStationTemplate): void {
1504     if (stationTemplate.Connectors != null && stationTemplate.Evses == null) {
1505       this.initializeConnectorsFromTemplate(stationTemplate)
1506     } else if (stationTemplate.Evses != null && stationTemplate.Connectors == null) {
1507       this.initializeEvsesFromTemplate(stationTemplate)
1508     } else if (stationTemplate.Evses != null && stationTemplate.Connectors != null) {
1509       const errorMsg = `Connectors and evses defined at the same time in template file ${this.templateFile}`
1510       logger.error(`${this.logPrefix()} ${errorMsg}`)
1511       throw new BaseError(errorMsg)
1512     } else {
1513       const errorMsg = `No connectors or evses defined in template file ${this.templateFile}`
1514       logger.error(`${this.logPrefix()} ${errorMsg}`)
1515       throw new BaseError(errorMsg)
1516     }
1517   }
1518
1519   private initializeConnectorsFromTemplate (stationTemplate: ChargingStationTemplate): void {
1520     if (stationTemplate.Connectors == null && this.connectors.size === 0) {
1521       const errorMsg = `No already defined connectors and charging station information from template ${this.templateFile} with no connectors configuration defined`
1522       logger.error(`${this.logPrefix()} ${errorMsg}`)
1523       throw new BaseError(errorMsg)
1524     }
1525     if (stationTemplate.Connectors?.[0] == null) {
1526       logger.warn(
1527         `${this.logPrefix()} Charging station information from template ${
1528           this.templateFile
1529         } with no connector id 0 configuration`
1530       )
1531     }
1532     if (stationTemplate.Connectors != null) {
1533       const { configuredMaxConnectors, templateMaxConnectors, templateMaxAvailableConnectors } =
1534         checkConnectorsConfiguration(stationTemplate, this.logPrefix(), this.templateFile)
1535       const connectorsConfigHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1536         .update(
1537           `${JSON.stringify(stationTemplate.Connectors)}${configuredMaxConnectors.toString()}`
1538         )
1539         .digest('hex')
1540       const connectorsConfigChanged =
1541         this.connectors.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash
1542       if (this.connectors.size === 0 || connectorsConfigChanged) {
1543         connectorsConfigChanged && this.connectors.clear()
1544         this.connectorsConfigurationHash = connectorsConfigHash
1545         if (templateMaxConnectors > 0) {
1546           for (let connectorId = 0; connectorId <= configuredMaxConnectors; connectorId++) {
1547             if (
1548               connectorId === 0 &&
1549               // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1550               (stationTemplate.Connectors[connectorId] == null ||
1551                 !this.getUseConnectorId0(stationTemplate))
1552             ) {
1553               continue
1554             }
1555             const templateConnectorId =
1556               connectorId > 0 && stationTemplate.randomConnectors === true
1557                 ? getRandomInteger(templateMaxAvailableConnectors, 1)
1558                 : connectorId
1559             const connectorStatus = stationTemplate.Connectors[templateConnectorId]
1560             checkStationInfoConnectorStatus(
1561               templateConnectorId,
1562               connectorStatus,
1563               this.logPrefix(),
1564               this.templateFile
1565             )
1566             this.connectors.set(connectorId, clone<ConnectorStatus>(connectorStatus))
1567           }
1568           initializeConnectorsMapStatus(this.connectors, this.logPrefix())
1569           this.saveConnectorsStatus()
1570         } else {
1571           logger.warn(
1572             `${this.logPrefix()} Charging station information from template ${
1573               this.templateFile
1574             } with no connectors configuration defined, cannot create connectors`
1575           )
1576         }
1577       }
1578     } else {
1579       logger.warn(
1580         `${this.logPrefix()} Charging station information from template ${
1581           this.templateFile
1582         } with no connectors configuration defined, using already defined connectors`
1583       )
1584     }
1585   }
1586
1587   private initializeEvsesFromTemplate (stationTemplate: ChargingStationTemplate): void {
1588     if (stationTemplate.Evses == null && this.evses.size === 0) {
1589       const errorMsg = `No already defined evses and charging station information from template ${this.templateFile} with no evses configuration defined`
1590       logger.error(`${this.logPrefix()} ${errorMsg}`)
1591       throw new BaseError(errorMsg)
1592     }
1593     if (stationTemplate.Evses?.[0] == null) {
1594       logger.warn(
1595         `${this.logPrefix()} Charging station information from template ${
1596           this.templateFile
1597         } with no evse id 0 configuration`
1598       )
1599     }
1600     if (stationTemplate.Evses?.[0]?.Connectors[0] == null) {
1601       logger.warn(
1602         `${this.logPrefix()} Charging station information from template ${
1603           this.templateFile
1604         } with evse id 0 with no connector id 0 configuration`
1605       )
1606     }
1607     if (Object.keys(stationTemplate.Evses?.[0]?.Connectors as object).length > 1) {
1608       logger.warn(
1609         `${this.logPrefix()} Charging station information from template ${
1610           this.templateFile
1611         } with evse id 0 with more than one connector configuration, only connector id 0 configuration will be used`
1612       )
1613     }
1614     if (stationTemplate.Evses != null) {
1615       const evsesConfigHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1616         .update(JSON.stringify(stationTemplate.Evses))
1617         .digest('hex')
1618       const evsesConfigChanged =
1619         this.evses.size !== 0 && this.evsesConfigurationHash !== evsesConfigHash
1620       if (this.evses.size === 0 || evsesConfigChanged) {
1621         evsesConfigChanged && this.evses.clear()
1622         this.evsesConfigurationHash = evsesConfigHash
1623         const templateMaxEvses = getMaxNumberOfEvses(stationTemplate.Evses)
1624         if (templateMaxEvses > 0) {
1625           for (const evseKey in stationTemplate.Evses) {
1626             const evseId = convertToInt(evseKey)
1627             this.evses.set(evseId, {
1628               connectors: buildConnectorsMap(
1629                 stationTemplate.Evses[evseKey].Connectors,
1630                 this.logPrefix(),
1631                 this.templateFile
1632               ),
1633               availability: AvailabilityType.Operative
1634             })
1635             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1636             initializeConnectorsMapStatus(this.evses.get(evseId)!.connectors, this.logPrefix())
1637           }
1638           this.saveEvsesStatus()
1639         } else {
1640           logger.warn(
1641             `${this.logPrefix()} Charging station information from template ${
1642               this.templateFile
1643             } with no evses configuration defined, cannot create evses`
1644           )
1645         }
1646       }
1647     } else {
1648       logger.warn(
1649         `${this.logPrefix()} Charging station information from template ${
1650           this.templateFile
1651         } with no evses configuration defined, using already defined evses`
1652       )
1653     }
1654   }
1655
1656   private getConfigurationFromFile (): ChargingStationConfiguration | undefined {
1657     let configuration: ChargingStationConfiguration | undefined
1658     if (isNotEmptyString(this.configurationFile) && existsSync(this.configurationFile)) {
1659       try {
1660         if (this.sharedLRUCache.hasChargingStationConfiguration(this.configurationFileHash)) {
1661           configuration = this.sharedLRUCache.getChargingStationConfiguration(
1662             this.configurationFileHash
1663           )
1664         } else {
1665           const measureId = `${FileType.ChargingStationConfiguration} read`
1666           const beginId = PerformanceStatistics.beginMeasure(measureId)
1667           configuration = JSON.parse(
1668             readFileSync(this.configurationFile, 'utf8')
1669           ) as ChargingStationConfiguration
1670           PerformanceStatistics.endMeasure(measureId, beginId)
1671           this.sharedLRUCache.setChargingStationConfiguration(configuration)
1672           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1673           this.configurationFileHash = configuration.configurationHash!
1674         }
1675       } catch (error) {
1676         handleFileException(
1677           this.configurationFile,
1678           FileType.ChargingStationConfiguration,
1679           error as NodeJS.ErrnoException,
1680           this.logPrefix()
1681         )
1682       }
1683     }
1684     return configuration
1685   }
1686
1687   private saveAutomaticTransactionGeneratorConfiguration (): void {
1688     if (this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration === true) {
1689       this.saveConfiguration()
1690     }
1691   }
1692
1693   private saveConnectorsStatus (): void {
1694     this.saveConfiguration()
1695   }
1696
1697   private saveEvsesStatus (): void {
1698     this.saveConfiguration()
1699   }
1700
1701   private saveConfiguration (): void {
1702     if (isNotEmptyString(this.configurationFile)) {
1703       try {
1704         if (!existsSync(dirname(this.configurationFile))) {
1705           mkdirSync(dirname(this.configurationFile), { recursive: true })
1706         }
1707         const configurationFromFile = this.getConfigurationFromFile()
1708         let configurationData: ChargingStationConfiguration =
1709           configurationFromFile != null
1710             ? clone<ChargingStationConfiguration>(configurationFromFile)
1711             : {}
1712         if (this.stationInfo?.stationInfoPersistentConfiguration === true) {
1713           configurationData.stationInfo = this.stationInfo
1714         } else {
1715           delete configurationData.stationInfo
1716         }
1717         if (
1718           this.stationInfo?.ocppPersistentConfiguration === true &&
1719           Array.isArray(this.ocppConfiguration?.configurationKey)
1720         ) {
1721           configurationData.configurationKey = this.ocppConfiguration.configurationKey
1722         } else {
1723           delete configurationData.configurationKey
1724         }
1725         configurationData = merge<ChargingStationConfiguration>(
1726           configurationData,
1727           buildChargingStationAutomaticTransactionGeneratorConfiguration(this)
1728         )
1729         if (this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration !== true) {
1730           delete configurationData.automaticTransactionGenerator
1731         }
1732         if (this.connectors.size > 0) {
1733           configurationData.connectorsStatus = buildConnectorsStatus(this)
1734         } else {
1735           delete configurationData.connectorsStatus
1736         }
1737         if (this.evses.size > 0) {
1738           configurationData.evsesStatus = buildEvsesStatus(this)
1739         } else {
1740           delete configurationData.evsesStatus
1741         }
1742         delete configurationData.configurationHash
1743         const configurationHash = createHash(Constants.DEFAULT_HASH_ALGORITHM)
1744           .update(
1745             JSON.stringify({
1746               stationInfo: configurationData.stationInfo,
1747               configurationKey: configurationData.configurationKey,
1748               automaticTransactionGenerator: configurationData.automaticTransactionGenerator,
1749               ...(this.connectors.size > 0 && {
1750                 connectorsStatus: configurationData.connectorsStatus
1751               }),
1752               ...(this.evses.size > 0 && { evsesStatus: configurationData.evsesStatus })
1753             } satisfies ChargingStationConfiguration)
1754           )
1755           .digest('hex')
1756         if (this.configurationFileHash !== configurationHash) {
1757           AsyncLock.runExclusive(AsyncLockType.configuration, () => {
1758             configurationData.configurationHash = configurationHash
1759             const measureId = `${FileType.ChargingStationConfiguration} write`
1760             const beginId = PerformanceStatistics.beginMeasure(measureId)
1761             writeFileSync(
1762               this.configurationFile,
1763               JSON.stringify(configurationData, undefined, 2),
1764               'utf8'
1765             )
1766             PerformanceStatistics.endMeasure(measureId, beginId)
1767             this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash)
1768             this.sharedLRUCache.setChargingStationConfiguration(configurationData)
1769             this.configurationFileHash = configurationHash
1770           }).catch(error => {
1771             handleFileException(
1772               this.configurationFile,
1773               FileType.ChargingStationConfiguration,
1774               error as NodeJS.ErrnoException,
1775               this.logPrefix()
1776             )
1777           })
1778         } else {
1779           logger.debug(
1780             `${this.logPrefix()} Not saving unchanged charging station configuration file ${
1781               this.configurationFile
1782             }`
1783           )
1784         }
1785       } catch (error) {
1786         handleFileException(
1787           this.configurationFile,
1788           FileType.ChargingStationConfiguration,
1789           error as NodeJS.ErrnoException,
1790           this.logPrefix()
1791         )
1792       }
1793     } else {
1794       logger.error(
1795         `${this.logPrefix()} Trying to save charging station configuration to undefined configuration file`
1796       )
1797     }
1798   }
1799
1800   private getOcppConfigurationFromTemplate (): ChargingStationOcppConfiguration | undefined {
1801     return this.getTemplateFromFile()?.Configuration
1802   }
1803
1804   private getOcppConfigurationFromFile (
1805     ocppPersistentConfiguration?: boolean
1806   ): ChargingStationOcppConfiguration | undefined {
1807     const configurationKey = this.getConfigurationFromFile()?.configurationKey
1808     if (ocppPersistentConfiguration === true && Array.isArray(configurationKey)) {
1809       return { configurationKey }
1810     }
1811     return undefined
1812   }
1813
1814   private getOcppConfiguration (
1815     ocppPersistentConfiguration: boolean | undefined = this.stationInfo?.ocppPersistentConfiguration
1816   ): ChargingStationOcppConfiguration | undefined {
1817     let ocppConfiguration: ChargingStationOcppConfiguration | undefined =
1818       this.getOcppConfigurationFromFile(ocppPersistentConfiguration)
1819     if (ocppConfiguration == null) {
1820       ocppConfiguration = this.getOcppConfigurationFromTemplate()
1821     }
1822     return ocppConfiguration
1823   }
1824
1825   private async onOpen (): Promise<void> {
1826     if (this.isWebSocketConnectionOpened()) {
1827       logger.info(
1828         `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.href} succeeded`
1829       )
1830       let registrationRetryCount = 0
1831       if (!this.isRegistered()) {
1832         // Send BootNotification
1833         do {
1834           this.bootNotificationResponse = await this.ocppRequestService.requestHandler<
1835           BootNotificationRequest,
1836           BootNotificationResponse
1837           >(this, RequestCommand.BOOT_NOTIFICATION, this.bootNotificationRequest, {
1838             skipBufferingOnError: true
1839           })
1840           // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1841           if (this.bootNotificationResponse?.currentTime != null) {
1842             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1843             this.bootNotificationResponse.currentTime = convertToDate(
1844               this.bootNotificationResponse.currentTime
1845             )!
1846           }
1847           if (!this.isRegistered()) {
1848             this.stationInfo?.registrationMaxRetries !== -1 && ++registrationRetryCount
1849             await sleep(
1850               // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
1851               this.bootNotificationResponse?.interval != null
1852                 ? secondsToMilliseconds(this.bootNotificationResponse.interval)
1853                 : Constants.DEFAULT_BOOT_NOTIFICATION_INTERVAL
1854             )
1855           }
1856         } while (
1857           !this.isRegistered() &&
1858           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1859           (registrationRetryCount <= this.stationInfo!.registrationMaxRetries! ||
1860             this.stationInfo?.registrationMaxRetries === -1)
1861         )
1862       }
1863       if (this.isRegistered()) {
1864         this.emit(ChargingStationEvents.registered)
1865         if (this.inAcceptedState()) {
1866           this.emit(ChargingStationEvents.accepted)
1867         }
1868       } else {
1869         if (this.inRejectedState()) {
1870           this.emit(ChargingStationEvents.rejected)
1871         }
1872         logger.error(
1873           `${this.logPrefix()} Registration failure: maximum retries reached (${registrationRetryCount}) or retry disabled (${
1874             this.stationInfo?.registrationMaxRetries
1875           })`
1876         )
1877       }
1878       this.wsConnectionRetryCount = 0
1879       this.emit(ChargingStationEvents.updated)
1880     } else {
1881       logger.warn(
1882         `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.href} failed`
1883       )
1884     }
1885   }
1886
1887   private onClose (code: WebSocketCloseEventStatusCode, reason: Buffer): void {
1888     this.emit(ChargingStationEvents.disconnected)
1889     switch (code) {
1890       // Normal close
1891       case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
1892       case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
1893         logger.info(
1894           `${this.logPrefix()} WebSocket normally closed with status '${getWebSocketCloseEventStatusString(
1895             code
1896           )}' and reason '${reason.toString()}'`
1897         )
1898         this.wsConnectionRetryCount = 0
1899         break
1900       // Abnormal close
1901       default:
1902         logger.error(
1903           `${this.logPrefix()} WebSocket abnormally closed with status '${getWebSocketCloseEventStatusString(
1904             code
1905           )}' and reason '${reason.toString()}'`
1906         )
1907         this.started &&
1908           this.reconnect().catch(error =>
1909             logger.error(`${this.logPrefix()} Error while reconnecting:`, error)
1910           )
1911         break
1912     }
1913     this.emit(ChargingStationEvents.updated)
1914   }
1915
1916   private getCachedRequest (
1917     messageType: MessageType | undefined,
1918     messageId: string
1919   ): CachedRequest | undefined {
1920     const cachedRequest = this.requests.get(messageId)
1921     if (Array.isArray(cachedRequest)) {
1922       return cachedRequest
1923     }
1924     throw new OCPPError(
1925       ErrorType.PROTOCOL_ERROR,
1926       `Cached request for message id ${messageId} ${getMessageTypeString(
1927         messageType
1928       )} is not an array`,
1929       undefined,
1930       cachedRequest
1931     )
1932   }
1933
1934   private async handleIncomingMessage (request: IncomingRequest): Promise<void> {
1935     const [messageType, messageId, commandName, commandPayload] = request
1936     if (this.stationInfo?.enableStatistics === true) {
1937       this.performanceStatistics?.addRequestStatistic(commandName, messageType)
1938     }
1939     logger.debug(
1940       `${this.logPrefix()} << Command '${commandName}' received request payload: ${JSON.stringify(
1941         request
1942       )}`
1943     )
1944     // Process the message
1945     await this.ocppIncomingRequestService.incomingRequestHandler(
1946       this,
1947       messageId,
1948       commandName,
1949       commandPayload
1950     )
1951     this.emit(ChargingStationEvents.updated)
1952   }
1953
1954   private handleResponseMessage (response: Response): void {
1955     const [messageType, messageId, commandPayload] = response
1956     if (!this.requests.has(messageId)) {
1957       // Error
1958       throw new OCPPError(
1959         ErrorType.INTERNAL_ERROR,
1960         `Response for unknown message id ${messageId}`,
1961         undefined,
1962         commandPayload
1963       )
1964     }
1965     // Respond
1966     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1967     const [responseCallback, , requestCommandName, requestPayload] = this.getCachedRequest(
1968       messageType,
1969       messageId
1970     )!
1971     logger.debug(
1972       `${this.logPrefix()} << Command '${requestCommandName}' received response payload: ${JSON.stringify(
1973         response
1974       )}`
1975     )
1976     responseCallback(commandPayload, requestPayload)
1977   }
1978
1979   private handleErrorMessage (errorResponse: ErrorResponse): void {
1980     const [messageType, messageId, errorType, errorMessage, errorDetails] = errorResponse
1981     if (!this.requests.has(messageId)) {
1982       // Error
1983       throw new OCPPError(
1984         ErrorType.INTERNAL_ERROR,
1985         `Error response for unknown message id ${messageId}`,
1986         undefined,
1987         { errorType, errorMessage, errorDetails }
1988       )
1989     }
1990     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1991     const [, errorCallback, requestCommandName] = this.getCachedRequest(messageType, messageId)!
1992     logger.debug(
1993       `${this.logPrefix()} << Command '${requestCommandName}' received error response payload: ${JSON.stringify(
1994         errorResponse
1995       )}`
1996     )
1997     errorCallback(new OCPPError(errorType, errorMessage, requestCommandName, errorDetails))
1998   }
1999
2000   private async onMessage (data: RawData): Promise<void> {
2001     let request: IncomingRequest | Response | ErrorResponse | undefined
2002     let messageType: MessageType | undefined
2003     let errorMsg: string
2004     try {
2005       // eslint-disable-next-line @typescript-eslint/no-base-to-string
2006       request = JSON.parse(data.toString()) as IncomingRequest | Response | ErrorResponse
2007       if (Array.isArray(request)) {
2008         [messageType] = request
2009         // Check the type of message
2010         switch (messageType) {
2011           // Incoming Message
2012           case MessageType.CALL_MESSAGE:
2013             await this.handleIncomingMessage(request as IncomingRequest)
2014             break
2015           // Response Message
2016           case MessageType.CALL_RESULT_MESSAGE:
2017             this.handleResponseMessage(request as Response)
2018             break
2019           // Error Message
2020           case MessageType.CALL_ERROR_MESSAGE:
2021             this.handleErrorMessage(request as ErrorResponse)
2022             break
2023           // Unknown Message
2024           default:
2025             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
2026             errorMsg = `Wrong message type ${messageType}`
2027             logger.error(`${this.logPrefix()} ${errorMsg}`)
2028             throw new OCPPError(ErrorType.PROTOCOL_ERROR, errorMsg)
2029         }
2030       } else {
2031         throw new OCPPError(
2032           ErrorType.PROTOCOL_ERROR,
2033           'Incoming message is not an array',
2034           undefined,
2035           {
2036             request
2037           }
2038         )
2039       }
2040     } catch (error) {
2041       if (!Array.isArray(request)) {
2042         logger.error(`${this.logPrefix()} Incoming message '${request}' parsing error:`, error)
2043         return
2044       }
2045       let commandName: IncomingRequestCommand | undefined
2046       let requestCommandName: RequestCommand | IncomingRequestCommand | undefined
2047       let errorCallback: ErrorCallback
2048       const [, messageId] = request
2049       switch (messageType) {
2050         case MessageType.CALL_MESSAGE:
2051           [, , commandName] = request as IncomingRequest
2052           // Send error
2053           await this.ocppRequestService.sendError(this, messageId, error as OCPPError, commandName)
2054           break
2055         case MessageType.CALL_RESULT_MESSAGE:
2056         case MessageType.CALL_ERROR_MESSAGE:
2057           if (this.requests.has(messageId)) {
2058             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2059             [, errorCallback, requestCommandName] = this.getCachedRequest(messageType, messageId)!
2060             // Reject the deferred promise in case of error at response handling (rejecting an already fulfilled promise is a no-op)
2061             errorCallback(error as OCPPError, false)
2062           } else {
2063             // Remove the request from the cache in case of error at response handling
2064             this.requests.delete(messageId)
2065           }
2066           break
2067       }
2068       if (!(error instanceof OCPPError)) {
2069         logger.warn(
2070           `${this.logPrefix()} Error thrown at incoming OCPP command '${
2071             commandName ?? requestCommandName ?? Constants.UNKNOWN_OCPP_COMMAND
2072             // eslint-disable-next-line @typescript-eslint/no-base-to-string
2073           }' message '${data.toString()}' handling is not an OCPPError:`,
2074           error
2075         )
2076       }
2077       logger.error(
2078         `${this.logPrefix()} Incoming OCPP command '${
2079           commandName ?? requestCommandName ?? Constants.UNKNOWN_OCPP_COMMAND
2080           // eslint-disable-next-line @typescript-eslint/no-base-to-string
2081         }' message '${data.toString()}'${
2082           this.requests.has(messageId)
2083             ? ` matching cached request '${JSON.stringify(this.getCachedRequest(messageType, messageId))}'`
2084             : ''
2085         } processing error:`,
2086         error
2087       )
2088     }
2089   }
2090
2091   private onPing (): void {
2092     logger.debug(`${this.logPrefix()} Received a WS ping (rfc6455) from the server`)
2093   }
2094
2095   private onPong (): void {
2096     logger.debug(`${this.logPrefix()} Received a WS pong (rfc6455) from the server`)
2097   }
2098
2099   private onError (error: WSError): void {
2100     this.closeWSConnection()
2101     logger.error(`${this.logPrefix()} WebSocket error:`, error)
2102   }
2103
2104   private getEnergyActiveImportRegister (
2105     connectorStatus: ConnectorStatus | undefined,
2106     rounded = false
2107   ): number {
2108     if (this.stationInfo?.meteringPerTransaction === true) {
2109       return (
2110         (rounded
2111           ? connectorStatus?.transactionEnergyActiveImportRegisterValue != null
2112             ? Math.round(connectorStatus.transactionEnergyActiveImportRegisterValue)
2113             : undefined
2114           : connectorStatus?.transactionEnergyActiveImportRegisterValue) ?? 0
2115       )
2116     }
2117     return (
2118       (rounded
2119         ? connectorStatus?.energyActiveImportRegisterValue != null
2120           ? Math.round(connectorStatus.energyActiveImportRegisterValue)
2121           : undefined
2122         : connectorStatus?.energyActiveImportRegisterValue) ?? 0
2123     )
2124   }
2125
2126   private getUseConnectorId0 (stationTemplate?: ChargingStationTemplate): boolean {
2127     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2128     return stationTemplate?.useConnectorId0 ?? Constants.DEFAULT_STATION_INFO.useConnectorId0!
2129   }
2130
2131   private async stopRunningTransactions (reason?: StopTransactionReason): Promise<void> {
2132     if (this.hasEvses) {
2133       for (const [evseId, evseStatus] of this.evses) {
2134         if (evseId === 0) {
2135           continue
2136         }
2137         for (const [connectorId, connectorStatus] of evseStatus.connectors) {
2138           if (connectorStatus.transactionStarted === true) {
2139             await this.stopTransactionOnConnector(connectorId, reason)
2140           }
2141         }
2142       }
2143     } else {
2144       for (const connectorId of this.connectors.keys()) {
2145         if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted === true) {
2146           await this.stopTransactionOnConnector(connectorId, reason)
2147         }
2148       }
2149     }
2150   }
2151
2152   // 0 for disabling
2153   private getConnectionTimeout (): number {
2154     if (getConfigurationKey(this, StandardParametersKey.ConnectionTimeOut) != null) {
2155       return convertToInt(
2156         getConfigurationKey(this, StandardParametersKey.ConnectionTimeOut)?.value ??
2157           Constants.DEFAULT_CONNECTION_TIMEOUT
2158       )
2159     }
2160     return Constants.DEFAULT_CONNECTION_TIMEOUT
2161   }
2162
2163   private getPowerDivider (): number {
2164     let powerDivider = this.hasEvses ? this.getNumberOfEvses() : this.getNumberOfConnectors()
2165     if (this.stationInfo?.powerSharedByConnectors === true) {
2166       powerDivider = this.getNumberOfRunningTransactions()
2167     }
2168     return powerDivider
2169   }
2170
2171   private getMaximumAmperage (stationInfo?: ChargingStationInfo): number | undefined {
2172     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2173     const maximumPower = (stationInfo ?? this.stationInfo!).maximumPower!
2174     switch (this.getCurrentOutType(stationInfo)) {
2175       case CurrentType.AC:
2176         return ACElectricUtils.amperagePerPhaseFromPower(
2177           this.getNumberOfPhases(stationInfo),
2178           maximumPower / (this.hasEvses ? this.getNumberOfEvses() : this.getNumberOfConnectors()),
2179           this.getVoltageOut(stationInfo)
2180         )
2181       case CurrentType.DC:
2182         return DCElectricUtils.amperage(maximumPower, this.getVoltageOut(stationInfo))
2183     }
2184   }
2185
2186   private getCurrentOutType (stationInfo?: ChargingStationInfo): CurrentType {
2187     return (
2188       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2189       (stationInfo ?? this.stationInfo!).currentOutType ??
2190       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2191       Constants.DEFAULT_STATION_INFO.currentOutType!
2192     )
2193   }
2194
2195   private getVoltageOut (stationInfo?: ChargingStationInfo): Voltage {
2196     return (
2197       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2198       (stationInfo ?? this.stationInfo!).voltageOut ??
2199       getDefaultVoltageOut(this.getCurrentOutType(stationInfo), this.logPrefix(), this.templateFile)
2200     )
2201   }
2202
2203   private getAmperageLimitation (): number | undefined {
2204     if (
2205       isNotEmptyString(this.stationInfo?.amperageLimitationOcppKey) &&
2206       getConfigurationKey(this, this.stationInfo.amperageLimitationOcppKey) != null
2207     ) {
2208       return (
2209         convertToInt(getConfigurationKey(this, this.stationInfo.amperageLimitationOcppKey)?.value) /
2210         getAmperageLimitationUnitDivider(this.stationInfo)
2211       )
2212     }
2213   }
2214
2215   private async startMessageSequence (ATGStopAbsoluteDuration?: boolean): Promise<void> {
2216     if (this.stationInfo?.autoRegister === true) {
2217       await this.ocppRequestService.requestHandler<
2218       BootNotificationRequest,
2219       BootNotificationResponse
2220       >(this, RequestCommand.BOOT_NOTIFICATION, this.bootNotificationRequest, {
2221         skipBufferingOnError: true
2222       })
2223     }
2224     // Start WebSocket ping
2225     this.startWebSocketPing()
2226     // Start heartbeat
2227     this.startHeartbeat()
2228     // Initialize connectors status
2229     if (this.hasEvses) {
2230       for (const [evseId, evseStatus] of this.evses) {
2231         if (evseId > 0) {
2232           for (const [connectorId, connectorStatus] of evseStatus.connectors) {
2233             const connectorBootStatus = getBootConnectorStatus(this, connectorId, connectorStatus)
2234             await sendAndSetConnectorStatus(this, connectorId, connectorBootStatus, evseId)
2235           }
2236         }
2237       }
2238     } else {
2239       for (const connectorId of this.connectors.keys()) {
2240         if (connectorId > 0) {
2241           const connectorBootStatus = getBootConnectorStatus(
2242             this,
2243             connectorId,
2244             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2245             this.getConnectorStatus(connectorId)!
2246           )
2247           await sendAndSetConnectorStatus(this, connectorId, connectorBootStatus)
2248         }
2249       }
2250     }
2251     if (this.stationInfo?.firmwareStatus === FirmwareStatus.Installing) {
2252       await this.ocppRequestService.requestHandler<
2253       FirmwareStatusNotificationRequest,
2254       FirmwareStatusNotificationResponse
2255       >(this, RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
2256         status: FirmwareStatus.Installed
2257       })
2258       this.stationInfo.firmwareStatus = FirmwareStatus.Installed
2259     }
2260
2261     // Start the ATG
2262     if (this.getAutomaticTransactionGeneratorConfiguration()?.enable === true) {
2263       this.startAutomaticTransactionGenerator(undefined, ATGStopAbsoluteDuration)
2264     }
2265     this.flushMessageBuffer()
2266   }
2267
2268   private internalStopMessageSequence (): void {
2269     // Stop WebSocket ping
2270     this.stopWebSocketPing()
2271     // Stop heartbeat
2272     this.stopHeartbeat()
2273     // Stop the ATG
2274     if (this.automaticTransactionGenerator?.started === true) {
2275       this.stopAutomaticTransactionGenerator()
2276     }
2277   }
2278
2279   private async stopMessageSequence (
2280     reason?: StopTransactionReason,
2281     stopTransactions?: boolean
2282   ): Promise<void> {
2283     this.internalStopMessageSequence()
2284     // Stop ongoing transactions
2285     stopTransactions === true && (await this.stopRunningTransactions(reason))
2286     if (this.hasEvses) {
2287       for (const [evseId, evseStatus] of this.evses) {
2288         if (evseId > 0) {
2289           for (const [connectorId, connectorStatus] of evseStatus.connectors) {
2290             await sendAndSetConnectorStatus(
2291               this,
2292               connectorId,
2293               ConnectorStatusEnum.Unavailable,
2294               evseId
2295             )
2296             delete connectorStatus.status
2297           }
2298         }
2299       }
2300     } else {
2301       for (const connectorId of this.connectors.keys()) {
2302         if (connectorId > 0) {
2303           await sendAndSetConnectorStatus(this, connectorId, ConnectorStatusEnum.Unavailable)
2304           delete this.getConnectorStatus(connectorId)?.status
2305         }
2306       }
2307     }
2308   }
2309
2310   private startWebSocketPing (): void {
2311     const webSocketPingInterval =
2312       getConfigurationKey(this, StandardParametersKey.WebSocketPingInterval) != null
2313         ? convertToInt(
2314           getConfigurationKey(this, StandardParametersKey.WebSocketPingInterval)?.value
2315         )
2316         : 0
2317     if (webSocketPingInterval > 0 && this.wsPingSetInterval == null) {
2318       this.wsPingSetInterval = setInterval(() => {
2319         if (this.isWebSocketConnectionOpened()) {
2320           this.wsConnection?.ping()
2321         }
2322       }, secondsToMilliseconds(webSocketPingInterval))
2323       logger.info(
2324         `${this.logPrefix()} WebSocket ping started every ${formatDurationSeconds(
2325           webSocketPingInterval
2326         )}`
2327       )
2328     } else if (this.wsPingSetInterval != null) {
2329       logger.info(
2330         `${this.logPrefix()} WebSocket ping already started every ${formatDurationSeconds(
2331           webSocketPingInterval
2332         )}`
2333       )
2334     } else {
2335       logger.error(
2336         `${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval}, not starting the WebSocket ping`
2337       )
2338     }
2339   }
2340
2341   private stopWebSocketPing (): void {
2342     if (this.wsPingSetInterval != null) {
2343       clearInterval(this.wsPingSetInterval)
2344       delete this.wsPingSetInterval
2345     }
2346   }
2347
2348   private getConfiguredSupervisionUrl (): URL {
2349     let configuredSupervisionUrl: string
2350     const supervisionUrls = this.stationInfo?.supervisionUrls ?? Configuration.getSupervisionUrls()
2351     if (isNotEmptyArray(supervisionUrls)) {
2352       let configuredSupervisionUrlIndex: number
2353       switch (Configuration.getSupervisionUrlDistribution()) {
2354         case SupervisionUrlDistribution.RANDOM:
2355           configuredSupervisionUrlIndex = Math.floor(secureRandom() * supervisionUrls.length)
2356           break
2357         case SupervisionUrlDistribution.ROUND_ROBIN:
2358         case SupervisionUrlDistribution.CHARGING_STATION_AFFINITY:
2359         default:
2360           !Object.values(SupervisionUrlDistribution).includes(
2361             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2362             Configuration.getSupervisionUrlDistribution()!
2363           ) &&
2364             logger.error(
2365               // eslint-disable-next-line @typescript-eslint/no-base-to-string
2366               `${this.logPrefix()} Unknown supervision url distribution '${Configuration.getSupervisionUrlDistribution()}' from values '${SupervisionUrlDistribution.toString()}', defaulting to ${
2367                 SupervisionUrlDistribution.CHARGING_STATION_AFFINITY
2368               }`
2369             )
2370           configuredSupervisionUrlIndex = (this.index - 1) % supervisionUrls.length
2371           break
2372       }
2373       configuredSupervisionUrl = supervisionUrls[configuredSupervisionUrlIndex]
2374     } else {
2375       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2376       configuredSupervisionUrl = supervisionUrls!
2377     }
2378     if (isNotEmptyString(configuredSupervisionUrl)) {
2379       return new URL(configuredSupervisionUrl)
2380     }
2381     const errorMsg = 'No supervision url(s) configured'
2382     logger.error(`${this.logPrefix()} ${errorMsg}`)
2383     throw new BaseError(errorMsg)
2384   }
2385
2386   private stopHeartbeat (): void {
2387     if (this.heartbeatSetInterval != null) {
2388       clearInterval(this.heartbeatSetInterval)
2389       delete this.heartbeatSetInterval
2390     }
2391   }
2392
2393   private terminateWSConnection (): void {
2394     if (this.isWebSocketConnectionOpened()) {
2395       this.wsConnection?.terminate()
2396       this.wsConnection = null
2397     }
2398   }
2399
2400   private async reconnect (): Promise<void> {
2401     if (
2402       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
2403       this.wsConnectionRetryCount < this.stationInfo!.autoReconnectMaxRetries! ||
2404       this.stationInfo?.autoReconnectMaxRetries === -1
2405     ) {
2406       this.wsConnectionRetried = true
2407       ++this.wsConnectionRetryCount
2408       const reconnectDelay =
2409         this.stationInfo?.reconnectExponentialDelay === true
2410           ? exponentialDelay(this.wsConnectionRetryCount)
2411           : secondsToMilliseconds(this.getConnectionTimeout())
2412       const reconnectDelayWithdraw = 1000
2413       const reconnectTimeout =
2414         reconnectDelay - reconnectDelayWithdraw > 0 ? reconnectDelay - reconnectDelayWithdraw : 0
2415       logger.error(
2416         `${this.logPrefix()} WebSocket connection retry in ${roundTo(
2417           reconnectDelay,
2418           2
2419         )}ms, timeout ${reconnectTimeout}ms`
2420       )
2421       await sleep(reconnectDelay)
2422       logger.error(
2423         `${this.logPrefix()} WebSocket connection retry #${this.wsConnectionRetryCount.toString()}`
2424       )
2425       this.openWSConnection(
2426         {
2427           handshakeTimeout: reconnectTimeout
2428         },
2429         { closeOpened: true }
2430       )
2431     } else if (this.stationInfo?.autoReconnectMaxRetries !== -1) {
2432       logger.error(
2433         `${this.logPrefix()} WebSocket connection retries failure: maximum retries reached (${
2434           this.wsConnectionRetryCount
2435         }) or retries disabled (${this.stationInfo?.autoReconnectMaxRetries})`
2436       )
2437     }
2438   }
2439 }