src/charging-station/ocpp/1.6/OCPP16IncomingRequestService.ts

   1 // Partial Copyright Jerome Benoit. 2021-2024. All Rights Reserved.
   2
   3 import { randomInt } from 'node:crypto'
   4 import { createWriteStream, readdirSync } from 'node:fs'
   5 import { dirname, extname, join, resolve } from 'node:path'
   6 import { fileURLToPath, URL } from 'node:url'
   7
   8 import type { ValidateFunction } from 'ajv'
   9 import { Client, type FTPResponse } from 'basic-ftp'
  10 import {
  11   addSeconds,
  12   differenceInSeconds,
  13   type Interval,
  14   isDate,
  15   secondsToMilliseconds
  16 } from 'date-fns'
  17 import { maxTime } from 'date-fns/constants'
  18 import { isEmpty } from 'rambda'
  19 import { create } from 'tar'
  20
  21 import {
  22   canProceedChargingProfile,
  23   type ChargingStation,
  24   checkChargingStation,
  25   getConfigurationKey,
  26   getConnectorChargingProfiles,
  27   prepareChargingProfileKind,
  28   removeExpiredReservations,
  29   setConfigurationKeyValue
  30 } from '../../../charging-station/index.js'
  31 import { OCPPError } from '../../../exception/index.js'
  32 import {
  33   type ChangeConfigurationRequest,
  34   type ChangeConfigurationResponse,
  35   ConfigurationSection,
  36   ErrorType,
  37   type GenericResponse,
  38   GenericStatus,
  39   type GetConfigurationRequest,
  40   type GetConfigurationResponse,
  41   type GetDiagnosticsRequest,
  42   type GetDiagnosticsResponse,
  43   type IncomingRequestHandler,
  44   type JsonType,
  45   type LogConfiguration,
  46   OCPP16AuthorizationStatus,
  47   OCPP16AvailabilityType,
  48   type OCPP16BootNotificationRequest,
  49   type OCPP16BootNotificationResponse,
  50   type OCPP16CancelReservationRequest,
  51   type OCPP16ChangeAvailabilityRequest,
  52   type OCPP16ChangeAvailabilityResponse,
  53   OCPP16ChargePointErrorCode,
  54   OCPP16ChargePointStatus,
  55   type OCPP16ChargingProfile,
  56   OCPP16ChargingProfilePurposeType,
  57   type OCPP16ChargingSchedule,
  58   type OCPP16ClearCacheRequest,
  59   type OCPP16ClearChargingProfileRequest,
  60   type OCPP16ClearChargingProfileResponse,
  61   type OCPP16DataTransferRequest,
  62   type OCPP16DataTransferResponse,
  63   OCPP16DataTransferVendorId,
  64   OCPP16DiagnosticsStatus,
  65   type OCPP16DiagnosticsStatusNotificationRequest,
  66   type OCPP16DiagnosticsStatusNotificationResponse,
  67   OCPP16FirmwareStatus,
  68   type OCPP16FirmwareStatusNotificationRequest,
  69   type OCPP16FirmwareStatusNotificationResponse,
  70   type OCPP16GetCompositeScheduleRequest,
  71   type OCPP16GetCompositeScheduleResponse,
  72   type OCPP16HeartbeatRequest,
  73   type OCPP16HeartbeatResponse,
  74   OCPP16IncomingRequestCommand,
  75   OCPP16MessageTrigger,
  76   OCPP16RequestCommand,
  77   type OCPP16ReserveNowRequest,
  78   type OCPP16ReserveNowResponse,
  79   OCPP16StandardParametersKey,
  80   type OCPP16StartTransactionRequest,
  81   type OCPP16StartTransactionResponse,
  82   type OCPP16StatusNotificationRequest,
  83   type OCPP16StatusNotificationResponse,
  84   OCPP16StopTransactionReason,
  85   OCPP16SupportedFeatureProfiles,
  86   type OCPP16TriggerMessageRequest,
  87   type OCPP16TriggerMessageResponse,
  88   OCPP16TriggerMessageStatus,
  89   type OCPP16UpdateFirmwareRequest,
  90   type OCPP16UpdateFirmwareResponse,
  91   type OCPPConfigurationKey,
  92   OCPPVersion,
  93   type RemoteStartTransactionRequest,
  94   type RemoteStopTransactionRequest,
  95   ReservationTerminationReason,
  96   type ResetRequest,
  97   type SetChargingProfileRequest,
  98   type SetChargingProfileResponse,
  99   type UnlockConnectorRequest,
 100   type UnlockConnectorResponse
 101 } from '../../../types/index.js'
 102 import {
 103   Configuration,
 104   Constants,
 105   convertToDate,
 106   convertToInt,
 107   formatDurationMilliSeconds,
 108   isAsyncFunction,
 109   isNotEmptyArray,
 110   isNotEmptyString,
 111   logger,
 112   sleep
 113 } from '../../../utils/index.js'
 114 import { OCPPIncomingRequestService } from '../OCPPIncomingRequestService.js'
 115 import { OCPP16Constants } from './OCPP16Constants.js'
 116 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils.js'
 117
 118 const moduleName = 'OCPP16IncomingRequestService'
 119
 120 export class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
 121   protected payloadValidateFunctions: Map<OCPP16IncomingRequestCommand, ValidateFunction<JsonType>>
 122
 123   private readonly incomingRequestHandlers: Map<
 124   OCPP16IncomingRequestCommand,
 125   IncomingRequestHandler
 126   >
 127
 128   public constructor () {
 129     // if (new.target.name === moduleName) {
 130     //   throw new TypeError(`Cannot construct ${new.target.name} instances directly`)
 131     // }
 132     super(OCPPVersion.VERSION_16)
 133     this.incomingRequestHandlers = new Map<OCPP16IncomingRequestCommand, IncomingRequestHandler>([
 134       [
 135         OCPP16IncomingRequestCommand.RESET,
 136         this.handleRequestReset.bind(this) as unknown as IncomingRequestHandler
 137       ],
 138       [
 139         OCPP16IncomingRequestCommand.CLEAR_CACHE,
 140         this.handleRequestClearCache.bind(this) as IncomingRequestHandler
 141       ],
 142       [
 143         OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR,
 144         this.handleRequestUnlockConnector.bind(this) as unknown as IncomingRequestHandler
 145       ],
 146       [
 147         OCPP16IncomingRequestCommand.GET_CONFIGURATION,
 148         this.handleRequestGetConfiguration.bind(this) as IncomingRequestHandler
 149       ],
 150       [
 151         OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
 152         this.handleRequestChangeConfiguration.bind(this) as unknown as IncomingRequestHandler
 153       ],
 154       [
 155         OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE,
 156         this.handleRequestGetCompositeSchedule.bind(this) as unknown as IncomingRequestHandler
 157       ],
 158       [
 159         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
 160         this.handleRequestSetChargingProfile.bind(this) as unknown as IncomingRequestHandler
 161       ],
 162       [
 163         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
 164         this.handleRequestClearChargingProfile.bind(this) as IncomingRequestHandler
 165       ],
 166       [
 167         OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
 168         this.handleRequestChangeAvailability.bind(this) as unknown as IncomingRequestHandler
 169       ],
 170       [
 171         OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
 172         this.handleRequestRemoteStartTransaction.bind(this) as unknown as IncomingRequestHandler
 173       ],
 174       [
 175         OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
 176         this.handleRequestRemoteStopTransaction.bind(this) as unknown as IncomingRequestHandler
 177       ],
 178       [
 179         OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
 180         this.handleRequestGetDiagnostics.bind(this) as IncomingRequestHandler
 181       ],
 182       [
 183         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
 184         this.handleRequestTriggerMessage.bind(this) as unknown as IncomingRequestHandler
 185       ],
 186       [
 187         OCPP16IncomingRequestCommand.DATA_TRANSFER,
 188         this.handleRequestDataTransfer.bind(this) as unknown as IncomingRequestHandler
 189       ],
 190       [
 191         OCPP16IncomingRequestCommand.UPDATE_FIRMWARE,
 192         this.handleRequestUpdateFirmware.bind(this) as unknown as IncomingRequestHandler
 193       ],
 194       [
 195         OCPP16IncomingRequestCommand.RESERVE_NOW,
 196         this.handleRequestReserveNow.bind(this) as unknown as IncomingRequestHandler
 197       ],
 198       [
 199         OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
 200         this.handleRequestCancelReservation.bind(this) as unknown as IncomingRequestHandler
 201       ]
 202     ])
 203     this.payloadValidateFunctions = new Map<
 204     OCPP16IncomingRequestCommand,
 205     ValidateFunction<JsonType>
 206     >([
 207       [
 208         OCPP16IncomingRequestCommand.RESET,
 209         this.ajv
 210           .compile(
 211             OCPP16ServiceUtils.parseJsonSchemaFile<ResetRequest>(
 212               'assets/json-schemas/ocpp/1.6/Reset.json',
 213               moduleName,
 214               'constructor'
 215             )
 216           )
 217           .bind(this)
 218       ],
 219       [
 220         OCPP16IncomingRequestCommand.CLEAR_CACHE,
 221         this.ajv
 222           .compile(
 223             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ClearCacheRequest>(
 224               'assets/json-schemas/ocpp/1.6/ClearCache.json',
 225               moduleName,
 226               'constructor'
 227             )
 228           )
 229           .bind(this)
 230       ],
 231       [
 232         OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR,
 233         this.ajv
 234           .compile(
 235             OCPP16ServiceUtils.parseJsonSchemaFile<UnlockConnectorRequest>(
 236               'assets/json-schemas/ocpp/1.6/UnlockConnector.json',
 237               moduleName,
 238               'constructor'
 239             )
 240           )
 241           .bind(this)
 242       ],
 243       [
 244         OCPP16IncomingRequestCommand.GET_CONFIGURATION,
 245         this.ajv
 246           .compile(
 247             OCPP16ServiceUtils.parseJsonSchemaFile<GetConfigurationRequest>(
 248               'assets/json-schemas/ocpp/1.6/GetConfiguration.json',
 249               moduleName,
 250               'constructor'
 251             )
 252           )
 253           .bind(this)
 254       ],
 255       [
 256         OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
 257         this.ajv
 258           .compile(
 259             OCPP16ServiceUtils.parseJsonSchemaFile<ChangeConfigurationRequest>(
 260               'assets/json-schemas/ocpp/1.6/ChangeConfiguration.json',
 261               moduleName,
 262               'constructor'
 263             )
 264           )
 265           .bind(this)
 266       ],
 267       [
 268         OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
 269         this.ajv
 270           .compile(
 271             OCPP16ServiceUtils.parseJsonSchemaFile<GetDiagnosticsRequest>(
 272               'assets/json-schemas/ocpp/1.6/GetDiagnostics.json',
 273               moduleName,
 274               'constructor'
 275             )
 276           )
 277           .bind(this)
 278       ],
 279       [
 280         OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE,
 281         this.ajv
 282           .compile(
 283             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16GetCompositeScheduleRequest>(
 284               'assets/json-schemas/ocpp/1.6/GetCompositeSchedule.json',
 285               moduleName,
 286               'constructor'
 287             )
 288           )
 289           .bind(this)
 290       ],
 291       [
 292         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
 293         this.ajv
 294           .compile(
 295             OCPP16ServiceUtils.parseJsonSchemaFile<SetChargingProfileRequest>(
 296               'assets/json-schemas/ocpp/1.6/SetChargingProfile.json',
 297               moduleName,
 298               'constructor'
 299             )
 300           )
 301           .bind(this)
 302       ],
 303       [
 304         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
 305         this.ajv
 306           .compile(
 307             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ClearChargingProfileRequest>(
 308               'assets/json-schemas/ocpp/1.6/ClearChargingProfile.json',
 309               moduleName,
 310               'constructor'
 311             )
 312           )
 313           .bind(this)
 314       ],
 315       [
 316         OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
 317         this.ajv
 318           .compile(
 319             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ChangeAvailabilityRequest>(
 320               'assets/json-schemas/ocpp/1.6/ChangeAvailability.json',
 321               moduleName,
 322               'constructor'
 323             )
 324           )
 325           .bind(this)
 326       ],
 327       [
 328         OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
 329         this.ajv
 330           .compile(
 331             OCPP16ServiceUtils.parseJsonSchemaFile<RemoteStartTransactionRequest>(
 332               'assets/json-schemas/ocpp/1.6/RemoteStartTransaction.json',
 333               moduleName,
 334               'constructor'
 335             )
 336           )
 337           .bind(this)
 338       ],
 339       [
 340         OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
 341         this.ajv
 342           .compile(
 343             OCPP16ServiceUtils.parseJsonSchemaFile<RemoteStopTransactionRequest>(
 344               'assets/json-schemas/ocpp/1.6/RemoteStopTransaction.json',
 345               moduleName,
 346               'constructor'
 347             )
 348           )
 349           .bind(this)
 350       ],
 351       [
 352         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
 353         this.ajv
 354           .compile(
 355             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16TriggerMessageRequest>(
 356               'assets/json-schemas/ocpp/1.6/TriggerMessage.json',
 357               moduleName,
 358               'constructor'
 359             )
 360           )
 361           .bind(this)
 362       ],
 363       [
 364         OCPP16IncomingRequestCommand.DATA_TRANSFER,
 365         this.ajv
 366           .compile(
 367             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16DataTransferRequest>(
 368               'assets/json-schemas/ocpp/1.6/DataTransfer.json',
 369               moduleName,
 370               'constructor'
 371             )
 372           )
 373           .bind(this)
 374       ],
 375       [
 376         OCPP16IncomingRequestCommand.UPDATE_FIRMWARE,
 377         this.ajv
 378           .compile(
 379             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16UpdateFirmwareRequest>(
 380               'assets/json-schemas/ocpp/1.6/UpdateFirmware.json',
 381               moduleName,
 382               'constructor'
 383             )
 384           )
 385           .bind(this)
 386       ],
 387       [
 388         OCPP16IncomingRequestCommand.RESERVE_NOW,
 389         this.ajv
 390           .compile(
 391             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ReserveNowRequest>(
 392               'assets/json-schemas/ocpp/1.6/ReserveNow.json',
 393               moduleName,
 394               'constructor'
 395             )
 396           )
 397           .bind(this)
 398       ],
 399       [
 400         OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
 401         this.ajv
 402           .compile(
 403             OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16CancelReservationRequest>(
 404               'assets/json-schemas/ocpp/1.6/CancelReservation.json',
 405               moduleName,
 406               'constructor'
 407             )
 408           )
 409           .bind(this)
 410       ]
 411     ])
 412     // Handle incoming request events
 413     this.on(
 414       OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
 415       (
 416         chargingStation: ChargingStation,
 417         request: RemoteStartTransactionRequest,
 418         response: GenericResponse
 419       ) => {
 420         if (response.status === GenericStatus.Accepted) {
 421           const { connectorId, idTag } = request
 422           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 423           chargingStation.getConnectorStatus(connectorId)!.transactionRemoteStarted = true
 424           chargingStation.ocppRequestService
 425             .requestHandler<Partial<OCPP16StartTransactionRequest>, OCPP16StartTransactionResponse>(
 426             chargingStation,
 427             OCPP16RequestCommand.START_TRANSACTION,
 428             {
 429               connectorId,
 430               idTag
 431             }
 432           )
 433             .then(response => {
 434               if (response.status === OCPP16AuthorizationStatus.ACCEPTED) {
 435                 logger.debug(
 436                   `${chargingStation.logPrefix()} Remote start transaction ACCEPTED on ${
 437                     chargingStation.stationInfo?.chargingStationId
 438                   }#${connectorId} for idTag '${idTag}'`
 439                 )
 440               } else {
 441                 logger.debug(
 442                   `${chargingStation.logPrefix()} Remote start transaction REJECTED on ${
 443                     chargingStation.stationInfo?.chargingStationId
 444                   }#${connectorId} for idTag '${idTag}'`
 445                 )
 446               }
 447             })
 448             .catch((error: unknown) => {
 449               logger.error(
 450                 `${chargingStation.logPrefix()} ${moduleName}.constructor: Remote start transaction error:`,
 451                 error
 452               )
 453             })
 454         }
 455       }
 456     )
 457     this.on(
 458       OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
 459       (
 460         chargingStation: ChargingStation,
 461         request: RemoteStopTransactionRequest,
 462         response: GenericResponse
 463       ) => {
 464         if (response.status === GenericStatus.Accepted) {
 465           const { transactionId } = request
 466           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 467           const connectorId = chargingStation.getConnectorIdByTransactionId(transactionId)!
 468           OCPP16ServiceUtils.remoteStopTransaction(chargingStation, connectorId)
 469             .then(response => {
 470               if (response.status === GenericStatus.Accepted) {
 471                 logger.debug(
 472                   `${chargingStation.logPrefix()} Remote stop transaction ACCEPTED on ${
 473                     chargingStation.stationInfo?.chargingStationId
 474                   }#${connectorId} for transaction '${transactionId}'`
 475                 )
 476               } else {
 477                 logger.debug(
 478                   `${chargingStation.logPrefix()} Remote stop transaction REJECTED on ${
 479                     chargingStation.stationInfo?.chargingStationId
 480                   }#${connectorId} for transaction '${transactionId}'`
 481                 )
 482               }
 483             })
 484             .catch((error: unknown) => {
 485               logger.error(
 486                 `${chargingStation.logPrefix()} ${moduleName}.constructor: Remote stop transaction error:`,
 487                 error
 488               )
 489             })
 490         }
 491       }
 492     )
 493     this.on(
 494       OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
 495       (
 496         chargingStation: ChargingStation,
 497         request: OCPP16TriggerMessageRequest,
 498         response: OCPP16TriggerMessageResponse
 499       ) => {
 500         if (response.status !== OCPP16TriggerMessageStatus.ACCEPTED) {
 501           return
 502         }
 503         const { requestedMessage, connectorId } = request
 504         const errorHandler = (error: unknown): void => {
 505           logger.error(
 506             `${chargingStation.logPrefix()} ${moduleName}.constructor: Trigger ${requestedMessage} error:`,
 507             error
 508           )
 509         }
 510         switch (requestedMessage) {
 511           case OCPP16MessageTrigger.BootNotification:
 512             chargingStation.ocppRequestService
 513               .requestHandler<OCPP16BootNotificationRequest, OCPP16BootNotificationResponse>(
 514               chargingStation,
 515               OCPP16RequestCommand.BOOT_NOTIFICATION,
 516               chargingStation.bootNotificationRequest as OCPP16BootNotificationRequest,
 517               { skipBufferingOnError: true, triggerMessage: true }
 518             )
 519               .then(response => {
 520                 chargingStation.bootNotificationResponse = response
 521               })
 522               .catch(errorHandler)
 523             break
 524           case OCPP16MessageTrigger.Heartbeat:
 525             chargingStation.ocppRequestService
 526               .requestHandler<OCPP16HeartbeatRequest, OCPP16HeartbeatResponse>(
 527               chargingStation,
 528               OCPP16RequestCommand.HEARTBEAT,
 529               undefined,
 530               {
 531                 triggerMessage: true
 532               }
 533             )
 534               .catch(errorHandler)
 535             break
 536           case OCPP16MessageTrigger.StatusNotification:
 537             if (connectorId != null) {
 538               chargingStation.ocppRequestService
 539                 .requestHandler<OCPP16StatusNotificationRequest, OCPP16StatusNotificationResponse>(
 540                 chargingStation,
 541                 OCPP16RequestCommand.STATUS_NOTIFICATION,
 542                 {
 543                   connectorId,
 544                   errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 545                   status: chargingStation.getConnectorStatus(connectorId)
 546                     ?.status as OCPP16ChargePointStatus
 547                 },
 548                 {
 549                   triggerMessage: true
 550                 }
 551               )
 552                 .catch(errorHandler)
 553             } else if (chargingStation.hasEvses) {
 554               for (const evseStatus of chargingStation.evses.values()) {
 555                 for (const [id, connectorStatus] of evseStatus.connectors) {
 556                   chargingStation.ocppRequestService
 557                     .requestHandler<
 558                   OCPP16StatusNotificationRequest,
 559                   OCPP16StatusNotificationResponse
 560                   >(
 561                     chargingStation,
 562                     OCPP16RequestCommand.STATUS_NOTIFICATION,
 563                     {
 564                       connectorId: id,
 565                       errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 566                       status: connectorStatus.status as OCPP16ChargePointStatus
 567                     },
 568                     {
 569                       triggerMessage: true
 570                     }
 571                   )
 572                     .catch(errorHandler)
 573                 }
 574               }
 575             } else {
 576               for (const [id, connectorStatus] of chargingStation.connectors) {
 577                 chargingStation.ocppRequestService
 578                   .requestHandler<
 579                 OCPP16StatusNotificationRequest,
 580                 OCPP16StatusNotificationResponse
 581                 >(
 582                   chargingStation,
 583                   OCPP16RequestCommand.STATUS_NOTIFICATION,
 584                   {
 585                     connectorId: id,
 586                     errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 587                     status: connectorStatus.status as OCPP16ChargePointStatus
 588                   },
 589                   {
 590                     triggerMessage: true
 591                   }
 592                 )
 593                   .catch(errorHandler)
 594               }
 595             }
 596             break
 597         }
 598       }
 599     )
 600     this.validatePayload = this.validatePayload.bind(this)
 601   }
 602
 603   public async incomingRequestHandler<ReqType extends JsonType, ResType extends JsonType>(
 604     chargingStation: ChargingStation,
 605     messageId: string,
 606     commandName: OCPP16IncomingRequestCommand,
 607     commandPayload: ReqType
 608   ): Promise<void> {
 609     let response: ResType
 610     if (
 611       chargingStation.stationInfo?.ocppStrictCompliance === true &&
 612       chargingStation.inPendingState() &&
 613       (commandName === OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION ||
 614         commandName === OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION)
 615     ) {
 616       throw new OCPPError(
 617         ErrorType.SECURITY_ERROR,
 618         `${commandName} cannot be issued to handle request PDU ${JSON.stringify(
 619           commandPayload,
 620           undefined,
 621           2
 622         )} while the charging station is in pending state on the central server`,
 623         commandName,
 624         commandPayload
 625       )
 626     }
 627     if (
 628       chargingStation.isRegistered() ||
 629       (chargingStation.stationInfo?.ocppStrictCompliance === false &&
 630         chargingStation.inUnknownState())
 631     ) {
 632       if (
 633         this.incomingRequestHandlers.has(commandName) &&
 634         OCPP16ServiceUtils.isIncomingRequestCommandSupported(chargingStation, commandName)
 635       ) {
 636         try {
 637           this.validatePayload(chargingStation, commandName, commandPayload)
 638           // Call the method to build the response
 639           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 640           const incomingRequestHandler = this.incomingRequestHandlers.get(commandName)!
 641           if (isAsyncFunction(incomingRequestHandler)) {
 642             response = (await incomingRequestHandler(chargingStation, commandPayload)) as ResType
 643           } else {
 644             response = incomingRequestHandler(chargingStation, commandPayload) as ResType
 645           }
 646         } catch (error) {
 647           // Log
 648           logger.error(
 649             `${chargingStation.logPrefix()} ${moduleName}.incomingRequestHandler: Handle incoming request error:`,
 650             error
 651           )
 652           throw error
 653         }
 654       } else {
 655         // Throw exception
 656         throw new OCPPError(
 657           ErrorType.NOT_IMPLEMENTED,
 658           `'${commandName}' is not implemented to handle request PDU ${JSON.stringify(
 659             commandPayload,
 660             undefined,
 661             2
 662           )}`,
 663           commandName,
 664           commandPayload
 665         )
 666       }
 667     } else {
 668       throw new OCPPError(
 669         ErrorType.SECURITY_ERROR,
 670         `${commandName} cannot be issued to handle request PDU ${JSON.stringify(
 671           commandPayload,
 672           undefined,
 673           2
 674         )} while the charging station is not registered on the central server`,
 675         commandName,
 676         commandPayload
 677       )
 678     }
 679     // Send the built response
 680     await chargingStation.ocppRequestService.sendResponse(
 681       chargingStation,
 682       messageId,
 683       response,
 684       commandName
 685     )
 686     // Emit command name event to allow delayed handling
 687     this.emit(commandName, chargingStation, commandPayload, response)
 688   }
 689
 690   private validatePayload (
 691     chargingStation: ChargingStation,
 692     commandName: OCPP16IncomingRequestCommand,
 693     commandPayload: JsonType
 694   ): boolean {
 695     if (this.payloadValidateFunctions.has(commandName)) {
 696       return this.validateIncomingRequestPayload(chargingStation, commandName, commandPayload)
 697     }
 698     logger.warn(
 699       `${chargingStation.logPrefix()} ${moduleName}.validatePayload: No JSON schema validation function found for command '${commandName}' PDU validation`
 700     )
 701     return false
 702   }
 703
 704   // Simulate charging station restart
 705   private handleRequestReset (
 706     chargingStation: ChargingStation,
 707     commandPayload: ResetRequest
 708   ): GenericResponse {
 709     const { type } = commandPayload
 710     chargingStation
 711       .reset(`${type}Reset` as OCPP16StopTransactionReason)
 712       .catch(Constants.EMPTY_FUNCTION)
 713     logger.info(
 714       `${chargingStation.logPrefix()} ${type} reset command received, simulating it. The station will be back online in ${formatDurationMilliSeconds(
 715         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 716         chargingStation.stationInfo!.resetTime!
 717       )}`
 718     )
 719     return OCPP16Constants.OCPP_RESPONSE_ACCEPTED
 720   }
 721
 722   private async handleRequestUnlockConnector (
 723     chargingStation: ChargingStation,
 724     commandPayload: UnlockConnectorRequest
 725   ): Promise<UnlockConnectorResponse> {
 726     const { connectorId } = commandPayload
 727     if (!chargingStation.hasConnector(connectorId)) {
 728       logger.error(
 729         `${chargingStation.logPrefix()} Trying to unlock a non existing connector id ${connectorId}`
 730       )
 731       return OCPP16Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED
 732     }
 733     if (connectorId === 0) {
 734       logger.error(`${chargingStation.logPrefix()} Trying to unlock connector id ${connectorId}`)
 735       return OCPP16Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED
 736     }
 737     if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
 738       const stopResponse = await chargingStation.stopTransactionOnConnector(
 739         connectorId,
 740         OCPP16StopTransactionReason.UNLOCK_COMMAND
 741       )
 742       if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 743         return OCPP16Constants.OCPP_RESPONSE_UNLOCKED
 744       }
 745       return OCPP16Constants.OCPP_RESPONSE_UNLOCK_FAILED
 746     }
 747     await OCPP16ServiceUtils.sendAndSetConnectorStatus(
 748       chargingStation,
 749       connectorId,
 750       OCPP16ChargePointStatus.Available
 751     )
 752     return OCPP16Constants.OCPP_RESPONSE_UNLOCKED
 753   }
 754
 755   private handleRequestGetConfiguration (
 756     chargingStation: ChargingStation,
 757     commandPayload: GetConfigurationRequest
 758   ): GetConfigurationResponse {
 759     const { key } = commandPayload
 760     const configurationKey: OCPPConfigurationKey[] = []
 761     const unknownKey: string[] = []
 762     if (key == null) {
 763       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 764       for (const configKey of chargingStation.ocppConfiguration!.configurationKey!) {
 765         if (!OCPP16ServiceUtils.isConfigurationKeyVisible(configKey)) {
 766           continue
 767         }
 768         configurationKey.push({
 769           key: configKey.key,
 770           readonly: configKey.readonly,
 771           value: configKey.value
 772         })
 773       }
 774     } else if (isNotEmptyArray(key)) {
 775       for (const k of key) {
 776         const keyFound = getConfigurationKey(chargingStation, k, true)
 777         if (keyFound != null) {
 778           if (!OCPP16ServiceUtils.isConfigurationKeyVisible(keyFound)) {
 779             continue
 780           }
 781           configurationKey.push({
 782             key: keyFound.key,
 783             readonly: keyFound.readonly,
 784             value: keyFound.value
 785           })
 786         } else {
 787           unknownKey.push(k)
 788         }
 789       }
 790     }
 791     return {
 792       configurationKey,
 793       unknownKey
 794     }
 795   }
 796
 797   private handleRequestChangeConfiguration (
 798     chargingStation: ChargingStation,
 799     commandPayload: ChangeConfigurationRequest
 800   ): ChangeConfigurationResponse {
 801     const { key, value } = commandPayload
 802     const keyToChange = getConfigurationKey(chargingStation, key, true)
 803     if (keyToChange?.readonly === true) {
 804       return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_REJECTED
 805     } else if (keyToChange?.readonly === false) {
 806       let valueChanged = false
 807       if (keyToChange.value !== value) {
 808         setConfigurationKeyValue(chargingStation, key, value, true)
 809         valueChanged = true
 810       }
 811       let triggerHeartbeatRestart = false
 812       if (
 813         (keyToChange.key as OCPP16StandardParametersKey) ===
 814           OCPP16StandardParametersKey.HeartBeatInterval &&
 815         valueChanged
 816       ) {
 817         setConfigurationKeyValue(
 818           chargingStation,
 819           OCPP16StandardParametersKey.HeartbeatInterval,
 820           value
 821         )
 822         triggerHeartbeatRestart = true
 823       }
 824       if (
 825         (keyToChange.key as OCPP16StandardParametersKey) ===
 826           OCPP16StandardParametersKey.HeartbeatInterval &&
 827         valueChanged
 828       ) {
 829         setConfigurationKeyValue(
 830           chargingStation,
 831           OCPP16StandardParametersKey.HeartBeatInterval,
 832           value
 833         )
 834         triggerHeartbeatRestart = true
 835       }
 836       if (triggerHeartbeatRestart) {
 837         chargingStation.restartHeartbeat()
 838       }
 839       if (
 840         (keyToChange.key as OCPP16StandardParametersKey) ===
 841           OCPP16StandardParametersKey.WebSocketPingInterval &&
 842         valueChanged
 843       ) {
 844         chargingStation.restartWebSocketPing()
 845       }
 846       if (keyToChange.reboot === true) {
 847         return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_REBOOT_REQUIRED
 848       }
 849       return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_ACCEPTED
 850     }
 851     return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED
 852   }
 853
 854   private handleRequestSetChargingProfile (
 855     chargingStation: ChargingStation,
 856     commandPayload: SetChargingProfileRequest
 857   ): SetChargingProfileResponse {
 858     if (
 859       !OCPP16ServiceUtils.checkFeatureProfile(
 860         chargingStation,
 861         OCPP16SupportedFeatureProfiles.SmartCharging,
 862         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE
 863       )
 864     ) {
 865       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_NOT_SUPPORTED
 866     }
 867     const { connectorId, csChargingProfiles } = commandPayload
 868     if (!chargingStation.hasConnector(connectorId)) {
 869       logger.error(
 870         `${chargingStation.logPrefix()} Trying to set charging profile(s) to a non existing connector id ${connectorId}`
 871       )
 872       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED
 873     }
 874     if (
 875       csChargingProfiles.chargingProfilePurpose ===
 876         OCPP16ChargingProfilePurposeType.CHARGE_POINT_MAX_PROFILE &&
 877       connectorId !== 0
 878     ) {
 879       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED
 880     }
 881     if (
 882       csChargingProfiles.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE &&
 883       connectorId === 0
 884     ) {
 885       logger.error(
 886         `${chargingStation.logPrefix()} Trying to set transaction charging profile(s) on connector ${connectorId}`
 887       )
 888       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED
 889     }
 890     const connectorStatus = chargingStation.getConnectorStatus(connectorId)
 891     if (
 892       csChargingProfiles.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE &&
 893       connectorId > 0 &&
 894       connectorStatus?.transactionStarted === false
 895     ) {
 896       logger.error(
 897         `${chargingStation.logPrefix()} Trying to set transaction charging profile(s) on connector ${connectorId} without a started transaction`
 898       )
 899       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED
 900     }
 901     if (
 902       csChargingProfiles.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE &&
 903       connectorId > 0 &&
 904       connectorStatus?.transactionStarted === true &&
 905       csChargingProfiles.transactionId !== connectorStatus.transactionId
 906     ) {
 907       logger.error(
 908         `${chargingStation.logPrefix()} Trying to set transaction charging profile(s) on connector ${connectorId} with a different transaction id ${
 909           csChargingProfiles.transactionId
 910         } than the started transaction id ${connectorStatus.transactionId}`
 911       )
 912       return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED
 913     }
 914     OCPP16ServiceUtils.setChargingProfile(chargingStation, connectorId, csChargingProfiles)
 915     logger.debug(
 916       `${chargingStation.logPrefix()} Charging profile(s) set on connector id ${connectorId}: %j`,
 917       csChargingProfiles
 918     )
 919     return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_ACCEPTED
 920   }
 921
 922   private handleRequestGetCompositeSchedule (
 923     chargingStation: ChargingStation,
 924     commandPayload: OCPP16GetCompositeScheduleRequest
 925   ): OCPP16GetCompositeScheduleResponse {
 926     if (
 927       !OCPP16ServiceUtils.checkFeatureProfile(
 928         chargingStation,
 929         OCPP16SupportedFeatureProfiles.SmartCharging,
 930         OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE
 931       )
 932     ) {
 933       return OCPP16Constants.OCPP_RESPONSE_REJECTED
 934     }
 935     const { connectorId, duration, chargingRateUnit } = commandPayload
 936     if (!chargingStation.hasConnector(connectorId)) {
 937       logger.error(
 938         `${chargingStation.logPrefix()} Trying to get composite schedule to a non existing connector id ${connectorId}`
 939       )
 940       return OCPP16Constants.OCPP_RESPONSE_REJECTED
 941     }
 942     if (connectorId === 0) {
 943       logger.error(
 944         `${chargingStation.logPrefix()} Get composite schedule on connector id ${connectorId} is not yet supported`
 945       )
 946       return OCPP16Constants.OCPP_RESPONSE_REJECTED
 947     }
 948     if (chargingRateUnit != null) {
 949       logger.warn(
 950         `${chargingStation.logPrefix()} Get composite schedule with a specified rate unit is not yet supported, no conversion will be done`
 951       )
 952     }
 953     const connectorStatus = chargingStation.getConnectorStatus(connectorId)
 954     if (
 955       isEmpty(connectorStatus?.chargingProfiles) &&
 956       isEmpty(chargingStation.getConnectorStatus(0)?.chargingProfiles)
 957     ) {
 958       return OCPP16Constants.OCPP_RESPONSE_REJECTED
 959     }
 960     const currentDate = new Date()
 961     const compositeScheduleInterval: Interval = {
 962       start: currentDate,
 963       end: addSeconds(currentDate, duration)
 964     }
 965     // Get charging profiles sorted by connector id then stack level
 966     const chargingProfiles: OCPP16ChargingProfile[] = getConnectorChargingProfiles(
 967       chargingStation,
 968       connectorId
 969     )
 970     let previousCompositeSchedule: OCPP16ChargingSchedule | undefined
 971     let compositeSchedule: OCPP16ChargingSchedule | undefined
 972     for (const chargingProfile of chargingProfiles) {
 973       if (chargingProfile.chargingSchedule.startSchedule == null) {
 974         logger.debug(
 975           `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetCompositeSchedule: Charging profile id ${
 976             chargingProfile.chargingProfileId
 977           } has no startSchedule defined. Trying to set it to the connector current transaction start date`
 978         )
 979         // OCPP specifies that if startSchedule is not defined, it should be relative to start of the connector transaction
 980         chargingProfile.chargingSchedule.startSchedule = connectorStatus?.transactionStart
 981       }
 982       if (!isDate(chargingProfile.chargingSchedule.startSchedule)) {
 983         logger.warn(
 984           `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetCompositeSchedule: Charging profile id ${
 985             chargingProfile.chargingProfileId
 986           } startSchedule property is not a Date instance. Trying to convert it to a Date instance`
 987         )
 988         chargingProfile.chargingSchedule.startSchedule = convertToDate(
 989           chargingProfile.chargingSchedule.startSchedule
 990         )
 991       }
 992       if (chargingProfile.chargingSchedule.duration == null) {
 993         logger.debug(
 994           `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetCompositeSchedule: Charging profile id ${
 995             chargingProfile.chargingProfileId
 996           } has no duration defined and will be set to the maximum time allowed`
 997         )
 998         // OCPP specifies that if duration is not defined, it should be infinite
 999         chargingProfile.chargingSchedule.duration = differenceInSeconds(
1000           maxTime,
1001           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1002           chargingProfile.chargingSchedule.startSchedule!
1003         )
1004       }
1005       if (
1006         !prepareChargingProfileKind(
1007           connectorStatus,
1008           chargingProfile,
1009           compositeScheduleInterval.start,
1010           chargingStation.logPrefix()
1011         )
1012       ) {
1013         continue
1014       }
1015       if (
1016         !canProceedChargingProfile(
1017           chargingProfile,
1018           compositeScheduleInterval.start,
1019           chargingStation.logPrefix()
1020         )
1021       ) {
1022         continue
1023       }
1024       compositeSchedule = OCPP16ServiceUtils.composeChargingSchedules(
1025         previousCompositeSchedule,
1026         chargingProfile.chargingSchedule,
1027         compositeScheduleInterval
1028       )
1029       previousCompositeSchedule = compositeSchedule
1030     }
1031     if (compositeSchedule != null) {
1032       return {
1033         status: GenericStatus.Accepted,
1034         scheduleStart: compositeSchedule.startSchedule,
1035         connectorId,
1036         chargingSchedule: compositeSchedule
1037       }
1038     }
1039     return OCPP16Constants.OCPP_RESPONSE_REJECTED
1040   }
1041
1042   private handleRequestClearChargingProfile (
1043     chargingStation: ChargingStation,
1044     commandPayload: OCPP16ClearChargingProfileRequest
1045   ): OCPP16ClearChargingProfileResponse {
1046     if (
1047       !OCPP16ServiceUtils.checkFeatureProfile(
1048         chargingStation,
1049         OCPP16SupportedFeatureProfiles.SmartCharging,
1050         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE
1051       )
1052     ) {
1053       return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN
1054     }
1055     const { connectorId } = commandPayload
1056     if (connectorId != null) {
1057       if (!chargingStation.hasConnector(connectorId)) {
1058         logger.error(
1059           `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to a non existing connector id ${connectorId}`
1060         )
1061         return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN
1062       }
1063       const connectorStatus = chargingStation.getConnectorStatus(connectorId)
1064       if (isNotEmptyArray(connectorStatus?.chargingProfiles)) {
1065         connectorStatus.chargingProfiles = []
1066         logger.debug(
1067           `${chargingStation.logPrefix()} Charging profile(s) cleared on connector id ${connectorId}`
1068         )
1069         return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED
1070       }
1071     } else {
1072       let clearedCP = false
1073       if (chargingStation.hasEvses) {
1074         for (const evseStatus of chargingStation.evses.values()) {
1075           for (const status of evseStatus.connectors.values()) {
1076             const clearedConnectorCP = OCPP16ServiceUtils.clearChargingProfiles(
1077               chargingStation,
1078               commandPayload,
1079               status.chargingProfiles
1080             )
1081             if (clearedConnectorCP && !clearedCP) {
1082               clearedCP = true
1083             }
1084           }
1085         }
1086       } else {
1087         for (const id of chargingStation.connectors.keys()) {
1088           const clearedConnectorCP = OCPP16ServiceUtils.clearChargingProfiles(
1089             chargingStation,
1090             commandPayload,
1091             chargingStation.getConnectorStatus(id)?.chargingProfiles
1092           )
1093           if (clearedConnectorCP && !clearedCP) {
1094             clearedCP = true
1095           }
1096         }
1097       }
1098       if (clearedCP) {
1099         return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED
1100       }
1101     }
1102     return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN
1103   }
1104
1105   private async handleRequestChangeAvailability (
1106     chargingStation: ChargingStation,
1107     commandPayload: OCPP16ChangeAvailabilityRequest
1108   ): Promise<OCPP16ChangeAvailabilityResponse> {
1109     const { connectorId, type } = commandPayload
1110     if (!chargingStation.hasConnector(connectorId)) {
1111       logger.error(
1112         `${chargingStation.logPrefix()} Trying to change the availability of a non existing connector id ${connectorId}`
1113       )
1114       return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED
1115     }
1116     const chargePointStatus: OCPP16ChargePointStatus =
1117       type === OCPP16AvailabilityType.Operative
1118         ? OCPP16ChargePointStatus.Available
1119         : OCPP16ChargePointStatus.Unavailable
1120     if (connectorId === 0) {
1121       let response: OCPP16ChangeAvailabilityResponse | undefined
1122       if (chargingStation.hasEvses) {
1123         for (const evseStatus of chargingStation.evses.values()) {
1124           response = await OCPP16ServiceUtils.changeAvailability(
1125             chargingStation,
1126             [...evseStatus.connectors.keys()],
1127             chargePointStatus,
1128             type
1129           )
1130         }
1131       } else {
1132         response = await OCPP16ServiceUtils.changeAvailability(
1133           chargingStation,
1134           [...chargingStation.connectors.keys()],
1135           chargePointStatus,
1136           type
1137         )
1138       }
1139       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1140       return response!
1141     } else if (
1142       connectorId > 0 &&
1143       (chargingStation.isChargingStationAvailable() ||
1144         (!chargingStation.isChargingStationAvailable() &&
1145           type === OCPP16AvailabilityType.Inoperative))
1146     ) {
1147       if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
1148         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1149         chargingStation.getConnectorStatus(connectorId)!.availability = type
1150         return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED
1151       }
1152       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1153       chargingStation.getConnectorStatus(connectorId)!.availability = type
1154       await OCPP16ServiceUtils.sendAndSetConnectorStatus(
1155         chargingStation,
1156         connectorId,
1157         chargePointStatus
1158       )
1159       return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED
1160     }
1161     return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED
1162   }
1163
1164   private async handleRequestRemoteStartTransaction (
1165     chargingStation: ChargingStation,
1166     commandPayload: RemoteStartTransactionRequest
1167   ): Promise<GenericResponse> {
1168     const { connectorId: transactionConnectorId, idTag, chargingProfile } = commandPayload
1169     if (!chargingStation.hasConnector(transactionConnectorId)) {
1170       return this.notifyRemoteStartTransactionRejected(
1171         chargingStation,
1172         transactionConnectorId,
1173         idTag
1174       )
1175     }
1176     if (
1177       !chargingStation.isChargingStationAvailable() ||
1178       !chargingStation.isConnectorAvailable(transactionConnectorId)
1179     ) {
1180       return this.notifyRemoteStartTransactionRejected(
1181         chargingStation,
1182         transactionConnectorId,
1183         idTag
1184       )
1185     }
1186     // idTag authorization check required
1187     if (
1188       chargingStation.getAuthorizeRemoteTxRequests() &&
1189       !(await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, transactionConnectorId, idTag))
1190     ) {
1191       return this.notifyRemoteStartTransactionRejected(
1192         chargingStation,
1193         transactionConnectorId,
1194         idTag
1195       )
1196     }
1197     if (
1198       chargingProfile != null &&
1199       !this.setRemoteStartTransactionChargingProfile(
1200         chargingStation,
1201         transactionConnectorId,
1202         chargingProfile
1203       )
1204     ) {
1205       return this.notifyRemoteStartTransactionRejected(
1206         chargingStation,
1207         transactionConnectorId,
1208         idTag
1209       )
1210     }
1211     logger.debug(
1212       `${chargingStation.logPrefix()} Remote start transaction ACCEPTED on ${
1213         chargingStation.stationInfo?.chargingStationId
1214       }#${transactionConnectorId}}, idTag '${idTag}'`
1215     )
1216     return OCPP16Constants.OCPP_RESPONSE_ACCEPTED
1217   }
1218
1219   private notifyRemoteStartTransactionRejected (
1220     chargingStation: ChargingStation,
1221     connectorId: number,
1222     idTag: string
1223   ): GenericResponse {
1224     const connectorStatus = chargingStation.getConnectorStatus(connectorId)
1225     logger.debug(
1226       `${chargingStation.logPrefix()} Remote start transaction REJECTED on ${
1227         chargingStation.stationInfo?.chargingStationId
1228       }#${connectorId}, idTag '${idTag}', availability '${
1229         connectorStatus?.availability
1230       }', status '${connectorStatus?.status}'`
1231     )
1232     return OCPP16Constants.OCPP_RESPONSE_REJECTED
1233   }
1234
1235   private setRemoteStartTransactionChargingProfile (
1236     chargingStation: ChargingStation,
1237     connectorId: number,
1238     chargingProfile: OCPP16ChargingProfile
1239   ): boolean {
1240     if (chargingProfile.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE) {
1241       OCPP16ServiceUtils.setChargingProfile(chargingStation, connectorId, chargingProfile)
1242       logger.debug(
1243         `${chargingStation.logPrefix()} Charging profile(s) set at remote start transaction on ${
1244           chargingStation.stationInfo?.chargingStationId
1245         }#${connectorId}`,
1246         chargingProfile
1247       )
1248       return true
1249     }
1250     logger.debug(
1251       `${chargingStation.logPrefix()} Not allowed to set ${
1252         chargingProfile.chargingProfilePurpose
1253       } charging profile(s) at remote start transaction`
1254     )
1255     return false
1256   }
1257
1258   private handleRequestRemoteStopTransaction (
1259     chargingStation: ChargingStation,
1260     commandPayload: RemoteStopTransactionRequest
1261   ): GenericResponse {
1262     const { transactionId } = commandPayload
1263     if (chargingStation.getConnectorIdByTransactionId(transactionId) != null) {
1264       logger.debug(
1265         `${chargingStation.logPrefix()} Remote stop transaction ACCEPTED for transactionId '${transactionId}'`
1266       )
1267       return OCPP16Constants.OCPP_RESPONSE_ACCEPTED
1268     }
1269     logger.debug(
1270       `${chargingStation.logPrefix()} Remote stop transaction REJECTED for transactionId '${transactionId}'`
1271     )
1272     return OCPP16Constants.OCPP_RESPONSE_REJECTED
1273   }
1274
1275   private handleRequestUpdateFirmware (
1276     chargingStation: ChargingStation,
1277     commandPayload: OCPP16UpdateFirmwareRequest
1278   ): OCPP16UpdateFirmwareResponse {
1279     if (
1280       !OCPP16ServiceUtils.checkFeatureProfile(
1281         chargingStation,
1282         OCPP16SupportedFeatureProfiles.FirmwareManagement,
1283         OCPP16IncomingRequestCommand.UPDATE_FIRMWARE
1284       )
1285     ) {
1286       logger.warn(
1287         `${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware: Cannot simulate firmware update: feature profile not supported`
1288       )
1289       return OCPP16Constants.OCPP_RESPONSE_EMPTY
1290     }
1291     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1292     commandPayload.retrieveDate = convertToDate(commandPayload.retrieveDate)!
1293     const { retrieveDate } = commandPayload
1294     if (chargingStation.stationInfo?.firmwareStatus !== OCPP16FirmwareStatus.Installed) {
1295       logger.warn(
1296         `${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware: Cannot simulate firmware update: firmware update is already in progress`
1297       )
1298       return OCPP16Constants.OCPP_RESPONSE_EMPTY
1299     }
1300     const now = Date.now()
1301     if (retrieveDate.getTime() <= now) {
1302       this.updateFirmwareSimulation(chargingStation).catch(Constants.EMPTY_FUNCTION)
1303     } else {
1304       setTimeout(() => {
1305         this.updateFirmwareSimulation(chargingStation).catch(Constants.EMPTY_FUNCTION)
1306       }, retrieveDate.getTime() - now)
1307     }
1308     return OCPP16Constants.OCPP_RESPONSE_EMPTY
1309   }
1310
1311   private async updateFirmwareSimulation (
1312     chargingStation: ChargingStation,
1313     maxDelay = 30,
1314     minDelay = 15
1315   ): Promise<void> {
1316     if (!checkChargingStation(chargingStation, chargingStation.logPrefix())) {
1317       return
1318     }
1319     if (chargingStation.hasEvses) {
1320       for (const [evseId, evseStatus] of chargingStation.evses) {
1321         if (evseId > 0) {
1322           for (const [connectorId, connectorStatus] of evseStatus.connectors) {
1323             if (connectorStatus.transactionStarted === false) {
1324               await OCPP16ServiceUtils.sendAndSetConnectorStatus(
1325                 chargingStation,
1326                 connectorId,
1327                 OCPP16ChargePointStatus.Unavailable
1328               )
1329             }
1330           }
1331         }
1332       }
1333     } else {
1334       for (const connectorId of chargingStation.connectors.keys()) {
1335         if (
1336           connectorId > 0 &&
1337           chargingStation.getConnectorStatus(connectorId)?.transactionStarted === false
1338         ) {
1339           await OCPP16ServiceUtils.sendAndSetConnectorStatus(
1340             chargingStation,
1341             connectorId,
1342             OCPP16ChargePointStatus.Unavailable
1343           )
1344         }
1345       }
1346     }
1347     await chargingStation.ocppRequestService.requestHandler<
1348     OCPP16FirmwareStatusNotificationRequest,
1349     OCPP16FirmwareStatusNotificationResponse
1350     >(chargingStation, OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
1351       status: OCPP16FirmwareStatus.Downloading
1352     })
1353     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1354     chargingStation.stationInfo!.firmwareStatus = OCPP16FirmwareStatus.Downloading
1355     if (
1356       chargingStation.stationInfo?.firmwareUpgrade?.failureStatus ===
1357       OCPP16FirmwareStatus.DownloadFailed
1358     ) {
1359       await sleep(secondsToMilliseconds(randomInt(minDelay, maxDelay)))
1360       await chargingStation.ocppRequestService.requestHandler<
1361       OCPP16FirmwareStatusNotificationRequest,
1362       OCPP16FirmwareStatusNotificationResponse
1363       >(chargingStation, OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
1364         status: chargingStation.stationInfo.firmwareUpgrade.failureStatus
1365       })
1366       chargingStation.stationInfo.firmwareStatus =
1367         chargingStation.stationInfo.firmwareUpgrade.failureStatus
1368       return
1369     }
1370     await sleep(secondsToMilliseconds(randomInt(minDelay, maxDelay)))
1371     await chargingStation.ocppRequestService.requestHandler<
1372     OCPP16FirmwareStatusNotificationRequest,
1373     OCPP16FirmwareStatusNotificationResponse
1374     >(chargingStation, OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
1375       status: OCPP16FirmwareStatus.Downloaded
1376     })
1377     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1378     chargingStation.stationInfo!.firmwareStatus = OCPP16FirmwareStatus.Downloaded
1379     let wasTransactionsStarted = false
1380     let transactionsStarted: boolean
1381     do {
1382       const runningTransactions = chargingStation.getNumberOfRunningTransactions()
1383       if (runningTransactions > 0) {
1384         const waitTime = secondsToMilliseconds(15)
1385         logger.debug(
1386           `${chargingStation.logPrefix()} ${moduleName}.updateFirmwareSimulation: ${runningTransactions} transaction(s) in progress, waiting ${formatDurationMilliSeconds(
1387             waitTime
1388           )} before continuing firmware update simulation`
1389         )
1390         await sleep(waitTime)
1391         transactionsStarted = true
1392         wasTransactionsStarted = true
1393       } else {
1394         if (chargingStation.hasEvses) {
1395           for (const [evseId, evseStatus] of chargingStation.evses) {
1396             if (evseId > 0) {
1397               for (const [connectorId, connectorStatus] of evseStatus.connectors) {
1398                 if (connectorStatus.status !== OCPP16ChargePointStatus.Unavailable) {
1399                   await OCPP16ServiceUtils.sendAndSetConnectorStatus(
1400                     chargingStation,
1401                     connectorId,
1402                     OCPP16ChargePointStatus.Unavailable
1403                   )
1404                 }
1405               }
1406             }
1407           }
1408         } else {
1409           for (const connectorId of chargingStation.connectors.keys()) {
1410             if (
1411               connectorId > 0 &&
1412               chargingStation.getConnectorStatus(connectorId)?.status !==
1413                 OCPP16ChargePointStatus.Unavailable
1414             ) {
1415               await OCPP16ServiceUtils.sendAndSetConnectorStatus(
1416                 chargingStation,
1417                 connectorId,
1418                 OCPP16ChargePointStatus.Unavailable
1419               )
1420             }
1421           }
1422         }
1423         transactionsStarted = false
1424       }
1425     } while (transactionsStarted)
1426     !wasTransactionsStarted && (await sleep(secondsToMilliseconds(randomInt(minDelay, maxDelay))))
1427     if (!checkChargingStation(chargingStation, chargingStation.logPrefix())) {
1428       return
1429     }
1430     await chargingStation.ocppRequestService.requestHandler<
1431     OCPP16FirmwareStatusNotificationRequest,
1432     OCPP16FirmwareStatusNotificationResponse
1433     >(chargingStation, OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
1434       status: OCPP16FirmwareStatus.Installing
1435     })
1436     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1437     chargingStation.stationInfo!.firmwareStatus = OCPP16FirmwareStatus.Installing
1438     if (
1439       chargingStation.stationInfo?.firmwareUpgrade?.failureStatus ===
1440       OCPP16FirmwareStatus.InstallationFailed
1441     ) {
1442       await sleep(secondsToMilliseconds(randomInt(minDelay, maxDelay)))
1443       await chargingStation.ocppRequestService.requestHandler<
1444       OCPP16FirmwareStatusNotificationRequest,
1445       OCPP16FirmwareStatusNotificationResponse
1446       >(chargingStation, OCPP16RequestCommand.FIRMWARE_STATUS_NOTIFICATION, {
1447         status: chargingStation.stationInfo.firmwareUpgrade.failureStatus
1448       })
1449       chargingStation.stationInfo.firmwareStatus =
1450         chargingStation.stationInfo.firmwareUpgrade.failureStatus
1451       return
1452     }
1453     if (chargingStation.stationInfo?.firmwareUpgrade?.reset === true) {
1454       await sleep(secondsToMilliseconds(randomInt(minDelay, maxDelay)))
1455       await chargingStation.reset(OCPP16StopTransactionReason.REBOOT)
1456     }
1457   }
1458
1459   private async handleRequestGetDiagnostics (
1460     chargingStation: ChargingStation,
1461     commandPayload: GetDiagnosticsRequest
1462   ): Promise<GetDiagnosticsResponse> {
1463     if (
1464       !OCPP16ServiceUtils.checkFeatureProfile(
1465         chargingStation,
1466         OCPP16SupportedFeatureProfiles.FirmwareManagement,
1467         OCPP16IncomingRequestCommand.GET_DIAGNOSTICS
1468       )
1469     ) {
1470       logger.warn(
1471         `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: Cannot get diagnostics: feature profile not supported`
1472       )
1473       return OCPP16Constants.OCPP_RESPONSE_EMPTY
1474     }
1475     const { location } = commandPayload
1476     const uri = new URL(location)
1477     if (uri.protocol.startsWith('ftp:')) {
1478       let ftpClient: Client | undefined
1479       try {
1480         const logConfiguration = Configuration.getConfigurationSection<LogConfiguration>(
1481           ConfigurationSection.log
1482         )
1483         const logFiles = readdirSync(
1484           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1485           resolve((fileURLToPath(import.meta.url), '../', dirname(logConfiguration.file!)))
1486         )
1487           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1488           .filter(file => file.endsWith(extname(logConfiguration.file!)))
1489           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1490           .map(file => join(dirname(logConfiguration.file!), file))
1491         const diagnosticsArchive = `${chargingStation.stationInfo?.chargingStationId}_logs.tar.gz`
1492         create({ gzip: true }, logFiles).pipe(createWriteStream(diagnosticsArchive))
1493         ftpClient = new Client()
1494         const accessResponse = await ftpClient.access({
1495           host: uri.hostname,
1496           ...(isNotEmptyString(uri.port) && { port: convertToInt(uri.port) }),
1497           ...(isNotEmptyString(uri.username) && { user: uri.username }),
1498           ...(isNotEmptyString(uri.password) && { password: uri.password })
1499         })
1500         let uploadResponse: FTPResponse | undefined
1501         if (accessResponse.code === 220) {
1502           ftpClient.trackProgress(info => {
1503             logger.info(
1504               `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: ${
1505                 info.bytes / 1024
1506               } bytes transferred from diagnostics archive ${info.name}`
1507             )
1508             chargingStation.ocppRequestService
1509               .requestHandler<
1510             OCPP16DiagnosticsStatusNotificationRequest,
1511             OCPP16DiagnosticsStatusNotificationResponse
1512             >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
1513               status: OCPP16DiagnosticsStatus.Uploading
1514             })
1515               .catch((error: unknown) => {
1516                 logger.error(
1517                   `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: Error while sending '${
1518                     OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION
1519                   }'`,
1520                   error
1521                 )
1522               })
1523           })
1524           uploadResponse = await ftpClient.uploadFrom(
1525             join(resolve(dirname(fileURLToPath(import.meta.url)), '../'), diagnosticsArchive),
1526             `${uri.pathname}${diagnosticsArchive}`
1527           )
1528           if (uploadResponse.code === 226) {
1529             await chargingStation.ocppRequestService.requestHandler<
1530             OCPP16DiagnosticsStatusNotificationRequest,
1531             OCPP16DiagnosticsStatusNotificationResponse
1532             >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
1533               status: OCPP16DiagnosticsStatus.Uploaded
1534             })
1535             ftpClient.close()
1536             return { fileName: diagnosticsArchive }
1537           }
1538           throw new OCPPError(
1539             ErrorType.GENERIC_ERROR,
1540             `Diagnostics transfer failed with error code ${accessResponse.code}|${uploadResponse.code}`,
1541             OCPP16IncomingRequestCommand.GET_DIAGNOSTICS
1542           )
1543         }
1544         throw new OCPPError(
1545           ErrorType.GENERIC_ERROR,
1546           `Diagnostics transfer failed with error code ${accessResponse.code}|${uploadResponse?.code}`,
1547           OCPP16IncomingRequestCommand.GET_DIAGNOSTICS
1548         )
1549       } catch (error) {
1550         await chargingStation.ocppRequestService.requestHandler<
1551         OCPP16DiagnosticsStatusNotificationRequest,
1552         OCPP16DiagnosticsStatusNotificationResponse
1553         >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
1554           status: OCPP16DiagnosticsStatus.UploadFailed
1555         })
1556         ftpClient?.close()
1557         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1558         return this.handleIncomingRequestError<GetDiagnosticsResponse>(
1559           chargingStation,
1560           OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
1561           error as Error,
1562           { errorResponse: OCPP16Constants.OCPP_RESPONSE_EMPTY }
1563         )!
1564       }
1565     } else {
1566       logger.error(
1567         `${chargingStation.logPrefix()} Unsupported protocol ${
1568           uri.protocol
1569         } to transfer the diagnostic logs archive`
1570       )
1571       await chargingStation.ocppRequestService.requestHandler<
1572       OCPP16DiagnosticsStatusNotificationRequest,
1573       OCPP16DiagnosticsStatusNotificationResponse
1574       >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
1575         status: OCPP16DiagnosticsStatus.UploadFailed
1576       })
1577       return OCPP16Constants.OCPP_RESPONSE_EMPTY
1578     }
1579   }
1580
1581   private handleRequestTriggerMessage (
1582     chargingStation: ChargingStation,
1583     commandPayload: OCPP16TriggerMessageRequest
1584   ): OCPP16TriggerMessageResponse {
1585     const { requestedMessage, connectorId } = commandPayload
1586     if (
1587       !OCPP16ServiceUtils.checkFeatureProfile(
1588         chargingStation,
1589         OCPP16SupportedFeatureProfiles.RemoteTrigger,
1590         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE
1591       ) ||
1592       !OCPP16ServiceUtils.isMessageTriggerSupported(chargingStation, requestedMessage)
1593     ) {
1594       return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED
1595     }
1596     if (
1597       !OCPP16ServiceUtils.isConnectorIdValid(
1598         chargingStation,
1599         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
1600         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1601         connectorId!
1602       )
1603     ) {
1604       return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED
1605     }
1606     switch (requestedMessage) {
1607       case OCPP16MessageTrigger.BootNotification:
1608       case OCPP16MessageTrigger.Heartbeat:
1609       case OCPP16MessageTrigger.StatusNotification:
1610         return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED
1611       default:
1612         return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED
1613     }
1614   }
1615
1616   private handleRequestDataTransfer (
1617     chargingStation: ChargingStation,
1618     commandPayload: OCPP16DataTransferRequest
1619   ): OCPP16DataTransferResponse {
1620     const { vendorId } = commandPayload
1621     try {
1622       if (Object.values(OCPP16DataTransferVendorId).includes(vendorId)) {
1623         return OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_ACCEPTED
1624       }
1625       return OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_UNKNOWN_VENDOR_ID
1626     } catch (error) {
1627       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1628       return this.handleIncomingRequestError<OCPP16DataTransferResponse>(
1629         chargingStation,
1630         OCPP16IncomingRequestCommand.DATA_TRANSFER,
1631         error as Error,
1632         { errorResponse: OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_REJECTED }
1633       )!
1634     }
1635   }
1636
1637   private async handleRequestReserveNow (
1638     chargingStation: ChargingStation,
1639     commandPayload: OCPP16ReserveNowRequest
1640   ): Promise<OCPP16ReserveNowResponse> {
1641     if (
1642       !OCPP16ServiceUtils.checkFeatureProfile(
1643         chargingStation,
1644         OCPP16SupportedFeatureProfiles.Reservation,
1645         OCPP16IncomingRequestCommand.RESERVE_NOW
1646       )
1647     ) {
1648       return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED
1649     }
1650     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1651     commandPayload.expiryDate = convertToDate(commandPayload.expiryDate)!
1652     const { reservationId, idTag, connectorId } = commandPayload
1653     let response: OCPP16ReserveNowResponse
1654     try {
1655       if (connectorId > 0 && !chargingStation.isConnectorAvailable(connectorId)) {
1656         return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED
1657       }
1658       if (connectorId === 0 && !chargingStation.getReserveConnectorZeroSupported()) {
1659         return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED
1660       }
1661       if (!(await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, connectorId, idTag))) {
1662         return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED
1663       }
1664       await removeExpiredReservations(chargingStation)
1665       switch (chargingStation.getConnectorStatus(connectorId)?.status) {
1666         case OCPP16ChargePointStatus.Faulted:
1667           response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED
1668           break
1669         case OCPP16ChargePointStatus.Preparing:
1670         case OCPP16ChargePointStatus.Charging:
1671         case OCPP16ChargePointStatus.SuspendedEV:
1672         case OCPP16ChargePointStatus.SuspendedEVSE:
1673         case OCPP16ChargePointStatus.Finishing:
1674           response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED
1675           break
1676         case OCPP16ChargePointStatus.Unavailable:
1677           response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_UNAVAILABLE
1678           break
1679         case OCPP16ChargePointStatus.Reserved:
1680           if (!chargingStation.isConnectorReservable(reservationId, idTag, connectorId)) {
1681             response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED
1682             break
1683           }
1684         // eslint-disable-next-line no-fallthrough
1685         default:
1686           if (!chargingStation.isConnectorReservable(reservationId, idTag)) {
1687             response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED
1688             break
1689           }
1690           await chargingStation.addReservation({
1691             id: commandPayload.reservationId,
1692             ...commandPayload
1693           })
1694           response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_ACCEPTED
1695           break
1696       }
1697       return response
1698     } catch (error) {
1699       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1700       chargingStation.getConnectorStatus(connectorId)!.status = OCPP16ChargePointStatus.Available
1701       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1702       return this.handleIncomingRequestError<OCPP16ReserveNowResponse>(
1703         chargingStation,
1704         OCPP16IncomingRequestCommand.RESERVE_NOW,
1705         error as Error,
1706         { errorResponse: OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED }
1707       )!
1708     }
1709   }
1710
1711   private async handleRequestCancelReservation (
1712     chargingStation: ChargingStation,
1713     commandPayload: OCPP16CancelReservationRequest
1714   ): Promise<GenericResponse> {
1715     if (
1716       !OCPP16ServiceUtils.checkFeatureProfile(
1717         chargingStation,
1718         OCPP16SupportedFeatureProfiles.Reservation,
1719         OCPP16IncomingRequestCommand.CANCEL_RESERVATION
1720       )
1721     ) {
1722       return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED
1723     }
1724     try {
1725       const { reservationId } = commandPayload
1726       const reservation = chargingStation.getReservationBy('reservationId', reservationId)
1727       if (reservation == null) {
1728         logger.debug(
1729           `${chargingStation.logPrefix()} Reservation with id ${reservationId} does not exist on charging station`
1730         )
1731         return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED
1732       }
1733       await chargingStation.removeReservation(
1734         reservation,
1735         ReservationTerminationReason.RESERVATION_CANCELED
1736       )
1737       return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_ACCEPTED
1738     } catch (error) {
1739       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
1740       return this.handleIncomingRequestError<GenericResponse>(
1741         chargingStation,
1742         OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
1743         error as Error,
1744         {
1745           errorResponse: OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED
1746         }
1747       )!
1748     }
1749   }
1750 }