X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2F1.6%2FOCPP16IncomingRequestService.ts;h=fbb76bec08790bb50126d4fb3557e3a8a7a194c9;hb=0eb666db012bc0c088e0b8c144381dfafbbeccf4;hp=50c46f29553109b3618c00b31ad55e32c87b6be9;hpb=5edd8ba0f8978cfb3ca9d80f299d9748c6c5970e;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/ocpp/1.6/OCPP16IncomingRequestService.ts b/src/charging-station/ocpp/1.6/OCPP16IncomingRequestService.ts
index 50c46f29..fbb76bec 100644
--- a/src/charging-station/ocpp/1.6/OCPP16IncomingRequestService.ts
+++ b/src/charging-station/ocpp/1.6/OCPP16IncomingRequestService.ts
@@ -6,24 +6,34 @@ import { URL, fileURLToPath } from 'node:url';
 
 import type { JSONSchemaType } from 'ajv';
 import { Client, type FTPResponse } from 'basic-ftp';
+import {
+  addSeconds,
+  isDate,
+  isWithinInterval,
+  maxTime,
+  min,
+  secondsToMilliseconds,
+} from 'date-fns';
 import { create } from 'tar';
 
 import { OCPP16Constants } from './OCPP16Constants';
 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
 import {
   type ChargingStation,
-  ChargingStationConfigurationUtils,
+  canProceedChargingProfile,
   checkChargingStation,
+  getConfigurationKey,
+  prepareChargingProfileKind,
+  removeExpiredReservations,
+  setConfigurationKeyValue,
 } from '../../../charging-station';
 import { OCPPError } from '../../../exception';
 import {
-  type ChangeAvailabilityRequest,
-  type ChangeAvailabilityResponse,
   type ChangeConfigurationRequest,
   type ChangeConfigurationResponse,
+  ChargingRateUnitType,
   type ClearChargingProfileRequest,
   type ClearChargingProfileResponse,
-  type ConnectorStatus,
   ErrorType,
   type GenericResponse,
   GenericStatus,
@@ -39,6 +49,8 @@ import {
   type OCPP16BootNotificationRequest,
   type OCPP16BootNotificationResponse,
   type OCPP16CancelReservationRequest,
+  type OCPP16ChangeAvailabilityRequest,
+  type OCPP16ChangeAvailabilityResponse,
   OCPP16ChargePointErrorCode,
   OCPP16ChargePointStatus,
   type OCPP16ChargingProfile,
@@ -78,17 +90,16 @@ import {
   OCPPVersion,
   type RemoteStartTransactionRequest,
   type RemoteStopTransactionRequest,
-  ReservationFilterKey,
   ReservationTerminationReason,
   type ResetRequest,
   type SetChargingProfileRequest,
   type SetChargingProfileResponse,
-  type StartTransactionRequest,
   type UnlockConnectorRequest,
   type UnlockConnectorResponse,
 } from '../../../types';
 import {
   Constants,
+  cloneObject,
   convertToDate,
   convertToInt,
   formatDurationMilliSeconds,
@@ -98,6 +109,7 @@ import {
   isNotEmptyString,
   isNullOrUndefined,
   isUndefined,
+  isValidTime,
   logger,
   sleep,
 } from '../../../utils';
@@ -115,49 +127,73 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     // }
     super(OCPPVersion.VERSION_16);
     this.incomingRequestHandlers = new Map<OCPP16IncomingRequestCommand, IncomingRequestHandler>([
-      [OCPP16IncomingRequestCommand.RESET, this.handleRequestReset.bind(this)],
-      [OCPP16IncomingRequestCommand.CLEAR_CACHE, this.handleRequestClearCache.bind(this)],
-      [OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR, this.handleRequestUnlockConnector.bind(this)],
+      [
+        OCPP16IncomingRequestCommand.RESET,
+        this.handleRequestReset.bind(this) as unknown as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.CLEAR_CACHE,
+        this.handleRequestClearCache.bind(this) as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR,
+        this.handleRequestUnlockConnector.bind(this) as unknown as IncomingRequestHandler,
+      ],
       [
         OCPP16IncomingRequestCommand.GET_CONFIGURATION,
-        this.handleRequestGetConfiguration.bind(this),
+        this.handleRequestGetConfiguration.bind(this) as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
-        this.handleRequestChangeConfiguration.bind(this),
+        this.handleRequestChangeConfiguration.bind(this) as unknown as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE,
-        this.handleRequestGetCompositeSchedule.bind(this),
+        this.handleRequestGetCompositeSchedule.bind(this) as unknown as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
-        this.handleRequestSetChargingProfile.bind(this),
+        this.handleRequestSetChargingProfile.bind(this) as unknown as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
-        this.handleRequestClearChargingProfile.bind(this),
+        this.handleRequestClearChargingProfile.bind(this) as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
-        this.handleRequestChangeAvailability.bind(this),
+        this.handleRequestChangeAvailability.bind(this) as unknown as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
-        this.handleRequestRemoteStartTransaction.bind(this),
+        this.handleRequestRemoteStartTransaction.bind(this) as unknown as IncomingRequestHandler,
       ],
       [
         OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
-        this.handleRequestRemoteStopTransaction.bind(this),
+        this.handleRequestRemoteStopTransaction.bind(this) as unknown as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
+        this.handleRequestGetDiagnostics.bind(this) as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
+        this.handleRequestTriggerMessage.bind(this) as unknown as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.DATA_TRANSFER,
+        this.handleRequestDataTransfer.bind(this) as unknown as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.UPDATE_FIRMWARE,
+        this.handleRequestUpdateFirmware.bind(this) as unknown as IncomingRequestHandler,
+      ],
+      [
+        OCPP16IncomingRequestCommand.RESERVE_NOW,
+        this.handleRequestReserveNow.bind(this) as unknown as IncomingRequestHandler,
       ],
-      [OCPP16IncomingRequestCommand.GET_DIAGNOSTICS, this.handleRequestGetDiagnostics.bind(this)],
-      [OCPP16IncomingRequestCommand.TRIGGER_MESSAGE, this.handleRequestTriggerMessage.bind(this)],
-      [OCPP16IncomingRequestCommand.DATA_TRANSFER, this.handleRequestDataTransfer.bind(this)],
-      [OCPP16IncomingRequestCommand.UPDATE_FIRMWARE, this.handleRequestUpdateFirmware.bind(this)],
-      [OCPP16IncomingRequestCommand.RESERVE_NOW, this.handleRequestReserveNow.bind(this)],
       [
         OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
-        this.handleRequestCancelReservation.bind(this),
+        this.handleRequestCancelReservation.bind(this) as unknown as IncomingRequestHandler,
       ],
     ]);
     this.jsonSchemas = new Map<OCPP16IncomingRequestCommand, JSONSchemaType<JsonObject>>([
@@ -235,7 +271,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       ],
       [
         OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
-        OCPP16ServiceUtils.parseJsonSchemaFile<ChangeAvailabilityRequest>(
+        OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ChangeAvailabilityRequest>(
           'assets/json-schemas/ocpp/1.6/ChangeAvailability.json',
           moduleName,
           'constructor',
@@ -305,13 +341,13 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     ) => boolean;
   }
 
-  public async incomingRequestHandler(
+  public async incomingRequestHandler<ReqType extends JsonType, ResType extends JsonType>(
     chargingStation: ChargingStation,
     messageId: string,
     commandName: OCPP16IncomingRequestCommand,
-    commandPayload: JsonType,
+    commandPayload: ReqType,
   ): Promise<void> {
-    let response: JsonType;
+    let response: ResType;
     if (
       chargingStation.getOcppStrictCompliance() === true &&
       chargingStation.inPendingState() === true &&
@@ -341,10 +377,10 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
         try {
           this.validatePayload(chargingStation, commandName, commandPayload);
           // Call the method to build the response
-          response = await this.incomingRequestHandlers.get(commandName)(
+          response = (await this.incomingRequestHandlers.get(commandName)!(
             chargingStation,
             commandPayload,
-          );
+          )) as ResType;
         } catch (error) {
           // Log
           logger.error(
@@ -397,7 +433,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       return this.validateIncomingRequestPayload(
         chargingStation,
         commandName,
-        this.jsonSchemas.get(commandName),
+        this.jsonSchemas.get(commandName)!,
         commandPayload,
       );
     }
@@ -413,19 +449,18 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     chargingStation: ChargingStation,
     commandPayload: ResetRequest,
   ): GenericResponse {
+    const { type } = commandPayload;
     this.runInAsyncScope(
       chargingStation.reset.bind(chargingStation) as (
         this: ChargingStation,
-        ...args: any[]
+        ...args: unknown[]
       ) => Promise<void>,
       chargingStation,
-      `${commandPayload.type}Reset` as OCPP16StopTransactionReason,
+      `${type}Reset` as OCPP16StopTransactionReason,
     ).catch(Constants.EMPTY_FUNCTION);
     logger.info(
-      `${chargingStation.logPrefix()} ${
-        commandPayload.type
-      } reset command received, simulating it. The station will be
-        back online in ${formatDurationMilliSeconds(chargingStation.stationInfo.resetTime)}`,
+      `${chargingStation.logPrefix()} ${type} reset command received, simulating it. The station will be
+        back online in ${formatDurationMilliSeconds(chargingStation.stationInfo.resetTime!)}`,
     );
     return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
   }
@@ -434,7 +469,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     chargingStation: ChargingStation,
     commandPayload: UnlockConnectorRequest,
   ): Promise<UnlockConnectorResponse> {
-    const connectorId = commandPayload.connectorId;
+    const { connectorId } = commandPayload;
     if (chargingStation.hasConnector(connectorId) === false) {
       logger.error(
         `${chargingStation.logPrefix()} Trying to unlock a non existing
@@ -470,10 +505,11 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     chargingStation: ChargingStation,
     commandPayload: GetConfigurationRequest,
   ): GetConfigurationResponse {
+    const { key } = commandPayload;
     const configurationKey: OCPPConfigurationKey[] = [];
     const unknownKey: string[] = [];
-    if (isUndefined(commandPayload.key) === true) {
-      for (const configuration of chargingStation.ocppConfiguration.configurationKey) {
+    if (isUndefined(key) === true) {
+      for (const configuration of chargingStation.ocppConfiguration!.configurationKey!) {
         if (isUndefined(configuration.visible) === true) {
           configuration.visible = true;
         }
@@ -486,13 +522,9 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
           value: configuration.value,
         });
       }
-    } else if (isNotEmptyArray(commandPayload.key) === true) {
-      for (const key of commandPayload.key) {
-        const keyFound = ChargingStationConfigurationUtils.getConfigurationKey(
-          chargingStation,
-          key,
-          true,
-        );
+    } else if (isNotEmptyArray(key) === true) {
+      for (const k of key!) {
+        const keyFound = getConfigurationKey(chargingStation, k, true);
         if (keyFound) {
           if (isUndefined(keyFound.visible) === true) {
             keyFound.visible = true;
@@ -506,7 +538,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
             value: keyFound.value,
           });
         } else {
-          unknownKey.push(key);
+          unknownKey.push(k);
         }
       }
     }
@@ -520,47 +552,49 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     chargingStation: ChargingStation,
     commandPayload: ChangeConfigurationRequest,
   ): ChangeConfigurationResponse {
-    const keyToChange = ChargingStationConfigurationUtils.getConfigurationKey(
-      chargingStation,
-      commandPayload.key,
-      true,
-    );
-    if (!keyToChange) {
-      return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
-    } else if (keyToChange?.readonly === true) {
+    const { key, value } = commandPayload;
+    const keyToChange = getConfigurationKey(chargingStation, key, true);
+    if (keyToChange?.readonly === true) {
       return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_REJECTED;
     } else if (keyToChange?.readonly === false) {
       let valueChanged = false;
-      if (keyToChange.value !== commandPayload.value) {
-        ChargingStationConfigurationUtils.setConfigurationKeyValue(
-          chargingStation,
-          commandPayload.key,
-          commandPayload.value,
-          true,
-        );
+      if (keyToChange.value !== value) {
+        setConfigurationKeyValue(chargingStation, key, value, true);
         valueChanged = true;
       }
       let triggerHeartbeatRestart = false;
-      if (keyToChange.key === OCPP16StandardParametersKey.HeartBeatInterval && valueChanged) {
-        ChargingStationConfigurationUtils.setConfigurationKeyValue(
+      if (
+        (keyToChange.key as OCPP16StandardParametersKey) ===
+          OCPP16StandardParametersKey.HeartBeatInterval &&
+        valueChanged
+      ) {
+        setConfigurationKeyValue(
           chargingStation,
           OCPP16StandardParametersKey.HeartbeatInterval,
-          commandPayload.value,
+          value,
         );
         triggerHeartbeatRestart = true;
       }
-      if (keyToChange.key === OCPP16StandardParametersKey.HeartbeatInterval && valueChanged) {
-        ChargingStationConfigurationUtils.setConfigurationKeyValue(
+      if (
+        (keyToChange.key as OCPP16StandardParametersKey) ===
+          OCPP16StandardParametersKey.HeartbeatInterval &&
+        valueChanged
+      ) {
+        setConfigurationKeyValue(
           chargingStation,
           OCPP16StandardParametersKey.HeartBeatInterval,
-          commandPayload.value,
+          value,
         );
         triggerHeartbeatRestart = true;
       }
       if (triggerHeartbeatRestart) {
         chargingStation.restartHeartbeat();
       }
-      if (keyToChange.key === OCPP16StandardParametersKey.WebSocketPingInterval && valueChanged) {
+      if (
+        (keyToChange.key as OCPP16StandardParametersKey) ===
+          OCPP16StandardParametersKey.WebSocketPingInterval &&
+        valueChanged
+      ) {
         chargingStation.restartWebSocketPing();
       }
       if (keyToChange.reboot) {
@@ -568,6 +602,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       }
       return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_ACCEPTED;
     }
+    return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
   }
 
   private handleRequestSetChargingProfile(
@@ -583,43 +618,36 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     ) {
       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_NOT_SUPPORTED;
     }
-    if (chargingStation.hasConnector(commandPayload.connectorId) === false) {
+    const { connectorId, csChargingProfiles } = commandPayload;
+    if (chargingStation.hasConnector(connectorId) === false) {
       logger.error(
         `${chargingStation.logPrefix()} Trying to set charging profile(s) to a
-          non existing connector id ${commandPayload.connectorId}`,
+          non existing connector id ${connectorId}`,
       );
       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
     }
     if (
-      commandPayload.csChargingProfiles.chargingProfilePurpose ===
+      csChargingProfiles.chargingProfilePurpose ===
         OCPP16ChargingProfilePurposeType.CHARGE_POINT_MAX_PROFILE &&
-      commandPayload.connectorId !== 0
+      connectorId !== 0
     ) {
       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
     }
     if (
-      commandPayload.csChargingProfiles.chargingProfilePurpose ===
-        OCPP16ChargingProfilePurposeType.TX_PROFILE &&
-      (commandPayload.connectorId === 0 ||
-        chargingStation.getConnectorStatus(commandPayload.connectorId)?.transactionStarted ===
-          false)
+      csChargingProfiles.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE &&
+      (connectorId === 0 ||
+        chargingStation.getConnectorStatus(connectorId)?.transactionStarted === false)
     ) {
       logger.error(
         `${chargingStation.logPrefix()} Trying to set transaction charging profile(s)
-          on connector ${commandPayload.connectorId} without a started transaction`,
+          on connector ${connectorId} without a started transaction`,
       );
       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
     }
-    OCPP16ServiceUtils.setChargingProfile(
-      chargingStation,
-      commandPayload.connectorId,
-      commandPayload.csChargingProfiles,
-    );
+    OCPP16ServiceUtils.setChargingProfile(chargingStation, connectorId, csChargingProfiles);
     logger.debug(
-      `${chargingStation.logPrefix()} Charging profile(s) set on connector id ${
-        commandPayload.connectorId
-      }: %j`,
-      commandPayload.csChargingProfiles,
+      `${chargingStation.logPrefix()} Charging profile(s) set on connector id ${connectorId}: %j`,
+      csChargingProfiles,
     );
     return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_ACCEPTED;
   }
@@ -632,41 +660,140 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       OCPP16ServiceUtils.checkFeatureProfile(
         chargingStation,
         OCPP16SupportedFeatureProfiles.SmartCharging,
-        OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
+        OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE,
       ) === false
     ) {
       return OCPP16Constants.OCPP_RESPONSE_REJECTED;
     }
-    if (chargingStation.hasConnector(commandPayload.connectorId) === false) {
+    const { connectorId, duration, chargingRateUnit } = commandPayload;
+    if (chargingStation.hasConnector(connectorId) === false) {
       logger.error(
         `${chargingStation.logPrefix()} Trying to get composite schedule to a
-          non existing connector id ${commandPayload.connectorId}`,
+          non existing connector id ${connectorId}`,
+      );
+      return OCPP16Constants.OCPP_RESPONSE_REJECTED;
+    }
+    if (connectorId === 0) {
+      logger.error(
+        `${chargingStation.logPrefix()} Get composite schedule on connector id ${connectorId} is not yet supported`,
+      );
+      return OCPP16Constants.OCPP_RESPONSE_REJECTED;
+    }
+    if (chargingRateUnit) {
+      logger.error(
+        `${chargingStation.logPrefix()} Get composite schedule with a specified rate unit is not yet supported`,
       );
       return OCPP16Constants.OCPP_RESPONSE_REJECTED;
     }
+    const connectorStatus = chargingStation.getConnectorStatus(connectorId)!;
     if (
-      isEmptyArray(chargingStation.getConnectorStatus(commandPayload.connectorId)?.chargingProfiles)
+      isEmptyArray(
+        connectorStatus?.chargingProfiles &&
+          isEmptyArray(chargingStation.getConnectorStatus(0)?.chargingProfiles),
+      )
     ) {
       return OCPP16Constants.OCPP_RESPONSE_REJECTED;
     }
-    const startDate = new Date();
-    const endDate = new Date(startDate.getTime() + commandPayload.duration * 1000);
-    let compositeSchedule: OCPP16ChargingSchedule;
-    for (const chargingProfile of chargingStation.getConnectorStatus(commandPayload.connectorId)
-      .chargingProfiles) {
-      // FIXME: build the composite schedule including the local power limit, the stack level, the charging rate unit, etc.
+    const currentDate = new Date();
+    const interval: Interval = {
+      start: currentDate,
+      end: addSeconds(currentDate, duration),
+    };
+    const chargingProfiles: OCPP16ChargingProfile[] = [];
+    for (const chargingProfile of cloneObject<OCPP16ChargingProfile[]>(
+      (connectorStatus?.chargingProfiles ?? []).concat(
+        chargingStation.getConnectorStatus(0)?.chargingProfiles ?? [],
+      ),
+    ).sort((a, b) => b.stackLevel - a.stackLevel)) {
+      if (
+        connectorStatus?.transactionStarted &&
+        isNullOrUndefined(chargingProfile.chargingSchedule?.startSchedule)
+      ) {
+        logger.debug(
+          `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetCompositeSchedule: Charging profile id ${
+            chargingProfile.chargingProfileId
+          } has no startSchedule defined. Trying to set it to the connector current transaction start date`,
+        );
+        // OCPP specifies that if startSchedule is not defined, it should be relative to start of the connector transaction
+        chargingProfile.chargingSchedule.startSchedule = connectorStatus?.transactionStart;
+      }
+      if (!isDate(chargingProfile.chargingSchedule?.startSchedule)) {
+        logger.warn(
+          `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetCompositeSchedule: Charging profile id ${
+            chargingProfile.chargingProfileId
+          } startSchedule property is not a Date object. Trying to convert it to a Date object`,
+        );
+        chargingProfile.chargingSchedule.startSchedule = convertToDate(
+          chargingProfile.chargingSchedule?.startSchedule,
+        )!;
+      }
+      if (
+        !prepareChargingProfileKind(
+          connectorStatus,
+          chargingProfile,
+          interval.start as Date,
+          chargingStation.logPrefix(),
+        )
+      ) {
+        continue;
+      }
+      if (
+        !canProceedChargingProfile(
+          chargingProfile,
+          interval.start as Date,
+          chargingStation.logPrefix(),
+        )
+      ) {
+        continue;
+      }
+      // Add active charging profiles into chargingProfiles array
       if (
-        chargingProfile.chargingSchedule?.startSchedule >= startDate &&
-        chargingProfile.chargingSchedule?.startSchedule <= endDate
+        isValidTime(chargingProfile.chargingSchedule?.startSchedule) &&
+        isWithinInterval(chargingProfile.chargingSchedule.startSchedule!, interval)
       ) {
-        compositeSchedule = chargingProfile.chargingSchedule;
-        break;
+        chargingProfiles.push(chargingProfile);
       }
     }
+    const compositeSchedule: OCPP16ChargingSchedule = {
+      startSchedule: min(
+        chargingProfiles.map(
+          (chargingProfile) => chargingProfile.chargingSchedule.startSchedule ?? maxTime,
+        ),
+      ),
+      duration: Math.max(
+        ...chargingProfiles.map(
+          (chargingProfile) => chargingProfile.chargingSchedule.duration ?? -Infinity,
+        ),
+      ),
+      chargingRateUnit: chargingProfiles.every(
+        (chargingProfile) =>
+          chargingProfile.chargingSchedule.chargingRateUnit === ChargingRateUnitType.AMPERE,
+      )
+        ? ChargingRateUnitType.AMPERE
+        : chargingProfiles.every(
+            (chargingProfile) =>
+              chargingProfile.chargingSchedule.chargingRateUnit === ChargingRateUnitType.WATT,
+          )
+        ? ChargingRateUnitType.WATT
+        : ChargingRateUnitType.AMPERE,
+      // FIXME: remove overlapping charging schedule periods
+      chargingSchedulePeriod: chargingProfiles
+        .map((chargingProfile) => chargingProfile.chargingSchedule.chargingSchedulePeriod)
+        .reduce(
+          (accumulator, value) =>
+            accumulator.concat(value).sort((a, b) => a.startPeriod - b.startPeriod),
+          [],
+        ),
+      minChargeRate: Math.min(
+        ...chargingProfiles.map(
+          (chargingProfile) => chargingProfile.chargingSchedule.minChargeRate ?? Infinity,
+        ),
+      ),
+    };
     return {
       status: GenericStatus.Accepted,
-      scheduleStart: compositeSchedule?.startSchedule,
-      connectorId: commandPayload.connectorId,
+      scheduleStart: compositeSchedule.startSchedule!,
+      connectorId,
       chargingSchedule: compositeSchedule,
     };
   }
@@ -684,76 +811,43 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     ) {
       return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
     }
-    if (chargingStation.hasConnector(commandPayload.connectorId) === false) {
+    const { connectorId } = commandPayload;
+    if (chargingStation.hasConnector(connectorId!) === false) {
       logger.error(
         `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to
-          a non existing connector id ${commandPayload.connectorId}`,
+          a non existing connector id ${connectorId}`,
       );
       return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
     }
     if (
-      !isNullOrUndefined(commandPayload.connectorId) &&
-      isNotEmptyArray(
-        chargingStation.getConnectorStatus(commandPayload.connectorId)?.chargingProfiles,
-      )
+      !isNullOrUndefined(connectorId) &&
+      isNotEmptyArray(chargingStation.getConnectorStatus(connectorId!)?.chargingProfiles)
     ) {
-      chargingStation.getConnectorStatus(commandPayload.connectorId).chargingProfiles = [];
+      chargingStation.getConnectorStatus(connectorId!)!.chargingProfiles = [];
       logger.debug(
-        `${chargingStation.logPrefix()} Charging profile(s) cleared on connector id ${
-          commandPayload.connectorId
-        }`,
+        `${chargingStation.logPrefix()} Charging profile(s) cleared on connector id ${connectorId}`,
       );
       return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
     }
-    if (isNullOrUndefined(commandPayload.connectorId)) {
+    if (isNullOrUndefined(connectorId)) {
       let clearedCP = false;
-      const clearChargingProfiles = (connectorStatus: ConnectorStatus) => {
-        if (isNotEmptyArray(connectorStatus?.chargingProfiles)) {
-          connectorStatus?.chargingProfiles?.forEach(
-            (chargingProfile: OCPP16ChargingProfile, index: number) => {
-              let clearCurrentCP = false;
-              if (chargingProfile.chargingProfileId === commandPayload.id) {
-                clearCurrentCP = true;
-              }
-              if (
-                !commandPayload.chargingProfilePurpose &&
-                chargingProfile.stackLevel === commandPayload.stackLevel
-              ) {
-                clearCurrentCP = true;
-              }
-              if (
-                !chargingProfile.stackLevel &&
-                chargingProfile.chargingProfilePurpose === commandPayload.chargingProfilePurpose
-              ) {
-                clearCurrentCP = true;
-              }
-              if (
-                chargingProfile.stackLevel === commandPayload.stackLevel &&
-                chargingProfile.chargingProfilePurpose === commandPayload.chargingProfilePurpose
-              ) {
-                clearCurrentCP = true;
-              }
-              if (clearCurrentCP) {
-                connectorStatus?.chargingProfiles?.splice(index, 1);
-                logger.debug(
-                  `${chargingStation.logPrefix()} Matching charging profile(s) cleared: %j`,
-                  chargingProfile,
-                );
-                clearedCP = true;
-              }
-            },
-          );
-        }
-      };
       if (chargingStation.hasEvses) {
         for (const evseStatus of chargingStation.evses.values()) {
           for (const connectorStatus of evseStatus.connectors.values()) {
-            clearChargingProfiles(connectorStatus);
+            clearedCP = OCPP16ServiceUtils.clearChargingProfiles(
+              chargingStation,
+              commandPayload,
+              connectorStatus.chargingProfiles,
+            );
           }
         }
       } else {
-        for (const connectorId of chargingStation.connectors.keys()) {
-          clearChargingProfiles(chargingStation.getConnectorStatus(connectorId));
+        for (const id of chargingStation.connectors.keys()) {
+          clearedCP = OCPP16ServiceUtils.clearChargingProfiles(
+            chargingStation,
+            commandPayload,
+            chargingStation.getConnectorStatus(id)?.chargingProfiles,
+          );
         }
       }
       if (clearedCP) {
@@ -765,9 +859,9 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
 
   private async handleRequestChangeAvailability(
     chargingStation: ChargingStation,
-    commandPayload: ChangeAvailabilityRequest,
-  ): Promise<ChangeAvailabilityResponse> {
-    const connectorId: number = commandPayload.connectorId;
+    commandPayload: OCPP16ChangeAvailabilityRequest,
+  ): Promise<OCPP16ChangeAvailabilityResponse> {
+    const { connectorId, type } = commandPayload;
     if (chargingStation.hasConnector(connectorId) === false) {
       logger.error(
         `${chargingStation.logPrefix()} Trying to change the availability of a
@@ -776,48 +870,40 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
     }
     const chargePointStatus: OCPP16ChargePointStatus =
-      commandPayload.type === OCPP16AvailabilityType.Operative
+      type === OCPP16AvailabilityType.Operative
         ? OCPP16ChargePointStatus.Available
         : OCPP16ChargePointStatus.Unavailable;
     if (connectorId === 0) {
-      let response: ChangeAvailabilityResponse =
-        OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
-      const changeAvailability = async (id: number, connectorStatus: ConnectorStatus) => {
-        if (connectorStatus?.transactionStarted === true) {
-          response = OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
-        }
-        connectorStatus.availability = commandPayload.type;
-        if (response === OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED) {
-          await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+      let response: OCPP16ChangeAvailabilityResponse;
+      if (chargingStation.hasEvses) {
+        for (const evseStatus of chargingStation.evses.values()) {
+          response = await OCPP16ServiceUtils.changeAvailability(
             chargingStation,
-            id,
+            [...evseStatus.connectors.keys()],
             chargePointStatus,
+            type,
           );
         }
-      };
-      if (chargingStation.hasEvses) {
-        for (const evseStatus of chargingStation.evses.values()) {
-          for (const [id, connectorStatus] of evseStatus.connectors) {
-            await changeAvailability(id, connectorStatus);
-          }
-        }
       } else {
-        for (const id of chargingStation.connectors.keys()) {
-          await changeAvailability(id, chargingStation.getConnectorStatus(id));
-        }
+        response = await OCPP16ServiceUtils.changeAvailability(
+          chargingStation,
+          [...chargingStation.connectors.keys()],
+          chargePointStatus,
+          type,
+        );
       }
-      return response;
+      return response!;
     } else if (
       connectorId > 0 &&
       (chargingStation.isChargingStationAvailable() === true ||
         (chargingStation.isChargingStationAvailable() === false &&
-          commandPayload.type === OCPP16AvailabilityType.Inoperative))
+          type === OCPP16AvailabilityType.Inoperative))
     ) {
       if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
-        chargingStation.getConnectorStatus(connectorId).availability = commandPayload.type;
+        chargingStation.getConnectorStatus(connectorId)!.availability = type;
         return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
       }
-      chargingStation.getConnectorStatus(connectorId).availability = commandPayload.type;
+      chargingStation.getConnectorStatus(connectorId)!.availability = type;
       await OCPP16ServiceUtils.sendAndSetConnectorStatus(
         chargingStation,
         connectorId,
@@ -833,18 +919,6 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     commandPayload: RemoteStartTransactionRequest,
   ): Promise<GenericResponse> {
     const { connectorId: transactionConnectorId, idTag, chargingProfile } = commandPayload;
-    const reserved =
-      chargingStation.getConnectorStatus(transactionConnectorId).status ===
-      OCPP16ChargePointStatus.Reserved;
-    const reservedOnConnectorZero =
-      chargingStation.getConnectorStatus(0).status === OCPP16ChargePointStatus.Reserved;
-    if (
-      (reserved &&
-        !chargingStation.validateIncomingRequestWithReservation(transactionConnectorId, idTag)) ||
-      (reservedOnConnectorZero && !chargingStation.validateIncomingRequestWithReservation(0, idTag))
-    ) {
-      return OCPP16Constants.OCPP_RESPONSE_REJECTED;
-    }
     if (chargingStation.hasConnector(transactionConnectorId) === false) {
       return this.notifyRemoteStartTransactionRejected(
         chargingStation,
@@ -871,10 +945,10 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       transactionConnectorId,
       OCPP16ChargePointStatus.Preparing,
     );
-    const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId);
-    // Check if authorized
+    const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId)!;
+    // Authorization check required
     if (
-      chargingStation.getAuthorizeRemoteTxRequests() &&
+      chargingStation.getAuthorizeRemoteTxRequests() === true &&
       (await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, transactionConnectorId, idTag))
     ) {
       // Authorization successful, start transaction
@@ -882,31 +956,19 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
         this.setRemoteStartTransactionChargingProfile(
           chargingStation,
           transactionConnectorId,
-          chargingProfile,
+          chargingProfile!,
         ) === true
       ) {
         connectorStatus.transactionRemoteStarted = true;
-        const startTransactionPayload: Partial<StartTransactionRequest> = {
-          connectorId: transactionConnectorId,
-          idTag,
-        };
-        if (reserved || reservedOnConnectorZero) {
-          const reservation = chargingStation.getReservationBy(
-            ReservationFilterKey.CONNECTOR_ID,
-            reservedOnConnectorZero ? 0 : transactionConnectorId,
-          );
-          startTransactionPayload.reservationId = reservation.id;
-          await chargingStation.removeReservation(
-            reservation,
-            ReservationTerminationReason.TRANSACTION_STARTED,
-          );
-        }
         if (
           (
             await chargingStation.ocppRequestService.requestHandler<
               OCPP16StartTransactionRequest,
               OCPP16StartTransactionResponse
-            >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, startTransactionPayload)
+            >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
+              connectorId: transactionConnectorId,
+              idTag,
+            })
           ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
         ) {
           logger.debug(remoteStartTransactionLogMsg);
@@ -929,7 +991,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       this.setRemoteStartTransactionChargingProfile(
         chargingStation,
         transactionConnectorId,
-        chargingProfile,
+        chargingProfile!,
       ) === true
     ) {
       connectorStatus.transactionRemoteStarted = true;
@@ -986,54 +1048,44 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
   private setRemoteStartTransactionChargingProfile(
     chargingStation: ChargingStation,
     connectorId: number,
-    cp: OCPP16ChargingProfile,
+    chargingProfile: OCPP16ChargingProfile,
   ): boolean {
-    if (cp && cp.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE) {
-      OCPP16ServiceUtils.setChargingProfile(chargingStation, connectorId, cp);
+    if (
+      chargingProfile &&
+      chargingProfile.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE
+    ) {
+      OCPP16ServiceUtils.setChargingProfile(chargingStation, connectorId, chargingProfile);
       logger.debug(
         `${chargingStation.logPrefix()} Charging profile(s) set at remote start transaction
           on connector id ${connectorId}: %j`,
-        cp,
+        chargingProfile,
       );
       return true;
-    } else if (cp && cp.chargingProfilePurpose !== OCPP16ChargingProfilePurposeType.TX_PROFILE) {
+    } else if (
+      chargingProfile &&
+      chargingProfile.chargingProfilePurpose !== OCPP16ChargingProfilePurposeType.TX_PROFILE
+    ) {
       logger.warn(
         `${chargingStation.logPrefix()} Not allowed to set ${
-          cp.chargingProfilePurpose
+          chargingProfile.chargingProfilePurpose
         } charging profile(s) at remote start transaction`,
       );
       return false;
-    } else if (!cp) {
-      return true;
     }
+    return true;
   }
 
   private async handleRequestRemoteStopTransaction(
     chargingStation: ChargingStation,
     commandPayload: RemoteStopTransactionRequest,
   ): Promise<GenericResponse> {
-    const transactionId = commandPayload.transactionId;
-    const remoteStopTransaction = async (connectorId: number): Promise<GenericResponse> => {
-      await OCPP16ServiceUtils.sendAndSetConnectorStatus(
-        chargingStation,
-        connectorId,
-        OCPP16ChargePointStatus.Finishing,
-      );
-      const stopResponse = await chargingStation.stopTransactionOnConnector(
-        connectorId,
-        OCPP16StopTransactionReason.REMOTE,
-      );
-      if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
-        return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
-      }
-      return OCPP16Constants.OCPP_RESPONSE_REJECTED;
-    };
+    const { transactionId } = commandPayload;
     if (chargingStation.hasEvses) {
       for (const [evseId, evseStatus] of chargingStation.evses) {
         if (evseId > 0) {
           for (const [connectorId, connectorStatus] of evseStatus.connectors) {
             if (connectorStatus.transactionId === transactionId) {
-              return remoteStopTransaction(connectorId);
+              return OCPP16ServiceUtils.remoteStopTransaction(chargingStation, connectorId);
             }
           }
         }
@@ -1044,12 +1096,12 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
           connectorId > 0 &&
           chargingStation.getConnectorStatus(connectorId)?.transactionId === transactionId
         ) {
-          return remoteStopTransaction(connectorId);
+          return OCPP16ServiceUtils.remoteStopTransaction(chargingStation, connectorId);
         }
       }
     }
     logger.warn(
-      `${chargingStation.logPrefix()} Trying to remote stop a non existing transaction with id:
+      `${chargingStation.logPrefix()} Trying to remote stop a non existing transaction with id
         ${transactionId.toString()}`,
     );
     return OCPP16Constants.OCPP_RESPONSE_REJECTED;
@@ -1072,6 +1124,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       );
       return OCPP16Constants.OCPP_RESPONSE_EMPTY;
     }
+    let { retrieveDate } = commandPayload;
     if (
       !isNullOrUndefined(chargingStation.stationInfo.firmwareStatus) &&
       chargingStation.stationInfo.firmwareStatus !== OCPP16FirmwareStatus.Installed
@@ -1082,13 +1135,13 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       );
       return OCPP16Constants.OCPP_RESPONSE_EMPTY;
     }
-    const retrieveDate = convertToDate(commandPayload.retrieveDate);
+    retrieveDate = convertToDate(retrieveDate)!;
     const now = Date.now();
     if (retrieveDate?.getTime() <= now) {
       this.runInAsyncScope(
         this.updateFirmwareSimulation.bind(this) as (
           this: OCPP16IncomingRequestService,
-          ...args: any[]
+          ...args: unknown[]
         ) => Promise<void>,
         this,
         chargingStation,
@@ -1099,7 +1152,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
           this.runInAsyncScope(
             this.updateFirmwareSimulation.bind(this) as (
               this: OCPP16IncomingRequestService,
-              ...args: any[]
+              ...args: unknown[]
             ) => Promise<void>,
             this,
             chargingStation,
@@ -1158,7 +1211,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       chargingStation.stationInfo?.firmwareUpgrade?.failureStatus ===
       OCPP16FirmwareStatus.DownloadFailed
     ) {
-      await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
+      await sleep(secondsToMilliseconds(getRandomInteger(maxDelay, minDelay)));
       await chargingStation.ocppRequestService.requestHandler<
         OCPP16FirmwareStatusNotificationRequest,
         OCPP16FirmwareStatusNotificationResponse
@@ -1169,7 +1222,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
         chargingStation.stationInfo?.firmwareUpgrade?.failureStatus;
       return;
     }
-    await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
+    await sleep(secondsToMilliseconds(getRandomInteger(maxDelay, minDelay)));
     await chargingStation.ocppRequestService.requestHandler<
       OCPP16FirmwareStatusNotificationRequest,
       OCPP16FirmwareStatusNotificationResponse
@@ -1182,12 +1235,12 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     do {
       const runningTransactions = chargingStation.getNumberOfRunningTransactions();
       if (runningTransactions > 0) {
-        const waitTime = 15 * 1000;
+        const waitTime = secondsToMilliseconds(15);
         logger.debug(
           `${chargingStation.logPrefix()} ${moduleName}.updateFirmwareSimulation:
-            ${runningTransactions} transaction(s) in progress, waiting ${
-              waitTime / 1000
-            } seconds before continuing firmware update simulation`,
+            ${runningTransactions} transaction(s) in progress, waiting ${formatDurationMilliSeconds(
+              waitTime,
+            )} before continuing firmware update simulation`,
         );
         await sleep(waitTime);
         transactionsStarted = true;
@@ -1225,7 +1278,8 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
         transactionsStarted = false;
       }
     } while (transactionsStarted);
-    !wasTransactionsStarted && (await sleep(getRandomInteger(maxDelay, minDelay) * 1000));
+    !wasTransactionsStarted &&
+      (await sleep(secondsToMilliseconds(getRandomInteger(maxDelay, minDelay))));
     if (checkChargingStation(chargingStation, chargingStation.logPrefix()) === false) {
       return;
     }
@@ -1240,7 +1294,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       chargingStation.stationInfo?.firmwareUpgrade?.failureStatus ===
       OCPP16FirmwareStatus.InstallationFailed
     ) {
-      await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
+      await sleep(secondsToMilliseconds(getRandomInteger(maxDelay, minDelay)));
       await chargingStation.ocppRequestService.requestHandler<
         OCPP16FirmwareStatusNotificationRequest,
         OCPP16FirmwareStatusNotificationResponse
@@ -1252,7 +1306,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       return;
     }
     if (chargingStation.stationInfo?.firmwareUpgrade?.reset === true) {
-      await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
+      await sleep(secondsToMilliseconds(getRandomInteger(maxDelay, minDelay)));
       await chargingStation.reset(OCPP16StopTransactionReason.REBOOT);
     }
   }
@@ -1274,9 +1328,10 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       );
       return OCPP16Constants.OCPP_RESPONSE_EMPTY;
     }
-    const uri = new URL(commandPayload.location);
+    const { location } = commandPayload;
+    const uri = new URL(location);
     if (uri.protocol.startsWith('ftp:')) {
-      let ftpClient: Client;
+      let ftpClient: Client | undefined;
       try {
         const logFiles = readdirSync(resolve(dirname(fileURLToPath(import.meta.url)), '../'))
           .filter((file) => file.endsWith('.log'))
@@ -1290,11 +1345,11 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
           ...(isNotEmptyString(uri.username) && { user: uri.username }),
           ...(isNotEmptyString(uri.password) && { password: uri.password }),
         });
-        let uploadResponse: FTPResponse;
+        let uploadResponse: FTPResponse | undefined;
         if (accessResponse.code === 220) {
           ftpClient.trackProgress((info) => {
             logger.info(
-              `${chargingStation.logPrefix()} ${
+              `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: ${
                 info.bytes / 1024
               } bytes transferred from diagnostics archive ${info.name}`,
             );
@@ -1354,12 +1409,12 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
         if (ftpClient) {
           ftpClient.close();
         }
-        return this.handleIncomingRequestError(
+        return this.handleIncomingRequestError<GetDiagnosticsResponse>(
           chargingStation,
           OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
           error as Error,
           { errorResponse: OCPP16Constants.OCPP_RESPONSE_EMPTY },
-        );
+        )!;
       }
     } else {
       logger.error(
@@ -1381,16 +1436,14 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     chargingStation: ChargingStation,
     commandPayload: OCPP16TriggerMessageRequest,
   ): OCPP16TriggerMessageResponse {
+    const { requestedMessage, connectorId } = commandPayload;
     if (
       !OCPP16ServiceUtils.checkFeatureProfile(
         chargingStation,
         OCPP16SupportedFeatureProfiles.RemoteTrigger,
         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
       ) ||
-      !OCPP16ServiceUtils.isMessageTriggerSupported(
-        chargingStation,
-        commandPayload.requestedMessage,
-      )
+      !OCPP16ServiceUtils.isMessageTriggerSupported(chargingStation, requestedMessage)
     ) {
       return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
     }
@@ -1398,13 +1451,13 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       !OCPP16ServiceUtils.isConnectorIdValid(
         chargingStation,
         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
-        commandPayload.connectorId,
+        connectorId!,
       )
     ) {
       return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED;
     }
     try {
-      switch (commandPayload.requestedMessage) {
+      switch (requestedMessage) {
         case OCPP16MessageTrigger.BootNotification:
           setTimeout(() => {
             chargingStation.ocppRequestService
@@ -1436,15 +1489,15 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
           return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
         case OCPP16MessageTrigger.StatusNotification:
           setTimeout(() => {
-            if (!isNullOrUndefined(commandPayload?.connectorId)) {
+            if (!isNullOrUndefined(connectorId)) {
               chargingStation.ocppRequestService
                 .requestHandler<OCPP16StatusNotificationRequest, OCPP16StatusNotificationResponse>(
                   chargingStation,
                   OCPP16RequestCommand.STATUS_NOTIFICATION,
                   {
-                    connectorId: commandPayload.connectorId,
+                    connectorId,
                     errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
-                    status: chargingStation.getConnectorStatus(commandPayload.connectorId)?.status,
+                    status: chargingStation.getConnectorStatus(connectorId!)?.status,
                   },
                   {
                     triggerMessage: true,
@@ -1455,7 +1508,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
               // eslint-disable-next-line no-lonely-if
               if (chargingStation.hasEvses) {
                 for (const evseStatus of chargingStation.evses.values()) {
-                  for (const [connectorId, connectorStatus] of evseStatus.connectors) {
+                  for (const [id, connectorStatus] of evseStatus.connectors) {
                     chargingStation.ocppRequestService
                       .requestHandler<
                         OCPP16StatusNotificationRequest,
@@ -1464,7 +1517,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
                         chargingStation,
                         OCPP16RequestCommand.STATUS_NOTIFICATION,
                         {
-                          connectorId,
+                          connectorId: id,
                           errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
                           status: connectorStatus.status,
                         },
@@ -1476,7 +1529,7 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
                   }
                 }
               } else {
-                for (const connectorId of chargingStation.connectors.keys()) {
+                for (const id of chargingStation.connectors.keys()) {
                   chargingStation.ocppRequestService
                     .requestHandler<
                       OCPP16StatusNotificationRequest,
@@ -1485,9 +1538,9 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
                       chargingStation,
                       OCPP16RequestCommand.STATUS_NOTIFICATION,
                       {
-                        connectorId,
+                        connectorId: id,
                         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
-                        status: chargingStation.getConnectorStatus(connectorId)?.status,
+                        status: chargingStation.getConnectorStatus(id)?.status,
                       },
                       {
                         triggerMessage: true,
@@ -1503,12 +1556,12 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
           return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
       }
     } catch (error) {
-      return this.handleIncomingRequestError(
+      return this.handleIncomingRequestError<OCPP16TriggerMessageResponse>(
         chargingStation,
         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
         error as Error,
         { errorResponse: OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED },
-      );
+      )!;
     }
   }
 
@@ -1516,18 +1569,19 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     chargingStation: ChargingStation,
     commandPayload: OCPP16DataTransferRequest,
   ): OCPP16DataTransferResponse {
+    const { vendorId } = commandPayload;
     try {
-      if (Object.values(OCPP16DataTransferVendorId).includes(commandPayload.vendorId)) {
+      if (Object.values(OCPP16DataTransferVendorId).includes(vendorId)) {
         return OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_ACCEPTED;
       }
       return OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_UNKNOWN_VENDOR_ID;
     } catch (error) {
-      return this.handleIncomingRequestError(
+      return this.handleIncomingRequestError<OCPP16DataTransferResponse>(
         chargingStation,
         OCPP16IncomingRequestCommand.DATA_TRANSFER,
         error as Error,
         { errorResponse: OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_REJECTED },
-      );
+      )!;
     }
   }
 
@@ -1547,16 +1601,17 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     const { reservationId, idTag, connectorId } = commandPayload;
     let response: OCPP16ReserveNowResponse;
     try {
-      if (!chargingStation.isConnectorAvailable(connectorId) && connectorId > 0) {
+      if (connectorId > 0 && !chargingStation.isConnectorAvailable(connectorId)) {
         return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
       }
-      if (connectorId === 0 && !chargingStation.getReservationOnConnectorId0Enabled()) {
+      if (connectorId === 0 && !chargingStation.getReserveConnectorZeroSupported()) {
         return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
       }
       if (!(await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, connectorId, idTag))) {
         return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
       }
-      switch (chargingStation.getConnectorStatus(connectorId).status) {
+      await removeExpiredReservations(chargingStation);
+      switch (chargingStation.getConnectorStatus(connectorId)!.status) {
         case OCPP16ChargePointStatus.Faulted:
           response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED;
           break;
@@ -1590,13 +1645,13 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
       }
       return response;
     } catch (error) {
-      chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.Available;
-      return this.handleIncomingRequestError(
+      chargingStation.getConnectorStatus(connectorId)!.status = OCPP16ChargePointStatus.Available;
+      return this.handleIncomingRequestError<OCPP16ReserveNowResponse>(
         chargingStation,
         OCPP16IncomingRequestCommand.RESERVE_NOW,
         error as Error,
         { errorResponse: OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED },
-      );
+      )!;
     }
   }
 
@@ -1615,26 +1670,26 @@ export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
     }
     try {
       const { reservationId } = commandPayload;
-      const [exists, reservation] = chargingStation.doesReservationExists({ id: reservationId });
-      if (!exists) {
-        logger.error(
-          `${chargingStation.logPrefix()} Reservation with ID ${reservationId}
+      const reservation = chargingStation.getReservationBy('reservationId', reservationId);
+      if (isUndefined(reservation)) {
+        logger.debug(
+          `${chargingStation.logPrefix()} Reservation with id ${reservationId}
             does not exist on charging station`,
         );
         return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
       }
       await chargingStation.removeReservation(
-        reservation,
+        reservation!,
         ReservationTerminationReason.RESERVATION_CANCELED,
       );
       return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_ACCEPTED;
     } catch (error) {
-      return this.handleIncomingRequestError(
+      return this.handleIncomingRequestError<GenericResponse>(
         chargingStation,
         OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
         error as Error,
         { errorResponse: OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED },
-      );
+      )!;
     }
   }
 }