Feature/persist installed certificate hashes

00_Base/src/index.ts

@@ -247,3 +247,4 @@ export { assert, notNull, deepDirectionalEqual } from './assertion/assertion';
 export { UnauthorizedError } from './interfaces/api/exception/UnauthorizedError';
 export { AuthorizationSecurity } from './interfaces/api/AuthorizationSecurity';
 export { Ajv };
+export declare type Constructable<T> = new (...args: any[]) => T;

00_Base/src/interfaces/repository.ts

@@ -63,6 +63,15 @@ export abstract class CrudRepository<T> extends EventEmitter {
     return result;
   }
 
+  public async bulkCreate(
+    values: T[],
+    clazz: any, // todo: should Model be in base so it can be used here?
+  ): Promise<T[]> {
+    const result = await this._bulkCreate(values, clazz);
+    this.emit('created', result);
+    return result;
+  }
+
   /**
    * Creates a new entry in the database with the specified value and key.
    * If a namespace is provided, the entry will be created within that namespace.
@@ -250,6 +259,7 @@ export abstract class CrudRepository<T> extends EventEmitter {
   abstract existByQuery(query: object, namespace?: string): Promise<number>;
 
   protected abstract _create(value: T, namespace?: string): Promise<T>;
+  protected abstract _bulkCreate(value: T[], namespace?: string): Promise<T[]>;
 
   protected abstract _createByKey(
     value: T,

00_Base/src/ocpp/persistence/namespace.ts

@@ -12,6 +12,7 @@ export enum Namespace {
   AuthorizationRestrictions = 'AuthorizationRestrictions',
   BootConfig = 'Boot',
   Certificate = 'Certificate',
+  InstalledCertificate = 'InstalledCertificate',
   CertificateChain = 'CertificateChain',
   ChargingNeeds = 'ChargingNeeds',
   ChargingProfile = 'ChargingProfile',

01_Data/src/index.ts

@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: Apache 2.0
 
 import { Transaction as SequelizeTransaction } from 'sequelize';
+
 export { SequelizeTransaction };
 export { IdTokenAdditionalInfo } from './layers/sequelize/model/Authorization/IdTokenAdditionalInfo';
 export * as sequelize from './layers/sequelize';
@@ -31,6 +32,7 @@ export {
   VariableCharacteristics,
   VariableStatus,
   Certificate,
+  InstalledCertificate,
   CountryNameEnumType,
   TransactionEvent,
   IdToken,
@@ -46,6 +48,7 @@ export {
   SequelizeBootRepository,
   SequelizeCallMessageRepository,
   SequelizeCertificateRepository,
+  SequelizeInstalledCertificateRepository,
   SequelizeChargingProfileRepository,
   SequelizeChargingStationSecurityInfoRepository,
   SequelizeDeviceModelRepository,

01_Data/src/interfaces/repositories.ts

@@ -4,54 +4,74 @@
 // SPDX-License-Identifier: Apache 2.0
 
 import {
-  MessageInfoType,
   type AuthorizationData,
   type BootConfig,
   type CallAction,
+  ChargingLimitSourceEnumType,
+  ChargingProfilePurposeEnumType,
+  ChargingProfileType,
   type ChargingStateEnumType,
+  ChargingStationSequenceType,
   type ComponentType,
+  CompositeScheduleType,
+  type CrudRepository,
   type EventDataType,
   type EVSEType,
   type GetVariableResultType,
-  type CrudRepository,
   type IdTokenType,
+  MessageInfoType,
+  MeterValueType,
   type MonitoringDataType,
+  NotifyEVChargingNeedsRequest,
   type RegistrationStatusEnumType,
   type ReportDataType,
+  ReserveNowRequest,
   type SecurityEventNotificationRequest,
   type SetMonitoringDataType,
   type SetMonitoringResultType,
   type SetVariableDataType,
   type SetVariableResultType,
   type StatusInfoType,
+  StatusNotificationRequest,
   type TransactionEventRequest,
+  UpdateEnumType,
   type VariableAttributeType,
   type VariableMonitoringType,
   type VariableType,
-  ChargingProfileType,
-  ChargingProfilePurposeEnumType,
-  NotifyEVChargingNeedsRequest,
-  ChargingLimitSourceEnumType,
-  CompositeScheduleType,
-  StatusNotificationRequest,
-  ReserveNowRequest,
-  MeterValueType,
-  UpdateEnumType,
-  ChargingStationSequenceType,
 } from '@citrineos/base';
 import { type AuthorizationQuerystring } from './queries/Authorization';
-import { CallMessage, ChargingStationSecurityInfo, ChargingStationSequence, CompositeSchedule, MeterValue, type Transaction, VariableCharacteristics } from '../layers/sequelize';
-import { type VariableAttribute } from '../layers/sequelize';
+import {
+  type Authorization,
+  type Boot,
+  CallMessage,
+  type Certificate,
+  ChargingNeeds,
+  ChargingProfile,
+  type ChargingStation,
+  ChargingStationSecurityInfo,
+  ChargingStationSequence,
+  type Component,
+  CompositeSchedule,
+  type EventData,
+  Evse,
+  type Location,
+  MessageInfo,
+  MeterValue,
+  Reservation,
+  type SecurityEvent,
+  Subscription,
+  Tariff,
+  type Transaction,
+  type Variable,
+  type VariableAttribute,
+  VariableCharacteristics,
+  type VariableMonitoring,
+} from '../layers/sequelize';
 import { type AuthorizationRestrictions, type VariableAttributeQuerystring } from '.';
-import { type Authorization, type Boot, type Certificate, ChargingNeeds, type ChargingStation, type Component, type EventData, Evse, type Location, type SecurityEvent, type Variable, type VariableMonitoring } from '../layers/sequelize';
-import { MessageInfo } from '../layers/sequelize';
-import { Subscription } from '../layers/sequelize';
-import { Tariff } from '../layers/sequelize';
 import { TariffQueryString } from './queries/Tariff';
-import { ChargingProfile } from '../layers/sequelize';
-import { Reservation } from '../layers/sequelize';
 import { LocalListVersion } from '../layers/sequelize/model/Authorization/LocalListVersion';
 import { SendLocalList } from '../layers/sequelize/model/Authorization/SendLocalList';
+import { InstalledCertificate } from '../layers/sequelize/model/Certificate/InstalledCertificate';
 
 export interface IAuthorizationRepository extends CrudRepository<AuthorizationData> {
   createOrUpdateByQuerystring: (value: AuthorizationData, query: AuthorizationQuerystring) => Promise<Authorization | undefined>;
@@ -171,6 +191,8 @@ export interface ICertificateRepository extends CrudRepository<Certificate> {
   createOrUpdateCertificate(certificate: Certificate): Promise<Certificate>;
 }
 
+export interface IInstalledCertificateRepository extends CrudRepository<InstalledCertificate> {}
+
 export interface IChargingProfileRepository extends CrudRepository<ChargingProfile> {
   createOrUpdateChargingProfile(chargingProfile: ChargingProfileType, stationId: string, evseId?: number | null, chargingLimitSource?: ChargingLimitSourceEnumType, isActive?: boolean): Promise<ChargingProfile>;
   createChargingNeeds(chargingNeeds: NotifyEVChargingNeedsRequest, stationId: string): Promise<ChargingNeeds>;

01_Data/src/layers/sequelize/index.ts

@@ -14,7 +14,7 @@ export { ChargingStationSequence } from './model/ChargingStationSequence';
 export { MessageInfo } from './model/MessageInfo';
 export { Tariff } from './model/Tariff';
 export { Subscription } from './model/Subscription';
-export { Certificate, SignatureAlgorithmEnumType, CountryNameEnumType } from './model/Certificate';
+export { Certificate, SignatureAlgorithmEnumType, CountryNameEnumType, InstalledCertificate } from './model/Certificate';
 export { ChargingProfile, ChargingNeeds, ChargingSchedule, CompositeSchedule, SalesTariff } from './model/ChargingProfile';
 export { CallMessage } from './model/CallMessage';
 export { Reservation } from './model/Reservation';
@@ -34,6 +34,7 @@ export { SequelizeMessageInfoRepository } from './repository/MessageInfo';
 export { SequelizeTariffRepository } from './repository/Tariff';
 export { SequelizeSubscriptionRepository } from './repository/Subscription';
 export { SequelizeCertificateRepository } from './repository/Certificate';
+export { SequelizeInstalledCertificateRepository } from './repository/InstalledCertificate';
 export { SequelizeChargingProfileRepository } from './repository/ChargingProfile';
 export { SequelizeCallMessageRepository } from './repository/CallMessage';
 export { SequelizeReservationRepository } from './repository/Reservation';

01_Data/src/layers/sequelize/model/Certificate/InstalledCertificate.ts

@@ -0,0 +1,45 @@
+import { CertificateHashDataType, GetCertificateIdUseEnumType, HashAlgorithmEnumType, Namespace } from '@citrineos/base';
+import { Column, DataType, ForeignKey, Model, Table } from 'sequelize-typescript';
+import { ChargingStation } from '../Location';
+
+@Table
+export class InstalledCertificate extends Model implements CertificateHashDataType {
+  static readonly MODEL_NAME: string = Namespace.InstalledCertificate;
+
+  @ForeignKey(() => ChargingStation)
+  @Column({
+    type: DataType.STRING(36),
+    allowNull: false,
+  })
+  declare stationId: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+  declare hashAlgorithm: HashAlgorithmEnumType;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+  declare issuerNameHash: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+  declare issuerKeyHash: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+  declare serialNumber: string;
+
+  @Column({
+    type: DataType.ENUM('V2GRootCertificate', 'MORootCertificate', 'CSMSRootCertificate', 'V2GCertificateChain', 'ManufacturerRootCertificate'),
+    allowNull: false,
+  })
+  declare certificateType: GetCertificateIdUseEnumType;
+}

01_Data/src/layers/sequelize/model/Certificate/index.ts

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache 2.0
 
 export { Certificate } from './Certificate';
+export { InstalledCertificate } from './InstalledCertificate';
 
 export const enum SignatureAlgorithmEnumType {
   RSA = 'SHA256withRSA',

01_Data/src/layers/sequelize/repository/Base.ts

@@ -62,6 +62,10 @@ export class SequelizeRepository<T extends Model<any, any>> extends CrudReposito
     return await value.save();
   }
 
+  protected async _bulkCreate(values: T[]): Promise<T[]> {
+    return await (this.s.models[this.namespace] as ModelStatic<T>).bulkCreate(values as any);
+  }
+
   protected async _createByKey(value: T, key: string): Promise<T> {
     const primaryKey = this.s.models[this.namespace].primaryKeyAttribute;
     value.setDataValue(primaryKey, key);

01_Data/src/layers/sequelize/repository/InstalledCertificate.ts

@@ -0,0 +1,16 @@
+// Copyright Contributors to the CitrineOS Project
+//
+// SPDX-License-Identifier: Apache 2.0
+
+import { SequelizeRepository } from './Base';
+import { IInstalledCertificateRepository } from '../../../interfaces';
+import { SystemConfig } from '@citrineos/base';
+import { Sequelize } from 'sequelize-typescript';
+import { ILogObj, Logger } from 'tslog';
+import { InstalledCertificate } from '../model/Certificate/InstalledCertificate';
+
+export class SequelizeInstalledCertificateRepository extends SequelizeRepository<InstalledCertificate> implements IInstalledCertificateRepository {
+  constructor(config: SystemConfig, logger?: Logger<ILogObj>, sequelizeInstance?: Sequelize) {
+    super(config, InstalledCertificate.MODEL_NAME, logger, sequelizeInstance);
+  }
+}

01_Data/src/layers/sequelize/util.ts

@@ -26,6 +26,7 @@ import {
   Evse,
   IdToken,
   IdTokenInfo,
+  InstalledCertificate,
   Location,
   MeterValue,
   Reservation,
@@ -118,6 +119,7 @@ export class DefaultSequelizeInstance {
         Boot,
         CallMessage,
         Certificate,
+        InstalledCertificate,
         ChargingNeeds,
         ChargingProfile,
         ChargingSchedule,

03_Modules/Certificates/src/module/api.ts

@@ -22,6 +22,7 @@ import {
   Namespace,
   WebsocketServerConfig,
 } from '@citrineos/base';
+import jsrsasign from 'jsrsasign';
 import { FastifyInstance, FastifyRequest } from 'fastify';
 import { ILogObj, Logger } from 'tslog';
 import { ICertificatesModuleApi } from './interface';
@@ -46,7 +47,6 @@ import {
 } from '@citrineos/data';
 import fs from 'fs';
 import moment from 'moment';
-import jsrsasign from 'jsrsasign';
 
 const enum PemType {
   Root = 'Root',