import Connectors, { Connector } from '../types/Connectors';
import { MeterValue, MeterValueLocation, MeterValueMeasurand, MeterValuePhase, MeterValueUnit, MeterValuesRequest, MeterValuesResponse, SampledValue } from '../types/ocpp/1.6/MeterValues';
import { PerformanceObserver, performance } from 'perf_hooks';
-import Requests, { BootNotificationRequest, ChangeConfigurationRequest, GetConfigurationRequest, HeartbeatRequest, RemoteStartTransactionRequest, RemoteStopTransactionRequest, ResetRequest, SetChargingProfileRequest, StatusNotificationRequest, UnlockConnectorRequest } from '../types/ocpp/1.6/Requests';
+import Requests, { BootNotificationRequest, ChangeConfigurationRequest, GetConfigurationRequest, HeartbeatRequest, IncomingRequest, IncomingRequestCommand, RemoteStartTransactionRequest, RemoteStopTransactionRequest, Request, RequestCommand, ResetRequest, SetChargingProfileRequest, StatusNotificationRequest, UnlockConnectorRequest } from '../types/ocpp/1.6/Requests';
import WebSocket, { MessageEvent } from 'ws';
import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
}
async onMessage(messageEvent: MessageEvent): Promise<void> {
- let [messageType, messageId, commandName, commandPayload, errorDetails] = [0, '', Constants.ENTITY_CHARGING_STATION, '', ''];
+ let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, '', ''];
+ let responseCallback: (payload?, requestPayload?) => void;
+ let rejectCallback: (error: OCPPError) => void;
+ let requestPayload: Record<string, unknown>;
+ let errMsg: string;
try {
// Parse the message
- [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent.toString());
+ [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent.toString()) as IncomingRequest;
// Check the Type of message
switch (messageType) {
// Outcome Message
case MessageType.CALL_RESULT_MESSAGE:
// Respond
- // eslint-disable-next-line no-case-declarations
- let responseCallback; let requestPayload;
if (Utils.isIterable(this._requests[messageId])) {
[responseCallback, , requestPayload] = this._requests[messageId];
} else {
// Error
throw new Error(`Error request for unknown message id ${messageId}`);
}
- // eslint-disable-next-line no-case-declarations
- let rejectCallback;
if (Utils.isIterable(this._requests[messageId])) {
[, rejectCallback] = this._requests[messageId];
} else {
break;
// Error
default:
- // eslint-disable-next-line no-case-declarations
- const errMsg = `${this._logPrefix()} Wrong message type ${messageType}`;
+ errMsg = `${this._logPrefix()} Wrong message type ${messageType}`;
logger.error(errMsg);
throw new Error(errMsg);
}
} catch (error) {
// Log
- logger.error('%s Incoming message %j processing error %s on request content type %s', this._logPrefix(), messageEvent, error, this._requests[messageId]);
+ logger.error('%s Incoming message %j processing error %j on request content type %j', this._logPrefix(), messageEvent, error, this._requests[messageId]);
// Send error
messageType !== MessageType.CALL_ERROR_MESSAGE && await this.sendError(messageId, error, commandName);
}
async sendHeartbeat(): Promise<void> {
try {
const payload: HeartbeatRequest = {};
- await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'Heartbeat');
+ await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.HEARTBEAT);
} catch (error) {
- logger.error(this._logPrefix() + ' Send Heartbeat error: %j', error);
- throw error;
+ this.handleRequestError(RequestCommand.HEARTBEAT, error);
}
}
async sendBootNotification(): Promise<BootNotificationResponse> {
try {
- return await this.sendMessage(Utils.generateUUID(), this._bootNotificationRequest, MessageType.CALL_MESSAGE, 'BootNotification') as BootNotificationResponse;
+ return await this.sendMessage(Utils.generateUUID(), this._bootNotificationRequest, MessageType.CALL_MESSAGE, RequestCommand.BOOT_NOTIFICATION) as BootNotificationResponse;
} catch (error) {
- logger.error(this._logPrefix() + ' Send BootNotification error: %j', error);
- throw error;
+ this.handleRequestError(RequestCommand.BOOT_NOTIFICATION, error);
}
}
errorCode,
status,
};
- await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'StatusNotification');
+ await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.STATUS_NOTIFICATION);
} catch (error) {
- logger.error(this._logPrefix() + ' Send StatusNotification error: %j', error);
- throw error;
+ this.handleRequestError(RequestCommand.STATUS_NOTIFICATION, error);
}
}
meterStart: 0,
timestamp: new Date().toISOString(),
};
- return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'StartTransaction') as StartTransactionResponse;
+ return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.START_TRANSACTION) as StartTransactionResponse;
} catch (error) {
- logger.error(this._logPrefix() + ' Send StartTransaction error: %j', error);
- throw error;
+ this.handleRequestError(RequestCommand.START_TRANSACTION, error);
}
}
timestamp: new Date().toISOString(),
...reason && { reason },
};
- return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'StopTransaction') as StartTransactionResponse;
+ return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.STOP_TRANSACTION) as StartTransactionResponse;
} catch (error) {
- logger.error(this._logPrefix() + ' Send StopTransaction error: %j', error);
- throw error;
+ this.handleRequestError(RequestCommand.STOP_TRANSACTION, error);
}
}
transactionId: self.getConnector(connectorId).transactionId,
meterValue: meterValue,
};
- await self.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, 'MeterValues');
+ await self.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.METERVALUES);
} catch (error) {
- logger.error(self._logPrefix() + ' Send MeterValues error: %j', error);
- throw error;
+ this.handleRequestError(RequestCommand.METERVALUES, error);
}
}
- async sendError(messageId: string, err: Error | OCPPError, commandName: string): Promise<unknown> {
+ async sendError(messageId: string, err: Error | OCPPError, commandName: RequestCommand | IncomingRequestCommand): Promise<unknown> {
// Check exception type: only OCPP error are accepted
const error = err instanceof OCPPError ? err : new OCPPError(ErrorType.INTERNAL_ERROR, err.message, err.stack && err.stack);
// Send error
return this.sendMessage(messageId, error, MessageType.CALL_ERROR_MESSAGE, commandName);
}
- async sendMessage(messageId: string, commandParams, messageType = MessageType.CALL_RESULT_MESSAGE, commandName: string): Promise<any> {
+ async sendMessage(messageId: string, commandParams, messageType = MessageType.CALL_RESULT_MESSAGE, commandName: RequestCommand | IncomingRequestCommand): Promise<any> {
// eslint-disable-next-line @typescript-eslint/no-this-alias
const self = this;
// Send a message through wsConnection
return new Promise((resolve: (value?: any | PromiseLike<any>) => void, reject: (reason?: any) => void) => {
- let messageToSend;
+ let messageToSend: string;
// Type of message
switch (messageType) {
// Request
case MessageType.CALL_MESSAGE:
// Build request
- this._requests[messageId] = [responseCallback, rejectCallback, commandParams];
+ this._requests[messageId] = [responseCallback, rejectCallback, commandParams] as Request;
messageToSend = JSON.stringify([messageType, messageId, commandName, commandParams]);
break;
// Response
break;
}
// Check if wsConnection opened and charging station registered
- if (this._isWebSocketOpen() && (this._isRegistered() || commandName === 'BootNotification')) {
+ if (this._isWebSocketOpen() && (this._isRegistered() || commandName === RequestCommand.BOOT_NOTIFICATION)) {
if (this.getEnableStatistics()) {
this._statistics.addMessage(commandName, messageType);
}
// Handle dups in buffer
for (const message of this._messageQueue) {
// Same message
- if (JSON.stringify(messageToSend) === JSON.stringify(message)) {
+ if (messageToSend === message) {
dups = true;
break;
}
self._statistics.addMessage(commandName, messageType);
}
// Send the response
- await self.handleResponse(commandName, payload, requestPayload);
+ await self.handleResponse(commandName as RequestCommand, payload, requestPayload);
resolve(payload);
}
});
}
- async handleResponse(commandName: string, payload, requestPayload): Promise<void> {
+ async handleResponse(commandName: RequestCommand, payload, requestPayload): Promise<void> {
const responseCallbackFn = 'handleResponse' + commandName;
if (typeof this[responseCallbackFn] === 'function') {
await this[responseCallbackFn](payload, requestPayload);
logger.debug(this._logPrefix() + ' Heartbeat response received: %j to Heartbeat request: %j', payload, requestPayload);
}
- async handleRequest(messageId: string, commandName: string, commandPayload): Promise<void> {
+ async handleRequest(messageId: string, commandName: IncomingRequestCommand, commandPayload): Promise<void> {
let response;
// Call
if (typeof this['handleRequest' + commandName] === 'function') {
logger.info(this._logPrefix() + ' Trying to remote stop a non existing transaction ' + transactionId.toString());
return Constants.OCPP_RESPONSE_REJECTED;
}
+
+ private handleRequestError(commandName: RequestCommand, error: Error) {
+ logger.error(this._logPrefix() + ' Send ' + commandName + ' error: %j', error);
+ throw error;
+ }
}