@spytecgps/nova-orm 0.0.224 → 0.0.225

package/dist/repositories/devicePairings/index.js

@@ -0,0 +1,90 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createDevicePairing } from './createDevicePairing';
+import { deleteDevicePairing } from './deleteDevicePairing';
+import { getDevicePairings } from './getDevicePairings';
+import { getDevicePairingsByImei } from './getDevicePairingsByImei';
+import { updateDevicePairing } from './updateDevicePairing';
+export class DevicePairingsRepository extends BaseRepository {
+    /**
+     * Get device pairings
+     * @param params params containing information to get device pairings with filters
+     * At least one of the following filters is required:
+     * filters.imeiMain: the main device IMEI
+     * filters.imeiSecondary: the secondary device IMEI
+     * filters.btmacMain: the main device bluetooth MAC
+     * filters.btmacSecondary: the secondary device bluetooth MAC
+     * @returns Promise<DevicePairing[]> the device pairings
+     */
+    async getDevicePairings(params) {
+        this.logger.trace(params, 'DevicePairingsRepository::getDevicePairings started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDevicePairings(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicePairingsRepository::getDevicePairings result');
+        return result;
+    }
+    /**
+     * Get device pairings by IMEI
+     * @param params params containing information to get device pairings by IMEI with filters
+     * filters.imei: the IMEI to get device pairings
+     * @returns Promise<DevicePairing[]> the device pairings
+     */
+    async getDevicePairingsByImei(params) {
+        this.logger.trace(params, 'DevicePairingsRepository::getDevicePairingsByImei started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDevicePairingsByImei(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicePairingsRepository::getDevicePairingsByImei result');
+        return result;
+    }
+    /**
+     * Create device pairing
+     * @param params params containing information to create device pairing
+     * params.imeiMain: the main device IMEI, required
+     * params.btmacMain: the main device bluetooth MAC, required
+     * params.imeiSecondary: the secondary device IMEI, required
+     * params.btmacSecondary: the secondary device bluetooth MAC, required
+     * params.pairingMode: the pairing mode, optional
+     * params.connectionType: the connection type, optional
+     * @returns Promise<DevicePairing> the created device pairing
+     */
+    async createDevicePairing(params) {
+        this.logger.trace(params, 'DevicePairingsRepository::createDevicePairing started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDevicePairing(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicePairingsRepository::createDevicePairing result');
+        return result;
+    }
+    /**
+     * Update device pairing
+     * @param params params containing information to update device pairing
+     * filters.id: the device pairing id
+     * At least one of the following values is required:
+     * values.imeiMain: the main device IMEI
+     * values.imeiSecondary: the secondary device IMEI
+     * values.btmacMain: the main device bluetooth MAC
+     * values.btmacSecondary: the secondary device bluetooth MAC
+     * values.pairingMode: the pairing mode
+     * values.connectionType: the connection type
+     * @returns Promise<boolean> true if the device pairing was updated, false otherwise
+     */
+    async updateDevicePairing(params) {
+        this.logger.trace(params, 'DevicePairingsRepository::updateDevicePairing started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateDevicePairing(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicePairingsRepository::updateDevicePairing result');
+        return result;
+    }
+    /**
+     * Delete device pairing
+     * @param params params containing information to delete device pairing
+     * filters.id: the device pairing id
+     * @returns Promise<boolean> true if the device pairing was deleted, false otherwise
+     */
+    async deleteDevicePairing(params) {
+        this.logger.trace(params, 'DevicePairingsRepository::deleteDevicePairing started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteDevicePairing(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicePairingsRepository::deleteDevicePairing result');
+        return result;
+    }
+}

package/dist/repositories/devicePairings/updateDevicePairing.js

@@ -0,0 +1,32 @@
+import { DevicePairing } from '../../entities';
+export const updateDevicePairing = async (novaDataSource, params, logger) => {
+    // id is required
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'DevicePairingsRepository::updateDevicePairing missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.imeiMain &&
+        !params?.values?.imeiSecondary &&
+        !params?.values?.btmacMain &&
+        !params?.values?.btmacSecondary &&
+        !params?.values?.connectionType &&
+        !params?.values?.pairingMode) {
+        logger.warn({ params }, 'DevicePairingsRepository::updateDevicePairing missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicePairingsRepository = dataSource.getRepository(DevicePairing);
+        const now = new Date();
+        const queryBuilder = devicePairingsRepository
+            .createQueryBuilder()
+            .update(DevicePairing)
+            .set({
+            ...params.values,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.id });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'DevicePairingsRepository::updateDevicePairing');
+};

package/dist/repositories/devices/createClientDeviceSetting.js

@@ -0,0 +1,25 @@
+import { ClientDeviceSetting } from '../../entities';
+export const createClientDeviceSetting = async (novaDataSource, params, logger) => {
+    if (!params?.imei || !params?.clientId) {
+        logger.warn({ params }, 'DevicesRepository::createClientDeviceSetting missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientDeviceSettingRepository = dataSource.getRepository(ClientDeviceSetting);
+        const newClientDeviceSetting = {
+            id: params.id,
+            imei: params.imei,
+            clientId: params.clientId,
+            generateTrips: params.generateTrips ?? true,
+            movingPingFrequency: params.movingPingFrequency,
+            stoppedPingFrequency: params.stoppedPingFrequency,
+            fixedStatus: params.fixedStatus,
+            stopThresholdMinutes: params.stopThresholdMinutes,
+            offlineThresholdMinutes: params.offlineThresholdMinutes,
+            movementThresholdSpeed: params.movementThresholdSpeed,
+            externalBatteryInformation: params.externalBatteryInformation,
+        };
+        const result = await clientDeviceSettingRepository.save(newClientDeviceSetting);
+        return result;
+    }, 'DevicesRepository::createClientDeviceSetting');
+};

package/dist/repositories/devices/createDevice.js

@@ -0,0 +1,30 @@
+import { Device } from '../../entities';
+import { generateDeviceIdentifierKey } from './generateDeviceIdentifierKey';
+export const createDevice = async (novaDataSource, params, logger) => {
+    if (!params?.imei || !params?.clientId || params?.clientId === 0 || !params?.deviceTypeId) {
+        logger.warn({ params }, 'DevicesRepository::createDevice missing required parameters');
+        return null;
+    }
+    const identifier = params.identifier || params.imei;
+    const identifierKey = await generateDeviceIdentifierKey(novaDataSource, {
+        deviceTypeId: params.deviceTypeId,
+        deviceIdentifier: identifier,
+    }, logger);
+    if (!identifierKey) {
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        const now = new Date();
+        const newDevice = {
+            ...params,
+            identifier,
+            identifierKey,
+            modifiedBy: params.createdBy,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        const result = await devicesRepository.save(newDevice);
+        return result;
+    }, 'DevicesRepository::createDevice');
+};

package/dist/repositories/devices/createDeviceReplacement.js

@@ -0,0 +1,34 @@
+import { DeviceReplacement } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createDeviceReplacement = async (novaDataSource, params, logger) => {
+    if (!params?.imeiOld ||
+        !params?.imeiNew ||
+        !params?.iccidNew ||
+        !params?.iccidOld ||
+        !params?.userId ||
+        !params?.clientId ||
+        params?.clientId === 0) {
+        logger.warn({ params }, 'DevicesRepository::createDeviceReplacement missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'DevicesRepository::createDeviceReplacement - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceReplacementsRepository = dataSource.getRepository(DeviceReplacement);
+        const newDeviceReplacement = {
+            id: params.id,
+            imeiOld: params.imeiOld,
+            imeiNew: params.imeiNew,
+            iccidOld: params.iccidOld,
+            iccidNew: params.iccidNew,
+            userId: binaryBuffer,
+            clientId: params.clientId,
+            createAt: new Date(),
+        };
+        const result = await deviceReplacementsRepository.save(newDeviceReplacement);
+        return result;
+    }, 'DevicesRepository::createDeviceReplacement');
+};

package/dist/repositories/devices/createDeviceType.js

@@ -0,0 +1,15 @@
+import { DeviceType } from '../../entities';
+export const createDeviceType = async (novaDataSource, params, logger) => {
+    if (!params?.brand || !params?.model || !params?.modelFamily || !params?.identifierType) {
+        logger.warn({ params }, 'DevicesRepository::createDeviceType missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceTypesRepository = dataSource.getRepository(DeviceType);
+        const newDeviceType = {
+            ...params,
+        };
+        const result = await deviceTypesRepository.save(newDeviceType);
+        return result;
+    }, 'DevicesRepository::createDeviceType');
+};

package/dist/repositories/devices/deleteDevice.js

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

package/dist/repositories/devices/generateDeviceIdentifierKey.js

@@ -0,0 +1,18 @@
+import { DeviceType } from '../../entities';
+export const generateDeviceIdentifierKey = async (novaDataSource, params, logger) => {
+    if (!params?.deviceTypeId || !params?.deviceIdentifier) {
+        logger.warn({ params }, 'DevicesRepository::generateDeviceIdentifierKey missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceTypesRepository = dataSource.getRepository(DeviceType);
+        const deviceType = await deviceTypesRepository
+            .createQueryBuilder()
+            .where('id = :deviceTypeId', { deviceTypeId: params.deviceTypeId })
+            .getOne();
+        if (!deviceType) {
+            return null;
+        }
+        return `${deviceType.identifierType}#${params.deviceIdentifier}`;
+    }, 'DevicesRepository::generateDeviceIdentifierKey');
+};

package/dist/repositories/devices/getCanceledDevicesWithActiveSimCards.js

@@ -0,0 +1,40 @@
+import { Device, IccidStatus, ImeiIccidCarrier, ServiceProvider } from '../../entities';
+export const getCanceledDevicesWithActiveSimCards = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.lastAnalyzedDeviceId || !params?.pagingOptions?.limit) {
+        logger.warn({ params }, 'DevicesRepository::getCanceledDevicesWithActiveSimCards missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const serviceProviderRepository = dataSource.getRepository(ServiceProvider);
+        const serviceProviders = await serviceProviderRepository.find();
+        const deviceRepository = dataSource.getRepository(Device);
+        const queryBuilder = deviceRepository
+            .createQueryBuilder('device')
+            .innerJoin(IccidStatus, 'iccidStatus', 'device.iccid = iccidStatus.iccid')
+            .innerJoin(ImeiIccidCarrier, 'imeiIccidCarrier', 'device.iccid = imeiIccidCarrier.iccid')
+            .where('device.status = :deviceStatus', { deviceStatus: 'D' })
+            .andWhere('device.id > :lastAnalyzedDeviceId', {
+            lastAnalyzedDeviceId: params.filters.lastAnalyzedDeviceId,
+        })
+            .andWhere('iccidStatus.status = :iccidStatus', {
+            iccidStatus: 'active',
+        })
+            .select([
+            'device.imei as imei',
+            'device.iccid as iccid',
+            'device.clientId as clientId',
+            'imeiIccidCarrier.carrier as carrierId',
+            'device.id as deviceId',
+        ])
+            .orderBy('device.id', 'ASC')
+            .limit(params.pagingOptions.limit);
+        const result = await queryBuilder.getRawMany();
+        return result.map(row => ({
+            imei: row.imei,
+            iccid: row.iccid,
+            clientId: row.clientId,
+            carrier: serviceProviders?.find(sp => sp.id === row.carrierId)?.name || 'Unknown Carrier',
+            deviceId: row.deviceId,
+        }));
+    }, 'DevicesRepository::getCanceledDevicesWithActiveSimCards');
+};

package/dist/repositories/devices/getCarrierStatusUpdatedBefore.js

@@ -0,0 +1,40 @@
+import { IccidStatus, ImeiIccidCarrier } from '../../entities';
+export const getCarrierStatusUpdatedBefore = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.beforeDate || !params?.pagingOptions?.limit) {
+        logger.warn({ params }, 'DevicesRepository::getCarrierStatusUpdatedBefore missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const iccidStatusRepository = dataSource.getRepository(IccidStatus);
+        const queryBuilder = iccidStatusRepository
+            .createQueryBuilder('iccidStatus')
+            .innerJoin(ImeiIccidCarrier, 'imeiIccidCarrier', 'iccidStatus.iccid = imeiIccidCarrier.iccid')
+            .where('iccidStatus.modifiedAt < :beforeDate', { beforeDate: params.filters.beforeDate })
+            .andWhere('coalesce(iccidStatus.processing, false) <> :processing', {
+            processing: true,
+        })
+            .andWhere('iccidStatus.status <> :status', {
+            status: 'not found in carrier',
+        })
+            .select([
+            'imeiIccidCarrier.carrier as carrier',
+            'iccidStatus.iccid as iccid',
+            'iccidStatus.status as status',
+            'iccidStatus.processing as processing',
+            'iccidStatus.carrierFound as carrierFound',
+            'iccidStatus.modifiedAt as modifiedAt',
+        ])
+            .orderBy('iccidStatus.modifiedAt', 'ASC')
+            .addOrderBy('iccidStatus.iccid', 'ASC')
+            .limit(params.pagingOptions.limit);
+        const result = await queryBuilder.getRawMany();
+        return result.map(row => ({
+            carrier: row.carrier,
+            iccid: row.iccid,
+            status: row.status,
+            processing: row.processing != null ? row.processing === 1 : null,
+            carrierFound: row.carrierFound,
+            modifiedAt: row.modifiedAt,
+        }));
+    }, 'DevicesRepository::getCarrierStatusUpdatedBefore');
+};

package/dist/repositories/devices/getClientDeviceSetting.js

@@ -0,0 +1,20 @@
+import { ClientDeviceSetting } from '../../entities';
+export const getClientDeviceSetting = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei || !params?.filters?.clientId) {
+        logger.warn({ params }, 'DevicesRepository::getClientDeviceSetting missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientDeviceSettingRepository = dataSource.getRepository(ClientDeviceSetting);
+        const queryBuilder = clientDeviceSettingRepository
+            .createQueryBuilder('clientDeviceSetting')
+            .where('clientDeviceSetting.imei = :imei', {
+            imei: params.filters.imei,
+        })
+            .andWhere('clientDeviceSetting.clientId = :clientId', {
+            clientId: params.filters.clientId,
+        });
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'DevicesRepository::getClientDeviceSetting');
+};

package/dist/repositories/devices/getClientDeviceSettings.js

@@ -0,0 +1,17 @@
+import { ClientDeviceSetting } from '../../entities';
+export const getClientDeviceSettings = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'DevicesRepository::getClientDeviceSettings missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientDeviceSettingRepository = dataSource.getRepository(ClientDeviceSetting);
+        const queryBuilder = clientDeviceSettingRepository
+            .createQueryBuilder('clientDeviceSetting')
+            .where('clientDeviceSetting.clientId = :clientId', {
+            clientId: params.filters.clientId,
+        });
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DevicesRepository::getClientDeviceSettings');
+};

package/dist/repositories/devices/getDevice.js

@@ -0,0 +1,33 @@
+import { ClientDeviceSetting, Device, ImeiIccidCarrier, ServiceProvider } from '../../entities';
+export const getDevice = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei && !params?.filters?.id) {
+        logger.warn({ params }, 'DevicesRepository::getDevice missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        let queryBuilder = devicesRepository.createQueryBuilder('device');
+        if (params.filters.id) {
+            queryBuilder = queryBuilder.where('device.id = :id', {
+                id: params.filters.id,
+            });
+        }
+        if (params.filters.imei) {
+            queryBuilder = queryBuilder.andWhere('device.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        if (params.projectionOptions.withDeviceType) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('device.deviceType', 'deviceType');
+        }
+        if (params.projectionOptions.withIccidCarrier) {
+            queryBuilder = queryBuilder.leftJoinAndMapOne('device.iccidCarrier', ImeiIccidCarrier, 'iccidCarrier', 'device.imei = iccidCarrier.imei');
+            queryBuilder = queryBuilder.leftJoinAndMapOne('iccidCarrier.serviceProvider', ServiceProvider, 'serviceProvider', 'iccidCarrier.carrier = serviceProvider.id');
+        }
+        if (params.projectionOptions.withClientDeviceSettings) {
+            queryBuilder = queryBuilder.leftJoinAndMapOne('device.clientDeviceSetting', ClientDeviceSetting, 'clientDeviceSetting', 'device.imei = clientDeviceSetting.imei and device.clientId = clientDeviceSetting.clientId');
+        }
+        const device = await queryBuilder.getOne();
+        return device;
+    }, 'DevicesRepository::getDevice');
+};

package/dist/repositories/devices/getDeviceCustomConfig.js

@@ -0,0 +1,37 @@
+import { DeviceCustomConfiguration } from '../../entities';
+export const getDeviceCustomConfigs = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId && !params?.filters?.imei && !params?.filters?.po) {
+        logger.warn({ params }, 'DevicesRepository::getDeviceCustomConfig missing required params');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceCustomConfigRepository = dataSource.getRepository(DeviceCustomConfiguration);
+        let queryBuilder = deviceCustomConfigRepository.createQueryBuilder('deviceCustomConfiguration');
+        if (params?.filters?.imei) {
+            queryBuilder = queryBuilder.orWhere(`(LOWER(deviceCustomConfiguration.imei) = LOWER(:imei) AND deviceCustomConfiguration.clientId IS NULL AND (deviceCustomConfiguration.po IS NULL OR deviceCustomConfiguration.po = ''))`, {
+                imei: params.filters.imei,
+            });
+        }
+        if (params?.filters?.po) {
+            queryBuilder = queryBuilder.orWhere(`(LOWER(deviceCustomConfiguration.po) = LOWER(:po) AND deviceCustomConfiguration.clientId IS NULL AND (deviceCustomConfiguration.imei IS NULL OR deviceCustomConfiguration.imei = ''))`, {
+                po: params.filters.po,
+            });
+        }
+        if (params?.filters?.clientId) {
+            queryBuilder = queryBuilder.orWhere(`deviceCustomConfiguration.clientId = :clientId AND (deviceCustomConfiguration.po IS NULL OR deviceCustomConfiguration.po = '') AND  (deviceCustomConfiguration.imei IS NULL OR deviceCustomConfiguration.imei = '')`, {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (params?.filters?.deviceTypeId) {
+            queryBuilder = queryBuilder.andWhere('(deviceCustomConfiguration.deviceTypeId = :deviceTypeId OR deviceCustomConfiguration.deviceTypeId IS NULL)', {
+                deviceTypeId: params.filters.deviceTypeId,
+            });
+        }
+        else {
+            queryBuilder = queryBuilder.andWhere('deviceCustomConfiguration.deviceTypeId IS NULL');
+        }
+        queryBuilder = queryBuilder.orderBy('deviceCustomConfiguration.id');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DevicesRepository::getDeviceCustomConfig');
+};

package/dist/repositories/devices/getDeviceTypeByImei.js

@@ -0,0 +1,18 @@
+import { DeviceType, ImeiIccidCarrier } from '../../entities';
+export const getDeviceTypeByImei = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'DevicesRepository::getDeviceTypeByImei - missing imei parameter');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const imeiIccidCarrierRepository = dataSource.getRepository(DeviceType);
+        const queryBuilder = imeiIccidCarrierRepository
+            .createQueryBuilder('deviceType')
+            .innerJoin(ImeiIccidCarrier, 'imeiIccidCarrier', 'deviceType.id = imeiIccidCarrier.deviceTypeId')
+            .where(`imeiIccidCarrier.imei = :imei`, {
+            imei: params.filters.imei,
+        });
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'DevicesRepository::getDeviceTypeByImei');
+};

package/dist/repositories/devices/getDeviceTypes.js

@@ -0,0 +1,30 @@
+import { DeviceType, ImeiIccidCarrier } from '../../entities';
+export const getDeviceTypes = async (novaDataSource, params) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceTypesRepository = dataSource.getRepository(DeviceType);
+        let queryBuilder = deviceTypesRepository.createQueryBuilder('deviceType');
+        if (params?.filters?.deviceTypeIdList?.length) {
+            queryBuilder = queryBuilder.where('deviceType.id IN (:...deviceTypeIdList)', {
+                deviceTypeIdList: params.filters.deviceTypeIdList,
+            });
+        }
+        if (params?.filters?.brand) {
+            queryBuilder = queryBuilder.andWhere('LOWER(deviceType.brand) = LOWER(:brand)', {
+                brand: params.filters.brand,
+            });
+        }
+        if (params?.filters?.model) {
+            queryBuilder = queryBuilder.andWhere('LOWER(deviceType.model) = LOWER(:model)', {
+                model: params.filters.model,
+            });
+        }
+        if (params?.filters?.onlyWithRelatedIccidCarrier) {
+            queryBuilder = queryBuilder
+                .innerJoin(ImeiIccidCarrier, 'iccidCarrier', 'deviceType.id = iccidCarrier.deviceTypeId')
+                .groupBy('deviceType.id');
+        }
+        queryBuilder = queryBuilder.orderBy('deviceType.id');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DevicesRepository::getDeviceTypes');
+};

package/dist/repositories/devices/getDeviceTypesModelsOrderedByDeviceCount.js

@@ -0,0 +1,27 @@
+import { Device, DeviceType } from '../../entities';
+export const getDeviceTypesModelsOrderedByDeviceCount = async (novaDataSource, params) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceTypesRepository = dataSource.getRepository(DeviceType);
+        let queryBuilder = deviceTypesRepository
+            .createQueryBuilder('dt')
+            .leftJoin(Device, 'd', 'd.deviceTypeId = dt.id')
+            .select([
+            'dt.id as id',
+            'dt.model as model',
+            'dt.protocol as protocol',
+            'dt.protocolMatch as protocolMatch',
+        ])
+            .addSelect('COUNT(d.id)', 'deviceCount');
+        if (params?.filters?.deviceStatus) {
+            queryBuilder = queryBuilder.where('d.status = :deviceStatus', {
+                deviceStatus: params.filters.deviceStatus,
+            });
+        }
+        queryBuilder = queryBuilder.groupBy('dt.id').orderBy('deviceCount', 'DESC');
+        const result = await queryBuilder.getRawMany();
+        return result.map(item => ({
+            ...item,
+            deviceCount: parseInt(item.deviceCount, 10),
+        }));
+    }, 'DevicesRepository::getDeviceTypesModelsOrderedByDeviceCount');
+};

package/dist/repositories/devices/getDeviceWithUsersInfo.js

@@ -0,0 +1,59 @@
+import { AlertType, Billing, Device, ImeiIccidCarrier, LatestPosition, SecurityRole, User, UserActivationDevice, UserAlertConfiguration, UserSecurityRole, } from '../../entities';
+export const getDeviceWithUsersInfo = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'DevicesRepository::getDeviceWithUsersInfo missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        const queryBuilder = devicesRepository
+            .createQueryBuilder('device')
+            .innerJoin(ImeiIccidCarrier, 'iccidCarrier', 'device.imei = iccidCarrier.imei')
+            .innerJoin(User, 'user', 'device.clientId = user.clientId')
+            .innerJoin(UserSecurityRole, 'userSecurityRole', 'user.id = userSecurityRole.userId')
+            .innerJoin(SecurityRole, 'securityRole', 'userSecurityRole.securityRoleId = securityRole.id')
+            .innerJoin(UserAlertConfiguration, 'userAlertConfiguration', 'user.id = userAlertConfiguration.userId')
+            .leftJoin(Billing, 'billing', 'device.imei = billing.imei')
+            .innerJoin(AlertType, 'alertType', 'userAlertConfiguration.alertTypeId = alertType.id and alertType.id < 6')
+            .innerJoin(UserActivationDevice, 'userActivationDevice', `device.imei = userActivationDevice.imei and userActivationDevice.id = (
+            select userActivationDevice.id from userActivationDevice where userActivationDevice.imei = :imei 
+            order by userActivationDevice.id desc limit 1)
+        `, { imei: params.filters.imei.toLowerCase() })
+            .leftJoin(LatestPosition, 'latestPosition', 'device.imei = latestPosition.imei')
+            .where('device.imei = :imei', { imei: params.filters.imei.toLowerCase() })
+            .orderBy('user.createdAt, userAlertConfiguration.alertTypeId', 'DESC')
+            .select([
+            'user.firstName as firstName',
+            'user.lastName as lastName',
+            'user.userName as username',
+            'user.email as email',
+            'latestPosition.createdAt as latestPositionCreatedAt',
+            'latestPosition.actualDate as latestPositionActualDate',
+            'latestPosition.lat as latestPositionLatitude',
+            'latestPosition.lon as latestPositionLongitude',
+            'latestPosition.odometer latestPositionOdometer',
+            'latestPosition.speed as latestPositionSpeed',
+            'device.status as deviceStatus',
+            'device.name as deviceName',
+            'iccidCarrier.iccid as iccid',
+            'alertType.name as alertName',
+            'userAlertConfiguration.alertValue as alertValue',
+            'userAlertConfiguration.smsNotification as smsNotification',
+            'userAlertConfiguration.emailNotification as emailNotification',
+            'userActivationDevice.servicePlan as servicePlan',
+            'securityRole.name as roleName',
+            'billing.subscriptionId as subscriptionId',
+        ]);
+        const result = await queryBuilder.getRawMany();
+        return result.map(item => ({
+            ...item,
+            firstName: undefined,
+            lastName: undefined,
+            clientName: item.firstName?.length && item.lastName?.length
+                ? `${item.firstName} ${item.lastName}`
+                : item.firstName || item.lastName || '',
+            smsNotification: item.smsNotification === 1,
+            emailNotification: item.emailNotification === 1,
+        }));
+    }, 'DevicesRepository::getDeviceWithUsersInfo');
+};

package/dist/repositories/devices/getDevices.js

@@ -0,0 +1,46 @@
+import { ClientDeviceSetting, Device, ImeiIccidCarrier, ServiceProvider } from '../../entities';
+export const getDevices = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.deviceTypeId &&
+        !params?.filters?.clientId &&
+        !params?.filters?.imeiList?.length &&
+        !params?.filters?.status) {
+        logger.warn({ params }, 'DevicesRepository::getDevices missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        let queryBuilder = devicesRepository.createQueryBuilder('device');
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.where('device.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (params.filters.deviceTypeId) {
+            queryBuilder = queryBuilder.andWhere('device.deviceTypeId = :deviceTypeId', {
+                deviceTypeId: params.filters.deviceTypeId,
+            });
+        }
+        if (params.filters.status) {
+            queryBuilder = queryBuilder.andWhere('device.status = :status', {
+                status: params.filters.status,
+            });
+        }
+        if (params.filters.imeiList?.length) {
+            queryBuilder = queryBuilder.andWhere('device.imei IN (:...imeiList)', {
+                imeiList: params.filters.imeiList,
+            });
+        }
+        if (params.projectionOptions.withDeviceType) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('device.deviceType', 'deviceType');
+        }
+        if (params.projectionOptions.withIccidCarrier) {
+            queryBuilder = queryBuilder.leftJoinAndMapOne('device.iccidCarrier', ImeiIccidCarrier, 'iccidCarrier', 'device.imei = iccidCarrier.imei');
+            queryBuilder = queryBuilder.leftJoinAndMapOne('iccidCarrier.serviceProvider', ServiceProvider, 'serviceProvider', 'iccidCarrier.carrier = serviceProvider.id');
+        }
+        if (params.projectionOptions.withClientDeviceSettings) {
+            queryBuilder = queryBuilder.leftJoinAndMapOne('device.clientDeviceSetting', ClientDeviceSetting, 'clientDeviceSetting', 'device.imei = clientDeviceSetting.imei and device.clientId = clientDeviceSetting.clientId');
+        }
+        const devices = await queryBuilder.getMany();
+        return devices;
+    }, 'DevicesRepository::getDevices');
+};