@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/boundaries/createBoundary.js

@@ -0,0 +1,52 @@
+import { Boundary } from '../../entities';
+import { BoundaryStatus } from '../../types/enums';
+const MIN_BOUNDARY_RADIUS_IN_M = 50; // in meters
+const DEFAULT_BOUNDARY_COLOR = '#e74c3c';
+const DEFAULT_BOUNDARY_DISPLAY_UNIT = 'm';
+export const createBoundary = async (novaDataSource, params, logger) => {
+    if (!params?.clientId ||
+        params.clientId === 0 ||
+        !params?.name ||
+        !params?.type ||
+        !params?.location ||
+        !params?.geometry) {
+        logger.warn({ params }, 'BoundariesRepository::createBoundary - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const now = new Date();
+        // radius
+        let buffer = parseFloat(params.buffer);
+        if (Number.isNaN(buffer)) {
+            buffer = 0;
+        }
+        const normalizedRadius = Math.max(buffer, MIN_BOUNDARY_RADIUS_IN_M);
+        // display unit
+        const radiusDisplayUnit = params.radiusDisplayUnit || DEFAULT_BOUNDARY_DISPLAY_UNIT;
+        // if not color default
+        const color = params.color || DEFAULT_BOUNDARY_COLOR;
+        // status
+        const status = params.status > 0 && params.status < 4 ? params.status : BoundaryStatus.Active;
+        const newBoundary = {
+            id: params.boundaryId,
+            name: params.name,
+            type: params.type,
+            buffer: `${normalizedRadius}`,
+            radiusDisplayUnit,
+            clientId: params.clientId,
+            createdAt: now,
+            modifiedAt: now,
+            createdBy: params.createdBy,
+            modifiedBy: params.createdBy,
+            location: params.location,
+            color,
+            geometry: params.geometry,
+            isUserCreated: params.isUserCreated ?? true,
+            status,
+            area: params.area,
+            dataSourceTypeId: params.dataSourceTypeId,
+        };
+        return await boundariesRepository.save(newBoundary);
+    }, 'BoundariesRepository::createBoundary');
+};

package/dist/repositories/boundaries/deleteBoundary.js

@@ -0,0 +1,23 @@
+import { Boundary } from '../../entities';
+import { BoundaryStatus } from '../../types/enums';
+export const deleteBoundary = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.boundaryId) {
+        logger.warn({ params }, 'BoundariesRepository::deleteBoundary - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const now = new Date();
+        const result = await boundariesRepository
+            .createQueryBuilder()
+            .update(Boundary)
+            .set({
+            status: BoundaryStatus.Deleted,
+            modifiedBy: params.values.modifiedBy,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.boundaryId })
+            .execute();
+        return result.affected > 0;
+    }, 'BoundariesRepository::deleteBoundary');
+};

package/dist/repositories/boundaries/getBoundariesByClientId.js

@@ -0,0 +1,17 @@
+import { Boundary } from '../../entities';
+export const getBoundariesByClientId = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesByClientId - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const filterCondition = params.filters.status
+            ? { where: { clientId: params.filters.clientId, status: params.filters.status } }
+            : {
+                where: { clientId: params.filters.clientId },
+            };
+        const boundaries = await boundariesRepository.find(filterCondition);
+        return boundaries;
+    }, 'BoundariesRepository::getBoundariesByClientId');
+};

package/dist/repositories/boundaries/getBoundariesIdsByClientId.js

@@ -0,0 +1,19 @@
+import { Boundary } from '../../entities';
+export const getBoundariesIdsByClientId = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesIdsByClientId - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const filterCondition = params.filters.status
+            ? { clientId: params.filters.clientId, status: params.filters.status }
+            : { clientId: params.filters.clientId };
+        const boundariesIds = await boundariesRepository
+            .createQueryBuilder()
+            .where(filterCondition)
+            .select('id')
+            .getRawMany();
+        return boundariesIds.map(x => x.id);
+    }, 'BoundariesRepository::getBoundariesIdsByClientId');
+};

package/dist/repositories/boundaries/getBoundariesReport.js

@@ -0,0 +1,141 @@
+import { Enums } from '../..';
+import { Boundary, BoundaryEvent, Device } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getBoundariesReport = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - missing required parameters');
+        return [];
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(BoundaryEvent);
+        const queryBuilder = boundariesRepository
+            .createQueryBuilder('boundaryEvent')
+            .innerJoin(Device, 'device', 'device.id = boundaryEvent.deviceId')
+            .innerJoin(Boundary, 'boundary', 'boundary.id = boundaryEvent.boundaryId')
+            .where('boundaryEvent.userId = :userId', { userId: userIdBinaryBuffer })
+            .andWhere('device.status = :deviceStatus', { deviceStatus: Enums.DeviceStatus.Active });
+        if (params.filters.boundaryId) {
+            queryBuilder.andWhere('boundaryEvent.boundaryId = :boundaryId', {
+                boundaryId: params.filters.boundaryId,
+            });
+        }
+        if (params.filters.boundaryName) {
+            queryBuilder.andWhere('boundary.name LIKE :boundaryName', {
+                boundaryName: `%${params.filters.boundaryName}%`,
+            });
+        }
+        if (params.filters.imeis?.length) {
+            queryBuilder.andWhere('device.imei IN (:...imeis)', { imeis: params.filters.imeis });
+        }
+        if (params.filters.boundaryInStartDate) {
+            queryBuilder.andWhere('boundaryEvent.inDate >= :boundaryInStartDate', {
+                boundaryInStartDate: params.filters.boundaryInStartDate,
+            });
+        }
+        if (params.filters.boundaryInEndDate) {
+            queryBuilder.andWhere('boundaryEvent.inDate <= :boundaryInEndDate', {
+                boundaryInEndDate: params.filters.boundaryInEndDate,
+            });
+        }
+        if (params.filters.boundaryOutStartDate) {
+            queryBuilder.andWhere('boundaryEvent.outDate >= :boundaryOutStartDate', {
+                boundaryOutStartDate: params.filters.boundaryOutStartDate,
+            });
+        }
+        if (params.filters.boundaryOutEndDate) {
+            queryBuilder.andWhere('boundaryEvent.outDate <= :boundaryOutEndDate', {
+                boundaryOutEndDate: params.filters.boundaryOutEndDate,
+            });
+        }
+        if (params.filters.minDuration) {
+            queryBuilder.andWhere(`((boundaryEvent.inOutDuration IS NOT NULL AND boundaryEvent.inOutDuration >= :minDuration) OR 
+         (boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL AND 
+            UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, '+00:00')) - UNIX_TIMESTAMP(boundaryEvent.inDate) >= :minDuration
+         ))`, {
+                minDuration: params.filters.minDuration,
+            });
+        }
+        if (params.filters.maxDuration) {
+            queryBuilder.andWhere(`((boundaryEvent.inOutDuration IS NOT NULL AND boundaryEvent.inOutDuration <= :maxDuration) OR 
+         (boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL AND 
+            UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, '+00:00')) - UNIX_TIMESTAMP(boundaryEvent.inDate) <= :maxDuration
+         ))`, {
+                maxDuration: params.filters.maxDuration,
+            });
+        }
+        const subQuery = queryBuilder.clone().select('COUNT(boundaryEvent.id)', 'totalCount');
+        queryBuilder.innerJoin(`(${subQuery.getQuery()})`, 'sub');
+        if (params.sortOptions?.sortField) {
+            let sortField = null;
+            switch (params.sortOptions.sortField) {
+                case 'inDateTime':
+                    sortField = 'boundaryEvent.inDate';
+                    break;
+                case 'outDateTime':
+                    sortField = 'boundaryEvent.outDate';
+                    break;
+                case 'inOutDuration':
+                    sortField = `CASE WHEN boundaryEvent.inOutDuration IS NOT NULL 
+                          THEN boundaryEvent.inOutDuration 
+                       WHEN boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL 
+                          THEN UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, "+00:00")) - UNIX_TIMESTAMP(boundaryEvent.inDate) 
+                       ELSE NULL
+                       END`;
+                    break;
+                case 'name':
+                    sortField = 'boundary.name';
+                    break;
+            }
+            queryBuilder.orderBy(sortField || 'boundaryEvent.inDate', params.sortOptions.sortOrder || 'DESC');
+        }
+        const result = await queryBuilder
+            .select([
+            'device.id AS deviceId',
+            'device.imei AS imei',
+            'device.name AS deviceName',
+            'boundary.id AS boundaryId',
+            'boundary.name AS boundaryName',
+            'boundaryEvent.inDate AS inDate',
+            'boundaryEvent.inLat AS inLat',
+            'boundaryEvent.inLon AS inLon',
+            'boundaryEvent.inAddress AS inAddress',
+            'boundaryEvent.outDate AS outDate',
+            'boundaryEvent.outLat AS outLat',
+            'boundaryEvent.outLon AS outLon',
+            'boundaryEvent.outAddress AS outAddress',
+            `CASE 
+            WHEN boundaryEvent.inOutDuration IS NOT NULL
+                THEN boundaryEvent.inOutDuration
+            WHEN boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL 
+                THEN UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, '+00:00')) - UNIX_TIMESTAMP(boundaryEvent.inDate)
+            ELSE NULL
+         END AS duration`,
+            `sub.totalCount AS totalCount`,
+        ])
+            .limit(params.pagingOptions.pageSize)
+            .offset(params.pagingOptions.pageSize * params.pagingOptions.pageIndex)
+            .getRawMany();
+        return result.map(row => ({
+            deviceId: row.deviceId,
+            imei: row.imei,
+            deviceName: row.deviceName,
+            boundaryId: row.boundaryId,
+            boundaryName: row.boundaryName,
+            inDate: row.inDate,
+            inLat: row.inLat,
+            inLon: row.inLon,
+            inAddress: row.inAddress,
+            outDate: row.outDate,
+            outLat: row.outLat,
+            outLon: row.outLon,
+            outAddress: row.outAddress,
+            inOutDuration: row.duration,
+            totalCount: row.totalCount,
+        }));
+    }, 'BoundariesRepository::getBoundariesReport');
+};

package/dist/repositories/boundaries/getBoundaryById.js

@@ -0,0 +1,14 @@
+import { Boundary } from '../../entities';
+export const getBoundaryById = async (novaDataSource, params, logger) => {
+    if (!params.filters.boundaryId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundaryById - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const boundary = await boundariesRepository.findOne({
+            where: { id: params.filters.boundaryId },
+        });
+        return boundary;
+    }, 'BoundariesRepository::getBoundaryById');
+};

package/dist/repositories/boundaries/index.js

@@ -0,0 +1,178 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createBoundary } from './createBoundary';
+import { deleteBoundary } from './deleteBoundary';
+import { getBoundariesByClientId } from './getBoundariesByClientId';
+import { getBoundariesIdsByClientId } from './getBoundariesIdsByClientId';
+import { getBoundariesReport } from './getBoundariesReport';
+import { getBoundaryById } from './getBoundaryById';
+import { processBoundaryEvent } from './processBoundaryEvent';
+import { updateBoundary } from './updateBoundary';
+import { upsertBoundaryEvent } from './upsertBoundaryEvent';
+export class BoundariesRepository extends BaseRepository {
+    /**
+     * Get all boundaries by client id
+     * @param  {GetBoundariesByClientIdParams} params containing information to get boundaries by clientId
+     * - filters.clientId: The client id
+     * - filters.status: The status to only obtain boundaries with that status, optional
+     */
+    async getBoundariesByClientId(params) {
+        this.logger.trace(params, 'BoundariesRepository::getBoundariesByClientId started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getBoundariesByClientId(novaDataSource, params, this.logger);
+        this.logger.trace({ result: result.map(x => x.id) }, 'BoundariesRepository::getBoundariesByClientId result');
+        return result;
+    }
+    /**
+     * Get all boundaries ids by client id
+     * @param  {GetBoundariesByClientIdParams} params containing information to get boundaries ids by clientId
+     * - filters.clientId: The client id
+     * - filters.status: The status to only obtain boundaries with that status, optional
+     */
+    async getBoundariesIdsByClientId(params) {
+        this.logger.trace(params, 'BoundariesRepository::getBoundariesIdsByClientId started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getBoundariesIdsByClientId(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'BoundariesRepository::getBoundariesIdsByClientId result');
+        return result;
+    }
+    /**
+     * Get a boundary by id
+     * @param  {GetBoundaryByIdParams} params containing information to get a boundary by id
+     * - filters.boundaryId: The boundary id
+     */
+    async getBoundaryById(params) {
+        this.logger.trace(params, 'BoundariesRepository::getBoundaryById started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getBoundaryById(novaDataSource, params, this.logger);
+        this.logger.trace({
+            result: {
+                ...result,
+                geometry: undefined,
+            },
+        }, 'BoundariesRepository::getBoundaryById result');
+        return result;
+    }
+    /**
+     * Create a boundary
+     * @param  {CreateBoundaryParams} params containing information to create a boundary
+     * - name: boundary name
+     * - type: boundary type
+     * - clientId: id of the client that owns the boundary
+     * - createdBy: id of the user that created the boundary
+     * - location: location of the boundary
+     * - buffer: buffer of the boundary
+     * - radiusDisplayUnit: radius display unit of the boundary
+     * - color: color of the boundary
+     * - geometry: geometry of the boundary
+     * - status: status of the boundary
+     * - dataSourceTypeId: data source type id of the boundary, optional
+     * - isUserCreated: if the boundary was created by a user, optional
+     * - area: area of the boundary, optional
+     */
+    async createBoundary(params) {
+        this.logger.trace(params, 'BoundariesRepository::createBoundary started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createBoundary(novaDataSource, params, this.logger);
+        this.logger.trace({
+            result: {
+                ...result,
+                geometry: undefined,
+            },
+        }, 'BoundariesRepository::createBoundary result');
+        return result;
+    }
+    /**
+     * Update a boundary
+     * @param  {UpdateBoundaryParams} params containing information to update a boundary
+     * - filters.boundaryId: The id of the boundary to update
+     * - values.name: The name of the boundary. Optional, if undefined, the name will not be updated.
+     * - values.type: The type of the boundary. Optional, if undefined, the type will not be updated.
+     * - values.modifiedBy: The user id of the user that modified the boundary. Optional, if undefined, the modifiedBy will not be updated.
+     * - values.location: The location of the boundary. Optional, if undefined, the location will not be updated.
+     * - values.geometry: The geometry of the boundary. Optional, if undefined, the geometry will not be updated.
+     * - values.status: The status of the boundary. Optional, if undefined, the status will not be updated.
+     * - values.buffer: The buffer of the boundary. Optional, if undefined, the buffer will not be updated.
+     * - values.radiusDisplayUnit: The radius display unit of the boundary. Optional, if undefined, the radius display unit will not be updated.
+     * - values.color: The color of the boundary. Optional, if undefined, the color will not be updated.
+     * - values.area: The area of the boundary. Optional, if undefined, the area will not be updated.
+     */
+    async updateBoundary(params) {
+        this.logger.trace(params, 'BoundariesRepository::updateBoundary started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateBoundary(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'BoundariesRepository::updateBoundary result');
+        return result;
+    }
+    /**
+     * Delete a boundary
+     * @param  {DeleteBoundaryParams} params containing information to delete a boundary
+     * The boundary will not be removed from the database, it will only be marked as deleted
+     * - filters.boundaryId: The id of the boundary to delete
+     * - values.modifiedBy: The user id of the user that deleted the boundary
+     */
+    async deleteBoundary(params) {
+        this.logger.trace(params, 'BoundariesRepository::deleteBoundary started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteBoundary(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'BoundariesRepository::deleteBoundary result');
+        return result;
+    }
+    /**
+     * Get boundaries report
+     * @param  {GetBoundariesReportParams} params containing information to get boundaries report
+     * - filters.userId: The user id
+     * - filters.boundaryId: The boundary id, optional
+     * - filters.boundaryName: The boundary name, optional
+     * - filters.imeis: The imeis, optional
+     * - filters.boundaryInStartDate: The boundary in start date, optional
+     * - filters.boundaryInEndDate: The boundary in end date, optional
+     * - filters.boundaryOutStartDate: The boundary out start date, optional
+     * - filters.boundaryOutEndDate: The boundary out end date, optional
+     * - pagingOptions.pageSize: The page size of the pagination, required
+     * - pagingOptions.pageIndex: The page index of the pagination, required
+     * - sortOptions.sortField: The field to sort the pagination, optional
+     * - sortOptions.sortOrder: The order to sort the pagination, optional
+     * @returns The boundaries report
+     */
+    async getBoundariesReport(params) {
+        this.logger.trace(params, 'BoundariesRepository::getBoundariesReport started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getBoundariesReport(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'BoundariesRepository::getBoundariesReport result');
+        return result;
+    }
+    /**
+     * Process boundary event
+     * @param  {ProcessBoundaryEventParams} params containing information to process boundary event
+     * - boundaryId: The boundary id
+     * - imei: The imei of the device
+     * - userId: The user id
+     * - sendTime: The event date
+     * - eventType: The event type (enter or exit)
+     * - lat: The latitude of the event
+     * - lon: The longitude of the event
+     * - address: The address of the event
+     * @returns true if the event was processed, false otherwise
+     */
+    async processBoundaryEvent(params) {
+        this.logger.trace(params, 'BoundariesRepository::processBoundaryEvent started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await processBoundaryEvent(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'BoundariesRepository::processBoundaryEvent result');
+        return result;
+    }
+    /**
+     * Upsert boundary event
+     * @param  {UpsertBoundaryEventParams} params containing information to upsert boundary event
+     * - id: The id of the boundary event
+     * @returns true if the event was upserted, false otherwise
+     */
+    async upsertBoundaryEvent(params) {
+        this.logger.trace(params, 'BoundariesRepository::upsertBoundaryEvent started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await upsertBoundaryEvent(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'BoundariesRepository::upsertBoundaryEvent result');
+        return result;
+    }
+}

package/dist/repositories/boundaries/processBoundaryEvent.js

@@ -0,0 +1,211 @@
+import { BoundaryEvent, Device } from '../../entities';
+import { BoundaryEventType } from '../../types/enums';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+const createBoundaryEvent = async (novaDataSource, params, deviceId) => {
+    const boundaryEventsRepository = novaDataSource.getRepository(BoundaryEvent);
+    const newBoundaryEvent = {
+        deviceId,
+        boundaryId: params.boundaryId,
+        userId: uuidStringToBinaryBuffer(params.userId),
+        inDate: params.eventType === BoundaryEventType.Enter ? params.sendTime : null,
+        inLat: params.eventType === BoundaryEventType.Enter ? params.lat : null,
+        inLon: params.eventType === BoundaryEventType.Enter ? params.lon : null,
+        inAddress: params.eventType === BoundaryEventType.Enter ? params.address : null,
+        outDate: params.eventType === BoundaryEventType.Exit ? params.sendTime : null,
+        outLat: params.eventType === BoundaryEventType.Exit ? params.lat : null,
+        outLon: params.eventType === BoundaryEventType.Exit ? params.lon : null,
+        outAddress: params.eventType === BoundaryEventType.Exit ? params.address : null,
+    };
+    const result = await boundaryEventsRepository.insert(newBoundaryEvent);
+    return result?.raw.affectedRows > 0;
+};
+const getPreviousEventDate = async (novaDataSource, params, deviceId) => {
+    let result = null;
+    const boundaryEventsRepository = novaDataSource.getRepository(BoundaryEvent);
+    // boundary events for this device, boundary and userId
+    const queryBuilder = boundaryEventsRepository
+        .createQueryBuilder('boundaryEvent')
+        .where('boundaryEvent.deviceId = :deviceId', { deviceId })
+        .andWhere('boundaryEvent.boundaryId = :boundaryId', { boundaryId: params.boundaryId })
+        .andWhere('boundaryEvent.userId = :userId', {
+        userId: uuidStringToBinaryBuffer(params.userId),
+    });
+    if (params.eventType === BoundaryEventType.Enter) {
+        // if eventType is enter, let's find the previous entry event
+        result = (await queryBuilder
+            .andWhere('boundaryEvent.inDate < :sendTime', { sendTime: params.sendTime })
+            .orderBy('boundaryEvent.inDate', 'DESC')
+            .select('boundaryEvent.inDate')
+            .limit(1)
+            .getOne())?.inDate;
+    }
+    else {
+        // if eventType is exit, let's find the previous exit event
+        result = (await queryBuilder
+            .andWhere('boundaryEvent.outDate < :sendTime', { sendTime: params.sendTime })
+            .orderBy('boundaryEvent.outDate', 'DESC')
+            .select('boundaryEvent.outDate')
+            .limit(1)
+            .getOne())?.outDate;
+    }
+    return result;
+};
+const getNextEventDate = async (novaDataSource, params, deviceId) => {
+    let result = null;
+    const boundaryEventsRepository = novaDataSource.getRepository(BoundaryEvent);
+    // boundary events for this device, boundary and userId
+    const queryBuilder = boundaryEventsRepository
+        .createQueryBuilder('boundaryEvent')
+        .where('boundaryEvent.deviceId = :deviceId', { deviceId })
+        .andWhere('boundaryEvent.boundaryId = :boundaryId', { boundaryId: params.boundaryId })
+        .andWhere('boundaryEvent.userId = :userId', {
+        userId: uuidStringToBinaryBuffer(params.userId),
+    });
+    if (params.eventType === BoundaryEventType.Enter) {
+        // if eventType is enter, let's find the next entry event
+        result = (await queryBuilder
+            .andWhere('boundaryEvent.inDate > :sendTime', { sendTime: params.sendTime })
+            .orderBy('boundaryEvent.inDate', 'ASC')
+            .select('boundaryEvent.inDate')
+            .limit(1)
+            .getOne())?.inDate;
+    }
+    else {
+        // if eventType is exit, let's find the next exit event
+        result = (await queryBuilder
+            .andWhere('boundaryEvent.outDate > :sendTime', { sendTime: params.sendTime })
+            .orderBy('boundaryEvent.outDate', 'ASC')
+            .select('boundaryEvent.outDate')
+            .limit(1)
+            .getOne())?.outDate;
+    }
+    return result;
+};
+const calculateSecondsBetween = (date1, date2) => {
+    // Convert dates to milliseconds since the Unix epoch
+    const time1 = date1.getTime();
+    const time2 = date2.getTime();
+    // Calculate the difference in milliseconds
+    const differenceInMilliseconds = Math.abs(time2 - time1);
+    // Convert milliseconds to seconds
+    const differenceInSeconds = differenceInMilliseconds / 1000;
+    return differenceInSeconds;
+};
+const getOrphanEventBetweenDates = async (novaDataSource, params, deviceId, previousEventDate, nextEventDate) => {
+    let result = null;
+    const boundaryEventsRepository = novaDataSource.getRepository(BoundaryEvent);
+    // events for this device, boundary and userId
+    const queryBuilder = boundaryEventsRepository
+        .createQueryBuilder('boundaryEvent')
+        .where('boundaryEvent.deviceId = :deviceId', { deviceId })
+        .andWhere('boundaryEvent.boundaryId = :boundaryId', { boundaryId: params.boundaryId })
+        .andWhere('boundaryEvent.userId = :userId', {
+        userId: uuidStringToBinaryBuffer(params.userId),
+    });
+    if (params.eventType === BoundaryEventType.Enter) {
+        // let's find newer orphan exits (with null inDate)
+        queryBuilder
+            .andWhere('boundaryEvent.inDate IS NULL')
+            .andWhere('boundaryEvent.outDate > :sendTime', { sendTime: params.sendTime });
+        // if nextEventDate is not null, we only use orphan exits that are older than nextEventDate
+        if (nextEventDate) {
+            queryBuilder.andWhere('boundaryEvent.outDate <= :nextEventDate', { nextEventDate });
+        }
+        // order by outDate ASC, so the first result is the closests newer orphan exit
+        queryBuilder.orderBy('boundaryEvent.outDate', 'ASC');
+    }
+    else {
+        // let's find older orphan entries (with null outDate)
+        queryBuilder
+            .andWhere('boundaryEvent.outDate IS NULL')
+            .andWhere('boundaryEvent.inDate < :sendTime', { sendTime: params.sendTime });
+        // if previousEventDate is available, we only use orphan entries that are newer than previousEventDate
+        if (previousEventDate) {
+            queryBuilder.andWhere('boundaryEvent.inDate >= :previousEventDate', { previousEventDate });
+        }
+        if (!previousEventDate && !nextEventDate) {
+            // if no other exit exist, we use the last orphan entry
+            queryBuilder.orderBy('boundaryEvent.inDate', 'DESC');
+        }
+        else {
+            // if there are other exits (previous or next), we use the first orphan entry
+            queryBuilder.orderBy('boundaryEvent.inDate', 'ASC');
+        }
+    }
+    // select the closest orphan entry / exit
+    result = await queryBuilder.limit(1).getOne();
+    return result;
+};
+export const processBoundaryEvent = async (novaDataSource, params, logger) => {
+    if (!params?.imei ||
+        !params?.boundaryId ||
+        !params?.userId ||
+        !params?.sendTime ||
+        !params?.lat ||
+        !params?.lon ||
+        !params?.address ||
+        !params?.eventType) {
+        logger.warn({ params }, 'BoundariesRepository::processBoundaryEvent - missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params.userId);
+    if (!userIdBinaryBuffer) {
+        logger.warn({ params }, 'BoundariesRepository::processBoundaryEvent - userId should be a valid uuid');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const devicesRepository = dataSource.getRepository(Device);
+        const device = await devicesRepository.findOne({
+            where: {
+                imei: params.imei,
+            },
+        });
+        // if device is not found, we can't process the event
+        if (!device) {
+            logger.warn({ params }, 'BoundariesRepository::processBoundaryEvent - device not found');
+            return false;
+        }
+        const boundaryEventsRepository = dataSource.getRepository(BoundaryEvent);
+        // we check if there is at least one event for this device, boundary and userId
+        const boundaryEvent = await boundaryEventsRepository.findOne({
+            where: {
+                deviceId: device.id,
+                boundaryId: params.boundaryId,
+                userId: userIdBinaryBuffer,
+            },
+        });
+        if (!boundaryEvent) {
+            // if no event exist for this device, boundary and userId, we create a new one
+            return await createBoundaryEvent(dataSource, params, device.id);
+        }
+        // at least one event exist, we obtain dates for events sorrounding the sendTime
+        const previousEventDate = await getPreviousEventDate(dataSource, params, device.id);
+        const nextEventDate = await getNextEventDate(dataSource, params, device.id);
+        logger.trace({ previousEventDate, nextEventDate }, 'BoundariesRepository::processBoundaryEvent - previousEventDate, nextEventDate');
+        // we check if there is an orphan event (entry or exit) between the previous and next event dates
+        const existingOrphanEvent = await getOrphanEventBetweenDates(dataSource, params, device.id, previousEventDate, nextEventDate);
+        logger.trace({ existingOrphanEventId: existingOrphanEvent?.id }, 'BoundariesRepository::processBoundaryEvent - existingOrphanEventId');
+        if (existingOrphanEvent != null) {
+            // an orphan event is available, let's update the entry or the exit part
+            const result = await boundaryEventsRepository.update({ id: existingOrphanEvent.id }, {
+                inDate: params.eventType === BoundaryEventType.Enter ? params.sendTime : undefined,
+                inLat: params.eventType === BoundaryEventType.Enter ? params.lat : undefined,
+                inLon: params.eventType === BoundaryEventType.Enter ? params.lon : undefined,
+                inAddress: params.eventType === BoundaryEventType.Enter ? params.address : undefined,
+                outDate: params.eventType === BoundaryEventType.Exit ? params.sendTime : undefined,
+                outLat: params.eventType === BoundaryEventType.Exit ? params.lat : undefined,
+                outLon: params.eventType === BoundaryEventType.Exit ? params.lon : undefined,
+                outAddress: params.eventType === BoundaryEventType.Exit ? params.address : undefined,
+                modifiedAt: new Date(),
+                inOutDuration: params.eventType === BoundaryEventType.Enter
+                    ? calculateSecondsBetween(params.sendTime, existingOrphanEvent.outDate)
+                    : calculateSecondsBetween(existingOrphanEvent.inDate, params.sendTime),
+            });
+            return result.affected > 0;
+        }
+        else {
+            // no orphan event is available, create a new one
+            return await createBoundaryEvent(dataSource, params, device.id);
+        }
+    }, 'BoundariesRepository::processBoundaryEvent');
+};