package jnpf.tmsService.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import jnpf.exception.DataException;
|
import jnpf.permission.OrganizeApi;
|
import jnpf.permission.UserApi;
|
import jnpf.permission.entity.OrganizeEntity;
|
import jnpf.permission.entity.UserEntity;
|
import jnpf.tmsEntity.TmsPersonTaskEntity;
|
import jnpf.tmsEntity.TmsPracticeEntity;
|
import jnpf.tmsEntity.TmsPracticeItemEntity;
|
import jnpf.tmsEntity.TmsRecordEntity;
|
import jnpf.tmsEntity.TmsRecordSignEntity;
|
import jnpf.tmsEntity.TmsTaskEntity;
|
import jnpf.tmsEntity.enums.TmsEvalMode;
|
import jnpf.tmsEntity.enums.TmsPassFlag;
|
import jnpf.tmsEntity.enums.TmsPersonTaskStatus;
|
import jnpf.tmsEntity.practice.TmsPracticeForm;
|
import jnpf.tmsEntity.practice.TmsPracticeItemForm;
|
import jnpf.tmsMapper.TmsPersonTaskMapper;
|
import jnpf.tmsMapper.TmsPracticeItemMapper;
|
import jnpf.tmsMapper.TmsPracticeMapper;
|
import jnpf.tmsMapper.TmsRecordMapper;
|
import jnpf.tmsMapper.TmsRecordSignMapper;
|
import jnpf.tmsMapper.TmsTaskMapper;
|
import jnpf.tmsService.TmsPracticeService;
|
import jnpf.tmsService.TmsRecordService;
|
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.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class TmsPracticeServiceImpl implements TmsPracticeService {
|
|
private static final String FMT = "yyyy-MM-dd HH:mm:ss";
|
|
private final TmsPracticeMapper practiceMapper;
|
private final TmsPracticeItemMapper practiceItemMapper;
|
private final TmsRecordMapper recordMapper;
|
private final TmsTaskMapper taskMapper;
|
private final TmsPersonTaskMapper personTaskMapper;
|
private final TmsRecordSignMapper recordSignMapper;
|
private final UserApi userApi;
|
private final OrganizeApi organizeApi;
|
|
@Lazy
|
@Autowired
|
private TmsRecordService recordService;
|
|
@Override
|
public TmsPracticeForm getByRecordId(String recordId) {
|
TmsRecordEntity record = requireRecord(recordId);
|
TmsPracticeEntity practice = practiceMapper.selectOne(new LambdaQueryWrapper<TmsPracticeEntity>()
|
.eq(TmsPracticeEntity::getRecordId, recordId)
|
.last("LIMIT 1"));
|
TmsPracticeForm form = new TmsPracticeForm();
|
form.setRecordId(recordId);
|
form.setTaskId(record.getTaskId());
|
if (practice != null) {
|
form.setId(practice.getId());
|
form.setTeacherId(practice.getTeacherId());
|
form.setPracticeTime(formatDate(practice.getPracticeTime()));
|
form.setRemark(practice.getRemark());
|
form.setItems(listItems(practice.getId()));
|
return form;
|
}
|
form.setTeacherId(UserProvider.getLoginUserId());
|
form.setItems(buildEmptyItems(record.getTaskId()));
|
return form;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public String save(TmsPracticeForm form) {
|
if (form == null || StringUtil.isEmpty(form.getRecordId())) {
|
throw new DataException("培训记录不能为空");
|
}
|
TmsRecordEntity record = requireRecord(form.getRecordId());
|
TmsTaskEntity task = taskMapper.selectById(record.getTaskId());
|
if (task == null) {
|
throw new DataException("培训任务不存在");
|
}
|
if (!TmsEvalMode.PRACTICE.equalsCode(task.getEvalMode())
|
&& !TmsEvalMode.PRACTICE.equalsCode(record.getEvalMode())) {
|
throw new DataException("当前记录非实操考核，无需实操打分");
|
}
|
List<TmsPracticeItemForm> items = form.getItems() == null ? Collections.emptyList() : form.getItems();
|
if (items.isEmpty()) {
|
throw new DataException("请至少录入一名学员的实操成绩");
|
}
|
|
Date now = new Date();
|
String teacherId = StringUtil.isNotEmpty(form.getTeacherId())
|
? form.getTeacherId()
|
: UserProvider.getLoginUserId();
|
TmsPracticeEntity practice = null;
|
if (StringUtil.isNotEmpty(form.getId())) {
|
practice = practiceMapper.selectById(form.getId());
|
}
|
if (practice == null) {
|
practice = practiceMapper.selectOne(new LambdaQueryWrapper<TmsPracticeEntity>()
|
.eq(TmsPracticeEntity::getRecordId, record.getId())
|
.last("LIMIT 1"));
|
}
|
if (practice == null) {
|
practice = new TmsPracticeEntity();
|
practice.setId(RandomUtil.uuId());
|
practice.setTaskId(record.getTaskId());
|
practice.setRecordId(record.getId());
|
practice.setTeacherId(teacherId);
|
practice.setPracticeTime(parseDate(form.getPracticeTime(), now));
|
practice.setRemark(form.getRemark());
|
practice.setCreatorUserId(UserProvider.getLoginUserId());
|
practice.setCreatorTime(now);
|
practiceMapper.insert(practice);
|
} else {
|
practice.setTeacherId(teacherId);
|
practice.setPracticeTime(parseDate(form.getPracticeTime(), now));
|
practice.setRemark(form.getRemark());
|
practice.setLastModifyUserId(UserProvider.getLoginUserId());
|
practice.setLastModifyTime(now);
|
practiceMapper.updateById(practice);
|
}
|
|
practiceItemMapper.delete(new LambdaQueryWrapper<TmsPracticeItemEntity>()
|
.eq(TmsPracticeItemEntity::getForeignId, practice.getId()));
|
|
BigDecimal passScore = task.getPassScore() == null ? BigDecimal.valueOf(60) : task.getPassScore();
|
for (TmsPracticeItemForm row : items) {
|
if (row == null || StringUtil.isEmpty(row.getUserId())) {
|
continue;
|
}
|
BigDecimal score = row.getScore() == null ? BigDecimal.ZERO : row.getScore();
|
String resultFlag = StringUtil.isNotEmpty(row.getResultFlag())
|
? TmsPassFlag.normalize(row.getResultFlag())
|
: TmsPassFlag.ofScore(score, passScore);
|
if (StringUtil.isEmpty(resultFlag)) {
|
resultFlag = score.compareTo(passScore) >= 0
|
? TmsPassFlag.PASS.getCode()
|
: TmsPassFlag.FAIL.getCode();
|
}
|
|
TmsPracticeItemEntity item = new TmsPracticeItemEntity();
|
item.setId(RandomUtil.uuId());
|
item.setForeignId(practice.getId());
|
item.setUserId(row.getUserId());
|
item.setContent(row.getContent());
|
item.setScore(score);
|
item.setResultFlag(resultFlag);
|
item.setCreatorUserId(UserProvider.getLoginUserId());
|
item.setCreatorTime(now);
|
practiceItemMapper.insert(item);
|
|
writeBackPerson(record.getTaskId(), record.getId(), row.getUserId(), score, resultFlag, now);
|
}
|
try {
|
recordService.refreshRatesByTaskId(record.getTaskId());
|
} catch (Exception ignored) {
|
// ignore
|
}
|
return practice.getId();
|
}
|
|
private void writeBackPerson(String taskId, String recordId, String userId,
|
BigDecimal score, String passFlag, Date now) {
|
TmsPersonTaskEntity person = personTaskMapper.selectOne(new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, taskId)
|
.eq(TmsPersonTaskEntity::getUserId, userId)
|
.last("LIMIT 1"));
|
if (person != null) {
|
person.setPassFlag(passFlag);
|
if (TmsPassFlag.isPass(passFlag)) {
|
person.setBizStatus(TmsPersonTaskStatus.DONE.getCode());
|
}
|
person.setLastModifyUserId(UserProvider.getLoginUserId());
|
person.setLastModifyTime(now);
|
personTaskMapper.updateById(person);
|
}
|
TmsRecordSignEntity sign = recordSignMapper.selectOne(new LambdaQueryWrapper<TmsRecordSignEntity>()
|
.eq(TmsRecordSignEntity::getForeignId, recordId)
|
.eq(TmsRecordSignEntity::getUserId, userId)
|
.last("LIMIT 1"));
|
if (sign != null) {
|
sign.setPracticeScore(score);
|
sign.setResultFlag(passFlag);
|
sign.setLastModifyUserId(UserProvider.getLoginUserId());
|
sign.setLastModifyTime(now);
|
recordSignMapper.updateById(sign);
|
}
|
}
|
|
private List<TmsPracticeItemForm> listItems(String practiceId) {
|
List<TmsPracticeItemEntity> rows = practiceItemMapper.selectList(
|
new LambdaQueryWrapper<TmsPracticeItemEntity>()
|
.eq(TmsPracticeItemEntity::getForeignId, practiceId)
|
.orderByAsc(TmsPracticeItemEntity::getCreatorTime));
|
List<String> userIds = rows.stream().map(TmsPracticeItemEntity::getUserId)
|
.filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
|
Map<String, String> names = loadUserNames(userIds);
|
List<TmsPracticeItemForm> list = new ArrayList<>(rows.size());
|
for (TmsPracticeItemEntity row : rows) {
|
TmsPracticeItemForm form = new TmsPracticeItemForm();
|
form.setId(row.getId());
|
form.setUserId(row.getUserId());
|
form.setUserName(names.getOrDefault(row.getUserId(), row.getUserId()));
|
form.setContent(row.getContent());
|
form.setScore(row.getScore());
|
form.setResultFlag(row.getResultFlag());
|
list.add(form);
|
}
|
return list;
|
}
|
|
private List<TmsPracticeItemForm> buildEmptyItems(String taskId) {
|
List<TmsPersonTaskEntity> persons = personTaskMapper.selectList(
|
new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, taskId)
|
.orderByAsc(TmsPersonTaskEntity::getCreatorTime));
|
List<TmsPersonTaskEntity> list = new ArrayList<>();
|
for (TmsPersonTaskEntity p : persons) {
|
if (p != null && !"1".equals(p.getGuestFlag()) && p.getSignTime() != null) {
|
list.add(p);
|
}
|
}
|
Map<String, String> names = loadUserNames(list.stream()
|
.map(TmsPersonTaskEntity::getUserId)
|
.filter(StringUtil::isNotEmpty)
|
.distinct()
|
.collect(Collectors.toList()));
|
Set<String> deptIds = new HashSet<>();
|
for (TmsPersonTaskEntity p : list) {
|
if (StringUtil.isNotEmpty(p.getDeptId())) {
|
deptIds.add(p.getDeptId());
|
}
|
}
|
Map<String, String> deptNames = loadDeptNames(deptIds);
|
List<TmsPracticeItemForm> items = new ArrayList<>(list.size());
|
for (TmsPersonTaskEntity p : list) {
|
TmsPracticeItemForm form = new TmsPracticeItemForm();
|
form.setUserId(p.getUserId());
|
form.setUserName(names.getOrDefault(p.getUserId(), p.getUserId()));
|
form.setDeptName(deptNames.getOrDefault(p.getDeptId(), ""));
|
form.setResultFlag(p.getPassFlag());
|
items.add(form);
|
}
|
return items;
|
}
|
|
private TmsRecordEntity requireRecord(String recordId) {
|
if (StringUtil.isEmpty(recordId)) {
|
throw new DataException("记录ID不能为空");
|
}
|
TmsRecordEntity record = recordMapper.selectById(recordId);
|
if (record == null) {
|
throw new DataException("培训记录不存在");
|
}
|
return record;
|
}
|
|
private Map<String, String> loadUserNames(List<String> userIds) {
|
if (userIds == null || userIds.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
try {
|
List<UserEntity> users = userApi.getUserName(userIds);
|
if (users == null || users.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
Map<String, String> map = new LinkedHashMap<>();
|
for (UserEntity user : users) {
|
if (user == null || StringUtil.isEmpty(user.getId())) {
|
continue;
|
}
|
String name = StringUtil.isNotEmpty(user.getRealName()) ? user.getRealName() : user.getAccount();
|
map.put(user.getId(), name);
|
}
|
return map;
|
} catch (Exception ex) {
|
return Collections.emptyMap();
|
}
|
}
|
|
private Map<String, String> loadDeptNames(Set<String> deptIds) {
|
Map<String, String> map = new HashMap<>();
|
if (deptIds == null || deptIds.isEmpty()) {
|
return map;
|
}
|
for (String id : deptIds) {
|
try {
|
OrganizeEntity org = organizeApi.getInfoById(id);
|
if (org != null && StringUtil.isNotEmpty(org.getFullName())) {
|
map.put(id, org.getFullName());
|
}
|
} catch (Exception ignored) {
|
// ignore
|
}
|
}
|
return map;
|
}
|
|
private Date parseDate(String text, Date fallback) {
|
if (StringUtil.isEmpty(text)) {
|
return fallback;
|
}
|
try {
|
return DateUtil.stringToDate(text);
|
} catch (Exception ex) {
|
return fallback;
|
}
|
}
|
|
private String formatDate(Date date) {
|
return date == null ? null : DateUtil.dateToString(date, FMT);
|
}
|
}
|
