X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2FOCPPRequestService.ts;h=a50500dc24047f7a7eb3276a03d725cedf69fb44;hb=a14022a2a2426ab1f42c3ee25ffbfab8969447ea;hp=000d8c0a426816ab43a9f058baf1a4d56d629bae;hpb=b0a67e55b5f2dc2128c6b1d63cc525b0bb98a690;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/ocpp/OCPPRequestService.ts b/src/charging-station/ocpp/OCPPRequestService.ts
index 000d8c0a..a50500dc 100644
--- a/src/charging-station/ocpp/OCPPRequestService.ts
+++ b/src/charging-station/ocpp/OCPPRequestService.ts
@@ -1,191 +1,497 @@
-import { AuthorizeResponse, StartTransactionResponse, StopTransactionReason, StopTransactionResponse } from '../../types/ocpp/Transaction';
-import { DiagnosticsStatus, IncomingRequestCommand, RequestCommand, ResponseType, SendParams } from '../../types/ocpp/Requests';
-
-import { BootNotificationResponse } from '../../types/ocpp/Responses';
-import { ChargePointErrorCode } from '../../types/ocpp/ChargePointErrorCode';
-import { ChargePointStatus } from '../../types/ocpp/ChargePointStatus';
-import type ChargingStation from '../ChargingStation';
-import Constants from '../../utils/Constants';
-import { ErrorType } from '../../types/ocpp/ErrorType';
-import { JsonType } from '../../types/JsonType';
-import { MessageType } from '../../types/ocpp/MessageType';
-import { MeterValue } from '../../types/ocpp/MeterValues';
-import OCPPError from '../../exception/OCPPError';
-import type OCPPResponseService from './OCPPResponseService';
-import PerformanceStatistics from '../../performance/PerformanceStatistics';
-import Utils from '../../utils/Utils';
-import logger from '../../utils/Logger';
-
-export default abstract class OCPPRequestService {
-  private static readonly instances: Map<string, OCPPRequestService> = new Map<string, OCPPRequestService>();
-  protected readonly chargingStation: ChargingStation;
+import Ajv, { type JSONSchemaType } from 'ajv';
+import ajvFormats from 'ajv-formats';
+
+import { OCPPConstants, type OCPPResponseService, OCPPServiceUtils } from './internal';
+import type { ChargingStation } from '../../charging-station';
+import { OCPPError } from '../../exception';
+import { PerformanceStatistics } from '../../performance';
+import {
+  type EmptyObject,
+  type ErrorCallback,
+  type ErrorResponse,
+  ErrorType,
+  type HandleErrorParams,
+  type IncomingRequestCommand,
+  type JsonObject,
+  type JsonType,
+  MessageType,
+  type OCPPVersion,
+  type OutgoingRequest,
+  RequestCommand,
+  type RequestParams,
+  type Response,
+  type ResponseCallback,
+  type ResponseType,
+} from '../../types';
+import { Constants, Utils, logger } from '../../utils';
+
+const moduleName = 'OCPPRequestService';
+
+export abstract class OCPPRequestService {
+  private static instance: OCPPRequestService | null = null;
+  private readonly version: OCPPVersion;
+  private readonly ajv: Ajv;
   private readonly ocppResponseService: OCPPResponseService;
+  protected abstract jsonSchemas: Map<RequestCommand, JSONSchemaType<JsonObject>>;
 
-  protected constructor(chargingStation: ChargingStation, ocppResponseService: OCPPResponseService) {
-    this.chargingStation = chargingStation;
+  protected constructor(version: OCPPVersion, ocppResponseService: OCPPResponseService) {
+    this.version = version;
+    this.ajv = new Ajv({
+      keywords: ['javaType'],
+      multipleOfPrecision: 2,
+    });
+    ajvFormats(this.ajv);
     this.ocppResponseService = ocppResponseService;
+    this.requestHandler = this.requestHandler.bind(this) as <
+      ReqType extends JsonType,
+      ResType extends JsonType
+    >(
+      chargingStation: ChargingStation,
+      commandName: RequestCommand,
+      commandParams?: JsonType,
+      params?: RequestParams
+    ) => Promise<ResType>;
+    this.sendMessage = this.sendMessage.bind(this) as (
+      chargingStation: ChargingStation,
+      messageId: string,
+      messagePayload: JsonType,
+      commandName: RequestCommand,
+      params?: RequestParams
+    ) => Promise<ResponseType>;
+    this.sendResponse = this.sendResponse.bind(this) as (
+      chargingStation: ChargingStation,
+      messageId: string,
+      messagePayload: JsonType,
+      commandName: IncomingRequestCommand
+    ) => Promise<ResponseType>;
+    this.sendError = this.sendError.bind(this) as (
+      chargingStation: ChargingStation,
+      messageId: string,
+      ocppError: OCPPError,
+      commandName: RequestCommand | IncomingRequestCommand
+    ) => Promise<ResponseType>;
+    this.internalSendMessage = this.internalSendMessage.bind(this) as (
+      chargingStation: ChargingStation,
+      messageId: string,
+      messagePayload: JsonType | OCPPError,
+      messageType: MessageType,
+      commandName: RequestCommand | IncomingRequestCommand,
+      params?: RequestParams
+    ) => Promise<ResponseType>;
+    this.buildMessageToSend = this.buildMessageToSend.bind(this) as (
+      chargingStation: ChargingStation,
+      messageId: string,
+      messagePayload: JsonType | OCPPError,
+      messageType: MessageType,
+      commandName: RequestCommand | IncomingRequestCommand,
+      responseCallback: ResponseCallback,
+      errorCallback: ErrorCallback
+    ) => string;
+    this.validateRequestPayload = this.validateRequestPayload.bind(this) as <T extends JsonObject>(
+      chargingStation: ChargingStation,
+      commandName: RequestCommand | IncomingRequestCommand,
+      payload: T
+    ) => boolean;
+    this.validateIncomingRequestResponsePayload = this.validateIncomingRequestResponsePayload.bind(
+      this
+    ) as <T extends JsonObject>(
+      chargingStation: ChargingStation,
+      commandName: RequestCommand | IncomingRequestCommand,
+      payload: T
+    ) => boolean;
   }
 
-  public static getInstance<T extends OCPPRequestService>(this: new (chargingStation: ChargingStation, ocppResponseService: OCPPResponseService) => T, chargingStation: ChargingStation, ocppResponseService: OCPPResponseService): T {
-    if (!OCPPRequestService.instances.has(chargingStation.id)) {
-      OCPPRequestService.instances.set(chargingStation.id, new this(chargingStation, ocppResponseService));
+  public static getInstance<T extends OCPPRequestService>(
+    this: new (ocppResponseService: OCPPResponseService) => T,
+    ocppResponseService: OCPPResponseService
+  ): T {
+    if (OCPPRequestService.instance === null) {
+      OCPPRequestService.instance = new this(ocppResponseService);
     }
-    return OCPPRequestService.instances.get(chargingStation.id) as T;
+    return OCPPRequestService.instance as T;
   }
 
-  public async sendResult(messageId: string, messagePayload: JsonType, commandName: IncomingRequestCommand): Promise<ResponseType> {
+  public async sendResponse(
+    chargingStation: ChargingStation,
+    messageId: string,
+    messagePayload: JsonType,
+    commandName: IncomingRequestCommand
+  ): Promise<ResponseType> {
     try {
-      // Send result message
-      return await this.internalSendMessage(messageId, messagePayload, MessageType.CALL_RESULT_MESSAGE, commandName);
+      // Send response message
+      return await this.internalSendMessage(
+        chargingStation,
+        messageId,
+        messagePayload,
+        MessageType.CALL_RESULT_MESSAGE,
+        commandName
+      );
     } catch (error) {
-      this.handleRequestError(commandName, error as Error);
+      this.handleSendMessageError(chargingStation, commandName, error as Error, {
+        throwError: true,
+      });
     }
   }
 
-  public async sendError(messageId: string, ocppError: OCPPError, commandName: IncomingRequestCommand): Promise<ResponseType> {
+  public async sendError(
+    chargingStation: ChargingStation,
+    messageId: string,
+    ocppError: OCPPError,
+    commandName: RequestCommand | IncomingRequestCommand
+  ): Promise<ResponseType> {
     try {
       // Send error message
-      return await this.internalSendMessage(messageId, ocppError, MessageType.CALL_ERROR_MESSAGE, commandName);
+      return await this.internalSendMessage(
+        chargingStation,
+        messageId,
+        ocppError,
+        MessageType.CALL_ERROR_MESSAGE,
+        commandName
+      );
     } catch (error) {
-      this.handleRequestError(commandName, error as Error);
+      this.handleSendMessageError(chargingStation, commandName, error as Error);
     }
   }
 
-  protected async sendMessage(messageId: string, messagePayload: JsonType, commandName: RequestCommand, params: SendParams = {
-    skipBufferingOnError: false,
-    triggerMessage: false
-  }): Promise<ResponseType> {
+  protected async sendMessage(
+    chargingStation: ChargingStation,
+    messageId: string,
+    messagePayload: JsonType,
+    commandName: RequestCommand,
+    params: RequestParams = {
+      skipBufferingOnError: false,
+      triggerMessage: false,
+      throwError: false,
+    }
+  ): Promise<ResponseType> {
     try {
-      return await this.internalSendMessage(messageId, messagePayload, MessageType.CALL_MESSAGE, commandName, params);
+      return await this.internalSendMessage(
+        chargingStation,
+        messageId,
+        messagePayload,
+        MessageType.CALL_MESSAGE,
+        commandName,
+        params
+      );
     } catch (error) {
-      this.handleRequestError(commandName, error as Error);
+      this.handleSendMessageError(chargingStation, commandName, error as Error, {
+        throwError: params.throwError,
+      });
     }
   }
 
-  private async internalSendMessage(messageId: string, messagePayload: JsonType | OCPPError, messageType: MessageType, commandName?: RequestCommand | IncomingRequestCommand,
-      params: SendParams = {
-        skipBufferingOnError: false,
-        triggerMessage: false
-      }): Promise<ResponseType> {
-    if ((this.chargingStation.isInUnknownState() && commandName === RequestCommand.BOOT_NOTIFICATION)
-      || (!this.chargingStation.getOcppStrictCompliance() && this.chargingStation.isInUnknownState())
-      || this.chargingStation.isInAcceptedState() || (this.chargingStation.isInPendingState() && params.triggerMessage)) {
+  private validateRequestPayload<T extends JsonObject>(
+    chargingStation: ChargingStation,
+    commandName: RequestCommand | IncomingRequestCommand,
+    payload: T
+  ): boolean {
+    if (chargingStation.getPayloadSchemaValidation() === false) {
+      return true;
+    }
+    if (this.jsonSchemas.has(commandName as RequestCommand) === false) {
+      logger.warn(
+        `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: No JSON schema found for command '${commandName}' PDU validation`
+      );
+      return true;
+    }
+    const validate = this.ajv.compile(this.jsonSchemas.get(commandName as RequestCommand));
+    payload = Utils.cloneObject<T>(payload);
+    OCPPServiceUtils.convertDateToISOString<T>(payload);
+    if (validate(payload)) {
+      return true;
+    }
+    logger.error(
+      `${chargingStation.logPrefix()} ${moduleName}.validateRequestPayload: Command '${commandName}' request PDU is invalid: %j`,
+      validate.errors
+    );
+    // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError().
+    throw new OCPPError(
+      OCPPServiceUtils.ajvErrorsToErrorType(validate.errors),
+      'Request PDU is invalid',
+      commandName,
+      JSON.stringify(validate.errors, null, 2)
+    );
+  }
+
+  private validateIncomingRequestResponsePayload<T extends JsonObject>(
+    chargingStation: ChargingStation,
+    commandName: RequestCommand | IncomingRequestCommand,
+    payload: T
+  ): boolean {
+    if (chargingStation.getPayloadSchemaValidation() === false) {
+      return true;
+    }
+    if (
+      this.ocppResponseService.jsonIncomingRequestResponseSchemas.has(
+        commandName as IncomingRequestCommand
+      ) === false
+    ) {
+      logger.warn(
+        `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: No JSON schema found for command '${commandName}' PDU validation`
+      );
+      return true;
+    }
+    const validate = this.ajv.compile(
+      this.ocppResponseService.jsonIncomingRequestResponseSchemas.get(
+        commandName as IncomingRequestCommand
+      )
+    );
+    payload = Utils.cloneObject<T>(payload);
+    OCPPServiceUtils.convertDateToISOString<T>(payload);
+    if (validate(payload)) {
+      return true;
+    }
+    logger.error(
+      `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestResponsePayload: Command '${commandName}' reponse PDU is invalid: %j`,
+      validate.errors
+    );
+    // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError().
+    throw new OCPPError(
+      OCPPServiceUtils.ajvErrorsToErrorType(validate.errors),
+      'Response PDU is invalid',
+      commandName,
+      JSON.stringify(validate.errors, null, 2)
+    );
+  }
+
+  private async internalSendMessage(
+    chargingStation: ChargingStation,
+    messageId: string,
+    messagePayload: JsonType | OCPPError,
+    messageType: MessageType,
+    commandName: RequestCommand | IncomingRequestCommand,
+    params: RequestParams = {
+      skipBufferingOnError: false,
+      triggerMessage: false,
+    }
+  ): Promise<ResponseType> {
+    if (
+      (chargingStation.isInUnknownState() === true &&
+        commandName === RequestCommand.BOOT_NOTIFICATION) ||
+      (chargingStation.getOcppStrictCompliance() === false &&
+        chargingStation.isInUnknownState() === true) ||
+      chargingStation.isInAcceptedState() === true ||
+      (chargingStation.isInPendingState() === true &&
+        (params.triggerMessage === true || messageType === MessageType.CALL_RESULT_MESSAGE))
+    ) {
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       const self = this;
       // Send a message through wsConnection
-      return Utils.promiseWithTimeout(new Promise((resolve, reject) => {
-        const messageToSend = this.buildMessageToSend(messageId, messagePayload, messageType, commandName, responseCallback, rejectCallback);
-        if (this.chargingStation.getEnableStatistics()) {
-          this.chargingStation.performanceStatistics.addRequestStatistic(commandName, messageType);
-        }
-        // Check if wsConnection opened
-        if (this.chargingStation.isWebSocketConnectionOpened()) {
-          // Yes: Send Message
-          const beginId = PerformanceStatistics.beginMeasure(commandName);
-          // FIXME: Handle sending error
-          this.chargingStation.wsConnection.send(messageToSend);
-          PerformanceStatistics.endMeasure(commandName, beginId);
-        } else if (!params.skipBufferingOnError) {
-          // Buffer it
-          this.chargingStation.bufferMessage(messageToSend);
-          const ocppError = new OCPPError(ErrorType.GENERIC_ERROR, `WebSocket closed for buffered message id '${messageId}' with content '${messageToSend}'`, commandName, messagePayload?.details as JsonType ?? {});
-          if (messageType === MessageType.CALL_MESSAGE) {
-            // Reject it but keep the request in the cache
-            return reject(ocppError);
-          }
-          return rejectCallback(ocppError, false);
-        } else {
-          // Reject it
-          return rejectCallback(new OCPPError(ErrorType.GENERIC_ERROR, `WebSocket closed for non buffered message id '${messageId}' with content '${messageToSend}'`, commandName, messagePayload?.details as JsonType ?? {}), false);
-        }
-        // Response?
-        if (messageType !== MessageType.CALL_MESSAGE) {
-          // Yes: send Ok
-          return resolve(messagePayload);
-        }
+      return Utils.promiseWithTimeout(
+        new Promise((resolve, reject) => {
+          /**
+           * Function that will receive the request's response
+           *
+           * @param payload -
+           * @param requestPayload -
+           */
+          const responseCallback = (payload: JsonType, requestPayload: JsonType): void => {
+            if (chargingStation.getEnableStatistics() === true) {
+              chargingStation.performanceStatistics?.addRequestStatistic(
+                commandName,
+                MessageType.CALL_RESULT_MESSAGE
+              );
+            }
+            // Handle the request's response
+            self.ocppResponseService
+              .responseHandler(
+                chargingStation,
+                commandName as RequestCommand,
+                payload,
+                requestPayload
+              )
+              .then(() => {
+                resolve(payload);
+              })
+              .catch((error) => {
+                reject(error);
+              })
+              .finally(() => {
+                chargingStation.requests.delete(messageId);
+              });
+          };
 
-        /**
-         * Function that will receive the request's response
-         *
-         * @param payload
-         * @param requestPayload
-         */
-        async function responseCallback(payload: JsonType | string, requestPayload: JsonType): Promise<void> {
-          if (self.chargingStation.getEnableStatistics()) {
-            self.chargingStation.performanceStatistics.addRequestStatistic(commandName, MessageType.CALL_RESULT_MESSAGE);
-          }
-          // Handle the request's response
-          try {
-            await self.ocppResponseService.handleResponse(commandName as RequestCommand, payload, requestPayload);
-            resolve(payload);
-          } catch (error) {
+          /**
+           * Function that will receive the request's error response
+           *
+           * @param error -
+           * @param requestStatistic -
+           */
+          const errorCallback = (error: OCPPError, requestStatistic = true): void => {
+            if (requestStatistic === true && chargingStation.getEnableStatistics() === true) {
+              chargingStation.performanceStatistics?.addRequestStatistic(
+                commandName,
+                MessageType.CALL_ERROR_MESSAGE
+              );
+            }
+            logger.error(
+              `${chargingStation.logPrefix()} Error occurred at ${OCPPServiceUtils.getMessageTypeString(
+                messageType
+              )} command ${commandName} with PDU %j:`,
+              messagePayload,
+              error
+            );
+            chargingStation.requests.delete(messageId);
             reject(error);
-            throw error;
-          } finally {
-            self.chargingStation.requests.delete(messageId);
-          }
-        }
+          };
 
-        /**
-         * Function that will receive the request's error response
-         *
-         * @param error
-         * @param requestStatistic
-         */
-        function rejectCallback(error: OCPPError, requestStatistic = true): void {
-          if (requestStatistic && self.chargingStation.getEnableStatistics()) {
-            self.chargingStation.performanceStatistics.addRequestStatistic(commandName, MessageType.CALL_ERROR_MESSAGE);
+          if (chargingStation.getEnableStatistics() === true) {
+            chargingStation.performanceStatistics?.addRequestStatistic(commandName, messageType);
+          }
+          const messageToSend = this.buildMessageToSend(
+            chargingStation,
+            messageId,
+            messagePayload,
+            messageType,
+            commandName,
+            responseCallback,
+            errorCallback
+          );
+          let sendError = false;
+          // Check if wsConnection opened
+          const wsOpened = chargingStation.isWebSocketConnectionOpened() === true;
+          if (wsOpened) {
+            const beginId = PerformanceStatistics.beginMeasure(commandName);
+            try {
+              chargingStation.wsConnection?.send(messageToSend);
+              logger.debug(
+                `${chargingStation.logPrefix()} >> Command '${commandName}' sent ${OCPPServiceUtils.getMessageTypeString(
+                  messageType
+                )} payload: ${messageToSend}`
+              );
+            } catch (error) {
+              logger.error(
+                `${chargingStation.logPrefix()} >> Command '${commandName}' failed to send ${OCPPServiceUtils.getMessageTypeString(
+                  messageType
+                )} payload: ${messageToSend}:`,
+                error
+              );
+              sendError = true;
+            }
+            PerformanceStatistics.endMeasure(commandName, beginId);
+          }
+          const wsClosedOrErrored = !wsOpened || sendError === true;
+          if (wsClosedOrErrored && params.skipBufferingOnError === false) {
+            // Buffer
+            chargingStation.bufferMessage(messageToSend);
+            // Reject and keep request in the cache
+            return reject(
+              new OCPPError(
+                ErrorType.GENERIC_ERROR,
+                `WebSocket closed or errored for buffered message id '${messageId}' with content '${messageToSend}'`,
+                commandName,
+                (messagePayload as JsonObject)?.details ?? Constants.EMPTY_FREEZED_OBJECT
+              )
+            );
+          } else if (wsClosedOrErrored) {
+            const ocppError = new OCPPError(
+              ErrorType.GENERIC_ERROR,
+              `WebSocket closed or errored for non buffered message id '${messageId}' with content '${messageToSend}'`,
+              commandName,
+              (messagePayload as JsonObject)?.details ?? Constants.EMPTY_FREEZED_OBJECT
+            );
+            // Reject response
+            if (messageType !== MessageType.CALL_MESSAGE) {
+              return reject(ocppError);
+            }
+            // Reject and remove request from the cache
+            return errorCallback(ocppError, false);
           }
-          logger.error(`${self.chargingStation.logPrefix()} Error %j occurred when calling command %s with message data %j`, error, commandName, messagePayload);
-          self.chargingStation.requests.delete(messageId);
-          reject(error);
+          // Resolve response
+          if (messageType !== MessageType.CALL_MESSAGE) {
+            return resolve(messagePayload);
+          }
+        }),
+        OCPPConstants.OCPP_WEBSOCKET_TIMEOUT,
+        new OCPPError(
+          ErrorType.GENERIC_ERROR,
+          `Timeout for message id '${messageId}'`,
+          commandName,
+          (messagePayload as JsonObject)?.details ?? Constants.EMPTY_FREEZED_OBJECT
+        ),
+        () => {
+          messageType === MessageType.CALL_MESSAGE && chargingStation.requests.delete(messageId);
         }
-      }), Constants.OCPP_WEBSOCKET_TIMEOUT, new OCPPError(ErrorType.GENERIC_ERROR, `Timeout for message id '${messageId}'`, commandName, messagePayload?.details as JsonType ?? {}), () => {
-        messageType === MessageType.CALL_MESSAGE && this.chargingStation.requests.delete(messageId);
-      });
+      );
     }
-    throw new OCPPError(ErrorType.SECURITY_ERROR, `Cannot send command ${commandName} payload when the charging station is in ${this.chargingStation.getRegistrationStatus()} state on the central server`, commandName);
+    throw new OCPPError(
+      ErrorType.SECURITY_ERROR,
+      `Cannot send command ${commandName} PDU when the charging station is in ${chargingStation.getRegistrationStatus()} state on the central server`,
+      commandName
+    );
   }
 
-  private buildMessageToSend(messageId: string, messagePayload: JsonType | OCPPError, messageType: MessageType, commandName?: RequestCommand | IncomingRequestCommand,
-      responseCallback?: (payload: JsonType | string, requestPayload: JsonType) => Promise<void>,
-      rejectCallback?: (error: OCPPError, requestStatistic?: boolean) => void): string {
+  private buildMessageToSend(
+    chargingStation: ChargingStation,
+    messageId: string,
+    messagePayload: JsonType | OCPPError,
+    messageType: MessageType,
+    commandName: RequestCommand | IncomingRequestCommand,
+    responseCallback: ResponseCallback,
+    errorCallback: ErrorCallback
+  ): string {
     let messageToSend: string;
     // Type of message
     switch (messageType) {
       // Request
       case MessageType.CALL_MESSAGE:
         // Build request
-        this.chargingStation.requests.set(messageId, [responseCallback, rejectCallback, commandName, messagePayload]);
-        messageToSend = JSON.stringify([messageType, messageId, commandName, messagePayload]);
+        this.validateRequestPayload(chargingStation, commandName, messagePayload as JsonObject);
+        chargingStation.requests.set(messageId, [
+          responseCallback,
+          errorCallback,
+          commandName,
+          messagePayload as JsonType,
+        ]);
+        messageToSend = JSON.stringify([
+          messageType,
+          messageId,
+          commandName,
+          messagePayload,
+        ] as OutgoingRequest);
         break;
       // Response
       case MessageType.CALL_RESULT_MESSAGE:
         // Build response
-        messageToSend = JSON.stringify([messageType, messageId, messagePayload]);
+        this.validateIncomingRequestResponsePayload(
+          chargingStation,
+          commandName,
+          messagePayload as JsonObject
+        );
+        messageToSend = JSON.stringify([messageType, messageId, messagePayload] as Response);
         break;
       // Error Message
       case MessageType.CALL_ERROR_MESSAGE:
         // Build Error Message
-        messageToSend = JSON.stringify([messageType, messageId, messagePayload?.code ?? ErrorType.GENERIC_ERROR, messagePayload?.message ?? '', messagePayload?.details ?? { commandName }]);
+        messageToSend = JSON.stringify([
+          messageType,
+          messageId,
+          (messagePayload as OCPPError)?.code ?? ErrorType.GENERIC_ERROR,
+          (messagePayload as OCPPError)?.message ?? '',
+          (messagePayload as OCPPError)?.details ?? { commandName },
+        ] as ErrorResponse);
         break;
     }
     return messageToSend;
   }
 
-  private handleRequestError(commandName: RequestCommand | IncomingRequestCommand, error: Error): void {
-    logger.error(this.chargingStation.logPrefix() + ' Request command %s error: %j', commandName, error);
-    throw error;
+  private handleSendMessageError(
+    chargingStation: ChargingStation,
+    commandName: RequestCommand | IncomingRequestCommand,
+    error: Error,
+    params: HandleErrorParams<EmptyObject> = { throwError: false }
+  ): void {
+    logger.error(`${chargingStation.logPrefix()} Request command '${commandName}' error:`, error);
+    if (params?.throwError === true) {
+      throw error;
+    }
   }
 
-  public abstract sendHeartbeat(params?: SendParams): Promise<void>;
-  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>;
-  public abstract sendStatusNotification(connectorId: number, status: ChargePointStatus, errorCode?: ChargePointErrorCode): Promise<void>;
-  public abstract sendAuthorize(connectorId: number, idTag?: string): Promise<AuthorizeResponse>;
-  public abstract sendStartTransaction(connectorId: number, idTag?: string): Promise<StartTransactionResponse>;
-  public abstract sendStopTransaction(transactionId: number, meterStop: number, idTag?: string, reason?: StopTransactionReason): Promise<StopTransactionResponse>;
-  public abstract sendMeterValues(connectorId: number, transactionId: number, interval: number): Promise<void>;
-  public abstract sendTransactionBeginMeterValues(connectorId: number, transactionId: number, beginMeterValue: MeterValue): Promise<void>;
-  public abstract sendTransactionEndMeterValues(connectorId: number, transactionId: number, endMeterValue: MeterValue): Promise<void>;
-  public abstract sendDiagnosticsStatusNotification(diagnosticsStatus: DiagnosticsStatus): Promise<void>;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public abstract requestHandler<ReqType extends JsonType, ResType extends JsonType>(
+    chargingStation: ChargingStation,
+    commandName: RequestCommand,
+    commandParams?: JsonType,
+    params?: RequestParams
+  ): Promise<ResType>;
 }