@zetra/citrineos-data 1.8.3-fork.1

package/dist/layers/sequelize/repository/TransactionEvent.d.ts

@@ -0,0 +1,46 @@
+import type { BootstrapConfig, MeterValueDto } from '@citrineos/base';
+import { CrudRepository, OCPP1_6, OCPP2_0_1 } from '@citrineos/base';
+import { Sequelize } from 'sequelize-typescript';
+import type { ILogObj } from 'tslog';
+import { Logger } from 'tslog';
+import type { IChargingStationSequenceRepository, ITransactionEventRepository } from '../../../interfaces/index.js';
+import { ChargingStation, Connector, Evse, MeterValue, StartTransaction, StopTransaction, Transaction, TransactionEvent } from '../model/index.js';
+import { SequelizeRepository } from './Base.js';
+export declare class SequelizeTransactionEventRepository extends SequelizeRepository<TransactionEvent> implements ITransactionEventRepository {
+    transaction: CrudRepository<Transaction>;
+    evse: CrudRepository<Evse>;
+    station: CrudRepository<ChargingStation>;
+    meterValue: CrudRepository<MeterValue>;
+    startTransaction: CrudRepository<StartTransaction>;
+    stopTransaction: CrudRepository<StopTransaction>;
+    connector: CrudRepository<Connector>;
+    chargingStationSequence: IChargingStationSequenceRepository;
+    constructor(config: BootstrapConfig, logger?: Logger<ILogObj>, namespace?: string, sequelizeInstance?: Sequelize, transaction?: CrudRepository<Transaction>, station?: CrudRepository<ChargingStation>, evse?: CrudRepository<Evse>, meterValue?: CrudRepository<MeterValue>, startTransaction?: CrudRepository<StartTransaction>, stopTransaction?: CrudRepository<StopTransaction>, connector?: CrudRepository<Connector>, chargingStationSequence?: IChargingStationSequenceRepository);
+    /**
+     * @param value TransactionEventRequest received from charging station. Will be used to create TransactionEvent,
+     * MeterValues, and either create or update Transaction. IdTokens (and associated AdditionalInfo) and EVSEs are
+     * assumed to already exist and will not be created as part of this call.
+     *
+     * @param stationId StationId of charging station which sent TransactionEventRequest.
+     *
+     * @returns Saved TransactionEvent
+     */
+    createOrUpdateTransactionByTransactionEventAndStationId(tenantId: number, value: OCPP2_0_1.TransactionEventRequest, stationId: string): Promise<Transaction>;
+    readAllByStationIdAndTransactionId(tenantId: number, stationId: string, transactionId: string): Promise<TransactionEvent[]>;
+    readTransactionByStationIdAndTransactionId(tenantId: number, stationId: string, transactionId: string): Promise<Transaction | undefined>;
+    readAllTransactionsByStationIdAndEvseAndChargingStates(tenantId: number, stationId: string, evse?: OCPP2_0_1.EVSEType, chargingStates?: OCPP2_0_1.ChargingStateEnumType[] | undefined): Promise<Transaction[]>;
+    readAllActiveTransactionsByAuthorizationId(tenantId: number, authorizationId: number): Promise<Transaction[]>;
+    readAllMeterValuesByTransactionDataBaseId(tenantId: number, transactionDataBaseId: number): Promise<MeterValue[]>;
+    findByTransactionId(tenantId: number, transactionId: string): Promise<Transaction | undefined>;
+    getTransactions(tenantId: number, dateFrom?: Date, dateTo?: Date, offset?: number, limit?: number): Promise<Transaction[]>;
+    getTransactionsCount(tenantId: number, dateFrom?: Date, dateTo?: Date): Promise<number>;
+    readAllTransactionsByQuery(tenantId: number, query: object): Promise<Transaction[]>;
+    getEvseIdsWithActiveTransactionByStationId(tenantId: number, stationId: string): Promise<number[]>;
+    getActiveTransactionByStationIdAndEvseId(tenantId: number, stationId: string, evseId: number): Promise<Transaction | undefined>;
+    createMeterValue(tenantId: number, meterValue: OCPP2_0_1.MeterValueType, transactionDatabaseId?: number | null, transactionId?: string | null, tariffId?: number | null): Promise<MeterValue>;
+    updateTransactionTotalCostById(tenantId: number, totalCost: number, id: number): Promise<void>;
+    updateTransactionByMeterValues(tenantId: number, meterValues: MeterValueDto[], stationId: string, transactionId: number): Promise<void>;
+    createTransactionByStartTransaction(tenantId: number, request: OCPP1_6.StartTransactionRequest, stationId: string): Promise<Transaction>;
+    createStopTransaction(tenantId: number, transactionDatabaseId: number, stationId: string, meterStop: number, timestamp: Date, meterValues: MeterValueDto[], reason?: string): Promise<StopTransaction>;
+    updateTransactionByStationIdAndTransactionId(tenantId: number, transaction: Partial<Transaction>, transactionId: string, stationId: string): Promise<Transaction | undefined>;
+}

package/dist/layers/sequelize/repository/TransactionEvent.js

@@ -0,0 +1,597 @@
+import { ChargingStationSequenceTypeEnum, CrudRepository, MeterValueUtils, OCPP1_6, OCPP2_0_1, } from '@citrineos/base';
+import { Op } from 'sequelize';
+import { Sequelize } from 'sequelize-typescript';
+import { Logger } from 'tslog';
+import { OCPP2_0_1_Mapper } from '../index.js';
+import { AuthorizationMapper } from '../mapper/2.0.1/index.js';
+import { Authorization, AuthorizationTenant, ChargingStation, Connector, Evse, EvseType, MeterValue, StartTransaction, StopTransaction, Tariff, Transaction, TransactionEvent, } from '../model/index.js';
+import { SequelizeRepository } from './Base.js';
+import { SequelizeChargingStationSequenceRepository } from './ChargingStationSequence.js';
+export class SequelizeTransactionEventRepository extends SequelizeRepository {
+    transaction;
+    evse;
+    station;
+    meterValue;
+    startTransaction;
+    stopTransaction;
+    connector;
+    chargingStationSequence;
+    constructor(config, logger, namespace = TransactionEvent.MODEL_NAME, sequelizeInstance, transaction, station, evse, meterValue, startTransaction, stopTransaction, connector, chargingStationSequence) {
+        super(config, namespace, logger, sequelizeInstance);
+        this.transaction = transaction
+            ? transaction
+            : new SequelizeRepository(config, Transaction.MODEL_NAME, logger, sequelizeInstance);
+        this.evse = evse
+            ? evse
+            : new SequelizeRepository(config, Evse.MODEL_NAME, logger, sequelizeInstance);
+        this.station = station
+            ? station
+            : new SequelizeRepository(config, ChargingStation.MODEL_NAME, logger, sequelizeInstance);
+        this.meterValue = meterValue
+            ? meterValue
+            : new SequelizeRepository(config, MeterValue.MODEL_NAME, logger, sequelizeInstance);
+        this.startTransaction = startTransaction
+            ? startTransaction
+            : new SequelizeRepository(config, StartTransaction.MODEL_NAME, logger, sequelizeInstance);
+        this.stopTransaction = stopTransaction
+            ? stopTransaction
+            : new SequelizeRepository(config, StopTransaction.MODEL_NAME, logger, sequelizeInstance);
+        this.connector = connector
+            ? connector
+            : new SequelizeRepository(config, Connector.MODEL_NAME, logger, sequelizeInstance);
+        this.chargingStationSequence =
+            chargingStationSequence || new SequelizeChargingStationSequenceRepository(config, logger);
+    }
+    /**
+     * @param value TransactionEventRequest received from charging station. Will be used to create TransactionEvent,
+     * MeterValues, and either create or update Transaction. IdTokens (and associated AdditionalInfo) and EVSEs are
+     * assumed to already exist and will not be created as part of this call.
+     *
+     * @param stationId StationId of charging station which sent TransactionEventRequest.
+     *
+     * @returns Saved TransactionEvent
+     */
+    async createOrUpdateTransactionByTransactionEventAndStationId(tenantId, value, stationId) {
+        return await this.s.transaction(async (sequelizeTransaction) => {
+            let finalTransaction;
+            let created = false;
+            const existingTransaction = await this.transaction.readOnlyOneByQuery(tenantId, {
+                where: {
+                    stationId,
+                    transactionId: value.transactionInfo.transactionId,
+                },
+                transaction: sequelizeTransaction,
+            });
+            if (existingTransaction) {
+                let evseId = existingTransaction.evseId;
+                if (!evseId && value.evse) {
+                    const [evse] = await this.evse.readOrCreateByQuery(tenantId, {
+                        where: {
+                            tenantId,
+                            stationId,
+                            evseTypeId: value.evse.id,
+                        },
+                    });
+                    evseId = evse.id;
+                }
+                let connectorId = existingTransaction.connectorId;
+                let tariffId = existingTransaction.tariffId;
+                if (!connectorId && value.evse?.connectorId) {
+                    const [evse] = await this.evse.readOrCreateByQuery(tenantId, {
+                        where: {
+                            tenantId,
+                            stationId,
+                            evseTypeId: value.evse.id,
+                        },
+                    });
+                    const [connector] = await this.connector.readOrCreateByQuery(tenantId, {
+                        where: {
+                            tenantId,
+                            stationId,
+                            evseId: evse.id,
+                            evseTypeConnectorId: value.evse.connectorId,
+                        },
+                        include: [Tariff],
+                    });
+                    connectorId = connector.id;
+                    tariffId = connector.tariffs?.[0]?.id;
+                }
+                let authorizationId = existingTransaction.authorizationId;
+                if (!authorizationId && value.idToken) {
+                    // Find Authorization by IdToken
+                    const authorization = await Authorization.findOne({
+                        where: {
+                            idToken: value.idToken.idToken,
+                            idTokenType: OCPP2_0_1_Mapper.AuthorizationMapper.fromIdTokenEnumType(value.idToken.type),
+                        },
+                        transaction: sequelizeTransaction,
+                        include: [
+                            {
+                                model: AuthorizationTenant,
+                                as: 'tenants',
+                                required: true,
+                                where: { tenantId },
+                                attributes: [],
+                            },
+                        ],
+                    });
+                    if (authorization) {
+                        authorizationId = authorization.id;
+                    }
+                    else {
+                        this.logger.warn(`Authorization with idToken ${value.idToken.idToken} : ${value.idToken.type} does not exist. Transaction ${existingTransaction.transactionId} will not be associated with an authorization.`);
+                    }
+                }
+                finalTransaction = await existingTransaction.update({
+                    isActive: value.eventType !== OCPP2_0_1.TransactionEventEnumType.Ended,
+                    endTime: value.eventType === OCPP2_0_1.TransactionEventEnumType.Ended
+                        ? value.timestamp
+                        : undefined,
+                    ...value.transactionInfo,
+                    authorizationId,
+                    evseId,
+                    connectorId,
+                    tariffId,
+                }, {
+                    transaction: sequelizeTransaction,
+                });
+            }
+            else {
+                const newTransaction = Transaction.build({
+                    tenantId,
+                    stationId,
+                    isActive: value.eventType !== OCPP2_0_1.TransactionEventEnumType.Ended,
+                    startTime: value.eventType === OCPP2_0_1.TransactionEventEnumType.Started
+                        ? value.timestamp
+                        : undefined,
+                    ...value.transactionInfo,
+                });
+                if (value.evse) {
+                    const [evse] = await this.evse.readOrCreateByQuery(tenantId, {
+                        where: {
+                            tenantId,
+                            stationId,
+                            evseTypeId: value.evse.id,
+                        },
+                    });
+                    newTransaction.set('evseId', evse.id);
+                    if (value.evse?.connectorId) {
+                        const [connector] = await this.connector.readOrCreateByQuery(tenantId, {
+                            where: {
+                                tenantId,
+                                stationId,
+                                evseId: evse.id,
+                                evseTypeConnectorId: value.evse.connectorId,
+                            },
+                            include: [Tariff],
+                        });
+                        newTransaction.set('connectorId', connector.id);
+                        newTransaction.set('tariffId', connector.tariffs?.[0]?.id);
+                    }
+                }
+                if (value.idToken) {
+                    // Find Authorization by IdToken
+                    const authorization = await Authorization.findOne({
+                        where: {
+                            idToken: value.idToken.idToken,
+                            idTokenType: OCPP2_0_1_Mapper.AuthorizationMapper.fromIdTokenEnumType(value.idToken.type),
+                        },
+                        transaction: sequelizeTransaction,
+                        include: [
+                            {
+                                model: AuthorizationTenant,
+                                as: 'tenants',
+                                required: true,
+                                where: { tenantId },
+                                attributes: [],
+                            },
+                        ],
+                    });
+                    if (authorization) {
+                        newTransaction.set('authorizationId', authorization.id);
+                    }
+                    else {
+                        this.logger.warn(`Authorization with idToken ${value.idToken.idToken} : ${value.idToken.type} does not exist. Transaction ${newTransaction.transactionId} will not be associated with an authorization.`);
+                    }
+                }
+                const chargingStation = await this.station.readByKey(tenantId, stationId);
+                if (!chargingStation) {
+                    this.logger.error(`Charging station with stationId ${stationId} does not exist.`);
+                }
+                else {
+                    if (chargingStation.locationId) {
+                        newTransaction.set('locationId', chargingStation.locationId);
+                    }
+                    else {
+                        this.logger.warn(`Charging station with stationId ${stationId} does not have a locationId. Transaction ${newTransaction.transactionId} will not be associated with a location, which may prevent it from being sent to upstream partners.`);
+                    }
+                }
+                finalTransaction = await newTransaction.save({ transaction: sequelizeTransaction });
+                created = true;
+            }
+            const transactionDatabaseId = finalTransaction.id;
+            let event = TransactionEvent.build({
+                tenantId,
+                stationId,
+                transactionDatabaseId,
+                ...value,
+            });
+            if (value.idToken && value.idToken.type !== OCPP2_0_1.IdTokenEnumType.NoAuthorization) {
+                const authorization = await Authorization.findOne({
+                    where: {
+                        idToken: value.idToken.idToken,
+                        idTokenType: AuthorizationMapper.fromIdTokenEnumType(value.idToken.type),
+                    },
+                    transaction: sequelizeTransaction,
+                    include: [
+                        {
+                            model: AuthorizationTenant,
+                            as: 'tenants',
+                            required: true,
+                            where: { tenantId },
+                            attributes: [],
+                        },
+                    ],
+                });
+                if (!authorization) {
+                    this.logger.warn(`Authorization not found for ${value.idToken.idToken}:${value.idToken.type}`);
+                }
+                else {
+                    event.idTokenValue = authorization.idToken;
+                    event.idTokenType = authorization.idTokenType ? authorization.idTokenType : undefined;
+                }
+            }
+            event = await event.save({ transaction: sequelizeTransaction });
+            if (value.meterValue && value.meterValue.length > 0) {
+                const meterValueTypes = value.meterValue.map((meterValue) => OCPP2_0_1_Mapper.MeterValueMapper.fromMeterValueType(meterValue));
+                const newMeterValues = await Promise.all(meterValueTypes.map(async (meterValueType) => {
+                    const savedMeterValue = await MeterValue.create({
+                        tenantId,
+                        transactionEventId: event.id,
+                        transactionDatabaseId: transactionDatabaseId,
+                        transactionId: finalTransaction.transactionId,
+                        tariffId: finalTransaction.tariffId,
+                        ...meterValueType,
+                    }, { transaction: sequelizeTransaction });
+                    this.meterValue.emit('created', [savedMeterValue]);
+                    return savedMeterValue;
+                }));
+                if (finalTransaction.meterStart === null || finalTransaction.meterStart === undefined) {
+                    const meterStart = MeterValueUtils.getMeterStart(meterValueTypes);
+                    await finalTransaction.update({
+                        totalKwh: MeterValueUtils.getTotalKwh(meterValueTypes, finalTransaction.totalKwh ?? 0, meterStart ?? undefined),
+                        meterStart: meterStart,
+                    }, { transaction: sequelizeTransaction });
+                }
+                else {
+                    await finalTransaction.update({
+                        totalKwh: MeterValueUtils.getTotalKwh(meterValueTypes, finalTransaction.totalKwh ?? 0, finalTransaction.meterStart ?? undefined),
+                    }, { transaction: sequelizeTransaction });
+                }
+                // Included for ease of access after creation
+                finalTransaction.meterValues = newMeterValues;
+            }
+            // Optimize: Skip eager loading of all MeterValues to reduce memory usage during long charging sessions
+            // For register-based calculations (most common), we only need first and last meter values
+            this.emit('created', [event]);
+            this.transaction.emit(created ? 'created' : 'updated', [finalTransaction]);
+            return finalTransaction;
+        });
+    }
+    async readAllByStationIdAndTransactionId(tenantId, stationId, transactionId) {
+        // Optimize memory: Skip eager loading of MeterValues to avoid loading large arrays
+        // MeterValues can be loaded separately per TransactionEvent if needed
+        return await super
+            .readAllByQuery(tenantId, {
+            where: { stationId },
+            include: [{ model: Transaction, where: { transactionId } }, Evse],
+            // Removed MeterValue eager loading to prevent memory issues with many meter values
+        })
+            .then((transactionEvents) => {
+            transactionEvents?.forEach((transactionEvent) => (transactionEvent.transaction = undefined));
+            return transactionEvents;
+        });
+    }
+    async readTransactionByStationIdAndTransactionId(tenantId, stationId, transactionId) {
+        // Optimize memory: Skip eager loading of all MeterValues to avoid memory issues
+        // MeterValues can be loaded separately if needed using readAllMeterValuesByTransactionDataBaseId
+        return await this.transaction.readOnlyOneByQuery(tenantId, {
+            where: { stationId, transactionId },
+            // Removed MeterValue eager loading to prevent memory leaks during long charging sessions
+        });
+    }
+    async readAllTransactionsByStationIdAndEvseAndChargingStates(tenantId, stationId, evse, chargingStates) {
+        const includeObj = evse
+            ? [
+                {
+                    model: Evse,
+                    where: { evseTypeId: evse.id },
+                },
+            ]
+            : [];
+        if (evse?.connectorId) {
+            includeObj.push({
+                model: Connector,
+                where: { evseTypeConnectorId: evse.connectorId },
+            });
+        }
+        return await this.transaction
+            .readAllByQuery(tenantId, {
+            where: {
+                stationId,
+                ...(chargingStates ? { chargingState: { [Op.in]: chargingStates } } : {}),
+            },
+            include: includeObj,
+        })
+            .then((row) => row);
+    }
+    async readAllActiveTransactionsByAuthorizationId(tenantId, authorizationId) {
+        return await this.transaction.readAllByQuery(tenantId, {
+            where: { isActive: true, authorizationId },
+        });
+    }
+    async readAllMeterValuesByTransactionDataBaseId(tenantId, transactionDataBaseId) {
+        return this.meterValue
+            .readAllByQuery(tenantId, {
+            where: { transactionDatabaseId: transactionDataBaseId },
+        })
+            .then((row) => row);
+    }
+    async findByTransactionId(tenantId, transactionId) {
+        return this.transaction.readOnlyOneByQuery(tenantId, {
+            where: { transactionId },
+            include: [
+                { model: TransactionEvent, as: Transaction.TRANSACTION_EVENTS_ALIAS, include: [EvseType] },
+                MeterValue,
+            ],
+        });
+    }
+    async getTransactions(tenantId, dateFrom, dateTo, offset, limit) {
+        const queryOptions = {
+            where: {},
+            include: [
+                { model: TransactionEvent, as: Transaction.TRANSACTION_EVENTS_ALIAS, include: [EvseType] },
+                MeterValue,
+            ],
+        };
+        if (dateFrom) {
+            queryOptions.where.updatedAt = queryOptions.where.updatedAt || {};
+            queryOptions.where.updatedAt[Op.gte] = dateFrom;
+        }
+        if (dateTo) {
+            queryOptions.where.updatedAt = queryOptions.where.updatedAt || {};
+            queryOptions.where.updatedAt[Op.lt] = dateTo;
+        }
+        if (offset) {
+            queryOptions.offset = offset;
+        }
+        if (limit) {
+            queryOptions.limit = limit;
+        }
+        return this.transaction.readAllByQuery(tenantId, queryOptions);
+    }
+    async getTransactionsCount(tenantId, dateFrom, dateTo) {
+        const queryOptions = {
+            where: {},
+        };
+        if (dateFrom) {
+            queryOptions.where.updatedAt = queryOptions.where.updatedAt || {};
+            queryOptions.where.updatedAt[Op.gte] = dateFrom;
+        }
+        if (dateTo) {
+            queryOptions.where.updatedAt = queryOptions.where.updatedAt || {};
+            queryOptions.where.updatedAt[Op.lt] = dateTo;
+        }
+        return Transaction.count(queryOptions);
+    }
+    async readAllTransactionsByQuery(tenantId, query) {
+        return await this.transaction.readAllByQuery(tenantId, query);
+    }
+    async getEvseIdsWithActiveTransactionByStationId(tenantId, stationId) {
+        const activeTransactions = await this.transaction.readAllByQuery(tenantId, {
+            where: {
+                stationId: stationId,
+                isActive: true,
+            },
+            include: [Evse],
+        });
+        const evseIds = [];
+        activeTransactions.forEach((transaction) => {
+            const evseId = transaction.evse?.evseTypeId;
+            if (evseId) {
+                evseIds.push(evseId);
+            }
+        });
+        return evseIds;
+    }
+    async getActiveTransactionByStationIdAndEvseId(tenantId, stationId, evseId) {
+        return await this.transaction
+            .readAllByQuery(tenantId, {
+            where: {
+                stationId,
+                isActive: true,
+            },
+            include: [
+                {
+                    model: TransactionEvent,
+                    as: Transaction.TRANSACTION_EVENTS_ALIAS,
+                    include: [EvseType],
+                },
+                MeterValue,
+                { model: Evse, where: { evseTypeId: evseId }, required: true },
+            ],
+        })
+            .then((transactions) => {
+            if (transactions.length > 1) {
+                transactions.sort((t1, t2) => t2.updatedAt.getTime() - t1.updatedAt.getTime());
+            }
+            return transactions[0];
+        });
+    }
+    async createMeterValue(tenantId, meterValue, transactionDatabaseId, transactionId, tariffId) {
+        const meterValueType = OCPP2_0_1_Mapper.MeterValueMapper.fromMeterValueType(meterValue);
+        const savedMeterValue = await MeterValue.create({
+            tenantId,
+            transactionDatabaseId: transactionDatabaseId,
+            transactionId,
+            tariffId,
+            ...meterValueType,
+        });
+        this.meterValue.emit('created', [savedMeterValue]);
+        return savedMeterValue;
+    }
+    async updateTransactionTotalCostById(tenantId, totalCost, id) {
+        await this.transaction.updateByKey(tenantId, { totalCost: totalCost }, id.toString());
+    }
+    async updateTransactionByMeterValues(tenantId, meterValues, stationId, transactionId) {
+        // Find existing transaction
+        const transaction = await this.readTransactionByStationIdAndTransactionId(tenantId, stationId, transactionId.toString());
+        if (!transaction) {
+            this.logger.error(`Transaction ${transactionId} on station ${stationId} does not exist.`);
+            return;
+        }
+        // Store meter values
+        await Promise.all(meterValues.map(async (meterValue) => {
+            meterValue.transactionDatabaseId = transaction.id;
+            meterValue.transactionId = transaction.transactionId;
+            meterValue.tariffId = transaction.tariffId;
+            const createdMeterValue = await MeterValue.create(meterValue);
+            this.meterValue.emit('created', [createdMeterValue]);
+        }));
+        if (transaction.meterStart === null || transaction.meterStart === undefined) {
+            const meterStart = MeterValueUtils.getMeterStart(meterValues);
+            await transaction.update({
+                totalKwh: MeterValueUtils.getTotalKwh(meterValues, transaction.totalKwh ?? 0, meterStart ?? undefined),
+                meterStart: meterStart,
+            });
+        }
+        else {
+            await transaction.update({
+                totalKwh: MeterValueUtils.getTotalKwh(meterValues, transaction.totalKwh ?? 0, transaction.meterStart ?? undefined),
+            });
+        }
+    }
+    async createTransactionByStartTransaction(tenantId, request, stationId) {
+        return await this.s.transaction(async (sequelizeTransaction) => {
+            // Build StartTransaction event
+            let event = StartTransaction.build({
+                tenantId,
+                stationId,
+                ...request,
+            });
+            // Associate Connector with StartTransaction
+            const connector = await this.connector.readOnlyOneByQuery(tenantId, {
+                where: {
+                    connectorId: request.connectorId,
+                    stationId,
+                },
+                include: [Tariff],
+                sequelizeTransaction,
+            });
+            if (!connector) {
+                this.logger.error(`Unable to find connector ${request.connectorId}.`);
+                throw new Error(`Unable to find connector ${request.connectorId}.`);
+            }
+            event.connectorDatabaseId = connector.id;
+            // Find Authorization by IdToken
+            const authorization = await Authorization.findOne({
+                where: {
+                    idToken: request.idTag,
+                },
+                transaction: sequelizeTransaction,
+                include: [
+                    {
+                        model: AuthorizationTenant,
+                        as: 'tenants',
+                        required: true,
+                        where: { tenantId },
+                        attributes: [],
+                    },
+                ],
+            });
+            if (!authorization) {
+                this.logger.warn(`Authorization with idToken ${request.idTag} does not exist.`);
+            }
+            // Generate transactionId
+            const transactionId = await this.chargingStationSequence.getNextSequenceValue(tenantId, stationId, ChargingStationSequenceTypeEnum.transactionId);
+            // Store transaction in db
+            let newTransaction = Transaction.build({
+                tenantId,
+                stationId,
+                evseId: connector.evseId,
+                connectorId: connector.id,
+                tariffId: connector.tariffs?.[0]?.id,
+                isActive: true,
+                transactionId: transactionId.toString(),
+                authorizationId: authorization ? authorization.id : null,
+                meterStart: request.meterStart,
+                startTime: request.timestamp,
+            });
+            const chargingStation = await this.station.readByKey(tenantId, stationId);
+            if (chargingStation) {
+                if (chargingStation.locationId) {
+                    newTransaction.set('locationId', chargingStation.locationId);
+                }
+                else {
+                    this.logger.warn(`Charging station with stationId ${stationId} does not have a locationId. Transaction ${newTransaction.transactionId} will not be associated with a location, which may prevent it from being sent to upstream partners.`);
+                }
+            }
+            newTransaction = await newTransaction.save({ transaction: sequelizeTransaction });
+            // Store StartTransaction in db
+            event.transactionDatabaseId = newTransaction.id;
+            event = await event.save({ transaction: sequelizeTransaction });
+            this.startTransaction.emit('created', [event]);
+            // Return the new transaction with StartTransaction and IdToken
+            await newTransaction.reload({
+                include: [{ model: StartTransaction }],
+                transaction: sequelizeTransaction,
+            });
+            this.transaction.emit('created', [newTransaction]);
+            return newTransaction;
+        });
+    }
+    async createStopTransaction(tenantId, transactionDatabaseId, stationId, meterStop, timestamp, meterValues, reason) {
+        const transaction = await this.transaction.readOnlyOneByQuery(tenantId, {
+            where: { id: transactionDatabaseId },
+            include: [StartTransaction],
+        });
+        if (!transaction) {
+            this.logger.error(`Transaction with id ${transactionDatabaseId} not found.`);
+            throw new Error(`Transaction with id ${transactionDatabaseId} not found.`);
+        }
+        const stopTransaction = await StopTransaction.create({
+            tenantId,
+            stationId,
+            transactionDatabaseId,
+            meterStop,
+            timestamp: timestamp.toISOString(),
+            reason,
+        });
+        this.stopTransaction.emit('created', [stopTransaction]);
+        await transaction.update({
+            endTime: timestamp,
+            isActive: false,
+        });
+        if (meterValues.length > 0) {
+            await Promise.all(meterValues.map(async (meterValue) => {
+                meterValue.transactionDatabaseId = transactionDatabaseId;
+                const createdMeterValue = MeterValue.build(meterValue);
+                createdMeterValue.stopTransactionDatabaseId = stopTransaction.id;
+                await createdMeterValue.save();
+                this.meterValue.emit('created', [createdMeterValue]);
+            }));
+        }
+        return stopTransaction;
+    }
+    async updateTransactionByStationIdAndTransactionId(tenantId, transaction, transactionId, stationId) {
+        const transactions = await this.transaction.updateAllByQuery(tenantId, transaction, {
+            where: {
+                // unique constraint
+                transactionId,
+                stationId,
+            },
+        });
+        return transactions.length > 0 ? transactions[0] : undefined;
+    }
+}
+//# sourceMappingURL=TransactionEvent.js.map