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

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import fs from 'fs';
   4 import path from 'path';
   5 import { fileURLToPath } from 'url';
   6
   7 import { JSONSchemaType } from 'ajv';
   8
   9 import OCPPError from '../../../exception/OCPPError';
  10 import { 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 {
  15   OCPP16MeterValuesRequest,
  16   OCPP16MeterValuesResponse,
  17 } from '../../../types/ocpp/1.6/MeterValues';
  18 import {
  19   OCPP16BootNotificationRequest,
  20   OCPP16RequestCommand,
  21   OCPP16StatusNotificationRequest,
  22 } from '../../../types/ocpp/1.6/Requests';
  23 import {
  24   DiagnosticsStatusNotificationResponse,
  25   OCPP16BootNotificationResponse,
  26   OCPP16HeartbeatResponse,
  27   OCPP16RegistrationStatus,
  28   OCPP16StatusNotificationResponse,
  29 } from '../../../types/ocpp/1.6/Responses';
  30 import {
  31   OCPP16AuthorizationStatus,
  32   OCPP16AuthorizeRequest,
  33   OCPP16AuthorizeResponse,
  34   OCPP16StartTransactionRequest,
  35   OCPP16StartTransactionResponse,
  36   OCPP16StopTransactionRequest,
  37   OCPP16StopTransactionResponse,
  38 } from '../../../types/ocpp/1.6/Transaction';
  39 import { ErrorType } from '../../../types/ocpp/ErrorType';
  40 import { ResponseHandler } from '../../../types/ocpp/Responses';
  41 import logger from '../../../utils/Logger';
  42 import Utils from '../../../utils/Utils';
  43 import type ChargingStation from '../../ChargingStation';
  44 import { ChargingStationConfigurationUtils } from '../../ChargingStationConfigurationUtils';
  45 import { ChargingStationUtils } from '../../ChargingStationUtils';
  46 import OCPPResponseService from '../OCPPResponseService';
  47 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
  48
  49 const moduleName = 'OCPP16ResponseService';
  50
  51 export default class OCPP16ResponseService extends OCPPResponseService {
  52   private responseHandlers: Map<OCPP16RequestCommand, ResponseHandler>;
  53   private jsonSchemas: Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>;
  54
  55   public constructor() {
  56     if (new.target?.name === moduleName) {
  57       throw new TypeError(`Cannot construct ${new.target?.name} instances directly`);
  58     }
  59     super();
  60     this.responseHandlers = new Map<OCPP16RequestCommand, ResponseHandler>([
  61       [OCPP16RequestCommand.BOOT_NOTIFICATION, this.handleResponseBootNotification.bind(this)],
  62       [OCPP16RequestCommand.HEARTBEAT, this.emptyResponseHandler.bind(this)],
  63       [OCPP16RequestCommand.AUTHORIZE, this.handleResponseAuthorize.bind(this)],
  64       [OCPP16RequestCommand.START_TRANSACTION, this.handleResponseStartTransaction.bind(this)],
  65       [OCPP16RequestCommand.STOP_TRANSACTION, this.handleResponseStopTransaction.bind(this)],
  66       [OCPP16RequestCommand.STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
  67       [OCPP16RequestCommand.METER_VALUES, this.emptyResponseHandler.bind(this)],
  68       [OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, this.emptyResponseHandler.bind(this)],
  69     ]);
  70     this.jsonSchemas = new Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>([
  71       [
  72         OCPP16RequestCommand.BOOT_NOTIFICATION,
  73         JSON.parse(
  74           fs.readFileSync(
  75             path.resolve(
  76               path.dirname(fileURLToPath(import.meta.url)),
  77               '../../../assets/json-schemas/ocpp/1.6/BootNotificationResponse.json'
  78             ),
  79             'utf8'
  80           )
  81         ) as JSONSchemaType<OCPP16BootNotificationResponse>,
  82       ],
  83       [
  84         OCPP16RequestCommand.HEARTBEAT,
  85         JSON.parse(
  86           fs.readFileSync(
  87             path.resolve(
  88               path.dirname(fileURLToPath(import.meta.url)),
  89               '../../../assets/json-schemas/ocpp/1.6/HeartbeatResponse.json'
  90             ),
  91             'utf8'
  92           )
  93         ) as JSONSchemaType<OCPP16HeartbeatResponse>,
  94       ],
  95       [
  96         OCPP16RequestCommand.AUTHORIZE,
  97         JSON.parse(
  98           fs.readFileSync(
  99             path.resolve(
 100               path.dirname(fileURLToPath(import.meta.url)),
 101               '../../../assets/json-schemas/ocpp/1.6/AuthorizeResponse.json'
 102             ),
 103             'utf8'
 104           )
 105         ) as JSONSchemaType<OCPP16AuthorizeResponse>,
 106       ],
 107       [
 108         OCPP16RequestCommand.START_TRANSACTION,
 109         JSON.parse(
 110           fs.readFileSync(
 111             path.resolve(
 112               path.dirname(fileURLToPath(import.meta.url)),
 113               '../../../assets/json-schemas/ocpp/1.6/StartTransactionResponse.json'
 114             ),
 115             'utf8'
 116           )
 117         ) as JSONSchemaType<OCPP16StartTransactionResponse>,
 118       ],
 119       [
 120         OCPP16RequestCommand.STOP_TRANSACTION,
 121         JSON.parse(
 122           fs.readFileSync(
 123             path.resolve(
 124               path.dirname(fileURLToPath(import.meta.url)),
 125               '../../../assets/json-schemas/ocpp/1.6/StopTransactionResponse.json'
 126             ),
 127             'utf8'
 128           )
 129         ) as JSONSchemaType<OCPP16StopTransactionResponse>,
 130       ],
 131       [
 132         OCPP16RequestCommand.STATUS_NOTIFICATION,
 133         JSON.parse(
 134           fs.readFileSync(
 135             path.resolve(
 136               path.dirname(fileURLToPath(import.meta.url)),
 137               '../../../assets/json-schemas/ocpp/1.6/StatusNotificationResponse.json'
 138             ),
 139             'utf8'
 140           )
 141         ) as JSONSchemaType<OCPP16StatusNotificationResponse>,
 142       ],
 143       [
 144         OCPP16RequestCommand.METER_VALUES,
 145         JSON.parse(
 146           fs.readFileSync(
 147             path.resolve(
 148               path.dirname(fileURLToPath(import.meta.url)),
 149               '../../../assets/json-schemas/ocpp/1.6/MeterValuesResponse.json'
 150             ),
 151             'utf8'
 152           )
 153         ) as JSONSchemaType<OCPP16MeterValuesResponse>,
 154       ],
 155       [
 156         OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION,
 157         JSON.parse(
 158           fs.readFileSync(
 159             path.resolve(
 160               path.dirname(fileURLToPath(import.meta.url)),
 161               '../../../assets/json-schemas/ocpp/1.6/DiagnosticsStatusNotificationResponse.json'
 162             ),
 163             'utf8'
 164           )
 165         ) as JSONSchemaType<DiagnosticsStatusNotificationResponse>,
 166       ],
 167     ]);
 168   }
 169
 170   public async responseHandler(
 171     chargingStation: ChargingStation,
 172     commandName: OCPP16RequestCommand,
 173     payload: JsonType,
 174     requestPayload: JsonType
 175   ): Promise<void> {
 176     if (chargingStation.isRegistered() || commandName === OCPP16RequestCommand.BOOT_NOTIFICATION) {
 177       if (
 178         this.responseHandlers.has(commandName) &&
 179         ChargingStationUtils.isRequestCommandSupported(commandName, chargingStation)
 180       ) {
 181         try {
 182           if (this.jsonSchemas.has(commandName)) {
 183             this.validateResponsePayload(
 184               chargingStation,
 185               commandName,
 186               this.jsonSchemas.get(commandName),
 187               payload
 188             );
 189           } else {
 190             logger.warn(
 191               `${chargingStation.logPrefix()} ${moduleName}.responseHandler: No JSON schema found for command ${commandName} PDU validation`
 192             );
 193           }
 194           await this.responseHandlers.get(commandName)(chargingStation, payload, requestPayload);
 195         } catch (error) {
 196           logger.error(chargingStation.logPrefix() + ' Handle request response error: %j', error);
 197           throw error;
 198         }
 199       } else {
 200         // Throw exception
 201         throw new OCPPError(
 202           ErrorType.NOT_IMPLEMENTED,
 203           `${commandName} is not implemented to handle request response PDU ${JSON.stringify(
 204             payload,
 205             null,
 206             2
 207           )}`,
 208           commandName,
 209           payload
 210         );
 211       }
 212     } else {
 213       throw new OCPPError(
 214         ErrorType.SECURITY_ERROR,
 215         `${commandName} cannot be issued to handle request response PDU ${JSON.stringify(
 216           payload,
 217           null,
 218           2
 219         )} while the charging station is not registered on the central server. `,
 220         commandName,
 221         payload
 222       );
 223     }
 224   }
 225
 226   private handleResponseBootNotification(
 227     chargingStation: ChargingStation,
 228     payload: OCPP16BootNotificationResponse
 229   ): void {
 230     if (payload.status === OCPP16RegistrationStatus.ACCEPTED) {
 231       ChargingStationConfigurationUtils.addConfigurationKey(
 232         chargingStation,
 233         OCPP16StandardParametersKey.HeartbeatInterval,
 234         payload.interval.toString(),
 235         {},
 236         { overwrite: true, save: true }
 237       );
 238       ChargingStationConfigurationUtils.addConfigurationKey(
 239         chargingStation,
 240         OCPP16StandardParametersKey.HeartBeatInterval,
 241         payload.interval.toString(),
 242         { visible: false },
 243         { overwrite: true, save: true }
 244       );
 245       chargingStation.heartbeatSetInterval
 246         ? chargingStation.restartHeartbeat()
 247         : chargingStation.startHeartbeat();
 248     }
 249     if (Object.values(OCPP16RegistrationStatus).includes(payload.status)) {
 250       const logMsg = `${chargingStation.logPrefix()} Charging station in '${
 251         payload.status
 252       }' state on the central server`;
 253       payload.status === OCPP16RegistrationStatus.REJECTED
 254         ? logger.warn(logMsg)
 255         : logger.info(logMsg);
 256     } else {
 257       logger.error(
 258         chargingStation.logPrefix() +
 259           ' Charging station boot notification response received: %j with undefined registration status',
 260         payload
 261       );
 262     }
 263   }
 264
 265   private handleResponseAuthorize(
 266     chargingStation: ChargingStation,
 267     payload: OCPP16AuthorizeResponse,
 268     requestPayload: OCPP16AuthorizeRequest
 269   ): void {
 270     let authorizeConnectorId: number;
 271     for (const connectorId of chargingStation.connectors.keys()) {
 272       if (
 273         connectorId > 0 &&
 274         chargingStation.getConnectorStatus(connectorId)?.authorizeIdTag === requestPayload.idTag
 275       ) {
 276         authorizeConnectorId = connectorId;
 277         break;
 278       }
 279     }
 280     if (payload.idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED) {
 281       chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = true;
 282       logger.debug(
 283         `${chargingStation.logPrefix()} IdTag ${
 284           requestPayload.idTag
 285         } authorized on connector ${authorizeConnectorId}`
 286       );
 287     } else {
 288       chargingStation.getConnectorStatus(authorizeConnectorId).idTagAuthorized = false;
 289       delete chargingStation.getConnectorStatus(authorizeConnectorId).authorizeIdTag;
 290       logger.debug(
 291         `${chargingStation.logPrefix()} IdTag ${requestPayload.idTag} refused with status '${
 292           payload.idTagInfo.status
 293         }' on connector ${authorizeConnectorId}`
 294       );
 295     }
 296   }
 297
 298   private async handleResponseStartTransaction(
 299     chargingStation: ChargingStation,
 300     payload: OCPP16StartTransactionResponse,
 301     requestPayload: OCPP16StartTransactionRequest
 302   ): Promise<void> {
 303     const connectorId = requestPayload.connectorId;
 304
 305     let transactionConnectorId: number;
 306     for (const id of chargingStation.connectors.keys()) {
 307       if (id > 0 && id === connectorId) {
 308         transactionConnectorId = id;
 309         break;
 310       }
 311     }
 312     if (!transactionConnectorId) {
 313       logger.error(
 314         chargingStation.logPrefix() +
 315           ' Trying to start a transaction on a non existing connector Id ' +
 316           connectorId.toString()
 317       );
 318       return;
 319     }
 320     if (
 321       chargingStation.getConnectorStatus(connectorId).transactionRemoteStarted &&
 322       chargingStation.getAuthorizeRemoteTxRequests() &&
 323       chargingStation.getLocalAuthListEnabled() &&
 324       chargingStation.hasAuthorizedTags() &&
 325       !chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized
 326     ) {
 327       logger.error(
 328         chargingStation.logPrefix() +
 329           ' Trying to start a transaction with a not local authorized idTag ' +
 330           chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag +
 331           ' on connector Id ' +
 332           connectorId.toString()
 333       );
 334       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 335       return;
 336     }
 337     if (
 338       chargingStation.getConnectorStatus(connectorId).transactionRemoteStarted &&
 339       chargingStation.getAuthorizeRemoteTxRequests() &&
 340       chargingStation.getMayAuthorizeAtRemoteStart() &&
 341       !chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized &&
 342       !chargingStation.getConnectorStatus(connectorId).idTagAuthorized
 343     ) {
 344       logger.error(
 345         chargingStation.logPrefix() +
 346           ' Trying to start a transaction with a not authorized idTag ' +
 347           chargingStation.getConnectorStatus(connectorId).authorizeIdTag +
 348           ' on connector Id ' +
 349           connectorId.toString()
 350       );
 351       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 352       return;
 353     }
 354     if (
 355       chargingStation.getConnectorStatus(connectorId).idTagAuthorized &&
 356       chargingStation.getConnectorStatus(connectorId).authorizeIdTag !== requestPayload.idTag
 357     ) {
 358       logger.error(
 359         chargingStation.logPrefix() +
 360           ' Trying to start a transaction with an idTag ' +
 361           requestPayload.idTag +
 362           ' different from the authorize request one ' +
 363           chargingStation.getConnectorStatus(connectorId).authorizeIdTag +
 364           ' on connector Id ' +
 365           connectorId.toString()
 366       );
 367       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 368       return;
 369     }
 370     if (
 371       chargingStation.getConnectorStatus(connectorId).idTagLocalAuthorized &&
 372       chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag !== requestPayload.idTag
 373     ) {
 374       logger.error(
 375         chargingStation.logPrefix() +
 376           ' Trying to start a transaction with an idTag ' +
 377           requestPayload.idTag +
 378           ' different from the local authorized one ' +
 379           chargingStation.getConnectorStatus(connectorId).localAuthorizeIdTag +
 380           ' on connector Id ' +
 381           connectorId.toString()
 382       );
 383       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 384       return;
 385     }
 386     if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted) {
 387       logger.debug(
 388         chargingStation.logPrefix() +
 389           ' Trying to start a transaction on an already used connector ' +
 390           connectorId.toString() +
 391           ': %j',
 392         chargingStation.getConnectorStatus(connectorId)
 393       );
 394       return;
 395     }
 396     if (
 397       chargingStation.getConnectorStatus(connectorId)?.status !==
 398         OCPP16ChargePointStatus.AVAILABLE &&
 399       chargingStation.getConnectorStatus(connectorId)?.status !== OCPP16ChargePointStatus.PREPARING
 400     ) {
 401       logger.error(
 402         `${chargingStation.logPrefix()} Trying to start a transaction on connector ${connectorId.toString()} with status ${
 403           chargingStation.getConnectorStatus(connectorId)?.status
 404         }`
 405       );
 406       return;
 407     }
 408     if (!Number.isInteger(payload.transactionId)) {
 409       logger.warn(
 410         `${chargingStation.logPrefix()} Trying to start a transaction on connector ${connectorId.toString()} with a non integer transaction Id ${
 411           payload.transactionId
 412         }, converting to integer`
 413       );
 414       payload.transactionId = Utils.convertToInt(payload.transactionId);
 415     }
 416
 417     if (payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 418       chargingStation.getConnectorStatus(connectorId).transactionStarted = true;
 419       chargingStation.getConnectorStatus(connectorId).transactionId = payload.transactionId;
 420       chargingStation.getConnectorStatus(connectorId).transactionIdTag = requestPayload.idTag;
 421       chargingStation.getConnectorStatus(
 422         connectorId
 423       ).transactionEnergyActiveImportRegisterValue = 0;
 424       chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue =
 425         OCPP16ServiceUtils.buildTransactionBeginMeterValue(
 426           chargingStation,
 427           connectorId,
 428           requestPayload.meterStart
 429         );
 430       chargingStation.getBeginEndMeterValues() &&
 431         (await chargingStation.ocppRequestService.requestHandler<
 432           OCPP16MeterValuesRequest,
 433           OCPP16MeterValuesResponse
 434         >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
 435           connectorId,
 436           transactionId: payload.transactionId,
 437           meterValue: [chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue],
 438         }));
 439       await chargingStation.ocppRequestService.requestHandler<
 440         OCPP16StatusNotificationRequest,
 441         OCPP16StatusNotificationResponse
 442       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 443         connectorId,
 444         status: OCPP16ChargePointStatus.CHARGING,
 445         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 446       });
 447       chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.CHARGING;
 448       logger.info(
 449         chargingStation.logPrefix() +
 450           ' Transaction ' +
 451           payload.transactionId.toString() +
 452           ' STARTED on ' +
 453           chargingStation.stationInfo.chargingStationId +
 454           '#' +
 455           connectorId.toString() +
 456           ' for idTag ' +
 457           requestPayload.idTag
 458       );
 459       if (chargingStation.stationInfo.powerSharedByConnectors) {
 460         chargingStation.powerDivider++;
 461       }
 462       const configuredMeterValueSampleInterval =
 463         ChargingStationConfigurationUtils.getConfigurationKey(
 464           chargingStation,
 465           OCPP16StandardParametersKey.MeterValueSampleInterval
 466         );
 467       chargingStation.startMeterValues(
 468         connectorId,
 469         configuredMeterValueSampleInterval
 470           ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000
 471           : 60000
 472       );
 473     } else {
 474       logger.warn(
 475         chargingStation.logPrefix() +
 476           ' Starting transaction id ' +
 477           payload.transactionId.toString() +
 478           " REJECTED with status '" +
 479           payload?.idTagInfo?.status +
 480           "', idTag " +
 481           requestPayload.idTag
 482       );
 483       await this.resetConnectorOnStartTransactionError(chargingStation, connectorId);
 484     }
 485   }
 486
 487   private async resetConnectorOnStartTransactionError(
 488     chargingStation: ChargingStation,
 489     connectorId: number
 490   ): Promise<void> {
 491     chargingStation.resetConnectorStatus(connectorId);
 492     if (
 493       chargingStation.getConnectorStatus(connectorId).status !== OCPP16ChargePointStatus.AVAILABLE
 494     ) {
 495       await chargingStation.ocppRequestService.requestHandler<
 496         OCPP16StatusNotificationRequest,
 497         OCPP16StatusNotificationResponse
 498       >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 499         connectorId,
 500         status: OCPP16ChargePointStatus.AVAILABLE,
 501         errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 502       });
 503       chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.AVAILABLE;
 504     }
 505   }
 506
 507   private async handleResponseStopTransaction(
 508     chargingStation: ChargingStation,
 509     payload: OCPP16StopTransactionResponse,
 510     requestPayload: OCPP16StopTransactionRequest
 511   ): Promise<void> {
 512     const transactionConnectorId = chargingStation.getConnectorIdByTransactionId(
 513       requestPayload.transactionId
 514     );
 515     if (!transactionConnectorId) {
 516       logger.error(
 517         chargingStation.logPrefix() +
 518           ' Trying to stop a non existing transaction ' +
 519           requestPayload.transactionId.toString()
 520       );
 521       return;
 522     }
 523     if (payload.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
 524       chargingStation.getBeginEndMeterValues() &&
 525         !chargingStation.getOcppStrictCompliance() &&
 526         chargingStation.getOutOfOrderEndMeterValues() &&
 527         (await chargingStation.ocppRequestService.requestHandler<
 528           OCPP16MeterValuesRequest,
 529           OCPP16MeterValuesResponse
 530         >(chargingStation, OCPP16RequestCommand.METER_VALUES, {
 531           connectorId: transactionConnectorId,
 532           transactionId: requestPayload.transactionId,
 533           meterValue: [
 534             OCPP16ServiceUtils.buildTransactionEndMeterValue(
 535               chargingStation,
 536               transactionConnectorId,
 537               requestPayload.meterStop
 538             ),
 539           ],
 540         }));
 541       if (
 542         !chargingStation.isChargingStationAvailable() ||
 543         !chargingStation.isConnectorAvailable(transactionConnectorId)
 544       ) {
 545         await chargingStation.ocppRequestService.requestHandler<
 546           OCPP16StatusNotificationRequest,
 547           OCPP16StatusNotificationResponse
 548         >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 549           connectorId: transactionConnectorId,
 550           status: OCPP16ChargePointStatus.UNAVAILABLE,
 551           errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 552         });
 553         chargingStation.getConnectorStatus(transactionConnectorId).status =
 554           OCPP16ChargePointStatus.UNAVAILABLE;
 555       } else {
 556         await chargingStation.ocppRequestService.requestHandler<
 557           OCPP16BootNotificationRequest,
 558           OCPP16BootNotificationResponse
 559         >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
 560           connectorId: transactionConnectorId,
 561           status: OCPP16ChargePointStatus.AVAILABLE,
 562           errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
 563         });
 564         chargingStation.getConnectorStatus(transactionConnectorId).status =
 565           OCPP16ChargePointStatus.AVAILABLE;
 566       }
 567       if (chargingStation.stationInfo.powerSharedByConnectors) {
 568         chargingStation.powerDivider--;
 569       }
 570       logger.info(
 571         chargingStation.logPrefix() +
 572           ' Transaction ' +
 573           requestPayload.transactionId.toString() +
 574           ' STOPPED on ' +
 575           chargingStation.stationInfo.chargingStationId +
 576           '#' +
 577           transactionConnectorId.toString()
 578       );
 579       chargingStation.resetConnectorStatus(transactionConnectorId);
 580     } else {
 581       logger.warn(
 582         chargingStation.logPrefix() +
 583           ' Stopping transaction id ' +
 584           requestPayload.transactionId.toString() +
 585           " REJECTED with status '" +
 586           payload.idTagInfo?.status +
 587           "'"
 588       );
 589     }
 590   }
 591 }