package cn.iocoder.yudao.module.hrm.service.training;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.hrm.controller.admin.training.vo.HrmTrainingPageReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.training.vo.HrmTrainingParticipantUpdateReqVO;
|
import cn.iocoder.yudao.module.hrm.controller.admin.training.vo.HrmTrainingSaveReqVO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.certificate.HrmCertificateDO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.training.HrmTrainingDO;
|
import cn.iocoder.yudao.module.hrm.dal.dataobject.training.HrmTrainingParticipantDO;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.certificate.HrmCertificateMapper;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.training.HrmTrainingMapper;
|
import cn.iocoder.yudao.module.hrm.dal.mysql.training.HrmTrainingParticipantMapper;
|
import cn.iocoder.yudao.module.hrm.dal.redis.HrmNoRedisDAO;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.time.LocalDate;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.hrm.dal.dataobject.training.HrmTrainingDO.*;
|
import static cn.iocoder.yudao.module.hrm.enums.ErrorCodeConstants.*;
|
|
/**
|
* HRM 培训活动 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
public class HrmTrainingServiceImpl implements HrmTrainingService {
|
|
@Resource
|
private HrmTrainingMapper trainingMapper;
|
@Resource
|
private HrmTrainingParticipantMapper participantMapper;
|
@Resource
|
private HrmCertificateMapper certificateMapper;
|
@Resource
|
private HrmNoRedisDAO noRedisDAO;
|
|
@Override
|
public Long createTraining(HrmTrainingSaveReqVO createReqVO) {
|
validateIssueCertificate(createReqVO.getTrainingType(), createReqVO.getIssueCertificate(),
|
createReqVO.getCertValidityMonths());
|
HrmTrainingDO training = BeanUtils.toBean(createReqVO, HrmTrainingDO.class);
|
training.setId(null);
|
training.setTrainingNo(noRedisDAO.generateTrainingNo());
|
training.setStatus(STATUS_DRAFT);
|
trainingMapper.insert(training);
|
return training.getId();
|
}
|
|
@Override
|
public void updateTraining(HrmTrainingSaveReqVO updateReqVO) {
|
HrmTrainingDO training = validateTrainingExists(updateReqVO.getId());
|
ensureMutable(training);
|
validateIssueCertificate(updateReqVO.getTrainingType(), updateReqVO.getIssueCertificate(),
|
updateReqVO.getCertValidityMonths());
|
HrmTrainingDO update = BeanUtils.toBean(updateReqVO, HrmTrainingDO.class);
|
update.setTrainingNo(training.getTrainingNo()); // 编号不可改
|
update.setStatus(null); // 状态走 start/complete/cancel 流转，不在此修改
|
trainingMapper.updateById(update);
|
}
|
|
@Override
|
public void deleteTraining(Collection<Long> ids) {
|
if (CollUtil.isEmpty(ids)) {
|
return;
|
}
|
for (Long id : ids) {
|
HrmTrainingDO training = validateTrainingExists(id);
|
ensureMutable(training);
|
participantMapper.deleteByTrainingId(id);
|
trainingMapper.deleteById(id);
|
}
|
}
|
|
@Override
|
public HrmTrainingDO getTraining(Long id) {
|
return trainingMapper.selectById(id);
|
}
|
|
@Override
|
public PageResult<HrmTrainingDO> getTrainingPage(HrmTrainingPageReqVO pageReqVO) {
|
return trainingMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public void startTraining(Long id) {
|
HrmTrainingDO training = validateTrainingExists(id);
|
if (training.getStatus() != null && !training.getStatus().equals(STATUS_DRAFT)) {
|
throw exception(TRAINING_COMPLETE_FAIL_STATUS); // 仅草稿可开始
|
}
|
trainingMapper.updateById(HrmTrainingDO.builder().id(id).status(STATUS_PLANNED).build());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void completeTraining(Long id) {
|
HrmTrainingDO training = validateTrainingExists(id);
|
if (training.getStatus() == null
|
|| (!training.getStatus().equals(STATUS_DRAFT) && !training.getStatus().equals(STATUS_PLANNED))) {
|
throw exception(TRAINING_COMPLETE_FAIL_STATUS);
|
}
|
trainingMapper.updateById(HrmTrainingDO.builder().id(id).status(STATUS_COMPLETED).build());
|
// 联动发证：培训完成后对合格人员自动生成证书（幂等，二次完成不重复发）
|
if (Boolean.TRUE.equals(training.getIssueCertificate())) {
|
issueCertificatesForPassed(training);
|
}
|
}
|
|
@Override
|
public void cancelTraining(Long id) {
|
HrmTrainingDO training = validateTrainingExists(id);
|
if (training.getStatus() == null || training.getStatus().equals(STATUS_COMPLETED)
|
|| training.getStatus().equals(STATUS_CANCELED)) {
|
throw exception(TRAINING_LOCKED);
|
}
|
trainingMapper.updateById(HrmTrainingDO.builder().id(id).status(STATUS_CANCELED).build());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int addParticipants(Long trainingId, Collection<Long> employeeIds) {
|
HrmTrainingDO training = validateTrainingExists(trainingId);
|
ensureMutable(training);
|
if (CollUtil.isEmpty(employeeIds)) {
|
return 0;
|
}
|
int count = 0;
|
for (Long employeeId : employeeIds) {
|
if (participantMapper.selectByTrainingIdAndEmployeeId(trainingId, employeeId) != null) {
|
continue; // 已在名单中，跳过不重复添加
|
}
|
HrmTrainingParticipantDO participant = HrmTrainingParticipantDO.builder()
|
.trainingId(trainingId)
|
.employeeId(employeeId)
|
.attended(false)
|
.isPass(false)
|
.build();
|
participantMapper.insert(participant);
|
count++;
|
}
|
return count;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateParticipant(HrmTrainingParticipantUpdateReqVO updateReqVO) {
|
HrmTrainingParticipantDO participant = validateParticipantExists(updateReqVO.getId());
|
HrmTrainingDO training = validateTrainingExists(participant.getTrainingId());
|
ensureMutable(training);
|
HrmTrainingParticipantDO update = HrmTrainingParticipantDO.builder()
|
.id(participant.getId())
|
.attended(updateReqVO.getAttended())
|
.score(updateReqVO.getScore())
|
.isPass(updateReqVO.getIsPass())
|
.remark(updateReqVO.getRemark())
|
.build();
|
participantMapper.updateById(update);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteParticipants(Collection<Long> ids) {
|
if (CollUtil.isEmpty(ids)) {
|
return;
|
}
|
for (Long id : ids) {
|
HrmTrainingParticipantDO participant = validateParticipantExists(id);
|
HrmTrainingDO training = validateTrainingExists(participant.getTrainingId());
|
ensureMutable(training);
|
participantMapper.deleteById(id);
|
}
|
}
|
|
@Override
|
public List<HrmTrainingParticipantDO> getParticipantsByTrainingId(Long trainingId) {
|
return participantMapper.selectListByTrainingId(trainingId);
|
}
|
|
@Override
|
public Map<Long, Integer> getParticipantCountMap(Collection<Long> trainingIds) {
|
if (CollUtil.isEmpty(trainingIds)) {
|
return Collections.emptyMap();
|
}
|
return participantMapper.selectListByTrainingIds(trainingIds).stream()
|
.collect(Collectors.groupingBy(HrmTrainingParticipantDO::getTrainingId, Collectors.summingInt(p -> 1)));
|
}
|
|
// ========== 私有方法 ==========
|
|
private void issueCertificatesForPassed(HrmTrainingDO training) {
|
if (training.getCertValidityMonths() == null || training.getCertValidityMonths() <= 0) {
|
throw exception(TRAINING_CERT_VALIDITY_REQUIRED);
|
}
|
List<HrmTrainingParticipantDO> participants = participantMapper.selectListByTrainingId(training.getId());
|
if (CollUtil.isEmpty(participants)) {
|
return;
|
}
|
Integer certType = convertToCertificateType(training.getTrainingType());
|
LocalDate issueDate = LocalDate.now();
|
LocalDate expireDate = issueDate.plusMonths(training.getCertValidityMonths());
|
for (HrmTrainingParticipantDO participant : participants) {
|
if (!Boolean.TRUE.equals(participant.getIsPass()) || participant.getCertificateId() != null) {
|
continue;
|
}
|
HrmCertificateDO certificate = HrmCertificateDO.builder()
|
.employeeId(participant.getEmployeeId())
|
.certType(certType)
|
.certName(training.getName())
|
.issueDate(issueDate)
|
.expireDate(expireDate)
|
.remark("由培训【" + training.getTrainingNo() + "】" + training.getName() + "完成自动发放")
|
.build();
|
certificateMapper.insert(certificate);
|
participantMapper.updateCertificateId(participant.getId(), certificate.getId());
|
}
|
}
|
|
/**
|
* 培训类型 → 证书资质类型映射：安全培训→4 安全培训合格证，技能培训→3 技能等级证书
|
*/
|
private Integer convertToCertificateType(Integer trainingType) {
|
return switch (trainingType == null ? 0 : trainingType) {
|
case TYPE_SAFETY -> 4;
|
case TYPE_SKILL -> 3;
|
default -> null;
|
};
|
}
|
|
private void validateIssueCertificate(Integer trainingType, Boolean issueCertificate, Integer certValidityMonths) {
|
if (Boolean.TRUE.equals(issueCertificate)) {
|
if (trainingType == null
|
|| (!trainingType.equals(TYPE_SAFETY) && !trainingType.equals(TYPE_SKILL))) {
|
throw exception(TRAINING_CERT_TYPE_NOT_SUPPORT);
|
}
|
if (certValidityMonths == null || certValidityMonths <= 0) {
|
throw exception(TRAINING_CERT_VALIDITY_REQUIRED);
|
}
|
}
|
}
|
|
private HrmTrainingDO validateTrainingExists(Long id) {
|
HrmTrainingDO training = trainingMapper.selectById(id);
|
if (training == null) {
|
throw exception(TRAINING_NOT_EXISTS);
|
}
|
return training;
|
}
|
|
private HrmTrainingParticipantDO validateParticipantExists(Long id) {
|
HrmTrainingParticipantDO participant = participantMapper.selectById(id);
|
if (participant == null) {
|
throw exception(TRAINING_PARTICIPANT_NOT_EXISTS);
|
}
|
return participant;
|
}
|
|
/**
|
* 已完成/已取消的培训不允许再修改
|
*/
|
private void ensureMutable(HrmTrainingDO training) {
|
if (training.getStatus() != null
|
&& (training.getStatus().equals(STATUS_COMPLETED) || training.getStatus().equals(STATUS_CANCELED))) {
|
throw exception(TRAINING_LOCKED);
|
}
|
}
|
|
}
|
