repositories
/
e-mobility-charging-stations-simulator.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
refactor: refine prettier configuration
[e-mobility-charging-stations-simulator.git]
/
src
/
charging-station
/
ui-server
/
UIHttpServer.ts
diff --git
a/src/charging-station/ui-server/UIHttpServer.ts
b/src/charging-station/ui-server/UIHttpServer.ts
index 85dbccdfe6ca5f79c10e360391f3b358f7aef871..eb3550830682f45cff76aff8559df71b34e855f5 100644
(file)
--- a/
src/charging-station/ui-server/UIHttpServer.ts
+++ b/
src/charging-station/ui-server/UIHttpServer.ts
@@
-1,10
+1,10
@@
-import type { IncomingMessage, RequestListener, ServerResponse } from 'node:http'
;
+import type { IncomingMessage, RequestListener, ServerResponse } from 'node:http'
-import { StatusCodes } from 'http-status-codes'
;
+import { StatusCodes } from 'http-status-codes'
-import { AbstractUIServer } from './AbstractUIServer
';
-import { UIServerUtils } from './UIServerUtils
';
-import { BaseError } from '../../exception
';
+import { AbstractUIServer } from './AbstractUIServer
.js'
+import { UIServerUtils } from './UIServerUtils
.js'
+import { BaseError } from '../../exception
/index.js'
import {
ApplicationProtocolVersion,
type ProcedureName,
import {
ApplicationProtocolVersion,
type ProcedureName,
@@
-14,155
+14,142
@@
import {
type ProtocolVersion,
type RequestPayload,
ResponseStatus,
type ProtocolVersion,
type RequestPayload,
ResponseStatus,
- type UIServerConfiguration,
-} from '../../types';
-import {
- Constants,
- generateUUID,
- isNotEmptyString,
- isNullOrUndefined,
- logPrefix,
- logger,
-} from '../../utils';
+ type UIServerConfiguration
+} from '../../types/index.js'
+import { Constants, generateUUID, isNotEmptyString, logPrefix, logger } from '../../utils/index.js'
-const moduleName = 'UIHttpServer'
;
+const moduleName = 'UIHttpServer'
enum HttpMethods {
GET = 'GET',
PUT = 'PUT',
POST = 'POST',
enum HttpMethods {
GET = 'GET',
PUT = 'PUT',
POST = 'POST',
- PATCH = 'PATCH'
,
+ PATCH = 'PATCH'
}
export class UIHttpServer extends AbstractUIServer {
}
export class UIHttpServer extends AbstractUIServer {
- public constructor(protected readonly uiServerConfiguration: UIServerConfiguration) {
- super(uiServerConfiguration)
;
+ public constructor
(protected readonly uiServerConfiguration: UIServerConfiguration) {
+ super(uiServerConfiguration)
}
}
- public start(): void {
- this.httpServer.on('request', this.requestListener.bind(this) as RequestListener)
;
- this.startHttpServer()
;
+ public start
(): void {
+ this.httpServer.on('request', this.requestListener.bind(this) as RequestListener)
+ this.startHttpServer()
}
}
- public sendRequest(request: ProtocolRequest): void {
+ public sendRequest
(request: ProtocolRequest): void {
switch (this.uiServerConfiguration.version) {
case ApplicationProtocolVersion.VERSION_20:
switch (this.uiServerConfiguration.version) {
case ApplicationProtocolVersion.VERSION_20:
- this.httpServer.emit('request', request)
;
- break
;
+ this.httpServer.emit('request', request)
+ break
}
}
}
}
- public sendResponse(response: ProtocolResponse): void {
- const [uuid, payload] = response
;
+ public sendResponse
(response: ProtocolResponse): void {
+ const [uuid, payload] = response
try {
try {
- if (this.hasResponseHandler(uuid)
=== true
) {
- const res = this.responseHandlers.get(uuid) as ServerResponse
;
+ if (this.hasResponseHandler(uuid)) {
+ const res = this.responseHandlers.get(uuid) as ServerResponse
res
.writeHead(this.responseStatusToStatusCode(payload.status), {
res
.writeHead(this.responseStatusToStatusCode(payload.status), {
- 'Content-Type': 'application/json'
,
+ 'Content-Type': 'application/json'
})
})
- .end(JSON.stringify(payload))
;
+ .end(JSON.stringify(payload))
} else {
logger.error(
} else {
logger.error(
- `${this.logPrefix(moduleName, 'sendResponse')} Response for unknown request id: ${uuid}`
,
- )
;
+ `${this.logPrefix(moduleName, 'sendResponse')} Response for unknown request id: ${uuid}`
+ )
}
} catch (error) {
logger.error(
`${this.logPrefix(moduleName, 'sendResponse')} Error at sending response id '${uuid}':`,
}
} catch (error) {
logger.error(
`${this.logPrefix(moduleName, 'sendResponse')} Error at sending response id '${uuid}':`,
- error
,
- )
;
+ error
+ )
} finally {
} finally {
- this.responseHandlers.delete(uuid)
;
+ this.responseHandlers.delete(uuid)
}
}
public logPrefix = (modName?: string, methodName?: string, prefixSuffix?: string): string => {
}
}
public logPrefix = (modName?: string, methodName?: string, prefixSuffix?: string): string => {
- const logMsgPrefix = prefixSuffix
? `UI HTTP Server ${prefixSuffix}` : 'UI HTTP Server';
+ const logMsgPrefix = prefixSuffix
!= null ? `UI HTTP Server ${prefixSuffix}` : 'UI HTTP Server'
const logMsg =
isNotEmptyString(modName) && isNotEmptyString(methodName)
? ` ${logMsgPrefix} | ${modName}.${methodName}:`
const logMsg =
isNotEmptyString(modName) && isNotEmptyString(methodName)
? ` ${logMsgPrefix} | ${modName}.${methodName}:`
- : ` ${logMsgPrefix} |`
;
- return logPrefix(logMsg)
;
- }
;
+ : ` ${logMsgPrefix} |`
+ return logPrefix(logMsg)
+ }
- private requestListener(req: IncomingMessage, res: ServerResponse): void {
- this.authenticate(req,
(err)
=> {
- if (err) {
+ private requestListener
(req: IncomingMessage, res: ServerResponse): void {
+ this.authenticate(req,
err
=> {
+ if (err
!= null
) {
res
.writeHead(StatusCodes.UNAUTHORIZED, {
'Content-Type': 'text/plain',
res
.writeHead(StatusCodes.UNAUTHORIZED, {
'Content-Type': 'text/plain',
- 'WWW-Authenticate': 'Basic realm=users'
,
+ 'WWW-Authenticate': 'Basic realm=users'
})
.end(`${StatusCodes.UNAUTHORIZED} Unauthorized`)
})
.end(`${StatusCodes.UNAUTHORIZED} Unauthorized`)
- .destroy()
;
- req.destroy()
;
+ .destroy()
+ req.destroy()
}
}
- })
;
+ })
// Expected request URL pathname: /ui/:version/:procedureName
const [protocol, version, procedureName] = req.url?.split('/').slice(1) as [
Protocol,
ProtocolVersion,
// Expected request URL pathname: /ui/:version/:procedureName
const [protocol, version, procedureName] = req.url?.split('/').slice(1) as [
Protocol,
ProtocolVersion,
- ProcedureName
,
- ]
;
- const uuid = generateUUID()
;
- this.responseHandlers.set(uuid, res)
;
+ ProcedureName
+ ]
+ const uuid = generateUUID()
+ this.responseHandlers.set(uuid, res)
try {
try {
- const fullProtocol = `${protocol}${version}`
;
- if (
UIServerUtils.isProtocolAndVersionSupported(fullProtocol) === false
) {
- throw new BaseError(`Unsupported UI protocol version: '${fullProtocol}'`)
;
+ const fullProtocol = `${protocol}${version}`
+ if (
!UIServerUtils.isProtocolAndVersionSupported(fullProtocol)
) {
+ throw new BaseError(`Unsupported UI protocol version: '${fullProtocol}'`)
}
}
- this.registerProtocolVersionUIService(version)
;
- req.on('error',
(error)
=> {
+ this.registerProtocolVersionUIService(version)
+ req.on('error',
error
=> {
logger.error(
`${this.logPrefix(moduleName, 'requestListener.req.onerror')} Error on HTTP request:`,
logger.error(
`${this.logPrefix(moduleName, 'requestListener.req.onerror')} Error on HTTP request:`,
- error
,
- )
;
- })
;
+ error
+ )
+ })
if (req.method === HttpMethods.POST) {
if (req.method === HttpMethods.POST) {
- const bodyBuffer: Uint8Array[] = []
;
+ const bodyBuffer: Uint8Array[] = []
req
.on('data', (chunk: Uint8Array) => {
req
.on('data', (chunk: Uint8Array) => {
- bodyBuffer.push(chunk)
;
+ bodyBuffer.push(chunk)
})
.on('end', () => {
})
.on('end', () => {
- const body = JSON.parse(Buffer.concat(bodyBuffer).toString()) as RequestPayload
;
+ const body = JSON.parse(Buffer.concat(bodyBuffer).toString()) as RequestPayload
this.uiServices
.get(version)
this.uiServices
.get(version)
- ?.requestHandler(
- this.buildProtocolRequest(
- uuid,
- procedureName,
- body ?? Constants.EMPTY_FROZEN_OBJECT,
- ),
- )
+ ?.requestHandler(this.buildProtocolRequest(uuid, procedureName, body))
.then((protocolResponse?: ProtocolResponse) => {
.then((protocolResponse?: ProtocolResponse) => {
- if (
!isNullOrUndefined(protocolResponse)
) {
- this.sendResponse(protocolResponse
!);
+ if (
protocolResponse != null
) {
+ this.sendResponse(protocolResponse
)
}
})
}
})
- .catch(Constants.EMPTY_FUNCTION)
;
- })
;
+ .catch(Constants.EMPTY_FUNCTION)
+ })
} else {
} else {
- throw new BaseError(`Unsupported HTTP method: '${req.method}'`)
;
+ throw new BaseError(`Unsupported HTTP method: '${req.method}'`)
}
} catch (error) {
logger.error(
`${this.logPrefix(moduleName, 'requestListener')} Handle HTTP request error:`,
}
} catch (error) {
logger.error(
`${this.logPrefix(moduleName, 'requestListener')} Handle HTTP request error:`,
- error
,
- )
;
- this.sendResponse(this.buildProtocolResponse(uuid, { status: ResponseStatus.FAILURE }))
;
+ error
+ )
+ this.sendResponse(this.buildProtocolResponse(uuid, { status: ResponseStatus.FAILURE }))
}
}
}
}
- private responseStatusToStatusCode(status: ResponseStatus): StatusCodes {
+ private responseStatusToStatusCode
(status: ResponseStatus): StatusCodes {
switch (status) {
case ResponseStatus.SUCCESS:
switch (status) {
case ResponseStatus.SUCCESS:
- return StatusCodes.OK
;
+ return StatusCodes.OK
case ResponseStatus.FAILURE:
case ResponseStatus.FAILURE:
- return StatusCodes.BAD_REQUEST
;
+ return StatusCodes.BAD_REQUEST
default:
default:
- return StatusCodes.INTERNAL_SERVER_ERROR
;
+ return StatusCodes.INTERNAL_SERVER_ERROR
}
}
}
}
}
}