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

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import {
   4   ChangeAvailabilityRequest,
   5   ChangeConfigurationRequest,
   6   ClearChargingProfileRequest,
   7   DiagnosticsStatusNotificationRequest,
   8   GetConfigurationRequest,
   9   GetDiagnosticsRequest,
  10   MessageTrigger,
  11   OCPP16AvailabilityType,
  12   OCPP16BootNotificationRequest,
  13   OCPP16HeartbeatRequest,
  14   OCPP16IncomingRequestCommand,
  15   OCPP16RequestCommand,
  16   OCPP16StatusNotificationRequest,
  17   OCPP16TriggerMessageRequest,
  18   RemoteStartTransactionRequest,
  19   RemoteStopTransactionRequest,
  20   ResetRequest,
  21   SetChargingProfileRequest,
  22   UnlockConnectorRequest,
  23 } from '../../../types/ocpp/1.6/Requests';
  24 import {
  25   ChangeAvailabilityResponse,
  26   ChangeConfigurationResponse,
  27   ClearChargingProfileResponse,
  28   DiagnosticsStatusNotificationResponse,
  29   GetConfigurationResponse,
  30   GetDiagnosticsResponse,
  31   OCPP16BootNotificationResponse,
  32   OCPP16HeartbeatResponse,
  33   OCPP16StatusNotificationResponse,
  34   OCPP16TriggerMessageResponse,
  35   SetChargingProfileResponse,
  36   UnlockConnectorResponse,
  37 } from '../../../types/ocpp/1.6/Responses';
  38 import {
  39   ChargingProfilePurposeType,
  40   OCPP16ChargingProfile,
  41 } from '../../../types/ocpp/1.6/ChargingProfile';
  42 import { Client, FTPResponse } from 'basic-ftp';
  43 import {
  44   OCPP16AuthorizationStatus,
  45   OCPP16AuthorizeRequest,
  46   OCPP16AuthorizeResponse,
  47   OCPP16StartTransactionRequest,
  48   OCPP16StartTransactionResponse,
  49   OCPP16StopTransactionReason,
  50   OCPP16StopTransactionRequest,
  51   OCPP16StopTransactionResponse,
  52 } from '../../../types/ocpp/1.6/Transaction';
  53 import {
  54   OCPP16MeterValuesRequest,
  55   OCPP16MeterValuesResponse,
  56 } from '../../../types/ocpp/1.6/MeterValues';
  57 import {
  58   OCPP16StandardParametersKey,
  59   OCPP16SupportedFeatureProfiles,
  60 } from '../../../types/ocpp/1.6/Configuration';
  61
  62 import type ChargingStation from '../../ChargingStation';
  63 import { ChargingStationConfigurationUtils } from '../../ChargingStationConfigurationUtils';
  64 import Constants from '../../../utils/Constants';
  65 import { DefaultResponse } from '../../../types/ocpp/Responses';
  66 import { ErrorType } from '../../../types/ocpp/ErrorType';
  67 import { IncomingRequestHandler } from '../../../types/ocpp/Requests';
  68 import { JsonType } from '../../../types/JsonType';
  69 import { OCPP16ChargePointErrorCode } from '../../../types/ocpp/1.6/ChargePointErrorCode';
  70 import { OCPP16ChargePointStatus } from '../../../types/ocpp/1.6/ChargePointStatus';
  71 import { OCPP16DiagnosticsStatus } from '../../../types/ocpp/1.6/DiagnosticsStatus';
  72 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
  73 import { OCPPConfigurationKey } from '../../../types/ocpp/Configuration';
  74 import OCPPError from '../../../exception/OCPPError';
  75 import OCPPIncomingRequestService from '../OCPPIncomingRequestService';
  76 import { URL } from 'url';
  77 import Utils from '../../../utils/Utils';
  78 import fs from 'fs';
  79 import logger from '../../../utils/Logger';
  80 import path from 'path';
  81 import tar from 'tar';
  82
  83 const moduleName = 'OCPP16IncomingRequestService';
  84
  85 export default class OCPP16IncomingRequestService extends OCPPIncomingRequestService {
  86   private incomingRequestHandlers: Map<OCPP16IncomingRequestCommand, IncomingRequestHandler>;
  87
  88   public constructor() {
  89     if (new.target?.name === moduleName) {
  90       throw new TypeError(`Cannot construct ${new.target?.name} instances directly`);
  91     }
  92     super();
  93     this.incomingRequestHandlers = new Map<OCPP16IncomingRequestCommand, IncomingRequestHandler>([
  94       [OCPP16IncomingRequestCommand.RESET, this.handleRequestReset.bind(this)],
  95       [OCPP16IncomingRequestCommand.CLEAR_CACHE, this.handleRequestClearCache.bind(this)],
  96       [OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR, this.handleRequestUnlockConnector.bind(this)],
  97       [
  98         OCPP16IncomingRequestCommand.GET_CONFIGURATION,
  99         this.handleRequestGetConfiguration.bind(this),
 100       ],
 101       [
 102         OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
 103         this.handleRequestChangeConfiguration.bind(this),
 104       ],
 105       [
 106         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
 107         this.handleRequestSetChargingProfile.bind(this),
 108       ],
 109       [
 110         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
 111         this.handleRequestClearChargingProfile.bind(this),
 112       ],
 113       [
 114         OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
 115         this.handleRequestChangeAvailability.bind(this),
 116       ],
 117       [
 118         OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
 119         this.handleRequestRemoteStartTransaction.bind(this),
 120       ],
 121       [
 122         OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
 123         this.handleRequestRemoteStopTransaction.bind(this),
 124       ],
 125       [OCPP16IncomingRequestCommand.GET_DIAGNOSTICS, this.handleRequestGetDiagnostics.bind(this)],
 126       [OCPP16IncomingRequestCommand.TRIGGER_MESSAGE, this.handleRequestTriggerMessage.bind(this)],
 127     ]);
 128   }
 129
 130   public async incomingRequestHandler(
 131     chargingStation: ChargingStation,
 132     messageId: string,
 133     commandName: OCPP16IncomingRequestCommand,
 134     commandPayload: JsonType
 135   ): Promise<void> {
 136     let response: JsonType;
 137     if (
 138       chargingStation.getOcppStrictCompliance() &&
 139       chargingStation.isInPendingState() &&
 140       (commandName === OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION ||
 141         commandName === OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION)
 142     ) {
 143       throw new OCPPError(
 144         ErrorType.SECURITY_ERROR,
 145         `${commandName} cannot be issued to handle request payload ${JSON.stringify(
 146           commandPayload,
 147           null,
 148           2
 149         )} while the charging station is in pending state on the central server`,
 150         commandName
 151       );
 152     }
 153     if (
 154       chargingStation.isRegistered() ||
 155       (!chargingStation.getOcppStrictCompliance() && chargingStation.isInUnknownState())
 156     ) {
 157       if (this.incomingRequestHandlers.has(commandName)) {
 158         try {
 159           // Call the method to build the response
 160           response = await this.incomingRequestHandlers.get(commandName)(
 161             chargingStation,
 162             commandPayload
 163           );
 164         } catch (error) {
 165           // Log
 166           logger.error(chargingStation.logPrefix() + ' Handle request error: %j', error);
 167           throw error;
 168         }
 169       } else {
 170         // Throw exception
 171         throw new OCPPError(
 172           ErrorType.NOT_IMPLEMENTED,
 173           `${commandName} is not implemented to handle request payload ${JSON.stringify(
 174             commandPayload,
 175             null,
 176             2
 177           )}`,
 178           commandName
 179         );
 180       }
 181     } else {
 182       throw new OCPPError(
 183         ErrorType.SECURITY_ERROR,
 184         `${commandName} cannot be issued to handle request payload ${JSON.stringify(
 185           commandPayload,
 186           null,
 187           2
 188         )} while the charging station is not registered on the central server.`,
 189         commandName
 190       );
 191     }
 192     // Send the built response
 193     await chargingStation.ocppRequestService.sendResponse(
 194       chargingStation,
 195       messageId,
 196       response,
 197       commandName
 198     );
 199   }
 200
 201   // Simulate charging station restart
 202   private handleRequestReset(
 203     chargingStation: ChargingStation,
 204     commandPayload: ResetRequest
 205   ): DefaultResponse {
 206     // eslint-disable-next-line @typescript-eslint/no-misused-promises
 207     setImmediate(async (): Promise<void> => {
 208       await chargingStation.reset((commandPayload.type + 'Reset') as OCPP16StopTransactionReason);
 209     });
 210     logger.info(
 211       `${chargingStation.logPrefix()} ${
 212         commandPayload.type
 213       } reset command received, simulating it. The station will be back online in ${Utils.formatDurationMilliSeconds(
 214         chargingStation.stationInfo.resetTime
 215       )}`
 216     );
 217     return Constants.OCPP_RESPONSE_ACCEPTED;
 218   }
 219
 220   private handleRequestClearCache(): DefaultResponse {
 221     return Constants.OCPP_RESPONSE_ACCEPTED;
 222   }
 223
 224   private async handleRequestUnlockConnector(
 225     chargingStation: ChargingStation,
 226     commandPayload: UnlockConnectorRequest
 227   ): Promise<UnlockConnectorResponse> {
 228     const connectorId = commandPayload.connectorId;
 229     if (connectorId === 0) {
 230       logger.error(
 231         chargingStation.logPrefix() + ' Trying to unlock connector ' + connectorId.toString()
 232       );
 233       return Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
 234     }
 235     if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted) {
 236       const transactionId = chargingStation.getConnectorStatus(connectorId).transactionId;
 237       if (
 238         chargingStation.getBeginEndMeterValues() &&
 239         chargingStation.getOcppStrictCompliance() &&
 240         !chargingStation.getOutOfOrderEndMeterValues()
 241       ) {
 242         // FIXME: Implement OCPP version agnostic helpers
 243         const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(
 244           chargingStation,
 245           connectorId,
 246           chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId)
 247         );
 248         await chargingStation.ocppRequestService.requestHandler<
 249           OCPP16MeterValuesRequest,
 250           OCPP16MeterValuesResponse
 251         >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
 252           connectorId,
 253           transactionId,
 254           meterValue: transactionEndMeterValue,
 255         });
 256       }
 257       const stopResponse = await chargingStation.ocppRequestService.requestHandler<
 258         OCPP16StopTransactionRequest,
 259         OCPP16StopTransactionResponse
 260       >(chargingStation, OCPP16RequestCommand.STOP_TRANSACTION, {
 261         transactionId,
 262         meterStop: chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId),
 263         idTag: chargingStation.getTransactionIdTag(transactionId),
 264         reason: OCPP16StopTransactionReason.UNLOCK_COMMAND,
 265       });
 266       if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 267         return Constants.OCPP_RESPONSE_UNLOCKED;
 268       }
 269       return Constants.OCPP_RESPONSE_UNLOCK_FAILED;
 270     }
 271     await chargingStation.ocppRequestService.requestHandler<
 272       OCPP16StatusNotificationRequest,
 273       OCPP16StatusNotificationResponse
 274     >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 275       connectorId,
 276       status: OCPP16ChargePointStatus.AVAILABLE,
 277       errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 278     });
 279     chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.AVAILABLE;
 280     return Constants.OCPP_RESPONSE_UNLOCKED;
 281   }
 282
 283   private handleRequestGetConfiguration(
 284     chargingStation: ChargingStation,
 285     commandPayload: GetConfigurationRequest
 286   ): GetConfigurationResponse {
 287     const configurationKey: OCPPConfigurationKey[] = [];
 288     const unknownKey: string[] = [];
 289     if (Utils.isEmptyArray(commandPayload.key)) {
 290       for (const configuration of chargingStation.ocppConfiguration.configurationKey) {
 291         if (Utils.isUndefined(configuration.visible)) {
 292           configuration.visible = true;
 293         }
 294         if (!configuration.visible) {
 295           continue;
 296         }
 297         configurationKey.push({
 298           key: configuration.key,
 299           readonly: configuration.readonly,
 300           value: configuration.value,
 301         });
 302       }
 303     } else {
 304       for (const key of commandPayload.key) {
 305         const keyFound = ChargingStationConfigurationUtils.getConfigurationKey(
 306           chargingStation,
 307           key
 308         );
 309         if (keyFound) {
 310           if (Utils.isUndefined(keyFound.visible)) {
 311             keyFound.visible = true;
 312           }
 313           if (!keyFound.visible) {
 314             continue;
 315           }
 316           configurationKey.push({
 317             key: keyFound.key,
 318             readonly: keyFound.readonly,
 319             value: keyFound.value,
 320           });
 321         } else {
 322           unknownKey.push(key);
 323         }
 324       }
 325     }
 326     return {
 327       configurationKey,
 328       unknownKey,
 329     };
 330   }
 331
 332   private handleRequestChangeConfiguration(
 333     chargingStation: ChargingStation,
 334     commandPayload: ChangeConfigurationRequest
 335   ): ChangeConfigurationResponse {
 336     // JSON request fields type sanity check
 337     if (!Utils.isString(commandPayload.key)) {
 338       logger.error(
 339         `${chargingStation.logPrefix()} ${
 340           OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION
 341         } request key field is not a string:`,
 342         commandPayload
 343       );
 344     }
 345     if (!Utils.isString(commandPayload.value)) {
 346       logger.error(
 347         `${chargingStation.logPrefix()} ${
 348           OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION
 349         } request value field is not a string:`,
 350         commandPayload
 351       );
 352     }
 353     const keyToChange = ChargingStationConfigurationUtils.getConfigurationKey(
 354       chargingStation,
 355       commandPayload.key,
 356       true
 357     );
 358     if (!keyToChange) {
 359       return Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
 360     } else if (keyToChange && keyToChange.readonly) {
 361       return Constants.OCPP_CONFIGURATION_RESPONSE_REJECTED;
 362     } else if (keyToChange && !keyToChange.readonly) {
 363       let valueChanged = false;
 364       if (keyToChange.value !== commandPayload.value) {
 365         ChargingStationConfigurationUtils.setConfigurationKeyValue(
 366           chargingStation,
 367           commandPayload.key,
 368           commandPayload.value,
 369           true
 370         );
 371         valueChanged = true;
 372       }
 373       let triggerHeartbeatRestart = false;
 374       if (keyToChange.key === OCPP16StandardParametersKey.HeartBeatInterval && valueChanged) {
 375         ChargingStationConfigurationUtils.setConfigurationKeyValue(
 376           chargingStation,
 377           OCPP16StandardParametersKey.HeartbeatInterval,
 378           commandPayload.value
 379         );
 380         triggerHeartbeatRestart = true;
 381       }
 382       if (keyToChange.key === OCPP16StandardParametersKey.HeartbeatInterval && valueChanged) {
 383         ChargingStationConfigurationUtils.setConfigurationKeyValue(
 384           chargingStation,
 385           OCPP16StandardParametersKey.HeartBeatInterval,
 386           commandPayload.value
 387         );
 388         triggerHeartbeatRestart = true;
 389       }
 390       if (triggerHeartbeatRestart) {
 391         chargingStation.restartHeartbeat();
 392       }
 393       if (keyToChange.key === OCPP16StandardParametersKey.WebSocketPingInterval && valueChanged) {
 394         chargingStation.restartWebSocketPing();
 395       }
 396       if (keyToChange.reboot) {
 397         return Constants.OCPP_CONFIGURATION_RESPONSE_REBOOT_REQUIRED;
 398       }
 399       return Constants.OCPP_CONFIGURATION_RESPONSE_ACCEPTED;
 400     }
 401   }
 402
 403   private handleRequestSetChargingProfile(
 404     chargingStation: ChargingStation,
 405     commandPayload: SetChargingProfileRequest
 406   ): SetChargingProfileResponse {
 407     if (
 408       !OCPP16ServiceUtils.checkFeatureProfile(
 409         chargingStation,
 410         OCPP16SupportedFeatureProfiles.SmartCharging,
 411         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE
 412       )
 413     ) {
 414       return Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_NOT_SUPPORTED;
 415     }
 416     if (!chargingStation.getConnectorStatus(commandPayload.connectorId)) {
 417       logger.error(
 418         `${chargingStation.logPrefix()} Trying to set charging profile(s) to a non existing connector Id ${
 419           commandPayload.connectorId
 420         }`
 421       );
 422       return Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
 423     }
 424     if (
 425       commandPayload.csChargingProfiles.chargingProfilePurpose ===
 426         ChargingProfilePurposeType.CHARGE_POINT_MAX_PROFILE &&
 427       commandPayload.connectorId !== 0
 428     ) {
 429       return Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
 430     }
 431     if (
 432       commandPayload.csChargingProfiles.chargingProfilePurpose ===
 433         ChargingProfilePurposeType.TX_PROFILE &&
 434       (commandPayload.connectorId === 0 ||
 435         !chargingStation.getConnectorStatus(commandPayload.connectorId)?.transactionStarted)
 436     ) {
 437       return Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
 438     }
 439     chargingStation.setChargingProfile(
 440       commandPayload.connectorId,
 441       commandPayload.csChargingProfiles
 442     );
 443     logger.debug(
 444       `${chargingStation.logPrefix()} Charging profile(s) set on connector id ${
 445         commandPayload.connectorId
 446       }, dump their stack: %j`,
 447       chargingStation.getConnectorStatus(commandPayload.connectorId).chargingProfiles
 448     );
 449     return Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_ACCEPTED;
 450   }
 451
 452   private handleRequestClearChargingProfile(
 453     chargingStation: ChargingStation,
 454     commandPayload: ClearChargingProfileRequest
 455   ): ClearChargingProfileResponse {
 456     if (
 457       !OCPP16ServiceUtils.checkFeatureProfile(
 458         chargingStation,
 459         OCPP16SupportedFeatureProfiles.SmartCharging,
 460         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE
 461       )
 462     ) {
 463       return Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
 464     }
 465     const connectorStatus = chargingStation.getConnectorStatus(commandPayload.connectorId);
 466     if (!connectorStatus) {
 467       logger.error(
 468         `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to a non existing connector Id ${
 469           commandPayload.connectorId
 470         }`
 471       );
 472       return Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
 473     }
 474     if (commandPayload.connectorId && !Utils.isEmptyArray(connectorStatus.chargingProfiles)) {
 475       connectorStatus.chargingProfiles = [];
 476       logger.debug(
 477         `${chargingStation.logPrefix()} Charging profile(s) cleared on connector id ${
 478           commandPayload.connectorId
 479         }, dump their stack: %j`,
 480         connectorStatus.chargingProfiles
 481       );
 482       return Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
 483     }
 484     if (!commandPayload.connectorId) {
 485       let clearedCP = false;
 486       for (const connectorId of chargingStation.connectors.keys()) {
 487         if (!Utils.isEmptyArray(chargingStation.getConnectorStatus(connectorId).chargingProfiles)) {
 488           chargingStation
 489             .getConnectorStatus(connectorId)
 490             .chargingProfiles?.forEach((chargingProfile: OCPP16ChargingProfile, index: number) => {
 491               let clearCurrentCP = false;
 492               if (chargingProfile.chargingProfileId === commandPayload.id) {
 493                 clearCurrentCP = true;
 494               }
 495               if (
 496                 !commandPayload.chargingProfilePurpose &&
 497                 chargingProfile.stackLevel === commandPayload.stackLevel
 498               ) {
 499                 clearCurrentCP = true;
 500               }
 501               if (
 502                 !chargingProfile.stackLevel &&
 503                 chargingProfile.chargingProfilePurpose === commandPayload.chargingProfilePurpose
 504               ) {
 505                 clearCurrentCP = true;
 506               }
 507               if (
 508                 chargingProfile.stackLevel === commandPayload.stackLevel &&
 509                 chargingProfile.chargingProfilePurpose === commandPayload.chargingProfilePurpose
 510               ) {
 511                 clearCurrentCP = true;
 512               }
 513               if (clearCurrentCP) {
 514                 connectorStatus.chargingProfiles.splice(index, 1);
 515                 logger.debug(
 516                   `${chargingStation.logPrefix()} Matching charging profile(s) cleared on connector id ${
 517                     commandPayload.connectorId
 518                   }, dump their stack: %j`,
 519                   connectorStatus.chargingProfiles
 520                 );
 521                 clearedCP = true;
 522               }
 523             });
 524         }
 525       }
 526       if (clearedCP) {
 527         return Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
 528       }
 529     }
 530     return Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
 531   }
 532
 533   private async handleRequestChangeAvailability(
 534     chargingStation: ChargingStation,
 535     commandPayload: ChangeAvailabilityRequest
 536   ): Promise<ChangeAvailabilityResponse> {
 537     const connectorId: number = commandPayload.connectorId;
 538     if (!chargingStation.getConnectorStatus(connectorId)) {
 539       logger.error(
 540         `${chargingStation.logPrefix()} Trying to change the availability of a non existing connector Id ${connectorId.toString()}`
 541       );
 542       return Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
 543     }
 544     const chargePointStatus: OCPP16ChargePointStatus =
 545       commandPayload.type === OCPP16AvailabilityType.OPERATIVE
 546         ? OCPP16ChargePointStatus.AVAILABLE
 547         : OCPP16ChargePointStatus.UNAVAILABLE;
 548     if (connectorId === 0) {
 549       let response: ChangeAvailabilityResponse = Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
 550       for (const id of chargingStation.connectors.keys()) {
 551         if (chargingStation.getConnectorStatus(id)?.transactionStarted) {
 552           response = Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
 553         }
 554         chargingStation.getConnectorStatus(id).availability = commandPayload.type;
 555         if (response === Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED) {
 556           await chargingStation.ocppRequestService.requestHandler<
 557             OCPP16StatusNotificationRequest,
 558             OCPP16StatusNotificationResponse
 559           >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 560             connectorId: id,
 561             status: chargePointStatus,
 562             errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 563           });
 564           chargingStation.getConnectorStatus(id).status = chargePointStatus;
 565         }
 566       }
 567       return response;
 568     } else if (
 569       connectorId > 0 &&
 570       (chargingStation.getConnectorStatus(0).availability === OCPP16AvailabilityType.OPERATIVE ||
 571         (chargingStation.getConnectorStatus(0).availability ===
 572           OCPP16AvailabilityType.INOPERATIVE &&
 573           commandPayload.type === OCPP16AvailabilityType.INOPERATIVE))
 574     ) {
 575       if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted) {
 576         chargingStation.getConnectorStatus(connectorId).availability = commandPayload.type;
 577         return Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
 578       }
 579       chargingStation.getConnectorStatus(connectorId).availability = commandPayload.type;
 580       await chargingStation.ocppRequestService.requestHandler<
 581         OCPP16StatusNotificationRequest,
 582         OCPP16StatusNotificationResponse
 583       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 584         connectorId,
 585         status: chargePointStatus,
 586         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 587       });
 588       chargingStation.getConnectorStatus(connectorId).status = chargePointStatus;
 589       return Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
 590     }
 591     return Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
 592   }
 593
 594   private async handleRequestRemoteStartTransaction(
 595     chargingStation: ChargingStation,
 596     commandPayload: RemoteStartTransactionRequest
 597   ): Promise<DefaultResponse> {
 598     const transactionConnectorId = commandPayload.connectorId;
 599     const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId);
 600     if (transactionConnectorId) {
 601       await chargingStation.ocppRequestService.requestHandler<
 602         OCPP16StatusNotificationRequest,
 603         OCPP16StatusNotificationResponse
 604       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 605         connectorId: transactionConnectorId,
 606         status: OCPP16ChargePointStatus.PREPARING,
 607         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 608       });
 609       connectorStatus.status = OCPP16ChargePointStatus.PREPARING;
 610       if (chargingStation.isChargingStationAvailable() && connectorStatus) {
 611         // Check if authorized
 612         if (chargingStation.getAuthorizeRemoteTxRequests()) {
 613           let authorized = false;
 614           if (
 615             chargingStation.getLocalAuthListEnabled() &&
 616             chargingStation.hasAuthorizedTags() &&
 617             chargingStation.authorizedTags.find((value) => value === commandPayload.idTag)
 618           ) {
 619             connectorStatus.localAuthorizeIdTag = commandPayload.idTag;
 620             connectorStatus.idTagLocalAuthorized = true;
 621             authorized = true;
 622           } else if (chargingStation.getMayAuthorizeAtRemoteStart()) {
 623             connectorStatus.authorizeIdTag = commandPayload.idTag;
 624             const authorizeResponse: OCPP16AuthorizeResponse =
 625               await chargingStation.ocppRequestService.requestHandler<
 626                 OCPP16AuthorizeRequest,
 627                 OCPP16AuthorizeResponse
 628               >(chargingStation, OCPP16RequestCommand.AUTHORIZE, {
 629                 idTag: commandPayload.idTag,
 630               });
 631             if (authorizeResponse?.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 632               authorized = true;
 633             }
 634           } else {
 635             logger.warn(
 636               `${chargingStation.logPrefix()} The charging station configuration expects authorize at remote start transaction but local authorization or authorize isn't enabled`
 637             );
 638           }
 639           if (authorized) {
 640             // Authorization successful, start transaction
 641             if (
 642               this.setRemoteStartTransactionChargingProfile(
 643                 chargingStation,
 644                 transactionConnectorId,
 645                 commandPayload.chargingProfile
 646               )
 647             ) {
 648               connectorStatus.transactionRemoteStarted = true;
 649               if (
 650                 (
 651                   await chargingStation.ocppRequestService.requestHandler<
 652                     OCPP16StartTransactionRequest,
 653                     OCPP16StartTransactionResponse
 654                   >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
 655                     connectorId: transactionConnectorId,
 656                     idTag: commandPayload.idTag,
 657                   })
 658                 ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
 659               ) {
 660                 logger.debug(
 661                   chargingStation.logPrefix() +
 662                     ' Transaction remotely STARTED on ' +
 663                     chargingStation.stationInfo.chargingStationId +
 664                     '#' +
 665                     transactionConnectorId.toString() +
 666                     ' for idTag ' +
 667                     commandPayload.idTag
 668                 );
 669                 return Constants.OCPP_RESPONSE_ACCEPTED;
 670               }
 671               return this.notifyRemoteStartTransactionRejected(
 672                 chargingStation,
 673                 transactionConnectorId,
 674                 commandPayload.idTag
 675               );
 676             }
 677             return this.notifyRemoteStartTransactionRejected(
 678               chargingStation,
 679               transactionConnectorId,
 680               commandPayload.idTag
 681             );
 682           }
 683           return this.notifyRemoteStartTransactionRejected(
 684             chargingStation,
 685             transactionConnectorId,
 686             commandPayload.idTag
 687           );
 688         }
 689         // No authorization check required, start transaction
 690         if (
 691           this.setRemoteStartTransactionChargingProfile(
 692             chargingStation,
 693             transactionConnectorId,
 694             commandPayload.chargingProfile
 695           )
 696         ) {
 697           connectorStatus.transactionRemoteStarted = true;
 698           if (
 699             (
 700               await chargingStation.ocppRequestService.requestHandler<
 701                 OCPP16StartTransactionRequest,
 702                 OCPP16StartTransactionResponse
 703               >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
 704                 connectorId: transactionConnectorId,
 705                 idTag: commandPayload.idTag,
 706               })
 707             ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
 708           ) {
 709             logger.debug(
 710               chargingStation.logPrefix() +
 711                 ' Transaction remotely STARTED on ' +
 712                 chargingStation.stationInfo.chargingStationId +
 713                 '#' +
 714                 transactionConnectorId.toString() +
 715                 ' for idTag ' +
 716                 commandPayload.idTag
 717             );
 718             return Constants.OCPP_RESPONSE_ACCEPTED;
 719           }
 720           return this.notifyRemoteStartTransactionRejected(
 721             chargingStation,
 722             transactionConnectorId,
 723             commandPayload.idTag
 724           );
 725         }
 726         return this.notifyRemoteStartTransactionRejected(
 727           chargingStation,
 728           transactionConnectorId,
 729           commandPayload.idTag
 730         );
 731       }
 732       return this.notifyRemoteStartTransactionRejected(
 733         chargingStation,
 734         transactionConnectorId,
 735         commandPayload.idTag
 736       );
 737     }
 738     return this.notifyRemoteStartTransactionRejected(
 739       chargingStation,
 740       transactionConnectorId,
 741       commandPayload.idTag
 742     );
 743   }
 744
 745   private async notifyRemoteStartTransactionRejected(
 746     chargingStation: ChargingStation,
 747     connectorId: number,
 748     idTag: string
 749   ): Promise<DefaultResponse> {
 750     if (
 751       chargingStation.getConnectorStatus(connectorId).status !== OCPP16ChargePointStatus.AVAILABLE
 752     ) {
 753       await chargingStation.ocppRequestService.requestHandler<
 754         OCPP16StatusNotificationRequest,
 755         OCPP16StatusNotificationResponse
 756       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 757         connectorId,
 758         status: OCPP16ChargePointStatus.AVAILABLE,
 759         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 760       });
 761       chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.AVAILABLE;
 762     }
 763     logger.warn(
 764       chargingStation.logPrefix() +
 765         ' Remote starting transaction REJECTED on connector Id ' +
 766         connectorId.toString() +
 767         ', idTag ' +
 768         idTag +
 769         ', availability ' +
 770         chargingStation.getConnectorStatus(connectorId).availability +
 771         ', status ' +
 772         chargingStation.getConnectorStatus(connectorId).status
 773     );
 774     return Constants.OCPP_RESPONSE_REJECTED;
 775   }
 776
 777   private setRemoteStartTransactionChargingProfile(
 778     chargingStation: ChargingStation,
 779     connectorId: number,
 780     cp: OCPP16ChargingProfile
 781   ): boolean {
 782     if (cp && cp.chargingProfilePurpose === ChargingProfilePurposeType.TX_PROFILE) {
 783       chargingStation.setChargingProfile(connectorId, cp);
 784       logger.debug(
 785         `${chargingStation.logPrefix()} Charging profile(s) set at remote start transaction on connector id ${connectorId}, dump their stack: %j`,
 786         chargingStation.getConnectorStatus(connectorId).chargingProfiles
 787       );
 788       return true;
 789     } else if (cp && cp.chargingProfilePurpose !== ChargingProfilePurposeType.TX_PROFILE) {
 790       logger.warn(
 791         `${chargingStation.logPrefix()} Not allowed to set ${
 792           cp.chargingProfilePurpose
 793         } charging profile(s) at remote start transaction`
 794       );
 795       return false;
 796     } else if (!cp) {
 797       return true;
 798     }
 799   }
 800
 801   private async handleRequestRemoteStopTransaction(
 802     chargingStation: ChargingStation,
 803     commandPayload: RemoteStopTransactionRequest
 804   ): Promise<DefaultResponse> {
 805     const transactionId = commandPayload.transactionId;
 806     for (const connectorId of chargingStation.connectors.keys()) {
 807       if (
 808         connectorId > 0 &&
 809         chargingStation.getConnectorStatus(connectorId)?.transactionId === transactionId
 810       ) {
 811         await chargingStation.ocppRequestService.requestHandler<
 812           OCPP16StatusNotificationRequest,
 813           OCPP16StatusNotificationResponse
 814         >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 815           connectorId,
 816           status: OCPP16ChargePointStatus.FINISHING,
 817           errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 818         });
 819         chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.FINISHING;
 820         if (
 821           chargingStation.getBeginEndMeterValues() &&
 822           chargingStation.getOcppStrictCompliance() &&
 823           !chargingStation.getOutOfOrderEndMeterValues()
 824         ) {
 825           // FIXME: Implement OCPP version agnostic helpers
 826           const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(
 827             chargingStation,
 828             connectorId,
 829             chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId)
 830           );
 831           await chargingStation.ocppRequestService.requestHandler<
 832             OCPP16MeterValuesRequest,
 833             OCPP16MeterValuesResponse
 834           >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
 835             connectorId,
 836             transactionId,
 837             meterValue: transactionEndMeterValue,
 838           });
 839         }
 840         await chargingStation.ocppRequestService.requestHandler<
 841           OCPP16StopTransactionRequest,
 842           OCPP16StopTransactionResponse
 843         >(chargingStation, OCPP16RequestCommand.STOP_TRANSACTION, {
 844           transactionId,
 845           meterStop: chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId),
 846           idTag: chargingStation.getTransactionIdTag(transactionId),
 847         });
 848         return Constants.OCPP_RESPONSE_ACCEPTED;
 849       }
 850     }
 851     logger.info(
 852       chargingStation.logPrefix() +
 853         ' Trying to remote stop a non existing transaction ' +
 854         transactionId.toString()
 855     );
 856     return Constants.OCPP_RESPONSE_REJECTED;
 857   }
 858
 859   private async handleRequestGetDiagnostics(
 860     chargingStation: ChargingStation,
 861     commandPayload: GetDiagnosticsRequest
 862   ): Promise<GetDiagnosticsResponse> {
 863     if (
 864       !OCPP16ServiceUtils.checkFeatureProfile(
 865         chargingStation,
 866         OCPP16SupportedFeatureProfiles.FirmwareManagement,
 867         OCPP16IncomingRequestCommand.GET_DIAGNOSTICS
 868       )
 869     ) {
 870       return Constants.OCPP_RESPONSE_EMPTY;
 871     }
 872     logger.debug(
 873       chargingStation.logPrefix() +
 874         ' ' +
 875         OCPP16IncomingRequestCommand.GET_DIAGNOSTICS +
 876         ' request received: %j',
 877       commandPayload
 878     );
 879     const uri = new URL(commandPayload.location);
 880     if (uri.protocol.startsWith('ftp:')) {
 881       let ftpClient: Client;
 882       try {
 883         const logFiles = fs
 884           .readdirSync(path.resolve(__dirname, '../../../../'))
 885           .filter((file) => file.endsWith('.log'))
 886           .map((file) => path.join('./', file));
 887         const diagnosticsArchive = chargingStation.stationInfo.chargingStationId + '_logs.tar.gz';
 888         tar.create({ gzip: true }, logFiles).pipe(fs.createWriteStream(diagnosticsArchive));
 889         ftpClient = new Client();
 890         const accessResponse = await ftpClient.access({
 891           host: uri.host,
 892           ...(!Utils.isEmptyString(uri.port) && { port: Utils.convertToInt(uri.port) }),
 893           ...(!Utils.isEmptyString(uri.username) && { user: uri.username }),
 894           ...(!Utils.isEmptyString(uri.password) && { password: uri.password }),
 895         });
 896         let uploadResponse: FTPResponse;
 897         if (accessResponse.code === 220) {
 898           // eslint-disable-next-line @typescript-eslint/no-misused-promises
 899           ftpClient.trackProgress(async (info) => {
 900             logger.info(
 901               `${chargingStation.logPrefix()} ${
 902                 info.bytes / 1024
 903               } bytes transferred from diagnostics archive ${info.name}`
 904             );
 905             await chargingStation.ocppRequestService.requestHandler<
 906               DiagnosticsStatusNotificationRequest,
 907               DiagnosticsStatusNotificationResponse
 908             >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
 909               status: OCPP16DiagnosticsStatus.Uploading,
 910             });
 911           });
 912           uploadResponse = await ftpClient.uploadFrom(
 913             path.join(path.resolve(__dirname, '../../../../'), diagnosticsArchive),
 914             uri.pathname + diagnosticsArchive
 915           );
 916           if (uploadResponse.code === 226) {
 917             await chargingStation.ocppRequestService.requestHandler<
 918               DiagnosticsStatusNotificationRequest,
 919               DiagnosticsStatusNotificationResponse
 920             >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
 921               status: OCPP16DiagnosticsStatus.Uploaded,
 922             });
 923             if (ftpClient) {
 924               ftpClient.close();
 925             }
 926             return { fileName: diagnosticsArchive };
 927           }
 928           throw new OCPPError(
 929             ErrorType.GENERIC_ERROR,
 930             `Diagnostics transfer failed with error code ${accessResponse.code.toString()}${
 931               uploadResponse?.code && '|' + uploadResponse?.code.toString()
 932             }`,
 933             OCPP16IncomingRequestCommand.GET_DIAGNOSTICS
 934           );
 935         }
 936         throw new OCPPError(
 937           ErrorType.GENERIC_ERROR,
 938           `Diagnostics transfer failed with error code ${accessResponse.code.toString()}${
 939             uploadResponse?.code && '|' + uploadResponse?.code.toString()
 940           }`,
 941           OCPP16IncomingRequestCommand.GET_DIAGNOSTICS
 942         );
 943       } catch (error) {
 944         await chargingStation.ocppRequestService.requestHandler<
 945           DiagnosticsStatusNotificationRequest,
 946           DiagnosticsStatusNotificationResponse
 947         >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
 948           status: OCPP16DiagnosticsStatus.UploadFailed,
 949         });
 950         if (ftpClient) {
 951           ftpClient.close();
 952         }
 953         return this.handleIncomingRequestError(
 954           chargingStation,
 955           OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
 956           error as Error,
 957           { errorResponse: Constants.OCPP_RESPONSE_EMPTY }
 958         );
 959       }
 960     } else {
 961       logger.error(
 962         `${chargingStation.logPrefix()} Unsupported protocol ${
 963           uri.protocol
 964         } to transfer the diagnostic logs archive`
 965       );
 966       await chargingStation.ocppRequestService.requestHandler<
 967         DiagnosticsStatusNotificationRequest,
 968         DiagnosticsStatusNotificationResponse
 969       >(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
 970         status: OCPP16DiagnosticsStatus.UploadFailed,
 971       });
 972       return Constants.OCPP_RESPONSE_EMPTY;
 973     }
 974   }
 975
 976   private handleRequestTriggerMessage(
 977     chargingStation: ChargingStation,
 978     commandPayload: OCPP16TriggerMessageRequest
 979   ): OCPP16TriggerMessageResponse {
 980     if (
 981       !OCPP16ServiceUtils.checkFeatureProfile(
 982         chargingStation,
 983         OCPP16SupportedFeatureProfiles.RemoteTrigger,
 984         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE
 985       )
 986     ) {
 987       return Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
 988     }
 989     // TODO: factor out the check on connector id
 990     if (commandPayload?.connectorId < 0) {
 991       logger.warn(
 992         `${chargingStation.logPrefix()} ${
 993           OCPP16IncomingRequestCommand.TRIGGER_MESSAGE
 994         } incoming request received with invalid connectorId ${commandPayload.connectorId}`
 995       );
 996       return Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED;
 997     }
 998     try {
 999       switch (commandPayload.requestedMessage) {
1000         case MessageTrigger.BootNotification:
1001           setTimeout(() => {
1002             chargingStation.ocppRequestService
1003               .requestHandler<OCPP16BootNotificationRequest, OCPP16BootNotificationResponse>(
1004                 chargingStation,
1005                 OCPP16RequestCommand.BOOT_NOTIFICATION,
1006                 {
1007                   chargePointModel: chargingStation.getBootNotificationRequest().chargePointModel,
1008                   chargePointVendor: chargingStation.getBootNotificationRequest().chargePointVendor,
1009                   chargeBoxSerialNumber:
1010                     chargingStation.getBootNotificationRequest().chargeBoxSerialNumber,
1011                   firmwareVersion: chargingStation.getBootNotificationRequest().firmwareVersion,
1012                   chargePointSerialNumber:
1013                     chargingStation.getBootNotificationRequest().chargePointSerialNumber,
1014                   iccid: chargingStation.getBootNotificationRequest().iccid,
1015                   imsi: chargingStation.getBootNotificationRequest().imsi,
1016                   meterSerialNumber: chargingStation.getBootNotificationRequest().meterSerialNumber,
1017                   meterType: chargingStation.getBootNotificationRequest().meterType,
1018                 },
1019                 { skipBufferingOnError: true, triggerMessage: true }
1020               )
1021               .then((value) => {
1022                 chargingStation.bootNotificationResponse = value;
1023               })
1024               .catch(() => {
1025                 /* This is intentional */
1026               });
1027           }, Constants.OCPP_TRIGGER_MESSAGE_DELAY);
1028           return Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
1029         case MessageTrigger.Heartbeat:
1030           setTimeout(() => {
1031             chargingStation.ocppRequestService
1032               .requestHandler<OCPP16HeartbeatRequest, OCPP16HeartbeatResponse>(
1033                 chargingStation,
1034                 OCPP16RequestCommand.HEARTBEAT,
1035                 null,
1036                 {
1037                   triggerMessage: true,
1038                 }
1039               )
1040               .catch(() => {
1041                 /* This is intentional */
1042               });
1043           }, Constants.OCPP_TRIGGER_MESSAGE_DELAY);
1044           return Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
1045         case MessageTrigger.StatusNotification:
1046           setTimeout(() => {
1047             if (commandPayload?.connectorId) {
1048               chargingStation.ocppRequestService
1049                 .requestHandler<OCPP16StatusNotificationRequest, OCPP16StatusNotificationResponse>(
1050                   chargingStation,
1051                   OCPP16RequestCommand.STATUS_NOTIFICATION,
1052                   {
1053                     connectorId: commandPayload.connectorId,
1054                     errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
1055                     status: chargingStation.getConnectorStatus(commandPayload.connectorId).status,
1056                   },
1057                   {
1058                     triggerMessage: true,
1059                   }
1060                 )
1061                 .catch(() => {
1062                   /* This is intentional */
1063                 });
1064             } else {
1065               for (const connectorId of chargingStation.connectors.keys()) {
1066                 chargingStation.ocppRequestService
1067                   .requestHandler<
1068                     OCPP16StatusNotificationRequest,
1069                     OCPP16StatusNotificationResponse
1070                   >(
1071                     chargingStation,
1072                     OCPP16RequestCommand.STATUS_NOTIFICATION,
1073                     {
1074                       connectorId,
1075                       errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
1076                       status: chargingStation.getConnectorStatus(connectorId).status,
1077                     },
1078                     {
1079                       triggerMessage: true,
1080                     }
1081                   )
1082                   .catch(() => {
1083                     /* This is intentional */
1084                   });
1085               }
1086             }
1087           }, Constants.OCPP_TRIGGER_MESSAGE_DELAY);
1088           return Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
1089         default:
1090           return Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
1091       }
1092     } catch (error) {
1093       return this.handleIncomingRequestError(
1094         chargingStation,
1095         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
1096         error as Error,
1097         { errorResponse: Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED }
1098       );
1099     }
1100   }
1101 }