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

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