src/charging-station/ocpp/OCPPIncomingRequestService.ts

   1 import Ajv, { type JSONSchemaType, type ValidateFunction } from 'ajv';
   2 import ajvFormats from 'ajv-formats';
   3
   4 import { OCPPConstants } from './OCPPConstants.js';
   5 import { OCPPServiceUtils } from './OCPPServiceUtils.js';
   6 import { type ChargingStation, getIdTagsFile } from '../../charging-station/index.js';
   7 import { OCPPError } from '../../exception/index.js';
   8 import type {
   9   ClearCacheResponse,
  10   HandleErrorParams,
  11   IncomingRequestCommand,
  12   JsonType,
  13   OCPPVersion,
  14 } from '../../types/index.js';
  15 import { logger, setDefaultErrorParams } from '../../utils/index.js';
  16
  17 const moduleName = 'OCPPIncomingRequestService';
  18
  19 export abstract class OCPPIncomingRequestService {
  20   private static instance: OCPPIncomingRequestService | null = null;
  21   private readonly version: OCPPVersion;
  22   private readonly ajv: Ajv;
  23   private jsonValidateFunctions: Map<IncomingRequestCommand, ValidateFunction<JsonType>>;
  24   protected abstract jsonSchemas: Map<IncomingRequestCommand, JSONSchemaType<JsonType>>;
  25
  26   protected constructor(version: OCPPVersion) {
  27     this.version = version;
  28     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
  29     this.ajv = new Ajv({
  30       keywords: ['javaType'],
  31       multipleOfPrecision: 2,
  32     });
  33     ajvFormats(this.ajv);
  34     this.jsonValidateFunctions = new Map<IncomingRequestCommand, ValidateFunction<JsonType>>();
  35     this.incomingRequestHandler = this.incomingRequestHandler.bind(this) as <
  36       ReqType extends JsonType,
  37       // eslint-disable-next-line @typescript-eslint/no-unused-vars
  38       ResType extends JsonType,
  39     >(
  40       chargingStation: ChargingStation,
  41       messageId: string,
  42       commandName: IncomingRequestCommand,
  43       commandPayload: ReqType,
  44     ) => Promise<void>;
  45     this.validateIncomingRequestPayload = this.validateIncomingRequestPayload.bind(this) as <
  46       T extends JsonType,
  47     >(
  48       chargingStation: ChargingStation,
  49       commandName: IncomingRequestCommand,
  50       schema: JSONSchemaType<T>,
  51       payload: T,
  52     ) => boolean;
  53   }
  54
  55   public static getInstance<T extends OCPPIncomingRequestService>(this: new () => T): T {
  56     if (OCPPIncomingRequestService.instance === null) {
  57       OCPPIncomingRequestService.instance = new this();
  58     }
  59     return OCPPIncomingRequestService.instance as T;
  60   }
  61
  62   protected handleIncomingRequestError<T extends JsonType>(
  63     chargingStation: ChargingStation,
  64     commandName: IncomingRequestCommand,
  65     error: Error,
  66     params: HandleErrorParams<T> = { throwError: true, consoleOut: false },
  67   ): T | undefined {
  68     setDefaultErrorParams(params);
  69     logger.error(
  70       `${chargingStation.logPrefix()} ${moduleName}.handleIncomingRequestError: Incoming request command '${commandName}' error:`,
  71       error,
  72     );
  73     if (!params?.throwError && params?.errorResponse) {
  74       return params?.errorResponse;
  75     }
  76     if (params?.throwError && !params?.errorResponse) {
  77       throw error;
  78     }
  79     if (params?.throwError && params?.errorResponse) {
  80       return params?.errorResponse;
  81     }
  82   }
  83
  84   protected validateIncomingRequestPayload<T extends JsonType>(
  85     chargingStation: ChargingStation,
  86     commandName: IncomingRequestCommand,
  87     schema: JSONSchemaType<T>,
  88     payload: T,
  89   ): boolean {
  90     if (chargingStation.stationInfo?.ocppStrictCompliance === false) {
  91       return true;
  92     }
  93     const validate = this.getJsonIncomingRequestValidateFunction<T>(commandName, schema);
  94     if (validate(payload)) {
  95       return true;
  96     }
  97     logger.error(
  98       `${chargingStation.logPrefix()} ${moduleName}.validateIncomingRequestPayload: Command '${commandName}' incoming request PDU is invalid: %j`,
  99       validate.errors,
 100     );
 101     throw new OCPPError(
 102       OCPPServiceUtils.ajvErrorsToErrorType(validate.errors),
 103       'Incoming request PDU is invalid',
 104       commandName,
 105       JSON.stringify(validate.errors, undefined, 2),
 106     );
 107   }
 108
 109   protected handleRequestClearCache(chargingStation: ChargingStation): ClearCacheResponse {
 110     if (chargingStation.idTagsCache.deleteIdTags(getIdTagsFile(chargingStation.stationInfo)!)) {
 111       return OCPPConstants.OCPP_RESPONSE_ACCEPTED;
 112     }
 113     return OCPPConstants.OCPP_RESPONSE_REJECTED;
 114   }
 115
 116   private getJsonIncomingRequestValidateFunction<T extends JsonType>(
 117     commandName: IncomingRequestCommand,
 118     schema: JSONSchemaType<T>,
 119   ) {
 120     if (this.jsonValidateFunctions.has(commandName) === false) {
 121       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 122       this.jsonValidateFunctions.set(commandName, this.ajv.compile<T>(schema).bind(this));
 123     }
 124     return this.jsonValidateFunctions.get(commandName)!;
 125   }
 126
 127   // eslint-disable-next-line @typescript-eslint/no-unused-vars
 128   public abstract incomingRequestHandler<ReqType extends JsonType, ResType extends JsonType>(
 129     chargingStation: ChargingStation,
 130     messageId: string,
 131     commandName: IncomingRequestCommand,
 132     commandPayload: ReqType,
 133   ): Promise<void>;
 134 }