Skip to content

TaskView is a self-hosted project and task management platform focused on clarity, ownership, and control. TaskView is built for teams that want a transparent, self-hosted alternative to SaaS task managers.

18.2 KB
Raw Blame
import type { TasksSchemaTypeForSelect } from 'taskview-db-schemas';
import type { AppUser } from '../../core/AppUser';
import { $logger } from '../../modules/logget';
import { eventBus } from '../../core/EventBus';
import { GoalPermissions } from '../../types/auth.types';
import type {
    AddTaskArg,
    FetchAssignedUsersArg,
    // FetchSubtasksArg,
    // FetchTaskHistoryArg,
    FetchTasksArg,
    MoveTaskArg,
    TaskDatesFromDb,
    TaskFetchTaskById,
    // TaskRecoverHistoryStateArg,
    TasksUpdateStatusId,
    TaskUpdateAmount,
    TaskUpdateOrders,
    TaskUpdateTransactionType,
    UpdatePriorityArg,
    UpdateTaskAssigneeArg,
    UpdateTaskCheckedArg,
    UpdateTaskDeadlineArg,
    UpdateTaskDescriptionArg,
    UpdateTaskNoteArg,
} from '../../types/tasks.types';
import { TaskItemForClient } from './TaskItemForClient';
import { TaskMovePlanner } from './TaskMovePlanner';
import { TaskMoveRepository } from './TaskMoveRepository';
import { TasksRepository } from './TasksRepository';
import type { TaskArgMove, TaskMoveOutcome, TaskMovePreviewDto } from './task-move.types';
import { FilesRepository } from '../files/FilesRepository';
import {
    type TaskAddResult,
    type TaskArgAdd,
    type TaskArgDelete,
    type TaskArgFetchTaskByIdNew,
    type TaskArgFetchTaskHistory,
    type TaskArgFetchTasksNew,
    type TaskArgRestoreTaskHistory,
    type TaskArgUpdate,
    type TaskForClientNew,
    type TaskUpdateResult,
    type TasksArgToggleTaskUsers,
} from './tasks.server.types';
import type { KanbanArgFetchTasksForColumn, KanbanArgFilters } from '../kanban/types';
import { hideUnwatchableTaskFields } from './task-field-visibility';

export class TasksManager {
    public readonly repository: TasksRepository;
    private readonly user: AppUser;

    constructor(user: AppUser) {
        this.user = user;
        this.repository = new TasksRepository();
    }

    /** @deprecated */
    async fetchTaskById(data: TaskFetchTaskById): Promise<TaskItemForClient | null> {
        const task = await this.repository.fetchTaskById(data.taskId);
        if (!task) return null;
        const tags = await this.repository.fetchTagsForTasks([task.id]);

        let tagIds: number[] = [];
        if (tags) {
            tagIds = tags.map((t) => t.tag_id);
        }

        return new TaskItemForClient(task, tagIds) ?? null;
    }

    /** @deprecated */
    async updateOrdersForTask(orderData: TaskUpdateOrders): Promise<boolean> {
        return this.repository.updateOrdersForTask(orderData);
    }

    /** @deprecated */
    async fetchAllTasks(data: FetchTasksArg): Promise<TaskItemForClient[]> {
        const tasks = await this.repository.fetchAllTasks(data);

        if (!tasks) {
            return [];
        }

        const tagsMap: Record<number, number[]> = {};
        const ids = tasks.map((t) => t.id);

        const tags = await this.repository.fetchTagsForTasks(ids);

        if (tags) {
            tags.forEach((item) => {
                if (!tagsMap[item.task_id]) {
                    tagsMap[item.task_id] = [];
                }
                tagsMap[item.task_id].push(item.tag_id);
            });
        }

        const assigneesMap: Record<number, number[]> = {};

        (await this.repository.fetchTaskAssigneeForTasks(ids)).forEach((a) => {
            if (!assigneesMap[a.task_id]) {
                assigneesMap[a.task_id] = [];
            }
            assigneesMap[a.task_id].push(a.collab_user_id);
        });

        const tasksForClient = tasks.map((t) => new TaskItemForClient(t, tagsMap[t.id], null, assigneesMap[t.id]));

        return tasksForClient;
    }

    async fetchTasks(data: FetchTasksArg): Promise<TaskItemForClient[]> {
        const tasks = await this.repository.fetchTasks(data);

        if (!tasks) {
            return [];
        }

        const tagsMap: Record<number, number[]> = {};
        const ids = tasks.map((t) => t.id);

        const tags = await this.repository.fetchTagsForTasks(ids);

        if (tags) {
            tags.forEach((item) => {
                if (!tagsMap[item.task_id]) {
                    tagsMap[item.task_id] = [];
                }
                tagsMap[item.task_id].push(item.tag_id);
            });
        }

        const assigneesMap: Record<number, number[]> = {};

        (await this.repository.fetchTaskAssigneeForTasks(ids)).forEach((a) => {
            if (!assigneesMap[a.task_id]) {
                assigneesMap[a.task_id] = [];
            }
            assigneesMap[a.task_id].push(a.collab_user_id);
        });

        const tasksForClient = tasks.map((t) => new TaskItemForClient(t, tagsMap[t.id], null, assigneesMap[t.id]));

        return tasksForClient;
    }

    async addTask(arg: AddTaskArg): Promise<TaskItemForClient | false> {
        const task = await this.repository.addTask(arg, this.user.getUserData()?.id as number);

        if (!task) {
            return false;
        }

        return new TaskItemForClient(task);
    }

    async updateChecked(arg: UpdateTaskCheckedArg): Promise<TaskItemForClient | false> {
        const task = await this.repository.updateTaskComplete(arg.taskId, arg.complete);

        if (!task) return false;

        // Sync task completion state to linked GitHub/GitLab issue
        this.user.integrationsManager.onTaskCompleteChanged(arg.taskId, arg.complete).catch(() => { });

        return new TaskItemForClient(task);
    }

    /** @deprecated use deleteTaskNew instead */
    async deleteTask(taskId: number): Promise<boolean> {
        return await this.repository.deleteTask(taskId);
    }

    async updateDescription(arg: UpdateTaskDescriptionArg) {
        const task = await this.repository.updateTaskDescription(arg.taskId, arg.description);

        if (!task) {
            return false;
        }

        return new TaskItemForClient(task);
    }

    async updateTaskNote(arg: UpdateTaskNoteArg): Promise<boolean> {
        return await this.repository.updateTaskNote(arg.taskId, arg.note);
    }

    async updateDeadline(data: UpdateTaskDeadlineArg): Promise<TaskDatesFromDb | false> {
        const result = await this.repository.updateTaskDate(data.taskId, data.data, data.status);
        if (!result) {
            $logger.error(data, `Can not update task dates`);
        }
        return await this.repository.getTaskDeadlineDates(data.taskId);
    }

    // /** @deprecated */
    // async fetchSubtasks(data: FetchSubtasksArg): Promise<TaskItemForClient[]> {
    //     const subtasks = await this.repository.fetchSubtasks(data.taskId);
    //     return subtasks.map((t) => new TaskItemForClient(t));
    // }

    async updatePriority(data: UpdatePriorityArg): Promise<boolean> {
        return await this.repository.updatePriority(data.taskId, data.priorityId);
    }

    async moveTask(data: MoveTaskArg): Promise<boolean> {
        if (data.listId !== null) {
            const listIds = await this.repository.fetchAllowedListIdsForTask(data.taskId);
            if (!listIds.includes(data.listId)) return false;
        }

        return await this.repository.moveTask(data.taskId, data.listId);
    }

    async fetchAssignedUsers(data: FetchAssignedUsersArg) {
        return await this.repository.fetchTaskAssignee(data.taskId);
    }

    async fetchTaskHistory(
        data: TaskArgFetchTaskHistory
    ): Promise<(TasksSchemaTypeForSelect & { historyId: number | null })[]> {
        const history = await this.repository.fetchTaskHistory(data.taskId);

        if (!history || history.length === 0) return [];

        const toCamel = (str: string) => str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());

        const normalizeKeys = <T extends object>(obj: T): any =>
            Object.fromEntries(
                Object.entries(obj).map(([k, v]) => [toCamel(k), v && typeof v === 'object' ? normalizeKeys(v) : v])
            );

        const normalizedHistory: (TasksSchemaTypeForSelect & { historyId: number | null })[] = history.map((item) => {
            return normalizeKeys({ ...item.task, history_id: item.history_id });
        });

        return normalizedHistory;
    }

    async recoverTaskHistory(data: TaskArgRestoreTaskHistory) {
        return await this.repository.recoveryTaskHistory(data.historyId, data.taskId);
    }

    async updateTaskAssignee(data: UpdateTaskAssigneeArg) {
        const result = await this.repository.updateTaskAssignee(data.taskId, data.usersIds);
        if (!result) {
            $logger.error('Can not update task assignee');
            return false;
        }
        return data.usersIds;
    }

    async updateTaskStatusId(data: TasksUpdateStatusId): Promise<boolean> {
        const result = await this.repository.updateTaskStatusId(data);
        if (!result) {
            $logger.error(`Can not update task statusId ${data}`);
        }
        return result;
    }

    async updateAmount(data: TaskUpdateAmount): Promise<boolean> {
        return await this.repository.updateAmount(data);
    }

    async updateTransactionType(data: TaskUpdateTransactionType): Promise<boolean> {
        return await this.repository.updateTransactionType(data);
    }

    async updateTask(data: TaskArgUpdate): Promise<TaskUpdateResult> {
        const currentTask = await this.repository.fetchTaskByIdNew(data.id);
        if (!currentTask) return { ok: false, reason: 'not_found' };

        const foreign = await this.repository.referencesOutsideGoal({
            taskId: data.id,
            goalId: currentTask.goalId,
            goalListId: data.goalListId,
            statusId: data.statusId,
            parentId: data.parentId,
        });
        if (foreign) return { ok: false, reason: 'foreign_reference' };

        if (data.statusId !== undefined && currentTask.statusId !== data.statusId) {
            data.kanbanOrder = await this.repository.getNextKanbanOrder(currentTask.goalId);
        }

        const task = await this.repository.updateTask(data);
        if (!task) return { ok: false, reason: 'not_found' };

        let syncFailed = false;
        if (data.complete !== undefined) {
            const synced = await this.user.integrationsManager.onTaskCompleteChanged(data.id, data.complete).catch(() => false);
            if (!synced) syncFailed = true;
        }

        const { id, ...changes } = data;
        eventBus.emit('task.updated', {
            task,
            changes,
            initiatorId: this.user.getUserData()?.id as number,
        });

        const tasks = await this.extendTasksWithTagsAndAssignees([task]);
        const result = tasks[0] ?? null;
        if (!result) return { ok: false, reason: 'not_found' };
        return { ok: true, task: result, syncFailed: syncFailed || undefined };
    }

    async fetchTasksNew(data: TaskArgFetchTasksNew) {
        const tasks = await this.repository.fetch(data);
        if (!tasks) return [];
        return await this.extendTasksWithTagsAndAssignees(tasks);
    }

    async fetchTaskByIdNew(data: TaskArgFetchTaskByIdNew) {
        const task = await this.repository.fetchTaskByIdNew(data.taskId);
        if (!task) return null;
        const extendedTask = await this.extendTasksWithTagsAndAssignees([task]);
        return extendedTask[0] ?? null;
    }

    /** Public: other modules returning task rows (e.g. recurrence) gate fields through the same cleaner. */
    async cleanTaskFieldsRegardPermissions(task: TasksSchemaTypeForSelect): Promise<TasksSchemaTypeForSelect> {
        const checker = await this.user.permissionsFetcher.getCheckerForGoal(task.goalId);
        return hideUnwatchableTaskFields({ task, checker });
    }

    /**
     * //TODO CHECK PERMISSIONS FOR ALL FIELDS OF TASK
     * Extend tasks with tags and assignees
     * @param tasks
     * @returns
     */
    async extendTasksWithTagsAndAssignees(
        tasks: TasksSchemaTypeForSelect[],
        justCreated: boolean = false
    ): Promise<TaskForClientNew[]> {
        if (!tasks || tasks.length === 0) {
            return [];
        }

        if (justCreated) {
            // TODO check permissions for task field here
            return await Promise.all(
                tasks.map(async (t) => ({
                    ...(await this.cleanTaskFieldsRegardPermissions(t)),
                    tags: [],
                    assignedUsers: [],
                    historyId: null,
                    subtasks: [],
                    filesCount: 0,
                }))
            );
        }

        const tagsMap = new Map<number, number[]>();
        const assigneesMap = new Map<number, number[]>();
        const ids = tasks.map((t) => t.id);

        const taskPermissions = await this.user.permissionsFetcher.getCheckerForGoal(tasks[0].goalId);

        const [tags, assignees, filesCount] = await Promise.all([
            taskPermissions.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_TAGS)
                ? this.repository.fetchTagsForTasks(ids)
                : Promise.resolve([]),
            taskPermissions.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_ASSIGNED_USERS)
                ? this.repository.fetchTaskAssigneeForTasks(ids)
                : Promise.resolve([]),
            taskPermissions.hasPermissions(GoalPermissions.FILE_CAN_VIEW)
                ? new FilesRepository().countForTasks(ids)
                : Promise.resolve(new Map<number, number>()),
        ]);

        tags.forEach((item) => {
            if (!tagsMap.get(item.task_id)) {
                tagsMap.set(item.task_id, []);
            }
            tagsMap.get(item.task_id)?.push(item.tag_id);
        });

        assignees.forEach((a) => {
            if (!assigneesMap.get(a.task_id)) {
                assigneesMap.set(a.task_id, []);
            }
            assigneesMap.get(a.task_id)?.push(a.collab_user_id);
        });

        return await Promise.all(
            tasks.map(async (t) => ({
                ...(await this.cleanTaskFieldsRegardPermissions(t)),
                tags: tagsMap.get(t.id) || [],
                assignedUsers: assigneesMap.get(t.id) || [],
                historyId: null,
                filesCount: filesCount.get(t.id) ?? 0,
                //subtasks should be without subtasks, tags and assignees
                subtasks: await this.extendTasksWithTagsAndAssignees(
                    taskPermissions.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_SUBTASKS)
                        ? await this.repository.fetchSubtasks(t.id)
                        : await Promise.resolve([]),
                    true
                ),
            }))
        );
    }

    async addTaskNew(data: TaskArgAdd): Promise<TaskAddResult> {
        // The caller is authorized on data.goalId only; a DB trigger would otherwise move the task into the list's project
        const foreign = await this.repository.referencesOutsideGoal({
            taskId: null,
            goalId: data.goalId,
            goalListId: data.goalListId,
            statusId: data.statusId,
            parentId: data.parentId,
        });
        if (foreign) return { ok: false, reason: 'foreign_reference' };

        const newData = { ...data };

        if (data.kanbanOrder === null || data.kanbanOrder === undefined) {
            newData.kanbanOrder = await this.repository.getNextKanbanOrder(data.goalId, data.statusId ?? null);
        }

        const task = await this.repository.addTaskNew({
            data: newData,
            creatorId: this.user.getUserData()?.id as number,
        });
        const result = await this.extendTasksWithTagsAndAssignees(task, true);

        if (task[0]) {
            eventBus.emit('task.created', {
                task: task[0],
                initiatorId: this.user.getUserData()?.id as number,
            });
        }

        return { ok: true, tasks: result };
    }

    async deleteTaskNew(data: TaskArgDelete) {
        const task = await this.repository.fetchTaskByIdNew(data.taskId);
        const result = await this.repository.deleteTaskNew(data);
        if (result) {
            eventBus.emit('task.deleted', { taskId: data.taskId, goalId: task?.goalId ?? 0, initiatorId: this.user.getUserData()?.id as number });
        }
        return result;
    }

    async toggleTaskUsers(data: TasksArgToggleTaskUsers) {
        const result = await this.repository.toggleTaskUsers(data);
        eventBus.emit('task.assigneesChanged', {
            taskId: data.taskId,
            userIds: data.userIds,
            initiatorId: this.user.getUserData()?.id as number,
        });
        return result;
    }

    async previewMoveToProject(args: TaskArgMove): Promise<TaskMovePreviewDto> {
        const planner = this.movePlanner();
        return planner.toPreview(await planner.plan(args));
    }

    async moveToProject(args: TaskArgMove): Promise<TaskMoveOutcome> {
        const decision = await this.movePlanner().plan(args);
        if (!decision.ok) return decision;
        const { plan } = decision;
        const initiatorId = this.user.getUserData()?.id as number;
        const repository = new TaskMoveRepository();

        if (plan.mode === 'copy') {
            const copy = await repository.executeCopy({ plan, creatorId: initiatorId });
            for (const task of copy.tasks) eventBus.emit('task.created', { task, initiatorId });
            return { ok: true, data: { mode: 'copy', taskId: copy.rootTaskId, goalId: plan.targetGoalId } };
        }

        const task = await repository.executeMove({ plan });
        if (!task) return { ok: false, reason: 'not_found' };
        eventBus.emit('task.moved', { task, taskIds: plan.taskIds, fromGoalId: plan.sourceGoalId, toGoalId: plan.targetGoalId, initiatorId });
        return { ok: true, data: { mode: 'move', taskId: task.id, goalId: plan.targetGoalId } };
    }

    private movePlanner(): TaskMovePlanner {
        return new TaskMovePlanner({
            repository: new TaskMoveRepository(),
            userId: this.user.getUserData()?.id as number,
            checkerForGoal: (goalId) => this.user.permissionsFetcher.getCheckerForGoal(goalId),
        });
    }

    async fetchTasksForKanbanColumn(data: KanbanArgFetchTasksForColumn & { filters?: KanbanArgFilters }): Promise<{ tasks: TaskForClientNew[], nextCursor: string | number | null }> {
        const tasks = await this.repository.fetchTasksForKanbanColumn(data.goalId, data.columnId, data.cursor, data.filters);
        if (!tasks || tasks.length === 0) return { tasks: [], nextCursor: null };
        return { tasks: await this.extendTasksWithTagsAndAssignees(tasks), nextCursor: tasks[tasks.length - 1].kanbanOrder };
    }
}