@spytecgps/nova-orm 1.2.35-rc1 → 1.2.35

package/dist/repositories/alerts/getAlertsReportByUser.js

@@ -1,132 +1,132 @@
-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 [];
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    try {
-        await novaDataSource.connect();
-        const alertRepository = novaDataSource.getRepository(Alert);
-        const alertQuery = alertRepository
-            .createQueryBuilder('a')
-            .setQueryRunner(dbQueryRunner)
-            .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 dbQueryRunner.release();
-        await novaDataSource.disconnect();
-    }
-};
+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 [];
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    try {
+        await novaDataSource.connect();
+        const alertRepository = novaDataSource.getRepository(Alert);
+        const alertQuery = alertRepository
+            .createQueryBuilder('a')
+            .setQueryRunner(dbQueryRunner)
+            .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 dbQueryRunner.release();
+        await novaDataSource.disconnect();
+    }
+};
 //# sourceMappingURL=getAlertsReportByUser.js.map

package/dist/repositories/alerts/index.d.ts

@@ -1,78 +1,78 @@
-import { Alert, UserAlertComplain } from '../../entities';
-import { AlertReport, CreateAlertParams, CreateUserAlertComplaintParams, GetAlertReportByUserParams } from '../../types/alert';
-import { BaseRepository } from '../baseRepository';
-export declare 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
-     */
-    createAlert(params: CreateAlertParams): Promise<Alert>;
-    /** 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
-     */
-    createAlerts(params: CreateAlertParams[]): Promise<Alert[]>;
-    /** 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[]>
-     */
-    getAlertsReportByUser(params: GetAlertReportByUserParams): Promise<AlertReport[]>;
-    /**
-     * 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
-     */
-    createUserAlertComplain(params: CreateUserAlertComplaintParams): Promise<UserAlertComplain>;
-}
+import { Alert, UserAlertComplain } from '../../entities';
+import { AlertReport, CreateAlertParams, CreateUserAlertComplaintParams, GetAlertReportByUserParams } from '../../types/alert';
+import { BaseRepository } from '../baseRepository';
+export declare 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
+     */
+    createAlert(params: CreateAlertParams): Promise<Alert>;
+    /** 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
+     */
+    createAlerts(params: CreateAlertParams[]): Promise<Alert[]>;
+    /** 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[]>
+     */
+    getAlertsReportByUser(params: GetAlertReportByUserParams): Promise<AlertReport[]>;
+    /**
+     * 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
+     */
+    createUserAlertComplain(params: CreateUserAlertComplaintParams): Promise<UserAlertComplain>;
+}

package/dist/repositories/alerts/index.js

@@ -1,105 +1,105 @@
-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, this.replicaNovaDataSourceConfig);
-        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, this.replicaNovaDataSourceConfig);
-        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, this.replicaNovaDataSourceConfig);
-        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, this.replicaNovaDataSourceConfig);
-        const result = await createUserAlertComplain(novaDataSource, params);
-        this.logger.trace(result, 'AlertRepository::createUserAlertComplain result');
-        return result;
-    }
-}
+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, this.replicaNovaDataSourceConfig);
+        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, this.replicaNovaDataSourceConfig);
+        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, this.replicaNovaDataSourceConfig);
+        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, this.replicaNovaDataSourceConfig);
+        const result = await createUserAlertComplain(novaDataSource, params);
+        this.logger.trace(result, 'AlertRepository::createUserAlertComplain result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map