+ {/* Welcome header */}
+
+
+
+ 欢迎回来，{user?.name || "球友"}
+
+
+
+ 已完成 {stats?.totalSessions || 0} 次训练
+
+
+
+
+ setLocation("/training")} className="gap-2">
+
+ setLocation("/analysis")} className="gap-2">
+
+
+
+
+ {/* Stats cards */}
+
+
+
+
+
+
NTRP评分
+
+ {(stats?.ntrpRating || 1.5).toFixed(1)}
+
+
+
+
+
+
+
+
+
+
+
训练次数
+
{stats?.totalSessions || 0}
+
+
+
+
+
+
+
+
+
+
训练时长
+
{stats?.totalMinutes || 0}分钟
+
+
+
+
+
+
+
+
+
+
+
总击球数
+
{stats?.totalShots || 0}
+
+
+
+
+
+
+
+ {/* Rating trend chart */}
+
+
+
+
+
+
+ setLocation("/rating")} className="text-xs gap-1">
+ 查看详情
+
+
+
+ {ratingData.length > 0 ? (
+
+
+
+
+
+
+
+
+ ) : (
+
+ )}
+
+
+
+ {/* Recent analyses */}
+
+
+
+
+
+ setLocation("/videos")} className="text-xs gap-1">
+ 查看全部
+
+
+
+ {(stats?.recentAnalyses?.length || 0) > 0 ? (
+
+ {stats!.recentAnalyses.slice(0, 4).map((a: any) => (
+
+
+
+ {Math.round(a.overallScore || 0)}
+
+
+
{a.exerciseType || "综合分析"}
+
+ {new Date(a.createdAt).toLocaleDateString("zh-CN")}
+ {a.shotCount ? ` · ${a.shotCount}次击球` : ""}
+
+
+
+
+
+
{Math.round(a.overallScore || 0)}分
+
+
+ ))}
+
+
+
+
+ {/* Quick actions */}
+
+
+ 快速开始
+
+
+
+
setLocation("/training")}
+ className="flex items-center gap-3 p-4 rounded-xl border hover:bg-accent transition-colors text-left"
+ >
+
+
+
+
+
setLocation("/analysis")}
+ className="flex items-center gap-3 p-4 rounded-xl border hover:bg-accent transition-colors text-left"
+ >
+
+
+
+
上传视频分析
+
MediaPipe AI姿势识别
+
+
setLocation("/rating")}
+ className="flex items-center gap-3 p-4 rounded-xl border hover:bg-accent transition-colors text-left"
+ >
+
+
+
+
+
+
-
- {/* Example: lucide-react for icons */}
- Any **markdown** content
- Example Button
-
+
+ {/* Hero */}
+
+
+
+
+
+
+
+ 在家也能提升
+ 网球技术水平
+
+
+ 只需一支球拍，通过AI姿势识别和智能训练计划，在家高效训练。
+ 实时分析挥拍动作，自动评分，持续进步。
+
+
+ setLocation("/login")} size="lg" className="gap-2 h-12 px-6">
+ 免费开始训练
+
+
+
+
+ {/* Features */}
+
+ 核心功能
+
+ {[
+ {
+ icon: Video,
+ title: "AI姿势识别",
+ desc: "基于MediaPipe的浏览器端实时姿势分析，识别33个身体关键点，精准评估挥拍动作",
+ color: "bg-blue-50 text-blue-600",
+ },
+ {
+ icon: Target,
+ title: "智能训练计划",
+ desc: "根据您的水平和分析结果，AI自动生成和调整个性化训练方案，只需球拍即可在家训练",
+ color: "bg-green-50 text-green-600",
+ },
+ {
+ icon: Award,
+ title: "NTRP自动评分",
+ desc: "基于美国网球协会标准，从5个维度综合评估您的技术水平，自动更新评分",
+ color: "bg-purple-50 text-purple-600",
+ },
+ {
+ icon: Zap,
+ title: "击球统计分析",
+ desc: "自动检测击球次数、挥拍速度、击球一致性，量化每次训练效果",
+ color: "bg-orange-50 text-orange-600",
+ },
+ {
+ icon: Footprints,
+ title: "运动轨迹追踪",
+ desc: "记录身体重心移动轨迹，分析脚步移动模式，提升步法灵活性",
+ color: "bg-teal-50 text-teal-600",
+ },
+ {
+ icon: TrendingUp,
+ title: "进度可视化",
+ desc: "直观展示训练历史、能力提升趋势和评分变化，激励持续进步",
+ color: "bg-indigo-50 text-indigo-600",
+ },
+ ].map((feature) => (
+
+
+
+
{feature.title}
+
{feature.desc}
+
+ ))}
+
+
+ {/* How it works */}
+
+ 使用流程
+
+ {[
+ { step: "1", title: "输入用户名", desc: "无需注册，输入用户名即可开始" },
+ { step: "2", title: "生成训练计划", desc: "选择水平，AI生成个性化方案" },
+ { step: "3", title: "上传训练视频", desc: "录制挥拍视频并上传分析" },
+ { step: "4", title: "获取评分建议", desc: "查看分析结果和矫正建议" },
+ ].map((item) => (
+
+
+ {item.step}
+
+
{item.title}
+
{item.desc}
+
+ ))}
+
+
+ {/* CTA */}
+
+
+
准备好提升网球技术了吗？
+
完全免费，无需注册，输入用户名即可开始
+
setLocation("/login")} size="lg" className="gap-2">
+ 立即开始
+
+
+
+ {/* Footer */}
+
);
}
diff --git a/client/src/pages/Login.tsx b/client/src/pages/Login.tsx
new file mode 100644
index 0000000..c2e0507
--- /dev/null
+++ b/client/src/pages/Login.tsx
@@ -0,0 +1,102 @@
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { trpc } from "@/lib/trpc";
+import { useLocation } from "wouter";
+import { toast } from "sonner";
+import { Target, Loader2 } from "lucide-react";
+
+export default function Login() {
+ const [username, setUsername] = useState("");
+ const [, setLocation] = useLocation();
+ const loginMutation = trpc.auth.loginWithUsername.useMutation({
+ onSuccess: (data) => {
+ toast.success(data.isNew ? `欢迎加入，${data.user.name}！` : `欢迎回来，${data.user.name}！`);
+ setLocation("/dashboard");
+ },
+ onError: (err) => {
+ toast.error("登录失败: " + err.message);
+ },
+ });
+
+ const handleLogin = (e: React.FormEvent) => {
+ e.preventDefault();
+ if (!username.trim()) {
+ toast.error("请输入用户名");
+ return;
+ }
+ loginMutation.mutate({ username: username.trim() });
+ };
+
+ return (
+
+
+
+
+
+
Tennis Training Hub
+
AI驱动的在家网球训练助手
+
+
+
+
+ 开始训练
+ 输入用户名即可开始使用
+
+
+
+
+
+
+
+
+
+ 无需注册，输入用户名即可使用全部功能
+
+
+
+ );
+}
diff --git a/client/src/pages/Progress.tsx b/client/src/pages/Progress.tsx
new file mode 100644
index 0000000..b0c8d5a
--- /dev/null
+++ b/client/src/pages/Progress.tsx
@@ -0,0 +1,215 @@
+import { useAuth } from "@/_core/hooks/useAuth";
+import { trpc } from "@/lib/trpc";
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Button } from "@/components/ui/button";
+import { Activity, Calendar, CheckCircle2, Clock, TrendingUp, Target } from "lucide-react";
+import {
+ ResponsiveContainer, BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip,
+ LineChart, Line, Legend
+} from "recharts";
+import { useLocation } from "wouter";
+
+export default function Progress() {
+ const { user } = useAuth();
+ const { data: records, isLoading } = trpc.record.list.useQuery({ limit: 100 });
+ const { data: analyses } = trpc.analysis.list.useQuery();
+ const { data: stats } = trpc.profile.stats.useQuery();
+ const [, setLocation] = useLocation();
+
+ if (isLoading) {
+ return (
+
+ {[1, 2, 3].map(i =>
+ );
+ }
+
+ // Aggregate data by date for charts
+ const dateMap = new Map
();
+ (records || []).forEach((r: any) => {
+ const date = new Date(r.trainingDate || r.createdAt).toLocaleDateString("zh-CN", { month: "short", day: "numeric" });
+ const existing = dateMap.get(date) || { date, sessions: 0, minutes: 0, avgScore: 0, scores: [] };
+ existing.sessions++;
+ existing.minutes += r.durationMinutes || 0;
+ if (r.poseScore) existing.scores.push(r.poseScore);
+ dateMap.set(date, existing);
+ });
+
+ const chartData = Array.from(dateMap.values()).map(d => ({
+ ...d,
+ avgScore: d.scores.length > 0 ? Math.round(d.scores.reduce((a, b) => a + b, 0) / d.scores.length) : 0,
+ }));
+
+ // Analysis score trend
+ const scoreTrend = (analyses || []).map((a: any) => ({
+ date: new Date(a.createdAt).toLocaleDateString("zh-CN", { month: "short", day: "numeric" }),
+ overall: Math.round(a.overallScore || 0),
+ consistency: Math.round(a.strokeConsistency || 0),
+ footwork: Math.round(a.footworkScore || 0),
+ fluidity: Math.round(a.fluidityScore || 0),
+ }));
+
+ const completedRecords = (records || []).filter((r: any) => r.completed === 1);
+ const totalMinutes = (records || []).reduce((sum: number, r: any) => sum + (r.durationMinutes || 0), 0);
+
+ return (
+
+
+
训练进度
+
追踪您的训练历史和能力提升趋势
+
+
+ {/* Summary stats */}
+
+
+
+
+ {stats?.totalSessions || 0}
+
+
+
+
+
+
+ {totalMinutes}分钟
+
+
+
+
+
+
+ {completedRecords.length}
+
+
+
+
+
+
+ {analyses?.length || 0}次
+
+
+
+
+
+ {/* Training frequency chart */}
+
+
+
+
+
+
+ {chartData.length > 0 ? (
+
+
+
+
+ ) : (
+
+ )}
+
+
+
+ {/* Score improvement trend */}
+
+
+
+
+
+
+ {scoreTrend.length > 0 ? (
+
+
+
+
+ ) : (
+
+ )}
+
+
+
+
+ {/* Recent records */}
+
+
+ 最近训练记录
+
+
+ {(records?.length || 0) > 0 ? (
+
+ {(records || []).slice(0, 20).map((record: any) => (
+
+
+
+ {record.completed ?
:
}
+
+
+
{record.exerciseName}
+
+ {new Date(record.trainingDate || record.createdAt).toLocaleDateString("zh-CN")}
+ {record.durationMinutes ? ` · ${record.durationMinutes}分钟` : ""}
+
+
+
+
+ {record.poseScore && (
+ {Math.round(record.poseScore)}分
+ )}
+ {record.completed ? (
+ 已完成
+ ) : (
+ 进行中
+ )}
+
+
+ ))}
+
+
+
还没有训练记录
+
setLocation("/training")} className="mt-2">
+ 开始第一次训练
+
+
+
+
+
+ );
+ }
+
+ return (
+
+
+
NTRP评分系统
+
基于所有历史训练记录自动计算的综合评分
+
+
+ {/* Current rating card */}
+
+
+
+
+
+ {currentRating.toFixed(1)}
+
+
+
{level.label}
+
{level.desc}
+
+
+
NTRP {currentRating.toFixed(1)}
+
+
+
+
+
+
+
+ {/* Radar chart */}
+
+
+
+
+ 五维度综合能力评估
+
+
+ {Object.keys(dimensions).length > 0 ? (
+
+
+
+
+ ) : (
+
+ )}
+
+
+
+ {/* Rating trend */}
+
+
+
+
+ NTRP评分随时间的变化
+
+
+ {trendData.length > 0 ? (
+
+
+
+
+
+
+
+
+ ) : (
+
+ )}
+
+
+
+
+ {/* Dimension details */}
+
+
+ 评分维度说明
+ NTRP评分由以下五个维度加权计算
+
+
+
+ {[
+ { icon: Target, label: "姿势准确性", weight: "30%", desc: "关节角度与标准动作的匹配度", value: dimensions.poseAccuracy },
+ { icon: Zap, label: "击球一致性", weight: "25%", desc: "多次击球动作的稳定性", value: dimensions.strokeConsistency },
+ { icon: Footprints, label: "脚步移动", weight: "20%", desc: "步法灵活性和重心转移", value: dimensions.footwork },
+ { icon: Wind, label: "动作流畅性", weight: "15%", desc: "动作连贯性和平滑度", value: dimensions.fluidity },
+ { icon: Activity, label: "力量", weight: "10%", desc: "挥拍速度和爆发力", value: dimensions.power },
+ ].map(item => (
+
+
+ {item.label}
+
+
{item.value ? Math.round(item.value) : "--"}
+
权重 {item.weight}
+
{item.desc}
+
+ ))}
+
+
+
+ {/* NTRP level reference */}
+
+
+ NTRP等级参考
+ 美国网球协会(USTA)标准评级体系
+
+
+
+ {NTRP_LEVELS.map(l => (
+
= l.min && currentRating < l.max
+ ? "bg-primary/5 border border-primary/20"
+ : "hover:bg-muted/50"
+ }`}
+ >
+
+ {l.min.toFixed(1)}-{l.max.toFixed(1)}
+
+
+ {currentRating >= l.min && currentRating < l.max && (
+
当前等级
+ )}
+
+ ))}
+
+
+
= {
+ "影子挥拍": = {
+ "影子挥拍": "bg-blue-50 text-blue-700 border-blue-200",
+ "脚步移动": "bg-green-50 text-green-700 border-green-200",
+ "体能训练": "bg-orange-50 text-orange-700 border-orange-200",
+ "墙壁练习": "bg-purple-50 text-purple-700 border-purple-200",
+};
+
+type Exercise = {
+ day: number;
+ name: string;
+ category: string;
+ duration: number;
+ description: string;
+ tips: string;
+ sets: number;
+ reps: number;
+};
+
+export default function Training() {
+ const { user } = useAuth();
+ const [skillLevel, setSkillLevel] = useState<"beginner" | "intermediate" | "advanced">("beginner");
+ const [durationDays, setDurationDays] = useState(7);
+ const [selectedDay, setSelectedDay] = useState(1);
+
+ const utils = trpc.useUtils();
+ const { data: activePlan, isLoading: planLoading } = trpc.plan.active.useQuery();
+
+ const generateMutation = trpc.plan.generate.useMutation({
+ onSuccess: () => {
+ toast.success("训练计划已生成！");
+ utils.plan.active.invalidate();
+ utils.plan.list.invalidate();
+ },
+ onError: (err) => toast.error("生成失败: " + err.message),
+ });
+
+ const adjustMutation = trpc.plan.adjust.useMutation({
+ onSuccess: (data) => {
+ toast.success("训练计划已调整！");
+ utils.plan.active.invalidate();
+ if (data.adjustmentNotes) toast.info("调整说明: " + data.adjustmentNotes);
+ },
+ onError: (err) => toast.error("调整失败: " + err.message),
+ });
+
+ const recordMutation = trpc.record.create.useMutation({
+ onSuccess: () => toast.success("训练记录已创建"),
+ });
+
+ const completeMutation = trpc.record.complete.useMutation({
+ onSuccess: () => {
+ toast.success("训练已完成！");
+ utils.profile.stats.invalidate();
+ },
+ });
+
+ const exercises = useMemo(() => {
+ if (!activePlan?.exercises) return [];
+ return (activePlan.exercises as Exercise[]).filter(e => e.day === selectedDay);
+ }, [activePlan, selectedDay]);
+
+ const totalDays = activePlan?.durationDays || 7;
+
+ if (planLoading) {
+ return (
+
+
+ );
+ }
+
+ return (
+
+
+
+
训练计划
+
AI为您定制的在家网球训练方案
+
+
+
+ {!activePlan ? (
+ /* Generate new plan */
+
+
+
+
+
+ 根据您的水平和目标，AI将生成个性化的在家训练方案（只需球拍）
+
+
+
+
+
+ 技能水平
+ setSkillLevel(v)}>
+
+
+
+ 初级 - 刚开始学习网球
+ 中级 - 有一定基础
+ 高级 - 有丰富经验
+
+
+
+
+ 训练周期
+ setDurationDays(Number(v))}>
+
+
+
+ 3天计划
+ 7天计划
+ 14天计划
+ 30天计划
+
+
+
+
generateMutation.mutate({ skillLevel, durationDays })}
+ disabled={generateMutation.isPending}
+ className="w-full sm:w-auto gap-2"
+ >
+ {generateMutation.isPending ? (
+ <>
+
+
+ ) : (
+ /* Active plan display */
+ <>
+
+
+
+
+ {activePlan.title}
+
+
+ {activePlan.skillLevel === "beginner" ? "初级" : activePlan.skillLevel === "intermediate" ? "中级" : "高级"}
+
+ {activePlan.durationDays}天计划
+ {activePlan.version > 1 && (
+ v{activePlan.version} 已调整
+ )}
+
+
+
adjustMutation.mutate({ planId: activePlan.id })}
+ disabled={adjustMutation.isPending}
+ className="gap-1"
+ >
+ {adjustMutation.isPending ? (
+
+
+ 调整说明： {activePlan.adjustmentNotes}
+
+ )}
+
+
+ {/* Day selector */}
+
+ {Array.from({ length: totalDays }, (_, i) => i + 1).map(day => (
+ setSelectedDay(day)}
+ className={`shrink-0 w-10 h-10 rounded-xl text-sm font-medium transition-all ${
+ selectedDay === day
+ ? "bg-primary text-primary-foreground shadow-md"
+ : "bg-muted hover:bg-accent"
+ }`}
+ >
+ {day}
+
+ ))}
+
+
+ 第 {selectedDay} 天训练
+
+ {exercises.length > 0 ? (
+
+ {exercises.map((ex, idx) => (
+
+
+
+
+ {categoryIcons[ex.category] ||
+
+
{ex.name}
+
{ex.description}
+
+
+
+ {ex.sets}组 × {ex.reps}次
+
+ {ex.tips && (
+
+ 💡 {ex.tips}
+
+ )}
+
+
+
{
+ recordMutation.mutate({
+ planId: activePlan.id,
+ exerciseName: ex.name,
+ durationMinutes: ex.duration,
+ });
+ }}
+ >
+
+
+
+ ))}
+
+
+
+
+ {
+ generateMutation.mutate({ skillLevel, durationDays });
+ }}
+ disabled={generateMutation.isPending}
+ className="gap-2"
+ >
+
+
+
+ )}
+
= {
+ pending: { label: "待分析", color: "bg-yellow-100 text-yellow-700" },
+ analyzing: { label: "分析中", color: "bg-blue-100 text-blue-700" },
+ completed: { label: "已完成", color: "bg-green-100 text-green-700" },
+ failed: { label: "失败", color: "bg-red-100 text-red-700" },
+};
+
+const exerciseTypeMap: Record = {
+ forehand: "正手挥拍",
+ backhand: "反手挥拍",
+ serve: "发球",
+ volley: "截击",
+ footwork: "脚步移动",
+ shadow: "影子挥拍",
+ wall: "墙壁练习",
+};
+
+export default function Videos() {
+ const { user } = useAuth();
+ const { data: videos, isLoading } = trpc.video.list.useQuery();
+ const { data: analyses } = trpc.analysis.list.useQuery();
+ const [, setLocation] = useLocation();
+
+ const getAnalysis = (videoId: number) => {
+ return analyses?.find((a: any) => a.videoId === videoId);
+ };
+
+ if (isLoading) {
+ return (
+
+
+ );
+ }
+
+ return (
+
+
+
+
训练视频库
+
+ 管理您的所有训练视频及分析结果 · 共 {videos?.length || 0} 个视频
+
+
+
setLocation("/analysis")} className="gap-2">
+
+
+
+ {(!videos || videos.length === 0) ? (
+
+
+ 还没有训练视频
+ 上传您的训练视频，AI将自动分析姿势并给出建议
+ setLocation("/analysis")} className="gap-2">
+
+
+
+ ) : (
+
+ {videos.map((video: any) => {
+ const analysis = getAnalysis(video.id);
+ const status = statusMap[video.analysisStatus] || statusMap.pending;
+
+ return (
+
+
+
+ {/* Thumbnail / icon */}
+
+ {video.url ? (
+
+ ) : (
+
+ )}
+
+
+ {/* Info */}
+
+
+
+
{video.title}
+
+ {status.label}
+ {video.exerciseType && (
+
+ {exerciseTypeMap[video.exerciseType] || video.exerciseType}
+
+ )}
+
+
+
+ {(video.fileSize / 1024 / 1024).toFixed(1)}MB
+
+
+
+
+
+ {/* Analysis summary */}
+ {analysis && (
+
+
+ {Math.round(analysis.overallScore || 0)}分
+
+ {(analysis.shotCount ?? 0) > 0 && (
+
+ {analysis.shotCount}次击球
+
+ )}
+ {(analysis.avgSwingSpeed ?? 0) > 0 && (
+
+ 速度 {(analysis.avgSwingSpeed ?? 0).toFixed(1)}
+
+ )}
+ {(analysis.strokeConsistency ?? 0) > 0 && (
+
+ 一致性 {Math.round(analysis.strokeConsistency ?? 0)}%
+
+ )}
+
+ )}
+
+
+
+ );
+ })}
+
+ )}
+
| null = null;
-// Lazily create the drizzle instance so local tooling can run without a DB.
export async function getDb() {
if (!_db && process.env.DATABASE_URL) {
try {
@@ -18,26 +25,19 @@ export async function getDb() {
return _db;
}
-export async function upsertUser(user: InsertUser): Promise {
- if (!user.openId) {
- throw new Error("User openId is required for upsert");
- }
+// ===== USER OPERATIONS =====
+export async function upsertUser(user: InsertUser): Promise {
+ if (!user.openId) throw new Error("User openId is required for upsert");
const db = await getDb();
- if (!db) {
- console.warn("[Database] Cannot upsert user: database not available");
- return;
- }
+ if (!db) { console.warn("[Database] Cannot upsert user: database not available"); return; }
try {
- const values: InsertUser = {
- openId: user.openId,
- };
+ const values: InsertUser = { openId: user.openId };
const updateSet: Record = {};
const textFields = ["name", "email", "loginMethod"] as const;
type TextField = (typeof textFields)[number];
-
const assignNullable = (field: TextField) => {
const value = user[field];
if (value === undefined) return;
@@ -45,48 +45,222 @@ export async function upsertUser(user: InsertUser): Promise {
values[field] = normalized;
updateSet[field] = normalized;
};
-
textFields.forEach(assignNullable);
- if (user.lastSignedIn !== undefined) {
- values.lastSignedIn = user.lastSignedIn;
- updateSet.lastSignedIn = user.lastSignedIn;
- }
- if (user.role !== undefined) {
- values.role = user.role;
- updateSet.role = user.role;
- } else if (user.openId === ENV.ownerOpenId) {
- values.role = 'admin';
- updateSet.role = 'admin';
- }
+ if (user.lastSignedIn !== undefined) { values.lastSignedIn = user.lastSignedIn; updateSet.lastSignedIn = user.lastSignedIn; }
+ if (user.role !== undefined) { values.role = user.role; updateSet.role = user.role; }
+ else if (user.openId === ENV.ownerOpenId) { values.role = 'admin'; updateSet.role = 'admin'; }
+ if (!values.lastSignedIn) values.lastSignedIn = new Date();
+ if (Object.keys(updateSet).length === 0) updateSet.lastSignedIn = new Date();
- if (!values.lastSignedIn) {
- values.lastSignedIn = new Date();
- }
-
- if (Object.keys(updateSet).length === 0) {
- updateSet.lastSignedIn = new Date();
- }
-
- await db.insert(users).values(values).onDuplicateKeyUpdate({
- set: updateSet,
- });
- } catch (error) {
- console.error("[Database] Failed to upsert user:", error);
- throw error;
- }
+ await db.insert(users).values(values).onDuplicateKeyUpdate({ set: updateSet });
+ } catch (error) { console.error("[Database] Failed to upsert user:", error); throw error; }
}
export async function getUserByOpenId(openId: string) {
const db = await getDb();
- if (!db) {
- console.warn("[Database] Cannot get user: database not available");
- return undefined;
- }
-
+ if (!db) return undefined;
const result = await db.select().from(users).where(eq(users.openId, openId)).limit(1);
-
return result.length > 0 ? result[0] : undefined;
}
-// TODO: add feature queries here as your schema grows.
+export async function getUserByUsername(username: string) {
+ const db = await getDb();
+ if (!db) return undefined;
+ const result = await db.select().from(usernameAccounts).where(eq(usernameAccounts.username, username)).limit(1);
+ if (result.length === 0) return undefined;
+ const userResult = await db.select().from(users).where(eq(users.id, result[0].userId)).limit(1);
+ return userResult.length > 0 ? userResult[0] : undefined;
+}
+
+export async function createUsernameAccount(username: string): Promise<{ user: typeof users.$inferSelect; isNew: boolean }> {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+
+ // Check if username already exists
+ const existing = await db.select().from(usernameAccounts).where(eq(usernameAccounts.username, username)).limit(1);
+ if (existing.length > 0) {
+ const user = await db.select().from(users).where(eq(users.id, existing[0].userId)).limit(1);
+ if (user.length > 0) {
+ await db.update(users).set({ lastSignedIn: new Date() }).where(eq(users.id, user[0].id));
+ return { user: user[0], isNew: false };
+ }
+ }
+
+ // Create new user with username as openId
+ const openId = `username_${username}_${Date.now()}`;
+ await db.insert(users).values({
+ openId,
+ name: username,
+ loginMethod: "username",
+ lastSignedIn: new Date(),
+ ntrpRating: 1.5,
+ totalSessions: 0,
+ totalMinutes: 0,
+ });
+
+ const newUser = await db.select().from(users).where(eq(users.openId, openId)).limit(1);
+ if (newUser.length === 0) throw new Error("Failed to create user");
+
+ await db.insert(usernameAccounts).values({ username, userId: newUser[0].id });
+ return { user: newUser[0], isNew: true };
+}
+
+export async function updateUserProfile(userId: number, data: {
+ skillLevel?: "beginner" | "intermediate" | "advanced";
+ trainingGoals?: string;
+ ntrpRating?: number;
+ totalSessions?: number;
+ totalMinutes?: number;
+}) {
+ const db = await getDb();
+ if (!db) return;
+ await db.update(users).set(data).where(eq(users.id, userId));
+}
+
+// ===== TRAINING PLAN OPERATIONS =====
+
+export async function createTrainingPlan(plan: InsertTrainingPlan) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ // Deactivate existing active plans
+ await db.update(trainingPlans).set({ isActive: 0 }).where(and(eq(trainingPlans.userId, plan.userId), eq(trainingPlans.isActive, 1)));
+ const result = await db.insert(trainingPlans).values(plan);
+ return result[0].insertId;
+}
+
+export async function getUserTrainingPlans(userId: number) {
+ const db = await getDb();
+ if (!db) return [];
+ return db.select().from(trainingPlans).where(eq(trainingPlans.userId, userId)).orderBy(desc(trainingPlans.createdAt));
+}
+
+export async function getActivePlan(userId: number) {
+ const db = await getDb();
+ if (!db) return undefined;
+ const result = await db.select().from(trainingPlans).where(and(eq(trainingPlans.userId, userId), eq(trainingPlans.isActive, 1))).limit(1);
+ return result.length > 0 ? result[0] : undefined;
+}
+
+export async function updateTrainingPlan(planId: number, data: Partial) {
+ const db = await getDb();
+ if (!db) return;
+ await db.update(trainingPlans).set(data).where(eq(trainingPlans.id, planId));
+}
+
+// ===== VIDEO OPERATIONS =====
+
+export async function createVideo(video: InsertTrainingVideo) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ const result = await db.insert(trainingVideos).values(video);
+ return result[0].insertId;
+}
+
+export async function getUserVideos(userId: number) {
+ const db = await getDb();
+ if (!db) return [];
+ return db.select().from(trainingVideos).where(eq(trainingVideos.userId, userId)).orderBy(desc(trainingVideos.createdAt));
+}
+
+export async function getVideoById(videoId: number) {
+ const db = await getDb();
+ if (!db) return undefined;
+ const result = await db.select().from(trainingVideos).where(eq(trainingVideos.id, videoId)).limit(1);
+ return result.length > 0 ? result[0] : undefined;
+}
+
+export async function updateVideoStatus(videoId: number, status: "pending" | "analyzing" | "completed" | "failed") {
+ const db = await getDb();
+ if (!db) return;
+ await db.update(trainingVideos).set({ analysisStatus: status }).where(eq(trainingVideos.id, videoId));
+}
+
+// ===== POSE ANALYSIS OPERATIONS =====
+
+export async function createPoseAnalysis(analysis: InsertPoseAnalysis) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ const result = await db.insert(poseAnalyses).values(analysis);
+ return result[0].insertId;
+}
+
+export async function getAnalysisByVideoId(videoId: number) {
+ const db = await getDb();
+ if (!db) return undefined;
+ const result = await db.select().from(poseAnalyses).where(eq(poseAnalyses.videoId, videoId)).orderBy(desc(poseAnalyses.createdAt)).limit(1);
+ return result.length > 0 ? result[0] : undefined;
+}
+
+export async function getUserAnalyses(userId: number) {
+ const db = await getDb();
+ if (!db) return [];
+ return db.select().from(poseAnalyses).where(eq(poseAnalyses.userId, userId)).orderBy(desc(poseAnalyses.createdAt));
+}
+
+// ===== TRAINING RECORD OPERATIONS =====
+
+export async function createTrainingRecord(record: InsertTrainingRecord) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ const result = await db.insert(trainingRecords).values(record);
+ return result[0].insertId;
+}
+
+export async function getUserTrainingRecords(userId: number, limit = 50) {
+ const db = await getDb();
+ if (!db) return [];
+ return db.select().from(trainingRecords).where(eq(trainingRecords.userId, userId)).orderBy(desc(trainingRecords.trainingDate)).limit(limit);
+}
+
+export async function markRecordCompleted(recordId: number, poseScore?: number) {
+ const db = await getDb();
+ if (!db) return;
+ await db.update(trainingRecords).set({ completed: 1, poseScore: poseScore ?? null }).where(eq(trainingRecords.id, recordId));
+}
+
+// ===== RATING HISTORY OPERATIONS =====
+
+export async function createRatingEntry(entry: InsertRatingHistory) {
+ const db = await getDb();
+ if (!db) throw new Error("Database not available");
+ const result = await db.insert(ratingHistory).values(entry);
+ return result[0].insertId;
+}
+
+export async function getUserRatingHistory(userId: number, limit = 30) {
+ const db = await getDb();
+ if (!db) return [];
+ return db.select().from(ratingHistory).where(eq(ratingHistory.userId, userId)).orderBy(desc(ratingHistory.createdAt)).limit(limit);
+}
+
+// ===== STATS HELPERS =====
+
+export async function getUserStats(userId: number) {
+ const db = await getDb();
+ if (!db) return null;
+
+ const [userRow] = await db.select().from(users).where(eq(users.id, userId)).limit(1);
+ if (!userRow) return null;
+
+ const analyses = await db.select().from(poseAnalyses).where(eq(poseAnalyses.userId, userId));
+ const records = await db.select().from(trainingRecords).where(eq(trainingRecords.userId, userId));
+ const videos = await db.select().from(trainingVideos).where(eq(trainingVideos.userId, userId));
+ const ratings = await db.select().from(ratingHistory).where(eq(ratingHistory.userId, userId)).orderBy(desc(ratingHistory.createdAt)).limit(30);
+
+ const completedRecords = records.filter(r => r.completed === 1);
+ const totalShots = analyses.reduce((sum, a) => sum + (a.shotCount || 0), 0);
+ const avgScore = analyses.length > 0 ? analyses.reduce((sum, a) => sum + (a.overallScore || 0), 0) / analyses.length : 0;
+
+ return {
+ ntrpRating: userRow.ntrpRating || 1.5,
+ totalSessions: completedRecords.length,
+ totalMinutes: records.reduce((sum, r) => sum + (r.durationMinutes || 0), 0),
+ totalVideos: videos.length,
+ analyzedVideos: videos.filter(v => v.analysisStatus === "completed").length,
+ totalShots,
+ averageScore: Math.round(avgScore * 10) / 10,
+ ratingHistory: ratings.reverse(),
+ recentAnalyses: analyses.slice(0, 10),
+ };
+}
diff --git a/server/features.test.ts b/server/features.test.ts
new file mode 100644
index 0000000..3614c09
--- /dev/null
+++ b/server/features.test.ts
@@ -0,0 +1,237 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { appRouter } from "./routers";
+import { COOKIE_NAME } from "../shared/const";
+import type { TrpcContext } from "./_core/context";
+
+type AuthenticatedUser = NonNullable;
+
+function createTestUser(overrides?: Partial): AuthenticatedUser {
+ return {
+ id: 1,
+ openId: "test-user-001",
+ email: "test@example.com",
+ name: "TestPlayer",
+ loginMethod: "username",
+ role: "user",
+ skillLevel: "beginner",
+ trainingGoals: null,
+ ntrpRating: 1.5,
+ totalSessions: 0,
+ totalMinutes: 0,
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ lastSignedIn: new Date(),
+ ...overrides,
+ };
+}
+
+function createMockContext(user: AuthenticatedUser | null = null): {
+ ctx: TrpcContext;
+ clearedCookies: { name: string; options: Record }[];
+ setCookies: { name: string; value: string; options: Record }[];
+} {
+ const clearedCookies: { name: string; options: Record }[] = [];
+ const setCookies: { name: string; value: string; options: Record }[] = [];
+
+ return {
+ ctx: {
+ user,
+ req: {
+ protocol: "https",
+ headers: {},
+ } as TrpcContext["req"],
+ res: {
+ clearCookie: (name: string, options: Record) => {
+ clearedCookies.push({ name, options });
+ },
+ cookie: (name: string, value: string, options: Record) => {
+ setCookies.push({ name, value, options });
+ },
+ } as TrpcContext["res"],
+ },
+ clearedCookies,
+ setCookies,
+ };
+}
+
+describe("auth.me", () => {
+ it("returns null for unauthenticated users", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+ const result = await caller.auth.me();
+ expect(result).toBeNull();
+ });
+
+ it("returns user data for authenticated users", async () => {
+ const user = createTestUser();
+ const { ctx } = createMockContext(user);
+ const caller = appRouter.createCaller(ctx);
+ const result = await caller.auth.me();
+ expect(result).toBeDefined();
+ expect(result?.name).toBe("TestPlayer");
+ expect(result?.openId).toBe("test-user-001");
+ });
+});
+
+describe("auth.logout", () => {
+ it("clears the session cookie and reports success", async () => {
+ const user = createTestUser();
+ const { ctx, clearedCookies } = createMockContext(user);
+ const caller = appRouter.createCaller(ctx);
+
+ const result = await caller.auth.logout();
+
+ expect(result).toEqual({ success: true });
+ expect(clearedCookies).toHaveLength(1);
+ expect(clearedCookies[0]?.name).toBe(COOKIE_NAME);
+ expect(clearedCookies[0]?.options).toMatchObject({
+ maxAge: -1,
+ secure: true,
+ sameSite: "none",
+ httpOnly: true,
+ path: "/",
+ });
+ });
+});
+
+describe("profile.stats", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+ await expect(caller.profile.stats()).rejects.toThrow();
+ });
+});
+
+describe("plan.generate input validation", () => {
+ it("rejects invalid skill level", async () => {
+ const user = createTestUser();
+ const { ctx } = createMockContext(user);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.plan.generate({
+ skillLevel: "expert" as any,
+ durationDays: 7,
+ })
+ ).rejects.toThrow();
+ });
+
+ it("rejects invalid duration", async () => {
+ const user = createTestUser();
+ const { ctx } = createMockContext(user);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.plan.generate({
+ skillLevel: "beginner",
+ durationDays: 0,
+ })
+ ).rejects.toThrow();
+ });
+
+ it("rejects duration over 30", async () => {
+ const user = createTestUser();
+ const { ctx } = createMockContext(user);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.plan.generate({
+ skillLevel: "beginner",
+ durationDays: 31,
+ })
+ ).rejects.toThrow();
+ });
+});
+
+describe("video.upload input validation", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.video.upload({
+ title: "test",
+ format: "mp4",
+ fileSize: 1000,
+ fileBase64: "dGVzdA==",
+ })
+ ).rejects.toThrow();
+ });
+});
+
+describe("analysis.save input validation", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.analysis.save({
+ videoId: 1,
+ overallScore: 75,
+ })
+ ).rejects.toThrow();
+ });
+});
+
+describe("analysis.getCorrections input validation", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.analysis.getCorrections({
+ poseMetrics: {},
+ exerciseType: "forehand",
+ detectedIssues: [],
+ })
+ ).rejects.toThrow();
+ });
+});
+
+describe("record.create input validation", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+
+ await expect(
+ caller.record.create({
+ exerciseName: "正手挥拍",
+ durationMinutes: 30,
+ })
+ ).rejects.toThrow();
+ });
+
+ it("accepts valid exercise name", async () => {
+ const user = createTestUser();
+ const { ctx } = createMockContext(user);
+ const caller = appRouter.createCaller(ctx);
+
+ // This should not throw on input validation (may throw on DB)
+ // We just verify the input schema accepts a valid name
+ try {
+ await caller.record.create({
+ exerciseName: "正手挥拍",
+ durationMinutes: 30,
+ });
+ } catch (e: any) {
+ // DB errors are expected in test env, but input validation should pass
+ expect(e.message).not.toContain("invalid_type");
+ }
+ });
+});
+
+describe("rating.history", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+ await expect(caller.rating.history()).rejects.toThrow();
+ });
+});
+
+describe("rating.current", () => {
+ it("requires authentication", async () => {
+ const { ctx } = createMockContext(null);
+ const caller = appRouter.createCaller(ctx);
+ await expect(caller.rating.current()).rejects.toThrow();
+ });
+});
diff --git a/server/routers.ts b/server/routers.ts
index 21836ad..16e9521 100644
--- a/server/routers.ts
+++ b/server/routers.ts
@@ -1,28 +1,479 @@
-import { COOKIE_NAME } from "@shared/const";
+import { COOKIE_NAME, ONE_YEAR_MS } from "@shared/const";
import { getSessionCookieOptions } from "./_core/cookies";
import { systemRouter } from "./_core/systemRouter";
-import { publicProcedure, router } from "./_core/trpc";
+import { publicProcedure, protectedProcedure, router } from "./_core/trpc";
+import { z } from "zod";
+import { sdk } from "./_core/sdk";
+import { invokeLLM } from "./_core/llm";
+import { storagePut } from "./storage";
+import * as db from "./db";
+import { nanoid } from "nanoid";
export const appRouter = router({
- // if you need to use socket.io, read and register route in server/_core/index.ts, all api should start with '/api/' so that the gateway can route correctly
system: systemRouter,
+
auth: router({
me: publicProcedure.query(opts => opts.ctx.user),
logout: publicProcedure.mutation(({ ctx }) => {
const cookieOptions = getSessionCookieOptions(ctx.req);
ctx.res.clearCookie(COOKIE_NAME, { ...cookieOptions, maxAge: -1 });
- return {
- success: true,
- } as const;
+ return { success: true } as const;
+ }),
+
+ // Username-based login
+ loginWithUsername: publicProcedure
+ .input(z.object({ username: z.string().min(1).max(64) }))
+ .mutation(async ({ ctx, input }) => {
+ const { user, isNew } = await db.createUsernameAccount(input.username);
+ const sessionToken = await sdk.createSessionToken(user.openId, {
+ name: user.name || input.username,
+ expiresInMs: ONE_YEAR_MS,
+ });
+ const cookieOptions = getSessionCookieOptions(ctx.req);
+ ctx.res.cookie(COOKIE_NAME, sessionToken, { ...cookieOptions, maxAge: ONE_YEAR_MS });
+ return { user, isNew };
+ }),
+ }),
+
+ // User profile management
+ profile: router({
+ update: protectedProcedure
+ .input(z.object({
+ skillLevel: z.enum(["beginner", "intermediate", "advanced"]).optional(),
+ trainingGoals: z.string().optional(),
+ }))
+ .mutation(async ({ ctx, input }) => {
+ await db.updateUserProfile(ctx.user.id, input);
+ return { success: true };
+ }),
+ stats: protectedProcedure.query(async ({ ctx }) => {
+ return db.getUserStats(ctx.user.id);
}),
}),
- // TODO: add feature routers here, e.g.
- // todo: router({
- // list: protectedProcedure.query(({ ctx }) =>
- // db.getUserTodos(ctx.user.id)
- // ),
- // }),
+ // Training plan management
+ plan: router({
+ generate: protectedProcedure
+ .input(z.object({
+ skillLevel: z.enum(["beginner", "intermediate", "advanced"]),
+ durationDays: z.number().min(1).max(30).default(7),
+ focusAreas: z.array(z.string()).optional(),
+ }))
+ .mutation(async ({ ctx, input }) => {
+ const user = ctx.user;
+ // Get user's recent analyses for personalization
+ const analyses = await db.getUserAnalyses(user.id);
+ const recentScores = analyses.slice(0, 5).map(a => ({
+ score: a.overallScore,
+ issues: a.detectedIssues,
+ exerciseType: a.exerciseType,
+ shotCount: a.shotCount,
+ strokeConsistency: a.strokeConsistency,
+ footworkScore: a.footworkScore,
+ }));
+
+ const prompt = `你是一位专业网球教练。请为一位${
+ input.skillLevel === "beginner" ? "初级" : input.skillLevel === "intermediate" ? "中级" : "高级"
+ }水平的网球学员生成一个${input.durationDays}天的在家训练计划。
+
+要求：
+- 只需要球拍，不需要球场和球网
+- 包含影子挥拍、墙壁练习、脚步移动、体能训练等
+- 每天训练30-60分钟
+${input.focusAreas?.length ? `- 重点关注: ${input.focusAreas.join(", ")}` : ""}
+${recentScores.length > 0 ? `- 用户最近的分析数据: ${JSON.stringify(recentScores)}` : ""}
+
+请返回JSON格式，包含每天的训练内容。`;
+
+ const response = await invokeLLM({
+ messages: [
+ { role: "system", content: "你是专业网球教练AI助手。返回严格的JSON格式。" },
+ { role: "user", content: prompt },
+ ],
+ response_format: {
+ type: "json_schema",
+ json_schema: {
+ name: "training_plan",
+ strict: true,
+ schema: {
+ type: "object",
+ properties: {
+ title: { type: "string", description: "训练计划标题" },
+ exercises: {
+ type: "array",
+ items: {
+ type: "object",
+ properties: {
+ day: { type: "number" },
+ name: { type: "string" },
+ category: { type: "string" },
+ duration: { type: "number", description: "分钟" },
+ description: { type: "string" },
+ tips: { type: "string" },
+ sets: { type: "number" },
+ reps: { type: "number" },
+ },
+ required: ["day", "name", "category", "duration", "description", "tips", "sets", "reps"],
+ additionalProperties: false,
+ },
+ },
+ },
+ required: ["title", "exercises"],
+ additionalProperties: false,
+ },
+ },
+ },
+ });
+
+ const content = response.choices[0]?.message?.content;
+ const parsed = typeof content === "string" ? JSON.parse(content) : null;
+ if (!parsed) throw new Error("Failed to generate training plan");
+
+ const planId = await db.createTrainingPlan({
+ userId: user.id,
+ title: parsed.title,
+ skillLevel: input.skillLevel,
+ durationDays: input.durationDays,
+ exercises: parsed.exercises,
+ isActive: 1,
+ version: 1,
+ });
+
+ return { planId, plan: parsed };
+ }),
+
+ list: protectedProcedure.query(async ({ ctx }) => {
+ return db.getUserTrainingPlans(ctx.user.id);
+ }),
+
+ active: protectedProcedure.query(async ({ ctx }) => {
+ return db.getActivePlan(ctx.user.id);
+ }),
+
+ adjust: protectedProcedure
+ .input(z.object({ planId: z.number() }))
+ .mutation(async ({ ctx, input }) => {
+ const analyses = await db.getUserAnalyses(ctx.user.id);
+ const recentAnalyses = analyses.slice(0, 5);
+ const currentPlan = (await db.getUserTrainingPlans(ctx.user.id)).find(p => p.id === input.planId);
+ if (!currentPlan) throw new Error("Plan not found");
+
+ const prompt = `基于以下用户的姿势分析结果，调整训练计划：
+
+当前计划: ${JSON.stringify(currentPlan.exercises)}
+最近分析结果: ${JSON.stringify(recentAnalyses.map(a => ({
+ score: a.overallScore,
+ issues: a.detectedIssues,
+ corrections: a.corrections,
+ shotCount: a.shotCount,
+ strokeConsistency: a.strokeConsistency,
+ footworkScore: a.footworkScore,
+ fluidityScore: a.fluidityScore,
+ })))}
+
+请根据分析结果调整训练计划，增加针对薄弱环节的训练，返回与原计划相同格式的JSON。`;
+
+ const response = await invokeLLM({
+ messages: [
+ { role: "system", content: "你是专业网球教练AI助手。返回严格的JSON格式。" },
+ { role: "user", content: prompt },
+ ],
+ response_format: {
+ type: "json_schema",
+ json_schema: {
+ name: "adjusted_plan",
+ strict: true,
+ schema: {
+ type: "object",
+ properties: {
+ title: { type: "string" },
+ adjustmentNotes: { type: "string", description: "调整说明" },
+ exercises: {
+ type: "array",
+ items: {
+ type: "object",
+ properties: {
+ day: { type: "number" },
+ name: { type: "string" },
+ category: { type: "string" },
+ duration: { type: "number" },
+ description: { type: "string" },
+ tips: { type: "string" },
+ sets: { type: "number" },
+ reps: { type: "number" },
+ },
+ required: ["day", "name", "category", "duration", "description", "tips", "sets", "reps"],
+ additionalProperties: false,
+ },
+ },
+ },
+ required: ["title", "adjustmentNotes", "exercises"],
+ additionalProperties: false,
+ },
+ },
+ },
+ });
+
+ const content = response.choices[0]?.message?.content;
+ const parsed = typeof content === "string" ? JSON.parse(content) : null;
+ if (!parsed) throw new Error("Failed to adjust plan");
+
+ await db.updateTrainingPlan(input.planId, {
+ exercises: parsed.exercises,
+ adjustmentNotes: parsed.adjustmentNotes,
+ version: (currentPlan.version || 1) + 1,
+ });
+
+ return { success: true, adjustmentNotes: parsed.adjustmentNotes };
+ }),
+ }),
+
+ // Video management
+ video: router({
+ upload: protectedProcedure
+ .input(z.object({
+ title: z.string(),
+ format: z.string(),
+ fileSize: z.number(),
+ exerciseType: z.string().optional(),
+ fileBase64: z.string(),
+ }))
+ .mutation(async ({ ctx, input }) => {
+ const fileBuffer = Buffer.from(input.fileBase64, "base64");
+ const fileKey = `videos/${ctx.user.id}/${nanoid()}.${input.format}`;
+ const contentType = input.format === "webm" ? "video/webm" : "video/mp4";
+ const { url } = await storagePut(fileKey, fileBuffer, contentType);
+
+ const videoId = await db.createVideo({
+ userId: ctx.user.id,
+ title: input.title,
+ fileKey,
+ url,
+ format: input.format,
+ fileSize: input.fileSize,
+ exerciseType: input.exerciseType || null,
+ analysisStatus: "pending",
+ });
+
+ return { videoId, url };
+ }),
+
+ list: protectedProcedure.query(async ({ ctx }) => {
+ return db.getUserVideos(ctx.user.id);
+ }),
+
+ get: protectedProcedure
+ .input(z.object({ videoId: z.number() }))
+ .query(async ({ input }) => {
+ return db.getVideoById(input.videoId);
+ }),
+
+ updateStatus: protectedProcedure
+ .input(z.object({
+ videoId: z.number(),
+ status: z.enum(["pending", "analyzing", "completed", "failed"]),
+ }))
+ .mutation(async ({ input }) => {
+ await db.updateVideoStatus(input.videoId, input.status);
+ return { success: true };
+ }),
+ }),
+
+ // Pose analysis
+ analysis: router({
+ save: protectedProcedure
+ .input(z.object({
+ videoId: z.number(),
+ overallScore: z.number().optional(),
+ poseMetrics: z.any().optional(),
+ detectedIssues: z.any().optional(),
+ corrections: z.any().optional(),
+ exerciseType: z.string().optional(),
+ framesAnalyzed: z.number().optional(),
+ shotCount: z.number().optional(),
+ avgSwingSpeed: z.number().optional(),
+ maxSwingSpeed: z.number().optional(),
+ totalMovementDistance: z.number().optional(),
+ strokeConsistency: z.number().optional(),
+ footworkScore: z.number().optional(),
+ fluidityScore: z.number().optional(),
+ keyMoments: z.any().optional(),
+ movementTrajectory: z.any().optional(),
+ }))
+ .mutation(async ({ ctx, input }) => {
+ const analysisId = await db.createPoseAnalysis({
+ ...input,
+ userId: ctx.user.id,
+ });
+ await db.updateVideoStatus(input.videoId, "completed");
+
+ // Auto-update NTRP rating after analysis
+ await recalculateNTRPRating(ctx.user.id, analysisId);
+
+ return { analysisId };
+ }),
+
+ getByVideo: protectedProcedure
+ .input(z.object({ videoId: z.number() }))
+ .query(async ({ input }) => {
+ return db.getAnalysisByVideoId(input.videoId);
+ }),
+
+ list: protectedProcedure.query(async ({ ctx }) => {
+ return db.getUserAnalyses(ctx.user.id);
+ }),
+
+ // Generate AI correction suggestions
+ getCorrections: protectedProcedure
+ .input(z.object({
+ poseMetrics: z.any(),
+ exerciseType: z.string(),
+ detectedIssues: z.any(),
+ }))
+ .mutation(async ({ input }) => {
+ const response = await invokeLLM({
+ messages: [
+ {
+ role: "system",
+ content: "你是一位专业网球教练。根据MediaPipe姿势分析数据，给出具体的姿势矫正建议。用中文回答。",
+ },
+ {
+ role: "user",
+ content: `分析以下网球动作数据并给出矫正建议：
+动作类型: ${input.exerciseType}
+姿势指标: ${JSON.stringify(input.poseMetrics)}
+检测到的问题: ${JSON.stringify(input.detectedIssues)}
+
+请给出：
+1. 每个问题的具体矫正方法
+2. 推荐的练习动作
+3. 需要注意的关键点`,
+ },
+ ],
+ });
+
+ return {
+ corrections: response.choices[0]?.message?.content || "暂无建议",
+ };
+ }),
+ }),
+
+ // Training records
+ record: router({
+ create: protectedProcedure
+ .input(z.object({
+ planId: z.number().optional(),
+ exerciseName: z.string(),
+ durationMinutes: z.number().optional(),
+ notes: z.string().optional(),
+ poseScore: z.number().optional(),
+ }))
+ .mutation(async ({ ctx, input }) => {
+ const recordId = await db.createTrainingRecord({
+ userId: ctx.user.id,
+ ...input,
+ completed: 0,
+ });
+ return { recordId };
+ }),
+
+ complete: protectedProcedure
+ .input(z.object({
+ recordId: z.number(),
+ poseScore: z.number().optional(),
+ }))
+ .mutation(async ({ ctx, input }) => {
+ await db.markRecordCompleted(input.recordId, input.poseScore);
+ // Update user stats
+ const records = await db.getUserTrainingRecords(ctx.user.id, 1000);
+ const completed = records.filter(r => r.completed === 1);
+ const totalMinutes = records.reduce((sum, r) => sum + (r.durationMinutes || 0), 0);
+ await db.updateUserProfile(ctx.user.id, {
+ totalSessions: completed.length,
+ totalMinutes,
+ });
+ return { success: true };
+ }),
+
+ list: protectedProcedure
+ .input(z.object({ limit: z.number().default(50) }).optional())
+ .query(async ({ ctx, input }) => {
+ return db.getUserTrainingRecords(ctx.user.id, input?.limit || 50);
+ }),
+ }),
+
+ // Rating system
+ rating: router({
+ history: protectedProcedure.query(async ({ ctx }) => {
+ return db.getUserRatingHistory(ctx.user.id);
+ }),
+ current: protectedProcedure.query(async ({ ctx }) => {
+ const user = await db.getUserByOpenId(ctx.user.openId);
+ return { rating: user?.ntrpRating || 1.5 };
+ }),
+ }),
});
+// NTRP Rating calculation function
+async function recalculateNTRPRating(userId: number, latestAnalysisId: number) {
+ const analyses = await db.getUserAnalyses(userId);
+ if (analyses.length === 0) return;
+
+ // Weight recent analyses more heavily
+ const weightedScores = analyses.slice(0, 20).map((a, i) => {
+ const weight = Math.max(0.3, 1 - i * 0.05); // Recent = higher weight
+ return {
+ overallScore: (a.overallScore || 0) * weight,
+ strokeConsistency: (a.strokeConsistency || 0) * weight,
+ footworkScore: (a.footworkScore || 0) * weight,
+ fluidityScore: (a.fluidityScore || 0) * weight,
+ shotCount: (a.shotCount || 0) * weight,
+ avgSwingSpeed: (a.avgSwingSpeed || 0) * weight,
+ weight,
+ };
+ });
+
+ const totalWeight = weightedScores.reduce((sum, s) => sum + s.weight, 0);
+
+ const dimensions = {
+ poseAccuracy: weightedScores.reduce((sum, s) => sum + s.overallScore, 0) / totalWeight,
+ strokeConsistency: weightedScores.reduce((sum, s) => sum + s.strokeConsistency, 0) / totalWeight,
+ footwork: weightedScores.reduce((sum, s) => sum + s.footworkScore, 0) / totalWeight,
+ fluidity: weightedScores.reduce((sum, s) => sum + s.fluidityScore, 0) / totalWeight,
+ power: Math.min(100, weightedScores.reduce((sum, s) => sum + s.avgSwingSpeed, 0) / totalWeight * 5),
+ };
+
+ // Convert 0-100 scores to NTRP 1.0-5.0
+ // NTRP mapping: 0-20 → 1.0-1.5, 20-40 → 1.5-2.5, 40-60 → 2.5-3.5, 60-80 → 3.5-4.5, 80-100 → 4.5-5.0
+ const avgDimension = (
+ dimensions.poseAccuracy * 0.30 +
+ dimensions.strokeConsistency * 0.25 +
+ dimensions.footwork * 0.20 +
+ dimensions.fluidity * 0.15 +
+ dimensions.power * 0.10
+ );
+
+ let ntrpRating: number;
+ if (avgDimension <= 20) ntrpRating = 1.0 + (avgDimension / 20) * 0.5;
+ else if (avgDimension <= 40) ntrpRating = 1.5 + ((avgDimension - 20) / 20) * 1.0;
+ else if (avgDimension <= 60) ntrpRating = 2.5 + ((avgDimension - 40) / 20) * 1.0;
+ else if (avgDimension <= 80) ntrpRating = 3.5 + ((avgDimension - 60) / 20) * 1.0;
+ else ntrpRating = 4.5 + ((avgDimension - 80) / 20) * 0.5;
+
+ ntrpRating = Math.round(ntrpRating * 10) / 10;
+ ntrpRating = Math.max(1.0, Math.min(5.0, ntrpRating));
+
+ // Save rating history
+ await db.createRatingEntry({
+ userId,
+ rating: ntrpRating,
+ reason: `基于${analyses.length}次视频分析自动评分`,
+ dimensionScores: dimensions,
+ analysisId: latestAnalysisId,
+ });
+
+ // Update user's current rating
+ await db.updateUserProfile(userId, { ntrpRating });
+}
+
export type AppRouter = typeof appRouter;
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000..4e50295
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,28 @@
+# Project TODO
+
+- [x] 用户名简单登录系统（只需输入用户名即可登录）
+- [x] 数据库schema设计（用户表、训练计划表、视频表、分析结果表、训练记录表）
+- [x] 训练计划生成系统（根据初级/中级/高级水平生成计划）
+- [x] 训练计划内容（影子挥拍、墙壁练习、脚步移动等只需球拍的训练）
+- [x] 视频上传功能（支持webm/mp4格式）
+- [x] 视频存储到S3
+- [x] MediaPipe Pose浏览器端姿势识别集成
+- [x] 视频播放与关键点可视化叠加显示
+- [x] 姿势矫正建议系统（基于AI识别结果生成矫正建议）
+- [x] 训练计划自动调整（根据姿势识别结果和进度调整计划）
+- [x] 训练进度追踪（可视化展示训练历史和姿势改进趋势）
+- [x] 训练视频库管理（保存和管理所有训练视频及分析结果）
+- [x] 全局UI设计和主题配置
+- [x] 响应式布局适配
+- [x] 编写vitest测试
+- [x] 击球次数统计（参考tennis_analysis）
+- [x] 挥拍速度估算（手腕/手臂关键点帧间位移）
+- [x] 运动轨迹可视化（身体中心点移动轨迹）
+- [ ] 迷你球场可视化叠加
+- [x] 球员统计面板（综合展示分析数据）
+- [x] 帧级别关键时刻标注
+- [x] NTRP自动评分系统（1.0-5.0）
+- [x] 基于所有历史记录自动更新用户评分
+- [x] 多维度评分（姿势正确性、动作流畅性、击球一致性、脚步移动、挥拍速度）
+- [x] 评分趋势图表展示
+- [ ] 推送代码到Gitea仓库