PowerUnits,
RegistrationStatusEnumType,
RequestCommand,
+ type Reservation,
+ ReservationFilterKey,
+ ReservationTerminationReason,
type Response,
StandardParametersKey,
+ type Status,
type StatusNotificationRequest,
type StatusNotificationResponse,
StopTransactionReason,
Configuration,
Constants,
DCElectricUtils,
- ErrorUtils,
- FileUtils,
- MessageChannelUtils,
Utils,
buildChargingStationAutomaticTransactionGeneratorConfiguration,
buildConnectorsStatus,
buildEvsesStatus,
+ buildStartedMessage,
+ buildStoppedMessage,
+ buildUpdatedMessage,
+ handleFileException,
logger,
+ watchJsonFile,
} from '../utils';
export class ChargingStation {
private readonly sharedLRUCache: SharedLRUCache;
private webSocketPingSetInterval!: NodeJS.Timeout;
private readonly chargingStationWorkerBroadcastChannel: ChargingStationWorkerBroadcastChannel;
+ private reservationExpirationSetInterval?: NodeJS.Timeout;
constructor(index: number, templateFile: string) {
this.started = false;
);
} else {
logger.error(
- `${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval()}, not starting the heartbeat`
+ `${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval()},
+ not starting the heartbeat`
);
}
}
}
if (!this.getConnectorStatus(connectorId)) {
logger.error(
- `${this.logPrefix()} Trying to start MeterValues on non existing connector id ${connectorId.toString()}`
+ `${this.logPrefix()} Trying to start MeterValues on non existing connector id
+ ${connectorId.toString()}`
);
return;
}
if (this.getConnectorStatus(connectorId)?.transactionStarted === false) {
logger.error(
- `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId} with no transaction started`
+ `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId}
+ with no transaction started`
);
return;
} else if (
Utils.isNullOrUndefined(this.getConnectorStatus(connectorId)?.transactionId)
) {
logger.error(
- `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId} with no transaction id`
+ `${this.logPrefix()} Trying to start MeterValues on connector id ${connectorId}
+ with no transaction id`
);
return;
}
if (this.getEnableStatistics() === true) {
this.performanceStatistics?.start();
}
+ if (this.hasFeatureProfile(SupportedFeatureProfiles.Reservation)) {
+ this.startReservationExpirationSetInterval();
+ }
this.openWSConnection();
// Monitor charging station template file
- this.templateFileWatcher = FileUtils.watchJsonFile(
+ this.templateFileWatcher = watchJsonFile(
this.templateFile,
FileType.ChargingStationTemplate,
this.logPrefix(),
}
);
this.started = true;
- parentPort?.postMessage(MessageChannelUtils.buildStartedMessage(this));
+ parentPort?.postMessage(buildStartedMessage(this));
this.starting = false;
} else {
logger.warn(`${this.logPrefix()} Charging station is already starting...`);
delete this.bootNotificationResponse;
this.started = false;
this.saveConfiguration();
- parentPort?.postMessage(MessageChannelUtils.buildStoppedMessage(this));
+ parentPort?.postMessage(buildStoppedMessage(this));
this.stopping = false;
} else {
logger.warn(`${this.logPrefix()} Charging station is already stopping...`);
terminateOpened: false,
}
): void {
- options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
+ options = { handshakeTimeout: this.getConnectionTimeout() * 1000, ...options };
params = { ...{ closeOpened: false, terminateOpened: false }, ...params };
if (this.started === false && this.starting === false) {
logger.warn(
- `${this.logPrefix()} Cannot open OCPP connection to URL ${this.wsConnectionUrl.toString()} on stopped charging station`
+ `${this.logPrefix()} Cannot open OCPP connection to URL ${this.wsConnectionUrl.toString()}
+ on stopped charging station`
);
return;
}
if (this.isWebSocketConnectionOpened() === true) {
logger.warn(
- `${this.logPrefix()} OCPP connection to URL ${this.wsConnectionUrl.toString()} is already opened`
+ `${this.logPrefix()} OCPP connection to URL ${this.wsConnectionUrl.toString()}
+ is already opened`
);
return;
}
public getAutomaticTransactionGeneratorConfiguration():
| AutomaticTransactionGeneratorConfiguration
| undefined {
+ let automaticTransactionGeneratorConfiguration:
+ | AutomaticTransactionGeneratorConfiguration
+ | undefined;
const automaticTransactionGeneratorConfigurationFromFile =
this.getConfigurationFromFile()?.automaticTransactionGenerator;
- if (automaticTransactionGeneratorConfigurationFromFile) {
- return automaticTransactionGeneratorConfigurationFromFile;
+ if (
+ this.getAutomaticTransactionGeneratorPersistentConfiguration() &&
+ automaticTransactionGeneratorConfigurationFromFile
+ ) {
+ automaticTransactionGeneratorConfiguration =
+ automaticTransactionGeneratorConfigurationFromFile;
+ } else {
+ automaticTransactionGeneratorConfiguration =
+ this.getTemplateFromFile()?.AutomaticTransactionGenerator;
}
- return this.getTemplateFromFile()?.AutomaticTransactionGenerator;
+ return {
+ ...Constants.DEFAULT_ATG_CONFIGURATION,
+ ...automaticTransactionGeneratorConfiguration,
+ };
+ }
+
+ public getAutomaticTransactionGeneratorStatuses(): Status[] | undefined {
+ return this.getConfigurationFromFile()?.automaticTransactionGeneratorStatuses;
}
public startAutomaticTransactionGenerator(connectorIds?: number[]): void {
} else {
this.automaticTransactionGenerator?.start();
}
- this.saveChargingStationAutomaticTransactionGeneratorConfiguration();
- parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(this));
+ this.saveAutomaticTransactionGeneratorConfiguration();
+ parentPort?.postMessage(buildUpdatedMessage(this));
}
public stopAutomaticTransactionGenerator(connectorIds?: number[]): void {
} else {
this.automaticTransactionGenerator?.stop();
}
- this.saveChargingStationAutomaticTransactionGeneratorConfiguration();
- parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(this));
+ this.saveAutomaticTransactionGeneratorConfiguration();
+ parentPort?.postMessage(buildUpdatedMessage(this));
}
public async stopTransactionOnConnector(
);
}
+ public getReservationOnConnectorId0Enabled(): boolean {
+ return Utils.convertToBoolean(
+ ChargingStationConfigurationUtils.getConfigurationKey(
+ this,
+ StandardParametersKey.ReserveConnectorZeroSupported
+ ).value
+ );
+ }
+
+ public async addReservation(reservation: Reservation): Promise<void> {
+ const [exists, reservationFound] = this.doesReservationExists(reservation);
+ if (exists) {
+ await this.removeReservation(reservationFound, ReservationTerminationReason.REPLACE_EXISTING);
+ }
+ this.getConnectorStatus(reservation.connectorId).reservation = reservation;
+ await OCPPServiceUtils.sendAndSetConnectorStatus(
+ this,
+ reservation.connectorId,
+ ConnectorStatusEnum.Reserved,
+ null,
+ { send: reservation.connectorId !== 0 }
+ );
+ }
+
+ public async removeReservation(
+ reservation: Reservation,
+ reason?: ReservationTerminationReason
+ ): Promise<void> {
+ const connector = this.getConnectorStatus(reservation.connectorId);
+ switch (reason) {
+ case ReservationTerminationReason.CONNECTOR_STATE_CHANGED:
+ delete connector.reservation;
+ break;
+ case ReservationTerminationReason.TRANSACTION_STARTED:
+ delete connector.reservation;
+ break;
+ case ReservationTerminationReason.RESERVATION_CANCELED ||
+ ReservationTerminationReason.REPLACE_EXISTING ||
+ ReservationTerminationReason.EXPIRED:
+ await OCPPServiceUtils.sendAndSetConnectorStatus(
+ this,
+ reservation.connectorId,
+ ConnectorStatusEnum.Available,
+ null,
+ { send: reservation.connectorId !== 0 }
+ );
+ delete connector.reservation;
+ break;
+ default:
+ break;
+ }
+ }
+
+ public getReservationBy(filterKey: ReservationFilterKey, value: number | string): Reservation {
+ if (this.hasEvses) {
+ for (const evse of this.evses.values()) {
+ for (const connector of evse.connectors.values()) {
+ if (connector?.reservation?.[filterKey] === value) {
+ return connector.reservation;
+ }
+ }
+ }
+ } else {
+ for (const connector of this.connectors.values()) {
+ if (connector?.reservation?.[filterKey] === value) {
+ return connector.reservation;
+ }
+ }
+ }
+ }
+
+ public doesReservationExists(reservation: Partial<Reservation>): [boolean, Reservation] {
+ const foundReservation = this.getReservationBy(
+ ReservationFilterKey.RESERVATION_ID,
+ reservation?.id
+ );
+ return Utils.isUndefined(foundReservation) ? [false, null] : [true, foundReservation];
+ }
+
+ public startReservationExpirationSetInterval(customInterval?: number): void {
+ const interval =
+ customInterval ?? Constants.DEFAULT_RESERVATION_EXPIRATION_OBSERVATION_INTERVAL;
+ logger.info(
+ `${this.logPrefix()} Reservation expiration date interval is set to ${interval}
+ and starts on charging station now`
+ );
+ // eslint-disable-next-line @typescript-eslint/no-misused-promises
+ this.reservationExpirationSetInterval = setInterval(async (): Promise<void> => {
+ if (this.hasEvses) {
+ for (const evse of this.evses.values()) {
+ for (const connector of evse.connectors.values()) {
+ if (connector?.reservation?.expiryDate.toString() < new Date().toISOString()) {
+ await this.removeReservation(
+ connector.reservation,
+ ReservationTerminationReason.EXPIRED
+ );
+ }
+ }
+ }
+ } else {
+ for (const connector of this.connectors.values()) {
+ if (connector?.reservation?.expiryDate.toString() < new Date().toISOString()) {
+ await this.removeReservation(
+ connector.reservation,
+ ReservationTerminationReason.EXPIRED
+ );
+ }
+ }
+ }
+ }, interval);
+ }
+
+ public restartReservationExpiryDateSetInterval(): void {
+ this.stopReservationExpirationSetInterval();
+ this.startReservationExpirationSetInterval();
+ }
+
+ public validateIncomingRequestWithReservation(connectorId: number, idTag: string): boolean {
+ const reservation = this.getReservationBy(ReservationFilterKey.CONNECTOR_ID, connectorId);
+ return !Utils.isUndefined(reservation) && reservation.idTag === idTag;
+ }
+
+ public isConnectorReservable(
+ reservationId: number,
+ idTag?: string,
+ connectorId?: number
+ ): boolean {
+ const [alreadyExists] = this.doesReservationExists({ id: reservationId });
+ if (alreadyExists) {
+ return alreadyExists;
+ }
+ const userReservedAlready = Utils.isUndefined(
+ this.getReservationBy(ReservationFilterKey.ID_TAG, idTag)
+ )
+ ? false
+ : true;
+ const notConnectorZero = Utils.isUndefined(connectorId) ? true : connectorId > 0;
+ const freeConnectorsAvailable = this.getNumberOfReservableConnectors() > 0;
+ return !alreadyExists && !userReservedAlready && notConnectorZero && freeConnectorsAvailable;
+ }
+
+ private getNumberOfReservableConnectors(): number {
+ let reservableConnectors = 0;
+ if (this.hasEvses) {
+ for (const evse of this.evses.values()) {
+ reservableConnectors = this.countReservableConnectors(evse.connectors);
+ }
+ } else {
+ reservableConnectors = this.countReservableConnectors(this.connectors);
+ }
+ return reservableConnectors - this.getNumberOfReservationsOnConnectorZero();
+ }
+
+ private countReservableConnectors(connectors: Map<number, ConnectorStatus>) {
+ let reservableConnectors = 0;
+ for (const [connectorId, connector] of connectors) {
+ if (connectorId === 0) {
+ continue;
+ }
+ if (connector.status === ConnectorStatusEnum.Available) {
+ ++reservableConnectors;
+ }
+ }
+ return reservableConnectors;
+ }
+
+ private getNumberOfReservationsOnConnectorZero(): number {
+ let numberOfReservations = 0;
+ if (this.hasEvses) {
+ for (const evse of this.evses.values()) {
+ if (evse.connectors.get(0)?.reservation) {
+ ++numberOfReservations;
+ }
+ }
+ } else if (this.connectors.get(0)?.reservation) {
+ ++numberOfReservations;
+ }
+ return numberOfReservations;
+ }
+
private flushMessageBuffer(): void {
if (this.messageBuffer.size > 0) {
for (const message of this.messageBuffer.values()) {
return this.stationInfo.supervisionUrlOcppConfiguration ?? false;
}
+ private stopReservationExpirationSetInterval(): void {
+ if (this.reservationExpirationSetInterval) {
+ clearInterval(this.reservationExpirationSetInterval);
+ }
+ }
+
private getSupervisionUrlOcppKey(): string {
return this.stationInfo.supervisionUrlOcppKey ?? VendorParametersKey.ConnectionUrl;
}
this.templateFileHash = template.templateHash;
}
} catch (error) {
- ErrorUtils.handleFileException(
+ handleFileException(
this.templateFile,
FileType.ChargingStationTemplate,
error as NodeJS.ErrnoException,
return this.stationInfo?.stationInfoPersistentConfiguration ?? true;
}
+ private getAutomaticTransactionGeneratorPersistentConfiguration(): boolean {
+ return this.stationInfo?.automaticTransactionGeneratorPersistentConfiguration ?? true;
+ }
+
private handleUnsupportedVersion(version: OCPPVersion) {
- const errorMsg = `Unsupported protocol version '${version}' configured in template file ${this.templateFile}`;
+ const errorMsg = `Unsupported protocol version '${version}' configured
+ in template file ${this.templateFile}`;
logger.error(`${this.logPrefix()} ${errorMsg}`);
throw new BaseError(errorMsg);
}
`${ChargingStationUtils.getHashId(this.index, stationTemplate)}.json`
);
const chargingStationConfiguration = this.getConfigurationFromFile();
- const featureFlag = false;
if (
- featureFlag &&
+ chargingStationConfiguration?.stationInfo?.templateHash === stationTemplate?.templateHash &&
(chargingStationConfiguration?.connectorsStatus || chargingStationConfiguration?.evsesStatus)
) {
this.initializeConnectorsOrEvsesFromFile(chargingStationConfiguration);
if (stationTemplate?.Evses) {
const evsesConfigHash = crypto
.createHash(Constants.DEFAULT_HASH_ALGORITHM)
- .update(`${JSON.stringify(stationTemplate?.Evses)}`)
+ .update(JSON.stringify(stationTemplate?.Evses))
.digest('hex');
const evsesConfigChanged =
this.evses?.size !== 0 && this.evsesConfigurationHash !== evsesConfigHash;
this.configurationFileHash = configuration.configurationHash;
}
} catch (error) {
- ErrorUtils.handleFileException(
+ handleFileException(
this.configurationFile,
FileType.ChargingStationConfiguration,
error as NodeJS.ErrnoException,
return configuration;
}
- private saveChargingStationAutomaticTransactionGeneratorConfiguration(): void {
- this.saveConfiguration();
+ private saveAutomaticTransactionGeneratorConfiguration(): void {
+ if (this.getAutomaticTransactionGeneratorPersistentConfiguration()) {
+ this.saveConfiguration();
+ }
}
private saveConnectorsStatus() {
Utils.cloneObject<ChargingStationConfiguration>(this.getConfigurationFromFile()) ?? {};
if (this.getStationInfoPersistentConfiguration() && this.stationInfo) {
configurationData.stationInfo = this.stationInfo;
+ } else {
+ delete configurationData.stationInfo;
}
if (this.getOcppPersistentConfiguration() && this.ocppConfiguration?.configurationKey) {
configurationData.configurationKey = this.ocppConfiguration.configurationKey;
+ } else {
+ delete configurationData.configurationKey;
}
configurationData = merge<ChargingStationConfiguration>(
configurationData,
buildChargingStationAutomaticTransactionGeneratorConfiguration(this)
);
+ if (
+ !this.getAutomaticTransactionGeneratorPersistentConfiguration() ||
+ !this.getAutomaticTransactionGeneratorConfiguration()
+ ) {
+ delete configurationData.automaticTransactionGenerator;
+ }
if (this.connectors.size > 0) {
configurationData.connectorsStatus = buildConnectorsStatus(this);
+ } else {
+ delete configurationData.connectorsStatus;
}
if (this.evses.size > 0) {
configurationData.evsesStatus = buildEvsesStatus(this);
+ } else {
+ delete configurationData.evsesStatus;
}
delete configurationData.configurationHash;
const configurationHash = crypto
.createHash(Constants.DEFAULT_HASH_ALGORITHM)
- .update(JSON.stringify(configurationData))
+ .update(
+ JSON.stringify({
+ stationInfo: configurationData.stationInfo,
+ configurationKey: configurationData.configurationKey,
+ automaticTransactionGenerator: configurationData.automaticTransactionGenerator,
+ } as ChargingStationConfiguration)
+ )
.digest('hex');
if (this.configurationFileHash !== configurationHash) {
AsyncLock.acquire(AsyncLockType.configuration)
this.configurationFileHash = configurationHash;
})
.catch((error) => {
- ErrorUtils.handleFileException(
+ handleFileException(
this.configurationFile,
FileType.ChargingStationConfiguration,
error as NodeJS.ErrnoException,
);
}
} catch (error) {
- ErrorUtils.handleFileException(
+ handleFileException(
this.configurationFile,
FileType.ChargingStationConfiguration,
error as NodeJS.ErrnoException,
skipBufferingOnError: true,
});
if (this.isRegistered() === false) {
- this.getRegistrationMaxRetries() !== -1 && registrationRetryCount++;
+ this.getRegistrationMaxRetries() !== -1 && ++registrationRetryCount;
await Utils.sleep(
this?.bootNotificationResponse?.interval
? this.bootNotificationResponse.interval * 1000
}
this.wsConnectionRestarted = false;
this.autoReconnectRetryCount = 0;
- parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(this));
+ parentPort?.postMessage(buildUpdatedMessage(this));
} else {
logger.warn(
`${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} failed`
this.started === true && (await this.reconnect());
break;
}
- parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(this));
+ parentPort?.postMessage(buildUpdatedMessage(this));
}
private getCachedRequest(messageType: MessageType, messageId: string): CachedRequest | undefined {
logger.error(`${this.logPrefix()} ${errorMsg}`);
throw new OCPPError(ErrorType.PROTOCOL_ERROR, errorMsg);
}
- parentPort?.postMessage(MessageChannelUtils.buildUpdatedMessage(this));
+ parentPort?.postMessage(buildUpdatedMessage(this));
} else {
throw new OCPPError(ErrorType.PROTOCOL_ERROR, 'Incoming message is not an array', null, {
request,
this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() ||
this.getAutoReconnectMaxRetries() === -1
) {
- this.autoReconnectRetryCount++;
+ ++this.autoReconnectRetryCount;
const reconnectDelay = this.getReconnectExponentialDelay()
? Utils.exponentialDelay(this.autoReconnectRetryCount)
: this.getConnectionTimeout() * 1000;
repositories / e-mobility-charging-stations-simulator.git / blobdiff