Improvement of Task filtering status

apps/web/src/app/[locale]/(dashboard)/[wsId]/tasks/boards/[boardId]/task.tsx

@@ -58,6 +58,8 @@
   isYesterday,
 } from 'date-fns';
 import { useEffect, useRef, useState } from 'react';
+import { moveTask } from '@/lib/task-helper';
+import { toast } from '@tuturuuu/ui/hooks/use-toast';
 
 export interface Task extends TaskType {}
 
@@ -67,6 +69,7 @@
   taskList?: TaskList;
   isOverlay?: boolean;
   onUpdate?: () => void;
+  availableLists?: TaskList[]; // Optional: pass from parent to avoid redundant API calls
 }
 
 export function TaskCard({
@@ -75,6 +78,7 @@
   taskList,
   isOverlay,
   onUpdate,
+  availableLists: propAvailableLists,
 }: Props) {
   const [isLoading, setIsLoading] = useState(false);
   const [isHovered, setIsHovered] = useState(false);
@@ -91,8 +95,13 @@
   const updateTaskMutation = useUpdateTask(boardId);
   const deleteTaskMutation = useDeleteTask(boardId);
 
-  // Fetch available task lists for the board
+  // Fetch available task lists for the board (only if not provided as prop)
   useEffect(() => {
+    if (propAvailableLists) {
+      setAvailableLists(propAvailableLists);
+      return;
+    }
+
     const fetchTaskLists = async () => {
       const supabase = createClient();
       const { data, error } = await supabase
@@ -109,7 +118,7 @@
     };
 
     fetchTaskLists();
-  }, [boardId]);
+  }, [boardId, propAvailableLists]);
 
   // Find the first list with 'done' or 'closed' status
   const getTargetCompletionList = () => {
@@ -244,22 +253,24 @@
     if (!targetCompletionList || !onUpdate) return;
 
     setIsLoading(true);
-    updateTaskMutation.mutate(
-      {
-        taskId: task.id,
-        updates: {
-          list_id: targetCompletionList.id,
-          archived: true, // Also mark as archived when moving to completion
-        },
-      },
-      {
-        onSettled: () => {
-          setIsLoading(false);
-          setMenuOpen(false);
-          onUpdate();
-        },
-      }
-    );
+
+    // Use the standard moveTask function to ensure consistent logic
+    const supabase = createClient();
+    try {
+      await moveTask(supabase, task.id, targetCompletionList.id);
+      // Manually invalidate queries since we're not using the mutation hook
+      onUpdate();
+    } catch (error) {
+      console.error('Failed to move task to completion:', error);
+      toast({
+        title: 'Error',
+        description: 'Failed to complete task. Please try again.',
+        variant: 'destructive',
+      });
+    } finally {
+      setIsLoading(false);
+      setMenuOpen(false);
+    }
   }
 
   async function handleDelete() {

apps/web/src/app/api/v1/workspaces/[wsId]/tasks/route.ts

@@ -14,14 +14,17 @@
 interface TaskListData {
   id: string;
   name: string | null;
+  // Task list status: 'not_started' | 'active' | 'done' | 'closed'
+  // Used to determine task availability for time tracking
+  status: string | null;
   workspace_boards: {
     id: string;
     name: string | null;
     ws_id: string;
   } | null;
 }
 
-interface RawTaskData {
+interface TaskData {
   id: string;
   name: string;
   description: string | null;
@@ -31,6 +34,7 @@
   end_date: string | null;
   created_at: string | null;
   list_id: string;
+  archived: boolean | null;
   task_lists: TaskListData | null;
   assignees?: TaskAssigneeData[];
 }
@@ -86,6 +90,9 @@
       Number.isFinite(parsedOffset) && parsedOffset >= 0 ? parsedOffset : 0;
     const boardId = url.searchParams.get('boardId');
     const listId = url.searchParams.get('listId');
+
+    // Check if this is a request for time tracking (indicated by limit=100 and no specific filters)
+    const isTimeTrackingRequest = limit === 100 && !boardId && !listId;
 
     // Build the query for fetching tasks with assignee information
     let query = supabase
@@ -101,9 +108,11 @@
         end_date,
         created_at,
         list_id,
+        archived,
         task_lists!inner (
           id,
           name,
+          status,
           board_id,
           workspace_boards!inner (
             id,
@@ -123,6 +132,14 @@
       .eq('task_lists.workspace_boards.ws_id', wsId)
       .eq('deleted', false);
 
+    // IMPORTANT: If this is for time tracking, apply the same filters as the server-side helper
+    if (isTimeTrackingRequest) {
+      query = query
+        .eq('archived', false) // Only non-archived tasks
+        .in('task_lists.status', ['not_started', 'active']) // Only from active lists
+        .eq('task_lists.deleted', false); // Ensure list is not deleted
+    }
+
     // Apply filters based on query parameters
     if (listId) {
       query = query.eq('list_id', listId);
@@ -142,7 +159,7 @@
 
     // Transform the data to match the expected WorkspaceTask format
     const tasks =
-      data?.map((task: RawTaskData) => ({
+      data?.map((task: TaskData) => ({
         id: task.id,
         name: task.name,
         description: task.description,
@@ -152,20 +169,22 @@
         end_date: task.end_date,
         created_at: task.created_at,
         list_id: task.list_id,
+        archived: task.archived,
         // Add board information for context
         board_name: task.task_lists?.workspace_boards?.name,
         list_name: task.task_lists?.name,
+        list_status: task.task_lists?.status,
         // Add assignee information
         assignees: [
           ...(task.assignees ?? [])
-            .map((a) => a.user)
-            .filter((u): u is NonNullable<typeof u> => !!u?.id)
-            .reduce((uniqueUsers, user) => {
+            .map((a: any) => a.user)
+            .filter((u: any) => !!u?.id)
+            .reduce((uniqueUsers: Map<string, any>, user: any) => {
               if (!uniqueUsers.has(user.id)) {
                 uniqueUsers.set(user.id, user);
               }
               return uniqueUsers;
-            }, new Map<string, NonNullable<typeof task.assignees>[0]['user']>())
+            }, new Map())
             .values(),
         ],
         // Add helper field to identify if current user is assigned

apps/web/src/lib/task-helper.ts

@@ -143,13 +143,32 @@
   return data as Task;
 }
 
+// Utility function to transform and deduplicate assignees
+export function transformAssignees(assignees: any[]): any[] {
+  return assignees
+    ?.map((a: any) => a.user)
+          .filter(
+        (user: any, index: number, self: any[]) =>
+          user?.id &&
+          self.findIndex((u: any) => u.id === user.id) === index
+      ) || [];
+}
+
+// Utility function to invalidate all task-related caches consistently
+export function invalidateTaskCaches(queryClient: any, boardId?: string) {
+  if (boardId) {
+    queryClient.invalidateQueries({ queryKey: ['tasks', boardId] });
+    queryClient.invalidateQueries({ queryKey: ['task_lists', boardId] });
+  }
+  // Always invalidate time tracker since task availability affects it
+  queryClient.invalidateQueries({ queryKey: ['time-tracking-data'] });
+}
+
 export async function moveTask(
   supabase: SupabaseClient,
   taskId: string,
   newListId: string
 ) {
-  console.log('🔄 Starting moveTask:', { taskId, newListId });
-
   // First, get the target list to check its status
   const { data: targetList, error: listError } = await supabase
     .from('task_lists')
@@ -162,17 +181,12 @@
     throw listError;
   }
 
-  console.log('✅ Target list found:', targetList);
-
-  // Determine if task should be marked as archived based on list status
+  // Determine task completion status based on list status
+  // - not_started, active: task is available for work (archived = false)
+  // - done, closed: task is completed/archived (archived = true)
   const shouldArchive =
     targetList.status === 'done' || targetList.status === 'closed';
 
-  console.log('📝 Task completion status will be:', {
-    shouldArchive,
-    reason: `List status is "${targetList.status}"`,
-  });
-
   const { data, error } = await supabase
     .from('tasks')
     .update({
@@ -199,23 +213,10 @@
     throw error;
   }
 
-  console.log('✅ Task moved successfully in database:', {
-    taskId: data.id,
-    newListId: data.list_id,
-    archived: data.archived,
-  });
-
   // Transform the nested assignees data
   const transformedTask = {
     ...data,
-    assignees: data.assignees
-      ?.map((a: any) => a.user)
-      .filter(
-        (user: any, index: number, self: any[]) =>
-          user &&
-          user.id &&
-          self.findIndex((u: any) => u.id === user.id) === index
-      ),
+    assignees: transformAssignees(data.assignees),
   };
 
   return transformedTask as Task;
@@ -484,17 +485,10 @@
       taskId: string;
       newListId: string;
     }) => {
-      console.log('🚀 useMoveTask mutation called:', {
-        taskId,
-        newListId,
-        boardId,
-      });
       const supabase = createClient();
       return moveTask(supabase, taskId, newListId);
     },
     onMutate: async ({ taskId, newListId }) => {
-      console.log('🔄 useMoveTask onMutate:', { taskId, newListId });
-
       // Cancel any outgoing refetches
       await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
 
@@ -514,9 +508,7 @@
 
       return { previousTasks };
     },
-    onError: (err, variables, context) => {
-      console.error('❌ useMoveTask onError:', err, variables);
-
+    onError: (err, _variables, context) => {
       // Rollback optimistic update on error
       if (context?.previousTasks) {
         queryClient.setQueryData(['tasks', boardId], context.previousTasks);
@@ -529,9 +521,7 @@
         variant: 'destructive',
       });
     },
-    onSuccess: (updatedTask, variables) => {
-      console.log('✅ useMoveTask onSuccess:', { updatedTask, variables });
-
+    onSuccess: (updatedTask, _variables) => {
       // Update the cache with the server response
       queryClient.setQueryData(
         ['tasks', boardId],
@@ -543,11 +533,9 @@
         }
       );
     },
-    onSettled: (data, error, variables) => {
-      console.log('🏁 useMoveTask onSettled:', { data, error, variables });
-
-      // Ensure data consistency
-      queryClient.invalidateQueries({ queryKey: ['tasks', boardId] });
+    onSettled: (_data, _error, _variables) => {
+      // Ensure data consistency across all task-related caches
+      invalidateTaskCaches(queryClient, boardId);
     },
   });
 }