@spytecgps/nova-orm 1.2.23 → 1.2.25

package/dist/repositories/boundaries/processBoundaryEvent.js

@@ -1,212 +1,212 @@
-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');
-};
+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');
+};
 //# sourceMappingURL=processBoundaryEvent.js.map

package/dist/repositories/boundaries/updateBoundary.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { UpdateBoundaryParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const updateBoundary: (novaDataSource: NovaDataSource, params: UpdateBoundaryParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { UpdateBoundaryParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const updateBoundary: (novaDataSource: NovaDataSource, params: UpdateBoundaryParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/boundaries/updateBoundary.js

@@ -1,54 +1,54 @@
-import { Boundary } from '../../entities';
-export const updateBoundary = async (novaDataSource, params, logger) => {
-    // boundaryId is required
-    if (!params?.filters?.boundaryId) {
-        logger.warn({ params }, 'BoundariesRepository::updateBoundary - missing required parameters');
-        return false;
-    }
-    // status
-    const status = params?.values?.status > 0 && params?.values?.status < 4 ? params.values.status : undefined;
-    // radius
-    let buffer = params?.values?.buffer;
-    if (buffer) {
-        const bufferFloat = parseFloat(params.values.buffer);
-        if (Number.isNaN(bufferFloat)) {
-            buffer = undefined;
-        }
-    }
-    // at least one field to update is required
-    if (!params?.values?.name &&
-        !params?.values?.type &&
-        !params?.values?.location &&
-        !buffer &&
-        !params?.values?.radiusDisplayUnit &&
-        !params?.values?.color &&
-        !params?.values?.geometry &&
-        !status &&
-        !params?.values?.area) {
-        logger.warn({ params }, 'BoundariesRepository::updateBoundary - 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({
-            name: params.values.name,
-            type: params.values.type,
-            modifiedBy: params.values.modifiedBy,
-            location: params.values.location,
-            buffer,
-            radiusDisplayUnit: params.values.radiusDisplayUnit,
-            color: params.values.color,
-            geometry: params.values.geometry,
-            status,
-            modifiedAt: now,
-        })
-            .where('id = :id', { id: params.filters.boundaryId })
-            .execute();
-        return result.affected > 0;
-    }, 'BoundariesRepository::updateBoundary');
-};
+import { Boundary } from '../../entities';
+export const updateBoundary = async (novaDataSource, params, logger) => {
+    // boundaryId is required
+    if (!params?.filters?.boundaryId) {
+        logger.warn({ params }, 'BoundariesRepository::updateBoundary - missing required parameters');
+        return false;
+    }
+    // status
+    const status = params?.values?.status > 0 && params?.values?.status < 4 ? params.values.status : undefined;
+    // radius
+    let buffer = params?.values?.buffer;
+    if (buffer) {
+        const bufferFloat = parseFloat(params.values.buffer);
+        if (Number.isNaN(bufferFloat)) {
+            buffer = undefined;
+        }
+    }
+    // at least one field to update is required
+    if (!params?.values?.name &&
+        !params?.values?.type &&
+        !params?.values?.location &&
+        !buffer &&
+        !params?.values?.radiusDisplayUnit &&
+        !params?.values?.color &&
+        !params?.values?.geometry &&
+        !status &&
+        !params?.values?.area) {
+        logger.warn({ params }, 'BoundariesRepository::updateBoundary - 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({
+            name: params.values.name,
+            type: params.values.type,
+            modifiedBy: params.values.modifiedBy,
+            location: params.values.location,
+            buffer,
+            radiusDisplayUnit: params.values.radiusDisplayUnit,
+            color: params.values.color,
+            geometry: params.values.geometry,
+            status,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.boundaryId })
+            .execute();
+        return result.affected > 0;
+    }, 'BoundariesRepository::updateBoundary');
+};
 //# sourceMappingURL=updateBoundary.js.map

package/dist/repositories/boundaries/upsertBoundaryEvent.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { UpsertBoundaryEventParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const upsertBoundaryEvent: (novaDataSource: NovaDataSource, params: UpsertBoundaryEventParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { UpsertBoundaryEventParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const upsertBoundaryEvent: (novaDataSource: NovaDataSource, params: UpsertBoundaryEventParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/boundaries/upsertBoundaryEvent.js

@@ -1,24 +1,24 @@
-import { BoundaryEvent } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const upsertBoundaryEvent = async (novaDataSource, params, logger) => {
-    if (!params?.id || !params?.boundaryId || !params?.deviceId || !params?.imei) {
-        logger.warn({ params }, 'BoundariesRepository::upsertBoundaryEvent missing required parameters');
-        return false;
-    }
-    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params.userId);
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const boundaryEventRepository = dataSource.getRepository(BoundaryEvent);
-        const now = new Date();
-        const boundaryEvent = {
-            ...params,
-            userId: userIdBinaryBuffer,
-            createdAt: params.createdAt ?? now,
-            modifiedAt: params.modifiedAt ?? now,
-        };
-        const result = await boundaryEventRepository.upsert(boundaryEvent, {
-            conflictPaths: ['id'],
-        });
-        return result?.raw?.affectedRows > 0;
-    }, 'BoundariesRepository::upsertBoundaryEvent');
-};
+import { BoundaryEvent } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const upsertBoundaryEvent = async (novaDataSource, params, logger) => {
+    if (!params?.id || !params?.boundaryId || !params?.deviceId || !params?.imei) {
+        logger.warn({ params }, 'BoundariesRepository::upsertBoundaryEvent missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params.userId);
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundaryEventRepository = dataSource.getRepository(BoundaryEvent);
+        const now = new Date();
+        const boundaryEvent = {
+            ...params,
+            userId: userIdBinaryBuffer,
+            createdAt: params.createdAt ?? now,
+            modifiedAt: params.modifiedAt ?? now,
+        };
+        const result = await boundaryEventRepository.upsert(boundaryEvent, {
+            conflictPaths: ['id'],
+        });
+        return result?.raw?.affectedRows > 0;
+    }, 'BoundariesRepository::upsertBoundaryEvent');
+};
 //# sourceMappingURL=upsertBoundaryEvent.js.map

package/dist/repositories/clientAlertConfiguration/createClientAlertConfiguration.d.ts

@@ -1,5 +1,5 @@
-import { ClientAlertConfiguration } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { CreateClientAlertConfigurationParams } from '../../types/clientAlertConfiguration';
-import { Logger } from '../../types/logger';
-export declare const createClientAlertConfiguration: (novaDataSource: NovaDataSource, params: CreateClientAlertConfigurationParams, logger: Logger) => Promise<ClientAlertConfiguration>;
+import { ClientAlertConfiguration } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { CreateClientAlertConfigurationParams } from '../../types/clientAlertConfiguration';
+import { Logger } from '../../types/logger';
+export declare const createClientAlertConfiguration: (novaDataSource: NovaDataSource, params: CreateClientAlertConfigurationParams, logger: Logger) => Promise<ClientAlertConfiguration>;