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

   1 // Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
   2
   3 import fs from 'fs';
   4 import path from 'path';
   5 import { fileURLToPath } from 'url';
   6
   7 import type { JSONSchemaType } from 'ajv';
   8
   9 import OCPPError from '../../../exception/OCPPError';
  10 import type { JsonObject, JsonType } from '../../../types/JsonType';
  11 import { OCPP16ChargePointErrorCode } from '../../../types/ocpp/1.6/ChargePointErrorCode';
  12 import { OCPP16ChargePointStatus } from '../../../types/ocpp/1.6/ChargePointStatus';
  13 import { OCPP16StandardParametersKey } from '../../../types/ocpp/1.6/Configuration';
  14 import type {
  15   OCPP16MeterValuesRequest,
  16   OCPP16MeterValuesResponse,
  17 } from '../../../types/ocpp/1.6/MeterValues';
  18 import {
  19   type OCPP16BootNotificationRequest,
  20   OCPP16IncomingRequestCommand,
  21   OCPP16RequestCommand,
  22   type OCPP16StatusNotificationRequest,
  23 } from '../../../types/ocpp/1.6/Requests';
  24 import type {
  25   ChangeAvailabilityResponse,
  26   ChangeConfigurationResponse,
  27   ClearChargingProfileResponse,
  28   DiagnosticsStatusNotificationResponse,
  29   GetConfigurationResponse,
  30   GetDiagnosticsResponse,
  31   OCPP16BootNotificationResponse,
  32   OCPP16DataTransferResponse,
  33   OCPP16HeartbeatResponse,
  34   OCPP16StatusNotificationResponse,
  35   OCPP16TriggerMessageResponse,
  36   OCPP16UpdateFirmwareResponse,
  37   SetChargingProfileResponse,
  38   UnlockConnectorResponse,
  39 } from '../../../types/ocpp/1.6/Responses';
  40 import {
  41   OCPP16AuthorizationStatus,
  42   type OCPP16AuthorizeRequest,
  43   type OCPP16AuthorizeResponse,
  44   type OCPP16StartTransactionRequest,
  45   type OCPP16StartTransactionResponse,
  46   type OCPP16StopTransactionRequest,
  47   type OCPP16StopTransactionResponse,
  48 } from '../../../types/ocpp/1.6/Transaction';
  49 import { ErrorType } from '../../../types/ocpp/ErrorType';
  50 import { OCPPVersion } from '../../../types/ocpp/OCPPVersion';
  51 import {
  52   type DefaultResponse,
  53   RegistrationStatusEnumType,
  54   type ResponseHandler,
  55 } from '../../../types/ocpp/Responses';
  56 import Constants from '../../../utils/Constants';
  57 import logger from '../../../utils/Logger';
  58 import Utils from '../../../utils/Utils';
  59 import type ChargingStation from '../../ChargingStation';
  60 import { ChargingStationConfigurationUtils } from '../../ChargingStationConfigurationUtils';
  61 import OCPPResponseService from '../OCPPResponseService';
  62 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
  63
  64 const moduleName = 'OCPP16ResponseService';
  65
  66 export default class OCPP16ResponseService extends OCPPResponseService {
  67   public jsonIncomingRequestResponseSchemas: Map<
  68     OCPP16IncomingRequestCommand,
  69     JSONSchemaType<JsonObject>
  70   >;
  71
  72   private responseHandlers: Map<OCPP16RequestCommand, ResponseHandler>;
  73   private jsonSchemas: Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>;
  74
  75   public constructor() {
  76     if (new.target?.name === moduleName) {
  77       throw new TypeError(`Cannot construct ${new.target?.name} instances directly`);
  78     }
  79     super(OCPPVersion.VERSION_16);
  80     this.responseHandlers = new Map<OCPP16RequestCommand, ResponseHandler>([
  81       [OCPP16RequestCommand.BOOT_NOTIFICATION, this.handleResponseBootNotification.bind(this)],
  82       [OCPP16RequestCommand.HEARTBEAT, this.emptyResponseHandler.bind(this)],
  83       [OCPP16RequestCommand.AUTHORIZE, this.handleResponseAuthorize.bind(this)],
  84       [OCPP16RequestCommand.START_TRANSACTION, this.handleResponseStartTransaction.bind(this)],
  85       [OCPP16RequestCommand.STOP_TRANSACTION, this.handleResponseStopTransaction.bind(this)],
  86       [OCPP16RequestCommand.STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
  87       [OCPP16RequestCommand.METER_VALUES, this.emptyResponseHandler.bind(this)],
  88       [OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
  89       [OCPP16RequestCommand.DATA_TRANSFER, this.emptyResponseHandler.bind(this)],
  90     ]);
  91     this.jsonSchemas = new Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>([
  92       [
  93         OCPP16RequestCommand.BOOT_NOTIFICATION,
  94         JSON.parse(
  95           fs.readFileSync(
  96             path.resolve(
  97               path.dirname(fileURLToPath(import.meta.url)),
  98               '../../../assets/json-schemas/ocpp/1.6/BootNotificationResponse.json'
  99             ),
 100             'utf8'
 101           )
 102         ) as JSONSchemaType<OCPP16BootNotificationResponse>,
 103       ],
 104       [
 105         OCPP16RequestCommand.HEARTBEAT,
 106         JSON.parse(
 107           fs.readFileSync(
 108             path.resolve(
 109               path.dirname(fileURLToPath(import.meta.url)),
 110               '../../../assets/json-schemas/ocpp/1.6/HeartbeatResponse.json'
 111             ),
 112             'utf8'
 113           )
 114         ) as JSONSchemaType<OCPP16HeartbeatResponse>,
 115       ],
 116       [
 117         OCPP16RequestCommand.AUTHORIZE,
 118         JSON.parse(
 119           fs.readFileSync(
 120             path.resolve(
 121               path.dirname(fileURLToPath(import.meta.url)),
 122               '../../../assets/json-schemas/ocpp/1.6/AuthorizeResponse.json'
 123             ),
 124             'utf8'
 125           )
 126         ) as JSONSchemaType<OCPP16AuthorizeResponse>,
 127       ],
 128       [
 129         OCPP16RequestCommand.START_TRANSACTION,
 130         JSON.parse(
 131           fs.readFileSync(
 132             path.resolve(
 133               path.dirname(fileURLToPath(import.meta.url)),
 134               '../../../assets/json-schemas/ocpp/1.6/StartTransactionResponse.json'
 135             ),
 136             'utf8'
 137           )
 138         ) as JSONSchemaType<OCPP16StartTransactionResponse>,
 139       ],
 140       [
 141         OCPP16RequestCommand.STOP_TRANSACTION,
 142         JSON.parse(
 143           fs.readFileSync(
 144             path.resolve(
 145               path.dirname(fileURLToPath(import.meta.url)),
 146               '../../../assets/json-schemas/ocpp/1.6/StopTransactionResponse.json'
 147             ),
 148             'utf8'
 149           )
 150         ) as JSONSchemaType<OCPP16StopTransactionResponse>,
 151       ],
 152       [
 153         OCPP16RequestCommand.STATUS_NOTIFICATION,
 154         JSON.parse(
 155           fs.readFileSync(
 156             path.resolve(
 157               path.dirname(fileURLToPath(import.meta.url)),
 158               '../../../assets/json-schemas/ocpp/1.6/StatusNotificationResponse.json'
 159             ),
 160             'utf8'
 161           )
 162         ) as JSONSchemaType<OCPP16StatusNotificationResponse>,
 163       ],
 164       [
 165         OCPP16RequestCommand.METER_VALUES,
 166         JSON.parse(
 167           fs.readFileSync(
 168             path.resolve(
 169               path.dirname(fileURLToPath(import.meta.url)),
 170               '../../../assets/json-schemas/ocpp/1.6/MeterValuesResponse.json'
 171             ),
 172             'utf8'
 173           )
 174         ) as JSONSchemaType<OCPP16MeterValuesResponse>,
 175       ],
 176       [
 177         OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION,
 178         JSON.parse(
 179           fs.readFileSync(
 180             path.resolve(
 181               path.dirname(fileURLToPath(import.meta.url)),
 182               '../../../assets/json-schemas/ocpp/1.6/DiagnosticsStatusNotificationResponse.json'
 183             ),
 184             'utf8'
 185           )
 186         ) as JSONSchemaType<DiagnosticsStatusNotificationResponse>,
 187       ],
 188       [
 189         OCPP16RequestCommand.DATA_TRANSFER,
 190         JSON.parse(
 191           fs.readFileSync(
 192             path.resolve(
 193               path.dirname(fileURLToPath(import.meta.url)),
 194               '../../../assets/json-schemas/ocpp/1.6/DataTransferResponse.json'
 195             ),
 196             'utf8'
 197           )
 198         ) as JSONSchemaType<OCPP16DataTransferResponse>,
 199       ],
 200     ]);
 201     this.jsonIncomingRequestResponseSchemas = new Map([
 202       [
 203         OCPP16IncomingRequestCommand.RESET,
 204         JSON.parse(
 205           fs.readFileSync(
 206             path.resolve(
 207               path.dirname(fileURLToPath(import.meta.url)),
 208               '../../../assets/json-schemas/ocpp/1.6/ResetResponse.json'
 209             ),
 210             'utf8'
 211           )
 212         ) as JSONSchemaType<DefaultResponse>,
 213       ],
 214       [
 215         OCPP16IncomingRequestCommand.CLEAR_CACHE,
 216         JSON.parse(
 217           fs.readFileSync(
 218             path.resolve(
 219               path.dirname(fileURLToPath(import.meta.url)),
 220               '../../../assets/json-schemas/ocpp/1.6/ClearCacheResponse.json'
 221             ),
 222             'utf8'
 223           )
 224         ) as JSONSchemaType<DefaultResponse>,
 225       ],
 226       [
 227         OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
 228         JSON.parse(
 229           fs.readFileSync(
 230             path.resolve(
 231               path.dirname(fileURLToPath(import.meta.url)),
 232               '../../../assets/json-schemas/ocpp/1.6/ChangeAvailabilityResponse.json'
 233             ),
 234             'utf8'
 235           )
 236         ) as JSONSchemaType<ChangeAvailabilityResponse>,
 237       ],
 238       [
 239         OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR,
 240         JSON.parse(
 241           fs.readFileSync(
 242             path.resolve(
 243               path.dirname(fileURLToPath(import.meta.url)),
 244               '../../../assets/json-schemas/ocpp/1.6/UnlockConnectorResponse.json'
 245             ),
 246             'utf8'
 247           )
 248         ) as JSONSchemaType<UnlockConnectorResponse>,
 249       ],
 250       [
 251         OCPP16IncomingRequestCommand.GET_CONFIGURATION,
 252         JSON.parse(
 253           fs.readFileSync(
 254             path.resolve(
 255               path.dirname(fileURLToPath(import.meta.url)),
 256               '../../../assets/json-schemas/ocpp/1.6/GetConfigurationResponse.json'
 257             ),
 258             'utf8'
 259           )
 260         ) as JSONSchemaType<GetConfigurationResponse>,
 261       ],
 262       [
 263         OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
 264         JSON.parse(
 265           fs.readFileSync(
 266             path.resolve(
 267               path.dirname(fileURLToPath(import.meta.url)),
 268               '../../../assets/json-schemas/ocpp/1.6/ChangeConfigurationResponse.json'
 269             ),
 270             'utf8'
 271           )
 272         ) as JSONSchemaType<ChangeConfigurationResponse>,
 273       ],
 274       [
 275         OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
 276         JSON.parse(
 277           fs.readFileSync(
 278             path.resolve(
 279               path.dirname(fileURLToPath(import.meta.url)),
 280               '../../../assets/json-schemas/ocpp/1.6/SetChargingProfileResponse.json'
 281             ),
 282             'utf8'
 283           )
 284         ) as JSONSchemaType<SetChargingProfileResponse>,
 285       ],
 286       [
 287         OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
 288         JSON.parse(
 289           fs.readFileSync(
 290             path.resolve(
 291               path.dirname(fileURLToPath(import.meta.url)),
 292               '../../../assets/json-schemas/ocpp/1.6/ClearChargingProfileResponse.json'
 293             ),
 294             'utf8'
 295           )
 296         ) as JSONSchemaType<ClearChargingProfileResponse>,
 297       ],
 298       [
 299         OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
 300         JSON.parse(
 301           fs.readFileSync(
 302             path.resolve(
 303               path.dirname(fileURLToPath(import.meta.url)),
 304               '../../../assets/json-schemas/ocpp/1.6/RemoteStartTransactionResponse.json'
 305             ),
 306             'utf8'
 307           )
 308         ) as JSONSchemaType<DefaultResponse>,
 309       ],
 310       [
 311         OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
 312         JSON.parse(
 313           fs.readFileSync(
 314             path.resolve(
 315               path.dirname(fileURLToPath(import.meta.url)),
 316               '../../../assets/json-schemas/ocpp/1.6/RemoteStopTransactionResponse.json'
 317             ),
 318             'utf8'
 319           )
 320         ) as JSONSchemaType<DefaultResponse>,
 321       ],
 322       [
 323         OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
 324         JSON.parse(
 325           fs.readFileSync(
 326             path.resolve(
 327               path.dirname(fileURLToPath(import.meta.url)),
 328               '../../../assets/json-schemas/ocpp/1.6/GetDiagnosticsResponse.json'
 329             ),
 330             'utf8'
 331           )
 332         ) as JSONSchemaType<GetDiagnosticsResponse>,
 333       ],
 334       [
 335         OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
 336         JSON.parse(
 337           fs.readFileSync(
 338             path.resolve(
 339               path.dirname(fileURLToPath(import.meta.url)),
 340               '../../../assets/json-schemas/ocpp/1.6/TriggerMessageResponse.json'
 341             ),
 342             'utf8'
 343           )
 344         ) as JSONSchemaType<OCPP16TriggerMessageResponse>,
 345       ],
 346       [
 347         OCPP16IncomingRequestCommand.DATA_TRANSFER,
 348         JSON.parse(
 349           fs.readFileSync(
 350             path.resolve(
 351               path.dirname(fileURLToPath(import.meta.url)),
 352               '../../../assets/json-schemas/ocpp/1.6/DataTransferResponse.json'
 353             ),
 354             'utf8'
 355           )
 356         ) as JSONSchemaType<OCPP16DataTransferResponse>,
 357       ],
 358       [
 359         OCPP16IncomingRequestCommand.UPDATE_FIRMWARE,
 360         JSON.parse(
 361           fs.readFileSync(
 362             path.resolve(
 363               path.dirname(fileURLToPath(import.meta.url)),
 364               '../../../assets/json-schemas/ocpp/1.6/UpdateFirmwareResponse.json'
 365             ),
 366             'utf8'
 367           )
 368         ) as JSONSchemaType<OCPP16UpdateFirmwareResponse>,
 369       ],
 370     ]);
 371     this.validatePayload.bind(this);
 372   }
 373
 374   public async responseHandler(
 375     chargingStation: ChargingStation,
 376     commandName: OCPP16RequestCommand,
 377     payload: JsonType,
 378     requestPayload: JsonType
 379   ): Promise<void> {
 380     if (
 381       chargingStation.isRegistered() === true ||
 382       commandName === OCPP16RequestCommand.BOOT_NOTIFICATION
 383     ) {
 384       if (
 385         this.responseHandlers.has(commandName) === true &&
 386         OCPP16ServiceUtils.isRequestCommandSupported(chargingStation, commandName) === true
 387       ) {
 388         try {
 389           this.validatePayload(chargingStation, commandName, payload);
 390           await this.responseHandlers.get(commandName)(chargingStation, payload, requestPayload);
 391         } catch (error) {
 392           logger.error(
 393             `${chargingStation.logPrefix()} ${moduleName}.responseHandler: Handle response error:`,
 394             error
 395           );
 396           throw error;
 397         }
 398       } else {
 399         // Throw exception
 400         throw new OCPPError(
 401           ErrorType.NOT_IMPLEMENTED,
 402           `${commandName} is not implemented to handle response PDU ${JSON.stringify(
 403             payload,
 404             null,
 405             2
 406           )}`,
 407           commandName,
 408           payload
 409         );
 410       }
 411     } else {
 412       throw new OCPPError(
 413         ErrorType.SECURITY_ERROR,
 414         `${commandName} cannot be issued to handle response PDU ${JSON.stringify(
 415           payload,
 416           null,
 417           2
 418         )} while the charging station is not registered on the central server.`,
 419         commandName,
 420         payload
 421       );
 422     }
 423   }
 424
 425   private validatePayload(
 426     chargingStation: ChargingStation,
 427     commandName: OCPP16RequestCommand,
 428     payload: JsonType
 429   ): boolean {
 430     if (this.jsonSchemas.has(commandName) === true) {
 431       return this.validateResponsePayload(
 432         chargingStation,
 433         commandName,
 434         this.jsonSchemas.get(commandName),
 435         payload
 436       );
 437     }
 438     logger.warn(
 439       `${chargingStation.logPrefix()} ${moduleName}.validatePayload: No JSON schema found for command '${commandName}' PDU validation`
 440     );
 441     return false;
 442   }
 443
 444   private handleResponseBootNotification(
 445     chargingStation: ChargingStation,
 446     payload: OCPP16BootNotificationResponse
 447   ): void {
 448     if (payload.status === RegistrationStatusEnumType.ACCEPTED) {
 449       ChargingStationConfigurationUtils.addConfigurationKey(
 450         chargingStation,
 451         OCPP16StandardParametersKey.HeartbeatInterval,
 452         payload.interval.toString(),
 453         {},
 454         { overwrite: true, save: true }
 455       );
 456       ChargingStationConfigurationUtils.addConfigurationKey(
 457         chargingStation,
 458         OCPP16StandardParametersKey.HeartBeatInterval,
 459         payload.interval.toString(),
 460         { visible: false },
 461         { overwrite: true, save: true }
 462       );
 463       chargingStation.heartbeatSetInterval
 464         ? chargingStation.restartHeartbeat()
 465         : chargingStation.startHeartbeat();
 466     }
 467     if (Object.values(RegistrationStatusEnumType).includes(payload.status)) {
 468       const logMsg = `${chargingStation.logPrefix()} Charging station in '${
 469         payload.status
 470       }' state on the central server`;
 471       payload.status === RegistrationStatusEnumType.REJECTED
 472         ? logger.warn(logMsg)
 473         : logger.info(logMsg);
 474     } else {
 475       logger.error(
 476         chargingStation.logPrefix() +
 477           ' Charging station boot notification response received: %j with undefined registration status',
 478         payload
 479       );
 480     }
 481   }
 482
 483   private handleResponseAuthorize(
 484     chargingStation: ChargingStation,
 485     payload: OCPP16AuthorizeResponse,
 486     requestPayload: OCPP16AuthorizeRequest
 487   ): void {
 488     let authorizeConnectorId: number;
 489     for (const connectorId of chargingStation.connectors.keys()) {
 490       if (
 491         connectorId > 0 &&
 492         chargingStation.getConnectorStatus(connectorId)?.authorizeIdTag === requestPayload.idTag
 493       ) {
 494         authorizeConnectorId = connectorId;
 495         break;
 496       }
 497     }
 498     const isAuthorizeConnectorIdDefined = authorizeConnectorId !== undefined;
 499     if (payload.idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED) {
 500       isAuthorizeConnectorIdDefined &&
 501         (chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = true);
 502       logger.debug(
 503         `${chargingStation.logPrefix()} IdTag '${requestPayload.idTag}' accepted${
 504           isAuthorizeConnectorIdDefined ? ` on connector ${authorizeConnectorId}` : ''
 505         }`
 506       );
 507     } else {
 508       if (isAuthorizeConnectorIdDefined) {
 509         chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = false;
 510         delete chargingStation.getConnectorStatus(authorizeConnectorId).authorizeIdTag;
 511       }
 512       logger.debug(
 513         `${chargingStation.logPrefix()} IdTag '${requestPayload.idTag}' rejected with status '${
 514           payload.idTagInfo.status
 515         }'${isAuthorizeConnectorIdDefined ? ` on connector ${authorizeConnectorId}` : ''}`
 516       );
 517     }
 518   }
 519
 520   private async handleResponseStartTransaction(
 521     chargingStation: ChargingStation,
 522     payload: OCPP16StartTransactionResponse,
 523     requestPayload: OCPP16StartTransactionRequest
 524   ): Promise<void> {
 525     const connectorId = requestPayload.connectorId;
 526
 527     let transactionConnectorId: number;
 528     for (const id of chargingStation.connectors.keys()) {
 529       if (id > 0 && id === connectorId) {
 530         transactionConnectorId = id;
 531         break;
 532       }
 533     }
 534     if (!transactionConnectorId) {
 535       logger.error(
 536         chargingStation.logPrefix() +
 537           ' Trying to start a transaction on a non existing connector Id ' +
 538           connectorId.toString()
 539       );
 540       return;
 541     }
 542     if (
 543       chargingStation.getConnectorStatus(connectorId).transactionRemoteStarted === true &&
 544       chargingStation.getAuthorizeRemoteTxRequests() === true &&
 545       chargingStation.getLocalAuthListEnabled() === true &&
 546       chargingStation.hasAuthorizedTags() &&
 547       chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized === false
 548     ) {
 549       logger.error(
 550         chargingStation.logPrefix() +
 551           ' Trying to start a transaction with a not local authorized idTag ' +
 552           chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag +
 553           ' on connector Id ' +
 554           connectorId.toString()
 555       );
 556       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 557       return;
 558     }
 559     if (
 560       chargingStation.getConnectorStatus(connectorId).transactionRemoteStarted === true &&
 561       chargingStation.getAuthorizeRemoteTxRequests() === true &&
 562       chargingStation.getMustAuthorizeAtRemoteStart() === true &&
 563       chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized === false &&
 564       chargingStation.getConnectorStatus(connectorId).idTagAuthorized === false
 565     ) {
 566       logger.error(
 567         chargingStation.logPrefix() +
 568           ' Trying to start a transaction with a not authorized idTag ' +
 569           chargingStation.getConnectorStatus(connectorId).authorizeIdTag +
 570           ' on connector Id ' +
 571           connectorId.toString()
 572       );
 573       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 574       return;
 575     }
 576     if (
 577       chargingStation.getConnectorStatus(connectorId).idTagAuthorized &&
 578       chargingStation.getConnectorStatus(connectorId).authorizeIdTag !== requestPayload.idTag
 579     ) {
 580       logger.error(
 581         chargingStation.logPrefix() +
 582           ' Trying to start a transaction with an idTag ' +
 583           requestPayload.idTag +
 584           ' different from the authorize request one ' +
 585           chargingStation.getConnectorStatus(connectorId).authorizeIdTag +
 586           ' on connector Id ' +
 587           connectorId.toString()
 588       );
 589       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 590       return;
 591     }
 592     if (
 593       chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized &&
 594       chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag !== requestPayload.idTag
 595     ) {
 596       logger.error(
 597         chargingStation.logPrefix() +
 598           ' Trying to start a transaction with an idTag ' +
 599           requestPayload.idTag +
 600           ' different from the local authorized one ' +
 601           chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag +
 602           ' on connector Id ' +
 603           connectorId.toString()
 604       );
 605       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 606       return;
 607     }
 608     if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
 609       logger.debug(
 610         chargingStation.logPrefix() +
 611           ' Trying to start a transaction on an already used connector ' +
 612           connectorId.toString() +
 613           ': %j',
 614         chargingStation.getConnectorStatus(connectorId)
 615       );
 616       return;
 617     }
 618     if (
 619       chargingStation.getConnectorStatus(connectorId)?.status !==
 620         OCPP16ChargePointStatus.AVAILABLE &&
 621       chargingStation.getConnectorStatus(connectorId)?.status !== OCPP16ChargePointStatus.PREPARING
 622     ) {
 623       logger.error(
 624         `${chargingStation.logPrefix()} Trying to start a transaction on connector ${connectorId.toString()} with status ${
 625           chargingStation.getConnectorStatus(connectorId)?.status
 626         }`
 627       );
 628       return;
 629     }
 630     // if (!Number.isInteger(payload.transactionId)) {
 631     //   logger.warn(
 632     //     `${chargingStation.logPrefix()} Trying to start a transaction on connector ${connectorId.toString()} with a non integer transaction Id ${
 633     //       payload.transactionId
 634     //     }, converting to integer`
 635     //   );
 636     //   payload.transactionId = Utils.convertToInt(payload.transactionId);
 637     // }
 638
 639     if (payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 640       chargingStation.getConnectorStatus(connectorId).transactionStarted = true;
 641       chargingStation.getConnectorStatus(connectorId).transactionId = payload.transactionId;
 642       chargingStation.getConnectorStatus(connectorId).transactionIdTag = requestPayload.idTag;
 643       chargingStation.getConnectorStatus(
 644         connectorId
 645       ).transactionEnergyActiveImportRegisterValue = 0;
 646       chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue =
 647         OCPP16ServiceUtils.buildTransactionBeginMeterValue(
 648           chargingStation,
 649           connectorId,
 650           requestPayload.meterStart
 651         );
 652       chargingStation.getBeginEndMeterValues() &&
 653         (await chargingStation.ocppRequestService.requestHandler<
 654           OCPP16MeterValuesRequest,
 655           OCPP16MeterValuesResponse
 656         >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
 657           connectorId,
 658           transactionId: payload.transactionId,
 659           meterValue: [chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue],
 660         }));
 661       await chargingStation.ocppRequestService.requestHandler<
 662         OCPP16StatusNotificationRequest,
 663         OCPP16StatusNotificationResponse
 664       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 665         connectorId,
 666         status: OCPP16ChargePointStatus.CHARGING,
 667         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 668       });
 669       chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.CHARGING;
 670       logger.info(
 671         chargingStation.logPrefix() +
 672           ' Transaction ' +
 673           payload.transactionId.toString() +
 674           ' STARTED on ' +
 675           chargingStation.stationInfo.chargingStationId +
 676           '#' +
 677           connectorId.toString() +
 678           " for idTag '" +
 679           requestPayload.idTag +
 680           "'"
 681       );
 682       if (chargingStation.stationInfo.powerSharedByConnectors) {
 683         chargingStation.powerDivider++;
 684       }
 685       const configuredMeterValueSampleInterval =
 686         ChargingStationConfigurationUtils.getConfigurationKey(
 687           chargingStation,
 688           OCPP16StandardParametersKey.MeterValueSampleInterval
 689         );
 690       chargingStation.startMeterValues(
 691         connectorId,
 692         configuredMeterValueSampleInterval
 693           ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000
 694           : Constants.DEFAULT_METER_VALUES_INTERVAL
 695       );
 696     } else {
 697       logger.warn(
 698         chargingStation.logPrefix() +
 699           ' Starting transaction id ' +
 700           payload.transactionId.toString() +
 701           " REJECTED with status '" +
 702           payload?.idTagInfo?.status +
 703           "', idTag '" +
 704           requestPayload.idTag +
 705           "'"
 706       );
 707       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 708     }
 709   }
 710
 711   private async resetConnectorOnStartTransactionError(
 712     chargingStation: ChargingStation,
 713     connectorId: number
 714   ): Promise<void> {
 715     chargingStation.resetConnectorStatus(connectorId);
 716     if (
 717       chargingStation.getConnectorStatus(connectorId).status !== OCPP16ChargePointStatus.AVAILABLE
 718     ) {
 719       await chargingStation.ocppRequestService.requestHandler<
 720         OCPP16StatusNotificationRequest,
 721         OCPP16StatusNotificationResponse
 722       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 723         connectorId,
 724         status: OCPP16ChargePointStatus.AVAILABLE,
 725         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 726       });
 727       chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.AVAILABLE;
 728     }
 729   }
 730
 731   private async handleResponseStopTransaction(
 732     chargingStation: ChargingStation,
 733     payload: OCPP16StopTransactionResponse,
 734     requestPayload: OCPP16StopTransactionRequest
 735   ): Promise<void> {
 736     const transactionConnectorId = chargingStation.getConnectorIdByTransactionId(
 737       requestPayload.transactionId
 738     );
 739     if (!transactionConnectorId) {
 740       logger.error(
 741         chargingStation.logPrefix() +
 742           ' Trying to stop a non existing transaction ' +
 743           requestPayload.transactionId.toString()
 744       );
 745       return;
 746     }
 747     if (payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 748       chargingStation.getBeginEndMeterValues() === true &&
 749         chargingStation.getOcppStrictCompliance() === false &&
 750         chargingStation.getOutOfOrderEndMeterValues() === true &&
 751         (await chargingStation.ocppRequestService.requestHandler<
 752           OCPP16MeterValuesRequest,
 753           OCPP16MeterValuesResponse
 754         >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
 755           connectorId: transactionConnectorId,
 756           transactionId: requestPayload.transactionId,
 757           meterValue: [
 758             OCPP16ServiceUtils.buildTransactionEndMeterValue(
 759               chargingStation,
 760               transactionConnectorId,
 761               requestPayload.meterStop
 762             ),
 763           ],
 764         }));
 765       if (
 766         chargingStation.isChargingStationAvailable() === false ||
 767         chargingStation.isConnectorAvailable(transactionConnectorId) === false
 768       ) {
 769         await chargingStation.ocppRequestService.requestHandler<
 770           OCPP16StatusNotificationRequest,
 771           OCPP16StatusNotificationResponse
 772         >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 773           connectorId: transactionConnectorId,
 774           status: OCPP16ChargePointStatus.UNAVAILABLE,
 775           errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 776         });
 777         chargingStation.getConnectorStatus(transactionConnectorId).status =
 778           OCPP16ChargePointStatus.UNAVAILABLE;
 779       } else {
 780         await chargingStation.ocppRequestService.requestHandler<
 781           OCPP16BootNotificationRequest,
 782           OCPP16BootNotificationResponse
 783         >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 784           connectorId: transactionConnectorId,
 785           status: OCPP16ChargePointStatus.AVAILABLE,
 786           errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 787         });
 788         chargingStation.getConnectorStatus(transactionConnectorId).status =
 789           OCPP16ChargePointStatus.AVAILABLE;
 790       }
 791       if (chargingStation.stationInfo.powerSharedByConnectors) {
 792         chargingStation.powerDivider--;
 793       }
 794       chargingStation.resetConnectorStatus(transactionConnectorId);
 795       logger.info(
 796         chargingStation.logPrefix() +
 797           ' Transaction ' +
 798           requestPayload.transactionId.toString() +
 799           ' STOPPED on ' +
 800           chargingStation.stationInfo.chargingStationId +
 801           '#' +
 802           transactionConnectorId.toString()
 803       );
 804     } else {
 805       logger.warn(
 806         chargingStation.logPrefix() +
 807           ' Stopping transaction id ' +
 808           requestPayload.transactionId.toString() +
 809           " REJECTED with status '" +
 810           payload.idTagInfo?.status +
 811           "'"
 812       );
 813     }
 814   }
 815 }