Merge pull request #690 from callumalpass:fix/multiday-tasks-in-calendar

callumalpass · web-flow · commit 489986518fba · 2025-09-17T22:27:23.000+10:00
Advanced calendar + Pomodoro fixes for multi-day events and auto-start (#641, $647)
diff --git a/src/modals/TimeblockInfoModal.ts b/src/modals/TimeblockInfoModal.ts
@@ -6,6 +6,7 @@ import {
     getAllDailyNotes,
     appHasDailyNotesPluginLoaded
 } from 'obsidian-daily-notes-interface';
+import { formatDateForStorage } from '../utils/dateUtils';
 
 export interface TimeBlock {
     title: string;
@@ -23,6 +24,7 @@ export interface TimeBlock {
 export class TimeblockInfoModal extends Modal {
     private timeblock: TimeBlock;
     private eventDate: Date;
+    private timeblockDate: string;
     private plugin: TaskNotesPlugin;
     private originalTimeblock: TimeBlock;
     
@@ -35,12 +37,13 @@ export class TimeblockInfoModal extends Modal {
     private selectedAttachments: TAbstractFile[] = [];
     private attachmentsList: HTMLElement;
 
-    constructor(app: App, plugin: TaskNotesPlugin, timeblock: TimeBlock, eventDate: Date) {
+    constructor(app: App, plugin: TaskNotesPlugin, timeblock: TimeBlock, eventDate: Date, timeblockDate?: string) {
         super(app);
         this.plugin = plugin;
         this.timeblock = { ...timeblock }; // Create a copy for editing
         this.originalTimeblock = timeblock; // Keep original for comparison
         this.eventDate = eventDate;
+        this.timeblockDate = timeblockDate || formatDateForStorage(eventDate);
     }
 
     async onOpen() {
@@ -280,8 +283,8 @@ export class TimeblockInfoModal extends Modal {
         }
 
         // Get daily note for the date
-        const dateStr = this.eventDate.toISOString().split('T')[0]; // YYYY-MM-DD
-        const moment = (window as any).moment(dateStr);
+        const dateStr = this.timeblockDate;
+        const moment = (window as any).moment(dateStr, 'YYYY-MM-DD');
         const allDailyNotes = getAllDailyNotes();
         const dailyNote = getDailyNote(moment, allDailyNotes);
 
@@ -406,8 +409,8 @@ export class TimeblockInfoModal extends Modal {
         }
 
         // Get daily note for the date
-        const dateStr = this.eventDate.toISOString().split('T')[0]; // YYYY-MM-DD
-        const moment = (window as any).moment(dateStr);
+        const dateStr = this.timeblockDate;
+        const moment = (window as any).moment(dateStr, 'YYYY-MM-DD');
         const allDailyNotes = getAllDailyNotes();
         const dailyNote = getDailyNote(moment, allDailyNotes);
 
@@ -474,4 +477,4 @@ export class TimeblockInfoModal extends Modal {
         const { contentEl } = this;
         contentEl.empty();
     }
-}
+}
diff --git a/src/services/PomodoroService.ts b/src/services/PomodoroService.ts
@@ -28,6 +28,9 @@ export class PomodoroService {
     private activeAudioContexts: Set<AudioContext> = new Set();
     private cleanupTimeouts: Set<number> = new Set();
     private webhookNotifier?: IWebhookNotifier;
+    private lastSelectedTaskPath?: string;
+    private lastSelectedTaskPathLoaded = false;
+    private lastWorkSessionTaskPath?: string;
 
     constructor(plugin: TaskNotesPlugin) {
         this.plugin = plugin;
@@ -136,6 +139,8 @@ export class PomodoroService {
     }
 
     async saveLastSelectedTask(taskPath: string | undefined) {
+        this.lastSelectedTaskPath = taskPath;
+        this.lastSelectedTaskPathLoaded = true;
         try {
             const data = await this.plugin.loadData() || {};
             data.lastSelectedTaskPath = taskPath;
@@ -146,9 +151,19 @@ export class PomodoroService {
     }
 
     async getLastSelectedTaskPath(): Promise<string | undefined> {
+        if (this.lastSelectedTaskPathLoaded) {
+            return this.lastSelectedTaskPath;
+        }
         try {
             const data = await this.plugin.loadData();
-            return data?.lastSelectedTaskPath;
+            const path = data?.lastSelectedTaskPath;
+            if (typeof path === 'string' && path.trim().length > 0) {
+                this.lastSelectedTaskPath = path;
+            } else {
+                this.lastSelectedTaskPath = undefined;
+            }
+            this.lastSelectedTaskPathLoaded = true;
+            return this.lastSelectedTaskPath;
         } catch (error) {
             console.error('Failed to load last selected task:', error);
             return undefined;
@@ -190,7 +205,13 @@ export class PomodoroService {
                 // endTime will be set when paused or completed
             }]
         };
-        
+
+        if (task?.path) {
+            this.lastWorkSessionTaskPath = task.path;
+            this.lastSelectedTaskPath = task.path;
+            this.lastSelectedTaskPathLoaded = true;
+        }
+
         this.state.currentSession = session;
         this.state.isRunning = true;
         this.state.timeRemaining = durationSeconds;
@@ -481,6 +502,72 @@ export class PomodoroService {
         }
     }
 
+    private async autoStartWorkSession(): Promise<void> {
+        if (this.state.isRunning) {
+            return;
+        }
+
+        try {
+            const task = await this.getAutoStartTask();
+            if (task) {
+                await this.startPomodoro(task);
+            } else {
+                await this.startPomodoro();
+            }
+        } catch (error) {
+            console.error('Failed to auto-start work session:', error);
+        }
+    }
+
+    private async getAutoStartTask(): Promise<TaskInfo | undefined> {
+        const candidatePaths: string[] = [];
+
+        if (this.lastWorkSessionTaskPath) {
+            candidatePaths.push(this.lastWorkSessionTaskPath);
+        }
+
+        if (this.state.currentSession?.taskPath) {
+            candidatePaths.push(this.state.currentSession.taskPath);
+        }
+
+        const persistedPath = await this.getLastSelectedTaskPath();
+        if (persistedPath) {
+            candidatePaths.push(persistedPath);
+        }
+
+        const uniquePaths = Array.from(new Set(candidatePaths.filter(path => typeof path === 'string' && path.length > 0)));
+
+        for (const path of uniquePaths) {
+            try {
+                const task = await this.plugin.cacheManager.getTaskInfo(path);
+                if (!task) {
+                    this.clearCachedTaskPath(path);
+                    continue;
+                }
+                if (task.archived || this.plugin.statusManager.isCompletedStatus(task.status)) {
+                    this.clearCachedTaskPath(path);
+                    continue;
+                }
+                return task;
+            } catch (error) {
+                console.warn(`Failed to load task for auto-start (${path}):`, error);
+            }
+        }
+
+        return undefined;
+    }
+
+    private clearCachedTaskPath(path: string): void {
+        if (this.lastWorkSessionTaskPath === path) {
+            this.lastWorkSessionTaskPath = undefined;
+        }
+
+        if (this.lastSelectedTaskPath === path) {
+            this.lastSelectedTaskPath = undefined;
+            this.lastSelectedTaskPathLoaded = true;
+        }
+    }
+
     private async completePomodoro() {
         this.stopTimer();
         
@@ -491,7 +578,11 @@ export class PomodoroService {
         const session = this.state.currentSession;
         session.completed = true;
         session.endTime = getCurrentTimestamp();
-        
+
+        if (session.type === 'work' && session.taskPath) {
+            this.lastWorkSessionTaskPath = session.taskPath;
+        }
+
         // End the current active period if it's still running
         if (session.activePeriods.length > 0) {
             const currentPeriod = session.activePeriods[session.activePeriods.length - 1];
@@ -595,7 +686,9 @@ export class PomodoroService {
             
             // Auto-start work if configured, otherwise just prepare the timer
             if (this.plugin.settings.pomodoroAutoStartWork) {
-                const timeout = setTimeout(() => this.startPomodoro(), 1000) as unknown as number;
+                const timeout = setTimeout(() => {
+                    this.autoStartWorkSession();
+                }, 1000) as unknown as number;
                 this.cleanupTimeouts.add(timeout);
             }
         }
@@ -756,6 +849,17 @@ export class PomodoroService {
 
         // Update the current session's task
         this.state.currentSession.taskPath = task?.path;
+
+        if (task?.path) {
+            this.lastWorkSessionTaskPath = task.path;
+            this.lastSelectedTaskPath = task.path;
+            this.lastSelectedTaskPathLoaded = true;
+        } else {
+            this.lastWorkSessionTaskPath = undefined;
+            this.lastSelectedTaskPath = undefined;
+            this.lastSelectedTaskPathLoaded = true;
+        }
+
         await this.saveState();
 
         // Emit tick event to update UI
@@ -1123,4 +1227,4 @@ export class PomodoroService {
             throw error;
         }
     }
-}
+}
diff --git a/src/utils/viewOptimizations.ts b/src/utils/viewOptimizations.ts
@@ -1,6 +1,6 @@
 import { ItemView } from 'obsidian';
 import { ViewPerformanceService, ViewPerformanceConfig, ViewUpdateHandler } from '../services/ViewPerformanceService';
-import { TaskInfo } from '../types';
+import { TaskInfo, TimeEntry } from '../types';
 import TaskNotesPlugin from '../main';
 
 /**
@@ -67,13 +67,19 @@ export function shouldRefreshForDateBasedView(
     if (!originalTask) return true;
 
     // For date-based views (calendars, agendas), check if date-related fields or visual properties changed
+    const timeEntriesChanged = !areTimeEntriesEqual(originalTask.timeEntries, updatedTask.timeEntries);
     return originalTask.due !== updatedTask.due ||
            originalTask.scheduled !== updatedTask.scheduled ||
            originalTask.status !== updatedTask.status ||
            originalTask.completedDate !== updatedTask.completedDate ||
            originalTask.recurrence !== updatedTask.recurrence ||
            originalTask.priority !== updatedTask.priority || // Priority affects event visual appearance
-           originalTask.title !== updatedTask.title; // Title changes should be reflected
+           originalTask.title !== updatedTask.title || // Title changes should be reflected
+           originalTask.archived !== updatedTask.archived || // Archived tasks should disappear from date-based views
+           originalTask.path !== updatedTask.path || // Path changes indicate the file moved and need re-render
+           originalTask.timeEstimate !== updatedTask.timeEstimate || // Duration changes affect multi-day rendering
+           originalTask.totalTrackedTime !== updatedTask.totalTrackedTime || // Time tracking summary changes event info
+           timeEntriesChanged; // Time entry adjustments affect rendered segments
 }
 
 /**
@@ -219,4 +225,23 @@ export class ViewPerformanceMonitor {
         this.startTimer(operation);
         return fn().finally(() => this.endTimer(operation));
     }
-}
+}
+
+function areTimeEntriesEqual(a?: TimeEntry[], b?: TimeEntry[]): boolean {
+    if (a === b) return true;
+    if (!a || !b) return a === b;
+    if (a.length !== b.length) return false;
+
+    for (let i = 0; i < a.length; i++) {
+        const entryA = a[i];
+        const entryB = b[i];
+        if (entryA.startTime !== entryB.startTime ||
+            entryA.endTime !== entryB.endTime ||
+            entryA.description !== entryB.description ||
+            entryA.duration !== entryB.duration) {
+            return false;
+        }
+    }
+
+    return true;
+}
diff --git a/src/views/AdvancedCalendarView.ts b/src/views/AdvancedCalendarView.ts
@@ -81,6 +81,7 @@ interface CalendarEvent {
         recurringTemplateTime?: string; // Original scheduled time
         subscriptionName?: string; // For ICS events
         attachments?: string[]; // For timeblocks
+        originalDate?: string; // For timeblock daily note reference
     };
 }
 
@@ -1015,6 +1016,8 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
             const start = parseDateToLocal(startDate);
             const end = new Date(start.getTime() + (task.timeEstimate * 60 * 1000));
             endDate = format(end, "yyyy-MM-dd'T'HH:mm");
+        } else if (!hasTime) {
+            endDate = this.calculateAllDayEndDate(startDate, task.timeEstimate);
         }
         
         // Get priority-based color for border
@@ -1231,6 +1234,8 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
             const start = parseDateToLocal(eventStart);
             const end = new Date(start.getTime() + (task.timeEstimate * 60 * 1000));
             endDate = format(end, "yyyy-MM-dd'T'HH:mm");
+        } else if (!hasTime) {
+            endDate = this.calculateAllDayEndDate(eventStart, task.timeEstimate);
         }
         
         // Get priority-based color for border
@@ -1273,6 +1278,8 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
             const start = parseDateToLocal(eventStart);
             const end = new Date(start.getTime() + (task.timeEstimate * 60 * 1000));
             endDate = format(end, "yyyy-MM-dd'T'HH:mm");
+        } else if (!hasTime) {
+            endDate = this.calculateAllDayEndDate(eventStart, task.timeEstimate);
         }
         
         // Get priority-based color for border
@@ -1307,6 +1314,18 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
         };
     }
 
+    private calculateAllDayEndDate(startDate: string, timeEstimate?: number): string | undefined {
+        if (!timeEstimate || timeEstimate <= 0) {
+            return undefined;
+        }
+
+        const minutesPerDay = 60 * 24;
+        const start = parseDateToLocal(startDate);
+        const days = Math.max(1, Math.ceil(timeEstimate / minutesPerDay));
+        const end = new Date(start.getTime() + (days * minutesPerDay * 60 * 1000));
+        return format(end, 'yyyy-MM-dd');
+    }
+
     // Event handlers
     handleDateSelect(selectInfo: any) {
         const { start, end, allDay, jsEvent } = selectInfo;
@@ -1496,7 +1515,7 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
             console.warn('[AdvancedCalendarView] Event clicked without extendedProps');
             return;
         }
-        const { taskInfo, icsEvent, timeblock, eventType, subscriptionName } = clickInfo.event.extendedProps;
+        const { taskInfo, icsEvent, timeblock, eventType, subscriptionName, originalDate } = clickInfo.event.extendedProps;
         const jsEvent = clickInfo.jsEvent;
 
         // Skip task events in list view - they have their own TaskCard-style handlers
@@ -1515,8 +1534,8 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
         }
         
         if (eventType === 'timeblock') {
-            // Timeblocks are read-only for now, could add editing later
-            this.showTimeblockInfo(timeblock, clickInfo.event.start);
+            // Timeblocks can be edited via modal
+            this.showTimeblockInfo(timeblock, clickInfo.event.start, originalDate);
             return;
         }
         
@@ -2767,8 +2786,8 @@ export class AdvancedCalendarView extends ItemView implements OptimizedView {
         modal.open();
     }
 
-    private showTimeblockInfo(timeblock: TimeBlock, eventDate: Date): void {
-        const modal = new TimeblockInfoModal(this.app, this.plugin, timeblock, eventDate);
+    private showTimeblockInfo(timeblock: TimeBlock, eventDate: Date, originalDate?: string): void {
+        const modal = new TimeblockInfoModal(this.app, this.plugin, timeblock, eventDate, originalDate);
         modal.open();
     }
 
