@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/tasks/deleteTask.js

@@ -0,0 +1,22 @@
+import { Task } from '../../entities';
+export const deleteTask = async (novaDataSource, params, logger) => {
+    if (!params?.id || !params?.deletedBy) {
+        logger.warn({ params }, 'TasksRepository::deleteTask 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: 'deleted',
+            deletedBy: params.deletedBy,
+            deletedAt: now,
+        })
+            .where('id = :id', { id: params.id })
+            .execute();
+        return result.affected > 0;
+    }, 'TasksRepository::deleteTask');
+};

package/dist/repositories/tasks/deleteTaskSchedule.js

@@ -0,0 +1,22 @@
+import { TaskSchedule } from '../../entities';
+export const deleteTaskSchedule = async (novaDataSource, params, logger) => {
+    if (!params?.id || !params?.deletedBy) {
+        logger.warn({ params }, 'TasksRepository::deleteTaskSchedule missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskScheduleRepository = dataSource.getRepository(TaskSchedule);
+        const now = new Date();
+        const result = await taskScheduleRepository
+            .createQueryBuilder()
+            .update(TaskSchedule)
+            .set({
+            status: 'deleted',
+            deletedBy: params.deletedBy,
+            deletedAt: now,
+        })
+            .where('id = :id', { id: params.id })
+            .execute();
+        return result.affected > 0;
+    }, 'TasksRepository::deleteTaskSchedule');
+};

package/dist/repositories/tasks/deleteTaskScheduleDevices.js

@@ -0,0 +1,17 @@
+import { DeviceTask } from '../../entities';
+export const deleteTaskScheduleDevices = async (novaDataSource, params, logger) => {
+    if (!params?.taskScheduleId || !params?.imeis?.length) {
+        logger.error('TasksRepository::deleteTaskScheduleDevices - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceTaskRepository = dataSource.getRepository(DeviceTask);
+        const result = await deviceTaskRepository
+            .createQueryBuilder()
+            .delete()
+            .where('taskScheduleId = :taskScheduleId', { taskScheduleId: params.taskScheduleId })
+            .andWhere('imei IN (:...imeis)', { imeis: params.imeis })
+            .execute();
+        return result?.affected > 0;
+    }, 'TasksRepository::deleteTaskScheduleDevices');
+};

package/dist/repositories/tasks/getDeviceTasks.js

@@ -0,0 +1,28 @@
+import { DeviceTask } from '../../entities';
+export const getDeviceTasks = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.taskScheduleId && !params?.filters?.imei && !params?.filters?.clientId) {
+        logger.warn({ params }, 'TasksRepository::getDeviceTasks missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const deviceTaskRepository = dataSource.getRepository(DeviceTask);
+        let queryBuilder = deviceTaskRepository.createQueryBuilder('deviceTask');
+        if (params.filters.taskScheduleId) {
+            queryBuilder = queryBuilder.where('deviceTask.taskScheduleId = :taskScheduleId', {
+                taskScheduleId: params.filters.taskScheduleId,
+            });
+        }
+        if (params.filters.imei) {
+            queryBuilder = queryBuilder.andWhere('deviceTask.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.andWhere('deviceTask.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'TasksRepository::getDeviceTasks');
+};

package/dist/repositories/tasks/getTaskSchedule.js

@@ -0,0 +1,31 @@
+import { DeviceTask, TaskSchedule } from '../../entities';
+export const getTaskSchedule = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'TasksRepository::getTaskSchedule missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskScheduleRepository = dataSource.getRepository(TaskSchedule);
+        const result = await taskScheduleRepository
+            .createQueryBuilder('taskSchedule')
+            .where('taskSchedule.id = :id', { id: params.filters.id })
+            .getOne();
+        if (params.projectionOptions?.numberOfDevicesToGet > 0 && result) {
+            const deviceTaskRepository = dataSource.getRepository(DeviceTask);
+            const deviceTasks = await deviceTaskRepository
+                .createQueryBuilder('deviceTask')
+                .where('deviceTask.taskScheduleId = :taskScheduleId', { taskScheduleId: result.id })
+                .limit(params.projectionOptions.numberOfDevicesToGet)
+                .getMany();
+            result.deviceTasks = deviceTasks;
+            const totalDevicesCount = await deviceTaskRepository
+                .createQueryBuilder('deviceTask')
+                .select('deviceTask.taskScheduleId', 'taskScheduleId')
+                .addSelect('COUNT(*)', 'deviceCount')
+                .groupBy('deviceTask.taskScheduleId')
+                .getRawOne();
+            result.totalDevicesCount = totalDevicesCount ? totalDevicesCount.deviceCount : 0;
+        }
+        return result;
+    }, 'TasksRepository::getTaskSchedule');
+};

package/dist/repositories/tasks/getTaskSchedules.js

@@ -0,0 +1,75 @@
+import { DeviceTask, TaskSchedule } from '../../entities';
+import { anyAttributeHasValue } from '../../utils/anyAttributeHasValue';
+import { addFilters, getTaskSchedulesFilterMapping } from '../../utils/filterTools';
+const getDeviceTasksForTaskSchedules = async (taskSchedulesIds, numberOfDevicesToGet, dataSource) => {
+    const result = taskSchedulesIds.map(id => ({
+        id,
+        deviceTasks: [],
+        deviceCount: 0,
+    }));
+    const deviceTaskRepository = dataSource.getRepository(DeviceTask);
+    const deviceTaskQueryBuilder = deviceTaskRepository
+        .createQueryBuilder('deviceTask')
+        .where('deviceTask.taskScheduleId IN (:...taskSchedulesIds)', {
+        taskSchedulesIds,
+    })
+        .andWhere(`(deviceTask.taskScheduleId, deviceTask.imei) in (
+          select taskScheduleId, imei from 
+          (
+            select dt.*, ROW_NUMBER() over (partition by dt.taskScheduleId order by dt.taskScheduleId) as row_rank
+            from deviceTask dt 
+          ) sub
+          where sub.row_rank <= ${numberOfDevicesToGet}
+        )`);
+    const deviceTasks = await deviceTaskQueryBuilder.getMany();
+    // get total devices count
+    const devicesCount = await deviceTaskRepository
+        .createQueryBuilder('deviceTask')
+        .select('deviceTask.taskScheduleId as taskScheduleId')
+        .addSelect('COUNT(deviceTask.taskScheduleId)', 'deviceCount')
+        .where('deviceTask.taskScheduleId IN (:...taskSchedulesIds)', {
+        taskSchedulesIds,
+    })
+        .groupBy('deviceTask.taskScheduleId')
+        .getRawMany();
+    for (const item of result) {
+        item.deviceTasks = deviceTasks.filter(deviceTask => deviceTask.taskScheduleId === item.id);
+        item.deviceCount =
+            devicesCount.find(devicesCount => devicesCount.taskScheduleId === item.id)?.deviceCount ?? 0;
+    }
+    return result;
+};
+export const getTaskSchedules = async (novaDataSource, params, logger) => {
+    if (!anyAttributeHasValue(params?.filters)) {
+        logger.warn({ params }, 'TasksRepository::getTaskSchedules missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskScheduleRepository = dataSource.getRepository(TaskSchedule);
+        let queryBuilder = taskScheduleRepository.createQueryBuilder('taskSchedule');
+        if (params.filters.imei) {
+            queryBuilder = queryBuilder
+                .innerJoin(DeviceTask, 'dt', 'taskSchedule.id = dt.taskScheduleId')
+                .andWhere('dt.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        queryBuilder = addFilters(queryBuilder, params.filters, getTaskSchedulesFilterMapping, 'taskSchedule');
+        const sortField = params.sortOptions?.sortField ?? 'id';
+        const sortOrder = params.sortOptions?.sortOrder ?? 'DESC';
+        queryBuilder = queryBuilder.orderBy(`taskSchedule.${sortField}`, sortOrder);
+        const result = await queryBuilder
+            .limit(params?.pagingOptions?.pageSize ?? 100)
+            .offset((params?.pagingOptions?.pageSize ?? 100) * (params?.pagingOptions?.pageIndex ?? 0))
+            .getMany();
+        if (params.projectionOptions?.numberOfDevicesToGet > 0) {
+            const items = await getDeviceTasksForTaskSchedules(result.map(taskSchedule => taskSchedule.id), params.projectionOptions.numberOfDevicesToGet, dataSource);
+            for (const taskSchedule of result) {
+                const filteredItems = items.filter(item => item.id === taskSchedule.id);
+                taskSchedule.deviceTasks = filteredItems.length ? filteredItems[0].deviceTasks : [];
+                taskSchedule.totalDevicesCount = filteredItems.length ? filteredItems[0].deviceCount : 0;
+            }
+        }
+        return result;
+    }, 'TasksRepository::getTaskSchedules');
+};

package/dist/repositories/tasks/getTaskSchedulesCount.js

@@ -0,0 +1,23 @@
+import { DeviceTask, TaskSchedule } from '../../entities';
+import { anyAttributeHasValue } from '../../utils/anyAttributeHasValue';
+import { addFilters, getTaskSchedulesFilterMapping } from '../../utils/filterTools';
+export const getTaskSchedulesCount = async (novaDataSource, params, logger) => {
+    if (!anyAttributeHasValue(params?.filters)) {
+        logger.warn({ params }, 'TasksRepository::getTaskSchedulesCount missing required parameters');
+        return -1;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskScheduleRepository = dataSource.getRepository(TaskSchedule);
+        let queryBuilder = taskScheduleRepository.createQueryBuilder('taskSchedule');
+        if (params.filters.imei) {
+            queryBuilder = queryBuilder
+                .innerJoin(DeviceTask, 'dt', 'taskSchedule.id = dt.taskScheduleId')
+                .andWhere('dt.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        queryBuilder = addFilters(queryBuilder, params.filters, getTaskSchedulesFilterMapping, 'taskSchedule');
+        const result = await queryBuilder.getCount();
+        return result;
+    }, 'TasksRepository::getTaskSchedulesCount');
+};

package/dist/repositories/tasks/getTasks.js

@@ -0,0 +1,29 @@
+import { Task } from '../../entities';
+import { anyAttributeHasValue } from '../../utils/anyAttributeHasValue';
+import { addFilters, tasksFilterMapping, tasksFilterMappingWithSchedule, } from '../../utils/filterTools';
+export const getTasks = async (novaDataSource, params, logger) => {
+    if (!anyAttributeHasValue(params?.filters)) {
+        logger.warn({ params }, 'TasksRepository::getTasks missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskRepository = dataSource.getRepository(Task);
+        let queryBuilder = taskRepository.createQueryBuilder('task');
+        if (params.projectionOptions?.includeTaskSchedule) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('task.taskSchedule', 'taskSchedule');
+        }
+        else if (params.filters.title || params.filters.description) {
+            queryBuilder = queryBuilder.innerJoin('task.taskSchedule', 'taskSchedule');
+        }
+        queryBuilder = addFilters(queryBuilder, params.filters, tasksFilterMapping, 'task');
+        queryBuilder = addFilters(queryBuilder, params.filters, tasksFilterMappingWithSchedule, 'taskSchedule');
+        const sortField = params.sortOptions?.sortField ?? 'id';
+        const sortOrder = params.sortOptions?.sortOrder ?? 'DESC';
+        queryBuilder = queryBuilder.orderBy(`task.${sortField}`, sortOrder);
+        const result = await queryBuilder
+            .limit(params?.pagingOptions?.pageSize ?? 100)
+            .offset((params?.pagingOptions?.pageSize ?? 100) * (params?.pagingOptions?.pageIndex ?? 0))
+            .getMany();
+        return result;
+    }, 'TasksRepository::getTasks');
+};

package/dist/repositories/tasks/getTasksCount.js

@@ -0,0 +1,20 @@
+import { Task } from '../../entities';
+import { anyAttributeHasValue } from '../../utils/anyAttributeHasValue';
+import { addFilters, tasksFilterMapping, tasksFilterMappingWithSchedule, } from '../../utils/filterTools';
+export const getTasksCount = async (novaDataSource, params, logger) => {
+    if (!anyAttributeHasValue(params?.filters)) {
+        logger.warn({ params }, 'TasksRepository::getTasksCount missing required parameters');
+        return -1;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const taskRepository = dataSource.getRepository(Task);
+        let queryBuilder = taskRepository.createQueryBuilder('task');
+        if (params.filters.title || params.filters.description) {
+            queryBuilder = queryBuilder.innerJoin('task.taskSchedule', 'taskSchedule');
+        }
+        queryBuilder = addFilters(queryBuilder, params.filters, tasksFilterMapping, 'task');
+        queryBuilder = addFilters(queryBuilder, params.filters, tasksFilterMappingWithSchedule, 'taskSchedule');
+        const result = await queryBuilder.getCount();
+        return result;
+    }, 'TasksRepository::getTasksCount');
+};