working leantime widget 105

components/flow.tsx

@@ -10,18 +10,19 @@ interface Task {
   id: number;
   headline: string;
   description: string;
-  date: string;
   dateToFinish: string;
-  editorId: string;
+  date: string;
-  editorFirstname: string;
+  projectId: number;
-  editorLastname: string;
+  projectName: string;
+  status: number;
+  editorId?: string;
+  editorFirstname?: string;
+  editorLastname?: string;
   authorFirstname: string;
   authorLastname: string;
-  milestoneHeadline: string;
+  milestoneHeadline?: string;
-  status: number;
+  editTo?: string;
-  editTo: string;
+  editFrom?: string;
-  editFrom: string;
-  projectName: string;
 }
 
 interface ProjectSummary {
@@ -33,7 +34,7 @@ interface ProjectSummary {
 }
 
 interface TaskWithDate extends Task {
-  validDate: Date;
+  validDate?: Date;
 }
 
 export function Flow() {
@@ -79,43 +80,123 @@ 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 (!Array.isArray(data)) {
+      if (!data.tasks || !Array.isArray(data.tasks)) {
-        console.warn("No tasks found in response", data as unknown);
+        console.warn('No tasks found in response', data as unknown);
         setTasks([]);
         return;
       }
 
-      const tasksWithDates: TaskWithDate[] = data.map((task: Task) => ({
+      // Debug log to see all tasks and their dates
-        ...task,
+      data.tasks.forEach((task: Task) => {
-        validDate: getEffectiveDate(task)
+        console.log(`Task ${task.id} - ${task.headline}:`, {
-      }));
+          dateToFinish: task.dateToFinish,
+          editTo: task.editTo,
+          editFrom: task.editFrom,
+          date: task.date
+        });
+      });
 
-      // Show all tasks, sorted by date
+      const getValidDate = (task: Task): Date | undefined => {
-      const sortedTasks = tasksWithDates
+        const tryParseDate = (dateStr: string | undefined, fieldName: string): Date | undefined => {
-        .sort((a, b) => a.validDate.getTime() - b.validDate.getTime())
+          console.log(`Trying to parse ${fieldName} for task ${task.id}:`, dateStr);
-        .slice(0, 6);
+          
+          if (!dateStr) {
+            console.log(`${fieldName} is empty or undefined for task ${task.id}`);
+            return undefined;
+          }
+          
+          if (dateStr === '0000-00-00 00:00:00') {
+            console.log(`${fieldName} is invalid format (0000-00-00) for task ${task.id}`);
+            return undefined;
+          }
+          
+          try {
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+              console.log(`${fieldName} parsed to invalid date for task ${task.id}`);
+              return undefined;
+            }
+            
+            console.log(`${fieldName} successfully parsed to: ${date.toISOString()} for task ${task.id}`);
+            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}`);
+          return dateToFinish;
+        }
+        
+        const editTo = tryParseDate(task.editTo, 'editTo');
+        if (editTo) {
+          console.log(`Using editTo for task ${task.id}`);
+          return editTo;
+        }
+        
+        const editFrom = tryParseDate(task.editFrom, 'editFrom');
+        if (editFrom) {
+          console.log(`Using editFrom for task ${task.id}`);
+          return editFrom;
+        }
+        
+        const date = tryParseDate(task.date, 'date');
+        if (date) {
+          console.log(`Using date for task ${task.id}`);
+          return date;
+        }
+
+        console.log(`No valid date found for task ${task.id}`);
+        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}:`, validDate?.toISOString() || 'NO DATE');
+        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(),
+        dates: {
+          dateToFinish: t.dateToFinish,
+          editTo: t.editTo,
+          editFrom: t.editFrom,
+          date: t.date
+        }
+      })));
 
-      console.log("Sorted tasks:", sortedTasks);
       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);
     }