@zetra/citrineos-evdriver 1.8.3-fork.1

package/dist/module/module.js

@@ -0,0 +1,706 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AbstractModule, AsHandler, AuthorizationStatusEnum, ChargingLimitSourceEnum, ChargingStationSequenceTypeEnum, ErrorCode, EventGroup, MessageOrigin, OCPP1_6, OCPP1_6_CallAction, OCPP2_0_1, OCPP2_0_1_CallAction, OcppError, OCPPValidator, OCPPVersion, } from '@citrineos/base';
+import { Authorization, OCPP1_6_Mapper, OCPP2_0_1_Mapper, sequelize, SequelizeChargingStationSequenceRepository, Tariff, VariableAttribute, } from '@citrineos/data';
+import { CertificateAuthorityService, IdGenerator, RabbitMqReceiver, RabbitMqSender, RealTimeAuthorizer, validateIdToken, } from '@citrineos/util';
+import { Logger } from 'tslog';
+import { LocalAuthListService } from './LocalAuthListService.js';
+/**
+ * Component that handles provisioning related messages.
+ */
+export class EVDriverModule extends AbstractModule {
+    /**
+     * Fields
+     */
+    _requests = [];
+    _responses = [];
+    _tariffRepository;
+    _locationRepository;
+    _certificateAuthorityService;
+    _authorizers;
+    _idGenerator;
+    /**
+     * This is the constructor function that initializes the {@link EVDriverModule}.
+     *
+     * @param {BootstrapConfig & SystemConfig} config - The `config` contains configuration settings for the module.
+     *
+     * @param {ICache} [cache] - The cache instance which is shared among the modules & Central System to pass information such as blacklisted actions or boot status.
+     *
+     * @param {IMessageSender} [sender] - The `sender` parameter is an optional parameter that represents an instance of the {@link IMessageSender} interface.
+     * It is used to send messages from the central system to external systems or devices. If no `sender` is provided, a default {@link RabbitMqSender} instance is created and used.
+     *
+     * @param {IMessageHandler} [handler] - The `handler` parameter is an optional parameter that represents an instance of the {@link IMessageHandler} interface.
+     * It is used to handle incoming messages and dispatch them to the appropriate methods or functions. If no `handler` is provided, a default {@link RabbitMqReceiver} instance is created and used.
+     *
+     * @param {Logger<ILogObj>} [logger] - The `logger` parameter is an optional parameter that represents an instance of {@link Logger<ILogObj>}.
+     * It is used to propagate system wide logger settings and will serve as the parent logger for any sub-component logging. If no `logger` is provided, a default {@link Logger<ILogObj>} instance is created and used.
+     *
+     * @param {IAuthorizationRepository} [authorizeRepository] - An optional parameter of type {@link IAuthorizationRepository} which represents a repository for accessing and manipulating Authorization data.
+     * If no `authorizeRepository` is provided, a default {@link sequelize:AuthorizationRepository} instance is created and used.
+     *
+     * @param {ILocalAuthListRepository} [localAuthListRepository] - An optional parameter of type {@link ILocalAuthListRepository} which represents a repository for accessing and manipulating Local Authorization List data.
+     * If no `localAuthListRepository` is provided, a default {@link sequelize:localAuthListRepository} instance is created and used.
+     *
+     * @param {IDeviceModelRepository} [deviceModelRepository] - An optional parameter of type {@link IDeviceModelRepository} which represents a repository for accessing and manipulating variable data.
+     * If no `deviceModelRepository` is provided, a default {@link sequelize:deviceModelRepository} instance is
+     * created and used.
+     *
+     * @param {ITariffRepository} [tariffRepository] - An optional parameter of type {@link ITariffRepository} which
+     * represents a repository for accessing and manipulating variable data.
+     * If no `deviceModelRepository` is provided, a default {@link sequelize:tariffRepository} instance is
+     * created and used.
+     *
+     * @param {ITransactionEventRepository} [transactionEventRepository] - An optional parameter of type {@link ITransactionEventRepository}
+     * which represents a repository for accessing and manipulating transaction data.
+     * If no `transactionEventRepository` is provided, a default {@link sequelize:transactionEventRepository} instance is
+     * created and used.
+     *
+     * @param {IChargingProfileRepository} [chargingProfileRepository] - An optional parameter of type {@link IChargingProfileRepository}
+     * which represents a repository for accessing and manipulating charging profile data.
+     * If no `chargingProfileRepository` is provided, a default {@link sequelize:chargingProfileRepository} instance is created and used.
+     *
+     * @param {IReservationRepository} [reservationRepository] - An optional parameter of type {@link IReservationRepository}
+     * which represents a repository for accessing and manipulating reservation data.
+     * If no `reservationRepository` is provided, a default {@link sequelize:reservationRepository} instance is created and used.
+     *
+     * @param {IOCPPMessageRepository} [ocppMessageRepository]  - An optional parameter of type {@link IOCPPMessageRepository}
+     * which represents a repository for accessing and manipulating ocppMessage data.
+     * If no `ocppMessageRepository` is provided, a default {@link sequelize:ocppMessageRepository} instance is created and used.
+     *
+     * @param {ILocationRepository} [locationRepository] - An optional parameter of type {@link ILocationRepository} which represents a repository for accessing and manipulating location and charging station data.
+     * If no `locationRepository` is provided, a default {@link sequelize:locationRepository} instance is
+     * created and used.
+     *
+     * @param {CertificateAuthorityService} [certificateAuthorityService] - An optional parameter of
+     * type {@link CertificateAuthorityService} which handles certificate authority operations.
+     *
+     * @param {IAuthorizer} [realTimeAuthorizer] - An optional parameter of type {@link IAuthorizer} which represents
+     * a real-time authorizer that can be used to authorize real-time requests.
+     *
+     * @param {IAuthorizer[]} [authorizers] - An optional parameter of type {@link IAuthorizer[]} which represents
+     * a list of authorizers that can be used to authorize requests.
+     *
+     * @param {IdGenerator} [idGenerator] - An optional parameter of type {@link IdGenerator} which generates
+     * unique identifiers.
+     */
+    constructor(config, cache, sender, handler, logger, ocppValidator, authorizeRepository, localAuthListRepository, deviceModelRepository, tariffRepository, transactionEventRepository, chargingProfileRepository, reservationRepository, ocppMessageRepository, locationRepository, certificateAuthorityService, realTimeAuthorizer, authorizers, idGenerator) {
+        super(config, cache, handler || new RabbitMqReceiver(config, logger), sender || new RabbitMqSender(config, logger), EventGroup.EVDriver, logger, ocppValidator);
+        this._requests = config.modules.evdriver.requests;
+        this._responses = config.modules.evdriver.responses;
+        this._authorizeRepository =
+            authorizeRepository || new sequelize.SequelizeAuthorizationRepository(config, logger);
+        this._localAuthListRepository =
+            localAuthListRepository || new sequelize.SequelizeLocalAuthListRepository(config, logger);
+        this._deviceModelRepository =
+            deviceModelRepository || new sequelize.SequelizeDeviceModelRepository(config, logger);
+        this._tariffRepository =
+            tariffRepository || new sequelize.SequelizeTariffRepository(config, logger);
+        this._transactionEventRepository =
+            transactionEventRepository ||
+                new sequelize.SequelizeTransactionEventRepository(config, logger);
+        this._chargingProfileRepository =
+            chargingProfileRepository || new sequelize.SequelizeChargingProfileRepository(config, logger);
+        this._reservationRepository =
+            reservationRepository || new sequelize.SequelizeReservationRepository(config, logger);
+        this._ocppMessageRepository =
+            ocppMessageRepository || new sequelize.SequelizeOCPPMessageRepository(config, logger);
+        this._locationRepository =
+            locationRepository || new sequelize.SequelizeLocationRepository(config, logger);
+        this._certificateAuthorityService =
+            certificateAuthorityService || new CertificateAuthorityService(config, cache, logger);
+        this._localAuthListService = new LocalAuthListService(this._localAuthListRepository, this._deviceModelRepository);
+        const _realTimeAuthorizer = realTimeAuthorizer ||
+            new RealTimeAuthorizer(this._locationRepository, this.config, this._logger);
+        this._authorizers = [_realTimeAuthorizer, ...(authorizers || [])];
+        this._idGenerator =
+            idGenerator ||
+                new IdGenerator(new SequelizeChargingStationSequenceRepository(config, this._logger));
+    }
+    _authorizeRepository;
+    get authorizeRepository() {
+        return this._authorizeRepository;
+    }
+    _localAuthListRepository;
+    get localAuthListRepository() {
+        return this._localAuthListRepository;
+    }
+    _deviceModelRepository;
+    get deviceModelRepository() {
+        return this._deviceModelRepository;
+    }
+    _transactionEventRepository;
+    get transactionEventRepository() {
+        return this._transactionEventRepository;
+    }
+    _chargingProfileRepository;
+    get chargingProfileRepository() {
+        return this._chargingProfileRepository;
+    }
+    _reservationRepository;
+    get reservationRepository() {
+        return this._reservationRepository;
+    }
+    _ocppMessageRepository;
+    get ocppMessageRepository() {
+        return this._ocppMessageRepository;
+    }
+    _localAuthListService;
+    get localAuthListService() {
+        return this._localAuthListService;
+    }
+    /**
+     * Handle OCPP 2.0.1 requests
+     */
+    async _handleAuthorize(message, props) {
+        this._logger.debug('Authorize received:', message, props);
+        const request = message.payload;
+        const context = message.context;
+        const response = {
+            idTokenInfo: {
+                status: OCPP2_0_1.AuthorizationStatusEnumType.Unknown,
+                // TODO determine how/if to set personalMessage
+            },
+        };
+        // Validate ID token format after AJV schema validation, checking if the token conforms to expected type e.g if type is ISO14443, the token should be a hex string of even length
+        const tokenValidation = validateIdToken(request.idToken.type, request.idToken.idToken);
+        if (!tokenValidation.isValid) {
+            this._logger.warn(`Invalid ID token format`, {
+                type: request.idToken.type,
+                token: request.idToken.idToken,
+                error: tokenValidation.errorMessage,
+            });
+            const messageId = message.context.correlationId;
+            const error = new OcppError(messageId, ErrorCode.PropertyConstraintViolation, tokenValidation.errorMessage || 'Invalid token value for specified type');
+            response.idTokenInfo.status = OCPP2_0_1.AuthorizationStatusEnumType.Invalid;
+            this._logger.error('Token validation failed:', tokenValidation.errorMessage);
+            await this.sendCallErrorWithMessage(message, error);
+            return;
+        }
+        if (message.payload.idToken.type === OCPP2_0_1.IdTokenEnumType.NoAuthorization) {
+            response.idTokenInfo.status = OCPP2_0_1.AuthorizationStatusEnumType.Accepted;
+            await this.sendCallResultWithMessage(message, response);
+            return;
+        }
+        // Validate Contract Certificates based on OCPP 2.0.1 Part 2 C07
+        if (request.iso15118CertificateHashData || request.certificate) {
+            // TODO - implement validation using cached OCSP data described in C07.FR.05
+            if (request.iso15118CertificateHashData && request.iso15118CertificateHashData.length > 0) {
+                response.certificateStatus =
+                    await this._certificateAuthorityService.validateCertificateHashData(request.iso15118CertificateHashData);
+            }
+            // If Charging Station is not able to validate a contract certificate,
+            // it SHALL pass the contract certificate chain to the CSMS in certificate attribute (in PEM
+            // format) of AuthorizeRequest for validation by CSMS, see C07.FR.06
+            if (request.certificate) {
+                response.certificateStatus =
+                    await this._certificateAuthorityService.validateCertificateChainPem(request.certificate);
+            }
+            if (response.certificateStatus !== OCPP2_0_1.AuthorizeCertificateStatusEnumType.Accepted) {
+                response.idTokenInfo.status = OCPP2_0_1.AuthorizationStatusEnumType.Invalid;
+                const messageConfirmation = await this.sendCallResultWithMessage(message, response);
+                this._logger.debug('Authorize response sent:', messageConfirmation);
+                return;
+            }
+        }
+        const authorization = await this._authorizeRepository.readOnlyOneByQuerystring(context.tenantId, {
+            idToken: request.idToken.idToken,
+            type: OCPP2_0_1_Mapper.AuthorizationMapper.fromIdTokenEnumType(request.idToken.type),
+        });
+        if (authorization) {
+            // Use flat fields directly instead of authorization.idTokenInfo
+            const idTokenInfo = OCPP2_0_1_Mapper.AuthorizationMapper.toIdTokenInfo(authorization);
+            if (idTokenInfo.status === OCPP2_0_1.AuthorizationStatusEnumType.Accepted) {
+                if (idTokenInfo.cacheExpiryDateTime &&
+                    new Date() > new Date(idTokenInfo.cacheExpiryDateTime)) {
+                    response.idTokenInfo = {
+                        status: OCPP2_0_1.AuthorizationStatusEnumType.Invalid,
+                        groupIdToken: idTokenInfo.groupIdToken,
+                        // TODO determine how/if to set personalMessage
+                    };
+                }
+                else {
+                    // If charging station does not have values and evses associated with the component/variable pairs below,
+                    // this logic will break. CSMS's aiming to use the allowedConnectorTypes or disallowedEvseIdPrefixes
+                    // Authorization restrictions MUST provide these variable attributes as defined in Physical Component
+                    // list of Part 2 - Appendices of OCPP 2.0.1
+                    let evseIds = undefined;
+                    if (authorization.allowedConnectorTypes &&
+                        authorization.allowedConnectorTypes.length > 0) {
+                        evseIds = new Set();
+                        const connectorTypes = await this._deviceModelRepository.readAllByQuerystring(context.tenantId, {
+                            tenantId: context.tenantId,
+                            stationId: message.context.stationId,
+                            component_name: 'Connector',
+                            variable_name: 'ConnectorType',
+                            type: OCPP2_0_1.AttributeEnumType.Actual,
+                        });
+                        for (const connectorType of connectorTypes) {
+                            if (authorization.allowedConnectorTypes.indexOf(connectorType.value) > 0) {
+                                evseIds.add(connectorType.evse?.id);
+                            }
+                        }
+                    }
+                    if (evseIds && evseIds.size === 0) {
+                        response.idTokenInfo = {
+                            status: OCPP2_0_1.AuthorizationStatusEnumType.NotAllowedTypeEVSE,
+                            groupIdToken: idTokenInfo.groupIdToken,
+                            // TODO determine how/if to set personalMessage
+                        };
+                    }
+                    else {
+                        if (authorization.disallowedEvseIdPrefixes &&
+                            authorization.disallowedEvseIdPrefixes.length > 0) {
+                            evseIds = evseIds ? evseIds : new Set();
+                            const evseIdAttributes = await this._deviceModelRepository.readAllByQuerystring(context.tenantId, {
+                                tenantId: context.tenantId,
+                                stationId: message.context.stationId,
+                                component_name: 'EVSE',
+                                variable_name: 'EvseId',
+                                type: OCPP2_0_1.AttributeEnumType.Actual,
+                            });
+                            for (const evseIdAttribute of evseIdAttributes) {
+                                const evseIdAllowed = authorization.disallowedEvseIdPrefixes.some((disallowedEvseId) => evseIdAttribute.value.startsWith(disallowedEvseId));
+                                if (evseIdAllowed && !authorization.allowedConnectorTypes) {
+                                    evseIds.add(evseIdAttribute.evse?.id);
+                                }
+                                else if (!evseIdAllowed && authorization.allowedConnectorTypes) {
+                                    evseIds.delete(evseIdAttribute.evse?.id);
+                                }
+                            }
+                        }
+                        if (evseIds && evseIds.size === 0) {
+                            response.idTokenInfo = {
+                                status: OCPP2_0_1.AuthorizationStatusEnumType.NotAtThisLocation,
+                                groupIdToken: idTokenInfo.groupIdToken,
+                                // TODO determine how/if to set personalMessage
+                            };
+                        }
+                        else {
+                            // TODO: Determine how to check for NotAtThisTime
+                            response.idTokenInfo = idTokenInfo;
+                            const evseId = [...(evseIds ? evseIds.values() : [])];
+                            if (evseId.length > 0) {
+                                response.idTokenInfo.evseId = [evseId.pop(), ...evseId];
+                            }
+                        }
+                    }
+                }
+                for (const authorizer of this._authorizers) {
+                    if (response.idTokenInfo.status !== OCPP2_0_1.AuthorizationStatusEnumType.Accepted) {
+                        break;
+                    }
+                    const result = await authorizer.authorize(authorization, context);
+                    response.idTokenInfo.status =
+                        OCPP2_0_1_Mapper.AuthorizationMapper.fromAuthorizationStatusEnumType(result);
+                }
+            }
+            else {
+                // Blocked, Expired, Invalid, NoCredit, Unknown
+                response.idTokenInfo = idTokenInfo;
+            }
+        }
+        else {
+            // Status is Unknown if no authorization found
+            response.idTokenInfo = {
+                status: OCPP2_0_1.AuthorizationStatusEnumType.Unknown,
+                // TODO determine how/if to set personalMessage
+            };
+            const messageConfirmation = await this.sendCallResultWithMessage(message, response);
+            this._logger.debug('Authorize response sent:', messageConfirmation);
+            return;
+        }
+        if (response.idTokenInfo.status === OCPP2_0_1.AuthorizationStatusEnumType.Accepted) {
+            const tariffAvailable = await this._deviceModelRepository.readAllByQuerystring(context.tenantId, {
+                tenantId: context.tenantId,
+                stationId: message.context.stationId,
+                component_name: 'TariffCostCtrlr',
+                variable_name: 'Available',
+                variable_instance: 'Tariff',
+                type: OCPP2_0_1.AttributeEnumType.Actual,
+            });
+            const displayMessageAvailable = await this._deviceModelRepository.readAllByQuerystring(context.tenantId, {
+                tenantId: context.tenantId,
+                stationId: message.context.stationId,
+                component_name: 'DisplayMessageCtrlr',
+                variable_name: 'Available',
+                type: OCPP2_0_1.AttributeEnumType.Actual,
+            });
+            // only send the tariff information if the Charging Station supports the tariff or DisplayMessage functionality
+            if ((tariffAvailable.length > 0 && Boolean(tariffAvailable[0].value)) ||
+                (displayMessageAvailable.length > 0 && Boolean(displayMessageAvailable[0].value))) {
+                // TODO: refactor the workaround below after tariff implementation is finalized.
+                const tariff = await this._tariffRepository.findByStationId(context.tenantId, message.context.stationId);
+                if (tariff) {
+                    if (!response.idTokenInfo.personalMessage) {
+                        response.idTokenInfo.personalMessage = {
+                            format: OCPP2_0_1.MessageFormatEnumType.ASCII,
+                        };
+                    }
+                    response.idTokenInfo.personalMessage.content = `${tariff.pricePerKwh}/kWh`;
+                }
+            }
+        }
+        const messageConfirmation = await this.sendCallResultWithMessage(message, response);
+        this._logger.debug('Authorize response sent:', messageConfirmation);
+    }
+    async _handleReservationStatusUpdate(message, props) {
+        this._logger.debug('ReservationStatusUpdateRequest received:', message, props);
+        try {
+            const status = message.payload
+                .reservationUpdateStatus;
+            const reservation = await this._reservationRepository.readOnlyOneByQuery(message.context.tenantId, {
+                where: {
+                    tenantId: message.context.tenantId,
+                    stationId: message.context.stationId,
+                    id: message.payload.reservationId,
+                },
+            });
+            if (reservation) {
+                if (status === OCPP2_0_1.ReservationUpdateStatusEnumType.Expired ||
+                    status === OCPP2_0_1.ReservationUpdateStatusEnumType.Removed) {
+                    await this._reservationRepository.updateByKey(message.context.tenantId, {
+                        isActive: false,
+                    }, reservation.databaseId.toString());
+                }
+            }
+            else {
+                throw new Error(`Reservation ${message.payload.reservationId} not found`);
+            }
+        }
+        catch (error) {
+            this._logger.error('Error reading reservation:', error);
+        }
+        // Create response
+        const response = {};
+        const messageConfirmation = await this.sendCallResultWithMessage(message, response);
+        this._logger.debug('ReservationStatusUpdate response sent: ', messageConfirmation);
+    }
+    /**
+     * Handle OCPP 2.0.1 responses
+     */
+    async _handleRequestStartTransaction(message, props) {
+        this._logger.debug('RequestStartTransactionResponse received:', message, props);
+        if (message.payload.status === OCPP2_0_1.RequestStartStopStatusEnumType.Accepted) {
+            // Start transaction with charging profile succeeds,
+            // we need to update db entity with the latest data from charger
+            const stationId = message.context.stationId;
+            // 1. Clear all existing profiles: find existing active profiles and set them to isActive false
+            await this._chargingProfileRepository.updateAllByQuery(message.context.tenantId, {
+                isActive: false,
+            }, {
+                where: {
+                    stationId: stationId,
+                    isActive: true,
+                    chargingLimitSource: OCPP2_0_1.ChargingLimitSourceEnumType.CSO,
+                    chargingProfilePurpose: OCPP2_0_1.ChargingProfilePurposeEnumType.TxProfile,
+                },
+                returning: false,
+            });
+            // 2. Request charging profiles to get the latest data
+            await this.sendCall(stationId, message.context.tenantId, OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.GetChargingProfiles, {
+                requestId: await this._idGenerator.generateRequestId(message.context.tenantId, message.context.stationId, ChargingStationSequenceTypeEnum.getChargingProfiles),
+                chargingProfile: {
+                    chargingProfilePurpose: OCPP2_0_1.ChargingProfilePurposeEnumType.TxProfile,
+                    chargingLimitSource: [OCPP2_0_1.ChargingLimitSourceEnumType.CSO],
+                },
+            });
+        }
+        else {
+            this._logger.error(`RequestStartTransaction failed: ${JSON.stringify(message.payload)}`);
+        }
+    }
+    async _handleRequestStopTransaction(message, props) {
+        this._logger.debug('RequestStopTransactionResponse received:', message, props);
+    }
+    async _handleCancelReservation(message, props) {
+        this._logger.debug('CancelReservationResponse received:', message, props);
+        const request = await this._ocppMessageRepository.readOnlyOneByQuery(message.context.tenantId, {
+            where: {
+                tenantId: message.context.tenantId,
+                stationId: message.context.stationId,
+                correlationId: message.context.correlationId,
+                origin: MessageOrigin.ChargingStationManagementSystem,
+            },
+        });
+        if (request) {
+            await this._reservationRepository.updateByKey(message.context.tenantId, {
+                isActive: message.payload.status === OCPP2_0_1.CancelReservationStatusEnumType.Rejected,
+            }, request.message[3].reservationId);
+        }
+        else {
+            this._logger.error(`Update reservation failed. ReservationId not found by CorrelationId ${message.context.correlationId}.`);
+        }
+    }
+    async _handleReserveNow(message, props) {
+        this._logger.debug('ReserveNowResponse received:', message, props);
+        const request = await this._ocppMessageRepository.readOnlyOneByQuery(message.context.tenantId, {
+            where: {
+                tenantId: message.context.tenantId,
+                stationId: message.context.stationId,
+                correlationId: message.context.correlationId,
+                origin: MessageOrigin.ChargingStationManagementSystem,
+            },
+        });
+        if (request) {
+            const status = message.payload.status;
+            await this._reservationRepository.updateByKey(message.context.tenantId, {
+                reserveStatus: status,
+                isActive: status === OCPP2_0_1.ReserveNowStatusEnumType.Accepted,
+            }, request.message[3].id);
+        }
+        else {
+            this._logger.error(`Update reservation failed. ReservationId not found by CorrelationId ${message.context.correlationId}.`);
+        }
+    }
+    async _handleUnlockConnector(message, props) {
+        this._logger.debug('UnlockConnectorResponse received:', message, props);
+    }
+    async _handleClearCache(message, props) {
+        this._logger.debug('ClearCacheResponse received:', message, props);
+    }
+    async _handleSendLocalList(message, props) {
+        this._logger.debug('SendLocalListResponse received:', message, props);
+        const stationId = message.context.stationId;
+        const sendLocalListRequest = await this._localAuthListRepository.getSendLocalListRequestByStationIdAndCorrelationId(message.context.tenantId, stationId, message.context.correlationId);
+        if (!sendLocalListRequest) {
+            this._logger.error(`Unable to process SendLocalListResponse. SendLocalListRequest not found for StationId ${stationId} by CorrelationId ${message.context.correlationId}.`);
+            return;
+        }
+        const sendLocalListResponse = message.payload;
+        switch (sendLocalListResponse.status) {
+            case OCPP2_0_1.SendLocalListStatusEnumType.Accepted:
+                await this._localAuthListRepository.createOrUpdateLocalListVersionFromStationIdAndSendLocalList(message.context.tenantId, stationId, sendLocalListRequest);
+                break;
+            case OCPP2_0_1.SendLocalListStatusEnumType.Failed:
+                // TODO: Surface alert for upstream handling
+                this._logger.error(`SendLocalListRequest failed for StationId ${stationId}: ${message.context.correlationId}, ${JSON.stringify(sendLocalListRequest)}.`);
+                break;
+            case OCPP2_0_1.SendLocalListStatusEnumType.VersionMismatch: {
+                this._logger.error(`SendLocalListRequest version mismatch for StationId ${stationId}: ${message.context.correlationId}, ${JSON.stringify(sendLocalListRequest)}.`);
+                this._logger.error(`Sending GetLocalListVersionRequest for StationId ${stationId} due to SendLocalListRequest version mismatch.`);
+                const messageConfirmation = await this.sendCall(stationId, message.context.tenantId, OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.GetLocalListVersion, {});
+                if (!messageConfirmation.success) {
+                    this._logger.error(`Unable to send GetLocalListVersionRequest for StationId ${stationId} due to SendLocalListRequest version mismatch.`, messageConfirmation);
+                }
+                break;
+            }
+            default:
+                this._logger.error(`Unknown SendLocalListStatusEnumType: ${sendLocalListResponse.status}.`);
+                break;
+        }
+    }
+    async _handleGetLocalListVersion(message, props) {
+        this._logger.debug('GetLocalListVersionResponse received:', message, props);
+        await this._localAuthListRepository.validateOrReplaceLocalListVersionForStation(message.context.tenantId, message.payload.versionNumber, message.context.stationId);
+    }
+    /**
+     * Handle OCPP 1.6 responses
+     */
+    async _handleOcpp16RemoteStopTransaction(message, props) {
+        this._logger.debug('RemoteStopTransactionResponse received:', message, props);
+    }
+    async _handleOCPP16Authorize(message, props) {
+        this._logger.debug('OCPP 16 Authorize received: ', message, props);
+        const request = message.payload;
+        const context = message.context;
+        // Default response: Invalid
+        const response = {
+            idTagInfo: {
+                status: OCPP1_6.AuthorizeResponseStatus.Invalid,
+            },
+        };
+        try {
+            const authorizations = await this._authorizeRepository.readAllByQuerystring(context.tenantId, {
+                idToken: request.idTag,
+            });
+            if (!authorizations || authorizations.length === 0) {
+                this._logger.error(`No authorization found for idToken: ${request.idTag}`);
+                //below line is just to make it more explicit. Default status is already invalid.
+                response.idTagInfo.status = OCPP1_6.AuthorizeResponseStatus.Invalid;
+                await this.sendCallResultWithMessage(message, response);
+                this._logger.debug('Authorize response sent:', response);
+                return;
+            }
+            // If we find more than one token for an idTag it's too opinionated on how to define which one is valid.
+            // For now, we error out, and implementers should change this according to their needs.
+            if (authorizations.length > 1) {
+                this._logger.error(`Too many authorizations found for idToken: ${request.idTag}`);
+                response.idTagInfo.status = OCPP1_6.AuthorizeResponseStatus.Invalid;
+                await this.sendCallResultWithMessage(message, response);
+                this._logger.debug('Authorize response sent:', response);
+                return;
+            }
+            const authorization = authorizations[0];
+            if (!authorization.status) {
+                response.idTagInfo.status = OCPP1_6.AuthorizeResponseStatus.Accepted;
+            }
+            else if (authorization.status === AuthorizationStatusEnum.Accepted) {
+                const cacheExpiryDateTime = authorization.cacheExpiryDateTime;
+                const groupAuthorizationId = authorization.groupAuthorizationId;
+                response.idTagInfo.expiryDate = cacheExpiryDateTime;
+                if (groupAuthorizationId) {
+                    // Look up the referenced Authorization for parentIdTag
+                    const parentAuth = await this._authorizeRepository.readOnlyOneByQuery(message.context.tenantId, { where: { id: groupAuthorizationId } });
+                    if (parentAuth) {
+                        response.idTagInfo.parentIdTag = parentAuth.idToken;
+                    }
+                }
+                if (cacheExpiryDateTime && new Date() > new Date(cacheExpiryDateTime)) {
+                    response.idTagInfo.status = OCPP1_6.AuthorizeResponseStatus.Expired;
+                }
+                else {
+                    // Apply authorizers
+                    let status = authorization.status;
+                    for (const authorizer of this._authorizers) {
+                        if (status !== AuthorizationStatusEnum.Accepted) {
+                            break;
+                        }
+                        status = await authorizer.authorize(authorization, context);
+                    }
+                    response.idTagInfo.status = OCPP1_6_Mapper.AuthorizationMapper.toIdTagInfoStatus(status);
+                }
+            }
+        }
+        catch (error) {
+            // Log any unexpected errors
+            this._logger.error(`Failed to retrieve authorization for idToken '${request.idTag}':`, error);
+            // response remains "Invalid" by default
+        }
+        await this.sendCallResultWithMessage(message, response).then((messageConfirmation) => {
+            this._logger.debug('Authorize response sent:', messageConfirmation);
+        });
+        return;
+    }
+    async _handleRemoteStartTransaction(message, props) {
+        this._logger.debug('RemoteStartTransactionResponse received:', message, props);
+        const tenantId = message.context.tenantId;
+        const stationId = message.context.stationId;
+        if (message.payload.status === OCPP1_6.RemoteStartTransactionResponseStatus.Accepted) {
+            const originalMessage = await this._ocppMessageRepository.readOnlyOneByQuery(tenantId, {
+                where: {
+                    tenantId: tenantId,
+                    stationId: stationId,
+                    correlationId: message.context.correlationId,
+                    origin: MessageOrigin.ChargingStationManagementSystem,
+                },
+            });
+            if (originalMessage) {
+                const originalRequest = originalMessage.message[3];
+                if (originalRequest.chargingProfile) {
+                    const mapped = OCPP1_6_Mapper.ChargingProfileMapper.fromRemoteStartChargingProfile(originalRequest.chargingProfile);
+                    await this._chargingProfileRepository.createOrUpdateChargingProfile(tenantId, mapped, stationId, originalRequest.connectorId ?? null, ChargingLimitSourceEnum.CSO, true);
+                }
+            }
+            else {
+                this._logger.error(`OCPP 1.6 RemoteStartTransaction accepted but original request not found by CorrelationId ${message.context.correlationId}.`);
+            }
+        }
+        else {
+            this._logger.error(`OCPP 1.6 RemoteStartTransaction rejected: ${JSON.stringify(message.payload)}`);
+        }
+    }
+    async _handleOcpp16ClearCache(message, props) {
+        this._logger.debug('ClearCacheResponse received:', message, props);
+    }
+    _updateAuthorizationFromDto(auth, dto) {
+        for (const key of Object.keys(dto)) {
+            const value = dto[key];
+            if (value !== undefined && value !== null) {
+                auth[key] = value;
+            }
+        }
+        return auth;
+    }
+}
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.Authorize),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleAuthorize", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.ReservationStatusUpdate),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleReservationStatusUpdate", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.RequestStartTransaction),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleRequestStartTransaction", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.RequestStopTransaction),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleRequestStopTransaction", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.CancelReservation),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleCancelReservation", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.ReserveNow),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleReserveNow", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.UnlockConnector),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleUnlockConnector", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.ClearCache),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleClearCache", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.SendLocalList),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleSendLocalList", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP2_0_1, OCPP2_0_1_CallAction.GetLocalListVersion),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleGetLocalListVersion", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP1_6, OCPP1_6_CallAction.RemoteStopTransaction),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleOcpp16RemoteStopTransaction", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP1_6, OCPP1_6_CallAction.Authorize),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleOCPP16Authorize", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP1_6, OCPP1_6_CallAction.RemoteStartTransaction),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleRemoteStartTransaction", null);
+__decorate([
+    AsHandler(OCPPVersion.OCPP1_6, OCPP1_6_CallAction.ClearCache),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], EVDriverModule.prototype, "_handleOcpp16ClearCache", null);
+//# sourceMappingURL=module.js.map