working leantime widget 103

components/flow.tsx

@@ -10,19 +10,18 @@ interface Task {
   id: number;
   headline: string;
   description: string;
-  dateToFinish: string;
   date: string;
-  projectId: number;
+  dateToFinish: string;
-  projectName: string;
+  editorId: string;
-  status: number;
+  editorFirstname: string;
-  editorId?: string;
+  editorLastname: string;
-  editorFirstname?: string;
-  editorLastname?: string;
   authorFirstname: string;
   authorLastname: string;
-  milestoneHeadline?: string;
+  milestoneHeadline: string;
-  editTo?: string;
+  status: number;
-  editFrom?: string;
+  editTo: string;
+  editFrom: string;
+  projectName: string;
 }
 
 interface ProjectSummary {
@@ -34,7 +33,7 @@ interface ProjectSummary {
 }
 
 interface TaskWithDate extends Task {
-  validDate?: Date;
+  validDate: Date;
 }
 
 export function Flow() {
@@ -80,138 +79,43 @@ export function Flow() {
     }
   };
 
+  const getEffectiveDate = (task: Task): Date => {
+    const dateToFinish = new Date(task.dateToFinish);
+    const createdDate = new Date(task.date);
+    
+    if (task.dateToFinish && task.dateToFinish !== "0000-00-00 00:00:00") {
+      return dateToFinish;
+    }
+    return createdDate;
+  };
+
   const fetchTasks = async () => {
     setLoading(true);
     try {
-      const response = await fetch('/api/leantime/tasks');
+      const response = await fetch("/api/leantime/tasks");
-      if (!response.ok) {
-        throw new Error('Failed to fetch tasks');
-      }
       const data = await response.json();
-      
+
-      if (!data.tasks || !Array.isArray(data.tasks)) {
+      if (!Array.isArray(data)) {
-        console.warn('No tasks found in response', data as unknown);
+        console.warn("No tasks found in response", data as unknown);
         setTasks([]);
         return;
       }
 
-      // Debug log to see all tasks and their dates
+      const tasksWithDates: TaskWithDate[] = data.map((task: Task) => ({
-      data.tasks.forEach((task: Task) => {
+        ...task,
-        console.log(`Task ${task.id} - ${task.headline} - Full data:`, {
+        validDate: getEffectiveDate(task)
-          id: task.id,
+      }));
-          headline: task.headline,
-          dateToFinish: task.dateToFinish,
-          editTo: task.editTo,
-          editFrom: task.editFrom,
-          date: task.date,
-          status: task.status,
-          type: typeof task.dateToFinish
-        });
-      });
 
-      const getValidDate = (task: Task): Date | undefined => {
+      const filteredTasks = tasksWithDates
-        const tryParseDate = (dateStr: string | undefined, fieldName: string): Date | undefined => {
+        .filter(task => task.status !== 3)
-          if (!dateStr) {
+        .sort((a, b) => a.validDate.getTime() - b.validDate.getTime())
-            console.log(`${fieldName} for task ${task.id} is empty`);
+        .slice(0, 6);
-            return undefined;
-          }
-          
-          if (dateStr === '0000-00-00 00:00:00') {
-            console.log(`${fieldName} for task ${task.id} is zero date`);
-            return undefined;
-          }
 
-          try {
+      console.log("Filtered and sorted tasks:", filteredTasks);
-            const date = new Date(dateStr);
+      setTasks(filteredTasks);
-            if (isNaN(date.getTime())) {
-              console.log(`${fieldName} for task ${task.id} parsed to invalid date:`, dateStr);
-              return undefined;
-            }
-            
-            console.log(`Successfully parsed ${fieldName} for task ${task.id}:`, {
-              input: dateStr,
-              output: date.toISOString(),
-              timestamp: date.getTime()
-            });
-            return date;
-          } catch (error) {
-            console.error(`Error parsing ${fieldName} for task ${task.id}:`, error);
-            return undefined;
-          }
-        };
-
-        // Try each date field in order of priority
-        const dateToFinish = tryParseDate(task.dateToFinish, 'dateToFinish');
-        if (dateToFinish) {
-          console.log(`Using dateToFinish for task ${task.id}:`, dateToFinish.toISOString());
-          return dateToFinish;
-        }
-        
-        const editTo = tryParseDate(task.editTo, 'editTo');
-        if (editTo) {
-          console.log(`Using editTo for task ${task.id}:`, editTo.toISOString());
-          return editTo;
-        }
-        
-        const editFrom = tryParseDate(task.editFrom, 'editFrom');
-        if (editFrom) {
-          console.log(`Using editFrom for task ${task.id}:`, editFrom.toISOString());
-          return editFrom;
-        }
-        
-        const date = tryParseDate(task.date, 'date');
-        if (date) {
-          console.log(`Using date for task ${task.id}:`, date.toISOString());
-          return date;
-        }
-
-        console.log(`No valid date found for task ${task.id} - Raw values:`, {
-          dateToFinish: task.dateToFinish,
-          editTo: task.editTo,
-          editFrom: task.editFrom,
-          date: task.date
-        });
-        return undefined;
-      };
-
-      // Process and sort tasks
-      const processedTasks = data.tasks.map((task: Task): TaskWithDate => {
-        const validDate = getValidDate(task);
-        console.log(`Final date for task ${task.id}:`, {
-          headline: task.headline,
-          validDate: validDate?.toISOString() || 'NO DATE',
-          rawDateToFinish: task.dateToFinish
-        });
-        return { ...task, validDate };
-      });
-
-      // Sort tasks
-      const sortedTasks = processedTasks.sort((a: TaskWithDate, b: TaskWithDate) => {
-        if (a.validDate && b.validDate) {
-          return a.validDate.getTime() - b.validDate.getTime();
-        }
-        if (!a.validDate && !b.validDate) {
-          return b.id - a.id;
-        }
-        return a.validDate ? -1 : 1;
-      });
-
-      console.log('Final sorted tasks:', sortedTasks.map((t: TaskWithDate) => ({
-        id: t.id,
-        headline: t.headline,
-        validDate: t.validDate?.toISOString(),
-        rawDates: {
-          dateToFinish: t.dateToFinish,
-          editTo: t.editTo,
-          editFrom: t.editFrom,
-          date: t.date
-        }
-      })));
-
-      setTasks(sortedTasks);
     } catch (error) {
-      console.error('Error fetching tasks:', error);
+      console.error("Error fetching tasks:", error);
-      setError('Failed to fetch tasks');
+      setError("Failed to fetch tasks");
     } finally {
       setLoading(false);
     }