X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2F1.6%2FOCPP16ResponseService.ts;h=1999473d74690e03fce39af5a261d44b450c5930;hb=1fe0632adfa4067470497e2de02249fc84a4e218;hp=b71227264432d1aaba678b39dacbd10e61cf95f6;hpb=74c6a95480f86afdaf3e763f6700e7c1a3c8f89d;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/ocpp/1.6/OCPP16ResponseService.ts b/src/charging-station/ocpp/1.6/OCPP16ResponseService.ts
index b7122726..1999473d 100644
--- a/src/charging-station/ocpp/1.6/OCPP16ResponseService.ts
+++ b/src/charging-station/ocpp/1.6/OCPP16ResponseService.ts
@@ -1,213 +1,725 @@
-// Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
+// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
 
-import { AuthorizeRequest, OCPP16AuthorizationStatus, OCPP16AuthorizeResponse, OCPP16StartTransactionResponse, OCPP16StopTransactionResponse, StartTransactionRequest, StopTransactionRequest } from '../../../types/ocpp/1.6/Transaction';
-import { HeartbeatRequest, OCPP16RequestCommand, StatusNotificationRequest } from '../../../types/ocpp/1.6/Requests';
-import { HeartbeatResponse, OCPP16BootNotificationResponse, OCPP16RegistrationStatus, StatusNotificationResponse } from '../../../types/ocpp/1.6/Responses';
-import { MeterValuesRequest, MeterValuesResponse } from '../../../types/ocpp/1.6/MeterValues';
+import { parentPort } from 'node:worker_threads';
+
+import type { JSONSchemaType } from 'ajv';
 
-import ChargingStation from '../../ChargingStation';
-import { ErrorType } from '../../../types/ocpp/ErrorType';
-import { JsonType } from '../../../types/JsonType';
-import { OCPP16ChargePointStatus } from '../../../types/ocpp/1.6/ChargePointStatus';
 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
-import { OCPP16StandardParametersKey } from '../../../types/ocpp/1.6/Configuration';
-import OCPPError from '../../../exception/OCPPError';
-import OCPPResponseService from '../OCPPResponseService';
-import { ResponseHandler } from '../../../types/ocpp/Responses';
-import Utils from '../../../utils/Utils';
-import logger from '../../../utils/Logger';
+import {
+  type ChargingStation,
+  ChargingStationConfigurationUtils,
+  ChargingStationUtils,
+} from '../../../charging-station';
+import { OCPPError } from '../../../exception';
+import {
+  type ChangeAvailabilityResponse,
+  type ChangeConfigurationResponse,
+  type ClearChargingProfileResponse,
+  ErrorType,
+  type GenericResponse,
+  type GetConfigurationResponse,
+  type GetDiagnosticsResponse,
+  type JsonObject,
+  type JsonType,
+  OCPP16AuthorizationStatus,
+  type OCPP16AuthorizeRequest,
+  type OCPP16AuthorizeResponse,
+  type OCPP16BootNotificationResponse,
+  OCPP16ChargePointStatus,
+  type OCPP16DataTransferResponse,
+  type OCPP16DiagnosticsStatusNotificationResponse,
+  type OCPP16FirmwareStatusNotificationResponse,
+  type OCPP16GetCompositeScheduleResponse,
+  type OCPP16HeartbeatResponse,
+  OCPP16IncomingRequestCommand,
+  type OCPP16MeterValuesRequest,
+  type OCPP16MeterValuesResponse,
+  OCPP16RequestCommand,
+  OCPP16StandardParametersKey,
+  type OCPP16StartTransactionRequest,
+  type OCPP16StartTransactionResponse,
+  type OCPP16StatusNotificationResponse,
+  type OCPP16StopTransactionRequest,
+  type OCPP16StopTransactionResponse,
+  type OCPP16TriggerMessageResponse,
+  type OCPP16UpdateFirmwareResponse,
+  OCPPVersion,
+  RegistrationStatusEnumType,
+  type ResponseHandler,
+  type SetChargingProfileResponse,
+  type UnlockConnectorResponse,
+} from '../../../types';
+import { Constants, MessageChannelUtils, Utils, logger } from '../../../utils';
+import { OCPPResponseService } from '../OCPPResponseService';
+
+const moduleName = 'OCPP16ResponseService';
+
+export class OCPP16ResponseService extends OCPPResponseService {
+  public jsonIncomingRequestResponseSchemas: Map<
+    OCPP16IncomingRequestCommand,
+    JSONSchemaType<JsonObject>
+  >;
 
-export default class OCPP16ResponseService extends OCPPResponseService {
   private responseHandlers: Map<OCPP16RequestCommand, ResponseHandler>;
+  private jsonSchemas: Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>;
 
-  constructor(chargingStation: ChargingStation) {
-    super(chargingStation);
+  public constructor() {
+    // if (new.target?.name === moduleName) {
+    //   throw new TypeError(`Cannot construct ${new.target?.name} instances directly`);
+    // }
+    super(OCPPVersion.VERSION_16);
     this.responseHandlers = new Map<OCPP16RequestCommand, ResponseHandler>([
       [OCPP16RequestCommand.BOOT_NOTIFICATION, this.handleResponseBootNotification.bind(this)],
-      [OCPP16RequestCommand.HEARTBEAT, this.handleResponseHeartbeat.bind(this)],
+      [OCPP16RequestCommand.HEARTBEAT, this.emptyResponseHandler.bind(this)],
       [OCPP16RequestCommand.AUTHORIZE, this.handleResponseAuthorize.bind(this)],
       [OCPP16RequestCommand.START_TRANSACTION, this.handleResponseStartTransaction.bind(this)],
       [OCPP16RequestCommand.STOP_TRANSACTION, this.handleResponseStopTransaction.bind(this)],
-      [OCPP16RequestCommand.STATUS_NOTIFICATION, this.handleResponseStatusNotification.bind(this)],
-      [OCPP16RequestCommand.METER_VALUES, this.handleResponseMeterValues.bind(this)]
+      [OCPP16RequestCommand.STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
+      [OCPP16RequestCommand.METER_VALUES, this.emptyResponseHandler.bind(this)],
+      [OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
+      [OCPP16RequestCommand.DATA_TRANSFER, this.emptyResponseHandler.bind(this)],
+      [OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
+    ]);
+    this.jsonSchemas = new Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>([
+      [
+        OCPP16RequestCommand.BOOT_NOTIFICATION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16BootNotificationResponse>(
+          'assets/json-schemas/ocpp/1.6/BootNotificationResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.HEARTBEAT,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16HeartbeatResponse>(
+          'assets/json-schemas/ocpp/1.6/HeartbeatResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.AUTHORIZE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16AuthorizeResponse>(
+          'assets/json-schemas/ocpp/1.6/AuthorizeResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.START_TRANSACTION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16StartTransactionResponse>(
+          'assets/json-schemas/ocpp/1.6/StartTransactionResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.STOP_TRANSACTION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16StopTransactionResponse>(
+          'assets/json-schemas/ocpp/1.6/StopTransactionResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.STATUS_NOTIFICATION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16StatusNotificationResponse>(
+          'assets/json-schemas/ocpp/1.6/StatusNotificationResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.METER_VALUES,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16MeterValuesResponse>(
+          'assets/json-schemas/ocpp/1.6/MeterValuesResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16DiagnosticsStatusNotificationResponse>(
+          'assets/json-schemas/ocpp/1.6/DiagnosticsStatusNotificationResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.DATA_TRANSFER,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16DataTransferResponse>(
+          'assets/json-schemas/ocpp/1.6/DataTransferResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16FirmwareStatusNotificationResponse>(
+          'assets/json-schemas/ocpp/1.6/FirmwareStatusNotificationResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+    ]);
+    this.jsonIncomingRequestResponseSchemas = new Map([
+      [
+        OCPP16IncomingRequestCommand.RESET,
+        OCPP16ServiceUtils.parseJsonSchemaFile<GenericResponse>(
+          'assets/json-schemas/ocpp/1.6/ResetResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.CLEAR_CACHE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<GenericResponse>(
+          'assets/json-schemas/ocpp/1.6/ClearCacheResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
+        OCPP16ServiceUtils.parseJsonSchemaFile<ChangeAvailabilityResponse>(
+          'assets/json-schemas/ocpp/1.6/ChangeAvailabilityResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR,
+        OCPP16ServiceUtils.parseJsonSchemaFile<UnlockConnectorResponse>(
+          'assets/json-schemas/ocpp/1.6/UnlockConnectorResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.GET_CONFIGURATION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<GetConfigurationResponse>(
+          'assets/json-schemas/ocpp/1.6/GetConfigurationResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<ChangeConfigurationResponse>(
+          'assets/json-schemas/ocpp/1.6/ChangeConfigurationResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16GetCompositeScheduleResponse>(
+          'assets/json-schemas/ocpp/1.6/GetCompositeScheduleResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<SetChargingProfileResponse>(
+          'assets/json-schemas/ocpp/1.6/SetChargingProfileResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<ClearChargingProfileResponse>(
+          'assets/json-schemas/ocpp/1.6/ClearChargingProfileResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<GenericResponse>(
+          'assets/json-schemas/ocpp/1.6/RemoteStartTransactionResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
+        OCPP16ServiceUtils.parseJsonSchemaFile<GenericResponse>(
+          'assets/json-schemas/ocpp/1.6/RemoteStopTransactionResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
+        OCPP16ServiceUtils.parseJsonSchemaFile<GetDiagnosticsResponse>(
+          'assets/json-schemas/ocpp/1.6/GetDiagnosticsResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16TriggerMessageResponse>(
+          'assets/json-schemas/ocpp/1.6/TriggerMessageResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.DATA_TRANSFER,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16DataTransferResponse>(
+          'assets/json-schemas/ocpp/1.6/DataTransferResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
+      [
+        OCPP16IncomingRequestCommand.UPDATE_FIRMWARE,
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16UpdateFirmwareResponse>(
+          'assets/json-schemas/ocpp/1.6/UpdateFirmwareResponse.json',
+          moduleName,
+          'constructor'
+        ),
+      ],
     ]);
+    this.validatePayload = this.validatePayload.bind(this) as (
+      chargingStation: ChargingStation,
+      commandName: OCPP16RequestCommand,
+      payload: JsonType
+    ) => boolean;
   }
 
-  public async handleResponse(commandName: OCPP16RequestCommand, payload: JsonType | string, requestPayload: JsonType): Promise<void> {
-    if (this.chargingStation.isRegistered() || commandName === OCPP16RequestCommand.BOOT_NOTIFICATION) {
-      if (this.responseHandlers.has(commandName)) {
+  public async responseHandler(
+    chargingStation: ChargingStation,
+    commandName: OCPP16RequestCommand,
+    payload: JsonType,
+    requestPayload: JsonType
+  ): Promise<void> {
+    if (
+      chargingStation.isRegistered() === true ||
+      commandName === OCPP16RequestCommand.BOOT_NOTIFICATION
+    ) {
+      if (
+        this.responseHandlers.has(commandName) === true &&
+        OCPP16ServiceUtils.isRequestCommandSupported(chargingStation, commandName) === true
+      ) {
         try {
-          await this.responseHandlers.get(commandName)(payload, requestPayload);
+          this.validatePayload(chargingStation, commandName, payload);
+          await this.responseHandlers.get(commandName)(chargingStation, payload, requestPayload);
         } catch (error) {
-          logger.error(this.chargingStation.logPrefix() + ' Handle request response error: %j', error);
+          logger.error(
+            `${chargingStation.logPrefix()} ${moduleName}.responseHandler: Handle response error:`,
+            error
+          );
           throw error;
         }
       } else {
         // Throw exception
-        throw new OCPPError(ErrorType.NOT_IMPLEMENTED, `${commandName} is not implemented to handle request response payload ${JSON.stringify(payload, null, 2)}`, commandName);
+        throw new OCPPError(
+          ErrorType.NOT_IMPLEMENTED,
+          `${commandName} is not implemented to handle response PDU ${JSON.stringify(
+            payload,
+            null,
+            2
+          )}`,
+          commandName,
+          payload
+        );
       }
     } else {
-      throw new OCPPError(ErrorType.SECURITY_ERROR, `${commandName} cannot be issued to handle request response payload ${JSON.stringify(payload, null, 2)} while the charging station is not registered on the central server. `, commandName);
+      throw new OCPPError(
+        ErrorType.SECURITY_ERROR,
+        `${commandName} cannot be issued to handle response PDU ${JSON.stringify(
+          payload,
+          null,
+          2
+        )} while the charging station is not registered on the central server.`,
+        commandName,
+        payload
+      );
     }
   }
 
-  private handleResponseBootNotification(payload: OCPP16BootNotificationResponse): void {
-    if (payload.status === OCPP16RegistrationStatus.ACCEPTED) {
-      this.chargingStation.addConfigurationKey(OCPP16StandardParametersKey.HeartBeatInterval, payload.interval.toString());
-      this.chargingStation.addConfigurationKey(OCPP16StandardParametersKey.HeartbeatInterval, payload.interval.toString(), { visible: false });
-      this.chargingStation.heartbeatSetInterval ? this.chargingStation.restartHeartbeat() : this.chargingStation.startHeartbeat();
-    }
-    if (Object.values(OCPP16RegistrationStatus).includes(payload.status)) {
-      const logMsg = `${this.chargingStation.logPrefix()} Charging station in '${payload.status}' state on the central server`;
-      payload.status === OCPP16RegistrationStatus.REJECTED ? logger.warn(logMsg) : logger.info(logMsg);
-    } else {
-      logger.error(this.chargingStation.logPrefix() + ' Charging station boot notification response received: %j with undefined registration status', payload);
+  private validatePayload(
+    chargingStation: ChargingStation,
+    commandName: OCPP16RequestCommand,
+    payload: JsonType
+  ): boolean {
+    if (this.jsonSchemas.has(commandName) === true) {
+      return this.validateResponsePayload(
+        chargingStation,
+        commandName,
+        this.jsonSchemas.get(commandName),
+        payload
+      );
     }
+    logger.warn(
+      `${chargingStation.logPrefix()} ${moduleName}.validatePayload: No JSON schema found for command '${commandName}' PDU validation`
+    );
+    return false;
   }
 
-  private handleResponseHeartbeat(payload: HeartbeatResponse, requestPayload: HeartbeatRequest): void {
-    logger.debug(this.chargingStation.logPrefix() + ' Heartbeat response received: %j to Heartbeat request: %j', payload, requestPayload);
+  private handleResponseBootNotification(
+    chargingStation: ChargingStation,
+    payload: OCPP16BootNotificationResponse
+  ): void {
+    if (payload.status === RegistrationStatusEnumType.ACCEPTED) {
+      ChargingStationConfigurationUtils.addConfigurationKey(
+        chargingStation,
+        OCPP16StandardParametersKey.HeartbeatInterval,
+        payload.interval.toString(),
+        {},
+        { overwrite: true, save: true }
+      );
+      ChargingStationConfigurationUtils.addConfigurationKey(
+        chargingStation,
+        OCPP16StandardParametersKey.HeartBeatInterval,
+        payload.interval.toString(),
+        { visible: false },
+        { overwrite: true, save: true }
+      );
+      OCPP16ServiceUtils.startHeartbeatInterval(chargingStation, payload.interval);
+    }
+    if (Object.values(RegistrationStatusEnumType).includes(payload.status)) {
+      const logMsg = `${chargingStation.logPrefix()} Charging station in '${
+        payload.status
+      }' state on the central server`;
+      payload.status === RegistrationStatusEnumType.REJECTED
+        ? logger.warn(logMsg)
+        : logger.info(logMsg);
+    } else {
+      logger.error(
+        `${chargingStation.logPrefix()} Charging station boot notification response received: %j with undefined registration status`,
+        payload
+      );
+    }
   }
 
-  private handleResponseAuthorize(payload: OCPP16AuthorizeResponse, requestPayload: AuthorizeRequest): void {
+  private handleResponseAuthorize(
+    chargingStation: ChargingStation,
+    payload: OCPP16AuthorizeResponse,
+    requestPayload: OCPP16AuthorizeRequest
+  ): void {
     let authorizeConnectorId: number;
-    for (const connectorId of this.chargingStation.connectors.keys()) {
-      if (connectorId > 0 && this.chargingStation.getConnectorStatus(connectorId)?.authorizeIdTag === requestPayload.idTag) {
-        authorizeConnectorId = connectorId;
-        break;
+    if (chargingStation.hasEvses) {
+      for (const [evseId, evseStatus] of chargingStation.evses) {
+        if (evseId > 0) {
+          for (const [connectorId, connectorStatus] of evseStatus.connectors) {
+            if (connectorStatus?.authorizeIdTag === requestPayload.idTag) {
+              authorizeConnectorId = connectorId;
+              break;
+            }
+          }
+        }
+      }
+    } else {
+      for (const connectorId of chargingStation.connectors.keys()) {
+        if (
+          connectorId > 0 &&
+          chargingStation.getConnectorStatus(connectorId)?.authorizeIdTag === requestPayload.idTag
+        ) {
+          authorizeConnectorId = connectorId;
+          break;
+        }
       }
     }
+    const authorizeConnectorIdDefined = !Utils.isNullOrUndefined(authorizeConnectorId);
     if (payload.idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED) {
-      this.chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = true;
-      logger.debug(`${this.chargingStation.logPrefix()} IdTag ${requestPayload.idTag} authorized on connector ${authorizeConnectorId}`);
+      authorizeConnectorIdDefined &&
+        (chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = true);
+      logger.debug(
+        `${chargingStation.logPrefix()} idTag '${requestPayload.idTag}' accepted${
+          authorizeConnectorIdDefined ? ` on connector id ${authorizeConnectorId}` : ''
+        }`
+      );
     } else {
-      this.chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = false;
-      delete this.chargingStation.getConnectorStatus(authorizeConnectorId).authorizeIdTag;
-      logger.debug(`${this.chargingStation.logPrefix()} IdTag ${requestPayload.idTag} refused with status ${payload.idTagInfo.status} on connector ${authorizeConnectorId}`);
+      if (authorizeConnectorIdDefined) {
+        chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = false;
+        delete chargingStation.getConnectorStatus(authorizeConnectorId)?.authorizeIdTag;
+      }
+      logger.debug(
+        `${chargingStation.logPrefix()} idTag '${requestPayload.idTag}' rejected with status '${
+          payload.idTagInfo.status
+        }'${authorizeConnectorIdDefined ? ` on connector id ${authorizeConnectorId}` : ''}`
+      );
     }
   }
 
-  private async handleResponseStartTransaction(payload: OCPP16StartTransactionResponse, requestPayload: StartTransactionRequest): Promise<void> {
-    const connectorId = requestPayload.connectorId;
-
-    let transactionConnectorId: number;
-    for (const id of this.chargingStation.connectors.keys()) {
-      if (id > 0 && id === connectorId) {
-        transactionConnectorId = id;
-        break;
-      }
-    }
-    if (!transactionConnectorId) {
-      logger.error(this.chargingStation.logPrefix() + ' Trying to start a transaction on a non existing connector Id ' + connectorId.toString());
+  private async handleResponseStartTransaction(
+    chargingStation: ChargingStation,
+    payload: OCPP16StartTransactionResponse,
+    requestPayload: OCPP16StartTransactionRequest
+  ): Promise<void> {
+    const transactionConnectorId = requestPayload.connectorId;
+    if (
+      transactionConnectorId === 0 ||
+      chargingStation.hasConnector(transactionConnectorId) === false
+    ) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction on a non existing connector id ${transactionConnectorId.toString()}`
+      );
       return;
     }
-    if (this.chargingStation.getConnectorStatus(connectorId).transactionRemoteStarted && this.chargingStation.getAuthorizeRemoteTxRequests()
-      && this.chargingStation.getLocalAuthListEnabled() && this.chargingStation.hasAuthorizedTags() && !this.chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized) {
-      logger.error(this.chargingStation.logPrefix() + ' Trying to start a transaction with a not local authorized idTag ' + this.chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag + ' on connector Id ' + connectorId.toString());
-      await this.resetConnectorOnStartTransactionError(connectorId);
+    if (
+      chargingStation.getConnectorStatus(transactionConnectorId)?.transactionRemoteStarted ===
+        true &&
+      chargingStation.getAuthorizeRemoteTxRequests() === true &&
+      chargingStation.getLocalAuthListEnabled() === true &&
+      chargingStation.hasIdTags() &&
+      chargingStation.getConnectorStatus(transactionConnectorId)?.idTagLocalAuthorized === false
+    ) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction with a not local authorized idTag ${
+          chargingStation.getConnectorStatus(transactionConnectorId)?.localAuthorizeIdTag
+        } on connector id ${transactionConnectorId.toString()}`
+      );
+      await this.resetConnectorOnStartTransactionError(chargingStation, transactionConnectorId);
       return;
     }
-    if (this.chargingStation.getConnectorStatus(connectorId).transactionRemoteStarted && this.chargingStation.getAuthorizeRemoteTxRequests()
-      && this.chargingStation.getMayAuthorizeAtRemoteStart() && !this.chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized
-      && !this.chargingStation.getConnectorStatus(connectorId).idTagAuthorized) {
-      logger.error(this.chargingStation.logPrefix() + ' Trying to start a transaction with a not authorized idTag ' + this.chargingStation.getConnectorStatus(connectorId).authorizeIdTag + ' on connector Id ' + connectorId.toString());
-      await this.resetConnectorOnStartTransactionError(connectorId);
+    if (
+      chargingStation.getConnectorStatus(transactionConnectorId)?.transactionRemoteStarted ===
+        true &&
+      chargingStation.getAuthorizeRemoteTxRequests() === true &&
+      chargingStation.getMustAuthorizeAtRemoteStart() === true &&
+      chargingStation.getConnectorStatus(transactionConnectorId)?.idTagLocalAuthorized === false &&
+      chargingStation.getConnectorStatus(transactionConnectorId)?.idTagAuthorized === false
+    ) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction with a not authorized idTag ${
+          chargingStation.getConnectorStatus(transactionConnectorId)?.authorizeIdTag
+        } on connector id ${transactionConnectorId.toString()}`
+      );
+      await this.resetConnectorOnStartTransactionError(chargingStation, transactionConnectorId);
       return;
     }
-    if (this.chargingStation.getConnectorStatus(connectorId).idTagAuthorized && this.chargingStation.getConnectorStatus(connectorId).authorizeIdTag !== requestPayload.idTag) {
-      logger.error(this.chargingStation.logPrefix() + ' Trying to start a transaction with an idTag ' + requestPayload.idTag + ' different from the authorize request one ' + this.chargingStation.getConnectorStatus(connectorId).authorizeIdTag + ' on connector Id ' + connectorId.toString());
-      await this.resetConnectorOnStartTransactionError(connectorId);
+    if (
+      chargingStation.getConnectorStatus(transactionConnectorId)?.idTagAuthorized &&
+      chargingStation.getConnectorStatus(transactionConnectorId)?.authorizeIdTag !==
+        requestPayload.idTag
+    ) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction with an idTag ${
+          requestPayload.idTag
+        } different from the authorize request one ${
+          chargingStation.getConnectorStatus(transactionConnectorId)?.authorizeIdTag
+        } on connector id ${transactionConnectorId.toString()}`
+      );
+      await this.resetConnectorOnStartTransactionError(chargingStation, transactionConnectorId);
       return;
     }
-    if (this.chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized
-      && this.chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag !== requestPayload.idTag) {
-      logger.error(this.chargingStation.logPrefix() + ' Trying to start a transaction with an idTag ' + requestPayload.idTag + ' different from the local authorized one ' + this.chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag + ' on connector Id ' + connectorId.toString());
-      await this.resetConnectorOnStartTransactionError(connectorId);
+    if (
+      chargingStation.getConnectorStatus(transactionConnectorId)?.idTagLocalAuthorized &&
+      chargingStation.getConnectorStatus(transactionConnectorId)?.localAuthorizeIdTag !==
+        requestPayload.idTag
+    ) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction with an idTag ${
+          requestPayload.idTag
+        } different from the local authorized one ${
+          chargingStation.getConnectorStatus(transactionConnectorId)?.localAuthorizeIdTag
+        } on connector id ${transactionConnectorId.toString()}`
+      );
+      await this.resetConnectorOnStartTransactionError(chargingStation, transactionConnectorId);
       return;
     }
-    if (this.chargingStation.getConnectorStatus(connectorId)?.transactionStarted) {
-      logger.debug(this.chargingStation.logPrefix() + ' Trying to start a transaction on an already used connector ' + connectorId.toString() + ': %j', this.chargingStation.getConnectorStatus(connectorId));
+    if (chargingStation.getConnectorStatus(transactionConnectorId)?.transactionStarted === true) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction on an already used connector id ${transactionConnectorId.toString()}:`,
+        chargingStation.getConnectorStatus(transactionConnectorId)
+      );
       return;
     }
-    if (this.chargingStation.getConnectorStatus(connectorId)?.status !== OCPP16ChargePointStatus.AVAILABLE
-      && this.chargingStation.getConnectorStatus(connectorId)?.status !== OCPP16ChargePointStatus.PREPARING) {
-      logger.error(`${this.chargingStation.logPrefix()} Trying to start a transaction on connector ${connectorId.toString()} with status ${this.chargingStation.getConnectorStatus(connectorId)?.status}`);
+    if (chargingStation.hasEvses) {
+      for (const [evseId, evseStatus] of chargingStation.evses) {
+        if (evseStatus.connectors.size > 1) {
+          for (const [connectorId, connectorStatus] of evseStatus.connectors) {
+            if (
+              transactionConnectorId !== connectorId &&
+              connectorStatus?.transactionStarted === true
+            ) {
+              logger.error(
+                `${chargingStation.logPrefix()} Trying to start a transaction on an already used evse id ${evseId.toString()}:`,
+                evseStatus
+              );
+              await this.resetConnectorOnStartTransactionError(
+                chargingStation,
+                transactionConnectorId
+              );
+              return;
+            }
+          }
+        }
+      }
+    }
+    if (
+      chargingStation.getConnectorStatus(transactionConnectorId)?.status !==
+        OCPP16ChargePointStatus.Available &&
+      chargingStation.getConnectorStatus(transactionConnectorId)?.status !==
+        OCPP16ChargePointStatus.Preparing
+    ) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to start a transaction on connector id ${transactionConnectorId.toString()} with status ${
+          chargingStation.getConnectorStatus(transactionConnectorId)?.status
+        }`
+      );
       return;
     }
     if (!Number.isInteger(payload.transactionId)) {
-      logger.warn(`${this.chargingStation.logPrefix()} Trying to start a transaction on connector ${connectorId.toString()} with a non integer transaction Id ${payload.transactionId}, converting to integer`);
+      logger.warn(
+        `${chargingStation.logPrefix()} Trying to start a transaction on connector id ${transactionConnectorId.toString()} with a non integer transaction id ${
+          payload.transactionId
+        }, converting to integer`
+      );
       payload.transactionId = Utils.convertToInt(payload.transactionId);
     }
 
     if (payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
-      this.chargingStation.getConnectorStatus(connectorId).transactionStarted = true;
-      this.chargingStation.getConnectorStatus(connectorId).transactionId = payload.transactionId;
-      this.chargingStation.getConnectorStatus(connectorId).transactionIdTag = requestPayload.idTag;
-      this.chargingStation.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
-      this.chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue = OCPP16ServiceUtils.buildTransactionBeginMeterValue(this.chargingStation, connectorId,
-        requestPayload.meterStart);
-      this.chargingStation.getBeginEndMeterValues() && await this.chargingStation.ocppRequestService.sendTransactionBeginMeterValues(connectorId, payload.transactionId,
-        this.chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue);
-      await this.chargingStation.ocppRequestService.sendStatusNotification(connectorId, OCPP16ChargePointStatus.CHARGING);
-      this.chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.CHARGING;
-      logger.info(this.chargingStation.logPrefix() + ' Transaction ' + payload.transactionId.toString() + ' STARTED on ' + this.chargingStation.stationInfo.chargingStationId + '#' + connectorId.toString() + ' for idTag ' + requestPayload.idTag);
-      if (this.chargingStation.stationInfo.powerSharedByConnectors) {
-        this.chargingStation.stationInfo.powerDivider++;
+      chargingStation.getConnectorStatus(transactionConnectorId).transactionStarted = true;
+      chargingStation.getConnectorStatus(transactionConnectorId).transactionId =
+        payload.transactionId;
+      chargingStation.getConnectorStatus(transactionConnectorId).transactionIdTag =
+        requestPayload.idTag;
+      chargingStation.getConnectorStatus(
+        transactionConnectorId
+      ).transactionEnergyActiveImportRegisterValue = 0;
+      chargingStation.getConnectorStatus(transactionConnectorId).transactionBeginMeterValue =
+        OCPP16ServiceUtils.buildTransactionBeginMeterValue(
+          chargingStation,
+          transactionConnectorId,
+          requestPayload.meterStart
+        );
+      chargingStation.getBeginEndMeterValues() &&
+        (await chargingStation.ocppRequestService.requestHandler<
+          OCPP16MeterValuesRequest,
+          OCPP16MeterValuesResponse
+        >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
+          connectorId: transactionConnectorId,
+          transactionId: payload.transactionId,
+          meterValue: [
+            chargingStation.getConnectorStatus(transactionConnectorId).transactionBeginMeterValue,
+          ],
+        }));
+      await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+        chargingStation,
+        transactionConnectorId,
+        OCPP16ChargePointStatus.Charging
+      );
+      logger.info(
+        `${chargingStation.logPrefix()} Transaction with id ${payload.transactionId.toString()} STARTED on ${
+          chargingStation.stationInfo.chargingStationId
+        }#${transactionConnectorId.toString()} for idTag '${requestPayload.idTag}'`
+      );
+      if (chargingStation.stationInfo.powerSharedByConnectors) {
+        ++chargingStation.powerDivider;
       }
-      const configuredMeterValueSampleInterval = this.chargingStation.getConfigurationKey(OCPP16StandardParametersKey.MeterValueSampleInterval);
-      this.chargingStation.startMeterValues(connectorId, configuredMeterValueSampleInterval ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000 : 60000);
+      const configuredMeterValueSampleInterval =
+        ChargingStationConfigurationUtils.getConfigurationKey(
+          chargingStation,
+          OCPP16StandardParametersKey.MeterValueSampleInterval
+        );
+      chargingStation.startMeterValues(
+        transactionConnectorId,
+        configuredMeterValueSampleInterval
+          ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000
+          : Constants.DEFAULT_METER_VALUES_INTERVAL
+      );
     } else {
-      logger.warn(this.chargingStation.logPrefix() + ' Starting transaction id ' + payload.transactionId.toString() + ' REJECTED with status ' + payload?.idTagInfo?.status + ', idTag ' + requestPayload.idTag);
-      await this.resetConnectorOnStartTransactionError(connectorId);
+      logger.warn(
+        `${chargingStation.logPrefix()} Starting transaction with id ${payload.transactionId.toString()} REJECTED with status '${
+          payload.idTagInfo?.status
+        }', idTag '${requestPayload.idTag}'`
+      );
+      await this.resetConnectorOnStartTransactionError(chargingStation, transactionConnectorId);
     }
   }
 
-  private async resetConnectorOnStartTransactionError(connectorId: number): Promise<void> {
-    this.chargingStation.resetConnectorStatus(connectorId);
-    if (this.chargingStation.getConnectorStatus(connectorId).status !== OCPP16ChargePointStatus.AVAILABLE) {
-      await this.chargingStation.ocppRequestService.sendStatusNotification(connectorId, OCPP16ChargePointStatus.AVAILABLE);
-      this.chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.AVAILABLE;
+  private async resetConnectorOnStartTransactionError(
+    chargingStation: ChargingStation,
+    connectorId: number
+  ): Promise<void> {
+    ChargingStationUtils.resetConnectorStatus(chargingStation.getConnectorStatus(connectorId));
+    chargingStation.stopMeterValues(connectorId);
+    parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(chargingStation));
+    if (
+      chargingStation.getConnectorStatus(connectorId)?.status !== OCPP16ChargePointStatus.Available
+    ) {
+      await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+        chargingStation,
+        connectorId,
+        OCPP16ChargePointStatus.Available
+      );
     }
   }
 
-  private async handleResponseStopTransaction(payload: OCPP16StopTransactionResponse, requestPayload: StopTransactionRequest): Promise<void> {
-    let transactionConnectorId: number;
-    for (const connectorId of this.chargingStation.connectors.keys()) {
-      if (connectorId > 0 && this.chargingStation.getConnectorStatus(connectorId)?.transactionId === requestPayload.transactionId) {
-        transactionConnectorId = connectorId;
-        break;
-      }
-    }
-    if (!transactionConnectorId) {
-      logger.error(this.chargingStation.logPrefix() + ' Trying to stop a non existing transaction ' + requestPayload.transactionId.toString());
+  private async handleResponseStopTransaction(
+    chargingStation: ChargingStation,
+    payload: OCPP16StopTransactionResponse,
+    requestPayload: OCPP16StopTransactionRequest
+  ): Promise<void> {
+    const transactionConnectorId = chargingStation.getConnectorIdByTransactionId(
+      requestPayload.transactionId
+    );
+    if (Utils.isNullOrUndefined(transactionConnectorId)) {
+      logger.error(
+        `${chargingStation.logPrefix()} Trying to stop a non existing transaction with id ${requestPayload.transactionId.toString()}`
+      );
       return;
     }
-    if (payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
-      (this.chargingStation.getBeginEndMeterValues() && !this.chargingStation.getOcppStrictCompliance() && this.chargingStation.getOutOfOrderEndMeterValues())
-        && await this.chargingStation.ocppRequestService.sendTransactionEndMeterValues(transactionConnectorId, requestPayload.transactionId,
-          OCPP16ServiceUtils.buildTransactionEndMeterValue(this.chargingStation, transactionConnectorId, requestPayload.meterStop));
-      if (!this.chargingStation.isChargingStationAvailable() || !this.chargingStation.isConnectorAvailable(transactionConnectorId)) {
-        await this.chargingStation.ocppRequestService.sendStatusNotification(transactionConnectorId, OCPP16ChargePointStatus.UNAVAILABLE);
-        this.chargingStation.getConnectorStatus(transactionConnectorId).status = OCPP16ChargePointStatus.UNAVAILABLE;
-      } else {
-        await this.chargingStation.ocppRequestService.sendStatusNotification(transactionConnectorId, OCPP16ChargePointStatus.AVAILABLE);
-        this.chargingStation.getConnectorStatus(transactionConnectorId).status = OCPP16ChargePointStatus.AVAILABLE;
-      }
-      if (this.chargingStation.stationInfo.powerSharedByConnectors) {
-        this.chargingStation.stationInfo.powerDivider--;
-      }
-      logger.info(this.chargingStation.logPrefix() + ' Transaction ' + requestPayload.transactionId.toString() + ' STOPPED on ' + this.chargingStation.stationInfo.chargingStationId + '#' + transactionConnectorId.toString());
-      this.chargingStation.resetConnectorStatus(transactionConnectorId);
+    chargingStation.getBeginEndMeterValues() === true &&
+      chargingStation.getOcppStrictCompliance() === false &&
+      chargingStation.getOutOfOrderEndMeterValues() === true &&
+      (await chargingStation.ocppRequestService.requestHandler<
+        OCPP16MeterValuesRequest,
+        OCPP16MeterValuesResponse
+      >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
+        connectorId: transactionConnectorId,
+        transactionId: requestPayload.transactionId,
+        meterValue: [
+          OCPP16ServiceUtils.buildTransactionEndMeterValue(
+            chargingStation,
+            transactionConnectorId,
+            requestPayload.meterStop
+          ),
+        ],
+      }));
+    if (
+      chargingStation.isChargingStationAvailable() === false ||
+      chargingStation.isConnectorAvailable(transactionConnectorId) === false
+    ) {
+      await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+        chargingStation,
+        transactionConnectorId,
+        OCPP16ChargePointStatus.Unavailable
+      );
     } else {
-      logger.warn(this.chargingStation.logPrefix() + ' Stopping transaction id ' + requestPayload.transactionId.toString() + ' REJECTED with status ' + payload.idTagInfo?.status);
+      await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+        chargingStation,
+        transactionConnectorId,
+        OCPP16ChargePointStatus.Available
+      );
+    }
+    if (chargingStation.stationInfo.powerSharedByConnectors) {
+      chargingStation.powerDivider--;
+    }
+    ChargingStationUtils.resetConnectorStatus(
+      chargingStation.getConnectorStatus(transactionConnectorId)
+    );
+    chargingStation.stopMeterValues(transactionConnectorId);
+    parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(chargingStation));
+    const logMsg = `${chargingStation.logPrefix()} Transaction with id ${requestPayload.transactionId.toString()} STOPPED on ${
+      chargingStation.stationInfo.chargingStationId
+    }#${transactionConnectorId?.toString()} with status '${
+      payload.idTagInfo?.status ?? 'undefined'
+    }'`;
+    if (
+      Utils.isNullOrUndefined(payload.idTagInfo) ||
+      payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED
+    ) {
+      logger.info(logMsg);
+    } else {
+      logger.warn(logMsg);
     }
-  }
-
-  private handleResponseStatusNotification(payload: StatusNotificationRequest, requestPayload: StatusNotificationResponse): void {
-    logger.debug(this.chargingStation.logPrefix() + ' Status notification response received: %j to StatusNotification request: %j', payload, requestPayload);
-  }
-
-  private handleResponseMeterValues(payload: MeterValuesRequest, requestPayload: MeterValuesResponse): void {
-    logger.debug(this.chargingStation.logPrefix() + ' MeterValues response received: %j to MeterValues request: %j', payload, requestPayload);
   }
 }