package com.ruoyi.process.service;
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.ruoyi.basic.pojo.StandardMethod;
|
import com.ruoyi.basic.pojo.StandardTemplate;
|
import com.ruoyi.basic.service.StandardMethodService;
|
import com.ruoyi.basic.service.StandardTemplateService;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.core.domain.entity.InformationNotification;
|
import com.ruoyi.system.service.InformationNotificationService;
|
import com.ruoyi.framework.exception.ErrorException;
|
import com.ruoyi.inspect.mapper.InsOrderMapper;
|
import com.ruoyi.inspect.mapper.InsOrderStandardTemplateMapper;
|
import com.ruoyi.inspect.mapper.InsSampleMapper;
|
import com.ruoyi.inspect.mapper.InsOrderStateMapper;
|
import com.ruoyi.inspect.pojo.InsOrder;
|
import com.ruoyi.inspect.pojo.InsOrderStandardTemplate;
|
import com.ruoyi.inspect.pojo.InsSample;
|
import com.ruoyi.inspect.pojo.InsOrderState;
|
import com.ruoyi.inspect.service.InsOrderService;
|
import com.ruoyi.process.mapper.QualityMonitorDetailsMapper;
|
import com.ruoyi.process.mapper.QualityMonitorMapper;
|
import com.ruoyi.process.mapper.QualityMonitorTaskCodeMapper;
|
import com.ruoyi.process.pojo.QualityMonitor;
|
import com.ruoyi.process.pojo.QualityMonitorDetails;
|
import com.ruoyi.system.mapper.UserMapper;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.YearMonth;
|
import java.util.ArrayList;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Set;
|
|
@Service
|
public class QualityMonitorTaskService {
|
public static final String SOURCE = "QUALITY_MONITOR";
|
private static final String LABORATORY = "新聚";
|
|
@Resource private QualityMonitorDetailsMapper detailsMapper;
|
@Resource private QualityMonitorMapper monitorMapper;
|
@Resource private QualityMonitorTaskCodeMapper codeMapper;
|
@Resource private InsOrderMapper orderMapper;
|
@Resource private InsSampleMapper sampleMapper;
|
@Resource private InsOrderStateMapper stateMapper;
|
@Resource private InsOrderStandardTemplateMapper snapshotMapper;
|
@Resource private InsOrderService orderService;
|
@Resource private StandardMethodService standardMethodService;
|
@Resource private StandardTemplateService standardTemplateService;
|
@Resource private UserMapper userMapper;
|
@Resource private InformationNotificationService notificationService;
|
|
@Transactional(rollbackFor = Exception.class)
|
public InsOrder dispatch(Integer detailsId) {
|
if (detailsId == null) throw new ErrorException("缺少质量监控计划明细ID");
|
QualityMonitorDetails detail = detailsMapper.selectOne(Wrappers.<QualityMonitorDetails>lambdaQuery()
|
.eq(QualityMonitorDetails::getQualityMonitorDetailsId, detailsId).last("FOR UPDATE"));
|
if (detail == null) throw new ErrorException("质量监控计划明细不存在");
|
InsOrder existing = getTask(detailsId);
|
if (existing != null) return existing;
|
QualityMonitor plan = monitorMapper.selectById(detail.getQualityMonitorId());
|
if (plan == null || !Integer.valueOf(1).equals(plan.getExamineStatus())
|
|| !Integer.valueOf(1).equals(plan.getRatifyStatus())) {
|
throw new ErrorException("质量监控计划审核、批准通过后才能下发");
|
}
|
if (!"INSPECTION".equals(detail.getItemKind())) throw new ErrorException("仅检测类明细可下发检验任务");
|
if (!StringUtils.hasText(detail.getTechnicalStandardText())
|
|| !StringUtils.hasText(detail.getMonitorWay())
|
|| !StringUtils.hasText(detail.getCompletionMonth())
|
|| detail.getResponsibleUserId() == null) {
|
throw new ErrorException("请补齐质控项目、技术标准、质控方式、完成时限和负责人");
|
}
|
List<Integer> templateIds = resolveTemplateIds(detail);
|
if (detail.getStandardMethodId() == null || templateIds.isEmpty()
|
|| detail.getInspectorUserId() == null
|
|| detail.getEvaluatorUserId() == null || detail.getDueDate() == null
|
|| !StringUtils.hasText(detail.getSampleName())) {
|
throw new ErrorException("请补齐标准、原始记录模板、检测员、评价人、样品和完成期限");
|
}
|
if (detail.getInspectorUserId().equals(detail.getEvaluatorUserId())) {
|
throw new ErrorException("检测员不能同时担任评价人");
|
}
|
if (userMapper.selectById(detail.getInspectorUserId()) == null
|
|| userMapper.selectById(detail.getEvaluatorUserId()) == null) {
|
throw new ErrorException("检测员或评价人不存在");
|
}
|
StandardMethod standard = standardMethodService.getById(detail.getStandardMethodId());
|
if (standard == null) throw new ErrorException("检测标准不存在");
|
List<StandardTemplate> templates = new ArrayList<>();
|
for (Integer templateId : templateIds) {
|
StandardTemplate template = standardTemplateService.getById(templateId);
|
if (template == null || !StringUtils.hasText(template.getThing())) {
|
throw new ErrorException("原始记录模板不存在或内容为空：" + templateId);
|
}
|
if (codeMapper.countStandardTemplateBinding(standard.getId(), template.getId()) == 0) {
|
throw new ErrorException("原始记录模板未绑定当前检测标准：" + template.getName());
|
}
|
templates.add(template);
|
}
|
LocalDate today = LocalDate.now(ZoneId.of("Asia/Shanghai"));
|
YearMonth completionMonth;
|
try {
|
completionMonth = YearMonth.parse(detail.getCompletionMonth());
|
} catch (Exception exception) {
|
throw new ErrorException("计划完成时限格式不正确");
|
}
|
if (YearMonth.from(detail.getDueDate()).isAfter(completionMonth)) {
|
throw new ErrorException("检验任务截止日不能晚于计划完成月份");
|
}
|
int year = today.getYear();
|
codeMapper.ensureYear(year);
|
int sequence = codeMapper.lockCurrent(year) + 1;
|
codeMapper.updateCurrent(year, sequence);
|
String code = String.format("QC-%d-%04d", year, sequence);
|
|
InsOrder order = new InsOrder();
|
order.setEntrustCode(code);
|
order.setTaskSource(SOURCE);
|
order.setQualityMonitorDetailsId(detailsId);
|
order.setOrderType(SOURCE);
|
order.setTypeSource(-1);
|
order.setState(1);
|
order.setInsState(0);
|
order.setLaboratory(LABORATORY);
|
order.setSample(detail.getSampleName());
|
order.setPartDetail(detail.getSampleSpec());
|
order.setAppointed(detail.getDueDate());
|
order.setExamineTime(LocalDateTime.now());
|
orderMapper.insert(order);
|
|
InsSample sample = new InsSample();
|
sample.setInsOrderId(order.getId());
|
sample.setSampleCode(code);
|
sample.setLaboratory(LABORATORY);
|
sample.setSample(detail.getSampleName());
|
sample.setQuantity(1);
|
sampleMapper.insert(sample);
|
|
for (int index = 0; index < templates.size(); index++) {
|
StandardTemplate template = templates.get(index);
|
InsOrderStandardTemplate snapshot = new InsOrderStandardTemplate();
|
snapshot.setInsOrderId(order.getId());
|
snapshot.setTemplateId(template.getId());
|
snapshot.setName(template.getName());
|
snapshot.setNumber(template.getNumber());
|
snapshot.setRemark(template.getRemark());
|
snapshot.setThing(template.getThing());
|
snapshot.setSort(index);
|
snapshotMapper.insert(snapshot);
|
}
|
|
orderService.upInsOrder(order.getId(), sample.getId(), detail.getDueDate().toString(),
|
detail.getInspectorUserId(), LABORATORY);
|
InformationNotification notice = new InformationNotification();
|
notice.setCreateUser(userMapper.selectById(SecurityUtils.getUserId().intValue()).getName());
|
notice.setSenderId(SecurityUtils.getUserId().intValue());
|
notice.setConsigneeId(detail.getInspectorUserId());
|
notice.setMessageType("2");
|
notice.setTheme("质量监控检验任务");
|
notice.setContent("质量监控任务 " + code + " 待检测，请查看评价要求和原始记录模板");
|
notice.setJumpPath("InspectionTask");
|
notificationService.addInformationNotification(notice);
|
return orderMapper.selectById(order.getId());
|
}
|
|
private List<Integer> resolveTemplateIds(QualityMonitorDetails detail) {
|
String rawIds = detail.getTemplateIds();
|
if (!StringUtils.hasText(rawIds) && detail.getTemplateId() != null) {
|
rawIds = String.valueOf(detail.getTemplateId());
|
}
|
Set<Integer> result = new LinkedHashSet<>();
|
if (!StringUtils.hasText(rawIds)) return new ArrayList<>();
|
try {
|
for (String rawId : rawIds.split(",")) {
|
if (!StringUtils.hasText(rawId)) continue;
|
int templateId = Integer.parseInt(rawId.trim());
|
if (templateId <= 0) throw new NumberFormatException();
|
result.add(templateId);
|
}
|
} catch (NumberFormatException exception) {
|
throw new ErrorException("原始记录模板参数不正确");
|
}
|
if (result.size() > 50) throw new ErrorException("原始记录模板最多选择50个");
|
return new ArrayList<>(result);
|
}
|
|
public InsOrder getTask(Integer detailsId) {
|
if (detailsId == null) return null;
|
return orderMapper.selectOne(Wrappers.<InsOrder>lambdaQuery()
|
.eq(InsOrder::getQualityMonitorDetailsId, detailsId).last("limit 1"));
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void cancel(Integer detailsId) {
|
InsOrder task = getTask(detailsId);
|
if (task == null || !SOURCE.equals(task.getTaskSource()) || !Integer.valueOf(1).equals(task.getState())) {
|
throw new ErrorException("质量监控任务不存在或已取消");
|
}
|
QualityMonitorDetails detail = detailsMapper.selectById(detailsId);
|
QualityMonitor plan = detail == null ? null : monitorMapper.selectById(detail.getQualityMonitorId());
|
int current = SecurityUtils.getUserId().intValue();
|
if (plan == null || !(Integer.valueOf(current).equals(plan.getRatifyUserId())
|
|| Integer.valueOf(current).equals(task.getCreateUser()))) {
|
throw new ErrorException("只有下发人或计划批准人可以取消任务");
|
}
|
Long startedStates = stateMapper.selectCount(Wrappers.<InsOrderState>lambdaQuery()
|
.eq(InsOrderState::getInsOrderId, task.getId()).ne(InsOrderState::getInsState, 0));
|
if (startedStates > 0) throw new ErrorException("任务已开始，不能取消");
|
Long filledSnapshots = snapshotMapper.selectCount(Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, task.getId())
|
.isNotNull(InsOrderStandardTemplate::getRecordValues));
|
if (filledSnapshots > 0) throw new ErrorException("原始记录已填写，不能取消任务");
|
task.setState(5);
|
orderMapper.updateById(task);
|
}
|
}
|
