439 lines
14 KiB
JavaScript
439 lines
14 KiB
JavaScript
const { Task, Tag, Project, sequelize } = require('../../../models');
|
|
const { Op, QueryTypes } = require('sequelize');
|
|
const permissionsService = require('../../../services/permissionsService');
|
|
const {
|
|
getSafeTimezone,
|
|
getUpcomingRangeInUTC,
|
|
getTodayBoundsInUTC,
|
|
} = require('../../../utils/timezone-utils');
|
|
|
|
async function filterTasksByParams(
|
|
params,
|
|
userId,
|
|
userTimezone,
|
|
permissionCache = null
|
|
) {
|
|
const ownedOrShared = await permissionsService.ownershipOrPermissionWhere(
|
|
'task',
|
|
userId,
|
|
permissionCache
|
|
);
|
|
if (params.type === 'upcoming') {
|
|
params = { ...params };
|
|
delete params.search;
|
|
}
|
|
let whereClause = {
|
|
parent_task_id: null,
|
|
};
|
|
|
|
whereClause[Op.or] = [
|
|
{
|
|
[Op.and]: [
|
|
{
|
|
[Op.or]: [
|
|
{ recurrence_type: 'none' },
|
|
{ recurrence_type: null },
|
|
],
|
|
},
|
|
{ recurring_parent_id: null },
|
|
],
|
|
},
|
|
{
|
|
[Op.and]: [
|
|
{ recurrence_type: { [Op.ne]: 'none' } },
|
|
{ recurrence_type: { [Op.ne]: null } },
|
|
{ recurring_parent_id: null },
|
|
{
|
|
[Op.or]: [
|
|
{ due_date: null },
|
|
{
|
|
due_date: {
|
|
[Op.gte]: new Date(
|
|
new Date().setHours(0, 0, 0, 0)
|
|
),
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
[Op.and]: [
|
|
{ recurring_parent_id: { [Op.ne]: null } },
|
|
{
|
|
[Op.or]: [
|
|
{ due_date: null },
|
|
{
|
|
due_date: {
|
|
[Op.gte]: new Date(
|
|
new Date().setHours(0, 0, 0, 0)
|
|
),
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
];
|
|
let includeClause = [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name', 'uid'],
|
|
through: { attributes: [] },
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'status', 'uid'],
|
|
required: false,
|
|
},
|
|
{
|
|
model: Task,
|
|
as: 'Subtasks',
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name', 'uid'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
],
|
|
required: false,
|
|
},
|
|
];
|
|
|
|
switch (params.type) {
|
|
case 'today': {
|
|
const safeTimezone = getSafeTimezone(userTimezone);
|
|
const todayBounds = getTodayBoundsInUTC(safeTimezone);
|
|
|
|
// Tasks in today view are those with active statuses (in_progress, planned, waiting)
|
|
const todayPlanStatuses = [
|
|
Task.STATUS.IN_PROGRESS,
|
|
Task.STATUS.WAITING,
|
|
Task.STATUS.PLANNED,
|
|
'in_progress',
|
|
'waiting',
|
|
'planned',
|
|
];
|
|
|
|
whereClause[Op.or] = [
|
|
{
|
|
// Non-recurring tasks with active status
|
|
[Op.and]: [
|
|
{
|
|
[Op.or]: [
|
|
{ recurrence_type: 'none' },
|
|
{ recurrence_type: null },
|
|
],
|
|
},
|
|
{ recurring_parent_id: null },
|
|
{ status: { [Op.in]: todayPlanStatuses } },
|
|
],
|
|
},
|
|
{
|
|
// Recurring parent tasks with active status
|
|
[Op.and]: [
|
|
{ recurrence_type: { [Op.ne]: 'none' } },
|
|
{ recurrence_type: { [Op.ne]: null } },
|
|
{ recurring_parent_id: null },
|
|
{ status: { [Op.in]: todayPlanStatuses } },
|
|
],
|
|
},
|
|
{
|
|
// Recurring instances due today
|
|
[Op.and]: [
|
|
{ recurring_parent_id: { [Op.ne]: null } },
|
|
{
|
|
due_date: {
|
|
[Op.between]: [
|
|
todayBounds.start,
|
|
todayBounds.end,
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
];
|
|
break;
|
|
}
|
|
case 'upcoming': {
|
|
const safeTimezone = getSafeTimezone(userTimezone);
|
|
const upcomingRange = getUpcomingRangeInUTC(safeTimezone, 7);
|
|
|
|
whereClause = {
|
|
parent_task_id: null,
|
|
[Op.or]: [
|
|
{
|
|
// Non-recurring tasks with due dates in the next 7 days
|
|
[Op.and]: [
|
|
{ recurring_parent_id: null },
|
|
{
|
|
[Op.or]: [
|
|
{ recurrence_type: 'none' },
|
|
{ recurrence_type: null },
|
|
],
|
|
},
|
|
{
|
|
due_date: {
|
|
[Op.between]: [
|
|
upcomingRange.start,
|
|
upcomingRange.end,
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
{
|
|
// Non-recurring tasks with defer_until dates in the next 7 days
|
|
[Op.and]: [
|
|
{ recurring_parent_id: null },
|
|
{
|
|
[Op.or]: [
|
|
{ recurrence_type: 'none' },
|
|
{ recurrence_type: null },
|
|
],
|
|
},
|
|
{
|
|
defer_until: {
|
|
[Op.between]: [
|
|
upcomingRange.start,
|
|
upcomingRange.end,
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
{
|
|
// All recurring parent tasks
|
|
[Op.and]: [
|
|
{ recurring_parent_id: null },
|
|
{ recurrence_type: { [Op.ne]: 'none' } },
|
|
{ recurrence_type: { [Op.ne]: null } },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
if (params.status === 'done' || params.status === 'completed') {
|
|
whereClause.status = {
|
|
[Op.in]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
};
|
|
} else if (params.status === 'active') {
|
|
whereClause.status = {
|
|
[Op.notIn]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
};
|
|
} else if (!params.client_side_filtering) {
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
}
|
|
break;
|
|
}
|
|
case 'next':
|
|
whereClause.due_date = null;
|
|
whereClause.project_id = null;
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
break;
|
|
case 'inbox':
|
|
whereClause[Op.or] = [{ due_date: null }, { project_id: null }];
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
break;
|
|
case 'someday':
|
|
whereClause.recurring_parent_id = null;
|
|
whereClause.due_date = null;
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
break;
|
|
case 'waiting':
|
|
whereClause.status = Task.STATUS.WAITING;
|
|
break;
|
|
case 'all':
|
|
if (params.status === 'done' || params.status === 'completed') {
|
|
whereClause.status = {
|
|
[Op.in]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
};
|
|
} else if (params.status === 'active') {
|
|
whereClause.status = {
|
|
[Op.notIn]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
};
|
|
} else if (!params.client_side_filtering) {
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
}
|
|
break;
|
|
default:
|
|
if (!params.include_instances) {
|
|
whereClause.recurring_parent_id = null;
|
|
}
|
|
if (params.status === 'done' || params.status === 'completed') {
|
|
whereClause.status = {
|
|
[Op.in]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
};
|
|
} else if (params.status === 'active') {
|
|
whereClause.status = {
|
|
[Op.notIn]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
};
|
|
} else if (!params.client_side_filtering) {
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
}
|
|
}
|
|
|
|
let tagFilteredTaskIds = null;
|
|
|
|
if (params.priority) {
|
|
whereClause.priority = Task.getPriorityValue(params.priority);
|
|
}
|
|
|
|
let orderClause = [['created_at', 'DESC']];
|
|
|
|
if (params.type === 'inbox') {
|
|
orderClause = [['created_at', 'DESC']];
|
|
}
|
|
|
|
if (params.order_by) {
|
|
const [orderColumn, orderDirection = 'asc'] =
|
|
params.order_by.split(':');
|
|
const allowedColumns = [
|
|
'created_at',
|
|
'updated_at',
|
|
'name',
|
|
'priority',
|
|
'status',
|
|
'due_date',
|
|
'completed_at',
|
|
];
|
|
|
|
if (!allowedColumns.includes(orderColumn)) {
|
|
throw new Error('Invalid order column specified.');
|
|
}
|
|
|
|
if (orderColumn === 'due_date') {
|
|
orderClause = [
|
|
[
|
|
sequelize.literal(
|
|
'CASE WHEN Task.due_date IS NULL THEN 1 ELSE 0 END'
|
|
),
|
|
'ASC',
|
|
],
|
|
['due_date', orderDirection.toUpperCase()],
|
|
];
|
|
} else {
|
|
orderClause = [[orderColumn, orderDirection.toUpperCase()]];
|
|
}
|
|
}
|
|
|
|
if (params.tag) {
|
|
const taggedTaskIds = await sequelize.query(
|
|
`SELECT DISTINCT tasks_tags.task_id
|
|
FROM tasks_tags
|
|
INNER JOIN tags ON tags.id = tasks_tags.tag_id
|
|
WHERE tags.name = :tagName`,
|
|
{
|
|
replacements: { tagName: params.tag },
|
|
type: QueryTypes.SELECT,
|
|
}
|
|
);
|
|
|
|
tagFilteredTaskIds = taggedTaskIds.map((row) => row.task_id);
|
|
|
|
if (tagFilteredTaskIds.length === 0) {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
if (tagFilteredTaskIds) {
|
|
whereClause.id = {
|
|
...(whereClause.id || {}),
|
|
[Op.in]: tagFilteredTaskIds,
|
|
};
|
|
}
|
|
|
|
const finalWhereClause = {
|
|
[Op.and]: [ownedOrShared, whereClause],
|
|
};
|
|
|
|
return await Task.findAll({
|
|
where: finalWhereClause,
|
|
include: includeClause,
|
|
order: orderClause,
|
|
distinct: true,
|
|
});
|
|
}
|
|
|
|
function getTaskIncludeConfig() {
|
|
return [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name', 'uid'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'status', 'uid'],
|
|
required: false,
|
|
},
|
|
{
|
|
model: Task,
|
|
as: 'Subtasks',
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name', 'uid'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
],
|
|
required: false,
|
|
},
|
|
];
|
|
}
|
|
|
|
// Lightweight include config for dashboard lists (no subtasks needed)
|
|
function getTaskIncludeConfigLight() {
|
|
return [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name', 'uid'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'status', 'uid'],
|
|
required: false,
|
|
},
|
|
];
|
|
}
|
|
|
|
module.exports = {
|
|
filterTasksByParams,
|
|
getTaskIncludeConfig,
|
|
getTaskIncludeConfigLight,
|
|
};
|