@spytecgps/nova-orm 0.0.224 → 0.0.225

package/dist/repositories/alerts/getAlertsReportByUser.js

@@ -0,0 +1,127 @@
+import { Alert, AlertType } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getAlertsReportByUser = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'AlertRepository::getAlertsReportByUser - missing required parameters');
+        return [];
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'AlertRepository::getAlertsReportByUser - user id should be a valid UUID');
+        return [];
+    }
+    try {
+        await novaDataSource.connect();
+        const alertRepository = novaDataSource.getRepository(Alert);
+        const alertQuery = alertRepository
+            .createQueryBuilder('a')
+            .innerJoin('a.alertType', 'aty')
+            .where('a.userId = :userId', { userId: uuidStringToBinaryBuffer(params.filters.userId) });
+        // When is test environment, we want to show all alerts including the ones with stage = test
+        if (params.filters.isTestEnvironment) {
+            alertQuery.andWhere('( aty.stage = :stage_test or aty.stage = :stage )', {
+                stage: 'prod',
+                stage_test: 'test',
+            });
+        }
+        else
+            alertQuery.andWhere('aty.stage = :stage', { stage: 'prod' });
+        if (params.filters.imeis?.length) {
+            alertQuery.andWhere('a.imei IN (:...imeis)', { imeis: params.filters.imeis });
+        }
+        if (params.filters.clientId) {
+            alertQuery.andWhere('a.clientId = :clientId', { clientId: params.filters.clientId });
+        }
+        let alertTypeIds = params.filters.alertTypeIds;
+        if (!alertTypeIds?.length && params.filters.alertTypeNames?.length) {
+            const alertTypesRepo = novaDataSource.getRepository(AlertType);
+            const filteredAlertTypesIds = await alertTypesRepo
+                .createQueryBuilder('aty')
+                .where('LOWER(aty.name) IN (:...alertTypeNames)', {
+                alertTypeNames: params.filters.alertTypeNames.map(x => x.toLowerCase()),
+            })
+                .select('aty.id')
+                .getMany();
+            if (filteredAlertTypesIds?.length) {
+                alertTypeIds = filteredAlertTypesIds.map(x => x.id);
+            }
+        }
+        if (alertTypeIds?.length) {
+            alertQuery.andWhere('a.alertTypeId IN (:alertTypeIds)', {
+                alertTypeIds,
+            });
+        }
+        if (params.filters.boundaryId) {
+            alertQuery.andWhere('a.boundaryId = :boundaryId', {
+                boundaryId: params.filters.boundaryId,
+            });
+        }
+        if (params.filters.sendTimeFrom) {
+            alertQuery.andWhere('a.sendTime >= :sendTimeFrom', {
+                sendTimeFrom: params.filters.sendTimeFrom,
+            });
+        }
+        if (params.filters.sendTimeTo) {
+            alertQuery.andWhere('a.sendTime <= :sendTimeTo', {
+                sendTimeTo: params.filters.sendTimeTo,
+            });
+        }
+        if (params.filters.createdFrom) {
+            alertQuery.andWhere('a.createdAt >= :createdFrom', {
+                createdFrom: params.filters.createdFrom,
+            });
+        }
+        if (params.filters.createdTo) {
+            alertQuery.andWhere('a.createdAt <= :createdTo', {
+                createdTo: params.filters.createdTo,
+            });
+        }
+        const subQuery = alertQuery.clone().select('COUNT(a.id)', 'totalCount');
+        if (params.filters.imeis?.length) {
+            alertQuery.useIndex('ixAlertUserId_Imei_AlertTypeId_SendTime');
+            subQuery.useIndex('ixAlertUserId_Imei_AlertTypeId_SendTime');
+        }
+        else if (alertTypeIds?.length) {
+            alertQuery.useIndex('ixAlertUserId_AlertTypeId_SendTime');
+            subQuery.useIndex('ixAlertUserId_AlertTypeId_SendTime');
+        }
+        alertQuery.innerJoin(`(${subQuery.getQuery()})`, 'sub');
+        if (params.sortOptions?.sortField) {
+            alertQuery.orderBy(params.sortOptions.sortField, params.sortOptions.sortOrder);
+        }
+        const alerts = await alertQuery
+            .select([
+            'a.id as id',
+            'a.alertTypeId as alertTypeId',
+            'aty.name as alertTypeName',
+            'a.value as value',
+            'a.createdAt as createdAt',
+            'a.userId as userId',
+            'a.clientId as clientId',
+            'a.messageId as messageId',
+            'a.boundaryId as boundaryId',
+            'a.imei as imei',
+            'a.sendTime as sendTime',
+            'a.lat as lat',
+            'a.lon as lon',
+            'a.address as address',
+            'a.isBuffer as isBuffer',
+            'a.isNotification as isNotification',
+            'a.gpsMessageId as gpsMessageId',
+            'a.gpsUTCTime as gpsUTCTime',
+            'aty.stage as stage',
+            `sub.totalCount as totalCount`,
+        ])
+            .limit(params.pagingOptions.pageSize)
+            .offset(params.pagingOptions.pageSize * params.pagingOptions.pageIndex)
+            .getRawMany();
+        return alerts;
+    }
+    catch (error) {
+        logger.error(error, 'AlertRepository::getAlertsReportByUserId error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/alerts/index.js

@@ -0,0 +1,104 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createAlert, createAlerts } from './createAlert';
+import { createUserAlertComplain } from './createUserAlertComplain';
+import { getAlertsReportByUser } from './getAlertsReportByUser';
+export class AlertRepository extends BaseRepository {
+    /** Create an alert record
+     * @param  {CreateAlertParams} params containing information to create an alert
+     * id: The alert id. if null will be generated
+     * clientId: The client id of the owner of the device generating the alert
+     * deviceId: The device id of the device generating the alert
+     * alertTypeId: The alert type id
+     * value: The alert value
+     * userId: The user id of the user associated with the alert
+     * messageId: The message id of the message that generated the alert
+     * boundaryId: The boundary id of the boundary if the alert is related to a boundary
+     * imei: The imei of the device generating the alert
+     * sendTime: The time the alert was sent
+     * lat: The latitude of the device when the alert was generated
+     * lon: The longitude of the device when the alert was generated
+     * address: The address of the device when the alert was generated
+     * isBuffer: The is buffer flag
+     * isNotification: The is notification flag
+     * gpsUtcTime: The time the gps utc time was set
+     * relevantAddress: The relevant address
+     * gpsMessageId: The gps message id
+     * cellTowerRelevantAddress: The cell tower relevant address
+     */
+    async createAlert(params) {
+        this.logger.trace(params, `AlertRepository::createAlert started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createAlert(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AlertRepository::createAlert result');
+        return result;
+    }
+    /** Create alert records
+     * @param  {CreateAlertParams[]} params containing information to create alert records
+     * id: The alert id. if null will be generated
+     * clientId: The client id of the owner of the device generating the alert
+     * deviceId: The device id of the device generating the alert
+     * alertTypeId: The alert type id
+     * value: The alert value
+     * userId: The user id of the user associated with the alert
+     * messageId: The message id of the message that generated the alert
+     * boundaryId: The boundary id of the boundary if the alert is related to a boundary
+     * imei: The imei of the device generating the alert
+     * sendTime: The time the alert was sent
+     * lat: The latitude of the device when the alert was generated
+     * lon: The longitude of the device when the alert was generated
+     * address: The address of the device when the alert was generated
+     * isBuffer: The is buffer flag
+     * isNotification: The is notification flag
+     * gpsUtcTime: The time the gps utc time was set
+     * relevantAddress: The relevant address
+     * gpsMessageId: The gps message id
+     * cellTowerRelevantAddress: The cell tower relevant address
+     */
+    async createAlerts(params) {
+        this.logger.trace(params, `AlertRepository::createAlerts started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createAlerts(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AlertRepository::createAlerts result');
+        return result;
+    }
+    /** Get alerts report by user id
+     * @param  {GetAlertReportByUserParams} params containing information to filter alerts report by user id
+     * params.filters.userId: The user id of the user associated with the alert
+     * params.filters.imeis: The imeis of the devices generating the alert
+     * params.filters.alertTypeId: The alert type id
+     * params.filters.boundaryId: The boundary id of the boundary if the alert is related to a boundary
+     * params.filters.sendTimeFrom: The time the alert was sent from
+     * params.filters.sendTimeTo: The time the alert was sent to
+     * params.pagingOptions.pageSize: The number of alerts to return
+     * params.pagingOptions.pageIndex: The page index of the alerts to return
+     * params.sortOptions.sortField: The field to sort the alerts by
+     * params.sortOptions.sortOrder: The order to sort the alerts by desc | asc
+     * @returns Promise<AlertReport[]>
+     */
+    async getAlertsReportByUser(params) {
+        this.logger.trace(params, `AlertRepository::getAlertsReportByUserId started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAlertsReportByUser(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AlertRepository::getAlertsReportByUserId result');
+        return result;
+    }
+    /**
+     * Insert a new user alert complain
+     * @param {CreateUserAlertComplaintParams} params containing information to create a user alert complain
+     * params.alertTypeId: The alert type id that has been disabled
+     * params.userId: The user id of the user associated with the alert
+     * params.clientId: The client id of the owner of the device generating the alert
+     * params.email: The email of the user
+     * params.reason: The reason for disabling the alert
+     * params.createdAt: The datetime the complaint was received, it will default to now if not provided
+     * @returns {Promise<UserAlertComplain>} The created user alert complain
+     */
+    async createUserAlertComplain(params) {
+        this.logger.trace(params, `AlertRepository::createUserAlertComplain started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserAlertComplain(novaDataSource, params);
+        this.logger.trace(result, 'AlertRepository::createUserAlertComplain result');
+        return result;
+    }
+}

package/dist/repositories/appFeatures/createAppFeatureType.js

@@ -0,0 +1,15 @@
+import { AppFeatureType } from '../../entities';
+export const createAppFeatureType = async (novaDataSource, params, logger) => {
+    if (!params?.description || !params?.name) {
+        logger.warn({ params }, 'AppFeaturesRepository::createAppFeatureType - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const appFeatureTypeRepository = dataSource.getRepository(AppFeatureType);
+        const newAppFeature = {
+            ...params,
+            statusId: params.statusId ?? 1,
+        };
+        return await appFeatureTypeRepository.save(newAppFeature);
+    }, 'AppFeaturesRepository::createAppFeatureType');
+};

package/dist/repositories/appFeatures/createClientAppFeature.js

@@ -0,0 +1,15 @@
+import { ClientAppFeature } from '../../entities';
+export const createClientAppFeature = async (novaDataSource, params, logger) => {
+    if (!params?.clientId || !params?.appFeatureTypeId || !params.entityId) {
+        logger.warn({ params }, 'AppFeaturesRepository::createClientAppFeature - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientAppFeatureRepository = dataSource.getRepository(ClientAppFeature);
+        const newClientAppFeature = {
+            ...params,
+            statusId: params.statusId ?? 1,
+        };
+        return await clientAppFeatureRepository.save(newClientAppFeature);
+    }, 'AppFeaturesRepository::createClientAppFeature');
+};

package/dist/repositories/appFeatures/getClientAppFeatures.js

@@ -0,0 +1,39 @@
+import { ClientAppFeature } from '../../entities';
+export const getClientAppFeatures = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId &&
+        !params?.filters?.appFeatureTypeId &&
+        !params.filters?.entityId &&
+        !params.filters?.statusId) {
+        logger.warn({ params }, 'AppFeaturesRepository::getClientAppFeatures - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientAppFeaturesRepository = dataSource.getRepository(ClientAppFeature);
+        let queryBuilder = clientAppFeaturesRepository.createQueryBuilder('clientAppFeature');
+        if (params.projectionOptions?.withAppFeatureType) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('clientAppFeature.appFeatureType', 'appFeatureType');
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.clientId = :clientId`, {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (params.filters.appFeatureTypeId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.appFeatureTypeId = :appFeatureTypeId`, {
+                appFeatureTypeId: params.filters.appFeatureTypeId,
+            });
+        }
+        if (params.filters.entityId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.entityId = :entityId`, {
+                entityId: params.filters.entityId,
+            });
+        }
+        if (params.filters.statusId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.statusId = :statusId`, {
+                statusId: params.filters.statusId,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'AppFeaturesRepository::getClientAppFeatures');
+};

package/dist/repositories/appFeatures/index.js

@@ -0,0 +1,57 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createAppFeatureType } from './createAppFeatureType';
+import { createClientAppFeature } from './createClientAppFeature';
+import { getClientAppFeatures } from './getClientAppFeatures';
+export class AppFeaturesRepository extends BaseRepository {
+    /**
+     * Create a new app feature type
+     * @param params - The parameters to create the app feature type
+     * params.id - The id of the app feature type, optional. If not provided, it will be auto-generated
+     * params.name - The name of the app feature type, required
+     * params.description - The description of the app feature type, required
+     * params.statusId - The status id of the app feature type, optional, default to 1
+     * @returns The created app feature type
+     */
+    async createAppFeatureType(params) {
+        this.logger.trace('AppFeaturesRepository::createAppFeatureType started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createAppFeatureType(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AppFeaturesRepository::createAppFeatureType result');
+        return result;
+    }
+    /**
+     * Create a new client app feature
+     * @param params - The parameters to create the client app feature
+     * params.clientId: The client id of the client app feature, required
+     * params.appFeatureTypeId: The app feature type id of the client app feature, required
+     * params.entityId: The entity id of the client app feature, required
+     * params.statusId: The status id of the client app feature, optional, default to 1
+     * @returns The created client app feature
+     */
+    async createClientAppFeature(params) {
+        this.logger.trace('AppFeaturesRepository::createClientAppFeature started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createClientAppFeature(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AppFeaturesRepository::createClientAppFeature result');
+        return result;
+    }
+    /**
+     * Get client app features
+     * @param params - The parameters to get client app features
+     * One of the following filters is required:
+     * params.filters.clientId: The client id to filter, optional
+     * params.filters.appFeatureTypeId: The app feature type id to filter, optional
+     * params.filters.entityId: The entity id to filter, optional
+     * params.filters.statusId: The status id to filter, optional
+     * params.projectionOptions.withAppFeatureType: Whether to include app feature type relation in the result
+     * @returns The client app features
+     */
+    async getClientAppFeatures(params) {
+        this.logger.trace('AppFeaturesRepository::getClientAppFeatures started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getClientAppFeatures(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AppFeaturesRepository::getClientAppFeatures result');
+        return result;
+    }
+}

package/dist/repositories/assetCategories/getAssetCategories.js

@@ -0,0 +1,8 @@
+import { AssetCategory } from '../../entities';
+export const getAssetCategories = async (novaDataSource) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const assetCategoriesRepository = dataSource.getRepository(AssetCategory);
+        const result = await assetCategoriesRepository.find();
+        return result;
+    }, 'AssetcategoriesRepository::getAssetCategories');
+};

package/dist/repositories/assetCategories/index.js

@@ -0,0 +1,16 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { getAssetCategories } from './getAssetCategories';
+export class AssetCategoriesRepository extends BaseRepository {
+    /**
+     * Get all asset categories
+     * @returns {Promise<AssetCategory[]>} The asset categories
+     */
+    async getAssetCategories() {
+        this.logger.trace('AssetCategoriesRepository::getAssetCategories started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAssetCategories(novaDataSource);
+        this.logger.trace(result, 'AssetCategoriesRepository::getAssetCategories result');
+        return result;
+    }
+}

package/dist/repositories/baseRepository.js

@@ -0,0 +1,9 @@
+import { ConsoleLogger } from '../utils/consoleLogger';
+export class BaseRepository {
+    novaDataSourceConfig;
+    logger;
+    constructor(config, logger) {
+        this.novaDataSourceConfig = config;
+        this.logger = logger ?? new ConsoleLogger();
+    }
+}

package/dist/repositories/billing/createBilling.js

@@ -0,0 +1,37 @@
+import { Billing } from '../../entities';
+export const createBilling = async (novaDataSource, params, logger) => {
+    if (!params?.id &&
+        !params?.deviceId &&
+        !params?.clientId &&
+        !params?.subscriptionId &&
+        !params?.imei &&
+        !params?.planId &&
+        !params?.platform &&
+        !params?.status &&
+        !params?.subscriptionValue &&
+        !params?.subscriptionPeriodMonths &&
+        !params?.subscriptionValueMonthly) {
+        logger.warn({ params }, 'BillingRepository::createBilling - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingRepository = dataSource.getRepository(Billing);
+        const now = new Date();
+        const newBilling = {
+            id: params.id,
+            deviceId: params.deviceId,
+            imei: params.imei,
+            planId: params.planId,
+            subscriptionId: params.subscriptionId,
+            platform: params.platform,
+            status: params.status,
+            subscriptionValue: params.subscriptionValue,
+            subscriptionPeriodMonths: params.subscriptionPeriodMonths,
+            subscriptionValueMonthly: params.subscriptionValueMonthly,
+            clientId: params.clientId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        return await billingRepository.save(newBilling);
+    }, 'BillingRepository::createBilling');
+};

package/dist/repositories/billing/createBillingDeviceHistory.js

@@ -0,0 +1,30 @@
+import { BillingDeviceHistory } from '../../entities';
+export const createBillingDeviceHistory = async (novaDataSource, params, logger) => {
+    if (!params?.id &&
+        !params?.clientId &&
+        !params?.deviceId &&
+        !params?.subscriptionId &&
+        !params?.imei &&
+        !params?.planId &&
+        !params?.platform &&
+        !params?.status) {
+        logger.warn({ params }, 'BillingRepository::createBillingDeviceHistory - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingRepository = dataSource.getRepository(BillingDeviceHistory);
+        const now = new Date();
+        const newBillingDeviceHistory = {
+            id: params.id,
+            deviceId: params.deviceId,
+            clientId: params.clientId,
+            imei: params.imei,
+            planId: params.planId,
+            subscriptionId: params.subscriptionId,
+            platform: params.platform,
+            status: params.status,
+            createAt: now,
+        };
+        return await billingRepository.save(newBillingDeviceHistory);
+    }, 'BillingRepository::createBillingDeviceHistory');
+};

package/dist/repositories/billing/createBillingHubspotPaymentLog.js

@@ -0,0 +1,61 @@
+import { BillingHubspotPaymentLog } from '../../entities';
+export const createBillingHubspotPaymentLog = async (novaDataSource, params, logger) => {
+    if (!params?.amountPaid) {
+        logger.warn({ params }, 'BillingRepository::createBillingHubspotPaymentLog - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const BillingHubspotPaymentLogRepository = dataSource.getRepository(BillingHubspotPaymentLog);
+        const newBillingHubspotPaymentLog = {
+            id: params.id,
+            amountPaid: params.amountPaid,
+            owner: params.owner,
+            bankOfIssuer: params.bankOfIssuer,
+            billingAddress: params.billingAddress,
+            billingAddressCity: params.billingAddressCity,
+            billingAddressCountry: params.billingAddressCountry,
+            billingAddressLine1: params.billingAddressLine1,
+            billingAddressLine2: params.billingAddressLine2,
+            billingAddressState: params.billingAddressState,
+            billingAddressZip: params.billingAddressZip,
+            createdByUserId: params.createdByUserId,
+            currencyCode: params.currencyCode,
+            customer: params.customer,
+            grossAmount: params.grossAmount,
+            lastFourDigits: params.lastFourDigits,
+            lineItemDiscountAmount: params.lineItemDiscountAmount,
+            netAmount: params.netAmount,
+            objectCreateDateTime: params.objectCreateDateTime,
+            objectId: params.objectId,
+            objectLastModifiedDateTime: params.objectLastModifiedDateTime,
+            orderDiscountAmount: params.orderDiscountAmount,
+            orderDiscountCode: params.orderDiscountCode,
+            orderDiscountPercentage: params.orderDiscountPercentage,
+            ownerAssignedDateTime: params.ownerAssignedDateTime,
+            paymentDateTime: params.paymentDateTime,
+            paymentId: params.paymentId,
+            paymentMethod: params.paymentMethod,
+            paymentSourceName: params.paymentSourceName,
+            paymentType: params.paymentType,
+            processingFees: params.processingFees,
+            refunded: params.refunded,
+            shippingAddress: params.shippingAddress,
+            shippingAddressCity: params.shippingAddressCity,
+            shippingAddressCountry: params.shippingAddressCountry,
+            shippingAddressLine1: params.shippingAddressLine1,
+            shippingAddressLine2: params.shippingAddressLine2,
+            shippingAddressState: params.shippingAddressState,
+            shippingAddressZip: params.shippingAddressZip,
+            source: params.source,
+            sourceId: params.sourceId,
+            sourceUrl: params.sourceUrl,
+            status: params.status,
+            statusUpdatedOn: params.statusUpdatedOn,
+            totalDiscountAmount: params.totalDiscountAmount,
+            totalFees: params.totalFees,
+            totalTaxes: params.totalTaxes,
+            updatedByUserId: params.updatedByUserId,
+        };
+        return await BillingHubspotPaymentLogRepository.save(newBillingHubspotPaymentLog);
+    }, 'BillingRepository::createBillingHubspotPaymentLog');
+};

package/dist/repositories/billing/createBillingStatusHistoryBraintree.js

@@ -0,0 +1,32 @@
+import { BillingStatusHistoryBraintree } from '../../entities';
+export const createBillingStatusHistoryBraintree = async (novaDataSource, params, logger) => {
+    if (!params?.subscriptionId || !params?.subscriptionHistories?.length) {
+        logger.warn({ params }, 'BillingRepository::createBillingStatusHistoryBraintree - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingStatusHistoryBraintreeRepository = dataSource.getRepository(BillingStatusHistoryBraintree);
+        const existingHistoriesRaw = await billingStatusHistoryBraintreeRepository
+            .createQueryBuilder('billingStatusHistoryBraintree')
+            .where('billingStatusHistoryBraintree.subscriptionId = :subscriptionId', {
+            subscriptionId: params.subscriptionId,
+        })
+            .andWhere('billingStatusHistoryBraintree.timestamp IN (:...timestamps)', {
+            timestamps: params.subscriptionHistories.map(history => history.timestamp),
+        })
+            .select('billingStatusHistoryBraintree.timestamp', 'timestamp')
+            .getRawMany();
+        const existingTimestamps = existingHistoriesRaw.map(history => history.timestamp);
+        const historiesToCreate = [];
+        for (const history of params.subscriptionHistories) {
+            if (!existingTimestamps.find(existingTimestamp => existingTimestamp === history.timestamp)) {
+                historiesToCreate.push({
+                    ...history,
+                    subscriptionId: params.subscriptionId,
+                });
+            }
+        }
+        const insertResult = await billingStatusHistoryBraintreeRepository.save(historiesToCreate);
+        return insertResult;
+    }, 'BillingRepository::createBillingStatusHistoryBraintree');
+};

package/dist/repositories/billing/getBillingCustomerBraintreeById.js

@@ -0,0 +1,18 @@
+import { BillingCustomerBraintree } from '../../entities';
+export const getBillingCustomerBraintreeById = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'BillingRepository::getBillingCustomerBraintreeById - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingCustomerBraintreeRepository = dataSource.getRepository(BillingCustomerBraintree);
+        const queryBuilder = billingCustomerBraintreeRepository
+            .createQueryBuilder('billingCustomerBraintree')
+            .where(`billingCustomerBraintree.id = :id`, {
+            id: params.filters.id,
+        })
+            .limit(1);
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'BillingRepository::getBillingCustomerBraintreeById');
+};

package/dist/repositories/billing/getBillingKlarnaOrderByImei.js

@@ -0,0 +1,18 @@
+import { Billing, BillingKlarnaOrder } from '../../entities';
+export const getBillingKlarnaOrderByImei = async (novaDataSource, params, logger) => {
+    if (!params?.imei) {
+        logger.warn({ params }, 'BillingRepository::getBillingKlarnaOrderByImei - missing imei parameter');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingKlarnaOrderRepository = dataSource.getRepository(BillingKlarnaOrder);
+        const queryBuilder = billingKlarnaOrderRepository
+            .createQueryBuilder('billingKlarnaOrder')
+            .innerJoin(Billing, 'billing', 'billingKlarnaOrder.orderId = billing.subscriptionId')
+            .where(`billing.imei = :imei`, {
+            imei: params.imei,
+        });
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'BillingRepository::getBillingKlarnaOrderByImei');
+};

package/dist/repositories/billing/getBillingSubscriptionBraintreeByImei.js

@@ -0,0 +1,18 @@
+import { Billing, BillingSubscriptionBraintree } from '../../entities';
+export const getBillingSubscriptionsBraintreeByImei = async (novaDataSource, params, logger) => {
+    if (!params?.imei) {
+        logger.warn({ params }, 'BillingRepository::getBillingSubscriptionsBraintreeByImei - missing imei parameter');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingSubscriptionBraintreeRepository = dataSource.getRepository(BillingSubscriptionBraintree);
+        const queryBuilder = billingSubscriptionBraintreeRepository
+            .createQueryBuilder('billingSubscriptionBraintree')
+            .innerJoin(Billing, 'billing', 'billingSubscriptionBraintree.subscriptionId = billing.subscriptionId')
+            .where(`billing.imei = :imei`, {
+            imei: params.imei,
+        });
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'BillingRepository::getBillingSubscriptionsBraintreeByImei');
+};

package/dist/repositories/billing/getBillingSubscriptionsBraintree.js

@@ -0,0 +1,25 @@
+import { Billing, BillingSubscriptionBraintree } from '../../entities';
+export const getBillingSubscriptionsBraintree = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.subscriptionId && !params?.filters?.clientId) {
+        logger.warn({ params }, 'BillingRepository::getBillingSubscriptionsBraintree - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const billingSubscriptionBraintreeRepository = dataSource.getRepository(BillingSubscriptionBraintree);
+        let queryBuilder = billingSubscriptionBraintreeRepository.createQueryBuilder('billingSubscriptionBraintree');
+        if (params?.filters?.subscriptionId) {
+            queryBuilder = queryBuilder.where(`billingSubscriptionBraintree.subscriptionId = :subscriptionId`, {
+                subscriptionId: params.filters.subscriptionId,
+            });
+        }
+        if (params?.filters?.clientId) {
+            queryBuilder = queryBuilder
+                .innerJoin(Billing, 'billing', 'billingSubscriptionBraintree.subscriptionId = billing.subscriptionId')
+                .where(`billing.clientId = :clientId`, {
+                clientId: params.filters.clientId,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'BillingRepository::getBillingSubscriptionsBraintree');
+};