ui/web/src/composables/UIClient.ts

   1 import {
   2   ProcedureName,
   3   type ProtocolResponse,
   4   type RequestPayload,
   5   type ResponsePayload,
   6   ResponseStatus
   7 } from '@/types'
   8 import config from '@/assets/config'
   9
  10 type ResponseHandler = {
  11   procedureName: ProcedureName
  12   resolve: (value: ResponsePayload | PromiseLike<ResponsePayload>) => void
  13   reject: (reason?: unknown) => void
  14 }
  15
  16 export class UIClient {
  17   private static instance: UIClient | null = null
  18
  19   private ws!: WebSocket
  20   private responseHandlers: Map<string, ResponseHandler>
  21
  22   private constructor() {
  23     this.openWS()
  24     this.responseHandlers = new Map<string, ResponseHandler>()
  25   }
  26
  27   public static getInstance() {
  28     if (UIClient.instance === null) {
  29       UIClient.instance = new UIClient()
  30     }
  31     return UIClient.instance
  32   }
  33
  34   public registerWSonOpenListener(listener: (event: Event) => void) {
  35     this.ws.addEventListener('open', listener)
  36   }
  37
  38   public async startSimulator(): Promise<ResponsePayload> {
  39     return this.sendRequest(ProcedureName.START_SIMULATOR, {})
  40   }
  41
  42   public async stopSimulator(): Promise<ResponsePayload> {
  43     return this.sendRequest(ProcedureName.STOP_SIMULATOR, {})
  44   }
  45
  46   public async listChargingStations(): Promise<ResponsePayload> {
  47     return this.sendRequest(ProcedureName.LIST_CHARGING_STATIONS, {})
  48   }
  49
  50   public async startChargingStation(hashId: string): Promise<ResponsePayload> {
  51     return this.sendRequest(ProcedureName.START_CHARGING_STATION, { hashIds: [hashId] })
  52   }
  53
  54   public async stopChargingStation(hashId: string): Promise<ResponsePayload> {
  55     return this.sendRequest(ProcedureName.STOP_CHARGING_STATION, { hashIds: [hashId] })
  56   }
  57
  58   public async openConnection(hashId: string): Promise<ResponsePayload> {
  59     return this.sendRequest(ProcedureName.OPEN_CONNECTION, {
  60       hashIds: [hashId]
  61     })
  62   }
  63
  64   public async closeConnection(hashId: string): Promise<ResponsePayload> {
  65     return this.sendRequest(ProcedureName.CLOSE_CONNECTION, {
  66       hashIds: [hashId]
  67     })
  68   }
  69
  70   public async startTransaction(
  71     hashId: string,
  72     connectorId: number,
  73     idTag: string | undefined
  74   ): Promise<ResponsePayload> {
  75     return this.sendRequest(ProcedureName.START_TRANSACTION, {
  76       hashIds: [hashId],
  77       connectorId,
  78       idTag
  79     })
  80   }
  81
  82   public async stopTransaction(
  83     hashId: string,
  84     transactionId: number | undefined
  85   ): Promise<ResponsePayload> {
  86     return this.sendRequest(ProcedureName.STOP_TRANSACTION, {
  87       hashIds: [hashId],
  88       transactionId
  89     })
  90   }
  91
  92   public async startAutomaticTransactionGenerator(
  93     hashId: string,
  94     connectorId: number
  95   ): Promise<ResponsePayload> {
  96     return this.sendRequest(ProcedureName.START_AUTOMATIC_TRANSACTION_GENERATOR, {
  97       hashIds: [hashId],
  98       connectorIds: [connectorId]
  99     })
 100   }
 101
 102   public async stopAutomaticTransactionGenerator(
 103     hashId: string,
 104     connectorId: number
 105   ): Promise<ResponsePayload> {
 106     return this.sendRequest(ProcedureName.STOP_AUTOMATIC_TRANSACTION_GENERATOR, {
 107       hashIds: [hashId],
 108       connectorIds: [connectorId]
 109     })
 110   }
 111
 112   private openWS(): void {
 113     this.ws = new WebSocket(
 114       `ws://${config.uiServer.host}:${config.uiServer.port}`,
 115       config.uiServer.protocol
 116     )
 117     this.ws.onmessage = this.responseHandler.bind(this)
 118     this.ws.onerror = errorEvent => {
 119       console.error('WebSocket error: ', errorEvent)
 120     }
 121     this.ws.onclose = closeEvent => {
 122       console.info('WebSocket closed: ', closeEvent)
 123     }
 124   }
 125
 126   private async sendRequest(
 127     procedureName: ProcedureName,
 128     payload: RequestPayload
 129   ): Promise<ResponsePayload> {
 130     return new Promise<ResponsePayload>((resolve, reject) => {
 131       if (this.ws.readyState !== WebSocket.OPEN) {
 132         this.openWS()
 133       }
 134       if (this.ws.readyState === WebSocket.OPEN) {
 135         const uuid = crypto.randomUUID()
 136         const msg = JSON.stringify([uuid, procedureName, payload])
 137         const sendTimeout = setTimeout(() => {
 138           this.responseHandlers.delete(uuid)
 139           return reject(new Error(`Send request '${procedureName}' message timeout`))
 140         }, 60 * 1000)
 141         try {
 142           this.ws.send(msg)
 143           this.responseHandlers.set(uuid, { procedureName, resolve, reject })
 144         } catch (error) {
 145           this.responseHandlers.delete(uuid)
 146           reject(error)
 147         } finally {
 148           clearTimeout(sendTimeout)
 149         }
 150       } else {
 151         throw new Error(`Send request '${procedureName}' message: connection not opened`)
 152       }
 153     })
 154   }
 155
 156   private responseHandler(messageEvent: MessageEvent<string>): void {
 157     const response = JSON.parse(messageEvent.data) as ProtocolResponse
 158
 159     if (Array.isArray(response) === false) {
 160       throw new Error(`Response not an array: ${JSON.stringify(response, undefined, 2)}`)
 161     }
 162
 163     const [uuid, responsePayload] = response
 164
 165     if (this.responseHandlers.has(uuid) === true) {
 166       const { procedureName, resolve, reject } = this.responseHandlers.get(uuid)!
 167       switch (responsePayload.status) {
 168         case ResponseStatus.SUCCESS:
 169           resolve(responsePayload)
 170           break
 171         case ResponseStatus.FAILURE:
 172           reject(responsePayload)
 173           break
 174         default:
 175           console.error(
 176             `Response status for procedure '${procedureName}' not supported: '${responsePayload.status}'`
 177           )
 178       }
 179       this.responseHandlers.delete(uuid)
 180     } else {
 181       throw new Error(`Not a response to a request: ${JSON.stringify(response, undefined, 2)}`)
 182     }
 183   }
 184 }