"...git@gitlab.ruzhoukj.com:wujipeng/practical_train.git" did not exist on "9e0dacc763c3fd21e6ce1ce8ce70f55a01a9f7ce"
Commit 9fc77652 authored by wujipeng's avatar wujipeng
Browse files

管理员-题库管理-理论题库

parent 5fe1aba7
package com.platform.business.model.dto;
import lombok.Data;
import java.util.List;
/** 批量删除的 ID 集合。 */
@Data
public class TheoreticalLibraryBatchDTO {
private List<String> ids;
}
package com.platform.business.model.dto;
import lombok.Data;
import java.util.List;
/** 批量启停试题请求。 */
@Data
public class TheoreticalLibraryBatchStatusDTO {
private List<String> ids;
private Integer status;
}
package com.platform.business.model.dto;
import lombok.Data;
import java.util.List;
/** 批量转移试题所属层级请求。 */
@Data
public class TheoreticalLibraryBatchTransferDTO {
private List<String> ids;
private String targetNodeId;
}
package com.platform.business.model.dto;
import lombok.Data;
/** Excel 导出配置。 */
@Data
public class TheoreticalLibraryExportDTO {
/** STRUCTURE 或 QUESTION。 */
private String dataType;
private String bankType;
/** ALL 或 FILTERED。 */
private String scope;
private Boolean includeAnswer;
private TheoreticalLibraryQuestionQueryDTO query;
}
package com.platform.business.model.dto;
import lombok.Data;
/** 节点同级移动请求,direction 仅允许 UP 或 DOWN。 */
@Data
public class TheoreticalLibraryNodeMoveDTO {
private String direction;
}
package com.platform.business.model.dto;
import lombok.Data;
/** 新增或编辑题库层级节点的请求。 */
@Data
public class TheoreticalLibraryNodeSaveDTO {
private String bankType;
private String parentId;
private String name;
private String code;
private Integer sortNo;
private Integer status;
private String remark;
}
package com.platform.business.model.dto;
import lombok.Data;
/** 选择题选项;标签由服务端按 A-E 顺序重新生成。 */
@Data
public class TheoreticalLibraryOptionDTO {
private String label;
private String text;
private Boolean correct;
}
package com.platform.business.model.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
import java.util.List;
/** 管理端试题分页、全选和导出共用筛选条件。 */
@Data
public class TheoreticalLibraryQuestionQueryDTO {
private Integer pageNum;
private Integer pageSize;
private String bankType;
private String nodeId;
private String type;
private String keyword;
private Integer status;
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date createStart;
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date createEnd;
/** 服务层展开选中节点后写入,客户端提交值会被覆盖。 */
private List<String> nodeIds;
}
package com.platform.business.model.dto;
import lombok.Data;
import java.util.List;
/** 管理端新增、编辑试题请求。创建人、旧层级冗余字段均由服务端生成。 */
@Data
public class TheoreticalLibraryQuestionSaveDTO {
private String nodeId;
private String type;
private Double score;
private String difficulty;
private Integer status;
private Boolean noExam;
private List<String> keywords;
private String stem;
private List<TheoreticalLibraryOptionDTO> options;
private String answer;
private String analysis;
}
package com.platform.business.model.dto;
import lombok.Data;
/** 节点或试题启停请求。 */
@Data
public class TheoreticalLibraryStatusDTO {
private Integer status;
}
package com.platform.business.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author : wujipeng
* @date : 2025/10/29 15:12
......@@ -92,5 +96,46 @@ public class TheoreticalLibraryEntity {
@ApiModelProperty("是否参与组卷")
private Boolean participate;
/** 新管理端题库类型:JOB 职级题库,COMP 竞赛题库。 */
@TableField("bank_type")
private String bankType;
/** 题目绑定的末级层级节点 ID;旧数据由增量脚本回填。 */
@TableField("node_id")
private String nodeId;
/** 题目默认分值,允许 0.5 等小数。 */
private Double score;
/** 难度代码:EASY、MEDIUM、HARD。 */
private String difficulty;
/** 题目状态:1 启用,0 禁用。 */
private Integer status;
/** 关键词标签的 JSON 数组字符串,避免破坏旧表结构。 */
private String keywords;
/** 题目解析。 */
private String analysis;
/** 创建人用户 ID,由服务端登录态写入。 */
@TableField("create_user_id")
private String createUserId;
/** 创建人姓名快照,避免账号改名后历史展示变化。 */
@TableField("create_user_name")
private String createUserName;
/** 创建时间,由统一元数据处理器填充。 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/** 最后更新时间,由统一元数据处理器填充。 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
}
package com.platform.business.model.entity;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
/**
* 理论题库层级节点。
*
* <p>节点与题目分表保存,避免继续依赖旧表中 {@code is_problem=false} 的伪层级行。
* {@code parentId="0"} 表示题库根节点,便于 MySQL 对根节点也执行同级编码唯一约束。</p>
*/
@Data
@TableName("theoretical_library_node")
public class TheoreticalLibraryNodeEntity {
@TableId(type = IdType.ASSIGN_ID)
private String id;
/** JOB 职级题库,COMP 竞赛题库。 */
@TableField("bank_type")
private String bankType;
/** 根节点统一使用字符串 0,不使用 NULL。 */
@TableField("parent_id")
private String parentId;
/** CRAFT、LEVEL、CHAPTER、SECTION、TOPIC、POINT 等稳定节点类型代码。 */
@TableField("node_type")
private String nodeType;
private String name;
private String code;
@TableField("sort_no")
private Integer sortNo;
/** 1 启用,0 禁用。 */
private Integer status;
private String remark;
@TableField("create_user_id")
private String createUserId;
@TableField("create_user_name")
private String createUserName;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
}
package com.platform.business.model.vo;
import lombok.Data;
/** Excel 导入结果;存在失败行时 errorFileId 用于下载错误明细。 */
@Data
public class TheoreticalLibraryImportResultVO {
private int successCount;
private int failureCount;
private Integer errorFileId;
}
package com.platform.business.model.vo;
import lombok.Data;
/** 叶子节点直接关联题量聚合结果。 */
@Data
public class TheoreticalLibraryNodeCountVO {
private String nodeId;
private Long questionCount;
}
package com.platform.business.model.vo;
import com.platform.business.model.entity.TheoreticalLibraryNodeEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.ArrayList;
import java.util.List;
/** 树节点响应,题量为当前节点整棵子树的有效题目总数。 */
@Data
@EqualsAndHashCode(callSuper = true)
public class TheoreticalLibraryNodeVO extends TheoreticalLibraryNodeEntity {
private Long questionCount = 0L;
private String fullPath;
private List<TheoreticalLibraryNodeVO> children = new ArrayList<>();
}
package com.platform.business.model.vo;
import com.platform.business.model.dto.TheoreticalLibraryOptionDTO;
import com.platform.business.model.entity.TheoreticalLibraryEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
/** 管理端试题列表与详情响应。 */
@Data
@EqualsAndHashCode(callSuper = true)
public class TheoreticalLibraryQuestionVO extends TheoreticalLibraryEntity {
/** 与旧实体 problem 同值,提供给新版页面使用的语义化字段。 */
private String stem;
private String typeCode;
private String typeLabel;
private String difficultyLabel;
private String fullPath;
private Boolean noExam;
private String answerText;
private List<String> keywordList;
private List<TheoreticalLibraryOptionDTO> options;
}
package com.platform.business.constant;
import com.platform.exception.BusinessException;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 理论题库管理端稳定代码及兼容映射。
*
* <p>数据库继续保存旧业务使用的中文题型,管理端接口使用稳定英文代码;所有转换集中
* 在本类,避免控制器、Excel 和随机组卷各自维护一份容易漂移的映射。</p>
*/
public final class TheoreticalLibraryAdminConstants {
public static final String BANK_JOB = "JOB";
public static final String BANK_COMP = "COMP";
public static final String ROOT_PARENT_ID = "0";
public static final long MAX_IMPORT_FILE_SIZE = 10L * 1024 * 1024;
public static final int MAX_BATCH_SIZE = 5000;
public static final List<String> JOB_NODE_TYPES = Collections.unmodifiableList(Arrays.asList(
"CRAFT", "LEVEL", "CHAPTER", "SECTION", "TOPIC", "POINT"));
public static final List<String> COMP_NODE_TYPES = Collections.unmodifiableList(Arrays.asList(
"COMPETITION", "CATEGORY", "DIRECTION"));
private static final Map<String, String> TYPE_LABELS = new LinkedHashMap<>();
private static final Map<String, String> TYPE_CODES = new LinkedHashMap<>();
private static final Map<String, String> DIFFICULTY_LABELS = new LinkedHashMap<>();
static {
registerType("SINGLE", "单选题");
registerType("MULTI", "多选题");
registerType("JUDGE", "判断题");
registerType("FILL", "填空题");
registerType("SHORT", "简答题");
registerType("CALC", "计算题");
// 旧库中的“主观题”按简答题展示,但保存新数据时统一使用“简答题”。
TYPE_CODES.put("主观题", "SHORT");
DIFFICULTY_LABELS.put("EASY", "易");
DIFFICULTY_LABELS.put("MEDIUM", "中");
DIFFICULTY_LABELS.put("HARD", "难");
}
private TheoreticalLibraryAdminConstants() {
}
private static void registerType(String code, String label) {
TYPE_LABELS.put(code, label);
TYPE_CODES.put(label, code);
}
public static List<String> nodeTypes(String bankType) {
if (BANK_JOB.equals(normalizeBankType(bankType))) {
return JOB_NODE_TYPES;
}
return COMP_NODE_TYPES;
}
public static String normalizeBankType(String bankType) {
String value = bankType == null ? "" : bankType.trim().toUpperCase();
if (!BANK_JOB.equals(value) && !BANK_COMP.equals(value)) {
throw new BusinessException("题库类型仅支持JOB或COMP");
}
return value;
}
public static String normalizeTypeCode(String type) {
String value = type == null ? "" : type.trim().toUpperCase();
if (TYPE_LABELS.containsKey(value)) {
return value;
}
String code = TYPE_CODES.get(type == null ? null : type.trim());
if (code == null) {
throw new BusinessException("不支持的题型");
}
return code;
}
public static String typeLabel(String typeCode) {
return TYPE_LABELS.get(normalizeTypeCode(typeCode));
}
public static String typeCodeFromDatabase(String databaseType) {
String code = TYPE_CODES.get(databaseType);
return code == null ? "SHORT" : code;
}
public static String normalizeDifficulty(String difficulty) {
String value = difficulty == null ? "" : difficulty.trim().toUpperCase();
if (!DIFFICULTY_LABELS.containsKey(value)) {
throw new BusinessException("难度仅支持EASY、MEDIUM或HARD");
}
return value;
}
public static String difficultyLabel(String difficulty) {
return DIFFICULTY_LABELS.get(difficulty);
}
}
package com.platform.business.controller;
import com.github.pagehelper.PageHelper;
import com.platform.business.model.dto.TheoreticalLibraryBatchDTO;
import com.platform.business.model.dto.TheoreticalLibraryBatchStatusDTO;
import com.platform.business.model.dto.TheoreticalLibraryBatchTransferDTO;
import com.platform.business.model.dto.TheoreticalLibraryExportDTO;
import com.platform.business.model.dto.TheoreticalLibraryNodeMoveDTO;
import com.platform.business.model.dto.TheoreticalLibraryNodeSaveDTO;
import com.platform.business.model.dto.TheoreticalLibraryQuestionQueryDTO;
import com.platform.business.model.dto.TheoreticalLibraryQuestionSaveDTO;
import com.platform.business.model.dto.TheoreticalLibraryStatusDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.TheoreticalLibraryImportResultVO;
import com.platform.business.model.vo.TheoreticalLibraryNodeVO;
import com.platform.business.model.vo.TheoreticalLibraryQuestionVO;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.TheoreticalLibraryAdminService;
import com.platform.business.service.TheoreticalLibraryExcelService;
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.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 org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 管理员端“题库管理-理论题库”接口。
*
* <p>独立 admin 前缀保留旧接口兼容性;每个入口都先解析 JWT 并校验管理员角色,
* 创建人等审计字段只使用登录用户,不接受客户端伪造。</p>
*/
@Api(tags = "管理员端-理论题库管理")
@RestController
@RequestMapping("/theoretical/library/admin")
public class TheoreticalLibraryAdminController extends BaseController {
@Resource
private TheoreticalLibraryAdminService adminService;
@Resource
private TheoreticalLibraryExcelService excelService;
@Resource
private AuthenticatedUserService authenticatedUserService;
@ApiOperation("查询职级题库或竞赛题库层级树")
@GetMapping("/nodes/tree")
public Result<List<TheoreticalLibraryNodeVO>> tree(
@RequestParam("bankType") String bankType,
@RequestParam(value = "keyword", required = false) String keyword,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.tree(bankType, keyword));
}
@ApiOperation("新增层级节点")
@PostMapping("/nodes")
public Result<TheoreticalLibraryNodeVO> createNode(
@RequestBody TheoreticalLibraryNodeSaveDTO body, HttpServletRequest request) {
return Result.data(adminService.createNode(body, currentAdmin(request)));
}
@ApiOperation("编辑层级节点")
@PutMapping("/nodes/{id}")
public Result<TheoreticalLibraryNodeVO> updateNode(
@PathVariable String id, @RequestBody TheoreticalLibraryNodeSaveDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.updateNode(id, body));
}
@ApiOperation("同级上移或下移节点")
@PutMapping("/nodes/{id}/move")
public Result<Boolean> moveNode(@PathVariable String id,
@RequestBody TheoreticalLibraryNodeMoveDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.moveNode(id, body));
}
@ApiOperation("启用或禁用节点")
@PutMapping("/nodes/{id}/status")
public Result<Boolean> changeNodeStatus(@PathVariable String id,
@RequestBody TheoreticalLibraryStatusDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.changeNodeStatus(id,
body == null ? null : body.getStatus()));
}
@ApiOperation("彻底删除节点子树及关联试题")
@DeleteMapping("/nodes/{id}")
public Result<Boolean> deleteNode(@PathVariable String id,
@RequestParam("cascade") boolean cascade,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.deleteNode(id, cascade));
}
@ApiOperation("分页筛选理论题库试题")
@PostMapping("/questions/page")
public TableDataInfo page(@RequestBody(required = false) TheoreticalLibraryQuestionQueryDTO query,
HttpServletRequest request) {
currentAdmin(request);
TheoreticalLibraryQuestionQueryDTO safeQuery = query == null
? new TheoreticalLibraryQuestionQueryDTO() : query;
normalizePage(safeQuery);
startPage(safeQuery.getPageNum(), safeQuery.getPageSize());
try {
return getDataTable(adminService.page(safeQuery));
} finally {
// PageHelper 使用线程变量;异常路径同样清理,避免容器线程复用污染后续请求。
PageHelper.clearPage();
}
}
@ApiOperation("查询当前筛选结果的全部试题ID")
@PostMapping("/questions/filter-ids")
public Result<List<String>> filteredIds(
@RequestBody TheoreticalLibraryQuestionQueryDTO query,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.filteredIds(query));
}
@ApiOperation("试题预览或编辑回显详情")
@GetMapping("/questions/{id}")
public Result<TheoreticalLibraryQuestionVO> questionDetail(
@PathVariable String id, HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.detail(id));
}
@ApiOperation("新增试题")
@PostMapping("/questions")
public Result<TheoreticalLibraryQuestionVO> createQuestion(
@RequestBody TheoreticalLibraryQuestionSaveDTO body, HttpServletRequest request) {
return Result.data(adminService.createQuestion(body, currentAdmin(request)));
}
@ApiOperation("编辑试题")
@PutMapping("/questions/{id}")
public Result<TheoreticalLibraryQuestionVO> updateQuestion(
@PathVariable String id, @RequestBody TheoreticalLibraryQuestionSaveDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.updateQuestion(id, body));
}
@ApiOperation("复制试题")
@PostMapping("/questions/{id}/copy")
public Result<TheoreticalLibraryQuestionVO> copyQuestion(
@PathVariable String id, HttpServletRequest request) {
return Result.data(adminService.copyQuestion(id, currentAdmin(request)));
}
@ApiOperation("删除单道试题")
@DeleteMapping("/questions/{id}")
public Result<Boolean> deleteQuestion(@PathVariable String id, HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.deleteQuestion(id));
}
@ApiOperation("批量启用或禁用试题")
@PutMapping("/questions/batch/status")
public Result<Boolean> batchStatus(@RequestBody TheoreticalLibraryBatchStatusDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.batchStatus(body));
}
@ApiOperation("批量转移试题层级")
@PutMapping("/questions/batch/transfer")
public Result<Boolean> batchTransfer(@RequestBody TheoreticalLibraryBatchTransferDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.batchTransfer(body));
}
@ApiOperation("批量彻底删除试题")
@PostMapping("/questions/batch/delete")
public Result<Boolean> batchDelete(@RequestBody TheoreticalLibraryBatchDTO body,
HttpServletRequest request) {
currentAdmin(request);
return Result.data(adminService.batchDelete(body));
}
@ApiOperation("下载层级结构或试题导入模板")
@GetMapping("/templates/{dataType}")
public void template(@PathVariable String dataType,
@RequestParam("bankType") String bankType,
HttpServletRequest request, HttpServletResponse response) {
currentAdmin(request);
excelService.template(dataType, bankType, response);
}
@ApiOperation("增量或覆盖导入层级结构/试题")
@PostMapping("/imports")
public Result<TheoreticalLibraryImportResultVO> importData(
@RequestParam("dataType") String dataType,
@RequestParam("bankType") String bankType,
@RequestParam("mode") String mode,
@RequestParam("file") MultipartFile file,
HttpServletRequest request) {
return Result.data(excelService.importData(
dataType, bankType, mode, file, currentAdmin(request)));
}
@ApiOperation("下载导入错误明细")
@GetMapping("/imports/errors/{fileId}")
public void importErrors(@PathVariable Integer fileId, HttpServletRequest request) {
currentAdmin(request);
excelService.downloadImportErrors(fileId);
}
@ApiOperation("按配置导出层级结构或试题")
@PostMapping("/exports")
public void export(@RequestBody TheoreticalLibraryExportDTO body,
HttpServletRequest request, HttpServletResponse response) {
currentAdmin(request);
excelService.export(body, response);
}
/** 缺省第1页、每页10条,最大100条,防止题干和解析造成过大响应。 */
void normalizePage(TheoreticalLibraryQuestionQueryDTO 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);
}
/** 所有管理端入口统一执行登录解析和管理员角色校验。 */
private UserEntity currentAdmin(HttpServletRequest request) {
UserEntity admin = authenticatedUserService.current(request);
authenticatedUserService.requireAdmin(admin);
return admin;
}
}
......@@ -6,6 +6,9 @@ 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.vo.TheoreticalLibraryVO;
import com.platform.business.model.dto.TheoreticalLibraryQuestionQueryDTO;
import com.platform.business.model.vo.TheoreticalLibraryNodeCountVO;
import com.platform.business.model.vo.TheoreticalLibraryQuestionVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
......@@ -34,4 +37,17 @@ public interface TheoreticalLibraryMapper extends BaseMapper<TheoreticalLibraryE
List<TheoreticalLibraryEntity> groupByChapter(@Param("level") String level);
/** 管理端分页与导出共用查询,分页上下文由控制器设置。 */
List<TheoreticalLibraryQuestionVO> selectAdminQuestions(
@Param("query") TheoreticalLibraryQuestionQueryDTO query);
/** 页面“全选筛选结果”仅查询主键,避免加载题干和解析等大字段。 */
List<String> selectAdminQuestionIds(@Param("query") TheoreticalLibraryQuestionQueryDTO query);
/** 查询各末级节点直接关联题量,服务层再向祖先节点汇总。 */
List<TheoreticalLibraryNodeCountVO> selectQuestionCounts(@Param("bankType") String bankType);
/** 写操作前锁定题目,保证批量转移、覆盖导入与并发编辑不会互相覆盖。 */
TheoreticalLibraryEntity selectQuestionForUpdate(@Param("id") String id);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.entity.TheoreticalLibraryNodeEntity;
import org.apache.ibatis.annotations.Mapper;
/** 理论题库层级节点数据访问接口。 */
@Mapper
public interface TheoreticalLibraryNodeMapper extends BaseMapper<TheoreticalLibraryNodeEntity> {
}
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