X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Fui-server%2Fui-services%2FAbstractUIService.ts;h=3fa3f8ba756782567755b9a24c4dcf883de99489;hb=1091427efe95a8f1733282589dc1794a5be7e785;hp=44caca5472daca4084a8e5177a47d225ac304901;hpb=13a6f27c10768faa05acf33fd8e0637511d49e3e;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/ui-server/ui-services/AbstractUIService.ts b/src/charging-station/ui-server/ui-services/AbstractUIService.ts
index 44caca54..3fa3f8ba 100644
--- a/src/charging-station/ui-server/ui-services/AbstractUIService.ts
+++ b/src/charging-station/ui-server/ui-services/AbstractUIService.ts
@@ -2,6 +2,10 @@ import { BaseError, type OCPPError } from '../../../exception/index.js'
 import {
   BroadcastChannelProcedureName,
   type BroadcastChannelRequestPayload,
+  type ChargingStationInfo,
+  type ChargingStationOptions,
+  ConfigurationSection,
+  type JsonObject,
   type JsonType,
   ProcedureName,
   type ProtocolRequest,
@@ -10,15 +14,22 @@ import {
   type ProtocolVersion,
   type RequestPayload,
   type ResponsePayload,
-  ResponseStatus
+  ResponseStatus,
+  type StorageConfiguration
 } from '../../../types/index.js'
-import { isNotEmptyArray, logger } from '../../../utils/index.js'
+import { Configuration, isAsyncFunction, isNotEmptyArray, logger } from '../../../utils/index.js'
 import { Bootstrap } from '../../Bootstrap.js'
 import { UIServiceWorkerBroadcastChannel } from '../../broadcast-channel/UIServiceWorkerBroadcastChannel.js'
 import type { AbstractUIServer } from '../AbstractUIServer.js'
 
 const moduleName = 'AbstractUIService'
 
+interface AddChargingStationsRequestPayload extends RequestPayload {
+  template: string
+  numberOfStations: number
+  options?: ChargingStationOptions
+}
+
 export abstract class AbstractUIService {
   protected static readonly ProcedureNameToBroadCastChannelProcedureNameMapping = new Map<
   ProcedureName,
@@ -26,6 +37,10 @@ export abstract class AbstractUIService {
   >([
     [ProcedureName.START_CHARGING_STATION, BroadcastChannelProcedureName.START_CHARGING_STATION],
     [ProcedureName.STOP_CHARGING_STATION, BroadcastChannelProcedureName.STOP_CHARGING_STATION],
+    [
+      ProcedureName.DELETE_CHARGING_STATIONS,
+      BroadcastChannelProcedureName.DELETE_CHARGING_STATIONS
+    ],
     [ProcedureName.CLOSE_CONNECTION, BroadcastChannelProcedureName.CLOSE_CONNECTION],
     [ProcedureName.OPEN_CONNECTION, BroadcastChannelProcedureName.OPEN_CONNECTION],
     [
@@ -59,31 +74,46 @@ export abstract class AbstractUIService {
   private readonly version: ProtocolVersion
   private readonly uiServer: AbstractUIServer
   private readonly uiServiceWorkerBroadcastChannel: UIServiceWorkerBroadcastChannel
-  private readonly broadcastChannelRequests: Map<string, number>
+  private readonly broadcastChannelRequests: Map<
+    `${string}-${string}-${string}-${string}-${string}`,
+  number
+  >
 
   constructor (uiServer: AbstractUIServer, version: ProtocolVersion) {
     this.uiServer = uiServer
     this.version = version
     this.requestHandlers = new Map<ProcedureName, ProtocolRequestHandler>([
+      [ProcedureName.LIST_TEMPLATES, this.handleListTemplates.bind(this)],
       [ProcedureName.LIST_CHARGING_STATIONS, this.handleListChargingStations.bind(this)],
+      [ProcedureName.ADD_CHARGING_STATIONS, this.handleAddChargingStations.bind(this)],
+      [ProcedureName.PERFORMANCE_STATISTICS, this.handlePerformanceStatistics.bind(this)],
+      [ProcedureName.SIMULATOR_STATE, this.handleSimulatorState.bind(this)],
       [ProcedureName.START_SIMULATOR, this.handleStartSimulator.bind(this)],
       [ProcedureName.STOP_SIMULATOR, this.handleStopSimulator.bind(this)]
     ])
     this.uiServiceWorkerBroadcastChannel = new UIServiceWorkerBroadcastChannel(this)
-    this.broadcastChannelRequests = new Map<string, number>()
+    this.broadcastChannelRequests = new Map<
+      `${string}-${string}-${string}-${string}-${string}`,
+    number
+    >()
+  }
+
+  public stop (): void {
+    this.broadcastChannelRequests.clear()
+    this.uiServiceWorkerBroadcastChannel.close()
   }
 
   public async requestHandler (request: ProtocolRequest): Promise<ProtocolResponse | undefined> {
-    let messageId: string | undefined
+    let uuid: `${string}-${string}-${string}-${string}-${string}` | undefined
     let command: ProcedureName | undefined
     let requestPayload: RequestPayload | undefined
     let responsePayload: ResponsePayload | undefined
     try {
-      [messageId, command, requestPayload] = request
+      [uuid, command, requestPayload] = request
 
       if (!this.requestHandlers.has(command)) {
         throw new BaseError(
-          `${command} is not implemented to handle message payload ${JSON.stringify(
+          `'${command}' is not implemented to handle message payload ${JSON.stringify(
             requestPayload,
             undefined,
             2
@@ -93,7 +123,18 @@ export abstract class AbstractUIService {
 
       // Call the request handler to build the response payload
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      responsePayload = await this.requestHandlers.get(command)!(messageId, command, requestPayload)
+      const requestHandler = this.requestHandlers.get(command)!
+      if (isAsyncFunction(requestHandler)) {
+        responsePayload = await requestHandler(uuid, command, requestPayload)
+      } else {
+        responsePayload = (
+          requestHandler as (
+            uuid?: string,
+            procedureName?: ProcedureName,
+            payload?: RequestPayload
+          ) => undefined | ResponsePayload
+        )(uuid, command, requestPayload)
+      }
     } catch (error) {
       // Log
       logger.error(`${this.logPrefix(moduleName, 'requestHandler')} Handle request error:`, error)
@@ -106,27 +147,30 @@ export abstract class AbstractUIService {
         errorMessage: (error as OCPPError).message,
         errorStack: (error as OCPPError).stack,
         errorDetails: (error as OCPPError).details
-      }
+      } satisfies ResponsePayload
     }
     if (responsePayload != null) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      return this.uiServer.buildProtocolResponse(messageId!, responsePayload)
+      return this.uiServer.buildProtocolResponse(uuid!, responsePayload)
     }
   }
 
   // public sendRequest (
-  //   messageId: string,
+  //   uuid: `${string}-${string}-${string}-${string}-${string}`,
   //   procedureName: ProcedureName,
   //   requestPayload: RequestPayload
   // ): void {
   //   this.uiServer.sendRequest(
-  //     this.uiServer.buildProtocolRequest(messageId, procedureName, requestPayload)
+  //     this.uiServer.buildProtocolRequest(uuid, procedureName, requestPayload)
   //   )
   // }
 
-  public sendResponse (messageId: string, responsePayload: ResponsePayload): void {
-    if (this.uiServer.hasResponseHandler(messageId)) {
-      this.uiServer.sendResponse(this.uiServer.buildProtocolResponse(messageId, responsePayload))
+  public sendResponse (
+    uuid: `${string}-${string}-${string}-${string}-${string}`,
+    responsePayload: ResponsePayload
+  ): void {
+    if (this.uiServer.hasResponseHandler(uuid)) {
+      this.uiServer.sendResponse(this.uiServer.buildProtocolResponse(uuid, responsePayload))
     }
   }
 
@@ -134,17 +178,21 @@ export abstract class AbstractUIService {
     return this.uiServer.logPrefix(modName, methodName, this.version)
   }
 
-  public deleteBroadcastChannelRequest (uuid: string): void {
+  public deleteBroadcastChannelRequest (
+    uuid: `${string}-${string}-${string}-${string}-${string}`
+  ): void {
     this.broadcastChannelRequests.delete(uuid)
   }
 
-  public getBroadcastChannelExpectedResponses (uuid: string): number {
+  public getBroadcastChannelExpectedResponses (
+    uuid: `${string}-${string}-${string}-${string}-${string}`
+  ): number {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return this.broadcastChannelRequests.get(uuid)!
   }
 
   protected handleProtocolRequest (
-    uuid: string,
+    uuid: `${string}-${string}-${string}-${string}-${string}`,
     procedureName: ProcedureName,
     payload: RequestPayload
   ): void {
@@ -157,7 +205,7 @@ export abstract class AbstractUIService {
   }
 
   private sendBroadcastChannelRequest (
-    uuid: string,
+    uuid: `${string}-${string}-${string}-${string}-${string}`,
     procedureName: BroadcastChannelProcedureName,
     payload: BroadcastChannelRequestPayload
   ): void {
@@ -191,6 +239,13 @@ export abstract class AbstractUIService {
     this.broadcastChannelRequests.set(uuid, expectedNumberOfResponses)
   }
 
+  private handleListTemplates (): ResponsePayload {
+    return {
+      status: ResponseStatus.SUCCESS,
+      templates: [...this.uiServer.chargingStationTemplates.values()] as JsonType[]
+    } satisfies ResponsePayload
+  }
+
   private handleListChargingStations (): ResponsePayload {
     return {
       status: ResponseStatus.SUCCESS,
@@ -198,12 +253,116 @@ export abstract class AbstractUIService {
     } satisfies ResponsePayload
   }
 
+  private async handleAddChargingStations (
+    _uuid?: `${string}-${string}-${string}-${string}-${string}`,
+    _procedureName?: ProcedureName,
+    requestPayload?: RequestPayload
+  ): Promise<ResponsePayload> {
+    const { template, numberOfStations, options } =
+      requestPayload as AddChargingStationsRequestPayload
+    if (!Bootstrap.getInstance().getState().started) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage:
+          'Cannot add charging station(s) while the charging stations simulator is not started'
+      } satisfies ResponsePayload
+    }
+    if (typeof template !== 'string' || typeof numberOfStations !== 'number') {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: 'Invalid request payload'
+      } satisfies ResponsePayload
+    }
+    if (!this.uiServer.chargingStationTemplates.has(template)) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: `Template '${template}' not found`
+      } satisfies ResponsePayload
+    }
+    const succeededStationInfos: ChargingStationInfo[] = []
+    const failedStationInfos: ChargingStationInfo[] = []
+    let err: Error | undefined
+    for (let i = 0; i < numberOfStations; i++) {
+      let stationInfo: ChargingStationInfo | undefined
+      try {
+        stationInfo = await Bootstrap.getInstance().addChargingStation(
+          Bootstrap.getInstance().getLastIndex(template) + 1,
+          `${template}.json`,
+          options
+        )
+        if (stationInfo != null) {
+          succeededStationInfos.push(stationInfo)
+        }
+      } catch (error) {
+        err = error as Error
+        if (stationInfo != null) {
+          failedStationInfos.push(stationInfo)
+        }
+      }
+    }
+    return {
+      status: failedStationInfos.length > 0 ? ResponseStatus.FAILURE : ResponseStatus.SUCCESS,
+      hashIdsSucceeded: succeededStationInfos.map(stationInfo => stationInfo.hashId),
+      ...(failedStationInfos.length > 0 && {
+        hashIdsFailed: failedStationInfos.map(stationInfo => stationInfo.hashId)
+      }),
+      ...(err != null && { errorMessage: err.message, errorStack: err.stack })
+    } satisfies ResponsePayload
+  }
+
+  private handlePerformanceStatistics (): ResponsePayload {
+    if (
+      Configuration.getConfigurationSection<StorageConfiguration>(
+        ConfigurationSection.performanceStorage
+      ).enabled !== true
+    ) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: 'Performance statistics storage is not enabled'
+      } satisfies ResponsePayload
+    }
+    try {
+      return {
+        status: ResponseStatus.SUCCESS,
+        performanceStatistics: [
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          ...Bootstrap.getInstance().getPerformanceStatistics()!
+        ] as JsonType[]
+      } satisfies ResponsePayload
+    } catch (error) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: (error as Error).message,
+        errorStack: (error as Error).stack
+      } satisfies ResponsePayload
+    }
+  }
+
+  private handleSimulatorState (): ResponsePayload {
+    try {
+      return {
+        status: ResponseStatus.SUCCESS,
+        state: Bootstrap.getInstance().getState() as unknown as JsonObject
+      } satisfies ResponsePayload
+    } catch (error) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: (error as Error).message,
+        errorStack: (error as Error).stack
+      } satisfies ResponsePayload
+    }
+  }
+
   private async handleStartSimulator (): Promise<ResponsePayload> {
     try {
       await Bootstrap.getInstance().start()
       return { status: ResponseStatus.SUCCESS }
-    } catch {
-      return { status: ResponseStatus.FAILURE }
+    } catch (error) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: (error as Error).message,
+        errorStack: (error as Error).stack
+      } satisfies ResponsePayload
     }
   }
 
@@ -211,8 +370,12 @@ export abstract class AbstractUIService {
     try {
       await Bootstrap.getInstance().stop()
       return { status: ResponseStatus.SUCCESS }
-    } catch {
-      return { status: ResponseStatus.FAILURE }
+    } catch (error) {
+      return {
+        status: ResponseStatus.FAILURE,
+        errorMessage: (error as Error).message,
+        errorStack: (error as Error).stack
+      } satisfies ResponsePayload
     }
   }
 }