#### Reservation Profile
-- _none_
+- :white_check_mark: ReserveConnectorZeroSupported (type: boolean) (units: -)
#### Smart Charging Profile
{
"key": "ReserveConnectorZeroSupported",
"readonly": false,
- "value": "true"
+ "value": "false"
}
]
},
{
"key": "TransactionMessageRetryInterval",
"value": "20"
+ },
+ {
+ "key": "ReserveConnectorZeroSupported",
+ "readonly": false,
+ "value": "false"
}
]
},
{
"key": "ReserveConnectorZeroSupported",
"readonly": false,
- "value": "true"
+ "value": "false"
}
]
},
"key": "WebSocketPingInterval",
"readonly": false,
"value": "60"
+ },
+ {
+ "key": "ReserveConnectorZeroSupported",
+ "readonly": false,
+ "value": "false"
}
]
},
{
"key": "ReserveConnectorZeroSupported",
"readonly": false,
- "value": "true"
+ "value": "false"
}
]
},
{
"key": "ReserveConnectorZeroSupported",
"readonly": false,
- "value": "true"
+ "value": "false"
}
]
},
{
"key": "ReserveConnectorZeroSupported",
"readonly": false,
- "value": "true"
+ "value": "false"
}
]
},
"key": "WebSocketPingInterval",
"readonly": false,
"value": "60"
+ },
+ {
+ "key": "ReserveConnectorZeroSupported",
+ "readonly": false,
+ "value": "false"
}
]
},
type OCPPRequestService,
OCPPServiceUtils,
} from './ocpp';
-import { OCPPConstants } from './ocpp/OCPPConstants';
import { SharedLRUCache } from './SharedLRUCache';
import { BaseError, OCPPError } from '../exception';
import { PerformanceStatistics } from '../performance';
MeterValueMeasurand,
type MeterValuesRequest,
type MeterValuesResponse,
- OCPP16AuthorizationStatus,
- type OCPP16AuthorizeRequest,
- type OCPP16AuthorizeResponse,
- OCPP16RequestCommand,
- OCPP16SupportedFeatureProfiles,
OCPPVersion,
type OutgoingRequest,
PowerUnits,
RegistrationStatusEnumType,
RequestCommand,
+ type Reservation,
+ ReservationFilterKey,
+ ReservationTerminationReason,
type Response,
StandardParametersKey,
type StatusNotificationRequest,
WebSocketCloseEventStatusCode,
type WsOptions,
} from '../types';
-import { ReservationTerminationReason } from '../types/ocpp/1.6/Reservation';
-import type { Reservation } from '../types/ocpp/Reservation';
import {
ACElectricUtils,
AsyncLock,
private readonly sharedLRUCache: SharedLRUCache;
private webSocketPingSetInterval!: NodeJS.Timeout;
private readonly chargingStationWorkerBroadcastChannel: ChargingStationWorkerBroadcastChannel;
- private reservations?: Reservation[];
private reservationExpiryDateSetInterval?: NodeJS.Timeout;
constructor(index: number, templateFile: string) {
);
} 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.supportsReservations()) {
+ if (this.hasFeatureProfile(SupportedFeatureProfiles.Reservation)) {
this.startReservationExpiryDateSetInterval();
}
this.openWSConnection();
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 supportsReservations(): boolean {
- logger.info(`${this.logPrefix()} Check for reservation support in charging station`);
- return ChargingStationConfigurationUtils.getConfigurationKey(
- this,
- StandardParametersKey.SupportedFeatureProfiles
- ).value.includes(OCPP16SupportedFeatureProfiles.Reservation);
- }
-
- public supportsReservationsOnConnectorId0(): boolean {
- logger.info(
- ` ${this.logPrefix()} Check for reservation support on connector 0 in charging station (CS)`
- );
- return (
- this.supportsReservations() &&
+ public getReservationOnConnectorId0Enabled(): boolean {
+ return Utils.convertToBoolean(
ChargingStationConfigurationUtils.getConfigurationKey(
this,
- OCPPConstants.OCPP_RESERVE_CONNECTOR_ZERO_SUPPORTED
- ).value === 'true'
+ StandardParametersKey.ReserveConnectorZeroSupported
+ ).value
);
}
public async addReservation(reservation: Reservation): Promise<void> {
- if (Utils.isNullOrUndefined(this.reservations)) {
- this.reservations = [];
- }
const [exists, reservationFound] = this.doesReservationExists(reservation);
if (exists) {
await this.removeReservation(reservationFound);
}
- this.reservations.push(reservation);
+ const connectorStatus = this.getConnectorStatus(reservation.connectorId);
+ connectorStatus.reservation = reservation;
+ connectorStatus.status = ConnectorStatusEnum.Reserved;
if (reservation.connectorId === 0) {
return;
}
- this.getConnectorStatus(reservation.connectorId).status = ConnectorStatusEnum.Reserved;
await this.ocppRequestService.requestHandler<
StatusNotificationRequest,
StatusNotificationResponse
reservation: Reservation,
reason?: ReservationTerminationReason
): Promise<void> {
- const sameReservation = (r: Reservation) => r.id === reservation.id;
- const index = this.reservations?.findIndex(sameReservation);
- this.reservations.splice(index, 1);
+ const connector = this.getConnectorStatus(reservation.connectorId);
switch (reason) {
- case ReservationTerminationReason.TRANSACTION_STARTED:
- // No action needed
+ case ReservationTerminationReason.TRANSACTION_STARTED: {
+ delete connector.reservation;
+ if (reservation.connectorId === 0) {
+ connector.status = ConnectorStatusEnum.Available;
+ }
break;
- case ReservationTerminationReason.CONNECTOR_STATE_CHANGED:
- // No action needed
+ }
+ case ReservationTerminationReason.CONNECTOR_STATE_CHANGED: {
+ delete connector.reservation;
break;
- default: // ReservationTerminationReason.EXPIRED, ReservationTerminationReason.CANCELED
- this.getConnectorStatus(reservation.connectorId).status = ConnectorStatusEnum.Available;
+ }
+ default: {
+ // ReservationTerminationReason.EXPIRED, ReservationTerminationReason.CANCELED
+ connector.status = ConnectorStatusEnum.Available;
+ delete connector.reservation;
await this.ocppRequestService.requestHandler<
StatusNotificationRequest,
StatusNotificationResponse
)
);
break;
+ }
}
}
- public getReservationById(id: number): Reservation {
- return this.reservations?.find((reservation) => reservation.id === id);
- }
-
- public getReservationByIdTag(id: string): Reservation {
- return this.reservations?.find((reservation) => reservation.idTag === id);
- }
-
- public getReservationByConnectorId(id: number): Reservation {
- return this.reservations?.find((reservation) => reservation.connectorId === id);
+ public getReservationBy(key: string, 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) {
+ return connector.reservation;
+ }
+ }
+ }
+ } else {
+ for (const connector of this.connectors.values()) {
+ if (connector?.reservation?.[key] === value) {
+ return connector.reservation;
+ }
+ }
+ }
}
public doesReservationExists(reservation: Partial<Reservation>): [boolean, Reservation] {
- const sameReservation = (r: Reservation) => r.id === reservation.id;
- const foundReservation = this.reservations?.find(sameReservation);
+ const foundReservation = this.getReservationBy(
+ ReservationFilterKey.RESERVATION_ID,
+ reservation?.id
+ );
return Utils.isUndefined(foundReservation) ? [false, null] : [true, foundReservation];
}
- public async isAuthorized(
- connectorId: number,
- idTag: string,
- parentIdTag?: string
- ): Promise<boolean> {
- let authorized = false;
- const connectorStatus = this.getConnectorStatus(connectorId);
- if (
- this.getLocalAuthListEnabled() === true &&
- this.hasIdTags() === true &&
- Utils.isNotEmptyString(
- this.idTagsCache
- .getIdTags(ChargingStationUtils.getIdTagsFile(this.stationInfo))
- ?.find((tag) => tag === idTag)
- )
- ) {
- connectorStatus.localAuthorizeIdTag = idTag;
- connectorStatus.idTagLocalAuthorized = true;
- authorized = true;
- } else if (this.getMustAuthorizeAtRemoteStart() === true) {
- connectorStatus.authorizeIdTag = idTag;
- const authorizeResponse: OCPP16AuthorizeResponse =
- await this.ocppRequestService.requestHandler<
- OCPP16AuthorizeRequest,
- OCPP16AuthorizeResponse
- >(this, OCPP16RequestCommand.AUTHORIZE, {
- idTag: idTag,
- });
- if (authorizeResponse?.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) {
- authorized = true;
- }
- } else {
- logger.warn(
- `${this.logPrefix()} The charging station configuration expects authorize at
- remote start transaction but local authorization or authorize isn't enabled`
- );
- }
- return authorized;
- }
-
public startReservationExpiryDateSetInterval(customInterval?: number): void {
const interval =
customInterval ?? Constants.DEFAULT_RESERVATION_EXPIRATION_OBSERVATION_INTERVAL;
);
// eslint-disable-next-line @typescript-eslint/no-misused-promises
this.reservationExpiryDateSetInterval = setInterval(async (): Promise<void> => {
- if (!Utils.isNullOrUndefined(this.reservations) && !Utils.isEmptyArray(this.reservations)) {
- for (const reservation of this.reservations) {
- if (reservation.expiryDate.toString() < new Date().toISOString()) {
- await this.removeReservation(reservation);
- logger.info(
- `${this.logPrefix()} Reservation with ID ${
- reservation.id
- } reached expiration date and was removed from CS`
- );
+ 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);
+ }
+ }
+ }
+ } else {
+ for (const connector of this.connectors.values()) {
+ if (connector?.reservation?.expiryDate.toString() < new Date().toISOString()) {
+ await this.removeReservation(connector.reservation);
}
}
}
}
public validateIncomingRequestWithReservation(connectorId: number, idTag: string): boolean {
- const reservation = this.getReservationByConnectorId(connectorId);
- return Utils.isUndefined(reservation) || reservation.idTag !== idTag;
+ const reservation = this.getReservationBy(ReservationFilterKey.CONNECTOR_ID, connectorId);
+ return !Utils.isUndefined(reservation) && reservation.idTag === idTag;
}
public isConnectorReservable(
reservationId: number,
- connectorId?: number,
- idTag?: string
+ idTag?: string,
+ connectorId?: number
): boolean {
const [alreadyExists] = this.doesReservationExists({ id: reservationId });
if (alreadyExists) {
return alreadyExists;
}
- const userReservedAlready = Utils.isUndefined(this.getReservationByIdTag(idTag)) ? false : true;
+ 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;
- this.connectors.forEach((connector, id) => {
+ 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 [id, connector] of connectors) {
if (id === 0) {
- return;
+ continue;
}
if (connector.status === ConnectorStatusEnum.Available) {
- reservableConnectors++;
+ ++reservableConnectors;
}
- });
- return reservableConnectors - this.getNumberOfReservationsOnConnectorZero();
+ }
+ return reservableConnectors;
}
private getNumberOfReservationsOnConnectorZero(): number {
- const reservations = this.reservations?.filter((reservation) => reservation.connectorId === 0);
- return Utils.isNullOrUndefined(reservations) ? 0 : reservations.length;
+ 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 {
}
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);
}
OCPP16AvailabilityType,
type OCPP16BootNotificationRequest,
type OCPP16BootNotificationResponse,
+ type OCPP16CancelReservationRequest,
+ type OCPP16CancelReservationResponse,
OCPP16ChargePointErrorCode,
OCPP16ChargePointStatus,
type OCPP16ChargingProfile,
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 type {
- OCPP16CancelReservationRequest,
- OCPP16ReserveNowRequest,
-} from '../../../types/ocpp/1.6/Requests';
-import { ReservationTerminationReason } from '../../../types/ocpp/1.6/Reservation';
-import type {
- OCPP16CancelReservationResponse,
- OCPP16ReserveNowResponse,
-} from '../../../types/ocpp/1.6/Responses';
import { Constants, Utils, logger } from '../../../utils';
import { OCPPConstants } from '../OCPPConstants';
import { OCPPIncomingRequestService } from '../OCPPIncomingRequestService';
} 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 (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;
+ 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,
- commandPayload.idTag
- )
+ (reserved &&
+ !chargingStation.validateIncomingRequestWithReservation(transactionConnectorId, idTag)) ||
+ (reservedOnConnectorZero && !chargingStation.validateIncomingRequestWithReservation(0, idTag))
) {
return OCPP16Constants.OCPP_RESPONSE_REJECTED;
}
return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- commandPayload.idTag
+ idTag
);
}
if (
return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- commandPayload.idTag
+ idTag
);
}
- const remoteStartTransactionLogMsg = `${chargingStation.logPrefix()} Transaction remotely STARTED on ${
+ const remoteStartTransactionLogMsg = `
+ ${chargingStation.logPrefix()} Transaction remotely STARTED on ${
chargingStation.stationInfo.chargingStationId
- }#${transactionConnectorId.toString()} for idTag '${commandPayload.idTag}'`;
+ }#${transactionConnectorId.toString()} for idTag '${idTag}'`;
await OCPP16ServiceUtils.sendAndSetConnectorStatus(
chargingStation,
transactionConnectorId,
);
const connectorStatus = chargingStation.getConnectorStatus(transactionConnectorId);
// Check if authorized
- if (chargingStation.getAuthorizeRemoteTxRequests() === true) {
- const authorized = await chargingStation.isAuthorized(
- transactionConnectorId,
- commandPayload.idTag
- );
- if (authorized === true) {
- // Authorization successful, start transaction
+ if (
+ chargingStation.getAuthorizeRemoteTxRequests() &&
+ (await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, transactionConnectorId, idTag))
+ ) {
+ // Authorization successful, start transaction
+ if (
+ this.setRemoteStartTransactionChargingProfile(
+ chargingStation,
+ transactionConnectorId,
+ chargingProfile
+ ) === true
+ ) {
+ connectorStatus.transactionRemoteStarted = true;
+ const startTransactionPayload: Partial<StartTransactionRequest> = {
+ connectorId: transactionConnectorId,
+ idTag: 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
+ );
+ }
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;
- const startTransactionPayload: JsonType = {
- connectorId: transactionConnectorId,
- idTag: commandPayload.idTag,
- };
- if (reserved) {
- const reservation = chargingStation.getReservationByConnectorId(transactionConnectorId);
- startTransactionData.reservationId = reservation.id;
- await chargingStation.removeReservation(
- reservation,
- ReservationTerminationReason.TRANSACTION_STARTED
- );
- }
- if (
- (
- await chargingStation.ocppRequestService.requestHandler<
- OCPP16StartTransactionRequest,
- OCPP16StartTransactionResponse
- >(chargingStation, OCPP16RequestCommand.START_TRANSACTION, startTransactionData)
- ).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
this.setRemoteStartTransactionChargingProfile(
chargingStation,
transactionConnectorId,
- commandPayload.chargingProfile
+ chargingProfile
) === true
) {
connectorStatus.transactionRemoteStarted = true;
OCPP16StartTransactionResponse
>(chargingStation, OCPP16RequestCommand.START_TRANSACTION, {
connectorId: transactionConnectorId,
- idTag: commandPayload.idTag,
+ idTag,
})
).idTagInfo.status === OCPP16AuthorizationStatus.ACCEPTED
) {
return this.notifyRemoteStartTransactionRejected(
chargingStation,
transactionConnectorId,
- commandPayload.idTag
+ 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;
}
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;
}
})
.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
);
});
chargingStation: ChargingStation,
commandPayload: OCPP16ReserveNowRequest
): Promise<OCPP16ReserveNowResponse> {
+ if (
+ !OCPP16ServiceUtils.checkFeatureProfile(
+ chargingStation,
+ OCPP16SupportedFeatureProfiles.Reservation,
+ OCPP16IncomingRequestCommand.RESERVE_NOW
+ )
+ ) {
+ return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
+ }
const { reservationId, idTag, connectorId } = commandPayload;
let response: OCPP16ReserveNowResponse;
try {
- if (
- !chargingStation.supportsReservations() &&
- chargingStation.isConnectorAvailable(connectorId)
- ) {
+ if (!chargingStation.isConnectorAvailable(connectorId) && connectorId > 0) {
return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
- if (connectorId === 0 && !chargingStation.supportsReservationsOnConnectorId0()) {
+ if (connectorId === 0 && !chargingStation.getReservationOnConnectorId0Enabled()) {
return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
- if (!(await chargingStation.isAuthorized(connectorId, idTag))) {
+ if (!(await OCPP16ServiceUtils.isIdTagAuthorized(chargingStation, connectorId, idTag))) {
return OCPPConstants.OCPP_RESERVATION_RESPONSE_REJECTED;
}
switch (chargingStation.getConnectorStatus(connectorId).status) {
response = OCPPConstants.OCPP_RESERVATION_RESPONSE_UNAVAILABLE;
break;
case ConnectorStatusEnum.Reserved:
- if (!chargingStation.isConnectorReservable(reservationId, connectorId, idTag)) {
+ if (!chargingStation.isConnectorReservable(reservationId, idTag, connectorId)) {
response = OCPPConstants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
break;
}
// eslint-disable-next-line no-fallthrough
default:
- if (!chargingStation.isConnectorReservable(reservationId)) {
+ if (!chargingStation.isConnectorReservable(reservationId, idTag)) {
response = OCPPConstants.OCPP_RESERVATION_RESPONSE_OCCUPIED;
break;
}
chargingStation: ChargingStation,
commandPayload: OCPP16CancelReservationRequest
): Promise<OCPP16CancelReservationResponse> {
+ if (
+ !OCPP16ServiceUtils.checkFeatureProfile(
+ chargingStation,
+ OCPP16SupportedFeatureProfiles.Reservation,
+ OCPP16IncomingRequestCommand.CANCEL_RESERVATION
+ )
+ ) {
+ return OCPPConstants.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`
+ `${chargingStation.logPrefix()} Reservation with ID ${reservationId}
+ does not exist on charging station`
);
return OCPPConstants.OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED;
}
type OCPP16AuthorizeRequest,
type OCPP16AuthorizeResponse,
type OCPP16BootNotificationResponse,
+ type OCPP16CancelReservationResponse,
OCPP16ChargePointStatus,
type OCPP16DataTransferResponse,
type OCPP16DiagnosticsStatusNotificationResponse,
type OCPP16MeterValuesRequest,
type OCPP16MeterValuesResponse,
OCPP16RequestCommand,
+ type OCPP16ReserveNowResponse,
OCPP16StandardParametersKey,
type OCPP16StartTransactionRequest,
type OCPP16StartTransactionResponse,
'constructor'
),
],
+ [
+ OCPP16RequestCommand.RESERVE_NOW,
+ OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16ReserveNowResponse>(
+ 'assets/json-schemas/ocpp/1.6/ReserveNowResponse.json',
+ moduleName,
+ 'constructor'
+ ),
+ ],
+ [
+ OCPP16RequestCommand.CANCEL_RESERVATION,
+ OCPP16ServiceUtils.parseJsonSchemaFile<OCPP16CancelReservationResponse>(
+ 'assets/json-schemas/ocpp/1.6/CancelReservationResponse.json',
+ moduleName,
+ 'constructor'
+ ),
+ ],
]);
this.jsonIncomingRequestResponseSchemas = new Map([
[
import type { JSONSchemaType } from 'ajv';
-import type { ChargingStation } from '../../../charging-station';
+import { type ChargingStation, ChargingStationUtils } from '../../../charging-station';
import { OCPPError } from '../../../exception';
import {
CurrentType,
MeterValueContext,
MeterValueLocation,
MeterValueUnit,
+ OCPP16AuthorizationStatus,
+ type OCPP16AuthorizeRequest,
+ type OCPP16AuthorizeResponse,
type OCPP16ChargingProfile,
type OCPP16IncomingRequestCommand,
type OCPP16MeterValue,
);
}
+ public static async isIdTagAuthorized(
+ chargingStation: ChargingStation,
+ connectorId: number,
+ idTag: string,
+ parentIdTag?: string
+ ): Promise<boolean> {
+ let authorized = false;
+ const connectorStatus = chargingStation.getConnectorStatus(connectorId);
+ if (OCPP16ServiceUtils.isIdTagLocalAuthorized(chargingStation, idTag)) {
+ connectorStatus.localAuthorizeIdTag = idTag;
+ connectorStatus.idTagLocalAuthorized = true;
+ authorized = true;
+ } else if (chargingStation.getMustAuthorizeAtRemoteStart() === true) {
+ connectorStatus.authorizeIdTag = idTag;
+ authorized = await OCPP16ServiceUtils.isIdTagRemoteAuthorized(chargingStation, idTag);
+ } else {
+ logger.warn(
+ `${chargingStation.logPrefix()} The charging station configuration expects authorize at
+ remote start transaction but local authorization or authorize isn't enabled`
+ );
+ }
+ return authorized;
+ }
+
private static buildSampledValue(
sampledValueTemplate: SampledValueTemplate,
value: number,
return MeterValueUnit.VOLT;
}
}
+
+ private static isIdTagLocalAuthorized(chargingStation: ChargingStation, idTag: string): boolean {
+ return (
+ chargingStation.getLocalAuthListEnabled() === true &&
+ chargingStation.hasIdTags() === true &&
+ Utils.isNotEmptyString(
+ chargingStation.idTagsCache
+ .getIdTags(ChargingStationUtils.getIdTagsFile(chargingStation.stationInfo))
+ ?.find((tag) => tag === idTag)
+ )
+ );
+ }
+
+ private static async isIdTagRemoteAuthorized(
+ chargingStation: ChargingStation,
+ idTag: string
+ ): Promise<boolean> {
+ const authorizeResponse: OCPP16AuthorizeResponse =
+ await chargingStation.ocppRequestService.requestHandler<
+ OCPP16AuthorizeRequest,
+ OCPP16AuthorizeResponse
+ >(chargingStation, OCPP16RequestCommand.AUTHORIZE, {
+ idTag: idTag,
+ });
+ return authorizeResponse?.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED;
+ }
}
TriggerMessageStatus,
UnlockStatus,
} from '../../types';
-import { CancelReservationStatus, ReservationStatus } from '../../types/ocpp/Responses';
+import { ReservationStatus } from '../../types/ocpp/Responses';
import { Constants } from '../../utils';
export class OCPPConstants {
status: DataTransferStatus.REJECTED,
});
- static readonly OCPP_RESERVATION_RESPONSE_ACCEPTED = Object.freeze({ status: ReservationStatus.ACCEPTED }); // Reservation has been made
- static readonly OCPP_RESERVATION_RESPONSE_FAULTED = Object.freeze({ status: ReservationStatus.FAULTED }); // Reservation has not been made, because of connector in FAULTED state
- static readonly OCPP_RESERVATION_RESPONSE_OCCUPIED = Object.freeze({ status: ReservationStatus.OCCUPIED }); // Reservation has not been made, because all connectors are OCCUPIED
- static readonly OCPP_RESERVATION_RESPONSE_REJECTED = Object.freeze({ status: ReservationStatus.REJECTED }); // Reservation has not been made, because CS is not configured to accept reservations
- static readonly OCPP_RESERVATION_RESPONSE_UNAVAILABLE = Object.freeze({ status: ReservationStatus.UNAVAILABLE }); // Reservation has not been made, because connectors are spec. connector is in UNAVAILABLE state
+ static readonly OCPP_RESERVATION_RESPONSE_ACCEPTED = Object.freeze({
+ status: ReservationStatus.ACCEPTED,
+ }); // Reservation has been made
- static readonly OCPP_CANCEL_RESERVATION_RESPONSE_ACCEPTED = Object.freeze({ status: CancelReservationStatus.ACCEPTED }); // Reservation for id has been cancelled has been made
- static readonly OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED = Object.freeze({ status: CancelReservationStatus.REJECTED }); // Reservation could not be cancelled, because there is no reservation active for id
+ static readonly OCPP_RESERVATION_RESPONSE_FAULTED = Object.freeze({
+ status: ReservationStatus.FAULTED,
+ }); // Reservation has not been made, because of connector in FAULTED state
- static readonly OCPP_SUPPORTED_FEATURE_PROFILE_RESERVATION = 'Reservation';
- static readonly OCPP_RESERVE_CONNECTOR_ZERO_SUPPORTED = 'ReserveConnectorZeroSupported';
+ static readonly OCPP_RESERVATION_RESPONSE_OCCUPIED = Object.freeze({
+ status: ReservationStatus.OCCUPIED,
+ }); // Reservation has not been made, because all connectors are OCCUPIED
+
+ static readonly OCPP_RESERVATION_RESPONSE_REJECTED = Object.freeze({
+ status: ReservationStatus.REJECTED,
+ }); // Reservation has not been made, because CS is not configured to accept reservations
+
+ static readonly OCPP_RESERVATION_RESPONSE_UNAVAILABLE = Object.freeze({
+ status: ReservationStatus.UNAVAILABLE,
+ }); // Reservation has not been made, because connectors are spec. connector is in UNAVAILABLE state
+
+ static readonly OCPP_CANCEL_RESERVATION_RESPONSE_ACCEPTED = Object.freeze({
+ status: GenericStatus.Accepted,
+ }); // Reservation for id has been cancelled has been made
+
+ static readonly OCPP_CANCEL_RESERVATION_RESPONSE_REJECTED = Object.freeze({
+ status: GenericStatus.Rejected,
+ }); // Reservation could not be cancelled, because there is no reservation active for id
protected constructor() {
// This is intentional
MessageTrigger,
RequestCommand,
} from './ocpp/Requests';
-import type { Reservation } from './ocpp/Reservation';
export enum CurrentType {
AC = 'AC',
AutomaticTransactionGenerator?: AutomaticTransactionGeneratorConfiguration;
Evses?: Record<string, EvseTemplate>;
Connectors?: Record<string, ConnectorStatus>;
- reservation?: Reservation[];
};
import type { ConnectorStatusEnum } from './ocpp/ConnectorStatusEnum';
import type { MeterValue } from './ocpp/MeterValues';
import type { AvailabilityType } from './ocpp/Requests';
+import type { Reservation } from './ocpp/Reservation';
export type ConnectorStatus = {
availability: AvailabilityType;
transactionEnergyActiveImportRegisterValue?: number; // In Wh
transactionBeginMeterValue?: MeterValue;
chargingProfiles?: ChargingProfile[];
+ reservation?: Reservation;
};
type ResetRequest,
type SetChargingProfileRequest,
type UnlockConnectorRequest,
+ type OCPP16ReserveNowRequest,
+ type OCPP16CancelReservationRequest,
} from './ocpp/1.6/Requests';
export {
type ChangeAvailabilityResponse,
type OCPP16UpdateFirmwareResponse,
type SetChargingProfileResponse,
type UnlockConnectorResponse,
+ type OCPP16ReserveNowResponse,
+ type OCPP16CancelReservationResponse,
} from './ocpp/1.6/Responses';
export { ChargePointErrorCode } from './ocpp/ChargePointErrorCode';
export {
WebSocketCloseEventStatusCode,
WebSocketCloseEventStatusString,
} from './WebSocket';
+export { ReservationFilterKey, ReservationTerminationReason } from './ocpp/1.6/Reservation';
+export { type Reservation } from './ocpp/Reservation';
EXPIRED = 'Expired',
TRANSACTION_STARTED = 'TransactionStarted',
CONNECTOR_STATE_CHANGED = 'ConnectorStateChanged',
- CANCELED = 'ReservationCanceled',
+ RESERVATION_CANCELED = 'ReservationCanceled',
+}
+
+export enum ReservationFilterKey {
+ RESERVATION_ID = 'id',
+ ID_TAG = 'idTag',
+ PARENT_ID_TAG = 'parentIdTag',
+ CONNECTOR_ID = 'connectorId',
+ EVSE_ID = 'evseId',
}
import type { EmptyObject } from '../../EmptyObject';
import type { JsonObject } from '../../JsonType';
import type { OCPPConfigurationKey } from '../Configuration';
-import type { GenericStatus, RegistrationStatusEnumType } from '../Responses';
+import { GenericStatus, type RegistrationStatusEnumType } from '../Responses';
export interface OCPP16HeartbeatResponse extends JsonObject {
currentTime: Date;
data?: string;
}
-export enum OCPP16CancelReservationStatus {
- ACCEPTED = 'Accepted',
- REJECTED = 'Rejected',
-}
-
-export interface OCPP16CancelReservationResponse {
- status: OCPP16CancelReservationStatus;
+export interface OCPP16CancelReservationResponse extends JsonObject {
+ status: GenericStatus;
}
export enum OCPP16ReservationStatus {
OCCUPIED = 'Occupied',
REJECTED = 'Rejected',
UNAVAILABLE = 'Unavailable',
+ NOT_SUPPORTED = 'NotSupported',
}
-export interface OCPP16ReserveNowResponse {
+export interface OCPP16ReserveNowResponse extends JsonObject {
status: OCPP16ReservationStatus;
}
import {
OCPP16AvailabilityType,
type OCPP16BootNotificationRequest,
+ type OCPP16CancelReservationRequest,
type OCPP16DataTransferRequest,
type OCPP16DiagnosticsStatusNotificationRequest,
OCPP16FirmwareStatus,
OCPP16IncomingRequestCommand,
OCPP16MessageTrigger,
OCPP16RequestCommand,
+ type OCPP16ReserveNowRequest,
type OCPP16StatusNotificationRequest,
} from './1.6/Requests';
import { OperationalStatusEnumType } from './2.0/Common';
export type FirmwareStatus = OCPP16FirmwareStatus;
export type ResponseType = JsonType | OCPPError;
+
+export type ReserveNowRequest = OCPP16ReserveNowRequest;
+
+export type CancelReservationRequest = OCPP16CancelReservationRequest;
import {
OCPP16AvailabilityStatus,
type OCPP16BootNotificationResponse,
- OCPP16CancelReservationStatus,
+ type OCPP16CancelReservationResponse,
OCPP16ChargingProfileStatus,
OCPP16ClearChargingProfileStatus,
OCPP16ConfigurationStatus,
...OCPP16ReservationStatus,
};
-export type CancelReservationStatus = OCPP16CancelReservationStatus;
export const CancelReservationStatus = {
- ...OCPP16CancelReservationStatus,
+ ...GenericStatus,
};
+
+export type CancelReservationResponse = OCPP16CancelReservationResponse;
repositories / e-mobility-charging-stations-simulator.git / commitdiff
