检验任务历史记录

zss

2024-09-14 e700e89f85e58747b57fc0d7e1fd30f3483aacca

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

@@ -87,6 +87,8 @@
    @Resource
    private InsProductMapper insProductMapper;
    @Resource
    private InsOrderUserMapper insOrderUserMapper;
    @Resource
    private ShiftTimeMapper shiftTimeMapper;
    @Resource
    private PerformanceShiftMapper performanceShiftMapper;
@@ -179,31 +181,6 @@
    public boolean claimInsOrderPlan(InsOrderPlanDTO entity) {
        if (Objects.isNull(entity)) {
            return false;
        }
        /*认领需要判断该样品是否在库*/
        //查询样品id(过滤没有检验项目的样品)
        List<Integer> sampleIds = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, entity.getInsSampleId())).stream().map(InsSample::getId).collect(Collectors.toList());
        for (Integer samId : sampleIds) {
            //过滤没有检验项目的样品id
            if (ObjectUtils.isEmpty(insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                    .eq(InsProduct::getInsSampleId, samId)
                    .eq(InsProduct::getState, 1)))) {
                continue;
            }
            //入库次数
            Long inCount = warehouseHistoryMapper.selectCount(Wrappers.<WarehouseHistory>lambdaQuery()
                    .eq(WarehouseHistory::getState, 1)
                    .eq(WarehouseHistory::getInsSampleId, samId));
            //出库次数
            Long outCount = warehouseHistoryMapper.selectCount(Wrappers.<WarehouseHistory>lambdaQuery()
                    .eq(WarehouseHistory::getState, 2)
                    .eq(WarehouseHistory::getInsSampleId, samId));
            if (inCount > 0 && inCount > outCount) {
                continue;
            } else {
                throw new ErrorException("所选的样品库存不足,请检查入库和出库记录!");
            }
        }
        Map<String, Integer> map1 = getLook.selectPowerByMethodAndUserId(null);
        Integer userId = map1.get("userId");
@@ -359,6 +336,54 @@
                .eq(InsProductResult2::getFrequency, insProductResultVo.getFrequency())
                .eq(InsProductResult2::getNum, insProductResultVo.getNum())
                .in(InsProductResult2::getInsProductId, insProductResultVo.getProductIds()));
    }

    //扫码报检
    @Override
    public int scanInsOrderState(String sonLaboratory, String sampleCode) {
        //先判断该订单是否有这个站点的项目
        InsSample insSample = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getSampleCode, sampleCode));
        List<Integer> sampleIds = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, insSample.getInsOrderId())).stream().map(InsSample::getId).collect(Collectors.toList());
        List<String> collect = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                .eq(InsProduct::getState, 1)
                .in(InsProduct::getInsSampleId, sampleIds)).stream().map(InsProduct::getSonLaboratory).collect(Collectors.toList());
        if (!collect.contains(sonLaboratory)) {
            throw new ErrorException("该订单没有" + sonLaboratory + "站点的相关项目,请查看下单详情!");
        }
        //判断该订单是否站点任务有结束试验
        List<InsOrderState> orderStates = insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, insSample.getInsOrderId())
                .eq(InsOrderState::getInsState, 5));
        if (CollectionUtils.isNotEmpty(orderStates)) {
            throw new ErrorException("该订单站点的任务已经结束试验,无法再次进行试验!");
        }
        InsOrderState orderState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, insSample.getInsOrderId())
                .eq(InsOrderState::getLaboratory, sonLaboratory));
        if (ObjectUtils.isNotEmpty(orderState)) {
            //继续试验
            if (orderState.getInsState() == 6) {
                orderState.setInsState(0);
                orderState.setNum(orderState.getNum() + 1);//递增
                insOrderStateMapper.updateById(orderState);
            } else {
                throw new ErrorException("该订单站点的任务已创建,无法再次创建!");
            }
        } else {
            InsOrderState insOrderState = new InsOrderState();
            insOrderState.setInsOrderId(insSample.getInsOrderId());
            insOrderState.setLaboratory(sonLaboratory);
            insOrderState.setInsState(0);
            insOrderState.setNum(1);//初始是第一次
            insOrderStateMapper.insert(insOrderState);
        }
        return 1;
    }

    @Override
    public List<InsOrderUser> getInsOrderUserList(Integer insOrderStateId) {
        return insOrderUserMapper.getInsOrderUserList(insOrderStateId);
    }


@@ -879,18 +904,22 @@
        }
        insUnPassService.saveBatch(insUnPasses);
        /*type=0  再次试验; type=1 继续试验 ; type=2 结束试验*/
        switch (type) {
            case 0:
                /*再次试验:该单子退回到检验状态(排序改成当前的最后),次数递增(保留以前的数据)；*/
                //更新原来的检验任务
                // 查询根据 id 倒序排列的第一条记录
                InsOrderState record = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                        .eq(InsOrderState::getInsOrderId, orderId)
                        .eq(InsOrderState::getLaboratory, laboratory)
                        .orderByDesc(InsOrderState::getId)
                        .last("LIMIT 1")); // 确保只取一条记录
                if (record != null) {
                    // 获取到第一条记录的 id 后，执行更新操作
        // 查询根据 id 倒序排列的第一条记录
        InsOrderState record = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, orderId)
                .eq(InsOrderState::getLaboratory, laboratory)
                .orderByDesc(InsOrderState::getId)
                .last("LIMIT 1")); // 确保只取一条记录
        if (record != null) {
            //更新记录
            insOrderUserMapper.update(null, Wrappers.<InsOrderUser>lambdaUpdate()
                    .eq(InsOrderUser::getInsOrderStateId, record.getId())
                    .eq(InsOrderUser::getNum, record.getNum())
                    .set(InsOrderUser::getTell, tell));
            switch (type) {
                case 0:
                    /*再次试验:该单子退回到检验状态(排序改成当前的最后),次数递增(保留以前的数据)；*/
                    //更新原来的检验任务
                    insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getId, record.getId())
                            .set(InsOrderState::getInsTime, now)
@@ -899,80 +928,34 @@
                            .set(InsOrderState::getVerifyUser, userId)
                            .set(InsOrderState::getNum, record.getNum() + 1)//次数加1
                            .set(InsOrderState::getCreateTime, LocalDateTime.now()));
                }
                break;
            case 1:
                //继续试验:则继续将检验任务转接至下一站点；
                insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                        .eq(InsOrderState::getInsOrderId, orderId)
                        .eq(InsOrderState::getLaboratory, laboratory)
                        .set(InsOrderState::getInsTime, now)
                        .set(InsOrderState::getInsState, 6)
                        .set(InsOrderState::getVerifyTell, tell)
                        .set(InsOrderState::getVerifyUser, userId));
                //转接至下一站点,需要先判断是否还有其余试验室,如果有其余试验室需要将订单下发
                List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                        .eq(InsSample::getInsOrderId, orderId).select(InsSample::getId));
                List<Integer> ids = insSamples.stream().map(a -> a.getId()).collect(Collectors.toList());
                List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                        .in(InsProduct::getInsSampleId, ids)
                        .eq(InsProduct::getState, 1));
                List<Integer> list = new ArrayList<>();
                list.add(4);
                list.add(5);
                list.add(6);
                List<InsOrderState> insOrderStates = insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery()
                        .eq(InsOrderState::getInsOrderId, orderId)
                        .in(InsOrderState::getInsState, list));
                List<String> strings = insOrderStates.stream().map(InsOrderState::getLaboratory).distinct().collect(Collectors.toList());
                //除去当前复核的试验室和已经复核的试验室
                List<String> collect = insProducts.stream()
                        .map(InsProduct::getSonLaboratory)
                        .distinct()
                        .filter(s -> !s.equals(laboratory))
                        .filter(s -> !strings.contains(s))
                        .collect(Collectors.toList());
                if (collect.size() > 0) {
                    //要判断剩余试验室中哪个最空闲就安排给哪个
                    Map<String, Long> dataCounts = new HashMap<>();
                    for (String sonLaboratory : collect) {
                        Long count = insOrderStateMapper.selectCount(Wrappers.<InsOrderState>lambdaQuery()
                                .eq(InsOrderState::getLaboratory, sonLaboratory)
                                .ne(InsOrderState::getInsState, 4)
                                .ne(InsOrderState::getInsState, 5)
                                .ne(InsOrderState::getInsState, 6));
                        dataCounts.put(sonLaboratory, count);
                    break;
                case 1:
                    //继续试验:则继续将检验任务转接至下一站点；
                    insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getInsOrderId, orderId)
                            .eq(InsOrderState::getLaboratory, laboratory)
                            .set(InsOrderState::getInsTime, now)
                            .set(InsOrderState::getInsState, 6)
                            .set(InsOrderState::getVerifyTell, tell)
                            .set(InsOrderState::getVerifyUser, userId));
                    break;
                case 2:
                    //结束试验:此委托单停止试验，直接生成最终报告和费用统计。
                    insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getInsOrderId, orderId)
                            .eq(InsOrderState::getLaboratory, laboratory)
                            .set(InsOrderState::getInsTime, now)
                            .set(InsOrderState::getInsState, 5)
                            .set(InsOrderState::getVerifyTell, tell)
                            .set(InsOrderState::getVerifyUser, userId));
                    //如果订单类型是原理样机,则该订单直接闭环
                    InsOrder insOrder = insOrderMapper.selectById(orderId);
                    if (insOrder.getFormType().equals("原理样机")) {
                        insOrder.setState(4);
                        insOrderMapper.updateById(insOrder);
                    }
                    // 查找数据量最少的元素
                    String minElement = null;
                    Long minCount = Long.MAX_VALUE;
                    for (Map.Entry<String, Long> entry : dataCounts.entrySet()) {
                        if (entry.getValue() < minCount) {
                            minCount = entry.getValue();
                            minElement = entry.getKey();
                        }
                    }
                    InsOrderState insOrderState = new InsOrderState();
                    insOrderState.setInsOrderId(orderId);
                    insOrderState.setLaboratory(minElement);
                    insOrderState.setInsState(0);
                    insOrderState.setNum(1);//初始是第一次
                    insOrderStateMapper.insert(insOrderState);
                } else {
                    //如果继续试验没有其他站点的检验任务那就结束试验
                    verifyPlan(orderId, laboratory, 2, tell);
                }
                break;
            case 2:
                //结束试验:此委托单停止试验，直接生成最终报告和费用统计。
                insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                        .eq(InsOrderState::getInsOrderId, orderId)
                        .eq(InsOrderState::getLaboratory, laboratory)
                        .set(InsOrderState::getInsTime, now)
                        .set(InsOrderState::getInsState, 5)
                        .set(InsOrderState::getVerifyTell, tell)
                        .set(InsOrderState::getVerifyUser, userId));
                break;
                    break;
            }
        }
        /*复核完成之后生成他自己的站点报告(仅限辐射试验检测(近场,远场)和电路试验)*/
        /*switch (laboratory) {
@@ -992,7 +975,7 @@
    }

    //生成电路试验的excel文件
    private MultipartFile generateExcelFile(Integer orderId, String laboratory) throws IOException{
    private MultipartFile generateExcelFile(Integer orderId, String laboratory) throws IOException {
        // 创建一个Workbook对象
        Workbook workbook = new XSSFWorkbook();

@@ -1048,7 +1031,7 @@
    }

    @Override
    public int submitPlan(Integer orderId, String laboratory, Integer verifyUser, String entrustCode) {
    public int submitPlan(Integer orderId, String laboratory, Integer verifyUser, String entrustCode, String note, String term) {
        List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, orderId).select(InsSample::getId));
        InsOrderState orderState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
@@ -1056,6 +1039,15 @@
                .eq(InsOrderState::getLaboratory, laboratory)
                .orderByDesc(InsOrderState::getId)
                .last("LIMIT 1"));// 确保只取一条记录
        /*记录检验任务每次的备注信息*/
        InsOrderUser insOrderUser = new InsOrderUser();
        insOrderUser.setInsOrderStateId(orderState.getId());
        insOrderUser.setSubmitUser(getLook.selectPowerByMethodAndUserId(null).get("userId"));
        insOrderUser.setSubmitTime(LocalDateTime.now());
        insOrderUser.setNum(orderState.getNum());
        insOrderUser.setNote(ObjectUtils.isNotEmpty(note) ? note : null);
        insOrderUser.setTerm(ObjectUtils.isNotEmpty(term) ? term : null);
        insOrderUserMapper.insert(insOrderUser);
        List<Integer> ids = insSamples.stream().map(a -> a.getId()).collect(Collectors.toList());
        List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                .in(InsProduct::getInsSampleId, ids)