diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/controller/PaperController.java b/src-源文件/main/java/com/yf/exam/modules/paper/controller/PaperController.java
index 5549670..a3ad8ed 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/controller/PaperController.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/controller/PaperController.java
@@ -1,13 +1,19 @@
-package com.yf.exam.modules.paper.controller;
+package com.yf.exam.modules.paper.controller; // 定义当前类所在的包路径
+// 引入分页查询结果的接口
import com.baomidou.mybatisplus.core.metadata.IPage;
+// 引入统一的API响应封装类
import com.yf.exam.core.api.ApiRest;
+// 引入基础控制器类,提供通用的API响应方法
import com.yf.exam.core.api.controller.BaseController;
+// 引入各种DTO类,用于请求和响应数据传输
import com.yf.exam.core.api.dto.BaseIdReqDTO;
import com.yf.exam.core.api.dto.BaseIdRespDTO;
import com.yf.exam.core.api.dto.BaseIdsReqDTO;
import com.yf.exam.core.api.dto.PagingReqDTO;
+// 引入工具类,用于对象之间的属性拷贝
import com.yf.exam.core.utils.BeanMapper;
+// 引入试卷相关的DTO类
import com.yf.exam.modules.paper.dto.PaperDTO;
import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
@@ -17,14 +23,22 @@ import com.yf.exam.modules.paper.dto.request.PaperQuQueryDTO;
import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
+// 引入试卷实体类
import com.yf.exam.modules.paper.entity.Paper;
+// 引入试卷相关的业务处理服务类
import com.yf.exam.modules.paper.service.PaperService;
+// 引入用户工具类,获取当前登录用户信息
import com.yf.exam.modules.user.UserUtils;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
+// 引入Shiro注解,用于角色权限管理
import org.apache.shiro.authz.annotation.RequiresRoles;
+// 引入Spring的Bean工具类,用于属性复制
import org.springframework.beans.BeanUtils;
+// 引入Spring的自动注入注解,用于自动注入服务
import org.springframework.beans.factory.annotation.Autowired;
+// 引入Spring的Web注解,定义HTTP请求的映射方式
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@@ -34,123 +48,126 @@ import org.springframework.web.bind.annotation.RestController;
*
* 试卷控制器
*
-*
+* 提供有关试卷的操作,如分页查询、创建试卷、查看试卷详情等
* @author 聪明笨狗
* @since 2020-05-25 16:33
*/
-@Api(tags={"试卷"})
-@RestController
-@RequestMapping("/exam/api/paper/paper")
-public class PaperController extends BaseController {
+@Api(tags={"试卷"}) // Swagger API 文档注解,用于描述该接口属于试卷相关操作
+@RestController // 标记为Spring的控制器,处理HTTP请求
+@RequestMapping("/exam/api/paper/paper") // 定义请求路径的基础路径
+public class PaperController extends BaseController { // 继承BaseController类,提供基本的API返回
- @Autowired
+ @Autowired // 自动注入PaperService,负责业务逻辑处理
private PaperService baseService;
/**
- * 分页查找
- * @param reqDTO
- * @return
+ * 分页查找试卷列表
+ * @param reqDTO 包含分页信息和查询条件的请求数据
+ * @return 分页后的试卷列表
*/
- @ApiOperation(value = "分页查找")
- @RequestMapping(value = "/paging", method = { RequestMethod.POST})
+ @ApiOperation(value = "分页查找") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/paging", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest> paging(@RequestBody PagingReqDTO reqDTO) {
- //分页查询并转换
+ // 调用业务层进行分页查询
IPage page = baseService.paging(reqDTO);
+ // 返回成功响应,并附带查询结果
return super.success(page);
}
-
-
/**
* 创建试卷
- * @param reqDTO
- * @return
+ * @param reqDTO 创建试卷所需的请求数据
+ * @return 返回创建成功后的试卷ID
*/
- @ApiOperation(value = "创建试卷")
- @RequestMapping(value = "/create-paper", method = { RequestMethod.POST})
+ @ApiOperation(value = "创建试卷") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/create-paper", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest save(@RequestBody PaperCreateReqDTO reqDTO) {
- //复制参数
+ // 调用业务层创建试卷,传入当前用户ID和考试ID
String paperId = baseService.createPaper(UserUtils.getUserId(), reqDTO.getExamId());
+ // 返回创建结果,包括试卷ID
return super.success(new BaseIdRespDTO(paperId));
}
/**
- * 批量删除
- * @param reqDTO
- * @return
+ * 获取试卷详情
+ * @param reqDTO 请求参数,包含试卷ID
+ * @return 返回试卷的详细信息
*/
- @ApiOperation(value = "试卷详情")
- @RequestMapping(value = "/paper-detail", method = { RequestMethod.POST})
+ @ApiOperation(value = "试卷详情") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/paper-detail", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest paperDetail(@RequestBody BaseIdReqDTO reqDTO) {
- //根据ID删除
+ // 调用业务层获取试卷详情
ExamDetailRespDTO respDTO = baseService.paperDetail(reqDTO.getId());
+ // 返回成功响应,并附带试卷详情
return super.success(respDTO);
}
/**
- * 批量删除
- * @param reqDTO
- * @return
+ * 获取试题详情
+ * @param reqDTO 请求参数,包含试卷ID和试题ID
+ * @return 返回试题的详细信息
*/
- @ApiOperation(value = "试题详情")
- @RequestMapping(value = "/qu-detail", method = { RequestMethod.POST})
+ @ApiOperation(value = "试题详情") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/qu-detail", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest quDetail(@RequestBody PaperQuQueryDTO reqDTO) {
- //根据ID删除
+ // 调用业务层获取试题详情
PaperQuDetailDTO respDTO = baseService.findQuDetail(reqDTO.getPaperId(), reqDTO.getQuId());
+ // 返回成功响应,并附带试题详情
return super.success(respDTO);
}
/**
* 填充答案
- * @param reqDTO
- * @return
+ * @param reqDTO 请求数据,包含填充的答案
+ * @return 返回操作成功的响应
*/
- @ApiOperation(value = "填充答案")
- @RequestMapping(value = "/fill-answer", method = { RequestMethod.POST})
+ @ApiOperation(value = "填充答案") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/fill-answer", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest fillAnswer(@RequestBody PaperAnswerDTO reqDTO) {
- //根据ID删除
+ // 调用业务层填充答案操作
baseService.fillAnswer(reqDTO);
+ // 返回成功响应
return super.success();
}
-
/**
* 交卷操作
- * @param reqDTO
- * @return
+ * @param reqDTO 请求数据,包含试卷ID
+ * @return 返回交卷操作成功的响应
*/
- @ApiOperation(value = "交卷操作")
- @RequestMapping(value = "/hand-exam", method = { RequestMethod.POST})
+ @ApiOperation(value = "交卷操作") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/hand-exam", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest handleExam(@RequestBody BaseIdReqDTO reqDTO) {
- //根据ID删除
+ // 调用业务层进行交卷操作
baseService.handExam(reqDTO.getId());
+ // 返回成功响应
return super.success();
}
-
/**
- * 批量删除
- * @param reqDTO
- * @return
+ * 获取试卷结果
+ * @param reqDTO 请求数据,包含试卷ID
+ * @return 返回试卷的考试结果
*/
- @ApiOperation(value = "试卷详情")
- @RequestMapping(value = "/paper-result", method = { RequestMethod.POST})
+ @ApiOperation(value = "试卷结果") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/paper-result", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest paperResult(@RequestBody BaseIdReqDTO reqDTO) {
- //根据ID删除
+ // 调用业务层获取试卷的考试结果
ExamResultRespDTO respDTO = baseService.paperResult(reqDTO.getId());
+ // 返回成功响应,并附带试卷结果
return super.success(respDTO);
}
-
/**
* 检测用户有没有中断的考试
- * @return
+ * @return 返回用户未完成的考试信息
*/
- @ApiOperation(value = "检测进行中的考试")
- @RequestMapping(value = "/check-process", method = { RequestMethod.POST})
+ @ApiOperation(value = "检测进行中的考试") // Swagger操作注解,用于描述接口
+ @RequestMapping(value = "/check-process", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest checkProcess() {
- //复制参数
+ // 调用业务层检测用户是否有未完成的考试
PaperDTO dto = baseService.checkProcess(UserUtils.getUserId());
+ // 返回成功响应,并附带考试进程数据
return super.success(dto);
}
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperDTO.java
index dcfb9ef..8b59dcb 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperDTO.java
@@ -1,79 +1,83 @@
-package com.yf.exam.modules.paper.dto;
+package com.yf.exam.modules.paper.dto; // 定义当前类所在的包路径
+// 引入Dict注解,用于字典表的映射
import com.yf.exam.core.annon.Dict;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入Serializable接口,用于对象序列化
import java.io.Serializable;
+// 引入Date类,用于表示日期和时间
import java.util.Date;
/**
-*
-* 试卷请求类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷", description="试卷")
-public class PaperDTO implements Serializable {
-
- private static final long serialVersionUID = 1L;
+ *
+ * 试卷请求类
+ *
+ * 该类用于传输试卷的基本信息,包含试卷的ID、考试规则、标题、时长、得分等字段。
+ * 提供了试卷的详细信息,通常在查询和展示试卷时使用。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷", description="试卷") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperDTO implements Serializable { // 实现Serializable接口,表示该类的对象可以被序列化
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
- @ApiModelProperty(value = "试卷ID", required=true)
- private String id;
+ @ApiModelProperty(value = "试卷ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String id; // 试卷ID
- @Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id")
- @ApiModelProperty(value = "用户ID", required=true)
- private String userId;
+ @Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id") // 字典表映射,映射用户表的姓名字段
+ @ApiModelProperty(value = "用户ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String userId; // 用户ID
- @Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id")
- @ApiModelProperty(value = "部门ID", required=true)
- private String departId;
+ @Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id") // 字典表映射,映射部门表的部门名称字段
+ @ApiModelProperty(value = "部门ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String departId; // 部门ID
- @ApiModelProperty(value = "规则ID", required=true)
- private String examId;
+ @ApiModelProperty(value = "规则ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String examId; // 规则ID,表示该试卷对应的考试规则
- @ApiModelProperty(value = "考试标题", required=true)
- private String title;
+ @ApiModelProperty(value = "考试标题", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String title; // 考试标题,表示试卷的名称
- @ApiModelProperty(value = "考试时长", required=true)
- private Integer totalTime;
+ @ApiModelProperty(value = "考试时长", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer totalTime; // 考试时长(单位:分钟)
- @ApiModelProperty(value = "用户时长", required=true)
- private Integer userTime;
+ @ApiModelProperty(value = "用户时长", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer userTime; // 用户已使用的时间(单位:分钟)
- @ApiModelProperty(value = "试卷总分", required=true)
- private Integer totalScore;
+ @ApiModelProperty(value = "试卷总分", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer totalScore; // 试卷总分
- @ApiModelProperty(value = "及格分", required=true)
- private Integer qualifyScore;
+ @ApiModelProperty(value = "及格分", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer qualifyScore; // 及格分数
- @ApiModelProperty(value = "客观分", required=true)
- private Integer objScore;
+ @ApiModelProperty(value = "客观分", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer objScore; // 客观题分数
- @ApiModelProperty(value = "主观分", required=true)
- private Integer subjScore;
+ @ApiModelProperty(value = "主观分", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer subjScore; // 主观题分数
- @ApiModelProperty(value = "用户得分", required=true)
- private Integer userScore;
+ @ApiModelProperty(value = "用户得分", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer userScore; // 用户得分
- @ApiModelProperty(value = "是否包含简答题", required=true)
- private Boolean hasSaq;
+ @ApiModelProperty(value = "是否包含简答题", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Boolean hasSaq; // 是否包含简答题,布尔类型,表示该试卷是否有简答题
- @ApiModelProperty(value = "试卷状态", required=true)
- private Integer state;
+ @ApiModelProperty(value = "试卷状态", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer state; // 试卷状态,表示试卷的当前状态,如未开始、进行中、已结束等
- @ApiModelProperty(value = "创建时间", required=true)
- private Date createTime;
+ @ApiModelProperty(value = "创建时间", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Date createTime; // 创建时间,表示试卷的创建时间
- @ApiModelProperty(value = "更新时间", required=true)
- private Date updateTime;
+ @ApiModelProperty(value = "更新时间", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Date updateTime; // 更新时间,表示试卷的最后更新时间
- @ApiModelProperty(value = "截止时间")
- private Date limitTime;
-
+ @ApiModelProperty(value = "截止时间") // Swagger注解,描述该字段在API文档中的含义
+ private Date limitTime; // 截止时间,表示考试的最后提交时间
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuAnswerDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuAnswerDTO.java
index e449e79..48672a7 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuAnswerDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuAnswerDTO.java
@@ -1,48 +1,50 @@
-package com.yf.exam.modules.paper.dto;
+package com.yf.exam.modules.paper.dto; // 定义当前类所在的包路径
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入Serializable接口,用于对象序列化
import java.io.Serializable;
/**
-*
-* 试卷考题备选答案请求类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
-public class PaperQuAnswerDTO implements Serializable {
-
- private static final long serialVersionUID = 1L;
+ *
+ * 试卷考题备选答案请求类
+ *
+ * 该类用于表示试卷考题的备选答案,包含每个备选答案的ID、题目ID、选项标签、是否选中等信息。
+ * 适用于考题答案的请求传输。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperQuAnswerDTO implements Serializable { // 实现Serializable接口,表示该类的对象可以被序列化
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
- @ApiModelProperty(value = "自增ID", required=true)
- private String id;
+ @ApiModelProperty(value = "自增ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String id; // 自增ID,表示备选答案的唯一标识符
- @ApiModelProperty(value = "试卷ID", required=true)
- private String paperId;
+ @ApiModelProperty(value = "试卷ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String paperId; // 试卷ID,表示该备选答案所属的试卷
- @ApiModelProperty(value = "回答项ID", required=true)
- private String answerId;
+ @ApiModelProperty(value = "回答项ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String answerId; // 回答项ID,表示该备选答案的唯一标识符
- @ApiModelProperty(value = "题目ID", required=true)
- private String quId;
+ @ApiModelProperty(value = "题目ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String quId; // 题目ID,表示该备选答案所属的题目
- @ApiModelProperty(value = "是否正确项", required=true)
- private Boolean isRight;
+ @ApiModelProperty(value = "是否正确项", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Boolean isRight; // 是否正确项,布尔值,表示该备选答案是否是正确答案
- @ApiModelProperty(value = "是否选中", required=true)
- private Boolean checked;
+ @ApiModelProperty(value = "是否选中", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Boolean checked; // 是否选中,布尔值,表示该备选答案是否已被选中
- @ApiModelProperty(value = "排序", required=true)
- private Integer sort;
+ @ApiModelProperty(value = "排序", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer sort; // 排序,表示该备选答案在题目中的排序位置
- @ApiModelProperty(value = "选项标签", required=true)
- private String abc;
-
+ @ApiModelProperty(value = "选项标签", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String abc; // 选项标签,通常为 A、B、C、D 等,表示该备选答案的标识符
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuDTO.java
index 349868e..05bf6d7 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuDTO.java
@@ -1,54 +1,55 @@
-package com.yf.exam.modules.paper.dto;
+package com.yf.exam.modules.paper.dto; // 定义当前类所在的包路径
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入Serializable接口,用于对象序列化
import java.io.Serializable;
/**
-*
-* 试卷考题请求类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷考题", description="试卷考题")
-public class PaperQuDTO implements Serializable {
-
- private static final long serialVersionUID = 1L;
+ *
+ * 试卷考题请求类
+ *
+ * 该类用于表示试卷中的每一道题目,包含题目的基本信息,如题目ID、试卷ID、题目类型、是否答对、得分等。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷考题", description="试卷考题") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperQuDTO implements Serializable { // 实现Serializable接口,表示该类的对象可以被序列化
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
- @ApiModelProperty(value = "ID", required=true)
- private String id;
+ @ApiModelProperty(value = "ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String id; // 题目ID,唯一标识符
- @ApiModelProperty(value = "试卷ID", required=true)
- private String paperId;
+ @ApiModelProperty(value = "试卷ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String paperId; // 试卷ID,表示该题目所属的试卷
- @ApiModelProperty(value = "题目ID", required=true)
- private String quId;
+ @ApiModelProperty(value = "题目ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String quId; // 题目ID,唯一标识该题目
- @ApiModelProperty(value = "题目类型", required=true)
- private Integer quType;
+ @ApiModelProperty(value = "题目类型", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer quType; // 题目类型,表示题目的分类,如选择题、判断题、主观题等
- @ApiModelProperty(value = "是否已答", required=true)
- private Boolean answered;
+ @ApiModelProperty(value = "是否已答", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Boolean answered; // 是否已答,布尔值,表示该题目是否已被回答
- @ApiModelProperty(value = "主观答案", required=true)
- private String answer;
+ @ApiModelProperty(value = "主观答案", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String answer; // 主观答案,表示对该题目的回答内容(适用于主观题)
- @ApiModelProperty(value = "问题排序", required=true)
- private Integer sort;
+ @ApiModelProperty(value = "问题排序", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer sort; // 问题排序,表示该题目在试卷中的顺序
- @ApiModelProperty(value = "单题分分值", required=true)
- private Integer score;
+ @ApiModelProperty(value = "单题分分值", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer score; // 单题分值,表示该题目的满分
- @ApiModelProperty(value = "实际得分(主观题)", required=true)
- private Integer actualScore;
+ @ApiModelProperty(value = "实际得分(主观题)", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer actualScore; // 实际得分,表示用户在该题目中实际得到的分数(适用于主观题)
- @ApiModelProperty(value = "是否答对", required=true)
- private Boolean isRight;
-
+ @ApiModelProperty(value = "是否答对", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Boolean isRight; // 是否答对,布尔值,表示用户是否答对了该题目
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuAnswerExtDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuAnswerExtDTO.java
index 3124d9e..357808a 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuAnswerExtDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuAnswerExtDTO.java
@@ -1,29 +1,30 @@
-package com.yf.exam.modules.paper.dto.ext;
+package com.yf.exam.modules.paper.dto.ext; // 定义该类所在的包路径
+// 引入试题答案DTO类,作为当前类的父类
import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
/**
*
* 试卷考题备选答案请求类
*
-*
+* 该类用于描述试卷考题的备选答案信息,继承自PaperQuAnswerDTO,扩展了额外的字段,如图片和内容。
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
-@Data
-@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
-public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO {
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案") // Swagger注解,描述模型信息,生成API文档时使用
+public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO { // 继承自PaperQuAnswerDTO类,扩展了额外属性
- private static final long serialVersionUID = 1L;
+ private static final long serialVersionUID = 1L; // 序列化版本号,用于序列化和反序列化时的版本控制
- @ApiModelProperty(value = "试题图片", required=true)
- private String image;
+ @ApiModelProperty(value = "试题图片", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String image; // 试题对应的图片内容
- @ApiModelProperty(value = "答案内容", required=true)
- private String content;
-
-
+ @ApiModelProperty(value = "答案内容", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String content; // 备选答案的具体内容
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuDetailDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuDetailDTO.java
index ee1e998..e2d693b 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuDetailDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuDetailDTO.java
@@ -1,32 +1,35 @@
-package com.yf.exam.modules.paper.dto.ext;
+package com.yf.exam.modules.paper.dto.ext; // 定义当前类所在的包路径
+// 引入试题DTO类,作为当前类的父类
import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入List集合,用于存储多个备选答案
import java.util.List;
/**
*
* 试卷考题请求类
*
-*
+* 该类用于描述试卷中每个考题的详细信息,继承自PaperQuDTO,扩展了试题的图片、内容和答案列表等字段。
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
-@Data
-@ApiModel(value="试卷题目详情类", description="试卷题目详情类")
-public class PaperQuDetailDTO extends PaperQuDTO {
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷题目详情类", description="试卷题目详情类") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperQuDetailDTO extends PaperQuDTO { // 继承自PaperQuDTO类,扩展了额外属性
- private static final long serialVersionUID = 1L;
+ private static final long serialVersionUID = 1L; // 序列化版本号,用于序列化和反序列化时的版本控制
- @ApiModelProperty(value = "图片", required=true)
- private String image;
+ @ApiModelProperty(value = "图片", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String image; // 题目的图片内容
- @ApiModelProperty(value = "题目内容", required=true)
- private String content;
+ @ApiModelProperty(value = "题目内容", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String content; // 试题的具体内容
- @ApiModelProperty(value = "答案内容", required=true)
- List answerList;
+ @ApiModelProperty(value = "答案内容", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private List answerList; // 存储该题目的备选答案,使用List集合存储多个答案
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperAnswerDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperAnswerDTO.java
index ccbe3ce..25df4c6 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperAnswerDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperAnswerDTO.java
@@ -1,22 +1,25 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入List集合,用于存储多个答案
import java.util.List;
/**
* @author bool
+ * 查找试卷题目详情请求类,用于接收查找试卷题目详情的请求数据。
+ * 继承自PaperQuQueryDTO,扩展了回答列表和主观答案字段。
*/
-@Data
-@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
-public class PaperAnswerDTO extends PaperQuQueryDTO {
-
- @ApiModelProperty(value = "回答列表", required=true)
- private List answers;
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperAnswerDTO extends PaperQuQueryDTO { // 继承自PaperQuQueryDTO类,扩展了额外属性
- @ApiModelProperty(value = "主观答案", required=true)
- private String answer;
+ @ApiModelProperty(value = "回答列表", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private List answers; // 存储多个选择题答案的列表
+ @ApiModelProperty(value = "主观答案", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String answer; // 存储主观题的答案内容
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperCreateReqDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperCreateReqDTO.java
index 6a8f8c5..22d11e9 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperCreateReqDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperCreateReqDTO.java
@@ -1,22 +1,26 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
+// 引入父类BaseDTO,用于继承基础字段和功能
import com.yf.exam.core.api.dto.BaseDTO;
+// 引入Jackson注解,用于处理JSON序列化时忽略某些字段
import com.fasterxml.jackson.annotation.JsonIgnore;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
/**
* @author bool
+ * 试卷创建请求类,用于接收试卷创建的请求数据,包含考试ID和用户ID等字段。
*/
-@Data
-@ApiModel(value="试卷创建请求类", description="试卷创建请求类")
-public class PaperCreateReqDTO extends BaseDTO {
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷创建请求类", description="试卷创建请求类") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperCreateReqDTO extends BaseDTO { // 继承自BaseDTO类,扩展了考试ID和用户ID字段
- @JsonIgnore
- private String userId;
-
- @ApiModelProperty(value = "考试ID", required=true)
- private String examId;
+ @JsonIgnore // Jackson注解,表示在进行JSON序列化/反序列化时忽略该字段
+ private String userId; // 存储用户ID,通常用于标识发起请求的用户,但在JSON序列化中不会被传递
+ @ApiModelProperty(value = "考试ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String examId; // 存储考试ID,用于创建试卷时指定关联的考试
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperListReqDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperListReqDTO.java
index c333241..a166dc8 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperListReqDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperListReqDTO.java
@@ -1,39 +1,40 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入Serializable接口,用于对象序列化
import java.io.Serializable;
/**
*
* 试卷请求类
*
-*
+* 该类用于接收请求数据,包含用户ID、部门ID、规则ID、用户昵称和试卷状态等信息,
+* 用于查询试卷列表。
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
-@Data
-@ApiModel(value="试卷", description="试卷")
-public class PaperListReqDTO implements Serializable {
-
- private static final long serialVersionUID = 1L;
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷", description="试卷") // Swagger注解,描述该类在API文档中的作用和说明
+public class PaperListReqDTO implements Serializable { // 实现Serializable接口,支持对象的序列化
- @ApiModelProperty(value = "用户ID", required=true)
- private String userId;
+ private static final long serialVersionUID = 1L; // 序列化版本号,用于序列化和反序列化时的版本控制
- @ApiModelProperty(value = "部门ID", required=true)
- private String departId;
+ @ApiModelProperty(value = "用户ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String userId; // 存储请求发起者的用户ID,通常用于标识用户
- @ApiModelProperty(value = "规则ID", required=true)
- private String examId;
+ @ApiModelProperty(value = "部门ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String departId; // 存储请求者所在部门的ID,用于查询特定部门的试卷
- @ApiModelProperty(value = "用户昵称", required=true)
- private String realName;
+ @ApiModelProperty(value = "规则ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String examId; // 存储与试卷相关的考试规则ID,用于标识试卷属于哪种考试
- @ApiModelProperty(value = "试卷状态", required=true)
- private Integer state;
+ @ApiModelProperty(value = "用户昵称", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String realName; // 存储用户的真实姓名,用于标识请求者
-
+ @ApiModelProperty(value = "试卷状态", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private Integer state; // 存储试卷的状态,可能的值如:未开始、进行中、已完成等
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperQuQueryDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperQuQueryDTO.java
index 48184b6..b91286c 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperQuQueryDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperQuQueryDTO.java
@@ -1,21 +1,25 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
+// 引入父类BaseDTO,用于继承基础字段和功能
import com.yf.exam.core.api.dto.BaseDTO;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
/**
* @author bool
+ * 查找试卷题目详情请求类,用于接收试卷和题目详情查询的请求数据。
+ * 包含试卷ID和题目ID字段。
*/
-@Data
-@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
-public class PaperQuQueryDTO extends BaseDTO {
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperQuQueryDTO extends BaseDTO { // 继承自BaseDTO类,扩展了试卷ID和题目ID字段
- @ApiModelProperty(value = "试卷ID", required=true)
- private String paperId;
-
- @ApiModelProperty(value = "题目ID", required=true)
- private String quId;
+ @ApiModelProperty(value = "试卷ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String paperId; // 存储试卷ID,用于查询特定试卷的题目详情
+ @ApiModelProperty(value = "题目ID", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String quId; // 存储题目ID,用于查询指定试卷中的某一道题目
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamDetailRespDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamDetailRespDTO.java
index c307c84..12aecf2 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamDetailRespDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamDetailRespDTO.java
@@ -1,38 +1,48 @@
-package com.yf.exam.modules.paper.dto.response;
+package com.yf.exam.modules.paper.dto.response; // 定义当前类所在的包路径
+// 引入父类PaperDTO,用于继承基础字段和功能
import com.yf.exam.modules.paper.dto.PaperDTO;
+// 引入PaperQuDTO类,用于表示试题的DTO
import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入Calendar类,用于时间计算
import java.util.Calendar;
+// 引入List集合,用于存储试题列表
import java.util.List;
-@Data
-@ApiModel(value="考试详情", description="考试详情")
-public class ExamDetailRespDTO extends PaperDTO {
-
+/**
+ *
+ * 考试详情响应类
+ *
+ * 该类继承自PaperDTO,扩展了多个属性,包含单选题、多选题、判断题的列表,
+ * 以及计算剩余时间的方法,用于提供考试的详细信息。
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="考试详情", description="考试详情") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class ExamDetailRespDTO extends PaperDTO { // 继承自PaperDTO,表示考试详情响应DTO
- @ApiModelProperty(value = "单选题列表", required=true)
- private List radioList;
+ @ApiModelProperty(value = "单选题列表", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private List radioList; // 存储单选题的列表,使用PaperQuDTO表示单个试题
- @ApiModelProperty(value = "多选题列表", required=true)
- private List multiList;
+ @ApiModelProperty(value = "多选题列表", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private List multiList; // 存储多选题的列表,使用PaperQuDTO表示单个试题
- @ApiModelProperty(value = "判断题", required=true)
- private List judgeList;
+ @ApiModelProperty(value = "判断题", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private List judgeList; // 存储判断题的列表,使用PaperQuDTO表示单个试题
-
- @ApiModelProperty(value = "剩余结束秒数", required=true)
- public Long getLeftSeconds(){
+ @ApiModelProperty(value = "剩余结束秒数", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ public Long getLeftSeconds(){ // 计算剩余时间的方法,返回剩余的秒数
// 结束时间
- Calendar cl = Calendar.getInstance();
- cl.setTime(this.getCreateTime());
- cl.add(Calendar.MINUTE, getTotalTime());
+ Calendar cl = Calendar.getInstance(); // 获取当前时间的Calendar实例
+ cl.setTime(this.getCreateTime()); // 设置Calendar的时间为试卷的创建时间
+ cl.add(Calendar.MINUTE, getTotalTime()); // 在创建时间的基础上加上试卷的总时间(分钟)
- return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000;
+ // 计算剩余时间(单位:秒)
+ return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000; // 返回剩余时间(当前时间到结束时间的差值,以秒为单位)
}
-
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamResultRespDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamResultRespDTO.java
index 64af63d..26c9710 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamResultRespDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamResultRespDTO.java
@@ -1,18 +1,29 @@
-package com.yf.exam.modules.paper.dto.response;
+package com.yf.exam.modules.paper.dto.response; // 定义当前类所在的包路径
+// 引入父类PaperDTO,用于继承基础字段和功能
import com.yf.exam.modules.paper.dto.PaperDTO;
+// 引入PaperQuDetailDTO类,用于表示试题详细信息
import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入List集合,用于存储试题列表
import java.util.List;
-@Data
-@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类")
-public class ExamResultRespDTO extends PaperDTO {
+/**
+ *
+ * 考试结果展示响应类
+ *
+ * 该类继承自PaperDTO,扩展了问题列表字段,用于展示考试结果的详细信息。
+ * 包含试题的详细信息列表,返回考试时各个问题的答案或状态。
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class ExamResultRespDTO extends PaperDTO { // 继承自PaperDTO,表示考试结果展示响应DTO
- @ApiModelProperty(value = "问题列表", required=true)
- private List quList;
+ @ApiModelProperty(value = "问题列表", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private List quList; // 存储试题详细信息的列表,使用PaperQuDetailDTO表示每个试题的详细数据
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/PaperListRespDTO.java b/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/PaperListRespDTO.java
index 9e003e4..379de39 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/PaperListRespDTO.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/dto/response/PaperListRespDTO.java
@@ -1,26 +1,29 @@
-package com.yf.exam.modules.paper.dto.response;
+package com.yf.exam.modules.paper.dto.response; // 定义当前类所在的包路径
+// 引入父类PaperDTO,用于继承基本的试卷信息
import com.yf.exam.modules.paper.dto.PaperDTO;
+// 引入Swagger注解,用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
/**
-*
-* 试卷请求类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷列表响应类", description="试卷列表响应类")
-public class PaperListRespDTO extends PaperDTO {
+ *
+ * 试卷列表响应类
+ *
+ * 该类继承自PaperDTO,扩展了人员(realName)字段,用于展示试卷列表响应数据。
+ * 包含试卷的基本信息以及相关人员信息。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷列表响应类", description="试卷列表响应类") // Swagger注解,用于描述该类在API文档中的作用和说明
+public class PaperListRespDTO extends PaperDTO { // 继承自PaperDTO,表示试卷列表响应DTO
- private static final long serialVersionUID = 1L;
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
- @ApiModelProperty(value = "人员", required=true)
- private String realName;
-
-
+ @ApiModelProperty(value = "人员", required=true) // Swagger注解,描述该字段在API文档中的含义,并标注该字段为必填项
+ private String realName; // 存储人员姓名,用于表示与该试卷相关的人员信息
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/entity/Paper.java b/src-源文件/main/java/com/yf/exam/modules/paper/entity/Paper.java
index e219471..f6baaac 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/entity/Paper.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/entity/Paper.java
@@ -1,125 +1,104 @@
-package com.yf.exam.modules.paper.entity;
+package com.yf.exam.modules.paper.entity; // 定义当前类所在的包路径
+// 引入MyBatis Plus的相关注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
-
+// 引入Date类,用于时间相关的字段
import java.util.Date;
/**
-*
-* 试卷实体类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@TableName("el_paper")
-public class Paper extends Model {
-
- private static final long serialVersionUID = 1L;
+ *
+ * 试卷实体类
+ *
+ * 该类对应数据库中的 `el_paper` 表,用于表示试卷的相关信息。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@TableName("el_paper") // MyBatis Plus注解,指定该实体类对应的数据库表名
+public class Paper extends Model { // 继承MyBatis Plus的Model类,提供了CRUD等基础操作
+
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
/**
* 试卷ID
*/
- @TableId(value = "id", type = IdType.ASSIGN_ID)
- private String id;
+ @TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解,指定主键字段及其生成策略
+ private String id; // 试卷ID,唯一标识符
/**
* 用户ID
*/
- @TableField("user_id")
- private String userId;
+ @TableField("user_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String userId; // 用户ID,表示创建该试卷的用户
/**
* 部门ID
*/
- @TableField("depart_id")
- private String departId;
+ @TableField("depart_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String departId; // 部门ID,表示该试卷所属的部门
/**
* 规则ID
*/
- @TableField("exam_id")
- private String examId;
+ @TableField("exam_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String examId; // 规则ID,表示该试卷所属的考试规则
/**
* 考试标题
*/
- private String title;
+ private String title; // 考试标题,表示试卷的名称或标题
/**
* 考试时长
*/
- @TableField("total_time")
- private Integer totalTime;
+ @TableField("total_time") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer totalTime; // 考试时长,单位为分钟
/**
* 用户时长
*/
- @TableField("user_time")
- private Integer userTime;
+ @TableField("user_time") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer userTime; // 用户实际用时,单位为分钟
/**
* 试卷总分
*/
- @TableField("total_score")
- private Integer totalScore;
+ @TableField("total_score") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer totalScore; // 试卷的总分数
/**
* 及格分
*/
- @TableField("qualify_score")
- private Integer qualifyScore;
+ @TableField("qualify_score") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer qualifyScore; // 及格分数,表示通过该试卷的最低分数
/**
* 客观分
*/
- @TableField("obj_score")
- private Integer objScore;
+ @TableField("obj_score") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer objScore; // 客观题部分的得分
/**
* 主观分
*/
- @TableField("subj_score")
- private Integer subjScore;
+ @TableField("subj_score") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer subjScore; // 主观题部分的得分
/**
* 用户得分
*/
- @TableField("user_score")
- private Integer userScore;
+ @TableField("user_score") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer userScore; // 用户在该试卷上的得分
/**
* 是否包含简答题
*/
- @TableField("has_saq")
- private Boolean hasSaq;
-
- /**
- * 试卷状态
- */
- private Integer state;
-
- /**
- * 创建时间
- */
- @TableField("create_time")
- private Date createTime;
-
- /**
- * 更新时间
- */
- @TableField("update_time")
- private Date updateTime;
-
- /**
- * 截止时间
- */
- @TableField("limit_time")
- private Date limitTime;
-}
+ @TableField("has_saq") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQu.java b/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQu.java
index 3723791..f6be46d 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQu.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQu.java
@@ -1,80 +1,82 @@
-package com.yf.exam.modules.paper.entity;
+package com.yf.exam.modules.paper.entity; // 定义当前类所在的包路径
+// 引入MyBatis Plus的相关注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
/**
-*
-* 试卷考题实体类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@TableName("el_paper_qu")
-public class PaperQu extends Model {
+ *
+ * 试卷考题实体类
+ *
+ * 该类对应数据库中的 `el_paper_qu` 表,用于表示与试卷相关的考题信息。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@TableName("el_paper_qu") // MyBatis Plus注解,指定该实体类对应的数据库表名
+public class PaperQu extends Model { // 继承MyBatis Plus的Model类,提供了基础的CRUD等操作
- private static final long serialVersionUID = 1L;
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
/**
* ID
*/
- @TableId(value = "id", type = IdType.ASSIGN_ID)
- private String id;
+ @TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解,指定主键字段及其生成策略
+ private String id; // 题目ID,唯一标识符
/**
* 试卷ID
*/
- @TableField("paper_id")
- private String paperId;
+ @TableField("paper_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String paperId; // 试卷ID,表示该题目所属的试卷ID
/**
* 题目ID
*/
- @TableField("qu_id")
- private String quId;
+ @TableField("qu_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String quId; // 题目ID,唯一标识符
/**
* 题目类型
*/
- @TableField("qu_type")
- private Integer quType;
+ @TableField("qu_type") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer quType; // 题目类型,表示该题目属于哪种类型(例如单选题、多选题、主观题等)
/**
* 是否已答
*/
- private Boolean answered;
+ private Boolean answered; // 是否已经回答,布尔值,表示该题目是否已经被回答
/**
* 主观答案
*/
- private String answer;
+ private String answer; // 主观题的答案,保存用户的回答内容
/**
* 问题排序
*/
- private Integer sort;
+ private Integer sort; // 问题在试卷中的排序,决定题目的显示顺序
/**
* 单题分分值
*/
- private Integer score;
+ private Integer score; // 每道题的分值,表示该题目的得分值
/**
* 实际得分(主观题)
*/
- @TableField("actual_score")
- private Integer actualScore;
+ @TableField("actual_score") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Integer actualScore; // 主观题的实际得分,可能与用户给出的答案相关
/**
* 是否答对
*/
- @TableField("is_right")
- private Boolean isRight;
-
+ @TableField("is_right") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Boolean isRight; // 是否答对,布尔值,表示用户是否答对了该题目
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQuAnswer.java b/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQuAnswer.java
index b3999da..78c17ce 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQuAnswer.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQuAnswer.java
@@ -1,68 +1,71 @@
-package com.yf.exam.modules.paper.entity;
+package com.yf.exam.modules.paper.entity; // 定义当前类所在的包路径
+// 引入MyBatis Plus的相关注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
+// 引入Lombok注解,用于自动生成getter、setter等方法
import lombok.Data;
/**
-*
-* 试卷考题备选答案实体类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@TableName("el_paper_qu_answer")
-public class PaperQuAnswer extends Model {
+ *
+ * 试卷考题备选答案实体类
+ *
+ * 该类对应数据库中的 `el_paper_qu_answer` 表,用于表示试卷考题的备选答案。
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data // Lombok注解,自动生成getter、setter、toString、equals和hashCode方法
+@TableName("el_paper_qu_answer") // MyBatis Plus注解,指定该实体类对应的数据库表名
+public class PaperQuAnswer extends Model { // 继承MyBatis Plus的Model类,提供了基础的CRUD等操作
+ private static final long serialVersionUID = 1L; // 序列化版本ID,用于序列化和反序列化操作
/**
* 自增ID
*/
- @TableId(value = "id", type = IdType.ASSIGN_ID)
- private String id;
+ @TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解,指定主键字段及其生成策略
+ private String id; // 唯一标识符ID,数据库中的主键
/**
* 试卷ID
*/
- @TableField("paper_id")
- private String paperId;
+ @TableField("paper_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String paperId; // 该备选答案对应的试卷ID
/**
* 回答项ID
*/
- @TableField("answer_id")
- private String answerId;
+ @TableField("answer_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String answerId; // 该备选答案的唯一标识符ID
/**
* 题目ID
*/
- @TableField("qu_id")
- private String quId;
+ @TableField("qu_id") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private String quId; // 该备选答案所属的题目ID
/**
* 是否正确项
*/
- @TableField("is_right")
- private Boolean isRight;
+ @TableField("is_right") // MyBatis Plus注解,指定字段与数据库表字段的映射关系
+ private Boolean isRight; // 是否是正确答案,布尔值(true 表示正确,false 表示错误)
/**
* 是否选中
*/
- private Boolean checked;
+ private Boolean checked; // 该备选答案是否被选中,布尔值(true 表示已选中,false 表示未选中)
/**
* 排序
*/
- private Integer sort;
+ private Integer sort; // 备选答案的排序,决定该答案在选项中的位置
/**
* 选项标签
*/
- private String abc;
-
+ private String abc; // 备选答案的标签,通常为A、B、C、D等,用于显示选项
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/enums/ExamState.java b/src-源文件/main/java/com/yf/exam/modules/paper/enums/ExamState.java
index a62f404..f681da9 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/enums/ExamState.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/enums/ExamState.java
@@ -1,33 +1,38 @@
-package com.yf.exam.modules.paper.enums;
-
+package com.yf.exam.modules.paper.enums; // 定义当前类所在的包路径
/**
- * 考试状态
- * @author bool
+ *
+ * 考试状态枚举接口
+ *
+ * 该接口定义了考试的不同状态,作为常量使用,帮助系统在处理考试过程中进行状态标识。
+ *
+ * @author bool
* @date 2019-10-30 13:11
*/
public interface ExamState {
-
/**
* 考试中
+ * 代表考试正在进行中,通常表示考试尚未结束,学生可以继续答题。
*/
Integer ENABLE = 0;
/**
* 待阅卷
+ * 代表考试已经结束,但还没有开始批阅试卷,通常表示考试已经提交,等待教师或系统自动阅卷。
*/
Integer DISABLED = 1;
/**
* 已完成
+ * 代表考试已经完成,阅卷完成,结果已公布,但没有开始考试。
*/
Integer READY_START = 2;
/**
* 已结束
+ * 代表考试已经结束,不再接受任何操作,考试时间已超出,无法继续答题。
*/
Integer OVERDUE = 3;
-
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/enums/PaperState.java b/src-源文件/main/java/com/yf/exam/modules/paper/enums/PaperState.java
index ceed269..27e342c 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/enums/PaperState.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/enums/PaperState.java
@@ -1,33 +1,38 @@
-package com.yf.exam.modules.paper.enums;
-
+package com.yf.exam.modules.paper.enums; // 定义当前类所在的包路径
/**
- * 试卷状态
- * @author bool
+ *
+ * 试卷状态枚举接口
+ *
+ * 该接口定义了试卷的不同状态,作为常量使用,帮助系统在处理试卷过程中进行状态标识。
+ *
+ * @author bool
* @date 2019-10-30 13:11
*/
public interface PaperState {
-
/**
* 考试中
+ * 代表试卷正在进行中,学生正在参与考试,答题环节尚未结束。
*/
Integer ING = 0;
/**
* 待阅卷
+ * 代表考试已经结束,试卷已经提交,正在等待阅卷(人工或系统自动阅卷)。
*/
Integer WAIT_OPT = 1;
/**
* 已完成
+ * 代表试卷已完成,包括考试、阅卷等所有环节,成绩已经确定。
*/
Integer FINISHED = 2;
/**
* 弃考
+ * 代表学生中途放弃考试,考试未完成,可能是由于学生主动退出或其他原因(如时间到期)导致考试中止。
*/
Integer BREAK = 3;
-
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/job/BreakExamJob.java b/src-源文件/main/java/com/yf/exam/modules/paper/job/BreakExamJob.java
index fb14f53..23a9762 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/job/BreakExamJob.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/job/BreakExamJob.java
@@ -1,45 +1,61 @@
-package com.yf.exam.modules.paper.job;
-
-import com.yf.exam.ability.job.service.JobService;
-import com.yf.exam.modules.paper.service.PaperService;
-import lombok.extern.log4j.Log4j2;
-import org.quartz.Job;
-import org.quartz.JobDetail;
-import org.quartz.JobExecutionContext;
-import org.quartz.JobExecutionException;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
+package com.yf.exam.modules.paper.job; // 定义类所在的包路径
+
+import com.yf.exam.ability.job.service.JobService; // 导入 JobService 类,用于获取任务数据
+import com.yf.exam.modules.paper.service.PaperService; // 导入 PaperService 类,用于处理试卷相关的业务逻辑
+import lombok.extern.log4j.Log4j2; // 引入 log4j2 日志工具
+import org.quartz.Job; // 导入 Quartz 作业接口
+import org.quartz.JobDetail; // 导入 Quartz JobDetail 类
+import org.quartz.JobExecutionContext; // 导入 Quartz JobExecutionContext 类
+import org.quartz.JobExecutionException; // 导入 Quartz JobExecutionException 类
+import org.springframework.beans.factory.annotation.Autowired; // 引入 Spring 注解,用于自动注入依赖
+import org.springframework.stereotype.Component; // 引入 Spring 组件注解,标识为 Spring Bean
/**
* 超时自动交卷任务
+ *
+ * 该类是一个 Quartz 定时任务,用于在考试时间到期后强制交卷。
+ * 它在定时任务触发时调用 PaperService 进行强制交卷操作。
+ *
+ *
* @author bool
*/
-@Log4j2
-@Component
+@Log4j2 // 启用 log4j2 日志记录
+@Component // 标识该类为一个 Spring 组件,Spring 会自动将其注册为 Bean
public class BreakExamJob implements Job {
+ // 自动注入 PaperService,用于处理与试卷相关的业务逻辑
@Autowired
private PaperService paperService;
+ /**
+ * 定时任务执行的方法
+ *
+ *
+ * Quartz 会在定时任务触发时调用此方法。该方法获取任务的详细信息,
+ * 并通过 PaperService 强制提交超时的考试。
+ *
+ *
+ * @param jobExecutionContext 包含了 Quartz 定时任务的上下文信息
+ * @throws JobExecutionException 如果任务执行过程中出现异常,将抛出该异常
+ */
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
- JobDetail detail = jobExecutionContext.getJobDetail();
- String name = detail.getKey().getName();
- String group = detail.getKey().getGroup();
+ // 从 jobExecutionContext 中获取任务的详细信息
+ JobDetail detail = jobExecutionContext.getJobDetail(); // 获取任务详情
+ String name = detail.getKey().getName(); // 获取任务名称
+ String group = detail.getKey().getGroup(); // 获取任务分组
+ // 获取任务的附加数据,通常是任务触发时的相关参数
String data = String.valueOf(detail.getJobDataMap().get(JobService.TASK_DATA));
+ // 打印任务执行日志,便于调试和跟踪
log.info("++++++++++定时任务:处理到期的交卷");
log.info("++++++++++jobName:{}", name);
log.info("++++++++++jobGroup:{}", group);
log.info("++++++++++taskData:{}", data);
-
- // 强制交卷
+ // 调用 PaperService 进行强制交卷操作
+ // data 参数通常是考试 ID 或者某种标识符,用于识别需要交卷的考试
paperService.handExam(data);
-
}
-
-
-
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperMapper.java b/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperMapper.java
index 1a52de5..833c518 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperMapper.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperMapper.java
@@ -1,39 +1,46 @@
-package com.yf.exam.modules.paper.mapper;
+package com.yf.exam.modules.paper.mapper; // 定义类所在的包路径
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.yf.exam.modules.paper.dto.PaperDTO;
-import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
-import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
-import com.yf.exam.modules.paper.entity.Paper;
-import org.apache.ibatis.annotations.Param;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 的 BaseMapper
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入分页结果接口 IPage
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 引入分页插件 Page
+import com.yf.exam.modules.paper.dto.PaperDTO; // 引入 DTO 类,表示试卷数据传输对象
+import com.yf.exam.modules.paper.dto.request.PaperListReqDTO; // 引入请求 DTO 类,表示查询试卷时的请求参数
+import com.yf.exam.modules.paper.dto.response.PaperListRespDTO; // 引入响应 DTO 类,表示查询试卷时的响应结果
+import com.yf.exam.modules.paper.entity.Paper; // 引入实体类,表示试卷数据表中的记录
+import org.apache.ibatis.annotations.Param; // 引入 MyBatis 注解,用于指定 SQL 查询中的参数
import java.util.List;
/**
-*
-* 试卷Mapper
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 16:33
-*/
-public interface PaperMapper extends BaseMapper {
+ *
+ * 试卷Mapper接口,用于操作试卷数据表
+ *
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 16:33
+ */
+public interface PaperMapper extends BaseMapper { // 继承 MyBatis-Plus 提供的 BaseMapper,自动实现 CRUD 操作
/**
* 查找试卷分页
- * @param page
- * @param query
- * @return
+ *
+ * 根据分页参数 `Page` 和查询条件 `PaperListReqDTO` 返回试卷的分页结果。
+ *
+ *
+ * @param page 分页参数,包含当前页、每页大小等
+ * @param query 查询条件,通常包含用户 ID、考试 ID 等信息
+ * @return 返回一个分页结果 `IPage`,包含了试卷数据和分页信息
*/
IPage paging(Page page, @Param("query") PaperListReqDTO query);
-
/**
* 试卷列表响应类
- * @param query
- * @return
+ *
+ * 根据查询条件返回试卷的列表数据,通常用于返回所有试卷的列表。
+ *
+ *
+ * @param query 查询条件,通常是试卷的基本信息,如试卷 ID、考试 ID 等
+ * @return 返回一个试卷列表 `List`,每一项是试卷的响应 DTO
*/
List list(@Param("query") PaperDTO query);
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuAnswerMapper.java b/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuAnswerMapper.java
index e795ba9..8ab65ee 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuAnswerMapper.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuAnswerMapper.java
@@ -1,27 +1,33 @@
-package com.yf.exam.modules.paper.mapper;
+package com.yf.exam.modules.paper.mapper; // 指定该类所在的包路径
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
-import com.yf.exam.modules.paper.entity.PaperQuAnswer;
-import org.apache.ibatis.annotations.Param;
+// 导入BaseMapper接口,提供通用的CRUD操作
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入PaperQuAnswerExtDTO类,表示试卷考题备选答案的扩展数据传输对象
+import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
+// 导入PaperQuAnswer实体类,表示试卷考题备选答案的数据模型
+import com.yf.exam.modules.paper.entity.PaperQuAnswer;
+// 导入MyBatis的注解,指定方法参数在SQL中的名称
+import org.apache.ibatis.annotations.Param;
-import java.util.List;
+// 导入List接口,表示返回类型为List集合,用于存储多个备选答案
+import java.util.List;
/**
*
-* 试卷考题备选答案Mapper
+* 试卷考题备选答案Mapper接口
*
-*
+* 该接口用于处理试卷考题备选答案的数据库操作,继承自MyBatis-Plus的BaseMapper,提供通用的CRUD方法。
+*
* @author 聪明笨狗
* @since 2020-05-25 16:33
*/
-public interface PaperQuAnswerMapper extends BaseMapper {
+public interface PaperQuAnswerMapper extends BaseMapper { // 继承自BaseMapper接口,提供了所有的基本CRUD操作
/**
* 查找试卷试题答案列表
- * @param paperId
- * @param quId
- * @return
+ * @param paperId 试卷ID,标识要查询的试卷
+ * @param quId 题目ID,标识要查询的题目
+ * @return 返回与试卷ID和题目ID相关的备选答案列表,包含更多的答案细节
*/
- List list(@Param("paperId") String paperId, @Param("quId") String quId);
+ List list(@Param("paperId") String paperId, @Param("quId") String quId); // 根据试卷ID和题目ID查询对应的备选答案列表
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuMapper.java b/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuMapper.java
index f833a1b..a9b2257 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuMapper.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuMapper.java
@@ -1,42 +1,46 @@
-package com.yf.exam.modules.paper.mapper;
+package com.yf.exam.modules.paper.mapper; // 定义该类所在的包路径
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
-import com.yf.exam.modules.paper.entity.PaperQu;
-import org.apache.ibatis.annotations.Param;
+// 导入BaseMapper接口,提供MyBatis-Plus的通用CRUD操作
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入PaperQuDetailDTO类,表示试卷考题详细数据传输对象
+import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
+// 导入PaperQu实体类,表示试卷考题的数据模型
+import com.yf.exam.modules.paper.entity.PaperQu;
+// 导入MyBatis的@Param注解,用于方法参数与SQL查询中的参数进行映射
+import org.apache.ibatis.annotations.Param;
-import java.util.List;
+// 导入List接口,用于返回多个试题
+import java.util.List;
/**
*
-* 试卷考题Mapper
+* 试卷考题Mapper接口
*
-*
+* 该接口用于处理与试卷考题相关的数据库操作,继承自MyBatis-Plus的BaseMapper,提供通用的CRUD操作。
+*
* @author 聪明笨狗
* @since 2020-05-25 16:33
*/
-public interface PaperQuMapper extends BaseMapper {
+public interface PaperQuMapper extends BaseMapper { // 继承自BaseMapper接口,提供通用的CRUD操作
/**
* 统计客观分
- * @param paperId
- * @return
+ * @param paperId 试卷ID,用于查询指定试卷的客观分数
+ * @return 返回试卷的客观分数总和
*/
- int sumObjective(@Param("paperId") String paperId);
+ int sumObjective(@Param("paperId") String paperId); // 根据试卷ID统计所有客观题的分数总和
/**
* 统计主观分
- * @param paperId
- * @return
+ * @param paperId 试卷ID,用于查询指定试卷的主观分数
+ * @return 返回试卷的主观分数总和
*/
- int sumSubjective(@Param("paperId") String paperId);
+ int sumSubjective(@Param("paperId") String paperId); // 根据试卷ID统计所有主观题的分数总和
/**
* 找出全部试题列表
- * @param paperId
- * @return
+ * @param paperId 试卷ID,用于查询指定试卷的所有试题
+ * @return 返回试卷中的所有试题列表,类型为PaperQuDetailDTO
*/
- List listByPaper(@Param("paperId") String paperId);
+ List listByPaper(@Param("paperId") String paperId); // 根据试卷ID查询所有试题的详细信息
}
-
-
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuAnswerService.java b/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuAnswerService.java
index a1cfffa..3d2f1d5 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuAnswerService.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuAnswerService.java
@@ -1,18 +1,20 @@
+// 导入所需的包
package com.yf.exam.modules.paper.service;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
-import com.yf.exam.modules.paper.entity.PaperQuAnswer;
+import com.baomidou.mybatisplus.core.metadata.IPage; // 用于分页查询
+import com.baomidou.mybatisplus.extension.service.IService; // 用于继承通用服务接口
+import com.yf.exam.core.api.dto.PagingReqDTO; // 分页请求DTO
+import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO; // 试卷问题答案DTO
+import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO; // 扩展的试卷问题答案DTO
+import com.yf.exam.modules.paper.entity.PaperQuAnswer; // 试卷问题答案实体类
-import java.util.List;
+import java.util.List; // 导入List类,用于处理集合数据
/**
*
* 试卷考题备选答案业务类
*
+* 该接口定义了与试卷考题备选答案相关的业务操作
*
* @author 聪明笨狗
* @since 2020-05-25 16:33
@@ -21,24 +23,24 @@ public interface PaperQuAnswerService extends IService {
/**
* 分页查询数据
- * @param reqDTO
- * @return
+ * @param reqDTO 分页请求DTO,包含查询的分页信息和条件
+ * @return 返回分页查询结果,包含 PaperQuAnswerDTO 对象的数据
*/
IPage paging(PagingReqDTO reqDTO);
/**
- * 查找试卷试题答案列表
- * @param paperId
- * @param quId
- * @return
+ * 查找试卷试题的答案列表
+ * @param paperId 试卷ID,用于定位试卷
+ * @param quId 试题ID,用于定位具体的试题
+ * @return 返回该试卷和试题的所有答案列表,数据类型为 PaperQuAnswerExtDTO
*/
List listForExam(String paperId, String quId);
/**
- * 查找答案列表,用来填充
- * @param paperId
- * @param quId
- * @return
+ * 查找答案列表,用来填充试卷答案
+ * @param paperId 试卷ID,用于定位试卷
+ * @param quId 试题ID,用于定位具体试题的答案
+ * @return 返回对应试题的答案列表,数据类型为 PaperQuAnswer 实体
*/
List listForFill(String paperId, String quId);
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuService.java b/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuService.java
index d0cc2e3..23d0af8 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuService.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuService.java
@@ -1,18 +1,20 @@
+// 导入所需的包
package com.yf.exam.modules.paper.service;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperQuDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
-import com.yf.exam.modules.paper.entity.PaperQu;
+import com.baomidou.mybatisplus.core.metadata.IPage; // 用于分页查询
+import com.baomidou.mybatisplus.extension.service.IService; // 用于继承通用服务接口
+import com.yf.exam.core.api.dto.PagingReqDTO; // 分页请求DTO
+import com.yf.exam.modules.paper.dto.PaperQuDTO; // 试卷问题DTO
+import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO; // 试卷问题详情DTO
+import com.yf.exam.modules.paper.entity.PaperQu; // 试卷问题实体类
-import java.util.List;
+import java.util.List; // 导入List类,用于处理集合数据
/**
*
* 试卷考题业务类
*
+* 该接口定义了与试卷考题相关的业务操作
*
* @author 聪明笨狗
* @since 2020-05-25 16:33
@@ -21,50 +23,50 @@ public interface PaperQuService extends IService {
/**
* 分页查询数据
- * @param reqDTO
- * @return
+ * @param reqDTO 分页请求DTO,包含查询的分页信息和条件
+ * @return 返回分页查询结果,包含 PaperQuDTO 对象的数据
*/
IPage paging(PagingReqDTO reqDTO);
/**
* 根据试卷找出题目列表
- * @param paperId
- * @return
+ * @param paperId 试卷ID,用于定位试卷
+ * @return 返回该试卷的所有题目列表,数据类型为 PaperQuDTO
*/
List listByPaper(String paperId);
/**
- * 查找详情
- * @param paperId
- * @param quId
- * @return
+ * 查找试卷中某个问题的详细信息
+ * @param paperId 试卷ID
+ * @param quId 试题ID,用于定位具体的试题
+ * @return 返回该试卷和试题的详细信息,数据类型为 PaperQu
*/
PaperQu findByKey(String paperId, String quId);
/**
- * 根据组合索引更新
- * @param qu
+ * 根据组合索引更新试题
+ * @param qu 试题实体,用于更新试卷中的试题
*/
void updateByKey(PaperQu qu);
/**
- * 统计客观分
- * @param paperId
- * @return
+ * 统计试卷中所有客观题的总分
+ * @param paperId 试卷ID
+ * @return 返回该试卷客观题的总分
*/
int sumObjective(String paperId);
/**
- * 统计主观分
- * @param paperId
- * @return
+ * 统计试卷中所有主观题的总分
+ * @param paperId 试卷ID
+ * @return 返回该试卷主观题的总分
*/
int sumSubjective(String paperId);
/**
- * 找出全部试题列表
- * @param paperId
- * @return
+ * 查找试卷的全部试题列表(用于展示结果)
+ * @param paperId 试卷ID
+ * @return 返回该试卷的详细试题列表,数据类型为 PaperQuDetailDTO
*/
List listForPaperResult(String paperId);
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperService.java b/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperService.java
index 042bb7d..ec5f724 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperService.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/service/PaperService.java
@@ -1,21 +1,23 @@
+// 导入所需的包
package com.yf.exam.modules.paper.service;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
-import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
-import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
-import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
-import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
-import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
-import com.yf.exam.modules.paper.entity.Paper;
+import com.baomidou.mybatisplus.core.metadata.IPage; // 用于分页查询
+import com.baomidou.mybatisplus.extension.service.IService; // 用于继承通用服务接口
+import com.yf.exam.core.api.dto.PagingReqDTO; // 分页请求DTO
+import com.yf.exam.modules.paper.dto.PaperDTO; // 试卷DTO
+import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO; // 试卷题目详情DTO
+import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO; // 提交答案请求DTO
+import com.yf.exam.modules.paper.dto.request.PaperListReqDTO; // 试卷列表请求DTO
+import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO; // 考试详情响应DTO
+import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO; // 考试结果响应DTO
+import com.yf.exam.modules.paper.dto.response.PaperListRespDTO; // 试卷列表响应DTO
+import com.yf.exam.modules.paper.entity.Paper; // 试卷实体类
/**
*
* 试卷业务类
*
+* 该接口定义了与试卷相关的所有业务操作
*
* @author 聪明笨狗
* @since 2020-05-25 16:33
@@ -24,60 +26,57 @@ public interface PaperService extends IService {
/**
* 创建试卷
- * @param userId
- * @param examId
- * @return
+ * @param userId 用户ID,表示试卷创建者
+ * @param examId 考试ID,表示该试卷属于哪个考试
+ * @return 返回创建的试卷ID
*/
String createPaper(String userId, String examId);
-
/**
- * 查找详情
- * @param paperId
- * @return
+ * 查找试卷详情
+ * @param paperId 试卷ID,表示要查找的试卷
+ * @return 返回试卷的详细信息,数据类型为 ExamDetailRespDTO
*/
ExamDetailRespDTO paperDetail(String paperId);
/**
- * 考试结果
- * @param paperId
- * @return
+ * 获取考试结果
+ * @param paperId 试卷ID,表示要查询结果的试卷
+ * @return 返回该试卷的考试结果,数据类型为 ExamResultRespDTO
*/
ExamResultRespDTO paperResult(String paperId);
/**
- * 查找题目详情
- * @param paperId
- * @param quId
- * @return
+ * 查找试卷题目详情
+ * @param paperId 试卷ID
+ * @param quId 题目ID,表示要查询的具体题目
+ * @return 返回该试卷和题目的详细信息,数据类型为 PaperQuDetailDTO
*/
PaperQuDetailDTO findQuDetail(String paperId, String quId);
/**
- * 填充答案
- * @param reqDTO
+ * 填充试卷答案
+ * @param reqDTO 填写答案的请求DTO,包含试卷答案信息
*/
void fillAnswer(PaperAnswerDTO reqDTO);
/**
- * 交卷操作
- * @param paperId
- * @return
+ * 提交试卷(交卷)
+ * @param paperId 试卷ID,表示要交卷的试卷
*/
void handExam(String paperId);
/**
- * 试卷列表响应类
- * @param reqDTO
- * @return
+ * 分页查询试卷列表
+ * @param reqDTO 分页请求DTO,包含分页信息和查询条件
+ * @return 返回分页后的试卷列表,数据类型为 IPage
*/
IPage paging(PagingReqDTO reqDTO);
/**
- * 检测是否有进行中的考试
- * @param userId
- * @return
+ * 检查用户是否有正在进行的考试
+ * @param userId 用户ID,用于查找该用户是否有未完成的考试
+ * @return 返回该用户正在进行的考试试卷信息,数据类型为 PaperDTO
*/
PaperDTO checkProcess(String userId);
-
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuAnswerServiceImpl.java b/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuAnswerServiceImpl.java
index c2dc0b7..14e8306 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuAnswerServiceImpl.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuAnswerServiceImpl.java
@@ -1,61 +1,95 @@
-package com.yf.exam.modules.paper.service.impl;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.TypeReference;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
-import com.yf.exam.modules.paper.entity.PaperQuAnswer;
-import com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper;
-import com.yf.exam.modules.paper.service.PaperQuAnswerService;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
+package com.yf.exam.modules.paper.service.impl; // 指定该类所在的包路径
+
+// 导入FastJSON库,用于处理JSON格式数据的转换
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.TypeReference;
+// 导入MyBatis-Plus的条件查询构造器
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入分页接口
+import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入分页Page类
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入MyBatis-Plus的服务实现类
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入分页请求DTO,用于分页查询
+import com.yf.exam.core.api.dto.PagingReqDTO;
+// 导入试卷考题备选答案DTO类
+import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
+// 导入试卷考题备选答案扩展DTO类
+import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
+// 导入试卷考题备选答案实体类
+import com.yf.exam.modules.paper.entity.PaperQuAnswer;
+// 导入试卷考题备选答案Mapper接口
+import com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper;
+// 导入试卷考题备选答案服务接口
+import com.yf.exam.modules.paper.service.PaperQuAnswerService;
+// 导入Spring的Service注解,表示这是一个服务实现类
+import org.springframework.stereotype.Service;
+
+import java.util.List; // 导入List接口,用于返回多个结果
/**
*
-* 语言设置 服务实现类
+* 试卷考题备选答案 服务实现类
*
-*
+* 该类实现了PaperQuAnswerService接口,处理与试卷考题备选答案相关的业务逻辑。
+*
* @author 聪明笨狗
* @since 2020-05-25 16:33
*/
-@Service
-public class PaperQuAnswerServiceImpl extends ServiceImpl implements PaperQuAnswerService {
+@Service // 标注为Spring的服务类
+public class PaperQuAnswerServiceImpl extends ServiceImpl implements PaperQuAnswerService { // 继承ServiceImpl类,提供基本的数据库操作功能
+ /**
+ * 分页查询试卷考题备选答案
+ * @param reqDTO 分页请求参数,包括当前页和页面大小
+ * @return 分页后的试卷考题备选答案列表
+ */
@Override
public IPage paging(PagingReqDTO reqDTO) {
- //创建分页对象
+ // 创建分页对象
IPage query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
- //查询条件
+ // 查询条件,可以根据需要添加更多过滤条件
QueryWrapper wrapper = new QueryWrapper<>();
- //获得数据
+ // 执行分页查询操作
IPage page = this.page(query, wrapper);
- //转换结果
+
+ // 将查询结果转换为DTO对象,返回分页后的结果
IPage pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference>(){});
- return pageData;
- }
+
+ return pageData; // 返回分页结果
+ }
+ /**
+ * 根据试卷ID和题目ID查询试题的备选答案列表
+ * @param paperId 试卷ID
+ * @param quId 题目ID
+ * @return 试卷考题备选答案的扩展DTO列表
+ */
@Override
public List listForExam(String paperId, String quId) {
+ // 调用Mapper中的list方法,查询并返回试题的备选答案列表
return baseMapper.list(paperId, quId);
}
+ /**
+ * 查询填空题的备选答案
+ * @param paperId 试卷ID
+ * @param quId 题目ID
+ * @return 填空题的备选答案列表
+ */
@Override
public List listForFill(String paperId, String quId) {
- //查询条件
+ // 创建查询条件
QueryWrapper wrapper = new QueryWrapper<>();
- wrapper.lambda()
- .eq(PaperQuAnswer::getPaperId, paperId)
- .eq(PaperQuAnswer::getQuId, quId);
+ wrapper.lambda() // 使用Lambda表达式,进行条件构造
+ .eq(PaperQuAnswer::getPaperId, paperId) // 通过试卷ID过滤
+ .eq(PaperQuAnswer::getQuId, quId); // 通过题目ID过滤
+ // 查询并返回符合条件的结果列表
return this.list(wrapper);
}
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuServiceImpl.java b/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuServiceImpl.java
index a0d9a1d..46c9635 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuServiceImpl.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuServiceImpl.java
@@ -1,94 +1,150 @@
-package com.yf.exam.modules.paper.service.impl;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.TypeReference;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.core.utils.BeanMapper;
-import com.yf.exam.modules.paper.dto.PaperQuDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
-import com.yf.exam.modules.paper.entity.PaperQu;
-import com.yf.exam.modules.paper.mapper.PaperQuMapper;
-import com.yf.exam.modules.paper.service.PaperQuService;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
+package com.yf.exam.modules.paper.service.impl; // 指定该类所在的包路径
+
+// 导入FastJSON库,用于处理JSON格式数据的转换
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.TypeReference;
+// 导入MyBatis-Plus的条件查询构造器
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入分页接口
+import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入分页Page类
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入MyBatis-Plus的服务实现类
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入分页请求DTO,用于分页查询
+import com.yf.exam.core.api.dto.PagingReqDTO;
+// 导入BeanMapper工具类,用于对象间的转换
+import com.yf.exam.core.utils.BeanMapper;
+// 导入试卷考题DTO类
+import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 导入试卷考题详情DTO类
+import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
+// 导入试卷考题实体类
+import com.yf.exam.modules.paper.entity.PaperQu;
+// 导入试卷考题Mapper接口
+import com.yf.exam.modules.paper.mapper.PaperQuMapper;
+// 导入试卷考题服务接口
+import com.yf.exam.modules.paper.service.PaperQuService;
+// 导入Spring的Service注解,表示这是一个服务实现类
+import org.springframework.stereotype.Service;
+
+import java.util.List; // 导入List接口,用于返回多个结果
/**
*
-* 语言设置 服务实现类
+* 试卷考题 服务实现类
*
-*
+* 该类实现了PaperQuService接口,处理与试卷考题相关的业务逻辑。
+*
* @author 聪明笨狗
* @since 2020-05-25 16:33
*/
-@Service
-public class PaperQuServiceImpl extends ServiceImpl implements PaperQuService {
-
+@Service // 标注为Spring的服务类
+public class PaperQuServiceImpl extends ServiceImpl implements PaperQuService { // 继承ServiceImpl类,提供基本的数据库操作功能
+
+ /**
+ * 分页查询试卷考题
+ * @param reqDTO 分页请求参数,包括当前页和页面大小
+ * @return 分页后的试卷考题列表
+ */
@Override
public IPage paging(PagingReqDTO reqDTO) {
- //创建分页对象
+ // 创建分页对象
IPage query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
- //查询条件
+ // 查询条件
QueryWrapper wrapper = new QueryWrapper<>();
- //获得数据
+ // 执行分页查询操作
IPage page = this.page(query, wrapper);
- //转换结果
+
+ // 将查询结果转换为DTO对象,返回分页后的结果
IPage pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference>(){});
- return pageData;
- }
+
+ return pageData; // 返回分页结果
+ }
+ /**
+ * 根据试卷ID查询试卷考题列表
+ * @param paperId 试卷ID
+ * @return 试卷考题DTO列表
+ */
@Override
public List listByPaper(String paperId) {
- //查询条件
+ // 查询条件
QueryWrapper wrapper = new QueryWrapper<>();
- wrapper.lambda().eq(PaperQu::getPaperId, paperId)
- .orderByAsc(PaperQu::getSort);
+ wrapper.lambda().eq(PaperQu::getPaperId, paperId) // 通过试卷ID过滤
+ .orderByAsc(PaperQu::getSort); // 按照题目排序字段升序排列
+ // 执行查询,获取试卷考题列表
List list = this.list(wrapper);
+
+ // 使用BeanMapper工具类将实体对象列表转换为DTO对象列表
return BeanMapper.mapList(list, PaperQuDTO.class);
}
+ /**
+ * 根据试卷ID和题目ID查找单个试卷考题
+ * @param paperId 试卷ID
+ * @param quId 题目ID
+ * @return 找到的试卷考题对象
+ */
@Override
public PaperQu findByKey(String paperId, String quId) {
- //查询条件
+ // 查询条件
QueryWrapper wrapper = new QueryWrapper<>();
- wrapper.lambda().eq(PaperQu::getPaperId, paperId)
- .eq(PaperQu::getQuId, quId);
+ wrapper.lambda().eq(PaperQu::getPaperId, paperId) // 通过试卷ID过滤
+ .eq(PaperQu::getQuId, quId); // 通过题目ID过滤
- return this.getOne(wrapper, false);
+ // 获取匹配的单个试卷考题对象
+ return this.getOne(wrapper, false); // 返回查询到的结果,false表示未查询到时返回null
}
+ /**
+ * 根据试卷ID和题目ID更新试卷考题
+ * @param qu 需要更新的试卷考题对象
+ */
@Override
public void updateByKey(PaperQu qu) {
- //查询条件
+ // 查询条件
QueryWrapper wrapper = new QueryWrapper<>();
- wrapper.lambda().eq(PaperQu::getPaperId, qu.getPaperId())
- .eq(PaperQu::getQuId, qu.getQuId());
+ wrapper.lambda().eq(PaperQu::getPaperId, qu.getPaperId()) // 通过试卷ID过滤
+ .eq(PaperQu::getQuId, qu.getQuId()); // 通过题目ID过滤
- this.update(qu, wrapper);
+ // 执行更新操作
+ this.update(qu, wrapper); // 更新满足条件的试卷考题
}
+ /**
+ * 统计试卷中的客观题分数
+ * @param paperId 试卷ID
+ * @return 客观题的总分
+ */
@Override
public int sumObjective(String paperId) {
- return baseMapper.sumObjective(paperId);
+ return baseMapper.sumObjective(paperId); // 调用Mapper方法,统计客观题总分
}
+ /**
+ * 统计试卷中的主观题分数
+ * @param paperId 试卷ID
+ * @return 主观题的总分
+ */
@Override
public int sumSubjective(String paperId) {
- return baseMapper.sumSubjective(paperId);
+ return baseMapper.sumSubjective(paperId); // 调用Mapper方法,统计主观题总分
}
+ /**
+ * 根据试卷ID查询试卷考题的详细信息
+ * @param paperId 试卷ID
+ * @return 试卷考题详细信息列表
+ */
@Override
public List listForPaperResult(String paperId) {
- return baseMapper.listByPaper(paperId);
+ return baseMapper.listByPaper(paperId); // 调用Mapper方法,获取试卷考题详细信息
}
}
diff --git a/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperServiceImpl.java b/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperServiceImpl.java
index 2eefec8..8f28028 100644
--- a/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperServiceImpl.java
+++ b/src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperServiceImpl.java
@@ -1,103 +1,167 @@
+// 定义包名,表示该类属于com.yf.exam.modules.paper.service.impl包下
package com.yf.exam.modules.paper.service.impl;
+// 导入MyBatis Plus框架的核心类,用于构建查询条件
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入MyBatis Plus框架的分页功能相关类
import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入MyBatis Plus框架的工具类,用于生成唯一ID
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+// 导入MyBatis Plus框架的服务实现类
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入项目中定义的作业组枚举
import com.yf.exam.ability.job.enums.JobGroup;
+// 导入项目中定义的作业前缀枚举
import com.yf.exam.ability.job.enums.JobPrefix;
+// 导入项目中的作业服务接口
import com.yf.exam.ability.job.service.JobService;
+// 导入项目中定义的API错误码类
import com.yf.exam.core.api.ApiError;
+// 导入项目中定义的DTO类,用于分页请求
import com.yf.exam.core.api.dto.PagingReqDTO;
+// 导入项目中的服务异常类
import com.yf.exam.core.exception.ServiceException;
+// 导入项目中定义的Bean映射工具类
import com.yf.exam.core.utils.BeanMapper;
+// 导入项目中定义的Cron表达式工具类
import com.yf.exam.core.utils.CronUtils;
+// 导入项目中定义的考试DTO类
import com.yf.exam.modules.exam.dto.ExamDTO;
+// 导入项目中定义的考试题库DTO类
import com.yf.exam.modules.exam.dto.ExamRepoDTO;
+// 导入项目中定义的扩展考试题库DTO类
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO;
+// 导入项目中的考试服务接口
import com.yf.exam.modules.exam.service.ExamRepoService;
+// 导入项目中的考试服务接口
import com.yf.exam.modules.exam.service.ExamService;
+// 导入项目中定义的试卷DTO类
import com.yf.exam.modules.paper.dto.PaperDTO;
+// 导入项目中定义的试卷题目DTO类
import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 导入项目中定义的扩展试卷题目答案DTO类
import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
+// 导入项目中定义的试卷题目详情DTO类
import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
+// 导入项目中定义的试卷答案DTO类
import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
+// 导入项目中定义的试卷列表请求DTO类
import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
+// 导入项目中定义的试卷列表响应DTO类
import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
+// 导入项目中定义的考试结果响应DTO类
import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
+// 导入项目中定义的试卷列表响应DTO类
import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
+// 导入项目中定义的试卷实体类
import com.yf.exam.modules.paper.entity.Paper;
+// 导入项目中定义的试卷题目实体类
import com.yf.exam.modules.paper.entity.PaperQu;
+// 导入项目中定义的试卷题目答案实体类
import com.yf.exam.modules.paper.entity.PaperQuAnswer;
+// 导入项目中定义的考试状态枚举
import com.yf.exam.modules.paper.enums.ExamState;
+// 导入项目中定义的试卷状态枚举
import com.yf.exam.modules.paper.enums.PaperState;
+// 导入项目中定义的强制交卷作业类
import com.yf.exam.modules.paper.job.BreakExamJob;
+// 导入项目中定义的试卷Mapper接口
import com.yf.exam.modules.paper.mapper.PaperMapper;
+// 导入项目中定义的试卷题目服务接口
import com.yf.exam.modules.paper.service.PaperQuAnswerService;
+// 导入项目中定义的试卷题目服务接口
import com.yf.exam.modules.paper.service.PaperQuService;
+// 导入项目中定义的试卷服务接口
import com.yf.exam.modules.paper.service.PaperService;
+// 导入项目中定义的题目实体类
import com.yf.exam.modules.qu.entity.Qu;
+// 导入项目中定义的题目答案实体类
import com.yf.exam.modules.qu.entity.QuAnswer;
+// 导入项目中定义的题目类型枚举
import com.yf.exam.modules.qu.enums.QuType;
+// 导入项目中定义的题目服务接口
import com.yf.exam.modules.qu.service.QuAnswerService;
+// 导入项目中定义的题目服务接口
import com.yf.exam.modules.qu.service.QuService;
+// 导入项目中定义的系统用户实体类
import com.yf.exam.modules.sys.user.entity.SysUser;
+// 导入项目中定义的系统用户服务接口
import com.yf.exam.modules.sys.user.service.SysUserService;
+// 导入项目中定义的用户书籍服务接口
import com.yf.exam.modules.user.book.service.UserBookService;
+// 导入项目中定义的用户考试服务接口
import com.yf.exam.modules.user.exam.service.UserExamService;
+// 导入Apache Commons Lang库中的StringUtils类,用于字符串操作
import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架中的注解,用于自动注入依赖
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架中的注解,用于声明服务组件
import org.springframework.stereotype.Service;
+// 导入Spring框架中的注解,用于声明事务管理
import org.springframework.transaction.annotation.Transactional;
+// 导入Spring框架中的类,用于工具操作
import org.springframework.util.CollectionUtils;
+// 导入Java.util包下的类,用于集合操作
import java.util.*;
+// 定义语言设置服务实现类,继承自ServiceImpl,并实现PaperService接口
/**
-*
-* 语言设置 服务实现类
-*
-*
-* @author 聪明笨狗
-* @since 2020-05-25 16:33
-*/
+ *
+ * 语言设置 服务实现类
+ *
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 16:33
+ */
@Service
public class PaperServiceImpl extends ServiceImpl implements PaperService {
-
+ // 自动注入系统用户服务
@Autowired
private SysUserService sysUserService;
+ // 自动注入考试服务
@Autowired
private ExamService examService;
+ // 自动注入题目服务
@Autowired
private QuService quService;
+ // 自动注入题目答案服务
@Autowired
private QuAnswerService quAnswerService;
+ // 自动注入试卷服务
@Autowired
private PaperService paperService;
+ // 自动注入试卷题目服务
@Autowired
private PaperQuService paperQuService;
+ // 自动注入试卷题目答案服务
@Autowired
private PaperQuAnswerService paperQuAnswerService;
+ // 自动注入用户书籍服务
@Autowired
private UserBookService userBookService;
+ // 自动注入考试题库服务
@Autowired
private ExamRepoService examRepoService;
+ // 自动注入用户考试服务
@Autowired
private UserExamService userExamService;
+ // 自动注入作业服务
@Autowired
private JobService jobService;
+ // 定义展示的选项,如ABC这样的选项列表
/**
* 展示的选项,ABC这样
*/
@@ -106,437 +170,503 @@ public class PaperServiceImpl extends ServiceImpl implements
,"Y","Z"
});
-
-
-
-
+ // 声明创建试卷的方法,使用事务管理,如果发生异常则回滚
+ /**
+ * 创建试卷的方法
+ * @param userId 用户ID
+ * @param examId 考试ID
+ * @return 返回试卷ID
+ */
@Transactional(rollbackFor = Exception.class)
@Override
public String createPaper(String userId, String examId) {
- // 校验是否有正在考试的试卷
+ // 构建查询条件,查询是否有正在考试的试卷
QueryWrapper wrapper = new QueryWrapper<>();
wrapper.lambda()
.eq(Paper::getUserId, userId)
.eq(Paper::getState, PaperState.ING);
+ // 统计符合条件的试卷数量
int exists = this.count(wrapper);
-
+ // 如果存在正在考试的试卷,则抛出服务异常
if (exists > 0) {
throw new ServiceException(ApiError.ERROR_20010002);
}
- // 查找考试
+ // 根据考试ID查询考试信息
ExamDTO exam = examService.findById(examId);
+ // 如果考试信息不存在,则抛出服务异常
if(exam == null){
throw new ServiceException(1, "考试不存在!");
}
+ // 如果考试状态不正确,则抛出服务异常
if(!ExamState.ENABLE.equals(exam.getState())){
throw new ServiceException(1, "考试状态不正确!");
}
- // 考试题目列表
- List quList = this.generateByRepo(examId);
-
- if(CollectionUtils.isEmpty(quList)){
- throw new ServiceException(1, "规则不正确,无对应的考题!");
- }
-
- //保存试卷内容
- Paper paper = this.savePaper(userId, exam, quList);
+ // 根据考试ID生成试卷题目列表
- // 强制交卷任务
- String jobName = JobPrefix.BREAK_EXAM + paper.getId();
- jobService.addCronJob(BreakExamJob.class, jobName, CronUtils.dateToCron(paper.getLimitTime()), paper.getId());
+ List quList = this.generateByRepo(examId);
- return paper.getId();
+ // 如果题目列表为空,则抛出服务异常
+ if(CollectionUtils.isEmpty(quList)){
+ throw new ServiceException(1, "规则不正确,无对应的考题!");
}
- @Override
- public ExamDetailRespDTO paperDetail(String paperId) {
-
-
- ExamDetailRespDTO respDTO = new ExamDetailRespDTO();
+ // 保存试卷内容,并返回试卷ID
+ Paper paper = this.savePaper(userId, exam, quList);
- // 试题基本信息
- Paper paper = paperService.getById(paperId);
- BeanMapper.copy(paper, respDTO);
+ // 添加强制交卷任务
+ String jobName = JobPrefix.BREAK_EXAM + paper.getId();
+ jobService.addCronJob(BreakExamJob.class, jobName, CronUtils.dateToCron(paper.getLimitTime()), paper.getId());
- // 查找题目列表
- List list = paperQuService.listByPaper(paperId);
+ return paper.getId();
+}
- List radioList = new ArrayList<>();
- List multiList = new ArrayList<>();
- List judgeList = new ArrayList<>();
- for(PaperQuDTO item: list){
- if(QuType.RADIO.equals(item.getQuType())){
- radioList.add(item);
- }
- if(QuType.MULTI.equals(item.getQuType())){
- multiList.add(item);
- }
- if(QuType.JUDGE.equals(item.getQuType())){
- judgeList.add(item);
- }
+// 声明查询试卷详情的方法
+/**
+ * 查询试卷详情的方法
+ * @param paperId 试卷ID
+ * @return 返回考试详情响应DTO
+ */
+@Override
+public ExamDetailRespDTO paperDetail(String paperId) {
+
+ // 创建考试详情响应DTO对象
+ ExamDetailRespDTO respDTO = new ExamDetailRespDTO();
+
+ // 根据试卷ID查询试卷基本信息,并复制到响应DTO中
+ Paper paper = paperService.getById(paperId);
+ BeanMapper.copy(paper, respDTO);
+
+ // 根据试卷ID查询题目列表
+ List list = paperQuService.listByPaper(paperId);
+
+ // 分类题目列表
+ List radioList = new ArrayList<>();
+ List multiList = new ArrayList<>();
+ List judgeList = new ArrayList<>();
+ for(PaperQuDTO item: list){
+ if(QuType.RADIO.equals(item.getQuType())){
+ radioList.add(item);
+ }
+ if(QuType.MULTI.equals(item.getQuType())){
+ multiList.add(item);
+ }
+ if(QuType.JUDGE.equals(item.getQuType())){
+ judgeList.add(item);
}
-
- respDTO.setRadioList(radioList);
- respDTO.setMultiList(multiList);
- respDTO.setJudgeList(judgeList);
- return respDTO;
- }
-
- @Override
- public ExamResultRespDTO paperResult(String paperId) {
-
- ExamResultRespDTO respDTO = new ExamResultRespDTO();
-
- // 试题基本信息
- Paper paper = paperService.getById(paperId);
- BeanMapper.copy(paper, respDTO);
-
- List quList = paperQuService.listForPaperResult(paperId);
- respDTO.setQuList(quList);
-
- return respDTO;
}
- @Override
- public PaperQuDetailDTO findQuDetail(String paperId, String quId) {
-
- PaperQuDetailDTO respDTO = new PaperQuDetailDTO();
- // 问题
- Qu qu = quService.getById(quId);
-
- // 基本信息
- PaperQu paperQu = paperQuService.findByKey(paperId, quId);
- BeanMapper.copy(paperQu, respDTO);
- respDTO.setContent(qu.getContent());
- respDTO.setImage(qu.getImage());
-
- // 答案列表
- List list = paperQuAnswerService.listForExam(paperId, quId);
- respDTO.setAnswerList(list);
-
- return respDTO;
- }
+ // 设置分类后的题目列表到响应DTO中
+ respDTO.setRadioList(radioList);
+ respDTO.setMultiList(multiList);
+ respDTO.setJudgeList(judgeList);
+ return respDTO;
+}
+// 声明查询试卷结果的方法
+/**
+ * 查询试卷结果的方法
+ * @param paperId 试卷ID
+ * @return 返回考试结果响应DTO
+ */
+@Override
+public ExamResultRespDTO paperResult(String paperId) {
- /**
- * 题库组题方式产生题目列表
- * @param examId
- * @return
- */
- private List generateByRepo(String examId){
+ // 创建考试结果响应DTO对象
+ ExamResultRespDTO respDTO = new ExamResultRespDTO();
- // 查找规则指定的题库
- List list = examRepoService.listByExam(examId);
+ // 根据试卷ID查询试卷基本信息,并复制到响应DTO中
+ Paper paper = paperService.getById(paperId);
+ BeanMapper.copy(paper, respDTO);
- //最终的题目列表
- List quList = new ArrayList<>();
+ // 根据试卷ID查询题目列表
+ List quList = paperQuService.listForPaperResult(paperId);
+ respDTO.setQuList(quList);
- //排除ID,避免题目重复
- List excludes = new ArrayList<>();
- excludes.add("none");
+ return respDTO;
+}
- if (!CollectionUtils.isEmpty(list)) {
- for (ExamRepoExtDTO item : list) {
+// 声明查询题目详情的方法
+/**
+ * 查询题目详情的方法
+ * @param paperId 试卷ID
+ * @param quId 题目ID
+ * @return 返回题目详情DTO
+ */
+@Override
+public PaperQuDetailDTO findQuDetail(String paperId, String quId) {
+
+ // 创建题目详情DTO对象
+ PaperQuDetailDTO respDTO = new PaperQuDetailDTO();
+ // 根据题目ID查询题目信息
+ Qu qu = quService.getById(quId);
+
+ // 根据试卷ID和题目ID查询试卷题目信息,并复制到响应DTO中
+ PaperQu paperQu = paperQuService.findByKey(paperId, quId);
+ BeanMapper.copy(paperQu, respDTO);
+ respDTO.setContent(qu.getContent());
+ respDTO.setImage(qu.getImage());
+
+ // 根据试卷ID和题目ID查询答案列表,并设置到响应DTO中
+ List list = paperQuAnswerService.listForExam(paperId, quId);
+ respDTO.setAnswerList(list);
+
+ return respDTO;
+}
- // 单选题
- if(item.getRadioCount() > 0){
- List radioList = quService.listByRandom(item.getRepoId(), QuType.RADIO, excludes, item.getRadioCount());
- for (Qu qu : radioList) {
- PaperQu paperQu = this.processPaperQu(item, qu);
- quList.add(paperQu);
- excludes.add(qu.getId());
- }
+// 声明题库组题方式产生题目列表的私有方法
+/**
+ * 题库组题方式产生题目列表的方法
+ * @param examId 考试ID
+ * @return 返回题目列表
+ */
+private List generateByRepo(String examId){
+
+ // 查询规则指定的题库
+ List list = examRepoService.listByExam(examId);
+
+ // 最终的题目列表
+ List quList = new ArrayList<>();
+
+ // 排除ID,避免题目重复
+ List excludes = new ArrayList<>();
+ excludes.add("none");
+
+ // 如果题库列表不为空,则进行题目抽取
+ if (!CollectionUtils.isEmpty(list)) {
+ for (ExamRepoExtDTO item : list) {
+
+ // 抽取单选题
+ if(item.getRadioCount() > 0){
+ List radioList = quService.listByRandom(item.getRepoId(), QuType.RADIO, excludes, item.getRadioCount());
+ for (Qu qu : radioList) {
+ PaperQu paperQu = this.processPaperQu(item, qu);
+ quList.add(paperQu);
+ excludes.add(qu.getId());
}
+ }
- //多选题
- if(item.getMultiCount() > 0) {
- List multiList = quService.listByRandom(item.getRepoId(), QuType.MULTI, excludes,
- item.getMultiCount());
- for (Qu qu : multiList) {
- PaperQu paperQu = this.processPaperQu(item, qu);
- quList.add(paperQu);
- excludes.add(qu.getId());
- }
+ // 抽取多选题
+ if(item.getMultiCount() > 0) {
+ List multiList = quService.listByRandom(item.getRepoId(), QuType.MULTI, excludes,
+ item.getMultiCount());
+ for (Qu qu : multiList) {
+ PaperQu paperQu = this.processPaperQu(item, qu);
+ quList.add(paperQu);
+ excludes.add(qu.getId());
}
+ }
- // 判断题
- if(item.getJudgeCount() > 0) {
- List judgeList = quService.listByRandom(item.getRepoId(), QuType.JUDGE, excludes,
- item.getJudgeCount());
- for (Qu qu : judgeList) {
- PaperQu paperQu = this.processPaperQu(item, qu);
- quList.add(paperQu);
- excludes.add(qu.getId());
- }
+ // 抽取判断题
+ if(item.getJudgeCount() > 0) {
+ List judgeList = quService.listByRandom(item.getRepoId(), QuType.JUDGE, excludes,
+ item.getJudgeCount());
+ for (Qu qu : judgeList) {
+ PaperQu paperQu = this.processPaperQu(item, qu);
+ quList.add(paperQu);
+ excludes.add(qu.getId());
}
}
}
- return quList;
}
+ return quList;
+}
+// 声明填充试题题目信息的私有方法
+/**
+ * 填充试题题目信息的方法
+ * @param repo 考试题库DTO
+ * @param qu 题目实体
+ * @return 返回试卷题目实体
+ */
+private PaperQu processPaperQu(ExamRepoDTO repo, Qu qu) {
+
+ // 创建试卷题目实体
+ PaperQu paperQu = new PaperQu();
+ paperQu.setQuId(qu.getId());
+ paperQu.setAnswered(false);
+ paperQu.setIsRight(false);
+ paperQu.setQuType(qu.getQuType());
+
+ // 设置单选题分数
+ if (QuType.RADIO.equals(qu.getQuType())) {
+ paperQu.setScore(repo.getRadioScore());
+ paperQu.setActualScore(repo.getRadioScore());
+ }
-
- /**
- * 填充试题题目信息
- * @param repo
- * @param qu
- * @return
- */
- private PaperQu processPaperQu(ExamRepoDTO repo, Qu qu) {
-
- //保存试题信息
- PaperQu paperQu = new PaperQu();
- paperQu.setQuId(qu.getId());
- paperQu.setAnswered(false);
- paperQu.setIsRight(false);
- paperQu.setQuType(qu.getQuType());
-
- if (QuType.RADIO.equals(qu.getQuType())) {
- paperQu.setScore(repo.getRadioScore());
- paperQu.setActualScore(repo.getRadioScore());
- }
-
- if (QuType.MULTI.equals(qu.getQuType())) {
- paperQu.setScore(repo.getMultiScore());
- paperQu.setActualScore(repo.getMultiScore());
- }
-
- if (QuType.JUDGE.equals(qu.getQuType())) {
- paperQu.setScore(repo.getJudgeScore());
- paperQu.setActualScore(repo.getJudgeScore());
- }
-
- return paperQu;
+ // 设置多选题分数
+ if (QuType.MULTI.equals(qu.getQuType())) {
+ paperQu.setScore(repo.getMultiScore());
+ paperQu.setActualScore(repo.getMultiScore());
}
+ // 设置判断题分数
+ if (QuType.JUDGE.equals(qu.getQuType())) {
+ paperQu.setScore(repo.getJudgeScore());
+ paperQu.setActualScore(repo.getJudgeScore());
+ }
- /**
- * 保存试卷
- * @param userId
- * @param exam
- * @param quList
- * @return
- */
- private Paper savePaper(String userId, ExamDTO exam, List quList) {
-
-
- // 查找用户
- SysUser user = sysUserService.getById(userId);
-
- //保存试卷基本信息
- Paper paper = new Paper();
- paper.setDepartId(user.getDepartId());
- paper.setExamId(exam.getId());
- paper.setTitle(exam.getTitle());
- paper.setTotalScore(exam.getTotalScore());
- paper.setTotalTime(exam.getTotalTime());
- paper.setUserScore(0);
- paper.setUserId(userId);
- paper.setCreateTime(new Date());
- paper.setUpdateTime(new Date());
- paper.setQualifyScore(exam.getQualifyScore());
- paper.setState(PaperState.ING);
- paper.setHasSaq(false);
-
- // 截止时间
- Calendar cl = Calendar.getInstance();
- cl.setTimeInMillis(System.currentTimeMillis());
- cl.add(Calendar.MINUTE, exam.getTotalTime());
- paper.setLimitTime(cl.getTime());
-
- paperService.save(paper);
-
- if (!CollectionUtils.isEmpty(quList)) {
- this.savePaperQu(paper.getId(), quList);
- }
+ return paperQu;
+}
- return paper;
+// 声明保存试卷的私有方法
+/**
+ * 保存试卷的方法
+ * @param userId 用户ID
+ * @param exam 考试DTO
+ * @param quList 题目列表
+ * @return 返回试卷实体
+ */
+private Paper savePaper(String userId, ExamDTO exam, List quList) {
+
+
+ // 根据用户ID查询用户信息
+ SysUser user = sysUserService.getById(userId);
+
+ // 创建试卷基本信息,并设置属性
+ Paper paper = new Paper();
+ paper.setDepartId(user.getDepartId());
+ paper.setExamId(exam.getId());
+ paper.setTitle(exam.getTitle());
+ paper.setTotalScore(exam.getTotalScore());
+ paper.setTotalTime(exam.getTotalTime());
+ paper.setUserScore(0);
+ paper.setUserId(userId);
+ paper.setCreateTime(new Date());
+ paper.setUpdateTime(new Date());
+ paper.setQualifyScore(exam.getQualifyScore());
+ paper.setState(PaperState.ING);
+ paper.setHasSaq(false);
+
+ // 计算截止时间
+ Calendar cl = Calendar.getInstance();
+ cl.setTimeInMillis(System.currentTimeMillis());
+ cl.add(Calendar.MINUTE, exam.getTotalTime());
+ paper.setLimitTime(cl.getTime());
+
+ // 保存试卷基本信息
+ paperService.save(paper);
+
+ // 如果题目列表不为空,则保存试卷题目列表
+ if (!CollectionUtils.isEmpty(quList)) {
+ this.savePaperQu(paper.getId(), quList);
}
+ return paper;
+}
-
- /**
- * 保存试卷试题列表
- * @param paperId
- * @param quList
- */
- private void savePaperQu(String paperId, List quList){
-
- List batchQuList = new ArrayList<>();
- List batchAnswerList = new ArrayList<>();
-
- int sort = 0;
- for (PaperQu item : quList) {
-
- item.setPaperId(paperId);
- item.setSort(sort);
- item.setId(IdWorker.getIdStr());
-
- //回答列表
- List answerList = quAnswerService.listAnswerByRandom(item.getQuId());
-
- if (!CollectionUtils.isEmpty(answerList)) {
-
- int ii = 0;
- for (QuAnswer answer : answerList) {
- PaperQuAnswer paperQuAnswer = new PaperQuAnswer();
- paperQuAnswer.setId(UUID.randomUUID().toString());
- paperQuAnswer.setPaperId(paperId);
- paperQuAnswer.setQuId(answer.getQuId());
- paperQuAnswer.setAnswerId(answer.getId());
- paperQuAnswer.setChecked(false);
- paperQuAnswer.setSort(ii);
- paperQuAnswer.setAbc(ABC.get(ii));
- paperQuAnswer.setIsRight(answer.getIsRight());
- ii++;
- batchAnswerList.add(paperQuAnswer);
- }
+// 声明保存试卷试题列表的私有方法
+/**
+ * 保存试卷试题列表的方法
+ * @param paperId 试卷ID
+ * @param quList 题目列表
+ */
+private void savePaperQu(String paperId, List quList){
+
+ // 创建批量保存的题目列表和答案列表
+ List batchQuList = new ArrayList<>();
+ List batchAnswerList = new ArrayList<>();
+
+ // 初始化排序号
+ int sort = 0;
+ for (PaperQu item : quList) {
+
+ // 设置试卷ID和排序号,并生成ID
+ item.setPaperId(paperId);
+ item.setSort(sort);
+ item.setId(IdWorker.getIdStr());
+
+ // 查询题目的答案列表
+ List answerList = quAnswerService.listAnswerByRandom(item.getQuId());
+
+ // 如果答案列表不为空,则进行处理
+ if (!CollectionUtils.isEmpty(answerList)) {
+
+ // 初始化答案排序号
+ int ii = 0;
+ for (QuAnswer answer : answerList) {
+ PaperQuAnswer paperQuAnswer = new PaperQuAnswer();
+ paperQuAnswer.setId(UUID.randomUUID().toString());
+ paperQuAnswer.setPaperId(paperId);
+ paperQuAnswer.setQuId(answer.getQuId());
+ paperQuAnswer.setAnswerId(answer.getId());
+ paperQuAnswer.setChecked(false);
+ paperQuAnswer.setSort(ii);
+ paperQuAnswer.setAbc(ABC.get(ii));
+ paperQuAnswer.setIsRight(answer.getIsRight());
+ ii++;
+ batchAnswerList.add(paperQuAnswer);
}
-
- batchQuList.add(item);
- sort++;
}
- //添加问题
- paperQuService.saveBatch(batchQuList);
-
- //批量添加问题答案
- paperQuAnswerService.saveBatch(batchAnswerList);
+ // 添加到批量保存的题目列表中
+ batchQuList.add(item);
+ sort++;
}
- @Transactional(rollbackFor = Exception.class)
- @Override
- public void fillAnswer(PaperAnswerDTO reqDTO) {
-
+ // 批量添加题目
+ paperQuService.saveBatch(batchQuList);
- // 未作答
- if(CollectionUtils.isEmpty(reqDTO.getAnswers())
- && StringUtils.isBlank(reqDTO.getAnswer())){
- return;
- }
+ // 批量添加答案
+ paperQuAnswerService.saveBatch(batchAnswerList);
+}
- //查找答案列表
- List list = paperQuAnswerService.listForFill(reqDTO.getPaperId(), reqDTO.getQuId());
+// 声明填充答案的方法,使用事务管理
+/**
+ * 填充答案的方法
+ * @param reqDTO 试卷答案DTO
+ */
+@Transactional(rollbackFor = Exception.class)
+@Override
+public void fillAnswer(PaperAnswerDTO reqDTO) {
+
+ // 如果答案列表为空且答案字符串也为空,则直接返回
+ if(CollectionUtils.isEmpty(reqDTO.getAnswers())
+ && StringUtils.isBlank(reqDTO.getAnswer())){
+ return;
+ }
- //是否正确
- boolean right = true;
+ // 查询答案列表
+ List list = paperQuAnswerService.listForFill(reqDTO.getPaperId(), reqDTO.getQuId());
- //更新正确答案
- for (PaperQuAnswer item : list) {
+ // 初始化是否正确的标记
+ boolean right = true;
- if (reqDTO.getAnswers().contains(item.getId())) {
- item.setChecked(true);
- } else {
- item.setChecked(false);
- }
+ // 更新正确答案
+ for (PaperQuAnswer item : list) {
- //有一个对不上就是错的
- if (item.getIsRight()!=null && !item.getIsRight().equals(item.getChecked())) {
- right = false;
- }
- paperQuAnswerService.updateById(item);
+ // 设置答案是否被选中
+ if (reqDTO.getAnswers().contains(item.getId())) {
+ item.setChecked(true);
+ } else {
+ item.setChecked(false);
}
- //修改为已回答
- PaperQu qu = new PaperQu();
- qu.setQuId(reqDTO.getQuId());
- qu.setPaperId(reqDTO.getPaperId());
- qu.setIsRight(right);
- qu.setAnswer(reqDTO.getAnswer());
- qu.setAnswered(true);
-
- paperQuService.updateByKey(qu);
-
- }
-
- @Transactional(rollbackFor = Exception.class)
- @Override
- public void handExam(String paperId) {
-
- //获取试卷信息
- Paper paper = paperService.getById(paperId);
-
- //如果不是正常的,抛出异常
- if(!PaperState.ING.equals(paper.getState())){
- throw new ServiceException(1, "试卷状态不正确!");
+ // 如果有一个答案不正确,则标记为错误
+ if (item.getIsRight()!=null && !item.getIsRight().equals(item.getChecked())) {
+ right = false;
}
+ paperQuAnswerService.updateById(item);
+ }
- // 客观分
- int objScore = paperQuService.sumObjective(paperId);
- paper.setObjScore(objScore);
- paper.setUserScore(objScore);
+ // 修改为已回答
+ PaperQu qu = new PaperQu();
+ qu.setQuId(reqDTO.getQuId());
+ qu.setPaperId(reqDTO.getPaperId());
+ qu.setIsRight(right);
+ qu.setAnswer(reqDTO.getAnswer());
+ qu.setAnswered(true);
- // 主观分,因为要阅卷,所以给0
- paper.setSubjScore(0);
+ paperQuService.updateByKey(qu);
- // 待阅卷
- if(paper.getHasSaq()) {
- paper.setState(PaperState.WAIT_OPT);
- }else {
+}
- // 同步保存考试成绩
- userExamService.joinResult(paper.getUserId(), paper.getExamId(), objScore, objScore>=paper.getQualifyScore());
+// 声明交卷的方法,使用事务管理
+/**
+ * 交卷的方法
+ * @param paperId 试卷ID
+ */
+@Transactional(rollbackFor = Exception.class)
+@Override
+public void handExam(String paperId) {
+
+ // 获取试卷信息
+ Paper paper = paperService.getById(paperId);
+
+ // 如果试卷状态不正确,则抛出服务异常
+ if(!PaperState.ING.equals(paper.getState())){
+ throw new ServiceException(1, "试卷状态不正确!");
+ }
- paper.setState(PaperState.FINISHED);
- }
- paper.setUpdateTime(new Date());
-
- //计算考试时长
- Calendar cl = Calendar.getInstance();
- cl.setTimeInMillis(System.currentTimeMillis());
- int userTime = (int)((System.currentTimeMillis() - paper.getCreateTime().getTime()) / 1000 / 60);
- if(userTime == 0){
- userTime = 1;
- }
- paper.setUserTime(userTime);
+ // 计算客观题分数
+ int objScore = paperQuService.sumObjective(paperId);
+ paper.setObjScore(objScore);
+ paper.setUserScore(objScore);
- //更新试卷
- paperService.updateById(paper);
+ // 设置主观题分数为0
+ paper.setSubjScore(0);
+ // 如果有主观题,则设置状态为待阅卷
+ if(paper.getHasSaq()) {
+ paper.setState(PaperState.WAIT_OPT);
+ }else {
- // 终止定时任务
- String name = JobPrefix.BREAK_EXAM + paperId;
- jobService.deleteJob(name, JobGroup.SYSTEM);
+ // 同步保存考试成绩
+ userExamService.joinResult(paper.getUserId(), paper.getExamId(), objScore, objScore>=paper.getQualifyScore());
- //把打错的问题加入错题本
- List list = paperQuService.listByPaper(paperId);
- for(PaperQuDTO qu: list){
- // 主观题和对的都不加入错题库
- if(qu.getIsRight()){
- continue;
- }
- //加入错题本
- new Thread(() -> userBookService.addBook(paper.getExamId(), qu.getQuId())).run();
- }
+ // 设置状态为已完成
+ paper.setState(PaperState.FINISHED);
}
-
- @Override
- public IPage paging(PagingReqDTO reqDTO) {
- return baseMapper.paging(reqDTO.toPage(), reqDTO.getParams());
+ paper.setUpdateTime(new Date());
+
+ // 计算考试时长
+ Calendar cl = Calendar.getInstance();
+ cl.setTimeInMillis(System.currentTimeMillis());
+ int userTime = (int)((System.currentTimeMillis() - paper.getCreateTime().getTime()) / 1000 / 60);
+ if(userTime == 0){
+ userTime = 1;
}
+ paper.setUserTime(userTime);
+ // 更新试卷信息
+ paperService.updateById(paper);
- @Override
- public PaperDTO checkProcess(String userId) {
-
- QueryWrapper wrapper = new QueryWrapper<>();
- wrapper.lambda()
- .eq(Paper::getUserId, userId)
- .eq(Paper::getState, PaperState.ING);
-
- Paper paper = this.getOne(wrapper, false);
+ // 终止定时任务
+ String name = JobPrefix.BREAK_EXAM + paperId;
+ jobService.deleteJob(name, JobGroup.SYSTEM);
- if (paper != null) {
- return BeanMapper.map(paper, PaperDTO.class);
+ // 把打错的问题加入错题本
+ List list = paperQuService.listByPaper(paperId);
+ for(PaperQuDTO qu: list){
+ // 主观题和对的都不加入错题库
+ if(qu.getIsRight()){
+ continue;
}
+ //加入错题本
+ new Thread(() -> userBookService.addBook(paper.getExamId(), qu.getQuId())).run();
+ }
+}
- return null;
+// 声明分页查询试卷列表的方法
+/**
+ * 分页查询试卷列表的方法
+ * @param reqDTO 分页请求DTO
+ * @return 返回分页响应
+ */
+@Override
+public IPage paging(PagingReqDTO reqDTO) {
+ return baseMapper.paging(reqDTO.toPage(), reqDTO.getParams());
+}
+
+// 声明检查考试进度的方法
+/**
+ * 检查考试进度的方法
+ * @param userId 用户ID
+ * @return 返回试卷DTO
+ */
+@Override
+public PaperDTO checkProcess(String userId) {
+
+ // 构建查询条件,查询是否有正在进行的考试
+ QueryWrapper wrapper = new QueryWrapper<>();
+ wrapper.lambda()
+ .eq(Paper::getUserId, userId)
+ .eq(Paper::getState, PaperState.ING);
+
+ // 查询正在进行的考试
+ Paper paper = this.getOne(wrapper, false);
+
+ // 如果存在正在进行的考试,则返回试卷DTO
+ if (paper != null) {
+ return BeanMapper.map(paper, PaperDTO.class);
}
+
+ // 如果不存在正在进行的考试,则返回null
+ return null;
}