drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/controller/GdClueEventController.java

@@ -16,6 +16,7 @@
 */
package org.sxkj.gd.workorder.controller;

import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
@@ -23,6 +24,7 @@
import lombok.AllArgsConstructor;
import javax.validation.Valid;

import lombok.extern.slf4j.Slf4j;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
@@ -52,6 +54,7 @@
 * @author lw
 * @since 2026-01-14
 */
@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("workOrder/gdClueEvent")
@@ -143,6 +146,7 @@
    @ApiOperationSupport(order = 6)
    @ApiOperation(value = "新增或修改", notes = "传入gdClueEvent")
    public R submitExternal(@Valid @RequestBody GdClueEventEntity gdClueEvent) {
        log.info("submitExternal-gdClueEvent:{}", JSON.toJSONString(gdClueEvent));
        return R.status(gdClueEventService.saveOrUpdateExternal(gdClueEvent));
    }


 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/enums/PatrolTaskStatusEnum.java

@@ -16,48 +16,57 @@

    /**
     * 待签收
     * 对应主任务状态：发布中_接单中(10)
     */
    PENDING_SIGNING("0", "待签收","巡检任务拆分"),
    PENDING_SIGNING("0", "待签收", "巡检任务拆分", 0, false, WorkOrderStatusEnum.PUBLISHING_ACCEPTING),

    /**
     * 拒绝签收
     * 拒绝签收（忽略）
     * 该状态不计入主任务状态计算
     */
    REJECTED_SIGNING("1", "拒绝签收","拒绝签收"),
    REJECTED_SIGNING("1", "拒绝签收", "拒绝签收", 1, true, null),

    /**
     * 已撤回
     * 已撤回（忽略）
     * 该状态不计入主任务状态计算
     */
    WITHDRAWN("2", "已撤回","任务撤回"),
    WITHDRAWN("2", "已撤回", "任务撤回", 2, true, null),

    /**
     * 待审核
     * 对应主任务状态：响应中_待拆分(20)
     */
    PENDING_AUDIT("3", "待审核","待签收"),
    PENDING_AUDIT("3", "待审核", "待签收", 3, false, WorkOrderStatusEnum.RESPONDING_TO_BE_SPLIT),

    /**
     * 审核驳回
     * 对应主任务状态：响应中_申请修改(22)
     */
    AUDIT_REJECTED("4", "审核驳回","审核驳回"),
    AUDIT_REJECTED("4", "审核驳回", "审核驳回", 4, false, WorkOrderStatusEnum.RESPONDING_APPLY_MODIFY),

    /**
     * 审核通过
     * 对应主任务状态：执行中_待全部完成(30)
     */
    AUDIT_PASSED("5", "审核通过","审核通过"),
    AUDIT_PASSED("5", "审核通过", "审核通过", 5, false, WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED),

    /**
     * 待验收
     * 对应主任务状态：完成待验_待全部验收(40)
     */
    PENDING_ACCEPTANCE("6", "待验收","待验收"),
    PENDING_ACCEPTANCE("6", "待验收", "待验收", 6, false, WorkOrderStatusEnum.COMPLETED_TO_BE_INSPECTED),

    /**
     * 拒绝验收
     * 拒绝验收（忽略）
     * 该状态不计入主任务状态计算
     */
    REJECTED_ACCEPTANCE("7", "拒绝验收","拒绝验收"),
    REJECTED_ACCEPTANCE("7", "拒绝验收", "拒绝验收", 7, true, null),

    /**
     * 验收通过
     * 对应主任务状态：验收通过_待结算(50)
     */
    ACCEPTANCE_PASSED("8", "验收通过","验收通过");
    ACCEPTANCE_PASSED("8", "验收通过", "验收通过", 8, false, WorkOrderStatusEnum.ACCEPTED_TO_BE_SETTLED);

    /**
     * 枚举值，对应数据库存储值
@@ -77,16 +86,59 @@
    @JsonValue
    private final String stageDesc;

    /**
     * 进度权重（数字越大进度越快）
     * 用于状态聚合时计算最小进度
     */
    private final int weight;

    /**
     * 是否应该忽略该状态
     * 拒绝签收、已撤回、拒绝验收的状态应该被忽略
     */
    private final boolean shouldIgnore;

    /**
     * 对应的主任务状态
     * 忽略状态对应null
     */
    private final WorkOrderStatusEnum workOrderStatusMapping;

    PatrolTaskStatusEnum(String stageDesc) {
        this.value = "";
        this.desc = "";
        this.stageDesc = stageDesc;
        this.weight = 0;
        this.shouldIgnore = false;
        this.workOrderStatusMapping = null;
    }

    PatrolTaskStatusEnum(String value, String desc, String stageDesc) {
        this.value = value;
        this.desc = desc;
        this.stageDesc = stageDesc;
        this.weight = 0;
        this.shouldIgnore = false;
        this.workOrderStatusMapping = null;
    }

    /**
     * 完整构造函数
     *
     * @param value 枚举值，对应数据库存储值
     * @param desc 枚举描述，用于展示
     * @param stageDesc 工单阶段描述
     * @param weight 进度权重（数字越大进度越快）
     * @param shouldIgnore 是否应该忽略该状态
     * @param workOrderStatusMapping 对应的主任务状态
     */
    PatrolTaskStatusEnum(String value, String desc, String stageDesc, int weight, boolean shouldIgnore, WorkOrderStatusEnum workOrderStatusMapping) {
        this.value = value;
        this.desc = desc;
        this.stageDesc = stageDesc;
        this.weight = weight;
        this.shouldIgnore = shouldIgnore;
        this.workOrderStatusMapping = workOrderStatusMapping;
    }

    /**

 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/service/impl/GdPatrolTaskServiceImpl.java

@@ -57,6 +57,7 @@
import org.sxkj.gd.workorder.service.IGdTaskResultService;
import org.sxkj.gd.workorder.service.IGdWorkOrderFlowService;
import org.sxkj.gd.workorder.utils.GdPatrolReportWordUtil;
import org.sxkj.gd.workorder.utils.WorkOrderStatusAggregator;
import org.sxkj.gd.workorder.vo.GdPatrolTaskSimpleVO;
import org.sxkj.gd.workorder.vo.GdPatrolTaskVO;
import org.sxkj.gd.xingtu.JianXingtuApiService;
@@ -103,7 +104,7 @@
    @Override
    public IPage<GdPatrolTaskVO> selectGdPatrolTaskPage(IPage<GdPatrolTaskVO> page, GdPatrolTaskPageParam gdPatrolTask) {
        List<Long> deptList = new ArrayList<>();
        if (!AuthUtil.isAdministrator() || !AuthUtil.isAdmin()) {
        if (!(AuthUtil.isAdministrator() || AuthUtil.isAdmin())) {
            deptList = SysCache.getDeptChildIds(Long.valueOf(StringUtil.isBlank(AuthUtil.getDeptId()) ? "0" : AuthUtil.getDeptId()));
        }
        gdPatrolTask.setDeptList(deptList);
@@ -277,19 +278,15 @@
            }
        }
        if (auditStatus == 3) {
            // 撤回任务操作：查询同一个工单下的所有子任务
            // 撤回任务操作：使用状态聚合工具类计算主任务状态
            List<GdPatrolTaskEntity> subTasks = list(Wrappers.<GdPatrolTaskEntity>lambdaQuery()
                .eq(GdPatrolTaskEntity::getWorkOrderId, task.getWorkOrderId()));

            // 检查是否所有子任务都已撤回
            boolean allSubTasksWithdrawn = subTasks.stream()
                .allMatch(item -> item.getTaskStatus().equals(PatrolTaskStatusEnum.WITHDRAWN.getValue()));

            // 如果所有子任务都已撤回，则将工单状态更新为"接单响应_已取消"
            if (allSubTasksWithdrawn) {
                return updateWorkOrderStatusAndFlow(task.getWorkOrderId(),
                    WorkOrderStatusEnum.RESPONDING_CANCELED);
            }
            // 使用状态聚合工具类计算主任务状态
            WorkOrderStatusEnum newWorkOrderStatus = WorkOrderStatusAggregator.aggregateWorkOrderStatus(subTasks);
			
            // 更新主任务状态
            updateWorkOrderStatusAndFlow(task.getWorkOrderId(), newWorkOrderStatus);
        }
        // 7. 验收拒绝
        if (auditStatus == 7) {

 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/service/impl/GdWorkOrderServiceImpl.java

@@ -61,7 +61,7 @@
    public IPage<GdWorkOrderVO> selectGdWorkOrderPage(IPage<GdWorkOrderVO> page, WorkOrderPageParam gdWorkOrder) {
        if (gdWorkOrder.getIsQueryAll()) {
            List<Long> deptList = new ArrayList<>();
            if (!AuthUtil.isAdministrator() || !AuthUtil.isAdmin()) {
            if (!(AuthUtil.isAdministrator() || AuthUtil.isAdmin())) {
                deptList = SysCache.getDeptChildIds(Long.valueOf(AuthUtil.getDeptId()));
            }
            gdWorkOrder.setDeptList(deptList);

 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/utils/WorkOrderStatusAggregator.java

New file
@@ -0,0 +1,69 @@
package org.sxkj.gd.workorder.utils;

import lombok.extern.slf4j.Slf4j;
import org.sxkj.gd.workorder.entity.GdPatrolTaskEntity;
import org.sxkj.gd.workorder.enums.PatrolTaskStatusEnum;
import org.sxkj.gd.workorder.enums.WorkOrderStatusEnum;

import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * 工单状态聚合工具类
 * 用于根据子任务状态计算主任务状态
 *
 * @author lw
 * @since 2026-06-26
 */
@Slf4j
public class WorkOrderStatusAggregator {

    /**
     * 根据子任务列表聚合计算主任务状态
     *
     * @param subTasks 子任务列表
     * @return 主任务状态，如果没有有效子任务则返回"接单响应_已取消"
     */
    public static WorkOrderStatusEnum aggregateWorkOrderStatus(List<GdPatrolTaskEntity> subTasks) {
        // 1. 参数校验：防止空指针
        if (subTasks == null || subTasks.isEmpty()) {
            log.warn("子任务列表为空，返回默认状态：接单响应_已取消");
            return WorkOrderStatusEnum.RESPONDING_CANCELED;
        }

        // 2. 过滤有效子任务（排除忽略状态）
        List<GdPatrolTaskEntity> validSubTasks = subTasks.stream()
            .filter(task -> task != null && task.getTaskStatus() != null)
            .filter(task -> {
                PatrolTaskStatusEnum statusEnum = PatrolTaskStatusEnum.getByValue(task.getTaskStatus());
                return statusEnum != null && !statusEnum.isShouldIgnore();
            })
            .collect(Collectors.toList());

        // 3. 如果没有有效子任务，返回"接单响应_已取消"
        if (validSubTasks.isEmpty()) {
            log.info("所有子任务都被撤回或拒绝，主任务状态：接单响应_已取消");
            return WorkOrderStatusEnum.RESPONDING_CANCELED;
        }

        // 4. 找到权重最小的有效子任务状态（进度最慢）
        Optional<PatrolTaskStatusEnum> minWeightStatus = validSubTasks.stream()
            .map(task -> PatrolTaskStatusEnum.getByValue(task.getTaskStatus()))
            .filter(Objects::nonNull)
            .min((s1, s2) -> Integer.compare(s1.getWeight(), s2.getWeight()));

        // 5. 如果找到最小权重状态，返回对应的主任务状态
        if (minWeightStatus.isPresent()) {
            WorkOrderStatusEnum workOrderStatus = minWeightStatus.get().getWorkOrderStatusMapping();
            log.info("最小进度子任务状态：{}，对应主任务状态：{}", 
                minWeightStatus.get().getDesc(), workOrderStatus.getDesc());
            return workOrderStatus;
        }

        // 6. 兜底逻辑：返回默认状态
        log.warn("无法找到有效的主任务状态映射，返回默认状态：接单响应_已取消");
        return WorkOrderStatusEnum.RESPONDING_CANCELED;
    }
}