src/charging-station/ocpp/OCPPRequestService.ts

   1 import { AuthorizeResponse, StartTransactionResponse, StopTransactionReason, StopTransactionResponse } from '../../types/ocpp/Transaction';
   2 import { DiagnosticsStatus, IncomingRequestCommand, RequestCommand, SendParams } from '../../types/ocpp/Requests';
   3
   4 import { BootNotificationResponse } from '../../types/ocpp/Responses';
   5 import { ChargePointErrorCode } from '../../types/ocpp/ChargePointErrorCode';
   6 import { ChargePointStatus } from '../../types/ocpp/ChargePointStatus';
   7 import ChargingStation from '../ChargingStation';
   8 import Constants from '../../utils/Constants';
   9 import { ErrorType } from '../../types/ocpp/ErrorType';
  10 import { MessageType } from '../../types/ocpp/MessageType';
  11 import { MeterValue } from '../../types/ocpp/MeterValues';
  12 import OCPPError from '../../exception/OCPPError';
  13 import OCPPResponseService from './OCPPResponseService';
  14 import PerformanceStatistics from '../../performance/PerformanceStatistics';
  15 import Utils from '../../utils/Utils';
  16 import logger from '../../utils/Logger';
  17
  18 export default abstract class OCPPRequestService {
  19   public chargingStation: ChargingStation;
  20   protected ocppResponseService: OCPPResponseService;
  21
  22   constructor(chargingStation: ChargingStation, ocppResponseService: OCPPResponseService) {
  23     this.chargingStation = chargingStation;
  24     this.ocppResponseService = ocppResponseService;
  25   }
  26
  27   public async sendMessage(messageId: string, messageData: any, messageType: MessageType, commandName: RequestCommand | IncomingRequestCommand,
  28       params: SendParams = {
  29         skipBufferingOnError: false,
  30         triggerMessage: false
  31       }): Promise<unknown> {
  32     if (this.chargingStation.isInRejectedState() || (this.chargingStation.isInPendingState() && !params.triggerMessage)) {
  33       throw new OCPPError(ErrorType.SECURITY_ERROR, 'Cannot send command payload if the charging station is not in accepted state', commandName);
  34     } else if (this.chargingStation.isInAcceptedState() || (this.chargingStation.isInPendingState() && params.triggerMessage)) {
  35       // eslint-disable-next-line @typescript-eslint/no-this-alias
  36       const self = this;
  37       // Send a message through wsConnection
  38       return Utils.promiseWithTimeout(new Promise((resolve, reject) => {
  39         const messageToSend = this.buildMessageToSend(messageId, messageData, messageType, commandName, responseCallback, rejectCallback);
  40         if (this.chargingStation.getEnableStatistics()) {
  41           this.chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType);
  42         }
  43         // Check if wsConnection opened
  44         if (this.chargingStation.isWebSocketConnectionOpened()) {
  45           // Yes: Send Message
  46           const beginId = PerformanceStatistics.beginMeasure(commandName);
  47           // FIXME: Handle sending error
  48           this.chargingStation.wsConnection.send(messageToSend);
  49           PerformanceStatistics.endMeasure(commandName, beginId);
  50         } else if (!params.skipBufferingOnError) {
  51           // Buffer it
  52           this.chargingStation.bufferMessage(messageToSend);
  53           const ocppError = new OCPPError(ErrorType.GENERIC_ERROR, `WebSocket closed for buffered message id '${messageId}' with content '${messageToSend}'`, messageData?.details ?? {});
  54           if (messageType === MessageType.CALL_MESSAGE) {
  55             // Reject it but keep the request in the cache
  56             return reject(ocppError);
  57           }
  58           return rejectCallback(ocppError, false);
  59         } else {
  60           // Reject it
  61           return rejectCallback(new OCPPError(ErrorType.GENERIC_ERROR, `WebSocket closed for non buffered message id '${messageId}' with content '${messageToSend}'`, messageData?.details ?? {}), false);
  62         }
  63         // Response?
  64         if (messageType !== MessageType.CALL_MESSAGE) {
  65           // Yes: send Ok
  66           return resolve(messageData);
  67         }
  68
  69         /**
  70          * Function that will receive the request's response
  71          *
  72          * @param payload
  73          * @param requestPayload
  74          */
  75         async function responseCallback(payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>): Promise<void> {
  76           if (self.chargingStation.getEnableStatistics()) {
  77             self.chargingStation.performanceStatistics.addRequestStatistic(commandName, MessageType.CALL_RESULT_MESSAGE);
  78           }
  79           // Handle the request's response
  80           try {
  81             await self.ocppResponseService.handleResponse(commandName as RequestCommand, payload, requestPayload);
  82             resolve(payload);
  83           } catch (error) {
  84             reject(error);
  85             throw error;
  86           } finally {
  87             self.chargingStation.requests.delete(messageId);
  88           }
  89         }
  90
  91         /**
  92          * Function that will receive the request's error response
  93          *
  94          * @param error
  95          * @param requestStatistic
  96          */
  97         function rejectCallback(error: OCPPError, requestStatistic = true): void {
  98           if (requestStatistic && self.chargingStation.getEnableStatistics()) {
  99             self.chargingStation.performanceStatistics.addRequestStatistic(commandName, MessageType.CALL_ERROR_MESSAGE);
 100           }
 101           logger.error(`${self.chargingStation.logPrefix()} Error %j occurred when calling command %s with message data %j`, error, commandName, messageData);
 102           self.chargingStation.requests.delete(messageId);
 103           reject(error);
 104         }
 105       }), Constants.OCPP_WEBSOCKET_TIMEOUT, new OCPPError(ErrorType.GENERIC_ERROR, `Timeout for message id '${messageId}'`, messageData?.details ?? {}), () => {
 106         messageType === MessageType.CALL_MESSAGE && this.chargingStation.requests.delete(messageId);
 107       });
 108     } else {
 109       throw new OCPPError(ErrorType.SECURITY_ERROR, 'Cannot send command payload if the charging station is in unknown state', commandName);
 110     }
 111   }
 112
 113   protected handleRequestError(commandName: RequestCommand, error: Error): void {
 114     logger.error(this.chargingStation.logPrefix() + ' Request command ' + commandName + ' error: %j', error);
 115     throw error;
 116   }
 117
 118   private buildMessageToSend(messageId: string, messageData: Record<string, unknown>, messageType: MessageType, commandName: RequestCommand | IncomingRequestCommand,
 119       responseCallback: (payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>) => Promise<void>,
 120       rejectCallback: (error: OCPPError, requestStatistic?: boolean) => void): string {
 121     let messageToSend: string;
 122     // Type of message
 123     switch (messageType) {
 124       // Request
 125       case MessageType.CALL_MESSAGE:
 126         // Build request
 127         this.chargingStation.requests.set(messageId, [responseCallback, rejectCallback, commandName, messageData]);
 128         messageToSend = JSON.stringify([messageType, messageId, commandName, messageData]);
 129         break;
 130       // Response
 131       case MessageType.CALL_RESULT_MESSAGE:
 132         // Build response
 133         messageToSend = JSON.stringify([messageType, messageId, messageData]);
 134         break;
 135       // Error Message
 136       case MessageType.CALL_ERROR_MESSAGE:
 137         // Build Error Message
 138         messageToSend = JSON.stringify([messageType, messageId, messageData?.code ?? ErrorType.GENERIC_ERROR, messageData?.message ?? '', messageData?.details ?? {}]);
 139         break;
 140     }
 141     return messageToSend;
 142   }
 143
 144   public abstract sendHeartbeat(params?: SendParams): Promise<void>;
 145   public abstract sendBootNotification(chargePointModel: string, chargePointVendor: string, chargeBoxSerialNumber?: string, firmwareVersion?: string, chargePointSerialNumber?: string, iccid?: string, imsi?: string, meterSerialNumber?: string, meterType?: string, params?: SendParams): Promise<BootNotificationResponse>;
 146   public abstract sendStatusNotification(connectorId: number, status: ChargePointStatus, errorCode?: ChargePointErrorCode): Promise<void>;
 147   public abstract sendAuthorize(connectorId: number, idTag?: string): Promise<AuthorizeResponse>;
 148   public abstract sendStartTransaction(connectorId: number, idTag?: string): Promise<StartTransactionResponse>;
 149   public abstract sendStopTransaction(transactionId: number, meterStop: number, idTag?: string, reason?: StopTransactionReason): Promise<StopTransactionResponse>;
 150   public abstract sendMeterValues(connectorId: number, transactionId: number, interval: number): Promise<void>;
 151   public abstract sendTransactionBeginMeterValues(connectorId: number, transactionId: number, beginMeterValue: MeterValue): Promise<void>;
 152   public abstract sendTransactionEndMeterValues(connectorId: number, transactionId: number, endMeterValue: MeterValue): Promise<void>;
 153   public abstract sendDiagnosticsStatusNotification(diagnosticsStatus: DiagnosticsStatus): Promise<void>;
 154   public abstract sendResult(messageId: string, resultMessageData: Record<string, unknown>, commandName: RequestCommand | IncomingRequestCommand): Promise<unknown>;
 155   public abstract sendError(messageId: string, error: OCPPError, commandName: RequestCommand | IncomingRequestCommand): Promise<unknown>;
 156 }