package jnpf.tmsService.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
import jnpf.audit.sdk.annotation.AuditLog;
|
import jnpf.exception.DataException;
|
import jnpf.tmsEntity.TmsExamEntity;
|
import jnpf.tmsEntity.TmsExamItemEntity;
|
import jnpf.tmsEntity.TmsPaperEntity;
|
import jnpf.tmsEntity.TmsPaperQuestionEntity;
|
import jnpf.tmsEntity.TmsPaperSectionEntity;
|
import jnpf.tmsEntity.TmsPersonTaskEntity;
|
import jnpf.tmsEntity.TmsQuestionEntity;
|
import jnpf.tmsEntity.TmsQuestionOptionEntity;
|
import jnpf.tmsEntity.TmsTaskEntity;
|
import jnpf.tmsEntity.exam.TmsOnlineExamAttemptVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamDetailVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamGradeItemVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamListVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamOptionVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamPaperVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamQuery;
|
import jnpf.tmsEntity.exam.TmsOnlineExamQuestionVO;
|
import jnpf.tmsEntity.exam.TmsOnlineExamSubmitForm;
|
import jnpf.tmsEntity.exam.TmsOnlineExamSubmitResultVO;
|
import jnpf.tmsMapper.TmsExamItemMapper;
|
import jnpf.tmsMapper.TmsExamMapper;
|
import jnpf.tmsMapper.TmsPaperMapper;
|
import jnpf.tmsMapper.TmsPaperQuestionMapper;
|
import jnpf.tmsMapper.TmsPaperSectionMapper;
|
import jnpf.tmsMapper.TmsPersonTaskMapper;
|
import jnpf.tmsMapper.TmsQuestionMapper;
|
import jnpf.tmsMapper.TmsQuestionOptionMapper;
|
import jnpf.tmsMapper.TmsTaskMapper;
|
import jnpf.tmsService.TmsOnlineExamService;
|
import jnpf.tmsService.TmsPersonTaskService;
|
import jnpf.tmsEntity.enums.TmsPassFlag;
|
import jnpf.tmsEntity.enums.TmsOpenClosedInvalid;
|
import jnpf.tmsEntity.enums.TmsExamStatus;
|
import jnpf.tmsEntity.enums.TmsGradeStatus;
|
import jnpf.tmsEntity.enums.TmsPaperSortMode;
|
import jnpf.tmsEntity.enums.TmsQuestionType;
|
import jnpf.tmsEntity.enums.TmsPersonTaskStatus;
|
import jnpf.tmsEntity.enums.TmsTaskPublishStatus;
|
import jnpf.tmsEntity.enums.TmsEvalMode;
|
import jnpf.util.DateUtil;
|
import jnpf.util.RandomUtil;
|
import jnpf.util.StringUtil;
|
import jnpf.util.UserProvider;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
/**
|
* 学员在线考试：抽卷/开考、答题保存、交卷阅卷（客观题）、回写个人任务。
|
*
|
* <p>发布任务时若考核方式=考试，会预建 {@code tms_exam} 待考壳；开考优先复用未开考壳。
|
* 交卷后调用 {@link TmsPersonTaskService#writeBackExamResult}，不直接写档案目录。</p>
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class TmsOnlineExamServiceImpl implements TmsOnlineExamService {
|
private static final String FMT = "yyyy-MM-dd HH:mm:ss";
|
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
|
private final TmsPaperMapper paperMapper;
|
private final TmsPaperSectionMapper sectionMapper;
|
private final TmsPaperQuestionMapper paperQuestionMapper;
|
private final TmsQuestionMapper questionMapper;
|
private final TmsQuestionOptionMapper optionMapper;
|
private final TmsExamMapper examMapper;
|
private final TmsExamItemMapper examItemMapper;
|
private final TmsTaskMapper taskMapper;
|
private final TmsPersonTaskMapper personTaskMapper;
|
private final TmsPersonTaskService personTaskService;
|
/**
|
* 查询我的试卷/考试列表
|
*/
|
@Override
|
public List<TmsOnlineExamListVO> getMyPapers(TmsOnlineExamQuery query) {
|
String userId = UserProvider.getLoginUserId();
|
// 只展示与「我的培训任务」或「已有答卷」相关的试卷，避免题库全量试卷都出现在考试记录
|
Set<String> relatedPaperIds = this.loadRelatedPaperIds(userId);
|
if (relatedPaperIds.isEmpty()) {
|
query.setData(new ArrayList<>(), 0L);
|
return new ArrayList<>();
|
}
|
LambdaQueryWrapper<TmsPaperEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsPaperEntity::getBizStatus, TmsOpenClosedInvalid.OPEN.getCode());
|
qw.in(TmsPaperEntity::getId, relatedPaperIds);
|
if (StringUtil.isNotEmpty(query.getKeyword()) && !"null".equalsIgnoreCase(query.getKeyword())) {
|
qw.like(TmsPaperEntity::getPaperName, query.getKeyword().trim());
|
}
|
Date examFrom = this.parseDayStart(query.getExamTimeFrom());
|
Date examTo = this.parseDayEnd(query.getExamTimeTo());
|
// 试卷考试窗口与查询区间有交集即可（该时段内可考的试卷）
|
if (examFrom != null) {
|
qw.and(w -> w.isNull(TmsPaperEntity::getExamEnd).or().ge(TmsPaperEntity::getExamEnd, examFrom));
|
}
|
if (examTo != null) {
|
qw.and(w -> w.isNull(TmsPaperEntity::getExamStart).or().le(TmsPaperEntity::getExamStart, examTo));
|
}
|
qw.orderByDesc(TmsPaperEntity::getCreatorTime);
|
List<TmsPaperEntity> papers = this.paperMapper.selectList(qw);
|
Map<String, TmsExamEntity> examMap = this.loadLatestExams(userId, papers);
|
ArrayList<TmsOnlineExamListVO> all = new ArrayList<TmsOnlineExamListVO>();
|
for (TmsPaperEntity paper : papers) {
|
TmsExamEntity exam = examMap.get(paper.getId());
|
// 尚无答卷壳且任务未到可考：不进考试记录（学满后才会生成待考壳）
|
if (exam == null) {
|
continue;
|
}
|
String status = this.statusOf(exam);
|
if (StringUtil.isNotEmpty(query.getStatus()) && !"null".equalsIgnoreCase(query.getStatus()) && !query.getStatus().equals(status)) {
|
continue;
|
}
|
TmsOnlineExamListVO vo = this.toListVo(paper, exam, status);
|
if (!this.matchPassFlag(query.getPassFlag(), vo.getPassFlag())) {
|
continue;
|
}
|
if (!this.matchAttemptType(query.getAttemptType(), vo.getAttemptNo())) {
|
continue;
|
}
|
if (!this.matchCanRetake(query.getCanRetake(), vo.getCanRetake())) {
|
continue;
|
}
|
all.add(vo);
|
}
|
long current = query.getCurrentPage() > 0L ? query.getCurrentPage() : 1L;
|
long size = query.getPageSize() > 0L ? query.getPageSize() : 20L;
|
int from = (int)((current - 1L) * size);
|
int to = Math.min(from + (int)size, all.size());
|
ArrayList<TmsOnlineExamListVO> page = from >= all.size() ? new ArrayList<TmsOnlineExamListVO>() : new ArrayList(all.subList(from, to));
|
query.setData(page, (long)all.size());
|
return page;
|
}
|
|
/**
|
* 加载与我相关的试卷 ID
|
*/
|
private Set<String> loadRelatedPaperIds(String userId) {
|
LinkedHashSet<String> ids = new LinkedHashSet<>();
|
if (StringUtil.isEmpty(userId)) {
|
return ids;
|
}
|
List<TmsExamEntity> exams = this.examMapper.selectList(new LambdaQueryWrapper<TmsExamEntity>()
|
.eq(TmsExamEntity::getUserId, userId)
|
.select(TmsExamEntity::getPaperId));
|
for (TmsExamEntity exam : exams) {
|
if (exam != null && StringUtil.isNotEmpty(exam.getPaperId())) {
|
ids.add(exam.getPaperId());
|
}
|
}
|
List<TmsPersonTaskEntity> persons = this.personTaskMapper.selectList(new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getUserId, userId)
|
.ne(TmsPersonTaskEntity::getBizStatus, TmsPersonTaskStatus.CANCELLED.getCode()));
|
if (persons == null || persons.isEmpty()) {
|
return ids;
|
}
|
List<String> taskIds = persons.stream()
|
.map(TmsPersonTaskEntity::getTaskId)
|
.filter(StringUtil::isNotEmpty)
|
.distinct()
|
.collect(Collectors.toList());
|
if (taskIds.isEmpty()) {
|
return ids;
|
}
|
List<TmsTaskEntity> tasks = this.taskMapper.selectList(new LambdaQueryWrapper<TmsTaskEntity>()
|
.in(TmsTaskEntity::getId, taskIds)
|
.eq(TmsTaskEntity::getPublishStatus, TmsTaskPublishStatus.PUBLISHED.getCode())
|
.eq(TmsTaskEntity::getEvalMode, TmsEvalMode.EXAM.getCode()));
|
for (TmsTaskEntity task : tasks) {
|
if (task != null && StringUtil.isNotEmpty(task.getPaperId())) {
|
ids.add(task.getPaperId());
|
}
|
}
|
return ids;
|
}
|
|
/**
|
* 筛选合格标识
|
*/
|
private boolean matchPassFlag(String queryFlag, String passFlag) {
|
if (StringUtil.isEmpty(queryFlag) || "null".equalsIgnoreCase(queryFlag)) {
|
return true;
|
}
|
if ("none".equalsIgnoreCase(queryFlag) || "-".equals(queryFlag)) {
|
return StringUtil.isEmpty(passFlag);
|
}
|
String q = TmsPassFlag.normalize(queryFlag);
|
String p = TmsPassFlag.normalize(passFlag);
|
if (StringUtil.isNotEmpty(q) && q.equals(p)) {
|
return true;
|
}
|
return queryFlag.equals(passFlag);
|
}
|
|
/**
|
* 筛选考试次数类型（正考/补考）
|
*/
|
private boolean matchAttemptType(String attemptType, Integer attemptNo) {
|
if (StringUtil.isEmpty(attemptType) || "null".equalsIgnoreCase(attemptType)) {
|
return true;
|
}
|
int n = attemptNo == null ? 1 : attemptNo;
|
if ("first".equalsIgnoreCase(attemptType)) {
|
return n <= 1;
|
}
|
if ("retake".equalsIgnoreCase(attemptType)) {
|
return n > 1;
|
}
|
return true;
|
}
|
|
/**
|
* 筛选是否可补考
|
*/
|
private boolean matchCanRetake(String canRetake, Boolean value) {
|
if (StringUtil.isEmpty(canRetake) || "null".equalsIgnoreCase(canRetake)) {
|
return true;
|
}
|
boolean want = "1".equals(canRetake) || "true".equalsIgnoreCase(canRetake) || "yes".equalsIgnoreCase(canRetake);
|
return want == Boolean.TRUE.equals(value);
|
}
|
|
/**
|
* 解析日开始时间
|
*/
|
private Date parseDayStart(String day) {
|
if (StringUtil.isEmpty(day) || "null".equalsIgnoreCase(day)) {
|
return null;
|
}
|
String s = day.trim();
|
try {
|
if (s.matches("^\\d{10,13}$")) {
|
long ts = Long.parseLong(s);
|
if (s.length() == 10) {
|
ts = ts * 1000L;
|
}
|
return new Date(ts);
|
}
|
if (s.length() > 10) {
|
s = s.substring(0, 10);
|
}
|
return DateUtil.stringToDate(s + " 00:00:00");
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
/**
|
* 解析日结束时间
|
*/
|
private Date parseDayEnd(String day) {
|
if (StringUtil.isEmpty(day) || "null".equalsIgnoreCase(day)) {
|
return null;
|
}
|
String s = day.trim();
|
try {
|
if (s.matches("^\\d{10,13}$")) {
|
long ts = Long.parseLong(s);
|
if (s.length() == 10) {
|
ts = ts * 1000L;
|
}
|
// 结束日按当天 23:59:59
|
Date d = new Date(ts);
|
return DateUtil.stringToDate(DateUtil.dateToString(d, "yyyy-MM-dd") + " 23:59:59");
|
}
|
if (s.length() > 10) {
|
s = s.substring(0, 10);
|
}
|
return DateUtil.stringToDate(s + " 23:59:59");
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
/**
|
* 查询详情
|
*/
|
@Override
|
public TmsOnlineExamDetailVO getDetail(String paperId) {
|
if (StringUtil.isEmpty(paperId)) {
|
throw new DataException("请选择试卷");
|
}
|
TmsPaperEntity paper = this.paperMapper.selectById(paperId);
|
if (paper == null) {
|
throw new DataException("试卷不存在");
|
}
|
TmsExamEntity exam = this.latestExam(UserProvider.getLoginUserId(), paperId);
|
if (exam == null && !TmsOpenClosedInvalid.OPEN.equalsCode(paper.getBizStatus())) {
|
throw new DataException("试卷未开放");
|
}
|
TmsOnlineExamDetailVO vo = new TmsOnlineExamDetailVO();
|
vo.setId(paper.getId());
|
vo.setPaperId(paper.getId());
|
vo.setPaperName(paper.getPaperName());
|
vo.setStatus(this.statusOf(exam));
|
vo.setExamTimeText(this.timeText(paper.getExamStart(), paper.getExamEnd()));
|
vo.setTotalScore(paper.getTotalScore());
|
vo.setPassScore(paper.getPassScore());
|
vo.setDurationMin(paper.getDurationMin());
|
if (exam != null) {
|
vo.setExamId(exam.getId());
|
vo.setGotScore(exam.getTotalScore());
|
vo.setStartTime(this.fmt(exam.getStartTime()));
|
vo.setSubmitTime(this.fmt(exam.getSubmitTime()));
|
vo.setPassFlag(exam.getPassFlag());
|
vo.setGradeStatus(exam.getGradeStatus());
|
if (TmsExamStatus.SUBMITTED.equalsCode(exam.getExamStatus())) {
|
vo.setQuestions(this.toReviewQuestions(this.loadItems(exam.getId())));
|
if (vo.getTotalScore() == null) {
|
BigDecimal total = BigDecimal.ZERO;
|
for (TmsOnlineExamQuestionVO q : vo.getQuestions()) {
|
total = total.add(this.nvl(q.getScore()));
|
}
|
vo.setTotalScore(total);
|
}
|
}
|
}
|
this.fillRetakeMeta(vo, paper.getId(), exam, UserProvider.getLoginUserId());
|
vo.setAttempts(this.listAttempts(UserProvider.getLoginUserId(), paper.getId()));
|
return vo;
|
}
|
/**
|
* 考试回顾详情
|
*/
|
@Override
|
public TmsOnlineExamDetailVO getExamReview(String examId) {
|
if (StringUtil.isEmpty(examId)) {
|
throw new DataException("请选择答卷");
|
}
|
TmsExamEntity exam = this.examMapper.selectById(examId);
|
if (exam == null) {
|
throw new DataException("答卷不存在");
|
}
|
if (!Objects.equals(UserProvider.getLoginUserId(), exam.getUserId())) {
|
throw new DataException("无权查看该答卷");
|
}
|
if (!TmsExamStatus.SUBMITTED.equalsCode(exam.getExamStatus())) {
|
throw new DataException("交卷后才能进行考试回顾");
|
}
|
TmsPaperEntity paper = this.paperMapper.selectById((exam.getPaperId()));
|
if (paper == null) {
|
throw new DataException("试卷不存在");
|
}
|
TmsOnlineExamDetailVO vo = new TmsOnlineExamDetailVO();
|
vo.setId(paper.getId());
|
vo.setPaperId(paper.getId());
|
vo.setPaperName(paper.getPaperName());
|
vo.setStatus(this.statusOf(exam));
|
vo.setExamTimeText(this.timeText(paper.getExamStart(), paper.getExamEnd()));
|
vo.setTotalScore(paper.getTotalScore());
|
vo.setPassScore(paper.getPassScore() != null ? paper.getPassScore() : exam.getPassScore());
|
vo.setDurationMin(paper.getDurationMin());
|
vo.setExamId(exam.getId());
|
vo.setGotScore(exam.getTotalScore());
|
vo.setStartTime(this.fmt(exam.getStartTime()));
|
vo.setSubmitTime(this.fmt(exam.getSubmitTime()));
|
vo.setPassFlag(exam.getPassFlag());
|
vo.setGradeStatus(exam.getGradeStatus());
|
vo.setAttemptNo(Integer.valueOf(exam.getAttemptNo() == null ? 1 : exam.getAttemptNo()));
|
vo.setAttemptLabel(this.attemptLabel(vo.getAttemptNo()));
|
vo.setQuestions(this.toReviewQuestions(this.loadItems(exam.getId())));
|
if (vo.getTotalScore() == null) {
|
BigDecimal total = BigDecimal.ZERO;
|
for (TmsOnlineExamQuestionVO q : vo.getQuestions()) {
|
total = total.add(this.nvl(q.getScore()));
|
}
|
vo.setTotalScore(total);
|
}
|
return vo;
|
}
|
|
/**
|
* 查询考试尝试记录
|
*/
|
private List<TmsOnlineExamAttemptVO> listAttempts(String userId, String paperId) {
|
if (StringUtil.isEmpty(userId) || StringUtil.isEmpty(paperId)) {
|
return Collections.emptyList();
|
}
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.eq(TmsExamEntity::getPaperId, paperId);
|
qw.orderByAsc(TmsExamEntity::getAttemptNo);
|
qw.orderByAsc(TmsExamEntity::getCreatorTime);
|
List<TmsExamEntity> exams = this.examMapper.selectList(qw);
|
ArrayList<TmsOnlineExamAttemptVO> list = new ArrayList<TmsOnlineExamAttemptVO>(exams.size());
|
for (TmsExamEntity exam : exams) {
|
TmsOnlineExamAttemptVO row = new TmsOnlineExamAttemptVO();
|
row.setExamId(exam.getId());
|
int attemptNo = exam.getAttemptNo() == null ? 1 : exam.getAttemptNo();
|
row.setAttemptNo(Integer.valueOf(attemptNo));
|
row.setAttemptLabel(this.attemptLabel(attemptNo));
|
row.setStatus(this.statusOf(exam));
|
row.setGradeStatus(exam.getGradeStatus());
|
row.setStartTime(this.fmt(exam.getStartTime()));
|
row.setSubmitTime(this.fmt(exam.getSubmitTime()));
|
row.setGotScore(exam.getTotalScore());
|
row.setPassFlag(exam.getPassFlag());
|
list.add(row);
|
}
|
return list;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class, noRollbackFor = ExamTimedOutException.class)
|
/**
|
* 开考：优先复用发布时预建的未开考壳，否则新建尝试；受补考次数限制。
|
*/
|
public TmsOnlineExamPaperVO start(String paperId) {
|
if (StringUtil.isEmpty(paperId)) {
|
throw new DataException("请选择试卷");
|
}
|
String userId = UserProvider.getLoginUserId();
|
TmsExamEntity doing = this.findDoing(userId, paperId);
|
if (doing != null) {
|
if (this.isTimedOut(doing)) {
|
// 超时须先交卷再返回；抛异常会导致事务回滚，答卷一直停在考试中
|
this.submitInternal(doing, null);
|
TmsOnlineExamPaperVO vo = this.toPaperVo(doing, this.loadItems(doing.getId()));
|
vo.setAutoSubmitted(Boolean.TRUE);
|
vo.setRemainSeconds(Integer.valueOf(0));
|
return vo;
|
}
|
return this.toPaperVo(doing, this.loadItems(doing.getId()));
|
}
|
TmsPaperEntity paper = this.requireOpenPaper(paperId);
|
this.assertExamWindow(paper);
|
RetakeContext retake = this.resolveRetake(userId, paperId);
|
if (!retake.allowStart) {
|
throw new DataException(retake.message);
|
}
|
TmsExamEntity exam = this.createExam(paper, userId, retake);
|
return this.toPaperVo(exam, this.loadItems(exam.getId()));
|
}
|
/**
|
* 保存答题
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class, noRollbackFor = ExamTimedOutException.class)
|
public void saveAnswers(String examId, TmsOnlineExamSubmitForm form) {
|
TmsExamEntity exam = this.requireDoingExam(examId);
|
if (this.isTimedOut(exam)) {
|
this.submitInternal(exam, form == null ? null : form.getAnswers());
|
throw new ExamTimedOutException();
|
}
|
this.writeAnswers(exam.getId(), form == null ? null : form.getAnswers());
|
}
|
|
@Override
|
@Transactional(rollbackFor={Exception.class})
|
@AuditLog(action = "EXAM_SUBMIT", label = "在线考试交卷", bizType = "TMS_EXAM",
|
bizCodeExpr = "#examId", targetTable = "tms_exam", targetIdExpr = "#examId")
|
/**
|
* 交卷
|
*/
|
public TmsOnlineExamSubmitResultVO submit(String examId, TmsOnlineExamSubmitForm form) {
|
TmsExamEntity exam = this.requireDoingExam(examId);
|
return this.submitInternal(exam, form == null ? null : form.getAnswers());
|
}
|
|
/**
|
* 交卷内部处理（计分/落库）
|
*/
|
private TmsOnlineExamSubmitResultVO submitInternal(TmsExamEntity exam, Map<String, Object> answers) {
|
List<TmsExamItemEntity> items = this.loadItems(exam.getId());
|
HashMap<String, String> normalized = new HashMap<String, String>();
|
for (TmsExamItemEntity item : items) {
|
if (answers != null && answers.containsKey(item.getId())) {
|
normalized.put(item.getId(), this.normalizeAnswer(answers.get(item.getId()), item.getQuestionType()));
|
continue;
|
}
|
normalized.put(item.getId(), item.getUserAnswer() == null ? "" : item.getUserAnswer());
|
}
|
BigDecimal objective = BigDecimal.ZERO;
|
boolean pending = false;
|
ArrayList<TmsOnlineExamGradeItemVO> grades = new ArrayList<TmsOnlineExamGradeItemVO>();
|
Date now = new Date();
|
for (TmsExamItemEntity item : items) {
|
String userAnswer = normalized.getOrDefault(item.getId(), "");
|
item.setUserAnswer(userAnswer);
|
TmsOnlineExamGradeItemVO grade = new TmsOnlineExamGradeItemVO();
|
grade.setId(item.getId());
|
grade.setCorrectAnswer(item.getCorrectAnswer());
|
grade.setAnalysis(item.getAnalysis());
|
boolean subjective = "1".equals(item.getIsSubjective());
|
grade.setSubjective(Boolean.valueOf(subjective));
|
if (subjective) {
|
pending = true;
|
item.setGotScore(null);
|
grade.setGotScore(null);
|
grade.setRight(null);
|
} else {
|
boolean right = this.answerRight(item, userAnswer);
|
BigDecimal got = right ? this.nvl(item.getScore()) : BigDecimal.ZERO;
|
item.setGotScore(got);
|
objective = objective.add(got);
|
grade.setGotScore(got);
|
grade.setRight(Boolean.valueOf(right));
|
}
|
item.setLastModifyTime(now);
|
this.examItemMapper.updateById(item);
|
grades.add(grade);
|
}
|
objective = objective.setScale(1, RoundingMode.HALF_UP);
|
exam.setObjectiveScore(objective);
|
exam.setSubmitTime(now);
|
exam.setExamStatus(TmsExamStatus.SUBMITTED.getCode());
|
exam.setLastModifyTime(now);
|
if (pending) {
|
exam.setGradeStatus(TmsGradeStatus.PENDING.getCode());
|
exam.setSubjectiveScore(null);
|
exam.setTotalScore(objective);
|
exam.setPassFlag(null);
|
} else {
|
exam.setGradeStatus(TmsGradeStatus.AUTO.getCode());
|
exam.setSubjectiveScore(BigDecimal.ZERO);
|
exam.setTotalScore(objective);
|
exam.setPassFlag(this.passFlag(objective, exam.getPassScore()));
|
}
|
this.examMapper.updateById(exam);
|
if (!pending) {
|
this.personTaskService.writeBackExamResult(exam.getPersonTaskId(), exam.getTotalScore(), exam.getPassFlag());
|
}
|
TmsOnlineExamSubmitResultVO result = new TmsOnlineExamSubmitResultVO();
|
result.setObjectiveScore(exam.getObjectiveScore());
|
result.setTotalScore(exam.getTotalScore());
|
result.setPassFlag(exam.getPassFlag());
|
result.setGradeStatus(exam.getGradeStatus());
|
result.setPendingGrade(Boolean.valueOf(pending));
|
result.setItems(grades);
|
return result;
|
}
|
|
/**
|
* 创建答卷记录
|
*/
|
private TmsExamEntity createExam(TmsPaperEntity paper, String userId, RetakeContext retake) {
|
List<QuestionSnap> snaps = this.loadPaperQuestions(paper.getId());
|
if (snaps.isEmpty()) {
|
throw new DataException("试卷没有试题，无法开考");
|
}
|
if (TmsPaperSortMode.RANDOM.equalsCode(paper.getSortMode())) {
|
Collections.shuffle(snaps);
|
}
|
Date now = new Date();
|
int attemptNo = retake == null || retake.nextAttemptNo == null ? 1 : retake.nextAttemptNo;
|
TmsExamEntity exam = this.findUnstartedShell(userId, paper.getId(), retake, attemptNo);
|
boolean reuseShell = exam != null;
|
if (!reuseShell) {
|
exam = new TmsExamEntity();
|
exam.setId(RandomUtil.uuId());
|
exam.setTaskId(retake == null ? null : retake.taskId);
|
exam.setPersonTaskId(retake == null ? null : retake.personTaskId);
|
exam.setPaperId(paper.getId());
|
exam.setPaperName(paper.getPaperName());
|
exam.setUserId(userId);
|
exam.setAttemptNo(Integer.valueOf(attemptNo));
|
exam.setDurationMin(paper.getDurationMin());
|
BigDecimal passScore = paper.getPassScore();
|
if (retake != null && retake.passScore != null) {
|
passScore = retake.passScore;
|
}
|
exam.setPassScore(passScore);
|
exam.setCreatorUserId(userId);
|
exam.setCreatorTime(now);
|
} else {
|
if (StringUtil.isEmpty(exam.getPaperName())) {
|
exam.setPaperName(paper.getPaperName());
|
}
|
if (exam.getDurationMin() == null) {
|
exam.setDurationMin(paper.getDurationMin());
|
}
|
if (exam.getPassScore() == null) {
|
BigDecimal passScore = paper.getPassScore();
|
if (retake != null && retake.passScore != null) {
|
passScore = retake.passScore;
|
}
|
exam.setPassScore(passScore);
|
}
|
if (StringUtil.isEmpty(exam.getTaskId()) && retake != null) {
|
exam.setTaskId(retake.taskId);
|
}
|
if (StringUtil.isEmpty(exam.getPersonTaskId()) && retake != null) {
|
exam.setPersonTaskId(retake.personTaskId);
|
}
|
}
|
exam.setStartTime(now);
|
exam.setGradeStatus(TmsGradeStatus.AUTO.getCode());
|
exam.setExamStatus(TmsExamStatus.DOING.getCode());
|
exam.setLastModifyUserId(userId);
|
exam.setLastModifyTime(now);
|
if (reuseShell) {
|
this.examMapper.updateById(exam);
|
} else {
|
this.examMapper.insert(exam);
|
}
|
int sort = 1;
|
for (QuestionSnap snap : snaps) {
|
TmsExamItemEntity item = new TmsExamItemEntity();
|
item.setId(RandomUtil.uuId());
|
item.setForeignId(exam.getId());
|
item.setQuestionId(snap.question.getId());
|
item.setQuestionType(snap.question.getQuestionType());
|
item.setStem(snap.question.getStem());
|
item.setOptionsJson(this.toJson(snap.options));
|
item.setCorrectAnswer(this.correctOf(snap));
|
item.setScore(snap.score);
|
item.setIsSubjective(TmsQuestionType.ESSAY.equalsCode(snap.question.getQuestionType()) ? "1" : "0");
|
item.setAnalysis(snap.question.getAnalysis());
|
item.setSortNo(Integer.valueOf(sort++));
|
item.setCreatorUserId(userId);
|
item.setCreatorTime(now);
|
this.examItemMapper.insert(item);
|
}
|
return exam;
|
}
|
|
/**
|
* 查找未开考答卷壳
|
*/
|
private TmsExamEntity findUnstartedShell(String userId, String paperId, RetakeContext retake, int attemptNo) {
|
if (StringUtil.isEmpty(userId) || StringUtil.isEmpty(paperId)) {
|
return null;
|
}
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.eq(TmsExamEntity::getPaperId, paperId);
|
qw.eq(TmsExamEntity::getAttemptNo, Integer.valueOf(attemptNo));
|
qw.and(w -> w.isNull(TmsExamEntity::getExamStatus)
|
.or().eq(TmsExamEntity::getExamStatus, "")
|
.or().eq(TmsExamEntity::getExamStatus, TmsExamStatus.NOT_STARTED.getCode()));
|
if (retake != null && StringUtil.isNotEmpty(retake.personTaskId)) {
|
qw.eq(TmsExamEntity::getPersonTaskId, retake.personTaskId);
|
} else if (retake != null && StringUtil.isNotEmpty(retake.taskId)) {
|
qw.eq(TmsExamEntity::getTaskId, retake.taskId);
|
}
|
qw.orderByAsc(TmsExamEntity::getCreatorTime);
|
qw.last("limit 1");
|
return this.examMapper.selectOne(qw);
|
}
|
|
/**
|
* 加载试卷题目
|
*/
|
private List<QuestionSnap> loadPaperQuestions(String paperId) {
|
LambdaQueryWrapper<TmsPaperSectionEntity> secQw = new LambdaQueryWrapper<>();
|
secQw.eq(TmsPaperSectionEntity::getForeignId, paperId);
|
secQw.orderByAsc(TmsPaperSectionEntity::getSortNo);
|
List<TmsPaperSectionEntity> sections = this.sectionMapper.selectList(secQw);
|
LambdaQueryWrapper<TmsPaperQuestionEntity> qQw = new LambdaQueryWrapper<>();
|
qQw.eq(TmsPaperQuestionEntity::getForeignId, paperId);
|
qQw.orderByAsc(TmsPaperQuestionEntity::getSortNo);
|
List<TmsPaperQuestionEntity> links = this.paperQuestionMapper.selectList(qQw);
|
HashMap<String, List<TmsPaperQuestionEntity>> bySection = new HashMap<>();
|
for (TmsPaperQuestionEntity link : links) {
|
bySection.computeIfAbsent(link.getSectionId(), k -> new ArrayList<>()).add(link);
|
}
|
List<String> questionIds = links.stream().map(TmsPaperQuestionEntity::getQuestionId).collect(Collectors.toList());
|
HashMap<String, TmsQuestionEntity> questions = new HashMap<String, TmsQuestionEntity>();
|
if (!questionIds.isEmpty()) {
|
for (TmsQuestionEntity q : this.questionMapper.selectBatchIds(questionIds)) {
|
questions.put(q.getId(), q);
|
}
|
}
|
Map<String, List<TmsQuestionOptionEntity>> optionMap = this.loadOptions(questionIds);
|
ArrayList<QuestionSnap> snaps = new ArrayList<QuestionSnap>();
|
for (TmsPaperSectionEntity section : sections) {
|
List<TmsPaperQuestionEntity> rows = bySection.getOrDefault(section.getId(), Collections.emptyList());
|
rows.sort(Comparator.comparing(r -> r.getSortNo() == null ? 0 : r.getSortNo()));
|
for (TmsPaperQuestionEntity row : rows) {
|
TmsQuestionEntity question = questions.get(row.getQuestionId());
|
if (question == null) {
|
throw new DataException("试卷中的试题已不存在，无法开考");
|
}
|
QuestionSnap snap = new QuestionSnap();
|
snap.question = question;
|
snap.score = row.getScore() == null ? BigDecimal.ZERO : row.getScore();
|
snap.options = this.toStoredOptions(optionMap.getOrDefault(question.getId(), Collections.emptyList()));
|
snaps.add(snap);
|
}
|
}
|
return snaps;
|
}
|
|
/**
|
* 写入考生答案
|
*/
|
private void writeAnswers(String examId, Map<String, Object> answers) {
|
List<TmsExamItemEntity> items = this.loadItems(examId);
|
Date now = new Date();
|
for (TmsExamItemEntity item : items) {
|
Object raw = answers == null ? null : answers.get(item.getId());
|
item.setUserAnswer(this.normalizeAnswer(raw, item.getQuestionType()));
|
item.setLastModifyTime(now);
|
this.examItemMapper.updateById(item);
|
}
|
}
|
|
/**
|
* 转为试卷作答 VO
|
*/
|
private TmsOnlineExamPaperVO toPaperVo(TmsExamEntity exam, List<TmsExamItemEntity> items) {
|
TmsOnlineExamPaperVO vo = new TmsOnlineExamPaperVO();
|
vo.setExamId(exam.getId());
|
vo.setPaperId(exam.getPaperId());
|
vo.setPaperName(exam.getPaperName());
|
vo.setPassScore(exam.getPassScore());
|
vo.setDurationMin(exam.getDurationMin());
|
vo.setStartTime(this.fmt(exam.getStartTime()));
|
vo.setRemainSeconds(this.remainSeconds(exam));
|
BigDecimal total = BigDecimal.ZERO;
|
ArrayList<TmsOnlineExamQuestionVO> questions = new ArrayList<TmsOnlineExamQuestionVO>();
|
for (TmsExamItemEntity item : items) {
|
total = total.add(this.nvl(item.getScore()));
|
TmsOnlineExamQuestionVO q = new TmsOnlineExamQuestionVO();
|
q.setId(item.getId());
|
q.setQuestionId(item.getQuestionId());
|
q.setQuestionType(item.getQuestionType());
|
q.setStem(item.getStem());
|
q.setScore(item.getScore());
|
q.setUserAnswer(item.getUserAnswer());
|
q.setOptions(this.toClientOptions(item.getOptionsJson()));
|
questions.add(q);
|
}
|
vo.setTotalScore(total);
|
vo.setQuestions(questions);
|
vo.setAttemptNo(Integer.valueOf(exam.getAttemptNo() == null ? 1 : exam.getAttemptNo()));
|
vo.setAttemptLabel(this.attemptLabel(vo.getAttemptNo()));
|
return vo;
|
}
|
|
/**
|
* 转为回顾题目
|
*/
|
private List<TmsOnlineExamQuestionVO> toReviewQuestions(List<TmsExamItemEntity> items) {
|
ArrayList<TmsOnlineExamQuestionVO> questions = new ArrayList<TmsOnlineExamQuestionVO>();
|
for (TmsExamItemEntity item : items) {
|
TmsOnlineExamQuestionVO q = new TmsOnlineExamQuestionVO();
|
q.setId(item.getId());
|
q.setQuestionId(item.getQuestionId());
|
q.setQuestionType(item.getQuestionType());
|
q.setStem(item.getStem());
|
q.setScore(item.getScore());
|
q.setGotScore(item.getGotScore());
|
q.setUserAnswer(item.getUserAnswer());
|
q.setCorrectAnswer(item.getCorrectAnswer());
|
q.setAnalysis(item.getAnalysis());
|
boolean subjective = "1".equals(item.getIsSubjective());
|
q.setSubjective(Boolean.valueOf(subjective));
|
if (subjective) {
|
q.setRight(null);
|
} else if (item.getScore() != null && item.getScore().compareTo(BigDecimal.ZERO) > 0) {
|
q.setRight(Boolean.valueOf(this.nvl(item.getGotScore()).compareTo(item.getScore()) >= 0));
|
} else {
|
q.setRight(Boolean.valueOf(Objects.equals(this.normalizeCorrect(item.getCorrectAnswer()), this.normalizeCorrect(item.getUserAnswer()))));
|
}
|
q.setOptions(this.toReviewOptions(item.getOptionsJson()));
|
questions.add(q);
|
}
|
return questions;
|
}
|
|
/**
|
* 转为回顾选项
|
*/
|
private List<TmsOnlineExamOptionVO> toReviewOptions(String json) {
|
List<StoredOption> stored = this.parseOptions(json);
|
ArrayList<TmsOnlineExamOptionVO> list = new ArrayList<TmsOnlineExamOptionVO>(stored.size());
|
for (StoredOption opt : stored) {
|
TmsOnlineExamOptionVO vo = new TmsOnlineExamOptionVO();
|
vo.setOptionLabel(opt.getOptionLabel());
|
vo.setOptionContent(opt.getOptionContent());
|
vo.setIsCorrect(opt.getIsCorrect());
|
list.add(vo);
|
}
|
return list;
|
}
|
|
/**
|
* 转为前端选项
|
*/
|
private List<TmsOnlineExamOptionVO> toClientOptions(String json) {
|
List<StoredOption> stored = this.parseOptions(json);
|
ArrayList<TmsOnlineExamOptionVO> list = new ArrayList<TmsOnlineExamOptionVO>(stored.size());
|
for (StoredOption opt : stored) {
|
TmsOnlineExamOptionVO vo = new TmsOnlineExamOptionVO();
|
vo.setOptionLabel(opt.getOptionLabel());
|
vo.setOptionContent(opt.getOptionContent());
|
list.add(vo);
|
}
|
return list;
|
}
|
|
/**
|
* 转为列表 VO
|
*/
|
private TmsOnlineExamListVO toListVo(TmsPaperEntity paper, TmsExamEntity exam, String status) {
|
TmsOnlineExamListVO vo = new TmsOnlineExamListVO();
|
vo.setId(paper.getId());
|
vo.setPaperId(paper.getId());
|
vo.setPaperName(paper.getPaperName());
|
vo.setStatus(status);
|
vo.setExamStart(this.fmt(paper.getExamStart()));
|
vo.setExamEnd(this.fmt(paper.getExamEnd()));
|
vo.setExamTimeText(this.timeText(paper.getExamStart(), paper.getExamEnd()));
|
vo.setTotalScore(paper.getTotalScore());
|
vo.setPassScore(paper.getPassScore());
|
vo.setDurationMin(paper.getDurationMin());
|
if (exam != null && TmsExamStatus.SUBMITTED.equalsCode(exam.getExamStatus())) {
|
vo.setGotScore(exam.getTotalScore());
|
vo.setPassFlag(exam.getPassFlag());
|
vo.setExamId(exam.getId());
|
} else if (exam != null) {
|
vo.setExamId(exam.getId());
|
}
|
this.fillRetakeMeta(vo, paper.getId(), exam, UserProvider.getLoginUserId());
|
return vo;
|
}
|
|
/**
|
* 回填补考元数据
|
*/
|
private void fillRetakeMeta(TmsOnlineExamListVO vo, String paperId, TmsExamEntity exam, String userId) {
|
RetakeMeta meta = this.buildRetakeMeta(paperId, exam, userId);
|
vo.setAttemptNo(meta.attemptNo);
|
vo.setAttemptLabel(meta.attemptLabel);
|
vo.setSubmittedCount(meta.submittedCount);
|
vo.setRetakeLimit(meta.retakeLimit);
|
vo.setRemainingRetakes(meta.remainingRetakes);
|
vo.setCanRetake(meta.canRetake);
|
}
|
|
/**
|
* 回填补考元数据
|
*/
|
private void fillRetakeMeta(TmsOnlineExamDetailVO vo, String paperId, TmsExamEntity exam, String userId) {
|
RetakeMeta meta = this.buildRetakeMeta(paperId, exam, userId);
|
vo.setAttemptNo(meta.attemptNo);
|
vo.setAttemptLabel(meta.attemptLabel);
|
vo.setSubmittedCount(meta.submittedCount);
|
vo.setRetakeLimit(meta.retakeLimit);
|
vo.setRemainingRetakes(meta.remainingRetakes);
|
vo.setCanRetake(meta.canRetake);
|
}
|
|
/**
|
* 构建补考元数据
|
*/
|
private RetakeMeta buildRetakeMeta(String paperId, TmsExamEntity exam, String userId) {
|
RetakeMeta meta = new RetakeMeta();
|
RetakeContext ctx = this.resolveRetake(userId, paperId);
|
meta.retakeLimit = ctx.retakeLimit;
|
meta.submittedCount = ctx.submittedCount == null ? 0 : ctx.submittedCount;
|
meta.attemptNo = exam != null && exam.getAttemptNo() != null ? exam.getAttemptNo() : (ctx.nextAttemptNo != null ? ctx.nextAttemptNo : Integer.valueOf(1));
|
meta.attemptLabel = this.attemptLabel(meta.attemptNo);
|
if (meta.retakeLimit == null) {
|
meta.remainingRetakes = 0;
|
meta.canRetake = false;
|
} else {
|
int usedRetakes = Math.max(0, meta.submittedCount - 1);
|
meta.remainingRetakes = Math.max(0, meta.retakeLimit - usedRetakes);
|
boolean submittedFail = exam != null && TmsExamStatus.SUBMITTED.equalsCode(exam.getExamStatus()) && TmsPassFlag.isFail(exam.getPassFlag());
|
meta.canRetake = submittedFail && ctx.allowStart;
|
}
|
return meta;
|
}
|
|
/**
|
* 考试次数标签
|
*/
|
private String attemptLabel(Integer attemptNo) {
|
int n;
|
int n2 = n = attemptNo == null ? 1 : attemptNo;
|
if (n <= 1) {
|
return "首考";
|
}
|
return "补考（第" + (n - 1) + "次）";
|
}
|
|
/**
|
* 加载用户各试卷最新答卷
|
*/
|
private Map<String, TmsExamEntity> loadLatestExams(String userId, List<TmsPaperEntity> papers) {
|
HashMap<String, TmsExamEntity> map = new HashMap<String, TmsExamEntity>();
|
if (papers.isEmpty() || StringUtil.isEmpty(userId)) {
|
return map;
|
}
|
List<String> ids = papers.stream().map(TmsPaperEntity::getId).collect(Collectors.toList());
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.in(TmsExamEntity::getPaperId, ids);
|
qw.orderByDesc(TmsExamEntity::getCreatorTime);
|
for (TmsExamEntity exam : this.examMapper.selectList(qw)) {
|
TmsExamEntity exists = map.get(exam.getPaperId());
|
if (exists != null && !TmsExamStatus.DOING.equalsCode(exam.getExamStatus())) continue;
|
map.put(exam.getPaperId(), exam);
|
}
|
return map;
|
}
|
|
/**
|
* 取最新答卷
|
*/
|
private TmsExamEntity latestExam(String userId, String paperId) {
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.eq(TmsExamEntity::getPaperId, paperId);
|
qw.orderByDesc(TmsExamEntity::getCreatorTime);
|
List<TmsExamEntity> list = this.examMapper.selectList(qw);
|
TmsExamEntity picked = null;
|
for (TmsExamEntity exam : list) {
|
if (TmsExamStatus.DOING.equalsCode(exam.getExamStatus())) {
|
return exam;
|
}
|
if (picked != null) continue;
|
picked = exam;
|
}
|
return picked;
|
}
|
|
/**
|
* 查找进行中的答卷
|
*/
|
private TmsExamEntity findDoing(String userId, String paperId) {
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.eq(TmsExamEntity::getPaperId, paperId);
|
qw.eq(TmsExamEntity::getExamStatus, TmsExamStatus.DOING.getCode());
|
qw.orderByDesc(TmsExamEntity::getCreatorTime);
|
qw.last("limit 1");
|
return this.examMapper.selectOne(qw);
|
}
|
|
/**
|
* 取最近一次已交卷
|
*/
|
private TmsExamEntity latestSubmitted(String userId, String paperId) {
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.eq(TmsExamEntity::getPaperId, paperId);
|
qw.eq(TmsExamEntity::getExamStatus, TmsExamStatus.SUBMITTED.getCode());
|
qw.orderByDesc(TmsExamEntity::getCreatorTime);
|
qw.last("limit 1");
|
return this.examMapper.selectOne(qw);
|
}
|
|
/**
|
* 解析是否可补考
|
*/
|
private RetakeContext resolveRetake(String userId, String paperId) {
|
RetakeContext ctx = new RetakeContext();
|
ctx.allowStart = true;
|
ctx.nextAttemptNo = 1;
|
TmsExamEntity last = this.latestSubmitted(userId, paperId);
|
TmsPersonTaskEntity personTask = this.findActivePersonTask(userId, paperId);
|
TmsTaskEntity task = null;
|
if (personTask != null) {
|
task = this.taskMapper.selectById((personTask.getTaskId()));
|
}
|
if (task != null) {
|
ctx.taskId = task.getId();
|
ctx.personTaskId = personTask == null ? null : personTask.getId();
|
ctx.passScore = task.getPassScore();
|
int retakeLimit = task.getRetakeLimit() == null ? 1 : Math.max(0, task.getRetakeLimit());
|
long submitted = this.countSubmitted(userId, paperId, task.getId());
|
ctx.retakeLimit = retakeLimit;
|
ctx.submittedCount = (int)submitted;
|
ctx.nextAttemptNo = (int)submitted + 1;
|
if (last == null) {
|
return ctx;
|
}
|
if (TmsPassFlag.isPass(last.getPassFlag())) {
|
ctx.allowStart = false;
|
ctx.message = "该试卷已合格，无需重考";
|
return ctx;
|
}
|
if (submitted > (long)retakeLimit) {
|
ctx.allowStart = false;
|
ctx.message = "补考次数已用尽（上限 " + retakeLimit + " 次）";
|
return ctx;
|
}
|
return ctx;
|
}
|
if (last != null) {
|
ctx.submittedCount = 1;
|
ctx.retakeLimit = 0;
|
ctx.allowStart = false;
|
ctx.message = "该试卷已交卷";
|
}
|
return ctx;
|
}
|
|
/**
|
* 统计已交卷数
|
*/
|
private long countSubmitted(String userId, String paperId, String taskId) {
|
Long cnt;
|
LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamEntity::getUserId, userId);
|
qw.eq(TmsExamEntity::getPaperId, paperId);
|
qw.eq(TmsExamEntity::getExamStatus, TmsExamStatus.SUBMITTED.getCode());
|
if (StringUtil.isNotEmpty(taskId)) {
|
qw.and(w -> ((w.eq(TmsExamEntity::getTaskId, taskId)).or()).isNull(TmsExamEntity::getTaskId));
|
}
|
return (cnt = this.examMapper.selectCount(qw)) == null ? 0L : cnt;
|
}
|
|
/**
|
* 查找进行中的个人任务
|
*/
|
private TmsPersonTaskEntity findActivePersonTask(String userId, String paperId) {
|
List<TmsTaskEntity> tasks = this.taskMapper.selectList(
|
new LambdaQueryWrapper<TmsTaskEntity>()
|
.eq(TmsTaskEntity::getPaperId, paperId)
|
.eq(TmsTaskEntity::getPublishStatus, TmsTaskPublishStatus.PUBLISHED.getCode())
|
.orderByDesc(TmsTaskEntity::getPublishTime));
|
for (TmsTaskEntity t : tasks) {
|
TmsPersonTaskEntity pt = this.findPersonTask(t.getId(), userId);
|
if (pt == null || TmsPersonTaskStatus.CANCELLED.equalsCode(pt.getBizStatus())) {
|
continue;
|
}
|
return pt;
|
}
|
return null;
|
}
|
|
/**
|
* 查找个人培训任务
|
*/
|
private TmsPersonTaskEntity findPersonTask(String taskId, String userId) {
|
return this.personTaskMapper.selectOne(new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, taskId)
|
.eq(TmsPersonTaskEntity::getUserId, userId)
|
.last("limit 1"));
|
}
|
|
/**
|
* 校验进行中答卷并返回
|
*/
|
private TmsExamEntity requireDoingExam(String examId) {
|
TmsExamEntity exam = this.examMapper.selectById(examId);
|
if (exam == null) {
|
throw new DataException("答卷不存在");
|
}
|
if (!Objects.equals(UserProvider.getLoginUserId(), exam.getUserId())) {
|
throw new DataException("无权操作该答卷");
|
}
|
if (!TmsExamStatus.DOING.equalsCode(exam.getExamStatus())) {
|
throw new DataException("试卷已交卷");
|
}
|
return exam;
|
}
|
|
/**
|
* 校验试卷可考并返回
|
*/
|
private TmsPaperEntity requireOpenPaper(String paperId) {
|
TmsPaperEntity paper = this.paperMapper.selectById(paperId);
|
if (paper == null) {
|
throw new DataException("试卷不存在");
|
}
|
if (!TmsOpenClosedInvalid.OPEN.equalsCode(paper.getBizStatus())) {
|
throw new DataException("试卷未开放，不能参加考试");
|
}
|
return paper;
|
}
|
|
/**
|
* 校验考试时间窗口
|
*/
|
private void assertExamWindow(TmsPaperEntity paper) {
|
Date now = new Date();
|
if (paper.getExamStart() != null && now.before(paper.getExamStart())) {
|
throw new DataException("未到考试时间");
|
}
|
if (paper.getExamEnd() != null && now.after(paper.getExamEnd())) {
|
throw new DataException("考试时间已结束");
|
}
|
}
|
|
/**
|
* 加载答卷题目明细
|
*/
|
private List<TmsExamItemEntity> loadItems(String examId) {
|
LambdaQueryWrapper<TmsExamItemEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsExamItemEntity::getForeignId, examId);
|
qw.orderByAsc(TmsExamItemEntity::getSortNo);
|
return this.examItemMapper.selectList(qw);
|
}
|
|
/**
|
* 加载题目选项
|
*/
|
private Map<String, List<TmsQuestionOptionEntity>> loadOptions(List<String> questionIds) {
|
if (questionIds == null || questionIds.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
LambdaQueryWrapper<TmsQuestionOptionEntity> qw = new LambdaQueryWrapper<>();
|
qw.in(TmsQuestionOptionEntity::getForeignId, questionIds);
|
qw.orderByAsc(TmsQuestionOptionEntity::getSortNo);
|
HashMap<String, List<TmsQuestionOptionEntity>> map = new HashMap<String, List<TmsQuestionOptionEntity>>();
|
for (TmsQuestionOptionEntity opt : this.optionMapper.selectList(qw)) {
|
map.computeIfAbsent(opt.getForeignId(), k -> new ArrayList()).add(opt);
|
}
|
return map;
|
}
|
|
/**
|
* 转为落库选项结构
|
*/
|
private List<StoredOption> toStoredOptions(List<TmsQuestionOptionEntity> opts) {
|
ArrayList<StoredOption> list = new ArrayList<StoredOption>();
|
for (TmsQuestionOptionEntity opt : opts) {
|
StoredOption stored = new StoredOption();
|
stored.setOptionLabel(opt.getOptionLabel());
|
stored.setOptionContent(opt.getOptionContent());
|
stored.setIsCorrect(opt.getIsCorrect());
|
list.add(stored);
|
}
|
return list;
|
}
|
|
/**
|
* 取标准答案
|
*/
|
private String correctOf(QuestionSnap snap) {
|
String type = snap.question.getQuestionType();
|
if (TmsQuestionType.ESSAY.equalsCode(type)) {
|
return "";
|
}
|
if (TmsQuestionType.BLANK.equalsCode(type)) {
|
return snap.options.stream().map(StoredOption::getOptionContent).filter(StringUtil::isNotEmpty).collect(Collectors.joining("?"));
|
}
|
return snap.options.stream().filter(o -> "1".equals(o.getIsCorrect())).map(StoredOption::getOptionLabel).filter(StringUtil::isNotEmpty).sorted().collect(Collectors.joining(","));
|
}
|
|
/**
|
* 判断作答是否正确
|
*/
|
private boolean answerRight(TmsExamItemEntity item, String userAnswer) {
|
if (StringUtil.isEmpty(item.getCorrectAnswer())) {
|
return false;
|
}
|
if (TmsQuestionType.BLANK.equalsCode(item.getQuestionType())) {
|
return item.getCorrectAnswer().trim().equals(userAnswer == null ? "" : userAnswer.trim());
|
}
|
return Objects.equals(this.normalizeCorrect(item.getCorrectAnswer()), this.normalizeCorrect(userAnswer));
|
}
|
|
/**
|
* 规范化作答内容
|
*/
|
private String normalizeAnswer(Object raw, String questionType) {
|
if (raw == null) {
|
return "";
|
}
|
if (TmsQuestionType.MULTI.equalsCode(questionType)) {
|
LinkedHashSet<String> labels = new LinkedHashSet<String>();
|
if (raw instanceof List) {
|
for (Object o : (List)raw) {
|
if (o == null || !StringUtil.isNotEmpty(String.valueOf(o))) continue;
|
labels.add(String.valueOf(o).trim());
|
}
|
} else {
|
String text = String.valueOf(raw).trim();
|
if (StringUtil.isNotEmpty(text)) {
|
for (String part : text.split("[,?]")) {
|
if (!StringUtil.isNotEmpty(part.trim())) continue;
|
labels.add(part.trim());
|
}
|
}
|
}
|
return labels.stream().sorted().collect(Collectors.joining(","));
|
}
|
return String.valueOf(raw).trim();
|
}
|
|
/**
|
* 规范化标准答案
|
*/
|
private String normalizeCorrect(String correct) {
|
if (StringUtil.isEmpty(correct)) {
|
return "";
|
}
|
return Arrays.stream(correct.split("[,?]")).map(String::trim).filter(StringUtil::isNotEmpty).sorted().collect(Collectors.joining(","));
|
}
|
|
/**
|
* 是否已超时
|
*/
|
private boolean isTimedOut(TmsExamEntity exam) {
|
Integer remain = this.remainSeconds(exam);
|
return remain != null && remain <= 0;
|
}
|
|
/**
|
* 剩余答题秒数
|
*/
|
private Integer remainSeconds(TmsExamEntity exam) {
|
if (exam == null || exam.getDurationMin() == null || exam.getDurationMin() <= 0 || exam.getStartTime() == null) {
|
return null;
|
}
|
long endMs = exam.getStartTime().getTime() + (long)exam.getDurationMin().intValue() * 60000L;
|
long remain = (endMs - System.currentTimeMillis()) / 1000L;
|
return (int)Math.max(0L, remain);
|
}
|
|
/**
|
* 根据得分与及格分计算合格标识
|
*/
|
private String passFlag(BigDecimal score, BigDecimal passScore) {
|
return TmsPassFlag.ofScore(score, passScore);
|
}
|
|
/**
|
* 解析答卷状态文案/编码
|
*/
|
private String statusOf(TmsExamEntity exam) {
|
if (exam == null || StringUtil.isEmpty(exam.getExamStatus())
|
|| TmsExamStatus.NOT_STARTED.equalsCode(exam.getExamStatus())) {
|
return TmsExamStatus.NOT_STARTED.getCode();
|
}
|
if (TmsExamStatus.DOING.equalsCode(exam.getExamStatus())) {
|
return TmsExamStatus.DOING.getCode();
|
}
|
return TmsExamStatus.SUBMITTED.getCode();
|
}
|
|
/**
|
* 时间展示文本
|
*/
|
private String timeText(Date start, Date end) {
|
if (start == null && end == null) {
|
return "??";
|
}
|
String left = start == null ? "??" : this.fmt(start);
|
String right = end == null ? "??" : this.fmt(end);
|
return left + " ~ " + right;
|
}
|
|
/**
|
* 格式化日期
|
*/
|
private String fmt(Date date) {
|
return date == null ? null : DateUtil.dateToString((Date)date, (String)FMT);
|
}
|
|
/**
|
* 空值兜底
|
*/
|
private BigDecimal nvl(BigDecimal value) {
|
return value == null ? BigDecimal.ZERO : value;
|
}
|
|
/**
|
* 对象转 JSON
|
*/
|
private String toJson(Object obj) {
|
try {
|
return OBJECT_MAPPER.writeValueAsString(obj);
|
}
|
catch (Exception e) {
|
throw new DataException("JSON序列化失败");
|
}
|
}
|
|
/**
|
* 解析选项 JSON
|
*/
|
private List<StoredOption> parseOptions(String json) {
|
if (StringUtil.isEmpty(json)) {
|
return Collections.emptyList();
|
}
|
try {
|
return (List)OBJECT_MAPPER.readValue(json, (TypeReference)new TypeReference<List<StoredOption>>(){});
|
}
|
catch (Exception e) {
|
return Collections.emptyList();
|
}
|
}
|
|
private static class RetakeContext {
|
private boolean allowStart;
|
private String message;
|
private String taskId;
|
private String personTaskId;
|
private Integer nextAttemptNo;
|
private BigDecimal passScore;
|
private Integer retakeLimit;
|
private Integer submittedCount;
|
|
private RetakeContext() {
|
}
|
}
|
|
private static class QuestionSnap {
|
private TmsQuestionEntity question;
|
private BigDecimal score;
|
private List<StoredOption> options;
|
|
private QuestionSnap() {
|
}
|
}
|
|
@JsonIgnoreProperties(ignoreUnknown=true)
|
private static class StoredOption {
|
private String optionLabel;
|
private String optionContent;
|
private String isCorrect;
|
public StoredOption() {
|
}
|
/**
|
* 获取选项标签
|
*/
|
public String getOptionLabel() {
|
return this.optionLabel;
|
}
|
/**
|
* 获取选项内容
|
*/
|
public String getOptionContent() {
|
return this.optionContent;
|
}
|
/**
|
* 获取是否正确
|
*/
|
public String getIsCorrect() {
|
return this.isCorrect;
|
}
|
/**
|
* 设置选项标签
|
*/
|
public void setOptionLabel(String optionLabel) {
|
this.optionLabel = optionLabel;
|
}
|
/**
|
* 设置选项内容
|
*/
|
public void setOptionContent(String optionContent) {
|
this.optionContent = optionContent;
|
}
|
/**
|
* 设置是否正确
|
*/
|
public void setIsCorrect(String isCorrect) {
|
this.isCorrect = isCorrect;
|
}
|
/**
|
* 相等比较
|
*/
|
public boolean equals(Object o) {
|
if (o == this) {
|
return true;
|
}
|
if (!(o instanceof StoredOption)) {
|
return false;
|
}
|
StoredOption other = (StoredOption)o;
|
if (!other.canEqual(this)) {
|
return false;
|
}
|
String this$optionLabel = this.getOptionLabel();
|
String other$optionLabel = other.getOptionLabel();
|
if (this$optionLabel == null ? other$optionLabel != null : !this$optionLabel.equals(other$optionLabel)) {
|
return false;
|
}
|
String this$optionContent = this.getOptionContent();
|
String other$optionContent = other.getOptionContent();
|
if (this$optionContent == null ? other$optionContent != null : !this$optionContent.equals(other$optionContent)) {
|
return false;
|
}
|
String this$isCorrect = this.getIsCorrect();
|
String other$isCorrect = other.getIsCorrect();
|
return !(this$isCorrect == null ? other$isCorrect != null : !this$isCorrect.equals(other$isCorrect));
|
}
|
|
/**
|
* 是否可与同类比较
|
*/
|
protected boolean canEqual(Object other) {
|
return other instanceof StoredOption;
|
}
|
|
/**
|
* 哈希值
|
*/
|
public int hashCode() {
|
int PRIME = 59;
|
int result = 1;
|
String $optionLabel = this.getOptionLabel();
|
result = result * 59 + ($optionLabel == null ? 43 : $optionLabel.hashCode());
|
String $optionContent = this.getOptionContent();
|
result = result * 59 + ($optionContent == null ? 43 : $optionContent.hashCode());
|
String $isCorrect = this.getIsCorrect();
|
result = result * 59 + ($isCorrect == null ? 43 : $isCorrect.hashCode());
|
return result;
|
}
|
|
/**
|
* 调试字符串
|
*/
|
public String toString() {
|
return "TmsOnlineExamServiceImpl.StoredOption(optionLabel=" + this.getOptionLabel() + ", optionContent=" + this.getOptionContent() + ", isCorrect=" + this.getIsCorrect() + ")";
|
}
|
}
|
|
/** 超时已自动交卷：配合 noRollbackFor，保证交卷结果先提交 */
|
public static class ExamTimedOutException extends DataException {
|
public ExamTimedOutException() {
|
super("考试时间已到，已自动交卷");
|
}
|
}
|
|
private static class RetakeMeta {
|
private Integer attemptNo;
|
private String attemptLabel;
|
private Integer submittedCount;
|
private Integer retakeLimit;
|
private Integer remainingRetakes;
|
private Boolean canRetake;
|
|
private RetakeMeta() {
|
}
|
}
|
}
|
