import {
ApplicationProtocol,
AuthenticationType,
- type ConfigurationData,
ProcedureName,
type ProtocolResponse,
type RequestPayload,
type ResponsePayload,
- ResponseStatus
+ ResponseStatus,
+ type UIServerConfigurationSection
} from '@/types'
type ResponseHandler = {
private ws!: WebSocket
private responseHandlers: Map<string, ResponseHandler>
- private constructor(private configuration: ConfigurationData) {
+ private constructor(private uiServerConfiguration: UIServerConfigurationSection) {
this.openWS()
this.responseHandlers = new Map<string, ResponseHandler>()
}
- public static getInstance(configuration: ConfigurationData) {
+ public static getInstance(uiServerConfiguration: UIServerConfigurationSection): UIClient {
if (UIClient.instance === null) {
- UIClient.instance = new UIClient(configuration)
+ UIClient.instance = new UIClient(uiServerConfiguration)
}
return UIClient.instance
}
- public registerWSonOpenListener(listener: (event: Event) => void) {
- this.ws.addEventListener('open', listener)
+ public registerWSEventListener<K extends keyof WebSocketEventMap>(
+ event: K,
+ listener: (event: WebSocketEventMap[K]) => void
+ ) {
+ this.ws.addEventListener(event, listener)
}
public async startSimulator(): Promise<ResponsePayload> {
return this.sendRequest(ProcedureName.STOP_SIMULATOR, {})
}
+ public async listTemplates(): Promise<ResponsePayload> {
+ return this.sendRequest(ProcedureName.LIST_TEMPLATES, {})
+ }
+
public async listChargingStations(): Promise<ResponsePayload> {
return this.sendRequest(ProcedureName.LIST_CHARGING_STATIONS, {})
}
+ public async addChargingStations(
+ template: string,
+ numberOfStations: number
+ ): Promise<ResponsePayload> {
+ return this.sendRequest(ProcedureName.ADD_CHARGING_STATIONS, { template, numberOfStations })
+ }
+
+ public async deleteChargingStation(hashId: string): Promise<ResponsePayload> {
+ return this.sendRequest(ProcedureName.DELETE_CHARGING_STATIONS, { hashIds: [hashId] })
+ }
+
+ public async setSupervisionUrl(hashId: string, supervisionUrl: string): Promise<ResponsePayload> {
+ return this.sendRequest(ProcedureName.SET_SUPERVISION_URL, {
+ hashIds: [hashId],
+ url: supervisionUrl
+ })
+ }
+
public async startChargingStation(hashId: string): Promise<ResponsePayload> {
return this.sendRequest(ProcedureName.START_CHARGING_STATION, { hashIds: [hashId] })
}
private openWS(): void {
const protocols =
- this.configuration.uiServer.authentication?.enabled === true &&
- this.configuration.uiServer.authentication?.type === AuthenticationType.PROTOCOL_BASIC_AUTH
+ this.uiServerConfiguration.authentication?.enabled === true &&
+ this.uiServerConfiguration.authentication?.type === AuthenticationType.PROTOCOL_BASIC_AUTH
? [
- `${this.configuration.uiServer.protocol}${this.configuration.uiServer.version}`,
- `authorization.basic.${btoa(`${this.configuration.uiServer.authentication.username}:${this.configuration.uiServer.authentication.password}`).replace(/={1,2}$/, '')}`
+ `${this.uiServerConfiguration.protocol}${this.uiServerConfiguration.version}`,
+ `authorization.basic.${btoa(`${this.uiServerConfiguration.authentication.username}:${this.uiServerConfiguration.authentication.password}`).replace(/={1,2}$/, '')}`
]
- : `${this.configuration.uiServer.protocol}${this.configuration.uiServer.version}`
+ : `${this.uiServerConfiguration.protocol}${this.uiServerConfiguration.version}`
this.ws = new WebSocket(
- `${this.configuration.uiServer.secure === true ? ApplicationProtocol.WSS : ApplicationProtocol.WS}://${this.configuration.uiServer.host}:${this.configuration.uiServer.port}`,
+ `${this.uiServerConfiguration.secure === true ? ApplicationProtocol.WSS : ApplicationProtocol.WS}://${this.uiServerConfiguration.host}:${this.uiServerConfiguration.port}`,
protocols
)
+ this.ws.onopen = openEvent => {
+ console.info('WebSocket opened', openEvent)
+ }
this.ws.onmessage = this.responseHandler.bind(this)
this.ws.onerror = errorEvent => {
console.error('WebSocket error: ', errorEvent)
payload: RequestPayload
): Promise<ResponsePayload> {
return new Promise<ResponsePayload>((resolve, reject) => {
- if (this.ws.readyState !== WebSocket.OPEN) {
- this.openWS()
- }
if (this.ws.readyState === WebSocket.OPEN) {
const uuid = crypto.randomUUID()
const msg = JSON.stringify([uuid, procedureName, payload])
const sendTimeout = setTimeout(() => {
this.responseHandlers.delete(uuid)
- return reject(new Error(`Send request '${procedureName}' message timeout`))
+ return reject(new Error(`Send request '${procedureName}' message: connection timeout`))
}, 60000)
try {
this.ws.send(msg)
clearTimeout(sendTimeout)
}
} else {
- throw new Error(`Send request '${procedureName}' message: connection not opened`)
+ reject(new Error(`Send request '${procedureName}' message: connection closed`))
}
})
}
reject(responsePayload)
break
default:
- console.error(
- `Response status for procedure '${procedureName}' not supported: '${responsePayload.status}'`
+ reject(
+ new Error(
+ `Response status for procedure '${procedureName}' not supported: '${responsePayload.status}'`
+ )
)
}
this.responseHandlers.delete(uuid)