-import { RawData } from 'ws';
+import type { RawData } from 'ws';
import BaseError from '../../../exception/BaseError';
-import { JsonType } from '../../../types/JsonType';
+import { Bootstrap } from '../../../internal';
+import type { JsonType } from '../../../types/JsonType';
import {
ProcedureName,
ProtocolRequest,
ProtocolRequestHandler,
- ProtocolResponse,
ProtocolVersion,
RequestPayload,
ResponsePayload,
ResponseStatus,
} from '../../../types/UIProtocol';
import logger from '../../../utils/Logger';
-import Utils from '../../../utils/Utils';
-import Bootstrap from '../../Bootstrap';
import UIServiceWorkerBroadcastChannel from '../../UIServiceWorkerBroadcastChannel';
-import { AbstractUIServer } from '../AbstractUIServer';
+import type { AbstractUIServer } from '../AbstractUIServer';
const moduleName = 'AbstractUIService';
this.uiServiceWorkerBroadcastChannel = new UIServiceWorkerBroadcastChannel(this);
}
- public async requestHandler(request: RawData): Promise<void> {
+ public async requestHandler(request: RawData | JsonType): Promise<void> {
let messageId: string;
let command: ProcedureName;
let requestPayload: RequestPayload | undefined;
responsePayload = await this.requestHandlers.get(command)(messageId, requestPayload);
} catch (error) {
// Log
- logger.error(
- `${this.uiServer.logPrefix(moduleName, 'messageHandler')} Handle request error:`,
- error
- );
+ logger.error(`${this.logPrefix(moduleName, 'messageHandler')} Handle request error:`, error);
responsePayload = {
status: ResponseStatus.FAILURE,
command,
if (responsePayload !== undefined) {
// Send the response
- this.uiServer.sendResponse(this.buildProtocolResponse(messageId ?? 'error', responsePayload));
+ this.sendResponse(messageId ?? 'error', responsePayload);
}
}
procedureName: ProcedureName,
requestPayload: RequestPayload
): void {
- this.uiServer.sendRequest(this.buildProtocolRequest(messageId, procedureName, requestPayload));
+ this.uiServer.sendRequest(
+ this.uiServer.buildProtocolRequest(messageId, procedureName, requestPayload)
+ );
}
public sendResponse(messageId: string, responsePayload: ResponsePayload): void {
- this.uiServer.sendResponse(this.buildProtocolResponse(messageId, responsePayload));
+ this.uiServer.sendResponse(this.uiServer.buildProtocolResponse(messageId, responsePayload));
}
public logPrefix(modName: string, methodName: string): string {
return this.uiServer.logPrefix(modName, methodName);
}
- private buildProtocolRequest(
- messageId: string,
- procedureName: ProcedureName,
- requestPayload: RequestPayload
- ): string {
- return JSON.stringify([messageId, procedureName, requestPayload] as ProtocolRequest);
- }
-
- private buildProtocolResponse(messageId: string, responsePayload: ResponsePayload): string {
- return JSON.stringify([messageId, responsePayload] as ProtocolResponse);
- }
-
- // Validate the raw data received from the WebSocket
- // TODO: should probably be moved to the ws verify clients callback
- private requestValidation(rawData: RawData): ProtocolRequest {
+ // Validate the raw data received from the UI server
+ private requestValidation(rawData: RawData | JsonType): ProtocolRequest {
// logger.debug(
- // `${this.uiServer.logPrefix(
+ // `${this.logPrefix(
// moduleName,
- // 'dataValidation'
- // )} Raw data received: ${rawData.toString()}`
+ // 'requestValidation'
+ // )} Data received in string format: ${rawData.toString()}`
// );
const data = JSON.parse(rawData.toString()) as JsonType[];
- if (Utils.isIterable(data) === false) {
- throw new BaseError('UI protocol request is not iterable');
+ if (Array.isArray(data) === false) {
+ throw new BaseError('UI protocol request is not an array');
}
if (data.length !== 3) {
// TODO: remove cast to unknown
return {
status: ResponseStatus.SUCCESS,
- ...Array.from(this.uiServer.chargingStations.values()),
+ ...[...this.uiServer.chargingStations.values()],
} as unknown as ResponsePayload;
}