docs: refine README

[e-mobility-charging-stations-simulator.git] / src / charging-station / ChargingStation.ts

diff --git a/src/charging-station/ChargingStation.ts b/src/charging-station/ChargingStation.ts
index a3f6769607c5b01bb9774bf614a71f31a80a5afe..726a2ce9fc63ee06253dc379d003930f9a791888 100644 (file)
--- a/src/charging-station/ChargingStation.ts
+++ b/src/charging-station/ChargingStation.ts
@@ -138,7 +138,7 @@ export class ChargingStation {
   private readonly sharedLRUCache: SharedLRUCache;
   private webSocketPingSetInterval!: NodeJS.Timeout;
   private readonly chargingStationWorkerBroadcastChannel: ChargingStationWorkerBroadcastChannel;
-  private reservationExpiryDateSetInterval?: NodeJS.Timeout;
+  private reservationExpirationSetInterval?: NodeJS.Timeout;
 
   constructor(index: number, templateFile: string) {
     this.started = false;
@@ -654,7 +654,7 @@ export class ChargingStation {
           this.performanceStatistics?.start();
         }
         if (this.hasFeatureProfile(SupportedFeatureProfiles.Reservation)) {
-          this.startReservationExpiryDateSetInterval();
+          this.startReservationExpirationSetInterval();
         }
         this.openWSConnection();
         // Monitor charging station template file
@@ -933,25 +933,15 @@ export class ChargingStation {
   public async addReservation(reservation: Reservation): Promise<void> {
     const [exists, reservationFound] = this.doesReservationExists(reservation);
     if (exists) {
-      await this.removeReservation(reservationFound);
+      await this.removeReservation(reservationFound, ReservationTerminationReason.REPLACE_EXISTING);
     }
-    const connectorStatus = this.getConnectorStatus(reservation.connectorId);
-    connectorStatus.reservation = reservation;
-    connectorStatus.status = ConnectorStatusEnum.Reserved;
-    if (reservation.connectorId === 0) {
-      return;
-    }
-    await this.ocppRequestService.requestHandler<
-      StatusNotificationRequest,
-      StatusNotificationResponse
-    >(
+    this.getConnectorStatus(reservation.connectorId).reservation = reservation;
+    await OCPPServiceUtils.sendAndSetConnectorStatus(
       this,
-      RequestCommand.STATUS_NOTIFICATION,
-      OCPPServiceUtils.buildStatusNotificationRequest(
-        this,
-        reservation.connectorId,
-        ConnectorStatusEnum.Reserved
-      )
+      reservation.connectorId,
+      ConnectorStatusEnum.Reserved,
+      null,
+      { send: reservation.connectorId !== 0 }
     );
   }
 
@@ -961,50 +951,41 @@ export class ChargingStation {
   ): Promise<void> {
     const connector = this.getConnectorStatus(reservation.connectorId);
     switch (reason) {
-      case ReservationTerminationReason.TRANSACTION_STARTED: {
+      case ReservationTerminationReason.CONNECTOR_STATE_CHANGED:
         delete connector.reservation;
-        if (reservation.connectorId === 0) {
-          connector.status = ConnectorStatusEnum.Available;
-        }
         break;
-      }
-      case ReservationTerminationReason.CONNECTOR_STATE_CHANGED: {
+      case ReservationTerminationReason.TRANSACTION_STARTED:
         delete connector.reservation;
         break;
-      }
-      default: {
-        // ReservationTerminationReason.EXPIRED, ReservationTerminationReason.CANCELED
-        connector.status = ConnectorStatusEnum.Available;
-        delete connector.reservation;
-        await this.ocppRequestService.requestHandler<
-          StatusNotificationRequest,
-          StatusNotificationResponse
-        >(
+      case ReservationTerminationReason.RESERVATION_CANCELED ||
+        ReservationTerminationReason.REPLACE_EXISTING ||
+        ReservationTerminationReason.EXPIRED:
+        await OCPPServiceUtils.sendAndSetConnectorStatus(
           this,
-          RequestCommand.STATUS_NOTIFICATION,
-          OCPPServiceUtils.buildStatusNotificationRequest(
-            this,
-            reservation.connectorId,
-            ConnectorStatusEnum.Available
-          )
+          reservation.connectorId,
+          ConnectorStatusEnum.Available,
+          null,
+          { send: reservation.connectorId !== 0 }
         );
+        delete connector.reservation;
+        break;
+      default:
         break;
-      }
     }
   }
 
-  public getReservationBy(key: string, value: number | string): Reservation {
+  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?.[key] === value) {
+          if (connector?.reservation?.[filterKey] === value) {
             return connector.reservation;
           }
         }
       }
     } else {
       for (const connector of this.connectors.values()) {
-        if (connector?.reservation?.[key] === value) {
+        if (connector?.reservation?.[filterKey] === value) {
           return connector.reservation;
         }
       }
@@ -1019,27 +1000,33 @@ export class ChargingStation {
     return Utils.isUndefined(foundReservation) ? [false, null] : [true, foundReservation];
   }
 
-  public startReservationExpiryDateSetInterval(customInterval?: number): void {
+  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 CS now`
+        and starts on charging station now`
     );
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    this.reservationExpiryDateSetInterval = setInterval(async (): Promise<void> => {
+    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);
+              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);
+            await this.removeReservation(
+              connector.reservation,
+              ReservationTerminationReason.EXPIRED
+            );
           }
         }
       }
@@ -1047,8 +1034,8 @@ export class ChargingStation {
   }
 
   public restartReservationExpiryDateSetInterval(): void {
-    this.stopReservationExpiryDateSetInterval();
-    this.startReservationExpiryDateSetInterval();
+    this.stopReservationExpirationSetInterval();
+    this.startReservationExpirationSetInterval();
   }
 
   public validateIncomingRequestWithReservation(connectorId: number, idTag: string): boolean {
@@ -1089,8 +1076,8 @@ export class ChargingStation {
 
   private countReservableConnectors(connectors: Map<number, ConnectorStatus>) {
     let reservableConnectors = 0;
-    for (const [id, connector] of connectors) {
-      if (id === 0) {
+    for (const [connectorId, connector] of connectors) {
+      if (connectorId === 0) {
         continue;
       }
       if (connector.status === ConnectorStatusEnum.Available) {
@@ -1141,9 +1128,9 @@ export class ChargingStation {
     return this.stationInfo.supervisionUrlOcppConfiguration ?? false;
   }
 
-  private stopReservationExpiryDateSetInterval(): void {
-    if (this.reservationExpiryDateSetInterval) {
-      clearInterval(this.reservationExpiryDateSetInterval);
+  private stopReservationExpirationSetInterval(): void {
+    if (this.reservationExpirationSetInterval) {
+      clearInterval(this.reservationExpirationSetInterval);
     }
   }