题库导入功能完成，考试计划功能完成。

api/controllers/adminController.ts

@@ -105,6 +105,25 @@ export class AdminController {
     }
   }
 
+  // 获取活跃任务统计数据
+  static async getActiveTasksStats(req: Request, res: Response) {
+    try {
+      const { ExamTaskModel } = await import('../models/examTask');
+      const stats = await ExamTaskModel.getActiveTasksWithStats();
+      
+      res.json({
+        success: true,
+        data: stats
+      });
+    } catch (error: any) {
+      console.error('获取活跃任务统计数据失败:', error);
+      res.status(500).json({
+        success: false,
+        message: error.message || '获取活跃任务统计数据失败'
+      });
+    }
+  }
+
   // 修改管理员密码
   static async updatePassword(req: Request, res: Response) {
     try {

api/controllers/adminUserController.ts

@@ -83,6 +83,67 @@ export class AdminUserController {
     }
   }
 
+  // 更新用户信息
+  static async updateUser(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const { name, phone, password } = req.body;
+
+      const user = await UserModel.findById(id);
+      if (!user) {
+        return res.status(404).json({
+          success: false,
+          message: '用户不存在'
+        });
+      }
+
+      // 准备更新数据
+      const updateData: Partial<{ name: string; phone: string; password: string }> = {};
+      if (name !== undefined) updateData.name = name;
+      if (phone !== undefined) updateData.phone = phone;
+      if (password !== undefined) updateData.password = password;
+
+      // 更新用户
+      const updatedUser = await UserModel.update(id, updateData);
+
+      res.json({
+        success: true,
+        data: updatedUser
+      });
+    } catch (error: any) {
+      // 处理手机号已存在的错误
+      if (error.message === '手机号已存在') {
+        return res.status(400).json({
+          success: false,
+          message: '手机号已存在'
+        });
+      }
+      
+      // 处理SQLITE_CONSTRAINT_UNIQUE错误
+      if (error.code === 'SQLITE_CONSTRAINT_UNIQUE') {
+        return res.status(400).json({
+          success: false,
+          message: '手机号已存在'
+        });
+      }
+      
+      // 处理数据验证错误
+      if (error.message.includes('姓名长度必须在2-20个字符之间') || 
+          error.message.includes('手机号格式不正确')) {
+        return res.status(400).json({
+          success: false,
+          message: error.message
+        });
+      }
+      
+      // 处理其他错误
+      res.status(500).json({
+        success: false,
+        message: error.message || '更新用户失败'
+      });
+    }
+  }
+
   static async importUsers(req: Request, res: Response) {
     try {
       const file = (req as any).file;

api/controllers/examTaskController.ts

@@ -141,4 +141,29 @@ export class ExamTaskController {
       });
     }
   }
+
+  static async getTaskUsers(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      
+      if (!id) {
+        return res.status(400).json({
+          success: false,
+          message: '任务ID不能为空'
+        });
+      }
+
+      const userIds = await ExamTaskModel.getTaskUsers(id);
+      
+      res.json({
+        success: true,
+        data: userIds
+      });
+    } catch (error: any) {
+      res.status(500).json({
+        success: false,
+        message: error.message || '获取任务用户失败'
+      });
+    }
+  }
 }

api/controllers/quizController.ts

@@ -43,23 +43,142 @@ export class QuizController {
         });
       }
 
-      const questions: Awaited<ReturnType<typeof QuestionModel.getRandomQuestions>> = [];
-
-      for (const [type, ratio] of Object.entries(subject.typeRatios)) {
-        if (ratio <= 0) continue;
-        const typeScore = Math.floor((ratio / 100) * subject.totalScore);
-        const avgScore = 10;
-        const count = Math.max(1, Math.round(typeScore / avgScore));
-
-        const categories = Object.entries(subject.categoryRatios)
-          .filter(([, r]) => r > 0)
-          .map(([c]) => c);
-
-        const qs = await QuestionModel.getRandomQuestions(type as any, count, categories);
-        questions.push(...qs);
+      let questions: Question[] = [];
+      const remainingScore = subject.totalScore;
+      
+      // 构建包含所有类别的数组，根据比重重复对应次数
+      const allCategories: string[] = [];
+      for (const [category, catRatio] of Object.entries(subject.categoryRatios)) {
+        if (catRatio > 0) {
+          // 根据比重计算该类别应占的总题目数比例
+          const count = Math.round((catRatio / 100) * 100); // 放大100倍避免小数问题
+          for (let i = 0; i < count; i++) {
+            allCategories.push(category);
+          }
+        }
+      }
+      
+      // 确保总题目数至少为1
+      if (allCategories.length === 0) {
+        allCategories.push('通用');
+      }
+      
+      // 按题型分配题目
+      for (const [type, typeRatio] of Object.entries(subject.typeRatios)) {
+        if (typeRatio <= 0) continue;
+        
+        // 计算该题型应占的总分
+        const targetTypeScore = Math.round((typeRatio / 100) * subject.totalScore);
+        let currentTypeScore = 0;
+        let typeQuestions: Question[] = [];
+        
+        // 尝试获取足够分数的题目
+        while (currentTypeScore < targetTypeScore) {
+          // 随机选择一个类别
+          const randomCategory = allCategories[Math.floor(Math.random() * allCategories.length)];
+          
+          // 获取该类型和类别的随机题目
+          const availableQuestions = await QuestionModel.getRandomQuestions(
+            type as any, 
+            10, // 一次获取多个，提高效率
+            [randomCategory]
+          );
+          
+          if (availableQuestions.length === 0) {
+            break; // 该类型/类别没有题目，跳过
+          }
+          
+          // 过滤掉已选题目
+          const availableUnselected = availableQuestions.filter(q => 
+            !questions.some(selected => selected.id === q.id)
+          );
+          
+          if (availableUnselected.length === 0) {
+            break; // 没有可用的新题目了
+          }
+          
+          // 选择分数最接近剩余需求的题目
+          const remainingForType = targetTypeScore - currentTypeScore;
+          const selectedQuestion = availableUnselected.reduce((prev, curr) => {
+            const prevDiff = Math.abs(remainingForType - prev.score);
+            const currDiff = Math.abs(remainingForType - curr.score);
+            return currDiff < prevDiff ? curr : prev;
+          });
+          
+          // 添加到题型题目列表
+          typeQuestions.push(selectedQuestion);
+          currentTypeScore += selectedQuestion.score;
+          
+          // 防止无限循环
+          if (typeQuestions.length > 100) {
+            break;
+          }
+        }
+        
+        questions.push(...typeQuestions);
+      }
+      
+      // 如果总分不足，尝试补充题目
+      let totalScore = questions.reduce((sum, q) => sum + q.score, 0);
+      while (totalScore < subject.totalScore) {
+        // 获取所有类型的随机题目
+        const allTypes = Object.keys(subject.typeRatios).filter(type => subject.typeRatios[type] > 0);
+        if (allTypes.length === 0) break;
+        
+        const randomType = allTypes[Math.floor(Math.random() * allTypes.length)];
+        const availableQuestions = await QuestionModel.getRandomQuestions(
+          randomType as any, 
+          10, 
+          allCategories
+        );
+        
+        if (availableQuestions.length === 0) break;
+        
+        // 过滤掉已选题目
+        const availableUnselected = availableQuestions.filter(q => 
+          !questions.some(selected => selected.id === q.id)
+        );
+        
+        if (availableUnselected.length === 0) break;
+        
+        // 选择分数最接近剩余需求的题目
+        const remainingScore = subject.totalScore - totalScore;
+        const selectedQuestion = availableUnselected.reduce((prev, curr) => {
+          const prevDiff = Math.abs(remainingScore - prev.score);
+          const currDiff = Math.abs(remainingScore - curr.score);
+          return currDiff < prevDiff ? curr : prev;
+        });
+        
+        questions.push(selectedQuestion);
+        totalScore += selectedQuestion.score;
+        
+        // 防止无限循环
+        if (questions.length > 200) {
+          break;
+        }
+      }
+      
+      // 如果总分超过，尝试移除一些题目
+      while (totalScore > subject.totalScore) {
+        // 找到最接近剩余差值的题目
+        const excessScore = totalScore - subject.totalScore;
+        let closestIndex = -1;
+        let closestDiff = Infinity;
+        
+        for (let i = 0; i < questions.length; i++) {
+          const diff = Math.abs(questions[i].score - excessScore);
+          if (diff < closestDiff) {
+            closestDiff = diff;
+            closestIndex = i;
+          }
+        }
+        
+        if (closestIndex === -1) break;
+        
+        // 移除该题目
+        totalScore -= questions[closestIndex].score;
+        questions.splice(closestIndex, 1);
       }
-
-      const totalScore = questions.reduce((sum, q) => sum + q.score, 0);
 
       res.json({
         success: true,

api/controllers/userController.ts

@@ -30,6 +30,15 @@ export class UserController {
       });
     } catch (error: any) {
       console.error('创建用户失败:', error);
+      
+      // 处理手机号唯一约束错误
+      if (error.code === 'SQLITE_CONSTRAINT' || error.message.includes('手机号已存在')) {
+        return res.status(400).json({
+          success: false,
+          message: '该手机号已被注册，请使用其他手机号'
+        });
+      }
+      
       res.status(500).json({
         success: false,
         message: error.message || '创建用户失败'
@@ -115,4 +124,30 @@ export class UserController {
       });
     }
   }
+
+  static async getUsersByName(req: Request, res: Response) {
+    try {
+      const { name } = req.params;
+      
+      if (!name || typeof name !== 'string') {
+        return res.status(400).json({
+          success: false,
+          message: '姓名不能为空'
+        });
+      }
+      
+      const users = await UserModel.findByName(name);
+      
+      res.json({
+        success: true,
+        data: users
+      });
+    } catch (error: any) {
+      console.error('根据姓名查询用户失败:', error);
+      res.status(500).json({
+        success: false,
+        message: error.message || '根据姓名查询用户失败'
+      });
+    }
+  }
 }