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

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

parent cc90e7f5
......@@ -53,6 +53,17 @@ public class TheoreticalPaperEntity {
@TableField("create_user")
private String createUser;
/**
* 创建教师的稳定用户ID。
*
* <p>create_user继续保存用于页面展示的名称或历史手机号快照,不能作为权限依据;
* 教师端所有数据隔离均使用本字段与JWT解析出的用户ID进行精确比较。管理员创建的
* 试卷以及无法安全认领的历史试卷允许为空。</p>
*/
@ApiModelProperty("创建教师ID;管理员创建或未认领历史数据为空")
@TableField("creator_id")
private String creatorId;
@ApiModelProperty("创建时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm", timezone = "GMT+8")
@TableField("create_time")
......
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.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.model.vo.CombinationVO;
import com.platform.business.model.vo.TheoreticalPaperVO;
import com.platform.business.service.AuthenticatedUserService;
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.model.resp.Result;
import com.platform.page.TableDataInfo;
import io.swagger.annotations.Api;
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.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author : wujipeng
* @date : 2025/11/3 14:01
* @Version: 1.0
* @Desc : 理论试卷管理
* 教师端“智能考评-理论试卷管理”接口。
*
* <p>保留历史页面使用的/page、/auto、/create、/detail和/export路径,同时提供完整的
* REST接口。所有入口都从Authorization解析当前教师,不接收客户端teacherId;服务层
* 再按theoretical_paper.creator_id校验归属,形成角色与数据范围两层保护。</p>
*/
@Api(tags = "理论试卷管理")
@Api(tags = "教师端-理论试卷管理")
@RestController
@RequestMapping("/theoretical/paper")
public class TheoreticalPaperController extends BaseController {
@Resource
private JwtTokenUtil jwtTokenUtil;
private TheoreticalPaperTeacherService paperTeacherService;
/** Word导出继续复用现有模板实现,导出前必须先通过教师服务的归属校验。 */
@Resource
private TheoreticalPaperService legacyPaperService;
@Resource
private TheoreticalPaperService theoreticalPaperService;
private AuthenticatedUserService authenticatedUserService;
@ApiOperation("分页查询当前教师创建的试卷")
@PostMapping("/page")
public TableDataInfo pageData(@RequestBody TheoreticalPaperDTO theoreticalPaperDTO) {
startPage(theoreticalPaperDTO.getPageNum(), theoreticalPaperDTO.getPageSize());
return getDataTable(theoreticalPaperService.pageData(theoreticalPaperDTO));
public TableDataInfo page(@RequestBody(required = false) TheoreticalPaperDTO query,
HttpServletRequest request) {
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("自动组卷")
public Result<CombinationVO> auto(@RequestParam(name = "lev") String lev) {
return Result.data(theoreticalPaperService.auto(lev));
@ApiOperation("查询自动组卷规则预览;/auto为旧页面兼容路径")
@GetMapping({"/auto-configuration", "/auto"})
public Result<CombinationVO> autoConfiguration(@RequestParam("lev") String level,
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")
@ApiOperation("创建试卷")
public Result<Boolean> create(@RequestBody CombinationDTO combinationDTO, HttpServletRequest httpServletRequest) {
String token = httpServletRequest.getHeader("Authorization");
String userName = jwtTokenUtil.getUsernameFromToken(token);
combinationDTO.setCreateUser(userName);
return Result.data(theoreticalPaperService.create(combinationDTO));
public Result<Boolean> createLegacy(@RequestBody CombinationDTO body,
HttpServletRequest request) {
UserEntity teacher = currentTeacher(request);
// 旧页面只识别布尔data,因此保留响应形态;创建失败仍由统一业务异常返回。
paperTeacherService.createAutomatic(
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("详情")
@GetMapping("/detail/{id}")
public Result<TheoreticalPaperVO> detail(@PathVariable(name = "id") String id) {
return Result.data(theoreticalPaperService.detail(id));
/** 缺省第1页、每页10条,单次最多100条,避免题型聚合查询返回过多数据。 */
void normalizePage(TheoreticalPaperDTO query) {
int pageNum = query.getPageNum() == null || query.getPageNum() < 1 ? 1 : query.getPageNum();
int pageSize = query.getPageSize() == null || query.getPageSize() < 1
? 10 : Math.min(query.getPageSize(), 100);
query.setPageNum(pageNum);
query.setPageSize(pageSize);
}
@ApiOperation("导出")
@GetMapping("/export/{id}")
public void export(@PathVariable String id, HttpServletResponse response) {
theoreticalPaperService.export(id, response);
/**
* 把旧CombinationDTO转换为可信的新请求。
*
* <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}")
public void exportWithAnswer(@PathVariable String id, HttpServletResponse response) {
theoreticalPaperService.exportWithAnswer(id, response);
/** 从令牌解析登录用户并校验教师角色,普通学员不能调用任何兼容旧路由。 */
private UserEntity currentTeacher(HttpServletRequest request) {
UserEntity teacher = authenticatedUserService.current(request);
authenticatedUserService.requireTeacher(teacher);
return teacher;
}
@ApiOperation("删除")
@DeleteMapping("/{id}")
public Result<Boolean> delete(@PathVariable String id) {
return Result.data(theoreticalPaperService.delete(id));
/** 创建人仅作为可读快照,权限始终使用teacher.id;账号字段不全时逐级降级。 */
private String displayName(UserEntity teacher) {
if (StringUtils.hasText(teacher.getNickName())) {
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
/** 管理端列表额外汇总题型和考试引用次数。 */
List<TheoreticalPaperVO> pageAdmin(TheoreticalPaperDTO query);
/** 教师列表在SQL层按稳定用户ID隔离,分页前不会混入其他教师数据。 */
List<TheoreticalPaperVO> pageTeacher(@Param("query") TheoreticalPaperDTO query,
@Param("teacherId") String teacherId);
/** 查询管理端详情主记录;题目列表由独立查询加载,避免一对多结果重复主对象。 */
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(
@Param("paperId") String paperId);
......@@ -37,4 +45,8 @@ public interface TheoreticalPaperMapper extends BaseMapper<TheoreticalPaperEntit
@Param("excludeId") String excludeId);
int countAdminUsage(@Param("paperId") String paperId);
/** 写操作委托公共管理服务前执行不可伪造的归属检查。 */
int countTeacherOwnership(@Param("paperId") String paperId,
@Param("teacherId") String teacherId);
}
......@@ -19,12 +19,26 @@ public interface TheoreticalPaperAdminService {
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,
String creatorId);
TheoreticalPaperVO update(String paperId, TheoreticalPaperManualSaveDTO request);
TheoreticalPaperVO copy(String paperId, String creatorName);
/** 深复制试卷并把新副本归属到当前教师,原试卷归属不会被继承。 */
TheoreticalPaperVO copy(String paperId, String creatorName, String creatorId);
TheoreticalPaperVO changeStatus(String paperId, String status);
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
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createAutomatic(TheoreticalPaperAutoSaveDTO request,
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) {
throw new BusinessException("自动组卷信息不能为空");
}
......@@ -184,17 +197,26 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
PreparedQuestions prepared = prepareQuestions(questions);
BigDecimal passScore = normalizePassScore(request.getPassScore(), prepared.totalScore);
return createPaper(level, name, passScore, sequence, status, "自动组卷",
creatorName, prepared.questions, prepared.totalScore);
creatorName, creatorId, prepared.questions, prepared.totalScore);
}
@Override
@Transactional(rollbackFor = Exception.class)
public TheoreticalPaperVO createManual(TheoreticalPaperManualSaveDTO request,
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);
ensureUniqueName(prepared.name, null);
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
......@@ -239,6 +261,16 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
@Override
@Transactional(rollbackFor = Exception.class)
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);
List<TheoreticalPaperDetailEntity> sourceQuestions = paperMapper.selectAdminQuestions(source.getId());
PreparedQuestions prepared = prepareQuestions(sourceQuestions);
......@@ -247,7 +279,7 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
BigDecimal passScore = normalizePassScore(source.getPassScore(), totalScore);
return createPaper(source.getLev(), copyName, passScore,
normalizeSequence(source.getSequence()), TheoreticalPaperAdminConstants.STATUS_DRAFT,
"复制组卷", creatorName, prepared.questions, totalScore);
"复制组卷", creatorName, creatorId, prepared.questions, totalScore);
}
@Override
......@@ -301,7 +333,7 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
/** 保存主表和题目明细;方法只接收已经过完整校验和重新计算的数据。 */
private TheoreticalPaperVO createPaper(String level, String name, BigDecimal passScore,
String sequence, String status, String createType,
String creatorName,
String creatorName, String creatorId,
List<TheoreticalPaperDetailEntity> questions,
BigDecimal totalScore) {
TheoreticalPaperEntity paper = new TheoreticalPaperEntity();
......@@ -312,6 +344,8 @@ public class TheoreticalPaperAdminServiceImpl implements TheoreticalPaperAdminSe
paper.setPassScore(passScore.setScale(2, RoundingMode.HALF_UP).doubleValue());
paper.setCreateType(createType);
paper.setCreateUser(requireText(creatorName, 100, "创建人"));
// creatorId不接受请求体字段,只保存控制器从可信JWT身份传入的值。
paper.setCreatorId(trimOptional(creatorId, 64, "创建人ID"));
Date now = new Date();
paper.setCreateTime(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 @@
sum,
create_type,
create_user,
creator_id,
create_time,
sequence
from
......@@ -46,6 +47,7 @@
paper.pass_score,
paper.create_type,
paper.create_user,
paper.creator_id,
paper.create_time,
paper.sequence,
coalesce(paper.status, 'PUBLISHED') as status,
......@@ -88,6 +90,63 @@
order by coalesce(paper.update_time, paper.create_time) desc, paper.id desc
</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
paper.id,
......@@ -98,6 +157,51 @@
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
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.sequence,
coalesce(paper.status, 'PUBLISHED') as status,
......@@ -125,6 +229,7 @@
group by exam.paper_id
) exam_summary on exam_summary.paper_id = paper.id
where paper.id = #{paperId}
and paper.creator_id = #{teacherId}
</select>
<select id="selectAdminQuestions"
......@@ -142,7 +247,7 @@
<select id="lockAdminPaper"
resultType="com.platform.business.model.entity.TheoreticalPaperEntity">
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
from theoretical_paper
where id = #{paperId}
......@@ -161,4 +266,12 @@
<select id="countAdminUsage" resultType="int">
select count(*) from exam where paper_id = #{paperId}
</select>
<!-- 写操作先做轻量归属检查,后续实际修改仍由公共服务通过行锁和状态条件保护。 -->
<select id="countTeacherOwnership" resultType="int">
select count(*)
from theoretical_paper
where id = #{paperId}
and creator_id = #{teacherId}
</select>
</mapper>
-- 管理员端“智能考评-理论试卷管理”增量数据库脚本(MySQL 5.7+/8.0)。
-- 管理员端与教师端“智能考评-理论试卷管理”增量数据库脚本(MySQL 5.7+/8.0)。
--
-- 设计说明:
-- 1. 复用现有theoretical_paper、theoretical_paper_detail和exam表,不复制业务数据。
-- 2. 新增及格分、发布状态和更新时间;历史试卷默认视为已发布,避免升级后从考试选项消失。
-- 3. 所有DDL先查询information_schema,可在开发、测试和生产环境重复执行。
-- 4. 沿用项目现状不新增外键;服务层在编辑、复制和删除事务中校验exam引用关系。
-- 2. 新增及格分、发布状态、更新时间和稳定创建教师ID;create_user继续作为可读历史快照。
-- 3. 历史试卷默认视为已发布,仅在create_user唯一匹配手机号时安全认领给对应用户。
-- 4. 所有DDL先查询information_schema,可在开发、测试和生产环境重复执行。
-- 5. 沿用项目现状不新增外键;服务层在编辑、复制和删除事务中校验归属及exam引用关系。
delimiter $$
......@@ -31,6 +32,18 @@ begin
add column status varchar(20) null comment 'DRAFT/PUBLISHED/ARCHIVED' after sequence;
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 (
select 1 from information_schema.columns
where table_schema = database()
......@@ -62,6 +75,18 @@ begin
add index idx_theoretical_paper_detail_paper (paper_id, type, sequence);
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检查考试引用。
if not exists (
select 1 from information_schema.statistics
......@@ -94,11 +119,34 @@ set pass_score = coalesce(pass_score, round(coalesce(sum, 0) * 0.60, 2)),
status = coalesce(nullif(trim(status), ''), 'PUBLISHED'),
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
where coalesce(num, 0) <= 0
or coalesce(sum, 0) <= 0
or pass_score < 0
or pass_score > sum
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;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** 在应用启动前验证管理员试卷聚合、锁定和引用检查SQL能够被MyBatis完整解析。 */
/** 在应用启动前验证管理员/教师试卷聚合、归属、锁定和引用检查SQL能够被MyBatis完整解析。 */
class TheoreticalPaperMapperXmlTest {
@Test
......@@ -30,5 +30,11 @@ class TheoreticalPaperMapperXmlTest {
"com.platform.business.mapper.TheoreticalPaperMapper.lockAdminPaper"));
assertTrue(configuration.hasStatement(
"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;
import static org.junit.jupiter.api.Assertions.assertEquals;
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.assertTrue;
import static org.mockito.ArgumentMatchers.any;
......@@ -75,10 +76,37 @@ class TheoreticalPaperAdminServiceImplTest {
assertEquals(2.0D, paperCaptor.getValue().getSum());
assertEquals(1.2D, paperCaptor.getValue().getPassScore());
assertEquals("管理员甲", paperCaptor.getValue().getCreateUser());
assertNull(paperCaptor.getValue().getCreatorId());
assertEquals("DRAFT", paperCaptor.getValue().getStatus());
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
void automaticCreateShouldRejectWhenQuestionBankIsInsufficient() {
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