Commit 4d4449c1 authored by wujipeng's avatar wujipeng
Browse files

教师-智能考评-理论试卷管理

parent cc90e7f5
...@@ -53,6 +53,17 @@ public class TheoreticalPaperEntity { ...@@ -53,6 +53,17 @@ public class TheoreticalPaperEntity {
@TableField("create_user") @TableField("create_user")
private String createUser; private String createUser;
/**
* 创建教师的稳定用户ID。
*
* <p>create_user继续保存用于页面展示的名称或历史手机号快照,不能作为权限依据;
* 教师端所有数据隔离均使用本字段与JWT解析出的用户ID进行精确比较。管理员创建的
* 试卷以及无法安全认领的历史试卷允许为空。</p>
*/
@ApiModelProperty("创建教师ID;管理员创建或未认领历史数据为空")
@TableField("creator_id")
private String creatorId;
@ApiModelProperty("创建时间") @ApiModelProperty("创建时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm", timezone = "GMT+8") @JsonFormat(pattern = "yyyy-MM-dd HH:mm", timezone = "GMT+8")
@TableField("create_time") @TableField("create_time")
......
package com.platform.business.controller; package com.platform.business.controller;
import com.github.pagehelper.PageHelper;
import com.platform.business.constant.TheoreticalPaperAdminConstants;
import com.platform.business.model.dto.CombinationDTO; import com.platform.business.model.dto.CombinationDTO;
import com.platform.business.model.dto.TheoreticalPaperAutoSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperDTO; import com.platform.business.model.dto.TheoreticalPaperDTO;
import com.platform.business.model.dto.TheoreticalPaperManualSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperStatusDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.CombinationVO; import com.platform.business.model.vo.CombinationVO;
import com.platform.business.model.vo.TheoreticalPaperVO; import com.platform.business.model.vo.TheoreticalPaperVO;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.TheoreticalPaperService; import com.platform.business.service.TheoreticalPaperService;
import com.platform.business.utils.JwtTokenUtil; import com.platform.business.service.TheoreticalPaperTeacherService;
import com.platform.controller.BaseController; import com.platform.controller.BaseController;
import com.platform.model.resp.Result; import com.platform.model.resp.Result;
import com.platform.page.TableDataInfo; import com.platform.page.TableDataInfo;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*; import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource; import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
/** /**
* @author : wujipeng * 教师端“智能考评-理论试卷管理”接口。
* @date : 2025/11/3 14:01 *
* @Version: 1.0 * <p>保留历史页面使用的/page、/auto、/create、/detail和/export路径,同时提供完整的
* @Desc : 理论试卷管理 * REST接口。所有入口都从Authorization解析当前教师,不接收客户端teacherId;服务层
* 再按theoretical_paper.creator_id校验归属,形成角色与数据范围两层保护。</p>
*/ */
@Api(tags = "理论试卷管理") @Api(tags = "教师端-理论试卷管理")
@RestController @RestController
@RequestMapping("/theoretical/paper") @RequestMapping("/theoretical/paper")
public class TheoreticalPaperController extends BaseController { public class TheoreticalPaperController extends BaseController {
@Resource @Resource
private JwtTokenUtil jwtTokenUtil; private TheoreticalPaperTeacherService paperTeacherService;
/** Word导出继续复用现有模板实现,导出前必须先通过教师服务的归属校验。 */
@Resource
private TheoreticalPaperService legacyPaperService;
@Resource @Resource
private TheoreticalPaperService theoreticalPaperService; private AuthenticatedUserService authenticatedUserService;
@ApiOperation("分页查询当前教师创建的试卷")
@PostMapping("/page") @PostMapping("/page")
public TableDataInfo pageData(@RequestBody TheoreticalPaperDTO theoreticalPaperDTO) { public TableDataInfo page(@RequestBody(required = false) TheoreticalPaperDTO query,
startPage(theoreticalPaperDTO.getPageNum(), theoreticalPaperDTO.getPageSize()); HttpServletRequest request) {
return getDataTable(theoreticalPaperService.pageData(theoreticalPaperDTO)); TheoreticalPaperDTO safeQuery = query == null ? new TheoreticalPaperDTO() : query;
normalizePage(safeQuery);
UserEntity teacher = currentTeacher(request);
startPage(safeQuery.getPageNum(), safeQuery.getPageSize());
try {
return getDataTable(paperTeacherService.page(safeQuery, teacher.getId()));
} finally {
// PageHelper通过ThreadLocal保存分页状态,异常路径也必须清理,避免污染复用线程。
PageHelper.clearPage();
}
} }
@GetMapping("/auto") @ApiOperation("查询自动组卷规则预览;/auto为旧页面兼容路径")
@ApiOperation("自动组卷") @GetMapping({"/auto-configuration", "/auto"})
public Result<CombinationVO> auto(@RequestParam(name = "lev") String lev) { public Result<CombinationVO> autoConfiguration(@RequestParam("lev") String level,
return Result.data(theoreticalPaperService.auto(lev)); HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.autoConfiguration(level, teacher.getId()));
} }
@ApiOperation("按数据库最新规则自动创建当前教师的试卷")
@PostMapping("/auto")
public Result<TheoreticalPaperVO> createAutomatic(
@RequestBody TheoreticalPaperAutoSaveDTO body, HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.createAutomatic(
body, teacher.getId(), displayName(teacher)));
}
@ApiOperation("兼容旧页面自动组卷;客户端题量、总分和分布字段会被忽略")
@PostMapping("/create") @PostMapping("/create")
@ApiOperation("创建试卷") public Result<Boolean> createLegacy(@RequestBody CombinationDTO body,
public Result<Boolean> create(@RequestBody CombinationDTO combinationDTO, HttpServletRequest httpServletRequest) { HttpServletRequest request) {
String token = httpServletRequest.getHeader("Authorization"); UserEntity teacher = currentTeacher(request);
String userName = jwtTokenUtil.getUsernameFromToken(token); // 旧页面只识别布尔data,因此保留响应形态;创建失败仍由统一业务异常返回。
combinationDTO.setCreateUser(userName); paperTeacherService.createAutomatic(
return Result.data(theoreticalPaperService.create(combinationDTO)); toLegacyAutomaticRequest(body), teacher.getId(), displayName(teacher));
return Result.data(true);
}
@ApiOperation("手动创建当前教师的试卷")
@PostMapping("/manual")
public Result<TheoreticalPaperVO> createManual(
@RequestBody TheoreticalPaperManualSaveDTO body, HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.createManual(
body, teacher.getId(), displayName(teacher)));
}
@ApiOperation("查看当前教师试卷详情;/detail/{paperId}为旧页面兼容路径")
@GetMapping({"/{paperId}", "/detail/{paperId}"})
public Result<TheoreticalPaperVO> detail(@PathVariable String paperId,
HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.detail(paperId, teacher.getId()));
}
@ApiOperation("编辑当前教师尚未被考试使用的试卷")
@PutMapping("/{paperId}")
public Result<TheoreticalPaperVO> update(
@PathVariable String paperId,
@RequestBody TheoreticalPaperManualSaveDTO body,
HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.update(paperId, body, teacher.getId()));
}
@ApiOperation("复制当前教师试卷为新的本人草稿")
@PostMapping("/{paperId}/copy")
public Result<TheoreticalPaperVO> copy(@PathVariable String paperId,
HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.copy(
paperId, teacher.getId(), displayName(teacher)));
}
@ApiOperation("发布、归档或按规则退回当前教师的试卷草稿")
@PutMapping("/{paperId}/status")
public Result<TheoreticalPaperVO> changeStatus(
@PathVariable String paperId,
@RequestBody TheoreticalPaperStatusDTO body,
HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.changeStatus(
paperId, body == null ? null : body.getStatus(), teacher.getId()));
}
@ApiOperation("删除当前教师未发布且未被考试使用的试卷")
@DeleteMapping("/{paperId}")
public Result<Boolean> delete(@PathVariable String paperId, HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
return Result.data(paperTeacherService.delete(paperId, teacher.getId()));
}
@ApiOperation("导出无答案Word;/export/{paperId}为旧页面兼容路径")
@GetMapping({"/{paperId}/export", "/export/{paperId}"})
public void export(@PathVariable String paperId, HttpServletRequest request,
HttpServletResponse response) {
UserEntity teacher = currentTeacher(request);
// 必须先验证详情归属,不能让旧模板服务按任意ID直接读取其他教师试卷。
paperTeacherService.detail(paperId, teacher.getId());
legacyPaperService.export(paperId, response);
}
@ApiOperation("导出带答案Word;/export/answer/{paperId}为旧页面兼容路径")
@GetMapping({"/{paperId}/export/answer", "/export/answer/{paperId}"})
public void exportWithAnswer(@PathVariable String paperId, HttpServletRequest request,
HttpServletResponse response) {
UserEntity teacher = currentTeacher(request);
paperTeacherService.detail(paperId, teacher.getId());
legacyPaperService.exportWithAnswer(paperId, response);
} }
@ApiOperation("详情") /** 缺省第1页、每页10条,单次最多100条,避免题型聚合查询返回过多数据。 */
@GetMapping("/detail/{id}") void normalizePage(TheoreticalPaperDTO query) {
public Result<TheoreticalPaperVO> detail(@PathVariable(name = "id") String id) { int pageNum = query.getPageNum() == null || query.getPageNum() < 1 ? 1 : query.getPageNum();
return Result.data(theoreticalPaperService.detail(id)); int pageSize = query.getPageSize() == null || query.getPageSize() < 1
? 10 : Math.min(query.getPageSize(), 100);
query.setPageNum(pageNum);
query.setPageSize(pageSize);
} }
@ApiOperation("导出") /**
@GetMapping("/export/{id}") * 把旧CombinationDTO转换为可信的新请求。
public void export(@PathVariable String id, HttpServletResponse response) { *
theoreticalPaperService.export(id, response); * <p>旧请求里的num、sum、paperDistributionList和createUser均可能被伪造,因此全部
* 丢弃;服务会在提交瞬间重新读取数据库规则。历史接口此前没有草稿概念,兼容入口
* 固定创建PUBLISHED,新的/auto接口仍默认创建DRAFT。</p>
*/
TheoreticalPaperAutoSaveDTO toLegacyAutomaticRequest(CombinationDTO body) {
TheoreticalPaperAutoSaveDTO request = new TheoreticalPaperAutoSaveDTO();
if (body != null) {
request.setLev(body.getLev());
request.setName(body.getName());
request.setSequence(body.getSequence());
}
request.setStatus(TheoreticalPaperAdminConstants.STATUS_PUBLISHED);
return request;
} }
@ApiOperation("导出带答案的版本") /** 从令牌解析登录用户并校验教师角色,普通学员不能调用任何兼容旧路由。 */
@GetMapping("/export/answer/{id}") private UserEntity currentTeacher(HttpServletRequest request) {
public void exportWithAnswer(@PathVariable String id, HttpServletResponse response) { UserEntity teacher = authenticatedUserService.current(request);
theoreticalPaperService.exportWithAnswer(id, response); authenticatedUserService.requireTeacher(teacher);
return teacher;
} }
@ApiOperation("删除") /** 创建人仅作为可读快照,权限始终使用teacher.id;账号字段不全时逐级降级。 */
@DeleteMapping("/{id}") private String displayName(UserEntity teacher) {
public Result<Boolean> delete(@PathVariable String id) { if (StringUtils.hasText(teacher.getNickName())) {
return Result.data(theoreticalPaperService.delete(id)); return teacher.getNickName().trim();
}
if (StringUtils.hasText(teacher.getUsername())) {
return teacher.getUsername().trim();
}
if (StringUtils.hasText(teacher.getPhoneNumber())) {
return teacher.getPhoneNumber().trim();
}
return teacher.getId();
} }
} }
...@@ -23,9 +23,17 @@ public interface TheoreticalPaperMapper extends BaseMapper<TheoreticalPaperEntit ...@@ -23,9 +23,17 @@ public interface TheoreticalPaperMapper extends BaseMapper<TheoreticalPaperEntit
/** 管理端列表额外汇总题型和考试引用次数。 */ /** 管理端列表额外汇总题型和考试引用次数。 */
List<TheoreticalPaperVO> pageAdmin(TheoreticalPaperDTO query); List<TheoreticalPaperVO> pageAdmin(TheoreticalPaperDTO query);
/** 教师列表在SQL层按稳定用户ID隔离,分页前不会混入其他教师数据。 */
List<TheoreticalPaperVO> pageTeacher(@Param("query") TheoreticalPaperDTO query,
@Param("teacherId") String teacherId);
/** 查询管理端详情主记录;题目列表由独立查询加载,避免一对多结果重复主对象。 */ /** 查询管理端详情主记录;题目列表由独立查询加载,避免一对多结果重复主对象。 */
TheoreticalPaperVO selectAdminDetail(@Param("paperId") String paperId); TheoreticalPaperVO selectAdminDetail(@Param("paperId") String paperId);
/** 查询当前教师拥有的试卷详情;不存在与越权均返回null。 */
TheoreticalPaperVO selectTeacherDetail(@Param("paperId") String paperId,
@Param("teacherId") String teacherId);
/** 按稳定题型顺序读取试题,复制、编辑和预览共用。 */ /** 按稳定题型顺序读取试题,复制、编辑和预览共用。 */
List<com.platform.business.model.entity.TheoreticalPaperDetailEntity> selectAdminQuestions( List<com.platform.business.model.entity.TheoreticalPaperDetailEntity> selectAdminQuestions(
@Param("paperId") String paperId); @Param("paperId") String paperId);
...@@ -37,4 +45,8 @@ public interface TheoreticalPaperMapper extends BaseMapper<TheoreticalPaperEntit ...@@ -37,4 +45,8 @@ public interface TheoreticalPaperMapper extends BaseMapper<TheoreticalPaperEntit
@Param("excludeId") String excludeId); @Param("excludeId") String excludeId);
int countAdminUsage(@Param("paperId") String paperId); int countAdminUsage(@Param("paperId") String paperId);
/** 写操作委托公共管理服务前执行不可伪造的归属检查。 */
int countTeacherOwnership(@Param("paperId") String paperId,
@Param("teacherId") String teacherId);
} }
...@@ -19,12 +19,26 @@ public interface TheoreticalPaperAdminService { ...@@ -19,12 +19,26 @@ public interface TheoreticalPaperAdminService {
TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request, String creatorName); TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request, String creatorName);
/**
* 使用管理端同一套校验规则创建带教师归属的自动试卷。
* creatorId只允许由教师端控制器从JWT传入,客户端请求体不提供该字段。
*/
TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request, String creatorName,
String creatorId);
TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request, String creatorName); TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request, String creatorName);
/** 使用公共组卷规则创建带教师归属的手动试卷。 */
TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request, String creatorName,
String creatorId);
TheoreticalPaperVO update(String paperId, TheoreticalPaperManualSaveDTO request); TheoreticalPaperVO update(String paperId, TheoreticalPaperManualSaveDTO request);
TheoreticalPaperVO copy(String paperId, String creatorName); TheoreticalPaperVO copy(String paperId, String creatorName);
/** 深复制试卷并把新副本归属到当前教师,原试卷归属不会被继承。 */
TheoreticalPaperVO copy(String paperId, String creatorName, String creatorId);
TheoreticalPaperVO changeStatus(String paperId, String status); TheoreticalPaperVO changeStatus(String paperId, String status);
boolean delete(String paperId); boolean delete(String paperId);
......
package com.platform.business.service;
import com.platform.business.model.dto.TheoreticalPaperAutoSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperDTO;
import com.platform.business.model.dto.TheoreticalPaperManualSaveDTO;
import com.platform.business.model.vo.CombinationVO;
import com.platform.business.model.vo.TheoreticalPaperVO;
import java.util.List;
/**
* 教师端“智能考评-理论试卷管理”业务接口。
*
* <p>所有方法都显式接收由JWT解析得到的teacherId。接口不接受客户端指定归属人,
* 服务实现会在SQL层和写操作入口同时校验试卷归属。</p>
*/
public interface TheoreticalPaperTeacherService {
List<TheoreticalPaperVO> page(TheoreticalPaperDTO query, String teacherId);
TheoreticalPaperVO detail(String paperId, String teacherId);
CombinationVO autoConfiguration(String level, String teacherId);
TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request,
String teacherId, String creatorName);
TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request,
String teacherId, String creatorName);
TheoreticalPaperVO update(String paperId, TheoreticalPaperManualSaveDTO request,
String teacherId);
TheoreticalPaperVO copy(String paperId, String teacherId, String creatorName);
TheoreticalPaperVO changeStatus(String paperId, String status, String teacherId);
boolean delete(String paperId, String teacherId);
}
...@@ -156,6 +156,19 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe ...@@ -156,6 +156,19 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request, public TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request,
String creatorName) { String creatorName) {
return createAutomatic(request, creatorName, null);
}
/**
* 管理员与教师共用的自动组卷事务入口。
*
* <p>creatorId为空表示管理员创建;非空表示教师端创建。归属字段随主表一次插入,
* 避免“试卷已经生成但尚未写入教师归属”的并发可见窗口。</p>
*/
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request,
String creatorName, String creatorId) {
if (request == null) { if (request == null) {
throw new BusinessException("自动组卷信息不能为空"); throw new BusinessException("自动组卷信息不能为空");
} }
...@@ -184,17 +197,26 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe ...@@ -184,17 +197,26 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
PreparedQuestions prepared = prepareQuestions(questions); PreparedQuestions prepared = prepareQuestions(questions);
BigDecimal passScore = normalizePassScore(request.getPassScore(), prepared.totalScore); BigDecimal passScore = normalizePassScore(request.getPassScore(), prepared.totalScore);
return createPaper(level, name, passScore, sequence, status, "自动组卷", return createPaper(level, name, passScore, sequence, status, "自动组卷",
creatorName, prepared.questions, prepared.totalScore); creatorName, creatorId, prepared.questions, prepared.totalScore);
} }
@Override @Override
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request, public TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request,
String creatorName) { String creatorName) {
return createManual(request, creatorName, null);
}
/** 教师端与管理员端共用手动题目校验、总分汇总和事务保存逻辑。 */
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request,
String creatorName, String creatorId) {
PreparedPaper prepared = prepareManualRequest(request, false); PreparedPaper prepared = prepareManualRequest(request, false);
ensureUniqueName(prepared.name, null); ensureUniqueName(prepared.name, null);
return createPaper(prepared.level, prepared.name, prepared.passScore, prepared.sequence, return createPaper(prepared.level, prepared.name, prepared.passScore, prepared.sequence,
prepared.status, "手动组卷", creatorName, prepared.questions, prepared.totalScore); prepared.status, "手动组卷", creatorName, creatorId,
prepared.questions, prepared.totalScore);
} }
@Override @Override
...@@ -239,6 +261,16 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe ...@@ -239,6 +261,16 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
@Override @Override
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO copy(String paperId, String creatorName) { public TheoreticalPaperVO copy(String paperId, String creatorName) {
return copy(paperId, creatorName, null);
}
/**
* 复制时使用调用者自己的creatorId,而不是沿用源试卷归属;这样管理员复制结果仍为
* 管理员公共试卷,教师复制结果则固定归属于发起复制的教师。
*/
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO copy(String paperId, String creatorName, String creatorId) {
TheoreticalPaperEntity source = lockPaper(paperId); TheoreticalPaperEntity source = lockPaper(paperId);
List<TheoreticalPaperDetailEntity> sourceQuestions = paperMapper.selectAdminQuestions(source.getId()); List<TheoreticalPaperDetailEntity> sourceQuestions = paperMapper.selectAdminQuestions(source.getId());
PreparedQuestions prepared = prepareQuestions(sourceQuestions); PreparedQuestions prepared = prepareQuestions(sourceQuestions);
...@@ -247,7 +279,7 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe ...@@ -247,7 +279,7 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
BigDecimal passScore = normalizePassScore(source.getPassScore(), totalScore); BigDecimal passScore = normalizePassScore(source.getPassScore(), totalScore);
return createPaper(source.getLev(), copyName, passScore, return createPaper(source.getLev(), copyName, passScore,
normalizeSequence(source.getSequence()), TheoreticalPaperAdminConstants.STATUS_DRAFT, normalizeSequence(source.getSequence()), TheoreticalPaperAdminConstants.STATUS_DRAFT,
"复制组卷", creatorName, prepared.questions, totalScore); "复制组卷", creatorName, creatorId, prepared.questions, totalScore);
} }
@Override @Override
...@@ -301,7 +333,7 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe ...@@ -301,7 +333,7 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
/** 保存主表和题目明细;方法只接收已经过完整校验和重新计算的数据。 */ /** 保存主表和题目明细;方法只接收已经过完整校验和重新计算的数据。 */
private TheoreticalPaperVO createPaper(String level, String name, BigDecimal passScore, private TheoreticalPaperVO createPaper(String level, String name, BigDecimal passScore,
String sequence, String status, String createType, String sequence, String status, String createType,
String creatorName, String creatorName, String creatorId,
List<TheoreticalPaperDetailEntity> questions, List<TheoreticalPaperDetailEntity> questions,
BigDecimal totalScore) { BigDecimal totalScore) {
TheoreticalPaperEntity paper = new TheoreticalPaperEntity(); TheoreticalPaperEntity paper = new TheoreticalPaperEntity();
...@@ -312,6 +344,8 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe ...@@ -312,6 +344,8 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
paper.setPassScore(passScore.setScale(2, RoundingMode.HALF_UP).doubleValue()); paper.setPassScore(passScore.setScale(2, RoundingMode.HALF_UP).doubleValue());
paper.setCreateType(createType); paper.setCreateType(createType);
paper.setCreateUser(requireText(creatorName, 100, "创建人")); paper.setCreateUser(requireText(creatorName, 100, "创建人"));
// creatorId不接受请求体字段,只保存控制器从可信JWT身份传入的值。
paper.setCreatorId(trimOptional(creatorId, 64, "创建人ID"));
Date now = new Date(); Date now = new Date();
paper.setCreateTime(now); paper.setCreateTime(now);
paper.setUpdateTime(now); paper.setUpdateTime(now);
......
package com.platform.business.service.impl;
import com.platform.business.constant.TheoreticalPaperAdminConstants;
import com.platform.business.mapper.TheoreticalPaperMapper;
import com.platform.business.model.dto.TheoreticalPaperAutoSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperDTO;
import com.platform.business.model.dto.TheoreticalPaperManualSaveDTO;
import com.platform.business.model.entity.TheoreticalPaperDetailEntity;
import com.platform.business.model.vo.CombinationVO;
import com.platform.business.model.vo.TheoreticalPaperVO;
import com.platform.business.service.TheoreticalPaperAdminService;
import com.platform.business.service.TheoreticalPaperTeacherService;
import com.platform.exception.BusinessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
/**
* 教师端理论试卷管理实现。
*
* <p>本服务只负责教师数据范围:读查询直接携带creator_id,写操作先验证归属,再委托
* 管理端成熟的公共组卷逻辑执行题目校验、行锁、考试引用保护和事务保存。这样教师端与
* 管理员端使用完全一致的业务规则,同时不会复制两套容易漂移的复杂组卷代码。</p>
*/
@Service
public class TheoreticalPaperTeacherServiceImpl implements TheoreticalPaperTeacherService {
@Resource
private TheoreticalPaperMapper paperMapper;
/** 复用管理端已经完整验证的组卷与状态业务,不复用管理端权限。 */
@Resource
private TheoreticalPaperAdminService paperManagementService;
@Override
@Transactional(readOnly = true)
public List<TheoreticalPaperVO> page(TheoreticalPaperDTO query, String teacherId) {
String safeTeacherId = requireTeacherId(teacherId);
TheoreticalPaperDTO safeQuery = query == null ? new TheoreticalPaperDTO() : query;
safeQuery.setSearch(trimOptional(safeQuery.getSearch(), 100, "搜索关键字"));
safeQuery.setLev(trimOptional(safeQuery.getLev(), 64, "适用职级"));
safeQuery.setCreateType(trimOptional(safeQuery.getCreateType(), 32, "组卷方式"));
if (StringUtils.hasText(safeQuery.getStatus())) {
safeQuery.setStatus(normalizeStatus(safeQuery.getStatus()));
}
List<TheoreticalPaperVO> rows = paperMapper.pageTeacher(safeQuery, safeTeacherId);
if (rows == null) {
return Collections.emptyList();
}
for (TheoreticalPaperVO row : rows) {
decorate(row);
}
return rows;
}
@Override
@Transactional(readOnly = true)
public TheoreticalPaperVO detail(String paperId, String teacherId) {
String safePaperId = requirePaperId(paperId);
String safeTeacherId = requireTeacherId(teacherId);
TheoreticalPaperVO result = paperMapper.selectTeacherDetail(safePaperId, safeTeacherId);
if (result == null) {
// 不区分ID不存在和属于其他教师,避免调用方通过错误提示枚举试卷归属。
throw new BusinessException("试卷不存在或无权访问");
}
List<TheoreticalPaperDetailEntity> questions = paperMapper.selectAdminQuestions(safePaperId);
result.setTheoreticalPaperDetailList(
questions == null ? Collections.emptyList() : questions);
decorate(result);
return result;
}
@Override
@Transactional(readOnly = true)
public CombinationVO autoConfiguration(String level, String teacherId) {
// 即使配置本身不包含教师私有数据,也必须校验身份,防止匿名调用教师端路由。
requireTeacherId(teacherId);
return paperManagementService.autoConfiguration(level);
}
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request,
String teacherId, String creatorName) {
String safeTeacherId = requireTeacherId(teacherId);
return paperManagementService.createAutomatic(request, creatorName, safeTeacherId);
}
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request,
String teacherId, String creatorName) {
String safeTeacherId = requireTeacherId(teacherId);
return paperManagementService.createManual(request, creatorName, safeTeacherId);
}
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO update(String paperId, TheoreticalPaperManualSaveDTO request,
String teacherId) {
requireOwnedPaper(paperId, teacherId);
return paperManagementService.update(paperId.trim(), request);
}
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO copy(String paperId, String teacherId, String creatorName) {
String safeTeacherId = requireOwnedPaper(paperId, teacherId);
return paperManagementService.copy(paperId.trim(), creatorName, safeTeacherId);
}
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO changeStatus(String paperId, String status, String teacherId) {
requireOwnedPaper(paperId, teacherId);
return paperManagementService.changeStatus(paperId.trim(), status);
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean delete(String paperId, String teacherId) {
requireOwnedPaper(paperId, teacherId);
return paperManagementService.delete(paperId.trim());
}
/**
* 写操作的统一归属门禁。
*
* <p>creator_id在创建后不允许修改,因此检查通过后可安全委托公共服务按主键加行锁;
* 即使记录在两步之间被并发删除,公共服务也只会返回“不存在”,不会操作其他数据。</p>
*/
private String requireOwnedPaper(String paperId, String teacherId) {
String safePaperId = requirePaperId(paperId);
String safeTeacherId = requireTeacherId(teacherId);
if (paperMapper.countTeacherOwnership(safePaperId, safeTeacherId) != 1) {
throw new BusinessException("试卷不存在或无权访问");
}
return safeTeacherId;
}
/** 与管理员列表保持相同的操作按钮口径。 */
private void decorate(TheoreticalPaperVO paper) {
int usageCount = paper.getUsageCount() == null ? 0 : paper.getUsageCount();
String status = StringUtils.hasText(paper.getStatus())
? paper.getStatus() : TheoreticalPaperAdminConstants.STATUS_PUBLISHED;
paper.setStatus(status);
paper.setUsageCount(usageCount);
paper.setStatusLabel(TheoreticalPaperAdminConstants.STATUS_DRAFT.equals(status)
? "草稿" : TheoreticalPaperAdminConstants.STATUS_ARCHIVED.equals(status)
? "已归档" : "已发布");
paper.setEditable(usageCount == 0);
paper.setDeletable(usageCount == 0
&& !TheoreticalPaperAdminConstants.STATUS_PUBLISHED.equals(status));
}
private String normalizeStatus(String status) {
String normalized = status.trim().toUpperCase(Locale.ROOT);
if (!TheoreticalPaperAdminConstants.STATUSES.contains(normalized)) {
throw new BusinessException("试卷状态只支持DRAFT、PUBLISHED或ARCHIVED");
}
return normalized;
}
private String requireTeacherId(String teacherId) {
if (!StringUtils.hasText(teacherId)) {
throw new BusinessException("无法获取当前教师身份");
}
String normalized = teacherId.trim();
if (normalized.length() > 64) {
throw new BusinessException("教师ID不能超过64个字符");
}
return normalized;
}
private String requirePaperId(String paperId) {
if (!StringUtils.hasText(paperId)) {
throw new BusinessException("试卷ID不能为空");
}
String normalized = paperId.trim();
if (normalized.length() > 64) {
throw new BusinessException("试卷ID不能超过64个字符");
}
return normalized;
}
private String trimOptional(String value, int maxLength, String fieldName) {
if (!StringUtils.hasText(value)) {
return null;
}
String normalized = value.trim();
if (normalized.length() > maxLength) {
throw new BusinessException(fieldName + "不能超过" + maxLength + "个字符");
}
return normalized;
}
}
...@@ -13,6 +13,7 @@ ...@@ -13,6 +13,7 @@
sum, sum,
create_type, create_type,
create_user, create_user,
creator_id,
create_time, create_time,
sequence sequence
from from
...@@ -46,6 +47,7 @@ ...@@ -46,6 +47,7 @@
paper.pass_score, paper.pass_score,
paper.create_type, paper.create_type,
paper.create_user, paper.create_user,
paper.creator_id,
paper.create_time, paper.create_time,
paper.sequence, paper.sequence,
coalesce(paper.status, 'PUBLISHED') as status, coalesce(paper.status, 'PUBLISHED') as status,
...@@ -88,6 +90,63 @@ ...@@ -88,6 +90,63 @@
order by coalesce(paper.update_time, paper.create_time) desc, paper.id desc order by coalesce(paper.update_time, paper.create_time) desc, paper.id desc
</select> </select>
<!--
教师列表与管理员列表返回相同的汇总字段,但必须在最外层主表查询中固定creator_id。
该条件在PageHelper生成分页SQL之前生效,既防止越权数据进入结果,也保证total只统计
当前教师自己的试卷。create_user仅为展示快照,绝不能用于数据权限判断。
-->
<select id="pageTeacher" resultType="com.platform.business.model.vo.TheoreticalPaperVO">
select
paper.id,
paper.lev,
paper.name,
coalesce(question_summary.question_count, paper.num, 0) as num,
paper.sum,
paper.pass_score,
paper.create_type,
paper.create_user,
paper.creator_id,
paper.create_time,
paper.sequence,
coalesce(paper.status, 'PUBLISHED') as status,
paper.update_time,
coalesce(question_summary.question_types, '') as question_types,
coalesce(exam_summary.usage_count, 0) as usage_count
from theoretical_paper paper
left join (
select
detail.paper_id,
count(*) as question_count,
group_concat(
distinct detail.type
order by field(detail.type, '判断题', '单选题', '多选题', '主观题')
separator '/'
) as question_types
from theoretical_paper_detail detail
group by detail.paper_id
) question_summary on question_summary.paper_id = paper.id
left join (
select exam.paper_id, count(*) as usage_count
from exam
where exam.paper_id is not null and exam.paper_id != ''
group by exam.paper_id
) exam_summary on exam_summary.paper_id = paper.id
where paper.creator_id = #{teacherId}
<if test="query.lev != null and query.lev != ''">
and paper.lev = #{query.lev}
</if>
<if test="query.createType != null and query.createType != ''">
and paper.create_type = #{query.createType}
</if>
<if test="query.status != null and query.status != ''">
and coalesce(paper.status, 'PUBLISHED') = #{query.status}
</if>
<if test="query.search != null and query.search != ''">
and paper.name like concat('%', #{query.search}, '%')
</if>
order by coalesce(paper.update_time, paper.create_time) desc, paper.id desc
</select>
<select id="selectAdminDetail" resultType="com.platform.business.model.vo.TheoreticalPaperVO"> <select id="selectAdminDetail" resultType="com.platform.business.model.vo.TheoreticalPaperVO">
select select
paper.id, paper.id,
...@@ -98,6 +157,51 @@ ...@@ -98,6 +157,51 @@
paper.pass_score, paper.pass_score,
paper.create_type, paper.create_type,
paper.create_user, paper.create_user,
paper.creator_id,
paper.create_time,
paper.sequence,
coalesce(paper.status, 'PUBLISHED') as status,
paper.update_time,
coalesce(question_summary.question_types, '') as question_types,
coalesce(exam_summary.usage_count, 0) as usage_count
from theoretical_paper paper
left join (
select
detail.paper_id,
count(*) as question_count,
group_concat(
distinct detail.type
order by field(detail.type, '判断题', '单选题', '多选题', '主观题')
separator '/'
) as question_types
from theoretical_paper_detail detail
where detail.paper_id = #{paperId}
group by detail.paper_id
) question_summary on question_summary.paper_id = paper.id
left join (
select exam.paper_id, count(*) as usage_count
from exam
where exam.paper_id = #{paperId}
group by exam.paper_id
) exam_summary on exam_summary.paper_id = paper.id
where paper.id = #{paperId}
</select>
<!--
教师详情直接在SQL中同时限制主键和creator_id。调用方无法通过枚举ID读取其他教师
的题量、状态或创建信息;题目明细仅会在本查询成功后继续加载。
-->
<select id="selectTeacherDetail" resultType="com.platform.business.model.vo.TheoreticalPaperVO">
select
paper.id,
paper.lev,
paper.name,
coalesce(question_summary.question_count, paper.num, 0) as num,
paper.sum,
paper.pass_score,
paper.create_type,
paper.create_user,
paper.creator_id,
paper.create_time, paper.create_time,
paper.sequence, paper.sequence,
coalesce(paper.status, 'PUBLISHED') as status, coalesce(paper.status, 'PUBLISHED') as status,
...@@ -125,6 +229,7 @@ ...@@ -125,6 +229,7 @@
group by exam.paper_id group by exam.paper_id
) exam_summary on exam_summary.paper_id = paper.id ) exam_summary on exam_summary.paper_id = paper.id
where paper.id = #{paperId} where paper.id = #{paperId}
and paper.creator_id = #{teacherId}
</select> </select>
<select id="selectAdminQuestions" <select id="selectAdminQuestions"
...@@ -142,7 +247,7 @@ ...@@ -142,7 +247,7 @@
<select id="lockAdminPaper" <select id="lockAdminPaper"
resultType="com.platform.business.model.entity.TheoreticalPaperEntity"> resultType="com.platform.business.model.entity.TheoreticalPaperEntity">
select select
id, lev, name, num, sum, pass_score, create_type, create_user, id, lev, name, num, sum, pass_score, create_type, create_user, creator_id,
create_time, sequence, coalesce(status, 'PUBLISHED') as status, update_time create_time, sequence, coalesce(status, 'PUBLISHED') as status, update_time
from theoretical_paper from theoretical_paper
where id = #{paperId} where id = #{paperId}
...@@ -161,4 +266,12 @@ ...@@ -161,4 +266,12 @@
<select id="countAdminUsage" resultType="int"> <select id="countAdminUsage" resultType="int">
select count(*) from exam where paper_id = #{paperId} select count(*) from exam where paper_id = #{paperId}
</select> </select>
<!-- 写操作先做轻量归属检查,后续实际修改仍由公共服务通过行锁和状态条件保护。 -->
<select id="countTeacherOwnership" resultType="int">
select count(*)
from theoretical_paper
where id = #{paperId}
and creator_id = #{teacherId}
</select>
</mapper> </mapper>
-- 管理员端“智能考评-理论试卷管理”增量数据库脚本(MySQL 5.7+/8.0)。 -- 管理员端与教师端“智能考评-理论试卷管理”增量数据库脚本(MySQL 5.7+/8.0)。
-- --
-- 设计说明: -- 设计说明:
-- 1. 复用现有theoretical_paper、theoretical_paper_detail和exam表,不复制业务数据。 -- 1. 复用现有theoretical_paper、theoretical_paper_detail和exam表,不复制业务数据。
-- 2. 新增及格分、发布状态和更新时间;历史试卷默认视为已发布,避免升级后从考试选项消失。 -- 2. 新增及格分、发布状态、更新时间和稳定创建教师ID;create_user继续作为可读历史快照。
-- 3. 所有DDL先查询information_schema,可在开发、测试和生产环境重复执行。 -- 3. 历史试卷默认视为已发布,仅在create_user唯一匹配手机号时安全认领给对应用户。
-- 4. 沿用项目现状不新增外键;服务层在编辑、复制和删除事务中校验exam引用关系。 -- 4. 所有DDL先查询information_schema,可在开发、测试和生产环境重复执行。
-- 5. 沿用项目现状不新增外键;服务层在编辑、复制和删除事务中校验归属及exam引用关系。
delimiter $$ delimiter $$
...@@ -31,6 +32,18 @@ begin ...@@ -31,6 +32,18 @@ begin
add column status varchar(20) null comment 'DRAFT/PUBLISHED/ARCHIVED' after sequence; add column status varchar(20) null comment 'DRAFT/PUBLISHED/ARCHIVED' after sequence;
end if; end if;
if not exists (
select 1 from information_schema.columns
where table_schema = database()
and table_name = 'theoretical_paper'
and column_name = 'creator_id'
) then
alter table theoretical_paper
add column creator_id varchar(64) null
comment '创建教师用户ID;教师端数据权限依据,管理员创建或未认领历史数据为空'
after create_user;
end if;
if not exists ( if not exists (
select 1 from information_schema.columns select 1 from information_schema.columns
where table_schema = database() where table_schema = database()
...@@ -62,6 +75,18 @@ begin ...@@ -62,6 +75,18 @@ begin
add index idx_theoretical_paper_detail_paper (paper_id, type, sequence); add index idx_theoretical_paper_detail_paper (paper_id, type, sequence);
end if; end if;
if not exists (
select 1 from information_schema.statistics
where table_schema = database()
and table_name = 'theoretical_paper'
and index_name = 'idx_theoretical_paper_creator_status_time'
) then
-- 教师试卷库固定按creator_id过滤,再按状态和更新时间分页排序。
alter table theoretical_paper
add index idx_theoretical_paper_creator_status_time
(creator_id, status, update_time, id);
end if;
-- 使用次数、编辑和删除保护均按paper_id检查考试引用。 -- 使用次数、编辑和删除保护均按paper_id检查考试引用。
if not exists ( if not exists (
select 1 from information_schema.statistics select 1 from information_schema.statistics
...@@ -94,11 +119,34 @@ set pass_score = coalesce(pass_score, round(coalesce(sum, 0) * 0.60, 2)), ...@@ -94,11 +119,34 @@ set pass_score = coalesce(pass_score, round(coalesce(sum, 0) * 0.60, 2)),
status = coalesce(nullif(trim(status), ''), 'PUBLISHED'), status = coalesce(nullif(trim(status), ''), 'PUBLISHED'),
update_time = coalesce(update_time, create_time, now()); update_time = coalesce(update_time, create_time, now());
--
-- 安全认领历史教师试卷:旧/create接口把JWT中的手机号写入create_user,因此只有该值
-- 在user.phone_number中恰好唯一匹配时才回填稳定用户ID。姓名、账号和重复手机号均不做
-- 猜测,避免把试卷误分配给其他教师;已经写入creator_id的新数据也不会被覆盖。
--
update theoretical_paper paper
inner join (
select phone_number, min(id) as creator_id
from user
where phone_number is not null
and trim(phone_number) != ''
group by phone_number
having count(*) = 1
) matched_user on matched_user.phone_number = trim(paper.create_user)
set paper.creator_id = matched_user.creator_id
where paper.creator_id is null or trim(paper.creator_id) = '';
-- 只读核查:执行后若有结果,需要人工修复空试卷、非法状态或及格分配置。 -- 只读核查:执行后若有结果,需要人工修复空试卷、非法状态或及格分配置。
select id, name, num, sum, pass_score, status select id, name, num, sum, pass_score, status, creator_id
from theoretical_paper from theoretical_paper
where coalesce(num, 0) <= 0 where coalesce(num, 0) <= 0
or coalesce(sum, 0) <= 0 or coalesce(sum, 0) <= 0
or pass_score < 0 or pass_score < 0
or pass_score > sum or pass_score > sum
or status not in ('DRAFT', 'PUBLISHED', 'ARCHIVED'); or status not in ('DRAFT', 'PUBLISHED', 'ARCHIVED');
-- 只读核查:这些历史试卷没有被安全认领,仍可由管理员查看和维护,但不会出现在教师列表。
select id, name, create_user, create_time
from theoretical_paper
where creator_id is null or trim(creator_id) = ''
order by create_time desc, id desc;
# 教师端理论试卷管理接口
页面路径为“教师 → 智能考评 → 理论试卷管理”,接口统一使用
`/theoretical/paper` 前缀。所有请求必须携带 `Authorization`。服务端从JWT解析当前用户、
校验“教师”角色,并只允许访问 `creator_id` 等于当前教师ID的试卷;请求体中的用户字段
不会参与权限判断。
部署或升级前执行以下幂等脚本:
```text
practical-business/src/main/resources/sql/theoretical_paper_management.sql
```
脚本会增加教师归属字段和查询索引,并仅把 `create_user` 唯一匹配用户手机号的历史试卷
安全认领给对应用户。未匹配数据仍可由管理员维护,不会出现在任何教师的列表中。
状态代码为 `DRAFT`(草稿)、`PUBLISHED`(已发布)、`ARCHIVED`(已归档)。教师可以
直接发布本人试卷;试卷被考试计划引用后不能改题、删除或退回草稿,但仍可复制和归档。
## 1. 本人试卷分页
`POST /theoretical/paper/page`
```json
{
"pageNum": 1,
"pageSize": 10,
"search": "污水一级",
"lev": "污水一级",
"createType": "自动组卷",
"status": "PUBLISHED"
}
```
返回项目统一 `TableDataInfo`。每行包含题型汇总 `questionTypes`、考试引用次数
`usageCount`、状态中文名 `statusLabel`、可编辑标记 `editable`、可删除标记
`deletable` 和稳定归属字段 `creatorId`。分页总数只统计当前教师数据。
## 2. 自动组卷
规则预览:
`GET /theoretical/paper/auto-configuration?lev=污水三级`
确认创建:
`POST /theoretical/paper/auto`
```json
{
"lev": "污水三级",
"name": "污水三级·教师练习卷",
"passScore": 60,
"sequence": "乱序",
"status": "DRAFT"
}
```
题量、抽题分布和配分只读取提交瞬间的数据库配置。题库不足、抽到重复题或规则不完整时
整个事务回滚,不会留下空试卷。状态为空时默认草稿,及格分为空时按总分60%计算。
## 3. 手动组卷
`POST /theoretical/paper/manual`
```json
{
"lev": "污水一级",
"name": "污水一级·课堂测验 A",
"passScore": 60,
"sequence": "顺序",
"status": "DRAFT",
"questions": [
{
"type": "单选题",
"problem": "示例题干",
"optionA": "选项A",
"optionB": "选项B",
"optionC": "选项C",
"optionD": "选项D",
"answer": "A",
"score": 2
}
]
}
```
支持判断题、单选题、多选题和主观题。服务端丢弃题目中的 `id`、`paperId` 和题号,
按数组顺序重新编号,并重新计算题量、总分和及格分;同一试卷不允许重复题目。
## 4. 详情、编辑、复制和状态
- `GET /theoretical/paper/{paperId}`:本人试卷预览或编辑回显。
- `PUT /theoretical/paper/{paperId}`:请求体同手动组卷;已被考试引用时禁止编辑。
- `POST /theoretical/paper/{paperId}/copy`:深复制为当前教师的新草稿,名称自动追加副本。
- `PUT /theoretical/paper/{paperId}/status`:请求体为 `{"status":"ARCHIVED"}`。
详情和所有写操作对“不存在”和“非本人试卷”统一返回“试卷不存在或无权访问”,避免通过
试卷ID探测其他教师数据。复制只允许复制本人试卷,新副本固定归属于当前教师。
## 5. 删除和导出
- `DELETE /theoretical/paper/{paperId}`:仅允许删除本人未发布且未被考试使用的试卷。
- `GET /theoretical/paper/{paperId}/export`:导出无答案Word。
- `GET /theoretical/paper/{paperId}/export/answer`:导出带答案Word。
导出前同样执行教师归属校验。Word继续使用项目现有职级模板;当前模板覆盖判断题、单选题
和多选题,包含主观题的试卷应以前端预览为准。
## 6. 旧页面兼容路径
- `GET /theoretical/paper/auto` 等同规则预览接口。
- `POST /theoretical/paper/create` 接收旧 `CombinationDTO`,但忽略客户端 `num`、`sum`、
`createUser`、抽题分布和配分规则,服务端重新读取数据库规则;为保持历史行为固定创建
`PUBLISHED` 试卷,并继续返回布尔型 `data`。
- `GET /theoretical/paper/detail/{paperId}` 为详情别名。
- `GET /theoretical/paper/export/{paperId}` 和
`GET /theoretical/paper/export/answer/{paperId}` 为导出别名。
所有兼容路径都执行与新接口完全相同的JWT教师鉴权和数据归属校验。
package com.platform.business.controller;
import com.platform.business.constant.TheoreticalPaperAdminConstants;
import com.platform.business.model.dto.CombinationDTO;
import com.platform.business.model.dto.TheoreticalPaperAutoSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperDTO;
import com.platform.business.model.dto.TheoreticalPaperManualSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperStatusDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.TheoreticalPaperService;
import com.platform.business.service.TheoreticalPaperTeacherService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 教师理论试卷控制器的角色鉴权、可信身份、兼容转换和分页边界测试。 */
@ExtendWith(MockitoExtension.class)
class TheoreticalPaperControllerTest {
@Mock
private TheoreticalPaperTeacherService paperTeacherService;
@Mock
private TheoreticalPaperService legacyPaperService;
@Mock
private AuthenticatedUserService authenticatedUserService;
private TheoreticalPaperController controller;
@BeforeEach
void setUp() {
controller = new TheoreticalPaperController();
ReflectionTestUtils.setField(controller, "paperTeacherService", paperTeacherService);
ReflectionTestUtils.setField(controller, "legacyPaperService", legacyPaperService);
ReflectionTestUtils.setField(controller, "authenticatedUserService", authenticatedUserService);
}
@Test
void everyEndpointShouldRequireTeacherAndUseJwtIdentity() {
MockHttpServletRequest request = new MockHttpServletRequest();
MockHttpServletResponse response = new MockHttpServletResponse();
UserEntity teacher = teacher();
when(authenticatedUserService.current(request)).thenReturn(teacher);
when(paperTeacherService.page(any(), any())).thenReturn(Collections.emptyList());
TheoreticalPaperDTO query = new TheoreticalPaperDTO();
TheoreticalPaperAutoSaveDTO automatic = new TheoreticalPaperAutoSaveDTO();
CombinationDTO legacy = new CombinationDTO();
legacy.setLev("污水一级");
legacy.setName("旧页面试卷");
TheoreticalPaperManualSaveDTO manual = new TheoreticalPaperManualSaveDTO();
TheoreticalPaperStatusDTO status = new TheoreticalPaperStatusDTO();
status.setStatus("ARCHIVED");
controller.page(query, request);
controller.autoConfiguration("污水一级", request);
controller.createAutomatic(automatic, request);
controller.createLegacy(legacy, request);
controller.createManual(manual, request);
controller.detail("paper-1", request);
controller.update("paper-1", manual, request);
controller.copy("paper-1", request);
controller.changeStatus("paper-1", status, request);
controller.delete("paper-1", request);
controller.export("paper-1", request, response);
controller.exportWithAnswer("paper-1", request, response);
verify(authenticatedUserService, times(12)).requireTeacher(teacher);
verify(paperTeacherService).createAutomatic(automatic, "teacher-1", "教师甲");
verify(paperTeacherService).createManual(manual, "teacher-1", "教师甲");
verify(paperTeacherService).copy("paper-1", "teacher-1", "教师甲");
verify(paperTeacherService, times(3)).detail("paper-1", "teacher-1");
verify(legacyPaperService).export("paper-1", response);
verify(legacyPaperService).exportWithAnswer("paper-1", response);
}
@Test
void legacyCreateShouldIgnoreClientCalculatedAndIdentityFields() {
MockHttpServletRequest request = new MockHttpServletRequest();
UserEntity teacher = teacher();
when(authenticatedUserService.current(request)).thenReturn(teacher);
CombinationDTO legacy = new CombinationDTO();
legacy.setLev("污水二级");
legacy.setName("兼容试卷");
legacy.setSequence("乱序");
legacy.setNum(999);
legacy.setSum(999D);
legacy.setCreateUser("伪造用户");
controller.createLegacy(legacy, request);
ArgumentCaptor<TheoreticalPaperAutoSaveDTO> captor =
ArgumentCaptor.forClass(TheoreticalPaperAutoSaveDTO.class);
verify(paperTeacherService).createAutomatic(captor.capture(),
org.mockito.Mockito.eq("teacher-1"), org.mockito.Mockito.eq("教师甲"));
TheoreticalPaperAutoSaveDTO converted = captor.getValue();
assertEquals("污水二级", converted.getLev());
assertEquals("兼容试卷", converted.getName());
assertEquals("乱序", converted.getSequence());
assertEquals(TheoreticalPaperAdminConstants.STATUS_PUBLISHED, converted.getStatus());
assertNull(converted.getPassScore());
}
@Test
void normalizePageShouldApplyDefaultsAndCapMaximum() {
TheoreticalPaperDTO query = new TheoreticalPaperDTO();
query.setPageNum(0);
query.setPageSize(1000);
controller.normalizePage(query);
assertEquals(1, query.getPageNum());
assertEquals(100, query.getPageSize());
}
@Test
void nonTeacherShouldStopBeforePaperService() {
MockHttpServletRequest request = new MockHttpServletRequest();
UserEntity student = new UserEntity();
when(authenticatedUserService.current(request)).thenReturn(student);
doThrow(new BusinessException("只有教师可以访问教师端接口"))
.when(authenticatedUserService).requireTeacher(student);
assertThrows(BusinessException.class,
() -> controller.detail("paper-1", request));
}
private UserEntity teacher() {
UserEntity teacher = new UserEntity();
teacher.setId("teacher-1");
teacher.setNickName("教师甲");
return teacher;
}
}
...@@ -9,7 +9,7 @@ import java.io.InputStream; ...@@ -9,7 +9,7 @@ import java.io.InputStream;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
/** 在应用启动前验证管理员试卷聚合、锁定和引用检查SQL能够被MyBatis完整解析。 */ /** 在应用启动前验证管理员/教师试卷聚合、归属、锁定和引用检查SQL能够被MyBatis完整解析。 */
class TheoreticalPaperMapperXmlTest { class TheoreticalPaperMapperXmlTest {
@Test @Test
...@@ -30,5 +30,11 @@ class TheoreticalPaperMapperXmlTest { ...@@ -30,5 +30,11 @@ class TheoreticalPaperMapperXmlTest {
"com.platform.business.mapper.TheoreticalPaperMapper.lockAdminPaper")); "com.platform.business.mapper.TheoreticalPaperMapper.lockAdminPaper"));
assertTrue(configuration.hasStatement( assertTrue(configuration.hasStatement(
"com.platform.business.mapper.TheoreticalPaperMapper.countAdminUsage")); "com.platform.business.mapper.TheoreticalPaperMapper.countAdminUsage"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.TheoreticalPaperMapper.pageTeacher"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.TheoreticalPaperMapper.selectTeacherDetail"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.TheoreticalPaperMapper.countTeacherOwnership"));
} }
} }
...@@ -24,6 +24,7 @@ import java.util.Collections; ...@@ -24,6 +24,7 @@ import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
...@@ -75,10 +76,37 @@ class TheoreticalPaperAdminServiceImplTest { ...@@ -75,10 +76,37 @@ class TheoreticalPaperAdminServiceImplTest {
assertEquals(2.0D, paperCaptor.getValue().getSum()); assertEquals(2.0D, paperCaptor.getValue().getSum());
assertEquals(1.2D, paperCaptor.getValue().getPassScore()); assertEquals(1.2D, paperCaptor.getValue().getPassScore());
assertEquals("管理员甲", paperCaptor.getValue().getCreateUser()); assertEquals("管理员甲", paperCaptor.getValue().getCreateUser());
assertNull(paperCaptor.getValue().getCreatorId());
assertEquals("DRAFT", paperCaptor.getValue().getStatus()); assertEquals("DRAFT", paperCaptor.getValue().getStatus());
assertEquals("paper-new", result.getId()); assertEquals("paper-new", result.getId());
} }
@Test
void teacherManualCreateShouldPersistTrustedCreatorIdWithMainRecord() {
TheoreticalPaperManualSaveDTO request = manualRequest("教师试卷");
when(paperMapper.countAdminDuplicateName("教师试卷", null)).thenReturn(0);
when(paperMapper.insert(any(TheoreticalPaperEntity.class))).thenAnswer(invocation -> {
TheoreticalPaperEntity paper = invocation.getArgument(0);
paper.setId("paper-teacher");
return 1;
});
when(paperDetailService.saveBatch(any())).thenReturn(true);
TheoreticalPaperVO saved = new TheoreticalPaperVO();
saved.setId("paper-teacher");
saved.setStatus("DRAFT");
saved.setCreatorId("teacher-1");
when(paperMapper.selectAdminDetail("paper-teacher")).thenReturn(saved);
when(paperMapper.selectAdminQuestions("paper-teacher")).thenReturn(request.getQuestions());
service.createManual(request, "教师甲", "teacher-1");
ArgumentCaptor<TheoreticalPaperEntity> paperCaptor =
ArgumentCaptor.forClass(TheoreticalPaperEntity.class);
verify(paperMapper).insert(paperCaptor.capture());
assertEquals("教师甲", paperCaptor.getValue().getCreateUser());
assertEquals("teacher-1", paperCaptor.getValue().getCreatorId());
}
@Test @Test
void automaticCreateShouldRejectWhenQuestionBankIsInsufficient() { void automaticCreateShouldRejectWhenQuestionBankIsInsufficient() {
TheoreticalPaperAutoSaveDTO request = new TheoreticalPaperAutoSaveDTO(); TheoreticalPaperAutoSaveDTO request = new TheoreticalPaperAutoSaveDTO();
......
package com.platform.business.service.impl;
import com.platform.business.mapper.TheoreticalPaperMapper;
import com.platform.business.model.dto.TheoreticalPaperAutoSaveDTO;
import com.platform.business.model.dto.TheoreticalPaperDTO;
import com.platform.business.model.dto.TheoreticalPaperManualSaveDTO;
import com.platform.business.model.vo.TheoreticalPaperVO;
import com.platform.business.service.TheoreticalPaperAdminService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 教师试卷服务的数据隔离、归属写入和公共业务规则委托测试。 */
@ExtendWith(MockitoExtension.class)
class TheoreticalPaperTeacherServiceImplTest {
@Mock
private TheoreticalPaperMapper paperMapper;
@Mock
private TheoreticalPaperAdminService paperManagementService;
@InjectMocks
private TheoreticalPaperTeacherServiceImpl service;
@Test
void pageShouldQueryOnlyCurrentTeacherAndDecorateRows() {
TheoreticalPaperDTO query = new TheoreticalPaperDTO();
query.setStatus("draft");
TheoreticalPaperVO row = new TheoreticalPaperVO();
row.setStatus("DRAFT");
row.setUsageCount(0);
when(paperMapper.pageTeacher(query, "teacher-1"))
.thenReturn(Collections.singletonList(row));
TheoreticalPaperVO result = service.page(query, "teacher-1").get(0);
assertEquals("DRAFT", query.getStatus());
assertEquals("草稿", result.getStatusLabel());
assertFalse(Boolean.FALSE.equals(result.getEditable()));
verify(paperMapper).pageTeacher(query, "teacher-1");
}
@Test
void detailShouldHideWhetherPaperDoesNotExistOrBelongsToAnotherTeacher() {
when(paperMapper.selectTeacherDetail("paper-2", "teacher-1")).thenReturn(null);
BusinessException error = assertThrows(BusinessException.class,
() -> service.detail("paper-2", "teacher-1"));
assertEquals("试卷不存在或无权访问", error.getMessage());
verify(paperMapper, never()).selectAdminQuestions(any());
}
@Test
void createMethodsShouldPassTrustedTeacherIdToSharedManagementService() {
TheoreticalPaperAutoSaveDTO automatic = new TheoreticalPaperAutoSaveDTO();
TheoreticalPaperManualSaveDTO manual = new TheoreticalPaperManualSaveDTO();
service.createAutomatic(automatic, "teacher-1", "教师甲");
service.createManual(manual, "teacher-1", "教师甲");
verify(paperManagementService).createAutomatic(automatic, "教师甲", "teacher-1");
verify(paperManagementService).createManual(manual, "教师甲", "teacher-1");
}
@Test
void writeShouldStopBeforeSharedServiceWhenPaperIsNotOwned() {
when(paperMapper.countTeacherOwnership("paper-2", "teacher-1")).thenReturn(0);
BusinessException error = assertThrows(BusinessException.class,
() -> service.update("paper-2", new TheoreticalPaperManualSaveDTO(), "teacher-1"));
assertEquals("试卷不存在或无权访问", error.getMessage());
verify(paperManagementService, never()).update(any(), any());
}
@Test
void copyShouldCreateNewDraftForCurrentTeacherRatherThanSourceOwner() {
when(paperMapper.countTeacherOwnership("paper-1", "teacher-1")).thenReturn(1);
service.copy("paper-1", "teacher-1", "教师甲");
verify(paperManagementService).copy("paper-1", "教师甲", "teacher-1");
}
}
package com.platform.business.sql;
import org.junit.jupiter.api.Test;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** 验证部署脚本包含教师归属字段、主查询索引、安全历史回填和未认领数据核查。 */
class TheoreticalPaperMigrationSqlTest {
@Test
void migrationShouldContainIdempotentTeacherOwnershipChanges() throws Exception {
String resource = "sql/theoretical_paper_management.sql";
String sql;
try (InputStream input = Thread.currentThread().getContextClassLoader()
.getResourceAsStream(resource)) {
assertTrue(input != null, "迁移SQL资源必须存在");
byte[] bytes = new byte[8192];
StringBuilder content = new StringBuilder();
int length;
while ((length = input.read(bytes)) >= 0) {
content.append(new String(bytes, 0, length, StandardCharsets.UTF_8));
}
sql = content.toString().toLowerCase();
}
assertTrue(sql.contains("column_name = 'creator_id'"));
assertTrue(sql.contains("idx_theoretical_paper_creator_status_time"));
assertTrue(sql.contains("group by phone_number"));
assertTrue(sql.contains("having count(*) = 1"));
assertTrue(sql.contains("where creator_id is null or trim(creator_id) = ''"));
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment