package jnpf.tmsService.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import jnpf.exception.DataException;
|
import jnpf.tmsEntity.TmsEvalModeEntity;
|
import jnpf.tmsEntity.TmsExamEntity;
|
import jnpf.tmsEntity.TmsMaterialEntity;
|
import jnpf.tmsEntity.TmsPaperEntity;
|
import jnpf.tmsEntity.TmsPersonTaskEntity;
|
import jnpf.tmsEntity.TmsQuizScoreEntity;
|
import jnpf.tmsEntity.TmsRecordEntity;
|
import jnpf.tmsEntity.TmsRecordSignEntity;
|
import jnpf.tmsEntity.TmsTaskEntity;
|
import jnpf.tmsEntity.TmsTaskFileEntity;
|
import jnpf.tmsEntity.TmsTaskQuizEntity;
|
import jnpf.tmsEntity.TmsSignModeEntity;
|
import jnpf.tmsEntity.TmsTrainModeEntity;
|
import jnpf.tmsMapper.TmsEvalModeMapper;
|
import jnpf.tmsMapper.TmsExamMapper;
|
import jnpf.tmsMapper.TmsPaperMapper;
|
import jnpf.tmsMapper.TmsQuizScoreMapper;
|
import jnpf.tmsMapper.TmsRecordMapper;
|
import jnpf.tmsMapper.TmsRecordSignMapper;
|
import jnpf.tmsEntity.person.TmsPersonTaskFileForm;
|
import jnpf.tmsEntity.person.TmsPersonTaskLearnResult;
|
import jnpf.tmsEntity.person.TmsPersonTaskMineForm;
|
import jnpf.tmsEntity.person.TmsPersonTaskQuery;
|
import jnpf.tmsEntity.person.TmsPersonTaskSignResult;
|
import jnpf.tmsEntity.person.TmsQuizAnswerForm;
|
import jnpf.tmsEntity.person.TmsQuizQuestionVO;
|
import jnpf.tmsEntity.person.TmsQuizSubmitResult;
|
import jnpf.tmsEntity.record.TmsQuizAnswerPaperVO;
|
import jnpf.tmsMapper.TmsMaterialMapper;
|
import jnpf.tmsMapper.TmsPersonTaskMapper;
|
import jnpf.tmsMapper.TmsSignModeMapper;
|
import jnpf.tmsMapper.TmsTaskFileMapper;
|
import jnpf.tmsMapper.TmsTaskMapper;
|
import jnpf.tmsMapper.TmsTaskQuizMapper;
|
import jnpf.tmsMapper.TmsTrainModeMapper;
|
import jnpf.tmsService.TmsPersonTaskService;
|
import jnpf.tmsService.TmsRecordService;
|
import jnpf.tmsEntity.enums.TmsPassFlag;
|
import jnpf.tmsEntity.enums.TmsPersonTaskStatus;
|
import jnpf.tmsEntity.enums.TmsSignMode;
|
import jnpf.tmsEntity.enums.TmsQrType;
|
import jnpf.tmsEntity.enums.TmsExamStatus;
|
import jnpf.tmsEntity.enums.TmsTaskPublishStatus;
|
import jnpf.tmsEntity.enums.TmsArchiveStatus;
|
import jnpf.tmsEntity.enums.TmsEvalMode;
|
import jnpf.tmsEntity.enums.TmsSignRule;
|
import jnpf.tmsEntity.enums.TmsTrainMode;
|
import jnpf.tmsUtil.TmsQuizHelper;
|
import jnpf.util.DateUtil;
|
import jnpf.util.RandomUtil;
|
import jnpf.util.StringUtil;
|
import jnpf.util.UserProvider;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* 学员端个人培训任务：我的列表、学完、签到/扫码签到、考试结果回写。
|
*
|
* <p>不负责写入个人档案培训目录；目录仅在培训记录归档时由 {@link TmsRecordServiceImpl} 写入。</p>
|
* <p>考试交卷后通过 {@link #writeBackExamResult} 更新本表成绩与合格标记。</p>
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class TmsPersonTaskServiceImpl implements TmsPersonTaskService {
|
|
private static final String FMT = "yyyy-MM-dd HH:mm:ss";
|
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
|
|
private final TmsPersonTaskMapper personTaskMapper;
|
private final TmsTaskMapper taskMapper;
|
private final TmsTaskFileMapper taskFileMapper;
|
private final TmsMaterialMapper materialMapper;
|
private final TmsTrainModeMapper trainModeMapper;
|
private final TmsSignModeMapper signModeMapper;
|
private final TmsRecordMapper recordMapper;
|
private final TmsRecordSignMapper recordSignMapper;
|
private final TmsExamMapper examMapper;
|
private final TmsPaperMapper paperMapper;
|
private final TmsTaskQuizMapper taskQuizMapper;
|
private final TmsQuizScoreMapper quizScoreMapper;
|
private final TmsEvalModeMapper evalModeMapper;
|
|
@Lazy
|
@Autowired
|
private TmsRecordService recordService;
|
|
/**
|
* 查询我的培训任务列表
|
*/
|
@Override
|
public List<TmsPersonTaskMineForm> getMine(TmsPersonTaskQuery query) {
|
String userId = UserProvider.getLoginUserId();
|
LambdaQueryWrapper<TmsPersonTaskEntity> qw = new LambdaQueryWrapper<>();
|
qw.eq(TmsPersonTaskEntity::getUserId, userId);
|
if (StringUtil.isNotEmpty(query.getBizStatus())) {
|
qw.eq(TmsPersonTaskEntity::getBizStatus, query.getBizStatus().trim());
|
} else {
|
qw.ne(TmsPersonTaskEntity::getBizStatus, TmsPersonTaskStatus.CANCELLED.getCode());
|
}
|
if (StringUtil.isNotEmpty(query.getTaskNo())) {
|
qw.like(TmsPersonTaskEntity::getTaskNo, query.getTaskNo().trim());
|
}
|
if ("1".equals(query.getSigned())) {
|
qw.isNotNull(TmsPersonTaskEntity::getSignTime);
|
} else if ("0".equals(query.getSigned())) {
|
qw.isNull(TmsPersonTaskEntity::getSignTime);
|
}
|
qw.orderByDesc(TmsPersonTaskEntity::getCreatorTime);
|
List<TmsPersonTaskEntity> persons = personTaskMapper.selectList(qw);
|
|
Map<String, TmsTaskEntity> taskMap = loadTasks(persons);
|
String keyword = StringUtil.isNotEmpty(query.getKeyword()) ? query.getKeyword().trim() : null;
|
String trainMode = StringUtil.isNotEmpty(query.getTrainMode()) ? query.getTrainMode().trim() : null;
|
String evalMode = StringUtil.isNotEmpty(query.getEvalMode()) ? query.getEvalMode().trim() : null;
|
String category = StringUtil.isNotEmpty(query.getCategory()) ? query.getCategory().trim() : null;
|
Date startFrom = parseDayStart(query.getStartTimeFrom());
|
Date startTo = parseDayEnd(query.getStartTimeTo());
|
List<TmsPersonTaskMineForm> all = new ArrayList<>();
|
for (TmsPersonTaskEntity person : persons) {
|
TmsTaskEntity task = taskMap.get(person.getTaskId());
|
if (task == null || !TmsTaskPublishStatus.PUBLISHED.equalsCode(task.getPublishStatus())) {
|
continue;
|
}
|
if (keyword != null && !matchKeyword(person, task, keyword)) {
|
continue;
|
}
|
if (trainMode != null && !trainMode.equals(task.getTrainMode())) {
|
continue;
|
}
|
if (evalMode != null && !evalMode.equals(task.getEvalMode())) {
|
continue;
|
}
|
if (category != null && !category.equals(task.getCategory())) {
|
continue;
|
}
|
if (startFrom != null && (task.getStartTime() == null || task.getStartTime().before(startFrom))) {
|
continue;
|
}
|
if (startTo != null && (task.getStartTime() == null || task.getStartTime().after(startTo))) {
|
continue;
|
}
|
if (!matchPassFlag(query.getPassFlag(), person.getPassFlag())) {
|
continue;
|
}
|
TmsPersonTaskMineForm form = toForm(person, task, false);
|
if (!matchYesNo(query.getCanExam(), Boolean.TRUE.equals(form.getCanExam()))) {
|
continue;
|
}
|
all.add(form);
|
}
|
all.sort(Comparator.comparing(TmsPersonTaskMineForm::getStartTime,
|
Comparator.nullsLast(Comparator.reverseOrder())));
|
|
long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
|
long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
|
int from = (int) Math.min((current - 1) * size, all.size());
|
int to = (int) Math.min(from + size, all.size());
|
List<TmsPersonTaskMineForm> page = all.subList(from, to);
|
query.setData(page, all.size());
|
return page;
|
}
|
/**
|
* 个人培训任务：按主键查询详情
|
*/
|
@Override
|
public TmsPersonTaskMineForm getInfo(String id) {
|
TmsPersonTaskEntity person = requireMine(id);
|
TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
TmsPersonTaskMineForm form = toForm(person, task, true);
|
form.setFiles(loadFiles(task.getId()));
|
return form;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
/**
|
* 标记学习进度/完成
|
*/
|
public TmsPersonTaskLearnResult markLearned(String id, Integer seconds) {
|
TmsPersonTaskEntity person = requireMine(id);
|
TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
if (person.getSignTime() == null) {
|
throw new DataException("请先签到后再学习");
|
}
|
|
int before = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
|
int required = toRequiredSeconds(person.getHours());
|
boolean alreadyFull = required > 0 && before >= required;
|
|
int add = seconds == null ? 0 : Math.max(0, seconds);
|
if (add > 0) {
|
person.setLearnSeconds(before + add);
|
person.setLastModifyUserId(UserProvider.getLoginUserId());
|
person.setLastModifyTime(new Date());
|
personTaskMapper.updateById(person);
|
}
|
|
int learned = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
|
boolean justFull = required > 0 && !alreadyFull && learned >= required;
|
|
TmsPersonTaskLearnResult result = new TmsPersonTaskLearnResult();
|
result.setLearnedSeconds(learned);
|
result.setRequiredSeconds(required);
|
result.setLearnStatus(resolveLearnStatus(learned, required));
|
result.setBizStatus(person.getBizStatus());
|
result.setAutoCompleted(false);
|
result.setMessage("");
|
|
boolean needExam = TmsEvalMode.EXAM.equalsCode(task.getEvalMode()) && StringUtil.isNotEmpty(task.getPaperId());
|
if (justFull) {
|
if (!needExam && !TmsPersonTaskStatus.DONE.equalsCode(person.getBizStatus())
|
&& !TmsPersonTaskStatus.CANCELLED.equalsCode(person.getBizStatus())) {
|
person.setBizStatus(TmsPersonTaskStatus.DONE.getCode());
|
person.setLastModifyUserId(UserProvider.getLoginUserId());
|
person.setLastModifyTime(new Date());
|
personTaskMapper.updateById(person);
|
result.setAutoCompleted(true);
|
result.setBizStatus(TmsPersonTaskStatus.DONE.getCode());
|
result.setMessage("已学满规定课时，系统已自动确认完成");
|
} else if (needExam) {
|
ensurePendingExam(person, task);
|
result.setMessage("已学满规定课时，待考试卷已生成，可以进入考试");
|
}
|
}
|
|
TmsPersonTaskMineForm tmp = new TmsPersonTaskMineForm();
|
fillExamFlag(tmp, task, person);
|
if (Boolean.TRUE.equals(tmp.getCanExam()) && needExam) {
|
ensurePendingExam(person, task);
|
}
|
result.setCanExam(Boolean.TRUE.equals(tmp.getCanExam()));
|
result.setExamTip(tmp.getExamTip());
|
return result;
|
}
|
|
/**
|
* 确保存在待考答卷壳
|
*/
|
private void ensurePendingExam(TmsPersonTaskEntity person, TmsTaskEntity task) {
|
if (person == null || task == null || StringUtil.isEmpty(task.getPaperId())) {
|
return;
|
}
|
if (TmsPersonTaskStatus.CANCELLED.equalsCode(person.getBizStatus())) {
|
return;
|
}
|
Long exists = examMapper.selectCount(new LambdaQueryWrapper<TmsExamEntity>()
|
.eq(TmsExamEntity::getPersonTaskId, person.getId())
|
.eq(TmsExamEntity::getPaperId, task.getPaperId())
|
.and(w -> w.isNull(TmsExamEntity::getExamStatus)
|
.or().eq(TmsExamEntity::getExamStatus, "")
|
.or().eq(TmsExamEntity::getExamStatus, TmsExamStatus.NOT_STARTED.getCode())
|
.or().eq(TmsExamEntity::getExamStatus, TmsExamStatus.DOING.getCode())
|
.or().eq(TmsExamEntity::getExamStatus, TmsExamStatus.SUBMITTED.getCode())));
|
if (exists != null && exists > 0) {
|
// 已有答卷：把仍为空的状态补成 notStarted，便于考试记录显示「待考」
|
examMapper.update(null, new LambdaUpdateWrapper<TmsExamEntity>()
|
.eq(TmsExamEntity::getPersonTaskId, person.getId())
|
.eq(TmsExamEntity::getPaperId, task.getPaperId())
|
.and(w -> w.isNull(TmsExamEntity::getExamStatus)
|
.or().eq(TmsExamEntity::getExamStatus, ""))
|
.set(TmsExamEntity::getExamStatus, TmsExamStatus.NOT_STARTED.getCode()));
|
return;
|
}
|
|
String recordId = null;
|
TmsRecordEntity record = recordMapper.selectOne(new LambdaQueryWrapper<TmsRecordEntity>()
|
.eq(TmsRecordEntity::getTaskId, task.getId())
|
.last("limit 1"));
|
if (record != null) {
|
recordId = record.getId();
|
}
|
TmsPaperEntity paper = paperMapper.selectById(task.getPaperId());
|
BigDecimal passScore = task.getPassScore();
|
if (passScore == null && paper != null) {
|
passScore = paper.getPassScore();
|
}
|
Date now = new Date();
|
TmsExamEntity exam = new TmsExamEntity();
|
exam.setId(RandomUtil.uuId());
|
exam.setTaskId(task.getId());
|
exam.setPersonTaskId(person.getId());
|
exam.setRecordId(recordId);
|
exam.setPaperId(task.getPaperId());
|
exam.setPaperName(StringUtil.isNotEmpty(task.getPaperName())
|
? task.getPaperName()
|
: (paper == null ? null : paper.getPaperName()));
|
exam.setUserId(person.getUserId());
|
exam.setAttemptNo(1);
|
exam.setExamStatus(TmsExamStatus.NOT_STARTED.getCode());
|
exam.setPassScore(passScore);
|
exam.setDurationMin(paper == null ? null : paper.getDurationMin());
|
exam.setCreatorUserId(UserProvider.getLoginUserId());
|
exam.setCreatorTime(now);
|
examMapper.insert(exam);
|
}
|
/**
|
* 学员签到
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public TmsPersonTaskSignResult sign(String id) {
|
TmsPersonTaskEntity person = requireMine(id);
|
TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
if (!TmsTaskPublishStatus.PUBLISHED.equalsCode(task.getPublishStatus())) {
|
throw new DataException("任务未发布，不可签到");
|
}
|
if (TmsPersonTaskStatus.CANCELLED.equalsCode(person.getBizStatus())) {
|
throw new DataException("任务已取消，不可签到");
|
}
|
if (person.getSignTime() != null) {
|
throw new DataException("您已签到，无需重复签到");
|
}
|
String deny = resolveSignDenyReason(task, person);
|
if (StringUtil.isNotEmpty(deny)) {
|
throw new DataException(deny);
|
}
|
|
Date now = new Date();
|
person.setSignTime(now);
|
person.setSignMode(TmsSignMode.ONLINE.getCode());
|
if (TmsPersonTaskStatus.TODO.equalsCode(person.getBizStatus()) || StringUtil.isEmpty(person.getBizStatus())) {
|
person.setBizStatus(TmsPersonTaskStatus.SIGNED.getCode());
|
}
|
person.setLastModifyUserId(UserProvider.getLoginUserId());
|
person.setLastModifyTime(now);
|
personTaskMapper.updateById(person);
|
upsertRecordSign(task.getId(), person, TmsSignMode.ONLINE.getCode(), now);
|
refreshRecordRates(task.getId());
|
|
TmsPersonTaskSignResult result = new TmsPersonTaskSignResult();
|
result.setSignTime(formatDate(now));
|
result.setBizStatus(person.getBizStatus());
|
result.setSigned(true);
|
result.setCanSign(false);
|
result.setSignTip("已签到");
|
result.setMessage("签到成功");
|
TmsPersonTaskMineForm tmp = new TmsPersonTaskMineForm();
|
fillExamFlag(tmp, task, person);
|
if (Boolean.TRUE.equals(tmp.getCanExam())
|
&& TmsEvalMode.EXAM.equalsCode(task.getEvalMode())
|
&& StringUtil.isNotEmpty(task.getPaperId())) {
|
ensurePendingExam(person, task);
|
}
|
result.setCanExam(Boolean.TRUE.equals(tmp.getCanExam()));
|
result.setExamTip(tmp.getExamTip());
|
result.setPersonTaskId(person.getId());
|
fillQuizOnSignResult(result, task, person);
|
return result;
|
}
|
/**
|
* 扫码签到
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public TmsPersonTaskSignResult scanSign(String qrContent, String signMode) {
|
Map<String, Object> payload = parseSignQr(qrContent);
|
String type = stringVal(payload.get("t"));
|
if (!TmsQrType.SIGN.equalsCode(type)) {
|
throw new DataException("无效的签到二维码");
|
}
|
long expMs = toLong(payload.get("exp"));
|
if (expMs <= 0 || System.currentTimeMillis() > expMs) {
|
throw new DataException("签到二维码已过期，请刷新后重扫");
|
}
|
String recordId = stringVal(payload.get("recordId"));
|
String taskId = stringVal(payload.get("taskId"));
|
if (StringUtil.isEmpty(recordId)) {
|
throw new DataException("签到二维码缺少培训记录");
|
}
|
|
TmsRecordEntity record = recordMapper.selectById(recordId);
|
if (record == null) {
|
throw new DataException("培训记录不存在");
|
}
|
if (TmsArchiveStatus.ARCHIVED.equalsCode(record.getArchiveStatus())) {
|
throw new DataException("已存档记录不可签到");
|
}
|
if (StringUtil.isEmpty(taskId)) {
|
taskId = record.getTaskId();
|
}
|
if (StringUtil.isEmpty(taskId) || !taskId.equals(record.getTaskId())) {
|
throw new DataException("签到二维码与培训记录不匹配");
|
}
|
|
TmsTaskEntity task = taskMapper.selectById(taskId);
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
if (!TmsTaskPublishStatus.PUBLISHED.equalsCode(task.getPublishStatus())) {
|
throw new DataException("任务未发布，不可签到");
|
}
|
String signRule = resolveSignRule(task.getTrainMode());
|
if (!TmsSignRule.SCAN.equalsCodeIgnoreCase(signRule) && !TmsSignRule.BOTH.equalsCodeIgnoreCase(signRule)) {
|
throw new DataException("该培训方式不支持扫码签到");
|
}
|
|
String mode = normalizeScanSignMode(signMode);
|
TmsSignModeEntity signModeCfg = requireEnabledSignMode(mode);
|
|
String userId = UserProvider.getLoginUserId();
|
if (StringUtil.isEmpty(userId)) {
|
throw new DataException("请先登录后再扫码签到");
|
}
|
TmsPersonTaskEntity person = personTaskMapper.selectOne(
|
new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, taskId)
|
.eq(TmsPersonTaskEntity::getUserId, userId)
|
.last("LIMIT 1"));
|
boolean guest = false;
|
if (person == null) {
|
if (!allowGuestScan(task.getTrainMode(), signModeCfg)) {
|
throw new DataException("您不在本场培训名单中，无法签到");
|
}
|
person = createGuestPersonTask(task, userId);
|
guest = true;
|
}
|
if (TmsPersonTaskStatus.CANCELLED.equalsCode(person.getBizStatus())) {
|
throw new DataException("任务已取消，不可签到");
|
}
|
if (person.getSignTime() != null) {
|
TmsPersonTaskSignResult dup = new TmsPersonTaskSignResult();
|
dup.setSignTime(formatDate(person.getSignTime()));
|
dup.setBizStatus(person.getBizStatus());
|
dup.setSigned(true);
|
dup.setCanSign(false);
|
dup.setSignTip("已签到");
|
dup.setMessage("您已签到，无需重复签到");
|
TmsPersonTaskMineForm tmp = new TmsPersonTaskMineForm();
|
fillExamFlag(tmp, task, person);
|
dup.setCanExam(Boolean.TRUE.equals(tmp.getCanExam()));
|
dup.setExamTip(tmp.getExamTip());
|
dup.setPersonTaskId(person.getId());
|
fillQuizOnSignResult(dup, task, person);
|
return dup;
|
}
|
|
String timeDeny = resolveScanTimeDenyReason(task);
|
if (StringUtil.isNotEmpty(timeDeny)) {
|
throw new DataException(timeDeny);
|
}
|
|
Date now = new Date();
|
person.setSignTime(now);
|
person.setSignMode(mode);
|
if (guest) {
|
person.setGuestFlag("1");
|
}
|
if (TmsPersonTaskStatus.TODO.equalsCode(person.getBizStatus()) || StringUtil.isEmpty(person.getBizStatus())) {
|
person.setBizStatus(TmsPersonTaskStatus.SIGNED.getCode());
|
}
|
person.setLastModifyUserId(userId);
|
person.setLastModifyTime(now);
|
personTaskMapper.updateById(person);
|
upsertRecordSign(recordId, person, mode, now);
|
if (!guest) {
|
refreshRecordRates(taskId);
|
}
|
|
TmsPersonTaskSignResult result = new TmsPersonTaskSignResult();
|
result.setSignTime(formatDate(now));
|
result.setBizStatus(person.getBizStatus());
|
result.setSigned(true);
|
result.setCanSign(false);
|
result.setSignTip("已签到");
|
result.setMessage(guest ? "扫码签到成功（名单外）" : "扫码签到成功");
|
TmsPersonTaskMineForm tmp = new TmsPersonTaskMineForm();
|
fillExamFlag(tmp, task, person);
|
result.setCanExam(Boolean.TRUE.equals(tmp.getCanExam()));
|
result.setExamTip(tmp.getExamTip());
|
result.setPersonTaskId(person.getId());
|
if (!guest) {
|
fillQuizOnSignResult(result, task, person);
|
} else {
|
result.setNeedQuiz(false);
|
}
|
return result;
|
}
|
|
@Override
|
public List<TmsQuizQuestionVO> listQuizQuestions(String personTaskId) {
|
TmsPersonTaskEntity person = requireMine(personTaskId);
|
TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
|
if (task == null || !needsQuiz(task)) {
|
return Collections.emptyList();
|
}
|
if (hasQuizScore(task.getId(), person.getUserId())) {
|
return Collections.emptyList();
|
}
|
return buildQuizQuestions(task.getId());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public TmsQuizSubmitResult submitQuiz(String personTaskId, TmsQuizAnswerForm form) {
|
TmsPersonTaskEntity person = requireMine(personTaskId);
|
TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
if (!needsQuiz(task)) {
|
throw new DataException("当前任务无需提问");
|
}
|
if (person.getSignTime() == null) {
|
throw new DataException("请先完成签到");
|
}
|
if (hasQuizScore(task.getId(), person.getUserId())) {
|
throw new DataException("您已提交过提问答案");
|
}
|
List<TmsTaskQuizEntity> presets = taskQuizMapper.selectList(new LambdaQueryWrapper<TmsTaskQuizEntity>()
|
.eq(TmsTaskQuizEntity::getForeignId, task.getId())
|
.orderByAsc(TmsTaskQuizEntity::getSortNo)
|
.orderByAsc(TmsTaskQuizEntity::getCreatorTime));
|
if (presets == null || presets.isEmpty()) {
|
throw new DataException("任务未配置提问预设");
|
}
|
Map<String, String> answerMap = new HashMap<>();
|
if (form != null && form.getAnswers() != null) {
|
for (TmsQuizAnswerForm.Item item : form.getAnswers()) {
|
if (item != null && StringUtil.isNotEmpty(item.getQuizId())) {
|
answerMap.put(item.getQuizId(), item.getAnswer() == null ? "" : item.getAnswer().trim());
|
}
|
}
|
}
|
for (TmsTaskQuizEntity q : presets) {
|
if (StringUtil.isEmpty(answerMap.get(q.getId()))) {
|
throw new DataException("请完成全部提问后再提交");
|
}
|
}
|
|
TmsRecordEntity record = recordMapper.selectOne(new LambdaQueryWrapper<TmsRecordEntity>()
|
.eq(TmsRecordEntity::getTaskId, task.getId())
|
.last("LIMIT 1"));
|
String recordId = record == null ? null : record.getId();
|
Date now = new Date();
|
int correct = 0;
|
BigDecimal unit = BigDecimal.valueOf(100)
|
.divide(BigDecimal.valueOf(presets.size()), 2, RoundingMode.HALF_UP);
|
for (TmsTaskQuizEntity q : presets) {
|
String userAns = answerMap.getOrDefault(q.getId(), "");
|
boolean ok = TmsQuizHelper.answersMatch(q.getAnswer(), userAns);
|
if (ok) {
|
correct++;
|
}
|
TmsQuizScoreEntity scoreRow = new TmsQuizScoreEntity();
|
scoreRow.setId(RandomUtil.uuId());
|
scoreRow.setTaskId(task.getId());
|
scoreRow.setRecordId(recordId);
|
scoreRow.setUserId(person.getUserId());
|
scoreRow.setQuestion(q.getQuestion());
|
scoreRow.setAnswer(userAns);
|
scoreRow.setScore(ok ? unit : BigDecimal.ZERO);
|
scoreRow.setQuizTime(now);
|
scoreRow.setCreatorUserId(person.getUserId());
|
scoreRow.setCreatorTime(now);
|
quizScoreMapper.insert(scoreRow);
|
}
|
|
BigDecimal totalScore = BigDecimal.valueOf(correct)
|
.multiply(BigDecimal.valueOf(100))
|
.divide(BigDecimal.valueOf(presets.size()), 1, RoundingMode.HALF_UP);
|
BigDecimal passScore = task.getPassScore() == null ? BigDecimal.valueOf(60) : task.getPassScore();
|
String passFlag = totalScore.compareTo(passScore) >= 0
|
? TmsPassFlag.PASS.getCode()
|
: TmsPassFlag.FAIL.getCode();
|
|
person.setPassFlag(passFlag);
|
if (TmsPassFlag.isPass(passFlag)) {
|
person.setBizStatus(TmsPersonTaskStatus.DONE.getCode());
|
}
|
person.setLastModifyUserId(person.getUserId());
|
person.setLastModifyTime(now);
|
personTaskMapper.updateById(person);
|
|
if (StringUtil.isNotEmpty(recordId)) {
|
TmsRecordSignEntity sign = recordSignMapper.selectOne(new LambdaQueryWrapper<TmsRecordSignEntity>()
|
.eq(TmsRecordSignEntity::getForeignId, recordId)
|
.eq(TmsRecordSignEntity::getUserId, person.getUserId())
|
.last("LIMIT 1"));
|
if (sign != null) {
|
sign.setQuizScore(totalScore);
|
sign.setResultFlag(passFlag);
|
sign.setLastModifyUserId(person.getUserId());
|
sign.setLastModifyTime(now);
|
recordSignMapper.updateById(sign);
|
}
|
}
|
refreshRecordRates(task.getId());
|
|
TmsQuizSubmitResult result = new TmsQuizSubmitResult();
|
result.setScore(totalScore);
|
result.setPassFlag(passFlag);
|
result.setMessage(TmsPassFlag.isPass(passFlag)
|
? "提问已提交，判定合格"
|
: "提问已提交，未达合格分");
|
return result;
|
}
|
|
@Override
|
public TmsQuizAnswerPaperVO getMyQuizAnswers(String personTaskId) {
|
TmsPersonTaskEntity person = requireMine(personTaskId);
|
TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
if (!needsQuiz(task)) {
|
throw new DataException("当前任务无需提问");
|
}
|
List<TmsQuizScoreEntity> scores = quizScoreMapper.selectList(new LambdaQueryWrapper<TmsQuizScoreEntity>()
|
.eq(TmsQuizScoreEntity::getTaskId, task.getId())
|
.eq(TmsQuizScoreEntity::getUserId, person.getUserId())
|
.orderByAsc(TmsQuizScoreEntity::getCreatorTime)
|
.orderByAsc(TmsQuizScoreEntity::getId));
|
if (scores == null || scores.isEmpty()) {
|
throw new DataException("尚未提交提问答卷");
|
}
|
List<TmsTaskQuizEntity> presets = taskQuizMapper.selectList(new LambdaQueryWrapper<TmsTaskQuizEntity>()
|
.eq(TmsTaskQuizEntity::getForeignId, task.getId())
|
.orderByAsc(TmsTaskQuizEntity::getSortNo)
|
.orderByAsc(TmsTaskQuizEntity::getCreatorTime));
|
TmsRecordEntity record = recordMapper.selectOne(new LambdaQueryWrapper<TmsRecordEntity>()
|
.eq(TmsRecordEntity::getTaskId, task.getId())
|
.last("LIMIT 1"));
|
String recordId = record == null ? null : record.getId();
|
BigDecimal quizScore = null;
|
if (StringUtil.isNotEmpty(recordId)) {
|
TmsRecordSignEntity sign = recordSignMapper.selectOne(new LambdaQueryWrapper<TmsRecordSignEntity>()
|
.eq(TmsRecordSignEntity::getForeignId, recordId)
|
.eq(TmsRecordSignEntity::getUserId, person.getUserId())
|
.last("LIMIT 1"));
|
if (sign != null) {
|
quizScore = sign.getQuizScore();
|
}
|
}
|
String quizTime = formatDate(scores.get(0).getQuizTime() != null
|
? scores.get(0).getQuizTime()
|
: scores.get(0).getCreatorTime());
|
TmsQuizAnswerPaperVO paper = TmsQuizHelper.buildAnswerPaper(
|
recordId,
|
task.getId(),
|
person.getUserId(),
|
null,
|
person.getPassFlag(),
|
quizTime,
|
scores,
|
presets);
|
if (quizScore != null) {
|
paper.setTotalScore(quizScore);
|
}
|
return paper;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
/**
|
* 在线考试交卷后回写：成绩、合格标记、个人任务业务状态。
|
* 不写 tms_person_train（档案目录仍等记录归档）。
|
*/
|
public void writeBackExamResult(String personTaskId, BigDecimal examScore, String passFlag) {
|
if (StringUtil.isEmpty(personTaskId)) {
|
return;
|
}
|
TmsPersonTaskEntity person = personTaskMapper.selectById(personTaskId);
|
if (person == null || TmsPersonTaskStatus.CANCELLED.equalsCode(person.getBizStatus())) {
|
return;
|
}
|
Date now = new Date();
|
person.setExamScore(examScore);
|
person.setPassFlag(TmsPassFlag.normalize(passFlag));
|
person.setBizStatus(TmsPersonTaskStatus.DONE.getCode());
|
person.setLastModifyTime(now);
|
String loginId = UserProvider.getLoginUserId();
|
if (StringUtil.isNotEmpty(loginId)) {
|
person.setLastModifyUserId(loginId);
|
}
|
personTaskMapper.updateById(person);
|
syncRecordSignExamResult(person, examScore, person.getPassFlag(), now);
|
refreshRecordRates(person.getTaskId());
|
}
|
|
private void refreshRecordRates(String taskId) {
|
try {
|
if (recordService != null) {
|
recordService.refreshRatesByTaskId(taskId);
|
}
|
} catch (Exception ignored) {
|
// 进度回写失败不影响主流程
|
}
|
}
|
|
private void fillQuizOnSignResult(TmsPersonTaskSignResult result, TmsTaskEntity task, TmsPersonTaskEntity person) {
|
if (result == null || task == null || person == null) {
|
return;
|
}
|
if (!needsQuiz(task) || hasQuizScore(task.getId(), person.getUserId())) {
|
result.setNeedQuiz(false);
|
result.setQuizQuestions(Collections.emptyList());
|
return;
|
}
|
List<TmsQuizQuestionVO> questions = buildQuizQuestions(task.getId());
|
result.setNeedQuiz(!questions.isEmpty());
|
result.setQuizQuestions(questions);
|
}
|
|
private boolean needsQuiz(TmsTaskEntity task) {
|
if (task == null) {
|
return false;
|
}
|
if (TmsEvalMode.QUIZ.equalsCode(task.getEvalMode())) {
|
return true;
|
}
|
if (StringUtil.isEmpty(task.getEvalMode())) {
|
return false;
|
}
|
TmsEvalModeEntity mode = evalModeMapper.selectOne(new LambdaQueryWrapper<TmsEvalModeEntity>()
|
.eq(TmsEvalModeEntity::getModeCode, task.getEvalMode())
|
.last("LIMIT 1"));
|
return mode != null && "1".equals(mode.getNeedQuiz());
|
}
|
|
private boolean hasQuizScore(String taskId, String userId) {
|
if (StringUtil.isEmpty(taskId) || StringUtil.isEmpty(userId)) {
|
return false;
|
}
|
Long cnt = quizScoreMapper.selectCount(new LambdaQueryWrapper<TmsQuizScoreEntity>()
|
.eq(TmsQuizScoreEntity::getTaskId, taskId)
|
.eq(TmsQuizScoreEntity::getUserId, userId));
|
return cnt != null && cnt > 0;
|
}
|
|
private List<TmsQuizQuestionVO> buildQuizQuestions(String taskId) {
|
List<TmsTaskQuizEntity> rows = taskQuizMapper.selectList(new LambdaQueryWrapper<TmsTaskQuizEntity>()
|
.eq(TmsTaskQuizEntity::getForeignId, taskId)
|
.orderByAsc(TmsTaskQuizEntity::getSortNo)
|
.orderByAsc(TmsTaskQuizEntity::getCreatorTime));
|
List<TmsQuizQuestionVO> list = new ArrayList<>();
|
if (rows == null) {
|
return list;
|
}
|
for (TmsTaskQuizEntity row : rows) {
|
if (row == null || StringUtil.isEmpty(row.getQuestion())) {
|
continue;
|
}
|
TmsQuizQuestionVO vo = new TmsQuizQuestionVO();
|
vo.setId(row.getId());
|
vo.setSortNo(row.getSortNo());
|
vo.setQuestion(row.getQuestion());
|
list.add(vo);
|
}
|
return list;
|
}
|
|
/**
|
* 同步签到记录中的考试结果
|
*/
|
private void syncRecordSignExamResult(TmsPersonTaskEntity person, BigDecimal examScore, String passFlag, Date now) {
|
if (person == null || StringUtil.isEmpty(person.getUserId()) || StringUtil.isEmpty(person.getTaskId())) {
|
return;
|
}
|
TmsRecordEntity record = recordMapper.selectOne(
|
new LambdaQueryWrapper<TmsRecordEntity>()
|
.eq(TmsRecordEntity::getTaskId, person.getTaskId())
|
.last("LIMIT 1"));
|
if (record == null) {
|
return;
|
}
|
TmsRecordSignEntity sign = recordSignMapper.selectOne(
|
new LambdaQueryWrapper<TmsRecordSignEntity>()
|
.eq(TmsRecordSignEntity::getForeignId, record.getId())
|
.eq(TmsRecordSignEntity::getUserId, person.getUserId())
|
.last("LIMIT 1"));
|
if (sign == null) {
|
return;
|
}
|
sign.setExamScore(examScore);
|
sign.setResultFlag(TmsPassFlag.normalize(passFlag));
|
sign.setLastModifyUserId(UserProvider.getLoginUserId());
|
sign.setLastModifyTime(now);
|
recordSignMapper.updateById(sign);
|
}
|
|
/** 写入/更新培训记录签到明细 */
|
private void upsertRecordSign(String recordIdOrTaskId, TmsPersonTaskEntity person, String signMode, Date now) {
|
if (person == null || StringUtil.isEmpty(person.getUserId())) {
|
return;
|
}
|
String recordId = recordIdOrTaskId;
|
TmsRecordEntity byId = StringUtil.isNotEmpty(recordId) ? recordMapper.selectById(recordId) : null;
|
if (byId == null && StringUtil.isNotEmpty(person.getTaskId())) {
|
byId = recordMapper.selectOne(
|
new LambdaQueryWrapper<TmsRecordEntity>()
|
.eq(TmsRecordEntity::getTaskId, person.getTaskId())
|
.last("LIMIT 1"));
|
}
|
if (byId == null) {
|
return;
|
}
|
recordId = byId.getId();
|
TmsRecordSignEntity exists = recordSignMapper.selectOne(
|
new LambdaQueryWrapper<TmsRecordSignEntity>()
|
.eq(TmsRecordSignEntity::getForeignId, recordId)
|
.eq(TmsRecordSignEntity::getUserId, person.getUserId())
|
.last("LIMIT 1"));
|
if (exists != null) {
|
exists.setSignTime(now);
|
exists.setSignMode(signMode);
|
exists.setGuestFlag(StringUtil.isNotEmpty(person.getGuestFlag()) ? person.getGuestFlag() : "0");
|
exists.setDeptId(person.getDeptId());
|
exists.setLastModifyUserId(UserProvider.getLoginUserId());
|
exists.setLastModifyTime(now);
|
recordSignMapper.updateById(exists);
|
return;
|
}
|
TmsRecordSignEntity row = new TmsRecordSignEntity();
|
row.setId(RandomUtil.uuId());
|
row.setForeignId(recordId);
|
row.setUserId(person.getUserId());
|
row.setDeptId(person.getDeptId());
|
row.setSignTime(now);
|
row.setSignMode(signMode);
|
row.setGuestFlag(StringUtil.isNotEmpty(person.getGuestFlag()) ? person.getGuestFlag() : "0");
|
row.setCreatorUserId(UserProvider.getLoginUserId());
|
row.setCreatorTime(now);
|
recordSignMapper.insert(row);
|
}
|
|
/**
|
* 创建访客个人任务
|
*/
|
private TmsPersonTaskEntity createGuestPersonTask(TmsTaskEntity task, String userId) {
|
Date now = new Date();
|
TmsPersonTaskEntity pt = new TmsPersonTaskEntity();
|
pt.setId(RandomUtil.uuId());
|
pt.setTaskId(task.getId());
|
pt.setTaskNo(task.getTaskNo());
|
pt.setUserId(userId);
|
pt.setHours(null);
|
pt.setBizStatus(TmsPersonTaskStatus.TODO.getCode());
|
pt.setGuestFlag("1");
|
pt.setCreatorUserId(userId);
|
pt.setCreatorTime(now);
|
personTaskMapper.insert(pt);
|
return pt;
|
}
|
|
/**
|
* 是否允许访客扫码
|
*/
|
private boolean allowGuestScan(String trainModeCode, TmsSignModeEntity signMode) {
|
if (signMode != null && "1".equals(signMode.getMatchRoster())) {
|
return false;
|
}
|
TmsTrainModeEntity tm = loadTrainMode(trainModeCode);
|
return tm != null && "1".equals(tm.getAllowGuestSign());
|
}
|
|
/**
|
* 加载培训方式配置
|
*/
|
private TmsTrainModeEntity loadTrainMode(String trainModeCode) {
|
if (StringUtil.isEmpty(trainModeCode)) {
|
return null;
|
}
|
return trainModeMapper.selectOne(
|
new LambdaQueryWrapper<TmsTrainModeEntity>()
|
.eq(TmsTrainModeEntity::getModeCode, trainModeCode)
|
.last("LIMIT 1"));
|
}
|
|
/**
|
* 解析签到二维码内容
|
*/
|
private Map<String, Object> parseSignQr(String qrContent) {
|
if (StringUtil.isEmpty(qrContent)) {
|
throw new DataException("签到二维码内容为空");
|
}
|
try {
|
Map<String, Object> map = OBJECT_MAPPER.readValue(qrContent.trim(),
|
new TypeReference<Map<String, Object>>() {
|
});
|
if (map == null || map.isEmpty()) {
|
throw new DataException("无效的签到二维码");
|
}
|
return map;
|
} catch (DataException ex) {
|
throw ex;
|
} catch (Exception ex) {
|
throw new DataException("无效的签到二维码");
|
}
|
}
|
|
/**
|
* 规范化扫码签到方式
|
*/
|
private String normalizeScanSignMode(String signMode) {
|
if (TmsSignMode.WX_SCAN.getCode().equalsIgnoreCase(signMode)) {
|
return TmsSignMode.WX_SCAN.getCode();
|
}
|
return TmsSignMode.APP_SCAN.getCode();
|
}
|
|
/**
|
* 确保扫码签到方式已启用
|
*/
|
private void ensureScanModeEnabled(String modeCode) {
|
requireEnabledSignMode(modeCode);
|
}
|
|
/**
|
* 校验签到方式已启用
|
*/
|
private TmsSignModeEntity requireEnabledSignMode(String modeCode) {
|
TmsSignModeEntity sm = signModeMapper.selectOne(
|
new LambdaQueryWrapper<TmsSignModeEntity>()
|
.eq(TmsSignModeEntity::getModeCode, modeCode)
|
.eq(TmsSignModeEntity::getEnabled, "1")
|
.last("LIMIT 1"));
|
if (sm == null) {
|
throw new DataException("签到方式未启用：" + modeCode);
|
}
|
return sm;
|
}
|
|
/** 扫码时间窗（不含在线签到规则校验） */
|
private String resolveScanTimeDenyReason(TmsTaskEntity task) {
|
Date now = new Date();
|
if (task.getStartTime() != null && now.before(task.getStartTime())) {
|
return "未到培训开始时间，暂不可签到";
|
}
|
if (task.getCloseTime() != null && now.after(task.getCloseTime())) {
|
return "培训已关闭，不可签到";
|
}
|
if (task.getEndTime() != null && now.after(task.getEndTime()) && task.getCloseTime() == null) {
|
return "已过培训结束时间，不可签到";
|
}
|
return "";
|
}
|
|
/**
|
* 安全转字符串
|
*/
|
private static String stringVal(Object raw) {
|
return raw == null ? "" : String.valueOf(raw).trim();
|
}
|
|
/**
|
* 转 Long
|
*/
|
private static long toLong(Object raw) {
|
if (raw == null) {
|
return 0L;
|
}
|
if (raw instanceof Number) {
|
return ((Number) raw).longValue();
|
}
|
try {
|
return Long.parseLong(String.valueOf(raw).trim());
|
} catch (Exception ex) {
|
return 0L;
|
}
|
}
|
|
/**
|
* 实体转为表单/VO
|
*/
|
private TmsPersonTaskMineForm toForm(TmsPersonTaskEntity person, TmsTaskEntity task, boolean detail) {
|
TmsPersonTaskMineForm form = new TmsPersonTaskMineForm();
|
form.setId(person.getId());
|
form.setTaskId(task.getId());
|
form.setTaskNo(StringUtil.isNotEmpty(person.getTaskNo()) ? person.getTaskNo() : task.getTaskNo());
|
form.setSubject(task.getSubject());
|
form.setCategory(task.getCategory());
|
form.setTrainMode(task.getTrainMode());
|
form.setEvalMode(task.getEvalMode());
|
form.setStartTime(formatDate(task.getStartTime()));
|
form.setEndTime(formatDate(task.getEndTime()));
|
form.setCloseTime(formatDate(task.getCloseTime()));
|
form.setPlaceName(task.getPlaceName());
|
form.setBizStatus(person.getBizStatus());
|
form.setSignTime(formatDate(person.getSignTime()));
|
form.setSigned(person.getSignTime() != null);
|
form.setSignRule(resolveSignRule(task.getTrainMode()));
|
form.setTipSeconds(resolveOnlineTipSeconds());
|
fillSignFlag(form, task, person);
|
form.setLearnSeconds(person.getLearnSeconds());
|
int learned = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
|
form.setLearnedSeconds(learned);
|
BigDecimal hours = person.getHours();
|
form.setRequiredHours(hours);
|
int requiredSeconds = toRequiredSeconds(hours);
|
form.setRequiredSeconds(requiredSeconds);
|
form.setLearnStatus(resolveLearnStatus(learned, requiredSeconds));
|
form.setExamScore(person.getExamScore());
|
form.setPassFlag(person.getPassFlag());
|
form.setPaperId(task.getPaperId());
|
form.setPaperName(task.getPaperName());
|
fillExamFlag(form, task, person);
|
if (detail) {
|
form.setKeyPoints(task.getKeyPoints());
|
}
|
return form;
|
}
|
|
/**
|
* 回填考试标识
|
*/
|
private void fillExamFlag(TmsPersonTaskMineForm form, TmsTaskEntity task, TmsPersonTaskEntity person) {
|
if (!TmsEvalMode.EXAM.equalsCode(task.getEvalMode())) {
|
form.setCanExam(false);
|
form.setExamTip("本次培训无需在线考试");
|
return;
|
}
|
if (StringUtil.isEmpty(task.getPaperId())) {
|
form.setCanExam(false);
|
form.setExamTip("未配置试卷");
|
return;
|
}
|
if (person.getSignTime() == null) {
|
form.setCanExam(false);
|
form.setExamTip("请先签到后再考试");
|
return;
|
}
|
// 配置了课时则须学满后再考（在线/现场一致），便于「学完生成待考试卷」
|
int required = toRequiredSeconds(person.getHours());
|
int learned = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
|
if (required > 0 && learned < required) {
|
form.setCanExam(false);
|
form.setExamTip("请先学满规定课时后再考试（已学 "
|
+ formatDuration(learned) + " / 需学 " + formatDuration(required) + "）");
|
return;
|
}
|
Date now = new Date();
|
if (task.getExamStart() != null && now.before(task.getExamStart())) {
|
form.setCanExam(false);
|
form.setExamTip("未到考试开始时间");
|
return;
|
}
|
if (task.getExamEnd() != null && now.after(task.getExamEnd())) {
|
form.setCanExam(false);
|
form.setExamTip("已过考试结束时间");
|
return;
|
}
|
form.setCanExam(true);
|
form.setExamTip("");
|
}
|
|
/**
|
* 回填签到标识
|
*/
|
private void fillSignFlag(TmsPersonTaskMineForm form, TmsTaskEntity task, TmsPersonTaskEntity person) {
|
if (person.getSignTime() != null) {
|
form.setCanSign(false);
|
form.setSignTip("已签到");
|
return;
|
}
|
String deny = resolveSignDenyReason(task, person);
|
if (StringUtil.isNotEmpty(deny)) {
|
form.setCanSign(false);
|
form.setSignTip(deny);
|
return;
|
}
|
form.setCanSign(true);
|
form.setSignTip("");
|
}
|
|
/** 返回不可签到原因；空字符串表示可签到 */
|
private String resolveSignDenyReason(TmsTaskEntity task, TmsPersonTaskEntity person) {
|
if (TmsPersonTaskStatus.CANCELLED.equalsCode(person.getBizStatus())) {
|
return "任务已取消，不可签到";
|
}
|
if (task == null || !TmsTaskPublishStatus.PUBLISHED.equalsCode(task.getPublishStatus())) {
|
return "任务未发布，不可签到";
|
}
|
if (!allowOnlineSign(task.getTrainMode())) {
|
return "该培训方式不支持在线签到，请到培训现场扫码签到";
|
}
|
Date now = new Date();
|
if (task.getStartTime() != null && now.before(task.getStartTime())) {
|
return "未到培训开始时间，暂不可签到";
|
}
|
if (task.getCloseTime() != null && now.after(task.getCloseTime())) {
|
return "培训已关闭，不可签到";
|
}
|
if (task.getEndTime() != null && now.after(task.getEndTime()) && task.getCloseTime() == null) {
|
return "已过培训结束时间，不可签到";
|
}
|
return "";
|
}
|
|
/**
|
* 是否允许在线签到
|
*/
|
private boolean allowOnlineSign(String trainMode) {
|
return TmsSignRule.BOTH.equalsCodeIgnoreCase(resolveSignRule(trainMode));
|
}
|
|
/** scan=仅扫码 / both=扫码+在线；无配置时 online→both，其它→scan */
|
private String resolveSignRule(String trainMode) {
|
if (StringUtil.isEmpty(trainMode)) {
|
return "";
|
}
|
TmsTrainModeEntity mode = trainModeMapper.selectOne(
|
new LambdaQueryWrapper<TmsTrainModeEntity>()
|
.eq(TmsTrainModeEntity::getModeCode, trainMode)
|
.last("LIMIT 1"));
|
if (mode != null && StringUtil.isNotEmpty(mode.getSignRule())) {
|
return mode.getSignRule().trim();
|
}
|
return TmsTrainMode.ONLINE.equalsCodeIgnoreCase(trainMode) ? TmsSignRule.BOTH.getCode() : TmsSignRule.SCAN.getCode();
|
}
|
|
/** 启用的在线签到方式要点秒数；未配置或未启用则 0 */
|
private int resolveOnlineTipSeconds() {
|
TmsSignModeEntity sm = signModeMapper.selectOne(
|
new LambdaQueryWrapper<TmsSignModeEntity>()
|
.eq(TmsSignModeEntity::getModeCode, TmsSignMode.ONLINE.getCode())
|
.eq(TmsSignModeEntity::getEnabled, "1")
|
.last("LIMIT 1"));
|
if (sm == null || sm.getTipSeconds() == null || sm.getTipSeconds() < 0) {
|
return 0;
|
}
|
return sm.getTipSeconds();
|
}
|
|
/**
|
* 换算要求学习秒数
|
*/
|
private int toRequiredSeconds(BigDecimal hours) {
|
if (hours == null || hours.compareTo(BigDecimal.ZERO) <= 0) {
|
return 0;
|
}
|
return hours.multiply(BigDecimal.valueOf(3600)).intValue();
|
}
|
|
/**
|
* 解析学习状态
|
*/
|
private String resolveLearnStatus(int learned, int required) {
|
if (required > 0 && learned >= required) {
|
return "已学满";
|
}
|
if (learned > 0) {
|
return "学习中";
|
}
|
return "未学习";
|
}
|
|
/**
|
* 格式化时长
|
*/
|
private String formatDuration(int seconds) {
|
int h = seconds / 3600;
|
int m = (seconds % 3600) / 60;
|
int s = seconds % 60;
|
if (h > 0) {
|
return h + "小时" + m + "分";
|
}
|
if (m > 0) {
|
return m + "分" + s + "秒";
|
}
|
return s + "秒";
|
}
|
|
/**
|
* 加载学习课件/附件
|
*/
|
private List<TmsPersonTaskFileForm> loadFiles(String taskId) {
|
List<TmsTaskFileEntity> files = taskFileMapper.selectList(
|
new LambdaQueryWrapper<TmsTaskFileEntity>()
|
.eq(TmsTaskFileEntity::getForeignId, taskId)
|
.orderByAsc(TmsTaskFileEntity::getCreatorTime));
|
if (files.isEmpty()) {
|
return Collections.emptyList();
|
}
|
List<String> materialIds = files.stream()
|
.map(TmsTaskFileEntity::getMaterialId)
|
.filter(StringUtil::isNotEmpty)
|
.distinct()
|
.collect(Collectors.toList());
|
Map<String, TmsMaterialEntity> materialMap = new HashMap<>();
|
if (!materialIds.isEmpty()) {
|
for (TmsMaterialEntity material : materialMapper.selectBatchIds(materialIds)) {
|
materialMap.put(material.getId(), material);
|
}
|
}
|
List<TmsPersonTaskFileForm> list = new ArrayList<>();
|
for (TmsTaskFileEntity file : files) {
|
Map<String, String> meta = extractFileMeta(file.getFileJson(), file.getFileName());
|
if ((StringUtil.isEmpty(meta.get("url")) || StringUtil.isEmpty(meta.get("ext")))
|
&& StringUtil.isNotEmpty(file.getMaterialId())) {
|
TmsMaterialEntity material = materialMap.get(file.getMaterialId());
|
if (material != null) {
|
Map<String, String> matMeta = extractFileMeta(material.getFileJson(), material.getMaterialName());
|
if (StringUtil.isEmpty(meta.get("url"))) {
|
meta.put("url", matMeta.get("url"));
|
}
|
if (StringUtil.isEmpty(meta.get("ext"))) {
|
meta.put("ext", matMeta.get("ext"));
|
}
|
if (StringUtil.isEmpty(meta.get("fileId"))) {
|
meta.put("fileId", matMeta.get("fileId"));
|
}
|
if (StringUtil.isEmpty(meta.get("fileVersionId"))) {
|
meta.put("fileVersionId", matMeta.get("fileVersionId"));
|
}
|
if (StringUtil.isEmpty(meta.get("name")) && StringUtil.isNotEmpty(matMeta.get("name"))) {
|
meta.put("name", matMeta.get("name"));
|
}
|
}
|
}
|
TmsPersonTaskFileForm item = new TmsPersonTaskFileForm();
|
item.setId(file.getId());
|
item.setName(StringUtil.isNotEmpty(file.getFileName()) ? file.getFileName() : meta.get("name"));
|
item.setUrl(meta.get("url"));
|
item.setFileId(meta.get("fileId"));
|
item.setFileVersionId(meta.get("fileVersionId"));
|
item.setFileExt(meta.get("ext"));
|
item.setPreviewType(resolvePreviewType(meta.get("ext")));
|
list.add(item);
|
}
|
return list;
|
}
|
|
/** 从 JNPF 附件 JSON 解析 url / fileId / 扩展名等。 */
|
private Map<String, String> extractFileMeta(String fileJson, String fileName) {
|
Map<String, String> meta = new HashMap<>();
|
meta.put("url", null);
|
meta.put("fileId", null);
|
meta.put("fileVersionId", null);
|
meta.put("ext", null);
|
meta.put("name", fileName);
|
try {
|
if (StringUtil.isNotEmpty(fileJson)) {
|
String text = fileJson.trim();
|
Map<String, Object> map = null;
|
if (text.startsWith("[")) {
|
List<Map<String, Object>> arr = OBJECT_MAPPER.readValue(text, new TypeReference<List<Map<String, Object>>>() {
|
});
|
if (arr != null && !arr.isEmpty()) {
|
map = arr.get(0);
|
}
|
} else {
|
map = OBJECT_MAPPER.readValue(text, new TypeReference<Map<String, Object>>() {
|
});
|
}
|
if (map != null) {
|
if (map.get("url") != null) {
|
meta.put("url", String.valueOf(map.get("url")));
|
}
|
Object fid = map.get("fileId");
|
if (fid == null) {
|
fid = map.get("file_id");
|
}
|
if (fid != null) {
|
meta.put("fileId", String.valueOf(fid));
|
}
|
Object fvid = map.get("fileVersionId");
|
if (fvid == null) {
|
fvid = map.get("fileVersion");
|
}
|
if (fvid != null) {
|
meta.put("fileVersionId", String.valueOf(fvid));
|
}
|
if (map.get("fileExtension") != null) {
|
meta.put("ext", String.valueOf(map.get("fileExtension")).toLowerCase());
|
}
|
if (map.get("name") != null) {
|
meta.put("name", String.valueOf(map.get("name")));
|
if (StringUtil.isEmpty(meta.get("ext"))) {
|
fileName = String.valueOf(map.get("name"));
|
}
|
}
|
}
|
}
|
} catch (Exception ignored) {
|
// ignore
|
}
|
if (StringUtil.isEmpty(meta.get("ext")) && StringUtil.isNotEmpty(fileName) && fileName.contains(".")) {
|
meta.put("ext", fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase());
|
}
|
return meta;
|
}
|
|
/**
|
* 解析附件预览类型
|
*/
|
private String resolvePreviewType(String ext) {
|
if (StringUtil.isEmpty(ext)) {
|
return "other";
|
}
|
String e = ext.toLowerCase();
|
if (Set.of("jpg", "jpeg", "png", "gif", "webp", "bmp", "svg").contains(e)) {
|
return "image";
|
}
|
if (Set.of("mp4", "webm", "ogg", "mov", "m4v").contains(e)) {
|
return "video";
|
}
|
if (Set.of("mp3", "wav", "aac", "m4a", "flac").contains(e)) {
|
return "audio";
|
}
|
if ("pdf".equals(e)) {
|
return "pdf";
|
}
|
if (Set.of("doc", "docx", "docm", "dot", "dotx", "xls", "xlsx", "xlsm", "xlt", "xltx",
|
"ppt", "pptx", "pptm", "pps", "ppsx", "pot", "potx", "csv", "rtf",
|
"odt", "ods", "odp", "ott", "ots", "otp").contains(e)) {
|
return "office";
|
}
|
return "other";
|
}
|
|
/**
|
* 批量加载培训任务
|
*/
|
private Map<String, TmsTaskEntity> loadTasks(List<TmsPersonTaskEntity> persons) {
|
List<String> ids = persons.stream()
|
.map(TmsPersonTaskEntity::getTaskId)
|
.filter(StringUtil::isNotEmpty)
|
.distinct()
|
.collect(Collectors.toList());
|
if (ids.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
Map<String, TmsTaskEntity> map = new HashMap<>();
|
for (TmsTaskEntity task : taskMapper.selectBatchIds(ids)) {
|
map.put(task.getId(), task);
|
}
|
return map;
|
}
|
|
/**
|
* 关键字匹配
|
*/
|
private boolean matchKeyword(TmsPersonTaskEntity person, TmsTaskEntity task, String keyword) {
|
String no = person.getTaskNo() == null ? "" : person.getTaskNo();
|
String taskNo = task.getTaskNo() == null ? "" : task.getTaskNo();
|
String subject = task.getSubject() == null ? "" : task.getSubject();
|
return no.contains(keyword) || taskNo.contains(keyword) || subject.contains(keyword);
|
}
|
|
/**
|
* 筛选合格标识
|
*/
|
private boolean matchPassFlag(String queryFlag, String passFlag) {
|
if (StringUtil.isEmpty(queryFlag)) {
|
return true;
|
}
|
String q = queryFlag.trim();
|
if ("none".equalsIgnoreCase(q)) {
|
return StringUtil.isEmpty(passFlag);
|
}
|
String normalizedQuery = TmsPassFlag.normalize(q);
|
String normalizedPass = TmsPassFlag.normalize(passFlag);
|
if (normalizedQuery == null) {
|
return false;
|
}
|
return normalizedQuery.equals(normalizedPass);
|
}
|
|
/**
|
* 是否类条件匹配
|
*/
|
private boolean matchYesNo(String query, boolean actual) {
|
if (StringUtil.isEmpty(query)) {
|
return true;
|
}
|
if ("1".equals(query) || "true".equalsIgnoreCase(query) || "yes".equalsIgnoreCase(query)) {
|
return actual;
|
}
|
if ("0".equals(query) || "false".equalsIgnoreCase(query) || "no".equalsIgnoreCase(query)) {
|
return !actual;
|
}
|
return true;
|
}
|
|
/**
|
* 解析日开始时间
|
*/
|
private static Date parseDayStart(String day) {
|
if (StringUtil.isEmpty(day) || "null".equalsIgnoreCase(day)) {
|
return null;
|
}
|
String raw = day.trim();
|
if (raw.matches("^\\d{13}$")) {
|
return new Date(Long.parseLong(raw));
|
}
|
if (raw.matches("^\\d{10}$")) {
|
return new Date(Long.parseLong(raw) * 1000L);
|
}
|
if (raw.length() == 10) {
|
raw = raw + " 00:00:00";
|
}
|
return DateUtil.stringToDate(raw);
|
}
|
|
/**
|
* 解析日结束时间
|
*/
|
private static Date parseDayEnd(String day) {
|
if (StringUtil.isEmpty(day) || "null".equalsIgnoreCase(day)) {
|
return null;
|
}
|
String raw = day.trim();
|
if (raw.matches("^\\d{13}$") || raw.matches("^\\d{10}$")) {
|
long ms = raw.length() == 13 ? Long.parseLong(raw) : Long.parseLong(raw) * 1000L;
|
java.util.Calendar cal = java.util.Calendar.getInstance();
|
cal.setTimeInMillis(ms);
|
// DateRange 常传当天 00:00，按日末过滤
|
if (cal.get(java.util.Calendar.HOUR_OF_DAY) == 0
|
&& cal.get(java.util.Calendar.MINUTE) == 0
|
&& cal.get(java.util.Calendar.SECOND) == 0) {
|
cal.set(java.util.Calendar.HOUR_OF_DAY, 23);
|
cal.set(java.util.Calendar.MINUTE, 59);
|
cal.set(java.util.Calendar.SECOND, 59);
|
cal.set(java.util.Calendar.MILLISECOND, 999);
|
}
|
return cal.getTime();
|
}
|
if (raw.length() == 10) {
|
raw = raw + " 23:59:59";
|
}
|
return DateUtil.stringToDate(raw);
|
}
|
|
/**
|
* 校验并获取当前用户个人任务
|
*/
|
private TmsPersonTaskEntity requireMine(String id) {
|
if (StringUtil.isEmpty(id)) {
|
throw new DataException("个人任务ID不能为空");
|
}
|
TmsPersonTaskEntity person = personTaskMapper.selectById(id);
|
if (person == null) {
|
throw new DataException("个人培训任务不存在");
|
}
|
if (!UserProvider.getLoginUserId().equals(person.getUserId())) {
|
throw new DataException("只能查看自己的培训任务");
|
}
|
return person;
|
}
|
|
/**
|
* 格式化日期时间
|
*/
|
private String formatDate(Date date) {
|
return date == null ? null : DateUtil.dateToString(date, FMT);
|
}
|
}
|
