package jnpf.tmsService.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import jnpf.exception.DataException;
|
import jnpf.tmsEntity.TmsAnnualPlanEntity;
|
import jnpf.tmsEntity.TmsAnnualPlanItemEntity;
|
import jnpf.tmsEntity.TmsMaterialEntity;
|
import jnpf.tmsEntity.TmsPaperEntity;
|
import jnpf.tmsEntity.TmsPersonTaskEntity;
|
import jnpf.tmsEntity.TmsPlaceEntity;
|
import jnpf.tmsEntity.TmsPostPlanEntity;
|
import jnpf.tmsEntity.TmsPostPlanItemEntity;
|
import jnpf.tmsEntity.TmsRecordEntity;
|
import jnpf.tmsEntity.TmsTaskEntity;
|
import jnpf.tmsEntity.TmsTaskFileEntity;
|
import jnpf.tmsEntity.TmsTrainerEntity;
|
import jnpf.tmsEntity.task.TmsFromPlanResult;
|
import jnpf.tmsEntity.task.TmsPersonTaskForm;
|
import jnpf.tmsEntity.task.TmsTaskFileForm;
|
import jnpf.tmsEntity.task.TmsTaskForm;
|
import jnpf.tmsEntity.task.TmsTaskQuery;
|
import jnpf.tmsMapper.TmsAnnualPlanItemMapper;
|
import jnpf.tmsMapper.TmsAnnualPlanMapper;
|
import jnpf.tmsMapper.TmsMaterialMapper;
|
import jnpf.tmsMapper.TmsPaperMapper;
|
import jnpf.tmsMapper.TmsPersonTaskMapper;
|
import jnpf.tmsMapper.TmsPlaceMapper;
|
import jnpf.tmsMapper.TmsPostPlanItemMapper;
|
import jnpf.tmsMapper.TmsPostPlanMapper;
|
import jnpf.tmsMapper.TmsRecordMapper;
|
import jnpf.tmsMapper.TmsTaskFileMapper;
|
import jnpf.tmsMapper.TmsTaskMapper;
|
import jnpf.tmsMapper.TmsTrainerMapper;
|
import jnpf.tmsService.TmsTaskService;
|
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;
|
|
import java.time.LocalDate;
|
import java.time.YearMonth;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Calendar;
|
import java.util.Date;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class TmsTaskServiceImpl implements TmsTaskService {
|
|
private static final String STATUS_DRAFT = "draft";
|
private static final String STATUS_PUBLISHED = "published";
|
private static final String STATUS_CANCELLED = "cancelled";
|
|
private static final String PERSON_TODO = "todo";
|
private static final String PERSON_SIGNED = "signed";
|
private static final String PERSON_DONE = "done";
|
private static final String PERSON_CANCELLED = "cancelled";
|
|
private static final String PREFIX_DRAFT = "TD";
|
private static final String PREFIX_PUBLISH = "TT";
|
private static final String FMT = "yyyy-MM-dd HH:mm:ss";
|
|
private final TmsTaskMapper taskMapper;
|
private final TmsTrainerMapper trainerMapper;
|
private final TmsPersonTaskMapper personTaskMapper;
|
private final TmsRecordMapper recordMapper;
|
private final TmsPaperMapper paperMapper;
|
private final TmsMaterialMapper materialMapper;
|
private final TmsTaskFileMapper taskFileMapper;
|
private final TmsPlaceMapper placeMapper;
|
private final TmsAnnualPlanMapper annualPlanMapper;
|
private final TmsAnnualPlanItemMapper annualPlanItemMapper;
|
private final TmsPostPlanMapper postPlanMapper;
|
private final TmsPostPlanItemMapper postPlanItemMapper;
|
|
@Override
|
public List<TmsTaskForm> getList(TmsTaskQuery query) {
|
LambdaQueryWrapper<TmsTaskEntity> qw = new LambdaQueryWrapper<>();
|
if (StringUtil.isNotEmpty(query.getPublishStatus())) {
|
qw.eq(TmsTaskEntity::getPublishStatus, query.getPublishStatus());
|
}
|
if (StringUtil.isNotEmpty(query.getTrainMode())) {
|
qw.eq(TmsTaskEntity::getTrainMode, query.getTrainMode());
|
}
|
if (StringUtil.isNotEmpty(query.getSourceType())) {
|
qw.eq(TmsTaskEntity::getSourceType, query.getSourceType());
|
}
|
if (StringUtil.isNotEmpty(query.getKeyword()) && !"null".equalsIgnoreCase(query.getKeyword())) {
|
String kw = query.getKeyword().trim();
|
qw.and(w -> w.like(TmsTaskEntity::getTaskNo, kw).or().like(TmsTaskEntity::getSubject, kw));
|
}
|
Date from = parseDayStart(query.getStartTimeFrom());
|
Date to = parseDayEnd(query.getStartTimeTo());
|
if (from != null) {
|
qw.ge(TmsTaskEntity::getStartTime, from);
|
}
|
if (to != null) {
|
qw.le(TmsTaskEntity::getStartTime, to);
|
}
|
qw.orderByDesc(TmsTaskEntity::getStartTime).orderByDesc(TmsTaskEntity::getCreatorTime);
|
|
long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
|
long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
|
Page<TmsTaskEntity> page = taskMapper.selectPage(new Page<>(current, size), qw);
|
|
List<TmsTaskForm> list = new ArrayList<>(page.getRecords().size());
|
for (TmsTaskEntity row : page.getRecords()) {
|
list.add(toForm(row, false));
|
}
|
query.setData(list, page.getTotal());
|
return list;
|
}
|
|
@Override
|
public TmsTaskForm getInfo(String id) {
|
TmsTaskEntity entity = requireOne(id);
|
TmsTaskForm form = toForm(entity, true);
|
List<TmsPersonTaskEntity> persons = personTaskMapper.selectList(
|
new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, id)
|
.orderByAsc(TmsPersonTaskEntity::getCreatorTime));
|
List<TmsPersonTaskForm> personForms = new ArrayList<>(persons.size());
|
for (TmsPersonTaskEntity p : persons) {
|
TmsPersonTaskForm pf = new TmsPersonTaskForm();
|
pf.setId(p.getId());
|
pf.setUserId(p.getUserId());
|
pf.setDeptId(p.getDeptId());
|
pf.setBizStatus(p.getBizStatus());
|
pf.setSignTime(formatDate(p.getSignTime()));
|
pf.setExamScore(p.getExamScore());
|
pf.setPassFlag(p.getPassFlag());
|
pf.setGuestFlag(p.getGuestFlag());
|
personForms.add(pf);
|
}
|
form.setPersonTasks(personForms);
|
form.setPersonCount(personForms.size());
|
form.setFiles(listTaskFiles(id));
|
return form;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public String create(TmsTaskForm form) {
|
// 空白新增仅允许临时培训；年/岗计划任务应由计划侧生成并带 source_id/item_id
|
boolean hasSourceLink = StringUtil.isNotEmpty(form.getSourceId())
|
|| StringUtil.isNotEmpty(form.getSourceItemId());
|
if (!hasSourceLink) {
|
form.setSourceType("temp");
|
form.setCategory("temp");
|
}
|
validateForm(form, true);
|
TmsTaskEntity entity = new TmsTaskEntity();
|
entity.setId(RandomUtil.uuId());
|
entity.setTaskNo(nextTaskNo(PREFIX_DRAFT));
|
entity.setPublishStatus(STATUS_DRAFT);
|
entity.setTaskKind(StringUtil.isNotEmpty(form.getTaskKind()) ? form.getTaskKind() : "new");
|
fillEntity(entity, form, false);
|
applyDefaults(entity);
|
fillRefs(entity);
|
taskMapper.insert(entity);
|
saveTaskFiles(entity.getId(), form.getFiles());
|
return entity.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void update(String id, TmsTaskForm form) {
|
TmsTaskEntity entity = requireOne(id);
|
if (!STATUS_DRAFT.equals(entity.getPublishStatus())) {
|
throw new DataException("仅未发布任务可编辑");
|
}
|
boolean fromPlan = isPlanSourced(entity);
|
if (fromPlan) {
|
// 计划带出：来源链路只读，业务内容允许维护补全
|
form.setCategory(entity.getCategory());
|
form.setSourceType(entity.getSourceType());
|
form.setSourcePlanNo(entity.getSourcePlanNo());
|
form.setSourceId(entity.getSourceId());
|
form.setSourceItemId(entity.getSourceItemId());
|
}
|
validateForm(form, false);
|
fillEntity(entity, form, false);
|
applyDefaults(entity);
|
fillRefs(entity);
|
entity.setLastModifyUserId(UserProvider.getLoginUserId());
|
entity.setLastModifyTime(new Date());
|
taskMapper.updateById(entity);
|
if (form.getFiles() != null) {
|
saveTaskFiles(entity.getId(), form.getFiles());
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void delete(String id) {
|
TmsTaskEntity entity = requireOne(id);
|
if (!STATUS_DRAFT.equals(entity.getPublishStatus())) {
|
throw new DataException("仅未发布任务可删除");
|
}
|
Long cnt = personTaskMapper.selectCount(
|
new LambdaQueryWrapper<TmsPersonTaskEntity>().eq(TmsPersonTaskEntity::getTaskId, id));
|
if (cnt != null && cnt > 0) {
|
throw new DataException("已生成个人任务，不可删除");
|
}
|
taskMapper.deleteById(id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void publish(String id) {
|
TmsTaskEntity entity = requireOne(id);
|
if (!STATUS_DRAFT.equals(entity.getPublishStatus())) {
|
throw new DataException("仅未发布任务可发布");
|
}
|
validateForPublish(entity);
|
|
String taskNo = entity.getTaskNo();
|
if (StringUtil.isEmpty(taskNo) || taskNo.startsWith(PREFIX_DRAFT)) {
|
taskNo = nextTaskNo(PREFIX_PUBLISH);
|
entity.setTaskNo(taskNo);
|
}
|
|
List<String> userIds = splitTrainees(entity.getTrainees());
|
if (userIds.isEmpty()) {
|
throw new DataException("培训对象不能为空");
|
}
|
|
Date now = new Date();
|
BigDecimal hours = resolveTaskHours(entity);
|
for (String userId : userIds) {
|
TmsPersonTaskEntity pt = new TmsPersonTaskEntity();
|
pt.setId(RandomUtil.uuId());
|
pt.setTaskId(entity.getId());
|
pt.setTaskNo(taskNo);
|
pt.setUserId(userId);
|
pt.setHours(hours);
|
pt.setBizStatus(PERSON_TODO);
|
pt.setGuestFlag("0");
|
pt.setCreatorUserId(UserProvider.getLoginUserId());
|
pt.setCreatorTime(now);
|
personTaskMapper.insert(pt);
|
}
|
|
Long recordCnt = recordMapper.selectCount(
|
new LambdaQueryWrapper<TmsRecordEntity>().eq(TmsRecordEntity::getTaskId, entity.getId()));
|
if (recordCnt == null || recordCnt == 0) {
|
TmsRecordEntity record = new TmsRecordEntity();
|
record.setId(RandomUtil.uuId());
|
record.setRecordNo(taskNo);
|
record.setTaskId(entity.getId());
|
record.setTaskNo(taskNo);
|
record.setCategory(entity.getCategory());
|
record.setSubject(entity.getSubject());
|
record.setTeacherId(entity.getTeacherId());
|
record.setTrainType(entity.getTrainType());
|
record.setTrainMode(entity.getTrainMode());
|
record.setEvalMode(entity.getEvalMode());
|
record.setStartTime(entity.getStartTime());
|
record.setEndTime(entity.getEndTime());
|
record.setCloseTime(entity.getCloseTime());
|
record.setArchiveStatus("pending");
|
record.setCreatorUserId(UserProvider.getLoginUserId());
|
record.setCreatorTime(now);
|
recordMapper.insert(record);
|
}
|
|
entity.setPublishStatus(STATUS_PUBLISHED);
|
entity.setPublishTime(now);
|
entity.setLastModifyUserId(UserProvider.getLoginUserId());
|
entity.setLastModifyTime(now);
|
taskMapper.updateById(entity);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void cancel(String id) {
|
TmsTaskEntity entity = requireOne(id);
|
if (!STATUS_PUBLISHED.equals(entity.getPublishStatus())) {
|
throw new DataException("仅已发布任务可取消");
|
}
|
Long signed = personTaskMapper.selectCount(
|
new LambdaQueryWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, id)
|
.and(w -> w.isNotNull(TmsPersonTaskEntity::getSignTime)
|
.or().in(TmsPersonTaskEntity::getBizStatus, PERSON_SIGNED, PERSON_DONE)));
|
if (signed != null && signed > 0) {
|
throw new DataException("已有人员签到，不可取消");
|
}
|
|
Date now = new Date();
|
entity.setPublishStatus(STATUS_CANCELLED);
|
entity.setLastModifyUserId(UserProvider.getLoginUserId());
|
entity.setLastModifyTime(now);
|
taskMapper.updateById(entity);
|
|
personTaskMapper.update(null, new LambdaUpdateWrapper<TmsPersonTaskEntity>()
|
.eq(TmsPersonTaskEntity::getTaskId, id)
|
.set(TmsPersonTaskEntity::getBizStatus, PERSON_CANCELLED)
|
.set(TmsPersonTaskEntity::getLastModifyUserId, UserProvider.getLoginUserId())
|
.set(TmsPersonTaskEntity::getLastModifyTime, now));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void cancelBatch(List<String> ids) {
|
if (ids == null || ids.isEmpty()) {
|
throw new DataException("请选择要取消的任务");
|
}
|
for (String id : ids) {
|
if (StringUtil.isNotEmpty(id)) {
|
cancel(id);
|
}
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void restore(String id) {
|
TmsTaskEntity entity = requireOne(id);
|
if (!STATUS_CANCELLED.equals(entity.getPublishStatus())) {
|
throw new DataException("仅已取消任务可恢复");
|
}
|
Date now = new Date();
|
String userId = UserProvider.getLoginUserId();
|
|
// 逻辑删除已生成的个人任务与记录，便于再次编辑后发布
|
List<TmsPersonTaskEntity> persons = personTaskMapper.selectList(
|
new LambdaQueryWrapper<TmsPersonTaskEntity>().eq(TmsPersonTaskEntity::getTaskId, id));
|
for (TmsPersonTaskEntity p : persons) {
|
personTaskMapper.deleteById(p.getId());
|
}
|
List<TmsRecordEntity> records = recordMapper.selectList(
|
new LambdaQueryWrapper<TmsRecordEntity>().eq(TmsRecordEntity::getTaskId, id));
|
for (TmsRecordEntity r : records) {
|
recordMapper.deleteById(r.getId());
|
}
|
|
entity.setPublishStatus(STATUS_DRAFT);
|
entity.setPublishTime(null);
|
entity.setLastModifyUserId(userId);
|
entity.setLastModifyTime(now);
|
taskMapper.updateById(entity);
|
// 清空发布时间字段（updateById 可能跳过 null）
|
taskMapper.update(null, new LambdaUpdateWrapper<TmsTaskEntity>()
|
.eq(TmsTaskEntity::getId, id)
|
.set(TmsTaskEntity::getPublishTime, null));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public TmsFromPlanResult createFromAnnual(String planId) {
|
if (StringUtil.isEmpty(planId)) {
|
throw new DataException("年计划ID不能为空");
|
}
|
String id = planId.trim();
|
TmsAnnualPlanEntity plan = annualPlanMapper.selectById(id);
|
if (plan == null) {
|
throw new DataException("年度培训计划不存在: " + id);
|
}
|
List<TmsAnnualPlanItemEntity> items = annualPlanItemMapper.selectList(
|
new LambdaQueryWrapper<TmsAnnualPlanItemEntity>()
|
.eq(TmsAnnualPlanItemEntity::getForeignId, plan.getId())
|
.orderByAsc(TmsAnnualPlanItemEntity::getTrainMonth));
|
if (items.isEmpty()) {
|
throw new DataException("年度计划没有明细，无法生成任务");
|
}
|
|
TmsFromPlanResult result = new TmsFromPlanResult();
|
result.setPlanId(plan.getId());
|
Date now = new Date();
|
String userId = UserProvider.getLoginUserId();
|
|
for (TmsAnnualPlanItemEntity item : items) {
|
TmsTaskEntity existed = findTaskBySourceItem(item.getId());
|
if (existed != null) {
|
result.setSkipped(result.getSkipped() + 1);
|
if (StringUtil.isEmpty(item.getTaskId())) {
|
item.setTaskId(existed.getId());
|
item.setLineStatus("tasked");
|
annualPlanItemMapper.updateById(item);
|
}
|
continue;
|
}
|
|
Date[] window = monthWindow(parseYear(plan.getPlanYear()), item.getTrainMonth());
|
TmsTaskEntity task = new TmsTaskEntity();
|
task.setId(RandomUtil.uuId());
|
task.setTaskNo(nextTaskNo(PREFIX_DRAFT));
|
task.setPublishStatus(STATUS_DRAFT);
|
task.setTaskKind("new");
|
task.setCategory("annual_plan");
|
task.setSourceType("annual");
|
task.setSourcePlanNo(plan.getPlanNo());
|
task.setSourceId(plan.getId());
|
task.setSourceItemId(item.getId());
|
String subject = StringUtil.isNotEmpty(item.getTrainSubject()) ? item.getTrainSubject().trim() : "年度培训";
|
task.setSubject(subject);
|
task.setTrainMode(item.getTrainMode());
|
task.setEvalMode(item.getEvalMode());
|
task.setTeacherId(resolveTeacherUserId(item.getTeacherId()));
|
task.setTrainees(normalizeTrainees(item.getTrainees()));
|
if (window != null) {
|
task.setStartTime(window[0]);
|
task.setEndTime(window[1]);
|
task.setCloseTime(window[1]);
|
}
|
task.setRetakeLimit(1);
|
task.setOverdueRemind("0");
|
task.setInviteFlag("0");
|
task.setCreatorUserId(userId);
|
task.setCreatorTime(now);
|
fillRefs(task);
|
taskMapper.insert(task);
|
|
item.setTaskId(task.getId());
|
item.setLineStatus("tasked");
|
annualPlanItemMapper.updateById(item);
|
|
result.setCreated(result.getCreated() + 1);
|
result.getTaskIds().add(task.getId());
|
}
|
return result;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public TmsFromPlanResult createFromPost(String planId) {
|
if (StringUtil.isEmpty(planId)) {
|
throw new DataException("岗位培训计划ID不能为空");
|
}
|
String id = planId.trim();
|
TmsPostPlanEntity plan = postPlanMapper.selectById(id);
|
if (plan == null) {
|
throw new DataException("岗位培训计划不存在: " + id);
|
}
|
List<TmsPostPlanItemEntity> items = postPlanItemMapper.selectList(
|
new LambdaQueryWrapper<TmsPostPlanItemEntity>()
|
.eq(TmsPostPlanItemEntity::getForeignId, plan.getId())
|
.orderByAsc(TmsPostPlanItemEntity::getPlanTime));
|
if (items.isEmpty()) {
|
throw new DataException("岗位培训计划没有明细，无法生成任务");
|
}
|
|
TmsFromPlanResult result = new TmsFromPlanResult();
|
result.setPlanId(plan.getId());
|
Date now = new Date();
|
String userId = UserProvider.getLoginUserId();
|
String trainees = normalizeTrainees(plan.getTrainees());
|
|
for (TmsPostPlanItemEntity item : items) {
|
TmsTaskEntity existed = findTaskBySourceItem(item.getId());
|
if (existed != null) {
|
result.setSkipped(result.getSkipped() + 1);
|
if (StringUtil.isEmpty(item.getTaskId())) {
|
item.setTaskId(existed.getId());
|
item.setLineStatus("tasked");
|
postPlanItemMapper.updateById(item);
|
}
|
continue;
|
}
|
|
Date[] window = dayWindow(item.getPlanTime() != null ? item.getPlanTime() : plan.getPlanEndTime());
|
TmsTaskEntity task = new TmsTaskEntity();
|
task.setId(RandomUtil.uuId());
|
task.setTaskNo(nextTaskNo(PREFIX_DRAFT));
|
task.setPublishStatus(STATUS_DRAFT);
|
task.setTaskKind("new");
|
task.setCategory("post_plan");
|
task.setSourceType("post");
|
task.setSourcePlanNo(plan.getPlanNo());
|
task.setSourceId(plan.getId());
|
task.setSourceItemId(item.getId());
|
String subject = StringUtil.isNotEmpty(item.getSubject()) ? item.getSubject().trim() : null;
|
if (StringUtil.isEmpty(subject)) {
|
subject = StringUtil.isNotEmpty(plan.getPostName()) ? plan.getPostName() + "岗位培训" : "岗位培训";
|
}
|
task.setSubject(subject);
|
task.setTrainMode(item.getTrainMode());
|
task.setEvalMode(item.getEvalMode());
|
task.setTeacherId(resolveTeacherUserId(item.getTeacherId()));
|
task.setTrainees(trainees);
|
task.setMaterialId(item.getMaterialId());
|
if (window != null) {
|
task.setStartTime(window[0]);
|
task.setEndTime(window[1]);
|
task.setCloseTime(window[1]);
|
}
|
task.setRetakeLimit(1);
|
task.setOverdueRemind("0");
|
task.setInviteFlag("0");
|
task.setCreatorUserId(userId);
|
task.setCreatorTime(now);
|
fillRefs(task);
|
taskMapper.insert(task);
|
|
item.setTaskId(task.getId());
|
item.setLineStatus("tasked");
|
postPlanItemMapper.updateById(item);
|
|
result.setCreated(result.getCreated() + 1);
|
result.getTaskIds().add(task.getId());
|
}
|
return result;
|
}
|
|
private TmsTaskEntity findTaskBySourceItem(String itemId) {
|
if (StringUtil.isEmpty(itemId)) {
|
return null;
|
}
|
return taskMapper.selectOne(new LambdaQueryWrapper<TmsTaskEntity>()
|
.eq(TmsTaskEntity::getSourceItemId, itemId)
|
.last("limit 1"));
|
}
|
|
/**
|
* 年份：2026、2026-01-01…、或 13 位毫秒时间戳。
|
* 在线表单日期控件会把年份存成日期字符串。
|
*/
|
private static Integer parseYear(String raw) {
|
if (StringUtil.isEmpty(raw)) {
|
return null;
|
}
|
String text = raw.trim();
|
try {
|
if (text.matches("\\d{4}")) {
|
return Integer.parseInt(text);
|
}
|
if (text.matches("\\d{13}")) {
|
return java.time.Instant.ofEpochMilli(Long.parseLong(text))
|
.atZone(ZoneId.systemDefault()).getYear();
|
}
|
if (text.length() >= 4 && text.substring(0, 4).matches("\\d{4}")) {
|
return Integer.parseInt(text.substring(0, 4));
|
}
|
} catch (Exception ignored) {
|
return null;
|
}
|
return null;
|
}
|
|
/** 月份占位：精确时间在任务「执行安排」再改。支持 yyyyMM、1-12、yyyy-MM-dd、13 位毫秒时间戳。 */
|
private static Date[] monthWindow(Integer planYear, String trainMonth) {
|
if (StringUtil.isEmpty(trainMonth)) {
|
return null;
|
}
|
String raw = trainMonth.trim();
|
int year;
|
int month;
|
try {
|
if (raw.matches("\\d{13}")) {
|
java.time.LocalDate day = java.time.Instant.ofEpochMilli(Long.parseLong(raw))
|
.atZone(ZoneId.systemDefault()).toLocalDate();
|
year = day.getYear();
|
month = day.getMonthValue();
|
} else if (raw.matches("\\d{4}-\\d{2}-\\d{2}.*")) {
|
year = Integer.parseInt(raw.substring(0, 4));
|
month = Integer.parseInt(raw.substring(5, 7));
|
} else if (raw.matches("\\d{6}")) {
|
year = Integer.parseInt(raw.substring(0, 4));
|
month = Integer.parseInt(raw.substring(4, 6));
|
} else if (raw.matches("\\d{1,2}")) {
|
if (planYear == null) {
|
return null;
|
}
|
year = planYear;
|
month = Integer.parseInt(raw);
|
} else {
|
return null;
|
}
|
if (month < 1 || month > 12) {
|
return null;
|
}
|
YearMonth ym = YearMonth.of(year, month);
|
ZoneId zone = ZoneId.systemDefault();
|
Date start = Date.from(ym.atDay(1).atStartOfDay(zone).toInstant());
|
Date end = Date.from(ym.atEndOfMonth().atTime(23, 59, 59).atZone(zone).toInstant());
|
return new Date[]{start, end};
|
} catch (Exception ex) {
|
return null;
|
}
|
}
|
|
/** 岗位计划明细是具体日期；没有明细日期时用计划结束日。 */
|
private static Date[] dayWindow(Date day) {
|
if (day == null) {
|
return null;
|
}
|
try {
|
java.time.LocalDate date = day.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
ZoneId zone = ZoneId.systemDefault();
|
Date start = Date.from(date.atStartOfDay(zone).toInstant());
|
Date end = Date.from(date.atTime(23, 59, 59).atZone(zone).toInstant());
|
return new Date[]{start, end};
|
} catch (Exception ex) {
|
return null;
|
}
|
}
|
|
private static String normalizeTrainees(String raw) {
|
if (StringUtil.isEmpty(raw)) {
|
return null;
|
}
|
String text = raw.trim();
|
if (text.startsWith("[") && text.endsWith("]")) {
|
text = text.substring(1, text.length() - 1).replace("\"", "");
|
}
|
List<String> ids = splitTrainees(text);
|
return ids.isEmpty() ? text : joinTrainees(ids);
|
}
|
|
private void validateForm(TmsTaskForm form, boolean creating) {
|
if (form == null) {
|
throw new DataException("表单不能为空");
|
}
|
if (StringUtil.isEmpty(form.getSubject())) {
|
throw new DataException("培训主题不能为空");
|
}
|
if (StringUtil.isEmpty(form.getCategory())) {
|
throw new DataException("培训分类不能为空");
|
}
|
if (StringUtil.isEmpty(form.getTrainMode())) {
|
throw new DataException("培训方式不能为空");
|
}
|
if (StringUtil.isEmpty(form.getSourceType())) {
|
throw new DataException("来源类型不能为空");
|
}
|
if (StringUtil.isEmpty(form.getEvalMode())) {
|
throw new DataException("考核方式不能为空");
|
}
|
Date start = parseDate(form.getStartTime());
|
Date end = parseDate(form.getEndTime());
|
Date close = parseDate(form.getCloseTime());
|
if (start == null || end == null || close == null) {
|
throw new DataException("开始/结束/关闭时间不能为空");
|
}
|
if (start.after(end)) {
|
throw new DataException("开始时间不能晚于结束时间");
|
}
|
if (end.after(close)) {
|
throw new DataException("结束时间不能晚于关闭时间");
|
}
|
if (creating && start.before(new Date())) {
|
// 允许当天稍早几分钟；严格：开始不得早于当前日 00:00
|
Calendar cal = Calendar.getInstance();
|
cal.set(Calendar.HOUR_OF_DAY, 0);
|
cal.set(Calendar.MINUTE, 0);
|
cal.set(Calendar.SECOND, 0);
|
cal.set(Calendar.MILLISECOND, 0);
|
if (start.before(cal.getTime())) {
|
throw new DataException("开始时间不得早于当天");
|
}
|
}
|
|
String mode = form.getTrainMode();
|
if ("onsite".equals(mode) || "practice".equals(mode)) {
|
if (!sameDay(start, end)) {
|
throw new DataException("集中/操作授课的开始与结束须为同一天");
|
}
|
if (StringUtil.isEmpty(form.getPlaceId()) && StringUtil.isEmpty(form.getPlaceName())) {
|
throw new DataException("现场类培训须填写地点");
|
}
|
}
|
if ("online".equals(mode) && splitTrainees(form.getMaterialId()).isEmpty()) {
|
throw new DataException("在线学习须选择教材");
|
}
|
if ("exam".equals(form.getEvalMode())) {
|
if (StringUtil.isEmpty(form.getPaperId())) {
|
throw new DataException("在线考试须选择试卷");
|
}
|
Date examStart = parseDate(form.getExamStart());
|
Date examEnd = parseDate(form.getExamEnd());
|
if (examStart != null && examStart.before(start)) {
|
throw new DataException("考试开始不得早于培训开始");
|
}
|
if (examStart != null && examEnd != null && examStart.after(examEnd)) {
|
throw new DataException("考试开始不能晚于考试结束");
|
}
|
}
|
|
List<String> trainees = resolveTraineeIds(form);
|
if (trainees.isEmpty()) {
|
throw new DataException("培训对象不能为空");
|
}
|
|
Integer retake = form.getRetakeLimit();
|
if (retake != null && retake < 0) {
|
throw new DataException("补考次数不能为负数");
|
}
|
}
|
|
private void validateForPublish(TmsTaskEntity entity) {
|
if (StringUtil.isEmpty(entity.getSubject())
|
|| StringUtil.isEmpty(entity.getTrainMode())
|
|| StringUtil.isEmpty(entity.getEvalMode())
|
|| entity.getStartTime() == null
|
|| entity.getEndTime() == null
|
|| entity.getCloseTime() == null) {
|
throw new DataException("任务信息不完整，请先完善后发布");
|
}
|
if (splitTrainees(entity.getTrainees()).isEmpty()) {
|
throw new DataException("培训对象不能为空");
|
}
|
if ("exam".equals(entity.getEvalMode())) {
|
if (StringUtil.isEmpty(entity.getPaperId())) {
|
throw new DataException("在线考试须选择试卷");
|
}
|
TmsPaperEntity paper = paperMapper.selectById(entity.getPaperId());
|
if (paper == null) {
|
throw new DataException("所选试卷不存在");
|
}
|
if ("invalid".equals(paper.getBizStatus())) {
|
throw new DataException("失效试卷不可用于发布");
|
}
|
}
|
}
|
|
private void fillEntity(TmsTaskEntity entity, TmsTaskForm form, boolean keepPlanContent) {
|
if (!keepPlanContent) {
|
entity.setCategory(form.getCategory());
|
entity.setTrainType(form.getTrainType());
|
entity.setSourceType(form.getSourceType());
|
entity.setSourcePlanNo(form.getSourcePlanNo());
|
entity.setSourceId(form.getSourceId());
|
entity.setSourceItemId(form.getSourceItemId());
|
entity.setSubject(form.getSubject() == null ? null : form.getSubject().trim());
|
entity.setKeyPoints(form.getKeyPoints());
|
entity.setMaterialId(firstId(form.getMaterialId()));
|
entity.setMaterialNo(firstId(form.getMaterialNo()));
|
entity.setTeacherId(form.getTeacherId());
|
entity.setTrainMode(form.getTrainMode());
|
entity.setEvalMode(form.getEvalMode());
|
entity.setTrainees(joinTrainees(resolveTraineeIds(form)));
|
if (StringUtil.isNotEmpty(form.getTaskKind())) {
|
entity.setTaskKind(form.getTaskKind());
|
}
|
entity.setPrevTaskNo(form.getPrevTaskNo());
|
}
|
// 执行信息：计划/临时均可维护
|
entity.setPlaceId(form.getPlaceId());
|
entity.setPlaceNo(form.getPlaceNo());
|
entity.setPlaceName(form.getPlaceName());
|
entity.setStartTime(parseDate(form.getStartTime()));
|
entity.setEndTime(parseDate(form.getEndTime()));
|
entity.setCloseTime(parseDate(form.getCloseTime()));
|
entity.setPaperId(form.getPaperId());
|
entity.setPaperName(form.getPaperName());
|
entity.setExamStart(parseDate(form.getExamStart()));
|
entity.setExamEnd(parseDate(form.getExamEnd()));
|
entity.setRetakeLimit(form.getRetakeLimit() == null ? 1 : form.getRetakeLimit());
|
entity.setPassScore(form.getPassScore());
|
entity.setQuizRatio(form.getQuizRatio());
|
entity.setOverdueRemind(StringUtil.isEmpty(form.getOverdueRemind()) ? "0" : form.getOverdueRemind());
|
entity.setInviteFlag(StringUtil.isEmpty(form.getInviteFlag()) ? "0" : form.getInviteFlag());
|
entity.setRemark(form.getRemark());
|
}
|
|
private static boolean isPlanSourced(TmsTaskEntity entity) {
|
if (StringUtil.isNotEmpty(entity.getSourceId())
|
|| StringUtil.isNotEmpty(entity.getSourceItemId())
|
|| StringUtil.isNotEmpty(entity.getSourcePlanNo())) {
|
return true;
|
}
|
String st = entity.getSourceType();
|
return StringUtil.isNotEmpty(st) && !"temp".equals(st);
|
}
|
|
private void applyDefaults(TmsTaskEntity entity) {
|
if (entity.getRetakeLimit() == null) {
|
entity.setRetakeLimit(1);
|
}
|
if (StringUtil.isEmpty(entity.getOverdueRemind())) {
|
entity.setOverdueRemind("0");
|
}
|
if (StringUtil.isEmpty(entity.getInviteFlag())) {
|
entity.setInviteFlag("0");
|
}
|
if (StringUtil.isEmpty(entity.getTaskKind())) {
|
entity.setTaskKind("new");
|
}
|
}
|
|
private void fillRefs(TmsTaskEntity entity) {
|
if (StringUtil.isNotEmpty(entity.getPaperId())) {
|
TmsPaperEntity paper = paperMapper.selectById(entity.getPaperId());
|
if (paper != null) {
|
entity.setPaperName(paper.getPaperName());
|
if (entity.getPassScore() == null) {
|
entity.setPassScore(paper.getPassScore());
|
}
|
}
|
} else {
|
entity.setPaperName(null);
|
}
|
if (StringUtil.isNotEmpty(entity.getMaterialId())) {
|
TmsMaterialEntity material = materialMapper.selectById(entity.getMaterialId());
|
if (material != null && StringUtil.isNotEmpty(material.getMaterialNo())) {
|
entity.setMaterialNo(material.getMaterialNo());
|
}
|
} else {
|
entity.setMaterialNo(null);
|
}
|
if (StringUtil.isNotEmpty(entity.getPlaceId())) {
|
TmsPlaceEntity place = placeMapper.selectById(entity.getPlaceId());
|
if (place != null) {
|
entity.setPlaceNo(place.getPlaceNo());
|
entity.setPlaceName(place.getPlaceName());
|
}
|
}
|
}
|
|
private void saveTaskFiles(String taskId, List<TmsTaskFileForm> files) {
|
taskFileMapper.delete(new LambdaQueryWrapper<TmsTaskFileEntity>()
|
.eq(TmsTaskFileEntity::getForeignId, taskId));
|
if (files == null || files.isEmpty()) {
|
return;
|
}
|
Date now = new Date();
|
String userId = UserProvider.getLoginUserId();
|
for (TmsTaskFileForm row : files) {
|
if (row == null || StringUtil.isEmpty(row.getFileName())) {
|
continue;
|
}
|
TmsTaskFileEntity entity = new TmsTaskFileEntity();
|
entity.setId(RandomUtil.uuId());
|
entity.setForeignId(taskId);
|
entity.setFileNo(row.getFileNo());
|
entity.setFileName(row.getFileName().trim());
|
entity.setMaterialId(row.getMaterialId());
|
entity.setFileJson(row.getFileJson());
|
entity.setCanDownload(StringUtil.isEmpty(row.getCanDownload()) ? "0" : row.getCanDownload());
|
entity.setCreatorUserId(userId);
|
entity.setCreatorTime(now);
|
taskFileMapper.insert(entity);
|
}
|
}
|
|
private List<TmsTaskFileForm> listTaskFiles(String taskId) {
|
List<TmsTaskFileEntity> rows = taskFileMapper.selectList(
|
new LambdaQueryWrapper<TmsTaskFileEntity>()
|
.eq(TmsTaskFileEntity::getForeignId, taskId)
|
.orderByAsc(TmsTaskFileEntity::getCreatorTime));
|
List<TmsTaskFileForm> list = new ArrayList<>(rows.size());
|
for (TmsTaskFileEntity row : rows) {
|
TmsTaskFileForm form = new TmsTaskFileForm();
|
form.setId(row.getId());
|
form.setFileNo(row.getFileNo());
|
form.setFileName(row.getFileName());
|
form.setMaterialId(row.getMaterialId());
|
form.setFileJson(row.getFileJson());
|
form.setCanDownload(row.getCanDownload());
|
list.add(form);
|
}
|
return list;
|
}
|
|
private static String firstId(String raw) {
|
List<String> ids = splitTrainees(raw);
|
return ids.isEmpty() ? null : ids.get(0);
|
}
|
|
private synchronized String nextTaskNo(String typePrefix) {
|
String ym = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMM"));
|
String prefix = typePrefix + ym;
|
String max = taskMapper.selectMaxTaskNo(prefix);
|
int seq = 1;
|
if (StringUtil.isNotEmpty(max) && max.length() == 12) {
|
try {
|
seq = Integer.parseInt(max.substring(8)) + 1;
|
} catch (NumberFormatException ignored) {
|
seq = 1;
|
}
|
}
|
if (seq > 9999) {
|
throw new DataException("当月任务编号已用尽");
|
}
|
return prefix + String.format("%04d", seq);
|
}
|
|
/**
|
* 年计划子表 teacher_id 多为培训师档案 f_id；任务表单用 UserSelect，需落到系统用户。
|
*/
|
private String resolveTeacherUserId(String teacherRef) {
|
if (StringUtil.isEmpty(teacherRef)) {
|
return null;
|
}
|
String raw = teacherRef.trim();
|
TmsTrainerEntity trainer = trainerMapper.selectById(raw);
|
if (trainer != null && StringUtil.isNotEmpty(trainer.getUserId())) {
|
return trainer.getUserId();
|
}
|
// 已是系统用户，或档案尚未关联用户
|
return raw;
|
}
|
|
private TmsTaskEntity requireOne(String id) {
|
if (StringUtil.isEmpty(id)) {
|
throw new DataException("任务ID不能为空");
|
}
|
TmsTaskEntity entity = taskMapper.selectById(id);
|
if (entity == null) {
|
throw new DataException("培训任务不存在");
|
}
|
return entity;
|
}
|
|
private TmsTaskForm toForm(TmsTaskEntity entity, boolean detail) {
|
TmsTaskForm form = new TmsTaskForm();
|
form.setId(entity.getId());
|
form.setTaskNo(entity.getTaskNo());
|
form.setCategory(entity.getCategory());
|
form.setTrainType(entity.getTrainType());
|
form.setSourceType(entity.getSourceType());
|
form.setSourcePlanNo(entity.getSourcePlanNo());
|
form.setSourceId(entity.getSourceId());
|
form.setSourceItemId(entity.getSourceItemId());
|
form.setSubject(entity.getSubject());
|
form.setKeyPoints(entity.getKeyPoints());
|
form.setMaterialId(entity.getMaterialId());
|
form.setMaterialNo(entity.getMaterialNo());
|
form.setPlaceId(entity.getPlaceId());
|
form.setPlaceNo(entity.getPlaceNo());
|
form.setPlaceName(entity.getPlaceName());
|
form.setStartTime(formatDate(entity.getStartTime()));
|
form.setEndTime(formatDate(entity.getEndTime()));
|
form.setCloseTime(formatDate(entity.getCloseTime()));
|
form.setPaperId(entity.getPaperId());
|
form.setPaperName(entity.getPaperName());
|
form.setExamStart(formatDate(entity.getExamStart()));
|
form.setExamEnd(formatDate(entity.getExamEnd()));
|
form.setTeacherId(resolveTeacherUserId(entity.getTeacherId()));
|
form.setTrainMode(entity.getTrainMode());
|
form.setEvalMode(entity.getEvalMode());
|
form.setTrainees(entity.getTrainees());
|
form.setTraineeIds(splitTrainees(entity.getTrainees()));
|
form.setTaskKind(entity.getTaskKind());
|
form.setPrevTaskNo(entity.getPrevTaskNo());
|
form.setPublishStatus(entity.getPublishStatus());
|
form.setPublishTime(formatDate(entity.getPublishTime()));
|
form.setRetakeLimit(entity.getRetakeLimit());
|
form.setPassScore(entity.getPassScore());
|
form.setQuizRatio(entity.getQuizRatio());
|
form.setOverdueRemind(entity.getOverdueRemind());
|
form.setInviteFlag(entity.getInviteFlag());
|
form.setRemark(entity.getRemark());
|
form.setCreatorTime(formatDate(entity.getCreatorTime()));
|
form.setCreatorUserId(entity.getCreatorUserId());
|
if (detail) {
|
// person tasks filled by caller
|
}
|
return form;
|
}
|
|
private static List<String> resolveTraineeIds(TmsTaskForm form) {
|
Set<String> set = new LinkedHashSet<>();
|
if (form.getTraineeIds() != null) {
|
for (String id : form.getTraineeIds()) {
|
if (StringUtil.isNotEmpty(id)) {
|
set.add(id.trim());
|
}
|
}
|
}
|
if (set.isEmpty() && StringUtil.isNotEmpty(form.getTrainees())) {
|
set.addAll(splitTrainees(form.getTrainees()));
|
}
|
return new ArrayList<>(set);
|
}
|
|
private static List<String> splitTrainees(String raw) {
|
if (StringUtil.isEmpty(raw)) {
|
return new ArrayList<>();
|
}
|
return Arrays.stream(raw.split("[,;，；\\s]+"))
|
.map(String::trim)
|
.filter(s -> !s.isEmpty())
|
.distinct()
|
.collect(Collectors.toList());
|
}
|
|
private static String joinTrainees(List<String> ids) {
|
if (ids == null || ids.isEmpty()) {
|
return null;
|
}
|
return ids.stream().filter(Objects::nonNull).map(String::trim).filter(s -> !s.isEmpty())
|
.distinct().collect(Collectors.joining(","));
|
}
|
|
private static boolean sameDay(Date a, Date b) {
|
LocalDate da = a.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
LocalDate db = b.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
return da.equals(db);
|
}
|
|
private static Date parseDate(String text) {
|
if (StringUtil.isEmpty(text)) {
|
return null;
|
}
|
String raw = text.trim();
|
try {
|
if (raw.matches("^\\d{10,13}$")) {
|
long ts = Long.parseLong(raw);
|
if (raw.length() == 10) {
|
ts = ts * 1000L;
|
}
|
return new Date(ts);
|
}
|
return DateUtil.stringToDate(raw);
|
} catch (Exception ex) {
|
throw new DataException("时间格式无效：" + text);
|
}
|
}
|
|
private static Date parseDayStart(String day) {
|
if (StringUtil.isEmpty(day) || "null".equalsIgnoreCase(day)) {
|
return null;
|
}
|
String raw = day.trim();
|
if (raw.length() == 10) {
|
raw = raw + " 00:00:00";
|
}
|
return parseDate(raw);
|
}
|
|
private static Date parseDayEnd(String day) {
|
if (StringUtil.isEmpty(day) || "null".equalsIgnoreCase(day)) {
|
return null;
|
}
|
String raw = day.trim();
|
if (raw.length() == 10) {
|
raw = raw + " 23:59:59";
|
}
|
return parseDate(raw);
|
}
|
|
private BigDecimal resolveTaskHours(TmsTaskEntity task) {
|
if (task == null || StringUtil.isEmpty(task.getSourceItemId())) {
|
return null;
|
}
|
if ("annual".equals(task.getSourceType())) {
|
TmsAnnualPlanItemEntity item = annualPlanItemMapper.selectById(task.getSourceItemId());
|
return item == null ? null : item.getHours();
|
}
|
if ("post".equals(task.getSourceType())) {
|
TmsPostPlanItemEntity item = postPlanItemMapper.selectById(task.getSourceItemId());
|
return item == null ? null : item.getHours();
|
}
|
return null;
|
}
|
|
private static String formatDate(Date date) {
|
if (date == null) {
|
return null;
|
}
|
return DateUtil.dateToString(date, FMT);
|
}
|
}
|
