1382 lines
47 KiB
JavaScript
1382 lines
47 KiB
JavaScript
const express = require('express');
|
|
const { Task, Tag, Project, TaskEvent, sequelize } = require('../models');
|
|
const { Op } = require('sequelize');
|
|
const RecurringTaskService = require('../services/recurringTaskService');
|
|
const TaskEventService = require('../services/taskEventService');
|
|
const moment = require('moment-timezone');
|
|
const router = express.Router();
|
|
|
|
// Helper function to serialize task with today move count
|
|
async function serializeTask(task) {
|
|
const taskJson = task.toJSON();
|
|
const todayMoveCount = await TaskEventService.getTaskTodayMoveCount(
|
|
task.id
|
|
);
|
|
|
|
return {
|
|
...taskJson,
|
|
tags: taskJson.Tags || [],
|
|
due_date: task.due_date
|
|
? task.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
today_move_count: todayMoveCount,
|
|
};
|
|
}
|
|
|
|
// Helper function to update task tags
|
|
async function updateTaskTags(task, tagsData, userId) {
|
|
if (!tagsData) return;
|
|
|
|
const tagNames = tagsData
|
|
.map((tag) => tag.name)
|
|
.filter((name) => name && name.trim())
|
|
.filter((name, index, arr) => arr.indexOf(name) === index); // unique
|
|
|
|
if (tagNames.length === 0) {
|
|
await task.setTags([]);
|
|
return;
|
|
}
|
|
|
|
// Find existing tags
|
|
const existingTags = await Tag.findAll({
|
|
where: { user_id: userId, name: tagNames },
|
|
});
|
|
|
|
// Create new tags
|
|
const existingTagNames = existingTags.map((tag) => tag.name);
|
|
const newTagNames = tagNames.filter(
|
|
(name) => !existingTagNames.includes(name)
|
|
);
|
|
|
|
const createdTags = await Promise.all(
|
|
newTagNames.map((name) => Tag.create({ name, user_id: userId }))
|
|
);
|
|
|
|
// Set all tags to task
|
|
const allTags = [...existingTags, ...createdTags];
|
|
await task.setTags(allTags);
|
|
}
|
|
|
|
// Filter tasks by parameters
|
|
async function filterTasksByParams(params, userId) {
|
|
let whereClause = { user_id: userId };
|
|
let includeClause = [
|
|
{ model: Tag, attributes: ['id', 'name'], through: { attributes: [] } },
|
|
{ model: Project, attributes: ['name'], required: false },
|
|
];
|
|
|
|
// Filter by type
|
|
switch (params.type) {
|
|
case 'today':
|
|
whereClause.status = {
|
|
[Op.notIn]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
}; // Exclude completed and archived tasks (both integer and string values)
|
|
break;
|
|
case 'upcoming':
|
|
whereClause.due_date = {
|
|
[Op.between]: [
|
|
new Date(),
|
|
new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
|
|
],
|
|
};
|
|
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.due_date = null;
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
break;
|
|
case 'waiting':
|
|
whereClause.status = Task.STATUS.WAITING;
|
|
break;
|
|
default:
|
|
if (params.status === 'done') {
|
|
whereClause.status = { [Op.in]: [Task.STATUS.DONE, 'done'] };
|
|
} else {
|
|
whereClause.status = { [Op.notIn]: [Task.STATUS.DONE, 'done'] };
|
|
}
|
|
}
|
|
|
|
// Filter by tag
|
|
if (params.tag) {
|
|
includeClause[0].where = { name: params.tag };
|
|
includeClause[0].required = true;
|
|
}
|
|
|
|
let orderClause = [['created_at', 'ASC']];
|
|
|
|
// Apply ordering
|
|
if (params.order_by) {
|
|
const [orderColumn, orderDirection = 'asc'] =
|
|
params.order_by.split(':');
|
|
const allowedColumns = [
|
|
'created_at',
|
|
'updated_at',
|
|
'name',
|
|
'priority',
|
|
'status',
|
|
'due_date',
|
|
];
|
|
|
|
if (!allowedColumns.includes(orderColumn)) {
|
|
throw new Error('Invalid order column specified.');
|
|
}
|
|
|
|
if (orderColumn === 'due_date') {
|
|
orderClause = [
|
|
[
|
|
sequelize.literal(
|
|
'CASE WHEN due_date IS NULL THEN 1 ELSE 0 END'
|
|
),
|
|
'ASC',
|
|
],
|
|
['due_date', orderDirection.toUpperCase()],
|
|
];
|
|
} else {
|
|
orderClause = [[orderColumn, orderDirection.toUpperCase()]];
|
|
}
|
|
}
|
|
|
|
return await Task.findAll({
|
|
where: whereClause,
|
|
include: includeClause,
|
|
order: orderClause,
|
|
distinct: true,
|
|
});
|
|
}
|
|
|
|
// Compute task metrics
|
|
async function computeTaskMetrics(userId, userTimezone = 'UTC') {
|
|
console.log(
|
|
'Computing metrics for user',
|
|
userId,
|
|
'with timezone:',
|
|
userTimezone
|
|
);
|
|
const totalOpenTasks = await Task.count({
|
|
where: { user_id: userId, status: { [Op.ne]: Task.STATUS.DONE } },
|
|
});
|
|
|
|
const oneMonthAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
|
|
const tasksPendingOverMonth = await Task.count({
|
|
where: {
|
|
user_id: userId,
|
|
status: { [Op.ne]: Task.STATUS.DONE },
|
|
created_at: { [Op.lt]: oneMonthAgo },
|
|
},
|
|
});
|
|
|
|
const tasksInProgress = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: { [Op.in]: [Task.STATUS.IN_PROGRESS, 'in_progress'] },
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
order: [['priority', 'DESC']],
|
|
});
|
|
|
|
// Get tasks in today plan
|
|
const todayPlanTasks = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
today: true,
|
|
status: {
|
|
[Op.notIn]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
},
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
order: [
|
|
['priority', 'DESC'],
|
|
['created_at', 'ASC'],
|
|
],
|
|
});
|
|
|
|
const today = new Date();
|
|
today.setHours(23, 59, 59, 999);
|
|
|
|
const tasksDueToday = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: {
|
|
[Op.notIn]: [
|
|
Task.STATUS.DONE,
|
|
Task.STATUS.ARCHIVED,
|
|
'done',
|
|
'archived',
|
|
],
|
|
},
|
|
[Op.or]: [
|
|
{ due_date: { [Op.lte]: today } },
|
|
sequelize.literal(`EXISTS (
|
|
SELECT 1 FROM projects
|
|
WHERE projects.id = Task.project_id
|
|
AND projects.due_date_at <= '${today.toISOString()}'
|
|
)`),
|
|
],
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
});
|
|
|
|
// Get suggested tasks only if user has a meaningful task base
|
|
let suggestedTasks = [];
|
|
|
|
// Only show suggested tasks if:
|
|
// 1. User has at least 3 total tasks, OR
|
|
// 2. User has at least 1 project with tasks
|
|
if (
|
|
totalOpenTasks >= 3 ||
|
|
tasksInProgress.length > 0 ||
|
|
tasksDueToday.length > 0
|
|
) {
|
|
const excludedTaskIds = [
|
|
...tasksInProgress.map((t) => t.id),
|
|
...tasksDueToday.map((t) => t.id),
|
|
];
|
|
|
|
// Get task IDs that have "someday" tag
|
|
const somedayTaskIds = await sequelize
|
|
.query(
|
|
`SELECT DISTINCT task_id FROM tasks_tags
|
|
JOIN tags ON tasks_tags.tag_id = tags.id
|
|
WHERE tags.name = 'someday' AND tags.user_id = ?`,
|
|
{
|
|
replacements: [userId],
|
|
type: sequelize.QueryTypes.SELECT,
|
|
}
|
|
)
|
|
.then((results) => results.map((r) => r.task_id));
|
|
|
|
// Get tasks without projects (excluding someday tagged tasks)
|
|
const nonProjectTasks = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: {
|
|
[Op.in]: [Task.STATUS.NOT_STARTED, Task.STATUS.WAITING],
|
|
},
|
|
id: { [Op.notIn]: [...excludedTaskIds, ...somedayTaskIds] },
|
|
[Op.or]: [{ project_id: null }, { project_id: '' }],
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
order: [
|
|
['priority', 'DESC'],
|
|
['created_at', 'ASC'],
|
|
],
|
|
limit: 6,
|
|
});
|
|
|
|
// Get tasks with projects (excluding someday tagged tasks)
|
|
const projectTasks = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: {
|
|
[Op.in]: [Task.STATUS.NOT_STARTED, Task.STATUS.WAITING],
|
|
},
|
|
id: { [Op.notIn]: [...excludedTaskIds, ...somedayTaskIds] },
|
|
project_id: { [Op.not]: null, [Op.ne]: '' },
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
order: [
|
|
['priority', 'DESC'],
|
|
['created_at', 'ASC'],
|
|
],
|
|
limit: 6,
|
|
});
|
|
|
|
// Check if we have enough suggestions (at least 6 total)
|
|
let combinedTasks = [...nonProjectTasks, ...projectTasks];
|
|
|
|
// If we don't have enough suggestions, include someday tasks as fallback
|
|
if (combinedTasks.length < 6) {
|
|
const usedTaskIds = [
|
|
...excludedTaskIds,
|
|
...combinedTasks.map((t) => t.id),
|
|
];
|
|
|
|
const somedayFallbackTasks = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: {
|
|
[Op.in]: [Task.STATUS.NOT_STARTED, Task.STATUS.WAITING],
|
|
},
|
|
id: {
|
|
[Op.notIn]: usedTaskIds,
|
|
[Op.in]: somedayTaskIds,
|
|
},
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
order: [
|
|
['priority', 'DESC'],
|
|
['created_at', 'ASC'],
|
|
],
|
|
limit: 12 - combinedTasks.length,
|
|
});
|
|
|
|
combinedTasks = [...combinedTasks, ...somedayFallbackTasks];
|
|
}
|
|
|
|
suggestedTasks = combinedTasks;
|
|
}
|
|
|
|
// Get tasks completed today - use user's timezone
|
|
const todayInUserTz = moment.tz(userTimezone);
|
|
const todayStart = todayInUserTz.clone().startOf('day').utc().toDate();
|
|
const todayEnd = todayInUserTz.clone().endOf('day').utc().toDate();
|
|
|
|
const tasksCompletedToday = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: Task.STATUS.DONE,
|
|
completed_at: {
|
|
[Op.between]: [todayStart, todayEnd],
|
|
},
|
|
},
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
required: false,
|
|
},
|
|
{
|
|
model: Project,
|
|
attributes: ['id', 'name', 'active'],
|
|
required: false,
|
|
},
|
|
],
|
|
order: [['completed_at', 'DESC']],
|
|
});
|
|
|
|
// Get weekly completion data (last 7 days) - use user's timezone
|
|
const weekStartInUserTz = moment.tz(userTimezone).subtract(6, 'days');
|
|
const weekStart = weekStartInUserTz.clone().startOf('day').utc().toDate();
|
|
const weekEnd = todayInUserTz.clone().endOf('day').utc().toDate();
|
|
|
|
// For SQLite, we'll fetch the raw data and process it in JavaScript
|
|
const weeklyCompletionsRaw = await Task.findAll({
|
|
where: {
|
|
user_id: userId,
|
|
status: Task.STATUS.DONE,
|
|
completed_at: {
|
|
[Op.between]: [weekStart, weekEnd],
|
|
},
|
|
},
|
|
attributes: ['completed_at'],
|
|
raw: true,
|
|
});
|
|
|
|
// Process the data in JavaScript to group by date in user's timezone
|
|
const dateCountMap = {};
|
|
weeklyCompletionsRaw.forEach((task) => {
|
|
// Parse the completed_at field more reliably - convert to Date first, then to moment
|
|
const completedDate = new Date(task.completed_at);
|
|
const dateInUserTz = moment(completedDate)
|
|
.tz(userTimezone)
|
|
.format('YYYY-MM-DD');
|
|
dateCountMap[dateInUserTz] = (dateCountMap[dateInUserTz] || 0) + 1;
|
|
});
|
|
|
|
// Convert to the format expected by the rest of the code
|
|
const weeklyCompletions = Object.entries(dateCountMap).map(
|
|
([date, count]) => ({
|
|
date,
|
|
count: count.toString(),
|
|
})
|
|
);
|
|
|
|
// Process weekly completion data to ensure all 7 days are represented
|
|
const weeklyData = [];
|
|
for (let i = 6; i >= 0; i--) {
|
|
const dateInUserTz = moment.tz(userTimezone).subtract(i, 'days');
|
|
const dateString = dateInUserTz.format('YYYY-MM-DD');
|
|
|
|
const found = weeklyCompletions.find(
|
|
(item) => item.date === dateString
|
|
);
|
|
const dayData = {
|
|
date: dateString,
|
|
count: found ? parseInt(found.count) : 0,
|
|
dayName: dateInUserTz.format('ddd'), // Short day name
|
|
};
|
|
weeklyData.push(dayData);
|
|
}
|
|
|
|
return {
|
|
total_open_tasks: totalOpenTasks,
|
|
tasks_pending_over_month: tasksPendingOverMonth,
|
|
tasks_in_progress_count: tasksInProgress.length,
|
|
tasks_in_progress: tasksInProgress,
|
|
tasks_due_today: tasksDueToday,
|
|
today_plan_tasks: todayPlanTasks,
|
|
suggested_tasks: suggestedTasks,
|
|
tasks_completed_today: tasksCompletedToday,
|
|
weekly_completions: weeklyData,
|
|
};
|
|
}
|
|
|
|
// GET /api/tasks
|
|
router.get('/tasks', async (req, res) => {
|
|
try {
|
|
const tasks = await filterTasksByParams(req.query, req.currentUser.id);
|
|
const metrics = await computeTaskMetrics(
|
|
req.currentUser.id,
|
|
req.currentUser.timezone
|
|
);
|
|
|
|
res.json({
|
|
tasks: await Promise.all(tasks.map((task) => serializeTask(task))),
|
|
metrics: {
|
|
total_open_tasks: metrics.total_open_tasks,
|
|
tasks_pending_over_month: metrics.tasks_pending_over_month,
|
|
tasks_in_progress_count: metrics.tasks_in_progress_count,
|
|
tasks_in_progress: await Promise.all(
|
|
metrics.tasks_in_progress.map((task) => serializeTask(task))
|
|
),
|
|
tasks_due_today: await Promise.all(
|
|
metrics.tasks_due_today.map((task) => serializeTask(task))
|
|
),
|
|
today_plan_tasks: await Promise.all(
|
|
metrics.today_plan_tasks.map((task) => serializeTask(task))
|
|
),
|
|
suggested_tasks: await Promise.all(
|
|
metrics.suggested_tasks.map((task) => serializeTask(task))
|
|
),
|
|
tasks_completed_today: await Promise.all(
|
|
metrics.tasks_completed_today.map(async (task) => {
|
|
const serialized = await serializeTask(task);
|
|
return {
|
|
...serialized,
|
|
completed_at: task.completed_at
|
|
? task.completed_at.toISOString()
|
|
: null,
|
|
};
|
|
})
|
|
),
|
|
weekly_completions: metrics.weekly_completions,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error('Error fetching tasks:', error);
|
|
if (error.message === 'Invalid order column specified.') {
|
|
return res.status(400).json({ error: error.message });
|
|
}
|
|
res.status(500).json({ error: 'Internal server error' });
|
|
}
|
|
});
|
|
|
|
// GET /api/task/uuid/:uuid
|
|
router.get('/task/uuid/:uuid', async (req, res) => {
|
|
try {
|
|
const task = await Task.findOne({
|
|
where: { uuid: req.params.uuid, user_id: req.currentUser.id },
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
},
|
|
{ model: Project, attributes: ['name'], required: false },
|
|
],
|
|
});
|
|
|
|
if (!task) {
|
|
return res.status(404).json({ error: 'Task not found.' });
|
|
}
|
|
|
|
const serializedTask = await serializeTask(task);
|
|
|
|
res.json(serializedTask);
|
|
} catch (error) {
|
|
console.error('Error fetching task by UUID:', error);
|
|
res.status(500).json({ error: 'Internal server error' });
|
|
}
|
|
});
|
|
|
|
// GET /api/task/:id
|
|
router.get('/task/:id', async (req, res) => {
|
|
try {
|
|
const task = await Task.findOne({
|
|
where: { id: req.params.id, user_id: req.currentUser.id },
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
},
|
|
{ model: Project, attributes: ['name'], required: false },
|
|
],
|
|
});
|
|
|
|
if (!task) {
|
|
return res.status(404).json({ error: 'Task not found.' });
|
|
}
|
|
|
|
const serializedTask = await serializeTask(task);
|
|
|
|
res.json(serializedTask);
|
|
} catch (error) {
|
|
console.error('Error fetching task:', error);
|
|
res.status(500).json({ error: 'Internal server error' });
|
|
}
|
|
});
|
|
|
|
// POST /api/task
|
|
router.post('/task', async (req, res) => {
|
|
try {
|
|
const {
|
|
name,
|
|
priority,
|
|
due_date,
|
|
status,
|
|
note,
|
|
project_id,
|
|
tags,
|
|
Tags,
|
|
today,
|
|
recurrence_type,
|
|
recurrence_interval,
|
|
recurrence_end_date,
|
|
recurrence_weekday,
|
|
recurrence_month_day,
|
|
recurrence_week_of_month,
|
|
completion_based,
|
|
} = req.body;
|
|
|
|
// Handle both tags and Tags (Sequelize association format)
|
|
const tagsData = tags || Tags;
|
|
|
|
// Validate required fields
|
|
if (!name || name.trim() === '') {
|
|
return res.status(400).json({ error: 'Task name is required.' });
|
|
}
|
|
|
|
const taskAttributes = {
|
|
name: name.trim(),
|
|
priority:
|
|
priority !== undefined
|
|
? typeof priority === 'string'
|
|
? Task.getPriorityValue(priority)
|
|
: priority
|
|
: Task.PRIORITY.LOW,
|
|
due_date: due_date || null,
|
|
status:
|
|
status !== undefined
|
|
? typeof status === 'string'
|
|
? Task.getStatusValue(status)
|
|
: status
|
|
: Task.STATUS.NOT_STARTED,
|
|
note,
|
|
today: today !== undefined ? today : false,
|
|
user_id: req.currentUser.id,
|
|
recurrence_type: recurrence_type || 'none',
|
|
recurrence_interval: recurrence_interval || null,
|
|
recurrence_end_date: recurrence_end_date || null,
|
|
recurrence_weekday:
|
|
recurrence_weekday !== undefined ? recurrence_weekday : null,
|
|
recurrence_month_day:
|
|
recurrence_month_day !== undefined
|
|
? recurrence_month_day
|
|
: null,
|
|
recurrence_week_of_month:
|
|
recurrence_week_of_month !== undefined
|
|
? recurrence_week_of_month
|
|
: null,
|
|
completion_based: completion_based || false,
|
|
};
|
|
|
|
// Handle project assignment
|
|
if (project_id && project_id.toString().trim()) {
|
|
const project = await Project.findOne({
|
|
where: { id: project_id, user_id: req.currentUser.id },
|
|
});
|
|
if (!project) {
|
|
return res.status(400).json({ error: 'Invalid project.' });
|
|
}
|
|
taskAttributes.project_id = project_id;
|
|
}
|
|
|
|
const task = await Task.create(taskAttributes);
|
|
await updateTaskTags(task, tagsData, req.currentUser.id);
|
|
|
|
// Log task creation event
|
|
try {
|
|
await TaskEventService.logTaskCreated(
|
|
task.id,
|
|
req.currentUser.id,
|
|
{
|
|
name: task.name,
|
|
status: task.status,
|
|
priority: task.priority,
|
|
due_date: task.due_date,
|
|
project_id: task.project_id,
|
|
},
|
|
{ source: 'web' }
|
|
);
|
|
} catch (eventError) {
|
|
console.error('Error logging task creation event:', eventError);
|
|
// Don't fail the request if event logging fails
|
|
}
|
|
|
|
// Reload task with associations
|
|
const taskWithAssociations = await Task.findByPk(task.id, {
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['name'],
|
|
through: { attributes: [] },
|
|
},
|
|
{ model: Project, attributes: ['name'], required: false },
|
|
],
|
|
});
|
|
|
|
const taskJson = taskWithAssociations.toJSON();
|
|
|
|
res.status(201).json({
|
|
...taskJson,
|
|
tags: taskJson.Tags || [],
|
|
due_date: taskWithAssociations.due_date
|
|
? taskWithAssociations.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
});
|
|
} catch (error) {
|
|
console.error('Error creating task:', error);
|
|
res.status(400).json({
|
|
error: 'There was a problem creating the task.',
|
|
details: error.errors
|
|
? error.errors.map((e) => e.message)
|
|
: [error.message],
|
|
});
|
|
}
|
|
});
|
|
|
|
// PATCH /api/task/:id
|
|
router.patch('/task/:id', async (req, res) => {
|
|
try {
|
|
const {
|
|
name,
|
|
priority,
|
|
status,
|
|
note,
|
|
due_date,
|
|
project_id,
|
|
tags,
|
|
Tags,
|
|
today,
|
|
recurrence_type,
|
|
recurrence_interval,
|
|
recurrence_end_date,
|
|
recurrence_weekday,
|
|
recurrence_month_day,
|
|
recurrence_week_of_month,
|
|
completion_based,
|
|
update_parent_recurrence,
|
|
} = req.body;
|
|
|
|
// Handle both tags and Tags (Sequelize association format)
|
|
const tagsData = tags || Tags;
|
|
|
|
const task = await Task.findOne({
|
|
where: { id: req.params.id, user_id: req.currentUser.id },
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
},
|
|
],
|
|
});
|
|
|
|
if (!task) {
|
|
return res.status(404).json({ error: 'Task not found.' });
|
|
}
|
|
|
|
// Capture old values for event logging
|
|
const oldValues = {
|
|
name: task.name,
|
|
status: task.status,
|
|
priority: task.priority,
|
|
due_date: task.due_date,
|
|
project_id: task.project_id,
|
|
note: task.note,
|
|
recurrence_type: task.recurrence_type,
|
|
recurrence_interval: task.recurrence_interval,
|
|
recurrence_end_date: task.recurrence_end_date,
|
|
recurrence_weekday: task.recurrence_weekday,
|
|
recurrence_month_day: task.recurrence_month_day,
|
|
recurrence_week_of_month: task.recurrence_week_of_month,
|
|
completion_based: task.completion_based,
|
|
tags: task.Tags
|
|
? task.Tags.map((tag) => ({ id: tag.id, name: tag.name }))
|
|
: [],
|
|
};
|
|
|
|
// Handle updating parent recurrence settings if this is a child task
|
|
if (update_parent_recurrence && task.recurring_parent_id) {
|
|
const parentTask = await Task.findOne({
|
|
where: {
|
|
id: task.recurring_parent_id,
|
|
user_id: req.currentUser.id,
|
|
},
|
|
});
|
|
|
|
if (parentTask) {
|
|
await parentTask.update({
|
|
recurrence_type:
|
|
recurrence_type !== undefined
|
|
? recurrence_type
|
|
: parentTask.recurrence_type,
|
|
recurrence_interval:
|
|
recurrence_interval !== undefined
|
|
? recurrence_interval
|
|
: parentTask.recurrence_interval,
|
|
recurrence_end_date:
|
|
recurrence_end_date !== undefined
|
|
? recurrence_end_date
|
|
: parentTask.recurrence_end_date,
|
|
recurrence_weekday:
|
|
recurrence_weekday !== undefined
|
|
? recurrence_weekday
|
|
: parentTask.recurrence_weekday,
|
|
recurrence_month_day:
|
|
recurrence_month_day !== undefined
|
|
? recurrence_month_day
|
|
: parentTask.recurrence_month_day,
|
|
recurrence_week_of_month:
|
|
recurrence_week_of_month !== undefined
|
|
? recurrence_week_of_month
|
|
: parentTask.recurrence_week_of_month,
|
|
completion_based:
|
|
completion_based !== undefined
|
|
? completion_based
|
|
: parentTask.completion_based,
|
|
});
|
|
console.log(
|
|
`Updated parent task ${parentTask.id} recurrence settings from child task ${task.id}`
|
|
);
|
|
}
|
|
}
|
|
|
|
const taskAttributes = {
|
|
name,
|
|
priority:
|
|
priority !== undefined
|
|
? typeof priority === 'string'
|
|
? Task.getPriorityValue(priority)
|
|
: priority
|
|
: undefined,
|
|
status:
|
|
status !== undefined
|
|
? typeof status === 'string'
|
|
? Task.getStatusValue(status)
|
|
: status
|
|
: Task.STATUS.NOT_STARTED,
|
|
note,
|
|
due_date: due_date || null,
|
|
today: today !== undefined ? today : task.today,
|
|
recurrence_type:
|
|
recurrence_type !== undefined
|
|
? recurrence_type
|
|
: task.recurrence_type,
|
|
recurrence_interval:
|
|
recurrence_interval !== undefined
|
|
? recurrence_interval
|
|
: task.recurrence_interval,
|
|
recurrence_end_date:
|
|
recurrence_end_date !== undefined
|
|
? recurrence_end_date
|
|
: task.recurrence_end_date,
|
|
recurrence_weekday:
|
|
recurrence_weekday !== undefined
|
|
? recurrence_weekday
|
|
: task.recurrence_weekday,
|
|
recurrence_month_day:
|
|
recurrence_month_day !== undefined
|
|
? recurrence_month_day
|
|
: task.recurrence_month_day,
|
|
recurrence_week_of_month:
|
|
recurrence_week_of_month !== undefined
|
|
? recurrence_week_of_month
|
|
: task.recurrence_week_of_month,
|
|
completion_based:
|
|
completion_based !== undefined
|
|
? completion_based
|
|
: task.completion_based,
|
|
};
|
|
|
|
// Set completed_at when task is marked as done
|
|
if (status !== undefined) {
|
|
const newStatus =
|
|
typeof status === 'string'
|
|
? Task.getStatusValue(status)
|
|
: status;
|
|
const oldStatus =
|
|
typeof task.status === 'string'
|
|
? Task.getStatusValue(task.status)
|
|
: task.status;
|
|
|
|
if (
|
|
newStatus === Task.STATUS.DONE &&
|
|
oldStatus !== Task.STATUS.DONE
|
|
) {
|
|
// Task is being completed
|
|
taskAttributes.completed_at = new Date();
|
|
} else if (
|
|
newStatus !== Task.STATUS.DONE &&
|
|
oldStatus === Task.STATUS.DONE
|
|
) {
|
|
// Task is being uncompleted
|
|
taskAttributes.completed_at = null;
|
|
}
|
|
}
|
|
|
|
// Handle project assignment
|
|
if (project_id && project_id.toString().trim()) {
|
|
const project = await Project.findOne({
|
|
where: { id: project_id, user_id: req.currentUser.id },
|
|
});
|
|
if (!project) {
|
|
return res.status(400).json({ error: 'Invalid project.' });
|
|
}
|
|
taskAttributes.project_id = project_id;
|
|
} else {
|
|
taskAttributes.project_id = null;
|
|
}
|
|
|
|
await task.update(taskAttributes);
|
|
await updateTaskTags(task, tagsData, req.currentUser.id);
|
|
|
|
// Log task update events
|
|
try {
|
|
const changes = {};
|
|
|
|
// Check for changes in each field
|
|
if (name !== undefined && name !== oldValues.name) {
|
|
changes.name = { oldValue: oldValues.name, newValue: name };
|
|
}
|
|
if (status !== undefined && status !== oldValues.status) {
|
|
changes.status = {
|
|
oldValue: oldValues.status,
|
|
newValue: status,
|
|
};
|
|
}
|
|
if (priority !== undefined && priority !== oldValues.priority) {
|
|
changes.priority = {
|
|
oldValue: oldValues.priority,
|
|
newValue: priority,
|
|
};
|
|
}
|
|
if (due_date !== undefined) {
|
|
// Normalize dates for comparison (convert to YYYY-MM-DD format)
|
|
const oldDateStr = oldValues.due_date
|
|
? oldValues.due_date.toISOString().split('T')[0]
|
|
: null;
|
|
const newDateStr = due_date || null;
|
|
|
|
if (oldDateStr !== newDateStr) {
|
|
changes.due_date = {
|
|
oldValue: oldValues.due_date,
|
|
newValue: due_date,
|
|
};
|
|
}
|
|
}
|
|
if (
|
|
project_id !== undefined &&
|
|
project_id !== oldValues.project_id
|
|
) {
|
|
changes.project_id = {
|
|
oldValue: oldValues.project_id,
|
|
newValue: project_id,
|
|
};
|
|
}
|
|
if (note !== undefined && note !== oldValues.note) {
|
|
changes.note = { oldValue: oldValues.note, newValue: note };
|
|
}
|
|
|
|
// Check recurrence field changes
|
|
if (
|
|
recurrence_type !== undefined &&
|
|
recurrence_type !== oldValues.recurrence_type
|
|
) {
|
|
changes.recurrence_type = {
|
|
oldValue: oldValues.recurrence_type,
|
|
newValue: recurrence_type,
|
|
};
|
|
}
|
|
if (
|
|
recurrence_interval !== undefined &&
|
|
recurrence_interval !== oldValues.recurrence_interval
|
|
) {
|
|
changes.recurrence_interval = {
|
|
oldValue: oldValues.recurrence_interval,
|
|
newValue: recurrence_interval,
|
|
};
|
|
}
|
|
if (
|
|
recurrence_end_date !== undefined &&
|
|
recurrence_end_date !== oldValues.recurrence_end_date
|
|
) {
|
|
changes.recurrence_end_date = {
|
|
oldValue: oldValues.recurrence_end_date,
|
|
newValue: recurrence_end_date,
|
|
};
|
|
}
|
|
if (
|
|
recurrence_weekday !== undefined &&
|
|
recurrence_weekday !== oldValues.recurrence_weekday
|
|
) {
|
|
changes.recurrence_weekday = {
|
|
oldValue: oldValues.recurrence_weekday,
|
|
newValue: recurrence_weekday,
|
|
};
|
|
}
|
|
if (
|
|
recurrence_month_day !== undefined &&
|
|
recurrence_month_day !== oldValues.recurrence_month_day
|
|
) {
|
|
changes.recurrence_month_day = {
|
|
oldValue: oldValues.recurrence_month_day,
|
|
newValue: recurrence_month_day,
|
|
};
|
|
}
|
|
if (
|
|
recurrence_week_of_month !== undefined &&
|
|
recurrence_week_of_month !== oldValues.recurrence_week_of_month
|
|
) {
|
|
changes.recurrence_week_of_month = {
|
|
oldValue: oldValues.recurrence_week_of_month,
|
|
newValue: recurrence_week_of_month,
|
|
};
|
|
}
|
|
if (
|
|
completion_based !== undefined &&
|
|
completion_based !== oldValues.completion_based
|
|
) {
|
|
changes.completion_based = {
|
|
oldValue: oldValues.completion_based,
|
|
newValue: completion_based,
|
|
};
|
|
}
|
|
|
|
// Log all changes
|
|
if (Object.keys(changes).length > 0) {
|
|
await TaskEventService.logTaskUpdate(
|
|
task.id,
|
|
req.currentUser.id,
|
|
changes,
|
|
{ source: 'web' }
|
|
);
|
|
}
|
|
|
|
// Check for tag changes (this is more complex due to the array comparison)
|
|
if (tagsData) {
|
|
const newTags = tagsData.map((tag) => ({
|
|
id: tag.id,
|
|
name: tag.name,
|
|
}));
|
|
const oldTagNames = oldValues.tags
|
|
.map((tag) => tag.name)
|
|
.sort();
|
|
const newTagNames = newTags.map((tag) => tag.name).sort();
|
|
|
|
if (
|
|
JSON.stringify(oldTagNames) !== JSON.stringify(newTagNames)
|
|
) {
|
|
await TaskEventService.logEvent({
|
|
taskId: task.id,
|
|
userId: req.currentUser.id,
|
|
eventType: 'tags_changed',
|
|
fieldName: 'tags',
|
|
oldValue: oldValues.tags,
|
|
newValue: newTags,
|
|
metadata: { source: 'web', action: 'tags_update' },
|
|
});
|
|
}
|
|
}
|
|
} catch (eventError) {
|
|
console.error('Error logging task update events:', eventError);
|
|
// Don't fail the request if event logging fails
|
|
}
|
|
|
|
// Reload task with associations
|
|
const taskWithAssociations = await Task.findByPk(task.id, {
|
|
include: [
|
|
{
|
|
model: Tag,
|
|
attributes: ['id', 'name'],
|
|
through: { attributes: [] },
|
|
},
|
|
{ model: Project, attributes: ['name'], required: false },
|
|
],
|
|
});
|
|
|
|
const taskJson = taskWithAssociations.toJSON();
|
|
|
|
res.json({
|
|
...taskJson,
|
|
tags: taskJson.Tags || [], // Normalize Tags to tags
|
|
due_date: taskWithAssociations.due_date
|
|
? taskWithAssociations.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
});
|
|
} catch (error) {
|
|
console.error('Error updating task:', error);
|
|
res.status(400).json({
|
|
error: 'There was a problem updating the task.',
|
|
details: error.errors
|
|
? error.errors.map((e) => e.message)
|
|
: [error.message],
|
|
});
|
|
}
|
|
});
|
|
|
|
// PATCH /api/task/:id/toggle_completion
|
|
router.patch('/task/:id/toggle_completion', async (req, res) => {
|
|
try {
|
|
const task = await Task.findOne({
|
|
where: { id: req.params.id, user_id: req.currentUser.id },
|
|
});
|
|
|
|
if (!task) {
|
|
return res.status(404).json({ error: 'Task not found.' });
|
|
}
|
|
|
|
console.log('🎯 Toggle completion called for task:', {
|
|
id: task.id,
|
|
name: task.name,
|
|
currentStatus: task.status,
|
|
recurrence_type: task.recurrence_type,
|
|
completion_based: task.completion_based,
|
|
});
|
|
|
|
const newStatus =
|
|
task.status === Task.STATUS.DONE || task.status === 'done'
|
|
? task.note
|
|
? Task.STATUS.IN_PROGRESS
|
|
: Task.STATUS.NOT_STARTED
|
|
: Task.STATUS.DONE;
|
|
|
|
console.log('📝 Status changing from', task.status, 'to', newStatus);
|
|
|
|
// Set completed_at when task is completed/uncompleted
|
|
const updateData = { status: newStatus };
|
|
if (newStatus === Task.STATUS.DONE) {
|
|
updateData.completed_at = new Date();
|
|
} else if (task.status === Task.STATUS.DONE || task.status === 'done') {
|
|
updateData.completed_at = null;
|
|
}
|
|
|
|
await task.update(updateData);
|
|
|
|
// Handle recurring task completion
|
|
let nextTask = null;
|
|
if (newStatus === Task.STATUS.DONE || newStatus === 'done') {
|
|
console.log(
|
|
'✅ Task marked as done, calling RecurringTaskService...'
|
|
);
|
|
nextTask = await RecurringTaskService.handleTaskCompletion(task);
|
|
} else {
|
|
console.log(
|
|
'❌ Task not marked as done, skipping RecurringTaskService'
|
|
);
|
|
}
|
|
|
|
const response = {
|
|
...task.toJSON(),
|
|
due_date: task.due_date
|
|
? task.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
};
|
|
|
|
if (nextTask) {
|
|
response.next_task = {
|
|
...nextTask.toJSON(),
|
|
due_date: nextTask.due_date
|
|
? nextTask.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
};
|
|
}
|
|
|
|
res.json(response);
|
|
} catch (error) {
|
|
console.error('Error toggling task completion:', error);
|
|
res.status(422).json({ error: 'Unable to update task' });
|
|
}
|
|
});
|
|
|
|
// DELETE /api/task/:id
|
|
router.delete('/task/:id', async (req, res) => {
|
|
try {
|
|
const task = await Task.findOne({
|
|
where: { id: req.params.id, user_id: req.currentUser.id },
|
|
});
|
|
|
|
if (!task) {
|
|
return res.status(404).json({ error: 'Task not found.' });
|
|
}
|
|
|
|
console.log(`Attempting to delete task ${req.params.id}`);
|
|
|
|
// Check for child tasks - prevent deletion of parent tasks with children
|
|
const childTasks = await Task.findAll({
|
|
where: { recurring_parent_id: req.params.id },
|
|
});
|
|
console.log(`Found ${childTasks.length} child tasks`);
|
|
|
|
// If this is a recurring parent task with children, prevent deletion
|
|
if (childTasks.length > 0) {
|
|
console.log(
|
|
`Cannot delete task ${req.params.id} - has ${childTasks.length} child tasks`
|
|
);
|
|
return res
|
|
.status(400)
|
|
.json({ error: 'There was a problem deleting the task.' });
|
|
}
|
|
|
|
const taskEvents = await TaskEvent.findAll({
|
|
where: { task_id: req.params.id },
|
|
});
|
|
console.log(`Found ${taskEvents.length} task events`);
|
|
|
|
const tagAssociations = await sequelize.query(
|
|
'SELECT COUNT(*) as count FROM tasks_tags WHERE task_id = ?',
|
|
{ replacements: [req.params.id], type: sequelize.QueryTypes.SELECT }
|
|
);
|
|
console.log(`Found ${tagAssociations[0].count} tag associations`);
|
|
|
|
// Check SQLite foreign key list for tasks table
|
|
const foreignKeys = await sequelize.query(
|
|
'PRAGMA foreign_key_list(tasks)',
|
|
{ type: sequelize.QueryTypes.SELECT }
|
|
);
|
|
console.log('Foreign keys in tasks table:', foreignKeys);
|
|
|
|
// Find all tables that reference tasks
|
|
const allTables = await sequelize.query(
|
|
"SELECT name FROM sqlite_master WHERE type='table'",
|
|
{ type: sequelize.QueryTypes.SELECT }
|
|
);
|
|
|
|
for (const table of allTables) {
|
|
if (table.name !== 'tasks') {
|
|
try {
|
|
const fks = await sequelize.query(
|
|
`PRAGMA foreign_key_list(${table.name})`,
|
|
{ type: sequelize.QueryTypes.SELECT }
|
|
);
|
|
const taskRefs = fks.filter((fk) => fk.table === 'tasks');
|
|
if (taskRefs.length > 0) {
|
|
console.log(
|
|
`Table ${table.name} references tasks:`,
|
|
taskRefs
|
|
);
|
|
// Check if this table has any records referencing our task
|
|
for (const fk of taskRefs) {
|
|
const count = await sequelize.query(
|
|
`SELECT COUNT(*) as count FROM ${table.name} WHERE ${fk.from} = ?`,
|
|
{
|
|
replacements: [req.params.id],
|
|
type: sequelize.QueryTypes.SELECT,
|
|
}
|
|
);
|
|
console.log(
|
|
` ${table.name}.${fk.from} -> tasks.${fk.to}: ${count[0].count} references`
|
|
);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
// Skip tables that might not exist or have issues
|
|
}
|
|
}
|
|
}
|
|
|
|
// Temporarily disable foreign key constraints for this operation
|
|
await sequelize.query('PRAGMA foreign_keys = OFF');
|
|
|
|
try {
|
|
// Use force delete to bypass foreign key constraints
|
|
await TaskEvent.destroy({
|
|
where: { task_id: req.params.id },
|
|
force: true,
|
|
});
|
|
|
|
await sequelize.query('DELETE FROM tasks_tags WHERE task_id = ?', {
|
|
replacements: [req.params.id],
|
|
});
|
|
|
|
await Task.update(
|
|
{ recurring_parent_id: null },
|
|
{ where: { recurring_parent_id: req.params.id } }
|
|
);
|
|
|
|
// Delete the task itself
|
|
await task.destroy({ force: true });
|
|
} finally {
|
|
// Re-enable foreign key constraints
|
|
await sequelize.query('PRAGMA foreign_keys = ON');
|
|
}
|
|
|
|
console.log(`Successfully deleted task ${req.params.id}`);
|
|
res.json({ message: 'Task successfully deleted' });
|
|
} catch (error) {
|
|
console.error('Error deleting task:', error);
|
|
res.status(400).json({
|
|
error: 'There was a problem deleting the task.',
|
|
});
|
|
}
|
|
});
|
|
|
|
// POST /api/tasks/generate-recurring
|
|
router.post('/tasks/generate-recurring', async (req, res) => {
|
|
try {
|
|
const newTasks = await RecurringTaskService.generateRecurringTasks(
|
|
req.currentUser.id
|
|
);
|
|
|
|
res.json({
|
|
message: `Generated ${newTasks.length} recurring tasks`,
|
|
tasks: newTasks.map((task) => ({
|
|
...task.toJSON(),
|
|
due_date: task.due_date
|
|
? task.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
})),
|
|
});
|
|
} catch (error) {
|
|
console.error('Error generating recurring tasks:', error);
|
|
res.status(500).json({ error: 'Failed to generate recurring tasks' });
|
|
}
|
|
});
|
|
|
|
// PATCH /api/task/:id/toggle-today
|
|
router.patch('/task/:id/toggle-today', async (req, res) => {
|
|
try {
|
|
const task = await Task.findOne({
|
|
where: { id: req.params.id, user_id: req.currentUser.id },
|
|
});
|
|
|
|
if (!task) {
|
|
return res.status(404).json({ error: 'Task not found.' });
|
|
}
|
|
|
|
// Toggle the today flag
|
|
const newTodayValue = !task.today;
|
|
await task.update({ today: newTodayValue });
|
|
|
|
// Log the change
|
|
try {
|
|
await TaskEventService.logEvent({
|
|
taskId: task.id,
|
|
userId: req.currentUser.id,
|
|
eventType: 'today_changed',
|
|
fieldName: 'today',
|
|
oldValue: !newTodayValue,
|
|
newValue: newTodayValue,
|
|
metadata: { source: 'web', action: 'toggle_today' },
|
|
});
|
|
} catch (eventError) {
|
|
console.error('Error logging today toggle event:', eventError);
|
|
// Don't fail the request if event logging fails
|
|
}
|
|
|
|
res.json({
|
|
...task.toJSON(),
|
|
due_date: task.due_date
|
|
? task.due_date.toISOString().split('T')[0]
|
|
: null,
|
|
});
|
|
} catch (error) {
|
|
console.error('Error toggling task today flag:', error);
|
|
res.status(500).json({ error: 'Failed to update task today flag' });
|
|
}
|
|
});
|
|
|
|
module.exports = router;
|