@spytecgps/nova-orm 0.0.223 → 0.0.225

package/dist/migration/1684483704434-addLowerCaseIndex.js

@@ -0,0 +1,16 @@
+export class addLowerCaseIndex1684483704434 {
+    async up(queryRunner) {
+        await queryRunner.query('ALTER TABLE `client` ADD KEY `ixClientEmailLower` ((lower(`email`)))');
+        await queryRunner.query('ALTER TABLE `device` ADD KEY `ixDeviceImeiLower` ((lower(`imei`)))');
+        await queryRunner.query('ALTER TABLE `user` ADD KEY `ixUserEmailLower` ((lower(`email`)))');
+        await queryRunner.query('ALTER TABLE `user` ADD KEY `ixUserNameLower` ((lower(`userName`)))');
+        await queryRunner.query('ALTER TABLE `user` ADD KEY `ixPreferredUserNameLower` ((lower(`preferredUserName`)))');
+    }
+    async down(queryRunner) {
+        await queryRunner.query('ALTER TABLE `client` DROP KEY `ixClientEmailLower`');
+        await queryRunner.query('ALTER TABLE `device` DROP KEY `ixDeviceImeiLower`');
+        await queryRunner.query('ALTER TABLE `user` DROP KEY `ixUserEmailLower`');
+        await queryRunner.query('ALTER TABLE `user` DROP KEY `ixUserNameLower`');
+        await queryRunner.query('ALTER TABLE `user` DROP KEY `ixPreferredUserNameLower`');
+    }
+}

package/dist/novaDataSource.js

@@ -0,0 +1,110 @@
+import { DataSource, } from 'typeorm';
+import { Entities } from '.';
+import * as Subscribers from './subscribers';
+import { QueryLogger } from './utils/queryLogger';
+export class NovaDataSource {
+    dataSource;
+    logger;
+    constructor(config, logger) {
+        this.logger = logger;
+        const entities = [];
+        for (const key in Entities) {
+            if (Entities.hasOwnProperty(key)) {
+                const entity = Entities[key];
+                entities.push(entity);
+            }
+        }
+        const subscribers = [];
+        for (const key in Subscribers) {
+            if (Subscribers.hasOwnProperty(key)) {
+                const subscriber = Subscribers[key];
+                subscribers.push(subscriber);
+            }
+        }
+        this.dataSource = new DataSource({
+            type: 'mysql',
+            host: 'aws.connect.psdb.cloud',
+            port: 3306,
+            database: 'nova',
+            ssl: {
+                rejectUnauthorized: true,
+            },
+            synchronize: false,
+            logging: true,
+            logger: new QueryLogger(this.logger, config.logging),
+            entities,
+            subscribers,
+            supportBigNumbers: true,
+            bigNumberStrings: false,
+            extra: {
+                decimalNumbers: true,
+            },
+            ...config,
+        });
+    }
+    /**
+     * Performs connection to the database.
+     */
+    async connect() {
+        await this.dataSource.initialize();
+    }
+    /**
+     * Closes connection with the database.
+     * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.
+     */
+    async disconnect() {
+        try {
+            if (this.dataSource.isInitialized) {
+                await this.dataSource.destroy();
+            }
+        }
+        catch (error) {
+            this.logger.error({ error }, 'Failed to close connection to database');
+        }
+    }
+    /**
+     * Gets repository for the given entity.
+     */
+    getRepository(target) {
+        return this.dataSource.getRepository(target);
+    }
+    /**
+     * Executes raw SQL query and returns raw database results.
+     */
+    async query(query, parameters) {
+        return this.dataSource.query(query, parameters, null);
+    }
+    /**
+     * Creates a new query builder that can be used to build a SQL query.
+     */
+    async createQueryBuilder(entityClass, alias) {
+        return this.dataSource.createQueryBuilder(entityClass, alias, null);
+    }
+    /**
+     * Creates a query runner used for perform queries on a single database connection.
+     * Using query runners you can control your queries to execute using single database connection and
+     * manually control your database transaction.
+     *
+     * Mode is used in replication mode and indicates whatever you want to connect
+     * to master database or any of slave databases.
+     * If you perform writes you must use master database,
+     * if you perform reads you can use slave databases.
+     */
+    createQueryRunner(mode) {
+        return this.dataSource.createQueryRunner(mode);
+    }
+    async safeQuery(queryBuilderHandler, tag) {
+        try {
+            await this.connect();
+            const result = await queryBuilderHandler(this);
+            return result;
+        }
+        catch (error) {
+            this.logger.error({ error }, tag ? tag + ' ' : '' + 'Error while executing query');
+            throw error;
+        }
+        finally {
+            await this.disconnect();
+        }
+    }
+}

package/dist/repositories/acumatica/getAcumaticaImeiIccidData.js

@@ -0,0 +1,35 @@
+import { AcumaticaImeiIccidData } from '../../entities';
+export const getAcumaticaImeiIccidData = async (novaDataSource, params, logger) => {
+    if (!params.filters.imei &&
+        params.filters.excludeNullAsin == null &&
+        params.filters.excludeNullCountyCode == null &&
+        !params.filters.excludeCountries?.length) {
+        logger.warn({ params }, 'AcumaticaRepository::getAcumaticaImeiIccidData - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const acumaticaImeiIccidDataRepository = dataSource.getRepository(AcumaticaImeiIccidData);
+        const queryBuilder = acumaticaImeiIccidDataRepository.createQueryBuilder('acumaticaImeiIccidData');
+        if (params.filters.imei) {
+            queryBuilder.where('acumaticaImeiIccidData.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        if (params.filters.excludeNullAsin) {
+            queryBuilder.andWhere('acumaticaImeiIccidData.asin IS NOT NULL');
+        }
+        if (params.filters.excludeNullCountyCode) {
+            queryBuilder.andWhere('acumaticaImeiIccidData.countryCode IS NOT NULL');
+        }
+        if (params.filters.excludeCountries?.length) {
+            queryBuilder.andWhere('acumaticaImeiIccidData.countryCode NOT IN (:...excludeCountries)', {
+                excludeCountries: params.filters.excludeCountries,
+            });
+        }
+        if (params.sortOptions?.sortField) {
+            queryBuilder.orderBy(`acumaticaImeiIccidData.${params.sortOptions.sortField}`, params.sortOptions.sortOrder === 'ASC' ? 'ASC' : 'DESC');
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'AcumaticaRepository::getAcumaticaImeiIccidData');
+};

package/dist/repositories/acumatica/getAcumaticaShipmentDetails.js

@@ -0,0 +1,50 @@
+import { AcumaticaAmazonProduct, AcumaticaImeiIccidData, AcumaticaOrderShipmentDetails, } from '../../entities';
+export const getAcumaticaShipmentDetails = async (novaDataSource, params, logger) => {
+    if (!params.filters.imeiList?.length) {
+        logger.warn({ params }, 'AcumaticaRepository::getAcumaticaShipmentDetails - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const acumaticaOrderShipmentDetailsRepository = dataSource.getRepository(AcumaticaOrderShipmentDetails);
+        const queryBuilder1 = acumaticaOrderShipmentDetailsRepository
+            .createQueryBuilder('acumaticaOrderShipmentDetails')
+            .where('acumaticaOrderShipmentDetails.imei IN (:imeiList)', {
+            imeiList: params.filters.imeiList,
+        })
+            .select([
+            'acumaticaOrderShipmentDetails.imei as imei',
+            'acumaticaOrderShipmentDetails.iccid as iccid',
+            `acumaticaOrderShipmentDetails.orderType as orderType`,
+            'acumaticaOrderShipmentDetails.shipmentDate as shipmentDate',
+            'NULL as reviewUrl',
+            'NULL as productUrl',
+        ]);
+        const query1WithParams = queryBuilder1.getQueryAndParameters();
+        const acumaticaImeiIccidDataRepository = dataSource.getRepository(AcumaticaImeiIccidData);
+        const queryBuilder2 = acumaticaImeiIccidDataRepository
+            .createQueryBuilder('acumaticaImeiIccidData')
+            .leftJoin(AcumaticaAmazonProduct, 'acumaticaAmazonProduct', 'acumaticaAmazonProduct.asin = acumaticaImeiIccidData.asin')
+            .where('acumaticaImeiIccidData.imei IN (:imeiList)', {
+            imeiList: params.filters.imeiList,
+        })
+            .select([
+            'acumaticaImeiIccidData.imei as imei',
+            'acumaticaImeiIccidData.iccid as iccid',
+            `'AZ' as orderType`,
+            'acumaticaImeiIccidData.shipDate as shipmentDate',
+            'acumaticaAmazonProduct.reviewUrl as reviewUrl',
+            'acumaticaAmazonProduct.productUrl as productUrl',
+        ]);
+        const query2WithParams = queryBuilder2.getQueryAndParameters();
+        const unionQueryParams = [...query1WithParams[1], ...query2WithParams[1]];
+        const result = await acumaticaOrderShipmentDetailsRepository.query(`(${query1WithParams[0]}) UNION (${query2WithParams[0]})`, unionQueryParams);
+        return result.map(item => ({
+            imei: item.imei,
+            iccid: item.iccid,
+            shipmentDate: item.shipmentDate instanceof Date ? item.shipmentDate : new Date(item.shipmentDate),
+            orderType: item.orderType,
+            reviewUrl: item.reviewUrl,
+            productUrl: item.productUrl,
+        }));
+    }, 'AcumaticaRepository::getAcumaticaShipmentDetails');
+};

package/dist/repositories/acumatica/getLastAcumaticaShipmentDetails.js

@@ -0,0 +1,27 @@
+import { AcumaticaImeiIccidData, Device } from '../../entities';
+export const getLastAcumaticaShipmentDetails = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'AcumaticaRepository::getLastAcumaticaShipmentDetails - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const acumaticaImeiIccidDataRepository = dataSource.getRepository(AcumaticaImeiIccidData);
+        const queryBuilder = acumaticaImeiIccidDataRepository
+            .createQueryBuilder('acumaticaImeiIccidData')
+            .innerJoin(Device, 'device', 'device.imei = acumaticaImeiIccidData.imei')
+            .where('device.clientId = :clientId', { clientId: params.filters.clientId })
+            .orderBy('acumaticaImeiIccidData.shipDate', 'DESC')
+            .limit(1);
+        const result = await queryBuilder.getOne();
+        return result
+            ? {
+                imei: result.imei,
+                iccid: result.iccid,
+                shipmentDate: new Date(result.shipDate),
+                orderType: 'AZ',
+                reviewUrl: null,
+                productUrl: null,
+            }
+            : null;
+    }, 'AcumaticaRepository::getLastAcumaticaShipmentDetails');
+};

package/dist/repositories/acumatica/index.js

@@ -0,0 +1,52 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { getAcumaticaImeiIccidData } from './getAcumaticaImeiIccidData';
+import { getAcumaticaShipmentDetails } from './getAcumaticaShipmentDetails';
+import { getLastAcumaticaShipmentDetails } from './getLastAcumaticaShipmentDetails';
+export class AcumaticaRepository extends BaseRepository {
+    /**
+     * Get Acumatica IMEI/ICCID data
+     * @param params containing information to get magento plan
+     * One of the following filters is required:
+     * - params.filters.imei IMEI to filter by
+     * - params.filters.excludeNullAsin Exclude IMEI/ICCID data with null ASIN
+     * - params.filters.excludeNullCountyCode Exclude IMEI/ICCID data with null country code
+     * - params.filters.excludeCountries Exclude IMEI/ICCID data with country code in this list
+     * - params.sortOptions.sortField Sort field
+     * - params.sortOptions.sortOrder Sort order
+     * @returns Acumatica IMEI/ICCID data list
+     */
+    async getAcumaticaImeiIccidData(params) {
+        this.logger.trace(params, `AcumaticaRepository::getAcumaticaImeiIccidData started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAcumaticaImeiIccidData(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AcumaticaRepository::getAcumaticaImeiIccidData result');
+        return result;
+    }
+    /**
+     * Get last Acumatica shipment details
+     * @param params containing information to get last Acumatica shipment details
+     * - params.filters.clientId Client ID to filter by
+     * @returns last Amazon device shipment details
+     */
+    async getLastAcumaticaShipmentDetails(params) {
+        this.logger.trace(params, `AcumaticaRepository::getLastAcumaticaShipmentDetails started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getLastAcumaticaShipmentDetails(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AcumaticaRepository::getLastAcumaticaShipmentDetails result');
+        return result;
+    }
+    /**
+     * Get Acumatica shipment details list
+     * @param params containing information to get Acumatica shipment details list
+     * - params.filters.imeiList IMEI list to filter by
+     * @returns Acumatica shipment details list
+     */
+    async getAcumaticaShipmentDetails(params) {
+        this.logger.trace(params, `AcumaticaRepository::getAcumaticaShipmentDetails started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAcumaticaShipmentDetails(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AcumaticaRepository::getAcumaticaShipmentDetails result');
+        return result;
+    }
+}

package/dist/repositories/aempToken/createAempToken.js

@@ -0,0 +1,26 @@
+import { AempToken } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createAempToken = async (novaDataSource, params, logger) => {
+    if (!params?.clientId || !params?.token) {
+        logger.warn({ params }, 'AempTokenRepository::createAempToken - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.token);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'AempTokenRepository::createAempToken - token should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const aempTokensRepository = dataSource.getRepository(AempToken);
+        const now = new Date();
+        const newAempToken = {
+            id: params?.id,
+            clientId: params?.clientId,
+            token: binaryBuffer,
+            createdAt: now,
+            updatedAt: now,
+            expiresAt: params?.expiresAt,
+        };
+        return await aempTokensRepository.save(newAempToken);
+    }, 'AempTokenRepository::createAempToken');
+};

package/dist/repositories/aempToken/deleteAempTokens.js

@@ -0,0 +1,30 @@
+import { AempToken } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const deleteAempTokens = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id && !params?.filters?.clientId && !params?.filters?.token) {
+        logger.warn({ params }, 'AempTokenRepository::deleteAempTokens - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.token);
+    if (params?.filters?.token && !binaryBuffer?.length) {
+        logger.warn({ params }, 'AempTokenRepository::deleteAempTokens - token should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const AempTokensRepository = dataSource.getRepository(AempToken);
+        let queryBuilder = AempTokensRepository.createQueryBuilder().delete();
+        if (params.filters.id) {
+            queryBuilder = queryBuilder.where('id = :id', { id: params.filters.id });
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.where('clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (params.filters.token) {
+            queryBuilder = queryBuilder.where('token = :token', { token: binaryBuffer });
+        }
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'AempTokenRepository::deleteAempTokens');
+};

package/dist/repositories/aempToken/getAempTokens.js

@@ -0,0 +1,27 @@
+import { AempToken } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getAempTokens = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId && !params?.filters?.token) {
+        logger.warn({ params }, 'AempTokenRepository::getAempTokens - missing required parameters');
+        return [];
+    }
+    const tokenBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.token);
+    if (params?.filters?.token && !tokenBinaryBuffer?.length) {
+        logger.warn({ params }, 'AempTokenRepository::getClientIdForToken - token should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const AempTokensRepository = dataSource.getRepository(AempToken);
+        let queryBuilder = AempTokensRepository.createQueryBuilder('AempToken');
+        if (params?.filters?.clientId) {
+            queryBuilder = queryBuilder.where('AempToken.clientId = :clientId', {
+                clientId: params?.filters?.clientId,
+            });
+        }
+        if (params?.filters?.token) {
+            queryBuilder = queryBuilder.where('AempToken.token = :token', { token: tokenBinaryBuffer });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'AempTokenRepository::getAempTokens');
+};

package/dist/repositories/aempToken/index.js

@@ -0,0 +1,53 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createAempToken } from './createAempToken';
+import { deleteAempTokens } from './deleteAempTokens';
+import { getAempTokens } from './getAempTokens';
+export class AempTokenRepository extends BaseRepository {
+    /**
+     * Get AMP tokens by client ID
+     * @param params - GetAempTokensParams
+     * One of the following is required:
+     * - filters.clientId: The client id
+     * - filters.token: The token
+     * @returns AempToken[]
+     */
+    async getAempTokens(params) {
+        this.logger.trace(params, 'AempTokenRepository::getAempTokens started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAempTokens(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AempTokenRepository::getAempTokens result');
+        return result;
+    }
+    /**
+     * Create an AMP token
+     * @param params - CreateAempTokenParams
+     * - clientId: The client id, required
+     * - token: The token, required
+     * - expiresAt: The expiration date, optional
+     * @returns AempToken
+     */
+    async createAempToken(params) {
+        this.logger.trace(params, 'AempTokenRepository::createAempToken started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createAempToken(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AempTokenRepository::createAempToken result');
+        return result;
+    }
+    /**
+     * Delete AMP tokens
+     * @param params - DeleteAempTokensParams
+     * One of the following is required:
+     * - filters.id: The id
+     * - filters.clientId: The client id
+     * - filters.token: The token
+     * @returns True if the token was deleted, false otherwise
+     */
+    async deleteAempTokens(params) {
+        this.logger.trace(params, 'AempTokenRepository::deleteAempTokens started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteAempTokens(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'AempTokenRepository::deleteAempTokens result');
+        return result;
+    }
+}

package/dist/repositories/alertTypes/getAlertTypes.js

@@ -0,0 +1,13 @@
+import { AlertType } from '../../entities';
+export const getAlertTypes = async (novaDataSource, params) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const alertTypesRepository = dataSource.getRepository(AlertType);
+        let queryBuilder = alertTypesRepository.createQueryBuilder('alertType');
+        const includeBeta = params?.filters?.includeBeta ?? false;
+        if (!includeBeta) {
+            queryBuilder = queryBuilder.where(`alertType.stage = 'prod'`);
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'AlertTypesRepository::getAlertTypes');
+};

package/dist/repositories/alertTypes/index.js

@@ -0,0 +1,18 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { getAlertTypes } from './getAlertTypes';
+export class AlertTypesRepository extends BaseRepository {
+    /*
+     * Get alert types
+     * @param {GetAlertTypesParams} params containing information to get alert types
+     * - filters.includeBeta: Whether to include beta alert types, optional. If not provided, defaults to false
+     * @returns The alert types list
+     */
+    async getAlertTypes(params) {
+        this.logger.trace(params, 'AlertTypesRepository::getAlertTypes started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAlertTypes(novaDataSource, params);
+        this.logger.trace(result, 'AlertTypesRepository::getAlertTypes result');
+        return result;
+    }
+}

package/dist/repositories/alerts/createAlert.js

@@ -0,0 +1,94 @@
+import { Alert } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createAlert = async (novaDataSource, params, logger) => {
+    if (!params?.clientId ||
+        params.clientId === 0 ||
+        !params?.alertTypeId ||
+        params.alertTypeId === 0 ||
+        !params?.messageId ||
+        !params?.imei ||
+        !params?.sendTime) {
+        return null;
+    }
+    try {
+        await novaDataSource.connect();
+        const alertRepository = novaDataSource.getRepository(Alert);
+        const now = new Date();
+        const newAlert = {
+            id: params.id,
+            alertTypeId: params.alertTypeId,
+            value: params.value,
+            userId: uuidStringToBinaryBuffer(params.userId),
+            messageId: uuidStringToBinaryBuffer(params.messageId),
+            imei: params.imei,
+            sendTime: params.sendTime,
+            lat: params.lat,
+            lon: params.lon,
+            address: params.address,
+            clientId: params.clientId,
+            isBuffer: params.isBuffer,
+            isNotification: params.isNotification,
+            gpsUtcTime: params.gpsUtcTime,
+            relevantAddress: params.relevantAddress,
+            gpsMessageId: uuidStringToBinaryBuffer(params.gpsMessageId),
+            cellTowerRelevantAddress: params.cellTowerRelevantAddress,
+            createdAt: params.createdAt ?? now,
+        };
+        return await alertRepository.save(newAlert);
+    }
+    catch (error) {
+        logger.error(error, 'AlertRepository::createAlert error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};
+export const createAlerts = async (novaDataSource, params, logger) => {
+    try {
+        await novaDataSource.connect();
+        const alertRepository = novaDataSource.getRepository(Alert);
+        const alerts = [];
+        params.forEach(param => {
+            if (!param?.clientId ||
+                param.clientId === 0 ||
+                !param?.alertTypeId ||
+                param.alertTypeId === 0 ||
+                !param?.messageId ||
+                !param?.imei ||
+                !param?.sendTime) {
+                return null;
+            }
+            const now = new Date();
+            const newAlert = {
+                id: param.id,
+                alertTypeId: param.alertTypeId,
+                value: param.value,
+                userId: uuidStringToBinaryBuffer(param.userId),
+                messageId: uuidStringToBinaryBuffer(param.messageId),
+                imei: param.imei,
+                sendTime: param.sendTime,
+                lat: param.lat,
+                lon: param.lon,
+                address: param.address,
+                clientId: param.clientId,
+                isBuffer: param.isBuffer,
+                isNotification: param.isNotification,
+                gpsUtcTime: param.gpsUtcTime,
+                relevantAddress: param.relevantAddress,
+                gpsMessageId: uuidStringToBinaryBuffer(param.gpsMessageId),
+                cellTowerRelevantAddress: param.cellTowerRelevantAddress,
+                createdAt: param.createdAt ?? now,
+            };
+            alerts.push(newAlert);
+        });
+        return await alertRepository.save(alerts);
+    }
+    catch (error) {
+        logger.error(error, 'AlertRepository::createAlert error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/alerts/createUserAlertComplain.js

@@ -0,0 +1,26 @@
+import { UserAlertComplain } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserAlertComplain = async (novaDataSource, params) => {
+    if (!params?.clientId ||
+        params.clientId === 0 ||
+        !params?.alertTypeId ||
+        params.alertTypeId === 0 ||
+        !params?.userId ||
+        !params?.email ||
+        !params?.reason) {
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const alertComplaintRepository = dataSource.getRepository(UserAlertComplain);
+        const now = new Date();
+        const newUserAlertComplaint = {
+            alertTypeId: params.alertTypeId,
+            userId: uuidStringToBinaryBuffer(params.userId),
+            clientId: params.clientId,
+            createdAt: params.createdAt ?? now,
+            email: params.email,
+            reason: params.reason,
+        };
+        return await alertComplaintRepository.save(newUserAlertComplaint);
+    }, 'AlertRepository::createUserAlertComplain');
+};

package/dist/repositories/alerts/getAlertsReportByClient.js

@@ -0,0 +1,65 @@
+import { Alert } from '../../entities';
+/**
+ * @deprecated The method should not be used
+ */
+export const getAlertsReportByClient = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        return [];
+    }
+    try {
+        await novaDataSource.connect();
+        const alertRepository = novaDataSource.getRepository(Alert);
+        const alertQuery = alertRepository
+            .createQueryBuilder('a')
+            .where('a.clientId = :clientId', { clientId: params.filters.clientId });
+        if (params.filters.imei) {
+            alertQuery.andWhere('a.imei = :imei', { imei: params.filters.imei });
+        }
+        if (params.filters.alertTypeId) {
+            alertQuery.andWhere('a.alertTypeId = :alertTypeId', {
+                alertTypeId: params.filters.alertTypeId,
+            });
+        }
+        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,
+            });
+        }
+        //get first the total count of the query without the paging
+        const totalCount = await alertQuery.getCount();
+        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',
+            'a.value as value',
+            'a.createdAt as createdAt',
+            'a.userId as userId',
+            'a.messageId as messageId',
+            'a.imei as imei',
+            'a.sendTime as sendTime',
+            'a.lat as lat',
+            'a.lon as lon',
+            'a.address as address',
+            `${totalCount} as totalCount`,
+        ])
+            .limit(params.pagingOptions.pageSize)
+            .offset(params.pagingOptions.pageSize * (params.pagingOptions.pageIndex - 1))
+            .getRawMany();
+        return alerts;
+    }
+    catch (error) {
+        logger.error(error, 'AlertRepository::getAlertsReportByClient error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};