8 import config from
'@/assets/config';
10 type ResponseHandler
= {
11 procedureName
: ProcedureName
;
12 resolve
: (value
: ResponsePayload
| PromiseLike
<ResponsePayload
>) => void;
13 reject
: (reason
?: unknown
) => void;
16 export class UIClient
{
17 private static instance
: UIClient
| null = null;
19 private ws
!: WebSocket
;
20 private responseHandlers
: Map
<string, ResponseHandler
>;
22 private constructor() {
24 this.responseHandlers
= new Map
<string, ResponseHandler
>();
27 public static getInstance() {
28 if (UIClient
.instance
=== null) {
29 UIClient
.instance
= new UIClient();
31 return UIClient
.instance
;
34 public registerWSonOpenListener(listener
: (event
: Event
) => void) {
35 this.ws
.addEventListener('open', listener
);
38 public async startSimulator(): Promise
<ResponsePayload
> {
39 return this.sendRequest(ProcedureName
.START_SIMULATOR
, {});
42 public async stopSimulator(): Promise
<ResponsePayload
> {
43 return this.sendRequest(ProcedureName
.STOP_SIMULATOR
, {});
46 public async listChargingStations(): Promise
<ResponsePayload
> {
47 return this.sendRequest(ProcedureName
.LIST_CHARGING_STATIONS
, {});
50 public async startChargingStation(hashId
: string): Promise
<ResponsePayload
> {
51 return this.sendRequest(ProcedureName
.START_CHARGING_STATION
, { hashIds
: [hashId
] });
54 public async stopChargingStation(hashId
: string): Promise
<ResponsePayload
> {
55 return this.sendRequest(ProcedureName
.STOP_CHARGING_STATION
, { hashIds
: [hashId
] });
58 public async openConnection(hashId
: string): Promise
<ResponsePayload
> {
59 return this.sendRequest(ProcedureName
.OPEN_CONNECTION
, {
64 public async closeConnection(hashId
: string): Promise
<ResponsePayload
> {
65 return this.sendRequest(ProcedureName
.CLOSE_CONNECTION
, {
70 public async startTransaction(
73 idTag
: string | undefined,
74 ): Promise
<ResponsePayload
> {
75 return this.sendRequest(ProcedureName
.START_TRANSACTION
, {
82 public async stopTransaction(
84 transactionId
: number | undefined,
85 ): Promise
<ResponsePayload
> {
86 return this.sendRequest(ProcedureName
.STOP_TRANSACTION
, {
92 public async startAutomaticTransactionGenerator(
95 ): Promise
<ResponsePayload
> {
96 return this.sendRequest(ProcedureName
.START_AUTOMATIC_TRANSACTION_GENERATOR
, {
98 connectorIds
: [connectorId
],
102 public async stopAutomaticTransactionGenerator(
105 ): Promise
<ResponsePayload
> {
106 return this.sendRequest(ProcedureName
.STOP_AUTOMATIC_TRANSACTION_GENERATOR
, {
108 connectorIds
: [connectorId
],
112 private openWS(): void {
113 this.ws
= new WebSocket(
114 `ws://${config.uiServer.host}:${config.uiServer.port}`,
115 config
.uiServer
.protocol
,
117 this.ws
.onmessage
= this.responseHandler
.bind(this);
118 this.ws
.onerror
= (errorEvent
) => {
119 console
.error('WebSocket error: ', errorEvent
);
121 this.ws
.onclose
= (closeEvent
) => {
122 console
.info('WebSocket closed: ', closeEvent
);
126 private setResponseHandler(
128 procedureName
: ProcedureName
,
129 resolve
: (value
: ResponsePayload
| PromiseLike
<ResponsePayload
>) => void,
130 reject
: (reason
?: unknown
) => void,
132 this.responseHandlers
.set(id
, { procedureName
, resolve
, reject
});
135 private getResponseHandler(id
: string): ResponseHandler
| undefined {
136 return this.responseHandlers
.get(id
);
139 private deleteResponseHandler(id
: string): boolean {
140 return this.responseHandlers
.delete(id
);
143 private async sendRequest(
144 command
: ProcedureName
,
145 data
: RequestPayload
,
146 ): Promise
<ResponsePayload
> {
147 return new Promise
<ResponsePayload
>((resolve
, reject
) => {
148 const uuid
= crypto
.randomUUID();
149 const msg
= JSON
.stringify([uuid
, command
, data
]);
151 if (this.ws
.readyState
!== WebSocket
.OPEN
) {
154 if (this.ws
.readyState
=== WebSocket
.OPEN
) {
155 const sendTimeout
= setTimeout(() => {
156 this.deleteResponseHandler(uuid
);
157 return reject(new Error(`Send request '${command}' message timeout`));
161 this.setResponseHandler(uuid
, command
, resolve
, reject
);
163 this.deleteResponseHandler(uuid
);
166 clearTimeout(sendTimeout
);
169 throw new Error(`Send request '${command}' message: connection not opened`);
174 private responseHandler(messageEvent
: MessageEvent
<string>): void {
175 const response
= JSON
.parse(messageEvent
.data
) as ProtocolResponse
;
177 if (Array.isArray(response
) === false) {
178 throw new Error(`Response not an array: ${JSON.stringify(response, undefined, 2)}`);
181 const [uuid
, responsePayload
] = response
;
183 if (this.responseHandlers
.has(uuid
) === true) {
184 const { procedureName
, resolve
, reject
} = this.getResponseHandler(uuid
)!;
185 switch (responsePayload
.status) {
186 case ResponseStatus
.SUCCESS
:
187 resolve(responsePayload
);
189 case ResponseStatus
.FAILURE
:
190 reject(responsePayload
);
194 `Response status for procedure '${procedureName}' not supported: '${responsePayload.status}'`,
197 this.deleteResponseHandler(uuid
);
199 throw new Error(`Not a response to a request: ${JSON.stringify(response, undefined, 2)}`);