src/charging-station/ChargingStation.ts

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