src/charging-station/ChargingStation.ts

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