feat(inspect): 新增新聚检验订单编辑功能并优化报告生成流程 - 新增 updateNewJuInsOrder 接口支持新聚检验订单修改 ...

liding

23 小时以前 82ce59218139d9fefeae7b9e5fbc88b499ff023f

 inspect-server/src/main/java/com/ruoyi/inspect/service/impl/InsOrderServiceImpl.java

@@ -57,6 +57,7 @@
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
@@ -107,6 +108,8 @@
    private StandardTemplateService standardTemplateService;
    private InsOrderStandardTemplateMapper insOrderStandardTemplateMapper;
    private InsOrderTemplateDeviceMapper insOrderTemplateDeviceMapper;
    private InsSampleReceiptMapper insSampleReceiptMapper;
    private ApplicationEventPublisher applicationEventPublisher;



@@ -120,7 +123,34 @@
            isOrderAll = "1";
            sampleOrderDto.setState(null);
        }
        return insOrderMapper.selectInsOrderPage(page, QueryWrappers.queryWrappers(sampleOrderDto), laboratory, isOrderAll);
        // 检验中：新聚下单免审核即受理，需样品接收提交后（ins_sample_receipt.status=1）才展示
        String receiptSubmitted = sampleOrderDto.getState() != null && sampleOrderDto.getState() == 1 ? "1" : null;
        IPage<SampleOrderDto> result = insOrderMapper.selectInsOrderPage(page,
                QueryWrappers.queryWrappers(sampleOrderDto), laboratory, isOrderAll, receiptSubmitted);
        List<Integer> candidateIds = result.getRecords().stream()
                .filter(row -> Integer.valueOf(-1).equals(row.getTypeSource())
                        && Integer.valueOf(1).equals(row.getState()))
                .map(SampleOrderDto::getId)
                .collect(Collectors.toList());
        if (!candidateIds.isEmpty()) {
            Set<Integer> receivedIds = insSampleReceiptMapper.selectList(Wrappers.<InsSampleReceipt>lambdaQuery()
                            .in(InsSampleReceipt::getInsOrderId, candidateIds)
                            .eq(InsSampleReceipt::getStatus, 1)
                            .select(InsSampleReceipt::getInsOrderId)).stream()
                    .map(InsSampleReceipt::getInsOrderId).collect(Collectors.toSet());
            Set<Integer> taskIds = insOrderStateService.list(Wrappers.<InsOrderState>lambdaQuery()
                            .in(InsOrderState::getInsOrderId, candidateIds)
                            .select(InsOrderState::getInsOrderId)).stream()
                    .map(InsOrderState::getInsOrderId).collect(Collectors.toSet());
            Set<Integer> assignedIds = insSampleUserMapper.selectList(Wrappers.<InsSampleUser>lambdaQuery()
                            .in(InsSampleUser::getInsSampleId, candidateIds)
                            .select(InsSampleUser::getInsSampleId)).stream()
                    .map(InsSampleUser::getInsSampleId).collect(Collectors.toSet());
            result.getRecords().forEach(row -> row.setEditable(
                    candidateIds.contains(row.getId()) && !receivedIds.contains(row.getId())
                            && !taskIds.contains(row.getId()) && !assignedIds.contains(row.getId())));
        }
        return result;
    }


@@ -175,13 +205,17 @@
        }

        if (userId != null) {
            InsSampleUser insSampleUser = new InsSampleUser();
            insSampleUser.setState(0);
            insSampleUser.setUserId(userId);
            insSampleUser.setInsSampleId(orderId);
            insSampleUser.setSonLaboratory(directTemplateOrder
                    ? DIRECT_TEMPLATE_LABORATORY : sonLaboratory);
            insSampleUserMapper.insert(insSampleUser);
            Set<String> assignedLaboratories = StringUtils.isBlank(sonLaboratory)
                    ? taskLaboratories
                    : Collections.singleton(sonLaboratory);
            for (String laboratory : assignedLaboratories) {
                InsSampleUser insSampleUser = new InsSampleUser();
                insSampleUser.setState(0);
                insSampleUser.setUserId(userId);
                insSampleUser.setInsSampleId(orderId);
                insSampleUser.setSonLaboratory(laboratory);
                insSampleUserMapper.insert(insSampleUser);
            }
        }

        // 判断订单有没有绑定抽样计划
@@ -364,6 +398,15 @@
                }
            }
        });
        // 下单时生成委托编号并校验唯一性；季度检验复用进厂检验编号，留待审核处理。
        if (!InsOrderTypeConstants.QUARTERLY_TEST.equals(insOrder.getOrderType())) {
            String entrustCode = buildEntrustCode(insOrder, Collections.emptyList());
            assertEntrustCodeUnique(entrustCode, insOrder.getId());
            insOrder.setEntrustCode(entrustCode);
            insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
                    .eq(InsOrder::getId, insOrder.getId())
                    .set(InsOrder::getEntrustCode, entrustCode));
        }
        //原材料下单或外购成品下单
        if (Objects.nonNull(insOrder.getTypeSource())&&Objects.nonNull(insOrder.getIfsInventoryId())) {
            // 委托人就是报检人, 生产单位就是供应商单位
@@ -403,9 +446,7 @@
            // 审核检验单
            upInsOrderOfState(insOrder);

            // 分配检验人
            String sonLaboratory = insOrder.getTypeSource().equals(1)?"原材料":"成品实验室";
            upInsOrder(insOrder.getId(), null, appointed != null ? appointed.toString() : null, SecurityUtils.getUserId().intValue(), sonLaboratory);
            // 审核通过后仅进入样品接收；由样品接收页面选择主检验人后再创建检验任务。

            //是否为原材料下单
            if(insOrder.getTypeSource().equals(1)){
@@ -463,6 +504,31 @@
    public int addNewJuInsOrder(InsPlaceOrderDto dto) {
        if (dto == null || dto.getInsOrder() == null || dto.getStandardTreeId() == null) {
            throw new ErrorException("下单信息或标准不能为空");
        }
        String sampleCode = StringUtils.trim(dto.getSampleCode());
        if (StringUtils.isBlank(sampleCode) || sampleCode.length() < 2) {
            throw new ErrorException("样品编号不能为空且不能少于2位");
        }
        // 委托要求字段校验：四组单选必选，分包/快递联动必填
        InsOrder reqOrder = dto.getInsOrder();
        if (reqOrder.getSampleDate() == null) {
            throw new ErrorException("送样日期不能为空");
        }
        if (reqOrder.getSubcontractType() == null || reqOrder.getSampleDisposal() == null
                || reqOrder.getResultEvaluation() == null || reqOrder.getReportDelivery() == null) {
            throw new ErrorException("请选择分包内容、样品处置、对结果评价和报告交付方式");
        }
        if (Integer.valueOf(1).equals(reqOrder.getSubcontractType())
                && StringUtils.isBlank(reqOrder.getSubcontractCompany())) {
            throw new ErrorException("分包内容为有时，分包单位信息不能为空");
        }
        if (Integer.valueOf(2).equals(reqOrder.getReportDelivery())) {
            if (StringUtils.isBlank(reqOrder.getReportAddress())) {
                throw new ErrorException("报告交付方式为快递时，报告寄送地址不能为空");
            }
            if (StringUtils.isBlank(reqOrder.getReportReceiver())) {
                throw new ErrorException("报告交付方式为快递时，收件人及电话不能为空");
            }
        }
        StandardTree standard = standardTreeService.getById(dto.getStandardTreeId());
        if (standard == null || StringUtils.isBlank(standard.getSample())
@@ -524,7 +590,9 @@

        InsOrder order = dto.getInsOrder();
        order.setId(null);
        order.setState(0);
        // 新聚下单免审核：直接受理，下单即流转到样品接收
        order.setState(1);
        order.setExamineTime(LocalDateTime.now());
        order.setIsExemption(0);
        order.setFactory(null);
        order.setLaboratory(standard.getLaboratory());
@@ -536,11 +604,19 @@
        // 新聚订单的环境条件由检验任务填写，避免下单模板或浏览器缓存带入旧值。
        order.setTemperature(null);
        order.setHumidity(null);
        // 未命中联动条件时清空对应文本字段，避免模板快照或浏览器缓存带入旧值。
        if (!Integer.valueOf(1).equals(order.getSubcontractType())) {
            order.setSubcontractCompany(null);
        }
        if (!Integer.valueOf(2).equals(order.getReportDelivery())) {
            order.setReportAddress(null);
            order.setReportReceiver(null);
        }
        insOrderMapper.insert(order);

        InsSample sample = new InsSample();
        sample.setInsOrderId(order.getId());
        sample.setSampleCode(dto.getSampleCode());
        sample.setSampleCode(sampleCode);
        sample.setFactory(null);
        sample.setLaboratory(standard.getLaboratory());
        sample.setSampleType(null);
@@ -569,11 +645,187 @@
            product.setSort(productSort++);
            insProductMapper.insert(product);
        }
        saveTemplateSnapshots(order.getId(), selections);
        saveTemplateSnapshots(order.getId(), selections, bindingMap);

        // 下单时生成委托编号并校验唯一性，重复则提示，避免留到审核才报错。
        String entrustCode = buildEntrustCode(order, Collections.singletonList(sample));
        assertEntrustCodeUnique(entrustCode, order.getId());
        insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
                .eq(InsOrder::getId, order.getId())
                .set(InsOrder::getEntrustCode, entrustCode));
        // 免审核后由下单生成待接收的样品接收记录，主检验人仍在样品接收页面选择后才创建检验任务
        insSampleReceiptMapper.insertIgnore(order.getId(), sample.getId());
        // 同事务内发布下单事件，由 cnas-process 自动生成检验委托单；监听器异常会连带下单回滚
        applicationEventPublisher.publishEvent(new com.ruoyi.inspect.event.NewJuOrderPlacedEvent(order.getId()));
        return order.getId();
    }

    private void saveTemplateSnapshots(Integer orderId, List<OrderTemplateSelectionDto> selections) {
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateNewJuInsOrder(InsPlaceOrderDto dto) {
        if (dto == null || dto.getOrderId() == null || dto.getInsOrder() == null || dto.getStandardTreeId() == null) {
            throw new ErrorException("下单信息或标准不能为空");
        }
        InsOrder currentOrder = insOrderMapper.selectById(dto.getOrderId());
        if (currentOrder == null) {
            throw new ErrorException("检验单不存在");
        }
        if (!Integer.valueOf(1).equals(currentOrder.getState()) || !Integer.valueOf(-1).equals(currentOrder.getTypeSource())) {
            throw new ErrorException("当前委托不允许编辑");
        }
        assertNewJuOrderEditable(dto.getOrderId());

        String sampleCode = StringUtils.trim(dto.getSampleCode());
        if (StringUtils.isBlank(sampleCode) || sampleCode.length() < 2) {
            throw new ErrorException("样品编号不能为空且不能少于2位");
        }
        InsOrder order = dto.getInsOrder();
        if (order.getSampleDate() == null) {
            throw new ErrorException("送样日期不能为空");
        }
        if (order.getSubcontractType() == null || order.getSampleDisposal() == null
                || order.getResultEvaluation() == null || order.getReportDelivery() == null) {
            throw new ErrorException("请选择分包内容、样品处置、对结果评价和报告交付方式");
        }
        if (Integer.valueOf(1).equals(order.getSubcontractType()) && StringUtils.isBlank(order.getSubcontractCompany())) {
            throw new ErrorException("分包内容为有时，分包单位信息不能为空");
        }
        if (Integer.valueOf(2).equals(order.getReportDelivery())
                && (StringUtils.isBlank(order.getReportAddress()) || StringUtils.isBlank(order.getReportReceiver()))) {
            throw new ErrorException("报告交付方式为快递时，请填写报告寄送地址和收件人及电话");
        }

        StandardTree standard = standardTreeService.getById(dto.getStandardTreeId());
        if (standard == null || StringUtils.isBlank(standard.getSample())
                || standard.getSampleType() != null || standard.getModel() != null) {
            throw new ErrorException("请选择标准库二级标准");
        }
        List<StandardTreeTemplateBindingVo> bindings = standardTreeService.selectTemplateBindings(dto.getStandardTreeId());
        if (bindings.isEmpty()) {
            throw new ErrorException("该标准尚未绑定可用的原始记录模板");
        }
        Map<Integer, StandardTreeTemplateBindingVo> bindingMap = bindings.stream()
                .collect(Collectors.toMap(StandardTreeTemplateBindingVo::getTemplateId, binding -> binding, (first, ignored) -> first));
        List<OrderTemplateSelectionDto> selections = dto.getTemplateList();
        if (selections == null) {
            selections = bindings.stream().map(binding -> {
                OrderTemplateSelectionDto selection = new OrderTemplateSelectionDto();
                selection.setTemplateId(binding.getTemplateId());
                selection.setSort(binding.getSort());
                return selection;
            }).collect(Collectors.toList());
        }
        if (selections.isEmpty()) {
            throw new ErrorException("请至少保留一个原始记录模板");
        }
        Set<Integer> selectedTemplateIds = new HashSet<>();
        for (int index = 0; index < selections.size(); index++) {
            OrderTemplateSelectionDto selection = selections.get(index);
            if (selection == null || selection.getTemplateId() == null || !bindingMap.containsKey(selection.getTemplateId())) {
                throw new ErrorException("所选原始记录模板不属于当前标准");
            }
            if (!selectedTemplateIds.add(selection.getTemplateId())) {
                throw new ErrorException("原始记录模板不能重复选择");
            }
            if (selection.getSort() == null) {
                selection.setSort(index);
            }
        }
        selections.sort(Comparator.comparing(OrderTemplateSelectionDto::getSort)
                .thenComparing(OrderTemplateSelectionDto::getTemplateId));
        Map<Integer, Integer> templateSortMap = selections.stream().collect(Collectors.toMap(
                OrderTemplateSelectionDto::getTemplateId, OrderTemplateSelectionDto::getSort));
        List<TemplateInspectionItemDto> templateItems = standardTreeService.selectTemplateInspectionItems(dto.getStandardTreeId()).stream()
                .filter(item -> selectedTemplateIds.contains(item.getTemplateId()))
                .sorted(Comparator.comparing((TemplateInspectionItemDto item) -> templateSortMap.get(item.getTemplateId()))
                        .thenComparing(item -> item.getTemplateRowIndex() == null ? Integer.MAX_VALUE : item.getTemplateRowIndex()))
                .collect(Collectors.toList());
        StandardMethod standardMethod = standardMethodService.getById(standard.getStandardMethodId());
        if (standardMethod == null || StringUtils.isBlank(standardMethod.getCode())) {
            throw new ErrorException("标准编号不存在");
        }
        String standardCode = standardMethod.getCode().trim();

        order.setId(currentOrder.getId());
        order.setState(currentOrder.getState());
        order.setInsState(currentOrder.getInsState());
        order.setExamineTime(currentOrder.getExamineTime());
        order.setSendTime(currentOrder.getSendTime());
        order.setIsExemption(currentOrder.getIsExemption());
        order.setFactory(null);
        order.setLaboratory(standard.getLaboratory());
        order.setSampleType(null);
        order.setSample(standardCode);
        order.setPrepareUserEn(null);
        order.setPrepareCode(null);
        order.setRemarkEn(null);
        order.setTemperature(null);
        order.setHumidity(null);
        if (!Integer.valueOf(1).equals(order.getSubcontractType())) {
            order.setSubcontractCompany(null);
        }
        if (!Integer.valueOf(2).equals(order.getReportDelivery())) {
            order.setReportAddress(null);
            order.setReportReceiver(null);
        }
        insOrderMapper.updateById(order);

        List<InsSample> samples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, currentOrder.getId()).orderByAsc(InsSample::getId));
        if (samples.size() != 1) {
            throw new ErrorException("检验样品数据异常");
        }
        InsSample sample = samples.get(0);
        sample.setSampleCode(sampleCode);
        sample.setLaboratory(standard.getLaboratory());
        sample.setSampleType(null);
        sample.setSample(standardCode);
        sample.setModel(null);
        insSampleMapper.updateById(sample);
        insProductMapper.delete(Wrappers.<InsProduct>lambdaQuery().eq(InsProduct::getInsSampleId, sample.getId()));
        insOrderStandardTemplateMapper.delete(Wrappers.<InsOrderStandardTemplate>lambdaQuery()
                .eq(InsOrderStandardTemplate::getInsOrderId, currentOrder.getId()));
        insOrderTemplateDeviceMapper.delete(Wrappers.<InsOrderTemplateDevice>lambdaQuery()
                .eq(InsOrderTemplateDevice::getInsOrderId, currentOrder.getId()));
        int productSort = 0;
        for (TemplateInspectionItemDto item : templateItems) {
            InsProduct product = new InsProduct();
            product.setInsSampleId(sample.getId());
            product.setInspectionItem(item.getInspectionItem());
            product.setInspectionItemClass("");
            product.setInspectionItemSubclass("");
            product.setLaboratory(standard.getLaboratory());
            product.setSample(standardCode);
            product.setTemplateId(item.getTemplateId());
            product.setTemplateRowIndex(item.getTemplateRowIndex());
            product.setSonLaboratory(DIRECT_TEMPLATE_LABORATORY);
            product.setState(1);
            product.setSort(productSort++);
            insProductMapper.insert(product);
        }
        saveTemplateSnapshots(currentOrder.getId(), selections, bindingMap);
        String entrustCode = buildEntrustCode(order, Collections.singletonList(sample));
        assertEntrustCodeUnique(entrustCode, currentOrder.getId());
        insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate().eq(InsOrder::getId, currentOrder.getId())
                .set(InsOrder::getEntrustCode, entrustCode));
        applicationEventPublisher.publishEvent(new com.ruoyi.inspect.event.NewJuOrderPlacedEvent(currentOrder.getId()));
        return currentOrder.getId();
    }

    private void assertNewJuOrderEditable(Integer orderId) {
        Long receiptCount = insSampleReceiptMapper.selectCount(Wrappers.<InsSampleReceipt>lambdaQuery()
                .eq(InsSampleReceipt::getInsOrderId, orderId).eq(InsSampleReceipt::getStatus, 1));
        Long taskCount = insOrderStateService.count(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, orderId));
        Long userCount = insSampleUserMapper.selectCount(Wrappers.<InsSampleUser>lambdaQuery()
                .eq(InsSampleUser::getInsSampleId, orderId));
        if (receiptCount > 0 || taskCount > 0 || userCount > 0) {
            throw new ErrorException("该委托已进入检验，不能编辑");
        }
    }

    private void saveTemplateSnapshots(Integer orderId, List<OrderTemplateSelectionDto> selections,
                                       Map<Integer, StandardTreeTemplateBindingVo> bindingMap) {
        for (OrderTemplateSelectionDto selection : selections) {
            StandardTemplate template = standardTemplateService.getById(selection.getTemplateId());
            if (template == null) {
@@ -588,6 +840,18 @@
            snapshot.setThing(template.getThing());
            snapshot.setSort(selection.getSort());
            insOrderStandardTemplateMapper.insert(snapshot);

            StandardTreeTemplateBindingVo binding = bindingMap.get(selection.getTemplateId());
            List<Integer> deviceIds = binding == null || binding.getDeviceIds() == null
                    ? Collections.emptyList() : binding.getDeviceIds();
            for (int index = 0; index < deviceIds.size(); index++) {
                InsOrderTemplateDevice relation = new InsOrderTemplateDevice();
                relation.setInsOrderId(orderId);
                relation.setTemplateId(selection.getTemplateId());
                relation.setDeviceId(deviceIds.get(index));
                relation.setSort(index);
                insOrderTemplateDeviceMapper.insert(relation);
            }
        }
    }

@@ -659,6 +923,36 @@
        map.put("sampleCode", orderSamples.isEmpty() ? null : orderSamples.get(0).getSampleCode());
        map.put("insOrderTemplate", map1);
        map.put("templateList", templateList);
        Set<Integer> orderTemplateIds = templateList.stream()
                .map(OrderTemplateSummaryVo::getTemplateId).collect(Collectors.toSet());
        List<Integer> methodIds = standardMethodService.list(Wrappers.<StandardMethod>lambdaQuery()
                        .eq(StandardMethod::getCode, insOrder.getSample())
                        .select(StandardMethod::getId)).stream()
                .map(StandardMethod::getId).collect(Collectors.toList());
        if (!methodIds.isEmpty() && !orderTemplateIds.isEmpty()) {
            List<StandardTree> candidates = standardTreeService.list(Wrappers.<StandardTree>lambdaQuery()
                    .in(StandardTree::getStandardMethodId, methodIds)
                    .isNull(StandardTree::getSampleType)
                    .isNull(StandardTree::getModel));
            Map<StandardTree, Set<Integer>> matches = candidates.stream()
                    .filter(tree -> StringUtils.isNotBlank(tree.getSample())
                            && Objects.equals(tree.getLaboratory(), insOrder.getLaboratory()))
                    .collect(Collectors.toMap(tree -> tree,
                            tree -> standardTreeService.selectTemplateBindings(tree.getId()).stream()
                                    .map(StandardTreeTemplateBindingVo::getTemplateId)
                                    .collect(Collectors.toSet())));
            matches.entrySet().removeIf(entry -> !entry.getValue().containsAll(orderTemplateIds));
            if (matches.size() == 1) {
                map.put("standardTreeId", matches.keySet().iterator().next().getId());
            } else if (matches.size() > 1) {
                List<StandardTree> exactMatches = matches.entrySet().stream()
                        .filter(entry -> entry.getValue().equals(orderTemplateIds))
                        .map(Map.Entry::getKey).collect(Collectors.toList());
                if (exactMatches.size() == 1) {
                    map.put("standardTreeId", exactMatches.get(0).getId());
                }
            }
        }
        return map;
    }

@@ -668,20 +962,16 @@
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int upInsOrderOfState(InsOrder insOrder) {
        insOrder.setExamineTime(LocalDateTime.now());
        if (insOrder.getState() == 1) {
            //审核通过才会生成委托编号
            //委托编号已在下单时生成并校验唯一性，审核时复用；历史/季度检验订单兜底生成。
            InsOrder order = this.getById(insOrder.getId());
            // 委托编号按送样日期独立流水，例如：LMSY-20260909-01。
            // 历史/外部订单未填写送样日期时回退到当天，避免影响原有流程。
            LocalDate entrustDate = order.getSampleDate() == null ? LocalDate.now() : order.getSampleDate();
            String entrustCodePrefix = "LMSY-"
                    + entrustDate.format(DateTimeFormatter.BASIC_ISO_DATE)
                    + "-";
            String no = numberGenerator.generateNumberWithPrefix(2,
                    entrustCodePrefix,
                    InsOrder::getEntrustCode);
            List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                    .eq(InsSample::getInsOrderId, insOrder.getId())
                    .orderByAsc(InsSample::getId));
            String no = order.getEntrustCode();
            // 判断是否是季度检验, 是季度检验取消原材料季度检验下单
            if (InsOrderTypeConstants.QUARTERLY_TEST.equals(order.getOrderType())) {
                ifsInventoryQuantityMapper.update(null,  Wrappers.<IfsInventoryQuantity>lambdaUpdate()
@@ -697,11 +987,12 @@
                  no = order1.getEntrustCode();
                }
            }
            if (StringUtils.isBlank(no)) {
                no = buildEntrustCode(order, insSamples);
            }
            assertEntrustCodeUnique(no, order.getId());

            int count = 1;
            // 查询样品表
            List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                    .eq(InsSample::getInsOrderId, insOrder.getId()));
            for (InsSample insSample : insSamples) {
                if (StringUtils.isBlank(insSample.getSampleCode())) {
                    // 如果只有一个样品就不需要拼接数字
@@ -717,7 +1008,48 @@

            insOrder.setEntrustCode(no);
        }
        return insOrderMapper.updateById(insOrder);
        int updated = insOrderMapper.updateById(insOrder);
        if (updated > 0 && Integer.valueOf(1).equals(insOrder.getState())) {
            List<InsSample> samples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                    .eq(InsSample::getInsOrderId, insOrder.getId())
                    .orderByAsc(InsSample::getId));
            if (samples.size() != 1) {
                throw new ErrorException("委托单必须且只能包含一个样品，不能进入样品接收流程");
            }
            insSampleReceiptMapper.insertIgnore(insOrder.getId(), samples.get(0).getId());
        }
        return updated;
    }

    /**
     * 委托编号全局唯一，生成编号和后续提交前均需排除当前订单后校验。
     */
    private void assertEntrustCodeUnique(String entrustCode, Integer currentOrderId) {
        Long count = insOrderMapper.selectCount(Wrappers.<InsOrder>lambdaQuery()
                .eq(InsOrder::getEntrustCode, entrustCode)
                .ne(currentOrderId != null, InsOrder::getId, currentOrderId));
        if (count > 0) {
            throw new ErrorException("样品/委托单已存在，请确认样品编号");
        }
    }

    /**
     * 生成委托编号：新聚直绑模板订单末两位取样品编号末两位，其余按送样日期生成序号。
     */
    private String buildEntrustCode(InsOrder order, List<InsSample> insSamples) {
        LocalDate entrustDate = order.getSampleDate() == null ? LocalDate.now() : order.getSampleDate();
        String entrustCodePrefix = "LMSY-"
                + entrustDate.format(DateTimeFormatter.BASIC_ISO_DATE)
                + "-";
        if (isDirectTemplateOrder(order, insSamples)) {
            String sampleCode = insSamples.get(0).getSampleCode();
            if (StringUtils.isBlank(sampleCode) || sampleCode.trim().length() < 2) {
                throw new ErrorException("样品编号不能为空且不能少于2位");
            }
            sampleCode = sampleCode.trim();
            return entrustCodePrefix + sampleCode.substring(sampleCode.length() - 2);
        }
        return numberGenerator.generateNumberWithPrefix(2, entrustCodePrefix, InsOrder::getEntrustCode);
    }

    @Override
@@ -739,7 +1071,6 @@
                                .eq(InsOrderStandardTemplate::getInsOrderId, id)
                                .select(InsOrderStandardTemplate::getTemplateId,
                                        InsOrderStandardTemplate::getTemperature,
                                        InsOrderStandardTemplate::getHumidity,
                                        InsOrderStandardTemplate::getDetectionTime,
                                        InsOrderStandardTemplate::getDetectionPlace,
                                        InsOrderStandardTemplate::getInsResult)
@@ -749,7 +1080,6 @@
                    TemplateConditionVo condition = new TemplateConditionVo();
                    condition.setTemplateId(snapshot.getTemplateId());
                    condition.setTemperature(snapshot.getTemperature());
                    condition.setHumidity(snapshot.getHumidity());
                    condition.setDetectionTime(snapshot.getDetectionTime());
                    condition.setDetectionPlace(snapshot.getDetectionPlace());
                    condition.setInsResult(snapshot.getInsResult());
@@ -1044,7 +1374,7 @@
        insOrder.setState(1);

        upInsOrderOfState(insOrder);
        upInsOrder(insOrder.getId(), null, appointed != null ? appointed.toString() : null, SecurityUtils.getUserId().intValue(), "原材料");
        // 审核通过后仅进入样品接收；由样品接收页面选择主检验人后再创建检验任务。

        return insOrder.getId();
    }