src/charging-station/ChargingStation.ts

   1 import { AuthorizationStatus, StartTransactionRequest, StartTransactionResponse, StopTransactionReason, StopTransactionRequest, StopTransactionResponse } from '../types/ocpp/1.6/Transaction';
   2 import { BootNotificationResponse, ChangeConfigurationResponse, DefaultResponse, GetConfigurationResponse, HeartbeatResponse, RegistrationStatus, SetChargingProfileResponse, StatusNotificationResponse, UnlockConnectorResponse } from '../types/ocpp/1.6/RequestResponses';
   3 import { ChargingProfile, ChargingProfilePurposeType } from '../types/ocpp/1.6/ChargingProfile';
   4 import ChargingStationConfiguration, { ConfigurationKey } from '../types/ChargingStationConfiguration';
   5 import ChargingStationTemplate, { PowerOutType } from '../types/ChargingStationTemplate';
   6 import Connectors, { Connector } from '../types/Connectors';
   7 import { MeterValue, MeterValueLocation, MeterValueMeasurand, MeterValuePhase, MeterValueUnit, MeterValuesRequest, MeterValuesResponse, SampledValue } from '../types/ocpp/1.6/MeterValues';
   8 import { PerformanceObserver, performance } from 'perf_hooks';
   9 import Requests, { BootNotificationRequest, ChangeConfigurationRequest, GetConfigurationRequest, HeartbeatRequest, RemoteStartTransactionRequest, RemoteStopTransactionRequest, ResetRequest, SetChargingProfileRequest, StatusNotificationRequest, UnlockConnectorRequest } from '../types/ocpp/1.6/Requests';
  10 import WebSocket, { MessageEvent } from 'ws';
  11
  12 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
  13 import { ChargePointErrorCode } from '../types/ocpp/1.6/ChargePointErrorCode';
  14 import { ChargePointStatus } from '../types/ocpp/1.6/ChargePointStatus';
  15 import ChargingStationInfo from '../types/ChargingStationInfo';
  16 import Configuration from '../utils/Configuration';
  17 import Constants from '../utils/Constants';
  18 import ElectricUtils from '../utils/ElectricUtils';
  19 import { ErrorType } from '../types/ocpp/ErrorType';
  20 import MeasurandValues from '../types/MeasurandValues';
  21 import { MessageType } from '../types/ocpp/MessageType';
  22 import OCPPError from './OcppError';
  23 import Statistics from '../utils/Statistics';
  24 import Utils from '../utils/Utils';
  25 import { WebSocketCloseEventStatusCode } from '../types/WebSocket';
  26 import crypto from 'crypto';
  27 import fs from 'fs';
  28 import logger from '../utils/Logger';
  29
  30 export default class ChargingStation {
  31   private _index: number;
  32   private _stationTemplateFile: string;
  33   private _stationInfo: ChargingStationInfo;
  34   private _bootNotificationRequest: BootNotificationRequest;
  35   private _bootNotificationResponse: BootNotificationResponse;
  36   private _connectors: Connectors;
  37   private _configuration: ChargingStationConfiguration;
  38   private _connectorsConfigurationHash: string;
  39   private _supervisionUrl: string;
  40   private _wsConnectionUrl: string;
  41   private _wsConnection: WebSocket;
  42   private _hasStopped: boolean;
  43   private _hasSocketRestarted: boolean;
  44   private _autoReconnectRetryCount: number;
  45   private _requests: Requests;
  46   private _messageQueue: string[];
  47   private _automaticTransactionGeneration: AutomaticTransactionGenerator;
  48   private _authorizedTags: string[];
  49   private _heartbeatInterval: number;
  50   private _heartbeatSetInterval: NodeJS.Timeout;
  51   private _webSocketPingSetInterval: NodeJS.Timeout;
  52   private _statistics: Statistics;
  53   private _performanceObserver: PerformanceObserver;
  54
  55   constructor(index: number, stationTemplateFile: string) {
  56     this._index = index;
  57     this._stationTemplateFile = stationTemplateFile;
  58     this._connectors = {} as Connectors;
  59     this._initialize();
  60
  61     this._hasStopped = false;
  62     this._hasSocketRestarted = false;
  63     this._autoReconnectRetryCount = 0;
  64
  65     this._requests = {} as Requests;
  66     this._messageQueue = [] as string[];
  67
  68     this._authorizedTags = this._loadAndGetAuthorizedTags();
  69   }
  70
  71   _getStationName(stationTemplate: ChargingStationTemplate): string {
  72     return stationTemplate.fixedName ? stationTemplate.baseName : stationTemplate.baseName + '-' + ('000000000' + this._index.toString()).substr(('000000000' + this._index.toString()).length - 4);
  73   }
  74
  75   _buildStationInfo(): ChargingStationInfo {
  76     let stationTemplateFromFile: ChargingStationTemplate;
  77     try {
  78       // Load template file
  79       const fileDescriptor = fs.openSync(this._stationTemplateFile, 'r');
  80       stationTemplateFromFile = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as ChargingStationTemplate;
  81       fs.closeSync(fileDescriptor);
  82     } catch (error) {
  83       logger.error('Template file ' + this._stationTemplateFile + ' loading error: %j', error);
  84       throw error;
  85     }
  86     const stationInfo: ChargingStationInfo = stationTemplateFromFile || {} as ChargingStationInfo;
  87     if (!Utils.isEmptyArray(stationTemplateFromFile.power)) {
  88       stationTemplateFromFile.power = stationTemplateFromFile.power as number[];
  89       stationInfo.maxPower = stationTemplateFromFile.power[Math.floor(Math.random() * stationTemplateFromFile.power.length)];
  90     } else {
  91       stationInfo.maxPower = stationTemplateFromFile.power as number;
  92     }
  93     stationInfo.name = this._getStationName(stationTemplateFromFile);
  94     stationInfo.resetTime = stationTemplateFromFile.resetTime ? stationTemplateFromFile.resetTime * 1000 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
  95     return stationInfo;
  96   }
  97
  98   get stationInfo(): ChargingStationInfo {
  99     return this._stationInfo;
 100   }
 101
 102   _initialize(): void {
 103     this._stationInfo = this._buildStationInfo();
 104     this._bootNotificationRequest = {
 105       chargePointModel: this._stationInfo.chargePointModel,
 106       chargePointVendor: this._stationInfo.chargePointVendor,
 107       ...!Utils.isUndefined(this._stationInfo.chargeBoxSerialNumberPrefix) && { chargeBoxSerialNumber: this._stationInfo.chargeBoxSerialNumberPrefix },
 108       ...!Utils.isUndefined(this._stationInfo.firmwareVersion) && { firmwareVersion: this._stationInfo.firmwareVersion },
 109     };
 110     this._configuration = this._getTemplateChargingStationConfiguration();
 111     this._supervisionUrl = this._getSupervisionURL();
 112     this._wsConnectionUrl = this._supervisionUrl + '/' + this._stationInfo.name;
 113     // Build connectors if needed
 114     const maxConnectors = this._getMaxNumberOfConnectors();
 115     if (maxConnectors <= 0) {
 116       logger.warn(`${this._logPrefix()} Charging station template ${this._stationTemplateFile} with ${maxConnectors} connectors`);
 117     }
 118     const templateMaxConnectors = this._getTemplateMaxNumberOfConnectors();
 119     if (templateMaxConnectors <= 0) {
 120       logger.warn(`${this._logPrefix()} Charging station template ${this._stationTemplateFile} with no connector configuration`);
 121     }
 122     if (!this._stationInfo.Connectors[0]) {
 123       logger.warn(`${this._logPrefix()} Charging station template ${this._stationTemplateFile} with no connector Id 0 configuration`);
 124     }
 125     // Sanity check
 126     if (maxConnectors > (this._stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) && !this._stationInfo.randomConnectors) {
 127       logger.warn(`${this._logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this._stationTemplateFile}, forcing random connector configurations affectation`);
 128       this._stationInfo.randomConnectors = true;
 129     }
 130     const connectorsConfigHash = crypto.createHash('sha256').update(JSON.stringify(this._stationInfo.Connectors) + maxConnectors.toString()).digest('hex');
 131     // FIXME: Handle shrinking the number of connectors
 132     if (!this._connectors || (this._connectors && this._connectorsConfigurationHash !== connectorsConfigHash)) {
 133       this._connectorsConfigurationHash = connectorsConfigHash;
 134       // Add connector Id 0
 135       let lastConnector = '0';
 136       for (lastConnector in this._stationInfo.Connectors) {
 137         if (Utils.convertToInt(lastConnector) === 0 && this._getUseConnectorId0() && this._stationInfo.Connectors[lastConnector]) {
 138           this._connectors[lastConnector] = Utils.cloneObject<Connector>(this._stationInfo.Connectors[lastConnector]);
 139         }
 140       }
 141       // Generate all connectors
 142       if ((this._stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
 143         for (let index = 1; index <= maxConnectors; index++) {
 144           const randConnectorID = this._stationInfo.randomConnectors ? Utils.getRandomInt(Utils.convertToInt(lastConnector), 1) : index;
 145           this._connectors[index] = Utils.cloneObject<Connector>(this._stationInfo.Connectors[randConnectorID]);
 146         }
 147       }
 148     }
 149     // Avoid duplication of connectors related information
 150     delete this._stationInfo.Connectors;
 151     // Initialize transaction attributes on connectors
 152     for (const connector in this._connectors) {
 153       if (Utils.convertToInt(connector) > 0 && !this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
 154         this._initTransactionOnConnector(Utils.convertToInt(connector));
 155       }
 156     }
 157     // OCPP parameters
 158     this._addConfigurationKey('NumberOfConnectors', this._getNumberOfConnectors().toString(), true);
 159     if (!this._getConfigurationKey('MeterValuesSampledData')) {
 160       this._addConfigurationKey('MeterValuesSampledData', MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER);
 161     }
 162     this._stationInfo.powerDivider = this._getPowerDivider();
 163     if (this.getEnableStatistics()) {
 164       this._statistics = Statistics.getInstance();
 165       this._statistics.objName = this._stationInfo.name;
 166       this._performanceObserver = new PerformanceObserver((list) => {
 167         const entry = list.getEntries()[0];
 168         this._statistics.logPerformance(entry, Constants.ENTITY_CHARGING_STATION);
 169         this._performanceObserver.disconnect();
 170       });
 171     }
 172   }
 173
 174   get connectors(): Connectors {
 175     return this._connectors;
 176   }
 177
 178   get statistics(): Statistics {
 179     return this._statistics;
 180   }
 181
 182   _logPrefix(): string {
 183     return Utils.logPrefix(` ${this._stationInfo.name}:`);
 184   }
 185
 186   _isWebSocketOpen(): boolean {
 187     return this._wsConnection?.readyState === WebSocket.OPEN;
 188   }
 189
 190   _isRegistered(): boolean {
 191     return this._bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
 192   }
 193
 194   _getTemplateChargingStationConfiguration(): ChargingStationConfiguration {
 195     return this._stationInfo.Configuration ? this._stationInfo.Configuration : {} as ChargingStationConfiguration;
 196   }
 197
 198   _getAuthorizationFile(): string {
 199     return this._stationInfo.authorizationFile && this._stationInfo.authorizationFile;
 200   }
 201
 202   _getUseConnectorId0(): boolean {
 203     return !Utils.isUndefined(this._stationInfo.useConnectorId0) ? this._stationInfo.useConnectorId0 : true;
 204   }
 205
 206   _loadAndGetAuthorizedTags(): string[] {
 207     let authorizedTags: string[] = [];
 208     const authorizationFile = this._getAuthorizationFile();
 209     if (authorizationFile) {
 210       try {
 211         // Load authorization file
 212         const fileDescriptor = fs.openSync(authorizationFile, 'r');
 213         authorizedTags = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as string[];
 214         fs.closeSync(fileDescriptor);
 215       } catch (error) {
 216         logger.error(this._logPrefix() + ' Authorization file ' + authorizationFile + ' loading error: %j', error);
 217         throw error;
 218       }
 219     } else {
 220       logger.info(this._logPrefix() + ' No authorization file given in template file ' + this._stationTemplateFile);
 221     }
 222     return authorizedTags;
 223   }
 224
 225   getRandomTagId(): string {
 226     const index = Math.floor(Math.random() * this._authorizedTags.length);
 227     return this._authorizedTags[index];
 228   }
 229
 230   hasAuthorizedTags(): boolean {
 231     return !Utils.isEmptyArray(this._authorizedTags);
 232   }
 233
 234   getEnableStatistics(): boolean {
 235     return !Utils.isUndefined(this._stationInfo.enableStatistics) ? this._stationInfo.enableStatistics : true;
 236   }
 237
 238   _getNumberOfPhases(): number {
 239     switch (this._getPowerOutType()) {
 240       case PowerOutType.AC:
 241         return !Utils.isUndefined(this._stationInfo.numberOfPhases) ? this._stationInfo.numberOfPhases : 3;
 242       case PowerOutType.DC:
 243         return 0;
 244     }
 245   }
 246
 247   _getNumberOfRunningTransactions(): number {
 248     let trxCount = 0;
 249     for (const connector in this._connectors) {
 250       if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
 251         trxCount++;
 252       }
 253     }
 254     return trxCount;
 255   }
 256
 257   // 0 for disabling
 258   _getConnectionTimeout(): number {
 259     if (!Utils.isUndefined(this._stationInfo.connectionTimeout)) {
 260       return this._stationInfo.connectionTimeout;
 261     }
 262     if (!Utils.isUndefined(Configuration.getConnectionTimeout())) {
 263       return Configuration.getConnectionTimeout();
 264     }
 265     return 30;
 266   }
 267
 268   // -1 for unlimited, 0 for disabling
 269   _getAutoReconnectMaxRetries(): number {
 270     if (!Utils.isUndefined(this._stationInfo.autoReconnectMaxRetries)) {
 271       return this._stationInfo.autoReconnectMaxRetries;
 272     }
 273     if (!Utils.isUndefined(Configuration.getAutoReconnectMaxRetries())) {
 274       return Configuration.getAutoReconnectMaxRetries();
 275     }
 276     return -1;
 277   }
 278
 279   // 0 for disabling
 280   _getRegistrationMaxRetries(): number {
 281     if (!Utils.isUndefined(this._stationInfo.registrationMaxRetries)) {
 282       return this._stationInfo.registrationMaxRetries;
 283     }
 284     return -1;
 285   }
 286
 287   _getPowerDivider(): number {
 288     let powerDivider = this._getNumberOfConnectors();
 289     if (this._stationInfo.powerSharedByConnectors) {
 290       powerDivider = this._getNumberOfRunningTransactions();
 291     }
 292     return powerDivider;
 293   }
 294
 295   getConnector(id: number): Connector {
 296     return this._connectors[id];
 297   }
 298
 299   _getTemplateMaxNumberOfConnectors(): number {
 300     return Object.keys(this._stationInfo.Connectors).length;
 301   }
 302
 303   _getMaxNumberOfConnectors(): number {
 304     let maxConnectors = 0;
 305     if (!Utils.isEmptyArray(this._stationInfo.numberOfConnectors)) {
 306       const numberOfConnectors = this._stationInfo.numberOfConnectors as number[];
 307       // Distribute evenly the number of connectors
 308       maxConnectors = numberOfConnectors[(this._index - 1) % numberOfConnectors.length];
 309     } else if (!Utils.isUndefined(this._stationInfo.numberOfConnectors)) {
 310       maxConnectors = this._stationInfo.numberOfConnectors as number;
 311     } else {
 312       maxConnectors = this._stationInfo.Connectors[0] ? this._getTemplateMaxNumberOfConnectors() - 1 : this._getTemplateMaxNumberOfConnectors();
 313     }
 314     return maxConnectors;
 315   }
 316
 317   _getNumberOfConnectors(): number {
 318     return this._connectors[0] ? Object.keys(this._connectors).length - 1 : Object.keys(this._connectors).length;
 319   }
 320
 321   _getVoltageOut(): number {
 322     const errMsg = `${this._logPrefix()} Unknown ${this._getPowerOutType()} powerOutType in template file ${this._stationTemplateFile}, cannot define default voltage out`;
 323     let defaultVoltageOut: number;
 324     switch (this._getPowerOutType()) {
 325       case PowerOutType.AC:
 326         defaultVoltageOut = 230;
 327         break;
 328       case PowerOutType.DC:
 329         defaultVoltageOut = 400;
 330         break;
 331       default:
 332         logger.error(errMsg);
 333         throw Error(errMsg);
 334     }
 335     return !Utils.isUndefined(this._stationInfo.voltageOut) ? this._stationInfo.voltageOut : defaultVoltageOut;
 336   }
 337
 338   _getTransactionIdTag(transactionId: number): string {
 339     for (const connector in this._connectors) {
 340       if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
 341         return this.getConnector(Utils.convertToInt(connector)).idTag;
 342       }
 343     }
 344   }
 345
 346   _getTransactionMeterStop(transactionId: number): number {
 347     for (const connector in this._connectors) {
 348       if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
 349         return this.getConnector(Utils.convertToInt(connector)).lastEnergyActiveImportRegisterValue;
 350       }
 351     }
 352   }
 353
 354   _getPowerOutType(): PowerOutType {
 355     return !Utils.isUndefined(this._stationInfo.powerOutType) ? this._stationInfo.powerOutType : PowerOutType.AC;
 356   }
 357
 358   _getSupervisionURL(): string {
 359     const supervisionUrls = Utils.cloneObject<string | string[]>(this._stationInfo.supervisionURL ? this._stationInfo.supervisionURL : Configuration.getSupervisionURLs());
 360     let indexUrl = 0;
 361     if (!Utils.isEmptyArray(supervisionUrls)) {
 362       if (Configuration.getDistributeStationsToTenantsEqually()) {
 363         indexUrl = this._index % supervisionUrls.length;
 364       } else {
 365         // Get a random url
 366         indexUrl = Math.floor(Math.random() * supervisionUrls.length);
 367       }
 368       return supervisionUrls[indexUrl];
 369     }
 370     return supervisionUrls as string;
 371   }
 372
 373   _getReconnectExponentialDelay(): boolean {
 374     return !Utils.isUndefined(this._stationInfo.reconnectExponentialDelay) ? this._stationInfo.reconnectExponentialDelay : false;
 375   }
 376
 377   _getAuthorizeRemoteTxRequests(): boolean {
 378     const authorizeRemoteTxRequests = this._getConfigurationKey('AuthorizeRemoteTxRequests');
 379     return authorizeRemoteTxRequests ? Utils.convertToBoolean(authorizeRemoteTxRequests.value) : false;
 380   }
 381
 382   _getLocalAuthListEnabled(): boolean {
 383     const localAuthListEnabled = this._getConfigurationKey('LocalAuthListEnabled');
 384     return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
 385   }
 386
 387   async _startMessageSequence(): Promise<void> {
 388     // Start WebSocket ping
 389     this._startWebSocketPing();
 390     // Start heartbeat
 391     this._startHeartbeat();
 392     // Initialize connectors status
 393     for (const connector in this._connectors) {
 394       if (Utils.convertToInt(connector) === 0) {
 395         continue;
 396       } else if (!this._hasStopped && !this.getConnector(Utils.convertToInt(connector)).status && this.getConnector(Utils.convertToInt(connector)).bootStatus) {
 397         // Send status in template at startup
 398         await this.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
 399       } else if (this._hasStopped && this.getConnector(Utils.convertToInt(connector)).bootStatus) {
 400         // Send status in template after reset
 401         await this.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
 402       } else if (!this._hasStopped && this.getConnector(Utils.convertToInt(connector)).status) {
 403         // Send previous status at template reload
 404         await this.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).status);
 405       } else {
 406         // Send default status
 407         await this.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.AVAILABLE);
 408       }
 409     }
 410     // Start the ATG
 411     if (this._stationInfo.AutomaticTransactionGenerator.enable) {
 412       if (!this._automaticTransactionGeneration) {
 413         this._automaticTransactionGeneration = new AutomaticTransactionGenerator(this);
 414       }
 415       if (this._automaticTransactionGeneration.timeToStop) {
 416         this._automaticTransactionGeneration.start();
 417       }
 418     }
 419     if (this.getEnableStatistics()) {
 420       this._statistics.start();
 421     }
 422   }
 423
 424   async _stopMessageSequence(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
 425     // Stop WebSocket ping
 426     this._stopWebSocketPing();
 427     // Stop heartbeat
 428     this._stopHeartbeat();
 429     // Stop the ATG
 430     if (this._stationInfo.AutomaticTransactionGenerator.enable &&
 431       this._automaticTransactionGeneration &&
 432       !this._automaticTransactionGeneration.timeToStop) {
 433       await this._automaticTransactionGeneration.stop(reason);
 434     } else {
 435       for (const connector in this._connectors) {
 436         if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
 437           await this.sendStopTransaction(this.getConnector(Utils.convertToInt(connector)).transactionId, reason);
 438         }
 439       }
 440     }
 441   }
 442
 443   _startWebSocketPing(): void {
 444     const webSocketPingInterval: number = this._getConfigurationKey('WebSocketPingInterval') ? Utils.convertToInt(this._getConfigurationKey('WebSocketPingInterval').value) : 0;
 445     if (webSocketPingInterval > 0 && !this._webSocketPingSetInterval) {
 446       this._webSocketPingSetInterval = setInterval(() => {
 447         if (this._isWebSocketOpen()) {
 448           this._wsConnection.ping((): void => { });
 449         }
 450       }, webSocketPingInterval * 1000);
 451       logger.info(this._logPrefix() + ' WebSocket ping started every ' + Utils.secondsToHHMMSS(webSocketPingInterval));
 452     } else if (this._webSocketPingSetInterval) {
 453       logger.info(this._logPrefix() + ' WebSocket ping every ' + Utils.secondsToHHMMSS(webSocketPingInterval) + ' already started');
 454     } else {
 455       logger.error(`${this._logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.secondsToHHMMSS(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
 456     }
 457   }
 458
 459   _stopWebSocketPing(): void {
 460     if (this._webSocketPingSetInterval) {
 461       clearInterval(this._webSocketPingSetInterval);
 462       this._webSocketPingSetInterval = null;
 463     }
 464   }
 465
 466   _restartWebSocketPing(): void {
 467     // Stop WebSocket ping
 468     this._stopWebSocketPing();
 469     // Start WebSocket ping
 470     this._startWebSocketPing();
 471   }
 472
 473   _startHeartbeat(): void {
 474     if (this._heartbeatInterval && this._heartbeatInterval > 0 && !this._heartbeatSetInterval) {
 475       this._heartbeatSetInterval = setInterval(async () => {
 476         await this.sendHeartbeat();
 477       }, this._heartbeatInterval);
 478       logger.info(this._logPrefix() + ' Heartbeat started every ' + Utils.milliSecondsToHHMMSS(this._heartbeatInterval));
 479     } else if (this._heartbeatSetInterval) {
 480       logger.info(this._logPrefix() + ' Heartbeat every ' + Utils.milliSecondsToHHMMSS(this._heartbeatInterval) + ' already started');
 481     } else {
 482       logger.error(`${this._logPrefix()} Heartbeat interval set to ${this._heartbeatInterval ? Utils.milliSecondsToHHMMSS(this._heartbeatInterval) : this._heartbeatInterval}, not starting the heartbeat`);
 483     }
 484   }
 485
 486   _stopHeartbeat(): void {
 487     if (this._heartbeatSetInterval) {
 488       clearInterval(this._heartbeatSetInterval);
 489       this._heartbeatSetInterval = null;
 490     }
 491   }
 492
 493   _restartHeartbeat(): void {
 494     // Stop heartbeat
 495     this._stopHeartbeat();
 496     // Start heartbeat
 497     this._startHeartbeat();
 498   }
 499
 500   _startAuthorizationFileMonitoring(): void {
 501     // eslint-disable-next-line @typescript-eslint/no-unused-vars
 502     fs.watchFile(this._getAuthorizationFile(), (current, previous) => {
 503       try {
 504         logger.debug(this._logPrefix() + ' Authorization file ' + this._getAuthorizationFile() + ' have changed, reload');
 505         // Initialize _authorizedTags
 506         this._authorizedTags = this._loadAndGetAuthorizedTags();
 507       } catch (error) {
 508         logger.error(this._logPrefix() + ' Authorization file monitoring error: %j', error);
 509       }
 510     });
 511   }
 512
 513   _startStationTemplateFileMonitoring(): void {
 514     // eslint-disable-next-line @typescript-eslint/no-unused-vars
 515     fs.watchFile(this._stationTemplateFile, (current, previous) => {
 516       try {
 517         logger.debug(this._logPrefix() + ' Template file ' + this._stationTemplateFile + ' have changed, reload');
 518         // Initialize
 519         this._initialize();
 520         if (!this._stationInfo.AutomaticTransactionGenerator.enable &&
 521           this._automaticTransactionGeneration) {
 522           this._automaticTransactionGeneration.stop().catch(() => { });
 523         }
 524         // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
 525       } catch (error) {
 526         logger.error(this._logPrefix() + ' Charging station template file monitoring error: %j', error);
 527       }
 528     });
 529   }
 530
 531   _startMeterValues(connectorId: number, interval: number): void {
 532     if (!this.getConnector(connectorId).transactionStarted) {
 533       logger.error(`${this._logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
 534       return;
 535     } else if (this.getConnector(connectorId).transactionStarted && !this.getConnector(connectorId).transactionId) {
 536       logger.error(`${this._logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
 537       return;
 538     }
 539     if (interval > 0) {
 540       this.getConnector(connectorId).transactionSetInterval = setInterval(async () => {
 541         if (this.getEnableStatistics()) {
 542           const sendMeterValues = performance.timerify(this.sendMeterValues);
 543           this._performanceObserver.observe({
 544             entryTypes: ['function'],
 545           });
 546           await sendMeterValues(connectorId, interval, this);
 547         } else {
 548           await this.sendMeterValues(connectorId, interval, this);
 549         }
 550       }, interval);
 551     } else {
 552       logger.error(`${this._logPrefix()} Charging station MeterValueSampleInterval configuration set to ${Utils.milliSecondsToHHMMSS(interval)}, not sending MeterValues`);
 553     }
 554   }
 555
 556   _openWSConnection(options?: WebSocket.ClientOptions, forceCloseOpened = false): void {
 557     if (Utils.isUndefined(options)) {
 558       options = {} as WebSocket.ClientOptions;
 559     }
 560     if (Utils.isUndefined(options.handshakeTimeout)) {
 561       options.handshakeTimeout = this._getConnectionTimeout() * 1000;
 562     }
 563     if (this._isWebSocketOpen() && forceCloseOpened) {
 564       this._wsConnection.close();
 565     }
 566     this._wsConnection = new WebSocket(this._wsConnectionUrl, 'ocpp' + Constants.OCPP_VERSION_16, options);
 567     logger.info(this._logPrefix() + ' Will communicate through URL ' + this._supervisionUrl);
 568   }
 569
 570   start(): void {
 571     this._openWSConnection();
 572     // Monitor authorization file
 573     this._startAuthorizationFileMonitoring();
 574     // Monitor station template file
 575     this._startStationTemplateFileMonitoring();
 576     // Handle Socket incoming messages
 577     this._wsConnection.on('message', this.onMessage.bind(this));
 578     // Handle Socket error
 579     this._wsConnection.on('error', this.onError.bind(this));
 580     // Handle Socket close
 581     this._wsConnection.on('close', this.onClose.bind(this));
 582     // Handle Socket opening connection
 583     this._wsConnection.on('open', this.onOpen.bind(this));
 584     // Handle Socket ping
 585     this._wsConnection.on('ping', this.onPing.bind(this));
 586     // Handle Socket pong
 587     this._wsConnection.on('pong', this.onPong.bind(this));
 588   }
 589
 590   async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
 591     // Stop message sequence
 592     await this._stopMessageSequence(reason);
 593     for (const connector in this._connectors) {
 594       if (Utils.convertToInt(connector) > 0) {
 595         await this.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.UNAVAILABLE);
 596       }
 597     }
 598     if (this._isWebSocketOpen()) {
 599       this._wsConnection.close();
 600     }
 601     this._bootNotificationResponse = null;
 602     this._hasStopped = true;
 603   }
 604
 605   async _reconnect(error): Promise<void> {
 606     // Stop heartbeat
 607     this._stopHeartbeat();
 608     // Stop the ATG if needed
 609     if (this._stationInfo.AutomaticTransactionGenerator.enable &&
 610       this._stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
 611       this._automaticTransactionGeneration &&
 612       !this._automaticTransactionGeneration.timeToStop) {
 613       this._automaticTransactionGeneration.stop().catch(() => { });
 614     }
 615     if (this._autoReconnectRetryCount < this._getAutoReconnectMaxRetries() || this._getAutoReconnectMaxRetries() === -1) {
 616       this._autoReconnectRetryCount++;
 617       const reconnectDelay = (this._getReconnectExponentialDelay() ? Utils.exponentialDelay(this._autoReconnectRetryCount) : this._getConnectionTimeout() * 1000);
 618       logger.error(`${this._logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectDelay - 100}ms`);
 619       await Utils.sleep(reconnectDelay);
 620       logger.error(this._logPrefix() + ' Socket: reconnecting try #' + this._autoReconnectRetryCount.toString());
 621       this._openWSConnection({ handshakeTimeout: reconnectDelay - 100 });
 622       this._hasSocketRestarted = true;
 623     } else if (this._getAutoReconnectMaxRetries() !== -1) {
 624       logger.error(`${this._logPrefix()} Socket reconnect failure: max retries reached (${this._autoReconnectRetryCount}) or retry disabled (${this._getAutoReconnectMaxRetries()})`);
 625     }
 626   }
 627
 628   async onOpen(): Promise<void> {
 629     logger.info(`${this._logPrefix()} Is connected to server through ${this._wsConnectionUrl}`);
 630     if (!this._isRegistered()) {
 631       // Send BootNotification
 632       let registrationRetryCount = 0;
 633       do {
 634         this._bootNotificationResponse = await this.sendBootNotification();
 635         if (!this._isRegistered()) {
 636           registrationRetryCount++;
 637           await Utils.sleep(this._bootNotificationResponse.interval * 1000);
 638         }
 639       } while (!this._isRegistered() && (registrationRetryCount <= this._getRegistrationMaxRetries() || this._getRegistrationMaxRetries() === -1));
 640     }
 641     if (this._isRegistered()) {
 642       await this._startMessageSequence();
 643       if (this._hasSocketRestarted && this._isWebSocketOpen()) {
 644         if (!Utils.isEmptyArray(this._messageQueue)) {
 645           this._messageQueue.forEach((message, index) => {
 646             this._messageQueue.splice(index, 1);
 647             this._wsConnection.send(message);
 648           });
 649         }
 650       }
 651     } else {
 652       logger.error(`${this._logPrefix()} Registration failure: max retries reached (${this._getRegistrationMaxRetries()}) or retry disabled (${this._getRegistrationMaxRetries()})`);
 653     }
 654     this._autoReconnectRetryCount = 0;
 655     this._hasSocketRestarted = false;
 656   }
 657
 658   async onError(errorEvent): Promise<void> {
 659     logger.error(this._logPrefix() + ' Socket error: %j', errorEvent);
 660     // pragma switch (errorEvent.code) {
 661     //   case 'ECONNREFUSED':
 662     //     await this._reconnect(errorEvent);
 663     //     break;
 664     // }
 665   }
 666
 667   async onClose(closeEvent): Promise<void> {
 668     switch (closeEvent) {
 669       case WebSocketCloseEventStatusCode.CLOSE_NORMAL: // Normal close
 670       case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
 671         logger.info(`${this._logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
 672         this._autoReconnectRetryCount = 0;
 673         break;
 674       default: // Abnormal close
 675         logger.error(`${this._logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
 676         await this._reconnect(closeEvent);
 677         break;
 678     }
 679   }
 680
 681   onPing(): void {
 682     logger.debug(this._logPrefix() + ' Has received a WS ping (rfc6455) from the server');
 683   }
 684
 685   onPong(): void {
 686     logger.debug(this._logPrefix() + ' Has received a WS pong (rfc6455) from the server');
 687   }
 688
 689   async onMessage(messageEvent: MessageEvent): Promise<void> {
 690     let [messageType, messageId, commandName, commandPayload, errorDetails] = [0, '', Constants.ENTITY_CHARGING_STATION, '', ''];
 691     try {
 692       // Parse the message
 693       [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent.toString());
 694
 695       // Check the Type of message
 696       switch (messageType) {
 697         // Incoming Message
 698         case MessageType.CALL_MESSAGE:
 699           if (this.getEnableStatistics()) {
 700             this._statistics.addMessage(commandName, messageType);
 701           }
 702           // Process the call
 703           await this.handleRequest(messageId, commandName, commandPayload);
 704           break;
 705         // Outcome Message
 706         case MessageType.CALL_RESULT_MESSAGE:
 707           // Respond
 708           // eslint-disable-next-line no-case-declarations
 709           let responseCallback; let requestPayload;
 710           if (Utils.isIterable(this._requests[messageId])) {
 711             [responseCallback, , requestPayload] = this._requests[messageId];
 712           } else {
 713             throw new Error(`Response request for message id ${messageId} is not iterable`);
 714           }
 715           if (!responseCallback) {
 716             // Error
 717             throw new Error(`Response request for unknown message id ${messageId}`);
 718           }
 719           delete this._requests[messageId];
 720           responseCallback(commandName, requestPayload);
 721           break;
 722         // Error Message
 723         case MessageType.CALL_ERROR_MESSAGE:
 724           if (!this._requests[messageId]) {
 725             // Error
 726             throw new Error(`Error request for unknown message id ${messageId}`);
 727           }
 728           // eslint-disable-next-line no-case-declarations
 729           let rejectCallback;
 730           if (Utils.isIterable(this._requests[messageId])) {
 731             [, rejectCallback] = this._requests[messageId];
 732           } else {
 733             throw new Error(`Error request for message id ${messageId} is not iterable`);
 734           }
 735           delete this._requests[messageId];
 736           rejectCallback(new OCPPError(commandName, commandPayload, errorDetails));
 737           break;
 738         // Error
 739         default:
 740           // eslint-disable-next-line no-case-declarations
 741           const errMsg = `${this._logPrefix()} Wrong message type ${messageType}`;
 742           logger.error(errMsg);
 743           throw new Error(errMsg);
 744       }
 745     } catch (error) {
 746       // Log
 747       logger.error('%s Incoming message %j processing error %s on request content type %s', this._logPrefix(), messageEvent, error, this._requests[messageId]);
 748       // Send error
 749       messageType !== MessageType.CALL_ERROR_MESSAGE && await this.sendError(messageId, error, commandName);
 750     }
 751   }
 752
 753   async sendHeartbeat(): Promise<void> {
 754     try {
 755       const payload: HeartbeatRequest = {};
 756       await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'Heartbeat');
 757     } catch (error) {
 758       logger.error(this._logPrefix() + ' Send Heartbeat error: %j', error);
 759       throw error;
 760     }
 761   }
 762
 763   async sendBootNotification(): Promise<BootNotificationResponse> {
 764     try {
 765       return await this.sendMessage(Utils.generateUUID(), this._bootNotificationRequest, MessageType.CALL_MESSAGE, 'BootNotification') as BootNotificationResponse;
 766     } catch (error) {
 767       logger.error(this._logPrefix() + ' Send BootNotification error: %j', error);
 768       throw error;
 769     }
 770   }
 771
 772   async sendStatusNotification(connectorId: number, status: ChargePointStatus, errorCode: ChargePointErrorCode = ChargePointErrorCode.NO_ERROR): Promise<void> {
 773     this.getConnector(connectorId).status = status;
 774     try {
 775       const payload: StatusNotificationRequest = {
 776         connectorId,
 777         errorCode,
 778         status,
 779       };
 780       await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'StatusNotification');
 781     } catch (error) {
 782       logger.error(this._logPrefix() + ' Send StatusNotification error: %j', error);
 783       throw error;
 784     }
 785   }
 786
 787   async sendStartTransaction(connectorId: number, idTag?: string): Promise<StartTransactionResponse> {
 788     try {
 789       const payload: StartTransactionRequest = {
 790         connectorId,
 791         ...!Utils.isUndefined(idTag) ? { idTag } : { idTag: Constants.TRANSACTION_DEFAULT_IDTAG },
 792         meterStart: 0,
 793         timestamp: new Date().toISOString(),
 794       };
 795       return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'StartTransaction') as StartTransactionResponse;
 796     } catch (error) {
 797       logger.error(this._logPrefix() + ' Send StartTransaction error: %j', error);
 798       throw error;
 799     }
 800   }
 801
 802   async sendStopTransaction(transactionId: number, reason: StopTransactionReason = StopTransactionReason.NONE): Promise<StopTransactionResponse> {
 803     const idTag = this._getTransactionIdTag(transactionId);
 804     try {
 805       const payload: StopTransactionRequest = {
 806         transactionId,
 807         ...!Utils.isUndefined(idTag) && { idTag: idTag },
 808         meterStop: this._getTransactionMeterStop(transactionId),
 809         timestamp: new Date().toISOString(),
 810         ...reason && { reason },
 811       };
 812       return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'StopTransaction') as StartTransactionResponse;
 813     } catch (error) {
 814       logger.error(this._logPrefix() + ' Send StopTransaction error: %j', error);
 815       throw error;
 816     }
 817   }
 818
 819   // eslint-disable-next-line consistent-this
 820   async sendMeterValues(connectorId: number, interval: number, self: ChargingStation, debug = false): Promise<void> {
 821     try {
 822       const meterValue: MeterValue = {
 823         timestamp: new Date().toISOString(),
 824         sampledValue: [],
 825       };
 826       const meterValuesTemplate: SampledValue[] = self.getConnector(connectorId).MeterValues;
 827       for (let index = 0; index < meterValuesTemplate.length; index++) {
 828         const connector = self.getConnector(connectorId);
 829         // SoC measurand
 830         if (meterValuesTemplate[index].measurand && meterValuesTemplate[index].measurand === MeterValueMeasurand.STATE_OF_CHARGE && self._getConfigurationKey('MeterValuesSampledData').value.includes(MeterValueMeasurand.STATE_OF_CHARGE)) {
 831           meterValue.sampledValue.push({
 832             ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.PERCENT },
 833             ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 834             measurand: meterValuesTemplate[index].measurand,
 835             ...!Utils.isUndefined(meterValuesTemplate[index].location) ? { location: meterValuesTemplate[index].location } : { location: MeterValueLocation.EV },
 836             ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: Utils.getRandomInt(100).toString() },
 837           });
 838           const sampledValuesIndex = meterValue.sampledValue.length - 1;
 839           if (Utils.convertToInt(meterValue.sampledValue[sampledValuesIndex].value) > 100 || debug) {
 840             logger.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/100`);
 841           }
 842         // Voltage measurand
 843         } else if (meterValuesTemplate[index].measurand && meterValuesTemplate[index].measurand === MeterValueMeasurand.VOLTAGE && self._getConfigurationKey('MeterValuesSampledData').value.includes(MeterValueMeasurand.VOLTAGE)) {
 844           const voltageMeasurandValue = Utils.getRandomFloatRounded(self._getVoltageOut() + self._getVoltageOut() * 0.1, self._getVoltageOut() - self._getVoltageOut() * 0.1);
 845           meterValue.sampledValue.push({
 846             ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.VOLT },
 847             ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 848             measurand: meterValuesTemplate[index].measurand,
 849             ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
 850             ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: voltageMeasurandValue.toString() },
 851           });
 852           for (let phase = 1; self._getNumberOfPhases() === 3 && phase <= self._getNumberOfPhases(); phase++) {
 853             let phaseValue: string;
 854             if (self._getVoltageOut() >= 0 && self._getVoltageOut() <= 250) {
 855               phaseValue = `L${phase}-N`;
 856             } else if (self._getVoltageOut() > 250) {
 857               phaseValue = `L${phase}-L${(phase + 1) % self._getNumberOfPhases() !== 0 ? (phase + 1) % self._getNumberOfPhases() : self._getNumberOfPhases()}`;
 858             }
 859             meterValue.sampledValue.push({
 860               ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.VOLT },
 861               ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 862               measurand: meterValuesTemplate[index].measurand,
 863               ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
 864               ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: voltageMeasurandValue.toString() },
 865               phase: phaseValue as MeterValuePhase,
 866             });
 867           }
 868         // Power.Active.Import measurand
 869         } else if (meterValuesTemplate[index].measurand && meterValuesTemplate[index].measurand === MeterValueMeasurand.POWER_ACTIVE_IMPORT && self._getConfigurationKey('MeterValuesSampledData').value.includes(MeterValueMeasurand.POWER_ACTIVE_IMPORT)) {
 870           // FIXME: factor out powerDivider checks
 871           if (Utils.isUndefined(self._stationInfo.powerDivider)) {
 872             const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider is undefined`;
 873             logger.error(errMsg);
 874             throw Error(errMsg);
 875           } else if (self._stationInfo.powerDivider && self._stationInfo.powerDivider <= 0) {
 876             const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider have zero or below value ${self._stationInfo.powerDivider}`;
 877             logger.error(errMsg);
 878             throw Error(errMsg);
 879           }
 880           const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: Unknown ${self._getPowerOutType()} powerOutType in template file ${self._stationTemplateFile}, cannot calculate ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} measurand value`;
 881           const powerMeasurandValues = {} as MeasurandValues;
 882           const maxPower = Math.round(self._stationInfo.maxPower / self._stationInfo.powerDivider);
 883           const maxPowerPerPhase = Math.round((self._stationInfo.maxPower / self._stationInfo.powerDivider) / self._getNumberOfPhases());
 884           switch (self._getPowerOutType()) {
 885             case PowerOutType.AC:
 886               if (Utils.isUndefined(meterValuesTemplate[index].value)) {
 887                 powerMeasurandValues.L1 = Utils.getRandomFloatRounded(maxPowerPerPhase);
 888                 powerMeasurandValues.L2 = 0;
 889                 powerMeasurandValues.L3 = 0;
 890                 if (self._getNumberOfPhases() === 3) {
 891                   powerMeasurandValues.L2 = Utils.getRandomFloatRounded(maxPowerPerPhase);
 892                   powerMeasurandValues.L3 = Utils.getRandomFloatRounded(maxPowerPerPhase);
 893                 }
 894                 powerMeasurandValues.allPhases = Utils.roundTo(powerMeasurandValues.L1 + powerMeasurandValues.L2 + powerMeasurandValues.L3, 2);
 895               }
 896               break;
 897             case PowerOutType.DC:
 898               if (Utils.isUndefined(meterValuesTemplate[index].value)) {
 899                 powerMeasurandValues.allPhases = Utils.getRandomFloatRounded(maxPower);
 900               }
 901               break;
 902             default:
 903               logger.error(errMsg);
 904               throw Error(errMsg);
 905           }
 906           meterValue.sampledValue.push({
 907             ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.WATT },
 908             ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 909             measurand: meterValuesTemplate[index].measurand,
 910             ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
 911             ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: powerMeasurandValues.allPhases.toString() },
 912           });
 913           const sampledValuesIndex = meterValue.sampledValue.length - 1;
 914           if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > maxPower || debug) {
 915             logger.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxPower}`);
 916           }
 917           for (let phase = 1; self._getNumberOfPhases() === 3 && phase <= self._getNumberOfPhases(); phase++) {
 918             const phaseValue = `L${phase}-N`;
 919             meterValue.sampledValue.push({
 920               ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.WATT },
 921               ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 922               ...!Utils.isUndefined(meterValuesTemplate[index].measurand) && { measurand: meterValuesTemplate[index].measurand },
 923               ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
 924               ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: powerMeasurandValues[`L${phase}`] as string },
 925               phase: phaseValue as MeterValuePhase,
 926             });
 927           }
 928         // Current.Import measurand
 929         } else if (meterValuesTemplate[index].measurand && meterValuesTemplate[index].measurand === MeterValueMeasurand.CURRENT_IMPORT && self._getConfigurationKey('MeterValuesSampledData').value.includes(MeterValueMeasurand.CURRENT_IMPORT)) {
 930           // FIXME: factor out powerDivider checks
 931           if (Utils.isUndefined(self._stationInfo.powerDivider)) {
 932             const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider is undefined`;
 933             logger.error(errMsg);
 934             throw Error(errMsg);
 935           } else if (self._stationInfo.powerDivider && self._stationInfo.powerDivider <= 0) {
 936             const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider have zero or below value ${self._stationInfo.powerDivider}`;
 937             logger.error(errMsg);
 938             throw Error(errMsg);
 939           }
 940           const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: Unknown ${self._getPowerOutType()} powerOutType in template file ${self._stationTemplateFile}, cannot calculate ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} measurand value`;
 941           const currentMeasurandValues: MeasurandValues = {} as MeasurandValues;
 942           let maxAmperage: number;
 943           switch (self._getPowerOutType()) {
 944             case PowerOutType.AC:
 945               maxAmperage = ElectricUtils.ampPerPhaseFromPower(self._getNumberOfPhases(), self._stationInfo.maxPower / self._stationInfo.powerDivider, self._getVoltageOut());
 946               if (Utils.isUndefined(meterValuesTemplate[index].value)) {
 947                 currentMeasurandValues.L1 = Utils.getRandomFloatRounded(maxAmperage);
 948                 currentMeasurandValues.L2 = 0;
 949                 currentMeasurandValues.L3 = 0;
 950                 if (self._getNumberOfPhases() === 3) {
 951                   currentMeasurandValues.L2 = Utils.getRandomFloatRounded(maxAmperage);
 952                   currentMeasurandValues.L3 = Utils.getRandomFloatRounded(maxAmperage);
 953                 }
 954                 currentMeasurandValues.allPhases = Utils.roundTo((currentMeasurandValues.L1 + currentMeasurandValues.L2 + currentMeasurandValues.L3) / self._getNumberOfPhases(), 2);
 955               }
 956               break;
 957             case PowerOutType.DC:
 958               maxAmperage = ElectricUtils.ampTotalFromPower(self._stationInfo.maxPower / self._stationInfo.powerDivider, self._getVoltageOut());
 959               if (Utils.isUndefined(meterValuesTemplate[index].value)) {
 960                 currentMeasurandValues.allPhases = Utils.getRandomFloatRounded(maxAmperage);
 961               }
 962               break;
 963             default:
 964               logger.error(errMsg);
 965               throw Error(errMsg);
 966           }
 967           meterValue.sampledValue.push({
 968             ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.AMP },
 969             ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 970             measurand: meterValuesTemplate[index].measurand,
 971             ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
 972             ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: currentMeasurandValues.allPhases.toString() },
 973           });
 974           const sampledValuesIndex = meterValue.sampledValue.length - 1;
 975           if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > maxAmperage || debug) {
 976             logger.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxAmperage}`);
 977           }
 978           for (let phase = 1; self._getNumberOfPhases() === 3 && phase <= self._getNumberOfPhases(); phase++) {
 979             const phaseValue = `L${phase}`;
 980             meterValue.sampledValue.push({
 981               ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.AMP },
 982               ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
 983               ...!Utils.isUndefined(meterValuesTemplate[index].measurand) && { measurand: meterValuesTemplate[index].measurand },
 984               ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
 985               ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } : { value: currentMeasurandValues[phaseValue] as string },
 986               phase: phaseValue as MeterValuePhase,
 987             });
 988           }
 989         // Energy.Active.Import.Register measurand (default)
 990         } else if (!meterValuesTemplate[index].measurand || meterValuesTemplate[index].measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER) {
 991           // FIXME: factor out powerDivider checks
 992           if (Utils.isUndefined(self._stationInfo.powerDivider)) {
 993             const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider is undefined`;
 994             logger.error(errMsg);
 995             throw Error(errMsg);
 996           } else if (self._stationInfo.powerDivider && self._stationInfo.powerDivider <= 0) {
 997             const errMsg = `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider have zero or below value ${self._stationInfo.powerDivider}`;
 998             logger.error(errMsg);
 999             throw Error(errMsg);
1000           }
1001           if (Utils.isUndefined(meterValuesTemplate[index].value)) {
1002             const measurandValue = Utils.getRandomInt(self._stationInfo.maxPower / (self._stationInfo.powerDivider * 3600000) * interval);
1003             // Persist previous value in connector
1004             if (connector && !Utils.isNullOrUndefined(connector.lastEnergyActiveImportRegisterValue) && connector.lastEnergyActiveImportRegisterValue >= 0) {
1005               connector.lastEnergyActiveImportRegisterValue += measurandValue;
1006             } else {
1007               connector.lastEnergyActiveImportRegisterValue = 0;
1008             }
1009           }
1010           meterValue.sampledValue.push({
1011             ...!Utils.isUndefined(meterValuesTemplate[index].unit) ? { unit: meterValuesTemplate[index].unit } : { unit: MeterValueUnit.WATT_HOUR },
1012             ...!Utils.isUndefined(meterValuesTemplate[index].context) && { context: meterValuesTemplate[index].context },
1013             ...!Utils.isUndefined(meterValuesTemplate[index].measurand) && { measurand: meterValuesTemplate[index].measurand },
1014             ...!Utils.isUndefined(meterValuesTemplate[index].location) && { location: meterValuesTemplate[index].location },
1015             ...!Utils.isUndefined(meterValuesTemplate[index].value) ? { value: meterValuesTemplate[index].value } :
1016               { value: connector.lastEnergyActiveImportRegisterValue.toString() },
1017           });
1018           const sampledValuesIndex = meterValue.sampledValue.length - 1;
1019           const maxConsumption = Math.round(self._stationInfo.maxPower * 3600 / (self._stationInfo.powerDivider * interval));
1020           if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > maxConsumption || debug) {
1021             logger.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxConsumption}`);
1022           }
1023         // Unsupported measurand
1024         } else {
1025           logger.info(`${self._logPrefix()} Unsupported MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} on connectorId ${connectorId}`);
1026         }
1027       }
1028       const payload: MeterValuesRequest = {
1029         connectorId,
1030         transactionId: self.getConnector(connectorId).transactionId,
1031         meterValue: meterValue,
1032       };
1033       await self.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'MeterValues');
1034     } catch (error) {
1035       logger.error(self._logPrefix() + ' Send MeterValues error: %j', error);
1036       throw error;
1037     }
1038   }
1039
1040   async sendError(messageId: string, err: Error | OCPPError, commandName: string): Promise<unknown> {
1041     // Check exception type: only OCPP error are accepted
1042     const error = err instanceof OCPPError ? err : new OCPPError(ErrorType.INTERNAL_ERROR, err.message, err.stack && err.stack);
1043     // Send error
1044     return this.sendMessage(messageId, error, MessageType.CALL_ERROR_MESSAGE, commandName);
1045   }
1046
1047   async sendMessage(messageId: string, commandParams, messageType = MessageType.CALL_RESULT_MESSAGE, commandName: string): Promise<any> {
1048     // eslint-disable-next-line @typescript-eslint/no-this-alias
1049     const self = this;
1050     // Send a message through wsConnection
1051     return new Promise((resolve: (value?: any | PromiseLike<any>) => void, reject: (reason?: any) => void) => {
1052       let messageToSend;
1053       // Type of message
1054       switch (messageType) {
1055         // Request
1056         case MessageType.CALL_MESSAGE:
1057           // Build request
1058           this._requests[messageId] = [responseCallback, rejectCallback, commandParams];
1059           messageToSend = JSON.stringify([messageType, messageId, commandName, commandParams]);
1060           break;
1061         // Response
1062         case MessageType.CALL_RESULT_MESSAGE:
1063           // Build response
1064           messageToSend = JSON.stringify([messageType, messageId, commandParams]);
1065           break;
1066         // Error Message
1067         case MessageType.CALL_ERROR_MESSAGE:
1068           // Build Error Message
1069           messageToSend = JSON.stringify([messageType, messageId, commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : '', commandParams.details ? commandParams.details : {}]);
1070           break;
1071       }
1072       // Check if wsConnection opened and charging station registered
1073       if (this._isWebSocketOpen() && (this._isRegistered() || commandName === 'BootNotification')) {
1074         if (this.getEnableStatistics()) {
1075           this._statistics.addMessage(commandName, messageType);
1076         }
1077         // Yes: Send Message
1078         this._wsConnection.send(messageToSend);
1079       } else {
1080         let dups = false;
1081         // Handle dups in buffer
1082         for (const message of this._messageQueue) {
1083           // Same message
1084           if (JSON.stringify(messageToSend) === JSON.stringify(message)) {
1085             dups = true;
1086             break;
1087           }
1088         }
1089         if (!dups) {
1090           // Buffer message
1091           this._messageQueue.push(messageToSend);
1092         }
1093         // Reject it
1094         return rejectCallback(new OCPPError(commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : `WebSocket closed for message id '${messageId}' with content '${messageToSend}', message buffered`, commandParams.details ? commandParams.details : {}));
1095       }
1096       // Response?
1097       if (messageType === MessageType.CALL_RESULT_MESSAGE) {
1098         // Yes: send Ok
1099         resolve();
1100       } else if (messageType === MessageType.CALL_ERROR_MESSAGE) {
1101         // Send timeout
1102         setTimeout(() => rejectCallback(new OCPPError(commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : `Timeout for message id '${messageId}' with content '${messageToSend}'`, commandParams.details ? commandParams.details : {})), Constants.OCPP_WEBSOCKET_TIMEOUT);
1103       }
1104
1105       // Function that will receive the request's response
1106       async function responseCallback(payload, requestPayload): Promise<void> {
1107         if (self.getEnableStatistics()) {
1108           self._statistics.addMessage(commandName, messageType);
1109         }
1110         // Send the response
1111         await self.handleResponse(commandName, payload, requestPayload);
1112         resolve(payload);
1113       }
1114
1115       // Function that will receive the request's rejection
1116       function rejectCallback(error: OCPPError): void {
1117         if (self.getEnableStatistics()) {
1118           self._statistics.addMessage(commandName, messageType);
1119         }
1120         logger.debug(`${self._logPrefix()} Error: %j occurred when calling command %s with parameters: %j`, error, commandName, commandParams);
1121         // Build Exception
1122         // eslint-disable-next-line no-empty-function
1123         self._requests[messageId] = [() => { }, () => { }, {}]; // Properly format the request
1124         // Send error
1125         reject(error);
1126       }
1127     });
1128   }
1129
1130   async handleResponse(commandName: string, payload, requestPayload): Promise<void> {
1131     const responseCallbackFn = 'handleResponse' + commandName;
1132     if (typeof this[responseCallbackFn] === 'function') {
1133       await this[responseCallbackFn](payload, requestPayload);
1134     } else {
1135       logger.error(this._logPrefix() + ' Trying to call an undefined response callback function: ' + responseCallbackFn);
1136     }
1137   }
1138
1139   handleResponseBootNotification(payload: BootNotificationResponse, requestPayload: BootNotificationRequest): void {
1140     if (payload.status === RegistrationStatus.ACCEPTED) {
1141       this._heartbeatInterval = payload.interval * 1000;
1142       this._heartbeatSetInterval ? this._restartHeartbeat() : this._startHeartbeat();
1143       this._addConfigurationKey('HeartBeatInterval', payload.interval.toString());
1144       this._addConfigurationKey('HeartbeatInterval', payload.interval.toString(), false, false);
1145       this._hasStopped && (this._hasStopped = false);
1146     } else if (payload.status === RegistrationStatus.PENDING) {
1147       logger.info(this._logPrefix() + ' Charging station in pending state on the central server');
1148     } else {
1149       logger.info(this._logPrefix() + ' Charging station rejected by the central server');
1150     }
1151   }
1152
1153   _initTransactionOnConnector(connectorId: number): void {
1154     this.getConnector(connectorId).transactionStarted = false;
1155     this.getConnector(connectorId).transactionId = null;
1156     this.getConnector(connectorId).idTag = null;
1157     this.getConnector(connectorId).lastEnergyActiveImportRegisterValue = -1;
1158   }
1159
1160   _resetTransactionOnConnector(connectorId: number): void {
1161     this._initTransactionOnConnector(connectorId);
1162     if (this.getConnector(connectorId).transactionSetInterval) {
1163       clearInterval(this.getConnector(connectorId).transactionSetInterval);
1164     }
1165   }
1166
1167   async handleResponseStartTransaction(payload: StartTransactionResponse, requestPayload: StartTransactionRequest): Promise<void> {
1168     const connectorId = requestPayload.connectorId;
1169     if (this.getConnector(connectorId).transactionStarted) {
1170       logger.debug(this._logPrefix() + ' Trying to start a transaction on an already used connector ' + connectorId.toString() + ': %j', this.getConnector(connectorId));
1171       return;
1172     }
1173
1174     let transactionConnectorId: number;
1175     for (const connector in this._connectors) {
1176       if (Utils.convertToInt(connector) > 0 && Utils.convertToInt(connector) === connectorId) {
1177         transactionConnectorId = Utils.convertToInt(connector);
1178         break;
1179       }
1180     }
1181     if (!transactionConnectorId) {
1182       logger.error(this._logPrefix() + ' Trying to start a transaction on a non existing connector Id ' + connectorId.toString());
1183       return;
1184     }
1185     if (payload.idTagInfo?.status === AuthorizationStatus.ACCEPTED) {
1186       this.getConnector(connectorId).transactionStarted = true;
1187       this.getConnector(connectorId).transactionId = payload.transactionId;
1188       this.getConnector(connectorId).idTag = requestPayload.idTag;
1189       this.getConnector(connectorId).lastEnergyActiveImportRegisterValue = 0;
1190       await this.sendStatusNotification(connectorId, ChargePointStatus.CHARGING);
1191       logger.info(this._logPrefix() + ' Transaction ' + payload.transactionId.toString() + ' STARTED on ' + this._stationInfo.name + '#' + connectorId.toString() + ' for idTag ' + requestPayload.idTag);
1192       if (this._stationInfo.powerSharedByConnectors) {
1193         this._stationInfo.powerDivider++;
1194       }
1195       const configuredMeterValueSampleInterval = this._getConfigurationKey('MeterValueSampleInterval');
1196       this._startMeterValues(connectorId,
1197         configuredMeterValueSampleInterval ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000 : 60000);
1198     } else {
1199       logger.error(this._logPrefix() + ' Starting transaction id ' + payload.transactionId.toString() + ' REJECTED with status ' + payload.idTagInfo.status + ', idTag ' + requestPayload.idTag);
1200       this._resetTransactionOnConnector(connectorId);
1201       await this.sendStatusNotification(connectorId, ChargePointStatus.AVAILABLE);
1202     }
1203   }
1204
1205   async handleResponseStopTransaction(payload: StopTransactionResponse, requestPayload: StopTransactionRequest): Promise<void> {
1206     let transactionConnectorId: number;
1207     for (const connector in this._connectors) {
1208       if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === requestPayload.transactionId) {
1209         transactionConnectorId = Utils.convertToInt(connector);
1210         break;
1211       }
1212     }
1213     if (!transactionConnectorId) {
1214       logger.error(this._logPrefix() + ' Trying to stop a non existing transaction ' + requestPayload.transactionId.toString());
1215       return;
1216     }
1217     if (payload.idTagInfo?.status === AuthorizationStatus.ACCEPTED) {
1218       await this.sendStatusNotification(transactionConnectorId, ChargePointStatus.AVAILABLE);
1219       if (this._stationInfo.powerSharedByConnectors) {
1220         this._stationInfo.powerDivider--;
1221       }
1222       logger.info(this._logPrefix() + ' Transaction ' + requestPayload.transactionId.toString() + ' STOPPED on ' + this._stationInfo.name + '#' + transactionConnectorId.toString());
1223       this._resetTransactionOnConnector(transactionConnectorId);
1224     } else {
1225       logger.error(this._logPrefix() + ' Stopping transaction id ' + requestPayload.transactionId.toString() + ' REJECTED with status ' + payload.idTagInfo?.status);
1226     }
1227   }
1228
1229   handleResponseStatusNotification(payload: StatusNotificationRequest, requestPayload: StatusNotificationResponse): void {
1230     logger.debug(this._logPrefix() + ' Status notification response received: %j to StatusNotification request: %j', payload, requestPayload);
1231   }
1232
1233   handleResponseMeterValues(payload: MeterValuesRequest, requestPayload: MeterValuesResponse): void {
1234     logger.debug(this._logPrefix() + ' MeterValues response received: %j to MeterValues request: %j', payload, requestPayload);
1235   }
1236
1237   handleResponseHeartbeat(payload: HeartbeatResponse, requestPayload: HeartbeatRequest): void {
1238     logger.debug(this._logPrefix() + ' Heartbeat response received: %j to Heartbeat request: %j', payload, requestPayload);
1239   }
1240
1241   async handleRequest(messageId: string, commandName: string, commandPayload): Promise<void> {
1242     let response;
1243     // Call
1244     if (typeof this['handleRequest' + commandName] === 'function') {
1245       try {
1246         // Call the method to build the response
1247         response = await this['handleRequest' + commandName](commandPayload);
1248       } catch (error) {
1249         // Log
1250         logger.error(this._logPrefix() + ' Handle request error: %j', error);
1251         // Send back response to inform backend
1252         await this.sendError(messageId, error, commandName);
1253         throw error;
1254       }
1255     } else {
1256       // Throw exception
1257       await this.sendError(messageId, new OCPPError(ErrorType.NOT_IMPLEMENTED, `${commandName} is not implemented`, {}), commandName);
1258       throw new Error(`${commandName} is not implemented ${JSON.stringify(commandPayload, null, ' ')}`);
1259     }
1260     // Send response
1261     await this.sendMessage(messageId, response, MessageType.CALL_RESULT_MESSAGE, commandName);
1262   }
1263
1264   // Simulate charging station restart
1265   handleRequestReset(commandPayload: ResetRequest): DefaultResponse {
1266     setImmediate(async () => {
1267       await this.stop(commandPayload.type + 'Reset' as StopTransactionReason);
1268       await Utils.sleep(this._stationInfo.resetTime);
1269       await this.start();
1270     });
1271     logger.info(`${this._logPrefix()} ${commandPayload.type} reset command received, simulating it. The station will be back online in ${Utils.milliSecondsToHHMMSS(this._stationInfo.resetTime)}`);
1272     return Constants.OCPP_RESPONSE_ACCEPTED;
1273   }
1274
1275   handleRequestClearCache(): DefaultResponse {
1276     return Constants.OCPP_RESPONSE_ACCEPTED;
1277   }
1278
1279   async handleRequestUnlockConnector(commandPayload: UnlockConnectorRequest): Promise<UnlockConnectorResponse> {
1280     const connectorId = commandPayload.connectorId;
1281     if (connectorId === 0) {
1282       logger.error(this._logPrefix() + ' Trying to unlock connector ' + connectorId.toString());
1283       return Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
1284     }
1285     if (this.getConnector(connectorId).transactionStarted) {
1286       const stopResponse = await this.sendStopTransaction(this.getConnector(connectorId).transactionId, StopTransactionReason.UNLOCK_COMMAND);
1287       if (stopResponse.idTagInfo?.status === AuthorizationStatus.ACCEPTED) {
1288         return Constants.OCPP_RESPONSE_UNLOCKED;
1289       }
1290       return Constants.OCPP_RESPONSE_UNLOCK_FAILED;
1291     }
1292     await this.sendStatusNotification(connectorId, ChargePointStatus.AVAILABLE);
1293     return Constants.OCPP_RESPONSE_UNLOCKED;
1294   }
1295
1296   _getConfigurationKey(key: string, caseInsensitive = false): ConfigurationKey {
1297     return this._configuration.configurationKey.find((configElement) => {
1298       if (caseInsensitive) {
1299         return configElement.key.toLowerCase() === key.toLowerCase();
1300       }
1301       return configElement.key === key;
1302     });
1303   }
1304
1305   _addConfigurationKey(key: string, value: string, readonly = false, visible = true, reboot = false): void {
1306     const keyFound = this._getConfigurationKey(key);
1307     if (!keyFound) {
1308       this._configuration.configurationKey.push({
1309         key,
1310         readonly,
1311         value,
1312         visible,
1313         reboot,
1314       });
1315     }
1316   }
1317
1318   _setConfigurationKeyValue(key: string, value: string): void {
1319     const keyFound = this._getConfigurationKey(key);
1320     if (keyFound) {
1321       const keyIndex = this._configuration.configurationKey.indexOf(keyFound);
1322       this._configuration.configurationKey[keyIndex].value = value;
1323     }
1324   }
1325
1326   handleRequestGetConfiguration(commandPayload: GetConfigurationRequest): GetConfigurationResponse {
1327     const configurationKey: ConfigurationKey[] = [];
1328     const unknownKey: string[] = [];
1329     if (Utils.isEmptyArray(commandPayload.key)) {
1330       for (const configuration of this._configuration.configurationKey) {
1331         if (Utils.isUndefined(configuration.visible)) {
1332           configuration.visible = true;
1333         }
1334         if (!configuration.visible) {
1335           continue;
1336         }
1337         configurationKey.push({
1338           key: configuration.key,
1339           readonly: configuration.readonly,
1340           value: configuration.value,
1341         });
1342       }
1343     } else {
1344       for (const key of commandPayload.key) {
1345         const keyFound = this._getConfigurationKey(key);
1346         if (keyFound) {
1347           if (Utils.isUndefined(keyFound.visible)) {
1348             keyFound.visible = true;
1349           }
1350           if (!keyFound.visible) {
1351             continue;
1352           }
1353           configurationKey.push({
1354             key: keyFound.key,
1355             readonly: keyFound.readonly,
1356             value: keyFound.value,
1357           });
1358         } else {
1359           unknownKey.push(key);
1360         }
1361       }
1362     }
1363     return {
1364       configurationKey,
1365       unknownKey,
1366     };
1367   }
1368
1369   handleRequestChangeConfiguration(commandPayload: ChangeConfigurationRequest): ChangeConfigurationResponse {
1370     // JSON request fields type sanity check
1371     if (!Utils.isString(commandPayload.key)) {
1372       logger.error(`${this._logPrefix()} ChangeConfiguration request key field is not a string:`, commandPayload);
1373     }
1374     if (!Utils.isString(commandPayload.value)) {
1375       logger.error(`${this._logPrefix()} ChangeConfiguration request value field is not a string:`, commandPayload);
1376     }
1377     const keyToChange = this._getConfigurationKey(commandPayload.key, true);
1378     if (!keyToChange) {
1379       return Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
1380     } else if (keyToChange && keyToChange.readonly) {
1381       return Constants.OCPP_CONFIGURATION_RESPONSE_REJECTED;
1382     } else if (keyToChange && !keyToChange.readonly) {
1383       const keyIndex = this._configuration.configurationKey.indexOf(keyToChange);
1384       let valueChanged = false;
1385       if (this._configuration.configurationKey[keyIndex].value !== commandPayload.value) {
1386         this._configuration.configurationKey[keyIndex].value = commandPayload.value;
1387         valueChanged = true;
1388       }
1389       let triggerHeartbeatRestart = false;
1390       if (keyToChange.key === 'HeartBeatInterval' && valueChanged) {
1391         this._setConfigurationKeyValue('HeartbeatInterval', commandPayload.value);
1392         triggerHeartbeatRestart = true;
1393       }
1394       if (keyToChange.key === 'HeartbeatInterval' && valueChanged) {
1395         this._setConfigurationKeyValue('HeartBeatInterval', commandPayload.value);
1396         triggerHeartbeatRestart = true;
1397       }
1398       if (triggerHeartbeatRestart) {
1399         this._heartbeatInterval = Utils.convertToInt(commandPayload.value) * 1000;
1400         this._restartHeartbeat();
1401       }
1402       if (keyToChange.key === 'WebSocketPingInterval' && valueChanged) {
1403         this._restartWebSocketPing();
1404       }
1405       if (keyToChange.reboot) {
1406         return Constants.OCPP_CONFIGURATION_RESPONSE_REBOOT_REQUIRED;
1407       }
1408       return Constants.OCPP_CONFIGURATION_RESPONSE_ACCEPTED;
1409     }
1410   }
1411
1412   handleRequestSetChargingProfile(commandPayload: SetChargingProfileRequest): SetChargingProfileResponse {
1413     if (!this.getConnector(commandPayload.connectorId)) {
1414       logger.error(`${this._logPrefix()} Trying to set a charging profile to a non existing connector Id ${commandPayload.connectorId}`);
1415       return Constants.OCPP_CHARGING_PROFILE_RESPONSE_REJECTED;
1416     }
1417     if (commandPayload.csChargingProfiles.chargingProfilePurpose === ChargingProfilePurposeType.TX_PROFILE && !this.getConnector(commandPayload.connectorId)?.transactionStarted) {
1418       return Constants.OCPP_CHARGING_PROFILE_RESPONSE_REJECTED;
1419     }
1420     this.getConnector(commandPayload.connectorId).chargingProfiles.forEach((chargingProfile: ChargingProfile, index: number) => {
1421       if (chargingProfile.chargingProfileId === commandPayload.csChargingProfiles.chargingProfileId
1422         || (chargingProfile.stackLevel === commandPayload.csChargingProfiles.stackLevel && chargingProfile.chargingProfilePurpose === commandPayload.csChargingProfiles.chargingProfilePurpose)) {
1423         this.getConnector(commandPayload.connectorId).chargingProfiles[index] = chargingProfile;
1424         return Constants.OCPP_CHARGING_PROFILE_RESPONSE_ACCEPTED;
1425       }
1426     });
1427     this.getConnector(commandPayload.connectorId).chargingProfiles.push(commandPayload.csChargingProfiles);
1428     return Constants.OCPP_CHARGING_PROFILE_RESPONSE_ACCEPTED;
1429   }
1430
1431   async handleRequestRemoteStartTransaction(commandPayload: RemoteStartTransactionRequest): Promise<DefaultResponse> {
1432     const transactionConnectorID: number = commandPayload.connectorId ? commandPayload.connectorId : 1;
1433     if (this._getAuthorizeRemoteTxRequests() && this._getLocalAuthListEnabled() && this.hasAuthorizedTags()) {
1434       // Check if authorized
1435       if (this._authorizedTags.find((value) => value === commandPayload.idTag)) {
1436         // Authorization successful start transaction
1437         await this.sendStartTransaction(transactionConnectorID, commandPayload.idTag);
1438         logger.debug(this._logPrefix() + ' Transaction remotely STARTED on ' + this._stationInfo.name + '#' + transactionConnectorID.toString() + ' for idTag ' + commandPayload.idTag);
1439         return Constants.OCPP_RESPONSE_ACCEPTED;
1440       }
1441       logger.error(this._logPrefix() + ' Remote starting transaction REJECTED, idTag ' + commandPayload.idTag);
1442       return Constants.OCPP_RESPONSE_REJECTED;
1443     }
1444     // No local authorization check required => start transaction
1445     await this.sendStartTransaction(transactionConnectorID, commandPayload.idTag);
1446     logger.debug(this._logPrefix() + ' Transaction remotely STARTED on ' + this._stationInfo.name + '#' + transactionConnectorID.toString() + ' for idTag ' + commandPayload.idTag);
1447     return Constants.OCPP_RESPONSE_ACCEPTED;
1448   }
1449
1450   async handleRequestRemoteStopTransaction(commandPayload: RemoteStopTransactionRequest): Promise<DefaultResponse> {
1451     const transactionId = commandPayload.transactionId;
1452     for (const connector in this._connectors) {
1453       if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
1454         await this.sendStopTransaction(transactionId);
1455         return Constants.OCPP_RESPONSE_ACCEPTED;
1456       }
1457     }
1458     logger.info(this._logPrefix() + ' Trying to remote stop a non existing transaction ' + transactionId.toString());
1459     return Constants.OCPP_RESPONSE_REJECTED;
1460   }
1461 }
1462