@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/devices/getFilteredImeisWithStatus.js

@@ -0,0 +1,20 @@
+import { Device } from '../../entities';
+export const getFilteredImeisWithStatus = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imeiList?.length && !params?.filters?.status) {
+        logger.warn({ params }, 'DevicesRepository::getFilteredImeisWithStatus missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        const queryBuilder = devicesRepository
+            .createQueryBuilder('device')
+            .where('imei IN (:...imeiList)', {
+            imeiList: params.filters.imeiList,
+        })
+            .andWhere('status = :status', {
+            status: params.filters.status,
+        });
+        const imeiList = await queryBuilder.select('imei').getRawMany();
+        return imeiList.map(x => x.imei);
+    }, 'DevicesRepository::getFilteredImeisWithStatus');
+};

package/dist/repositories/devices/getIccidStatus.js

@@ -0,0 +1,17 @@
+import { IccidStatus } from '../../entities';
+export const getIccidStatus = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.iccid) {
+        logger.warn({ params }, 'DevicesRepository::getIccidStatus missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const iccidStatusRepository = dataSource.getRepository(IccidStatus);
+        const queryBuilder = iccidStatusRepository
+            .createQueryBuilder('iccidStatus')
+            .where('iccidStatus.iccid = :iccid', {
+            iccid: params.filters.iccid,
+        });
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'DevicesRepository::getIccidStatus');
+};

package/dist/repositories/devices/getImeiIccidCarrier.js

@@ -0,0 +1,23 @@
+import { ImeiIccidCarrier } from '../../entities';
+export const getImeiIccidCarrier = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei && !params?.filters?.iccid) {
+        logger.warn({ params }, 'DevicesRepository::getImeiIccidCarrier missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const imeiIccidCarrierRepository = dataSource.getRepository(ImeiIccidCarrier);
+        let queryBuilder = imeiIccidCarrierRepository.createQueryBuilder('imeiIccidCarrier');
+        if (params?.filters?.imei) {
+            queryBuilder = queryBuilder.where('imeiIccidCarrier.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        if (params?.filters?.iccid) {
+            queryBuilder = queryBuilder.andWhere('imeiIccidCarrier.iccid = :iccid', {
+                iccid: params.filters.iccid,
+            });
+        }
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'DevicesRepository::getImeiIccidCarrier');
+};

package/dist/repositories/devices/getImeiIccidCarriers.js

@@ -0,0 +1,17 @@
+import { ImeiIccidCarrier } from '../../entities';
+export const getImeiIccidCarriers = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imeiList?.length) {
+        logger.warn({ params }, 'DevicesRepository::getImeiIccidCarriers missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const imeiIccidCarrierRepository = dataSource.getRepository(ImeiIccidCarrier);
+        const queryBuilder = imeiIccidCarrierRepository
+            .createQueryBuilder('imeiIccidCarrier')
+            .where('imeiIccidCarrier.imei IN (:...imeiList)', {
+            imeiList: params.filters.imeiList,
+        });
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'DevicesRepository::getImeiIccidCarriers');
+};

package/dist/repositories/devices/index.js

@@ -0,0 +1,464 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from './../baseRepository';
+import { createClientDeviceSetting } from './createClientDeviceSetting';
+import { createDevice } from './createDevice';
+import { createDeviceReplacement } from './createDeviceReplacement';
+import { createDeviceType } from './createDeviceType';
+import { deleteDevice } from './deleteDevice';
+import { generateDeviceIdentifierKey } from './generateDeviceIdentifierKey';
+import { getCanceledDevicesWithActiveSimCards } from './getCanceledDevicesWithActiveSimCards';
+import { getCarrierStatusUpdatedBefore } from './getCarrierStatusUpdatedBefore';
+import { getClientDeviceSetting } from './getClientDeviceSetting';
+import { getClientDeviceSettings } from './getClientDeviceSettings';
+import { getDevice } from './getDevice';
+import { getDeviceCustomConfigs } from './getDeviceCustomConfig';
+import { getDevices } from './getDevices';
+import { getDeviceTypeByImei } from './getDeviceTypeByImei';
+import { getDeviceTypes } from './getDeviceTypes';
+import { getDeviceTypesModelsOrderedByDeviceCount } from './getDeviceTypesModelsOrderedByDeviceCount';
+import { getDeviceWithUsersInfo } from './getDeviceWithUsersInfo';
+import { getFilteredImeisWithStatus } from './getFilteredImeisWithStatus';
+import { getIccidStatus } from './getIccidStatus';
+import { getImeiIccidCarrier } from './getImeiIccidCarrier';
+import { getImeiIccidCarriers } from './getImeiIccidCarriers';
+import { updateClientDeviceSetting } from './updateClientDeviceSetting';
+import { updateDevice } from './updateDevice';
+import { updateDeviceType } from './updateDeviceType';
+import { updateIccidStatus } from './updateIccidStatus';
+import { updateImeiIccidCarrier } from './updateImeiIccidCarrier';
+import { upsertIccidStatus } from './upsertIccidStatus';
+export class DevicesRepository extends BaseRepository {
+    /**
+     * Get device with filters
+     * @param  {GetDeviceParams} params containing information to get a device with filters
+     * - filters.imei: The imei of the device
+     * - filters.id: The id of the device
+     * - projectionOptions.withDeviceType: Whether to get the device type object
+     * - projectionOptions.withIccidCarrier: Whether to get the iccid carrier object
+     */
+    async getDevice(params) {
+        this.logger.trace(params, 'DevicesRepository::getDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDevice(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getDevice result');
+        return result;
+    }
+    /**
+     * Get devices by type id
+     * @param  {GetDevicesParams} params containing information to get devices by type id
+     * - filters.deviceTypeId: The device type id
+     * - filters.status: The device status
+     * - filters.clientId: The client id
+     * - filters.imeiList: The imei list
+     * - projectionOptions.withDeviceType: Whether to get the device type object
+     * - projectionOptions.withIccidCarrier: Whether to get the iccid carrier object
+     */
+    async getDevices(params) {
+        this.logger.trace(params, 'DevicesRepository::getDevices started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDevices(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getDevices result');
+        return result;
+    }
+    /**
+     * Get filtered imeis with status
+     * @param  {GetFilteredImeisWithStatusParams} params containing information to get filtered imeis with status
+     * - filters.imeiList: The imei list to filter
+     * - filters.status: The device status
+     * @returns {Promise<string>} The imei list filtered by status
+     */
+    async getFilteredImeisWithStatus(params) {
+        this.logger.trace(params, 'DevicesRepository::getFilteredImeisWithStatus started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getFilteredImeisWithStatus(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getFilteredImeisWithStatus result');
+        return result;
+    }
+    /**
+     * Create device
+     * @param  {CreateDeviceParams} params containing information to create a device
+     * - identifier: The device identifier
+     * - imei: The imei of the device
+     * - clientId: The client id
+     * - deviceTypeId: The device type id
+     * - iccid: The iccid of the device
+     * - name: The name of the device
+     * - color: The color of the device
+     * - icon: The icon of the device
+     * - status: The status of the device
+     * - forward: Whether to forward the device
+     * - description: The description of the device
+     * - dataSourceTypeId: The data source type id of the device
+     * - assetCategoryId: The asset category id of the device
+     * - usageRegion: The usage region of the device
+     * - createdBy: The user who created the device
+     *
+     * @returns {Promise<Device>} The created device
+     */
+    async createDevice(params) {
+        this.logger.trace(params, 'DevicesRepository::createDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDevice(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::createDevice result');
+        return result;
+    }
+    /**
+     * Update device
+     * @param  {UpdateDeviceParams} params containing information to update a device
+     * - filters.imei: The imei of the device
+     * - filters.status: The status of the device
+     * - values.clientId: The client id
+     * - values.deviceTypeId: The device type id
+     * - values.iccid: The iccid of the device
+     * - values.name: The name of the device
+     * - values.color: The color of the device
+     * - values.icon: The icon of the device
+     * - values.status: The status of the device
+     * - values.forward: Whether to forward the device
+     * - values.description: The description of the device
+     * - values.dataSourceTypeId: The data source type id of the device
+     * - values.assetCategoryId: The asset category id of the device
+     * - values.usageRegion: The usage region of the device
+     * - values.modifiedBy: The user who updated the device
+     * @returns {Promise<boolean>} Whether the device was updated
+     */
+    async updateDevice(params) {
+        this.logger.trace(params, 'DevicesRepository::updateDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateDevice(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::updateDevice result');
+        return result;
+    }
+    /**
+     * Delete device
+     * @param  {DeleteDeviceParams} params containing information to delete a device
+     * - filters.imei: The imei of the device
+     *
+     * @returns {Promise<boolean>} Whether the device was deleted
+     */
+    async deleteDevice(params) {
+        this.logger.trace(params, 'DevicesRepository::deleteDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteDevice(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::deleteDevice result');
+        return result;
+    }
+    /**
+     * Generate device identifier key from device type and device identifier
+     * @param  {GenerateIdentifierKeyParams} params containing information to generate a device identifier key
+     * - deviceTypeId: The device type id
+     * - deviceIdentifier: The device identifier
+     * @returns {Promise<string>} The generated device identifier key
+     */
+    async generateDeviceIdentifierKey(params) {
+        this.logger.trace(params, 'DevicesRepository::generateDeviceIdentifierKey started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await generateDeviceIdentifierKey(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::generateDeviceIdentifierKey result');
+        return result;
+    }
+    /**
+     * Get device types
+     * @param  {GetDeviceTypesParams} params containing information to get device types
+     * - filters.onlyWithRelatedIccidCarrier: Whether to get only device types with iccid carrier
+     */
+    async getDeviceTypes(params) {
+        this.logger.trace(params, 'DevicesRepository::getDeviceTypes started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceTypes(novaDataSource, params);
+        this.logger.trace(result, 'DevicesRepository::getDeviceTypes result');
+        return result;
+    }
+    /**
+     * Get ImeiIccidCarrier
+     * @param  {GetImeiIccidCarrierParams} params containing information to get the ImeiIccidCarrier
+     * - filters.imei: The imei of the device
+     * - filters.iccid: The iccid of the device
+     * @returns {Promise<ImeiIccidCarrier>} The imei iccid carrier
+     */
+    async getImeiIccidCarrier(params) {
+        this.logger.trace(params, 'DevicesRepository::getImeiIccidCarrier started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getImeiIccidCarrier(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getImeiIccidCarrier result');
+        return result;
+    }
+    /**
+     * Get DeviceTypeByImei
+     * @param  {GetDeviceTypeByImeiParams} params containing information to get the device type by imei
+     * - filters.imei: The imei of the device
+     * @returns {Promise<DeviceType>} The device type record of an imei
+     */
+    async getDeviceTypeByImei(params) {
+        this.logger.trace(params, 'DevicesRepository::getDeviceTypeByImei started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceTypeByImei(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getDeviceTypeByImei result');
+        return result;
+    }
+    /**
+     * Get ImeiIccidCarriers from a list of imeis
+     * @param  {GetImeiIccidCarriersParams} params containing information to get the ImeiIccidCarriers
+     * - filters.imeis: The imeis of the devices
+     * @returns {Promise<ImeiIccidCarrier[]>} The imei iccid carriers
+     */
+    async getImeiIccidCarriers(params) {
+        this.logger.trace(params, 'DevicesRepository::getImeiIccidCarriers started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getImeiIccidCarriers(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getImeiIccidCarriers result');
+        return result;
+    }
+    /**
+     * Update the ImeiIccidCarrier
+     * @param  {UpdateImeiIccidCarrierParams} params containing information to update the ImeiIccidCarrier
+     * - filters.imei: The imei of the device to update
+     * - filters.iccid: The iccid of the device to update
+     * - values.carrierId: The carrier id
+     * - values.phone: The phone or MSISDN of the device
+     * - values.deviceTypeId: The device type id
+     * - values.serviceProviderProductId: The service provider product id
+     * - values.isValid: Whether the imei iccid carrier is valid
+     * - values.realModel: The real model of the device
+     * - values.po: The purchase order number of the device
+     * - values.outOfInventory: Whether the device is out of inventory
+     * - values.apn: The apn of the device
+     *
+     * @returns {Promise<boolean>} Whether the imei iccid carrier was updated
+     */
+    async updateImeiIccidCarrier(params) {
+        this.logger.trace(params, 'DevicesRepository::updateImeiIccidCarrier started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateImeiIccidCarrier(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::updateImeiIccidCarrier result');
+        return result;
+    }
+    /**
+     * Get a ClientDeviceSetting
+     * @param  {GetClientDeviceSettingParams} params containing information to get a ClientDeviceSetting
+     * - filters.imei: The imei of the device
+     * - filters.clientId: The client id
+     * @returns {Promise<ClientDeviceSetting>} The ClientDeviceSetting
+     */
+    async getClientDeviceSetting(params) {
+        this.logger.trace(params, 'DevicesRepository::getClientDeviceSetting with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getClientDeviceSetting(novaDataSource, params, this.logger);
+        this.logger.info(result, 'DevicesRepository::getClientDeviceSetting result');
+        return result;
+    }
+    /**
+     * Get a list of ClientDeviceSettings with filters
+     * @param  {GetClientDeviceSettingsParams} params containing information to get ClientDeviceSettings
+     * - filters.clientId: The client id
+     * @returns {Promise<ClientDeviceSetting[]>} An array of ClientDeviceSettings matching the filters
+     */
+    async getClientDeviceSettings(params) {
+        this.logger.trace(params, 'DevicesRepository::getClientDeviceSettings started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getClientDeviceSettings(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getClientDeviceSettings result');
+        return result;
+    }
+    /**
+     * Create a ClientDeviceSetting
+     * @param  {CreateClientDeviceSettingParams} params containing information to create a ClientDeviceSetting
+     * - values.imei: The imei of the device
+     * - values.clientId: The client id
+     * - values.generateTrips: Whether to generate trips
+     * - values.movingPingFrequency: The moving ping frequency
+     * - values.stoppedPingFrequency: The stopped ping frequency
+     * - values.fixedStatus: The fixed status
+     * - values.stopThresholdMinutes: The threshold in minutes to consider that the device is stopped
+     * - values.offlineThresholdMinutes: The threshold in minutes to consider that the device is offline
+     * - values.movementThresholdSpeed: The threshold for the speed to consider that the device is moving
+     * - values.externalBatteryInformation: The external battery information
+     * @returns {Promise<ClientDeviceSetting>} The created ClientDeviceSetting
+     */
+    async createClientDeviceSetting(params) {
+        this.logger.trace(params, 'DevicesRepository::createClientDeviceSetting started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createClientDeviceSetting(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::createClientDeviceSetting result');
+        return result;
+    }
+    /**
+     * Update a ClientDeviceSetting
+     * @param  {UpdateClientDeviceSettingParams} params containing information to update a ClientDeviceSetting
+     * - filters.imei: The imei of the device
+     * - filters.clientId: The client id
+     * - values.generateTrips: Whether to generate trips
+     * - values.movingPingFrequency: The moving ping frequency
+     * - values.stoppedPingFrequency: The stopped ping frequency
+     * - values.fixedStatus: The fixed status
+     * - values.stopThresholdMinutes: The threshold in minutes to consider that the device is stopped
+     * - values.offlineThresholdMinutes: The threshold in minutes to consider that the device is offline
+     * - values.movementThresholdSpeed: The threshold for the speed to consider that the device is moving
+     * - values.externalBatteryInformation: The external battery information
+     * @returns {Promise<boolean>} Whether the ClientDeviceSetting was updated
+     */
+    async updateClientDeviceSetting(params) {
+        this.logger.trace(params, 'DevicesRepository::updateClientDeviceSetting started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateClientDeviceSetting(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::updateClientDeviceSetting result');
+        return result;
+    }
+    /**
+     * Get a list of DeviceTypeModel with the count of associated devices, ordered by device count
+     * @param  {GetDeviceTypesModelsOrderedByDeviceCountParams} params containing information to get DeviceTypeModelWithDeviceCount
+     * - filters.deviceStatus: The device status to filter by, optional. If not provided, all devices will be counted
+     */
+    async getDeviceTypesModelsOrderedByDeviceCount(params) {
+        this.logger.trace(params, 'DevicesRepository::getDeviceTypesOrderedByDeviceCount started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceTypesModelsOrderedByDeviceCount(novaDataSource, params);
+        this.logger.trace({ result }, 'DevicesRepository::getDeviceTypesOrderedByDeviceCount result');
+        return result;
+    }
+    /**
+     * Get the device custom configuration
+     * @param {GetDeviceCustomConfigParams} params containing information to get the device custom configuration
+     *  - filters.clientId: The client id
+     *  - filters.imei: The imei of the device
+     *  - filters.po: The purchase order number of the device
+     * @returns The device custom configurations if found, empty array otherwise
+     */
+    async getDeviceCustomConfigs(params) {
+        this.logger.trace(params, 'DevicesRepository::getDeviceCustomConfig started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceCustomConfigs(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::getDeviceCustomConfig result');
+        return result;
+    }
+    /**
+     * Create a device replacement
+     * @param  {CreateDeviceReplacementParams} params containing information to create a device replacement
+     * - id: The id of the device replacement, optional
+     * - imeiOld: The old imei of the device, required
+     * - imeiNew: The new imei of the device, required
+     * - iccidOld: The old iccid of the device, required
+     * - iccidNew: The new iccid of the device, required
+     * - userId: The user id, required
+     * - clientId: The client id, required
+     * @returns {Promise<DeviceReplacement>} The created device replacement
+     */
+    async createDeviceReplacement(params) {
+        this.logger.trace(params, 'DevicesRepository::createDeviceReplacement started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDeviceReplacement(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::createDeviceReplacement result');
+        return result;
+    }
+    /**
+     * Get the iccid status for a given iccid
+     * @param  {GetIccidStatusParams} params containing information to get the iccid status
+     * - filters.iccid: The iccid of the device
+     * @returns The iccid status
+     */
+    async getIccidStatus(params) {
+        this.logger.trace(params, 'DevicesRepository::getIccidStatus started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getIccidStatus(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getIccidStatus result');
+        return result;
+    }
+    /**
+     * Update the iccid status for a given iccid
+     * @param  {UpdateIccidStatusParams} params containing information to update the iccid status
+     * - filters.iccid: The iccid of the device
+     * - values.status: The status of the iccid
+     * - values.processing: Whether the iccid is processing
+     * - values.carrierFound: Whether the carrier was found
+     * @returns Whether the iccid status was updated
+     */
+    async updateIccidStatus(params) {
+        this.logger.trace(params, 'DevicesRepository::updateIccidStatus started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateIccidStatus(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::updateIccidStatus result');
+        return result;
+    }
+    /**
+     * Get the canceled devices with active sim cards
+     * @param  {GetCanceledDevicesWithActiveSimCardsParams} params containing information to get the canceled devices with active sim cards
+     * - filters.lastAnalyzedDeviceId: The last analyzed device id
+     * - pagingOptions.limit: The amount of devices to get
+     * @returns The canceled devices with active sim cards
+     */
+    async getCanceledDevicesWithActiveSimCards(params) {
+        this.logger.trace(params, 'DevicesRepository::getCanceledDevicesWithActiveSimCards started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getCanceledDevicesWithActiveSimCards(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getCanceledDevicesWithActiveSimCards result');
+        return result;
+    }
+    /**
+     * Get the carrier status for all devices updated before a given date
+     * @param  {GetCarrierStatusUpdatedBeforeParams} params containing information to get the carrier status
+     * - filters.beforeDate: The date to compare
+     * - pagingOptions.limit: The amount of devices to get
+     * @returns The carrier status for devices updated before a given date
+     */
+    async getCarrierStatusUpdatedBefore(params) {
+        this.logger.trace(params, 'DevicesRepository::getCarrierStatusUpdatedBefore started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getCarrierStatusUpdatedBefore(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getCarrierStatusUpdatedBefore result');
+        return result;
+    }
+    /**
+     * Upsert the iccid status for a given iccid
+     * @param  {UpsertIccidStatusParams} params containing information to upsert the iccid status
+     * - iccid: The iccid of the device
+     * - status: The status of the iccid
+     * - carrierFound: The carrier found
+     * @returns Whether the iccid status was upserted
+     */
+    async upsertIccidStatus(params) {
+        this.logger.trace(params, 'DevicesRepository::upsertIccidStatus started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await upsertIccidStatus(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::upsertIccidStatus result');
+        return result;
+    }
+    /**
+     * Get device with users info
+     * @param  {GetDeviceWithUsersInfoParams} params containing information to get device with users info
+     * - filters.imei: The imei of the device
+     * @returns The device with users info
+     */
+    async getDeviceWithUsersInfo(params) {
+        this.logger.trace(params, 'DevicesRepository::getDeviceWithUsersInfo started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceWithUsersInfo(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::getDeviceWithUsersInfo result');
+        return result;
+    }
+    /**
+     * Create a device type
+     * @param  {CreateDeviceTypeParams} params containing information to create a device type
+     * @returns {Promise<DeviceType>} The created device type
+     */
+    async createDeviceType(params) {
+        this.logger.trace(params, 'DevicesRepository::createDeviceType started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDeviceType(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'DevicesRepository::createDeviceType result');
+        return result;
+    }
+    /**
+     * Update a device type
+     * @param  {UpdateDeviceTypeParams} params containing information to update a device type
+     * - filters.id: The id of the device type
+     * - values: The values to update. At least one field is required
+     * @returns {Promise<boolean>} Whether the device type was updated
+     */
+    async updateDeviceType(params) {
+        this.logger.trace(params, 'DevicesRepository::updateDeviceType started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateDeviceType(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'DevicesRepository::updateDeviceType result');
+        return result;
+    }
+}

package/dist/repositories/devices/updateClientDeviceSetting.js

@@ -0,0 +1,38 @@
+import { ClientDeviceSetting } from '../../entities';
+export const updateClientDeviceSetting = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei || !params?.filters?.clientId) {
+        logger.warn({ params }, 'DevicesRepository::updateClientDeviceSetting missing required parameters');
+        return false;
+    }
+    if (params?.values?.generateTrips == null &&
+        !params?.values?.movingPingFrequency &&
+        !params?.values?.stoppedPingFrequency &&
+        !params?.values?.fixedStatus &&
+        !params?.values?.stopThresholdMinutes &&
+        !params?.values?.offlineThresholdMinutes &&
+        !params?.values?.movementThresholdSpeed &&
+        params?.values?.externalBatteryInformation == null) {
+        logger.warn({ params }, 'DevicesRepository::updateClientDeviceSetting missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientDeviceSettingRepository = dataSource.getRepository(ClientDeviceSetting);
+        const queryBuilder = clientDeviceSettingRepository
+            .createQueryBuilder()
+            .update(ClientDeviceSetting)
+            .set({
+            generateTrips: params.values.generateTrips,
+            movingPingFrequency: params.values.movingPingFrequency,
+            stoppedPingFrequency: params.values.stoppedPingFrequency,
+            fixedStatus: params.values.fixedStatus,
+            stopThresholdMinutes: params.values.stopThresholdMinutes,
+            offlineThresholdMinutes: params.values.offlineThresholdMinutes,
+            movementThresholdSpeed: params.values.movementThresholdSpeed,
+            externalBatteryInformation: params.values.externalBatteryInformation,
+        })
+            .where('imei = :imei', { imei: params.filters.imei })
+            .andWhere('clientId = :clientId', { clientId: params.filters.clientId });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'DevicesRepository::updateClientDeviceSetting');
+};

package/dist/repositories/devices/updateDevice.js

@@ -0,0 +1,56 @@
+import { Device } from '../../entities';
+import { generateDeviceIdentifierKey } from './generateDeviceIdentifierKey';
+export const updateDevice = async (novaDataSource, params, logger) => {
+    // imei is required
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'DevicesRepository::updateDevice missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.clientId &&
+        !params?.values?.deviceTypeId &&
+        !params?.values?.iccid &&
+        !params?.values?.name &&
+        !params?.values?.color &&
+        !params?.values?.icon &&
+        !params?.values?.status &&
+        params?.values?.forward == null &&
+        !params?.values?.description &&
+        !params?.values?.dataSourceTypeId &&
+        !params?.values?.assetCategoryId &&
+        !params?.values?.usageRegion &&
+        !params?.values?.btmac) {
+        logger.warn({ params }, 'DevicesRepository::updateDevice missing required parameters');
+        return false;
+    }
+    let identifierKey = undefined;
+    if (params.values.deviceTypeId) {
+        // Note: imei and identifier are the same for now. We need to change this when identifier replaces imei
+        const identifier = params.filters.imei;
+        identifierKey = await generateDeviceIdentifierKey(novaDataSource, {
+            deviceTypeId: params.values.deviceTypeId,
+            deviceIdentifier: identifier,
+        }, logger);
+        if (!identifierKey) {
+            return false;
+        }
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        const now = new Date();
+        let queryBuilder = devicesRepository
+            .createQueryBuilder()
+            .update(Device)
+            .set({
+            ...params.values,
+            identifierKey,
+            modifiedAt: now,
+        })
+            .where('imei = :imei', { imei: params.filters.imei });
+        if (params.filters.status) {
+            queryBuilder = queryBuilder.andWhere('status = :status', { status: params.filters.status });
+        }
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'DevicesRepository::updateDevice');
+};