Commit b98ba531 authored by wujipeng's avatar wujipeng
Browse files

优化

parent dedf77a4
......@@ -14,7 +14,7 @@ public class PracticePaperRuleQueryDTO {
@ApiModelProperty("规则名称关键字")
private String name;
@ApiModelProperty("标准等级:一级至五级")
@ApiModelProperty("完整职级:污水一级至五级或污泥一级至五级")
private String lev;
@ApiModelProperty("状态:DRAFT/PUBLISHED")
......
......@@ -9,10 +9,10 @@ import java.util.List;
@Data
public class PracticePaperRuleSaveDTO {
@ApiModelProperty("规则名称;同一标准等级内不能重复")
@ApiModelProperty("规则名称;同一完整职级内不能重复")
private String name;
@ApiModelProperty("使用职级;支持一级或污水一级/污泥一级等以标准等级结尾的名称")
@ApiModelProperty("使用完整职级;仅支持系统中启用的污水一级至五级或污泥一级至五级")
private String lev;
@ApiModelProperty("该等级完整规则列表,类目必须与服务端Excel标准类目完全对应")
......
......@@ -19,6 +19,7 @@ public class PracticePaperRuleDefinitionEntity {
private String name;
/** 完整职级名称;字段名沿用历史结构,但不再只保存一级至五级后缀。 */
@TableField("level_grade")
private String levelGrade;
......
......@@ -7,7 +7,7 @@ import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/** 一套按标准等级归一化后的实操自动组卷配置。 */
/** 一套归属于完整职级、并复用对应标准等级类目的实操自动组卷配置。 */
@Data
public class PracticePaperRuleConfigurationVO {
......@@ -16,10 +16,10 @@ public class PracticePaperRuleConfigurationVO {
@ApiModelProperty("规则名称")
private String name;
@ApiModelProperty("请求使用的原始职级名称")
@ApiModelProperty("完整职级名称,例如污水一级或污泥一级")
private String lev;
@ApiModelProperty("用于匹配Excel类目的标准等级")
@ApiModelProperty("从完整职级派生、用于匹配Excel类目的标准等级,例如一级")
private String grade;
@ApiModelProperty("状态:DRAFT/PUBLISHED")
......
package com.platform.business.controller;
import com.platform.business.model.dto.TheoreticalLibraryDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.TheoreticalLibraryService;
import com.platform.controller.BaseController;
import com.platform.model.resp.Result;
......@@ -11,6 +13,7 @@ import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
......@@ -27,11 +30,20 @@ public class TheoreticalLibraryController extends BaseController {
@Resource
private TheoreticalLibraryService theoreticalLibraryService;
@Resource
private AuthenticatedUserService authenticatedUserService;
@ApiOperation("上传")
@PostMapping("/import")
public Result<Boolean> importTheoreticalLibrary(@RequestParam(name = "file") MultipartFile file) throws IOException {
return theoreticalLibraryService.importTheoreticalLibrary(file);
public Result<Boolean> importTheoreticalLibrary(@RequestParam(name = "file") MultipartFile file,
HttpServletRequest request) throws IOException {
/*
* 旧模板入口仍保持原有路径和 multipart 参数,但创建人必须来自服务端登录态。
* 这里同时校验管理员角色,避免客户端伪造创建人或通过兼容入口绕过管理端权限。
*/
UserEntity administrator = authenticatedUserService.current(request);
authenticatedUserService.requireAdmin(administrator);
return theoreticalLibraryService.importTheoreticalLibrary(file, administrator);
}
@ApiOperation("分页")
......
......@@ -26,7 +26,7 @@ public interface PracticePaperRuleMapper extends BaseMapper<PracticePaperRuleEnt
List<PracticePaperRuleItemVO> selectDefinitionDetails(@Param("ruleId") Integer ruleId);
int countDuplicateDefinition(@Param("grade") String grade,
int countDuplicateDefinition(@Param("level") String level,
@Param("name") String name,
@Param("excludeId") Integer excludeId);
......@@ -47,7 +47,7 @@ public interface PracticePaperRuleMapper extends BaseMapper<PracticePaperRuleEnt
int countDefinitionUsage(@Param("ruleId") Integer ruleId);
List<ClassAdminOptionVO> selectPublishedOptions(@Param("grade") String grade);
List<ClassAdminOptionVO> selectPublishedOptions(@Param("level") String level);
PracticePaperRuleDefinitionEntity selectPublishedDefinition(@Param("ruleId") Integer ruleId);
}
......@@ -6,6 +6,7 @@ import com.platform.business.model.dto.TheoreticalLibraryDTO;
import com.platform.business.model.entity.TheoreticalLibraryEntity;
import com.platform.business.model.entity.TheoreticalPaperDetailEntity;
import com.platform.business.model.entity.TheoreticalPracticeStudentSimulationDetailEntity;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.TheoreticalLibraryVO;
import com.platform.model.resp.Result;
import org.springframework.web.multipart.MultipartFile;
......@@ -40,7 +41,14 @@ public interface TheoreticalLibraryService extends IService<TheoreticalLibraryEn
List<TheoreticalPracticeStudentSimulationDetailEntity> randomQuestionsSimulation(String lev, String type, Integer moreCount, String chapter, String section);
Result<Boolean> importTheoreticalLibrary(MultipartFile file) throws IOException;
/**
* 导入旧格式题库,并使用服务端认证通过的管理员写入创建人审计字段。
*
* @param file 旧格式题库文件
* @param administrator 当前登录管理员,不接受客户端自行指定
*/
Result<Boolean> importTheoreticalLibrary(MultipartFile file, UserEntity administrator)
throws IOException;
List<TheoreticalLibraryVO> pageData(TheoreticalLibraryDTO theoreticalLibraryDTO);
Boolean updateData(TheoreticalLibraryDTO theoreticalLibraryDTO);
......
......@@ -8,10 +8,12 @@ import com.platform.business.model.dto.PracticePaperRuleSaveDTO;
import com.platform.business.model.entity.PracticePaperRuleDefinitionEntity;
import com.platform.business.model.entity.PracticePaperRuleDetailEntity;
import com.platform.business.model.entity.PracticePaperRuleEntity;
import com.platform.business.model.entity.SysLevelEntity;
import com.platform.business.model.vo.ClassAdminOptionVO;
import com.platform.business.model.vo.PracticePaperRuleConfigurationVO;
import com.platform.business.model.vo.PracticePaperRuleItemVO;
import com.platform.business.service.PracticePaperRuleService;
import com.platform.business.service.SysLevelService;
import com.platform.exception.BusinessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
......@@ -53,13 +55,20 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
@Resource
private PracticePaperRuleMapper ruleMapper;
/**
* 完整职级以系统职级配置为事实来源。规则服务不能只检查字符串后缀,否则已经停用或
* 根本不存在的“某某一级”也可能进入规则主表,最终无法与班级职级可靠关联。
*/
@Resource
private SysLevelService sysLevelService;
@Override
@Transactional(readOnly = true)
public List<PracticePaperRuleConfigurationVO> queryPage(PracticePaperRuleQueryDTO query) {
PracticePaperRuleQueryDTO safe = query == null ? new PracticePaperRuleQueryDTO() : query;
safe.setName(optionalText(safe.getName(), "规则名称", 200));
if (StringUtils.hasText(safe.getLev())) {
safe.setLev(normalizeGrade(safe.getLev()));
safe.setLev(normalizeLevel(safe.getLev()));
}
if (StringUtils.hasText(safe.getStatus())) {
safe.setStatus(normalizeStatus(safe.getStatus()));
......@@ -69,6 +78,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
return Collections.emptyList();
}
for (PracticePaperRuleConfigurationVO row : rows) {
applyLevelFields(row);
decorate(row);
}
return rows;
......@@ -77,7 +87,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
@Override
@Transactional(readOnly = true)
public List<PracticePaperRuleItemVO> catalog(String level) {
String grade = normalizeGrade(level);
String grade = extractGrade(normalizeLevel(level));
List<PracticePaperRuleEntity> catalog = ruleMapper.selectList(
new LambdaQueryWrapper<PracticePaperRuleEntity>()
.eq(PracticePaperRuleEntity::getLevelGrade, grade)
......@@ -121,7 +131,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
public PracticePaperRuleConfigurationVO create(PracticePaperRuleSaveDTO request,
String operatorId) {
PreparedRule prepared = prepare(request, operatorId);
ensureUniqueName(prepared.grade, prepared.name, null);
ensureUniqueName(prepared.level, prepared.name, null);
Date now = new Date();
PracticePaperRuleDefinitionEntity definition = definition(prepared, operatorId, now);
......@@ -147,7 +157,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
throw new BusinessException("已发布实操试卷规则不能编辑");
}
PreparedRule prepared = prepare(request, operatorId);
ensureUniqueName(prepared.grade, prepared.name, ruleId);
ensureUniqueName(prepared.level, prepared.name, ruleId);
PracticePaperRuleDefinitionEntity update = definition(prepared, operatorId, new Date());
update.setId(ruleId);
......@@ -217,7 +227,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
@Override
@Transactional(readOnly = true)
public List<ClassAdminOptionVO> publishedOptions(String level) {
List<ClassAdminOptionVO> options = ruleMapper.selectPublishedOptions(normalizeGrade(level));
List<ClassAdminOptionVO> options = ruleMapper.selectPublishedOptions(normalizeLevel(level));
return options == null ? Collections.emptyList() : options;
}
......@@ -234,8 +244,8 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
if (definition == null || !STATUS_PUBLISHED.equals(definition.getStatus())) {
throw new BusinessException("所选实操试卷规则不存在、已删除或尚未发布");
}
String grade = normalizeGrade(level);
if (!grade.equals(definition.getLevelGrade())) {
String normalizedLevel = normalizeLevel(level);
if (!normalizedLevel.equals(definition.getLevelGrade())) {
throw new BusinessException("所选实操试卷规则与班级职业等级不匹配");
}
if (definition.getTotalScore() == null
......@@ -254,7 +264,8 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
throw new BusinessException("实操试卷规则不能为空");
}
String name = requireText(request.getName(), "规则名称", 200);
String grade = normalizeGrade(request.getLev());
String level = normalizeLevel(request.getLev());
String grade = extractGrade(level);
requireText(operatorId, "操作人ID", 64);
List<PracticePaperRuleEntity> catalog = ruleMapper.selectList(
new LambdaQueryWrapper<PracticePaperRuleEntity>()
......@@ -280,6 +291,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
PreparedRule result = new PreparedRule();
result.name = name;
result.level = level;
result.grade = grade;
result.details = new ArrayList<>(catalog.size());
result.totalScore = BigDecimal.ZERO;
......@@ -318,7 +330,8 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
Date now) {
PracticePaperRuleDefinitionEntity result = new PracticePaperRuleDefinitionEntity();
result.setName(prepared.name);
result.setLevelGrade(prepared.grade);
// 规则主表保存完整职级;一级至五级只用于选择共享的标准类目目录。
result.setLevelGrade(prepared.level);
result.setQuestionCount(prepared.totalQuestionCount);
result.setTotalDuration(prepared.totalDuration);
result.setTotalScore(prepared.totalScore);
......@@ -348,7 +361,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
result.setId(definition.getId());
result.setName(definition.getName());
result.setLev(definition.getLevelGrade());
result.setGrade(definition.getLevelGrade());
result.setGrade(extractGrade(definition.getLevelGrade()));
result.setStatus(definition.getStatus());
result.setTotalQuestionCount(definition.getQuestionCount());
result.setTotalDuration(definition.getTotalDuration());
......@@ -371,8 +384,15 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
rule.setDeletable(usage == 0);
}
private void ensureUniqueName(String grade, String name, Integer excludeId) {
if (ruleMapper.countDuplicateDefinition(grade, name, excludeId) > 0) {
/** 列表SQL直接返回完整职级;标准等级在服务层统一派生,避免两个字段再次混用。 */
private void applyLevelFields(PracticePaperRuleConfigurationVO rule) {
if (rule != null && StringUtils.hasText(rule.getLev())) {
rule.setGrade(extractGrade(rule.getLev()));
}
}
private void ensureUniqueName(String level, String name, Integer excludeId) {
if (ruleMapper.countDuplicateDefinition(level, name, excludeId) > 0) {
throw new BusinessException("同一职级下实操试卷规则名称已存在");
}
}
......@@ -397,7 +417,29 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
}
}
String normalizeGrade(String level) {
/**
* 校验并返回完整职级。裸的“一级”虽然能匹配标准类目,但无法判断属于污水还是污泥,
* 因此不能再作为规则归属写入数据库。
*/
String normalizeLevel(String level) {
String normalized = requireText(level, "使用职级", 32);
String grade = extractGrade(normalized);
if (!("污水" + grade).equals(normalized) && !("污泥" + grade).equals(normalized)) {
throw new BusinessException("使用职级只支持污水一级至污水五级或污泥一级至污泥五级");
}
List<SysLevelEntity> levels = sysLevelService.list(
new LambdaQueryWrapper<SysLevelEntity>()
.eq(SysLevelEntity::getName, normalized)
.and(wrapper -> wrapper.isNull(SysLevelEntity::getHiddeFlag)
.or().eq(SysLevelEntity::getHiddeFlag, false)));
if (levels == null || levels.isEmpty()) {
throw new BusinessException("使用职级不存在或已停用");
}
return normalized;
}
/** 从完整职级末尾提取共享标准类目使用的一级至五级。 */
String extractGrade(String level) {
String normalized = requireText(level, "使用职级", 32);
for (String grade : GRADES) {
if (normalized.endsWith(grade)) {
......@@ -467,6 +509,7 @@ public class PracticePaperRuleServiceImpl implements PracticePaperRuleService {
private static final class PreparedRule {
private String name;
private String level;
private String grade;
private int totalQuestionCount;
private int totalDuration;
......
......@@ -10,6 +10,7 @@ import com.platform.business.model.entity.TheoreticalLibraryEntity;
import com.platform.business.model.entity.TheoreticalLibraryNodeEntity;
import com.platform.business.model.entity.TheoreticalPaperDetailEntity;
import com.platform.business.model.entity.TheoreticalPracticeStudentSimulationDetailEntity;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.TheoreticalLibraryVO;
import com.platform.business.service.TheoreticalLibraryService;
import com.platform.exception.BusinessException;
......@@ -69,7 +70,8 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
@Override
@Transactional
public Result<Boolean> importTheoreticalLibrary(MultipartFile file) throws IOException {
public Result<Boolean> importTheoreticalLibrary(MultipartFile file, UserEntity administrator)
throws IOException {
//判断是否是技能竞赛
String scope;
......@@ -80,7 +82,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
prefix = "J";
//删除原始旧数据
remove(new LambdaQueryWrapper<TheoreticalLibraryEntity>().eq(TheoreticalLibraryEntity::getScope, scope));
return handleJn(file, prefix, codeLev, scope);
return handleJn(file, prefix, codeLev, scope, administrator);
} else {
//判断是污水还是污泥
prefix = Objects.requireNonNull(file.getOriginalFilename()).contains("污水") ? "S" : "N";
......@@ -108,12 +110,13 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
}
//删除原始旧数据
remove(new LambdaQueryWrapper<TheoreticalLibraryEntity>().eq(TheoreticalLibraryEntity::getScope, scope));
return handleWsWn(file, prefix, codeLev, scope);
return handleWsWn(file, prefix, codeLev, scope, administrator);
}
}
@Transactional
public Result<Boolean> handleJn(MultipartFile file, String prefix, int codeLev, String scope) throws IOException {
public Result<Boolean> handleJn(MultipartFile file, String prefix, int codeLev, String scope,
UserEntity administrator) throws IOException {
List<TheoreticalLibraryEntity> theoreticalLibraryList = Lists.newArrayList();
try (Workbook workbook = WorkbookFactory.create(file.getInputStream())) {
Sheet sheet = workbook.getSheetAt(0);
......@@ -290,14 +293,15 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
//删除脏数据
removeDirtyData();
// 旧竞赛模板仍由本入口导入;同步新节点和管理字段,保证新旧页面数据一致。
synchronizeImportedScope(scope);
synchronizeImportedScope(scope, administrator);
return Result.success("导入成功");
}
}
@Transactional
public Result<Boolean> handleWsWn(MultipartFile file, String prefix, int codeLev, String scope) throws IOException {
public Result<Boolean> handleWsWn(MultipartFile file, String prefix, int codeLev, String scope,
UserEntity administrator) throws IOException {
String firstLevelName = null;
String secondLevelName = null;
String thirdLevelName = null;
......@@ -503,7 +507,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
//删除脏数据
removeDirtyData();
// 旧职级模板导入后补齐六级树及新字段,旧接口无需感知新表结构。
synchronizeImportedScope(scope);
synchronizeImportedScope(scope, administrator);
return Result.success("导入成功");
}
}
......@@ -514,9 +518,11 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
* <p>旧模板会把章、节、目、点标题保存为 {@code is_problem=false}
* 的独立记录。如果只同步题目行,没有题目的空分支会从管理端树中消失,
* 因此这里必须查询指定 scope 的全部记录。结构行只创建自身已提供的
* 层级,题目行则使用“未分类”节点补到固定末级并回填 {@code node_id}。</p>
* 层级,题目行则使用“未分类”节点补到固定末级并回填 {@code node_id}。
* 当前管理员由控制器根据 JWT 获取,统一传到题目与本次新建节点的审计字段中;
* 已存在节点仍保留原创建人,避免一次导入篡改历史归属。</p>
*/
private void synchronizeImportedScope(String scope) {
private void synchronizeImportedScope(String scope, UserEntity administrator) {
List<TheoreticalLibraryEntity> importedRows = list(
new LambdaQueryWrapper<TheoreticalLibraryEntity>()
.eq(TheoreticalLibraryEntity::getScope, scope));
......@@ -531,7 +537,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity competitionNode = ensureLegacyNode(cache, "COMP",
"0", "COMPETITION", competitionName, 10);
"0", "COMPETITION", competitionName, 10, administrator);
String categoryName = importedLevelName(importedRow.getSecondLevelName(),
"未分类", question);
......@@ -539,7 +545,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity category = ensureLegacyNode(cache, "COMP",
competitionNode.getId(), "CATEGORY", categoryName, 10);
competitionNode.getId(), "CATEGORY", categoryName, 10, administrator);
String directionName = importedLevelName(importedRow.getThirdLevelName(),
"未分类方向", question);
......@@ -547,9 +553,9 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity leaf = ensureLegacyNode(cache, "COMP",
category.getId(), "DIRECTION", directionName, 10);
category.getId(), "DIRECTION", directionName, 10, administrator);
if (question) {
updateImportedQuestion(importedRow, "COMP", leaf);
updateImportedQuestion(importedRow, "COMP", leaf, administrator);
}
} else {
String craftName = scope != null && (scope.startsWith("污水") || scope.startsWith("污泥"))
......@@ -557,9 +563,9 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
String levelName = scope != null && scope.length() > craftName.length()
? scope.substring(craftName.length()) : "未分级";
TheoreticalLibraryNodeEntity craft = ensureLegacyNode(cache, "JOB", "0",
"CRAFT", craftName, 10);
"CRAFT", craftName, 10, administrator);
TheoreticalLibraryNodeEntity level = ensureLegacyNode(cache, "JOB", craft.getId(),
"LEVEL", levelName, 10);
"LEVEL", levelName, 10, administrator);
String chapterName = importedLevelName(importedRow.getFirstLevelName(),
"未分类章", question);
......@@ -567,7 +573,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity chapter = ensureLegacyNode(cache, "JOB", level.getId(),
"CHAPTER", chapterName, 10);
"CHAPTER", chapterName, 10, administrator);
String sectionName = importedLevelName(importedRow.getSecondLevelName(),
"未分类节", question);
......@@ -575,7 +581,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity section = ensureLegacyNode(cache, "JOB", chapter.getId(),
"SECTION", sectionName, 10);
"SECTION", sectionName, 10, administrator);
String topicName = importedLevelName(importedRow.getThirdLevelName(),
"未分类目", question);
......@@ -583,7 +589,7 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity topic = ensureLegacyNode(cache, "JOB", section.getId(),
"TOPIC", topicName, 10);
"TOPIC", topicName, 10, administrator);
String pointName = importedLevelName(importedRow.getFourthLevelName(),
"未分类知识点", question);
......@@ -591,9 +597,9 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
continue;
}
TheoreticalLibraryNodeEntity leaf = ensureLegacyNode(cache, "JOB", topic.getId(),
"POINT", pointName, 10);
"POINT", pointName, 10, administrator);
if (question) {
updateImportedQuestion(importedRow, "JOB", leaf);
updateImportedQuestion(importedRow, "JOB", leaf, administrator);
}
}
}
......@@ -610,25 +616,33 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
return question ? missingQuestionName : null;
}
/** 只回写真正的题目行,历史结构行仍保持原表数据不变。 */
/**
* 只回写真正的题目行,历史结构行仍保持原表数据不变。
* 创建人 ID 与名称必须成对取自当前登录管理员,不能继续使用无法追溯到用户的固定文案。
*/
private void updateImportedQuestion(TheoreticalLibraryEntity question, String bankType,
TheoreticalLibraryNodeEntity leaf) {
TheoreticalLibraryNodeEntity leaf,
UserEntity administrator) {
question.setBankType(bankType);
question.setNodeId(leaf.getId());
question.setStatus(1);
question.setDifficulty("MEDIUM");
question.setScore(defaultScore(question.getType()));
question.setParticipate(question.getParticipate() == null || question.getParticipate());
question.setCreateUserName("旧格式导入");
question.setCreateUserId(administrator == null ? null : administrator.getId());
question.setCreateUserName(displayName(administrator));
question.setCreateTime(question.getCreateTime() == null ? new Date() : question.getCreateTime());
question.setUpdateTime(new Date());
updateById(question);
}
/** 查找或创建旧数据回填节点,数据库唯一索引承担并发场景的最终保护。 */
/**
* 查找或创建旧数据回填节点,数据库唯一索引承担并发场景的最终保护。
* 只有本次确实创建的节点才记录当前管理员;命中已有节点时直接复用,保留原审计信息。
*/
private TheoreticalLibraryNodeEntity ensureLegacyNode(
Map<String, TheoreticalLibraryNodeEntity> cache, String bankType, String parentId,
String nodeType, String name, int sortNo) {
String nodeType, String name, int sortNo, UserEntity administrator) {
String cacheKey = bankType + '|' + parentId + '|' + name;
TheoreticalLibraryNodeEntity cached = cache.get(cacheKey);
if (cached != null) {
......@@ -652,13 +666,34 @@ public class TheoreticalLibraryServiceImpl extends ServiceImpl<TheoreticalLibrar
.toUpperCase(Locale.ROOT));
existing.setSortNo(sortNo);
existing.setStatus(1);
existing.setCreateUserName("旧格式导入");
existing.setCreateUserId(administrator == null ? null : administrator.getId());
existing.setCreateUserName(displayName(administrator));
theoreticalLibraryNodeMapper.insert(existing);
}
cache.put(cacheKey, existing);
return existing;
}
/**
* 与新版题库管理保持相同的创建人展示规则:优先展示姓名,其次依次降级到
* 登录账号、手机号和用户 ID,确保账号资料不完整时列表仍有稳定可读的创建人。
*/
private String displayName(UserEntity user) {
if (user == null) {
return "系统迁移";
}
if (StringUtils.isNotBlank(user.getNickName())) {
return user.getNickName().trim();
}
if (StringUtils.isNotBlank(user.getUsername())) {
return user.getUsername().trim();
}
if (StringUtils.isNotBlank(user.getPhoneNumber())) {
return user.getPhoneNumber().trim();
}
return user.getId();
}
private String fallback(String value, String fallback) {
return StringUtils.isNotBlank(value) ? value.trim() : fallback;
}
......
......@@ -13,6 +13,36 @@ spring:
namespace: 272b9958-7a2d-41f8-ba0b-fdcb7ee8ead0
shared-configs:
- application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
# RabbitMQ只保存事件和实时提示,消息正文及用户状态仍以MySQL为最终数据源。
rabbitmq:
host: ${RABBITMQ_HOST:127.0.0.1}
port: ${RABBITMQ_PORT:5672}
username: ${RABBITMQ_USERNAME:admin}
password: ${RABBITMQ_PASSWORD:ruzhoukj@2026}
virtual-host: ${RABBITMQ_VHOST:/}
publisher-confirm-type: correlated
publisher-returns: true
template:
mandatory: true
listener:
simple:
# 1000人在线基线下2~4个消费者足够;prefetch限制单消费者未确认消息数量。
concurrency: 2
max-concurrency: 4
prefetch: 50
acknowledge-mode: auto
default-requeue-rejected: true
# Redis故障时消息列表和未读数可回源MySQL,但新WebSocket票据无法签发。
redis:
host: ${REDIS_HOST:127.0.0.1}
port: ${REDIS_PORT:6379}
password: ${REDIS_PASSWORD:}
database: ${REDIS_DATABASE:0}
timeout: 2s
servlet:
multipart:
max-file-size: 500MB
max-request-size: 510MB
# 测试环境不要求秒级发送通知,将发件箱空轮询间隔调整为10秒,减少无待发消息时的数据库查询和日志输出。
# 该配置仅覆盖dev环境;公共配置及生产环境的轮询间隔保持不变。
......
......@@ -13,3 +13,33 @@ spring:
namespace: 272b9958-7a2d-41f8-ba0b-fdcb7ee8ead0
shared-configs:
- application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
# RabbitMQ只保存事件和实时提示,消息正文及用户状态仍以MySQL为最终数据源。
rabbitmq:
host: ${RABBITMQ_HOST:47.110.71.183}
port: ${RABBITMQ_PORT:5672}
username: ${RABBITMQ_USERNAME:admin}
password: ${RABBITMQ_PASSWORD:ruzhoukj@2026}
virtual-host: ${RABBITMQ_VHOST:/}
publisher-confirm-type: correlated
publisher-returns: true
template:
mandatory: true
listener:
simple:
# 1000人在线基线下2~4个消费者足够;prefetch限制单消费者未确认消息数量。
concurrency: 2
max-concurrency: 4
prefetch: 50
acknowledge-mode: auto
default-requeue-rejected: true
# Redis故障时消息列表和未读数可回源MySQL,但新WebSocket票据无法签发。
redis:
host: ${REDIS_HOST:47.110.71.183}
port: ${REDIS_PORT:6379}
password: ${REDIS_PASSWORD:}
database: ${REDIS_DATABASE:0}
timeout: 2s
servlet:
multipart:
max-file-size: 500MB
max-request-size: 510MB
spring:
profiles:
active: dev
# RabbitMQ只保存事件和实时提示,消息正文及用户状态仍以MySQL为最终数据源。
rabbitmq:
host: ${RABBITMQ_HOST:127.0.0.1}
port: ${RABBITMQ_PORT:5672}
username: ${RABBITMQ_USERNAME:admin}
password: ${RABBITMQ_PASSWORD:ruzhoukj@2026}
virtual-host: ${RABBITMQ_VHOST:/}
publisher-confirm-type: correlated
publisher-returns: true
template:
mandatory: true
listener:
simple:
# 1000人在线基线下2~4个消费者足够;prefetch限制单消费者未确认消息数量。
concurrency: 2
max-concurrency: 4
prefetch: 50
acknowledge-mode: auto
default-requeue-rejected: true
# Redis故障时消息列表和未读数可回源MySQL,但新WebSocket票据无法签发。
redis:
host: ${REDIS_HOST:127.0.0.1}
port: ${REDIS_PORT:6379}
password: ${REDIS_PASSWORD:}
database: ${REDIS_DATABASE:0}
timeout: 2s
servlet:
multipart:
max-file-size: 500MB
max-request-size: 510MB
# Tomcat还维护独立的表单POST上限;与multipart请求上限保持一致,避免大视频在进入Controller前
# 被Servlet容器拒绝。文件仍由MultipartFile流式落盘,不会因此整体加载到JVM内存。
......
......@@ -11,7 +11,6 @@
resultType="com.platform.business.model.vo.PracticePaperRuleConfigurationVO">
select rule.id,
rule.name,
rule.level_grade as grade,
rule.level_grade as lev,
rule.question_count as totalQuestionCount,
rule.total_duration as totalDuration,
......@@ -72,7 +71,7 @@
<select id="countDuplicateDefinition" resultType="java.lang.Integer">
select count(*)
from practice_paper_rule_definition
where level_grade = #{grade}
where level_grade = #{level}
and name = #{name}
<if test="excludeId != null">
and id &lt;&gt; #{excludeId}
......@@ -137,7 +136,7 @@
level_grade as parentValue,
concat(question_count, '题 · ', total_score, '分') as extra
from practice_paper_rule_definition
where level_grade = #{grade}
where level_grade = #{level}
and status = 'PUBLISHED'
order by updated_time desc, id desc
</select>
......
......@@ -2,7 +2,7 @@
页面位置为“管理员 → 智能考评 → 试卷管理 → 实操试卷规则”。部署时先执行
`sql/exam_management.sql`,再执行 `sql/practice_paper_rule.sql`。后者会创建规则主表、
明细表和考试教师关系表,并把原一级至五级配置迁移成五条已发布默认规则。
明细表和考试教师关系表,并把原一级至五级规则迁移为污水、污泥完整职级规则。
状态仅有 `DRAFT`(草稿)和 `PUBLISHED`(已发布)。草稿可编辑、发布和删除;已发布
规则不可编辑或退回草稿,但未被考试使用时仍可删除。任何被考试引用的规则均不可删除。
......@@ -15,9 +15,10 @@
{"pageNum":1,"pageSize":10,"name":"默认","lev":"污水一级","status":"PUBLISHED"}
```
`lev` 会归一化为一级至五级,因此污水一级与污泥一级查询同一组共享规则。列表返回
`lev` 使用系统中启用的完整职级,污水一级与污泥一级分别查询各自独立的规则。列表返回
`id/name/lev/grade/totalQuestionCount/totalDuration/totalScore/status/statusLabel/usageCount`
以及 `publishable/editable/deletable`,页面应直接依据这三个布尔值显示操作按钮。
以及 `publishable/editable/deletable`;其中 `lev` 是完整职级,`grade` 是用于复用标准类目的
一级至五级后缀,页面应直接依据这三个布尔值显示操作按钮。
## 2. 新建、详情和编辑
......@@ -40,9 +41,11 @@
}
```
必须回传详情中该等级的全部标准类目,不能跨等级混用 `catalogId`。每项时间为1~600
必须回传详情中该等级的全部标准类目,不能跨等级混用 `catalogId`。裸的“一级~五级”、
不存在或已停用的完整职级均会被拒绝。每项时间为1~600
分钟、配分大于0且不超过99999.99,所有类目的题量合计必须为1~5。题量、总时间和总分
由服务端计算,客户端提交同名字段不会作为事实来源。同一等级内规则名称不能重复。
由服务端计算,客户端提交同名字段不会作为事实来源。同一完整职级内规则名称不能重复,
污水与污泥同等级可以分别使用相同规则名称。
## 3. 发布与删除
......@@ -55,6 +58,6 @@
## 4. 考试使用
`GET /exam/admin/classes/{classId}/options` 的 `practiceRules` 只包含与班级等级后缀匹配的
`GET /exam/admin/classes/{classId}/options` 的 `practiceRules` 只包含与班级完整职级匹配的
已发布规则。实训考试提交 `practiceRuleId`,服务端从规则复制总分到考试快照。学员最近
考试的 `practiceRule` 也按考试保存的规则ID读取,不会随新增规则或学员职级变化。
......@@ -2,8 +2,8 @@
--
-- 业务口径:
-- 1. practice_paper_rule保留为一级至五级标准类目目录,不生成theoretical_paper。
-- 2. level_grade使用Excel中的一级至五级;污水一级、污泥一级等职级在服务层统一匹配一级。
-- 3. 考核时间和单题配分默认20;目录数值会迁移成每级一条已发布默认规则。
-- 2. practice_paper_rule_definition.level_grade保存污水/污泥完整职级;服务层只在读取目录时提取等级后缀。
-- 3. 考核时间和单题配分默认20;目录数值会为十个完整职级分别生成已发布默认规则。
-- 4. INSERT IGNORE只补充缺失类目,重复执行不会覆盖已经迁移的具名规则。
create table if not exists practice_paper_rule (
......@@ -95,7 +95,7 @@ order by field(level_grade, '五级', '四级', '三级', '二级', '一级');
create table if not exists practice_paper_rule_definition (
id int not null auto_increment comment '实操试卷规则ID',
name varchar(200) not null comment '规则名称',
level_grade varchar(8) not null comment '共享标准等级:一级至五级',
level_grade varchar(32) not null comment '完整职级:污水一级至五级或污泥一级至五级',
question_count int not null comment '规则总题量快照',
total_duration int not null comment '规则总考核时间(分钟)',
total_score decimal(8,2) not null comment '规则总分快照',
......@@ -105,8 +105,8 @@ create table if not exists practice_paper_rule_definition (
updated_by varchar(64) null comment '最后更新管理员ID',
updated_time datetime not null default current_timestamp comment '更新时间',
primary key (id),
unique key uk_practice_definition_grade_name (level_grade, name),
key idx_practice_definition_grade_status (level_grade, status, updated_time, id)
unique key uk_practice_definition_level_name (level_grade, name),
key idx_practice_definition_level_status (level_grade, status, updated_time, id)
) engine=InnoDB
comment='具名实操试卷规则主表';
......@@ -123,27 +123,6 @@ create table if not exists practice_paper_rule_detail (
) engine=InnoDB
comment='具名实操试卷规则明细';
-- 把升级前每个等级的唯一配置固化成已发布默认规则;唯一键保证脚本可重复执行。
insert ignore into practice_paper_rule_definition
(name, level_grade, question_count, total_duration, total_score, status,
created_by, created_time, updated_by, updated_time)
select concat(catalog.level_grade, '实操默认规则'),
catalog.level_grade,
sum(catalog.question_count),
sum(catalog.assessment_duration * catalog.question_count),
sum(catalog.score * catalog.question_count),
'PUBLISHED', null, now(), null, now()
from practice_paper_rule catalog
group by catalog.level_grade;
insert ignore into practice_paper_rule_detail
(rule_id, catalog_id, assessment_duration, score, question_count)
select definition.id, catalog.id, catalog.assessment_duration, catalog.score, catalog.question_count
from practice_paper_rule catalog
inner join practice_paper_rule_definition definition
on definition.level_grade = catalog.level_grade
and definition.name = concat(catalog.level_grade, '实操默认规则');
-- ==================== 考试规则引用与教师多选关系 ====================
create table if not exists exam_teacher_assignment (
......@@ -164,6 +143,8 @@ delimiter $$
drop procedure if exists migrate_exam_practice_rule$$
create procedure migrate_exam_practice_rule()
begin
declare active_level_count int default 0;
if not exists (
select 1 from information_schema.columns
where table_schema = database() and table_name = 'exam'
......@@ -180,6 +161,192 @@ begin
) then
alter table exam add index idx_exam_practice_rule (practice_rule_id, id);
end if;
/*
* 旧结构只保存“一级至五级”。先确认十个目标职级完整存在,再转换历史规则;缺少任一
* 职级时直接终止,避免把无法判定归属的数据静默迁移到错误工种。
*/
select count(distinct trim(name)) into active_level_count
from sys_level
where coalesce(hidde_flag, 0) = 0
and trim(name) in (
'污水一级', '污水二级', '污水三级', '污水四级', '污水五级',
'污泥一级', '污泥二级', '污泥三级', '污泥四级', '污泥五级'
);
if active_level_count <> 10 then
signal sqlstate '45000'
set message_text = '实操规则迁移失败:sys_level必须配置并启用污水、污泥共十个完整职级';
end if;
/* 字段名为兼容旧代码继续保留,字段值从本次迁移起保存完整职级。 */
alter table practice_paper_rule_definition
modify column level_grade varchar(32) not null
comment '完整职级:污水一级至五级或污泥一级至五级';
/*
* 已关联旧规则的考试必须能从班级解析出有效完整职级。该校验先于任何规则更新,
* 一旦失败不会发生部分规则已经改名、考试却尚未重绑的情况。
*/
if exists (
select 1
from exam e
inner join practice_paper_rule_definition definition
on definition.id = e.practice_rule_id
and definition.level_grade in ('一级', '二级', '三级', '四级', '五级')
left join `class` c on c.id = e.class_id
left join sys_level level_info on cast(level_info.id as char) = c.level
where level_info.id is null
or coalesce(level_info.hidde_flag, 0) <> 0
or trim(level_info.name) not in (
'污水一级', '污水二级', '污水三级', '污水四级', '污水五级',
'污泥一级', '污泥二级', '污泥三级', '污泥四级', '污泥五级'
)
or right(trim(level_info.name), char_length(definition.level_grade))
<> definition.level_grade
) then
signal sqlstate '45000'
set message_text = '实操规则迁移失败:历史考试存在缺失、停用或与规则等级不一致的班级职级';
end if;
drop temporary table if exists tmp_practice_rule_targets;
create temporary table tmp_practice_rule_targets (
old_rule_id int not null,
target_level varchar(32) not null,
primary key (old_rule_id, target_level)
) engine=InnoDB;
/* 名称明确包含完整职级的规则优先保留原有业务归属。 */
insert ignore into tmp_practice_rule_targets (old_rule_id, target_level)
select definition.id, trim(level_info.name)
from practice_paper_rule_definition definition
inner join sys_level level_info
on right(trim(level_info.name), char_length(definition.level_grade))
= definition.level_grade
and instr(definition.name, trim(level_info.name)) > 0
where definition.level_grade in ('一级', '二级', '三级', '四级', '五级')
and coalesce(level_info.hidde_flag, 0) = 0;
/* 名称没有工种信息的共享旧规则,为同等级的污水和污泥职级各保留一份。 */
insert ignore into tmp_practice_rule_targets (old_rule_id, target_level)
select definition.id, trim(level_info.name)
from practice_paper_rule_definition definition
inner join sys_level level_info
on right(trim(level_info.name), char_length(definition.level_grade))
= definition.level_grade
where definition.level_grade in ('一级', '二级', '三级', '四级', '五级')
and coalesce(level_info.hidde_flag, 0) = 0
and not exists (
select 1
from sys_level named_level
where coalesce(named_level.hidde_flag, 0) = 0
and right(trim(named_level.name), char_length(definition.level_grade))
= definition.level_grade
and instr(definition.name, trim(named_level.name)) > 0
);
/* 即使规则名称与实际历史用法不一致,也必须为每个已引用班级建立可重绑的目标副本。 */
insert ignore into tmp_practice_rule_targets (old_rule_id, target_level)
select distinct definition.id, trim(level_info.name)
from practice_paper_rule_definition definition
inner join exam e on e.practice_rule_id = definition.id
inner join `class` c on c.id = e.class_id
inner join sys_level level_info on cast(level_info.id as char) = c.level
where definition.level_grade in ('一级', '二级', '三级', '四级', '五级');
drop temporary table if exists tmp_practice_rule_primary;
create temporary table tmp_practice_rule_primary (
old_rule_id int not null,
target_level varchar(32) not null,
primary key (old_rule_id)
) engine=InnoDB;
insert into tmp_practice_rule_primary (old_rule_id, target_level)
select old_rule_id, min(target_level)
from tmp_practice_rule_targets
group by old_rule_id;
/* 原记录承接一个目标职级,其余目标通过复制主表和明细产生,确保原ID仍然有效。 */
update practice_paper_rule_definition definition
inner join tmp_practice_rule_primary target on target.old_rule_id = definition.id
set definition.level_grade = target.target_level;
insert ignore into practice_paper_rule_definition
(name, level_grade, question_count, total_duration, total_score, status,
created_by, created_time, updated_by, updated_time)
select source.name, target.target_level, source.question_count, source.total_duration,
source.total_score, source.status, source.created_by, source.created_time,
source.updated_by, source.updated_time
from tmp_practice_rule_targets target
inner join tmp_practice_rule_primary primary_target
on primary_target.old_rule_id = target.old_rule_id
and primary_target.target_level <> target.target_level
inner join practice_paper_rule_definition source on source.id = target.old_rule_id;
insert ignore into practice_paper_rule_detail
(rule_id, catalog_id, assessment_duration, score, question_count)
select target_definition.id, old_detail.catalog_id, old_detail.assessment_duration,
old_detail.score, old_detail.question_count
from tmp_practice_rule_targets target
inner join practice_paper_rule_definition source on source.id = target.old_rule_id
inner join practice_paper_rule_definition target_definition
on target_definition.level_grade = target.target_level
and target_definition.name = source.name
inner join practice_paper_rule_detail old_detail
on old_detail.rule_id = target.old_rule_id;
/* 按考试所属班级完整职级选择迁移后的规则ID,彻底消除跨工种共享引用。 */
update exam e
inner join `class` c on c.id = e.class_id
inner join sys_level level_info on cast(level_info.id as char) = c.level
inner join tmp_practice_rule_targets target
on target.old_rule_id = e.practice_rule_id
and target.target_level = trim(level_info.name)
inner join practice_paper_rule_definition source on source.id = target.old_rule_id
inner join practice_paper_rule_definition target_definition
on target_definition.level_grade = target.target_level
and target_definition.name = source.name
set e.practice_rule_id = target_definition.id;
/* 索引列保持不变,但名称同步体现其现在约束的是完整职级而非共享等级。 */
if exists (
select 1 from information_schema.statistics
where table_schema = database()
and table_name = 'practice_paper_rule_definition'
and index_name = 'uk_practice_definition_grade_name'
) then
alter table practice_paper_rule_definition
drop index uk_practice_definition_grade_name;
end if;
if not exists (
select 1 from information_schema.statistics
where table_schema = database()
and table_name = 'practice_paper_rule_definition'
and index_name = 'uk_practice_definition_level_name'
) then
alter table practice_paper_rule_definition
add unique index uk_practice_definition_level_name (level_grade, name);
end if;
if exists (
select 1 from information_schema.statistics
where table_schema = database()
and table_name = 'practice_paper_rule_definition'
and index_name = 'idx_practice_definition_grade_status'
) then
alter table practice_paper_rule_definition
drop index idx_practice_definition_grade_status;
end if;
if not exists (
select 1 from information_schema.statistics
where table_schema = database()
and table_name = 'practice_paper_rule_definition'
and index_name = 'idx_practice_definition_level_status'
) then
alter table practice_paper_rule_definition
add index idx_practice_definition_level_status
(level_grade, status, updated_time, id);
end if;
drop temporary table if exists tmp_practice_rule_primary;
drop temporary table if exists tmp_practice_rule_targets;
end$$
call migrate_exam_practice_rule()$$
......@@ -187,6 +354,42 @@ drop procedure if exists migrate_exam_practice_rule$$
delimiter ;
/*
* 历史规则迁移完成后,仅给仍没有任何规则的完整职级补一条默认规则。这样新环境会得到十条
* 默认规则,而升级环境会保留历史规则名称,也不会在脚本重复执行时不断追加默认规则。
*/
insert ignore into practice_paper_rule_definition
(name, level_grade, question_count, total_duration, total_score, status,
created_by, created_time, updated_by, updated_time)
select concat(trim(level_info.name), '实操默认规则'),
trim(level_info.name),
sum(catalog.question_count),
sum(catalog.assessment_duration * catalog.question_count),
sum(catalog.score * catalog.question_count),
'PUBLISHED', null, now(), null, now()
from sys_level level_info
inner join practice_paper_rule catalog
on right(trim(level_info.name), char_length(catalog.level_grade)) = catalog.level_grade
where coalesce(level_info.hidde_flag, 0) = 0
and trim(level_info.name) in (
'污水一级', '污水二级', '污水三级', '污水四级', '污水五级',
'污泥一级', '污泥二级', '污泥三级', '污泥四级', '污泥五级'
)
and not exists (
select 1
from practice_paper_rule_definition existing
where existing.level_grade = trim(level_info.name)
)
group by trim(level_info.name);
insert ignore into practice_paper_rule_detail
(rule_id, catalog_id, assessment_duration, score, question_count)
select definition.id, catalog.id, catalog.assessment_duration, catalog.score, catalog.question_count
from practice_paper_rule catalog
inner join practice_paper_rule_definition definition
on right(definition.level_grade, char_length(catalog.level_grade)) = catalog.level_grade
and definition.name = concat(definition.level_grade, '实操默认规则');
-- 首席考评员历史字段为单值,可直接迁移;空值不会生成无效关系。
insert ignore into exam_teacher_assignment (exam_id, teacher_id, role, display_order)
select e.id, trim(e.chief_id), 'CHIEF', 0
......@@ -210,13 +413,16 @@ inner join (
where e.invigilation_id is not null
and trim(substring_index(substring_index(e.invigilation_id, ',', seq_table.seq), ',', -1)) <> '';
-- 历史实训考试按班级职级末尾的一级至五级匹配默认规则,延续原先跨工种共享规则的口径。
-- 尚未绑定规则的历史实训考试,按班级完整职级匹配各自独立的默认规则。
update exam e
inner join `class` c on c.id = e.class_id
inner join sys_level level_info on cast(level_info.id as char) = c.level
inner join practice_paper_rule_definition definition
on right(trim(level_info.name), char_length(definition.level_grade)) = definition.level_grade
and definition.name = concat(definition.level_grade, '实操默认规则')
on definition.level_grade = trim(level_info.name)
and definition.name in (
concat(trim(level_info.name), '实操默认规则'),
concat(right(trim(level_info.name), 2), '实操默认规则')
)
set e.practice_rule_id = definition.id,
e.total_score = coalesce(e.total_score, definition.total_score),
e.pass_score = coalesce(e.pass_score, round(definition.total_score * 0.60, 2))
......
......@@ -145,3 +145,7 @@ SQL 应全部返回空结果,否则管理端树或分页接口会明确报告
原 `/theoretical/library` 分页、旧模板导入、编辑、删除和导出继续保留。旧格式导入完成后
服务端自动创建新节点并回填管理字段。随机组卷和模拟练习仍按原 `scope/章/节` 参数调用,
但只会抽取题目启用、允许组卷且所属节点整条祖先链均启用的数据。
其中 `POST /theoretical/library/import` 仍只接收原有的 `file` 表单字段,但必须携带管理员
`Authorization`。服务端从 JWT 获取当前管理员,并将其用户 ID 和可读名称同时记录到本次
导入的试题及新建层级节点;已存在节点的原创建人不会被覆盖。
package com.platform.business.controller;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.TheoreticalLibraryService;
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.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.util.ReflectionTestUtils;
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.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 旧格式理论题库接口的登录用户传递与管理员鉴权测试。 */
@ExtendWith(MockitoExtension.class)
class TheoreticalLibraryControllerTest {
@Mock
private TheoreticalLibraryService theoreticalLibraryService;
@Mock
private AuthenticatedUserService authenticatedUserService;
private TheoreticalLibraryController controller;
private MockHttpServletRequest request;
private MockMultipartFile file;
@BeforeEach
void setUp() {
controller = new TheoreticalLibraryController();
ReflectionTestUtils.setField(controller, "theoreticalLibraryService",
theoreticalLibraryService);
ReflectionTestUtils.setField(controller, "authenticatedUserService",
authenticatedUserService);
request = new MockHttpServletRequest();
file = new MockMultipartFile("file", "污水一级.xlsx",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
new byte[]{1});
}
@Test
void legacyImportShouldAuthenticateAdministratorAndPassIdentityToService() throws Exception {
UserEntity administrator = new UserEntity();
administrator.setId("admin-1");
when(authenticatedUserService.current(request)).thenReturn(administrator);
controller.importTheoreticalLibrary(file, request);
// 创建人只能使用服务端认证结果,上传文件和请求参数都不能覆盖该用户对象。
verify(authenticatedUserService).requireAdmin(administrator);
verify(theoreticalLibraryService).importTheoreticalLibrary(file, administrator);
}
@Test
void legacyImportShouldStopBeforeServiceWhenUserIsNotAdministrator() throws Exception {
UserEntity user = new UserEntity();
when(authenticatedUserService.current(request)).thenReturn(user);
doThrow(new BusinessException("只有管理员可以访问管理端接口"))
.when(authenticatedUserService).requireAdmin(user);
assertThrows(BusinessException.class,
() -> controller.importTheoreticalLibrary(file, request));
verify(theoreticalLibraryService, never())
.importTheoreticalLibrary(any(), any());
}
}
......@@ -7,7 +7,11 @@ import com.platform.business.model.dto.PracticePaperRuleSaveDTO;
import com.platform.business.model.entity.PracticePaperRuleDefinitionEntity;
import com.platform.business.model.entity.PracticePaperRuleDetailEntity;
import com.platform.business.model.entity.PracticePaperRuleEntity;
import com.platform.business.model.entity.SysLevelEntity;
import com.platform.business.model.vo.ClassAdminOptionVO;
import com.platform.business.model.vo.PracticePaperRuleConfigurationVO;
import com.platform.business.model.vo.PracticePaperRuleItemVO;
import com.platform.business.service.SysLevelService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
......@@ -30,6 +34,7 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
......@@ -40,44 +45,52 @@ class PracticePaperRuleServiceImplTest {
@Mock
private PracticePaperRuleMapper mapper;
@Mock
private SysLevelService sysLevelService;
private PracticePaperRuleServiceImpl service;
@BeforeEach
void setUp() {
service = new PracticePaperRuleServiceImpl();
ReflectionTestUtils.setField(service, "ruleMapper", mapper);
ReflectionTestUtils.setField(service, "sysLevelService", sysLevelService);
lenient().when(sysLevelService.list(any(Wrapper.class)))
.thenReturn(Arrays.asList(activeLevel()));
}
@Test
@SuppressWarnings("unchecked")
void createShouldNormalizeSuffixAndPersistCalculatedSnapshots() {
void createShouldPreserveCompleteLevelAndPersistCalculatedSnapshots() {
List<PracticePaperRuleEntity> catalog = Arrays.asList(
catalog(1, "一级", "运行管理", "项目开发"),
catalog(2, "一级", "安全管理", "现场安全管理"));
when(mapper.selectList(any(Wrapper.class))).thenReturn(catalog);
when(mapper.countDuplicateDefinition("一级", "规则A", null)).thenReturn(0);
when(mapper.countDuplicateDefinition("污泥一级", "规则A", null)).thenReturn(0);
when(mapper.insertDefinition(any())).thenAnswer(invocation -> {
PracticePaperRuleDefinitionEntity entity = invocation.getArgument(0);
entity.setId(10);
return 1;
});
when(mapper.insertDefinitionDetails(anyList())).thenReturn(2);
when(mapper.selectDefinition(10)).thenReturn(definition(10, "规则A", "一级",
when(mapper.selectDefinition(10)).thenReturn(definition(10, "规则A", "污泥一级",
3, 70, "50.50", "DRAFT"));
when(mapper.selectDefinitionDetails(10)).thenReturn(new ArrayList<>());
PracticePaperRuleSaveDTO request = request("规则A", "污泥一级", Arrays.asList(
item(1, 20, "20.00", 2), item(2, 30, "10.50", 1)));
service.create(request, "admin-1");
PracticePaperRuleConfigurationVO saved = service.create(request, "admin-1");
ArgumentCaptor<PracticePaperRuleDefinitionEntity> header =
ArgumentCaptor.forClass(PracticePaperRuleDefinitionEntity.class);
verify(mapper).insertDefinition(header.capture());
assertEquals("一级", header.getValue().getLevelGrade());
assertEquals("污泥一级", header.getValue().getLevelGrade());
assertEquals(3, header.getValue().getQuestionCount());
assertEquals(70, header.getValue().getTotalDuration());
assertEquals(new BigDecimal("50.50"), header.getValue().getTotalScore());
assertEquals("DRAFT", header.getValue().getStatus());
assertEquals("污泥一级", saved.getLev());
assertEquals("一级", saved.getGrade());
@SuppressWarnings("rawtypes")
ArgumentCaptor<List> details = ArgumentCaptor.forClass(List.class);
......@@ -113,7 +126,7 @@ class PracticePaperRuleServiceImplTest {
catalog(2, "一级", "安全管理", "现场安全管理")));
BusinessException error = assertThrows(BusinessException.class,
() -> service.create(request("规则A", "一级",
() -> service.create(request("规则A", "污水一级",
Arrays.asList(item(1, 20, "20.00", 1))), "admin-1"));
assertEquals("必须提交一级全部2条标准类目规则", error.getMessage());
......@@ -122,10 +135,10 @@ class PracticePaperRuleServiceImplTest {
@Test
@SuppressWarnings("unchecked")
void createShouldRejectDuplicateNameWithinSameGrade() {
void createShouldRejectDuplicateNameWithinSameCompleteLevel() {
when(mapper.selectList(any(Wrapper.class))).thenReturn(Arrays.asList(
catalog(1, "一级", "运行管理", "项目开发")));
when(mapper.countDuplicateDefinition("一级", "重复规则", null)).thenReturn(1);
when(mapper.countDuplicateDefinition("污水一级", "重复规则", null)).thenReturn(1);
BusinessException error = assertThrows(BusinessException.class,
() -> service.create(request("重复规则", "污水一级",
......@@ -151,17 +164,17 @@ class PracticePaperRuleServiceImplTest {
@SuppressWarnings("unchecked")
void updateShouldReplaceCompleteDraftDetails() {
when(mapper.lockDefinition(7)).thenReturn(
definition(7, "旧名称", "一级", 1, 20, "20", "DRAFT"));
definition(7, "旧名称", "污水一级", 1, 20, "20", "DRAFT"));
when(mapper.selectList(any(Wrapper.class))).thenReturn(Arrays.asList(
catalog(1, "一级", "运行管理", "项目开发")));
when(mapper.countDuplicateDefinition("一级", "新名称", 7)).thenReturn(0);
when(mapper.countDuplicateDefinition("污水一级", "新名称", 7)).thenReturn(0);
when(mapper.updateDefinition(any())).thenReturn(1);
when(mapper.insertDefinitionDetails(anyList())).thenReturn(1);
when(mapper.selectDefinition(7)).thenReturn(
definition(7, "新名称", "一级", 2, 50, "30", "DRAFT"));
definition(7, "新名称", "污水一级", 2, 50, "30", "DRAFT"));
when(mapper.selectDefinitionDetails(7)).thenReturn(new ArrayList<>());
service.update(7, request("新名称", "一级",
service.update(7, request("新名称", "污水一级",
Arrays.asList(item(1, 25, "15.00", 2))), "admin-1");
verify(mapper).deleteDefinitionDetails(7);
......@@ -171,7 +184,7 @@ class PracticePaperRuleServiceImplTest {
@Test
void publishShouldOnlyMoveDraftDirectlyToPublished() {
when(mapper.lockDefinition(9)).thenReturn(
definition(9, "待发布规则", "三级", 1, 20, "20", "DRAFT"));
definition(9, "待发布规则", "污水三级", 1, 20, "20", "DRAFT"));
PracticePaperRuleItemVO detail = new PracticePaperRuleItemVO();
detail.setCatalogId(1);
detail.setQuestionCount(1);
......@@ -179,7 +192,7 @@ class PracticePaperRuleServiceImplTest {
when(mapper.updateDefinitionStatus(eq(9), eq("PUBLISHED"), eq("admin-1"), any()))
.thenReturn(1);
when(mapper.selectDefinition(9)).thenReturn(
definition(9, "待发布规则", "三级", 1, 20, "20", "PUBLISHED"));
definition(9, "待发布规则", "污水三级", 1, 20, "20", "PUBLISHED"));
assertEquals("PUBLISHED", service.publish(9, "published", "admin-1").getStatus());
verify(mapper).updateDefinitionStatus(eq(9), eq("PUBLISHED"), eq("admin-1"), any());
......@@ -188,7 +201,7 @@ class PracticePaperRuleServiceImplTest {
@Test
void deleteShouldProtectUsedRuleRegardlessOfStatus() {
when(mapper.lockDefinition(8)).thenReturn(
definition(8, "规则C", "二级", 5, 100, "100", "DRAFT"));
definition(8, "规则C", "污泥二级", 5, 100, "100", "DRAFT"));
when(mapper.countDefinitionUsage(8)).thenReturn(1);
BusinessException error = assertThrows(BusinessException.class, () -> service.delete(8));
......@@ -200,7 +213,7 @@ class PracticePaperRuleServiceImplTest {
@Test
void deleteShouldAllowUnusedPublishedRule() {
when(mapper.lockDefinition(8)).thenReturn(
definition(8, "规则C", "二级", 5, 100, "100", "PUBLISHED"));
definition(8, "规则C", "污泥二级", 5, 100, "100", "PUBLISHED"));
when(mapper.countDefinitionUsage(8)).thenReturn(0);
when(mapper.deleteDefinition(8)).thenReturn(1);
......@@ -212,19 +225,65 @@ class PracticePaperRuleServiceImplTest {
@Test
void pageShouldExposePublishedUnusedRuleAsDeletableButNotEditable() {
com.platform.business.model.vo.PracticePaperRuleConfigurationVO row =
new com.platform.business.model.vo.PracticePaperRuleConfigurationVO();
PracticePaperRuleConfigurationVO row = new PracticePaperRuleConfigurationVO();
row.setLev("污水四级");
row.setStatus("PUBLISHED");
row.setUsageCount(0);
when(mapper.pageDefinitions(any())).thenReturn(Arrays.asList(row));
com.platform.business.model.vo.PracticePaperRuleConfigurationVO result =
service.queryPage(null).get(0);
PracticePaperRuleConfigurationVO result = service.queryPage(null).get(0);
assertFalse(result.getEditable());
assertFalse(result.getPublishable());
assertEquals(true, result.getDeletable());
assertEquals("已发布", result.getStatusLabel());
assertEquals("污水四级", result.getLev());
assertEquals("四级", result.getGrade());
}
@Test
void pageFilterShouldKeepCompleteLevelInsteadOfNormalizingToGrade() {
com.platform.business.model.dto.PracticePaperRuleQueryDTO query =
new com.platform.business.model.dto.PracticePaperRuleQueryDTO();
query.setLev(" 污泥五级 ");
when(mapper.pageDefinitions(query)).thenReturn(new ArrayList<>());
service.queryPage(query);
assertEquals("污泥五级", query.getLev());
verify(mapper).pageDefinitions(query);
}
@Test
void publishedOptionsShouldUseCompleteLevel() {
when(mapper.selectPublishedOptions("污水一级"))
.thenReturn(Arrays.asList(new ClassAdminOptionVO()));
assertEquals(1, service.publishedOptions("污水一级").size());
verify(mapper).selectPublishedOptions("污水一级");
}
@Test
void requirePublishedDefinitionShouldRejectSameGradeFromDifferentOccupation() {
when(mapper.lockDefinition(6)).thenReturn(
definition(6, "污泥规则", "污泥一级", 1, 20, "20", "PUBLISHED"));
BusinessException error = assertThrows(BusinessException.class,
() -> service.requirePublishedDefinition(6, "污水一级"));
assertEquals("所选实操试卷规则与班级职业等级不匹配", error.getMessage());
}
@Test
void completeLevelValidationShouldRejectBareAndInactiveLevels() {
BusinessException bare = assertThrows(BusinessException.class,
() -> service.catalog("一级"));
assertEquals("使用职级只支持污水一级至污水五级或污泥一级至污泥五级", bare.getMessage());
when(sysLevelService.list(any(Wrapper.class))).thenReturn(new ArrayList<>());
BusinessException inactive = assertThrows(BusinessException.class,
() -> service.catalog("污水一级"));
assertEquals("使用职级不存在或已停用", inactive.getMessage());
}
private PracticePaperRuleSaveDTO request(String name, String level,
......@@ -267,4 +326,11 @@ class PracticePaperRuleServiceImplTest {
row.setStatus(status);
return row;
}
private SysLevelEntity activeLevel() {
SysLevelEntity level = new SysLevelEntity();
level.setName("污水一级");
level.setHiddeFlag(false);
return level;
}
}
......@@ -4,6 +4,7 @@ import com.platform.business.mapper.TheoreticalLibraryMapper;
import com.platform.business.mapper.TheoreticalLibraryNodeMapper;
import com.platform.business.model.entity.TheoreticalLibraryEntity;
import com.platform.business.model.entity.TheoreticalLibraryNodeEntity;
import com.platform.business.model.entity.UserEntity;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
......@@ -13,6 +14,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
......@@ -68,7 +70,9 @@ class TheoreticalLibraryServiceImplTest {
}).when(nodeMapper).insert(any(TheoreticalLibraryNodeEntity.class));
when(libraryMapper.updateById(any(TheoreticalLibraryEntity.class))).thenReturn(1);
ReflectionTestUtils.invokeMethod(service, "synchronizeImportedScope", "污水一级");
UserEntity administrator = administrator();
ReflectionTestUtils.invokeMethod(service, "synchronizeImportedScope",
"污水一级", administrator);
ArgumentCaptor<TheoreticalLibraryNodeEntity> nodeCaptor =
ArgumentCaptor.forClass(TheoreticalLibraryNodeEntity.class);
......@@ -84,10 +88,79 @@ class TheoreticalLibraryServiceImplTest {
assertTrue(insertedNames.contains("未分类知识点"));
assertEquals("JOB", incompleteQuestion.getBankType());
assertNotNull(incompleteQuestion.getNodeId());
assertEquals("admin-1", incompleteQuestion.getCreateUserId());
assertEquals("题库管理员", incompleteQuestion.getCreateUserName());
// 本次导入新建的所有层级节点均应记录同一位管理员,避免节点和试题审计信息不一致。
insertedNodes.forEach(node -> {
assertEquals("admin-1", node.getCreateUserId());
assertEquals("题库管理员", node.getCreateUserName());
});
verify(libraryMapper).updateById(incompleteQuestion);
verify(libraryMapper, never()).updateById(emptySection);
}
@Test
void competitionLegacyImportShouldWriteCurrentAdministrator() {
TheoreticalLibraryEntity question = row("competition-question", true);
question.setScope("技能竞赛");
question.setFirstLevelName("污水处理竞赛");
question.setSecondLevelName("理论知识");
question.setThirdLevelName("基础知识");
question.setType("判断题");
when(libraryMapper.selectList(any())).thenReturn(Arrays.asList(question));
when(nodeMapper.selectOne(any())).thenReturn(null);
AtomicInteger idSequence = new AtomicInteger();
doAnswer(invocation -> {
TheoreticalLibraryNodeEntity node = invocation.getArgument(0);
node.setId("competition-" + idSequence.incrementAndGet());
return 1;
}).when(nodeMapper).insert(any(TheoreticalLibraryNodeEntity.class));
when(libraryMapper.updateById(any(TheoreticalLibraryEntity.class))).thenReturn(1);
ReflectionTestUtils.invokeMethod(service, "synchronizeImportedScope",
"技能竞赛", administrator());
assertEquals("COMP", question.getBankType());
assertEquals("admin-1", question.getCreateUserId());
assertEquals("题库管理员", question.getCreateUserName());
assertNotNull(question.getNodeId());
}
@Test
void legacyImportShouldPreserveCreatorWhenNodeAlreadyExists() {
TheoreticalLibraryNodeEntity existing = new TheoreticalLibraryNodeEntity();
existing.setId("existing-node");
existing.setCreateUserId("original-admin");
existing.setCreateUserName("原创建人");
when(nodeMapper.selectOne(any())).thenReturn(existing);
TheoreticalLibraryNodeEntity result = ReflectionTestUtils.invokeMethod(service,
"ensureLegacyNode", new HashMap<String, TheoreticalLibraryNodeEntity>(),
"JOB", "0", "CRAFT", "污水", 10, administrator());
assertEquals("existing-node", result.getId());
assertEquals("original-admin", result.getCreateUserId());
assertEquals("原创建人", result.getCreateUserName());
verify(nodeMapper, never()).insert(any(TheoreticalLibraryNodeEntity.class));
}
@Test
void creatorDisplayNameShouldUseStableFallbackOrder() {
UserEntity user = new UserEntity();
user.setId("admin-id");
user.setNickName(" 管理员姓名 ");
user.setUsername("admin-account");
user.setPhoneNumber("13800000000");
assertEquals("管理员姓名", ReflectionTestUtils.invokeMethod(service, "displayName", user));
user.setNickName(" ");
assertEquals("admin-account", ReflectionTestUtils.invokeMethod(service, "displayName", user));
user.setUsername(null);
assertEquals("13800000000", ReflectionTestUtils.invokeMethod(service, "displayName", user));
user.setPhoneNumber(null);
assertEquals("admin-id", ReflectionTestUtils.invokeMethod(service, "displayName", user));
}
/** 构造仅包含同步链路所需字段的旧表记录。 */
private TheoreticalLibraryEntity row(String id, boolean question) {
TheoreticalLibraryEntity row = new TheoreticalLibraryEntity();
......@@ -96,4 +169,14 @@ class TheoreticalLibraryServiceImplTest {
row.setIsProblem(question);
return row;
}
/** 构造旧模板导入链路中由控制器认证并传入的管理员。 */
private UserEntity administrator() {
UserEntity administrator = new UserEntity();
administrator.setId("admin-1");
administrator.setNickName("题库管理员");
administrator.setUsername("library-admin");
administrator.setPhoneNumber("13800000000");
return administrator;
}
}
......@@ -34,12 +34,14 @@ class PracticePaperRuleMigrationSqlTest {
assertTrue(sql.contains("'设施设备操作'"));
assertFalse(sql.contains("'设施设备擦欧总'"));
assertTrue(sql.contains("'新业态项目安全管理'"));
// 五个等级的目录条数必须与迁移约定完全一致,明细迁移会为每个目录生成一条记录。
assertEquals(6, occurrences(sql, "('五级',"));
assertEquals(6, occurrences(sql, "('四级',"));
assertEquals(6, occurrences(sql, "('三级',"));
assertEquals(9, occurrences(sql, "('二级',"));
assertEquals(9, occurrences(sql, "('一级',"));
// 只统计标准类目种子区,避免后续历史迁移的等级枚举影响目录条数断言。
String catalogSql = sql.substring(0,
sql.indexOf("-- ==================== 具名规则主表与明细 ===================="));
assertEquals(6, occurrences(catalogSql, "('五级',"));
assertEquals(6, occurrences(catalogSql, "('四级',"));
assertEquals(6, occurrences(catalogSql, "('三级',"));
assertEquals(9, occurrences(catalogSql, "('二级',"));
assertEquals(9, occurrences(catalogSql, "('一级',"));
assertTrue(sql.contains("create table if not exists practice_paper_rule_definition"));
assertTrue(sql.contains("create table if not exists practice_paper_rule_detail"));
assertTrue(sql.contains("create table if not exists exam_teacher_assignment"));
......@@ -52,6 +54,14 @@ class PracticePaperRuleMigrationSqlTest {
assertTrue(sql.contains("where e.type = '实训' and e.practice_rule_id is null"));
assertTrue(sql.contains("information_schema.columns"));
assertTrue(sql.contains("information_schema.statistics"));
assertTrue(sql.contains("modify column level_grade varchar(32) not null"));
assertTrue(sql.contains("create temporary table tmp_practice_rule_targets"));
assertTrue(sql.contains("instr(definition.name, trim(level_info.name)) > 0"));
assertTrue(sql.contains("target.target_level = trim(level_info.name)"));
assertTrue(sql.contains("set e.practice_rule_id = target_definition.id"));
assertTrue(sql.contains("signal sqlstate '45000'"));
assertTrue(sql.contains("uk_practice_definition_level_name"));
assertTrue(sql.contains("idx_practice_definition_level_status"));
}
private int occurrences(String source, String token) {
......
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