import { ChargePointStatus } from '../types/ocpp/1.6/ChargePointStatus';
import ChargingStationInfo from '../types/ChargingStationInfo';
import Configuration from '../utils/Configuration';
-import Constants from '../utils/Constants.js';
+import Constants from '../utils/Constants';
import ElectricUtils from '../utils/ElectricUtils';
import MeasurandValues from '../types/MeasurandValues';
-import OCPPError from './OcppError.js';
+import OCPPError from './OcppError';
+import Requests from '../types/ocpp/1.6/Requests';
import Statistics from '../utils/Statistics';
import Utils from '../utils/Utils';
import WebSocket from 'ws';
private _autoReconnectRetryCount: number;
private _autoReconnectMaxRetries: number;
private _autoReconnectTimeout: number;
- private _requests: { [id: string]: [(payload?, requestPayload?) => void, (error?: OCPPError) => void, object] };
- private _messageQueue: any[];
+ private _requests: Requests;
+ private _messageQueue: string[];
private _automaticTransactionGeneration: AutomaticTransactionGenerator;
private _authorizedTags: string[];
private _heartbeatInterval: number;
constructor(index: number, stationTemplateFile: string) {
this._index = index;
this._stationTemplateFile = stationTemplateFile;
- this._connectors = {};
+ this._connectors = {} as Connectors;
this._initialize();
this._hasStopped = false;
this._autoReconnectMaxRetries = Configuration.getAutoReconnectMaxRetries(); // -1 for unlimited
this._autoReconnectTimeout = Configuration.getAutoReconnectTimeout() * 1000; // Ms, zero for disabling
- this._requests = {};
- this._messageQueue = [];
+ this._requests = {} as Requests;
+ this._messageQueue = [] as string[];
this._authorizedTags = this._loadAndGetAuthorizedTags();
}
}
_reconnect(error): void {
- logger.error(this._logPrefix() + ' Socket: abnormally closed %j', error);
+ logger.error(this._logPrefix() + ' Socket: abnormally closed: %j', error);
// Stop the ATG if needed
if (this._stationInfo.AutomaticTransactionGenerator.enable &&
this._stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
if (this._hasSocketRestarted) {
this._startMessageSequence();
if (!Utils.isEmptyArray(this._messageQueue)) {
- this._messageQueue.forEach((message) => {
+ this._messageQueue.forEach((message, index) => {
if (this._wsConnection && this._wsConnection.readyState === WebSocket.OPEN) {
+ this._messageQueue.splice(index, 1);
this._wsConnection.send(message);
}
});
this._hasSocketRestarted = false;
}
- onError(error): void {
- switch (error) {
+ onError(errorEvent): void {
+ switch (errorEvent) {
case 'ECONNREFUSED':
this._hasSocketRestarted = true;
- this._reconnect(error);
+ this._reconnect(errorEvent);
break;
default:
- logger.error(this._logPrefix() + ' Socket error: %j', error);
+ logger.error(this._logPrefix() + ' Socket error: %j', errorEvent);
break;
}
}
- onClose(error): void {
- switch (error) {
+ onClose(closeEvent): void {
+ switch (closeEvent) {
case 1000: // Normal close
case 1005:
- logger.info(this._logPrefix() + ' Socket normally closed %j', error);
+ logger.info(this._logPrefix() + ' Socket normally closed: %j', closeEvent);
this._autoReconnectRetryCount = 0;
break;
default: // Abnormal close
this._hasSocketRestarted = true;
- this._reconnect(error);
+ this._reconnect(closeEvent);
break;
}
}
logger.debug(this._logPrefix() + ' Has received a WS ping (rfc6455) from the server');
}
- async onMessage(message): Promise<void> {
+ async onMessage(messageEvent): Promise<void> {
let [messageType, messageId, commandName, commandPayload, errorDetails] = [0, '', Constants.ENTITY_CHARGING_STATION, '', ''];
try {
// Parse the message
- [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(message);
+ [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent);
// Check the Type of message
switch (messageType) {
}
} catch (error) {
// Log
- logger.error('%s Incoming message %j processing error %s on request content type %s', this._logPrefix(), message, error, this._requests[messageId]);
+ logger.error('%s Incoming message %j processing error %s on request content type %s', this._logPrefix(), messageEvent, error, this._requests[messageId]);
// Send error
await this.sendError(messageId, error, commandName);
}
if (self.getEnableStatistics()) {
self._statistics.addMessage(commandName, messageType);
}
- logger.debug(`${self._logPrefix()} Error %j occurred when calling command %s with parameters %j`, error, commandName, commandParams);
+ logger.debug(`${self._logPrefix()} Error: %j occurred when calling command %s with parameters: %j`, error, commandName, commandParams);
// Build Exception
// eslint-disable-next-line no-empty-function
self._requests[messageId] = [() => { }, () => { }, {}]; // Properly format the request
handleResponseStartTransaction(payload: StartTransactionResponse, requestPayload): void {
const connectorId = Utils.convertToInt(requestPayload.connectorId);
if (this.getConnector(connectorId).transactionStarted) {
- logger.debug(this._logPrefix() + ' Try to start a transaction on an already used connector ' + connectorId.toString() + ': %j', this.getConnector(connectorId));
+ logger.debug(this._logPrefix() + ' Trying to start a transaction on an already used connector ' + connectorId.toString() + ': %j', this.getConnector(connectorId));
return;
}
}
}
if (!transactionConnectorId) {
- logger.error(this._logPrefix() + ' Try to start a transaction on a non existing connector Id ' + connectorId.toString());
+ logger.error(this._logPrefix() + ' Trying to start a transaction on a non existing connector Id ' + connectorId.toString());
return;
}
if (payload.idTagInfo?.status === AuthorizationStatus.ACCEPTED) {
}
}
if (!transactionConnectorId) {
- logger.error(this._logPrefix() + ' Try to stop a non existing transaction ' + requestPayload.transactionId);
+ logger.error(this._logPrefix() + ' Trying to stop a non existing transaction ' + requestPayload.transactionId);
return;
}
if (payload.idTagInfo?.status === AuthorizationStatus.ACCEPTED) {
async handleRequestUnlockConnector(commandPayload): Promise<UnlockResponse> {
const connectorId = Utils.convertToInt(commandPayload.connectorId);
if (connectorId === 0) {
- logger.error(this._logPrefix() + ' Try to unlock connector ' + connectorId.toString());
+ logger.error(this._logPrefix() + ' Trying to unlock connector ' + connectorId.toString());
return Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
}
if (this.getConnector(connectorId).transactionStarted) {
return Constants.OCPP_RESPONSE_ACCEPTED;
}
}
- logger.info(this._logPrefix() + ' Try to stop remotely a non existing transaction ' + transactionId.toString());
+ logger.info(this._logPrefix() + ' Trying to remote stop a non existing transaction ' + transactionId.toString());
return Constants.OCPP_RESPONSE_REJECTED;
}
}