src/charging-station/ChargingStation.js

   1 const Configuration = require('../utils/Configuration');
   2 const logger = require('../utils/Logger');
   3 const WebSocket = require('ws');
   4 const Constants = require('../utils/Constants');
   5 const Utils = require('../utils/Utils');
   6 const OCPPError = require('./OcppError');
   7 const AutomaticTransactionGenerator = require('./AutomaticTransactionGenerator');
   8 const Statistics = require('../utils/Statistics');
   9 const fs = require('fs');
  10 const {performance, PerformanceObserver} = require('perf_hooks');
  11
  12 class ChargingStation {
  13   constructor(index, stationTemplateFile) {
  14     this._index = index;
  15     this._stationTemplateFile = stationTemplateFile;
  16     this._initialize();
  17
  18     this._isSocketRestart = false;
  19     this._autoReconnectRetryCount = 0;
  20     this._autoReconnectMaxRetries = Configuration.getAutoReconnectMaxRetries(); // -1 for unlimited
  21     this._autoReconnectTimeout = Configuration.getAutoReconnectTimeout() * 1000; // ms, zero for disabling
  22
  23     this._requests = {};
  24     this._messageQueue = [];
  25
  26     this._authorizedTags = this._loadAndGetAuthorizedTags();
  27   }
  28
  29   _getStationName(stationTemplate) {
  30     return stationTemplate.fixedName ? stationTemplate.baseName : stationTemplate.baseName + '-' + ('000000000' + this._index).substr(('000000000' + this._index).length - 4);
  31   }
  32
  33   _buildStationInfo() {
  34     let stationTemplateFromFile;
  35     try {
  36       // Load template file
  37       const fileDescriptor = fs.openSync(this._stationTemplateFile, 'r');
  38       stationTemplateFromFile = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8'));
  39       fs.closeSync(fileDescriptor);
  40     } catch (error) {
  41       logger.error(this._logPrefix() + ' Template file loading error: ' + error);
  42     }
  43     const stationTemplate = stationTemplateFromFile || {};
  44     if (!Utils.isEmptyArray(stationTemplateFromFile.power)) {
  45       stationTemplate.maxPower = stationTemplateFromFile.power[Math.floor(Math.random() * stationTemplateFromFile.power.length)];
  46     } else {
  47       stationTemplate.maxPower = stationTemplateFromFile.power;
  48     }
  49     stationTemplate.name = this._getStationName(stationTemplateFromFile);
  50     stationTemplate.resetTime = stationTemplateFromFile.resetTime ? stationTemplateFromFile.resetTime * 1000 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
  51     return stationTemplate;
  52   }
  53
  54   _initialize() {
  55     this._stationInfo = this._buildStationInfo();
  56     this._bootNotificationMessage = {
  57       chargePointModel: this._stationInfo.chargePointModel,
  58       chargePointVendor: this._stationInfo.chargePointVendor,
  59       chargePointSerialNumber: this._stationInfo.chargePointSerialNumberPrefix ? this._stationInfo.chargePointSerialNumberPrefix : '',
  60       firmwareVersion: this._stationInfo.firmwareVersion ? this._stationInfo.firmwareVersion : '',
  61     };
  62     this._configuration = this._getConfiguration();
  63     this._supervisionUrl = this._getSupervisionURL();
  64     this._wsConnectionUrl = this._supervisionUrl + '/' + this._stationInfo.name;
  65     // Build connectors if needed
  66     const maxConnectors = this._getMaxConnectors();
  67     const connectorsConfig = Utils.cloneJSonDocument(this._stationInfo.Connectors);
  68     const connectorsConfigLength = Utils.convertToBoolean(this._stationInfo.useConnectorId0) && Object.keys(connectorsConfig).includes('0') ? Object.keys(connectorsConfig).length : Object.keys(connectorsConfig).length - 1;
  69     if (!this._connectors || (this._connectors && Object.keys(this._connectors).length !== connectorsConfigLength)) {
  70       this._connectors = {};
  71       // Determine number of customized connectors
  72       let lastConnector;
  73       for (lastConnector in connectorsConfig) {
  74         // Add connector 0, OCPP specification violation that for example KEBA have
  75         if (Utils.convertToInt(lastConnector) === 0 && Utils.convertToBoolean(this._stationInfo.useConnectorId0) &&
  76           connectorsConfig[lastConnector]) {
  77           this._connectors[lastConnector] = connectorsConfig[lastConnector];
  78         }
  79       }
  80       this._addConfigurationKey('NumberOfConnectors', maxConnectors, true);
  81       // Generate all connectors
  82       for (let index = 1; index <= maxConnectors; index++) {
  83         const randConnectorID = Utils.convertToBoolean(this._stationInfo.randomConnectors) ? Utils.getRandomInt(lastConnector, 1) : index;
  84         this._connectors[index] = connectorsConfig[randConnectorID];
  85       }
  86     }
  87     // Initialize transaction attributes on connectors
  88     for (const connector in this._connectors) {
  89       if (!this._connectors[connector].transactionStarted) {
  90         this._initTransactionOnConnector(connector);
  91       }
  92     }
  93     this._statistics = new Statistics(this._stationInfo.name);
  94     this._performanceObserver = new PerformanceObserver((list) => {
  95       const entry = list.getEntries()[0];
  96       this._statistics.logPerformance(entry, 'ChargingStation');
  97       this._performanceObserver.disconnect();
  98     });
  99   }
 100
 101   _logPrefix() {
 102     return Utils.logPrefix(` ${this._stationInfo.name}:`);
 103   }
 104
 105   _getConfiguration() {
 106     return this._stationInfo.Configuration ? this._stationInfo.Configuration : {};
 107   }
 108
 109   _getAuthorizationFile() {
 110     return this._stationInfo.authorizationFile ? this._stationInfo.authorizationFile : '';
 111   }
 112
 113   _loadAndGetAuthorizedTags() {
 114     let authorizedTags = [];
 115     const authorizationFile = this._getAuthorizationFile();
 116     if (authorizationFile) {
 117       try {
 118         // Load authorization file
 119         const fileDescriptor = fs.openSync(authorizationFile, 'r');
 120         authorizedTags = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8'));
 121         fs.closeSync(fileDescriptor);
 122       } catch (error) {
 123         logger.error(this._logPrefix() + ' Authorization file loading error: ' + error);
 124       }
 125     } else {
 126       logger.info(this._logPrefix() + ' No authorization file given in template file ' + this._stationTemplateFile);
 127     }
 128     return authorizedTags;
 129   }
 130
 131   getRandomTagId() {
 132     const index = Math.floor(Math.random() * this._authorizedTags.length);
 133     return this._authorizedTags[index];
 134   }
 135
 136   hasAuthorizedTags() {
 137     return !Utils.isEmptyArray(this._authorizedTags);
 138   }
 139
 140   _getConnector(number) {
 141     return this._stationInfo.Connectors[number];
 142   }
 143
 144   _getMaxConnectors() {
 145     let maxConnectors = 0;
 146     if (!Utils.isEmptyArray(this._stationInfo.numberOfConnectors)) {
 147       // Get evenly the number of connectors
 148       maxConnectors = this._stationInfo.numberOfConnectors[(this._index - 1) % this._stationInfo.numberOfConnectors.length];
 149     } else {
 150       maxConnectors = this._stationInfo.numberOfConnectors;
 151     }
 152     return maxConnectors;
 153   }
 154
 155   _getSupervisionURL() {
 156     const supervisionUrls = Utils.cloneJSonDocument(this._stationInfo.supervisionURL ? this._stationInfo.supervisionURL : Configuration.getSupervisionURLs());
 157     let indexUrl = 0;
 158     if (!Utils.isEmptyArray(supervisionUrls)) {
 159       if (Configuration.getDistributeStationToTenantEqually()) {
 160         indexUrl = this._index % supervisionUrls.length;
 161       } else {
 162         // Get a random url
 163         indexUrl = Math.floor(Math.random() * supervisionUrls.length);
 164       }
 165       return supervisionUrls[indexUrl];
 166     }
 167     return supervisionUrls;
 168   }
 169
 170   _getAuthorizeRemoteTxRequests() {
 171     const authorizeRemoteTxRequests = this._getConfigurationKey('AuthorizeRemoteTxRequests');
 172     return authorizeRemoteTxRequests ? Utils.convertToBoolean(authorizeRemoteTxRequests.value) : false;
 173   }
 174
 175   _getLocalAuthListEnabled() {
 176     const localAuthListEnabled = this._getConfigurationKey('LocalAuthListEnabled');
 177     return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
 178   }
 179
 180   async _basicStartMessageSequence() {
 181     // Start heartbeat
 182     this._startHeartbeat(this);
 183     // Initialize connectors status
 184     for (const connector in this._connectors) {
 185       if (!this._connectors[connector].transactionStarted) {
 186         if (this._connectors[connector].bootStatus) {
 187           this.sendStatusNotificationWithTimeout(connector, this._connectors[connector].bootStatus);
 188         } else {
 189           this.sendStatusNotificationWithTimeout(connector, 'Available');
 190         }
 191       } else {
 192         this.sendStatusNotificationWithTimeout(connector, 'Charging');
 193       }
 194     }
 195     // Start the ATG
 196     if (Utils.convertToBoolean(this._stationInfo.AutomaticTransactionGenerator.enable)) {
 197       if (!this._automaticTransactionGeneration) {
 198         this._automaticTransactionGeneration = new AutomaticTransactionGenerator(this);
 199       }
 200       if (this._automaticTransactionGeneration.timeToStop) {
 201         this._automaticTransactionGeneration.start();
 202       }
 203     }
 204     this._statistics.start();
 205   }
 206
 207   // eslint-disable-next-line class-methods-use-this
 208   async _startHeartbeat(self) {
 209     if (self._heartbeatInterval && self._heartbeatInterval > 0 && !self._heartbeatSetInterval) {
 210       self._heartbeatSetInterval = setInterval(() => {
 211         this.sendHeartbeat();
 212       }, self._heartbeatInterval);
 213       logger.info(self._logPrefix() + ' Heartbeat started every ' + self._heartbeatInterval + 'ms');
 214     } else {
 215       logger.error(`${self._logPrefix()} Heartbeat interval set to ${self._heartbeatInterval}, not starting the heartbeat`);
 216     }
 217   }
 218
 219   async _stopHeartbeat() {
 220     if (this._heartbeatSetInterval) {
 221       clearInterval(this._heartbeatSetInterval);
 222       this._heartbeatSetInterval = null;
 223     }
 224   }
 225
 226   _startAuthorizationFileMonitoring() {
 227     // eslint-disable-next-line no-unused-vars
 228     fs.watchFile(this._getAuthorizationFile(), (current, previous) => {
 229       try {
 230         logger.debug(this._logPrefix() + ' Authorization file ' + this._getAuthorizationFile() + ' have changed, reload');
 231         // Initialize _authorizedTags
 232         this._authorizedTags = this._loadAndGetAuthorizedTags();
 233       } catch (error) {
 234         logger.error(this._logPrefix() + ' Authorization file monitoring error: ' + error);
 235       }
 236     });
 237   }
 238
 239   _startStationTemplateFileMonitoring() {
 240     // eslint-disable-next-line no-unused-vars
 241     fs.watchFile(this._stationTemplateFile, (current, previous) => {
 242       try {
 243         logger.debug(this._logPrefix() + ' Template file ' + this._stationTemplateFile + ' have changed, reload');
 244         // Initialize
 245         this._initialize();
 246         this._addConfigurationKey('HeartBeatInterval', Utils.convertToInt(this._heartbeatInterval ? this._heartbeatInterval / 1000 : 0));
 247         this._addConfigurationKey('HeartbeatInterval', Utils.convertToInt(this._heartbeatInterval ? this._heartbeatInterval / 1000 : 0), false, false);
 248       } catch (error) {
 249         logger.error(this._logPrefix() + ' Charging station template file monitoring error: ' + error);
 250       }
 251     });
 252   }
 253
 254   async _startMeterValues(connectorId, interval) {
 255     if (!this._connectors[connectorId].transactionStarted) {
 256       logger.error(`${this._logPrefix()} Trying to start MeterValues on connector ID ${connectorId} with no transaction started`);
 257       return;
 258     } else if (this._connectors[connectorId].transactionStarted && !this._connectors[connectorId].transactionId) {
 259       logger.error(`${this._logPrefix()} Trying to start MeterValues on connector ID ${connectorId} with no transaction id`);
 260       return;
 261     }
 262     if (interval > 0) {
 263       this._connectors[connectorId].transactionSetInterval = setInterval(async () => {
 264         const sendMeterValues = performance.timerify(this.sendMeterValues);
 265         this._performanceObserver.observe({
 266           entryTypes: ['function'],
 267         });
 268         await sendMeterValues(connectorId, interval, this);
 269       }, interval);
 270     } else {
 271       logger.error(`${this._logPrefix()} Charging station MeterValueSampleInterval configuration set to ${interval}ms, not sending MeterValues`);
 272     }
 273   }
 274
 275   async start() {
 276     if (!this._wsConnectionUrl) {
 277       this._wsConnectionUrl = this._supervisionUrl + '/' + this._stationInfo.name;
 278     }
 279     this._wsConnection = new WebSocket(this._wsConnectionUrl, 'ocpp' + Constants.OCPP_VERSION_16);
 280     logger.info(this._logPrefix() + ' Will communicate through URL ' + this._supervisionUrl);
 281     // Monitor authorization file
 282     this._startAuthorizationFileMonitoring();
 283     // Monitor station template file
 284     this._startStationTemplateFileMonitoring();
 285     // Handle Socket incoming messages
 286     this._wsConnection.on('message', this.onMessage.bind(this));
 287     // Handle Socket error
 288     this._wsConnection.on('error', this.onError.bind(this));
 289     // Handle Socket close
 290     this._wsConnection.on('close', this.onClose.bind(this));
 291     // Handle Socket opening connection
 292     this._wsConnection.on('open', this.onOpen.bind(this));
 293     // Handle Socket ping
 294     this._wsConnection.on('ping', this.onPing.bind(this));
 295   }
 296
 297   async stop(reason = '') {
 298     // Stop heartbeat
 299     await this._stopHeartbeat();
 300     // Stop the ATG
 301     if (Utils.convertToBoolean(this._stationInfo.AutomaticTransactionGenerator.enable) &&
 302       this._automaticTransactionGeneration &&
 303       !this._automaticTransactionGeneration.timeToStop) {
 304       await this._automaticTransactionGeneration.stop(reason);
 305     } else {
 306       for (const connector in this._connectors) {
 307         if (this._connectors[connector].transactionStarted) {
 308           await this.sendStopTransaction(this._connectors[connector].transactionId, reason);
 309         }
 310       }
 311     }
 312     // eslint-disable-next-line guard-for-in
 313     for (const connector in this._connectors) {
 314       await this.sendStatusNotification(connector, 'Unavailable');
 315     }
 316     if (this._wsConnection && this._wsConnection.readyState === WebSocket.OPEN) {
 317       await this._wsConnection.close();
 318     }
 319   }
 320
 321   _reconnect(error) {
 322     logger.error(this._logPrefix() + ' Socket: abnormally closed', error);
 323     // Stop the ATG if needed
 324     if (Utils.convertToBoolean(this._stationInfo.AutomaticTransactionGenerator.enable) &&
 325       Utils.convertToBoolean(this._stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure) &&
 326       this._automaticTransactionGeneration &&
 327       !this._automaticTransactionGeneration.timeToStop) {
 328       this._automaticTransactionGeneration.stop();
 329     }
 330     // Stop heartbeat
 331     this._stopHeartbeat();
 332     if (this._autoReconnectTimeout !== 0 &&
 333       (this._autoReconnectRetryCount < this._autoReconnectMaxRetries || this._autoReconnectMaxRetries === -1)) {
 334       logger.error(`${this._logPrefix()} Socket: connection retry with timeout ${this._autoReconnectTimeout}ms`);
 335       this._autoReconnectRetryCount++;
 336       setTimeout(() => {
 337         logger.error(this._logPrefix() + ' Socket: reconnecting try #' + this._autoReconnectRetryCount);
 338         this.start();
 339       }, this._autoReconnectTimeout);
 340     } else if (this._autoReconnectTimeout !== 0 || this._autoReconnectMaxRetries !== -1) {
 341       logger.error(`${this._logPrefix()} Socket: max retries reached (${this._autoReconnectRetryCount}) or retry disabled (${this._autoReconnectTimeout})`);
 342     }
 343   }
 344
 345   onOpen() {
 346     logger.info(`${this._logPrefix()} Is connected to server through ${this._wsConnectionUrl}`);
 347     if (!this._isSocketRestart) {
 348       // Send BootNotification
 349       this.sendBootNotification();
 350     }
 351     if (this._isSocketRestart) {
 352       this._basicStartMessageSequence();
 353       if (!Utils.isEmptyArray(this._messageQueue)) {
 354         this._messageQueue.forEach((message) => {
 355           if (this._wsConnection && this._wsConnection.readyState === WebSocket.OPEN) {
 356             this._wsConnection.send(message);
 357           }
 358         });
 359       }
 360     }
 361     this._autoReconnectRetryCount = 0;
 362     this._isSocketRestart = false;
 363   }
 364
 365   onError(error) {
 366     switch (error) {
 367       case 'ECONNREFUSED':
 368         this._isSocketRestart = true;
 369         this._reconnect(error);
 370         break;
 371       default:
 372         logger.error(this._logPrefix() + ' Socket error: ' + error);
 373         break;
 374     }
 375   }
 376
 377   onClose(error) {
 378     switch (error) {
 379       case 1000: // Normal close
 380       case 1005:
 381         logger.info(this._logPrefix() + ' Socket normally closed ' + error);
 382         this._autoReconnectRetryCount = 0;
 383         break;
 384       default: // Abnormal close
 385         this._isSocketRestart = true;
 386         this._reconnect(error);
 387         break;
 388     }
 389   }
 390
 391   onPing() {
 392     logger.debug(this._logPrefix() + ' Has received a WS ping (rfc6455) from the server');
 393   }
 394
 395   async onMessage(message) {
 396     let [messageType, messageId, commandName, commandPayload, errorDetails] = [0, '', Constants.ENTITY_CHARGING_STATION, '', ''];
 397     try {
 398       // Parse the message
 399       [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(message);
 400
 401       // Check the Type of message
 402       switch (messageType) {
 403         // Incoming Message
 404         case Constants.OCPP_JSON_CALL_MESSAGE:
 405           // Process the call
 406           await this.handleRequest(messageId, commandName, commandPayload);
 407           break;
 408         // Outcome Message
 409         case Constants.OCPP_JSON_CALL_RESULT_MESSAGE:
 410           // Respond
 411           // eslint-disable-next-line no-case-declarations
 412           let responseCallback; let requestPayload;
 413           if (Utils.isIterable(this._requests[messageId])) {
 414             [responseCallback, , requestPayload] = this._requests[messageId];
 415           } else {
 416             throw new Error(`Response request for unknown message id ${messageId} is not iterable`);
 417           }
 418           if (!responseCallback) {
 419             // Error
 420             throw new Error(`Response for unknown message id ${messageId}`);
 421           }
 422           delete this._requests[messageId];
 423           responseCallback(commandName, requestPayload);
 424           break;
 425         // Error Message
 426         case Constants.OCPP_JSON_CALL_ERROR_MESSAGE:
 427           if (!this._requests[messageId]) {
 428             // Error
 429             throw new Error(`Error for unknown message id ${messageId}`);
 430           }
 431           // eslint-disable-next-line no-case-declarations
 432           let rejectCallback;
 433           if (Utils.isIterable(this._requests[messageId])) {
 434             [, rejectCallback] = this._requests[messageId];
 435           } else {
 436             throw new Error(`Error request for unknown message id ${messageId} is not iterable`);
 437           }
 438           delete this._requests[messageId];
 439           rejectCallback(new OCPPError(commandName, commandPayload, errorDetails));
 440           break;
 441         // Error
 442         default:
 443           throw new Error(`Wrong message type ${messageType}`);
 444       }
 445     } catch (error) {
 446       // Log
 447       logger.error('%s Incoming message %j processing error %s on request content %s', this._logPrefix(), message, error, this._requests[messageId]);
 448       // Send error
 449       // await this.sendError(messageId, error);
 450     }
 451   }
 452
 453   sendHeartbeat() {
 454     try {
 455       const payload = {
 456         currentTime: new Date().toISOString(),
 457       };
 458       this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'Heartbeat');
 459     } catch (error) {
 460       logger.error(this._logPrefix() + ' Send Heartbeat error: ' + error);
 461       throw error;
 462     }
 463   }
 464
 465   sendBootNotification() {
 466     try {
 467       this.sendMessage(Utils.generateUUID(), this._bootNotificationMessage, Constants.OCPP_JSON_CALL_MESSAGE, 'BootNotification');
 468     } catch (error) {
 469       logger.error(this._logPrefix() + ' Send BootNotification error: ' + error);
 470       throw error;
 471     }
 472   }
 473
 474   async sendStatusNotification(connectorId, status, errorCode = 'NoError') {
 475     try {
 476       const payload = {
 477         connectorId,
 478         errorCode,
 479         status,
 480       };
 481       await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'StatusNotification');
 482     } catch (error) {
 483       logger.error(this._logPrefix() + ' Send StatusNotification error: ' + error);
 484       throw error;
 485     }
 486   }
 487
 488   sendStatusNotificationWithTimeout(connectorId, status, errorCode = 'NoError', timeout = Constants.STATUS_NOTIFICATION_TIMEOUT) {
 489     setTimeout(() => this.sendStatusNotification(connectorId, status, errorCode), timeout);
 490   }
 491
 492   async sendStartTransaction(connectorId, idTag) {
 493     try {
 494       const payload = {
 495         connectorId,
 496         idTag,
 497         meterStart: 0,
 498         timestamp: new Date().toISOString(),
 499       };
 500       return await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'StartTransaction');
 501     } catch (error) {
 502       logger.error(this._logPrefix() + ' Send StartTransaction error: ' + error);
 503       throw error;
 504     }
 505   }
 506
 507   sendStartTransactionWithTimeout(connectorId, idTag, timeout) {
 508     setTimeout(() => this.sendStartTransaction(connectorId, idTag), timeout);
 509   }
 510
 511   async sendStopTransaction(transactionId, reason = '') {
 512     try {
 513       let payload;
 514       if (reason) {
 515         payload = {
 516           transactionId,
 517           meterStop: 0,
 518           timestamp: new Date().toISOString(),
 519           reason,
 520         };
 521       } else {
 522         payload = {
 523           transactionId,
 524           meterStop: 0,
 525           timestamp: new Date().toISOString(),
 526         };
 527       }
 528       await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'StopTransaction');
 529     } catch (error) {
 530       logger.error(this._logPrefix() + ' Send StopTransaction error: ' + error);
 531       throw error;
 532     }
 533   }
 534
 535   // eslint-disable-next-line class-methods-use-this
 536   async sendMeterValues(connectorId, interval, self, debug = false) {
 537     try {
 538       const sampledValueLcl = {
 539         timestamp: new Date().toISOString(),
 540       };
 541       const meterValuesClone = Utils.cloneJSonDocument(self._getConnector(connectorId).MeterValues);
 542       if (!Utils.isEmptyArray(meterValuesClone)) {
 543         sampledValueLcl.sampledValue = meterValuesClone;
 544       } else {
 545         sampledValueLcl.sampledValue = [meterValuesClone];
 546       }
 547       for (let index = 0; index < sampledValueLcl.sampledValue.length; index++) {
 548         const connector = self._connectors[connectorId];
 549         // SoC measurand
 550         if (sampledValueLcl.sampledValue[index].measurand && sampledValueLcl.sampledValue[index].measurand === 'SoC') {
 551           sampledValueLcl.sampledValue[index].value = !Utils.isUndefined(sampledValueLcl.sampledValue[index].value) ?
 552             sampledValueLcl.sampledValue[index].value :
 553             sampledValueLcl.sampledValue[index].value = Utils.getRandomInt(100);
 554           if (sampledValueLcl.sampledValue[index].value > 100 || debug) {
 555             logger.error(`${self._logPrefix()} MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${sampledValueLcl.sampledValue[index].value}`);
 556           }
 557         // Voltage measurand
 558         } else if (sampledValueLcl.sampledValue[index].measurand && sampledValueLcl.sampledValue[index].measurand === 'Voltage') {
 559           sampledValueLcl.sampledValue[index].value = !Utils.isUndefined(sampledValueLcl.sampledValue[index].value) ? sampledValueLcl.sampledValue[index].value : 230;
 560         // Energy.Active.Import.Register measurand (default)
 561         } else if (!sampledValueLcl.sampledValue[index].measurand || sampledValueLcl.sampledValue[index].measurand === 'Energy.Active.Import.Register') {
 562           if (Utils.isUndefined(sampledValueLcl.sampledValue[index].value)) {
 563             const measurandValue = Utils.getRandomInt(self._stationInfo.maxPower / 3600000 * interval);
 564             // Persist previous value in connector
 565             if (connector && connector.lastEnergyActiveImportRegisterValue >= 0) {
 566               connector.lastEnergyActiveImportRegisterValue += measurandValue;
 567             } else {
 568               connector.lastEnergyActiveImportRegisterValue = 0;
 569             }
 570             sampledValueLcl.sampledValue[index].value = connector.lastEnergyActiveImportRegisterValue;
 571           }
 572           logger.info(`${self._logPrefix()} MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'}: connectorId ${connectorId}, transaction ${connector.transactionId}, value ${sampledValueLcl.sampledValue[index].value}`);
 573           const maxConsumption = self._stationInfo.maxPower * 3600 / interval;
 574           if (sampledValueLcl.sampledValue[index].value > maxConsumption || debug) {
 575             logger.error(`${self._logPrefix()} MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${sampledValueLcl.sampledValue[index].value}/${maxConsumption}`);
 576           }
 577         // Unsupported measurand
 578         } else {
 579           logger.info(`${self._logPrefix()} Unsupported MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'} on connectorId ${connectorId}`);
 580         }
 581       }
 582
 583       const payload = {
 584         connectorId,
 585         transactionId: self._connectors[connectorId].transactionId,
 586         meterValue: [sampledValueLcl],
 587       };
 588       await self.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'MeterValues');
 589     } catch (error) {
 590       logger.error(self._logPrefix() + ' Send MeterValues error: ' + error);
 591       throw error;
 592     }
 593   }
 594
 595   sendError(messageId, err) {
 596     // Check exception: only OCPP error are accepted
 597     const error = err instanceof OCPPError ? err : new OCPPError(Constants.OCPP_ERROR_INTERNAL_ERROR, err.message);
 598     // Send error
 599     return this.sendMessage(messageId, error, Constants.OCPP_JSON_CALL_ERROR_MESSAGE);
 600   }
 601
 602   sendMessage(messageId, command, messageType = Constants.OCPP_JSON_CALL_RESULT_MESSAGE, commandName = '') {
 603     // Send a message through wsConnection
 604     const self = this;
 605     // Create a promise
 606     return new Promise((resolve, reject) => {
 607       let messageToSend;
 608       // Type of message
 609       switch (messageType) {
 610         // Request
 611         case Constants.OCPP_JSON_CALL_MESSAGE:
 612           this._statistics.addMessage(commandName);
 613           // Build request
 614           this._requests[messageId] = [responseCallback, rejectCallback, command];
 615           messageToSend = JSON.stringify([messageType, messageId, commandName, command]);
 616           break;
 617         // Response
 618         case Constants.OCPP_JSON_CALL_RESULT_MESSAGE:
 619           this._statistics.addMessage(commandName);
 620           // Build response
 621           messageToSend = JSON.stringify([messageType, messageId, command]);
 622           break;
 623         // Error Message
 624         case Constants.OCPP_JSON_CALL_ERROR_MESSAGE:
 625           // Build Message
 626           this._statistics.addMessage(`Error ${command.code ? command.code : Constants.OCPP_ERROR_GENERIC_ERROR} on ${commandName || ''}`);
 627           messageToSend = JSON.stringify([messageType, messageId, command.code ? command.code : Constants.OCPP_ERROR_GENERIC_ERROR, command.message ? command.message : '', command.details ? command.details : {}]);
 628           break;
 629       }
 630       // Check if wsConnection is ready
 631       if (this._wsConnection && this._wsConnection.readyState === WebSocket.OPEN) {
 632         // Yes: Send Message
 633         this._wsConnection.send(messageToSend);
 634       } else {
 635         // Buffer message until connection is back
 636         this._messageQueue.push(messageToSend);
 637       }
 638       // Request?
 639       if (messageType !== Constants.OCPP_JSON_CALL_MESSAGE) {
 640         // Yes: send Ok
 641         resolve();
 642       } else if (this._wsConnection && this._wsConnection.readyState === WebSocket.OPEN) {
 643         // Send timeout in case connection is open otherwise wait for ever
 644         // FIXME: Handle message on timeout
 645         setTimeout(() => rejectCallback(`Timeout for message ${messageId}`), Constants.OCPP_SOCKET_TIMEOUT);
 646       }
 647
 648       // Function that will receive the request's response
 649       function responseCallback(payload, requestPayload) {
 650         self._statistics.addMessage(commandName, true);
 651         const responseCallbackFn = 'handleResponse' + commandName;
 652         if (typeof self[responseCallbackFn] === 'function') {
 653           self[responseCallbackFn](payload, requestPayload, self);
 654         } else {
 655           logger.debug(self._logPrefix() + ' Trying to call an undefined response callback function: ' + responseCallbackFn);
 656         }
 657         // Send the response
 658         resolve(payload);
 659       }
 660
 661       // Function that will receive the request's rejection
 662       function rejectCallback(reason) {
 663         self._statistics.addMessage(`Error ${command.code ? command.code : Constants.OCPP_ERROR_GENERIC_ERROR} on ${commandName || ''}`, true);
 664         // Build Exception
 665         // eslint-disable-next-line no-empty-function
 666         self._requests[messageId] = [() => { }, () => { }, '']; // Properly format the request
 667         const error = reason instanceof OCPPError ? reason : new Error(reason);
 668         // Send error
 669         reject(error);
 670       }
 671     });
 672   }
 673
 674   handleResponseBootNotification(payload) {
 675     if (payload.status === 'Accepted') {
 676       this._heartbeatInterval = payload.interval * 1000;
 677       this._addConfigurationKey('HeartBeatInterval', Utils.convertToInt(payload.interval));
 678       this._addConfigurationKey('HeartbeatInterval', Utils.convertToInt(payload.interval), false, false);
 679       this._basicStartMessageSequence();
 680     } else if (payload.status === 'Pending') {
 681       logger.info(this._logPrefix() + ' Charging station pending on the central server');
 682     } else {
 683       logger.info(this._logPrefix() + ' Charging station rejected by the central server');
 684     }
 685   }
 686
 687   _initTransactionOnConnector(connectorId) {
 688     this._connectors[connectorId].transactionStarted = false;
 689     this._connectors[connectorId].transactionId = null;
 690     this._connectors[connectorId].idTag = null;
 691     this._connectors[connectorId].lastEnergyActiveImportRegisterValue = -1;
 692   }
 693
 694   _resetTransactionOnConnector(connectorId) {
 695     this._initTransactionOnConnector(connectorId);
 696     if (this._connectors[connectorId].transactionSetInterval) {
 697       clearInterval(this._connectors[connectorId].transactionSetInterval);
 698     }
 699   }
 700
 701   handleResponseStartTransaction(payload, requestPayload) {
 702     if (this._connectors[requestPayload.connectorId].transactionStarted) {
 703       logger.debug(this._logPrefix() + ' Try to start a transaction on an already used connector ' + requestPayload.connectorId + ': %s', this._connectors[requestPayload.connectorId]);
 704       return;
 705     }
 706
 707     let transactionConnectorId;
 708     for (const connector in this._connectors) {
 709       if (Utils.convertToInt(connector) === Utils.convertToInt(requestPayload.connectorId)) {
 710         transactionConnectorId = connector;
 711         break;
 712       }
 713     }
 714     if (!transactionConnectorId) {
 715       logger.error(this._logPrefix() + ' Try to start a transaction on a non existing connector Id ' + requestPayload.connectorId);
 716       return;
 717     }
 718     if (payload.idTagInfo && payload.idTagInfo.status === 'Accepted') {
 719       this._connectors[transactionConnectorId].transactionStarted = true;
 720       this._connectors[transactionConnectorId].transactionId = payload.transactionId;
 721       this._connectors[transactionConnectorId].idTag = requestPayload.idTag;
 722       this._connectors[transactionConnectorId].lastEnergyActiveImportRegisterValue = 0;
 723       this.sendStatusNotification(requestPayload.connectorId, 'Charging');
 724       logger.info(this._logPrefix() + ' Transaction ' + payload.transactionId + ' STARTED on ' + this._stationInfo.name + '#' + requestPayload.connectorId + ' for idTag ' + requestPayload.idTag);
 725       const configuredMeterValueSampleInterval = this._getConfigurationKey('MeterValueSampleInterval');
 726       this._startMeterValues(requestPayload.connectorId,
 727         configuredMeterValueSampleInterval ? configuredMeterValueSampleInterval.value * 1000 : 60000);
 728     } else {
 729       logger.error(this._logPrefix() + ' Starting transaction id ' + payload.transactionId + ' REJECTED with status ' + payload.idTagInfo.status + ', idTag ' + requestPayload.idTag);
 730       this._resetTransactionOnConnector(transactionConnectorId);
 731       this.sendStatusNotification(requestPayload.connectorId, 'Available');
 732     }
 733   }
 734
 735   handleResponseStopTransaction(payload, requestPayload) {
 736     let transactionConnectorId;
 737     for (const connector in this._connectors) {
 738       if (this._connectors[connector].transactionId === requestPayload.transactionId) {
 739         transactionConnectorId = connector;
 740         break;
 741       }
 742     }
 743     if (!transactionConnectorId) {
 744       logger.error(this._logPrefix() + ' Try to stop a non existing transaction ' + requestPayload.transactionId);
 745       return;
 746     }
 747     if (payload.idTagInfo && payload.idTagInfo.status === 'Accepted') {
 748       this.sendStatusNotification(transactionConnectorId, 'Available');
 749       logger.info(this._logPrefix() + ' Transaction ' + requestPayload.transactionId + ' STOPPED on ' + this._stationInfo.name + '#' + transactionConnectorId);
 750       this._resetTransactionOnConnector(transactionConnectorId);
 751     } else {
 752       logger.error(this._logPrefix() + ' Stopping transaction id ' + requestPayload.transactionId + ' REJECTED with status ' + payload.idTagInfo.status);
 753     }
 754   }
 755
 756   handleResponseStatusNotification(payload, requestPayload) {
 757     logger.debug(this._logPrefix() + ' Status notification response received: %j to StatusNotification request: %j', payload, requestPayload);
 758   }
 759
 760   handleResponseMeterValues(payload, requestPayload) {
 761     logger.debug(this._logPrefix() + ' MeterValues response received: %j to MeterValues request: %j', payload, requestPayload);
 762   }
 763
 764   handleResponseHeartbeat(payload, requestPayload) {
 765     logger.debug(this._logPrefix() + ' Heartbeat response received: %j to Heartbeat request: %j', payload, requestPayload);
 766   }
 767
 768   async handleRequest(messageId, commandName, commandPayload) {
 769     let result;
 770     this._statistics.addMessage(commandName, true);
 771     // Call
 772     if (typeof this['handle' + commandName] === 'function') {
 773       try {
 774         // Call the method
 775         result = await this['handle' + commandName](commandPayload);
 776       } catch (error) {
 777         // Log
 778         logger.error(this._logPrefix() + ' Handle request error: ' + error);
 779         // Send back response to inform backend
 780         await this.sendError(messageId, error);
 781       }
 782     } else {
 783       // Throw exception
 784       await this.sendError(messageId, new OCPPError(Constants.OCPP_ERROR_NOT_IMPLEMENTED, 'Not implemented', {}));
 785       throw new Error(`${commandName} is not implemented ${JSON.stringify(commandPayload, null, ' ')}`);
 786     }
 787     // Send response
 788     await this.sendMessage(messageId, result, Constants.OCPP_JSON_CALL_RESULT_MESSAGE);
 789   }
 790
 791   async handleReset(commandPayload) {
 792     // Simulate charging station restart
 793     setImmediate(async () => {
 794       await this.stop(commandPayload.type + 'Reset');
 795       await Utils.sleep(this._stationInfo.resetTime);
 796       await this.start();
 797     });
 798     logger.info(`${this._logPrefix()} ${commandPayload.type} reset command received, simulating it. The station will be back online in ${this._stationInfo.resetTime}ms`);
 799     return Constants.OCPP_RESPONSE_ACCEPTED;
 800   }
 801
 802   _getConfigurationKey(key) {
 803     return this._configuration.configurationKey.find((configElement) => configElement.key === key);
 804   }
 805
 806   _addConfigurationKey(key, value, readonly = false, visible = true, reboot = false) {
 807     const keyFound = this._getConfigurationKey(key);
 808     if (!keyFound) {
 809       this._configuration.configurationKey.push({
 810         key,
 811         readonly,
 812         value,
 813         visible,
 814         reboot,
 815       });
 816     }
 817   }
 818
 819   _setConfigurationKeyValue(key, value) {
 820     const keyFound = this._getConfigurationKey(key);
 821     if (keyFound) {
 822       const keyIndex = this._configuration.configurationKey.indexOf(keyFound);
 823       this._configuration.configurationKey[keyIndex].value = value;
 824     }
 825   }
 826
 827   async handleGetConfiguration(commandPayload) {
 828     const configurationKey = [];
 829     const unknownKey = [];
 830     if (Utils.isEmptyArray(commandPayload.key)) {
 831       for (const configuration of this._configuration.configurationKey) {
 832         if (Utils.isUndefined(configuration.visible)) {
 833           configuration.visible = true;
 834         } else {
 835           configuration.visible = Utils.convertToBoolean(configuration.visible);
 836         }
 837         if (!configuration.visible) {
 838           continue;
 839         }
 840         configurationKey.push({
 841           key: configuration.key,
 842           readonly: configuration.readonly,
 843           value: configuration.value,
 844         });
 845       }
 846     } else {
 847       for (const configurationKey of commandPayload.key) {
 848         const keyFound = this._getConfigurationKey(configurationKey);
 849         if (keyFound) {
 850           if (Utils.isUndefined(keyFound.visible)) {
 851             keyFound.visible = true;
 852           } else {
 853             keyFound.visible = Utils.convertToBoolean(configurationKey.visible);
 854           }
 855           if (!keyFound.visible) {
 856             continue;
 857           }
 858           configurationKey.push({
 859             key: keyFound.key,
 860             readonly: keyFound.readonly,
 861             value: keyFound.value,
 862           });
 863         } else {
 864           unknownKey.push(configurationKey);
 865         }
 866       }
 867     }
 868     return {
 869       configurationKey,
 870       unknownKey,
 871     };
 872   }
 873
 874   async handleChangeConfiguration(commandPayload) {
 875     const keyToChange = this._getConfigurationKey(commandPayload.key);
 876     if (!keyToChange) {
 877       return {status: Constants.OCPP_ERROR_NOT_SUPPORTED};
 878     } else if (keyToChange && Utils.convertToBoolean(keyToChange.readonly)) {
 879       return Constants.OCPP_RESPONSE_REJECTED;
 880     } else if (keyToChange && !Utils.convertToBoolean(keyToChange.readonly)) {
 881       const keyIndex = this._configuration.configurationKey.indexOf(keyToChange);
 882       this._configuration.configurationKey[keyIndex].value = commandPayload.value;
 883       let triggerHeartbeatRestart = false;
 884       if (keyToChange.key === 'HeartBeatInterval') {
 885         this._setConfigurationKeyValue('HeartbeatInterval', commandPayload.value);
 886         triggerHeartbeatRestart = true;
 887       }
 888       if (keyToChange.key === 'HeartbeatInterval') {
 889         this._setConfigurationKeyValue('HeartBeatInterval', commandPayload.value);
 890         triggerHeartbeatRestart = true;
 891       }
 892       if (triggerHeartbeatRestart) {
 893         this._heartbeatInterval = Utils.convertToInt(commandPayload.value) * 1000;
 894         // Stop heartbeat
 895         this._stopHeartbeat();
 896         // Start heartbeat
 897         this._startHeartbeat(this);
 898       }
 899       if (Utils.convertToBoolean(keyToChange.reboot)) {
 900         return Constants.OCPP_RESPONSE_REBOOT_REQUIRED;
 901       }
 902       return Constants.OCPP_RESPONSE_ACCEPTED;
 903     }
 904   }
 905
 906   async handleRemoteStartTransaction(commandPayload) {
 907     const transactionConnectorID = commandPayload.connectorId ? commandPayload.connectorId : '1';
 908     if (this.hasAuthorizedTags() && this._getLocalAuthListEnabled() && this._getAuthorizeRemoteTxRequests()) {
 909       // Check if authorized
 910       if (this._authorizedTags.find((value) => value === commandPayload.idTag)) {
 911         // Authorization successful start transaction
 912         this.sendStartTransactionWithTimeout(transactionConnectorID, commandPayload.idTag, Constants.START_TRANSACTION_TIMEOUT);
 913         logger.debug(this._logPrefix() + ' Transaction remotely STARTED on ' + this._stationInfo.name + '#' + transactionConnectorID + ' for idTag ' + commandPayload.idTag);
 914         return Constants.OCPP_RESPONSE_ACCEPTED;
 915       }
 916       logger.error(this._logPrefix() + ' Remote starting transaction REJECTED with status ' + commandPayload.idTagInfo.status + ', idTag ' + commandPayload.idTag);
 917       return Constants.OCPP_RESPONSE_REJECTED;
 918     }
 919     // No local authorization check required => start transaction
 920     this.sendStartTransactionWithTimeout(transactionConnectorID, commandPayload.idTag, Constants.START_TRANSACTION_TIMEOUT);
 921     logger.debug(this._logPrefix() + ' Transaction remotely STARTED on ' + this._stationInfo.name + '#' + transactionConnectorID + ' for idTag ' + commandPayload.idTag);
 922     return Constants.OCPP_RESPONSE_ACCEPTED;
 923   }
 924
 925   async handleRemoteStopTransaction(commandPayload) {
 926     for (const connector in this._connectors) {
 927       if (this._connectors[connector].transactionId === commandPayload.transactionId) {
 928         this.sendStopTransaction(commandPayload.transactionId);
 929         return Constants.OCPP_RESPONSE_ACCEPTED;
 930       }
 931     }
 932     logger.info(this._logPrefix() + ' Try to stop remotely a non existing transaction ' + commandPayload.transactionId);
 933     return Constants.OCPP_RESPONSE_REJECTED;
 934   }
 935 }
 936
 937 module.exports = ChargingStation;