Files
goal-planner/frontend/App.tsx
T
2026-11-02 17:15:39 +08:00

511 lines
20 KiB
TypeScript

import React, { useState, useCallback, useEffect, useRef } from 'react';
import { loginUser, registerUser, getCurrentUser, generatePlan, updateTask, updateTaskStatus, createTask, deleteTask as apiDeleteTask, reorderTasks, logout as apiLogout, User, Plan, StatusUpdateResult, GenerateProgressEvent } from './services/apiService';
import { CascadeCompletedTask } from './types';
import LandingPage from './components/LandingPage';
import GoalInputForm from './components/GoalInputForm';
import PlannerView from './components/PlannerView';
import PlanHistory from './components/PlanHistory';
import Loader from './components/Loader';
import GenerationProgress from './components/GenerationProgress';
import Header from './components/Header';
import Footer from './components/Footer';
import LoginPage from './components/LoginPage';
import SignUpPage from './components/SignUpPage';
import ToastProvider, { toast } from './components/Toast';
import { useLanguage } from './i18n/LanguageContext';
type View = 'landing' | 'input' | 'loading' | 'planner' | 'error' | 'login' | 'signup' | 'history';
const App: React.FC = () => {
const { t } = useLanguage();
const [view, setView] = useState<View>('landing');
const [currentPlan, setCurrentPlan] = useState<Plan | null>(null);
const [goal, setGoal] = useState('');
const [error, setError] = useState<string | null>(null);
const [currentUser, setCurrentUser] = useState<User | null>(null);
const [isLoading, setIsLoading] = useState(true);
const [cascadeCompleted, setCascadeCompleted] = useState<CascadeCompletedTask[]>([]);
const cascadeConsumedRef = useRef(0);
const [lastXpGain, setLastXpGain] = useState(0);
const [levelUpInfo, setLevelUpInfo] = useState<{ oldLevel: number; newLevel: number } | null>(null);
const [darkMode, setDarkMode] = useState(() => {
const saved = localStorage.getItem('darkMode');
return saved === 'true';
});
const [genProgress, setGenProgress] = useState<{ progress: number; message: string; step: string } | null>(null);
// Apply dark mode
useEffect(() => {
document.documentElement.classList.toggle('dark', darkMode);
localStorage.setItem('darkMode', String(darkMode));
}, [darkMode]);
useEffect(() => {
const checkAuth = async () => {
const user = await getCurrentUser();
if (user) {
setCurrentUser(user);
setView('input');
}
setIsLoading(false);
};
checkAuth();
}, []);
const handleGetStarted = () => {
if (currentUser) {
setView('input');
} else {
setView('login');
}
};
const handleLogin = async (email: string, password: string) => {
try {
const { user } = await loginUser(email, password);
setCurrentUser(user);
setView('input');
toast.success(t('welcomeBack', { name: user.name }));
} catch (err) {
if (err instanceof Error) {
setError(err.message);
toast.error(err.message);
}
setView('login');
}
};
const handleSignUp = async (name: string, email: string, password: string) => {
try {
await registerUser(name, email, password);
const { user } = await loginUser(email, password);
setCurrentUser(user);
setView('input');
toast.success(t('signupSuccess'));
} catch (err) {
if (err instanceof Error) {
setError(err.message);
toast.error(err.message);
}
setView('signup');
}
};
const handleLogout = () => {
apiLogout();
setCurrentUser(null);
setCurrentPlan(null);
setGoal('');
setError(null);
setView('landing');
};
const handleGeneratePlan = async (userGoal: string, additionalInfo?: string) => {
setGoal(userGoal);
setView('loading');
setError(null);
setGenProgress({ progress: 5, message: t('preparing'), step: 'analyzing' });
try {
const plan = await generatePlan(userGoal, additionalInfo, (event: GenerateProgressEvent) => {
setGenProgress({
progress: event.progress,
message: event.message,
step: event.step || 'analyzing',
});
});
setCurrentPlan(plan);
setGenProgress(null);
setView('planner');
toast.success(t('planReady'));
} catch (err) {
setGenProgress(null);
if (err instanceof Error) {
setError(err.message);
toast.error(err.message);
} else {
setError(t('unknownError'));
toast.error(t('unknownError'));
}
setView('error');
}
};
const handleStartOver = () => {
setCurrentPlan(null);
setGoal('');
setError(null);
setView('input');
};
const handleResetToLanding = useCallback(() => {
setView('landing');
}, []);
const handleToggleTask = async (taskDbId: number) => {
if (!currentPlan) return;
const findTaskWithLevel = (items: Plan['tasks'], id: number, lvl: number = 0): { task: Plan['tasks'][0]; level: number } | null => {
for (const t of items) {
if (t.id === id) return { task: t, level: lvl };
if (t.children?.length) {
const found = findTaskWithLevel(t.children, id, lvl + 1);
if (found) return found;
}
}
return null;
};
const result = findTaskWithLevel(currentPlan.tasks, taskDbId);
if (!result) return;
const newStatus = result.task.status === 'done' ? 'todo' : 'done';
try {
const statusResult = await updateTaskStatus(currentPlan.id, taskDbId, newStatus);
const changeMap = new Map<number, string>();
for (const c of statusResult.changes) {
changeMap.set(c.id, c.status as 'todo' | 'in_progress' | 'done');
}
const cascadeParentTasks: CascadeCompletedTask[] = [];
for (const c of statusResult.changes) {
if (c.id !== taskDbId && c.status === 'done') {
const found = findTaskWithLevel(currentPlan.tasks, c.id);
if (found && found.task.children && found.task.children.length > 0) {
cascadeParentTasks.push({ taskId: c.id, level: found.level });
}
}
}
// Update XP state
if (statusResult.xp_change !== 0) {
setCurrentUser(prev => {
const updated = prev ? { ...prev, xp: statusResult.user_xp } : prev;
if (updated) localStorage.setItem('user', JSON.stringify(updated));
return updated;
});
setLastXpGain(statusResult.xp_change);
}
// Level up notification
if (statusResult.level_up) {
setLevelUpInfo({ oldLevel: statusResult.old_level, newLevel: statusResult.new_level });
setTimeout(() => setLevelUpInfo(null), 3000);
toast.success(t('levelUp', { old: statusResult.old_level, next: statusResult.new_level }));
}
// All done bonus notification
if (statusResult.all_done_bonus > 0) {
toast.success(t('allDoneBonus', { xp: statusResult.all_done_bonus }));
}
if (cascadeParentTasks.length > 0) {
cascadeConsumedRef.current = 0;
setCascadeCompleted(cascadeParentTasks);
}
setCurrentPlan(prev => {
if (!prev) return prev;
const applyChanges = (items: Plan['tasks']): Plan['tasks'] =>
items.map(t => {
const newStatusForTask = changeMap.get(t.id);
const updatedT = newStatusForTask ? { ...t, status: newStatusForTask } : t;
if (updatedT.children?.length) {
return { ...updatedT, children: applyChanges(updatedT.children) };
}
return updatedT;
});
return { ...prev, tasks: applyChanges(prev.tasks) };
});
} catch (err) {
if (err instanceof Error) {
toast.error(err.message);
}
}
};
const handleStatusChange = async (taskDbId: number, status: string) => {
if (!currentPlan) return;
try {
const statusResult = await updateTaskStatus(currentPlan.id, taskDbId, status);
const changeMap = new Map<number, string>();
for (const c of statusResult.changes) {
changeMap.set(c.id, c.status as 'todo' | 'in_progress' | 'done');
}
if (statusResult.xp_change !== 0) {
setCurrentUser(prev => {
const updated = prev ? { ...prev, xp: statusResult.user_xp } : prev;
if (updated) localStorage.setItem('user', JSON.stringify(updated));
return updated;
});
setLastXpGain(statusResult.xp_change);
}
if (statusResult.level_up) {
setLevelUpInfo({ oldLevel: statusResult.old_level, newLevel: statusResult.new_level });
setTimeout(() => setLevelUpInfo(null), 3000);
toast.success(t('levelUp', { old: statusResult.old_level, next: statusResult.new_level }));
}
if (statusResult.all_done_bonus > 0) {
toast.success(t('allDoneBonus', { xp: statusResult.all_done_bonus }));
}
setCurrentPlan(prev => {
if (!prev) return prev;
const applyChanges = (items: Plan['tasks']): Plan['tasks'] =>
items.map(t => {
const newStatusForTask = changeMap.get(t.id);
const updatedT = newStatusForTask ? { ...t, status: newStatusForTask } : t;
if (updatedT.children?.length) {
return { ...updatedT, children: applyChanges(updatedT.children) };
}
return updatedT;
});
return { ...prev, tasks: applyChanges(prev.tasks) };
});
} catch (err) {
if (err instanceof Error) {
toast.error(err.message);
}
}
};
const handleSaveTask = async (updatedTask: any) => {
if (!currentPlan) return;
try {
const task = await updateTask(currentPlan.id, updatedTask.id, {
title: updatedTask.title,
description: updatedTask.description,
dependencies: updatedTask.dependencies,
durationInHours: updatedTask.durationInHours,
priority: updatedTask.priority,
dueDate: updatedTask.dueDate,
});
setCurrentPlan(prev => {
if (!prev) return prev;
const updateTaskInTree = (items: Plan['tasks']): Plan['tasks'] =>
items.map(t =>
t.id === task.id
? { ...t, ...task, durationInHours: task.durationInHours, children: t.children }
: t.children?.length
? { ...t, children: updateTaskInTree(t.children) }
: t
);
return { ...prev, tasks: updateTaskInTree(prev.tasks) };
});
toast.success(t('taskUpdated'));
} catch (err) {
if (err instanceof Error) {
toast.error(err.message);
}
}
};
const handleDeleteTask = async (taskDbId: number) => {
if (!currentPlan) return;
try {
const result = await apiDeleteTask(currentPlan.id, taskDbId);
const deletedSet = new Set(result.deleted_ids);
setCurrentPlan(prev => {
if (!prev) return prev;
const removeTasks = (items: Plan['tasks']): Plan['tasks'] =>
items
.filter(t => !deletedSet.has(t.id))
.map(t => t.children?.length
? { ...t, children: removeTasks(t.children) }
: t
);
return { ...prev, tasks: removeTasks(prev.tasks) };
});
toast.success(t('taskDeleted'));
} catch (err) {
if (err instanceof Error) {
toast.error(err.message);
}
}
};
const handleAddTask = async (data: {
task_id: string;
title: string;
description: string;
parent_id?: number | null;
dependencies: string[];
durationInHours: number;
priority?: string;
dueDate?: string | null;
sortOrder?: number;
}) => {
if (!currentPlan) return;
try {
const newTask = await createTask(currentPlan.id, {
...data,
priority: data.priority as any,
dueDate: data.dueDate,
sortOrder: data.sortOrder,
});
setCurrentPlan(prev => {
if (!prev) return prev;
const addTaskToTree = (items: Plan['tasks']): Plan['tasks'] => {
if (data.parent_id === null || data.parent_id === undefined) {
return [...items, newTask];
}
return items.map(t => {
if (t.id === data.parent_id) {
return { ...t, children: [...(t.children || []), newTask] };
}
if (t.children?.length) {
return { ...t, children: addTaskToTree(t.children) };
}
return t;
});
};
return { ...prev, tasks: addTaskToTree(prev.tasks) };
});
toast.success(t('taskAdded'));
} catch (err) {
if (err instanceof Error) {
toast.error(err.message);
}
}
};
const handleReorderTasks = async (taskOrders: { id: number; sort_order: number }[]) => {
if (!currentPlan) return;
try {
await reorderTasks(currentPlan.id, taskOrders);
// Update local state optimistically
const orderMap = new Map(taskOrders.map(o => [o.id, o.sort_order]));
setCurrentPlan(prev => {
if (!prev) return prev;
const reorderItems = (items: Plan['tasks']): Plan['tasks'] =>
items
.map(t => {
const newSortOrder = orderMap.get(t.id) ?? t.sortOrder;
return {
...t,
sortOrder: newSortOrder,
children: t.children?.length ? reorderItems(t.children) : t.children,
};
})
.sort((a, b) => a.sortOrder - b.sortOrder);
return { ...prev, tasks: reorderItems(prev.tasks) };
});
} catch (err) {
if (err instanceof Error) {
toast.error(t('reorderFail'));
}
}
};
const handleViewPlan = (plan: Plan) => {
setCurrentPlan(plan);
setView('planner');
};
const handleMyPlans = () => {
setView('history');
};
const renderContent = () => {
switch (view) {
case 'landing':
return <LandingPage onGetStarted={handleGetStarted} />;
case 'login':
return <LoginPage onLogin={handleLogin} onNavigateToSignUp={() => setView('signup')} />;
case 'signup':
return <SignUpPage onSignUp={handleSignUp} onNavigateToLogin={() => setView('login')} />;
case 'input':
if (!currentUser) { setView('login'); return null; }
return <GoalInputForm onGeneratePlan={handleGeneratePlan} />;
case 'planner':
if (!currentUser || !currentPlan) { setView('login'); return null; }
return (
<PlannerView
goal={currentPlan.goal}
tasks={currentPlan.tasks}
planId={currentPlan.id}
onToggleTask={handleToggleTask}
onSaveTask={handleSaveTask}
onDeleteTask={handleDeleteTask}
onAddTask={handleAddTask}
onStatusChange={handleStatusChange}
onReorderTasks={handleReorderTasks}
onStartOver={handleStartOver}
onMyPlans={handleMyPlans}
cascadeCompleted={cascadeCompleted}
onCascadeConsumed={() => {
cascadeConsumedRef.current += 1;
if (cascadeConsumedRef.current >= cascadeCompleted.length) {
setCascadeCompleted([]);
}
}}
/>
);
case 'history':
if (!currentUser) { setView('login'); return null; }
return (
<PlanHistory
onViewPlan={handleViewPlan}
onCreateNew={() => setView('input')}
/>
);
case 'error':
return (
<div className="bg-red-100 dark:bg-red-900/30 border border-red-400 dark:border-red-700 text-red-700 dark:text-red-300 px-4 py-3 rounded-lg text-center">
<strong className="font-bold">{t('oops')}</strong>
<p className="block sm:inline">{error}</p>
<button
onClick={handleStartOver}
className="mt-4 bg-red-600 text-white font-semibold px-4 py-2 rounded-lg hover:bg-red-700 transition-colors"
>
{t('tryAgain')}
</button>
</div>
);
default:
return null;
}
};
if (isLoading) {
return <Loader message={t('loading')} />;
}
return (
<ToastProvider>
<div className="flex flex-col min-h-screen bg-gradient-to-b from-slate-100 via-slate-50 to-white dark:from-slate-950 dark:via-slate-900 dark:to-slate-900 transition-colors duration-200">
<Header
user={currentUser}
onLogout={handleLogout}
onLoginClick={() => setView('login')}
onSignUpClick={() => setView('signup')}
onLogoClick={handleResetToLanding}
onMyPlans={handleMyPlans}
xpGain={lastXpGain}
levelUpInfo={levelUpInfo}
darkMode={darkMode}
onToggleDarkMode={() => setDarkMode(!darkMode)}
/>
<main className="flex-grow container mx-auto px-4 sm:px-6 py-8 sm:py-10 md:py-14">
<div className="max-w-5xl mx-auto">
{renderContent()}
</div>
</main>
{view === 'landing' && <Footer />}
{view === 'loading' && !genProgress && <Loader message={t('generating')} />}
{view === 'loading' && genProgress && (
<GenerationProgress
progress={genProgress.progress}
message={genProgress.message}
step={genProgress.step}
/>
)}
</div>
</ToastProvider>
);
};
export default App;