@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/deactivations/createDeactivation.js

@@ -0,0 +1,16 @@
+import { Deactivation } from '../../entities';
+export const createDeactivation = async (novaDataSource, params, logger) => {
+    if (!params?.imei || !params?.clientId || !params?.createdBy) {
+        logger.warn({ params }, 'DeactivationsRepository::createDeactivation - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deactivationsRepository = dataSource.getRepository(Deactivation);
+        const now = new Date();
+        const newDeactivation = {
+            ...params,
+            createdAt: now,
+        };
+        return await deactivationsRepository.save(newDeactivation);
+    }, 'DeactivationsRepository::createDeactivation');
+};

package/dist/repositories/deactivations/getDeactivationReasons.js

@@ -0,0 +1,24 @@
+import { DeactivationReason } from '../../entities';
+export const getDeactivationReasons = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.code && params?.filters?.customerVisible == null) {
+        logger.warn({ params }, 'DeactivationsRepository::getDeactivationReasons - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deactivationReasonsRepository = dataSource.getRepository(DeactivationReason);
+        let queryBuilder = deactivationReasonsRepository.createQueryBuilder('deactivationReason');
+        if (params.filters.code) {
+            queryBuilder = queryBuilder.andWhere('deactivationReason.code = :code', {
+                code: params.filters.code,
+            });
+        }
+        if (params.filters.customerVisible != null) {
+            queryBuilder = queryBuilder.andWhere('deactivationReason.customerVisible = :customerVisible', {
+                customerVisible: params.filters.customerVisible,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('deactivationReason.id');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DeactivationsRepository::getDeactivationReasons');
+};

package/dist/repositories/deactivations/getLatestDeactivationByImei.js

@@ -0,0 +1,19 @@
+import { Deactivation } from '../../entities';
+export const getLatestDeactivationByImei = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'DeactivationsRepository::getLatestDeactivationByImei - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deactivationsRepository = dataSource.getRepository(Deactivation);
+        const queryBuilder = deactivationsRepository
+            .createQueryBuilder('deactivation')
+            .where('deactivation.imei = :imei', {
+            imei: params.filters.imei,
+        })
+            .orderBy('deactivation.createdAt', 'DESC')
+            .limit(1);
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'DeactivationsRepository::getLatestDeactivationByImei');
+};

package/dist/repositories/deactivations/index.js

@@ -0,0 +1,58 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createDeactivation } from './createDeactivation';
+import { getDeactivationReasons } from './getDeactivationReasons';
+import { getLatestDeactivationByImei } from './getLatestDeactivationByImei';
+export class DeactivationsRepository extends BaseRepository {
+    /**
+     * Get deactivation reasons
+     * @param {GetDeactivationReasonsParams} params containing information to get deactivation reasons
+     * One of the following filters is required:
+     * - filters.code: The code
+     * - filters.customerVisible: The customer visible
+     * @returns The deactivation reasons list
+     */
+    async getDeactivationReasons(params) {
+        this.logger.trace(params, 'DeactivationsRepository::getDeactivationReasons started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeactivationReasons(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeactivationsRepository::getDeactivationReasons result');
+        return result;
+    }
+    /**
+     * Get latest deactivation by imei
+     * @param {GetLatestDeactivationByImeiParams} params containing information to get latest deactivation by imei
+     * - filters.imei: The imei
+     * @returns The deactivation
+     */
+    async getLatestDeactivationByImei(params) {
+        this.logger.trace(params, 'DeactivationsRepository::getLatestDeactivationByImei started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getLatestDeactivationByImei(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeactivationsRepository::getLatestDeactivationByImei result');
+        return result;
+    }
+    /**
+     * Create deactivation
+     * @param {CreateDeactivationParams} params containing information to create deactivation
+     * - params.id: The id, optional
+     * - params.imei: The imei, required
+     * - params.clientId: The client id, required
+     * - params.createdBy: The created by, required
+     * - params.billingSubscriptionId: The billing subscription id, optional
+     * - params.planId: The plan id, optional
+     * - params.billingPlatform: The billing platform, optional
+     * - params.deactivationReason: The deactivation reason, optional
+     * - params.deactivationReasonId: The deactivation reason id, optional
+     * - params.scheduledDate: The scheduled date, optional
+     * - params.displayOrder: The display order, optional
+     * @returns The deactivation
+     */
+    async createDeactivation(params) {
+        this.logger.trace(params, 'DeactivationsRepository::createDeactivation started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDeactivation(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeactivationsRepository::createDeactivation result');
+        return result;
+    }
+}

package/dist/repositories/deviceBehaviors/createDeviceBehaviorTask.js

@@ -0,0 +1,48 @@
+import { UserDeviceBehaviorTask } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createDeviceBehaviorTask = async (novaDataSource, params, logger) => {
+    if (!params?.taskId ||
+        !params?.deviceBehaviorId ||
+        !params?.clientId ||
+        !params?.userId ||
+        !params?.imei ||
+        !params?.behaviorName ||
+        !params?.status) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::createDeviceBehaviorTask - missing required parameters');
+        return null;
+    }
+    const taskIdBinaryBuffer = uuidStringToBinaryBuffer(params?.taskId);
+    if (!taskIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::createDeviceBehaviorTask - taskId should be a valid UUID');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::createDeviceBehaviorTask - user id should be a valid UUID');
+        return null;
+    }
+    const commandTaskIdBinaryBuffer = uuidStringToBinaryBuffer(params?.commandTaskId);
+    if (params.commandTaskId && !commandTaskIdBinaryBuffer) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::createDeviceBehaviorTask - command task id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userDeviceBehaviorTaskRepository = dataSource.getRepository(UserDeviceBehaviorTask);
+        const now = new Date();
+        const newUserDeviceBehaviorTask = {
+            id: taskIdBinaryBuffer,
+            deviceBehaviorId: params.deviceBehaviorId,
+            clientId: params.clientId,
+            userId: userIdBinaryBuffer,
+            imei: params.imei,
+            behaviorName: params.behaviorName,
+            behaviorParams: params.behaviorParams,
+            status: params.status,
+            extraParams: params.extraParams,
+            commandTaskId: commandTaskIdBinaryBuffer,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await userDeviceBehaviorTaskRepository.save(newUserDeviceBehaviorTask);
+    }, 'DeviceBehaviorsRepository::createDeviceBehaviorTask');
+};

package/dist/repositories/deviceBehaviors/getDeviceBehaviorTasks.js

@@ -0,0 +1,40 @@
+import { UserDeviceBehaviorTask } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getDeviceBehaviorTasks = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.taskId && !params?.filters?.imeiList?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::getDeviceBehaviorTasks - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceBehaviorsRepository = dataSource.getRepository(UserDeviceBehaviorTask);
+        let queryBuilder = deviceBehaviorsRepository.createQueryBuilder('userDeviceBehaviorTask');
+        if (params.filters.taskId) {
+            const taskIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.taskId);
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.id = :taskId', {
+                taskId: taskIdBinaryBuffer,
+            });
+        }
+        if (params.filters.imeiList?.length) {
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.imei IN (:...imeiList)', {
+                imeiList: params.filters.imeiList,
+            });
+        }
+        if (params.filters.status) {
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.status = :status', {
+                status: params.filters.status,
+            });
+        }
+        if (params.filters.deviceBehaviorIdList?.length) {
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.deviceBehaviorId IN (:...deviceBehaviorIdList)', {
+                deviceBehaviorIdList: params.filters.deviceBehaviorIdList,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('userDeviceBehaviorTask.modifiedAt', 'DESC');
+        if (params?.pagingOptions?.offset) {
+            queryBuilder = queryBuilder.offset(params?.pagingOptions?.offset);
+        }
+        queryBuilder = queryBuilder.limit(params?.pagingOptions?.limit ?? 100);
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DeviceBehaviorsRepository::getDeviceBehaviorTasks');
+};

package/dist/repositories/deviceBehaviors/getDeviceBehaviors.js

@@ -0,0 +1,41 @@
+import { DeviceBehavior } from '../../entities';
+export const getDeviceBehaviors = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.status ||
+        !params?.filters?.imeiList?.length ||
+        !params?.filters?.deviceTypeIdList?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::getDeviceBehaviors - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceBehaviorsRepository = dataSource.getRepository(DeviceBehavior);
+        let queryBuilder = deviceBehaviorsRepository.createQueryBuilder('deviceBehavior');
+        queryBuilder = queryBuilder.andWhere('deviceBehavior.status = :status', {
+            status: params.filters.status,
+        });
+        queryBuilder = queryBuilder.andWhere('deviceBehavior.imei IN (:...imeiList)', {
+            imeiList: params.filters.imeiList,
+        });
+        queryBuilder = queryBuilder.andWhere('deviceBehavior.deviceTypeId IN (:...deviceTypeIdList)', {
+            deviceTypeIdList: params.filters.deviceTypeIdList,
+        });
+        queryBuilder = queryBuilder.andWhere(`(deviceBehavior.stage IS NULL OR deviceBehavior.stage = '' OR deviceBehavior.stage = :stage)`, {
+            stage: params.filters.stage,
+        });
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.andWhere('(deviceBehavior.clientId IS NULL OR deviceBehavior.clientId <= 0 OR deviceBehavior.clientId = :clientId)', {
+                clientId: params.filters.clientId,
+            });
+        }
+        else {
+            queryBuilder = queryBuilder.andWhere('(deviceBehavior.clientId IS NULL OR deviceBehavior.clientId <= 0)');
+        }
+        if (params.filters.type) {
+            queryBuilder = queryBuilder.andWhere('deviceBehavior.type = :type', {
+                type: params.filters.type,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('deviceBehavior.ordinalPosition');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DeviceBehaviorsRepository::getDeviceBehaviors');
+};

package/dist/repositories/deviceBehaviors/getDeviceBehaviorsByIds.js

@@ -0,0 +1,16 @@
+import { DeviceBehavior } from '../../entities';
+export const getDeviceBehaviorsByIds = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.deviceBehaviorIdList?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::getDeviceBehaviorsByIds - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceBehaviorsRepository = dataSource.getRepository(DeviceBehavior);
+        let queryBuilder = deviceBehaviorsRepository.createQueryBuilder('deviceBehavior');
+        queryBuilder = queryBuilder.andWhere('deviceBehavior.id IN (:...deviceBehaviorIdList)', {
+            deviceBehaviorIdList: params.filters.deviceBehaviorIdList,
+        });
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DeviceBehaviorsRepository::getDeviceBehaviorsByIds');
+};

package/dist/repositories/deviceBehaviors/getDevicesLastBehaviorTask.js

@@ -0,0 +1,42 @@
+import { UserDeviceBehaviorTask } from '../../entities';
+export const getDevicesLastBehaviorTask = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imeiList?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::getDevicesLastBehaviorTask - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceBehaviorsRepository = dataSource.getRepository(UserDeviceBehaviorTask);
+        let queryBuilder = deviceBehaviorsRepository.createQueryBuilder('userDeviceBehaviorTask');
+        if (params.filters.imeiList?.length) {
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.imei IN (:...imeiList)', {
+                imeiList: params.filters.imeiList,
+            });
+        }
+        if (params.filters.status) {
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.status = :status', {
+                status: params.filters.status,
+            });
+        }
+        if (params.filters.deviceBehaviorIdList?.length) {
+            queryBuilder = queryBuilder.andWhere('userDeviceBehaviorTask.deviceBehaviorId IN (:...deviceBehaviorIdList)', {
+                deviceBehaviorIdList: params.filters.deviceBehaviorIdList,
+            });
+        }
+        queryBuilder.andWhere(subQuery => {
+            const subQueryAlias = subQuery
+                .subQuery()
+                .select('MAX(modifiedAt)')
+                .from(UserDeviceBehaviorTask, 'subTask')
+                .where('subTask.imei = userDeviceBehaviorTask.imei')
+                .getQuery();
+            return `userDeviceBehaviorTask.modifiedAt = (${subQueryAlias})`;
+        });
+        queryBuilder = queryBuilder.orderBy('userDeviceBehaviorTask.modifiedAt', 'DESC');
+        if (params?.pagingOptions?.offset) {
+            queryBuilder = queryBuilder.offset(params?.pagingOptions?.offset);
+        }
+        queryBuilder = queryBuilder.limit(params?.pagingOptions?.limit ?? 100);
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DeviceBehaviorsRepository::getDevicesLastBehaviorTask');
+};

package/dist/repositories/deviceBehaviors/getLatestDeviceBehaviorTasks.js

@@ -0,0 +1,40 @@
+import { UserDeviceBehaviorTask } from '../../entities';
+import { binaryBufferToUuidString } from '../../utils/uuidHelpers';
+export const getLatestDeviceBehaviorTasks = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId && !params?.filters?.type && !params?.filters?.status) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::getLatestDeviceBehaviorTasks - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceBehaviorsRepository = dataSource.getRepository(UserDeviceBehaviorTask);
+        const query = `SELECT sub.imei AS imei, 
+                          sub.name AS name, 
+                          sub.description AS description, 
+                          sub.modifiedAt AS modifiedAt, 
+                          sub.taskId AS taskId
+                    FROM (
+                      SELECT userDeviceBehaviorTask.imei AS imei,
+                            deviceBehavior.name as name,
+                            deviceBehavior.description as description,
+                            userDeviceBehaviorTask.modifiedAt AS modifiedAt,
+                            userDeviceBehaviorTask.id AS taskId,
+                            RANK() OVER (PARTITION BY userDeviceBehaviorTask.imei ORDER BY userDeviceBehaviorTask.modifiedAt DESC) AS rk
+                      FROM userDeviceBehaviorTask
+                      INNER JOIN deviceBehavior ON userDeviceBehaviorTask.deviceBehaviorId = deviceBehavior.id AND deviceBehavior.type = ?
+                      WHERE userDeviceBehaviorTask.clientId = ? AND userDeviceBehaviorTask.status = ?
+                    ) AS sub
+                    WHERE sub.rk = 1`;
+        const result = await deviceBehaviorsRepository.query(query, [
+            params.filters.type,
+            params.filters.clientId,
+            params.filters.status,
+        ]);
+        return result.map(item => ({
+            imei: item.imei,
+            name: item.name,
+            description: item.description,
+            modifiedAt: item.modifiedAt,
+            taskId: binaryBufferToUuidString(item.taskId),
+        }));
+    }, 'DeviceBehaviorsRepository::getLatestDeviceBehaviorTasks');
+};

package/dist/repositories/deviceBehaviors/index.js

@@ -0,0 +1,147 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createDeviceBehaviorTask } from './createDeviceBehaviorTask';
+import { getDeviceBehaviors } from './getDeviceBehaviors';
+import { getDeviceBehaviorsByIds } from './getDeviceBehaviorsByIds';
+import { getDeviceBehaviorTasks } from './getDeviceBehaviorTasks';
+import { getDevicesLastBehaviorTask } from './getDevicesLastBehaviorTask';
+import { getLatestDeviceBehaviorTasks } from './getLatestDeviceBehaviorTasks';
+import { updateDeviceBehaviorTask } from './updateDeviceBehaviorTask';
+import { upsertDeviceBehavior } from './upsertDeviceBehavior';
+export class DeviceBehaviorsRepository extends BaseRepository {
+    /**
+     * Get user rating requests
+     * @param {GetDeviceBehaviorsParams} params containing information to get device behaviors
+     * - filters.status: The status
+     * - filters.imeiList: The imei list
+     * - filters.deviceTypeIdList: The device type id list
+     * - filters.stage: The stage
+     * - filters.clientId: The client id, optional
+     * - filters.type: The type, optional
+     * @returns The device behaviors list
+     */
+    async getDeviceBehaviors(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::getDeviceBehaviors started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceBehaviors(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::getDeviceBehaviors result');
+        return result;
+    }
+    /**
+     * Get device behaviors by ids
+     * @params  {GetDeviceBehaviorsByIdsParams} params containing information to get device behaviors by ids
+     * - filters.deviceBehaviorIdList: The device behavior id list, required
+     * @returns The device behaviors list
+     */
+    async getDeviceBehaviorsByIds(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::getDeviceBehaviorsByIds started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceBehaviorsByIds(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::getDeviceBehaviorsByIds result');
+        return result;
+    }
+    /**
+     * Get device behavior tasks
+     * @param {GetDeviceBehaviorTasksParams} params containing information to get device behavior tasks
+     * Filters (One of taskId or imeiList is required):
+     * - filters.taskId: The task id
+     * - filters.imeiList: The imei list
+     * - filters.status: The status, optional
+     * - filters.deviceBehaviorIdList: The device behavior id list, optional
+     * Paging options:
+     * - pagingOptions.offset: The offset, optional. Default is 0
+     * - pagingOptions.limit: The limit, optional. Default is 100
+     * @returns The device behavior tasks list
+     */
+    async getDeviceBehaviorTasks(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::getDeviceBehaviorTasks started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceBehaviorTasks(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::getDeviceBehaviorTasks result');
+        return result;
+    }
+    /**
+     * Get the devices last behavior task
+     * @param {GettDevicesLastBehaviorTaskParams} params containing information to get device behavior tasks
+     * Filters (One of taskId or imeiList is required):
+     * - filters.imeiList: The imei list
+     * - filters.status: The status, optional
+     * - filters.deviceBehaviorIdList: The device behavior id list, optional
+     * Paging options:
+     * - pagingOptions.offset: The offset, optional. Default is 0
+     * - pagingOptions.limit: The limit, optional. Default is 100
+     * @returns The device behavior tasks list
+     */
+    async getDevicesLastBehaviorTask(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::getDevicesLastBehaviorTask started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDevicesLastBehaviorTask(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::getDevicesLastBehaviorTask result');
+        return result;
+    }
+    /**
+     * Create device behavior task
+     * @param {CreateDeviceBehaviorTaskParams} params containing information to create a device behavior task
+     * - params.taskId: The task id
+     * - params.deviceBehaviorId: The device behavior id
+     * - params.clientId: The client id
+     * - params.userId: The user id
+     * - params.imei: The imei
+     * - params.behaviorName: The behavior name
+     * - params.behaviorParams: The behavior params, optional
+     * - params.status: The status
+     * - params.extraParams: The extra params, optional
+     * - params.commandTaskId: The common command task if the behavior is part of a bulk action, optional
+     * @returns The device behavior task
+     */
+    async createDeviceBehaviorTask(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::createDeviceBehaviorTasks started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDeviceBehaviorTask(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::createDeviceBehaviorTasks result');
+        return result;
+    }
+    /**
+     * Update device behavior task
+     * @param {UpdateDeviceBehaviorTaskParams} params containing information to update a device behavior task
+     * Filters:
+     * - params.filters.taskId: The task id
+     * Values:
+     * - params.values.status: The status
+     * @returns Whether the device behavior task was updated
+     */
+    async updateDeviceBehaviorTask(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::updateDeviceBehaviorTask started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateDeviceBehaviorTask(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DeviceBehaviorsRepository::updateDeviceBehaviorTask result');
+        return result;
+    }
+    /**
+     * Get latest device behavior tasks
+     * @param {GetLatestDeviceBehaviorTasksParams} params containing information to get latest device behavior tasks
+     * - params.filters.clientId: The client id
+     * - params.filters.type: The device behavior type
+     * - params.filters.status: The task status
+     * @returns The latest device behavior tasks list
+     */
+    async getLatestDeviceBehaviorTasks(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::getLatestDeviceBehaviorTasks started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getLatestDeviceBehaviorTasks(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::getLatestDeviceBehaviorTasks result');
+        return result;
+    }
+    /**
+     * Upsert device behavior
+     * @param {UpsertDeviceBehaviorParams} params containing information to upsert a device behavior
+     * @returns The device behavior
+     */
+    async upsertDeviceBehavior(params) {
+        this.logger.trace(params, 'DeviceBehaviorsRepository::upsertDeviceBehavior started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await upsertDeviceBehavior(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DeviceBehaviorsRepository::upsertDeviceBehavior result');
+        return result;
+    }
+}

package/dist/repositories/deviceBehaviors/updateDeviceBehaviorTask.js

@@ -0,0 +1,27 @@
+import { UserDeviceBehaviorTask } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateDeviceBehaviorTask = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.taskId || !params?.values?.status) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::updateDeviceBehaviorTask - missing required parameters');
+        return null;
+    }
+    const taskIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters.taskId);
+    if (!taskIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::updateDeviceBehaviorTask - taskId should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userDeviceBehaviorTaskRepository = dataSource.getRepository(UserDeviceBehaviorTask);
+        const now = new Date();
+        let queryBuilder = userDeviceBehaviorTaskRepository
+            .createQueryBuilder()
+            .update(UserDeviceBehaviorTask)
+            .set({
+            status: params.values.status,
+            modifiedAt: now,
+        });
+        queryBuilder = queryBuilder.where('id = :id', { id: taskIdBinaryBuffer });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'DeviceBehaviorsRepository::updateDeviceBehaviorTask');
+};

package/dist/repositories/deviceBehaviors/upsertDeviceBehavior.js

@@ -0,0 +1,20 @@
+import { DeviceBehavior } from '../../entities';
+export const upsertDeviceBehavior = async (novaDataSource, params, logger) => {
+    if (!params?.deviceTypeId ||
+        !params?.name ||
+        !params?.description ||
+        !params?.status ||
+        !params?.behaviorName) {
+        logger.warn({ params }, 'DeviceBehaviorsRepository::upsertDeviceBehavior - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceBehaviorRepository = dataSource.getRepository(DeviceBehavior);
+        const newDeviceBehavior = {
+            ...params,
+            ordinalPosition: params.ordinalPosition || 1,
+            blocking: params.blocking ?? true,
+        };
+        return await deviceBehaviorRepository.save(newDeviceBehavior);
+    }, 'DeviceBehaviorsRepository::upsertDeviceBehavior');
+};

package/dist/repositories/devicePairings/createDevicePairing.js

@@ -0,0 +1,21 @@
+import { DevicePairing } from '../../entities';
+export const createDevicePairing = async (novaDataSource, params, logger) => {
+    if (!params?.imeiMain ||
+        !params?.imeiSecondary ||
+        !params?.btmacMain ||
+        !params?.btmacSecondary) {
+        logger.warn({ params }, 'DevicePairingsRepository::createDevicePairing missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicePaitingsRepository = dataSource.getRepository(DevicePairing);
+        const now = new Date();
+        const newDevicePairing = {
+            ...params,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        const result = await devicePaitingsRepository.save(newDevicePairing);
+        return result;
+    }, 'DevicePairingsRepository::createDevicePairing');
+};

package/dist/repositories/devicePairings/deleteDevicePairing.js

@@ -0,0 +1,16 @@
+import { DevicePairing } from '../../entities';
+export const deleteDevicePairing = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'DevicePairingsRepository::deleteDevicePairing - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicePairingsRepository = dataSource.getRepository(DevicePairing);
+        const queryBuilder = devicePairingsRepository
+            .createQueryBuilder()
+            .delete()
+            .where('id = :id', { id: params.filters.id });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'DevicePairingsRepository::deleteDevicePairing');
+};

package/dist/repositories/devicePairings/getDevicePairings.js

@@ -0,0 +1,36 @@
+import { DevicePairing } from '../../entities';
+export const getDevicePairings = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imeiMain &&
+        !params?.filters?.imeiSecondary &&
+        !params?.filters?.btmacMain &&
+        !params?.filters?.btmacSecondary) {
+        logger.warn({ params }, 'DevicePairingsRepository::getDevicePairings missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicePairingsRepository = dataSource.getRepository(DevicePairing);
+        let queryBuilder = devicePairingsRepository.createQueryBuilder('devicePairing');
+        if (params.filters.imeiMain) {
+            queryBuilder = queryBuilder.where('devicePairing.imeiMain = :imeiMain', {
+                imeiMain: params.filters.imeiMain,
+            });
+        }
+        if (params.filters.imeiSecondary) {
+            queryBuilder = queryBuilder.andWhere('devicePairing.imeiSecondary = :imeiSecondary', {
+                imeiSecondary: params.filters.imeiSecondary,
+            });
+        }
+        if (params.filters.btmacMain) {
+            queryBuilder = queryBuilder.andWhere('devicePairing.btmacMain = :btmacMain', {
+                btmacMain: params.filters.btmacMain,
+            });
+        }
+        if (params.filters.btmacSecondary) {
+            queryBuilder = queryBuilder.andWhere('devicePairing.btmacSecondary = :btmacSecondary', {
+                btmacSecondary: params.filters.btmacSecondary,
+            });
+        }
+        const devicePairings = await queryBuilder.getMany();
+        return devicePairings;
+    }, 'DevicePairingsRepository::getDevicePairings');
+};

package/dist/repositories/devicePairings/getDevicePairingsByImei.js

@@ -0,0 +1,20 @@
+import { DevicePairing } from '../../entities';
+export const getDevicePairingsByImei = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'DevicePairingsRepository::getDevicePairingsByImei missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicePairingsRepository = dataSource.getRepository(DevicePairing);
+        const queryBuilder = devicePairingsRepository
+            .createQueryBuilder('devicePairing')
+            .where('devicePairing.imeiMain = :imeiMain', {
+            imeiMain: params.filters.imei,
+        })
+            .orWhere('devicePairing.imeiSecondary = :imeiSecondary', {
+            imeiSecondary: params.filters.imei,
+        });
+        const devicePairings = await queryBuilder.getMany();
+        return devicePairings;
+    }, 'DevicePairingsRepository::getDevicePairingsByImei');
+};