// 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,
- ChargingStationUtils,
+ checkChargingStation,
} from '../../../charging-station';
import { OCPPError } from '../../../exception';
import {
type ClearChargingProfileRequest,
type ClearChargingProfileResponse,
type ConnectorStatus,
- ConnectorStatusEnum,
ErrorType,
type GenericResponse,
GenericStatus,
type OCPP16BootNotificationRequest,
type OCPP16BootNotificationResponse,
type OCPP16CancelReservationRequest,
- type OCPP16CancelReservationResponse,
OCPP16ChargePointErrorCode,
OCPP16ChargePointStatus,
type OCPP16ChargingProfile,
type OCPP16ClearCacheRequest,
type OCPP16DataTransferRequest,
type OCPP16DataTransferResponse,
- OCPP16DataTransferStatus,
OCPP16DataTransferVendorId,
OCPP16DiagnosticsStatus,
type OCPP16DiagnosticsStatusNotificationRequest,
type UnlockConnectorRequest,
type UnlockConnectorResponse,
} from '../../../types';
-import { Constants, Utils, logger } from '../../../utils';
-import { OCPPConstants } from '../OCPPConstants';
+import {
+ Constants,
+ convertToDate,
+ convertToInt,
+ formatDurationMilliSeconds,
+ getRandomInteger,
+ isEmptyArray,
+ isNotEmptyArray,
+ isNotEmptyString,
+ isNullOrUndefined,
+ isUndefined,
+ logger,
+ sleep,
+} from '../../../utils';
import { OCPPIncomingRequestService } from '../OCPPIncomingRequestService';
const moduleName = 'OCPP16IncomingRequestService';
`${chargingStation.logPrefix()} ${
commandPayload.type
} reset command received, simulating it. The station will be
- back online in ${Utils.formatDurationMilliSeconds(chargingStation.stationInfo.resetTime)}`
+ back online in ${formatDurationMilliSeconds(chargingStation.stationInfo.resetTime)}`
);
return OCPP16Constants.OCPP_RESPONSE_ACCEPTED;
}
): GetConfigurationResponse {
const configurationKey: OCPPConfigurationKey[] = [];
const unknownKey: string[] = [];
- if (Utils.isUndefined(commandPayload.key) === true) {
+ if (isUndefined(commandPayload.key) === true) {
for (const configuration of chargingStation.ocppConfiguration.configurationKey) {
- if (Utils.isUndefined(configuration.visible) === true) {
+ if (isUndefined(configuration.visible) === true) {
configuration.visible = true;
}
if (configuration.visible === false) {
value: configuration.value,
});
}
- } else if (Utils.isNotEmptyArray(commandPayload.key) === true) {
+ } else if (isNotEmptyArray(commandPayload.key) === true) {
for (const key of commandPayload.key) {
const keyFound = ChargingStationConfigurationUtils.getConfigurationKey(
chargingStation,
true
);
if (keyFound) {
- if (Utils.isUndefined(keyFound.visible) === true) {
+ if (isUndefined(keyFound.visible) === true) {
keyFound.visible = true;
}
if (keyFound.visible === false) {
return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
if (
- Utils.isEmptyArray(
- chargingStation.getConnectorStatus(commandPayload.connectorId)?.chargingProfiles
- )
+ isEmptyArray(chargingStation.getConnectorStatus(commandPayload.connectorId)?.chargingProfiles)
) {
return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_UNKNOWN;
}
if (
- !Utils.isNullOrUndefined(commandPayload.connectorId) &&
- Utils.isNotEmptyArray(
+ !isNullOrUndefined(commandPayload.connectorId) &&
+ isNotEmptyArray(
chargingStation.getConnectorStatus(commandPayload.connectorId)?.chargingProfiles
)
) {
);
return OCPP16Constants.OCPP_CLEAR_CHARGING_PROFILE_RESPONSE_ACCEPTED;
}
- if (Utils.isNullOrUndefined(commandPayload.connectorId)) {
+ if (isNullOrUndefined(commandPayload.connectorId)) {
let clearedCP = false;
const clearChargingProfiles = (connectorStatus: ConnectorStatus) => {
- if (Utils.isNotEmptyArray(connectorStatus?.chargingProfiles)) {
+ if (isNotEmptyArray(connectorStatus?.chargingProfiles)) {
connectorStatus?.chargingProfiles?.forEach(
(chargingProfile: OCPP16ChargingProfile, index: number) => {
let clearCurrentCP = false;
connectorStatus.transactionRemoteStarted = true;
const startTransactionPayload: Partial<StartTransactionRequest> = {
connectorId: transactionConnectorId,
- idTag: idTag,
+ idTag,
};
if (reserved || reservedOnConnectorZero) {
const reservation = chargingStation.getReservationBy(
return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
if (
- !Utils.isNullOrUndefined(chargingStation.stationInfo.firmwareStatus) &&
+ !isNullOrUndefined(chargingStation.stationInfo.firmwareStatus) &&
chargingStation.stationInfo.firmwareStatus !== OCPP16FirmwareStatus.Installed
) {
logger.warn(
);
return OCPP16Constants.OCPP_RESPONSE_EMPTY;
}
- const retrieveDate = Utils.convertToDate(commandPayload.retrieveDate);
+ const retrieveDate = convertToDate(commandPayload.retrieveDate);
const now = Date.now();
if (retrieveDate?.getTime() <= now) {
this.runInAsyncScope(
).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;
maxDelay = 30,
minDelay = 15
): Promise<void> {
- if (
- ChargingStationUtils.checkChargingStation(chargingStation, chargingStation.logPrefix()) ===
- false
- ) {
+ if (checkChargingStation(chargingStation, chargingStation.logPrefix()) === false) {
return;
}
if (chargingStation.hasEvses) {
chargingStation.stationInfo?.firmwareUpgrade?.failureStatus ===
OCPP16FirmwareStatus.DownloadFailed
) {
- await Utils.sleep(Utils.getRandomInteger(maxDelay, minDelay) * 1000);
+ await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
await chargingStation.ocppRequestService.requestHandler<
OCPP16FirmwareStatusNotificationRequest,
OCPP16FirmwareStatusNotificationResponse
chargingStation.stationInfo?.firmwareUpgrade?.failureStatus;
return;
}
- await Utils.sleep(Utils.getRandomInteger(maxDelay, minDelay) * 1000);
+ await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
await chargingStation.ocppRequestService.requestHandler<
OCPP16FirmwareStatusNotificationRequest,
OCPP16FirmwareStatusNotificationResponse
waitTime / 1000
} seconds before continuing firmware update simulation`
);
- await Utils.sleep(waitTime);
+ await sleep(waitTime);
transactionsStarted = true;
wasTransactionsStarted = true;
} else {
transactionsStarted = false;
}
} while (transactionsStarted);
- !wasTransactionsStarted &&
- (await Utils.sleep(Utils.getRandomInteger(maxDelay, minDelay) * 1000));
- if (
- ChargingStationUtils.checkChargingStation(chargingStation, chargingStation.logPrefix()) ===
- false
- ) {
+ !wasTransactionsStarted && (await sleep(getRandomInteger(maxDelay, minDelay) * 1000));
+ if (checkChargingStation(chargingStation, chargingStation.logPrefix()) === false) {
return;
}
await chargingStation.ocppRequestService.requestHandler<
chargingStation.stationInfo?.firmwareUpgrade?.failureStatus ===
OCPP16FirmwareStatus.InstallationFailed
) {
- await Utils.sleep(Utils.getRandomInteger(maxDelay, minDelay) * 1000);
+ await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
await chargingStation.ocppRequestService.requestHandler<
OCPP16FirmwareStatusNotificationRequest,
OCPP16FirmwareStatusNotificationResponse
return;
}
if (chargingStation.stationInfo?.firmwareUpgrade?.reset === true) {
- await Utils.sleep(Utils.getRandomInteger(maxDelay, minDelay) * 1000);
+ await sleep(getRandomInteger(maxDelay, minDelay) * 1000);
await chargingStation.reset(OCPP16StopTransactionReason.REBOOT);
}
}
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,
- ...(Utils.isNotEmptyString(uri.port) && { port: Utils.convertToInt(uri.port) }),
- ...(Utils.isNotEmptyString(uri.username) && { user: uri.username }),
- ...(Utils.isNotEmptyString(uri.password) && { password: uri.password }),
+ ...(isNotEmptyString(uri.port) && { port: convertToInt(uri.port) }),
+ ...(isNotEmptyString(uri.username) && { user: uri.username }),
+ ...(isNotEmptyString(uri.password) && { password: uri.password }),
});
let uploadResponse: FTPResponse;
if (accessResponse.code === 220) {
});
});
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) {
return OCPP16Constants.OCPP_TRIGGER_MESSAGE_RESPONSE_ACCEPTED;
case OCPP16MessageTrigger.StatusNotification:
setTimeout(() => {
- if (!Utils.isNullOrUndefined(commandPayload?.connectorId)) {
+ if (!isNullOrUndefined(commandPayload?.connectorId)) {
chargingStation.ocppRequestService
.requestHandler<OCPP16StatusNotificationRequest, OCPP16StatusNotificationResponse>(
chargingStation,
): 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,
OCPP16IncomingRequestCommand.RESERVE_NOW
)
) {
- return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
const { reservationId, idTag, connectorId } = commandPayload;
let response: OCPP16ReserveNowResponse;
try {
if (!chargingStation.isConnectorAvailable(connectorId) && connectorId > 0) {
- return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
if (connectorId === 0 && !chargingStation.getReservationOnConnectorId0Enabled()) {
- return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
if (!(await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, connectorId, idTag))) {
- return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
switch (chargingStation.getConnectorStatus(connectorId).status) {
- case ConnectorStatusEnum.Faulted:
- response = OCPPConstants.OCPP_RESERVATION_RESPONSE_FAULTED;
+ case OCPP16ChargePointStatus.Faulted:
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED;
break;
- case ConnectorStatusEnum.Occupied:
- response = OCPPConstants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
+ case OCPP16ChargePointStatus.Preparing:
+ case OCPP16ChargePointStatus.Charging:
+ case OCPP16ChargePointStatus.SuspendedEV:
+ case OCPP16ChargePointStatus.SuspendedEVSE:
+ case OCPP16ChargePointStatus.Finishing:
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
break;
- case ConnectorStatusEnum.Unavailable:
- response = OCPPConstants.OCPP_RESERVATION_RESPONSE_UNAVAILABLE;
+ case OCPP16ChargePointStatus.Unavailable:
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_UNAVAILABLE;
break;
- case ConnectorStatusEnum.Reserved:
+ case OCPP16ChargePointStatus.Reserved:
if (!chargingStation.isConnectorReservable(reservationId, idTag, connectorId)) {
- response = OCPPConstants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
break;
}
// eslint-disable-next-line no-fallthrough
default:
if (!chargingStation.isConnectorReservable(reservationId, idTag)) {
- response = OCPPConstants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
break;
}
await chargingStation.addReservation({
id: commandPayload.reservationId,
...commandPayload,
});
- response = OCPPConstants.OCPP_RESERVATION_RESPONSE_ACCEPTED;
+ response = OCPP16Constants.OCPP_RESERVATION_RESPONSE_ACCEPTED;
break;
}
return response;
} catch (error) {
- chargingStation.getConnectorStatus(connectorId).status = ConnectorStatusEnum.Available;
+ chargingStation.getConnectorStatus(connectorId).status = OCPP16ChargePointStatus.Available;
return this.handleIncomingRequestError(
chargingStation,
OCPP16IncomingRequestCommand.RESERVE_NOW,
error as Error,
- { errorResponse: OCPPConstants.OCPP_RESERVATION_RESPONSE_FAULTED }
+ { errorResponse: OCPP16Constants.OCPP_RESERVATION_RESPONSE_FAULTED }
);
}
}
private async handleRequestCancelReservation(
chargingStation: ChargingStation,
commandPayload: OCPP16CancelReservationRequest
- ): Promise<OCPP16CancelReservationResponse> {
+ ): Promise<GenericResponse> {
if (
!OCPP16ServiceUtils.checkFeatureProfile(
chargingStation,
OCPP16IncomingRequestCommand.CANCEL_RESERVATION
)
) {
- return OCPPConstants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
}
try {
const { reservationId } = commandPayload;
`${chargingStation.logPrefix()} Reservation with ID ${reservationId}
does not exist on charging station`
);
- return OCPPConstants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
+ return OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
}
- await chargingStation.removeReservation(reservation);
- return OCPPConstants.OCPP_CANCEL_RESERVATION_RESPONSE_ACCEPTED;
+ 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: OCPPConstants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED }
+ { errorResponse: OCPP16Constants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED }
);
}
}