配置新增以及bug修改

zxl

2025-12-02 4f2c9b54c8d0f358f3b7c6821f091a493b24e006

 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java

@@ -119,7 +119,14 @@
        WorkOrderServiceImpl self = applicationContext.getBean(WorkOrderServiceImpl.class);
        return self.batchAddWorkOrder(workOrderList);
    }

    private boolean isSameDay(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return false;
        }
        LocalDate localDate1 = date1.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDate localDate2 = date2.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        return localDate1.isEqual(localDate2);
    }
    @Transactional(rollbackFor = Exception.class)
    public Boolean batchAddWorkOrder(List<WorkOrder> workOrderList) {
        int total = workOrderList.size();
@@ -143,14 +150,76 @@
        List<String> serialNumberList = workOrderList.stream().map(WorkOrder::getSerialNumber).collect(Collectors.toList());
        // 查出数据库中国标码对应的未完成的工单
        List<WorkOrder> inDatabaseWorkOrderList = baseMapper.getNotFinishedWorkOrders(serialNumberList);
        inDatabaseWorkOrderList.stream().forEach(item -> {
            if (StringUtils.hasText(item.getErrorType())) {
                item.setErrorTypeList(List.of(item.getErrorType().split(",")));
        log.info("打印出inDatabaseWorkOrderList:{}",inDatabaseWorkOrderList);

        // 2. 按 serialNumber 分组，合并错误类型
        Map<String, WorkOrder> mergedWorkOrders = new LinkedHashMap<>();

        for (WorkOrder order : inDatabaseWorkOrderList) {
            String serialNumber = order.getSerialNumber();

            if (mergedWorkOrders.containsKey(serialNumber)) {
                // 如果序列号已存在，合并错误类型
                WorkOrder existingOrder = mergedWorkOrders.get(serialNumber);
                //判断时间先后
                boolean isExistingNewer = existingOrder.getCreateTime() != null &&
                        order.getCreateTime() != null &&
                        existingOrder.getCreateTime().after(order.getCreateTime());

                WorkOrder latestOrder = isExistingNewer ? existingOrder : order;
                WorkOrder olderOrder = isExistingNewer ? order : existingOrder;

                List<String> latestErrorTypes = latestOrder.getErrorTypeList() != null
                        ? new ArrayList<>(latestOrder.getErrorTypeList())
                        : new ArrayList<>();

                if (StringUtils.hasText(olderOrder.getErrorType())) {
                    List<String> olderErrorTypes = Arrays.asList(olderOrder.getErrorType().split(","));
                    latestErrorTypes.addAll(olderErrorTypes);
                }

                // 去重并更新错误类型
                List<String> uniqueErrorTypes = latestErrorTypes.stream()
                        .distinct()
                        .collect(Collectors.toList());

                latestOrder.setErrorTypeList(uniqueErrorTypes);
                latestOrder.setErrorType(String.join(",", uniqueErrorTypes));

                // 更新Map中的工单为最新的工单
                mergedWorkOrders.put(serialNumber, latestOrder);



            } else {
                item.setErrorTypeList(new ArrayList<>(1));
                // 如果序列号不存在，初始化错误类型列表并添加到Map
                if (StringUtils.hasText(order.getErrorType())) {
                    order.setErrorTypeList(Arrays.asList(order.getErrorType().split(",")));
                } else {
                    order.setErrorTypeList(new ArrayList<>(1));
                }
                mergedWorkOrders.put(serialNumber, order);
            }
        });
        Map<String, WorkOrder> mapping = inDatabaseWorkOrderList.stream().collect((Collectors.toMap(WorkOrder::getSerialNumber, workOrder -> workOrder)));
        }
        log.info("打印出mergedWorkOrders合并后:{}",inDatabaseWorkOrderList);
// 3. 获取合并后的工单列表（保持顺序）
//        List<WorkOrder> finalWorkOrderList = new ArrayList<>(mergedWorkOrders.values());


//        Map<String, WorkOrder> mapping = null;
//        try {
//            mapping = finalWorkOrderList.stream()
//                    .collect(Collectors.toMap(WorkOrder::getSerialNumber, workOrder -> workOrder));
//        } catch (IllegalStateException e) {
//            // 捕获键重复异常
//            System.err.println("错误：发现重复的序列号，无法创建映射");
//            System.err.println("异常详情：" + e.getMessage());
//
//            // 可选：你可以在这里处理异常，比如返回一个空Map或者使用备用策略
//            // 方案1：返回空Map
//            mapping = new HashMap<>(); // Java 9+
//
//        }
        List<WorkOrder> waitAddList = new ArrayList<>(48);
        List<WorkOrderErrorType> waitAddErrorTypeList = new ArrayList<>(48);
        Integer updateNum = 0;
@@ -162,8 +231,17 @@
        // 即将要添加的错误类型
        List<WorkOrderErrorType> willAddErrorType = new ArrayList<>(96);
        for (WorkOrder workOrder : workOrderList) {
            WorkOrder databaseWorkOrder = mapping.get(workOrder.getSerialNumber());
            WorkOrder databaseWorkOrder = mergedWorkOrders.get(workOrder.getSerialNumber());
            if (Objects.nonNull(databaseWorkOrder)) {
                //判断是否是今天的工单
                if (!isSameDay(databaseWorkOrder.getCreateTime(), now)) {
                    // 若为前一天的工单，不更新，直接当作新工单新增
                    workOrder.setCreateTime(now);
                    workOrder.setUpdateTime(now);
                    waitAddList.add(workOrder);
                    continue; // 跳过后续的更新逻辑
                }

                List<String> errorNameList = databaseWorkOrder.getErrorTypeList();
                List<String> errorTypes = workOrder.getErrorTypeList();
                if (errorNameList.containsAll(errorTypes)) {
@@ -858,6 +936,43 @@
                }
            });
        }
        //加上报备信息
        if (!CollectionUtils.isEmpty(page.getRecords())) {
            List<String> serialNumberList = page.getRecords().stream()
                    .map(WorkOrderVO::getSerialNumber).collect(Collectors.toList());
            List<Report> reports = new LambdaQueryChainWrapper<>(reportMapper)
                    .in(Report::getSerialNumber, serialNumberList)
                    .eq(Report::getStatus,1)
                    .eq(Report::getDeleted,Boolean.FALSE).list();
            Map<String, List<Report>> reportMap = reports.stream()
                    .collect(Collectors.groupingBy(Report::getSerialNumber));

            for (WorkOrderVO workOrder : page.getRecords()) {
                workOrder.setHasReport(false);
                List<Report> reportsByWorkOrder = reportMap.get(workOrder.getSerialNumber());
                if (CollectionUtils.isEmpty(reportsByWorkOrder)) {
                    continue; // 无报告，直接跳过
                }
                Date distributeTime = workOrder.getDistributeTime();
                for (Report report : reportsByWorkOrder) {
                    Date beginTime = report.getBeginCreateTime();
                    Date endTime = report.getEndCreateTime();
                    // 空指针防护
                    if (distributeTime == null || beginTime == null || endTime == null) {
                        continue;
                    }
                    // 时间区间判断：distributeTime 在 [beginTime, endTime] 内
                    boolean isInRange = distributeTime.compareTo(beginTime) >= 0
                            && distributeTime.compareTo(endTime) <= 0;
                    if (isInRange) {
                        workOrder.setHasReport(true);
                        break; // 找到一个即退出循环
                    }
                }
            }
        }


        return Result.ok().data(page.getRecords()).total(page.getTotal());
    }

@@ -1072,8 +1187,10 @@

    @Override
    public WorkOrderTotalVO workOrderTotal(DashboardQuery dashboardQuery) {
        //todo大屏工单未处理工单数量有点问题
        return baseMapper.workOrderTotal(dashboardQuery);
    }


    @Override
    public List<WorkOrderRegionVO> workOrderRegion(DashboardQuery dashboardQuery) {
@@ -1287,10 +1404,30 @@
        }

        // 是否报备
        boolean hasReport = new LambdaQueryChainWrapper<>(reportMapper)
                .eq(Report::getSerialNumber, workOrder.getSerialNumber())
                .exists();
        workOrder.setHasReport(hasReport);

        List<Report> reports = new LambdaQueryChainWrapper<>(reportMapper)
                .eq(Report::getSerialNumber,workOrder.getSerialNumber())
                .eq(Report::getStatus,1)
                .orderByDesc(Report::getCreateTime)
                .list();
        log.info("报备记录:{}",reports);
        Date distributeTime = workOrder.getDistributeTime();
        workOrder.setHasReport(false);
        for (Report report : reports) {
            Date beginTime = report.getBeginCreateTime();
            Date endTime = report.getEndCreateTime();
            // 空指针防护
            if (distributeTime == null || beginTime == null || endTime == null) {
                continue;
            }
            // 时间区间判断：distributeTime 在 [beginTime, endTime] 内
            boolean isInRange = distributeTime.compareTo(beginTime) >= 0
                    && distributeTime.compareTo(endTime) <= 0;
            if (isInRange) {
                workOrder.setHasReport(true);
                break; // 找到一个即退出循环
            }
        }
        // 故障类型
        List<SysDictData> errorList = workOrderErrorTypeService.getBaseMapper().getErrorList(workOrder.getWorkOrderNo());
        List<String> errList = errorList.stream().map(SysDictData::getDictLabel).collect(Collectors.toList());