Improvement of Task filtering status

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

@@ -1,6 +1,7 @@
 import { AssigneeSelect } from './_components/assignee-select';
 import { TaskActions } from './task-actions';
 import { useDeleteTask, useUpdateTask } from '@/lib/task-helper';
+import { moveTask } from '@/lib/task-helper';
 import { useSortable } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
 import { createClient } from '@tuturuuu/supabase/next/client';
@@ -29,6 +30,7 @@
   DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from '@tuturuuu/ui/dropdown-menu';
+import { toast } from '@tuturuuu/ui/hooks/use-toast';
 import {
   AlertCircle,
   Calendar,
@@ -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

@@ -2,6 +2,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 
 // Type interfaces for better type safety
+interface ProcessedAssignee {
+  id: string;
+  display_name: string | null;
+  avatar_url: string | null;
+}
+
 interface TaskAssigneeData {
   user: {
     id: string;
@@ -14,14 +20,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 +40,7 @@
   end_date: string | null;
   created_at: string | null;
   list_id: string;
+  archived: boolean | null;
   task_lists: TaskListData | null;
   assignees?: TaskAssigneeData[];
 }
@@ -87,6 +97,9 @@
     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
       .from('tasks')
@@ -101,9 +114,11 @@
         end_date,
         created_at,
         list_id,
+        archived,
         task_lists!inner (
           id,
           name,
+          status,
           board_id,
           workspace_boards!inner (
             id,
@@ -123,6 +138,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 +165,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 +175,28 @@
         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) => {
-              if (!uniqueUsers.has(user.id)) {
-                uniqueUsers.set(user.id, user);
-              }
-              return uniqueUsers;
-            }, new Map<string, NonNullable<typeof task.assignees>[0]['user']>())
+            .map((a: TaskAssigneeData) => a.user)
+            .filter((u): u is ProcessedAssignee => !!u?.id)
+            .reduce(
+              (
+                uniqueUsers: Map<string, ProcessedAssignee>,
+                user: ProcessedAssignee
+              ) => {
+                if (!uniqueUsers.has(user.id)) {
+                  uniqueUsers.set(user.id, user);
+                }
+                return uniqueUsers;
+              },
+              new Map()
+            )
             .values(),
         ],
         // Add helper field to identify if current user is assigned

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

@@ -143,13 +143,33 @@
   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 +182,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 +214,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 +486,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 +509,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 +522,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 +534,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);
     },
   });
 }