src/charging-station/ocpp/1.6/OCPP16RequestService.ts

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import fs from 'fs';
   4 import path from 'path';
   5 import { fileURLToPath } from 'url';
   6
   7 import type { JSONSchemaType } from 'ajv';
   8
   9 import OCPPError from '../../../exception/OCPPError';
  10 import type { JsonObject, JsonType } from '../../../types/JsonType';
  11 import type { OCPP16MeterValuesRequest } from '../../../types/ocpp/1.6/MeterValues';
  12 import {
  13   DiagnosticsStatusNotificationRequest,
  14   OCPP16BootNotificationRequest,
  15   OCPP16HeartbeatRequest,
  16   OCPP16RequestCommand,
  17   OCPP16StatusNotificationRequest,
  18 } from '../../../types/ocpp/1.6/Requests';
  19 import type {
  20   OCPP16AuthorizeRequest,
  21   OCPP16StartTransactionRequest,
  22   OCPP16StopTransactionRequest,
  23 } from '../../../types/ocpp/1.6/Transaction';
  24 import { ErrorType } from '../../../types/ocpp/ErrorType';
  25 import type { RequestParams } from '../../../types/ocpp/Requests';
  26 import Constants from '../../../utils/Constants';
  27 import logger from '../../../utils/Logger';
  28 import Utils from '../../../utils/Utils';
  29 import type ChargingStation from '../../ChargingStation';
  30 import OCPPRequestService from '../OCPPRequestService';
  31 import type OCPPResponseService from '../OCPPResponseService';
  32 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
  33
  34 const moduleName = 'OCPP16RequestService';
  35
  36 export default class OCPP16RequestService extends OCPPRequestService {
  37   private jsonSchemas: Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>;
  38
  39   public constructor(ocppResponseService: OCPPResponseService) {
  40     if (new.target?.name === moduleName) {
  41       throw new TypeError(`Cannot construct ${new.target?.name} instances directly`);
  42     }
  43     super(ocppResponseService);
  44     this.jsonSchemas = new Map<OCPP16RequestCommand, JSONSchemaType<JsonObject>>([
  45       [
  46         OCPP16RequestCommand.AUTHORIZE,
  47         JSON.parse(
  48           fs.readFileSync(
  49             path.resolve(
  50               path.dirname(fileURLToPath(import.meta.url)),
  51               '../../../assets/json-schemas/ocpp/1.6/Authorize.json'
  52             ),
  53             'utf8'
  54           )
  55         ) as JSONSchemaType<OCPP16AuthorizeRequest>,
  56       ],
  57       [
  58         OCPP16RequestCommand.BOOT_NOTIFICATION,
  59         JSON.parse(
  60           fs.readFileSync(
  61             path.resolve(
  62               path.dirname(fileURLToPath(import.meta.url)),
  63               '../../../assets/json-schemas/ocpp/1.6/BootNotification.json'
  64             ),
  65             'utf8'
  66           )
  67         ) as JSONSchemaType<OCPP16BootNotificationRequest>,
  68       ],
  69       [
  70         OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION,
  71         JSON.parse(
  72           fs.readFileSync(
  73             path.resolve(
  74               path.dirname(fileURLToPath(import.meta.url)),
  75               '../../../assets/json-schemas/ocpp/1.6/DiagnosticsStatusNotification.json'
  76             ),
  77             'utf8'
  78           )
  79         ) as JSONSchemaType<DiagnosticsStatusNotificationRequest>,
  80       ],
  81       [
  82         OCPP16RequestCommand.HEARTBEAT,
  83         JSON.parse(
  84           fs.readFileSync(
  85             path.resolve(
  86               path.dirname(fileURLToPath(import.meta.url)),
  87               '../../../assets/json-schemas/ocpp/1.6/Heartbeat.json'
  88             ),
  89             'utf8'
  90           )
  91         ) as JSONSchemaType<OCPP16HeartbeatRequest>,
  92       ],
  93       [
  94         OCPP16RequestCommand.METER_VALUES,
  95         JSON.parse(
  96           fs.readFileSync(
  97             path.resolve(
  98               path.dirname(fileURLToPath(import.meta.url)),
  99               '../../../assets/json-schemas/ocpp/1.6/MeterValues.json'
 100             ),
 101             'utf8'
 102           )
 103         ) as JSONSchemaType<OCPP16MeterValuesRequest>,
 104       ],
 105       [
 106         OCPP16RequestCommand.STATUS_NOTIFICATION,
 107         JSON.parse(
 108           fs.readFileSync(
 109             path.resolve(
 110               path.dirname(fileURLToPath(import.meta.url)),
 111               '../../../assets/json-schemas/ocpp/1.6/StatusNotification.json'
 112             ),
 113             'utf8'
 114           )
 115         ) as JSONSchemaType<OCPP16StatusNotificationRequest>,
 116       ],
 117       [
 118         OCPP16RequestCommand.START_TRANSACTION,
 119         JSON.parse(
 120           fs.readFileSync(
 121             path.resolve(
 122               path.dirname(fileURLToPath(import.meta.url)),
 123               '../../../assets/json-schemas/ocpp/1.6/StartTransaction.json'
 124             ),
 125             'utf8'
 126           )
 127         ) as JSONSchemaType<OCPP16StartTransactionRequest>,
 128       ],
 129       [
 130         OCPP16RequestCommand.STOP_TRANSACTION,
 131         JSON.parse(
 132           fs.readFileSync(
 133             path.resolve(
 134               path.dirname(fileURLToPath(import.meta.url)),
 135               '../../../assets/json-schemas/ocpp/1.6/StopTransaction.json'
 136             ),
 137             'utf8'
 138           )
 139         ) as JSONSchemaType<OCPP16StopTransactionRequest>,
 140       ],
 141     ]);
 142     this.buildRequestPayload.bind(this);
 143     this.validatePayload.bind(this);
 144   }
 145
 146   public async requestHandler<RequestType extends JsonType, ResponseType extends JsonType>(
 147     chargingStation: ChargingStation,
 148     commandName: OCPP16RequestCommand,
 149     commandParams?: JsonType,
 150     params?: RequestParams
 151   ): Promise<ResponseType> {
 152     if (OCPP16ServiceUtils.isRequestCommandSupported(chargingStation, commandName)) {
 153       const requestPayload = this.buildRequestPayload<RequestType>(
 154         chargingStation,
 155         commandName,
 156         commandParams
 157       );
 158       this.validatePayload(chargingStation, commandName, requestPayload);
 159       return (await this.sendMessage(
 160         chargingStation,
 161         Utils.generateUUID(),
 162         requestPayload,
 163         commandName,
 164         params
 165       )) as unknown as ResponseType;
 166     }
 167     // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError().
 168     throw new OCPPError(
 169       ErrorType.NOT_SUPPORTED,
 170       `Unsupported OCPP command '${commandName}'`,
 171       commandName,
 172       commandParams
 173     );
 174   }
 175
 176   private buildRequestPayload<Request extends JsonType>(
 177     chargingStation: ChargingStation,
 178     commandName: OCPP16RequestCommand,
 179     commandParams?: JsonType
 180   ): Request {
 181     let connectorId: number;
 182     let energyActiveImportRegister: number;
 183     commandParams = commandParams as JsonObject;
 184     switch (commandName) {
 185       case OCPP16RequestCommand.AUTHORIZE:
 186         return {
 187           ...(!Utils.isUndefined(commandParams?.idTag)
 188             ? { idTag: commandParams.idTag }
 189             : { idTag: Constants.DEFAULT_IDTAG }),
 190         } as unknown as Request;
 191       case OCPP16RequestCommand.BOOT_NOTIFICATION:
 192         return {
 193           chargePointModel: commandParams?.chargePointModel,
 194           chargePointVendor: commandParams?.chargePointVendor,
 195           ...(!Utils.isUndefined(commandParams?.chargeBoxSerialNumber) && {
 196             chargeBoxSerialNumber: commandParams.chargeBoxSerialNumber,
 197           }),
 198           ...(!Utils.isUndefined(commandParams?.chargePointSerialNumber) && {
 199             chargePointSerialNumber: commandParams.chargePointSerialNumber,
 200           }),
 201           ...(!Utils.isUndefined(commandParams?.firmwareVersion) && {
 202             firmwareVersion: commandParams.firmwareVersion,
 203           }),
 204           ...(!Utils.isUndefined(commandParams?.iccid) && { iccid: commandParams.iccid }),
 205           ...(!Utils.isUndefined(commandParams?.imsi) && { imsi: commandParams.imsi }),
 206           ...(!Utils.isUndefined(commandParams?.meterSerialNumber) && {
 207             meterSerialNumber: commandParams.meterSerialNumber,
 208           }),
 209           ...(!Utils.isUndefined(commandParams?.meterType) && {
 210             meterType: commandParams.meterType,
 211           }),
 212         } as unknown as Request;
 213       case OCPP16RequestCommand.DIAGNOSTICS_STATUS_NOTIFICATION:
 214         return {
 215           status: commandParams?.diagnosticsStatus,
 216         } as unknown as Request;
 217       case OCPP16RequestCommand.HEARTBEAT:
 218         return {} as unknown as Request;
 219       case OCPP16RequestCommand.METER_VALUES:
 220         return {
 221           connectorId: commandParams?.connectorId,
 222           transactionId: commandParams?.transactionId,
 223           meterValue: commandParams?.meterValue,
 224         } as unknown as Request;
 225       case OCPP16RequestCommand.STATUS_NOTIFICATION:
 226         return {
 227           connectorId: commandParams?.connectorId,
 228           status: commandParams?.status,
 229           errorCode: commandParams?.errorCode,
 230         } as unknown as Request;
 231       case OCPP16RequestCommand.START_TRANSACTION:
 232         return {
 233           connectorId: commandParams?.connectorId,
 234           ...(!Utils.isUndefined(commandParams?.idTag)
 235             ? { idTag: commandParams?.idTag }
 236             : { idTag: Constants.DEFAULT_IDTAG }),
 237           meterStart: chargingStation.getEnergyActiveImportRegisterByConnectorId(
 238             commandParams?.connectorId as number
 239           ),
 240           timestamp: new Date().toISOString(),
 241         } as unknown as Request;
 242       case OCPP16RequestCommand.STOP_TRANSACTION:
 243         connectorId = chargingStation.getConnectorIdByTransactionId(
 244           commandParams?.transactionId as number
 245         );
 246         commandParams?.meterStop &&
 247           (energyActiveImportRegister =
 248             chargingStation.getEnergyActiveImportRegisterByTransactionId(
 249               commandParams?.transactionId as number,
 250               true
 251             ));
 252         return {
 253           transactionId: commandParams?.transactionId,
 254           idTag:
 255             commandParams?.idTag ??
 256             chargingStation.getTransactionIdTag(commandParams?.transactionId as number),
 257           meterStop: commandParams?.meterStop ?? energyActiveImportRegister,
 258           timestamp: new Date().toISOString(),
 259           reason: commandParams?.reason,
 260           ...(chargingStation.getTransactionDataMeterValues() && {
 261             transactionData: OCPP16ServiceUtils.buildTransactionDataMeterValues(
 262               chargingStation.getConnectorStatus(connectorId).transactionBeginMeterValue,
 263               OCPP16ServiceUtils.buildTransactionEndMeterValue(
 264                 chargingStation,
 265                 connectorId,
 266                 (commandParams?.meterStop as number) ?? energyActiveImportRegister
 267               )
 268             ),
 269           }),
 270         } as unknown as Request;
 271       default:
 272         // OCPPError usage here is debatable: it's an error in the OCPP stack but not targeted to sendError().
 273         throw new OCPPError(
 274           ErrorType.NOT_SUPPORTED,
 275           // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 276           `Unsupported OCPP command '${commandName}'`,
 277           commandName,
 278           commandParams
 279         );
 280     }
 281   }
 282
 283   private validatePayload<Request extends JsonType>(
 284     chargingStation: ChargingStation,
 285     commandName: OCPP16RequestCommand,
 286     requestPayload: Request
 287   ): boolean {
 288     if (this.jsonSchemas.has(commandName)) {
 289       return this.validateRequestPayload(
 290         chargingStation,
 291         commandName,
 292         this.jsonSchemas.get(commandName),
 293         requestPayload
 294       );
 295     }
 296     logger.warn(
 297       `${chargingStation.logPrefix()} ${moduleName}.validatePayload: No JSON schema found for command ${commandName} PDU validation`
 298     );
 299     return false;
 300   }
 301 }