608 行
20 KiB
TypeScript
608 行
20 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 { storagePut } from "./storage";
|
|
import * as db from "./db";
|
|
import { nanoid } from "nanoid";
|
|
import { getRemoteMediaSession } from "./mediaService";
|
|
import { prepareCorrectionImageUrls } from "./taskWorker";
|
|
import { toPublicUrl } from "./publicUrl";
|
|
|
|
async function enqueueTask(params: {
|
|
userId: number;
|
|
type: "media_finalize" | "training_plan_generate" | "training_plan_adjust" | "analysis_corrections" | "pose_correction_multimodal";
|
|
title: string;
|
|
payload: Record<string, unknown>;
|
|
message: string;
|
|
}) {
|
|
const taskId = nanoid();
|
|
await db.createBackgroundTask({
|
|
id: taskId,
|
|
userId: params.userId,
|
|
type: params.type,
|
|
title: params.title,
|
|
message: params.message,
|
|
payload: params.payload,
|
|
progress: 0,
|
|
maxAttempts: params.type === "media_finalize" ? 90 : 3,
|
|
});
|
|
|
|
const task = await db.getBackgroundTaskById(taskId);
|
|
return { taskId, task };
|
|
}
|
|
|
|
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 }) => {
|
|
return enqueueTask({
|
|
userId: ctx.user.id,
|
|
type: "training_plan_generate",
|
|
title: `${input.durationDays}天训练计划生成`,
|
|
message: "训练计划已加入后台队列",
|
|
payload: input,
|
|
});
|
|
}),
|
|
|
|
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 currentPlan = (await db.getUserTrainingPlans(ctx.user.id)).find(p => p.id === input.planId);
|
|
if (!currentPlan) throw new Error("Plan not found");
|
|
return enqueueTask({
|
|
userId: ctx.user.id,
|
|
type: "training_plan_adjust",
|
|
title: `${currentPlan.title} 调整`,
|
|
message: "训练计划调整任务已加入后台队列",
|
|
payload: input,
|
|
});
|
|
}),
|
|
}),
|
|
|
|
// 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 publicUrl = toPublicUrl(url);
|
|
|
|
const videoId = await db.createVideo({
|
|
userId: ctx.user.id,
|
|
title: input.title,
|
|
fileKey,
|
|
url: publicUrl,
|
|
format: input.format,
|
|
fileSize: input.fileSize,
|
|
exerciseType: input.exerciseType || null,
|
|
analysisStatus: "pending",
|
|
});
|
|
|
|
return { videoId, url: publicUrl };
|
|
}),
|
|
|
|
registerExternal: protectedProcedure
|
|
.input(z.object({
|
|
title: z.string().min(1).max(256),
|
|
url: z.string().min(1),
|
|
fileKey: z.string().min(1),
|
|
format: z.string().min(1).max(16),
|
|
fileSize: z.number().optional(),
|
|
duration: z.number().optional(),
|
|
exerciseType: z.string().optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const publicUrl = toPublicUrl(input.url);
|
|
const videoId = await db.createVideo({
|
|
userId: ctx.user.id,
|
|
title: input.title,
|
|
fileKey: input.fileKey,
|
|
url: publicUrl,
|
|
format: input.format,
|
|
fileSize: input.fileSize ?? null,
|
|
duration: input.duration ?? null,
|
|
exerciseType: input.exerciseType || "recording",
|
|
analysisStatus: "completed",
|
|
});
|
|
|
|
return { videoId, url: publicUrl };
|
|
}),
|
|
|
|
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(),
|
|
imageUrls: z.array(z.string()).optional(),
|
|
imageDataUrls: z.array(z.string()).max(4).optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const imageUrls = await prepareCorrectionImageUrls({
|
|
userId: ctx.user.id,
|
|
imageUrls: input.imageUrls,
|
|
imageDataUrls: input.imageDataUrls,
|
|
});
|
|
|
|
return enqueueTask({
|
|
userId: ctx.user.id,
|
|
type: imageUrls.length > 0 ? "pose_correction_multimodal" : "analysis_corrections",
|
|
title: `${input.exerciseType} 动作纠正`,
|
|
message: imageUrls.length > 0 ? "多模态动作纠正任务已加入后台队列" : "动作纠正任务已加入后台队列",
|
|
payload: {
|
|
poseMetrics: input.poseMetrics,
|
|
exerciseType: input.exerciseType,
|
|
detectedIssues: input.detectedIssues,
|
|
imageUrls,
|
|
},
|
|
});
|
|
}),
|
|
}),
|
|
|
|
task: router({
|
|
list: protectedProcedure
|
|
.input(z.object({ limit: z.number().min(1).max(50).default(20) }).optional())
|
|
.query(async ({ ctx, input }) => {
|
|
return db.listUserBackgroundTasks(ctx.user.id, input?.limit ?? 20);
|
|
}),
|
|
|
|
get: protectedProcedure
|
|
.input(z.object({ taskId: z.string().min(1) }))
|
|
.query(async ({ ctx, input }) => {
|
|
return db.getUserBackgroundTaskById(ctx.user.id, input.taskId);
|
|
}),
|
|
|
|
retry: protectedProcedure
|
|
.input(z.object({ taskId: z.string().min(1) }))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const task = await db.retryBackgroundTask(ctx.user.id, input.taskId);
|
|
return { task };
|
|
}),
|
|
|
|
createMediaFinalize: protectedProcedure
|
|
.input(z.object({
|
|
sessionId: z.string().min(1),
|
|
title: z.string().min(1).max(256),
|
|
exerciseType: z.string().optional(),
|
|
}))
|
|
.mutation(async ({ ctx, input }) => {
|
|
const session = await getRemoteMediaSession(input.sessionId);
|
|
if (session.userId !== String(ctx.user.id)) {
|
|
throw new Error("Media session not found");
|
|
}
|
|
|
|
return enqueueTask({
|
|
userId: ctx.user.id,
|
|
type: "media_finalize",
|
|
title: `${input.title} 归档`,
|
|
message: "录制文件归档任务已加入后台队列",
|
|
payload: input,
|
|
});
|
|
}),
|
|
}),
|
|
|
|
// 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;
|