import BaseError from '../exception/BaseError';
import type OCPPError from '../exception/OCPPError';
+import { StandardParametersKey } from '../types/ocpp/Configuration';
import {
- HeartbeatRequest,
+ type BootNotificationRequest,
+ type HeartbeatRequest,
+ type MeterValuesRequest,
RequestCommand,
type StatusNotificationRequest,
} from '../types/ocpp/Requests';
-import type { HeartbeatResponse, StatusNotificationResponse } from '../types/ocpp/Responses';
+import {
+ type BootNotificationResponse,
+ type HeartbeatResponse,
+ type MeterValuesResponse,
+ RegistrationStatus,
+ type StatusNotificationResponse,
+} from '../types/ocpp/Responses';
import {
AuthorizationStatus,
- AuthorizeRequest,
- AuthorizeResponse,
- StartTransactionRequest,
- StartTransactionResponse,
- StopTransactionRequest,
- StopTransactionResponse,
+ type AuthorizeRequest,
+ type AuthorizeResponse,
+ type StartTransactionRequest,
+ type StartTransactionResponse,
+ type StopTransactionRequest,
+ type StopTransactionResponse,
} from '../types/ocpp/Transaction';
import {
BroadcastChannelProcedureName,
- BroadcastChannelRequest,
- BroadcastChannelRequestPayload,
- BroadcastChannelResponsePayload,
- MessageEvent,
+ type BroadcastChannelRequest,
+ type BroadcastChannelRequestPayload,
+ type BroadcastChannelResponsePayload,
+ type MessageEvent,
} from '../types/WorkerBroadcastChannel';
import { ResponseStatus } from '../ui/web/src/types/UIProtocol';
+import Constants from '../utils/Constants';
import logger from '../utils/Logger';
import Utils from '../utils/Utils';
import type ChargingStation from './ChargingStation';
+import { ChargingStationConfigurationUtils } from './ChargingStationConfigurationUtils';
+import { OCPP16ServiceUtils } from './ocpp/1.6/OCPP16ServiceUtils';
import WorkerBroadcastChannel from './WorkerBroadcastChannel';
const moduleName = 'ChargingStationWorkerBroadcastChannel';
| StartTransactionResponse
| StopTransactionResponse
| AuthorizeResponse
+ | BootNotificationResponse
| StatusNotificationResponse
- | HeartbeatResponse;
+ | HeartbeatResponse
+ | MeterValuesResponse;
type CommandHandler = (
requestPayload?: BroadcastChannelRequestPayload
export default class ChargingStationWorkerBroadcastChannel extends WorkerBroadcastChannel {
private readonly commandHandlers: Map<BroadcastChannelProcedureName, CommandHandler>;
-
private readonly chargingStation: ChargingStation;
constructor(chargingStation: ChargingStation) {
StopTransactionRequest,
StartTransactionResponse
>(this.chargingStation, RequestCommand.STOP_TRANSACTION, {
- ...requestPayload,
meterStop: this.chargingStation.getEnergyActiveImportRegisterByTransactionId(
requestPayload.transactionId,
true
),
+ ...requestPayload,
}),
],
[
AuthorizeResponse
>(this.chargingStation, RequestCommand.AUTHORIZE, requestPayload),
],
+ [
+ BroadcastChannelProcedureName.BOOT_NOTIFICATION,
+ async (requestPayload?: BroadcastChannelRequestPayload) => {
+ this.chargingStation.bootNotificationResponse =
+ await this.chargingStation.ocppRequestService.requestHandler<
+ BootNotificationRequest,
+ BootNotificationResponse
+ >(
+ this.chargingStation,
+ RequestCommand.BOOT_NOTIFICATION,
+ {
+ ...this.chargingStation.bootNotificationRequest,
+ ...requestPayload,
+ },
+ {
+ skipBufferingOnError: true,
+ }
+ );
+ return this.chargingStation.bootNotificationResponse;
+ },
+ ],
[
BroadcastChannelProcedureName.STATUS_NOTIFICATION,
async (requestPayload?: BroadcastChannelRequestPayload) =>
HeartbeatResponse
>(this.chargingStation, RequestCommand.HEARTBEAT, requestPayload),
],
+ [
+ BroadcastChannelProcedureName.METER_VALUES,
+ async (requestPayload?: BroadcastChannelRequestPayload) => {
+ const configuredMeterValueSampleInterval =
+ ChargingStationConfigurationUtils.getConfigurationKey(
+ chargingStation,
+ StandardParametersKey.MeterValueSampleInterval
+ );
+ return this.chargingStation.ocppRequestService.requestHandler<
+ MeterValuesRequest,
+ MeterValuesResponse
+ >(this.chargingStation, RequestCommand.METER_VALUES, {
+ meterValue: [
+ OCPP16ServiceUtils.buildMeterValue(
+ this.chargingStation,
+ requestPayload.connectorId,
+ this.chargingStation.getConnectorStatus(requestPayload.connectorId)?.transactionId,
+ configuredMeterValueSampleInterval
+ ? Utils.convertToInt(configuredMeterValueSampleInterval.value) * 1000
+ : Constants.DEFAULT_METER_VALUES_INTERVAL
+ ),
+ ],
+ ...requestPayload,
+ });
+ },
+ ],
]);
this.chargingStation = chargingStation;
this.onmessage = this.requestHandler.bind(this) as (message: MessageEvent) => void;
return;
}
const [uuid, command, requestPayload] = validatedMessageEvent.data as BroadcastChannelRequest;
-
if (
requestPayload?.hashIds !== undefined &&
requestPayload?.hashIds?.includes(this.chargingStation.stationInfo.hashId) === false
status: ResponseStatus.SUCCESS,
};
} else {
- const commandResponseStatus = this.commandResponseToResponseStatus(
+ responsePayload = this.commandResponseToResponsePayload(
command,
+ requestPayload,
commandResponse as CommandResponse
);
- if (commandResponseStatus === ResponseStatus.SUCCESS) {
- responsePayload = {
- hashId: this.chargingStation.stationInfo.hashId,
- status: commandResponseStatus,
- };
- } else {
- responsePayload = {
- hashId: this.chargingStation.stationInfo.hashId,
- status: commandResponseStatus,
- command,
- requestPayload,
- commandResponse: commandResponse as CommandResponse,
- };
- }
}
} catch (error) {
logger.error(
private messageErrorHandler(messageEvent: MessageEvent): void {
logger.error(
`${this.chargingStation.logPrefix()} ${moduleName}.messageErrorHandler: Error at handling message:`,
- { messageEvent }
+ messageEvent
);
}
].includes(command) === false && delete requestPayload.connectorIds;
}
+ private commandResponseToResponsePayload(
+ command: BroadcastChannelProcedureName,
+ requestPayload: BroadcastChannelRequestPayload,
+ commandResponse: CommandResponse
+ ): BroadcastChannelResponsePayload {
+ const responseStatus = this.commandResponseToResponseStatus(command, commandResponse);
+ if (responseStatus === ResponseStatus.SUCCESS) {
+ return {
+ hashId: this.chargingStation.stationInfo.hashId,
+ status: responseStatus,
+ };
+ }
+ return {
+ hashId: this.chargingStation.stationInfo.hashId,
+ status: responseStatus,
+ command,
+ requestPayload,
+ commandResponse,
+ };
+ }
+
private commandResponseToResponseStatus(
command: BroadcastChannelProcedureName,
commandResponse: CommandResponse
return ResponseStatus.SUCCESS;
}
return ResponseStatus.FAILURE;
+ case BroadcastChannelProcedureName.BOOT_NOTIFICATION:
+ if (commandResponse?.status === RegistrationStatus.ACCEPTED) {
+ return ResponseStatus.SUCCESS;
+ }
+ return ResponseStatus.FAILURE;
case BroadcastChannelProcedureName.STATUS_NOTIFICATION:
+ case BroadcastChannelProcedureName.METER_VALUES:
if (Utils.isEmptyObject(commandResponse) === true) {
return ResponseStatus.SUCCESS;
}