王菲的提交

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/DashboardController.java

@@ -12,18 +12,34 @@ import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
 
+/**
+ * 管理员仪表盘控制器，提供与仪表盘相关的API接口。
+ */
 @RestController("AdminDashboardController")
 @RequestMapping(value = "/api/admin/dashboard")
 public class DashboardController extends BaseApiController {
 
+    // 注入相关服务
     private final ExamPaperService examPaperService;
     private final QuestionService questionService;
     private final ExamPaperAnswerService examPaperAnswerService;
     private final ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService;
     private final UserEventLogService userEventLogService;
 
+    /**
+     * 构造器，自动注入所需服务。
+     *
+     * @param examPaperService 试卷服务
+     * @param questionService 问题服务
+     * @param examPaperAnswerService 试卷答题服务
+     * @param examPaperQuestionCustomerAnswerService 用户答题服务
+     * @param userEventLogService 用户事件日志服务
+     */
     @Autowired
-    public DashboardController(ExamPaperService examPaperService, QuestionService questionService, ExamPaperAnswerService examPaperAnswerService, ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService, UserEventLogService userEventLogService) {
+    public DashboardController(ExamPaperService examPaperService, QuestionService questionService,
+                               ExamPaperAnswerService examPaperAnswerService,
+                               ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService,
+                               UserEventLogService userEventLogService) {
         this.examPaperService = examPaperService;
         this.questionService = questionService;
         this.examPaperAnswerService = examPaperAnswerService;
@@ -31,26 +47,39 @@ public class DashboardController extends BaseApiController {
         this.userEventLogService = userEventLogService;
     }
 
+    /**
+     * 获取仪表盘首页信息，包括试卷数量、问题数量、答题情况等。
+     *
+     * @return RestResponse 返回仪表盘数据的响应
+     */
     @RequestMapping(value = "/index", method = RequestMethod.POST)
     public RestResponse<IndexVM> Index() {
-        IndexVM vm = new IndexVM();
+        IndexVM vm = new IndexVM();  // 创建返回的视图模型
 
+        // 获取试卷数量、问题数量、已答试卷数和已答问题数
         Integer examPaperCount = examPaperService.selectAllCount();
         Integer questionCount = questionService.selectAllCount();
         Integer doExamPaperCount = examPaperAnswerService.selectAllCount();
         Integer doQuestionCount = examPaperQuestionCustomerAnswerService.selectAllCount();
 
+        // 将获取的数据设置到视图模型中
         vm.setExamPaperCount(examPaperCount);
         vm.setQuestionCount(questionCount);
         vm.setDoExamPaperCount(doExamPaperCount);
         vm.setDoQuestionCount(doQuestionCount);
 
+        // 获取本月的用户行为数据和答题数据
         List<Integer> mothDayUserActionValue = userEventLogService.selectMothCount();
         List<Integer> mothDayDoExamQuestionValue = examPaperQuestionCustomerAnswerService.selectMothCount();
+
+        // 将这些数据设置到视图模型中
         vm.setMothDayUserActionValue(mothDayUserActionValue);
         vm.setMothDayDoExamQuestionValue(mothDayDoExamQuestionValue);
 
+        // 设置当前月份的日期信息
         vm.setMothDayText(DateTimeUtil.MothDay());
+
+        // 返回成功响应，并将视图模型传递到客户端
         return RestResponse.ok(vm);
     }
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/EducationController.java

@@ -1,6 +1,5 @@
 package com.mindskip.xzs.controller.admin;
 
-
 import com.mindskip.xzs.base.BaseApiController;
 import com.mindskip.xzs.base.RestResponse;
 import com.mindskip.xzs.domain.Subject;
@@ -16,52 +15,100 @@ import org.springframework.web.bind.annotation.*;
 import javax.validation.Valid;
 import java.util.List;
 
+/**
+ * 教育模块管理控制器，提供与课程相关的API接口。
+ */
 @RestController("AdminEducationController")
 @RequestMapping(value = "/api/admin/education")
 public class EducationController extends BaseApiController {
 
+    // 注入课程服务
     private final SubjectService subjectService;
 
+    /**
+     * 构造器，自动注入课程服务。
+     *
+     * @param subjectService 课程服务
+     */
     @Autowired
     public EducationController(SubjectService subjectService) {
         this.subjectService = subjectService;
     }
 
+    /**
+     * 获取所有课程列表。
+     *
+     * @return RestResponse 返回课程列表的响应
+     */
     @RequestMapping(value = "/subject/list", method = RequestMethod.POST)
     public RestResponse<List<Subject>> list() {
         List<Subject> subjects = subjectService.allSubject();
         return RestResponse.ok(subjects);
     }
 
+    /**
+     * 获取课程分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回分页课程数据的响应
+     */
     @RequestMapping(value = "/subject/page", method = RequestMethod.POST)
     public RestResponse<PageInfo<SubjectResponseVM>> pageList(@RequestBody SubjectPageRequestVM model) {
+        // 获取分页数据
         PageInfo<Subject> pageInfo = subjectService.page(model);
+        // 将分页数据转换为视图模型
         PageInfo<SubjectResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> modelMapper.map(e, SubjectResponseVM.class));
         return RestResponse.ok(page);
     }
 
+    /**
+     * 编辑课程信息。
+     * 如果课程ID为空则插入新课程，否则更新现有课程。
+     *
+     * @param model 课程编辑请求模型
+     * @return RestResponse 返回操作结果的响应
+     */
     @RequestMapping(value = "/subject/edit", method = RequestMethod.POST)
     public RestResponse edit(@RequestBody @Valid SubjectEditRequestVM model) {
+        // 将编辑请求模型映射为课程对象
         Subject subject = modelMapper.map(model, Subject.class);
         if (model.getId() == null) {
-            subject.setDeleted(false);
+            // 如果没有ID，则插入新课程
+            subject.setDeleted(false);  // 标记为未删除
             subjectService.insertByFilter(subject);
         } else {
+            // 如果有ID，则更新现有课程
             subjectService.updateByIdFilter(subject);
         }
         return RestResponse.ok();
     }
 
+    /**
+     * 获取指定ID的课程信息，用于编辑页面。
+     *
+     * @param id 课程ID
+     * @return RestResponse 返回课程编辑请求模型的响应
+     */
     @RequestMapping(value = "/subject/select/{id}", method = RequestMethod.POST)
     public RestResponse<SubjectEditRequestVM> select(@PathVariable Integer id) {
+        // 根据ID查询课程
         Subject subject = subjectService.selectById(id);
+        // 将课程对象映射为编辑请求模型
         SubjectEditRequestVM vm = modelMapper.map(subject, SubjectEditRequestVM.class);
         return RestResponse.ok(vm);
     }
 
+    /**
+     * 删除指定ID的课程，将课程标记为已删除。
+     *
+     * @param id 课程ID
+     * @return RestResponse 返回操作结果的响应
+     */
     @RequestMapping(value = "/subject/delete/{id}", method = RequestMethod.POST)
     public RestResponse delete(@PathVariable Integer id) {
+        // 根据ID查询课程
         Subject subject = subjectService.selectById(id);
+        // 将课程标记为已删除
         subject.setDeleted(true);
         subjectService.updateByIdFilter(subject);
         return RestResponse.ok();

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/ExamPaperAnswerController.java

@@ -15,14 +15,25 @@ import com.github.pagehelper.PageInfo;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
+/**
+ * 管理员试卷答题管理控制器，提供与试卷答题相关的API接口。
+ */
 @RestController("AdminExamPaperAnswerController")
 @RequestMapping(value = "/api/admin/examPaperAnswer")
 public class ExamPaperAnswerController extends BaseApiController {
 
+    // 注入试卷答题服务、课程服务和用户服务
     private final ExamPaperAnswerService examPaperAnswerService;
     private final SubjectService subjectService;
     private final UserService userService;
 
+    /**
+     * 构造器，自动注入试卷答题、课程和用户服务。
+     *
+     * @param examPaperAnswerService 试卷答题服务
+     * @param subjectService 课程服务
+     * @param userService 用户服务
+     */
     @Autowired
     public ExamPaperAnswerController(ExamPaperAnswerService examPaperAnswerService, SubjectService subjectService, UserService userService) {
         this.examPaperAnswerService = examPaperAnswerService;
@@ -30,25 +41,38 @@ public class ExamPaperAnswerController extends BaseApiController {
         this.userService = userService;
     }
 
-
+    /**
+     * 获取试卷答题的分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回分页试卷答题数据的响应
+     */
     @RequestMapping(value = "/page", method = RequestMethod.POST)
     public RestResponse<PageInfo<ExamPaperAnswerPageResponseVM>> pageJudgeList(@RequestBody ExamPaperAnswerPageRequestVM model) {
+        // 获取试卷答题数据的分页信息
         PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.adminPage(model);
+
+        // 将分页数据转换为视图模型
         PageInfo<ExamPaperAnswerPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            // 将试卷答题数据映射为视图模型
             ExamPaperAnswerPageResponseVM vm = modelMapper.map(e, ExamPaperAnswerPageResponseVM.class);
+
+            // 获取课程信息并设置
             Subject subject = subjectService.selectById(vm.getSubjectId());
-            vm.setDoTime(ExamUtil.secondToVM(e.getDoTime()));
-            vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore()));
-            vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore()));
-            vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore()));
-            vm.setSubjectName(subject.getName());
-            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            vm.setDoTime(ExamUtil.secondToVM(e.getDoTime()));  // 格式化做题时间
+            vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore()));  // 格式化系统评分
+            vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore()));  // 格式化用户评分
+            vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore()));  // 格式化试卷评分
+            vm.setSubjectName(subject.getName());  // 设置课程名称
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));  // 格式化创建时间
+
+            // 获取用户信息并设置
             User user = userService.selectById(e.getCreateUser());
-            vm.setUserName(user.getUserName());
+            vm.setUserName(user.getUserName());  // 设置用户名
+
             return vm;
         });
-        return RestResponse.ok(page);
-    }
-
 
+        return RestResponse.ok(page);  // 返回分页数据的响应
+    }
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/ExamPaperController.java

@@ -13,63 +13,112 @@ import com.github.pagehelper.PageInfo;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
-import javax.validation.Valid;
-
+/**
+ * 管理员考试试卷管理控制器，提供对考试试卷的管理功能。
+ */
 @RestController("AdminExamPaperController")
 @RequestMapping(value = "/api/admin/exam/paper")
 public class ExamPaperController extends BaseApiController {
 
+    // 注入考试试卷服务
     private final ExamPaperService examPaperService;
 
+    /**
+     * 构造器，自动注入考试试卷服务
+     *
+     * @param examPaperService 考试试卷服务
+     */
     @Autowired
     public ExamPaperController(ExamPaperService examPaperService) {
         this.examPaperService = examPaperService;
     }
 
+    /**
+     * 获取考试试卷分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回分页试卷数据的响应
+     */
     @RequestMapping(value = "/page", method = RequestMethod.POST)
     public RestResponse<PageInfo<ExamResponseVM>> pageList(@RequestBody ExamPaperPageRequestVM model) {
+        // 获取考试试卷数据的分页信息
         PageInfo<ExamPaper> pageInfo = examPaperService.page(model);
+
+        // 将分页数据转换为视图模型
         PageInfo<ExamResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            // 映射每个试卷为视图模型
             ExamResponseVM vm = modelMapper.map(e, ExamResponseVM.class);
+            // 格式化创建时间
             vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
             return vm;
         });
-        return RestResponse.ok(page);
-    }
-
 
+        return RestResponse.ok(page);  // 返回分页数据的响应
+    }
 
+    /**
+     * 获取任务考试试卷的分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回任务考试试卷分页数据的响应
+     */
     @RequestMapping(value = "/taskExamPage", method = RequestMethod.POST)
     public RestResponse<PageInfo<ExamResponseVM>> taskExamPageList(@RequestBody ExamPaperPageRequestVM model) {
+        // 获取任务考试试卷数据的分页信息
         PageInfo<ExamPaper> pageInfo = examPaperService.taskExamPage(model);
+
+        // 将分页数据转换为视图模型
         PageInfo<ExamResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
             ExamResponseVM vm = modelMapper.map(e, ExamResponseVM.class);
+            // 格式化创建时间
             vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
             return vm;
         });
-        return RestResponse.ok(page);
-    }
-
 
+        return RestResponse.ok(page);  // 返回分页数据的响应
+    }
 
+    /**
+     * 编辑考试试卷。
+     *
+     * @param model 编辑请求模型
+     * @return RestResponse 返回编辑后的试卷视图模型
+     */
     @RequestMapping(value = "/edit", method = RequestMethod.POST)
     public RestResponse<ExamPaperEditRequestVM> edit(@RequestBody @Valid ExamPaperEditRequestVM model) {
+        // 根据编辑请求模型保存试卷
         ExamPaper examPaper = examPaperService.savePaperFromVM(model, getCurrentUser());
+        // 根据试卷ID获取新的试卷视图模型
         ExamPaperEditRequestVM newVM = examPaperService.examPaperToVM(examPaper.getId());
-        return RestResponse.ok(newVM);
+        return RestResponse.ok(newVM);  // 返回新的试卷视图模型
     }
 
+    /**
+     * 获取指定ID的考试试卷信息。
+     *
+     * @param id 试卷ID
+     * @return RestResponse 返回指定ID的试卷编辑请求模型
+     */
     @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
     public RestResponse<ExamPaperEditRequestVM> select(@PathVariable Integer id) {
+        // 获取试卷的编辑请求模型
         ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id);
-        return RestResponse.ok(vm);
+        return RestResponse.ok(vm);  // 返回试卷编辑请求模型
     }
 
+    /**
+     * 删除指定ID的考试试卷。
+     *
+     * @param id 试卷ID
+     * @return RestResponse 返回删除操作的响应
+     */
     @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
     public RestResponse delete(@PathVariable Integer id) {
+        // 获取指定ID的试卷
         ExamPaper examPaper = examPaperService.selectById(id);
+        // 设置试卷为已删除状态
         examPaper.setDeleted(true);
-        examPaperService.updateByIdFilter(examPaper);
-        return RestResponse.ok();
+        examPaperService.updateByIdFilter(examPaper);  // 更新试卷状态
+        return RestResponse.ok();  // 返回操作成功的响应
     }
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/MessageController.java

@@ -1,6 +1,5 @@
 package com.mindskip.xzs.controller.admin;
 
-
 import com.mindskip.xzs.base.BaseApiController;
 import com.mindskip.xzs.base.RestResponse;
 import com.mindskip.xzs.domain.Message;
@@ -25,41 +24,73 @@ import java.util.Date;
 import java.util.List;
 import java.util.stream.Collectors;
 
+/**
+ * 管理员消息管理控制器，提供对消息的管理和发送功能。
+ */
 @RestController("AdminMessageController")
 @RequestMapping(value = "/api/admin/message")
 public class MessageController extends BaseApiController {
 
+    // 注入消息服务和用户服务
     private final MessageService messageService;
     private final UserService userService;
 
+    /**
+     * 构造器，自动注入消息服务和用户服务
+     *
+     * @param messageService 消息服务
+     * @param userService    用户服务
+     */
     @Autowired
     public MessageController(MessageService messageService, UserService userService) {
         this.messageService = messageService;
         this.userService = userService;
     }
 
+    /**
+     * 获取消息分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回分页消息数据的响应
+     */
     @RequestMapping(value = "/page", method = RequestMethod.POST)
     public RestResponse<PageInfo<MessageResponseVM>> pageList(@RequestBody MessagePageRequestVM model) {
+        // 获取消息数据的分页信息
         PageInfo<Message> pageInfo = messageService.page(model);
+
+        // 获取消息ID列表，并根据ID获取消息用户列表
         List<Integer> ids = pageInfo.getList().stream().map(d -> d.getId()).collect(Collectors.toList());
         List<MessageUser> messageUsers = ids.size() == 0 ? null : messageService.selectByMessageIds(ids);
+
+        // 将分页数据转换为视图模型
         PageInfo<MessageResponseVM> page = PageInfoHelper.copyMap(pageInfo, m -> {
             MessageResponseVM vm = modelMapper.map(m, MessageResponseVM.class);
-            String receives = messageUsers.stream().filter(d -> d.getMessageId().equals(m.getId())).map(d -> d.getReceiveUserName())
-                    .collect(Collectors.joining(","));
+            // 将接收用户的用户名合并为字符串
+            String receives = messageUsers.stream().filter(d -> d.getMessageId().equals(m.getId()))
+                    .map(d -> d.getReceiveUserName()).collect(Collectors.joining(","));
             vm.setReceives(receives);
+            // 格式化创建时间
             vm.setCreateTime(DateTimeUtil.dateFormat(m.getCreateTime()));
             return vm;
         });
-        return RestResponse.ok(page);
-    }
 
+        return RestResponse.ok(page);  // 返回分页消息数据的响应
+    }
 
+    /**
+     * 发送消息给指定用户。
+     *
+     * @param model 发送请求模型
+     * @return RestResponse 返回发送成功的响应
+     */
     @RequestMapping(value = "/send", method = RequestMethod.POST)
     public RestResponse send(@RequestBody @Valid MessageSendVM model) {
-        User user = getCurrentUser();
+        User user = getCurrentUser();  // 获取当前用户
+        // 获取接收用户的列表
         List<User> receiveUser = userService.selectByIds(model.getReceiveUserIds());
-        Date now = new Date();
+        Date now = new Date();  // 获取当前时间
+
+        // 创建新的消息对象
         Message message = new Message();
         message.setTitle(model.getTitle());
         message.setContent(model.getContent());
@@ -69,17 +100,21 @@ public class MessageController extends BaseApiController {
         message.setSendUserId(user.getId());
         message.setSendUserName(user.getUserName());
         message.setSendRealName(user.getRealName());
+
+        // 创建每个接收用户的消息记录
         List<MessageUser> messageUsers = receiveUser.stream().map(d -> {
             MessageUser messageUser = new MessageUser();
             messageUser.setCreateTime(now);
-            messageUser.setReaded(false);
+            messageUser.setReaded(false);  // 设置为未读
             messageUser.setReceiveRealName(d.getRealName());
             messageUser.setReceiveUserId(d.getId());
             messageUser.setReceiveUserName(d.getUserName());
             return messageUser;
         }).collect(Collectors.toList());
+
+        // 发送消息和相关用户消息记录
         messageService.sendMessage(message, messageUsers);
-        return RestResponse.ok();
-    }
 
+        return RestResponse.ok();  // 返回发送成功的响应
+    }
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/QuestionController.java

@@ -20,6 +20,9 @@ import org.springframework.web.bind.annotation.*;
 
 import javax.validation.Valid;
 
+/**
+ * 管理员题目管理控制器，提供对题目的增删改查功能。
+ */
 @RestController("AdminQuestionController")
 @RequestMapping(value = "/api/admin/question")
 public class QuestionController extends BaseApiController {
@@ -27,62 +30,105 @@ public class QuestionController extends BaseApiController {
     private final QuestionService questionService;
     private final TextContentService textContentService;
 
+    /**
+     * 构造器，自动注入题目服务和文本内容服务
+     *
+     * @param questionService   题目服务
+     * @param textContentService 文本内容服务
+     */
     @Autowired
     public QuestionController(QuestionService questionService, TextContentService textContentService) {
         this.questionService = questionService;
         this.textContentService = textContentService;
     }
 
+    /**
+     * 获取题目分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回分页题目数据的响应
+     */
     @RequestMapping(value = "/page", method = RequestMethod.POST)
     public RestResponse<PageInfo<QuestionResponseVM>> pageList(@RequestBody QuestionPageRequestVM model) {
+        // 获取题目数据的分页信息
         PageInfo<Question> pageInfo = questionService.page(model);
+
+        // 将分页数据转换为视图模型
         PageInfo<QuestionResponseVM> page = PageInfoHelper.copyMap(pageInfo, q -> {
             QuestionResponseVM vm = modelMapper.map(q, QuestionResponseVM.class);
-            vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime()));
-            vm.setScore(ExamUtil.scoreToVM(q.getScore()));
-            TextContent textContent = textContentService.selectById(q.getInfoTextContentId());
+            vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime())); // 格式化创建时间
+            vm.setScore(ExamUtil.scoreToVM(q.getScore())); // 转换分数
+            TextContent textContent = textContentService.selectById(q.getInfoTextContentId()); // 获取题目信息
             QuestionObject questionObject = JsonUtil.toJsonObject(textContent.getContent(), QuestionObject.class);
-            String clearHtml = HtmlUtil.clear(questionObject.getTitleContent());
-            vm.setShortTitle(clearHtml);
+            String clearHtml = HtmlUtil.clear(questionObject.getTitleContent()); // 清理HTML标签
+            vm.setShortTitle(clearHtml); // 设置简短标题
             return vm;
         });
-        return RestResponse.ok(page);
+
+        return RestResponse.ok(page);  // 返回分页题目数据的响应
     }
 
+    /**
+     * 编辑题目。
+     *
+     * @param model 编辑请求模型
+     * @return RestResponse 返回编辑操作结果
+     */
     @RequestMapping(value = "/edit", method = RequestMethod.POST)
     public RestResponse edit(@RequestBody @Valid QuestionEditRequestVM model) {
+        // 验证编辑请求的合法性
         RestResponse validQuestionEditRequestResult = validQuestionEditRequestVM(model);
         if (validQuestionEditRequestResult.getCode() != SystemCode.OK.getCode()) {
-            return validQuestionEditRequestResult;
+            return validQuestionEditRequestResult; // 如果验证失败，返回错误信息
         }
 
+        // 如果没有题目ID，表示是新增题目
         if (null == model.getId()) {
-            questionService.insertFullQuestion(model, getCurrentUser().getId());
+            questionService.insertFullQuestion(model, getCurrentUser().getId()); // 新增题目
         } else {
-            questionService.updateFullQuestion(model);
+            questionService.updateFullQuestion(model); // 更新题目
         }
 
-        return RestResponse.ok();
+        return RestResponse.ok();  // 返回成功响应
     }
 
+    /**
+     * 获取指定ID的题目信息。
+     *
+     * @param id 题目ID
+     * @return RestResponse 返回题目信息
+     */
     @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
     public RestResponse<QuestionEditRequestVM> select(@PathVariable Integer id) {
-        QuestionEditRequestVM newVM = questionService.getQuestionEditRequestVM(id);
-        return RestResponse.ok(newVM);
+        QuestionEditRequestVM newVM = questionService.getQuestionEditRequestVM(id); // 获取题目信息
+        return RestResponse.ok(newVM);  // 返回题目信息
     }
 
-
+    /**
+     * 删除题目。
+     *
+     * @param id 题目ID
+     * @return RestResponse 返回删除结果
+     */
     @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
     public RestResponse delete(@PathVariable Integer id) {
-        Question question = questionService.selectById(id);
-        question.setDeleted(true);
-        questionService.updateByIdFilter(question);
-        return RestResponse.ok();
+        Question question = questionService.selectById(id); // 根据ID获取题目
+        question.setDeleted(true); // 标记为已删除
+        questionService.updateByIdFilter(question); // 更新题目状态
+        return RestResponse.ok();  // 返回成功响应
     }
 
+    /**
+     * 验证题目编辑请求是否合法。
+     *
+     * @param model 编辑请求模型
+     * @return RestResponse 返回验证结果
+     */
     private RestResponse validQuestionEditRequestVM(QuestionEditRequestVM model) {
         int qType = model.getQuestionType().intValue();
         boolean requireCorrect = qType == QuestionTypeEnum.SingleChoice.getCode() || qType == QuestionTypeEnum.TrueFalse.getCode();
+
+        // 对单选题和判断题检查是否填写正确答案
         if (requireCorrect) {
             if (StringUtils.isBlank(model.getCorrect())) {
                 String errorMsg = ErrorUtil.parameterErrorFormat("correct", "不能为空");
@@ -90,6 +136,7 @@ public class QuestionController extends BaseApiController {
             }
         }
 
+        // 对填空题检查分数是否一致
         if (qType == QuestionTypeEnum.GapFilling.getCode()) {
             Integer fillSumScore = model.getItems().stream().mapToInt(d -> ExamUtil.scoreFromVM(d.getScore())).sum();
             Integer questionScore = ExamUtil.scoreFromVM(model.getScore());
@@ -98,6 +145,7 @@ public class QuestionController extends BaseApiController {
                 return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
             }
         }
-        return RestResponse.ok();
+
+        return RestResponse.ok();  // 返回验证成功的响应
     }
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/TaskController.java

@@ -1,6 +1,5 @@
 package com.mindskip.xzs.controller.admin;
 
-
 import com.mindskip.xzs.base.BaseApiController;
 import com.mindskip.xzs.base.RestResponse;
 import com.mindskip.xzs.domain.TaskExam;
@@ -16,48 +15,86 @@ import org.springframework.web.bind.annotation.*;
 
 import javax.validation.Valid;
 
+/**
+ * 管理员任务控制器，提供对任务相关操作的接口。
+ */
 @RestController("AdminTaskController")
 @RequestMapping(value = "/api/admin/task")
 public class TaskController extends BaseApiController {
 
     private final TaskExamService taskExamService;
 
+    /**
+     * 构造器，自动注入任务服务。
+     *
+     * @param taskExamService 任务服务
+     */
     @Autowired
     public TaskController(TaskExamService taskExamService) {
         this.taskExamService = taskExamService;
     }
 
+    /**
+     * 获取任务分页列表。
+     *
+     * @param model 分页请求模型
+     * @return RestResponse 返回分页任务数据的响应
+     */
     @RequestMapping(value = "/page", method = RequestMethod.POST)
     public RestResponse<PageInfo<TaskPageResponseVM>> pageList(@RequestBody TaskPageRequestVM model) {
+        // 获取任务数据的分页信息
         PageInfo<TaskExam> pageInfo = taskExamService.page(model);
+
+        // 将分页数据转换为视图模型
         PageInfo<TaskPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, m -> {
             TaskPageResponseVM vm = modelMapper.map(m, TaskPageResponseVM.class);
-            vm.setCreateTime(DateTimeUtil.dateFormat(m.getCreateTime()));
+            vm.setCreateTime(DateTimeUtil.dateFormat(m.getCreateTime())); // 格式化创建时间
             return vm;
         });
-        return RestResponse.ok(page);
-    }
 
+        return RestResponse.ok(page);  // 返回分页任务数据的响应
+    }
 
+    /**
+     * 编辑任务。
+     *
+     * @param model 编辑请求模型
+     * @return RestResponse 返回编辑后的任务信息
+     */
     @RequestMapping(value = "/edit", method = RequestMethod.POST)
     public RestResponse edit(@RequestBody @Valid TaskRequestVM model) {
+        // 调用服务层方法处理任务编辑
         taskExamService.edit(model, getCurrentUser());
+
+        // 编辑后返回更新后的任务信息
         TaskRequestVM vm = taskExamService.taskExamToVM(model.getId());
-        return RestResponse.ok(vm);
+        return RestResponse.ok(vm);  // 返回更新后的任务信息
     }
 
-
+    /**
+     * 获取指定ID的任务信息。
+     *
+     * @param id 任务ID
+     * @return RestResponse 返回任务信息
+     */
     @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
     public RestResponse<TaskRequestVM> select(@PathVariable Integer id) {
-        TaskRequestVM vm = taskExamService.taskExamToVM(id);
-        return RestResponse.ok(vm);
+        TaskRequestVM vm = taskExamService.taskExamToVM(id); // 获取任务信息
+        return RestResponse.ok(vm);  // 返回任务信息
     }
 
+    /**
+     * 删除指定ID的任务。
+     *
+     * @param id 任务ID
+     * @return RestResponse 返回删除结果
+     */
     @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
     public RestResponse delete(@PathVariable Integer id) {
+        // 获取指定ID的任务
         TaskExam taskExam = taskExamService.selectById(id);
-        taskExam.setDeleted(true);
-        taskExamService.updateByIdFilter(taskExam);
-        return RestResponse.ok();
+        taskExam.setDeleted(true); // 标记任务为已删除
+        taskExamService.updateByIdFilter(taskExam); // 更新任务状态
+        return RestResponse.ok();  // 返回删除成功的响应
     }
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/UploadController.java

@@ -1,6 +1,5 @@
 package com.mindskip.xzs.controller.admin;
 
-
 import com.mindskip.xzs.base.BaseApiController;
 import com.mindskip.xzs.base.RestResponse;
 import com.mindskip.xzs.configuration.property.SystemConfig;
@@ -21,18 +20,27 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.Arrays;
 
-
+/**
+ * 管理员上传控制器，处理文件上传相关的接口。
+ */
 @RequestMapping("/api/admin/upload")
 @RestController("AdminUploadController")
 public class UploadController extends BaseApiController {
 
-    private final FileUpload fileUpload;
-    private final SystemConfig systemConfig;
-    private static final Logger logger = LoggerFactory.getLogger(UploadController.class);
-    private static final String IMAGE_UPLOAD = "imgUpload";
-    private static final String IMAGE_UPLOAD_FILE = "upFile";
-    private final UserService userService;
+    private final FileUpload fileUpload;  // 文件上传服务
+    private final SystemConfig systemConfig;  // 系统配置
+    private static final Logger logger = LoggerFactory.getLogger(UploadController.class);  // 日志记录器
+    private static final String IMAGE_UPLOAD = "imgUpload";  // 图片上传的标识
+    private static final String IMAGE_UPLOAD_FILE = "upFile";  // 上传文件的字段名
+    private final UserService userService;  // 用户服务
 
+    /**
+     * 构造器，自动注入文件上传服务、系统配置和用户服务。
+     *
+     * @param fileUpload   文件上传服务
+     * @param systemConfig 系统配置
+     * @param userService  用户服务
+     */
     @Autowired
     public UploadController(FileUpload fileUpload, SystemConfig systemConfig, UserService userService) {
         this.fileUpload = fileUpload;
@@ -40,20 +48,34 @@ public class UploadController extends BaseApiController {
         this.userService = userService;
     }
 
+    /**
+     * 处理上传请求，根据不同的 action 进行不同的操作。
+     *
+     * @param request  HTTP 请求
+     * @param response HTTP 响应
+     * @return Object 返回上传结果或配置
+     */
     @ResponseBody
     @RequestMapping("/configAndUpload")
     public Object upload(HttpServletRequest request, HttpServletResponse response) {
-        String action = request.getParameter("action");
+        String action = request.getParameter("action");  // 获取请求中的 action 参数
+
+        // 如果 action 为图片上传
         if (action.equals(IMAGE_UPLOAD)) {
             try {
+                // 获取上传的文件
                 MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
                 MultipartFile multipartFile = multipartHttpServletRequest.getFile(IMAGE_UPLOAD_FILE);
-                long attachSize = multipartFile.getSize();
-                String imgName = multipartFile.getOriginalFilename();
+                long attachSize = multipartFile.getSize();  // 获取文件大小
+                String imgName = multipartFile.getOriginalFilename();  // 获取文件名
+
+                // 上传文件并获取文件路径
                 String filePath;
                 try (InputStream inputStream = multipartFile.getInputStream()) {
                     filePath = fileUpload.uploadFile(inputStream, attachSize, imgName);
                 }
+
+                // 获取文件类型并封装上传结果
                 String imageType = imgName.substring(imgName.lastIndexOf("."));
                 UploadResultVM uploadResultVM = new UploadResultVM();
                 uploadResultVM.setOriginal(imgName);
@@ -61,43 +83,55 @@ public class UploadController extends BaseApiController {
                 uploadResultVM.setUrl(filePath);
                 uploadResultVM.setSize(multipartFile.getSize());
                 uploadResultVM.setType(imageType);
-                uploadResultVM.setState("SUCCESS");
-                return uploadResultVM;
+                uploadResultVM.setState("SUCCESS");  // 上传成功
+
+                return uploadResultVM;  // 返回上传结果
             } catch (IOException e) {
-                logger.error(e.getMessage(), e);
+                logger.error(e.getMessage(), e);  // 记录异常日志
             }
         } else {
+            // 如果 action 不为图片上传，返回 Ueditor 配置
             UeditorConfigVM ueditorConfigVM = new UeditorConfigVM();
             ueditorConfigVM.setImageActionName(IMAGE_UPLOAD);
             ueditorConfigVM.setImageFieldName(IMAGE_UPLOAD_FILE);
-            ueditorConfigVM.setImageMaxSize(2048000L);
+            ueditorConfigVM.setImageMaxSize(2048000L);  // 最大文件大小：2MB
             ueditorConfigVM.setImageAllowFiles(Arrays.asList(".png", ".jpg", ".jpeg", ".gif", ".bmp"));
             ueditorConfigVM.setImageCompressEnable(true);
             ueditorConfigVM.setImageCompressBorder(1600);
             ueditorConfigVM.setImageInsertAlign("none");
             ueditorConfigVM.setImageUrlPrefix("");
             ueditorConfigVM.setImagePathFormat("");
-            return ueditorConfigVM;
+
+            return ueditorConfigVM;  // 返回 Ueditor 配置
         }
-        return null;
-    }
 
+        return null;  // 默认返回 null
+    }
 
+    /**
+     * 上传图片并更新用户头像。
+     *
+     * @param request HTTP 请求
+     * @return RestResponse 返回上传结果
+     */
     @RequestMapping("/image")
     @ResponseBody
     public RestResponse questionUploadAndReadExcel(HttpServletRequest request) {
+        // 获取上传的文件
         MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
         MultipartFile multipartFile = multipartHttpServletRequest.getFile("file");
-        long attachSize = multipartFile.getSize();
-        String imgName = multipartFile.getOriginalFilename();
+        long attachSize = multipartFile.getSize();  // 获取文件大小
+        String imgName = multipartFile.getOriginalFilename();  // 获取文件名
+
         try (InputStream inputStream = multipartFile.getInputStream()) {
+            // 上传文件并获取文件路径
             String filePath = fileUpload.uploadFile(inputStream, attachSize, imgName);
+
+            // 更新当前用户头像
             userService.changePicture(getCurrentUser(), filePath);
-            return RestResponse.ok(filePath);
+            return RestResponse.ok(filePath);  // 返回上传后的文件路径
         } catch (IOException e) {
-            return RestResponse.fail(2, e.getMessage());
+            return RestResponse.fail(2, e.getMessage());  // 返回失败响应
         }
     }
-
-
 }

source/xzs/src/main/java/com/mindskip/xzs/controller/admin/UserController.java

@@ -23,15 +23,24 @@ import java.util.Date;
 import java.util.List;
 import java.util.UUID;
 
-
+/**
+ * 用户管理控制器，提供管理员操作用户的各类接口，如分页查询、编辑用户、修改状态等。
+ */
 @RestController("AdminUserController")
 @RequestMapping(value = "/api/admin/user")
 public class UserController extends BaseApiController {
 
-    private final UserService userService;
-    private final UserEventLogService userEventLogService;
-    private final AuthenticationService authenticationService;
-
+    private final UserService userService;  // 用户服务
+    private final UserEventLogService userEventLogService;  // 用户事件日志服务
+    private final AuthenticationService authenticationService;  // 认证服务
+
+    /**
+     * 构造器，自动注入所需服务。
+     *
+     * @param userService          用户服务
+     * @param userEventLogService  用户事件日志服务
+     * @param authenticationService 认证服务
+     */
     @Autowired
     public UserController(UserService userService, UserEventLogService userEventLogService, AuthenticationService authenticationService) {
         this.userService = userService;
@@ -39,113 +48,159 @@ public class UserController extends BaseApiController {
         this.authenticationService = authenticationService;
     }
 
-
+    /**
+     * 分页获取用户列表。
+     *
+     * @param model 用户分页请求模型
+     * @return 分页的用户信息
+     */
     @RequestMapping(value = "/page/list", method = RequestMethod.POST)
     public RestResponse<PageInfo<UserResponseVM>> pageList(@RequestBody UserPageRequestVM model) {
-        PageInfo<User> pageInfo = userService.userPage(model);
-        PageInfo<UserResponseVM> page = PageInfoHelper.copyMap(pageInfo, d -> UserResponseVM.from(d));
-        return RestResponse.ok(page);
+        PageInfo<User> pageInfo = userService.userPage(model);  // 获取用户分页数据
+        PageInfo<UserResponseVM> page = PageInfoHelper.copyMap(pageInfo, d -> UserResponseVM.from(d));  // 转换为视图模型
+        return RestResponse.ok(page);  // 返回分页数据
     }
 
-
+    /**
+     * 分页获取用户事件日志列表。
+     *
+     * @param model 用户事件分页请求模型
+     * @return 分页的用户事件日志信息
+     */
     @RequestMapping(value = "/event/page/list", method = RequestMethod.POST)
     public RestResponse<PageInfo<UserEventLogVM>> eventPageList(@RequestBody UserEventPageRequestVM model) {
-        PageInfo<UserEventLog> pageInfo = userEventLogService.page(model);
+        PageInfo<UserEventLog> pageInfo = userEventLogService.page(model);  // 获取用户事件日志分页数据
         PageInfo<UserEventLogVM> page = PageInfoHelper.copyMap(pageInfo, d -> {
             UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class);
-            vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));
+            vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));  // 格式化时间
             return vm;
         });
-        return RestResponse.ok(page);
+        return RestResponse.ok(page);  // 返回分页数据
     }
 
+    /**
+     * 根据用户ID获取用户详情。
+     *
+     * @param id 用户ID
+     * @return 用户信息
+     */
     @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
     public RestResponse<UserResponseVM> select(@PathVariable Integer id) {
-        User user = userService.getUserById(id);
-        UserResponseVM userVm = UserResponseVM.from(user);
-        return RestResponse.ok(userVm);
+        User user = userService.getUserById(id);  // 获取用户信息
+        UserResponseVM userVm = UserResponseVM.from(user);  // 转换为视图模型
+        return RestResponse.ok(userVm);  // 返回用户信息
     }
 
+    /**
+     * 获取当前登录用户信息。
+     *
+     * @return 当前登录用户信息
+     */
     @RequestMapping(value = "/current", method = RequestMethod.POST)
     public RestResponse<UserResponseVM> current() {
-        User user = getCurrentUser();
-        UserResponseVM userVm = UserResponseVM.from(user);
-        return RestResponse.ok(userVm);
+        User user = getCurrentUser();  // 获取当前登录用户
+        UserResponseVM userVm = UserResponseVM.from(user);  // 转换为视图模型
+        return RestResponse.ok(userVm);  // 返回当前用户信息
     }
 
-
+    /**
+     * 编辑用户信息，支持新增和修改用户。
+     *
+     * @param model 用户创建或更新模型
+     * @return 编辑后的用户信息
+     */
     @RequestMapping(value = "/edit", method = RequestMethod.POST)
     public RestResponse<User> edit(@RequestBody @Valid UserCreateVM model) {
-        if (model.getId() == null) {  //create
+        if (model.getId() == null) {  // 新增用户
             User existUser = userService.getUserByUserName(model.getUserName());
             if (null != existUser) {
-                return new RestResponse<>(2, "用户已存在");
+                return new RestResponse<>(2, "用户已存在");  // 用户名已存在
             }
 
             if (StringUtils.isBlank(model.getPassword())) {
-                return new RestResponse<>(3, "密码不能为空");
+                return new RestResponse<>(3, "密码不能为空");  // 密码不能为空
             }
         }
         if (StringUtils.isBlank(model.getBirthDay())) {
-            model.setBirthDay(null);
+            model.setBirthDay(null);  // 生日为空时设置为 null
         }
-        User user = modelMapper.map(model, User.class);
+        User user = modelMapper.map(model, User.class);  // 转换为用户实体
 
-        if (model.getId() == null) {
-            String encodePwd = authenticationService.pwdEncode(model.getPassword());
+        if (model.getId() == null) {  // 新增用户时加密密码并设置其他默认值
+            String encodePwd = authenticationService.pwdEncode(model.getPassword());  // 密码加密
             user.setPassword(encodePwd);
             user.setUserUuid(UUID.randomUUID().toString());
             user.setCreateTime(new Date());
             user.setLastActiveTime(new Date());
             user.setDeleted(false);
-            userService.insertByFilter(user);
-        } else {
+            userService.insertByFilter(user);  // 插入新用户
+        } else {  // 修改用户时更新信息
             if (!StringUtils.isBlank(model.getPassword())) {
-                String encodePwd = authenticationService.pwdEncode(model.getPassword());
+                String encodePwd = authenticationService.pwdEncode(model.getPassword());  // 密码加密
                 user.setPassword(encodePwd);
             }
-            user.setModifyTime(new Date());
-            userService.updateByIdFilter(user);
+            user.setModifyTime(new Date());  // 设置修改时间
+            userService.updateByIdFilter(user);  // 更新用户信息
         }
-        return RestResponse.ok(user);
+        return RestResponse.ok(user);  // 返回操作后的用户信息
     }
 
-
+    /**
+     * 更新当前用户信息。
+     *
+     * @param model 用户更新模型
+     * @return 操作结果
+     */
     @RequestMapping(value = "/update", method = RequestMethod.POST)
     public RestResponse update(@RequestBody @Valid UserUpdateVM model) {
-        User user = userService.selectById(getCurrentUser().getId());
-        modelMapper.map(model, user);
-        user.setModifyTime(new Date());
-        userService.updateByIdFilter(user);
-        return RestResponse.ok();
+        User user = userService.selectById(getCurrentUser().getId());  // 获取当前用户
+        modelMapper.map(model, user);  // 更新用户信息
+        user.setModifyTime(new Date());  // 设置修改时间
+        userService.updateByIdFilter(user);  // 更新用户
+        return RestResponse.ok();  // 返回成功响应
     }
 
-
+    /**
+     * 修改用户状态（启用/禁用）。
+     *
+     * @param id 用户ID
+     * @return 更新后的状态
+     */
     @RequestMapping(value = "/changeStatus/{id}", method = RequestMethod.POST)
     public RestResponse<Integer> changeStatus(@PathVariable Integer id) {
-        User user = userService.getUserById(id);
+        User user = userService.getUserById(id);  // 获取用户信息
         UserStatusEnum userStatusEnum = UserStatusEnum.fromCode(user.getStatus());
-        Integer newStatus = userStatusEnum == UserStatusEnum.Enable ? UserStatusEnum.Disable.getCode() : UserStatusEnum.Enable.getCode();
+        Integer newStatus = userStatusEnum == UserStatusEnum.Enable ? UserStatusEnum.Disable.getCode() : UserStatusEnum.Enable.getCode();  // 切换状态
         user.setStatus(newStatus);
-        user.setModifyTime(new Date());
-        userService.updateByIdFilter(user);
-        return RestResponse.ok(newStatus);
+        user.setModifyTime(new Date());  // 设置修改时间
+        userService.updateByIdFilter(user);  // 更新用户状态
+        return RestResponse.ok(newStatus);  // 返回新状态
     }
 
-
+    /**
+     * 删除用户（标记为删除）。
+     *
+     * @param id 用户ID
+     * @return 操作结果
+     */
     @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
     public RestResponse delete(@PathVariable Integer id) {
-        User user = userService.getUserById(id);
-        user.setDeleted(true);
-        userService.updateByIdFilter(user);
-        return RestResponse.ok();
+        User user = userService.getUserById(id);  // 获取用户信息
+        user.setDeleted(true);  // 标记为已删除
+        userService.updateByIdFilter(user);  // 更新用户状态
+        return RestResponse.ok();  // 返回成功响应
     }
 
-
+    /**
+     * 根据用户名查找用户。
+     *
+     * @param userName 用户名
+     * @return 用户列表
+     */
     @RequestMapping(value = "/selectByUserName", method = RequestMethod.POST)
     public RestResponse<List<KeyValue>> selectByUserName(@RequestBody String userName) {
-        List<KeyValue> keyValues = userService.selectByUserName(userName);
-        return RestResponse.ok(keyValues);
+        List<KeyValue> keyValues = userService.selectByUserName(userName);  // 查找用户名
+        return RestResponse.ok(keyValues);  // 返回用户名匹配的结果
     }
 
 }