src/charging-station/AutomaticTransactionGenerator.ts

   1 // Partial Copyright Jerome Benoit. 2021-2024. All Rights Reserved.
   2
   3 import { hoursToMilliseconds, secondsToMilliseconds } from 'date-fns'
   4
   5 import type { ChargingStation } from './ChargingStation.js'
   6 import { checkChargingStation } from './Helpers.js'
   7 import { IdTagsCache } from './IdTagsCache.js'
   8 import { isIdTagAuthorized } from './ocpp/index.js'
   9 import { BaseError } from '../exception/index.js'
  10 import { PerformanceStatistics } from '../performance/index.js'
  11 import {
  12   AuthorizationStatus,
  13   RequestCommand,
  14   type StartTransactionRequest,
  15   type StartTransactionResponse,
  16   type Status,
  17   StopTransactionReason,
  18   type StopTransactionResponse
  19 } from '../types/index.js'
  20 import {
  21   Constants,
  22   clone,
  23   convertToDate,
  24   formatDurationMilliSeconds,
  25   getRandomInteger,
  26   isValidDate,
  27   logPrefix,
  28   logger,
  29   secureRandom,
  30   sleep
  31 } from '../utils/index.js'
  32
  33 export class AutomaticTransactionGenerator {
  34   private static readonly instances: Map<string, AutomaticTransactionGenerator> = new Map<
  35   string,
  36   AutomaticTransactionGenerator
  37   >()
  38
  39   public readonly connectorsStatus: Map<number, Status>
  40   public started: boolean
  41   private starting: boolean
  42   private stopping: boolean
  43   private readonly chargingStation: ChargingStation
  44
  45   private constructor (chargingStation: ChargingStation) {
  46     this.started = false
  47     this.starting = false
  48     this.stopping = false
  49     this.chargingStation = chargingStation
  50     this.connectorsStatus = new Map<number, Status>()
  51     this.initializeConnectorsStatus()
  52   }
  53
  54   public static getInstance (
  55     chargingStation: ChargingStation
  56   ): AutomaticTransactionGenerator | undefined {
  57     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  58     if (!AutomaticTransactionGenerator.instances.has(chargingStation.stationInfo!.hashId)) {
  59       AutomaticTransactionGenerator.instances.set(
  60         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  61         chargingStation.stationInfo!.hashId,
  62         new AutomaticTransactionGenerator(chargingStation)
  63       )
  64     }
  65     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  66     return AutomaticTransactionGenerator.instances.get(chargingStation.stationInfo!.hashId)
  67   }
  68
  69   public start (stopAbsoluteDuration?: boolean): void {
  70     if (!checkChargingStation(this.chargingStation, this.logPrefix())) {
  71       return
  72     }
  73     if (this.started) {
  74       logger.warn(`${this.logPrefix()} is already started`)
  75       return
  76     }
  77     if (this.starting) {
  78       logger.warn(`${this.logPrefix()} is already starting`)
  79       return
  80     }
  81     this.starting = true
  82     this.startConnectors(stopAbsoluteDuration)
  83     this.started = true
  84     this.starting = false
  85   }
  86
  87   public stop (): void {
  88     if (!this.started) {
  89       logger.warn(`${this.logPrefix()} is already stopped`)
  90       return
  91     }
  92     if (this.stopping) {
  93       logger.warn(`${this.logPrefix()} is already stopping`)
  94       return
  95     }
  96     this.stopping = true
  97     this.stopConnectors()
  98     this.started = false
  99     this.stopping = false
 100   }
 101
 102   public startConnector (connectorId: number, stopAbsoluteDuration?: boolean): void {
 103     if (!checkChargingStation(this.chargingStation, this.logPrefix(connectorId))) {
 104       return
 105     }
 106     if (!this.connectorsStatus.has(connectorId)) {
 107       logger.error(`${this.logPrefix(connectorId)} starting on non existing connector`)
 108       throw new BaseError(`Connector ${connectorId} does not exist`)
 109     }
 110     if (this.connectorsStatus.get(connectorId)?.start === false) {
 111       this.internalStartConnector(connectorId, stopAbsoluteDuration).catch(Constants.EMPTY_FUNCTION)
 112     } else if (this.connectorsStatus.get(connectorId)?.start === true) {
 113       logger.warn(`${this.logPrefix(connectorId)} is already started on connector`)
 114     }
 115   }
 116
 117   public stopConnector (connectorId: number): void {
 118     if (!this.connectorsStatus.has(connectorId)) {
 119       logger.error(`${this.logPrefix(connectorId)} stopping on non existing connector`)
 120       throw new BaseError(`Connector ${connectorId} does not exist`)
 121     }
 122     if (this.connectorsStatus.get(connectorId)?.start === true) {
 123       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 124       this.connectorsStatus.get(connectorId)!.start = false
 125     } else if (this.connectorsStatus.get(connectorId)?.start === false) {
 126       logger.warn(`${this.logPrefix(connectorId)} is already stopped on connector`)
 127     }
 128   }
 129
 130   private startConnectors (stopAbsoluteDuration?: boolean): void {
 131     if (
 132       this.connectorsStatus.size > 0 &&
 133       this.connectorsStatus.size !== this.chargingStation.getNumberOfConnectors()
 134     ) {
 135       this.connectorsStatus.clear()
 136       this.initializeConnectorsStatus()
 137     }
 138     if (this.chargingStation.hasEvses) {
 139       for (const [evseId, evseStatus] of this.chargingStation.evses) {
 140         if (evseId > 0) {
 141           for (const connectorId of evseStatus.connectors.keys()) {
 142             this.startConnector(connectorId, stopAbsoluteDuration)
 143           }
 144         }
 145       }
 146     } else {
 147       for (const connectorId of this.chargingStation.connectors.keys()) {
 148         if (connectorId > 0) {
 149           this.startConnector(connectorId, stopAbsoluteDuration)
 150         }
 151       }
 152     }
 153   }
 154
 155   private stopConnectors (): void {
 156     if (this.chargingStation.hasEvses) {
 157       for (const [evseId, evseStatus] of this.chargingStation.evses) {
 158         if (evseId > 0) {
 159           for (const connectorId of evseStatus.connectors.keys()) {
 160             this.stopConnector(connectorId)
 161           }
 162         }
 163       }
 164     } else {
 165       for (const connectorId of this.chargingStation.connectors.keys()) {
 166         if (connectorId > 0) {
 167           this.stopConnector(connectorId)
 168         }
 169       }
 170     }
 171   }
 172
 173   private async internalStartConnector (
 174     connectorId: number,
 175     stopAbsoluteDuration?: boolean
 176   ): Promise<void> {
 177     this.setStartConnectorStatus(connectorId, stopAbsoluteDuration)
 178     logger.info(
 179       `${this.logPrefix(
 180         connectorId
 181       )} started on connector and will run for ${formatDurationMilliSeconds(
 182         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 183         this.connectorsStatus.get(connectorId)!.stopDate!.getTime() -
 184           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 185           this.connectorsStatus.get(connectorId)!.startDate!.getTime()
 186       )}`
 187     )
 188     while (this.connectorsStatus.get(connectorId)?.start === true) {
 189       await this.waitChargingStationAvailable(connectorId)
 190       await this.waitConnectorAvailable(connectorId)
 191       await this.waitRunningTransactionStopped(connectorId)
 192       if (!this.canStartConnector(connectorId)) {
 193         this.stopConnector(connectorId)
 194         break
 195       }
 196       const wait = secondsToMilliseconds(
 197         getRandomInteger(
 198           this.chargingStation.getAutomaticTransactionGeneratorConfiguration()
 199             ?.maxDelayBetweenTwoTransactions,
 200           this.chargingStation.getAutomaticTransactionGeneratorConfiguration()
 201             ?.minDelayBetweenTwoTransactions
 202         )
 203       )
 204       logger.info(`${this.logPrefix(connectorId)} waiting for ${formatDurationMilliSeconds(wait)}`)
 205       await sleep(wait)
 206       const start = secureRandom()
 207       if (
 208         start <
 209         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 210         this.chargingStation.getAutomaticTransactionGeneratorConfiguration()!.probabilityOfStart
 211       ) {
 212         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 213         this.connectorsStatus.get(connectorId)!.skippedConsecutiveTransactions = 0
 214         // Start transaction
 215         const startResponse = await this.startTransaction(connectorId)
 216         if (startResponse?.idTagInfo.status === AuthorizationStatus.ACCEPTED) {
 217           // Wait until end of transaction
 218           const waitTrxEnd = secondsToMilliseconds(
 219             getRandomInteger(
 220               this.chargingStation.getAutomaticTransactionGeneratorConfiguration()?.maxDuration,
 221               this.chargingStation.getAutomaticTransactionGeneratorConfiguration()?.minDuration
 222             )
 223           )
 224           logger.info(
 225             `${this.logPrefix(connectorId)} transaction started with id ${
 226               this.chargingStation.getConnectorStatus(connectorId)?.transactionId
 227             } and will stop in ${formatDurationMilliSeconds(waitTrxEnd)}`
 228           )
 229           await sleep(waitTrxEnd)
 230           await this.stopTransaction(connectorId)
 231         }
 232       } else {
 233         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 234         ++this.connectorsStatus.get(connectorId)!.skippedConsecutiveTransactions
 235         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 236         ++this.connectorsStatus.get(connectorId)!.skippedTransactions
 237         logger.info(
 238           `${this.logPrefix(connectorId)} skipped consecutively ${
 239             this.connectorsStatus.get(connectorId)?.skippedConsecutiveTransactions
 240           }/${this.connectorsStatus.get(connectorId)?.skippedTransactions} transaction(s)`
 241         )
 242       }
 243       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 244       this.connectorsStatus.get(connectorId)!.lastRunDate = new Date()
 245     }
 246     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 247     this.connectorsStatus.get(connectorId)!.stoppedDate = new Date()
 248     logger.info(
 249       `${this.logPrefix(
 250         connectorId
 251       )} stopped on connector and lasted for ${formatDurationMilliSeconds(
 252         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 253         this.connectorsStatus.get(connectorId)!.stoppedDate!.getTime() -
 254           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 255           this.connectorsStatus.get(connectorId)!.startDate!.getTime()
 256       )}`
 257     )
 258     logger.debug(
 259       `${this.logPrefix(connectorId)} connector status: %j`,
 260       this.connectorsStatus.get(connectorId)
 261     )
 262   }
 263
 264   private setStartConnectorStatus (
 265     connectorId: number,
 266     stopAbsoluteDuration = this.chargingStation.getAutomaticTransactionGeneratorConfiguration()
 267       ?.stopAbsoluteDuration
 268   ): void {
 269     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 270     this.connectorsStatus.get(connectorId)!.startDate = new Date()
 271     if (
 272       stopAbsoluteDuration === false ||
 273       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 274       !isValidDate(this.connectorsStatus.get(connectorId)!.stopDate)
 275     ) {
 276       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 277       this.connectorsStatus.get(connectorId)!.stopDate = new Date(
 278         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 279         this.connectorsStatus.get(connectorId)!.startDate!.getTime() +
 280           hoursToMilliseconds(
 281             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 282             this.chargingStation.getAutomaticTransactionGeneratorConfiguration()!.stopAfterHours
 283           )
 284       )
 285     }
 286     delete this.connectorsStatus.get(connectorId)?.stoppedDate
 287     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 288     this.connectorsStatus.get(connectorId)!.skippedConsecutiveTransactions = 0
 289     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 290     this.connectorsStatus.get(connectorId)!.start = true
 291   }
 292
 293   private canStartConnector (connectorId: number): boolean {
 294     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 295     if (new Date() > this.connectorsStatus.get(connectorId)!.stopDate!) {
 296       logger.info(
 297         `${this.logPrefix(
 298           connectorId
 299         )} entered in transaction loop while the ATG stop date has been reached`
 300       )
 301       return false
 302     }
 303     if (!this.chargingStation.inAcceptedState()) {
 304       logger.error(
 305         `${this.logPrefix(
 306           connectorId
 307         )} entered in transaction loop while the charging station is not in accepted state`
 308       )
 309       return false
 310     }
 311     if (!this.chargingStation.isChargingStationAvailable()) {
 312       logger.info(
 313         `${this.logPrefix(
 314           connectorId
 315         )} entered in transaction loop while the charging station is unavailable`
 316       )
 317       return false
 318     }
 319     if (!this.chargingStation.isConnectorAvailable(connectorId)) {
 320       logger.info(
 321         `${this.logPrefix(
 322           connectorId
 323         )} entered in transaction loop while the connector ${connectorId} is unavailable`
 324       )
 325       return false
 326     }
 327     return true
 328   }
 329
 330   private async waitChargingStationAvailable (connectorId: number): Promise<void> {
 331     let logged = false
 332     while (!this.chargingStation.isChargingStationAvailable()) {
 333       if (!logged) {
 334         logger.info(
 335           `${this.logPrefix(
 336             connectorId
 337           )} transaction loop waiting for charging station to be available`
 338         )
 339         logged = true
 340       }
 341       await sleep(Constants.DEFAULT_ATG_WAIT_TIME)
 342     }
 343   }
 344
 345   private async waitConnectorAvailable (connectorId: number): Promise<void> {
 346     let logged = false
 347     while (!this.chargingStation.isConnectorAvailable(connectorId)) {
 348       if (!logged) {
 349         logger.info(
 350           `${this.logPrefix(
 351             connectorId
 352           )} transaction loop waiting for connector ${connectorId} to be available`
 353         )
 354         logged = true
 355       }
 356       await sleep(Constants.DEFAULT_ATG_WAIT_TIME)
 357     }
 358   }
 359
 360   private async waitRunningTransactionStopped (connectorId: number): Promise<void> {
 361     const connectorStatus = this.chargingStation.getConnectorStatus(connectorId)
 362     let logged = false
 363     while (connectorStatus?.transactionStarted === true) {
 364       if (!logged) {
 365         logger.info(
 366           `${this.logPrefix(
 367             connectorId
 368           )} transaction loop waiting for running transaction ${connectorStatus.transactionId} on connector ${connectorId} to be stopped`
 369         )
 370         logged = true
 371       }
 372       await sleep(Constants.DEFAULT_ATG_WAIT_TIME)
 373     }
 374   }
 375
 376   private initializeConnectorsStatus (): void {
 377     if (this.chargingStation.hasEvses) {
 378       for (const [evseId, evseStatus] of this.chargingStation.evses) {
 379         if (evseId > 0) {
 380           for (const connectorId of evseStatus.connectors.keys()) {
 381             this.connectorsStatus.set(connectorId, this.getConnectorStatus(connectorId))
 382           }
 383         }
 384       }
 385     } else {
 386       for (const connectorId of this.chargingStation.connectors.keys()) {
 387         if (connectorId > 0) {
 388           this.connectorsStatus.set(connectorId, this.getConnectorStatus(connectorId))
 389         }
 390       }
 391     }
 392   }
 393
 394   private getConnectorStatus (connectorId: number): Status {
 395     const statusIndex = connectorId - 1
 396     let connectorStatus: Status | undefined
 397     if (this.chargingStation.getAutomaticTransactionGeneratorStatuses()?.[statusIndex] != null) {
 398       connectorStatus = clone<Status>(
 399         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 400         this.chargingStation.getAutomaticTransactionGeneratorStatuses()![statusIndex]
 401       )
 402     } else if (this.chargingStation.getAutomaticTransactionGeneratorStatuses() != null) {
 403       logger.warn(
 404         `${this.logPrefix(connectorId)} no status found for connector #${connectorId} in charging station configuration file. New status will be created`
 405       )
 406     }
 407     if (connectorStatus != null) {
 408       connectorStatus.startDate = convertToDate(connectorStatus.startDate)
 409       connectorStatus.lastRunDate = convertToDate(connectorStatus.lastRunDate)
 410       connectorStatus.stopDate = convertToDate(connectorStatus.stopDate)
 411       connectorStatus.stoppedDate = convertToDate(connectorStatus.stoppedDate)
 412       if (
 413         !this.started &&
 414         (connectorStatus.start ||
 415           this.chargingStation.getAutomaticTransactionGeneratorConfiguration()?.enable !== true)
 416       ) {
 417         connectorStatus.start = false
 418       }
 419     }
 420     return (
 421       connectorStatus ?? {
 422         start: false,
 423         authorizeRequests: 0,
 424         acceptedAuthorizeRequests: 0,
 425         rejectedAuthorizeRequests: 0,
 426         startTransactionRequests: 0,
 427         acceptedStartTransactionRequests: 0,
 428         rejectedStartTransactionRequests: 0,
 429         stopTransactionRequests: 0,
 430         acceptedStopTransactionRequests: 0,
 431         rejectedStopTransactionRequests: 0,
 432         skippedConsecutiveTransactions: 0,
 433         skippedTransactions: 0
 434       }
 435     )
 436   }
 437
 438   private async startTransaction (
 439     connectorId: number
 440   ): Promise<StartTransactionResponse | undefined> {
 441     const measureId = 'StartTransaction with ATG'
 442     const beginId = PerformanceStatistics.beginMeasure(measureId)
 443     let startResponse: StartTransactionResponse | undefined
 444     if (this.chargingStation.hasIdTags()) {
 445       const idTag = IdTagsCache.getInstance().getIdTag(
 446         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 447         this.chargingStation.getAutomaticTransactionGeneratorConfiguration()!.idTagDistribution!,
 448         this.chargingStation,
 449         connectorId
 450       )
 451       const startTransactionLogMsg = `${this.logPrefix(
 452         connectorId
 453       )} start transaction with an idTag '${idTag}'`
 454       if (this.getRequireAuthorize()) {
 455         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 456         ++this.connectorsStatus.get(connectorId)!.authorizeRequests
 457         if (await isIdTagAuthorized(this.chargingStation, connectorId, idTag)) {
 458           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 459           ++this.connectorsStatus.get(connectorId)!.acceptedAuthorizeRequests
 460           logger.info(startTransactionLogMsg)
 461           // Start transaction
 462           startResponse = await this.chargingStation.ocppRequestService.requestHandler<
 463           StartTransactionRequest,
 464           StartTransactionResponse
 465           >(this.chargingStation, RequestCommand.START_TRANSACTION, {
 466             connectorId,
 467             idTag
 468           })
 469           this.handleStartTransactionResponse(connectorId, startResponse)
 470           PerformanceStatistics.endMeasure(measureId, beginId)
 471           return startResponse
 472         }
 473         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 474         ++this.connectorsStatus.get(connectorId)!.rejectedAuthorizeRequests
 475         PerformanceStatistics.endMeasure(measureId, beginId)
 476         return startResponse
 477       }
 478       logger.info(startTransactionLogMsg)
 479       // Start transaction
 480       startResponse = await this.chargingStation.ocppRequestService.requestHandler<
 481       StartTransactionRequest,
 482       StartTransactionResponse
 483       >(this.chargingStation, RequestCommand.START_TRANSACTION, {
 484         connectorId,
 485         idTag
 486       })
 487       this.handleStartTransactionResponse(connectorId, startResponse)
 488       PerformanceStatistics.endMeasure(measureId, beginId)
 489       return startResponse
 490     }
 491     logger.info(`${this.logPrefix(connectorId)} start transaction without an idTag`)
 492     startResponse = await this.chargingStation.ocppRequestService.requestHandler<
 493     StartTransactionRequest,
 494     StartTransactionResponse
 495     >(this.chargingStation, RequestCommand.START_TRANSACTION, { connectorId })
 496     this.handleStartTransactionResponse(connectorId, startResponse)
 497     PerformanceStatistics.endMeasure(measureId, beginId)
 498     return startResponse
 499   }
 500
 501   private async stopTransaction (
 502     connectorId: number,
 503     reason = StopTransactionReason.LOCAL
 504   ): Promise<StopTransactionResponse | undefined> {
 505     const measureId = 'StopTransaction with ATG'
 506     const beginId = PerformanceStatistics.beginMeasure(measureId)
 507     let stopResponse: StopTransactionResponse | undefined
 508     if (this.chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
 509       logger.info(
 510         `${this.logPrefix(connectorId)} stop transaction with id ${
 511           this.chargingStation.getConnectorStatus(connectorId)?.transactionId
 512         }`
 513       )
 514       stopResponse = await this.chargingStation.stopTransactionOnConnector(connectorId, reason)
 515       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 516       ++this.connectorsStatus.get(connectorId)!.stopTransactionRequests
 517       if (stopResponse.idTagInfo?.status === AuthorizationStatus.ACCEPTED) {
 518         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 519         ++this.connectorsStatus.get(connectorId)!.acceptedStopTransactionRequests
 520       } else {
 521         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 522         ++this.connectorsStatus.get(connectorId)!.rejectedStopTransactionRequests
 523       }
 524     } else {
 525       const transactionId = this.chargingStation.getConnectorStatus(connectorId)?.transactionId
 526       logger.debug(
 527         `${this.logPrefix(connectorId)} stopping a not started transaction${
 528           transactionId != null ? ` with id ${transactionId}` : ''
 529         }`
 530       )
 531     }
 532     PerformanceStatistics.endMeasure(measureId, beginId)
 533     return stopResponse
 534   }
 535
 536   private getRequireAuthorize (): boolean {
 537     return (
 538       this.chargingStation.getAutomaticTransactionGeneratorConfiguration()?.requireAuthorize ?? true
 539     )
 540   }
 541
 542   private readonly logPrefix = (connectorId?: number): string => {
 543     return logPrefix(
 544       ` ${this.chargingStation.stationInfo?.chargingStationId} | ATG${
 545         connectorId != null ? ` on connector #${connectorId}` : ''
 546       }:`
 547     )
 548   }
 549
 550   private handleStartTransactionResponse (
 551     connectorId: number,
 552     startResponse: StartTransactionResponse
 553   ): void {
 554     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 555     ++this.connectorsStatus.get(connectorId)!.startTransactionRequests
 556     if (startResponse.idTagInfo.status === AuthorizationStatus.ACCEPTED) {
 557       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 558       ++this.connectorsStatus.get(connectorId)!.acceptedStartTransactionRequests
 559     } else {
 560       logger.warn(`${this.logPrefix(connectorId)} start transaction rejected`)
 561       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 562       ++this.connectorsStatus.get(connectorId)!.rejectedStartTransactionRequests
 563     }
 564   }
 565 }