@spytecgps/nova-orm 1.2.33 → 1.2.34

package/dist/repositories/positions/createPosition.js

@@ -1,103 +1,103 @@
-import { Position } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-import { upsertLatestPosition } from './upsertLatestPosition';
-export const createPosition = async (novaDataSource, params, logger) => {
-    if (!params?.messageId || !params?.actualDate || !params?.clientId || !params?.imei) {
-        return null;
-    }
-    try {
-        await novaDataSource.connect();
-        const positionsRepository = novaDataSource.getRepository(Position);
-        const now = new Date();
-        const newPosition = {
-            id: params.id,
-            imei: params.imei,
-            lat: params.lat,
-            lon: params.lon,
-            actualDate: params.actualDate,
-            speed: params.speed,
-            odometer: params.odometer,
-            createdAt: params.createdAt ?? now,
-            messageId: uuidStringToBinaryBuffer(params.messageId),
-            batteryPercentage: params.batteryPercentage,
-            clientId: params.clientId,
-            address: params.address,
-            sendTime: params.sendTime,
-            gpsUtcTime: params.gpsUtcTime,
-            externalBatteryPercentage: params.externalBatteryPercentage,
-            externalPowerVoltage: params.externalPowerVoltage,
-            azimuth: params.azimuth,
-        };
-        const createdPosition = await positionsRepository.save(newPosition);
-        if (!createdPosition) {
-            return null;
-        }
-        await upsertLatestPosition(novaDataSource, createdPosition, logger);
-        return { ...createdPosition, id: Number(createdPosition.id) };
-    }
-    catch (error) {
-        logger.error(error, `PositionsRepository::createPosition error`);
-        throw error;
-    }
-    finally {
-        await novaDataSource.disconnect();
-    }
-};
-export const upsertPositions = async (novaDataSource, params, logger) => {
-    try {
-        await novaDataSource.connect();
-        const positionsRepository = novaDataSource.getRepository(Position);
-        const positions = [];
-        params.forEach(param => {
-            if (!param?.messageId || !param?.actualDate || !param?.clientId || !param?.imei) {
-                return null;
-            }
-            const now = new Date();
-            const newPosition = {
-                id: param.id,
-                imei: param.imei,
-                lat: param.lat,
-                lon: param.lon,
-                actualDate: param.actualDate,
-                speed: param.speed,
-                odometer: param.odometer,
-                createdAt: param.createdAt ?? now,
-                messageId: uuidStringToBinaryBuffer(param.messageId),
-                batteryPercentage: param.batteryPercentage,
-                clientId: param.clientId,
-                address: param.address,
-                sendTime: param.sendTime,
-                gpsUtcTime: param.gpsUtcTime,
-                externalBatteryPercentage: param.externalBatteryPercentage,
-                externalPowerVoltage: param.externalPowerVoltage,
-                azimuth: param.azimuth,
-            };
-            positions.push(newPosition);
-        });
-        await positionsRepository.upsert(positions, {
-            conflictPaths: ['messageId'],
-        });
-        const insertedPositions = await positionsRepository
-            .createQueryBuilder('p')
-            .where('p.messageId IN (:messageIds)', {
-            messageIds: positions.map(p => p.messageId),
-        })
-            .orderBy('p.id', 'ASC')
-            .getMany();
-        for (const position of insertedPositions) {
-            await upsertLatestPosition(novaDataSource, position, logger);
-        }
-        return (insertedPositions?.map(p => ({
-            ...p,
-            id: Number(p.id),
-        })) ?? []);
-    }
-    catch (error) {
-        logger.error(error, `PositionsRepository::upsertPositions error`);
-        throw error;
-    }
-    finally {
-        await novaDataSource.disconnect();
-    }
-};
+import { Position } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+import { upsertLatestPosition } from './upsertLatestPosition';
+export const createPosition = async (novaDataSource, params, logger) => {
+    if (!params?.messageId || !params?.actualDate || !params?.clientId || !params?.imei) {
+        return null;
+    }
+    try {
+        await novaDataSource.connect();
+        const positionsRepository = novaDataSource.getRepository(Position);
+        const now = new Date();
+        const newPosition = {
+            id: params.id,
+            imei: params.imei,
+            lat: params.lat,
+            lon: params.lon,
+            actualDate: params.actualDate,
+            speed: params.speed,
+            odometer: params.odometer,
+            createdAt: params.createdAt ?? now,
+            messageId: uuidStringToBinaryBuffer(params.messageId),
+            batteryPercentage: params.batteryPercentage,
+            clientId: params.clientId,
+            address: params.address,
+            sendTime: params.sendTime,
+            gpsUtcTime: params.gpsUtcTime,
+            externalBatteryPercentage: params.externalBatteryPercentage,
+            externalPowerVoltage: params.externalPowerVoltage,
+            azimuth: params.azimuth,
+        };
+        const createdPosition = await positionsRepository.save(newPosition);
+        if (!createdPosition) {
+            return null;
+        }
+        await upsertLatestPosition(novaDataSource, createdPosition, logger);
+        return { ...createdPosition, id: Number(createdPosition.id) };
+    }
+    catch (error) {
+        logger.error(error, `PositionsRepository::createPosition error`);
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};
+export const upsertPositions = async (novaDataSource, params, logger) => {
+    try {
+        await novaDataSource.connect();
+        const positionsRepository = novaDataSource.getRepository(Position);
+        const positions = [];
+        params.forEach(param => {
+            if (!param?.messageId || !param?.actualDate || !param?.clientId || !param?.imei) {
+                return null;
+            }
+            const now = new Date();
+            const newPosition = {
+                id: param.id,
+                imei: param.imei,
+                lat: param.lat,
+                lon: param.lon,
+                actualDate: param.actualDate,
+                speed: param.speed,
+                odometer: param.odometer,
+                createdAt: param.createdAt ?? now,
+                messageId: uuidStringToBinaryBuffer(param.messageId),
+                batteryPercentage: param.batteryPercentage,
+                clientId: param.clientId,
+                address: param.address,
+                sendTime: param.sendTime,
+                gpsUtcTime: param.gpsUtcTime,
+                externalBatteryPercentage: param.externalBatteryPercentage,
+                externalPowerVoltage: param.externalPowerVoltage,
+                azimuth: param.azimuth,
+            };
+            positions.push(newPosition);
+        });
+        await positionsRepository.upsert(positions, {
+            conflictPaths: ['messageId'],
+        });
+        const insertedPositions = await positionsRepository
+            .createQueryBuilder('p')
+            .where('p.messageId IN (:messageIds)', {
+            messageIds: positions.map(p => p.messageId),
+        })
+            .orderBy('p.id', 'ASC')
+            .getMany();
+        for (const position of insertedPositions) {
+            await upsertLatestPosition(novaDataSource, position, logger);
+        }
+        return (insertedPositions?.map(p => ({
+            ...p,
+            id: Number(p.id),
+        })) ?? []);
+    }
+    catch (error) {
+        logger.error(error, `PositionsRepository::upsertPositions error`);
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};
 //# sourceMappingURL=createPosition.js.map

package/dist/repositories/positions/getBatteryReportForDevice.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { GetBatteryReportForDeviceParams } from '../../types/position';
-export declare const getBatteryReportForDevice: (novaDataSource: NovaDataSource, params: GetBatteryReportForDeviceParams, logger: Logger) => Promise<any[]>;
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { GetBatteryReportForDeviceParams } from '../../types/position';
+export declare const getBatteryReportForDevice: (novaDataSource: NovaDataSource, params: GetBatteryReportForDeviceParams, logger: Logger) => Promise<any[]>;

package/dist/repositories/positions/getBatteryReportForDevice.js

@@ -1,47 +1,47 @@
-import { Position } from '../../entities/position';
-export const getBatteryReportForDevice = async (novaDataSource, params, logger) => {
-    if (!(params.filters.clientId && params.filters.imei)) {
-        return [];
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    try {
-        await novaDataSource.connect();
-        const positionsRepository = novaDataSource.getRepository(Position);
-        let positionsQuery = positionsRepository
-            .createQueryBuilder('p')
-            .setQueryRunner(dbQueryRunner)
-            .select('DATE(p.actualDate)', 'actualDate')
-            .addSelect('MAX(p.batteryPercentage)', 'batteryPercentage')
-            .where('p.clientId = :clientId', { clientId: params.filters.clientId })
-            .andWhere('p.imei = :imei', { imei: params.filters.imei });
-        if (params.filters.startDate) {
-            positionsQuery = positionsQuery.andWhere('p.actualDate >= :startDate', {
-                startDate: params.filters.startDate,
-            });
-        }
-        if (params.filters.endDate) {
-            positionsQuery = positionsQuery.andWhere('p.actualDate <= :endDate', {
-                endDate: params.filters.endDate,
-            });
-        }
-        const pageSize = params?.pagingOptions?.pageSize ?? 100;
-        const pageIndex = params?.pagingOptions?.pageIndex ?? 1;
-        positionsQuery = positionsQuery
-            .groupBy('DATE(p.actualDate)')
-            .orderBy('DATE(p.actualDate)', 'DESC')
-            .limit(pageSize)
-            .offset(pageSize * (pageIndex - 1));
-        const results = await positionsQuery.getRawMany();
-        return results;
-    }
-    catch (error) {
-        logger.error({ error }, 'PositionsRepository::GetPositionsReportByClientId error');
-        throw error;
-    }
-    finally {
-        await dbQueryRunner.release();
-        await novaDataSource.disconnect();
-    }
-};
+import { Position } from '../../entities/position';
+export const getBatteryReportForDevice = async (novaDataSource, params, logger) => {
+    if (!(params.filters.clientId && params.filters.imei)) {
+        return [];
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    try {
+        await novaDataSource.connect();
+        const positionsRepository = novaDataSource.getRepository(Position);
+        let positionsQuery = positionsRepository
+            .createQueryBuilder('p')
+            .setQueryRunner(dbQueryRunner)
+            .select('DATE(p.actualDate)', 'actualDate')
+            .addSelect('MAX(p.batteryPercentage)', 'batteryPercentage')
+            .where('p.clientId = :clientId', { clientId: params.filters.clientId })
+            .andWhere('p.imei = :imei', { imei: params.filters.imei });
+        if (params.filters.startDate) {
+            positionsQuery = positionsQuery.andWhere('p.actualDate >= :startDate', {
+                startDate: params.filters.startDate,
+            });
+        }
+        if (params.filters.endDate) {
+            positionsQuery = positionsQuery.andWhere('p.actualDate <= :endDate', {
+                endDate: params.filters.endDate,
+            });
+        }
+        const pageSize = params?.pagingOptions?.pageSize ?? 100;
+        const pageIndex = params?.pagingOptions?.pageIndex ?? 1;
+        positionsQuery = positionsQuery
+            .groupBy('DATE(p.actualDate)')
+            .orderBy('DATE(p.actualDate)', 'DESC')
+            .limit(pageSize)
+            .offset(pageSize * (pageIndex - 1));
+        const results = await positionsQuery.getRawMany();
+        return results;
+    }
+    catch (error) {
+        logger.error({ error }, 'PositionsRepository::GetPositionsReportByClientId error');
+        throw error;
+    }
+    finally {
+        await dbQueryRunner.release();
+        await novaDataSource.disconnect();
+    }
+};
 //# sourceMappingURL=getBatteryReportForDevice.js.map

package/dist/repositories/positions/getLatestPositionByImei.d.ts

@@ -1,5 +1,5 @@
-import { LatestPosition } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { GetLatestPositionByImeiParams } from '../../types/position';
-export declare const getLatestPositionByImei: (novaDataSource: NovaDataSource, params: GetLatestPositionByImeiParams, logger: Logger) => Promise<LatestPosition>;
+import { LatestPosition } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { GetLatestPositionByImeiParams } from '../../types/position';
+export declare const getLatestPositionByImei: (novaDataSource: NovaDataSource, params: GetLatestPositionByImeiParams, logger: Logger) => Promise<LatestPosition>;

package/dist/repositories/positions/getLatestPositionByImei.js

@@ -1,33 +1,33 @@
-import { LatestPosition } from '../../entities';
-export const getLatestPositionByImei = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.imei) {
-        return null;
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    try {
-        await novaDataSource.connect();
-        const latestPositionsRepository = novaDataSource.getRepository(LatestPosition);
-        const result = await latestPositionsRepository
-            .createQueryBuilder('latestPosition')
-            .setQueryRunner(dbQueryRunner)
-            .where('latestPosition.imei = :imei', { imei: params.filters.imei })
-            .getOne();
-        if (!result) {
-            return null;
-        }
-        return {
-            ...result,
-            positionId: Number(result.positionId),
-        };
-    }
-    catch (error) {
-        logger.error({ error }, 'PositionsRepository::getLatestPositionsByImei error');
-        throw error;
-    }
-    finally {
-        await dbQueryRunner.release();
-        await novaDataSource.disconnect();
-    }
-};
+import { LatestPosition } from '../../entities';
+export const getLatestPositionByImei = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        return null;
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    try {
+        await novaDataSource.connect();
+        const latestPositionsRepository = novaDataSource.getRepository(LatestPosition);
+        const result = await latestPositionsRepository
+            .createQueryBuilder('latestPosition')
+            .setQueryRunner(dbQueryRunner)
+            .where('latestPosition.imei = :imei', { imei: params.filters.imei })
+            .getOne();
+        if (!result) {
+            return null;
+        }
+        return {
+            ...result,
+            positionId: Number(result.positionId),
+        };
+    }
+    catch (error) {
+        logger.error({ error }, 'PositionsRepository::getLatestPositionsByImei error');
+        throw error;
+    }
+    finally {
+        await dbQueryRunner.release();
+        await novaDataSource.disconnect();
+    }
+};
 //# sourceMappingURL=getLatestPositionByImei.js.map

package/dist/repositories/positions/getPositionsByImei.d.ts

@@ -1,5 +1,5 @@
-import { Position } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { GetPositionsByImeiParams } from '../../types/position';
-export declare const getPositionsByImei: (novaDataSource: NovaDataSource, params: GetPositionsByImeiParams, logger: Logger) => Promise<Position[]>;
+import { Position } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { GetPositionsByImeiParams } from '../../types/position';
+export declare const getPositionsByImei: (novaDataSource: NovaDataSource, params: GetPositionsByImeiParams, logger: Logger) => Promise<Position[]>;

package/dist/repositories/positions/getPositionsByImei.js

@@ -1,30 +1,30 @@
-import { Position } from '../../entities';
-export const getPositionsByImei = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.imei) {
-        return [];
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    try {
-        await novaDataSource.connect();
-        const positionsRepository = novaDataSource.getRepository(Position);
-        const positions = await positionsRepository
-            .createQueryBuilder('position')
-            .setQueryRunner(dbQueryRunner)
-            .where('position.imei = :imei', { imei: params.filters.imei })
-            .getMany();
-        return (positions?.map(p => ({
-            ...p,
-            id: Number(p.id),
-        })) ?? []);
-    }
-    catch (error) {
-        logger.error({ error }, 'PositionsRepository::getPositionsByImei error');
-        throw error;
-    }
-    finally {
-        await dbQueryRunner.release();
-        await novaDataSource.disconnect();
-    }
-};
+import { Position } from '../../entities';
+export const getPositionsByImei = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        return [];
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    try {
+        await novaDataSource.connect();
+        const positionsRepository = novaDataSource.getRepository(Position);
+        const positions = await positionsRepository
+            .createQueryBuilder('position')
+            .setQueryRunner(dbQueryRunner)
+            .where('position.imei = :imei', { imei: params.filters.imei })
+            .getMany();
+        return (positions?.map(p => ({
+            ...p,
+            id: Number(p.id),
+        })) ?? []);
+    }
+    catch (error) {
+        logger.error({ error }, 'PositionsRepository::getPositionsByImei error');
+        throw error;
+    }
+    finally {
+        await dbQueryRunner.release();
+        await novaDataSource.disconnect();
+    }
+};
 //# sourceMappingURL=getPositionsByImei.js.map

package/dist/repositories/positions/getPositionsReportByClient.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { GetPositionsReportByClientParams, PositionReport } from '../../types/position';
-export declare const getPositionsReportByClient: (novaDataSource: NovaDataSource, params: GetPositionsReportByClientParams, logger: Logger) => Promise<PositionReport[]>;
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { GetPositionsReportByClientParams, PositionReport } from '../../types/position';
+export declare const getPositionsReportByClient: (novaDataSource: NovaDataSource, params: GetPositionsReportByClientParams, logger: Logger) => Promise<PositionReport[]>;