653 行
23 KiB
TypeScript
653 行
23 KiB
TypeScript
import { COOKIE_NAME, ONE_YEAR_MS } from "@shared/const";
|
|
import { getSessionCookieOptions } from "./_core/cookies";
|
|
import { systemRouter } from "./_core/systemRouter";
|
|
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({
|
|
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;
|
|
}),
|
|
|
|
// 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);
|
|
}),
|
|
}),
|
|
|
|
// 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 };
|
|
}),
|
|
}),
|
|
|
|
// Daily check-in system
|
|
checkin: router({
|
|
today: protectedProcedure.query(async ({ ctx }) => {
|
|
return db.getTodayCheckin(ctx.user.id);
|
|
}),
|
|
do: protectedProcedure
|
|
.input(z.object({
|
|
notes: z.string().optional(),
|
|
minutesTrained: z.number().optional(),
|
|
}).optional())
|
|
.mutation(async ({ ctx, input }) => {
|
|
const result = await db.checkinToday(ctx.user.id, input?.notes, input?.minutesTrained);
|
|
// Check for new badges after check-in
|
|
const newBadges = await db.checkAndAwardBadges(ctx.user.id);
|
|
return { ...result, newBadges };
|
|
}),
|
|
history: protectedProcedure
|
|
.input(z.object({ limit: z.number().default(60) }).optional())
|
|
.query(async ({ ctx, input }) => {
|
|
return db.getUserCheckins(ctx.user.id, input?.limit || 60);
|
|
}),
|
|
}),
|
|
|
|
// Badge system
|
|
badge: router({
|
|
list: protectedProcedure.query(async ({ ctx }) => {
|
|
const earned = await db.getUserBadges(ctx.user.id);
|
|
const allBadges = Object.entries(db.BADGE_DEFINITIONS).map(([key, def]) => {
|
|
const earnedBadge = earned.find(b => b.badgeKey === key);
|
|
return {
|
|
key,
|
|
...def,
|
|
earned: !!earnedBadge,
|
|
earnedAt: earnedBadge?.earnedAt || null,
|
|
};
|
|
});
|
|
return allBadges;
|
|
}),
|
|
check: protectedProcedure.mutation(async ({ ctx }) => {
|
|
const newBadges = await db.checkAndAwardBadges(ctx.user.id);
|
|
return { newBadges: newBadges.map(key => ({ key, ...db.BADGE_DEFINITIONS[key] })) };
|
|
}),
|
|
definitions: publicProcedure.query(() => {
|
|
return Object.entries(db.BADGE_DEFINITIONS).map(([key, def]) => ({ key, ...def }));
|
|
}),
|
|
}),
|
|
|
|
// Leaderboard
|
|
leaderboard: router({
|
|
get: protectedProcedure
|
|
.input(z.object({
|
|
sortBy: z.enum(["ntrpRating", "totalMinutes", "totalSessions", "totalShots"]).default("ntrpRating"),
|
|
limit: z.number().default(50),
|
|
}).optional())
|
|
.query(async ({ input }) => {
|
|
return db.getLeaderboard(input?.sortBy || "ntrpRating", input?.limit || 50);
|
|
}),
|
|
}),
|
|
|
|
// Tutorial video library
|
|
tutorial: router({
|
|
list: publicProcedure
|
|
.input(z.object({
|
|
category: z.string().optional(),
|
|
skillLevel: z.string().optional(),
|
|
}).optional())
|
|
.query(async ({ input }) => {
|
|
// Auto-seed tutorials on first request
|
|
await db.seedTutorials();
|
|
return db.getTutorials(input?.category, input?.skillLevel);
|
|
}),
|
|
|
|
get: publicProcedure
|
|
.input(z.object({ id: z.number() }))
|
|
.query(async ({ input }) => {
|
|
return db.getTutorialById(input.id);
|
|
}),
|
|
|
|
progress: protectedProcedure.query(async ({ ctx }) => {
|
|
return db.getUserTutorialProgress(ctx.user.id);
|
|
}),
|
|
|
|
updateProgress: protectedProcedure
|
|
.input(z.object({
|
|
tutorialId: z.number(),
|
|
watched: z.number().optional(),
|
|
selfScore: z.number().optional(),
|
|
notes: z.string().optional(),
|
|
comparisonVideoId: z.number().optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const { tutorialId, ...data } = input;
|
|
await db.updateTutorialProgress(ctx.user.id, tutorialId, data);
|
|
return { success: true };
|
|
}),
|
|
}),
|
|
|
|
// Training reminders
|
|
reminder: router({
|
|
list: protectedProcedure.query(async ({ ctx }) => {
|
|
return db.getUserReminders(ctx.user.id);
|
|
}),
|
|
|
|
create: protectedProcedure
|
|
.input(z.object({
|
|
reminderType: z.string(),
|
|
title: z.string(),
|
|
message: z.string().optional(),
|
|
timeOfDay: z.string(),
|
|
daysOfWeek: z.array(z.number()),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const reminderId = await db.createReminder({
|
|
userId: ctx.user.id,
|
|
...input,
|
|
});
|
|
return { reminderId };
|
|
}),
|
|
|
|
update: protectedProcedure
|
|
.input(z.object({
|
|
reminderId: z.number(),
|
|
title: z.string().optional(),
|
|
message: z.string().optional(),
|
|
timeOfDay: z.string().optional(),
|
|
daysOfWeek: z.array(z.number()).optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const { reminderId, ...data } = input;
|
|
await db.updateReminder(reminderId, ctx.user.id, data);
|
|
return { success: true };
|
|
}),
|
|
|
|
delete: protectedProcedure
|
|
.input(z.object({ reminderId: z.number() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
await db.deleteReminder(input.reminderId, ctx.user.id);
|
|
return { success: true };
|
|
}),
|
|
|
|
toggle: protectedProcedure
|
|
.input(z.object({ reminderId: z.number(), isActive: z.number() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
await db.toggleReminder(input.reminderId, ctx.user.id, input.isActive);
|
|
return { success: true };
|
|
}),
|
|
}),
|
|
|
|
// Notifications
|
|
notification: router({
|
|
list: protectedProcedure
|
|
.input(z.object({ limit: z.number().default(50) }).optional())
|
|
.query(async ({ ctx, input }) => {
|
|
return db.getUserNotifications(ctx.user.id, input?.limit || 50);
|
|
}),
|
|
|
|
unreadCount: protectedProcedure.query(async ({ ctx }) => {
|
|
return db.getUnreadNotificationCount(ctx.user.id);
|
|
}),
|
|
|
|
markRead: protectedProcedure
|
|
.input(z.object({ notificationId: z.number() }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
await db.markNotificationRead(input.notificationId, ctx.user.id);
|
|
return { success: true };
|
|
}),
|
|
|
|
markAllRead: protectedProcedure.mutation(async ({ ctx }) => {
|
|
await db.markAllNotificationsRead(ctx.user.id);
|
|
return { success: true };
|
|
}),
|
|
}),
|
|
});
|
|
|
|
// 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;
|