type UnlockConnectorResponse,
} from '../../../types';
import { Constants, Utils, logger } from '../../../utils';
-import { OCPP16ServiceUtils, OCPPConstants, OCPPIncomingRequestService } from '../internal';
+import { OCPP16Constants, OCPP16ServiceUtils, OCPPIncomingRequestService } from '../internal';
const moduleName = 'OCPP16IncomingRequestService';
),
],
]);
- this.validatePayload.bind(this);
+ this.validatePayload = this.validatePayload.bind(this) as (
+ chargingStation: ChargingStation,
+ commandName: OCPP16IncomingRequestCommand,
+ commandPayload: JsonType
+ ) => boolean;
}
public async incomingRequestHandler(
chargingStation.stationInfo.resetTime
)}`
);
- return OCPPConstants.OCPP_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
private async handleRequestUnlockConnector(
const connectorId = commandPayload.connectorId;
if (chargingStation.connectors.has(connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to unlock a non existing connector Id ${connectorId.toString()}`
+ `${chargingStation.logPrefix()} Trying to unlock a non existing connector id ${connectorId.toString()}`
);
- return OCPPConstants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
+ return OCPP16Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
}
if (connectorId === 0) {
logger.error(
- `${chargingStation.logPrefix()} Trying to unlock connector Id ${connectorId.toString()}`
+ `${chargingStation.logPrefix()} Trying to unlock connector id ${connectorId.toString()}`
);
- return OCPPConstants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
+ return OCPP16Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
}
if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
const stopResponse = await chargingStation.stopTransactionOnConnector(
OCPP16StopTransactionReason.UNLOCK_COMMAND
);
if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
- return OCPPConstants.OCPP_RESPONSE_UNLOCKED;
+ return OCPP16Constants.OCPP_RESPONSE_UNLOCKED;
}
- return OCPPConstants.OCPP_RESPONSE_UNLOCK_FAILED;
+ return OCPP16Constants.OCPP_RESPONSE_UNLOCK_FAILED;
}
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
connectorId,
- status: OCPP16ChargePointStatus.Available,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.Available;
- return OCPPConstants.OCPP_RESPONSE_UNLOCKED;
+ OCPP16ChargePointStatus.Available
+ );
+ return OCPP16Constants.OCPP_RESPONSE_UNLOCKED;
}
private handleRequestGetConfiguration(
true
);
if (!keyToChange) {
- return OCPPConstants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
+ return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
} else if (keyToChange && keyToChange.readonly) {
- return OCPPConstants.OCPP_CONFIGURATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_REJECTED;
} else if (keyToChange && !keyToChange.readonly) {
let valueChanged = false;
if (keyToChange.value !== commandPayload.value) {
chargingStation.restartWebSocketPing();
}
if (keyToChange.reboot) {
- return OCPPConstants.OCPP_CONFIGURATION_RESPONSE_REBOOT_REQUIRED;
+ return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_REBOOT_REQUIRED;
}
- return OCPPConstants.OCPP_CONFIGURATION_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_ACCEPTED;
}
}
OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE
) === false
) {
- return OCPPConstants.OCPP_SET_CHARGING_PROFILE_RESPONSE_NOT_SUPPORTED;
+ return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_NOT_SUPPORTED;
}
if (chargingStation.connectors.has(commandPayload.connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to set charging profile(s) to a non existing connector Id ${
+ `${chargingStation.logPrefix()} Trying to set charging profile(s) to a non existing connector id ${
commandPayload.connectorId
}`
);
- return OCPPConstants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
}
if (
commandPayload.csChargingProfiles.chargingProfilePurpose ===
OCPP16ChargingProfilePurposeType.CHARGE_POINT_MAX_PROFILE &&
commandPayload.connectorId !== 0
) {
- return OCPPConstants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
}
if (
commandPayload.csChargingProfiles.chargingProfilePurpose ===
commandPayload.connectorId
} without a started transaction`
);
- return OCPPConstants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
}
OCPP16ServiceUtils.setChargingProfile(
chargingStation,
}: %j`,
commandPayload.csChargingProfiles
);
- return OCPPConstants.OCPP_SET_CHARGING_PROFILE_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_ACCEPTED;
}
private handleRequestGetCompositeSchedule(
OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE
) === false
) {
- return OCPPConstants.OCPP_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
if (chargingStation.connectors.has(commandPayload.connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to get composite schedule to a non existing connector Id ${
+ `${chargingStation.logPrefix()} Trying to get composite schedule to a non existing connector id ${
commandPayload.connectorId
}`
);
- return OCPPConstants.OCPP_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
if (
Utils.isEmptyArray(
chargingStation.getConnectorStatus(commandPayload.connectorId)?.chargingProfiles
)
) {
- return OCPPConstants.OCPP_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
const startDate = new Date();
const endDate = new Date(startDate.getTime() + commandPayload.duration * 1000);
OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE
) === false
) {
- return OCPPConstants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
+ return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
}
if (chargingStation.connectors.has(commandPayload.connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to a non existing connector Id ${
+ `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to a non existing connector id ${
commandPayload.connectorId
}`
);
- return OCPPConstants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
+ return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
}
const connectorStatus = chargingStation.getConnectorStatus(commandPayload.connectorId);
if (
commandPayload.connectorId
}`
);
- return OCPPConstants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
}
if (Utils.isNullOrUndefined(commandPayload.connectorId)) {
let clearedCP = false;
}
}
if (clearedCP) {
- return OCPPConstants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
}
}
- return OCPPConstants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
+ return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
}
private async handleRequestChangeAvailability(
const connectorId: number = commandPayload.connectorId;
if (chargingStation.connectors.has(connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to change the availability of a non existing connector Id ${connectorId.toString()}`
+ `${chargingStation.logPrefix()} Trying to change the availability of a non existing connector id ${connectorId.toString()}`
);
- return OCPPConstants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
}
const chargePointStatus: OCPP16ChargePointStatus =
- commandPayload.type === OCPP16AvailabilityType.OPERATIVE
+ commandPayload.type === OCPP16AvailabilityType.Operative
? OCPP16ChargePointStatus.Available
: OCPP16ChargePointStatus.Unavailable;
if (connectorId === 0) {
- let response: ChangeAvailabilityResponse = OCPPConstants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
+ let response: ChangeAvailabilityResponse =
+ OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
for (const id of chargingStation.connectors.keys()) {
if (chargingStation.getConnectorStatus(id)?.transactionStarted === true) {
- response = OCPPConstants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
+ response = OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
}
chargingStation.getConnectorStatus(id).availability = commandPayload.type;
- if (response === OCPPConstants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED) {
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
- connectorId: id,
- status: chargePointStatus,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(id).status = chargePointStatus;
+ if (response === OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED) {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
+ id,
+ chargePointStatus
+ );
}
}
return response;
connectorId > 0 &&
(chargingStation.isChargingStationAvailable() === true ||
(chargingStation.isChargingStationAvailable() === false &&
- commandPayload.type === OCPP16AvailabilityType.INOPERATIVE))
+ commandPayload.type === OCPP16AvailabilityType.Inoperative))
) {
if (chargingStation.getConnectorStatus(connectorId)?.transactionStarted === true) {
chargingStation.getConnectorStatus(connectorId).availability = commandPayload.type;
- return OCPPConstants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
+ return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED;
}
chargingStation.getConnectorStatus(connectorId).availability = commandPayload.type;
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
connectorId,
- status: chargePointStatus,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(connectorId).status = chargePointStatus;
- return OCPPConstants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
+ chargePointStatus
+ );
+ return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED;
}
- return OCPPConstants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
}
private async handleRequestRemoteStartTransaction(
const remoteStartTransactionLogMsg = `${chargingStation.logPrefix()} Transaction remotely STARTED on ${
chargingStation.stationInfo.chargingStationId
}#${transactionConnectorId.toString()} for idTag '${commandPayload.idTag}'`;
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
- connectorId: transactionConnectorId,
- status: OCPP16ChargePointStatus.Preparing,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
+ transactionConnectorId,
+ OCPP16ChargePointStatus.Preparing
+ );
const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId);
- connectorStatus.status = OCPP16ChargePointStatus.Preparing;
if (
chargingStation.isChargingStationAvailable() === true &&
chargingStation.isConnectorAvailable(transactionConnectorId) === true
).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
) {
logger.debug(remoteStartTransactionLogMsg);
- return OCPPConstants.OCPP_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
return this.notifyRemoteStartTransactionRejected(
chargingStation,
).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
) {
logger.debug(remoteStartTransactionLogMsg);
- return OCPPConstants.OCPP_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
return this.notifyRemoteStartTransactionRejected(
chargingStation,
if (
chargingStation.getConnectorStatus(connectorId)?.status !== OCPP16ChargePointStatus.Available
) {
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
connectorId,
- status: OCPP16ChargePointStatus.Available,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.Available;
+ OCPP16ChargePointStatus.Available
+ );
}
logger.warn(
- `${chargingStation.logPrefix()} Remote starting transaction REJECTED on connector Id ${connectorId.toString()}, idTag '${idTag}', availability '${
+ `${chargingStation.logPrefix()} Remote starting transaction REJECTED on connector id ${connectorId.toString()}, idTag '${idTag}', availability '${
chargingStation.getConnectorStatus(connectorId)?.availability
}', status '${chargingStation.getConnectorStatus(connectorId)?.status}'`
);
- return OCPPConstants.OCPP_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
private setRemoteStartTransactionChargingProfile(
connectorId > 0 &&
chargingStation.getConnectorStatus(connectorId)?.transactionId === transactionId
) {
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
connectorId,
- status: OCPP16ChargePointStatus.Finishing,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.Finishing;
+ OCPP16ChargePointStatus.Finishing
+ );
const stopResponse = await chargingStation.stopTransactionOnConnector(
connectorId,
OCPP16StopTransactionReason.REMOTE
);
if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
- return OCPPConstants.OCPP_RESPONSE_ACCEPTED;
+ return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
- return OCPPConstants.OCPP_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
}
logger.warn(
`${chargingStation.logPrefix()} Trying to remote stop a non existing transaction ${transactionId.toString()}`
);
- return OCPPConstants.OCPP_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
private handleRequestUpdateFirmware(
logger.warn(
`${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware: Cannot simulate firmware update: feature profile not supported`
);
- return OCPPConstants.OCPP_RESPONSE_EMPTY;
+ return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
if (
!Utils.isNullOrUndefined(chargingStation.stationInfo.firmwareStatus) &&
logger.warn(
`${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware: Cannot simulate firmware update: firmware update is already in progress`
);
- return OCPPConstants.OCPP_RESPONSE_EMPTY;
+ return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
const retrieveDate = Utils.convertToDate(commandPayload.retrieveDate);
const now = Date.now();
this.updateFirmwareSimulation(chargingStation).catch(Constants.EMPTY_FUNCTION);
}, retrieveDate?.getTime() - now);
}
- return OCPPConstants.OCPP_RESPONSE_EMPTY;
+ return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
private async updateFirmwareSimulation(
connectorId > 0 &&
chargingStation.getConnectorStatus(connectorId)?.transactionStarted === false
) {
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
connectorId,
- status: OCPP16ChargePointStatus.Unavailable,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(connectorId).status =
- OCPP16ChargePointStatus.Unavailable;
+ OCPP16ChargePointStatus.Unavailable
+ );
}
}
await chargingStation.ocppRequestService.requestHandler<
chargingStation.getConnectorStatus(connectorId)?.status !==
OCPP16ChargePointStatus.Unavailable
) {
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StatusNotificationRequest,
- OCPP16StatusNotificationResponse
- >(chargingStation, OCPP16RequestCommand.STATUS_NOTIFICATION, {
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
connectorId,
- status: OCPP16ChargePointStatus.Unavailable,
- errorCode: OCPP16ChargePointErrorCode.NO_ERROR,
- });
- chargingStation.getConnectorStatus(connectorId).status =
- OCPP16ChargePointStatus.Unavailable;
+ OCPP16ChargePointStatus.Unavailable
+ );
}
}
transactionsStarted = false;
logger.warn(
`${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: Cannot get diagnostics: feature profile not supported`
);
- return OCPPConstants.OCPP_RESPONSE_EMPTY;
+ return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
const uri = new URL(commandPayload.location);
if (uri.protocol.startsWith('ftp:')) {
chargingStation,
OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
error as Error,
- { errorResponse: OCPPConstants.OCPP_RESPONSE_EMPTY }
+ { errorResponse: OCPP16Constants.OCPP_RESPONSE_EMPTY }
);
}
} else {
>(chargingStation, OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION, {
status: OCPP16DiagnosticsStatus.UploadFailed,
});
- return OCPPConstants.OCPP_RESPONSE_EMPTY;
+ return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
}
commandPayload.requestedMessage
)
) {
- return OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
+ return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
}
if (
!OCPP16ServiceUtils.isConnectorIdValid(
commandPayload.connectorId
)
) {
- return OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED;
}
try {
switch (commandPayload.requestedMessage) {
chargingStation.bootNotificationResponse = response;
})
.catch(Constants.EMPTY_FUNCTION);
- }, Constants.OCPP_TRIGGER_MESSAGE_DELAY);
- return OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
+ }, OCPP16Constants.OCPP_TRIGGER_MESSAGE_DELAY);
+ return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
case OCPP16MessageTrigger.Heartbeat:
setTimeout(() => {
chargingStation.ocppRequestService
}
)
.catch(Constants.EMPTY_FUNCTION);
- }, Constants.OCPP_TRIGGER_MESSAGE_DELAY);
- return OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
+ }, OCPP16Constants.OCPP_TRIGGER_MESSAGE_DELAY);
+ return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
case OCPP16MessageTrigger.StatusNotification:
setTimeout(() => {
if (!Utils.isNullOrUndefined(commandPayload?.connectorId)) {
.catch(Constants.EMPTY_FUNCTION);
}
}
- }, Constants.OCPP_TRIGGER_MESSAGE_DELAY);
- return OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
+ }, OCPP16Constants.OCPP_TRIGGER_MESSAGE_DELAY);
+ return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
default:
- return OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
+ return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_NOT_IMPLEMENTED;
}
} catch (error) {
return this.handleIncomingRequestError(
chargingStation,
OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
error as Error,
- { errorResponse: OCPPConstants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED }
+ { errorResponse: OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_REJECTED }
);
}
}
chargingStation,
OCPP16IncomingRequestCommand.DATA_TRANSFER,
error as Error,
- { errorResponse: OCPPConstants.OCPP_DATA_TRANSFER_RESPONSE_REJECTED }
+ { errorResponse: OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_REJECTED }
);
}
}