}
public isRegistered(): boolean {
- return !this.isInUnknownState() && (this.isInAcceptedState() || this.isInPendingState());
+ return (
+ this.isInUnknownState() === false &&
+ (this.isInAcceptedState() === true || this.isInPendingState() === true)
+ );
}
public isChargingStationAvailable(): boolean {
this.stopping = true;
await this.stopMessageSequence(reason);
this.closeWSConnection();
- this.wsConnectionRestarted = false;
if (this.getEnableStatistics()) {
this.performanceStatistics.stop();
}
): Promise<StopTransactionResponse> {
const transactionId = this.getConnectorStatus(connectorId).transactionId;
if (
- this.getBeginEndMeterValues() &&
- this.getOcppStrictCompliance() &&
- !this.getOutOfOrderEndMeterValues()
+ this.getBeginEndMeterValues() === true &&
+ this.getOcppStrictCompliance() === true &&
+ this.getOutOfOrderEndMeterValues() === false
) {
// FIXME: Implement OCPP version agnostic helpers
const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(
this.handleUnsupportedVersion(this.getOcppVersion());
break;
}
- if (this.stationInfo?.autoRegister) {
+ if (this.stationInfo?.autoRegister === true) {
this.bootNotificationResponse = {
currentTime: new Date().toISOString(),
interval: this.getHeartbeatInterval() / 1000,
}
// Initialize transaction attributes on connectors
for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionStarted === true) {
+ logger.warn(
+ `${this.logPrefix()} Connector ${connectorId} at initialization has a transaction started: ${
+ this.getConnectorStatus(connectorId).transactionId
+ }`
+ );
+ }
if (
connectorId > 0 &&
(this.getConnectorStatus(connectorId).transactionStarted === undefined ||
- this.getConnectorStatus(connectorId).transactionStarted === false)
+ this.getConnectorStatus(connectorId).transactionStarted === null)
) {
this.initializeConnectorStatus(connectorId);
}
private getOcppConfigurationFromFile(): ChargingStationOcppConfiguration | null {
let configuration: ChargingStationConfiguration = null;
- if (this.getOcppPersistentConfiguration()) {
+ if (this.getOcppPersistentConfiguration() === true) {
const configurationFromFile = this.getConfigurationFromFile();
configuration = configurationFromFile?.configurationKey && configurationFromFile;
}
logger.info(
`${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} succeeded`
);
- if (!this.isRegistered()) {
+ if (this.isRegistered() === false) {
// Send BootNotification
let registrationRetryCount = 0;
do {
>(this, RequestCommand.BOOT_NOTIFICATION, this.bootNotificationRequest, {
skipBufferingOnError: true,
});
- if (!this.isRegistered()) {
+ if (this.isRegistered() === false) {
this.getRegistrationMaxRetries() !== -1 && registrationRetryCount++;
await Utils.sleep(
this.bootNotificationResponse?.interval
);
}
} while (
- !this.isRegistered() &&
+ this.isRegistered() === false &&
(registrationRetryCount <= this.getRegistrationMaxRetries() ||
this.getRegistrationMaxRetries() === -1)
);
}
- if (this.isRegistered()) {
- if (this.isInAcceptedState()) {
+ if (this.isRegistered() === true) {
+ if (this.isInAcceptedState() === true) {
await this.startMessageSequence();
}
} else {
}
private async startMessageSequence(): Promise<void> {
- if (this.stationInfo?.autoRegister) {
+ if (this.stationInfo?.autoRegister === true) {
await this.ocppRequestService.requestHandler<
BootNotificationRequest,
BootNotificationResponse
} else if (
!this.getConnectorStatus(connectorId)?.status &&
(this.isChargingStationAvailable() === false ||
- (this.isChargingStationAvailable() === true &&
- this.isConnectorAvailable(connectorId) === false))
+ this.isConnectorAvailable(connectorId) === false)
) {
chargePointStatus = ChargePointStatus.UNAVAILABLE;
} else if (
if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
this.webSocketPingSetInterval = setInterval(() => {
if (this.isWebSocketConnectionOpened() === true) {
- this.wsConnection.ping((): void => {
- /* This is intentional */
- });
+ this.wsConnection.ping();
}
}, webSocketPingInterval * 1000);
logger.info(
} else if (this.webSocketPingSetInterval) {
logger.info(
this.logPrefix() +
- ' WebSocket ping every ' +
- Utils.formatDurationSeconds(webSocketPingInterval) +
- ' already started'
+ ' WebSocket ping already started every ' +
+ Utils.formatDurationSeconds(webSocketPingInterval)
);
} else {
logger.error(
if (HeartBeatInterval) {
return Utils.convertToInt(HeartBeatInterval.value) * 1000;
}
- !this.stationInfo?.autoRegister &&
+ this.stationInfo?.autoRegister === false &&
logger.warn(
`${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${
Constants.DEFAULT_HEARTBEAT_INTERVAL
? reconnectDelay - reconnectDelayWithdraw
: 0;
logger.error(
- `${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(
+ `${this.logPrefix()} WebSocket connection retry in ${Utils.roundTo(
reconnectDelay,
2
)}ms, timeout ${reconnectTimeout}ms`
);
await Utils.sleep(reconnectDelay);
logger.error(
- this.logPrefix() +
- ' WebSocket: reconnecting try #' +
- this.autoReconnectRetryCount.toString()
+ this.logPrefix() + ' WebSocket connection retry #' + this.autoReconnectRetryCount.toString()
);
this.openWSConnection(
{ ...(this.stationInfo?.wsOptions ?? {}), handshakeTimeout: reconnectTimeout },
this.wsConnectionRestarted = true;
} else if (this.getAutoReconnectMaxRetries() !== -1) {
logger.error(
- `${this.logPrefix()} WebSocket reconnect failure: maximum retries reached (${
+ `${this.logPrefix()} WebSocket connection retries failure: maximum retries reached (${
this.autoReconnectRetryCount
- }) or retry disabled (${this.getAutoReconnectMaxRetries()})`
+ }) or retries disabled (${this.getAutoReconnectMaxRetries()})`
);
}
}