feat(device): 设备核查计划附件与设备使用记录联动改造

吴羡

2026-10-24 3d397976d08f0359b8cfeb4e4f22403ae5d0c04f

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

@@ -368,7 +368,7 @@
                }
            }
            map.put("errorMsg", collect);
            map.put("missingExportItems", getMissingTemplateExportValues(orderId));
            map.put("missingExportItems", getMissingTemplateExportValues(orderId, laboratory));
            map.put("unInsOrderCount", 0L);
            return map;
        }
@@ -605,11 +605,9 @@
        }


        // 添加设备记录
        threadPoolTaskExecutor.execute(() -> {
            // 添加设备使用记录
            addDeviceRecord(insSample, userId);
        });
        // 原始记录保存后，按当前模板选用的设备生成使用记录
        syncDeviceRecordsFromTemplate(saveInsContextDto.getOrderId(), saveInsContextDto.getSampleId(),
                saveInsContextDto.getCurrentTable(), userId);
    }

    /**
@@ -652,10 +650,11 @@

        JSONObject values = JSON.parseObject(JSON.toJSONString(dto.getValues() == null
                ? Collections.emptyMap() : dto.getValues()));
        // 检验期间页面展示的是标准维护中的最新模板，保存校验必须使用同一份模板，
        // 避免模板新增“导出值”批注后仍按下单时的旧快照误报未配置。
        String currentTemplateThing = getCurrentTemplateThing(snapshot);
        List<String> exportValueCoordinates = getExportValueCoordinates(currentTemplateThing).values().stream()
        // 保存时必须使用页面当前展示的模板：待检、在检阶段展示标准维护中的实时模板，
        // 复核、驳回阶段展示订单快照；否则模板在检验途中被修改后会取错导出值单元格。
        boolean useSnapshot = useSnapshotTemplate(dto.getOrderId(), getCurrentUserLaboratory(dto.getOrderId()));
        String pageTemplateThing = getPageTemplateThing(snapshot, useSnapshot);
        List<String> exportValueCoordinates = getExportValueCoordinates(pageTemplateThing).values().stream()
                .flatMap(Collection::stream)
                .distinct()
                .collect(Collectors.toList());
@@ -691,6 +690,9 @@
                .and(w -> w.isNull(InsProduct::getLastValue).or().eq(InsProduct::getLastValue, "")));
        sample.setInsState(unfinished == 0 ? 2 : 1);
        insSampleMapper.updateById(sample);

        // 原始记录保存后，按当前模板选用的设备生成使用记录
        syncDeviceRecordsFromTemplate(dto.getOrderId(), dto.getSampleId(), dto.getTemplateId(), userId);
    }

    /**
@@ -892,8 +894,8 @@
    }

    /**
     * 检验保存、提交校验读取标准维护中的实时模板；模板已被删除或内容为空时才回退订单快照。
     * 检验完成后的展示和报告仍由订单快照负责，不会随标准模板后续修改而变化。
     * 读取标准维护中的实时模板；模板已被删除或内容为空时才回退订单快照。
     * 仅用于检验室仍处于待检、在检阶段（页面展示实时模板）的保存与校验。
     */
    private String getCurrentTemplateThing(InsOrderStandardTemplate snapshot) {
        if (snapshot != null && snapshot.getTemplateId() != null) {
@@ -906,9 +908,53 @@
    }

    /**
     * 检验单页面在检验室进入复核及之后状态时展示订单快照，导出值的保存和提交校验必须与页面
     * 使用同一份模板；否则标准模板在检验途中被修改后，历史单据会按新坐标读取快照数据而误报为空。
     */
    private String getPageTemplateThing(InsOrderStandardTemplate snapshot, boolean useSnapshot) {
        if (useSnapshot && snapshot != null && StrUtil.isNotBlank(snapshot.getThing())) {
            return snapshot.getThing();
        }
        return getCurrentTemplateThing(snapshot);
    }

    /**
     * 与检验单页面 getTemplateThing 的判定保持一致：检验室状态进入复核（2）及之后时使用订单快照。
     * 指派记录里的实验室名称可能和状态行不一致（如“全部”），此时退回按订单整体状态判定。
     */
    private boolean useSnapshotTemplate(Integer orderId, String laboratory) {
        if (StringUtils.isNotBlank(laboratory)) {
            InsOrderState state = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                    .eq(InsOrderState::getInsOrderId, orderId)
                    .eq(InsOrderState::getLaboratory, laboratory)
                    .last("limit 1"));
            if (state != null) {
                return state.getInsState() != null && state.getInsState() >= 2;
            }
        }
        return insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery()
                        .eq(InsOrderState::getInsOrderId, orderId))
                .stream()
                .anyMatch(state -> state.getInsState() != null && state.getInsState() >= 2);
    }

    /**
     * 取当前登录人在该订单上最近一条指派记录所属的检验室；未指派账号返回 null，由状态判定兜底。
     */
    private String getCurrentUserLaboratory(Integer orderId) {
        Integer userId = SecurityUtils.getUserId().intValue();
        InsSampleUser sampleUser = insSampleUserMapper.selectOne(Wrappers.<InsSampleUser>lambdaQuery()
                .eq(InsSampleUser::getInsSampleId, orderId)
                .eq(InsSampleUser::getUserId, userId)
                .orderByDesc(InsSampleUser::getId)
                .last("limit 1"));
        return sampleUser == null ? null : sampleUser.getSonLaboratory();
    }

    /**
     * 直绑模板订单只校验每个“导出值”批注所在区域右侧紧邻单元格，不使用检验项状态或 last_value 判定。
     */
    private List<String> getMissingTemplateExportValues(Integer orderId) {
    private List<String> getMissingTemplateExportValues(Integer orderId, String laboratory) {
        List<InsOrderStandardTemplate> snapshots = insOrderStandardTemplateService.list(
                Wrappers.<InsOrderStandardTemplate>lambdaQuery()
                        .eq(InsOrderStandardTemplate::getInsOrderId, orderId)
@@ -918,9 +964,10 @@
            missing.add("当前订单未找到原始记录模板快照");
            return missing;
        }
        boolean useSnapshot = useSnapshotTemplate(orderId, laboratory);
        for (InsOrderStandardTemplate snapshot : snapshots) {
            Integer templateId = snapshot.getTemplateId();
            List<String> coordinates = getExportValueCoordinates(getCurrentTemplateThing(snapshot)).values().stream()
            List<String> coordinates = getExportValueCoordinates(getPageTemplateThing(snapshot, useSnapshot)).values().stream()
                    .flatMap(Collection::stream)
                    .distinct()
                    .collect(Collectors.toList());
@@ -985,60 +1032,52 @@
        }
    }

    private synchronized void addDeviceRecord(InsSample insSample, Integer userId) {
        InsOrder order = insOrderMapper.selectById(insSample.getInsOrderId());
    /**
     * 原始记录保存后，按当前模板选用的设备生成待填写的使用记录。
     * 同一订单、样品、设备只生成一条；已经填写过的记录不会被覆盖。
     */
    private synchronized void syncDeviceRecordsFromTemplate(Integer orderId, Integer sampleId,
                                                            Integer templateId, Integer userId) {
        if (orderId == null || sampleId == null || templateId == null) {
            return;
        }
        InsOrder order = insOrderMapper.selectById(orderId);
        InsSample sample = insSampleMapper.selectById(sampleId);
        if (order == null || sample == null) {
            return;
        }
        List<Integer> deviceIds = insOrderTemplateDeviceMapper
                .selectDeviceIdsByOrderAndTemplate(orderId, templateId);
        if (CollectionUtils.isEmpty(deviceIds)) {
            return;
        }
        User user = userMapper.selectById(userId);
        // 查询设备使用记录查询该订单的使用记录
        List<InsOrderDeviceRecordDto> deviceRecordDtoList = insOrderDeviceRecordMapper.selectDeviceNumber(insSample.getInsOrderId());
        Set<String> recordCodeset = deviceRecordDtoList.stream().map(InsOrderDeviceRecordDto::getManagementNumber).collect(Collectors.toSet());

        // 获取订单设备编号
        List<InsProductResult> resultList = insProductResultMapper.selectResultByOrderId(insSample.getInsOrderId());
        Set<String> deviceCodeSet = new HashSet<>();
        for (InsProductResult result : resultList) {
            // 添加设备编号
            List<JSONObject> jsonObjects = JSON.parseArray(result.getEquipValue(), JSONObject.class);
            for (JSONObject jsonObject : jsonObjects) {
                if (!"".equals(jsonObject.get("v") + "")) {
                    List<String> v = StrUtil.split(jsonObject.get("v") + "", "，");
                    deviceCodeSet.addAll(v);
                }
        String usePerson = user == null ? "" : user.getName();
        String sampleCode = StringUtils.isNotBlank(sample.getSampleCode())
                ? sample.getSampleCode() : order.getEntrustCode();
        for (Integer deviceId : deviceIds) {
            if (deviceId == null) {
                continue;
            }
            Long count = insOrderDeviceRecordMapper.selectCount(Wrappers.<InsOrderDeviceRecord>lambdaQuery()
                    .eq(InsOrderDeviceRecord::getInsOrderId, orderId)
                    .eq(InsOrderDeviceRecord::getDeviceId, deviceId)
                    .eq(InsOrderDeviceRecord::getSampleCode, sampleCode));
            if (count != null && count > 0) {
                continue;
            }
            InsOrderDeviceRecord record = new InsOrderDeviceRecord();
            record.setInsOrderId(orderId);
            record.setDeviceId(deviceId);
            record.setSampleCode(sampleCode);
            record.setTemperature(order.getTemperature());
            record.setHumidity(order.getHumidity());
            record.setUseBefore(1);
            record.setUseAfter(1);
            record.setUsePersonId(userId);
            record.setUsePerson(usePerson);
            insOrderDeviceRecordMapper.insert(record);
        }
        // 1.判断是否有没有添加的使用记录
        Set<String> orderDeviceNumbers = getDeviceDifference(deviceCodeSet, recordCodeset);
        // 添加使用记录, 根据编号查询设备id
        if (CollectionUtils.isNotEmpty(orderDeviceNumbers)) {
            List<Integer> orderDeviceIds = insOrderDeviceRecordMapper.selectDeviceIdsByNumbers(orderDeviceNumbers);
            List<InsOrderDeviceRecord> collect = orderDeviceIds.stream().map(deviceId -> {
                InsOrderDeviceRecord insOrderDeviceRecord = new InsOrderDeviceRecord();
                insOrderDeviceRecord.setInsOrderId(insSample.getInsOrderId());
                insOrderDeviceRecord.setDeviceId(deviceId);
                insOrderDeviceRecord.setSampleCode(order.getEntrustCode());
                insOrderDeviceRecord.setUseBefore(1);
                insOrderDeviceRecord.setUseAfter(1);
                insOrderDeviceRecord.setUsePerson(user.getName());
                insOrderDeviceRecord.setUsePersonId(user.getId());
                return insOrderDeviceRecord;
            }).collect(Collectors.toList());

            insOrderDeviceRecordService.saveBatch(collect);

        }

        // 2.判断是否取消了设备使用
        Set<String> repoprNumbers = getDeviceDifference(recordCodeset, deviceCodeSet);
        if (CollectionUtils.isNotEmpty(repoprNumbers)) {
            List<Integer> reportDeviceIds = insOrderDeviceRecordMapper.selectDeviceIdsByNumbers(repoprNumbers);
            insOrderDeviceRecordMapper.delete(Wrappers.<InsOrderDeviceRecord>lambdaQuery()
                    .in(InsOrderDeviceRecord::getDeviceId, reportDeviceIds)
                    .eq(InsOrderDeviceRecord::getInsOrderId, insSample.getInsOrderId()));
        }
    }

    private static Set<String> getDeviceDifference(Set<String> number1, Set<String> number2) {
        return number1.stream().filter(s1 -> number2.stream().noneMatch(s2 -> s1.equals(s2)))
                .collect(Collectors.toSet());
    }


@@ -1276,7 +1315,7 @@
        boolean directTemplateOrder = isDirectTemplateOrder(orderId);
        List<InsProduct> insProducts;
        if (directTemplateOrder) {
            List<String> missingExportValues = getMissingTemplateExportValues(orderId);
            List<String> missingExportValues = getMissingTemplateExportValues(orderId, laboratory);
            if (!missingExportValues.isEmpty()) {
                throw new ErrorException("模板中的导出值不能为空：\n" + String.join("\n", missingExportValues));
            }
@@ -1888,9 +1927,17 @@


        } else {
            //复核不通过将把复核的负责人去掉
            Integer id = insSampleUserMapper.selectOne(Wrappers.<InsSampleUser>lambdaQuery().eq(InsSampleUser::getInsSampleId, orderId).orderByDesc(InsSampleUser::getId).last("limit 1")).getId();
            insSampleUserMapper.deleteById(id);
            // 复核不通过只去掉本检验室本次提交的复核负责人；按复核人状态和检验室定位，
            // 避免误删其他检验室的记录或检验人员记录。
            InsSampleUser reviewerRow = insSampleUserMapper.selectOne(Wrappers.<InsSampleUser>lambdaQuery()
                    .eq(InsSampleUser::getInsSampleId, orderId)
                    .eq(InsSampleUser::getState, 1)
                    .eq(InsSampleUser::getSonLaboratory, laboratory)
                    .orderByDesc(InsSampleUser::getId)
                    .last("limit 1"));
            if (reviewerRow != null) {
                insSampleUserMapper.deleteById(reviewerRow.getId());
            }

            // 当前审核人
            Integer currentUserId = SecurityUtils.getUserId().intValue();