import {
BroadcastChannelProcedureName,
type BroadcastChannelRequestPayload,
+ type ChargingStationInfo,
type ChargingStationOptions,
ConfigurationSection,
+ type JsonObject,
type JsonType,
ProcedureName,
type ProtocolRequest,
const moduleName = 'AbstractUIService'
+interface AddChargingStationsRequestPayload extends RequestPayload {
+ template: string
+ numberOfStations: number
+ options?: ChargingStationOptions
+}
+
export abstract class AbstractUIService {
protected static readonly ProcedureNameToBroadCastChannelProcedureNameMapping = new Map<
ProcedureName,
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
[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 {
}
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(
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const requestHandler = this.requestHandlers.get(command)!
if (isAsyncFunction(requestHandler)) {
- responsePayload = await requestHandler(messageId, command, requestPayload)
+ responsePayload = await requestHandler(uuid, command, requestPayload)
} else {
responsePayload = (
requestHandler as (
procedureName?: ProcedureName,
payload?: RequestPayload
) => undefined | ResponsePayload
- )(messageId, command, requestPayload)
+ )(uuid, command, requestPayload)
}
} catch (error) {
// Log
}
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))
}
}
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 {
}
private sendBroadcastChannelRequest (
- uuid: string,
+ uuid: `${string}-${string}-${string}-${string}-${string}`,
procedureName: BroadcastChannelProcedureName,
payload: BroadcastChannelRequestPayload
): void {
}
private async handleAddChargingStations (
- _messageId?: string,
+ _uuid?: `${string}-${string}-${string}-${string}-${string}`,
_procedureName?: ProcedureName,
requestPayload?: RequestPayload
): Promise<ResponsePayload> {
- const { template, numberOfStations, options } = requestPayload as {
- template: string
- numberOfStations: number
- options?: ChargingStationOptions
- }
+ const { template, numberOfStations, options } =
+ requestPayload as AddChargingStationsRequestPayload
if (!Bootstrap.getInstance().getState().started) {
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 {
- await Bootstrap.getInstance().addChargingStation(
+ stationInfo = await Bootstrap.getInstance().addChargingStation(
Bootstrap.getInstance().getLastIndex(template) + 1,
`${template}.json`,
options
)
+ if (stationInfo != null) {
+ succeededStationInfos.push(stationInfo)
+ }
} catch (error) {
- return {
- status: ResponseStatus.FAILURE,
- errorMessage: (error as Error).message,
- errorStack: (error as Error).stack
- } satisfies ResponsePayload
+ err = error as Error
+ if (stationInfo != null) {
+ failedStationInfos.push(stationInfo)
+ }
}
}
return {
- status: ResponseStatus.SUCCESS
- }
+ status: err != null ? ResponseStatus.FAILURE : ResponseStatus.SUCCESS,
+ ...(succeededStationInfos.length > 0 && {
+ 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 {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
...Bootstrap.getInstance().getPerformanceStatistics()!
] as JsonType[]
- }
+ } satisfies ResponsePayload
} catch (error) {
return {
status: ResponseStatus.FAILURE,
try {
return {
status: ResponseStatus.SUCCESS,
- state: Bootstrap.getInstance().getState()
+ state: Bootstrap.getInstance().getState() as unknown as JsonObject
} satisfies ResponsePayload
} catch (error) {
return {