src/charging-station/ChargingStation.ts

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import { ACElectricUtils, DCElectricUtils } from '../utils/ElectricUtils';
   4 import {
   5   AvailabilityType,
   6   BootNotificationRequest,
   7   CachedRequest,
   8   HeartbeatRequest,
   9   IncomingRequest,
  10   IncomingRequestCommand,
  11   MeterValuesRequest,
  12   RequestCommand,
  13   StatusNotificationRequest,
  14 } from '../types/ocpp/Requests';
  15 import {
  16   BootNotificationResponse,
  17   ErrorResponse,
  18   HeartbeatResponse,
  19   MeterValuesResponse,
  20   RegistrationStatus,
  21   Response,
  22   StatusNotificationResponse,
  23 } from '../types/ocpp/Responses';
  24 import { ChargingProfile, ChargingRateUnitType } from '../types/ocpp/ChargingProfile';
  25 import ChargingStationTemplate, {
  26   CurrentType,
  27   PowerUnits,
  28   WsOptions,
  29 } from '../types/ChargingStationTemplate';
  30 import {
  31   ConnectorPhaseRotation,
  32   StandardParametersKey,
  33   SupportedFeatureProfiles,
  34   VendorDefaultParametersKey,
  35 } from '../types/ocpp/Configuration';
  36 import { MeterValue, MeterValueMeasurand } from '../types/ocpp/MeterValues';
  37 import {
  38   StopTransactionReason,
  39   StopTransactionRequest,
  40   StopTransactionResponse,
  41 } from '../types/ocpp/Transaction';
  42 import { URL, fileURLToPath } from 'url';
  43 import { WSError, WebSocketCloseEventStatusCode } from '../types/WebSocket';
  44 import WebSocket, { Data, RawData } from 'ws';
  45
  46 import AuthorizedTagsCache from './AuthorizedTagsCache';
  47 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
  48 import { AutomaticTransactionGeneratorConfiguration } from '../types/AutomaticTransactionGenerator';
  49 import BaseError from '../exception/BaseError';
  50 import { ChargePointErrorCode } from '../types/ocpp/ChargePointErrorCode';
  51 import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
  52 import ChargingStationConfiguration from '../types/ChargingStationConfiguration';
  53 import { ChargingStationConfigurationUtils } from './ChargingStationConfigurationUtils';
  54 import ChargingStationInfo from '../types/ChargingStationInfo';
  55 import ChargingStationOcppConfiguration from '../types/ChargingStationOcppConfiguration';
  56 import { ChargingStationUtils } from './ChargingStationUtils';
  57 import { ChargingStationWorkerMessageEvents } from '../types/ChargingStationWorker';
  58 import Configuration from '../utils/Configuration';
  59 import { ConnectorStatus } from '../types/ConnectorStatus';
  60 import Constants from '../utils/Constants';
  61 import { ErrorType } from '../types/ocpp/ErrorType';
  62 import { FileType } from '../types/FileType';
  63 import FileUtils from '../utils/FileUtils';
  64 import { JsonType } from '../types/JsonType';
  65 import { MessageType } from '../types/ocpp/MessageType';
  66 import OCPP16IncomingRequestService from './ocpp/1.6/OCPP16IncomingRequestService';
  67 import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
  68 import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
  69 import { OCPP16ServiceUtils } from './ocpp/1.6/OCPP16ServiceUtils';
  70 import OCPPError from '../exception/OCPPError';
  71 import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
  72 import OCPPRequestService from './ocpp/OCPPRequestService';
  73 import { OCPPVersion } from '../types/ocpp/OCPPVersion';
  74 import PerformanceStatistics from '../performance/PerformanceStatistics';
  75 import SharedLRUCache from './SharedLRUCache';
  76 import { SupervisionUrlDistribution } from '../types/ConfigurationData';
  77 import Utils from '../utils/Utils';
  78 import crypto from 'crypto';
  79 import fs from 'fs';
  80 import logger from '../utils/Logger';
  81 import { parentPort } from 'worker_threads';
  82 import path from 'path';
  83
  84 export default class ChargingStation {
  85   public hashId!: string;
  86   public readonly templateFile: string;
  87   public authorizedTagsCache: AuthorizedTagsCache;
  88   public stationInfo!: ChargingStationInfo;
  89   public readonly connectors: Map<number, ConnectorStatus>;
  90   public ocppConfiguration!: ChargingStationOcppConfiguration;
  91   public wsConnection!: WebSocket;
  92   public readonly requests: Map<string, CachedRequest>;
  93   public performanceStatistics!: PerformanceStatistics;
  94   public heartbeatSetInterval!: NodeJS.Timeout;
  95   public ocppRequestService!: OCPPRequestService;
  96   public bootNotificationResponse!: BootNotificationResponse | null;
  97   public powerDivider!: number;
  98   private readonly index: number;
  99   private configurationFile!: string;
 100   private configurationFileHash!: string;
 101   private bootNotificationRequest!: BootNotificationRequest;
 102   private connectorsConfigurationHash!: string;
 103   private ocppIncomingRequestService!: OCPPIncomingRequestService;
 104   private readonly messageBuffer: Set<string>;
 105   private configuredSupervisionUrl!: URL;
 106   private wsConnectionRestarted: boolean;
 107   private autoReconnectRetryCount: number;
 108   private stopped: boolean;
 109   private templateFileWatcher!: fs.FSWatcher;
 110   private readonly sharedLRUCache: SharedLRUCache;
 111   private automaticTransactionGenerator!: AutomaticTransactionGenerator;
 112   private webSocketPingSetInterval!: NodeJS.Timeout;
 113
 114   constructor(index: number, templateFile: string) {
 115     this.index = index;
 116     this.templateFile = templateFile;
 117     this.stopped = false;
 118     this.wsConnectionRestarted = false;
 119     this.autoReconnectRetryCount = 0;
 120     this.sharedLRUCache = SharedLRUCache.getInstance();
 121     this.authorizedTagsCache = AuthorizedTagsCache.getInstance();
 122     this.connectors = new Map<number, ConnectorStatus>();
 123     this.requests = new Map<string, CachedRequest>();
 124     this.messageBuffer = new Set<string>();
 125     this.initialize();
 126   }
 127
 128   private get wsConnectionUrl(): URL {
 129     return new URL(
 130       (this.getSupervisionUrlOcppConfiguration()
 131         ? ChargingStationConfigurationUtils.getConfigurationKey(
 132             this,
 133             this.getSupervisionUrlOcppKey()
 134           ).value
 135         : this.configuredSupervisionUrl.href) +
 136         '/' +
 137         this.stationInfo.chargingStationId
 138     );
 139   }
 140
 141   public logPrefix(): string {
 142     return Utils.logPrefix(
 143       ` ${
 144         this?.stationInfo?.chargingStationId ??
 145         ChargingStationUtils.getChargingStationId(this.index, this.getTemplateFromFile())
 146       } |`
 147     );
 148   }
 149
 150   public getBootNotificationRequest(): BootNotificationRequest {
 151     return this.bootNotificationRequest;
 152   }
 153
 154   public getRandomIdTag(): string {
 155     const authorizationFile = ChargingStationUtils.getAuthorizationFile(this.stationInfo);
 156     const index = Math.floor(
 157       Utils.secureRandom() * this.authorizedTagsCache.getAuthorizedTags(authorizationFile).length
 158     );
 159     return this.authorizedTagsCache.getAuthorizedTags(authorizationFile)[index];
 160   }
 161
 162   public hasAuthorizedTags(): boolean {
 163     return !Utils.isEmptyArray(
 164       this.authorizedTagsCache.getAuthorizedTags(
 165         ChargingStationUtils.getAuthorizationFile(this.stationInfo)
 166       )
 167     );
 168   }
 169
 170   public getEnableStatistics(): boolean | undefined {
 171     return !Utils.isUndefined(this.stationInfo.enableStatistics)
 172       ? this.stationInfo.enableStatistics
 173       : true;
 174   }
 175
 176   public getMayAuthorizeAtRemoteStart(): boolean | undefined {
 177     return this.stationInfo.mayAuthorizeAtRemoteStart ?? true;
 178   }
 179
 180   public getNumberOfPhases(stationInfo?: ChargingStationInfo): number | undefined {
 181     const localStationInfo: ChargingStationInfo = stationInfo ?? this.stationInfo;
 182     switch (this.getCurrentOutType(stationInfo)) {
 183       case CurrentType.AC:
 184         return !Utils.isUndefined(localStationInfo.numberOfPhases)
 185           ? localStationInfo.numberOfPhases
 186           : 3;
 187       case CurrentType.DC:
 188         return 0;
 189     }
 190   }
 191
 192   public isWebSocketConnectionOpened(): boolean {
 193     return this?.wsConnection?.readyState === WebSocket.OPEN;
 194   }
 195
 196   public getRegistrationStatus(): RegistrationStatus {
 197     return this?.bootNotificationResponse?.status;
 198   }
 199
 200   public isInUnknownState(): boolean {
 201     return Utils.isNullOrUndefined(this?.bootNotificationResponse?.status);
 202   }
 203
 204   public isInPendingState(): boolean {
 205     return this?.bootNotificationResponse?.status === RegistrationStatus.PENDING;
 206   }
 207
 208   public isInAcceptedState(): boolean {
 209     return this?.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
 210   }
 211
 212   public isInRejectedState(): boolean {
 213     return this?.bootNotificationResponse?.status === RegistrationStatus.REJECTED;
 214   }
 215
 216   public isRegistered(): boolean {
 217     return !this.isInUnknownState() && (this.isInAcceptedState() || this.isInPendingState());
 218   }
 219
 220   public isChargingStationAvailable(): boolean {
 221     return this.getConnectorStatus(0).availability === AvailabilityType.OPERATIVE;
 222   }
 223
 224   public isConnectorAvailable(id: number): boolean {
 225     return id > 0 && this.getConnectorStatus(id).availability === AvailabilityType.OPERATIVE;
 226   }
 227
 228   public getNumberOfConnectors(): number {
 229     return this.connectors.get(0) ? this.connectors.size - 1 : this.connectors.size;
 230   }
 231
 232   public getConnectorStatus(id: number): ConnectorStatus {
 233     return this.connectors.get(id);
 234   }
 235
 236   public getCurrentOutType(stationInfo?: ChargingStationInfo): CurrentType {
 237     return (stationInfo ?? this.stationInfo).currentOutType ?? CurrentType.AC;
 238   }
 239
 240   public getOcppStrictCompliance(): boolean {
 241     return this.stationInfo?.ocppStrictCompliance ?? false;
 242   }
 243
 244   public getVoltageOut(stationInfo?: ChargingStationInfo): number | undefined {
 245     const defaultVoltageOut = ChargingStationUtils.getDefaultVoltageOut(
 246       this.getCurrentOutType(stationInfo),
 247       this.templateFile,
 248       this.logPrefix()
 249     );
 250     const localStationInfo: ChargingStationInfo = stationInfo ?? this.stationInfo;
 251     return !Utils.isUndefined(localStationInfo.voltageOut)
 252       ? localStationInfo.voltageOut
 253       : defaultVoltageOut;
 254   }
 255
 256   public getConnectorMaximumAvailablePower(connectorId: number): number {
 257     let connectorAmperageLimitationPowerLimit: number;
 258     if (
 259       !Utils.isNullOrUndefined(this.getAmperageLimitation()) &&
 260       this.getAmperageLimitation() < this.stationInfo.maximumAmperage
 261     ) {
 262       connectorAmperageLimitationPowerLimit =
 263         (this.getCurrentOutType() === CurrentType.AC
 264           ? ACElectricUtils.powerTotal(
 265               this.getNumberOfPhases(),
 266               this.getVoltageOut(),
 267               this.getAmperageLimitation() * this.getNumberOfConnectors()
 268             )
 269           : DCElectricUtils.power(this.getVoltageOut(), this.getAmperageLimitation())) /
 270         this.powerDivider;
 271     }
 272     const connectorMaximumPower = this.getMaximumPower() / this.powerDivider;
 273     const connectorChargingProfilePowerLimit = this.getChargingProfilePowerLimit(connectorId);
 274     return Math.min(
 275       isNaN(connectorMaximumPower) ? Infinity : connectorMaximumPower,
 276       isNaN(connectorAmperageLimitationPowerLimit)
 277         ? Infinity
 278         : connectorAmperageLimitationPowerLimit,
 279       isNaN(connectorChargingProfilePowerLimit) ? Infinity : connectorChargingProfilePowerLimit
 280     );
 281   }
 282
 283   public getTransactionIdTag(transactionId: number): string | undefined {
 284     for (const connectorId of this.connectors.keys()) {
 285       if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
 286         return this.getConnectorStatus(connectorId).transactionIdTag;
 287       }
 288     }
 289   }
 290
 291   public getOutOfOrderEndMeterValues(): boolean {
 292     return this.stationInfo?.outOfOrderEndMeterValues ?? false;
 293   }
 294
 295   public getBeginEndMeterValues(): boolean {
 296     return this.stationInfo?.beginEndMeterValues ?? false;
 297   }
 298
 299   public getMeteringPerTransaction(): boolean {
 300     return this.stationInfo?.meteringPerTransaction ?? true;
 301   }
 302
 303   public getTransactionDataMeterValues(): boolean {
 304     return this.stationInfo?.transactionDataMeterValues ?? false;
 305   }
 306
 307   public getMainVoltageMeterValues(): boolean {
 308     return this.stationInfo?.mainVoltageMeterValues ?? true;
 309   }
 310
 311   public getPhaseLineToLineVoltageMeterValues(): boolean {
 312     return this.stationInfo?.phaseLineToLineVoltageMeterValues ?? false;
 313   }
 314
 315   public getCustomValueLimitationMeterValues(): boolean {
 316     return this.stationInfo?.customValueLimitationMeterValues ?? true;
 317   }
 318
 319   public getConnectorIdByTransactionId(transactionId: number): number | undefined {
 320     for (const connectorId of this.connectors.keys()) {
 321       if (
 322         connectorId > 0 &&
 323         this.getConnectorStatus(connectorId)?.transactionId === transactionId
 324       ) {
 325         return connectorId;
 326       }
 327     }
 328   }
 329
 330   public getEnergyActiveImportRegisterByTransactionId(transactionId: number): number | undefined {
 331     const transactionConnectorStatus = this.getConnectorStatus(
 332       this.getConnectorIdByTransactionId(transactionId)
 333     );
 334     if (this.getMeteringPerTransaction()) {
 335       return transactionConnectorStatus?.transactionEnergyActiveImportRegisterValue;
 336     }
 337     return transactionConnectorStatus?.energyActiveImportRegisterValue;
 338   }
 339
 340   public getEnergyActiveImportRegisterByConnectorId(connectorId: number): number | undefined {
 341     const connectorStatus = this.getConnectorStatus(connectorId);
 342     if (this.getMeteringPerTransaction()) {
 343       return connectorStatus?.transactionEnergyActiveImportRegisterValue;
 344     }
 345     return connectorStatus?.energyActiveImportRegisterValue;
 346   }
 347
 348   public getAuthorizeRemoteTxRequests(): boolean {
 349     const authorizeRemoteTxRequests = ChargingStationConfigurationUtils.getConfigurationKey(
 350       this,
 351       StandardParametersKey.AuthorizeRemoteTxRequests
 352     );
 353     return authorizeRemoteTxRequests
 354       ? Utils.convertToBoolean(authorizeRemoteTxRequests.value)
 355       : false;
 356   }
 357
 358   public getLocalAuthListEnabled(): boolean {
 359     const localAuthListEnabled = ChargingStationConfigurationUtils.getConfigurationKey(
 360       this,
 361       StandardParametersKey.LocalAuthListEnabled
 362     );
 363     return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
 364   }
 365
 366   public startHeartbeat(): void {
 367     if (
 368       this.getHeartbeatInterval() &&
 369       this.getHeartbeatInterval() > 0 &&
 370       !this.heartbeatSetInterval
 371     ) {
 372       // eslint-disable-next-line @typescript-eslint/no-misused-promises
 373       this.heartbeatSetInterval = setInterval(async (): Promise<void> => {
 374         await this.ocppRequestService.requestHandler<HeartbeatRequest, HeartbeatResponse>(
 375           this,
 376           RequestCommand.HEARTBEAT
 377         );
 378       }, this.getHeartbeatInterval());
 379       logger.info(
 380         this.logPrefix() +
 381           ' Heartbeat started every ' +
 382           Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
 383       );
 384     } else if (this.heartbeatSetInterval) {
 385       logger.info(
 386         this.logPrefix() +
 387           ' Heartbeat already started every ' +
 388           Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
 389       );
 390     } else {
 391       logger.error(
 392         `${this.logPrefix()} Heartbeat interval set to ${
 393           this.getHeartbeatInterval()
 394             ? Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
 395             : this.getHeartbeatInterval()
 396         }, not starting the heartbeat`
 397       );
 398     }
 399   }
 400
 401   public restartHeartbeat(): void {
 402     // Stop heartbeat
 403     this.stopHeartbeat();
 404     // Start heartbeat
 405     this.startHeartbeat();
 406   }
 407
 408   public restartWebSocketPing(): void {
 409     // Stop WebSocket ping
 410     this.stopWebSocketPing();
 411     // Start WebSocket ping
 412     this.startWebSocketPing();
 413   }
 414
 415   public startMeterValues(connectorId: number, interval: number): void {
 416     if (connectorId === 0) {
 417       logger.error(
 418         `${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`
 419       );
 420       return;
 421     }
 422     if (!this.getConnectorStatus(connectorId)) {
 423       logger.error(
 424         `${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`
 425       );
 426       return;
 427     }
 428     if (!this.getConnectorStatus(connectorId)?.transactionStarted) {
 429       logger.error(
 430         `${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`
 431       );
 432       return;
 433     } else if (
 434       this.getConnectorStatus(connectorId)?.transactionStarted &&
 435       !this.getConnectorStatus(connectorId)?.transactionId
 436     ) {
 437       logger.error(
 438         `${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`
 439       );
 440       return;
 441     }
 442     if (interval > 0) {
 443       // eslint-disable-next-line @typescript-eslint/no-misused-promises
 444       this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(
 445         // eslint-disable-next-line @typescript-eslint/no-misused-promises
 446         async (): Promise<void> => {
 447           // FIXME: Implement OCPP version agnostic helpers
 448           const meterValue: MeterValue = OCPP16ServiceUtils.buildMeterValue(
 449             this,
 450             connectorId,
 451             this.getConnectorStatus(connectorId).transactionId,
 452             interval
 453           );
 454           await this.ocppRequestService.requestHandler<MeterValuesRequest, MeterValuesResponse>(
 455             this,
 456             RequestCommand.METER_VALUES,
 457             {
 458               connectorId,
 459               transactionId: this.getConnectorStatus(connectorId).transactionId,
 460               meterValue: [meterValue],
 461             }
 462           );
 463         },
 464         interval
 465       );
 466     } else {
 467       logger.error(
 468         `${this.logPrefix()} Charging station ${
 469           StandardParametersKey.MeterValueSampleInterval
 470         } configuration set to ${
 471           interval ? Utils.formatDurationMilliSeconds(interval) : interval
 472         }, not sending MeterValues`
 473       );
 474     }
 475   }
 476
 477   public start(): void {
 478     if (this.getEnableStatistics()) {
 479       this.performanceStatistics.start();
 480     }
 481     this.openWSConnection();
 482     // Handle WebSocket message
 483     this.wsConnection.on(
 484       'message',
 485       this.onMessage.bind(this) as (this: WebSocket, data: RawData, isBinary: boolean) => void
 486     );
 487     // Handle WebSocket error
 488     this.wsConnection.on(
 489       'error',
 490       this.onError.bind(this) as (this: WebSocket, error: Error) => void
 491     );
 492     // Handle WebSocket close
 493     this.wsConnection.on(
 494       'close',
 495       this.onClose.bind(this) as (this: WebSocket, code: number, reason: Buffer) => void
 496     );
 497     // Handle WebSocket open
 498     this.wsConnection.on('open', this.onOpen.bind(this) as (this: WebSocket) => void);
 499     // Handle WebSocket ping
 500     this.wsConnection.on('ping', this.onPing.bind(this) as (this: WebSocket, data: Buffer) => void);
 501     // Handle WebSocket pong
 502     this.wsConnection.on('pong', this.onPong.bind(this) as (this: WebSocket, data: Buffer) => void);
 503     // Monitor charging station template file
 504     this.templateFileWatcher = FileUtils.watchJsonFile(
 505       this.logPrefix(),
 506       FileType.ChargingStationTemplate,
 507       this.templateFile,
 508       null,
 509       (event, filename): void => {
 510         if (filename && event === 'change') {
 511           try {
 512             logger.debug(
 513               `${this.logPrefix()} ${FileType.ChargingStationTemplate} ${
 514                 this.templateFile
 515               } file have changed, reload`
 516             );
 517             this.sharedLRUCache.deleteChargingStationTemplate(this.stationInfo?.templateHash);
 518             // Initialize
 519             this.initialize();
 520             // Restart the ATG
 521             this.stopAutomaticTransactionGenerator();
 522             this.startAutomaticTransactionGenerator();
 523             if (this.getEnableStatistics()) {
 524               this.performanceStatistics.restart();
 525             } else {
 526               this.performanceStatistics.stop();
 527             }
 528             // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
 529           } catch (error) {
 530             logger.error(
 531               `${this.logPrefix()} ${FileType.ChargingStationTemplate} file monitoring error: %j`,
 532               error
 533             );
 534           }
 535         }
 536       }
 537     );
 538     parentPort.postMessage({
 539       id: ChargingStationWorkerMessageEvents.STARTED,
 540       data: { id: this.stationInfo.chargingStationId },
 541     });
 542   }
 543
 544   public async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
 545     // Stop message sequence
 546     await this.stopMessageSequence(reason);
 547     for (const connectorId of this.connectors.keys()) {
 548       if (connectorId > 0) {
 549         await this.ocppRequestService.requestHandler<
 550           StatusNotificationRequest,
 551           StatusNotificationResponse
 552         >(this, RequestCommand.STATUS_NOTIFICATION, {
 553           connectorId,
 554           status: ChargePointStatus.UNAVAILABLE,
 555           errorCode: ChargePointErrorCode.NO_ERROR,
 556         });
 557         this.getConnectorStatus(connectorId).status = ChargePointStatus.UNAVAILABLE;
 558       }
 559     }
 560     this.closeWSConnection();
 561     if (this.getEnableStatistics()) {
 562       this.performanceStatistics.stop();
 563     }
 564     this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash);
 565     this.templateFileWatcher.close();
 566     this.sharedLRUCache.deleteChargingStationTemplate(this.stationInfo?.templateHash);
 567     this.bootNotificationResponse = null;
 568     parentPort.postMessage({
 569       id: ChargingStationWorkerMessageEvents.STOPPED,
 570       data: { id: this.stationInfo.chargingStationId },
 571     });
 572     this.stopped = true;
 573   }
 574
 575   public async reset(reason?: StopTransactionReason): Promise<void> {
 576     await this.stop(reason);
 577     await Utils.sleep(this.stationInfo.resetTime);
 578     this.initialize();
 579     this.start();
 580   }
 581
 582   public saveOcppConfiguration(): void {
 583     if (this.getOcppPersistentConfiguration()) {
 584       this.saveConfiguration();
 585     }
 586   }
 587
 588   public getChargingProfilePowerLimit(connectorId: number): number | undefined {
 589     let limit: number, matchingChargingProfile: ChargingProfile;
 590     let chargingProfiles: ChargingProfile[] = [];
 591     // Get charging profiles for connector and sort by stack level
 592     chargingProfiles = this.getConnectorStatus(connectorId).chargingProfiles.sort(
 593       (a, b) => b.stackLevel - a.stackLevel
 594     );
 595     // Get profiles on connector 0
 596     if (this.getConnectorStatus(0).chargingProfiles) {
 597       chargingProfiles.push(
 598         ...this.getConnectorStatus(0).chargingProfiles.sort((a, b) => b.stackLevel - a.stackLevel)
 599       );
 600     }
 601     if (!Utils.isEmptyArray(chargingProfiles)) {
 602       const result = ChargingStationUtils.getLimitFromChargingProfiles(
 603         chargingProfiles,
 604         Utils.logPrefix()
 605       );
 606       if (!Utils.isNullOrUndefined(result)) {
 607         limit = result.limit;
 608         matchingChargingProfile = result.matchingChargingProfile;
 609         switch (this.getCurrentOutType()) {
 610           case CurrentType.AC:
 611             limit =
 612               matchingChargingProfile.chargingSchedule.chargingRateUnit ===
 613               ChargingRateUnitType.WATT
 614                 ? limit
 615                 : ACElectricUtils.powerTotal(this.getNumberOfPhases(), this.getVoltageOut(), limit);
 616             break;
 617           case CurrentType.DC:
 618             limit =
 619               matchingChargingProfile.chargingSchedule.chargingRateUnit ===
 620               ChargingRateUnitType.WATT
 621                 ? limit
 622                 : DCElectricUtils.power(this.getVoltageOut(), limit);
 623         }
 624
 625         const connectorMaximumPower = this.getMaximumPower() / this.powerDivider;
 626         if (limit > connectorMaximumPower) {
 627           logger.error(
 628             `${this.logPrefix()} Charging profile id ${
 629               matchingChargingProfile.chargingProfileId
 630             } limit is greater than connector id ${connectorId} maximum, dump charging profiles' stack: %j`,
 631             this.getConnectorStatus(connectorId).chargingProfiles
 632           );
 633           limit = connectorMaximumPower;
 634         }
 635       }
 636     }
 637     return limit;
 638   }
 639
 640   public setChargingProfile(connectorId: number, cp: ChargingProfile): void {
 641     if (Utils.isNullOrUndefined(this.getConnectorStatus(connectorId).chargingProfiles)) {
 642       logger.error(
 643         `${this.logPrefix()} Trying to set a charging profile on connectorId ${connectorId} with an uninitialized charging profiles array attribute, applying deferred initialization`
 644       );
 645       this.getConnectorStatus(connectorId).chargingProfiles = [];
 646     }
 647     if (!Array.isArray(this.getConnectorStatus(connectorId).chargingProfiles)) {
 648       logger.error(
 649         `${this.logPrefix()} Trying to set a charging profile on connectorId ${connectorId} with an improper attribute type for the charging profiles array, applying proper type initialization`
 650       );
 651       this.getConnectorStatus(connectorId).chargingProfiles = [];
 652     }
 653     let cpReplaced = false;
 654     if (!Utils.isEmptyArray(this.getConnectorStatus(connectorId).chargingProfiles)) {
 655       this.getConnectorStatus(connectorId).chargingProfiles?.forEach(
 656         (chargingProfile: ChargingProfile, index: number) => {
 657           if (
 658             chargingProfile.chargingProfileId === cp.chargingProfileId ||
 659             (chargingProfile.stackLevel === cp.stackLevel &&
 660               chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)
 661           ) {
 662             this.getConnectorStatus(connectorId).chargingProfiles[index] = cp;
 663             cpReplaced = true;
 664           }
 665         }
 666       );
 667     }
 668     !cpReplaced && this.getConnectorStatus(connectorId).chargingProfiles?.push(cp);
 669   }
 670
 671   public resetConnectorStatus(connectorId: number): void {
 672     this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
 673     this.getConnectorStatus(connectorId).idTagAuthorized = false;
 674     this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
 675     this.getConnectorStatus(connectorId).transactionStarted = false;
 676     delete this.getConnectorStatus(connectorId).localAuthorizeIdTag;
 677     delete this.getConnectorStatus(connectorId).authorizeIdTag;
 678     delete this.getConnectorStatus(connectorId).transactionId;
 679     delete this.getConnectorStatus(connectorId).transactionIdTag;
 680     this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
 681     delete this.getConnectorStatus(connectorId).transactionBeginMeterValue;
 682     this.stopMeterValues(connectorId);
 683   }
 684
 685   public hasFeatureProfile(featureProfile: SupportedFeatureProfiles) {
 686     return ChargingStationConfigurationUtils.getConfigurationKey(
 687       this,
 688       StandardParametersKey.SupportedFeatureProfiles
 689     )?.value.includes(featureProfile);
 690   }
 691
 692   public bufferMessage(message: string): void {
 693     this.messageBuffer.add(message);
 694   }
 695
 696   private flushMessageBuffer() {
 697     if (this.messageBuffer.size > 0) {
 698       this.messageBuffer.forEach((message) => {
 699         // TODO: evaluate the need to track performance
 700         this.wsConnection.send(message);
 701         this.messageBuffer.delete(message);
 702       });
 703     }
 704   }
 705
 706   private getSupervisionUrlOcppConfiguration(): boolean {
 707     return this.stationInfo.supervisionUrlOcppConfiguration ?? false;
 708   }
 709
 710   private getSupervisionUrlOcppKey(): string {
 711     return this.stationInfo.supervisionUrlOcppKey ?? VendorDefaultParametersKey.ConnectionUrl;
 712   }
 713
 714   private getTemplateFromFile(): ChargingStationTemplate | null {
 715     let template: ChargingStationTemplate = null;
 716     try {
 717       if (this.sharedLRUCache.hasChargingStationTemplate(this.stationInfo?.templateHash)) {
 718         template = this.sharedLRUCache.getChargingStationTemplate(this.stationInfo.templateHash);
 719       } else {
 720         const measureId = `${FileType.ChargingStationTemplate} read`;
 721         const beginId = PerformanceStatistics.beginMeasure(measureId);
 722         template = JSON.parse(
 723           fs.readFileSync(this.templateFile, 'utf8')
 724         ) as ChargingStationTemplate;
 725         PerformanceStatistics.endMeasure(measureId, beginId);
 726         template.templateHash = crypto
 727           .createHash(Constants.DEFAULT_HASH_ALGORITHM)
 728           .update(JSON.stringify(template))
 729           .digest('hex');
 730         this.sharedLRUCache.setChargingStationTemplate(template);
 731       }
 732     } catch (error) {
 733       FileUtils.handleFileException(
 734         this.logPrefix(),
 735         FileType.ChargingStationTemplate,
 736         this.templateFile,
 737         error as NodeJS.ErrnoException
 738       );
 739     }
 740     return template;
 741   }
 742
 743   private getStationInfoFromTemplate(): ChargingStationInfo {
 744     const stationTemplate: ChargingStationTemplate = this.getTemplateFromFile();
 745     if (Utils.isNullOrUndefined(stationTemplate)) {
 746       const errorMsg = 'Failed to read charging station template file';
 747       logger.error(`${this.logPrefix()} ${errorMsg}`);
 748       throw new BaseError(errorMsg);
 749     }
 750     if (Utils.isEmptyObject(stationTemplate)) {
 751       const errorMsg = `Empty charging station information from template file ${this.templateFile}`;
 752       logger.error(`${this.logPrefix()} ${errorMsg}`);
 753       throw new BaseError(errorMsg);
 754     }
 755     // Deprecation template keys section
 756     ChargingStationUtils.warnDeprecatedTemplateKey(
 757       stationTemplate,
 758       'supervisionUrl',
 759       this.templateFile,
 760       this.logPrefix(),
 761       "Use 'supervisionUrls' instead"
 762     );
 763     ChargingStationUtils.convertDeprecatedTemplateKey(
 764       stationTemplate,
 765       'supervisionUrl',
 766       'supervisionUrls'
 767     );
 768     const stationInfo: ChargingStationInfo =
 769       ChargingStationUtils.stationTemplateToStationInfo(stationTemplate);
 770     stationInfo.chargingStationId = ChargingStationUtils.getChargingStationId(
 771       this.index,
 772       stationTemplate
 773     );
 774     ChargingStationUtils.createSerialNumber(stationTemplate, stationInfo);
 775     if (!Utils.isEmptyArray(stationTemplate.power)) {
 776       stationTemplate.power = stationTemplate.power as number[];
 777       const powerArrayRandomIndex = Math.floor(Utils.secureRandom() * stationTemplate.power.length);
 778       stationInfo.maximumPower =
 779         stationTemplate.powerUnit === PowerUnits.KILO_WATT
 780           ? stationTemplate.power[powerArrayRandomIndex] * 1000
 781           : stationTemplate.power[powerArrayRandomIndex];
 782     } else {
 783       stationTemplate.power = stationTemplate.power as number;
 784       stationInfo.maximumPower =
 785         stationTemplate.powerUnit === PowerUnits.KILO_WATT
 786           ? stationTemplate.power * 1000
 787           : stationTemplate.power;
 788     }
 789     stationInfo.resetTime = stationTemplate.resetTime
 790       ? stationTemplate.resetTime * 1000
 791       : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
 792     const configuredMaxConnectors = ChargingStationUtils.getConfiguredNumberOfConnectors(
 793       this.index,
 794       stationTemplate
 795     );
 796     ChargingStationUtils.checkConfiguredMaxConnectors(
 797       configuredMaxConnectors,
 798       this.templateFile,
 799       Utils.logPrefix()
 800     );
 801     const templateMaxConnectors =
 802       ChargingStationUtils.getTemplateMaxNumberOfConnectors(stationTemplate);
 803     ChargingStationUtils.checkTemplateMaxConnectors(
 804       templateMaxConnectors,
 805       this.templateFile,
 806       Utils.logPrefix()
 807     );
 808     if (
 809       configuredMaxConnectors >
 810         (stationTemplate?.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) &&
 811       !stationTemplate?.randomConnectors
 812     ) {
 813       logger.warn(
 814         `${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${
 815           this.templateFile
 816         }, forcing random connector configurations affectation`
 817       );
 818       stationInfo.randomConnectors = true;
 819     }
 820     // Build connectors if needed (FIXME: should be factored out)
 821     this.initializeConnectors(stationInfo, configuredMaxConnectors, templateMaxConnectors);
 822     stationInfo.maximumAmperage = this.getMaximumAmperage(stationInfo);
 823     ChargingStationUtils.createStationInfoHash(stationInfo);
 824     return stationInfo;
 825   }
 826
 827   private getStationInfoFromFile(): ChargingStationInfo | null {
 828     let stationInfo: ChargingStationInfo = null;
 829     this.getStationInfoPersistentConfiguration() &&
 830       (stationInfo = this.getConfigurationFromFile()?.stationInfo ?? null);
 831     stationInfo && ChargingStationUtils.createStationInfoHash(stationInfo);
 832     return stationInfo;
 833   }
 834
 835   private getStationInfo(): ChargingStationInfo {
 836     const stationInfoFromTemplate: ChargingStationInfo = this.getStationInfoFromTemplate();
 837     const stationInfoFromFile: ChargingStationInfo = this.getStationInfoFromFile();
 838     // Priority: charging station info from template > charging station info from configuration file > charging station info attribute
 839     if (stationInfoFromFile?.templateHash === stationInfoFromTemplate.templateHash) {
 840       if (this.stationInfo?.infoHash === stationInfoFromFile?.infoHash) {
 841         return this.stationInfo;
 842       }
 843       return stationInfoFromFile;
 844     }
 845     stationInfoFromFile &&
 846       ChargingStationUtils.propagateSerialNumber(
 847         this.getTemplateFromFile(),
 848         stationInfoFromFile,
 849         stationInfoFromTemplate
 850       );
 851     return stationInfoFromTemplate;
 852   }
 853
 854   private saveStationInfo(): void {
 855     if (this.getStationInfoPersistentConfiguration()) {
 856       this.saveConfiguration();
 857     }
 858   }
 859
 860   private getOcppVersion(): OCPPVersion {
 861     return this.stationInfo.ocppVersion ?? OCPPVersion.VERSION_16;
 862   }
 863
 864   private getOcppPersistentConfiguration(): boolean {
 865     return this.stationInfo?.ocppPersistentConfiguration ?? true;
 866   }
 867
 868   private getStationInfoPersistentConfiguration(): boolean {
 869     return this.stationInfo?.stationInfoPersistentConfiguration ?? true;
 870   }
 871
 872   private handleUnsupportedVersion(version: OCPPVersion) {
 873     const errMsg = `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${
 874       this.templateFile
 875     }`;
 876     logger.error(errMsg);
 877     throw new Error(errMsg);
 878   }
 879
 880   private initialize(): void {
 881     this.hashId = ChargingStationUtils.getHashId(this.index, this.getTemplateFromFile());
 882     logger.info(`${this.logPrefix()} Charging station hashId '${this.hashId}'`);
 883     this.configurationFile = path.join(
 884       path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../'),
 885       'assets',
 886       'configurations',
 887       this.hashId + '.json'
 888     );
 889     this.stationInfo = this.getStationInfo();
 890     this.saveStationInfo();
 891     // Avoid duplication of connectors related information in RAM
 892     this.stationInfo?.Connectors && delete this.stationInfo.Connectors;
 893     this.configuredSupervisionUrl = this.getConfiguredSupervisionUrl();
 894     if (this.getEnableStatistics()) {
 895       this.performanceStatistics = PerformanceStatistics.getInstance(
 896         this.hashId,
 897         this.stationInfo.chargingStationId,
 898         this.configuredSupervisionUrl
 899       );
 900     }
 901     this.bootNotificationRequest = ChargingStationUtils.createBootNotificationRequest(
 902       this.stationInfo
 903     );
 904     this.powerDivider = this.getPowerDivider();
 905     // OCPP configuration
 906     this.ocppConfiguration = this.getOcppConfiguration();
 907     this.initializeOcppConfiguration();
 908     switch (this.getOcppVersion()) {
 909       case OCPPVersion.VERSION_16:
 910         this.ocppIncomingRequestService =
 911           OCPP16IncomingRequestService.getInstance<OCPP16IncomingRequestService>();
 912         this.ocppRequestService = OCPP16RequestService.getInstance<OCPP16RequestService>(
 913           OCPP16ResponseService.getInstance<OCPP16ResponseService>()
 914         );
 915         break;
 916       default:
 917         this.handleUnsupportedVersion(this.getOcppVersion());
 918         break;
 919     }
 920     if (this.stationInfo?.autoRegister) {
 921       this.bootNotificationResponse = {
 922         currentTime: new Date().toISOString(),
 923         interval: this.getHeartbeatInterval() / 1000,
 924         status: RegistrationStatus.ACCEPTED,
 925       };
 926     }
 927   }
 928
 929   private initializeOcppConfiguration(): void {
 930     if (
 931       !ChargingStationConfigurationUtils.getConfigurationKey(
 932         this,
 933         StandardParametersKey.HeartbeatInterval
 934       )
 935     ) {
 936       ChargingStationConfigurationUtils.addConfigurationKey(
 937         this,
 938         StandardParametersKey.HeartbeatInterval,
 939         '0'
 940       );
 941     }
 942     if (
 943       !ChargingStationConfigurationUtils.getConfigurationKey(
 944         this,
 945         StandardParametersKey.HeartBeatInterval
 946       )
 947     ) {
 948       ChargingStationConfigurationUtils.addConfigurationKey(
 949         this,
 950         StandardParametersKey.HeartBeatInterval,
 951         '0',
 952         { visible: false }
 953       );
 954     }
 955     if (
 956       this.getSupervisionUrlOcppConfiguration() &&
 957       !ChargingStationConfigurationUtils.getConfigurationKey(this, this.getSupervisionUrlOcppKey())
 958     ) {
 959       ChargingStationConfigurationUtils.addConfigurationKey(
 960         this,
 961         this.getSupervisionUrlOcppKey(),
 962         this.configuredSupervisionUrl.href,
 963         { reboot: true }
 964       );
 965     } else if (
 966       !this.getSupervisionUrlOcppConfiguration() &&
 967       ChargingStationConfigurationUtils.getConfigurationKey(this, this.getSupervisionUrlOcppKey())
 968     ) {
 969       ChargingStationConfigurationUtils.deleteConfigurationKey(
 970         this,
 971         this.getSupervisionUrlOcppKey(),
 972         { save: false }
 973       );
 974     }
 975     if (
 976       this.stationInfo.amperageLimitationOcppKey &&
 977       !ChargingStationConfigurationUtils.getConfigurationKey(
 978         this,
 979         this.stationInfo.amperageLimitationOcppKey
 980       )
 981     ) {
 982       ChargingStationConfigurationUtils.addConfigurationKey(
 983         this,
 984         this.stationInfo.amperageLimitationOcppKey,
 985         (
 986           this.stationInfo.maximumAmperage *
 987           ChargingStationUtils.getAmperageLimitationUnitDivider(this.stationInfo)
 988         ).toString()
 989       );
 990     }
 991     if (
 992       !ChargingStationConfigurationUtils.getConfigurationKey(
 993         this,
 994         StandardParametersKey.SupportedFeatureProfiles
 995       )
 996     ) {
 997       ChargingStationConfigurationUtils.addConfigurationKey(
 998         this,
 999         StandardParametersKey.SupportedFeatureProfiles,
1000         `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.FirmwareManagement},${SupportedFeatureProfiles.LocalAuthListManagement},${SupportedFeatureProfiles.SmartCharging},${SupportedFeatureProfiles.RemoteTrigger}`
1001       );
1002     }
1003     ChargingStationConfigurationUtils.addConfigurationKey(
1004       this,
1005       StandardParametersKey.NumberOfConnectors,
1006       this.getNumberOfConnectors().toString(),
1007       { readonly: true },
1008       { overwrite: true }
1009     );
1010     if (
1011       !ChargingStationConfigurationUtils.getConfigurationKey(
1012         this,
1013         StandardParametersKey.MeterValuesSampledData
1014       )
1015     ) {
1016       ChargingStationConfigurationUtils.addConfigurationKey(
1017         this,
1018         StandardParametersKey.MeterValuesSampledData,
1019         MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
1020       );
1021     }
1022     if (
1023       !ChargingStationConfigurationUtils.getConfigurationKey(
1024         this,
1025         StandardParametersKey.ConnectorPhaseRotation
1026       )
1027     ) {
1028       const connectorPhaseRotation = [];
1029       for (const connectorId of this.connectors.keys()) {
1030         // AC/DC
1031         if (connectorId === 0 && this.getNumberOfPhases() === 0) {
1032           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
1033         } else if (connectorId > 0 && this.getNumberOfPhases() === 0) {
1034           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
1035           // AC
1036         } else if (connectorId > 0 && this.getNumberOfPhases() === 1) {
1037           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
1038         } else if (connectorId > 0 && this.getNumberOfPhases() === 3) {
1039           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
1040         }
1041       }
1042       ChargingStationConfigurationUtils.addConfigurationKey(
1043         this,
1044         StandardParametersKey.ConnectorPhaseRotation,
1045         connectorPhaseRotation.toString()
1046       );
1047     }
1048     if (
1049       !ChargingStationConfigurationUtils.getConfigurationKey(
1050         this,
1051         StandardParametersKey.AuthorizeRemoteTxRequests
1052       )
1053     ) {
1054       ChargingStationConfigurationUtils.addConfigurationKey(
1055         this,
1056         StandardParametersKey.AuthorizeRemoteTxRequests,
1057         'true'
1058       );
1059     }
1060     if (
1061       !ChargingStationConfigurationUtils.getConfigurationKey(
1062         this,
1063         StandardParametersKey.LocalAuthListEnabled
1064       ) &&
1065       ChargingStationConfigurationUtils.getConfigurationKey(
1066         this,
1067         StandardParametersKey.SupportedFeatureProfiles
1068       )?.value.includes(SupportedFeatureProfiles.LocalAuthListManagement)
1069     ) {
1070       ChargingStationConfigurationUtils.addConfigurationKey(
1071         this,
1072         StandardParametersKey.LocalAuthListEnabled,
1073         'false'
1074       );
1075     }
1076     if (
1077       !ChargingStationConfigurationUtils.getConfigurationKey(
1078         this,
1079         StandardParametersKey.ConnectionTimeOut
1080       )
1081     ) {
1082       ChargingStationConfigurationUtils.addConfigurationKey(
1083         this,
1084         StandardParametersKey.ConnectionTimeOut,
1085         Constants.DEFAULT_CONNECTION_TIMEOUT.toString()
1086       );
1087     }
1088     this.saveOcppConfiguration();
1089   }
1090
1091   private initializeConnectors(
1092     stationInfo: ChargingStationInfo,
1093     configuredMaxConnectors: number,
1094     templateMaxConnectors: number
1095   ): void {
1096     if (!stationInfo?.Connectors && this.connectors.size === 0) {
1097       const logMsg = `${this.logPrefix()} No already defined connectors and charging station information from template ${
1098         this.templateFile
1099       } with no connectors configuration defined`;
1100       logger.error(logMsg);
1101       throw new BaseError(logMsg);
1102     }
1103     if (!stationInfo?.Connectors[0]) {
1104       logger.warn(
1105         `${this.logPrefix()} Charging station information from template ${
1106           this.templateFile
1107         } with no connector Id 0 configuration`
1108       );
1109     }
1110     if (stationInfo?.Connectors) {
1111       const connectorsConfigHash = crypto
1112         .createHash(Constants.DEFAULT_HASH_ALGORITHM)
1113         .update(JSON.stringify(stationInfo?.Connectors) + configuredMaxConnectors.toString())
1114         .digest('hex');
1115       const connectorsConfigChanged =
1116         this.connectors?.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash;
1117       if (this.connectors?.size === 0 || connectorsConfigChanged) {
1118         connectorsConfigChanged && this.connectors.clear();
1119         this.connectorsConfigurationHash = connectorsConfigHash;
1120         // Add connector Id 0
1121         let lastConnector = '0';
1122         for (lastConnector in stationInfo?.Connectors) {
1123           const lastConnectorId = Utils.convertToInt(lastConnector);
1124           if (
1125             lastConnectorId === 0 &&
1126             this.getUseConnectorId0(stationInfo) &&
1127             stationInfo?.Connectors[lastConnector]
1128           ) {
1129             this.connectors.set(
1130               lastConnectorId,
1131               Utils.cloneObject<ConnectorStatus>(stationInfo?.Connectors[lastConnector])
1132             );
1133             this.getConnectorStatus(lastConnectorId).availability = AvailabilityType.OPERATIVE;
1134             if (Utils.isUndefined(this.getConnectorStatus(lastConnectorId)?.chargingProfiles)) {
1135               this.getConnectorStatus(lastConnectorId).chargingProfiles = [];
1136             }
1137           }
1138         }
1139         // Generate all connectors
1140         if ((stationInfo?.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
1141           for (let index = 1; index <= configuredMaxConnectors; index++) {
1142             const randConnectorId = stationInfo?.randomConnectors
1143               ? Utils.getRandomInteger(Utils.convertToInt(lastConnector), 1)
1144               : index;
1145             this.connectors.set(
1146               index,
1147               Utils.cloneObject<ConnectorStatus>(stationInfo?.Connectors[randConnectorId])
1148             );
1149             this.getConnectorStatus(index).availability = AvailabilityType.OPERATIVE;
1150             if (Utils.isUndefined(this.getConnectorStatus(index)?.chargingProfiles)) {
1151               this.getConnectorStatus(index).chargingProfiles = [];
1152             }
1153           }
1154         }
1155       }
1156     } else {
1157       logger.warn(
1158         `${this.logPrefix()} Charging station information from template ${
1159           this.templateFile
1160         } with no connectors configuration defined, using already defined connectors`
1161       );
1162     }
1163     // Initialize transaction attributes on connectors
1164     for (const connectorId of this.connectors.keys()) {
1165       if (connectorId > 0 && !this.getConnectorStatus(connectorId)?.transactionStarted) {
1166         this.initializeConnectorStatus(connectorId);
1167       }
1168     }
1169   }
1170
1171   private getConfigurationFromFile(): ChargingStationConfiguration | null {
1172     let configuration: ChargingStationConfiguration = null;
1173     if (this.configurationFile && fs.existsSync(this.configurationFile)) {
1174       try {
1175         if (this.sharedLRUCache.hasChargingStationConfiguration(this.configurationFileHash)) {
1176           configuration = this.sharedLRUCache.getChargingStationConfiguration(
1177             this.configurationFileHash
1178           );
1179         } else {
1180           const measureId = `${FileType.ChargingStationConfiguration} read`;
1181           const beginId = PerformanceStatistics.beginMeasure(measureId);
1182           configuration = JSON.parse(
1183             fs.readFileSync(this.configurationFile, 'utf8')
1184           ) as ChargingStationConfiguration;
1185           PerformanceStatistics.endMeasure(measureId, beginId);
1186           this.configurationFileHash = configuration.configurationHash;
1187           this.sharedLRUCache.setChargingStationConfiguration(configuration);
1188         }
1189       } catch (error) {
1190         FileUtils.handleFileException(
1191           this.logPrefix(),
1192           FileType.ChargingStationConfiguration,
1193           this.configurationFile,
1194           error as NodeJS.ErrnoException
1195         );
1196       }
1197     }
1198     return configuration;
1199   }
1200
1201   private saveConfiguration(): void {
1202     if (this.configurationFile) {
1203       try {
1204         if (!fs.existsSync(path.dirname(this.configurationFile))) {
1205           fs.mkdirSync(path.dirname(this.configurationFile), { recursive: true });
1206         }
1207         const configurationData: ChargingStationConfiguration =
1208           this.getConfigurationFromFile() ?? {};
1209         this.ocppConfiguration?.configurationKey &&
1210           (configurationData.configurationKey = this.ocppConfiguration.configurationKey);
1211         this.stationInfo && (configurationData.stationInfo = this.stationInfo);
1212         delete configurationData.configurationHash;
1213         const configurationHash = crypto
1214           .createHash(Constants.DEFAULT_HASH_ALGORITHM)
1215           .update(JSON.stringify(configurationData))
1216           .digest('hex');
1217         if (this.configurationFileHash !== configurationHash) {
1218           configurationData.configurationHash = configurationHash;
1219           const measureId = `${FileType.ChargingStationConfiguration} write`;
1220           const beginId = PerformanceStatistics.beginMeasure(measureId);
1221           const fileDescriptor = fs.openSync(this.configurationFile, 'w');
1222           fs.writeFileSync(fileDescriptor, JSON.stringify(configurationData, null, 2), 'utf8');
1223           fs.closeSync(fileDescriptor);
1224           PerformanceStatistics.endMeasure(measureId, beginId);
1225           this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash);
1226           this.configurationFileHash = configurationHash;
1227           this.sharedLRUCache.setChargingStationConfiguration(configurationData);
1228         } else {
1229           logger.debug(
1230             `${this.logPrefix()} Not saving unchanged charging station configuration file ${
1231               this.configurationFile
1232             }`
1233           );
1234         }
1235       } catch (error) {
1236         FileUtils.handleFileException(
1237           this.logPrefix(),
1238           FileType.ChargingStationConfiguration,
1239           this.configurationFile,
1240           error as NodeJS.ErrnoException
1241         );
1242       }
1243     } else {
1244       logger.error(
1245         `${this.logPrefix()} Trying to save charging station configuration to undefined configuration file`
1246       );
1247     }
1248   }
1249
1250   private getOcppConfigurationFromTemplate(): ChargingStationOcppConfiguration | null {
1251     return this.getTemplateFromFile()?.Configuration ?? null;
1252   }
1253
1254   private getOcppConfigurationFromFile(): ChargingStationOcppConfiguration | null {
1255     let configuration: ChargingStationConfiguration = null;
1256     if (this.getOcppPersistentConfiguration()) {
1257       const configurationFromFile = this.getConfigurationFromFile();
1258       configuration = configurationFromFile?.configurationKey && configurationFromFile;
1259     }
1260     configuration && delete configuration.stationInfo;
1261     return configuration;
1262   }
1263
1264   private getOcppConfiguration(): ChargingStationOcppConfiguration | null {
1265     let ocppConfiguration: ChargingStationOcppConfiguration = this.getOcppConfigurationFromFile();
1266     if (!ocppConfiguration) {
1267       ocppConfiguration = this.getOcppConfigurationFromTemplate();
1268     }
1269     return ocppConfiguration;
1270   }
1271
1272   private async onOpen(): Promise<void> {
1273     if (this.isWebSocketConnectionOpened()) {
1274       logger.info(
1275         `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} succeeded`
1276       );
1277       if (!this.isRegistered()) {
1278         // Send BootNotification
1279         let registrationRetryCount = 0;
1280         do {
1281           this.bootNotificationResponse = await this.ocppRequestService.requestHandler<
1282             BootNotificationRequest,
1283             BootNotificationResponse
1284           >(
1285             this,
1286             RequestCommand.BOOT_NOTIFICATION,
1287             {
1288               chargePointModel: this.bootNotificationRequest.chargePointModel,
1289               chargePointVendor: this.bootNotificationRequest.chargePointVendor,
1290               chargeBoxSerialNumber: this.bootNotificationRequest.chargeBoxSerialNumber,
1291               firmwareVersion: this.bootNotificationRequest.firmwareVersion,
1292               chargePointSerialNumber: this.bootNotificationRequest.chargePointSerialNumber,
1293               iccid: this.bootNotificationRequest.iccid,
1294               imsi: this.bootNotificationRequest.imsi,
1295               meterSerialNumber: this.bootNotificationRequest.meterSerialNumber,
1296               meterType: this.bootNotificationRequest.meterType,
1297             },
1298             { skipBufferingOnError: true }
1299           );
1300           if (!this.isRegistered()) {
1301             this.getRegistrationMaxRetries() !== -1 && registrationRetryCount++;
1302             await Utils.sleep(
1303               this.bootNotificationResponse?.interval
1304                 ? this.bootNotificationResponse.interval * 1000
1305                 : Constants.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL
1306             );
1307           }
1308         } while (
1309           !this.isRegistered() &&
1310           (registrationRetryCount <= this.getRegistrationMaxRetries() ||
1311             this.getRegistrationMaxRetries() === -1)
1312         );
1313       }
1314       if (this.isRegistered()) {
1315         if (this.isInAcceptedState()) {
1316           await this.startMessageSequence();
1317           this.wsConnectionRestarted && this.flushMessageBuffer();
1318         }
1319       } else {
1320         logger.error(
1321           `${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`
1322         );
1323       }
1324       this.stopped && (this.stopped = false);
1325       this.autoReconnectRetryCount = 0;
1326       this.wsConnectionRestarted = false;
1327     } else {
1328       logger.warn(
1329         `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} failed`
1330       );
1331     }
1332   }
1333
1334   private async onClose(code: number, reason: string): Promise<void> {
1335     switch (code) {
1336       // Normal close
1337       case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
1338       case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
1339         logger.info(
1340           `${this.logPrefix()} WebSocket normally closed with status '${ChargingStationUtils.getWebSocketCloseEventStatusString(
1341             code
1342           )}' and reason '${reason}'`
1343         );
1344         this.autoReconnectRetryCount = 0;
1345         break;
1346       // Abnormal close
1347       default:
1348         logger.error(
1349           `${this.logPrefix()} WebSocket abnormally closed with status '${ChargingStationUtils.getWebSocketCloseEventStatusString(
1350             code
1351           )}' and reason '${reason}'`
1352         );
1353         await this.reconnect(code);
1354         break;
1355     }
1356   }
1357
1358   private async onMessage(data: Data): Promise<void> {
1359     let messageType: number;
1360     let messageId: string;
1361     let commandName: IncomingRequestCommand;
1362     let commandPayload: JsonType;
1363     let errorType: ErrorType;
1364     let errorMessage: string;
1365     let errorDetails: JsonType;
1366     let responseCallback: (payload: JsonType, requestPayload: JsonType) => void;
1367     let errorCallback: (error: OCPPError, requestStatistic?: boolean) => void;
1368     let requestCommandName: RequestCommand | IncomingRequestCommand;
1369     let requestPayload: JsonType;
1370     let cachedRequest: CachedRequest;
1371     let errMsg: string;
1372     try {
1373       const request = JSON.parse(data.toString()) as IncomingRequest | Response | ErrorResponse;
1374       if (Utils.isIterable(request)) {
1375         [messageType, messageId] = request;
1376         // Check the type of message
1377         switch (messageType) {
1378           // Incoming Message
1379           case MessageType.CALL_MESSAGE:
1380             [, , commandName, commandPayload] = request as IncomingRequest;
1381             if (this.getEnableStatistics()) {
1382               this.performanceStatistics.addRequestStatistic(commandName, messageType);
1383             }
1384             logger.debug(
1385               `${this.logPrefix()} << Command '${commandName}' received request payload: ${JSON.stringify(
1386                 request
1387               )}`
1388             );
1389             // Process the message
1390             await this.ocppIncomingRequestService.incomingRequestHandler(
1391               this,
1392               messageId,
1393               commandName,
1394               commandPayload
1395             );
1396             break;
1397           // Outcome Message
1398           case MessageType.CALL_RESULT_MESSAGE:
1399             [, , commandPayload] = request as Response;
1400             if (!this.requests.has(messageId)) {
1401               // Error
1402               throw new OCPPError(
1403                 ErrorType.INTERNAL_ERROR,
1404                 `Response for unknown message id ${messageId}`,
1405                 null,
1406                 commandPayload
1407               );
1408             }
1409             // Respond
1410             cachedRequest = this.requests.get(messageId);
1411             if (Utils.isIterable(cachedRequest)) {
1412               [responseCallback, , requestCommandName, requestPayload] = cachedRequest;
1413             } else {
1414               throw new OCPPError(
1415                 ErrorType.PROTOCOL_ERROR,
1416                 `Cached request for message id ${messageId} response is not iterable`,
1417                 null,
1418                 cachedRequest as unknown as JsonType
1419               );
1420             }
1421             logger.debug(
1422               `${this.logPrefix()} << Command '${
1423                 requestCommandName ?? ''
1424               }' received response payload: ${JSON.stringify(request)}`
1425             );
1426             responseCallback(commandPayload, requestPayload);
1427             break;
1428           // Error Message
1429           case MessageType.CALL_ERROR_MESSAGE:
1430             [, , errorType, errorMessage, errorDetails] = request as ErrorResponse;
1431             if (!this.requests.has(messageId)) {
1432               // Error
1433               throw new OCPPError(
1434                 ErrorType.INTERNAL_ERROR,
1435                 `Error response for unknown message id ${messageId}`,
1436                 null,
1437                 { errorType, errorMessage, errorDetails }
1438               );
1439             }
1440             cachedRequest = this.requests.get(messageId);
1441             if (Utils.isIterable(cachedRequest)) {
1442               [, errorCallback, requestCommandName] = cachedRequest;
1443             } else {
1444               throw new OCPPError(
1445                 ErrorType.PROTOCOL_ERROR,
1446                 `Cached request for message id ${messageId} error response is not iterable`,
1447                 null,
1448                 cachedRequest as unknown as JsonType
1449               );
1450             }
1451             logger.debug(
1452               `${this.logPrefix()} << Command '${
1453                 requestCommandName ?? ''
1454               }' received error payload: ${JSON.stringify(request)}`
1455             );
1456             errorCallback(new OCPPError(errorType, errorMessage, requestCommandName, errorDetails));
1457             break;
1458           // Error
1459           default:
1460             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
1461             errMsg = `${this.logPrefix()} Wrong message type ${messageType}`;
1462             logger.error(errMsg);
1463             throw new OCPPError(ErrorType.PROTOCOL_ERROR, errMsg);
1464         }
1465       } else {
1466         throw new OCPPError(ErrorType.PROTOCOL_ERROR, 'Incoming message is not iterable', null, {
1467           payload: request,
1468         });
1469       }
1470     } catch (error) {
1471       // Log
1472       logger.error(
1473         '%s Incoming OCPP message %j matching cached request %j processing error %j',
1474         this.logPrefix(),
1475         data.toString(),
1476         this.requests.get(messageId),
1477         error
1478       );
1479       // Send error
1480       messageType === MessageType.CALL_MESSAGE &&
1481         (await this.ocppRequestService.sendError(
1482           this,
1483           messageId,
1484           error as OCPPError,
1485           commandName ?? requestCommandName ?? null
1486         ));
1487     }
1488   }
1489
1490   private onPing(): void {
1491     logger.debug(this.logPrefix() + ' Received a WS ping (rfc6455) from the server');
1492   }
1493
1494   private onPong(): void {
1495     logger.debug(this.logPrefix() + ' Received a WS pong (rfc6455) from the server');
1496   }
1497
1498   private onError(error: WSError): void {
1499     logger.error(this.logPrefix() + ' WebSocket error: %j', error);
1500   }
1501
1502   private getUseConnectorId0(stationInfo?: ChargingStationInfo): boolean | undefined {
1503     const localStationInfo = stationInfo ?? this.stationInfo;
1504     return !Utils.isUndefined(localStationInfo.useConnectorId0)
1505       ? localStationInfo.useConnectorId0
1506       : true;
1507   }
1508
1509   private getNumberOfRunningTransactions(): number {
1510     let trxCount = 0;
1511     for (const connectorId of this.connectors.keys()) {
1512       if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
1513         trxCount++;
1514       }
1515     }
1516     return trxCount;
1517   }
1518
1519   // 0 for disabling
1520   private getConnectionTimeout(): number | undefined {
1521     if (
1522       ChargingStationConfigurationUtils.getConfigurationKey(
1523         this,
1524         StandardParametersKey.ConnectionTimeOut
1525       )
1526     ) {
1527       return (
1528         parseInt(
1529           ChargingStationConfigurationUtils.getConfigurationKey(
1530             this,
1531             StandardParametersKey.ConnectionTimeOut
1532           ).value
1533         ) ?? Constants.DEFAULT_CONNECTION_TIMEOUT
1534       );
1535     }
1536     return Constants.DEFAULT_CONNECTION_TIMEOUT;
1537   }
1538
1539   // -1 for unlimited, 0 for disabling
1540   private getAutoReconnectMaxRetries(): number | undefined {
1541     if (!Utils.isUndefined(this.stationInfo.autoReconnectMaxRetries)) {
1542       return this.stationInfo.autoReconnectMaxRetries;
1543     }
1544     if (!Utils.isUndefined(Configuration.getAutoReconnectMaxRetries())) {
1545       return Configuration.getAutoReconnectMaxRetries();
1546     }
1547     return -1;
1548   }
1549
1550   // 0 for disabling
1551   private getRegistrationMaxRetries(): number | undefined {
1552     if (!Utils.isUndefined(this.stationInfo.registrationMaxRetries)) {
1553       return this.stationInfo.registrationMaxRetries;
1554     }
1555     return -1;
1556   }
1557
1558   private getPowerDivider(): number {
1559     let powerDivider = this.getNumberOfConnectors();
1560     if (this.stationInfo?.powerSharedByConnectors) {
1561       powerDivider = this.getNumberOfRunningTransactions();
1562     }
1563     return powerDivider;
1564   }
1565
1566   private getMaximumPower(stationInfo?: ChargingStationInfo): number {
1567     const localStationInfo = stationInfo ?? this.stationInfo;
1568     return (localStationInfo['maxPower'] as number) ?? localStationInfo.maximumPower;
1569   }
1570
1571   private getMaximumAmperage(stationInfo: ChargingStationInfo): number | undefined {
1572     const maximumPower = this.getMaximumPower(stationInfo);
1573     switch (this.getCurrentOutType(stationInfo)) {
1574       case CurrentType.AC:
1575         return ACElectricUtils.amperagePerPhaseFromPower(
1576           this.getNumberOfPhases(stationInfo),
1577           maximumPower / this.getNumberOfConnectors(),
1578           this.getVoltageOut(stationInfo)
1579         );
1580       case CurrentType.DC:
1581         return DCElectricUtils.amperage(maximumPower, this.getVoltageOut(stationInfo));
1582     }
1583   }
1584
1585   private getAmperageLimitation(): number | undefined {
1586     if (
1587       this.stationInfo.amperageLimitationOcppKey &&
1588       ChargingStationConfigurationUtils.getConfigurationKey(
1589         this,
1590         this.stationInfo.amperageLimitationOcppKey
1591       )
1592     ) {
1593       return (
1594         Utils.convertToInt(
1595           ChargingStationConfigurationUtils.getConfigurationKey(
1596             this,
1597             this.stationInfo.amperageLimitationOcppKey
1598           ).value
1599         ) / ChargingStationUtils.getAmperageLimitationUnitDivider(this.stationInfo)
1600       );
1601     }
1602   }
1603
1604   private async startMessageSequence(): Promise<void> {
1605     if (this.stationInfo?.autoRegister) {
1606       await this.ocppRequestService.requestHandler<
1607         BootNotificationRequest,
1608         BootNotificationResponse
1609       >(
1610         this,
1611         RequestCommand.BOOT_NOTIFICATION,
1612         {
1613           chargePointModel: this.bootNotificationRequest.chargePointModel,
1614           chargePointVendor: this.bootNotificationRequest.chargePointVendor,
1615           chargeBoxSerialNumber: this.bootNotificationRequest.chargeBoxSerialNumber,
1616           firmwareVersion: this.bootNotificationRequest.firmwareVersion,
1617           chargePointSerialNumber: this.bootNotificationRequest.chargePointSerialNumber,
1618           iccid: this.bootNotificationRequest.iccid,
1619           imsi: this.bootNotificationRequest.imsi,
1620           meterSerialNumber: this.bootNotificationRequest.meterSerialNumber,
1621           meterType: this.bootNotificationRequest.meterType,
1622         },
1623         { skipBufferingOnError: true }
1624       );
1625     }
1626     // Start WebSocket ping
1627     this.startWebSocketPing();
1628     // Start heartbeat
1629     this.startHeartbeat();
1630     // Initialize connectors status
1631     for (const connectorId of this.connectors.keys()) {
1632       if (connectorId === 0) {
1633         continue;
1634       } else if (
1635         !this.stopped &&
1636         !this.getConnectorStatus(connectorId)?.status &&
1637         this.getConnectorStatus(connectorId)?.bootStatus
1638       ) {
1639         // Send status in template at startup
1640         await this.ocppRequestService.requestHandler<
1641           StatusNotificationRequest,
1642           StatusNotificationResponse
1643         >(this, RequestCommand.STATUS_NOTIFICATION, {
1644           connectorId,
1645           status: this.getConnectorStatus(connectorId).bootStatus,
1646           errorCode: ChargePointErrorCode.NO_ERROR,
1647         });
1648         this.getConnectorStatus(connectorId).status =
1649           this.getConnectorStatus(connectorId).bootStatus;
1650       } else if (
1651         this.stopped &&
1652         this.getConnectorStatus(connectorId)?.status &&
1653         this.getConnectorStatus(connectorId)?.bootStatus
1654       ) {
1655         // Send status in template after reset
1656         await this.ocppRequestService.requestHandler<
1657           StatusNotificationRequest,
1658           StatusNotificationResponse
1659         >(this, RequestCommand.STATUS_NOTIFICATION, {
1660           connectorId,
1661           status: this.getConnectorStatus(connectorId).bootStatus,
1662           errorCode: ChargePointErrorCode.NO_ERROR,
1663         });
1664         this.getConnectorStatus(connectorId).status =
1665           this.getConnectorStatus(connectorId).bootStatus;
1666       } else if (!this.stopped && this.getConnectorStatus(connectorId)?.status) {
1667         // Send previous status at template reload
1668         await this.ocppRequestService.requestHandler<
1669           StatusNotificationRequest,
1670           StatusNotificationResponse
1671         >(this, RequestCommand.STATUS_NOTIFICATION, {
1672           connectorId,
1673           status: this.getConnectorStatus(connectorId).status,
1674           errorCode: ChargePointErrorCode.NO_ERROR,
1675         });
1676       } else {
1677         // Send default status
1678         await this.ocppRequestService.requestHandler<
1679           StatusNotificationRequest,
1680           StatusNotificationResponse
1681         >(this, RequestCommand.STATUS_NOTIFICATION, {
1682           connectorId,
1683           status: ChargePointStatus.AVAILABLE,
1684           errorCode: ChargePointErrorCode.NO_ERROR,
1685         });
1686         this.getConnectorStatus(connectorId).status = ChargePointStatus.AVAILABLE;
1687       }
1688     }
1689     // Start the ATG
1690     this.startAutomaticTransactionGenerator();
1691   }
1692
1693   private startAutomaticTransactionGenerator() {
1694     if (this.getAutomaticTransactionGeneratorConfigurationFromTemplate()?.enable) {
1695       if (!this.automaticTransactionGenerator) {
1696         this.automaticTransactionGenerator = AutomaticTransactionGenerator.getInstance(
1697           this.getAutomaticTransactionGeneratorConfigurationFromTemplate(),
1698           this
1699         );
1700       }
1701       if (!this.automaticTransactionGenerator.started) {
1702         this.automaticTransactionGenerator.start();
1703       }
1704     }
1705   }
1706
1707   private stopAutomaticTransactionGenerator(): void {
1708     if (this.automaticTransactionGenerator?.started) {
1709       this.automaticTransactionGenerator.stop();
1710       this.automaticTransactionGenerator = null;
1711     }
1712   }
1713
1714   private async stopMessageSequence(
1715     reason: StopTransactionReason = StopTransactionReason.NONE
1716   ): Promise<void> {
1717     // Stop WebSocket ping
1718     this.stopWebSocketPing();
1719     // Stop heartbeat
1720     this.stopHeartbeat();
1721     // Stop ongoing transactions
1722     if (this.automaticTransactionGenerator?.configuration?.enable) {
1723       this.stopAutomaticTransactionGenerator();
1724     } else {
1725       for (const connectorId of this.connectors.keys()) {
1726         if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
1727           const transactionId = this.getConnectorStatus(connectorId).transactionId;
1728           if (
1729             this.getBeginEndMeterValues() &&
1730             this.getOcppStrictCompliance() &&
1731             !this.getOutOfOrderEndMeterValues()
1732           ) {
1733             // FIXME: Implement OCPP version agnostic helpers
1734             const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(
1735               this,
1736               connectorId,
1737               this.getEnergyActiveImportRegisterByTransactionId(transactionId)
1738             );
1739             await this.ocppRequestService.requestHandler<MeterValuesRequest, MeterValuesResponse>(
1740               this,
1741               RequestCommand.METER_VALUES,
1742               {
1743                 connectorId,
1744                 transactionId,
1745                 meterValue: transactionEndMeterValue,
1746               }
1747             );
1748           }
1749           await this.ocppRequestService.requestHandler<
1750             StopTransactionRequest,
1751             StopTransactionResponse
1752           >(this, RequestCommand.STOP_TRANSACTION, {
1753             transactionId,
1754             meterStop: this.getEnergyActiveImportRegisterByTransactionId(transactionId),
1755             idTag: this.getTransactionIdTag(transactionId),
1756             reason,
1757           });
1758         }
1759       }
1760     }
1761   }
1762
1763   private startWebSocketPing(): void {
1764     const webSocketPingInterval: number = ChargingStationConfigurationUtils.getConfigurationKey(
1765       this,
1766       StandardParametersKey.WebSocketPingInterval
1767     )
1768       ? Utils.convertToInt(
1769           ChargingStationConfigurationUtils.getConfigurationKey(
1770             this,
1771             StandardParametersKey.WebSocketPingInterval
1772           ).value
1773         )
1774       : 0;
1775     if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
1776       this.webSocketPingSetInterval = setInterval(() => {
1777         if (this.isWebSocketConnectionOpened()) {
1778           this.wsConnection.ping((): void => {
1779             /* This is intentional */
1780           });
1781         }
1782       }, webSocketPingInterval * 1000);
1783       logger.info(
1784         this.logPrefix() +
1785           ' WebSocket ping started every ' +
1786           Utils.formatDurationSeconds(webSocketPingInterval)
1787       );
1788     } else if (this.webSocketPingSetInterval) {
1789       logger.info(
1790         this.logPrefix() +
1791           ' WebSocket ping every ' +
1792           Utils.formatDurationSeconds(webSocketPingInterval) +
1793           ' already started'
1794       );
1795     } else {
1796       logger.error(
1797         `${this.logPrefix()} WebSocket ping interval set to ${
1798           webSocketPingInterval
1799             ? Utils.formatDurationSeconds(webSocketPingInterval)
1800             : webSocketPingInterval
1801         }, not starting the WebSocket ping`
1802       );
1803     }
1804   }
1805
1806   private stopWebSocketPing(): void {
1807     if (this.webSocketPingSetInterval) {
1808       clearInterval(this.webSocketPingSetInterval);
1809     }
1810   }
1811
1812   private getConfiguredSupervisionUrl(): URL {
1813     const supervisionUrls = Utils.cloneObject<string | string[]>(
1814       this.stationInfo.supervisionUrls ?? Configuration.getSupervisionUrls()
1815     );
1816     if (!Utils.isEmptyArray(supervisionUrls)) {
1817       let urlIndex = 0;
1818       switch (Configuration.getSupervisionUrlDistribution()) {
1819         case SupervisionUrlDistribution.ROUND_ROBIN:
1820           urlIndex = (this.index - 1) % supervisionUrls.length;
1821           break;
1822         case SupervisionUrlDistribution.RANDOM:
1823           // Get a random url
1824           urlIndex = Math.floor(Utils.secureRandom() * supervisionUrls.length);
1825           break;
1826         case SupervisionUrlDistribution.SEQUENTIAL:
1827           if (this.index <= supervisionUrls.length) {
1828             urlIndex = this.index - 1;
1829           } else {
1830             logger.warn(
1831               `${this.logPrefix()} No more configured supervision urls available, using the first one`
1832             );
1833           }
1834           break;
1835         default:
1836           logger.error(
1837             `${this.logPrefix()} Unknown supervision url distribution '${Configuration.getSupervisionUrlDistribution()}' from values '${SupervisionUrlDistribution.toString()}', defaulting to ${
1838               SupervisionUrlDistribution.ROUND_ROBIN
1839             }`
1840           );
1841           urlIndex = (this.index - 1) % supervisionUrls.length;
1842           break;
1843       }
1844       return new URL(supervisionUrls[urlIndex]);
1845     }
1846     return new URL(supervisionUrls as string);
1847   }
1848
1849   private getHeartbeatInterval(): number | undefined {
1850     const HeartbeatInterval = ChargingStationConfigurationUtils.getConfigurationKey(
1851       this,
1852       StandardParametersKey.HeartbeatInterval
1853     );
1854     if (HeartbeatInterval) {
1855       return Utils.convertToInt(HeartbeatInterval.value) * 1000;
1856     }
1857     const HeartBeatInterval = ChargingStationConfigurationUtils.getConfigurationKey(
1858       this,
1859       StandardParametersKey.HeartBeatInterval
1860     );
1861     if (HeartBeatInterval) {
1862       return Utils.convertToInt(HeartBeatInterval.value) * 1000;
1863     }
1864     !this.stationInfo?.autoRegister &&
1865       logger.warn(
1866         `${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${
1867           Constants.DEFAULT_HEARTBEAT_INTERVAL
1868         }`
1869       );
1870     return Constants.DEFAULT_HEARTBEAT_INTERVAL;
1871   }
1872
1873   private stopHeartbeat(): void {
1874     if (this.heartbeatSetInterval) {
1875       clearInterval(this.heartbeatSetInterval);
1876     }
1877   }
1878
1879   private openWSConnection(
1880     options: WsOptions = this.stationInfo?.wsOptions ?? {},
1881     params: { closeOpened?: boolean; terminateOpened?: boolean } = {
1882       closeOpened: false,
1883       terminateOpened: false,
1884     }
1885   ): void {
1886     options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
1887     params.closeOpened = params?.closeOpened ?? false;
1888     params.terminateOpened = params?.terminateOpened ?? false;
1889     if (
1890       !Utils.isNullOrUndefined(this.stationInfo.supervisionUser) &&
1891       !Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)
1892     ) {
1893       options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`;
1894     }
1895     if (params?.closeOpened) {
1896       this.closeWSConnection();
1897     }
1898     if (params?.terminateOpened) {
1899       this.terminateWSConnection();
1900     }
1901     let protocol: string;
1902     switch (this.getOcppVersion()) {
1903       case OCPPVersion.VERSION_16:
1904         protocol = 'ocpp' + OCPPVersion.VERSION_16;
1905         break;
1906       default:
1907         this.handleUnsupportedVersion(this.getOcppVersion());
1908         break;
1909     }
1910     this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
1911     logger.info(
1912       this.logPrefix() + ' Open OCPP connection to URL ' + this.wsConnectionUrl.toString()
1913     );
1914   }
1915
1916   private closeWSConnection(): void {
1917     if (this.isWebSocketConnectionOpened()) {
1918       this.wsConnection.close();
1919       this.wsConnection = null;
1920     }
1921   }
1922
1923   private terminateWSConnection(): void {
1924     if (this.isWebSocketConnectionOpened()) {
1925       this.wsConnection.terminate();
1926       this.wsConnection = null;
1927     }
1928   }
1929
1930   private stopMeterValues(connectorId: number) {
1931     if (this.getConnectorStatus(connectorId)?.transactionSetInterval) {
1932       clearInterval(this.getConnectorStatus(connectorId).transactionSetInterval);
1933     }
1934   }
1935
1936   private getReconnectExponentialDelay(): boolean | undefined {
1937     return !Utils.isUndefined(this.stationInfo.reconnectExponentialDelay)
1938       ? this.stationInfo.reconnectExponentialDelay
1939       : false;
1940   }
1941
1942   private async reconnect(code: number): Promise<void> {
1943     // Stop WebSocket ping
1944     this.stopWebSocketPing();
1945     // Stop heartbeat
1946     this.stopHeartbeat();
1947     // Stop the ATG if needed
1948     if (this.automaticTransactionGenerator?.configuration?.stopOnConnectionFailure) {
1949       this.stopAutomaticTransactionGenerator();
1950     }
1951     if (
1952       this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() ||
1953       this.getAutoReconnectMaxRetries() === -1
1954     ) {
1955       this.autoReconnectRetryCount++;
1956       const reconnectDelay = this.getReconnectExponentialDelay()
1957         ? Utils.exponentialDelay(this.autoReconnectRetryCount)
1958         : this.getConnectionTimeout() * 1000;
1959       const reconnectDelayWithdraw = 1000;
1960       const reconnectTimeout =
1961         reconnectDelay && reconnectDelay - reconnectDelayWithdraw > 0
1962           ? reconnectDelay - reconnectDelayWithdraw
1963           : 0;
1964       logger.error(
1965         `${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(
1966           reconnectDelay,
1967           2
1968         )}ms, timeout ${reconnectTimeout}ms`
1969       );
1970       await Utils.sleep(reconnectDelay);
1971       logger.error(
1972         this.logPrefix() +
1973           ' WebSocket: reconnecting try #' +
1974           this.autoReconnectRetryCount.toString()
1975       );
1976       this.openWSConnection(
1977         { ...(this.stationInfo?.wsOptions ?? {}), handshakeTimeout: reconnectTimeout },
1978         { closeOpened: true }
1979       );
1980       this.wsConnectionRestarted = true;
1981     } else if (this.getAutoReconnectMaxRetries() !== -1) {
1982       logger.error(
1983         `${this.logPrefix()} WebSocket reconnect failure: maximum retries reached (${
1984           this.autoReconnectRetryCount
1985         }) or retry disabled (${this.getAutoReconnectMaxRetries()})`
1986       );
1987     }
1988   }
1989
1990   private getAutomaticTransactionGeneratorConfigurationFromTemplate(): AutomaticTransactionGeneratorConfiguration | null {
1991     return this.getTemplateFromFile()?.AutomaticTransactionGenerator ?? null;
1992   }
1993
1994   private initializeConnectorStatus(connectorId: number): void {
1995     this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
1996     this.getConnectorStatus(connectorId).idTagAuthorized = false;
1997     this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
1998     this.getConnectorStatus(connectorId).transactionStarted = false;
1999     this.getConnectorStatus(connectorId).energyActiveImportRegisterValue = 0;
2000     this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
2001   }
2002 }