X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2F1.6%2FOCPP16ServiceUtils.ts;h=b8048927ccb824f4ff8e20320cfd356c33af6f0f;hb=5dc7c990eff43659bd48589cfc5afe09f9ec6664;hp=4062bc0af881d3445fdfc5207983d531dbf89b2a;hpb=41f3983a4f934199769f9ef1c46bfae2adc22b56;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts b/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts index 4062bc0a..b8048927 100644 --- a/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts +++ b/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts @@ -1,6 +1,6 @@ // Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. -import type { JSONSchemaType } from 'ajv'; +import type { JSONSchemaType } from 'ajv' import { type Interval, addSeconds, @@ -8,20 +8,21 @@ import { differenceInSeconds, isAfter, isBefore, - isWithinInterval, -} from 'date-fns'; + isWithinInterval +} from 'date-fns' -import { OCPP16Constants } from './OCPP16Constants'; +import { OCPP16Constants } from './OCPP16Constants.js' import { type ChargingStation, hasFeatureProfile, - hasReservationExpired, -} from '../../../charging-station'; + hasReservationExpired +} from '../../../charging-station/index.js' import { + type ConfigurationKey, type GenericResponse, type JsonType, OCPP16AuthorizationStatus, - OCPP16AvailabilityType, + type OCPP16AvailabilityType, type OCPP16ChangeAvailabilityResponse, OCPP16ChargePointStatus, type OCPP16ChargingProfile, @@ -31,251 +32,274 @@ import { type OCPP16MeterValue, OCPP16MeterValueContext, OCPP16MeterValueUnit, - OCPP16RequestCommand, + type OCPP16RequestCommand, OCPP16StandardParametersKey, OCPP16StopTransactionReason, type OCPP16SupportedFeatureProfiles, - OCPPVersion, -} from '../../../types'; -import { isNotEmptyArray, isNullOrUndefined, logger, roundTo } from '../../../utils'; -import { OCPPServiceUtils } from '../OCPPServiceUtils'; + OCPPVersion +} from '../../../types/index.js' +import { convertToDate, isNotEmptyArray, logger, roundTo } from '../../../utils/index.js' +import { OCPPServiceUtils } from '../OCPPServiceUtils.js' export class OCPP16ServiceUtils extends OCPPServiceUtils { - public static checkFeatureProfile( + public static checkFeatureProfile ( chargingStation: ChargingStation, featureProfile: OCPP16SupportedFeatureProfiles, - command: OCPP16RequestCommand | OCPP16IncomingRequestCommand, + command: OCPP16RequestCommand | OCPP16IncomingRequestCommand ): boolean { - if (!hasFeatureProfile(chargingStation, featureProfile)) { + if (hasFeatureProfile(chargingStation, featureProfile) === false) { logger.warn( `${chargingStation.logPrefix()} Trying to '${command}' without '${featureProfile}' feature enabled in ${ OCPP16StandardParametersKey.SupportedFeatureProfiles - } in configuration`, - ); - return false; + } in configuration` + ) + return false } - return true; + return true } - public static buildTransactionBeginMeterValue( + public static buildTransactionBeginMeterValue ( chargingStation: ChargingStation, connectorId: number, - meterStart: number, + meterStart: number | undefined ): OCPP16MeterValue { const meterValue: OCPP16MeterValue = { timestamp: new Date(), - sampledValue: [], - }; + sampledValue: [] + } // Energy.Active.Import.Register measurand (default) const sampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, - connectorId, - ); + connectorId + ) const unitDivider = - sampledValueTemplate?.unit === OCPP16MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; + sampledValueTemplate?.unit === OCPP16MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1 meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion sampledValueTemplate!, roundTo((meterStart ?? 0) / unitDivider, 4), - OCPP16MeterValueContext.TRANSACTION_BEGIN, - ), - ); - return meterValue; + OCPP16MeterValueContext.TRANSACTION_BEGIN + ) + ) + return meterValue } - public static buildTransactionDataMeterValues( + public static buildTransactionDataMeterValues ( transactionBeginMeterValue: OCPP16MeterValue, - transactionEndMeterValue: OCPP16MeterValue, + transactionEndMeterValue: OCPP16MeterValue ): OCPP16MeterValue[] { - const meterValues: OCPP16MeterValue[] = []; - meterValues.push(transactionBeginMeterValue); - meterValues.push(transactionEndMeterValue); - return meterValues; + const meterValues: OCPP16MeterValue[] = [] + meterValues.push(transactionBeginMeterValue) + meterValues.push(transactionEndMeterValue) + return meterValues } public static remoteStopTransaction = async ( chargingStation: ChargingStation, - connectorId: number, + connectorId: number ): Promise => { await OCPP16ServiceUtils.sendAndSetConnectorStatus( chargingStation, connectorId, - OCPP16ChargePointStatus.Finishing, - ); + OCPP16ChargePointStatus.Finishing + ) const stopResponse = await chargingStation.stopTransactionOnConnector( connectorId, - OCPP16StopTransactionReason.REMOTE, - ); + OCPP16StopTransactionReason.REMOTE + ) if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) { - return OCPP16Constants.OCPP_RESPONSE_ACCEPTED; + return OCPP16Constants.OCPP_RESPONSE_ACCEPTED } - return OCPP16Constants.OCPP_RESPONSE_REJECTED; - }; + return OCPP16Constants.OCPP_RESPONSE_REJECTED + } public static changeAvailability = async ( chargingStation: ChargingStation, connectorIds: number[], chargePointStatus: OCPP16ChargePointStatus, - availabilityType: OCPP16AvailabilityType, + availabilityType: OCPP16AvailabilityType ): Promise => { - const responses: OCPP16ChangeAvailabilityResponse[] = []; + const responses: OCPP16ChangeAvailabilityResponse[] = [] for (const connectorId of connectorIds) { let response: OCPP16ChangeAvailabilityResponse = - OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED; - const connectorStatus = chargingStation.getConnectorStatus(connectorId)!; - if (connectorStatus?.transactionStarted === true) { - response = OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED; + OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const connectorStatus = chargingStation.getConnectorStatus(connectorId)! + if (connectorStatus.transactionStarted === true) { + response = OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED } - connectorStatus.availability = availabilityType; + connectorStatus.availability = availabilityType if (response === OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED) { await OCPP16ServiceUtils.sendAndSetConnectorStatus( chargingStation, connectorId, - chargePointStatus, - ); + chargePointStatus + ) } - responses.push(response); + responses.push(response) } if (responses.includes(OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED)) { - return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED; + return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED } - return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED; - }; + return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED + } - public static setChargingProfile( + public static setChargingProfile ( chargingStation: ChargingStation, connectorId: number, - cp: OCPP16ChargingProfile, + cp: OCPP16ChargingProfile ): void { - if (isNullOrUndefined(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { + if (chargingStation.getConnectorStatus(connectorId)?.chargingProfiles == null) { logger.error( - `${chargingStation.logPrefix()} Trying to set a charging profile on connector id ${connectorId} with an uninitialized charging profiles array attribute, applying deferred initialization`, - ); - chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = []; + `${chargingStation.logPrefix()} Trying to set a charging profile on connector id ${connectorId} with an uninitialized charging profiles array attribute, applying deferred initialization` + ) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = [] } - if ( - Array.isArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles) === false - ) { + if (!Array.isArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { logger.error( - `${chargingStation.logPrefix()} Trying to set a charging profile on connector id ${connectorId} with an improper attribute type for the charging profiles array, applying proper type deferred initialization`, - ); - chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = []; + `${chargingStation.logPrefix()} Trying to set a charging profile on connector id ${connectorId} with an improper attribute type for the charging profiles array, applying proper type deferred initialization` + ) + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = [] } - let cpReplaced = false; + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + cp.chargingSchedule.startSchedule = convertToDate(cp.chargingSchedule.startSchedule)! + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + cp.validFrom = convertToDate(cp.validFrom)! + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + cp.validTo = convertToDate(cp.validTo)! + let cpReplaced = false if (isNotEmptyArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { - chargingStation - .getConnectorStatus(connectorId) - ?.chargingProfiles?.forEach((chargingProfile: OCPP16ChargingProfile, index: number) => { - if ( - chargingProfile.chargingProfileId === cp.chargingProfileId || - (chargingProfile.stackLevel === cp.stackLevel && - chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose) - ) { - chargingStation.getConnectorStatus(connectorId)!.chargingProfiles![index] = cp; - cpReplaced = true; - } - }); + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + for (const [index, chargingProfile] of chargingStation + .getConnectorStatus(connectorId)! + .chargingProfiles!.entries()) { + if ( + chargingProfile.chargingProfileId === cp.chargingProfileId || + (chargingProfile.stackLevel === cp.stackLevel && + chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose) + ) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles![index] = cp + cpReplaced = true + } + } } - !cpReplaced && chargingStation.getConnectorStatus(connectorId)?.chargingProfiles?.push(cp); + !cpReplaced && chargingStation.getConnectorStatus(connectorId)?.chargingProfiles?.push(cp) } public static clearChargingProfiles = ( chargingStation: ChargingStation, commandPayload: OCPP16ClearChargingProfileRequest, - chargingProfiles: OCPP16ChargingProfile[] | undefined, + chargingProfiles: OCPP16ChargingProfile[] | undefined ): boolean => { - const { id, chargingProfilePurpose, stackLevel } = commandPayload; - let clearedCP = false; + const { id, chargingProfilePurpose, stackLevel } = commandPayload + let clearedCP = false if (isNotEmptyArray(chargingProfiles)) { - chargingProfiles?.forEach((chargingProfile: OCPP16ChargingProfile, index: number) => { - let clearCurrentCP = false; + chargingProfiles.forEach((chargingProfile: OCPP16ChargingProfile, index: number) => { + let clearCurrentCP = false if (chargingProfile.chargingProfileId === id) { - clearCurrentCP = true; + clearCurrentCP = true } - if (!chargingProfilePurpose && chargingProfile.stackLevel === stackLevel) { - clearCurrentCP = true; + if (chargingProfilePurpose == null && chargingProfile.stackLevel === stackLevel) { + clearCurrentCP = true } - if (!stackLevel && chargingProfile.chargingProfilePurpose === chargingProfilePurpose) { - clearCurrentCP = true; + if ( + stackLevel == null && + chargingProfile.chargingProfilePurpose === chargingProfilePurpose + ) { + clearCurrentCP = true } if ( chargingProfile.stackLevel === stackLevel && chargingProfile.chargingProfilePurpose === chargingProfilePurpose ) { - clearCurrentCP = true; + clearCurrentCP = true } if (clearCurrentCP) { - chargingProfiles.splice(index, 1); + chargingProfiles.splice(index, 1) logger.debug( `${chargingStation.logPrefix()} Matching charging profile(s) cleared: %j`, - chargingProfile, - ); - clearedCP = true; + chargingProfile + ) + clearedCP = true } - }); + }) } - return clearedCP; - }; + return clearedCP + } public static composeChargingSchedules = ( chargingScheduleHigher: OCPP16ChargingSchedule | undefined, chargingScheduleLower: OCPP16ChargingSchedule | undefined, - compositeInterval: Interval, + compositeInterval: Interval ): OCPP16ChargingSchedule | undefined => { - if (!chargingScheduleHigher && !chargingScheduleLower) { - return undefined; + if (chargingScheduleHigher == null && chargingScheduleLower == null) { + return undefined } - if (chargingScheduleHigher && !chargingScheduleLower) { - return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher, compositeInterval); + if (chargingScheduleHigher != null && chargingScheduleLower == null) { + return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher, compositeInterval) } - if (!chargingScheduleHigher && chargingScheduleLower) { - return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower, compositeInterval); + if (chargingScheduleHigher == null && chargingScheduleLower != null) { + return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower, compositeInterval) } const compositeChargingScheduleHigher: OCPP16ChargingSchedule | undefined = - OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher!, compositeInterval); + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher!, compositeInterval) const compositeChargingScheduleLower: OCPP16ChargingSchedule | undefined = - OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower!, compositeInterval); + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower!, compositeInterval) const compositeChargingScheduleHigherInterval: Interval = { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion start: compositeChargingScheduleHigher!.startSchedule!, end: addSeconds( + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion compositeChargingScheduleHigher!.startSchedule!, - compositeChargingScheduleHigher!.duration!, - ), - }; + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + compositeChargingScheduleHigher!.duration! + ) + } const compositeChargingScheduleLowerInterval: Interval = { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion start: compositeChargingScheduleLower!.startSchedule!, end: addSeconds( + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion compositeChargingScheduleLower!.startSchedule!, - compositeChargingScheduleLower!.duration!, - ), - }; + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + compositeChargingScheduleLower!.duration! + ) + } const higherFirst = isBefore( compositeChargingScheduleHigherInterval.start, - compositeChargingScheduleLowerInterval.start, - ); + compositeChargingScheduleLowerInterval.start + ) if ( !areIntervalsOverlapping( compositeChargingScheduleHigherInterval, - compositeChargingScheduleLowerInterval, + compositeChargingScheduleLowerInterval ) ) { return { ...compositeChargingScheduleLower, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion ...compositeChargingScheduleHigher!, startSchedule: higherFirst ? (compositeChargingScheduleHigherInterval.start as Date) : (compositeChargingScheduleLowerInterval.start as Date), duration: higherFirst ? differenceInSeconds( - compositeChargingScheduleLowerInterval.end, - compositeChargingScheduleHigherInterval.start, - ) + compositeChargingScheduleLowerInterval.end, + compositeChargingScheduleHigherInterval.start + ) : differenceInSeconds( - compositeChargingScheduleHigherInterval.end, - compositeChargingScheduleLowerInterval.start, - ), + compositeChargingScheduleHigherInterval.end, + compositeChargingScheduleLowerInterval.start + ), chargingSchedulePeriod: [ - ...compositeChargingScheduleHigher!.chargingSchedulePeriod.map((schedulePeriod) => { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ...compositeChargingScheduleHigher!.chargingSchedulePeriod.map(schedulePeriod => { return { ...schedulePeriod, startPeriod: higherFirst @@ -283,42 +307,45 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { : schedulePeriod.startPeriod + differenceInSeconds( compositeChargingScheduleHigherInterval.start, - compositeChargingScheduleLowerInterval.start, - ), - }; + compositeChargingScheduleLowerInterval.start + ) + } }), - ...compositeChargingScheduleLower!.chargingSchedulePeriod.map((schedulePeriod) => { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ...compositeChargingScheduleLower!.chargingSchedulePeriod.map(schedulePeriod => { return { ...schedulePeriod, startPeriod: higherFirst ? schedulePeriod.startPeriod + differenceInSeconds( compositeChargingScheduleLowerInterval.start, - compositeChargingScheduleHigherInterval.start, + compositeChargingScheduleHigherInterval.start ) - : 0, - }; - }), - ].sort((a, b) => a.startPeriod - b.startPeriod), - }; + : 0 + } + }) + ].sort((a, b) => a.startPeriod - b.startPeriod) + } } return { ...compositeChargingScheduleLower, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion ...compositeChargingScheduleHigher!, startSchedule: higherFirst ? (compositeChargingScheduleHigherInterval.start as Date) : (compositeChargingScheduleLowerInterval.start as Date), duration: higherFirst ? differenceInSeconds( - compositeChargingScheduleLowerInterval.end, - compositeChargingScheduleHigherInterval.start, - ) + compositeChargingScheduleLowerInterval.end, + compositeChargingScheduleHigherInterval.start + ) : differenceInSeconds( - compositeChargingScheduleHigherInterval.end, - compositeChargingScheduleLowerInterval.start, - ), + compositeChargingScheduleHigherInterval.end, + compositeChargingScheduleLowerInterval.start + ), chargingSchedulePeriod: [ - ...compositeChargingScheduleHigher!.chargingSchedulePeriod.map((schedulePeriod) => { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ...compositeChargingScheduleHigher!.chargingSchedulePeriod.map(schedulePeriod => { return { ...schedulePeriod, startPeriod: higherFirst @@ -326,10 +353,11 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { : schedulePeriod.startPeriod + differenceInSeconds( compositeChargingScheduleHigherInterval.start, - compositeChargingScheduleLowerInterval.start, - ), - }; + compositeChargingScheduleLowerInterval.start + ) + } }), + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion ...compositeChargingScheduleLower!.chargingSchedulePeriod .filter((schedulePeriod, index) => { if ( @@ -337,62 +365,64 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { isWithinInterval( addSeconds( compositeChargingScheduleLowerInterval.start, - schedulePeriod.startPeriod, + schedulePeriod.startPeriod ), { start: compositeChargingScheduleLowerInterval.start, - end: compositeChargingScheduleHigherInterval.end, - }, + end: compositeChargingScheduleHigherInterval.end + } ) ) { - return false; + return false } if ( higherFirst && + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion index < compositeChargingScheduleLower!.chargingSchedulePeriod.length - 1 && !isWithinInterval( addSeconds( compositeChargingScheduleLowerInterval.start, - schedulePeriod.startPeriod, + schedulePeriod.startPeriod ), { start: compositeChargingScheduleLowerInterval.start, - end: compositeChargingScheduleHigherInterval.end, - }, + end: compositeChargingScheduleHigherInterval.end + } ) && isWithinInterval( addSeconds( compositeChargingScheduleLowerInterval.start, - compositeChargingScheduleLower!.chargingSchedulePeriod[index + 1].startPeriod, + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + compositeChargingScheduleLower!.chargingSchedulePeriod[index + 1].startPeriod ), { start: compositeChargingScheduleLowerInterval.start, - end: compositeChargingScheduleHigherInterval.end, - }, + end: compositeChargingScheduleHigherInterval.end + } ) ) { - return false; + return false } if ( !higherFirst && isWithinInterval( addSeconds( compositeChargingScheduleLowerInterval.start, - schedulePeriod.startPeriod, + schedulePeriod.startPeriod ), { start: compositeChargingScheduleHigherInterval.start, - end: compositeChargingScheduleLowerInterval.end, - }, + end: compositeChargingScheduleLowerInterval.end + } ) ) { - return false; + return false } - return true; + return true }) .map((schedulePeriod, index) => { if (index === 0 && schedulePeriod.startPeriod !== 0) { - schedulePeriod.startPeriod = 0; + schedulePeriod.startPeriod = 0 } return { ...schedulePeriod, @@ -400,126 +430,136 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { ? schedulePeriod.startPeriod + differenceInSeconds( compositeChargingScheduleLowerInterval.start, - compositeChargingScheduleHigherInterval.start, + compositeChargingScheduleHigherInterval.start ) - : 0, - }; - }), - ].sort((a, b) => a.startPeriod - b.startPeriod), - }; - }; + : 0 + } + }) + ].sort((a, b) => a.startPeriod - b.startPeriod) + } + } + + public static isConfigurationKeyVisible (key: ConfigurationKey): boolean { + if (key.visible == null) { + return true + } + return key.visible + } public static hasReservation = ( chargingStation: ChargingStation, connectorId: number, - idTag: string, + idTag: string ): boolean => { - const connectorReservation = chargingStation.getReservationBy('connectorId', connectorId); - const chargingStationReservation = chargingStation.getReservationBy('connectorId', 0); + const connectorReservation = chargingStation.getReservationBy('connectorId', connectorId) + const chargingStationReservation = chargingStation.getReservationBy('connectorId', 0) if ( (chargingStation.getConnectorStatus(connectorId)?.status === OCPP16ChargePointStatus.Reserved && - connectorReservation && + connectorReservation != null && !hasReservationExpired(connectorReservation) && - // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing - connectorReservation?.idTag === idTag) || + connectorReservation.idTag === idTag) || (chargingStation.getConnectorStatus(0)?.status === OCPP16ChargePointStatus.Reserved && - chargingStationReservation && + chargingStationReservation != null && !hasReservationExpired(chargingStationReservation) && - chargingStationReservation?.idTag === idTag) + chargingStationReservation.idTag === idTag) ) { logger.debug( `${chargingStation.logPrefix()} Connector id ${connectorId} has a valid reservation for idTag ${idTag}: %j`, - connectorReservation ?? chargingStationReservation, - ); - return true; + connectorReservation ?? chargingStationReservation + ) + return true } - return false; - }; + return false + } public static parseJsonSchemaFile( relativePath: string, moduleName?: string, - methodName?: string, + methodName?: string ): JSONSchemaType { return super.parseJsonSchemaFile( relativePath, OCPPVersion.VERSION_16, moduleName, - methodName, - ); + methodName + ) } - private static composeChargingSchedule = ( + private static readonly composeChargingSchedule = ( chargingSchedule: OCPP16ChargingSchedule, - compositeInterval: Interval, + compositeInterval: Interval ): OCPP16ChargingSchedule | undefined => { const chargingScheduleInterval: Interval = { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion start: chargingSchedule.startSchedule!, - end: addSeconds(chargingSchedule.startSchedule!, chargingSchedule.duration!), - }; + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + end: addSeconds(chargingSchedule.startSchedule!, chargingSchedule.duration!) + } if (areIntervalsOverlapping(chargingScheduleInterval, compositeInterval)) { - chargingSchedule.chargingSchedulePeriod.sort((a, b) => a.startPeriod - b.startPeriod); + chargingSchedule.chargingSchedulePeriod.sort((a, b) => a.startPeriod - b.startPeriod) if (isBefore(chargingScheduleInterval.start, compositeInterval.start)) { return { ...chargingSchedule, startSchedule: compositeInterval.start as Date, duration: differenceInSeconds( chargingScheduleInterval.end, - compositeInterval.start as Date, + compositeInterval.start as Date ), chargingSchedulePeriod: chargingSchedule.chargingSchedulePeriod .filter((schedulePeriod, index) => { if ( isWithinInterval( + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion addSeconds(chargingScheduleInterval.start, schedulePeriod.startPeriod)!, - compositeInterval, + compositeInterval ) ) { - return true; + return true } if ( index < chargingSchedule.chargingSchedulePeriod.length - 1 && !isWithinInterval( addSeconds(chargingScheduleInterval.start, schedulePeriod.startPeriod), - compositeInterval, + compositeInterval ) && isWithinInterval( addSeconds( chargingScheduleInterval.start, - chargingSchedule.chargingSchedulePeriod[index + 1].startPeriod, + chargingSchedule.chargingSchedulePeriod[index + 1].startPeriod ), - compositeInterval, + compositeInterval ) ) { - return true; + return true } - return false; + return false }) .map((schedulePeriod, index) => { if (index === 0 && schedulePeriod.startPeriod !== 0) { - schedulePeriod.startPeriod = 0; + schedulePeriod.startPeriod = 0 } - return schedulePeriod; - }), - }; + return schedulePeriod + }) + } } if (isAfter(chargingScheduleInterval.end, compositeInterval.end)) { return { ...chargingSchedule, duration: differenceInSeconds( compositeInterval.end as Date, - chargingScheduleInterval.start, + chargingScheduleInterval.start ), - chargingSchedulePeriod: chargingSchedule.chargingSchedulePeriod.filter((schedulePeriod) => + chargingSchedulePeriod: chargingSchedule.chargingSchedulePeriod.filter(schedulePeriod => isWithinInterval( + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion addSeconds(chargingScheduleInterval.start, schedulePeriod.startPeriod)!, - compositeInterval, - ), - ), - }; + compositeInterval + ) + ) + } } - return chargingSchedule; + return chargingSchedule } - }; + } }