430报表接口与列表流程添加

lyh

2 天以前 d61b21c50e62298f185ecafa8e0b22f7ee8c4973

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/service/impl/EamInspectionOrderServiceImpl.java

@@ -3,6 +3,7 @@
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -10,6 +11,7 @@
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
import org.apache.shiro.SecurityUtils;
import org.flowable.engine.TaskService;
import org.flowable.task.api.Task;
@@ -18,35 +20,43 @@
import org.jeecg.common.constant.DataBaseConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.StrUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.eam.aspect.annotation.EquipmentHistoryLog;
import org.jeecg.modules.eam.base.entity.BaseFactory;
import org.jeecg.modules.eam.base.entity.BaseFactoryUser;
import org.jeecg.modules.eam.base.service.IBaseFactoryService;
import org.jeecg.modules.eam.base.service.IBaseFactoryUserService;
import org.jeecg.modules.eam.constant.BusinessCodeConst;
import org.jeecg.modules.eam.constant.EquipmentOperationTagEnum;
import org.jeecg.modules.eam.constant.InspectionItemCategroyEnum;
import org.jeecg.modules.eam.constant.InspectionStatus;
import org.jeecg.modules.eam.constant.*;
import org.jeecg.modules.eam.dto.DailyResponsibleInfo;
import org.jeecg.modules.eam.dto.EamInspectionOrderDetailExport;
import org.jeecg.modules.eam.dto.EamInspectionOrderExport;
import org.jeecg.modules.eam.dto.WeeklyResponsibleInfo;
import org.jeecg.modules.eam.request.*;
import org.jeecg.modules.system.entity.BaseFactory;
import org.jeecg.modules.system.entity.BaseFactoryUser;
import org.jeecg.modules.system.service.IBaseFactoryService;
import org.jeecg.modules.system.service.IBaseFactoryUserService;
import org.jeecg.modules.eam.entity.*;
import org.jeecg.modules.eam.mapper.EamInspectionOrderMapper;
import org.jeecg.modules.eam.request.EamInspectionOrderQuery;
import org.jeecg.modules.eam.request.EamInspectionOrderRequest;
import org.jeecg.modules.eam.service.*;
import org.jeecg.modules.eam.util.DateUtils;
import org.jeecg.modules.eam.vo.InspectionVo;
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
import org.jeecg.modules.flowable.apithird.business.service.impl.FlowMyBusinessServiceImpl;
import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI;
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
import org.jeecg.modules.flowable.service.IFlowTaskService;
import org.jeecg.modules.system.service.ISysDictService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.vo.UserSelector;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

/**
@@ -84,6 +94,12 @@
    private IEamReportRepairService eamReportRepairService;
    @Resource
    private IEamMaintenanceStandardDetailService eamMaintenanceStandardDetailService;
    @Resource
    private ISysDictService sysDictService;
    @Resource
    private ISysUserService sysUserService;
    @Resource
    private IEamBaseHFCodeService eamBaseHFCodeService;

    @Override
    public IPage<EamInspectionOrder> queryPageList(Page<EamInspectionOrder> page, EamInspectionOrderQuery query) {
@@ -93,18 +109,20 @@
        if (sysUser == null) {
            return page;
        }
        if (StringUtils.isNotBlank(sysUser.getEquipmentIds())) {
        if (StringUtils.isNotBlank(sysUser.getEamEquipmentIds())) {
            //选择了设备，根据设备id过滤设备
            List<String> equipArr = Arrays.asList(sysUser.getEquipmentIds().split(","));
            List<String> equipArr = Arrays.asList(sysUser.getEamEquipmentIds().split(","));
            queryWrapper.in("e.equipment_code", equipArr);
        } else {
            //没有选择设备，根据中心过滤设备
            List<BaseFactoryUser> baseFactoryUserList = baseFactoryUserService.
                    list(new LambdaQueryWrapper<BaseFactoryUser>().eq(BaseFactoryUser::getUserId, sysUser.getId()));
            if (!CollectionUtils.isEmpty(baseFactoryUserList)) {
                List<String> factoryIds = baseFactoryUserList.stream().map(BaseFactoryUser::getFactoryId).collect(Collectors.toList());
                List<String> factoryCode = baseFactoryService.listByIds(factoryIds).stream().map(BaseFactory::getFactoryCode).collect(Collectors.toList());
                queryWrapper.in("e.factory_code", factoryCode);
                Set<String> factoryIds = baseFactoryUserList.stream().map(BaseFactoryUser::getFactoryId).collect(Collectors.toSet());
                Set<String> factoryCode = baseFactoryService.listByIds(factoryIds).stream().map(BaseFactory::getOrgCode).collect(Collectors.toSet());
                queryWrapper.in("e.factory_org_code", factoryCode);
            }else {
                return page;
            }
        }
        //查询条件过滤
@@ -154,18 +172,329 @@
        return eamInspectionOrderMapper.selectList(queryWrapper);
    }

    /**
     * 导出获取基本信息
     * @param equipmentCode 设备编码
     * @param inspectionDate 点检日期
     * @return
     */
    @Override
    public JSONObject exportInspectionOrderBaseInfo(String equipmentCode, String inspectionDate) {
        if (StrUtils.isEmpty(inspectionDate)) {
            // 获取当前日期
            LocalDate currentDate = LocalDate.now();
            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
            // 格式化当前月份
            inspectionDate = currentDate.format(formatter);
        }
        // 创建结果对象
        JSONObject result = new JSONObject();
        EamInspectionOrderBaseResponse eamInspectionOrderBaseResponse = eamInspectionOrderMapper.findInsOrderBaseInfo(equipmentCode, inspectionDate);
        // 处理单位
        String factoryOrgCode = eamInspectionOrderBaseResponse.getFactoryName();
        BaseFactory baseFactory = baseFactoryService.getOne(new LambdaQueryWrapper<BaseFactory>().eq(BaseFactory::getOrgCode, factoryOrgCode.substring(0, 6)));
        eamInspectionOrderBaseResponse.setFactoryName(baseFactory.getFactoryName());
        result.put("data",Collections.singletonList(eamInspectionOrderBaseResponse));
        return result;
    }

    /**
     * 日点检项列表
     * @param equipmentCode 设备编码
     * @param inspectionDate 点检日期
     * @return
     */
    @Override
    public JSONObject exportInspectionOrderDetailList(String equipmentCode, String inspectionDate) {
        if (StrUtils.isEmpty(inspectionDate)) {
            // 获取当前日期
            LocalDate currentDate = LocalDate.now();
            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
            // 格式化当前月份
            inspectionDate = currentDate.format(formatter);
        }
        // 创建结果对象
        JSONObject result = new JSONObject();
        List<EamInsOrderDetailResultResponse> eamInsOrderDetailResultResponseList = eamInspectionOrderMapper.findInsOrderDetailList(equipmentCode, inspectionDate);
        if (eamInsOrderDetailResultResponseList == null || eamInsOrderDetailResultResponseList.isEmpty()) {
            return result;
        }
        Map<EamInsOrderDetailResultResponse, List<EamInsOrderDetailResultResponse>> groupMap = eamInsOrderDetailResultResponseList
                .stream().collect(Collectors.groupingBy(
                        // 分组键：包含 itemCode、itemName、itemDemand 的对象
                        item -> new EamInsOrderDetailResultResponse(
                                item.getItemCode(),
                                item.getItemName(),
                                item.getItemDemand()
                        ),
                        // 用 TreeMap 作为容器，并指定按 itemCode 排序的比较器
                        () -> new TreeMap<>(Comparator.comparingInt(EamInsOrderDetailResultResponse::getItemCode)),
                        // 收集每组的元素为 List
                        Collectors.toList()
                ));
        List<Map<String, Object>> resultList = new ArrayList<>();
        groupMap.forEach((insOrderDetailResultResponse, insOrderDetailResultResponseList) -> {
            Map<String, Object> resultMap = new LinkedHashMap<>();
            resultMap.put("itemCode", insOrderDetailResultResponse.getItemCode());
            resultMap.put("itemName", insOrderDetailResultResponse.getItemName());
            resultMap.put("itemDemand", insOrderDetailResultResponse.getItemDemand());
            Map<Integer, EamInsOrderDetailResultResponse> collect = insOrderDetailResultResponseList
                    .stream().collect(Collectors.toMap(
                            // 分组键：提取日期中的“天”
                            item -> {
                                Date date = item.getInspectionDate();
                                LocalDate localDate = date.toInstant()
                                        .atZone(ZoneId.systemDefault())
                                        .toLocalDate();
                                return localDate.getDayOfMonth(); // 键为“天”（1-31）
                            },
                            // 值：直接使用当前对象（作为初始值）
                            item -> item,
                            // 合并函数：当同一“天”有多个对象时，如何处理（这里示例取第一个）
                            (existing, replacement) -> existing // 若有重复键，保留已存在的对象
                    ));
            for (int i = 1; i <= 31; i++) {
                if (collect.containsKey(i)) {
                    String inspectionResult = "";
                    if (!StrUtils.isEmpty(collect.get(i).getInspectionResult())) {
                        switch (collect.get(i).getInspectionResult()) {
                            case "NORMAL":
                                inspectionResult = "√";
                                break;
                            case "ANOMALY":
                                inspectionResult = "×";
                                break;
                            case "FAULT":
                                inspectionResult = "△";
                                break;
                            case "CLOSE":
                                inspectionResult = "T";
                                break;
                        }
                    }
                    resultMap.put("inspectionResult" + i, inspectionResult);
                } else {
                    resultMap.put("inspectionResult" + i, "");
                }
            }
            resultList.add(resultMap);
        });
        result.put("data", resultList);
        return result;
    }

    /**
     * 日点检责任人列表
     * @param equipmentCode 设备编码
     * @param inspectionDate 点检日期
     * @return
     */
    @Override
    public JSONObject exportInspectionOrderDetailUserList(String equipmentCode, String inspectionDate) {
        if (StrUtils.isEmpty(inspectionDate)) {
            // 获取当前日期
            LocalDate currentDate = LocalDate.now();
            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
            // 格式化当前月份
            inspectionDate = currentDate.format(formatter);
        }
        // 创建结果对象
        JSONObject result = new JSONObject();
        List<EamInsOrderDetailUserResponse> eamInsOrderDetailUserResponseList = eamInspectionOrderMapper.findInspectionOrderDetailUserList(equipmentCode, inspectionDate);
        if (eamInsOrderDetailUserResponseList == null || eamInsOrderDetailUserResponseList.isEmpty()) {
            return result;
        }
        Map<Integer, EamInsOrderDetailUserResponse> groupMap = eamInsOrderDetailUserResponseList.stream().collect(Collectors.toMap(
                // 分组键：提取日期中的“天”
                item -> {
                    Date date = item.getInspectionDate();
                    LocalDate localDate = date.toInstant()
                            .atZone(ZoneId.systemDefault())
                            .toLocalDate();
                    return localDate.getDayOfMonth(); // 键为“天”（1-31）
                },
                // 值：直接使用当前对象（作为初始值）
                item -> item,
                // 合并函数：当同一“天”有多个对象时，如何处理（这里示例取第一个）
                (existing, replacement) -> existing // 若有重复键，保留已存在的对象
        ));
        Map<String, Object> resultMap = new LinkedHashMap<>();
        for (int i = 1; i <= 31; i++) {
            if (groupMap.containsKey(i)) {
                EamInsOrderDetailUserResponse eamInsOrderDetailUserResponse = groupMap.get(i);
                resultMap.put("operator" + i, sysDictService.queryTableDictTextByKey("sys_user", "realname", "username", eamInsOrderDetailUserResponse.getOperator()));
                resultMap.put("confirmUser" + i, sysDictService.queryTableDictTextByKey("sys_user", "realname", "username", eamInsOrderDetailUserResponse.getConfirmUser()));
            } else {
                resultMap.put("operator" + i, "");
                resultMap.put("confirmUser" + i, "");
            }
        }
        result.put("data", Collections.singletonList(resultMap));
        return result;
    }

    /**
     * 周点检项列表
     * @param equipmentCode 设备编码
     * @param inspectionDate 点检日期
     * @return
     */
    @Override
    public JSONObject exportWeekInsDetailList(String equipmentCode, String inspectionDate) {
        if (StrUtils.isEmpty(inspectionDate)) {
            // 获取当前日期
            LocalDate currentDate = LocalDate.now();
            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
            // 格式化当前月份
            inspectionDate = currentDate.format(formatter);
        }
        // 创建结果对象
        JSONObject result = new JSONObject();
        List<EamWeekInsDetailResultResponse> eamWeekInsDetailResultResponseList = eamInspectionOrderMapper.findWeekInsDetailList(equipmentCode, inspectionDate);
        if (eamWeekInsDetailResultResponseList == null || eamWeekInsDetailResultResponseList.isEmpty()) {
            return result;
        }
        Map<EamWeekInsDetailResultResponse, List<EamWeekInsDetailResultResponse>> groupMap = eamWeekInsDetailResultResponseList
                .stream().collect(Collectors.groupingBy(
                        // 分组键：包含 itemCode、itemName、itemDemand 的对象
                        item -> new EamWeekInsDetailResultResponse(
                                item.getItemCode(),
                                item.getItemName(),
                                item.getItemDemand()
                        ),
                        // 用 TreeMap 作为容器，并指定按 itemCode 排序的比较器
                        () -> new TreeMap<>(Comparator.comparingInt(EamWeekInsDetailResultResponse::getItemCode)),
                        // 收集每组的元素为 List
                        Collectors.toList()
                ));
        List<Map<String, Object>> resultList = new ArrayList<>();
        groupMap.forEach((weekInsDetailResultResponse, weekInsDetailResultResponseList) -> {
            Map<String, Object> resultMap = new LinkedHashMap<>();
            resultMap.put("itemCode", weekInsDetailResultResponse.getItemCode());
            resultMap.put("itemName", weekInsDetailResultResponse.getItemName());
            resultMap.put("itemDemand", weekInsDetailResultResponse.getItemDemand());
            Map<Integer, EamWeekInsDetailResultResponse> collect = weekInsDetailResultResponseList
                    .stream()
                    .collect(Collectors.toMap(
                            // 分组键：使用planInspectionDate字段落在本月的周数
                            item -> {
                                Calendar calendar = Calendar.getInstance();
                                calendar.setTime(item.getPlanInspectionDate());
                                return calendar.get(Calendar.WEEK_OF_MONTH);
                            },
                            // 值：直接使用当前对象
                            item -> item,
                            // 合并函数：当同一周有多个对象时（根据需求不会发生，但仍需提供）
                            (existing, replacement) -> existing,
                            // 指定Map的具体实现（可选）
                            LinkedHashMap::new // 保持插入顺序
                    ));
            for (int i = 1; i <= 5; i++) {
                if (collect.containsKey(i)) {
                    String inspectionResult = "";
                    if (!StrUtils.isEmpty(collect.get(i).getInspectionResult())) {
                        switch (collect.get(i).getInspectionResult()) {
                            case "NORMAL":
                                inspectionResult = "√";
                                break;
                            case "ANOMALY":
                                inspectionResult = "×";
                                break;
                            case "FAULT":
                                inspectionResult = "△";
                                break;
                            case "CLOSE":
                                inspectionResult = "T";
                                break;
                        }
                    }
                    resultMap.put("inspectionResult" + i, inspectionResult);
                } else {
                    resultMap.put("inspectionResult" + i, "");
                }
            }
            resultList.add(resultMap);
        });
        result.put("data", resultList);
        return result;
    }

    /**
     * 周点检责任人列表
     * @param equipmentCode 设备编码
     * @param inspectionDate 点检日期
     * @return
     */
    @Override
    public JSONObject exportWeekInsOrderDetailUserList(String equipmentCode, String inspectionDate) {
        if (StrUtils.isEmpty(inspectionDate)) {
            // 获取当前日期
            LocalDate currentDate = LocalDate.now();
            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
            // 格式化当前月份
            inspectionDate = currentDate.format(formatter);
        }
        // 创建结果对象
        JSONObject result = new JSONObject();
        List<EamWeekInsDetailUserResponse> eamWeekInsDetailUserResponseList = eamInspectionOrderMapper.findWeekInsOrderDetailUserList(equipmentCode, inspectionDate);
        if (eamWeekInsDetailUserResponseList == null || eamWeekInsDetailUserResponseList.isEmpty()) {
            return result;
        }
        Map<Integer, EamWeekInsDetailUserResponse> groupMap = eamWeekInsDetailUserResponseList
                .stream()
                .collect(Collectors.toMap(
                        // 分组键：使用 planInspectionDate 字段落在本月的周数
                        item -> {
                            Calendar calendar = Calendar.getInstance();
                            calendar.setTime(item.getPlanInspectionDate());
                            return calendar.get(Calendar.WEEK_OF_MONTH);
                        },
                        // 值：直接使用当前对象
                        item -> item,
                        // 合并函数：当同一周有多个对象时（根据需求不会发生）
                        (existing, replacement) -> existing,
                        // 使用 LinkedHashMap 保持插入顺序
                        LinkedHashMap::new
                ));
        Map<String, Object> resultMap = new LinkedHashMap<>();
        for (int i = 1; i <= 5; i++) {
            if (groupMap.containsKey(i)) {
                EamWeekInsDetailUserResponse eamWeekInsDetailUserResponse = groupMap.get(i);
                resultMap.put("operator" + i, sysDictService.queryTableDictTextByKey("sys_user", "realname", "username", eamWeekInsDetailUserResponse.getInspector()));
                resultMap.put("confirmUser" + i, sysDictService.queryTableDictTextByKey("sys_user", "realname", "username", eamWeekInsDetailUserResponse.getConfirmUser()));
            } else {
                resultMap.put("operator" + i, "");
                resultMap.put("confirmUser" + i, "");
            }
        }
        result.put("data", Collections.singletonList(resultMap));

        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addInspectionOrder(EamInspectionOrderRequest eamInspectionOrderRequest) {
    public Result<String> addInspectionOrder(EamInspectionOrderRequest eamInspectionOrderRequest) {
        List<EamInspectionOrder> eamInspectionOrders = eamInspectionOrderMapper.selectList(new LambdaQueryWrapper<EamInspectionOrder>().eq(EamInspectionOrder::getStandardId, eamInspectionOrderRequest.getStandardId()).eq(EamInspectionOrder::getInspectionDate, eamInspectionOrderRequest.getInspectionDate()).ne(EamInspectionOrder::getInspectionStatus, InspectionStatus.ABOLISH.name()));
        if (CollectionUtils.isNotEmpty(eamInspectionOrders)) {
            return Result.error("添加失败,系统已存在当前日期工单！");
        }
        EamInspectionOrder eamInspectionOrder = new EamInspectionOrder();
        BeanUtils.copyProperties(eamInspectionOrderRequest, eamInspectionOrder);
        //修改状态
        if (StrUtil.isNotBlank(eamInspectionOrderRequest.getOperator())) {
            eamInspectionOrder.setInspectionStatus(InspectionStatus.UNDER_INSPECTION.name());
        } else {
            eamInspectionOrder.setInspectionStatus(InspectionStatus.WAIT_INSPECTION.name());
        }
        eamInspectionOrder.setInspectionStatus(InspectionStatus.WAIT_INSPECTION.name());
        eamInspectionOrder.setDelFlag(CommonConstant.DEL_FLAG_0);
        //HF码处理
        EamBaseHFCode eamBaseHFCode = eamBaseHFCodeService.selectByCategory(HfTemplateCategoryEnum.INSPECTION.name());
        if (eamBaseHFCode == null) {
            return Result.error("添加失败,未配置点检HF编码！");
        }
        eamInspectionOrder.setHfCode(eamBaseHFCode.getHfCode());
        save(eamInspectionOrder);
        //处理日点检明细数据
        if (StrUtil.isNotBlank(eamInspectionOrderRequest.getStandardId())) {
@@ -191,19 +520,15 @@
                if (CollectionUtils.isNotEmpty(maintenanceStandardDetailList)) {
                    List<EamWeekInspectionDetail> weekInspectionDetailList = maintenanceStandardDetailList.stream().map(EamWeekInspectionDetail::new).collect(Collectors.toList());
                    weekInspectionDetailList.forEach(weekInspectionDetail -> {
                        weekInspectionDetail.setEquipmentId(eamInspectionOrderRequest.getEquipmentId());
                        weekInspectionDetail.setStandardId(eamInspectionOrderRequest.getStandardId());
                        // TODO 周点检日期
                        weekInspectionDetail.setPlanInspectionDate(eamInspectionOrderRequest.getInspectionDate());
                    });
                    eamWeekInspectionDetailService.saveBatch(weekInspectionDetailList);
                }
            }
        }

//        if (StrUtil.isNotBlank(eamInspectionOrderRequest.getOperator())) {
//            triggerProcess(eamInspectionOrder);
//        }
        return true;
        return Result.OK("添加成功！");
    }

    /**
@@ -219,7 +544,7 @@
        } else {
            eamInspectionOrder.setEquipmentId(equipment.getId());
        }
        flowCommonService.initActBusiness("工单号: " + eamInspectionOrder.getOrderNum() + ";设备编号: " + equipment.getEquipmentCode() + (equipment.getInstallationPosition() == null ? "" : ";安装位置: " + equipment.getInstallationPosition()),
        flowCommonService.initActBusiness("工单号: " + eamInspectionOrder.getOrderNum() + ";设备编号: " + equipment.getEquipmentCode(),
                eamInspectionOrder.getId(), "IEamInspectionOrderService", "eam_inspection", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("dataId", eamInspectionOrder.getId());
@@ -338,8 +663,26 @@
                throw new JeecgBootException("任务不存在、已完成或已被他人认领");
            }

            EamEquipment equipment = eamEquipmentService.getById(eamInspectionOrder.getEquipmentId());
            if (equipment == null) {
                throw new JeecgBootException("设备不存在，请检查！");
            }

            // 检查周保过期时间
            if (eamInspectionOrderRequest.getTableWeekDetailList() == null || eamInspectionOrderRequest.getTableWeekDetailList().isEmpty()) {
                List<EamWeekInspectionDetail> weekInspectionDetailList = eamWeekInspectionDetailService.list(new LambdaQueryWrapper<EamWeekInspectionDetail>().eq(EamWeekInspectionDetail::getStandardId, eamInspectionOrderRequest.getStandardId()).between(EamWeekInspectionDetail::getPlanInspectionDate, DateUtils.getFirstDayOfWeek(eamInspectionOrderRequest.getInspectionDate()), DateUtils.getLastDayOfWeek(eamInspectionOrderRequest.getInspectionDate())));
                if (weekInspectionDetailList != null && !weekInspectionDetailList.isEmpty()) {
                    if (StrUtil.isEmpty(eamInspectionOrderRequest.getOperator())) {
                        Date lastDate = DateUtils.getLastDayOfWeek(eamInspectionOrderRequest.getInspectionDate());
                        if (DateUtils.isSameDay(lastDate, new Date())) {
                            throw new JeecgBootException("本周点检未完成，请进行填报！");
                        }
                    }
                }
            }

            // 设置流程变量
            setupProcessVariables(eamInspectionOrderRequest, eamInspectionOrder, user);
            setupProcessVariables(eamInspectionOrderRequest, eamInspectionOrder, user, equipment);

            // 完成流程任务
            Result result = flowTaskService.complete(eamInspectionOrderRequest);
@@ -351,9 +694,9 @@
            updateEamInspectionOrder(eamInspectionOrder);

            //查询数据,进行设备维修处理
            if (eamInspectionOrder.getInspectionStatus().equals(InspectionStatus.WAIT_CONFIRM.name())) {
                updateEamInspectionOrderDetail(eamInspectionOrder);
            }
//            if (eamInspectionOrder.getInspectionStatus().equals(InspectionStatus.WAIT_CONFIRM.name())) {
//                updateEamInspectionOrderDetail(eamInspectionOrder);
//            }

            return eamInspectionOrder;
        } catch (Exception e) {
@@ -361,6 +704,270 @@
        }
    }

    /**
     * 生产设备自主维护点检表打印
     * @param ids
     * @return
     */
    @Override
    public List<EamInspectionOrderExport> printInspectionOrder(String ids) {

        List<EamInspectionOrderExport> eamInspectionOrderExports =
                this.eamInspectionOrderMapper.queryList(Arrays.asList(ids.split(",")));

        if (eamInspectionOrderExports == null || eamInspectionOrderExports.isEmpty()) {
            return null;
        }

        eamInspectionOrderExports.forEach(eamInspectionOrderExport -> {

            // 日期处理
            if (StrUtil.isNotEmpty(eamInspectionOrderExport.getInspectionMonth())){
                if (eamInspectionOrderExport.getInspectionMonth().length() == 1) {
                    eamInspectionOrderExport.setInspectionMonth("0" + eamInspectionOrderExport.getInspectionMonth());
                }
            }
            String finalInspectionDate = eamInspectionOrderExport.getInspectionYear()+"-" + eamInspectionOrderExport.getInspectionMonth();
            // 获取该设备的日点检明细数据
            List<EamInsOrderDetailResultResponse> detailResponseList =
                    eamInspectionOrderMapper.findInsOrderDetailList(
                            eamInspectionOrderExport.getEquipmentCode(),
                            finalInspectionDate
                    );

            if (!detailResponseList.isEmpty()) {
                // 按项目分组存储（项目编码为key）
                Map<Integer, EamInspectionOrderDetailExport> detailExportMap = new HashMap<>();

                // 初始化项目信息（每个项目对应一个31天状态的对象）
                detailResponseList.forEach(detail -> {
                    Integer itemCode = detail.getItemCode();
                    EamInspectionOrderDetailExport export = detailExportMap.get(itemCode);

                    if (export == null) {
                        // 创建新的点检项目对象
                        export = new EamInspectionOrderDetailExport()
                                .setItemCode(itemCode)
                                .setItemName(detail.getItemName())
                                .setItemDemand(detail.getItemDemand())
                                .setDateFlag(new String[31]); // 初始化31天状态数组

                        detailExportMap.put(itemCode, export);
                    }
                });

                // 填充各项目每日的点检状态
                detailResponseList.forEach(detail -> {
                    Integer itemCode = detail.getItemCode();
                    EamInspectionOrderDetailExport export = detailExportMap.get(itemCode);

                    try {
                        Date newinspectionDate = detail.getInspectionDate();

                        // 处理空日期情况
                        if (newinspectionDate == null) {
                            log.warn("检测到空日期值, itemCode: {}");
                            return;
                        }
                        // 转换为LocalDate
                        LocalDate date = newinspectionDate.toInstant()
                                .atZone(ZoneId.systemDefault())
                                .toLocalDate();
                        int day = date.getDayOfMonth();
                        // 安全设置日期状态
                        if (day >= 1 && day <= 31) {
                            String[] dateFlags = export.getDateFlag();
                            if (dateFlags == null) {
                                dateFlags = new String[31];
                                export.setDateFlag(dateFlags);
                            }
                            if (StrUtil.isNotEmpty(detail.getInspectionResult())){
                                switch (detail.getInspectionResult()) {
                                    case "NORMAL":
                                        dateFlags[day - 1] = "√";
                                        break;
                                    case "ANOMALY":
                                        dateFlags[day - 1] = "×";
                                        break;
                                    case "FAULT":
                                        dateFlags[day - 1] = "△";
                                        break;
                                    case "CLOSE":
                                        dateFlags[day - 1] = "T";
                                        break;
                                }
                            }
                        } else {
                            log.warn("非法日期值: {}, itemCode: {}");
                        }
                    }
                    catch (DateTimeParseException | NullPointerException e) {
                        log.error("日期处理错误 - 原始值: {}, 项目: {}, 错误: {}");
                    }
                });
                // 将点检项目集合转换为列表
                List<EamInspectionOrderDetailExport> detailExports =
                        new ArrayList<>(detailExportMap.values());
                // 设置到主导出对象中
                eamInspectionOrderExport.setEamDailyInspectionList(detailExports);
            }else {
                eamInspectionOrderExport.setEamDailyInspectionList(null);
            }
            // 获取该设备的周点检明细数据
            List<EamWeekInsDetailResultResponse> eamWeekInsDetailResultResponseList =
                    eamInspectionOrderMapper.findWeekInsDetailList(
                            eamInspectionOrderExport.getEquipmentCode(),
                            finalInspectionDate
                    );
            if (!eamWeekInsDetailResultResponseList.isEmpty()) {
                // 按项目分组存储（项目编码为key）
                Map<Integer, EamInspectionOrderDetailExport> detailExportMap = new HashMap<>();
                // 初始化项目信息
                eamWeekInsDetailResultResponseList.forEach(detail -> {
                    Integer itemCode = detail.getItemCode();
                    EamInspectionOrderDetailExport export = detailExportMap.get(itemCode);
                    if (export == null) {
                        // 创建新的点检项目对象并初始化weekFlag数组
                        export = new EamInspectionOrderDetailExport()
                                .setItemCode(itemCode)
                                .setItemName(detail.getItemName())
                                .setItemDemand(detail.getItemDemand())
                                .setWeekFlag(new String[5]); // 明确初始化长度为5
                        detailExportMap.put(itemCode, export);
                    }
                });
                // 填充各项目每周的点检状态
                eamWeekInsDetailResultResponseList.forEach(detail -> {
                    Integer itemCode = detail.getItemCode();
                    EamInspectionOrderDetailExport export = detailExportMap.get(itemCode);

                    Date newinspectionDate = detail.getPlanInspectionDate();
                    if (newinspectionDate == null) {
                        log.warn("检测到空日期值, itemCode: {}");
                        return;
                    }

                    // 计算该日期是当月第几周 (1-5)
                    int week = calculateWeekOfMonth(newinspectionDate);

                    if (week >= 1 && week <= 5) {
                        String[] weekFlags = export.getWeekFlag();
                        if (weekFlags == null) {
                            weekFlags = new String[31];
                            export.setWeekFlag(weekFlags);
                        }
                        if (StrUtil.isNotEmpty(detail.getInspectionResult())){
                            switch (detail.getInspectionResult()) {
                                case "NORMAL":
                                    weekFlags[week - 1] = "√";
                                    break;
                                case "ANOMALY":
                                    weekFlags[week - 1] = "×";
                                    break;
                                case "FAULT":
                                    weekFlags[week - 1] = "△";
                                    break;
                                case "CLOSE":
                                    weekFlags[week - 1] = "T";
                                    break;
                            }
                        }
                    }
                });
                // 将点检项目集合转换为列表
                List<EamInspectionOrderDetailExport> weekDetailExports =
                        new ArrayList<>(detailExportMap.values());
                // 设置到主导出对象中
                eamInspectionOrderExport.setEamWeeklyInspectionList(weekDetailExports);
            }else {
                eamInspectionOrderExport.setEamWeeklyInspectionList(null);
            }


            // ================== 添加日点检责任人信息 ==================
            DailyResponsibleInfo dailyResponsible = new DailyResponsibleInfo();
            List<EamInsOrderDetailUserResponse> dailyUserResponses =
                    eamInspectionOrderMapper.findInspectionOrderDetailUserList(
                            eamInspectionOrderExport.getEquipmentCode(),
                            finalInspectionDate
                    );

            if (dailyUserResponses != null && !dailyUserResponses.isEmpty()) {
                dailyUserResponses.forEach(response -> {
                    try {
                        Date date = response.getInspectionDate();
                        if (date == null) return;

                        LocalDate localDate = date.toInstant()
                                .atZone(ZoneId.systemDefault())
                                .toLocalDate();

                        int day = localDate.getDayOfMonth();
                        if (day < 1 || day > 31) return;

                        // 获取操作员和确认人姓名
                        String operator = sysDictService.queryTableDictTextByKey(
                                "sys_user", "realname", "username", response.getOperator());
                        String confirmUser = sysDictService.queryTableDictTextByKey(
                                "sys_user", "realname", "username", response.getConfirmUser());

                        // 设置责任人信息
                        dailyResponsible.setResponsibleForDay(day, operator, confirmUser);
                    } catch (Exception e) {
                        log.error("处理日点检责任人信息出错: {}");
                    }
                });
            }
            eamInspectionOrderExport.setDailyResponsibleInfo(dailyResponsible);

            // ================== 添加周点检责任人信息 ==================
            WeeklyResponsibleInfo weeklyResponsible = new WeeklyResponsibleInfo();
            List<EamWeekInsDetailUserResponse> weeklyUserResponses =
                    eamInspectionOrderMapper.findWeekInsOrderDetailUserList(
                            eamInspectionOrderExport.getEquipmentCode(),
                            finalInspectionDate
                    );

            if (weeklyUserResponses != null && !weeklyUserResponses.isEmpty()) {
                weeklyUserResponses.forEach(response -> {
                    try {
                        Date date = response.getPlanInspectionDate();
                        if (date == null) return;

                        // 计算周数
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(date);
                        int week = calendar.get(Calendar.WEEK_OF_MONTH);
                        if (week < 1 || week > 5) return;

                        // 获取操作员和确认人姓名
                        String operator = sysDictService.queryTableDictTextByKey(
                                "sys_user", "realname", "username", response.getInspector());
                        String confirmUser = sysDictService.queryTableDictTextByKey(
                                "sys_user", "realname", "username", response.getConfirmUser());

                        // 设置责任人信息
                        weeklyResponsible.setResponsibleForWeek(week, operator, confirmUser);
                    } catch (Exception e) {
                        log.error("处理周点检责任人信息出错: {}");
                    }
                });
            }
            eamInspectionOrderExport.setWeeklyResponsibleInfo(weeklyResponsible);
        });

        return eamInspectionOrderExports;

    }

    /**
     * 计算日期在当月是第几周（1-5）
     */
    private int calculateWeekOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.WEEK_OF_MONTH);
    }

    private boolean isValidRequest(EamInspectionOrderRequest request) {
        return StrUtil.isNotBlank(request.getTaskId()) && StrUtil.isNotBlank(request.getDataId());
@@ -401,13 +1008,20 @@
        return true;
    }

    private void setupProcessVariables(EamInspectionOrderRequest request, EamInspectionOrder order, LoginUser user) {
    private void setupProcessVariables(EamInspectionOrderRequest request, EamInspectionOrder order, LoginUser user, EamEquipment equipment) {
        Map<String, Object> values = new HashMap<>();
        if (InspectionStatus.UNDER_INSPECTION.name().equals(order.getInspectionStatus()) && user.getUsername().equals(order.getOperator())) {
            // 点检人点检结束
            values.put("dataId", order.getId());
            values.put("organization", "点检人点检结束");
            values.put("comment", "点检人点检结束");
            // 获取下一步执行人
            List<UserSelector> userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getFactoryOrgCode(), BusinessCodeConst.PCR0002);
            if (CollectionUtil.isEmpty(userSelectors)) {
                throw new JeecgBootException("设备未分配给维修工，无法进入下级审批！");
            }
            List<String> userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
            values.put("NextAssignee", userApprovalList);
            request.setComment("点检人点检结束");
        } else {
            // 维修工确认
@@ -415,13 +1029,14 @@
            values.put("organization", request.getConfirmComment());
            values.put("comment", request.getConfirmComment());
            values.put("confirmation", request.getConfirmDealType());
            request.setComment(request.getConfirmComment());
            request.setComment("维修工确认结束");
            if ("2".equals(request.getConfirmDealType())) {
                // 维修工驳回
                List<String> usernames = new ArrayList<>();
                usernames.add(order.getOperator());
                order.setInspectionStatus(InspectionStatus.UNDER_INSPECTION.name());
                values.put("NextAssignee", usernames);
                request.setComment("维修工驳回结束");
            }
        }
        request.setValues(values);
@@ -436,10 +1051,17 @@
                eamInspectionOrderDetailService.remove(new QueryWrapper<EamInspectionOrderDetail>().eq("order_id", order.getId()));
                eamInspectionOrderDetailService.saveBatch(request.getTableDetailList());

                //设置周点检
                if (request.getTableWeekDetailList() != null && !request.getTableWeekDetailList().isEmpty()) {
                    // 设置周点检
//                eamWeekInspectionDetailService.remove(new QueryWrapper<EamWeekInspectionDetail>().eq("order_id", order.getId()));
                    eamWeekInspectionDetailService.saveOrUpdateBatch(request.getTableWeekDetailList());
                    List<EamWeekInspectionDetail> tableWeekDetailList = request.getTableWeekDetailList();
                    for (EamWeekInspectionDetail eamWeekInspectionDetail : tableWeekDetailList) {
                        if (StringUtils.isEmpty(eamWeekInspectionDetail.getInspectionResult())) {
                            break;
                        }
                        eamWeekInspectionDetail.setInspector(user.getUsername());
                        eamWeekInspectionDetail.setInspectTime(new Date());
                    }
                    eamWeekInspectionDetailService.saveOrUpdateBatch(tableWeekDetailList);
                }
            } else if (InspectionStatus.WAIT_CONFIRM.name().equals(order.getInspectionStatus()) && StrUtil.isNotEmpty(request.getConfirmDealType())) {
                // 班组长确认任务
@@ -463,8 +1085,10 @@
     */
    private void updateEamInspectionOrderDetail(EamInspectionOrder eamInspectionOrder) {
        List<EamInspectionOrderDetail> eamInspectionOrderDetails = eamInspectionOrderDetailService
                .list(new QueryWrapper<EamInspectionOrderDetail>()
                        .eq("order_id", eamInspectionOrder.getId()).eq("report_flag", "1").eq("inspection_result", "2"));
                .list(new LambdaQueryWrapper<EamInspectionOrderDetail>()
                        .eq(EamInspectionOrderDetail::getOrderId, eamInspectionOrder.getId()).eq(EamInspectionOrderDetail::getReportFlag, "1"));

        // TODO 点检完成后自动保修
        eamReportRepairService.reportRepairFromInspection(eamInspectionOrder.getEquipmentId(), eamInspectionOrder.getOperator(), eamInspectionOrderDetails);
    }

@@ -543,18 +1167,4 @@
        return (List<String>) object;
    }

    @Override
    public List<InspectionVo> findInspectionResult(String equipmentId, String itemDemand, String yearMonth) {
        return this.baseMapper.findInspectionResult(equipmentId, itemDemand, yearMonth);
    }

    @Override
    public List<InspectionVo> findInspectionUser(String equipmentId, String yearMonth) {
        return this.baseMapper.findInspectionUser(equipmentId, yearMonth);
    }

    @Override
    public List<Map<String, Object>> findInspectionStandard(String equipmentId) {
        return this.baseMapper.findInspectionStandard(equipmentId);
    }
}