src/charging-station/ui-server/ui-services/AbstractUIService.ts

   1 import BaseError from '../../../exception/BaseError';
   2 import type OCPPError from '../../../exception/OCPPError';
   3 import { Bootstrap } from '../../../internal';
   4 import {
   5   ProcedureName,
   6   type ProtocolRequest,
   7   type ProtocolRequestHandler,
   8   type ProtocolVersion,
   9   type RequestPayload,
  10   type ResponsePayload,
  11   ResponseStatus,
  12 } from '../../../types/UIProtocol';
  13 import {
  14   BroadcastChannelProcedureName,
  15   type BroadcastChannelRequestPayload,
  16 } from '../../../types/WorkerBroadcastChannel';
  17 import logger from '../../../utils/Logger';
  18 import Utils from '../../../utils/Utils';
  19 import UIServiceWorkerBroadcastChannel from '../../UIServiceWorkerBroadcastChannel';
  20 import type { AbstractUIServer } from '../AbstractUIServer';
  21
  22 const moduleName = 'AbstractUIService';
  23
  24 export default abstract class AbstractUIService {
  25   protected static readonly ProcedureNameToBroadCastChannelProcedureNameMap: Omit<
  26     Record<ProcedureName, BroadcastChannelProcedureName>,
  27     | ProcedureName.START_SIMULATOR
  28     | ProcedureName.STOP_SIMULATOR
  29     | ProcedureName.LIST_CHARGING_STATIONS
  30   > = {
  31     [ProcedureName.START_CHARGING_STATION]: BroadcastChannelProcedureName.START_CHARGING_STATION,
  32     [ProcedureName.STOP_CHARGING_STATION]: BroadcastChannelProcedureName.STOP_CHARGING_STATION,
  33     [ProcedureName.CLOSE_CONNECTION]: BroadcastChannelProcedureName.CLOSE_CONNECTION,
  34     [ProcedureName.OPEN_CONNECTION]: BroadcastChannelProcedureName.OPEN_CONNECTION,
  35     [ProcedureName.START_AUTOMATIC_TRANSACTION_GENERATOR]:
  36       BroadcastChannelProcedureName.START_AUTOMATIC_TRANSACTION_GENERATOR,
  37     [ProcedureName.STOP_AUTOMATIC_TRANSACTION_GENERATOR]:
  38       BroadcastChannelProcedureName.STOP_AUTOMATIC_TRANSACTION_GENERATOR,
  39     [ProcedureName.START_TRANSACTION]: BroadcastChannelProcedureName.START_TRANSACTION,
  40     [ProcedureName.STOP_TRANSACTION]: BroadcastChannelProcedureName.STOP_TRANSACTION,
  41     [ProcedureName.AUTHORIZE]: BroadcastChannelProcedureName.AUTHORIZE,
  42     [ProcedureName.BOOT_NOTIFICATION]: BroadcastChannelProcedureName.BOOT_NOTIFICATION,
  43     [ProcedureName.STATUS_NOTIFICATION]: BroadcastChannelProcedureName.STATUS_NOTIFICATION,
  44     [ProcedureName.HEARTBEAT]: BroadcastChannelProcedureName.HEARTBEAT,
  45     [ProcedureName.METER_VALUES]: BroadcastChannelProcedureName.METER_VALUES,
  46     [ProcedureName.DATA_TRANSFER]: BroadcastChannelProcedureName.DATA_TRANSFER,
  47     [ProcedureName.DIAGNOSTICS_STATUS_NOTIFICATION]:
  48       BroadcastChannelProcedureName.DIAGNOSTICS_STATUS_NOTIFICATION,
  49     [ProcedureName.FIRMWARE_STATUS_NOTIFICATION]:
  50       BroadcastChannelProcedureName.FIRMWARE_STATUS_NOTIFICATION,
  51   };
  52
  53   protected readonly requestHandlers: Map<ProcedureName, ProtocolRequestHandler>;
  54   private readonly version: ProtocolVersion;
  55   private readonly uiServer: AbstractUIServer;
  56   private readonly uiServiceWorkerBroadcastChannel: UIServiceWorkerBroadcastChannel;
  57   private readonly broadcastChannelRequests: Map<string, number>;
  58
  59   constructor(uiServer: AbstractUIServer, version: ProtocolVersion) {
  60     this.uiServer = uiServer;
  61     this.version = version;
  62     this.requestHandlers = new Map<ProcedureName, ProtocolRequestHandler>([
  63       [ProcedureName.LIST_CHARGING_STATIONS, this.handleListChargingStations.bind(this)],
  64       [ProcedureName.START_SIMULATOR, this.handleStartSimulator.bind(this)],
  65       [ProcedureName.STOP_SIMULATOR, this.handleStopSimulator.bind(this)],
  66     ]);
  67     this.uiServiceWorkerBroadcastChannel = new UIServiceWorkerBroadcastChannel(this);
  68     this.broadcastChannelRequests = new Map<string, number>();
  69   }
  70
  71   public async requestHandler(request: ProtocolRequest): Promise<void> {
  72     let messageId: string;
  73     let command: ProcedureName;
  74     let requestPayload: RequestPayload | undefined;
  75     let responsePayload: ResponsePayload;
  76     try {
  77       [messageId, command, requestPayload] = request;
  78
  79       if (this.requestHandlers.has(command) === false) {
  80         throw new BaseError(
  81           `${command} is not implemented to handle message payload ${JSON.stringify(
  82             requestPayload,
  83             null,
  84             2
  85           )}`
  86         );
  87       }
  88
  89       // Call the request handler to build the response payload
  90       responsePayload = await this.requestHandlers.get(command)(messageId, command, requestPayload);
  91     } catch (error) {
  92       // Log
  93       logger.error(`${this.logPrefix(moduleName, 'messageHandler')} Handle request error:`, error);
  94       responsePayload = {
  95         hashIds: requestPayload.hashIds,
  96         status: ResponseStatus.FAILURE,
  97         command,
  98         requestPayload,
  99         responsePayload,
 100         errorMessage: (error as Error).message,
 101         errorStack: (error as Error).stack,
 102         errorDetails: (error as OCPPError).details,
 103       };
 104     } finally {
 105       // Send response for payload not forwarded to broadcast channel
 106       if (responsePayload !== undefined) {
 107         this.sendResponse(messageId, responsePayload);
 108       }
 109     }
 110   }
 111
 112   public sendRequest(
 113     messageId: string,
 114     procedureName: ProcedureName,
 115     requestPayload: RequestPayload
 116   ): void {
 117     this.uiServer.sendRequest(
 118       this.uiServer.buildProtocolRequest(messageId, procedureName, requestPayload)
 119     );
 120   }
 121
 122   public sendResponse(messageId: string, responsePayload: ResponsePayload): void {
 123     this.uiServer.sendResponse(this.uiServer.buildProtocolResponse(messageId, responsePayload));
 124   }
 125
 126   public logPrefix(modName: string, methodName: string): string {
 127     return this.uiServer.logPrefix(modName, methodName, this.version);
 128   }
 129
 130   public deleteBroadcastChannelRequest(uuid: string): void {
 131     this.broadcastChannelRequests.delete(uuid);
 132   }
 133
 134   public getBroadcastChannelExpectedResponses(uuid: string): number {
 135     return this.broadcastChannelRequests.get(uuid) ?? 0;
 136   }
 137
 138   protected handleProtocolRequest(
 139     uuid: string,
 140     procedureName: ProcedureName,
 141     payload: RequestPayload
 142   ): void {
 143     this.sendBroadcastChannelRequest(
 144       uuid,
 145       AbstractUIService.ProcedureNameToBroadCastChannelProcedureNameMap[
 146         procedureName
 147       ] as BroadcastChannelProcedureName,
 148       payload
 149     );
 150   }
 151
 152   private sendBroadcastChannelRequest(
 153     uuid: string,
 154     procedureName: BroadcastChannelProcedureName,
 155     payload: BroadcastChannelRequestPayload
 156   ): void {
 157     if (!Utils.isEmptyArray(payload.hashIds)) {
 158       payload.hashIds = payload.hashIds
 159         .map(hashId => {
 160           if (this.uiServer.chargingStations.has(hashId) === true) {
 161             return hashId;
 162           }
 163           logger.warn(
 164             `${this.logPrefix(
 165               moduleName,
 166               'sendBroadcastChannelRequest'
 167             )} Charging station with hashId '${hashId}' not found`
 168           );
 169         })
 170         .filter(hashId => hashId !== undefined);
 171     }
 172     const expectedNumberOfResponses = !Utils.isEmptyArray(payload.hashIds)
 173       ? payload.hashIds.length
 174       : this.uiServer.chargingStations.size;
 175     this.uiServiceWorkerBroadcastChannel.sendRequest([uuid, procedureName, payload]);
 176     this.broadcastChannelRequests.set(uuid, expectedNumberOfResponses);
 177   }
 178
 179   private handleListChargingStations(): ResponsePayload {
 180     return {
 181       status: ResponseStatus.SUCCESS,
 182       chargingStations: [...this.uiServer.chargingStations.values()],
 183     } as ResponsePayload;
 184   }
 185
 186   private async handleStartSimulator(): Promise<ResponsePayload> {
 187     await Bootstrap.getInstance().start();
 188     return { status: ResponseStatus.SUCCESS };
 189   }
 190
 191   private async handleStopSimulator(): Promise<ResponsePayload> {
 192     await Bootstrap.getInstance().stop();
 193     return { status: ResponseStatus.SUCCESS };
 194   }
 195 }