@spytecgps/nova-orm 0.0.224 → 0.0.225

package/dist/repositories/positions/getPositionsByImei.js

@@ -0,0 +1,23 @@
+import { Position } from '../../entities';
+export const getPositionsByImei = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        return [];
+    }
+    try {
+        await novaDataSource.connect();
+        const positionsRepository = novaDataSource.getRepository(Position);
+        const filterCondition = { where: { imei: params.filters.imei } };
+        const positions = await positionsRepository.find(filterCondition);
+        return (positions?.map(p => ({
+            ...p,
+            id: Number(p.id),
+        })) ?? []);
+    }
+    catch (error) {
+        logger.error({ error }, 'PositionsRepository::getPositionsByImei error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/positions/getPositionsReportByClient.js

@@ -0,0 +1,87 @@
+import { Position } from '../../entities/position';
+export const getPositionsReportByClient = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        return [];
+    }
+    try {
+        await novaDataSource.connect();
+        const positionsRepository = novaDataSource.getRepository(Position);
+        let positionsQuery = positionsRepository
+            .createQueryBuilder('p')
+            .where('p.clientId = :clientId', { clientId: params.filters.clientId });
+        if (params.filters.imeis) {
+            positionsQuery = positionsQuery.andWhere('p.imei IN (:...imeis)', {
+                imeis: params.filters.imeis,
+            });
+        }
+        if (params.filters.actualDateFrom) {
+            positionsQuery = positionsQuery.andWhere('p.actualDate >= :actualDateFrom', {
+                actualDateFrom: params.filters.actualDateFrom,
+            });
+        }
+        if (params.filters.actualDateTo) {
+            positionsQuery = positionsQuery.andWhere('p.actualDate <= :actualDateTo', {
+                actualDateTo: params.filters.actualDateTo,
+            });
+        }
+        if (params.filters.speedMin) {
+            positionsQuery = positionsQuery.andWhere('p.speed >= :speedMin', {
+                speedMin: params.filters.speedMin,
+            });
+        }
+        if (params.filters.speedMax) {
+            positionsQuery = positionsQuery.andWhere('p.speed <= :speedMax', {
+                speedMax: params.filters.speedMax,
+            });
+        }
+        if (params.filters.odometerMin) {
+            positionsQuery = positionsQuery.andWhere('p.odometer >= :odometerMin', {
+                odometerMin: params.filters.odometerMin,
+            });
+        }
+        if (params.filters.odometerMax) {
+            positionsQuery = positionsQuery.andWhere('p.odometer <= :odometerMax', {
+                odometerMax: params.filters.odometerMax,
+            });
+        }
+        const subQuery = positionsQuery.clone().select('COUNT(p.id)', 'totalCount');
+        if (params.filters.imeis?.length) {
+            positionsQuery.useIndex('ixPositionClientId_Imei_ActualDate');
+            subQuery.useIndex('ixPositionClientId_Imei_ActualDate');
+        }
+        else {
+            positionsQuery.useIndex('ixPositionClientId_ActualDate');
+            subQuery.useIndex('ixPositionClientId_ActualDate');
+        }
+        positionsQuery.innerJoin(`(${subQuery.getQuery()})`, 'sub');
+        if (params.sortOptions?.sortField) {
+            positionsQuery.orderBy(params.sortOptions.sortField, params.sortOptions.sortOrder);
+        }
+        const positions = await positionsQuery
+            .select([
+            'p.imei as imei',
+            'p.createdAt as createdAt',
+            'p.actualDate as actualDate',
+            'p.lat as lat',
+            'p.lon as lon',
+            'p.address as address',
+            'p.speed as speed',
+            'p.odometer as odometer',
+            'p.batteryPercentage as batteryPercentage',
+            'p.externalPowerVoltage as externalPowerVoltage',
+            'p.externalBatteryPercentage as externalBatteryPercentage',
+            `sub.totalCount as totalCount`,
+        ])
+            .limit(params.pagingOptions.pageSize)
+            .offset(params.pagingOptions.pageSize * params.pagingOptions.pageIndex)
+            .getRawMany();
+        return positions;
+    }
+    catch (error) {
+        logger.error({ error }, 'PositionsRepository::GetPositionsReportByClientId error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/positions/index.js

@@ -0,0 +1,101 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createPosition, upsertPositions } from './createPosition';
+import { getLatestPositionByImei } from './getLatestPositionByImei';
+import { getPositionsByImei } from './getPositionsByImei';
+import { getPositionsReportByClient } from './getPositionsReportByClient';
+export class PositionRepository extends BaseRepository {
+    /**
+     * Create a position
+     * @param  {CreatePositionParams} params containing information to create a position
+     * - id: position id. if null will be generated
+     * - imei: imei of the device reporting the position
+     * - lat: the latitude of the position
+     * - lon: the longitude of the position
+     * - actualDate: the actual date of the message
+     * - speed: the speed reported by the device
+     * - odometer: the odometer reported by the device
+     * - messageId: the id of the message
+     * - batteryPercentage: the battery percentage reported by the device
+     * - clientId: the client id of owner of the device
+     * - address: the address of the position
+     * - sendTime: the time the message was sent
+     * - gpsUtcTime: the time the gps was set
+     * - externalBatteryPercentage: the external battery percentage reported by the device
+     */
+    async createPosition(params) {
+        this.logger.trace(params, `PositionsRepository::this.createPosition started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createPosition(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'PositionsRepository::insertPositions result');
+        return result;
+    }
+    /**
+     * Create a position
+     * @param  {CreatePositionParams[]} params array containing information to create a positions
+     * - id: position id. if null will be generated
+     * - imei: imei of the device reporting the position
+     * - lat: the latitude of the position
+     * - lon: the longitude of the position
+     * - actualDate: the actual date of the message
+     * - speed: the speed reported by the device
+     * - odometer: the odometer reported by the device
+     * - messageId: the id of the message
+     * - batteryPercentage: the battery percentage reported by the device
+     * - clientId: the client id of owner of the device
+     * - address: the address of the position
+     * - sendTime: the time the message was sent
+     * - gpsUtcTime: the time the gps was set
+     * - externalBatteryPercentage: the external battery percentage reported by the device
+     * @returns {Position[]} the created positions
+     */
+    async upsertPositions(params) {
+        this.logger.trace(params, `PositionsRepository::this.createPosition started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await upsertPositions(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'PositionsRepository::insertPositions result');
+        return result;
+    }
+    /**
+     * Get positions by imei
+     * @param  {GetPositionsByImeiParams} params containing information to get positions
+     * - filters.imei: filters by imei to get positions
+     */
+    async getPositionsByImei(params) {
+        this.logger.trace(params, `PositionsRepository::this.getPositionsByImei started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getPositionsByImei(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'PositionsRepository::getPositionsByImei result');
+        return result;
+    }
+    /**
+     * Get positions report by client id
+     * @param  {GetPositionsReportByClientParams} params containing information to get positions
+     * - filters.clientId: filters by client id to get positions
+     * - filters.imeis: filters by imeis to get positions
+     * - filters.actualDateFrom: filters by actual date from to get positions
+     * - filters.actualDateTo: filters by actual date to to get positions
+     * - filters.speedMin: filters by speed min to get positions
+     * - filters.speedMax: filters by speed max to get positions
+     * - filters.odometerMin: filters by odometer min to get positions
+     * - filters.odometerMax: filters by odometer max to get positions
+     * - pagingOptions.pageSize: the page size
+     * - pagingOptions.pageIndex: the page index
+     * - sortOptions.sortField: the sort field
+     * - sortOptions.sortOrder: the sort order
+     */
+    async getPositionsReportByClient(params) {
+        this.logger.trace(params, `PositionsRepository::getPositionsReportByClientId started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getPositionsReportByClient(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'PositionsRepository::getPositionsReportByClientId result');
+        return result;
+    }
+    async getLatestPositionByImei(params) {
+        this.logger.trace(params, `PositionsRepository::this.getLatestPositionByImei started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getLatestPositionByImei(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'PositionsRepository::getLatestPositionByImei result');
+        return result;
+    }
+}

package/dist/repositories/positions/upsertLatestPosition.js

@@ -0,0 +1,41 @@
+import { LatestPosition } from '../../entities';
+export const upsertLatestPosition = async (novaDataSource, position, logger) => {
+    if (!position?.id || !position?.imei) {
+        return false;
+    }
+    const latestPositionsRepository = novaDataSource.getRepository(LatestPosition);
+    try {
+        const { id, ...rest } = position;
+        const queryBuilder = latestPositionsRepository.createQueryBuilder();
+        const insertResult = await queryBuilder
+            .insert()
+            .into(LatestPosition)
+            .values({
+            ...rest,
+            positionId: id,
+        })
+            .orIgnore()
+            .execute();
+        if (insertResult.raw.affectedRows > 0) {
+            return true;
+        }
+        const updateResult = await queryBuilder
+            .update(LatestPosition)
+            .set({
+            ...rest,
+            positionId: id,
+        })
+            .where(`imei = :imei`, {
+            imei: position.imei,
+        })
+            .andWhere(`positionId < :positionId`, {
+            positionId: position.id,
+        })
+            .execute();
+        return updateResult.affected > 0;
+    }
+    catch (error) {
+        logger.warn(error, `PositionsRepository::upsertLatestPosition error`);
+        return false;
+    }
+};

package/dist/repositories/security/createUserRole.js

@@ -0,0 +1,30 @@
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserRole = async (novaDataSource, params, logger) => {
+    if (!params?.userId) {
+        logger.warn({ params }, 'SecurityRepository::createUserRole - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userRole = await userSecurityRolesRepository.findOne({
+            where: {
+                userId: uuidStringToBinaryBuffer(params.userId),
+            },
+        });
+        if (!userRole) {
+            const newUserRole = {
+                userId: uuidStringToBinaryBuffer(params.userId),
+                clientId: params.clientId,
+                securityRoleId: params.roleId,
+            };
+            return await userSecurityRolesRepository.save(newUserRole);
+        }
+        if (userRole.clientId === params.clientId && userRole.securityRoleId === params.roleId) {
+            return userRole; // nothing to create, role already exists
+        }
+        else {
+            throw new Error('User role cannot be created because another role already exists');
+        }
+    }, 'SecurityRepository::createUserRole');
+};

package/dist/repositories/security/getAllRoles.js

@@ -0,0 +1,8 @@
+import { SecurityRole } from '../../entities';
+export const getAllRoles = async (novaDataSource) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const rolesRepository = dataSource.getRepository(SecurityRole);
+        const roles = await rolesRepository.find();
+        return roles;
+    }, 'SecurityRepository::getAllRoles');
+};

package/dist/repositories/security/getUserRoles.js

@@ -0,0 +1,15 @@
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserRoles = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::getUserRoles - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userRoles = await userSecurityRolesRepository.find({
+            where: { userId: uuidStringToBinaryBuffer(params.filters.userId) },
+        });
+        return userRoles;
+    }, 'SecurityRepository::getUserRoles');
+};

package/dist/repositories/security/getUserRolesByClientId.js

@@ -0,0 +1,17 @@
+import { UserSecurityRole } from '../../entities';
+export const getUserRolesByClientId = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'SecurityRepository::getUserRolesByClientId - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const filterCondition = params.filters.role
+            ? { where: { clientId: params.filters.clientId, securityRoleId: params.filters.role } }
+            : {
+                where: { clientId: params.filters.clientId },
+            };
+        const userRoles = await userSecurityRolesRepository.find(filterCondition);
+        return userRoles;
+    }, 'SecurityRepository::getUserRolesByClientId');
+};

package/dist/repositories/security/index.js

@@ -0,0 +1,111 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserRole } from './createUserRole';
+import { getAllRoles } from './getAllRoles';
+import { getUserRoles } from './getUserRoles';
+import { getUserRolesByClientId } from './getUserRolesByClientId';
+import { removeUserRoles } from './removeUserRoles';
+import { updateUserRole } from './updateUserRole';
+import { userIsAdminOrOwner } from './userIsAdminOrOwner';
+import { userIsInRole } from './userIsInRole';
+export class SecurityRepository extends BaseRepository {
+    /**
+     * Get all security roles
+     */
+    async getAllRoles() {
+        this.logger.trace('SecurityRepository::getAllRoles started');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getAllRoles(novaDataSource);
+        this.logger.trace(result, 'SecurityRepository::getAllRoles result');
+        return result;
+    }
+    /**
+     * Get roles of the user
+     * @param  {GetUserRolesParams} params containing information to get roles of the user
+     * - filters.userId: The user id
+     */
+    async getUserRoles(params) {
+        this.logger.trace(params, 'SecurityRepository::getUserRoles started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserRoles(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'SecurityRepository::getUserRoles result');
+        return result;
+    }
+    /**
+     * Get user roles by clientId
+     * @param  {GetUserRolesByClientIdParams} params containing information to get user roles by clientId
+     * - filters.clientId: The client id
+     * - filters.role: The role to only obtain user roles with that role, optional
+     */
+    async getUserRolesByClientId(params) {
+        this.logger.trace(params, 'SecurityRepository::getUserRolesByClientId started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserRolesByClientId(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'SecurityRepository::getUserRolesByClientId result');
+        return result;
+    }
+    /**
+     * Whether the user is in role
+     * @param  {UserIsInRoleParams} params containing information to know if the user is in role
+     * - filters.userId: The user id
+     * - filters.role: The role to check if the user is in that role
+     */
+    async userIsInRole(params) {
+        this.logger.trace(params, 'SecurityRepository::userIsInRole started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await userIsInRole(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::userIsInRole result');
+        return result;
+    }
+    /**
+     * Whether the user is admin or owner
+     * @param  {UserIsAdminOrOwnerParams} params containing information to know if the user is admin or owner
+     * - filters.userId: The user id
+     */
+    async userIsAdminOrOwner(params) {
+        this.logger.trace(params, 'SecurityRepository::userIsAdminOrOwner started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await userIsAdminOrOwner(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::userIsAdminOrOwner result');
+        return result;
+    }
+    /**
+     * Create user role
+     * @param  {CreateUserRoleParams} params containing information to create user role
+     * - userId: The user id
+     * - clientId: The client id
+     * - roleId: The role to assign to the user
+     */
+    async createUserRole(params) {
+        this.logger.trace(params, 'SecurityRepository::createUserRole started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserRole(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'SecurityRepository::createUserRole result');
+        return result;
+    }
+    /**
+     * Update user role
+     * @param  {UpdateUserRoleParams} params containing information to update user role
+     * - filters.userId: The user id to update role
+     * - values.roleId: The role to assign to the user
+     */
+    async updateUserRole(params) {
+        this.logger.trace(params, 'SecurityRepository::updateUserRole started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserRole(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::updateUserRole result');
+        return result;
+    }
+    /**
+     * Remove user roles
+     * @param  {RemoveUserRolesParams} params containing information to remove user roles
+     * - filters.userId: The user id to remove roles from
+     */
+    async removeUserRoles(params) {
+        this.logger.trace(params, 'SecurityRepository::removeUserRoles started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await removeUserRoles(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::removeUserRoles result');
+        return result;
+    }
+}

package/dist/repositories/security/removeUserRoles.js

@@ -0,0 +1,21 @@
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const removeUserRoles = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::removeUserRoles - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userRoles = await userSecurityRolesRepository.find({
+            where: {
+                userId: uuidStringToBinaryBuffer(params.filters.userId),
+            },
+        });
+        if (!userRoles.length) {
+            return true; // nothing to remove
+        }
+        await userSecurityRolesRepository.remove(userRoles);
+        return true;
+    }, 'SecurityRepository::removeUserRoles');
+};

package/dist/repositories/security/updateUserRole.js

@@ -0,0 +1,27 @@
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserRole = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::updateUserRole - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userId = uuidStringToBinaryBuffer(params.filters.userId);
+        const userRole = await userSecurityRolesRepository.findOne({
+            where: {
+                userId,
+            },
+        });
+        if (!userRole) {
+            return false;
+        }
+        if (userRole.securityRoleId === params.values.roleId) {
+            return true; // nothing to update
+        }
+        const oldRoleId = userRole.securityRoleId;
+        userRole.securityRoleId = params.values.roleId;
+        const result = await userSecurityRolesRepository.update({ userId, securityRoleId: oldRoleId }, userRole);
+        return result.affected > 0;
+    }, 'SecurityRepository::updateUserRole');
+};

package/dist/repositories/security/userIsAdminOrOwner.js

@@ -0,0 +1,20 @@
+import { In } from 'typeorm';
+import { UserSecurityRole } from '../../entities';
+import { HapnSecurityRole } from '../../types/enums';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const userIsAdminOrOwner = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::userIsAdminOrOwner - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userRole = await userSecurityRolesRepository.findOne({
+            where: {
+                userId: uuidStringToBinaryBuffer(params.filters.userId),
+                securityRoleId: In([HapnSecurityRole.Admin, HapnSecurityRole.Owner]),
+            },
+        });
+        return userRole !== null;
+    }, 'SecurityRepository::userIsAdminOrOwner');
+};

package/dist/repositories/security/userIsInRole.js

@@ -0,0 +1,18 @@
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const userIsInRole = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::userIsInRole - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userRole = await userSecurityRolesRepository.findOne({
+            where: {
+                userId: uuidStringToBinaryBuffer(params.filters.userId),
+                securityRoleId: params.filters.role,
+            },
+        });
+        return userRole !== null;
+    }, 'SecurityRepository::userIsInRole');
+};

package/dist/repositories/tasks/addTaskScheduleDevices.js

@@ -0,0 +1,37 @@
+import { DeviceTask, TaskSchedule } from '../../entities';
+export const addTaskScheduleDevices = async (novaDataSource, params, logger) => {
+    if (!params?.taskScheduleId || !params?.imeis?.length) {
+        logger.error('TasksRepository::addTaskScheduleDevices - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskSchedulesRepository = dataSource.getRepository(TaskSchedule);
+        const existentTaskSchedule = await taskSchedulesRepository.findOne({
+            where: { id: params.taskScheduleId },
+        });
+        if (!existentTaskSchedule) {
+            return false;
+        }
+        const deviceTaskRepository = dataSource.getRepository(DeviceTask);
+        // We split the devices in groups of 50 to avoid having a query with too many items to insert
+        const maxDevicesPerQuery = 50;
+        const partitionedImeis = [];
+        for (let i = 0; i < params.imeis.length; i += maxDevicesPerQuery) {
+            partitionedImeis.push(params.imeis.slice(i, i + maxDevicesPerQuery));
+        }
+        for (const imeis of partitionedImeis) {
+            const deviceTasks = imeis.map(imei => ({
+                taskScheduleId: params.taskScheduleId,
+                imei,
+                clientId: existentTaskSchedule.clientId,
+            }));
+            const result = await deviceTaskRepository.upsert(deviceTasks, {
+                conflictPaths: ['taskScheduleId', 'imei'],
+            });
+            if (!result?.raw?.affectedRows) {
+                return false;
+            }
+        }
+        return true;
+    }, 'TasksRepository::addTaskScheduleDevices');
+};

package/dist/repositories/tasks/completeTask.js

@@ -0,0 +1,25 @@
+import { Task } from '../../entities';
+export const completeTask = async (novaDataSource, params, logger) => {
+    if (!params?.id || !params?.completedBy) {
+        logger.warn({ params }, 'TasksRepository::completeTask missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskRepository = dataSource.getRepository(Task);
+        const now = new Date();
+        const result = await taskRepository
+            .createQueryBuilder()
+            .update(Task)
+            .set({
+            status: 'completed',
+            completedBy: params.completedBy,
+            completedAt: now,
+            completionNotes: params.completionNotes,
+            completionOdometer: params.completionOdometer,
+            completionActiveHours: params.completionActiveHours,
+        })
+            .where('id = :id', { id: params.id })
+            .execute();
+        return result.affected > 0;
+    }, 'TasksRepository::completeTask');
+};

package/dist/repositories/tasks/createTask.js

@@ -0,0 +1,22 @@
+import { Task } from '../../entities';
+export const createTask = async (novaDataSource, params, logger) => {
+    if (!params?.taskScheduleId || !params?.imei || !params?.clientId) {
+        logger.warn({ params }, 'TasksRepository::createTask missing required parameters');
+        return null;
+    }
+    if (!params.dueDate && !params.dueOdometer && !params.dueActiveHours) {
+        logger.warn({ params }, 'TasksRepository::createTask missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const tasksRepository = dataSource.getRepository(Task);
+        const now = new Date();
+        const newTask = {
+            ...params,
+            createdAt: now,
+            status: 'pending',
+        };
+        const result = await tasksRepository.save(newTask);
+        return result;
+    }, 'TasksRepository::createTask');
+};

package/dist/repositories/tasks/createTaskSchedule.js

@@ -0,0 +1,33 @@
+import { TaskSchedule } from '../../entities';
+export const createTaskSchedule = async (novaDataSource, params, logger) => {
+    if (!params?.clientId ||
+        !params?.title ||
+        !params?.description ||
+        params?.repeats == null ||
+        !params?.createdBy) {
+        logger.warn({ params }, 'TasksRepository::createTaskSchedule missing required parameters');
+        return null;
+    }
+    if (!params.repeats && !params.dueDate && !params.dueOdometer && !params.dueActiveHours) {
+        logger.warn({ params }, 'TasksRepository::createTaskSchedule missing required parameters');
+        return null;
+    }
+    if (params.repeats &&
+        !params.intervalDays &&
+        !params.intervalOdometer &&
+        !params.intervalActiveHours) {
+        logger.warn({ params }, 'TasksRepository::createTaskSchedule missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskScheduleRepository = dataSource.getRepository(TaskSchedule);
+        const now = new Date();
+        const newTaskSchedule = {
+            ...params,
+            createdAt: now,
+            status: 'active',
+        };
+        const result = await taskScheduleRepository.save(newTaskSchedule);
+        return result;
+    }, 'TasksRepository::createTaskSchedule');
+};