src/charging-station/ocpp/OCPPServiceUtils.ts

   1 import type { DefinedError, ErrorObject } from 'ajv';
   2
   3 import BaseError from '../../exception/BaseError';
   4 import type { JsonObject, JsonType } from '../../types/JsonType';
   5 import type { SampledValueTemplate } from '../../types/MeasurandPerPhaseSampledValueTemplates';
   6 import type { OCPP16StatusNotificationRequest } from '../../types/ocpp/1.6/Requests';
   7 import type { OCPP20StatusNotificationRequest } from '../../types/ocpp/2.0/Requests';
   8 import { ChargePointErrorCode } from '../../types/ocpp/ChargePointErrorCode';
   9 import { StandardParametersKey } from '../../types/ocpp/Configuration';
  10 import type { ConnectorStatusEnum } from '../../types/ocpp/ConnectorStatusEnum';
  11 import { ErrorType } from '../../types/ocpp/ErrorType';
  12 import { MeterValueMeasurand, type MeterValuePhase } from '../../types/ocpp/MeterValues';
  13 import { OCPPVersion } from '../../types/ocpp/OCPPVersion';
  14 import {
  15   IncomingRequestCommand,
  16   MessageTrigger,
  17   RequestCommand,
  18   type StatusNotificationRequest,
  19 } from '../../types/ocpp/Requests';
  20 import Constants from '../../utils/Constants';
  21 import logger from '../../utils/Logger';
  22 import Utils from '../../utils/Utils';
  23 import type ChargingStation from '../ChargingStation';
  24 import { ChargingStationConfigurationUtils } from '../ChargingStationConfigurationUtils';
  25
  26 export class OCPPServiceUtils {
  27   protected constructor() {
  28     // This is intentional
  29   }
  30
  31   public static ajvErrorsToErrorType(errors: ErrorObject[]): ErrorType {
  32     for (const error of errors as DefinedError[]) {
  33       switch (error.keyword) {
  34         case 'type':
  35           return ErrorType.TYPE_CONSTRAINT_VIOLATION;
  36         case 'dependencies':
  37         case 'required':
  38           return ErrorType.OCCURRENCE_CONSTRAINT_VIOLATION;
  39         case 'pattern':
  40         case 'format':
  41           return ErrorType.PROPERTY_CONSTRAINT_VIOLATION;
  42       }
  43     }
  44     return ErrorType.FORMAT_VIOLATION;
  45   }
  46
  47   public static isRequestCommandSupported(
  48     chargingStation: ChargingStation,
  49     command: RequestCommand
  50   ): boolean {
  51     const isRequestCommand = Object.values<RequestCommand>(RequestCommand).includes(command);
  52     if (
  53       isRequestCommand === true &&
  54       !chargingStation.stationInfo?.commandsSupport?.outgoingCommands
  55     ) {
  56       return true;
  57     } else if (
  58       isRequestCommand === true &&
  59       chargingStation.stationInfo?.commandsSupport?.outgoingCommands
  60     ) {
  61       return chargingStation.stationInfo?.commandsSupport?.outgoingCommands[command] ?? false;
  62     }
  63     logger.error(`${chargingStation.logPrefix()} Unknown outgoing OCPP command '${command}'`);
  64     return false;
  65   }
  66
  67   public static isIncomingRequestCommandSupported(
  68     chargingStation: ChargingStation,
  69     command: IncomingRequestCommand
  70   ): boolean {
  71     const isIncomingRequestCommand =
  72       Object.values<IncomingRequestCommand>(IncomingRequestCommand).includes(command);
  73     if (
  74       isIncomingRequestCommand === true &&
  75       !chargingStation.stationInfo?.commandsSupport?.incomingCommands
  76     ) {
  77       return true;
  78     } else if (
  79       isIncomingRequestCommand === true &&
  80       chargingStation.stationInfo?.commandsSupport?.incomingCommands
  81     ) {
  82       return chargingStation.stationInfo?.commandsSupport?.incomingCommands[command] ?? false;
  83     }
  84     logger.error(`${chargingStation.logPrefix()} Unknown incoming OCPP command '${command}'`);
  85     return false;
  86   }
  87
  88   public static isMessageTriggerSupported(
  89     chargingStation: ChargingStation,
  90     messageTrigger: MessageTrigger
  91   ): boolean {
  92     const isMessageTrigger = Object.values(MessageTrigger).includes(messageTrigger);
  93     if (isMessageTrigger === true && !chargingStation.stationInfo?.messageTriggerSupport) {
  94       return true;
  95     } else if (isMessageTrigger === true && chargingStation.stationInfo?.messageTriggerSupport) {
  96       return chargingStation.stationInfo?.messageTriggerSupport[messageTrigger] ?? false;
  97     }
  98     logger.error(
  99       `${chargingStation.logPrefix()} Unknown incoming OCPP message trigger '${messageTrigger}'`
 100     );
 101     return false;
 102   }
 103
 104   public static isConnectorIdValid(
 105     chargingStation: ChargingStation,
 106     ocppCommand: IncomingRequestCommand,
 107     connectorId: number
 108   ): boolean {
 109     if (connectorId < 0) {
 110       logger.error(
 111         `${chargingStation.logPrefix()} ${ocppCommand} incoming request received with invalid connector Id ${connectorId}`
 112       );
 113       return false;
 114     }
 115     return true;
 116   }
 117
 118   public static convertDateToISOString<T extends JsonType>(obj: T): void {
 119     for (const key in obj) {
 120       if (obj[key] instanceof Date) {
 121         (obj as JsonObject)[key] = (obj[key] as Date).toISOString();
 122       } else if (obj[key] !== null && typeof obj[key] === 'object') {
 123         this.convertDateToISOString<T>(obj[key] as T);
 124       }
 125     }
 126   }
 127
 128   public static buildStatusNotificationRequest(
 129     chargingStation: ChargingStation,
 130     connectorId: number,
 131     status: ConnectorStatusEnum
 132   ): StatusNotificationRequest {
 133     switch (chargingStation.stationInfo.ocppVersion ?? OCPPVersion.VERSION_16) {
 134       case OCPPVersion.VERSION_16:
 135         return {
 136           connectorId,
 137           status,
 138           errorCode: ChargePointErrorCode.NO_ERROR,
 139         } as OCPP16StatusNotificationRequest;
 140       case OCPPVersion.VERSION_20:
 141       case OCPPVersion.VERSION_201:
 142         return {
 143           timestamp: new Date(),
 144           connectorStatus: status,
 145           connectorId,
 146           evseId: connectorId,
 147         } as OCPP20StatusNotificationRequest;
 148       default:
 149         throw new BaseError('Cannot build status notification payload: OCPP version not supported');
 150     }
 151   }
 152
 153   protected static getSampledValueTemplate(
 154     chargingStation: ChargingStation,
 155     connectorId: number,
 156     measurand: MeterValueMeasurand = MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER,
 157     phase?: MeterValuePhase
 158   ): SampledValueTemplate | undefined {
 159     const onPhaseStr = phase ? `on phase ${phase} ` : '';
 160     if (Constants.SUPPORTED_MEASURANDS.includes(measurand) === false) {
 161       logger.warn(
 162         `${chargingStation.logPrefix()} Trying to get unsupported MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}`
 163       );
 164       return;
 165     }
 166     if (
 167       measurand !== MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER &&
 168       ChargingStationConfigurationUtils.getConfigurationKey(
 169         chargingStation,
 170         StandardParametersKey.MeterValuesSampledData
 171       )?.value.includes(measurand) === false
 172     ) {
 173       logger.debug(
 174         `${chargingStation.logPrefix()} Trying to get MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId} not found in '${
 175           StandardParametersKey.MeterValuesSampledData
 176         }' OCPP parameter`
 177       );
 178       return;
 179     }
 180     const sampledValueTemplates: SampledValueTemplate[] =
 181       chargingStation.getConnectorStatus(connectorId).MeterValues;
 182     for (
 183       let index = 0;
 184       Utils.isEmptyArray(sampledValueTemplates) === false && index < sampledValueTemplates.length;
 185       index++
 186     ) {
 187       if (
 188         Constants.SUPPORTED_MEASURANDS.includes(
 189           sampledValueTemplates[index]?.measurand ??
 190             MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
 191         ) === false
 192       ) {
 193         logger.warn(
 194           `${chargingStation.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}`
 195         );
 196       } else if (
 197         phase &&
 198         sampledValueTemplates[index]?.phase === phase &&
 199         sampledValueTemplates[index]?.measurand === measurand &&
 200         ChargingStationConfigurationUtils.getConfigurationKey(
 201           chargingStation,
 202           StandardParametersKey.MeterValuesSampledData
 203         )?.value.includes(measurand) === true
 204       ) {
 205         return sampledValueTemplates[index];
 206       } else if (
 207         !phase &&
 208         !sampledValueTemplates[index].phase &&
 209         sampledValueTemplates[index]?.measurand === measurand &&
 210         ChargingStationConfigurationUtils.getConfigurationKey(
 211           chargingStation,
 212           StandardParametersKey.MeterValuesSampledData
 213         )?.value.includes(measurand) === true
 214       ) {
 215         return sampledValueTemplates[index];
 216       } else if (
 217         measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER &&
 218         (!sampledValueTemplates[index].measurand ||
 219           sampledValueTemplates[index].measurand === measurand)
 220       ) {
 221         return sampledValueTemplates[index];
 222       }
 223     }
 224     if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER) {
 225       const errorMsg = `Missing MeterValues for default measurand '${measurand}' in template on connectorId ${connectorId}`;
 226       logger.error(`${chargingStation.logPrefix()} ${errorMsg}`);
 227       throw new BaseError(errorMsg);
 228     }
 229     logger.debug(
 230       `${chargingStation.logPrefix()} No MeterValues for measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}`
 231     );
 232   }
 233
 234   protected static getLimitFromSampledValueTemplateCustomValue(
 235     value: string,
 236     limit: number,
 237     options: { limitationEnabled?: boolean; unitMultiplier?: number } = {
 238       limitationEnabled: true,
 239       unitMultiplier: 1,
 240     }
 241   ): number {
 242     options.limitationEnabled = options?.limitationEnabled ?? true;
 243     options.unitMultiplier = options?.unitMultiplier ?? 1;
 244     const parsedInt = parseInt(value);
 245     const numberValue = isNaN(parsedInt) ? Infinity : parsedInt;
 246     return options?.limitationEnabled
 247       ? Math.min(numberValue * options.unitMultiplier, limit)
 248       : numberValue * options.unitMultiplier;
 249   }
 250 }