deleteConfigurationKey,
getConfigurationKey,
setConfigurationKeyValue,
-} from './ChargingStationConfigurationUtils';
+} from './ConfigurationKeyUtils';
import {
buildConnectorsMap,
checkConnectorsConfiguration,
checkStationInfoConnectorStatus,
checkTemplate,
- countReservableConnectors,
createBootNotificationRequest,
createSerialNumber,
getAmperageLimitationUnitDivider,
getHashId,
getIdTagsFile,
getMaxNumberOfEvses,
+ getNumberOfReservableConnectors,
getPhaseRotationValue,
+ hasFeatureProfile,
+ hasReservationExpired,
initializeConnectorsMapStatus,
propagateSerialNumber,
+ removeExpiredReservations,
stationTemplateToStationInfo,
warnTemplateKeysDeprecation,
-} from './ChargingStationUtils';
+} from './Helpers';
import { IdTagsCache } from './IdTagsCache';
import {
OCPP16IncomingRequestService,
RegistrationStatusEnumType,
RequestCommand,
type Reservation,
- ReservationFilterKey,
+ type ReservationKey,
ReservationTerminationReason,
type Response,
StandardParametersKey,
return this.stationInfo.enableStatistics ?? false;
}
- public getMustAuthorizeAtRemoteStart(): boolean {
- return this.stationInfo.mustAuthorizeAtRemoteStart ?? true;
+ public getRemoteAuthorization(): boolean {
+ return this.stationInfo.remoteAuthorization ?? true;
}
public getNumberOfPhases(stationInfo?: ChargingStationInfo): number {
if (this.getEnableStatistics() === true) {
this.performanceStatistics?.start();
}
- if (this.hasFeatureProfile(SupportedFeatureProfiles.Reservation)) {
+ if (hasFeatureProfile(this, SupportedFeatureProfiles.Reservation)) {
this.startReservationExpirationSetInterval();
}
this.openWSConnection();
if (this.getEnableStatistics() === true) {
this.performanceStatistics?.stop();
}
- if (this.hasFeatureProfile(SupportedFeatureProfiles.Reservation)) {
+ if (hasFeatureProfile(this, SupportedFeatureProfiles.Reservation)) {
this.stopReservationExpirationSetInterval();
}
this.sharedLRUCache.deleteChargingStationConfiguration(this.configurationFileHash);
}
}
- public hasFeatureProfile(featureProfile: SupportedFeatureProfiles): boolean | undefined {
- return getConfigurationKey(
- this,
- StandardParametersKey.SupportedFeatureProfiles,
- )?.value?.includes(featureProfile);
- }
-
public bufferMessage(message: string): void {
this.messageBuffer.add(message);
}
);
}
- public getReservationOnConnectorId0Enabled(): boolean {
+ public getReserveConnectorZeroSupported(): boolean {
return convertToBoolean(
getConfigurationKey(this, StandardParametersKey.ReserveConnectorZeroSupported)!.value,
);
}
public async addReservation(reservation: Reservation): Promise<void> {
- const [exists, reservationFound] = this.doesReservationExists(reservation);
- if (exists) {
+ const reservationFound = this.getReservationBy('reservationId', reservation.reservationId);
+ if (!isUndefined(reservationFound)) {
await this.removeReservation(
reservationFound!,
ReservationTerminationReason.REPLACE_EXISTING,
public async removeReservation(
reservation: Reservation,
- reason?: ReservationTerminationReason,
+ 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;
delete connector.reservation;
break;
default:
- break;
+ // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+ throw new BaseError(`Unknown reservation termination reason '${reason}'`);
}
}
public getReservationBy(
- filterKey: ReservationFilterKey,
+ filterKey: ReservationKey,
value: number | string,
): Reservation | undefined {
if (this.hasEvses) {
for (const evseStatus of this.evses.values()) {
for (const connectorStatus of evseStatus.connectors.values()) {
- if (connectorStatus?.reservation?.[filterKey as keyof Reservation] === value) {
+ if (connectorStatus?.reservation?.[filterKey] === value) {
return connectorStatus.reservation;
}
}
}
} else {
for (const connectorStatus of this.connectors.values()) {
- if (connectorStatus?.reservation?.[filterKey as keyof Reservation] === value) {
+ if (connectorStatus?.reservation?.[filterKey] === value) {
return connectorStatus.reservation;
}
}
}
}
- public doesReservationExists(
- reservation: Partial<Reservation>,
- ): [boolean, Reservation | undefined] {
- const foundReservation = this.getReservationBy(
- ReservationFilterKey.RESERVATION_ID,
- reservation.id!,
- );
- return isUndefined(foundReservation) ? [false, undefined] : [true, foundReservation];
+ public isConnectorReservable(
+ reservationId: number,
+ idTag?: string,
+ connectorId?: number,
+ ): boolean {
+ const reservation = this.getReservationBy('reservationId', reservationId);
+ const reservationExists = !isUndefined(reservation) && !hasReservationExpired(reservation!);
+ if (arguments.length === 1) {
+ return !reservationExists;
+ } else if (arguments.length > 1) {
+ const userReservation = !isUndefined(idTag)
+ ? this.getReservationBy('idTag', idTag!)
+ : undefined;
+ const userReservationExists =
+ !isUndefined(userReservation) && !hasReservationExpired(userReservation!);
+ const notConnectorZero = isUndefined(connectorId) ? true : connectorId! > 0;
+ const freeConnectorsAvailable = this.getNumberOfReservableConnectors() > 0;
+ return (
+ !reservationExists && !userReservationExists && notConnectorZero && freeConnectorsAvailable
+ );
+ }
+ return false;
}
- public startReservationExpirationSetInterval(customInterval?: number): void {
+ private startReservationExpirationSetInterval(customInterval?: number): void {
const interval =
customInterval ?? Constants.DEFAULT_RESERVATION_EXPIRATION_OBSERVATION_INTERVAL;
if (interval > 0) {
)}`,
);
this.reservationExpirationSetInterval = setInterval((): void => {
- const currentDate = new Date();
- if (this.hasEvses) {
- for (const evseStatus of this.evses.values()) {
- for (const connectorStatus of evseStatus.connectors.values()) {
- if (
- connectorStatus.reservation &&
- connectorStatus.reservation.expiryDate < currentDate
- ) {
- this.removeReservation(
- connectorStatus.reservation,
- ReservationTerminationReason.EXPIRED,
- ).catch(Constants.EMPTY_FUNCTION);
- }
- }
- }
- } else {
- for (const connectorStatus of this.connectors.values()) {
- if (
- connectorStatus.reservation &&
- connectorStatus.reservation.expiryDate < currentDate
- ) {
- this.removeReservation(
- connectorStatus.reservation,
- ReservationTerminationReason.EXPIRED,
- ).catch(Constants.EMPTY_FUNCTION);
- }
- }
- }
+ removeExpiredReservations(this).catch(Constants.EMPTY_FUNCTION);
}, interval);
}
}
- public restartReservationExpiryDateSetInterval(): void {
- this.stopReservationExpirationSetInterval();
- this.startReservationExpirationSetInterval();
- }
-
- public validateIncomingRequestWithReservation(connectorId: number, idTag: string): boolean {
- return this.getReservationBy(ReservationFilterKey.CONNECTOR_ID, connectorId)?.idTag === idTag;
- }
-
- public isConnectorReservable(
- reservationId: number,
- idTag?: string,
- connectorId?: number,
- ): boolean {
- const [alreadyExists] = this.doesReservationExists({ id: reservationId });
- if (alreadyExists) {
- return alreadyExists;
+ private stopReservationExpirationSetInterval(): void {
+ if (this.reservationExpirationSetInterval) {
+ clearInterval(this.reservationExpirationSetInterval);
}
- const userReservedAlready = isUndefined(
- this.getReservationBy(ReservationFilterKey.ID_TAG, idTag!),
- )
- ? false
- : true;
- const notConnectorZero = isUndefined(connectorId) ? true : connectorId! > 0;
- const freeConnectorsAvailable = this.getNumberOfReservableConnectors() > 0;
- return !alreadyExists && !userReservedAlready && notConnectorZero && freeConnectorsAvailable;
}
+ // private restartReservationExpiryDateSetInterval(): void {
+ // this.stopReservationExpirationSetInterval();
+ // this.startReservationExpirationSetInterval();
+ // }
+
private getNumberOfReservableConnectors(): number {
- let reservableConnectors = 0;
+ let numberOfReservableConnectors = 0;
if (this.hasEvses) {
for (const evseStatus of this.evses.values()) {
- reservableConnectors += countReservableConnectors(evseStatus.connectors);
+ numberOfReservableConnectors += getNumberOfReservableConnectors(evseStatus.connectors);
}
} else {
- reservableConnectors = countReservableConnectors(this.connectors);
+ numberOfReservableConnectors = getNumberOfReservableConnectors(this.connectors);
}
- return reservableConnectors - this.getNumberOfReservationsOnConnectorZero();
+ return numberOfReservableConnectors - this.getNumberOfReservationsOnConnectorZero();
}
private getNumberOfReservationsOnConnectorZero(): number {
return this.stationInfo.supervisionUrlOcppConfiguration ?? false;
}
- private stopReservationExpirationSetInterval(): void {
- if (this.reservationExpirationSetInterval) {
- clearInterval(this.reservationExpirationSetInterval);
- }
- }
-
private getSupervisionUrlOcppKey(): string {
return this.stationInfo.supervisionUrlOcppKey ?? VendorParametersKey.ConnectionUrl;
}