// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
-import fs from 'node:fs';
-import path from 'node:path';
+import { createWriteStream, readdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
import { URL, fileURLToPath } from 'node:url';
import type { JSONSchemaType } from 'ajv';
import { Client, type FTPResponse } from 'basic-ftp';
-import tar from 'tar';
+import { create } from 'tar';
+import { OCPP16Constants } from './OCPP16Constants';
+import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
import {
type ChargingStation,
ChargingStationConfigurationUtils,
type JsonObject,
type JsonType,
OCPP16AuthorizationStatus,
- type OCPP16AuthorizeRequest,
- type OCPP16AuthorizeResponse,
OCPP16AvailabilityType,
type OCPP16BootNotificationRequest,
type OCPP16BootNotificationResponse,
+ type OCPP16CancelReservationRequest,
OCPP16ChargePointErrorCode,
OCPP16ChargePointStatus,
type OCPP16ChargingProfile,
type OCPP16ClearCacheRequest,
type OCPP16DataTransferRequest,
type OCPP16DataTransferResponse,
- OCPP16DataTransferStatus,
OCPP16DataTransferVendorId,
OCPP16DiagnosticsStatus,
type OCPP16DiagnosticsStatusNotificationRequest,
OCPP16IncomingRequestCommand,
OCPP16MessageTrigger,
OCPP16RequestCommand,
+ type OCPP16ReserveNowRequest,
+ type OCPP16ReserveNowResponse,
OCPP16StandardParametersKey,
type OCPP16StartTransactionRequest,
type OCPP16StartTransactionResponse,
OCPPVersion,
type RemoteStartTransactionRequest,
type RemoteStopTransactionRequest,
+ ReservationFilterKey,
+ ReservationTerminationReason,
type ResetRequest,
type SetChargingProfileRequest,
type SetChargingProfileResponse,
+ type StartTransactionRequest,
type UnlockConnectorRequest,
type UnlockConnectorResponse,
} from '../../../types';
import { Constants, Utils, logger } from '../../../utils';
-import { OCPP16Constants, OCPP16ServiceUtils, OCPPIncomingRequestService } from '../internal';
+import { OCPPIncomingRequestService } from '../OCPPIncomingRequestService';
const moduleName = 'OCPP16IncomingRequestService';
[OCPP16IncomingRequestCommand.TRIGGER_MESSAGE, this.handleRequestTriggerMessage.bind(this)],
[OCPP16IncomingRequestCommand.DATA_TRANSFER, this.handleRequestDataTransfer.bind(this)],
[OCPP16IncomingRequestCommand.UPDATE_FIRMWARE, this.handleRequestUpdateFirmware.bind(this)],
+ [OCPP16IncomingRequestCommand.RESERVE_NOW, this.handleRequestReserveNow.bind(this)],
+ [
+ OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
+ this.handleRequestCancelReservation.bind(this),
+ ],
]);
this.jsonSchemas = new Map<OCPP16IncomingRequestCommand, JSONSchemaType<JsonObject>>([
[
OCPP16IncomingRequestCommand.RESET,
OCPP16ServiceUtils.parseJsonSchemaFile<ResetRequest>(
- '../../../assets/json-schemas/ocpp/1.6/Reset.json',
+ 'assets/json-schemas/ocpp/1.6/Reset.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.CLEAR_CACHE,
OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ClearCacheRequest>(
- '../../../assets/json-schemas/ocpp/1.6/ClearCache.json',
+ 'assets/json-schemas/ocpp/1.6/ClearCache.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.UNLOCK_CONNECTOR,
OCPP16ServiceUtils.parseJsonSchemaFile<UnlockConnectorRequest>(
- '../../../assets/json-schemas/ocpp/1.6/UnlockConnector.json',
+ 'assets/json-schemas/ocpp/1.6/UnlockConnector.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.GET_CONFIGURATION,
OCPP16ServiceUtils.parseJsonSchemaFile<GetConfigurationRequest>(
- '../../../assets/json-schemas/ocpp/1.6/GetConfiguration.json',
+ 'assets/json-schemas/ocpp/1.6/GetConfiguration.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.CHANGE_CONFIGURATION,
OCPP16ServiceUtils.parseJsonSchemaFile<ChangeConfigurationRequest>(
- '../../../assets/json-schemas/ocpp/1.6/ChangeConfiguration.json',
+ 'assets/json-schemas/ocpp/1.6/ChangeConfiguration.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.GET_DIAGNOSTICS,
OCPP16ServiceUtils.parseJsonSchemaFile<GetDiagnosticsRequest>(
- '../../../assets/json-schemas/ocpp/1.6/GetDiagnostics.json',
+ 'assets/json-schemas/ocpp/1.6/GetDiagnostics.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.GET_COMPOSITE_SCHEDULE,
OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16GetCompositeScheduleRequest>(
- '../../../assets/json-schemas/ocpp/1.6/GetCompositeSchedule.json',
+ 'assets/json-schemas/ocpp/1.6/GetCompositeSchedule.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.SET_CHARGING_PROFILE,
OCPP16ServiceUtils.parseJsonSchemaFile<SetChargingProfileRequest>(
- '../../../assets/json-schemas/ocpp/1.6/SetChargingProfile.json',
+ 'assets/json-schemas/ocpp/1.6/SetChargingProfile.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.CLEAR_CHARGING_PROFILE,
OCPP16ServiceUtils.parseJsonSchemaFile<ClearChargingProfileRequest>(
- '../../../assets/json-schemas/ocpp/1.6/ClearChargingProfile.json',
+ 'assets/json-schemas/ocpp/1.6/ClearChargingProfile.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.CHANGE_AVAILABILITY,
OCPP16ServiceUtils.parseJsonSchemaFile<ChangeAvailabilityRequest>(
- '../../../assets/json-schemas/ocpp/1.6/ChangeAvailability.json',
+ 'assets/json-schemas/ocpp/1.6/ChangeAvailability.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION,
OCPP16ServiceUtils.parseJsonSchemaFile<RemoteStartTransactionRequest>(
- '../../../assets/json-schemas/ocpp/1.6/RemoteStartTransaction.json',
+ 'assets/json-schemas/ocpp/1.6/RemoteStartTransaction.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION,
OCPP16ServiceUtils.parseJsonSchemaFile<RemoteStopTransactionRequest>(
- '../../../assets/json-schemas/ocpp/1.6/RemoteStopTransaction.json',
+ 'assets/json-schemas/ocpp/1.6/RemoteStopTransaction.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.TRIGGER_MESSAGE,
OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16TriggerMessageRequest>(
- '../../../assets/json-schemas/ocpp/1.6/TriggerMessage.json',
+ 'assets/json-schemas/ocpp/1.6/TriggerMessage.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.DATA_TRANSFER,
OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16DataTransferRequest>(
- '../../../assets/json-schemas/ocpp/1.6/DataTransfer.json',
+ 'assets/json-schemas/ocpp/1.6/DataTransfer.json',
moduleName,
'constructor'
),
[
OCPP16IncomingRequestCommand.UPDATE_FIRMWARE,
OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16UpdateFirmwareRequest>(
- '../../../assets/json-schemas/ocpp/1.6/UpdateFirmware.json',
+ 'assets/json-schemas/ocpp/1.6/UpdateFirmware.json',
+ moduleName,
+ 'constructor'
+ ),
+ ],
+ [
+ OCPP16IncomingRequestCommand.RESERVE_NOW,
+ OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ReserveNowRequest>(
+ 'assets/json-schemas/ocpp/1.6/ReserveNow.json',
+ moduleName,
+ 'constructor'
+ ),
+ ],
+ [
+ OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
+ OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16CancelReservationRequest>(
+ 'assets/json-schemas/ocpp/1.6/CancelReservation.json',
moduleName,
'constructor'
),
let response: JsonType;
if (
chargingStation.getOcppStrictCompliance() === true &&
- chargingStation.isInPendingState() === true &&
+ chargingStation.inPendingState() === true &&
(commandName === OCPP16IncomingRequestCommand.REMOTE_START_TRANSACTION ||
commandName === OCPP16IncomingRequestCommand.REMOTE_STOP_TRANSACTION)
) {
if (
chargingStation.isRegistered() === true ||
(chargingStation.getOcppStrictCompliance() === false &&
- chargingStation.isInUnknownState() === true)
+ chargingStation.inUnknownState() === true)
) {
if (
this.incomingRequestHandlers.has(commandName) === true &&
} catch (error) {
// Log
logger.error(
- `${chargingStation.logPrefix()} ${moduleName}.incomingRequestHandler: Handle incoming request error:`,
+ `${chargingStation.logPrefix()} ${moduleName}.incomingRequestHandler:
+ Handle incoming request error:`,
error
);
throw error;
);
}
logger.warn(
- `${chargingStation.logPrefix()} ${moduleName}.validatePayload: No JSON schema found for command '${commandName}' PDU validation`
+ `${chargingStation.logPrefix()} ${moduleName}.validatePayload: No JSON schema found
+ for command '${commandName}' PDU validation`
);
return false;
}
logger.info(
`${chargingStation.logPrefix()} ${
commandPayload.type
- } reset command received, simulating it. The station will be back online in ${Utils.formatDurationMilliSeconds(
- chargingStation.stationInfo.resetTime
- )}`
+ } reset command received, simulating it. The station will be
+ back online in ${Utils.formatDurationMilliSeconds(chargingStation.stationInfo.resetTime)}`
);
return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
const connectorId = commandPayload.connectorId;
if (chargingStation.hasConnector(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 OCPP16Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
}
);
if (!keyToChange) {
return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
- } else if (keyToChange && keyToChange.readonly) {
+ } else if (keyToChange?.readonly === true) {
return OCPP16Constants.OCPP_CONFIGURATION_RESPONSE_REJECTED;
- } else if (keyToChange && !keyToChange.readonly) {
+ } else if (keyToChange?.readonly === false) {
let valueChanged = false;
if (keyToChange.value !== commandPayload.value) {
ChargingStationConfigurationUtils.setConfigurationKeyValue(
}
if (chargingStation.hasConnector(commandPayload.connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to set charging profile(s) to a non existing connector id ${
- commandPayload.connectorId
- }`
+ `${chargingStation.logPrefix()} Trying to set charging profile(s) to a
+ non existing connector id ${commandPayload.connectorId}`
);
return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
}
false)
) {
logger.error(
- `${chargingStation.logPrefix()} Trying to set transaction charging profile(s) on connector ${
- commandPayload.connectorId
- } without a started transaction`
+ `${chargingStation.logPrefix()} Trying to set transaction charging profile(s)
+ on connector ${commandPayload.connectorId} without a started transaction`
);
return OCPP16Constants.OCPP_SET_CHARGING_PROFILE_RESPONSE_REJECTED;
}
}
if (chargingStation.hasConnector(commandPayload.connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to get composite schedule to a non existing connector id ${
- commandPayload.connectorId
- }`
+ `${chargingStation.logPrefix()} Trying to get composite schedule to a
+ non existing connector id ${commandPayload.connectorId}`
);
return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
}
if (chargingStation.hasConnector(commandPayload.connectorId) === false) {
logger.error(
- `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to a non existing connector id ${
- commandPayload.connectorId
- }`
+ `${chargingStation.logPrefix()} Trying to clear a charging profile(s) to
+ a non existing connector id ${commandPayload.connectorId}`
);
return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
}
const connectorId: number = commandPayload.connectorId;
if (chargingStation.hasConnector(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 OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_REJECTED;
}
chargingStation: ChargingStation,
commandPayload: RemoteStartTransactionRequest
): Promise<GenericResponse> {
- const transactionConnectorId = commandPayload.connectorId;
- if (chargingStation.hasConnector(transactionConnectorId) === true) {
- const remoteStartTransactionLogMsg = `${chargingStation.logPrefix()} Transaction remotely STARTED on ${
- chargingStation.stationInfo.chargingStationId
- }#${transactionConnectorId.toString()} for idTag '${commandPayload.idTag}'`;
- await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ const { connectorId: transactionConnectorId, idTag, chargingProfile } = commandPayload;
+ const reserved =
+ chargingStation.getConnectorStatus(transactionConnectorId).status ===
+ OCPP16ChargePointStatus.Reserved;
+ const reservedOnConnectorZero =
+ chargingStation.getConnectorStatus(0).status === OCPP16ChargePointStatus.Reserved;
+ if (
+ (reserved &&
+ !chargingStation.validateIncomingRequestWithReservation(transactionConnectorId, idTag)) ||
+ (reservedOnConnectorZero && !chargingStation.validateIncomingRequestWithReservation(0, idTag))
+ ) {
+ return OCPP16Constants.OCPP_RESPONSE_REJECTED;
+ }
+ if (chargingStation.hasConnector(transactionConnectorId) === false) {
+ return this.notifyRemoteStartTransactionRejected(
+ chargingStation,
+ transactionConnectorId,
+ idTag
+ );
+ }
+ if (
+ !chargingStation.isChargingStationAvailable() ||
+ !chargingStation.isConnectorAvailable(transactionConnectorId)
+ ) {
+ return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- OCPP16ChargePointStatus.Preparing
+ idTag
);
- const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId);
+ }
+ const remoteStartTransactionLogMsg = `
+ ${chargingStation.logPrefix()} Transaction remotely STARTED on ${
+ chargingStation.stationInfo.chargingStationId
+ }#${transactionConnectorId.toString()} for idTag '${idTag}'`;
+ await OCPP16ServiceUtils.sendAndSetConnectorStatus(
+ chargingStation,
+ transactionConnectorId,
+ OCPP16ChargePointStatus.Preparing
+ );
+ const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId);
+ // Check if authorized
+ if (
+ chargingStation.getAuthorizeRemoteTxRequests() &&
+ (await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, transactionConnectorId, idTag))
+ ) {
+ // Authorization successful, start transaction
if (
- chargingStation.isChargingStationAvailable() === true &&
- chargingStation.isConnectorAvailable(transactionConnectorId) === true
+ this.setRemoteStartTransactionChargingProfile(
+ chargingStation,
+ transactionConnectorId,
+ chargingProfile
+ ) === true
) {
- // Check if authorized
- if (chargingStation.getAuthorizeRemoteTxRequests() === true) {
- let authorized = false;
- if (
- chargingStation.getLocalAuthListEnabled() === true &&
- chargingStation.hasIdTags() === true &&
- Utils.isNotEmptyString(
- chargingStation.idTagsCache
- .getIdTags(ChargingStationUtils.getIdTagsFile(chargingStation.stationInfo))
- ?.find((idTag) => idTag === commandPayload.idTag)
- )
- ) {
- connectorStatus.localAuthorizeIdTag = commandPayload.idTag;
- connectorStatus.idTagLocalAuthorized = true;
- authorized = true;
- } else if (chargingStation.getMustAuthorizeAtRemoteStart() === true) {
- connectorStatus.authorizeIdTag = commandPayload.idTag;
- const authorizeResponse: OCPP16AuthorizeResponse =
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16AuthorizeRequest,
- OCPP16AuthorizeResponse
- >(chargingStation, OCPP16RequestCommand.AUTHORIZE, {
- idTag: commandPayload.idTag,
- });
- if (authorizeResponse?.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
- authorized = true;
- }
- } else {
- logger.warn(
- `${chargingStation.logPrefix()} The charging station configuration expects authorize at remote start transaction but local authorization or authorize isn't enabled`
- );
- }
- if (authorized === true) {
- // Authorization successful, start transaction
- if (
- this.setRemoteStartTransactionChargingProfile(
- chargingStation,
- transactionConnectorId,
- commandPayload.chargingProfile
- ) === true
- ) {
- connectorStatus.transactionRemoteStarted = true;
- if (
- (
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StartTransactionRequest,
- OCPP16StartTransactionResponse
- >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
- connectorId: transactionConnectorId,
- idTag: commandPayload.idTag,
- })
- ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
- ) {
- logger.debug(remoteStartTransactionLogMsg);
- return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
- }
- return this.notifyRemoteStartTransactionRejected(
- chargingStation,
- transactionConnectorId,
- commandPayload.idTag
- );
- }
- return this.notifyRemoteStartTransactionRejected(
- chargingStation,
- transactionConnectorId,
- commandPayload.idTag
- );
- }
- return this.notifyRemoteStartTransactionRejected(
- chargingStation,
- transactionConnectorId,
- commandPayload.idTag
+ connectorStatus.transactionRemoteStarted = true;
+ const startTransactionPayload: Partial<StartTransactionRequest> = {
+ connectorId: transactionConnectorId,
+ idTag,
+ };
+ if (reserved || reservedOnConnectorZero) {
+ const reservation = chargingStation.getReservationBy(
+ ReservationFilterKey.CONNECTOR_ID,
+ reservedOnConnectorZero ? 0 : transactionConnectorId
+ );
+ startTransactionPayload.reservationId = reservation.id;
+ await chargingStation.removeReservation(
+ reservation,
+ ReservationTerminationReason.TRANSACTION_STARTED
);
}
- // No authorization check required, start transaction
if (
- this.setRemoteStartTransactionChargingProfile(
- chargingStation,
- transactionConnectorId,
- commandPayload.chargingProfile
- ) === true
+ (
+ await chargingStation.ocppRequestService.requestHandler<
+ OCPP16StartTransactionRequest,
+ OCPP16StartTransactionResponse
+ >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, startTransactionPayload)
+ ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
) {
- connectorStatus.transactionRemoteStarted = true;
- if (
- (
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StartTransactionRequest,
- OCPP16StartTransactionResponse
- >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
- connectorId: transactionConnectorId,
- idTag: commandPayload.idTag,
- })
- ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
- ) {
- logger.debug(remoteStartTransactionLogMsg);
- return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
- }
- return this.notifyRemoteStartTransactionRejected(
- chargingStation,
- transactionConnectorId,
- commandPayload.idTag
- );
+ logger.debug(remoteStartTransactionLogMsg);
+ return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- commandPayload.idTag
+ idTag
);
}
return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- commandPayload.idTag
+ idTag
+ );
+ }
+ // No authorization check required, start transaction
+ if (
+ this.setRemoteStartTransactionChargingProfile(
+ chargingStation,
+ transactionConnectorId,
+ chargingProfile
+ ) === true
+ ) {
+ connectorStatus.transactionRemoteStarted = true;
+ if (
+ (
+ await chargingStation.ocppRequestService.requestHandler<
+ OCPP16StartTransactionRequest,
+ OCPP16StartTransactionResponse
+ >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
+ connectorId: transactionConnectorId,
+ idTag,
+ })
+ ).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
+ ) {
+ logger.debug(remoteStartTransactionLogMsg);
+ return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
+ }
+ return this.notifyRemoteStartTransactionRejected(
+ chargingStation,
+ transactionConnectorId,
+ idTag
);
}
return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- commandPayload.idTag
+ idTag
);
}
);
}
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}'`
);
if (cp && cp.chargingProfilePurpose === OCPP16ChargingProfilePurposeType.TX_PROFILE) {
OCPP16ServiceUtils.setChargingProfile(chargingStation, connectorId, cp);
logger.debug(
- `${chargingStation.logPrefix()} Charging profile(s) set at remote start transaction on connector id ${connectorId}: %j`,
+ `${chargingStation.logPrefix()} Charging profile(s) set at remote start transaction
+ on connector id ${connectorId}: %j`,
cp
);
return true;
}
}
logger.warn(
- `${chargingStation.logPrefix()} Trying to remote stop a non existing transaction with id: ${transactionId.toString()}`
+ `${chargingStation.logPrefix()} Trying to remote stop a non existing transaction with id:
+ ${transactionId.toString()}`
);
return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
) === false
) {
logger.warn(
- `${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware: Cannot simulate firmware update: feature profile not supported`
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware:
+ Cannot simulate firmware update: feature profile not supported`
);
return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
chargingStation.stationInfo.firmwareStatus !== OCPP16FirmwareStatus.Installed
) {
logger.warn(
- `${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware: Cannot simulate firmware update: firmware update is already in progress`
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestUpdateFirmware:
+ Cannot simulate firmware update: firmware update is already in progress`
);
return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
).catch(Constants.EMPTY_FUNCTION);
} else {
setTimeout(() => {
- this.updateFirmwareSimulation(chargingStation).catch(Constants.EMPTY_FUNCTION);
+ this.runInAsyncScope(
+ this.updateFirmwareSimulation.bind(this) as (
+ this: OCPP16IncomingRequestService,
+ ...args: any[]
+ ) => Promise<void>,
+ this,
+ chargingStation
+ ).catch(Constants.EMPTY_FUNCTION);
}, retrieveDate?.getTime() - now);
}
return OCPP16Constants.OCPP_RESPONSE_EMPTY;
if (runningTransactions > 0) {
const waitTime = 15 * 1000;
logger.debug(
- `${chargingStation.logPrefix()} ${moduleName}.updateFirmwareSimulation: ${runningTransactions} transaction(s) in progress, waiting ${
+ `${chargingStation.logPrefix()} ${moduleName}.updateFirmwareSimulation:
+ ${runningTransactions} transaction(s) in progress, waiting ${
waitTime / 1000
} seconds before continuing firmware update simulation`
);
) === false
) {
logger.warn(
- `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: Cannot get diagnostics: feature profile not supported`
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics:
+ Cannot get diagnostics: feature profile not supported`
);
return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
if (uri.protocol.startsWith('ftp:')) {
let ftpClient: Client;
try {
- const logFiles = fs
- .readdirSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../'))
+ const logFiles = readdirSync(resolve(dirname(fileURLToPath(import.meta.url)), '../'))
.filter((file) => file.endsWith('.log'))
- .map((file) => path.join('./', file));
+ .map((file) => join('./', file));
const diagnosticsArchive = `${chargingStation.stationInfo.chargingStationId}_logs.tar.gz`;
- tar.create({ gzip: true }, logFiles).pipe(fs.createWriteStream(diagnosticsArchive));
+ create({ gzip: true }, logFiles).pipe(createWriteStream(diagnosticsArchive));
ftpClient = new Client();
const accessResponse = await ftpClient.access({
host: uri.host,
})
.catch((error) => {
logger.error(
- `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics: Error while sending '${
- OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION
- }'`,
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestGetDiagnostics:
+ Error while sending '${OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION}'`,
error
);
});
});
uploadResponse = await ftpClient.uploadFrom(
- path.join(
- path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../'),
- diagnosticsArchive
- ),
+ join(resolve(dirname(fileURLToPath(import.meta.url)), '../'), diagnosticsArchive),
`${uri.pathname}${diagnosticsArchive}`
);
if (uploadResponse.code === 226) {
): OCPP16DataTransferResponse {
try {
if (Object.values(OCPP16DataTransferVendorId).includes(commandPayload.vendorId)) {
- return {
- status: OCPP16DataTransferStatus.ACCEPTED,
- };
+ return OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_ACCEPTED;
}
- return {
- status: OCPP16DataTransferStatus.UNKNOWN_VENDOR_ID,
- };
+ return OCPP16Constants.OCPP_DATA_TRANSFER_RESPONSE_UNKNOWN_VENDOR_ID;
} catch (error) {
return this.handleIncomingRequestError(
chargingStation,
);
}
}
+
+ private async handleRequestReserveNow(
+ chargingStation: ChargingStation,
+ commandPayload: OCPP16ReserveNowRequest
+ ): Promise<OCPP16ReserveNowResponse> {
+ if (
+ !OCPP16ServiceUtils.checkFeatureProfile(
+ chargingStation,
+ OCPP16SupportedFeatureProfiles.Reservation,
+ OCPP16IncomingRequestCommand.RESERVE_NOW
+ )
+ ) {
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ }
+ const { reservationId, idTag, connectorId } = commandPayload;
+ let response: OCPP16ReserveNowResponse;
+ try {
+ if (!chargingStation.isConnectorAvailable(connectorId) && connectorId > 0) {
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ }
+ if (connectorId === 0 && !chargingStation.getReservationOnConnectorId0Enabled()) {
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ }
+ if (!(await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, connectorId, idTag))) {
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ }
+ switch (chargingStation.getConnectorStatus(connectorId).status) {
+ case OCPP16ChargePointStatus.Faulted:
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED;
+ break;
+ case OCPP16ChargePointStatus.Preparing:
+ case OCPP16ChargePointStatus.Charging:
+ case OCPP16ChargePointStatus.SuspendedEV:
+ case OCPP16ChargePointStatus.SuspendedEVSE:
+ case OCPP16ChargePointStatus.Finishing:
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
+ break;
+ case OCPP16ChargePointStatus.Unavailable:
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_UNAVAILABLE;
+ break;
+ case OCPP16ChargePointStatus.Reserved:
+ if (!chargingStation.isConnectorReservable(reservationId, idTag, connectorId)) {
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
+ break;
+ }
+ // eslint-disable-next-line no-fallthrough
+ default:
+ if (!chargingStation.isConnectorReservable(reservationId, idTag)) {
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
+ break;
+ }
+ await chargingStation.addReservation({
+ id: commandPayload.reservationId,
+ ...commandPayload,
+ });
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_ACCEPTED;
+ break;
+ }
+ return response;
+ } catch (error) {
+ chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.Available;
+ return this.handleIncomingRequestError(
+ chargingStation,
+ OCPP16IncomingRequestCommand.RESERVE_NOW,
+ error as Error,
+ { errorResponse: OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED }
+ );
+ }
+ }
+
+ private async handleRequestCancelReservation(
+ chargingStation: ChargingStation,
+ commandPayload: OCPP16CancelReservationRequest
+ ): Promise<GenericResponse> {
+ if (
+ !OCPP16ServiceUtils.checkFeatureProfile(
+ chargingStation,
+ OCPP16SupportedFeatureProfiles.Reservation,
+ OCPP16IncomingRequestCommand.CANCEL_RESERVATION
+ )
+ ) {
+ return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
+ }
+ try {
+ const { reservationId } = commandPayload;
+ const [exists, reservation] = chargingStation.doesReservationExists({ id: reservationId });
+ if (!exists) {
+ logger.error(
+ `${chargingStation.logPrefix()} Reservation with ID ${reservationId}
+ does not exist on charging station`
+ );
+ return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
+ }
+ await chargingStation.removeReservation(
+ reservation,
+ ReservationTerminationReason.RESERVATION_CANCELED
+ );
+ return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_ACCEPTED;
+ } catch (error) {
+ return this.handleIncomingRequestError(
+ chargingStation,
+ OCPP16IncomingRequestCommand.CANCEL_RESERVATION,
+ error as Error,
+ { errorResponse: OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED }
+ );
+ }
+ }
}
repositories / e-mobility-charging-stations-simulator.git / blobdiff