@spytecgps/nova-orm 0.0.224 → 0.0.225

package/dist/repositories/trips/getTrips.js

@@ -0,0 +1,65 @@
+import { Device, Trip } from '../../entities';
+import { requiredGetTripsParamsAttributes, } from '../../types/trip';
+import { anyAttributeIsNull } from '../../utils/anyAttributeIsNull';
+const addAndWhere = (queryBuilder, params, entityAttributeName, operation, paramsName) => {
+    if (params[paramsName] != null) {
+        const parameter = {};
+        parameter[paramsName] = params[paramsName];
+        queryBuilder.andWhere(`${entityAttributeName} ${operation} :${paramsName}`, parameter);
+    }
+};
+const addOrderBy = (queryBuilder, sortOptions) => {
+    let sortingTableAlias = 'trip';
+    let sortingAttributeName = sortOptions?.sortField ?? 'startDate';
+    if (sortingAttributeName === 'deviceName') {
+        sortingTableAlias = 'device';
+        sortingAttributeName = 'name';
+    }
+    queryBuilder.orderBy(`${sortingTableAlias}.${sortingAttributeName}`, sortOptions?.sortOrder === 'ASC' ? 'ASC' : 'DESC');
+};
+export const getTrips = async (novaDataSource, params, logger) => {
+    if (anyAttributeIsNull(params, requiredGetTripsParamsAttributes)) {
+        logger.warn('TripRepository::getTrips missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (safeDataSource) => {
+        const tripsRepository = safeDataSource.getRepository(Trip);
+        const queryBuilder = tripsRepository
+            .createQueryBuilder('trip')
+            .innerJoin(Device, 'device', 'device.imei = trip.imei AND device.clientId = trip.clientId');
+        const { filters, pagingOptions, sortOptions } = params;
+        queryBuilder.where('trip.startDate between :from and :to', {
+            from: filters.from,
+            to: filters.to,
+        });
+        addAndWhere(queryBuilder, filters, 'trip.clientId', '=', 'clientId');
+        if (!filters.deviceStatus) {
+            filters.deviceStatus = 'A';
+        }
+        addAndWhere(queryBuilder, filters, 'device.status', '=', 'deviceStatus');
+        if (filters.imeis?.length) {
+            queryBuilder.andWhere('trip.imei IN (:imeiList)', {
+                imeiList: filters.imeis,
+            });
+        }
+        addAndWhere(queryBuilder, filters, 'device.name', '=', 'deviceName');
+        addAndWhere(queryBuilder, filters, 'trip.tripCompletionStatusId', '=', 'completionStatus');
+        addAndWhere(queryBuilder, filters, 'trip.tripType', '=', 'tripType');
+        addAndWhere(queryBuilder, filters, 'trip.duration', '>=', 'durationMin');
+        addAndWhere(queryBuilder, filters, 'trip.duration', '<=', 'durationMax');
+        addAndWhere(queryBuilder, filters, 'trip.distance', '>=', 'distanceMin');
+        addAndWhere(queryBuilder, filters, 'trip.distance', '<=', 'distanceMax');
+        addOrderBy(queryBuilder, sortOptions);
+        // counting before applying pagination
+        const tripCount = await queryBuilder.getCount();
+        const limit = pagingOptions.pageSize ?? 50;
+        queryBuilder.limit(limit);
+        const globalIndex = (pagingOptions.pageIndex ?? 0) * limit;
+        queryBuilder.offset(globalIndex);
+        const trips = await queryBuilder.getMany();
+        return {
+            trips,
+            totalCount: tripCount,
+        };
+    }, 'TripRepository::getTrips error');
+};

package/dist/repositories/trips/index.js

@@ -0,0 +1,69 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createTrip } from './createTrip';
+import { getTripById } from './getTripById';
+import { getTrips } from './getTrips';
+import { updateTripEndValues } from './updateTripEndValues';
+import { upsertTrip } from './upsertTrip';
+export class TripRepository extends BaseRepository {
+    /**
+     * Create a trip
+     * @param  {CreateTripParams} params containing information to create a trip
+     * @returns {Trip} the created trip
+     */
+    async createTrip(params) {
+        this.logger.trace(params, `TripRepository::this.createTrip started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createTrip(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'TripRepository::createTrip result');
+        return result;
+    }
+    /**
+     * Update the end's attributes in a trip
+     * @param  {UpdateTripEndValuesParams} params containing information to update the trip
+     * @returns {boolean} true if the update was successfull, false otherwise
+     */
+    async updateTripEndValues(params) {
+        this.logger.trace(params, `TripRepository::this.updateTripEndValues started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateTripEndValues(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'TripRepository::updateTripEndValues result');
+        return result;
+    }
+    /**
+     * Get a trip by id
+     * @param  {CreateTripParams} id the trip's id
+     * @returns {Trip} the Trip associated to the passed id or null
+     */
+    async getTripById(id) {
+        this.logger.trace({}, `TripRepository::this.getTripById started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getTripById(novaDataSource, id, this.logger);
+        this.logger.trace(result, 'TripRepository::getTripById result');
+        return result;
+    }
+    /**
+     * Get a trip by id
+     * @param  {GetTripsParams} id the trip's filters
+     * @returns {GetTripsResult} The GetTripsResult containing the trips and the totalCount.
+     */
+    async getTrips(params) {
+        this.logger.trace({}, `TripRepository::this.getTrips started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getTrips(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'TripRepository::getTrips result');
+        return result;
+    }
+    /**
+     * Upsert a trip
+     * @param  {UpsertTripParams} params containing information to upsert a trip
+     * @returns {boolean} true if the event was upserted, false otherwise
+     */
+    async upsertTrip(params) {
+        this.logger.trace(params, `TripRepository::this.upsertTrip started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await upsertTrip(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'TripRepository::upsertTrip result');
+        return result;
+    }
+}

package/dist/repositories/trips/updateTripEndValues.js

@@ -0,0 +1,36 @@
+import { Trip } from '../../entities';
+import { requiredUpdateTripEndValuesParamsAttributes, } from '../../types/trip';
+import { anyAttributeIsNull } from '../../utils/anyAttributeIsNull';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateTripEndValues = async (novaDataSource, params, logger) => {
+    const buffertripGuid = uuidStringToBinaryBuffer(params?.filters?.tripGuid);
+    const bufferEndMessageId = uuidStringToBinaryBuffer(params?.values?.endMessageId);
+    if (!buffertripGuid ||
+        !bufferEndMessageId ||
+        anyAttributeIsNull(params, requiredUpdateTripEndValuesParamsAttributes)) {
+        logger.warn({ params }, 'TripRepository::updateTripEndValues missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (safeDataSource) => {
+        const tripsRepository = safeDataSource.getRepository(Trip);
+        const { values } = params;
+        const updateResult = await tripsRepository
+            .createQueryBuilder()
+            .update(Trip)
+            .set({
+            endDate: values.endDate,
+            endLat: values.endLat,
+            endLon: values.endLon,
+            endAddress: values.endAddress,
+            positionEnd: values.positionEnd,
+            endMessageId: bufferEndMessageId,
+            distance: values.distance,
+            duration: values.duration,
+            tripType: values.tripType,
+            tripCompletionStatusId: values.tripCompletionStatusId,
+        })
+            .where('tripGuid = :tripGuid', { tripGuid: buffertripGuid })
+            .execute();
+        return updateResult.affected > 0;
+    }, 'TripRepository::updateTripEndValues error');
+};

package/dist/repositories/trips/upsertTrip.js

@@ -0,0 +1,31 @@
+import { Trip } from '../../entities';
+import { requiredCreateTripParamsAttributes } from '../../types/trip';
+import { anyAttributeIsNull } from '../../utils/anyAttributeIsNull';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const upsertTrip = async (novaDataSource, params, logger) => {
+    const bufferId = uuidStringToBinaryBuffer(params?.tripGuid);
+    const bufferSartMessageId = uuidStringToBinaryBuffer(params?.startMessageId);
+    const bufferEndMessageId = uuidStringToBinaryBuffer(params?.endMessageId);
+    if (!bufferId ||
+        (params?.startMessageId && !bufferSartMessageId) ||
+        (params?.endMessageId && !bufferEndMessageId) ||
+        anyAttributeIsNull(params, requiredCreateTripParamsAttributes)) {
+        logger.warn({ params }, 'TripRepository::upsertTrip missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (safeDataSource) => {
+        const tripsRepository = safeDataSource.getRepository(Trip);
+        const now = new Date();
+        const newTrip = {
+            ...params,
+            tripGuid: bufferId,
+            createdAt: params.createdAt ?? now,
+            startMessageId: bufferSartMessageId,
+            endMessageId: bufferEndMessageId,
+        };
+        const result = await tripsRepository.upsert(newTrip, {
+            conflictPaths: ['tripGuid'],
+        });
+        return result?.raw?.affectedRows > 0;
+    }, 'TripRepository::upsertTrip error');
+};

package/dist/repositories/userActivations/createUserActivation.js

@@ -0,0 +1,26 @@
+import { UserActivation } from '../../entities/userActivation';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserActivation = async (novaDataSource, params, logger) => {
+    if (!params?.userId || !params?.clientId) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivation - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivation - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationsRepository = dataSource.getRepository(UserActivation);
+        const now = new Date();
+        const newUserActivation = {
+            id: params?.id,
+            userId: binaryBuffer,
+            clientId: params?.clientId,
+            createdAt: now,
+            legacyCreatedAt: now,
+            status: params?.status ?? 'A',
+        };
+        return await userActivationsRepository.save(newUserActivation);
+    }, 'UserActivationsRepository::createUserActivation');
+};

package/dist/repositories/userActivations/createUserActivationDevice.js

@@ -0,0 +1,35 @@
+import { UserActivationDevice } from '../../entities/userActivationDevice';
+export const createUserActivationDevice = async (novaDataSource, params, logger) => {
+    if (!params?.userActivationId || !params?.deviceId || !params?.imei) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivation - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationDevicesRepository = dataSource.getRepository(UserActivationDevice);
+        const now = new Date();
+        const newUserActivationDevice = {
+            id: params?.id,
+            deviceId: params?.deviceId,
+            billingInterval: params?.billingInterval,
+            deviceName: params?.deviceName,
+            userActivationId: params?.userActivationId,
+            trackingReason: params?.trackingReason,
+            deviceColor: params?.deviceColor,
+            notificationByEmail: params?.notificationByEmail,
+            notificationBySms: params?.notificationBySms,
+            planAnnual: params?.planAnnual,
+            dataSourceTypeId: params?.dataSourceTypeId,
+            subscriptionId: params?.subscriptionId,
+            platform: params?.platform,
+            eventType: params?.eventType,
+            planCode: params?.planCode,
+            servicePlan: params?.servicePlan,
+            model: params?.model,
+            imei: params?.imei,
+            status: params?.status,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await userActivationDevicesRepository.save(newUserActivationDevice);
+    }, 'UserActivationsRepository::createUserActivation');
+};

package/dist/repositories/userActivations/createUserActivationEvent.js

@@ -0,0 +1,34 @@
+import { UserActivationEvent } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserActivationEvent = async (novaDataSource, params, logger) => {
+    if (!params?.userId || !params?.eventId || !params?.eventName) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivationEvent - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivationEvent - user id should be a valid UUID');
+        return null;
+    }
+    const eventIdBinaryBuffer = uuidStringToBinaryBuffer(params?.eventId);
+    if (!eventIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivationEvent - event id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationEventsRepository = dataSource.getRepository(UserActivationEvent);
+        const now = new Date();
+        const newUserActivationEvent = {
+            userId: userIdBinaryBuffer,
+            eventId: eventIdBinaryBuffer,
+            eventName: params?.eventName,
+            eventValue: params?.eventValue,
+            eventMetadata: params?.eventMetadata,
+            platform: params?.platform,
+            ip: params?.ip,
+            userAgent: params?.userAgent,
+            createdAt: params?.createdAt ?? now,
+        };
+        return await userActivationEventsRepository.save(newUserActivationEvent);
+    }, 'UserActivationsRepository::createUserActivationEvent');
+};

package/dist/repositories/userActivations/createUserActivationMetric.js

@@ -0,0 +1,28 @@
+import { UserActivationMetric } from '../../entities/userActivationMetric';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserActivationMetric = async (novaDataSource, params, logger) => {
+    if (!params?.userId || !params?.firstName || !params?.lastName || !params?.email) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivationMetric - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::createUserActivationMetric - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationUserActivationMetricsRepository = dataSource.getRepository(UserActivationMetric);
+        const now = new Date();
+        const newUserActivationUserActivationMetric = {
+            id: params?.id,
+            userId: binaryBuffer,
+            firstName: params?.firstName,
+            lastName: params?.lastName,
+            email: params?.email,
+            phone: params?.phone,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await userActivationUserActivationMetricsRepository.save(newUserActivationUserActivationMetric);
+    }, 'UserActivationsRepository::createUserActivationMetric');
+};

package/dist/repositories/userActivations/deleteUserActivation.js

@@ -0,0 +1,22 @@
+import { UserActivation } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const deleteUserActivation = async (novaDataSource, params, logger) => {
+    if (!params?.userId) {
+        logger.warn({ params }, 'UserActivationsRepository::deleteUserActivation - missing required parameters');
+        return false;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::deleteUserActivation - user id should be a valid UUID');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationsRepository = dataSource.getRepository(UserActivation);
+        const result = await userActivationsRepository
+            .createQueryBuilder('userActivation')
+            .delete()
+            .where('userId = :userId', { userId: binaryBuffer })
+            .execute();
+        return result.affected > 0;
+    }, 'UserActivationsRepository::deleteUserActivation');
+};

package/dist/repositories/userActivations/getLastActivationDevice.js

@@ -0,0 +1,26 @@
+import { UserActivationDevice } from '../../entities';
+export const getLastActivationDevice = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'UserActivationsRepository::getLastActivationDevice - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationDevicesRepository = dataSource.getRepository(UserActivationDevice);
+        let queryBuilder = userActivationDevicesRepository.createQueryBuilder('userActivationDevice');
+        if (params.projectionOptions?.withDevice) {
+            queryBuilder = queryBuilder.innerJoinAndSelect('userActivationDevice.device', 'device');
+        }
+        if (params.projectionOptions?.withUserActivation) {
+            queryBuilder = queryBuilder.innerJoinAndSelect('userActivationDevice.userActivation', 'userActivation');
+        }
+        queryBuilder = queryBuilder.where('LOWER(userActivationDevice.imei) = LOWER(:imei)', {
+            imei: params.filters.imei,
+        });
+        const sortField = params.sortOptions?.sortField
+            ? `userActivationDevice.${params.sortOptions.sortField}`
+            : 'userActivationDevice.id';
+        queryBuilder = queryBuilder.orderBy(sortField, 'DESC').limit(1);
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'UserActivationsRepository::getLastActivationDevice');
+};

package/dist/repositories/userActivations/getUserActivationDevices.js

@@ -0,0 +1,24 @@
+import { UserActivationDevice } from '../../entities';
+export const getUserActivationDevices = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id && !params?.filters?.imei) {
+        logger.warn({ params }, 'UserActivationsRepository::getUserActivations - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationDevicesRepository = dataSource.getRepository(UserActivationDevice);
+        let queryBuilder = userActivationDevicesRepository.createQueryBuilder('userActivationDevice');
+        if (params.filters.id) {
+            queryBuilder = queryBuilder.where('userActivationDevice.id = :id', {
+                id: params.filters.id,
+            });
+        }
+        if (params.filters.imei) {
+            queryBuilder = queryBuilder.andWhere('userActivationDevice.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('userActivationDevice.id', 'DESC');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserActivationsRepository::getUserActivationDevices');
+};

package/dist/repositories/userActivations/getUserActivationDevicesByClientId.js

@@ -0,0 +1,26 @@
+import { UserActivationDevice } from '../../entities';
+export const getUserActivationDevicesByClientId = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'UserActivationsRepository::getUserActivationDevicesByClientId - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationDevicesRepository = dataSource.getRepository(UserActivationDevice);
+        const query = `SELECT *
+                    FROM (
+                      SELECT uad.*,
+                             row_number() over (partition by uad.imei order by uad.createdAt desc) as rk
+                      FROM userActivationDevice uad
+                      INNER JOIN device d on uad.deviceId  = d.id
+                      WHERE d.clientId = ?
+                    ) AS sub
+                    WHERE sub.rk = 1`;
+        const result = await userActivationDevicesRepository.query(query, [params.filters.clientId]);
+        return result.map(uad => ({
+            ...uad,
+            notificationByEmail: uad.notificationByEmail === 1,
+            notificationBySms: uad.notificationBySms === 1,
+            planAnnual: uad.planAnnual === 1,
+        }));
+    }, 'UserActivationsRepository::getUserActivationDevicesByClientId');
+};

package/dist/repositories/userActivations/getUserActivationMetrics.js

@@ -0,0 +1,24 @@
+import { UserActivationMetric } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserActivationMetrics = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserActivationsRepository::getUserActivationMetrics - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::getUserActivationMetrics - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationMetricsRepository = dataSource.getRepository(UserActivationMetric);
+        let queryBuilder = userActivationMetricsRepository.createQueryBuilder('userActivationMetric');
+        if (params.filters.userId) {
+            queryBuilder = queryBuilder.where('userActivationMetric.userId = :userId', {
+                userId: binaryBuffer,
+            });
+        }
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'UserActivationsRepository::getUserActivationMetrics');
+};

package/dist/repositories/userActivations/getUserActivations.js

@@ -0,0 +1,29 @@
+import { UserActivation } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserActivations = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId && !params?.filters?.clientId) {
+        logger.warn({ params }, 'UserActivationsRepository::getUserActivations - missing required parameters');
+        return [];
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (params?.filters?.userId && !binaryBuffer?.length) {
+        logger.warn({ params }, 'UserActivationsRepository::getUserActivations - user id should be a valid UUID');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationsRepository = dataSource.getRepository(UserActivation);
+        let queryBuilder = userActivationsRepository.createQueryBuilder('userActivation');
+        if (params.filters.userId) {
+            queryBuilder = queryBuilder.where('userActivation.userId = :userId', {
+                userId: binaryBuffer,
+            });
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.andWhere('userActivation.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserActivationsRepository::getUserActivations');
+};