工单调整

linwei

2026-01-20 48c703eebe54947ca7232d68b2851d5da57b578f

工单调整

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

@@ -34,9 +34,12 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.sxkj.gd.workorder.entity.GdPatrolTaskEntity;
import org.sxkj.gd.workorder.entity.GdWorkOrderEntity;
import org.sxkj.gd.workorder.param.GdPatrolTaskAddParam;
import org.sxkj.gd.workorder.param.GdPatrolTaskAuditParam;
import org.sxkj.gd.workorder.param.GdPatrolTaskPageParam;
import org.sxkj.gd.workorder.param.GdPatrolTaskUpdateParam;
import org.sxkj.gd.workorder.vo.GdClueEventVO;
import org.sxkj.gd.workorder.vo.GdPatrolTaskVO;
import org.sxkj.gd.workorder.excel.GdPatrolTaskExcel;
import org.sxkj.gd.workorder.wrapper.GdPatrolTaskWrapper;
@@ -156,6 +159,7 @@
    @GetMapping("/export-gdPatrolTask")
    @ApiOperationSupport(order = 9)
    @ApiOperation(value = "导出数据", notes = "传入gdPatrolTask")
    @ApiIgnore
    public void exportGdPatrolTask(@ApiIgnore @RequestParam Map<String, Object> gdPatrolTask, BladeUser bladeUser, HttpServletResponse response) {
        QueryWrapper<GdPatrolTaskEntity> queryWrapper = Condition.getQueryWrapper(gdPatrolTask, GdPatrolTaskEntity.class);
        //if (!AuthUtil.isAdministrator()) {
@@ -177,4 +181,16 @@
        return R.status(result);
    }

    /**
     * 更新单个巡查任务信息
     */
    @PostMapping("/republish")
    @ApiOperationSupport(order = 11)
    @ApiOperation(value = "更新单个巡查任务信息", notes = "传入巡查任务信息")
    public R republish(@Valid @RequestBody GdPatrolTaskUpdateParam gdPatrolTask) {
         GdPatrolTaskEntity gdPatrolTaskEntity = Objects.requireNonNull(BeanUtil.copy(gdPatrolTask, GdPatrolTaskEntity.class));
        boolean result = gdPatrolTaskService.republishPatrolTask(gdPatrolTaskEntity);
        return R.status(result);
    }

}

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

@@ -16,90 +16,108 @@
@AllArgsConstructor
public enum PatrolTaskStatusEnum {

    /**
     * 待签收
     */
    PENDING_SIGNING("0", "待签收"),
    /**
     * 待签收
     */
    PENDING_SIGNING("0", "待签收"),

    /**
     * 拒绝签收
     */
    REJECTED_SIGNING("1", "拒绝签收"),
    /**
     * 拒绝签收
     */
    REJECTED_SIGNING("1", "拒绝签收"),

    /**
     * 已撤回
     */
    WITHDRAWN("2", "已撤回"),
    /**
     * 已撤回
     */
    WITHDRAWN("2", "已撤回"),

    /**
     * 待审核
     */
    PENDING_AUDIT("3", "待审核"),
    /**
     * 待审核
     */
    PENDING_AUDIT("3", "待审核"),

    /**
     * 审核驳回
     */
    AUDIT_REJECTED("4", "审核驳回"),
    /**
     * 审核驳回
     */
    AUDIT_REJECTED("4", "审核驳回"),

    /**
     * 审核通过
     */
    AUDIT_PASSED("5", "审核通过"),
    /**
     * 审核通过
     */
    AUDIT_PASSED("5", "审核通过"),

    /**
     * 待验收
     */
    PENDING_ACCEPTANCE("6", "待验收"),
    /**
     * 待验收
     */
    PENDING_ACCEPTANCE("6", "待验收"),

    /**
     * 拒绝验收
     */
    REJECTED_ACCEPTANCE("7", "拒绝验收"),
    /**
     * 拒绝验收
     */
    REJECTED_ACCEPTANCE("7", "拒绝验收"),

    /**
     * 验收通过
     */
    ACCEPTANCE_PASSED("8", "验收通过");
    /**
     * 验收通过
     */
    ACCEPTANCE_PASSED("8", "验收通过");

    /**
     * 枚举值，对应数据库存储值
     */
    @EnumValue
    private final String value;
    /**
     * 枚举值，对应数据库存储值
     */
    @EnumValue
    private final String value;

    /**
     * 枚举描述，用于展示
     */
    @JsonValue
    private final String desc;
    /**
     * 枚举描述，用于展示
     */
    @JsonValue
    private final String desc;

    /**
     * 根据值获取对应的枚举
     *
     * @param value 枚举值
     * @return 对应的枚举，如果未找到则返回null
     */
    public static PatrolTaskStatusEnum getByValue(String value) {
        for (PatrolTaskStatusEnum status : values()) {
            if (status.getValue().equals(value)) {
                return status;
            }
        }
        return null;
    }
    /**
     * 根据值获取对应的枚举
     *
     * @param value 枚举值
     * @return 对应的枚举，如果未找到则返回null
     */
    public static PatrolTaskStatusEnum getByValue(String value) {
        for (PatrolTaskStatusEnum status : values()) {
            if (status.getValue().equals(value)) {
                return status;
            }
        }
        return null;
    }

    /**
     * 判断值是否为有效的巡查任务状态
     *
     * @param value 待验证的值
     * @return 是否有效
     */
    public static boolean isValidValue(String value) {
        return getByValue(value) != null;
    }
    /**
     * 检查当前状态是否允许转换到目标状态
     *
     * @param targetStatus 审核状态：1.同意签收、2.拒绝签收 、3.撤回任务 、4.同意审核、 5.拒绝审核、 6.验收通过、 7.验收拒绝"
     * @return 是否允许转换
     */
    public boolean isAllowedTransition(Integer targetStatus) {
        if (targetStatus == null) {
            return false;
        }
        switch (this) {
            case PENDING_SIGNING:
                // 待签收状态允许转换到：拒绝签收、待审核
                return targetStatus == 1 || targetStatus == 2;
            case PENDING_AUDIT:
                // 待审核状态允许转换到：审核通过、审核驳回
                return targetStatus == 3 || targetStatus == 4 || targetStatus == 5;
            case PENDING_ACCEPTANCE:
                // 待验收状态允许转换到：验收通过、拒绝验收
                return targetStatus == 6 || targetStatus == 7;
            default:
                // 其他状态不允许转换
                return false;
        }
    }


    /**
     * 检查当前状态是否允许指定的操作类型
     *
     * @param operationType 操作类型：1接单，2拒接接单，3申请取消，4申请修改，5同意取消，6不同意取消，7同意修改，8不同意修改
     * @return 是否允许操作
     */
@@ -114,13 +132,13 @@
                return operationType == 1 || operationType == 2;
            case REJECTED_SIGNING:
                // 响应中_待拆分状态允许：3申请取消，4申请修改
                return operationType == 3 || operationType == 4 ;
                return operationType == 3 || operationType == 4;
            case WITHDRAWN:
                // 响应中_申请取消状态允许：5同意取消，6不同意取消
                return operationType == 5 || operationType == 6;
            case PENDING_AUDIT:
                // 响应中_申请修改状态允许：7同意修改，8不同意修改
                return operationType ==7 || operationType == 8 ;
                return operationType == 7 || operationType == 8;
            case AUDIT_REJECTED:
                // 响应中_拒绝取消状态允许：3申请取消
                return operationType == 3;

 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/param/GdPatrolTaskAuditParam.java

@@ -20,7 +20,7 @@
     */
    @ApiModelProperty(value = "审核状态：1.同意签收、2.拒绝签收 、3.撤回任务 、4.同意审核、 5.拒绝审核、 6.验收通过、 7.验收拒绝", required = true)
    @NotNull(message = "审核状态不能为空")
    private String auditStatus;
    private Integer auditStatus;

    /**
     * 拒绝原因（审核拒绝时必填）

 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/param/GdPatrolTaskUpdateParam.java

New file
@@ -0,0 +1,72 @@
package org.sxkj.gd.workorder.param;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotNull;
import java.util.Date;

@Data
public class GdPatrolTaskUpdateParam {

    /**
     * 任务ID
     */
    @ApiModelProperty(value = "任务ID", required = true)
    @NotNull(message = "任务ID不能为空")
    private Long id;

    /**
     * 关联工单任务表ID
     */
    @ApiModelProperty(value = "关联工单任务表ID")
    private Long workOrderId;

    /**
     * 巡查任务编号
     */
    @ApiModelProperty(value = "巡查任务编号")
    private String taskNo;
    /**
     * 巡查任务名称
     */
    @ApiModelProperty(value = "巡查任务名称")
    private String patrolTaskName;
    /**
     * 巡查任务类型（巡查类/安检类等）
     */
    @ApiModelProperty(value = "巡查任务类型 1.巡查类 2.巡检类 3.安保类 4.文旅类 5.采集数据类 ")
    private String patrolTaskType;
    /**
     * 执行时间
     */
    @ApiModelProperty(value = "执行时间")
    private Date executeTime;
    /**
     * 巡查任务航线URL
     */
    @ApiModelProperty(value = "巡查任务航线URL")
    private String patrolRouteUrl;
    /**
     * 推荐飞手名称
     */
    @ApiModelProperty(value = "推荐飞手名称")
    private String recommendFlyerName;
    /**
     * 关联设备ID
     */
    @ApiModelProperty(value = "关联设备ID")
    private Long deviceId;
    /**
     * 任务描述
     */
    @ApiModelProperty(value = "任务描述")
    private String taskDesc;
    /**
     * 状态：0待签收、1拒绝签收、2已撤回、3待审核、4审核驳回、5审核通过、6待验收、7拒绝验收、8验收通过
     */
    @ApiModelProperty(value = "状态：0待签收、1拒绝签收、2已撤回、3待审核、4审核驳回、5审核通过、6待验收、7拒绝验收、8验收通过")
    private String taskStatus;


}

 drone-service/drone-gd/src/main/java/org/sxkj/gd/workorder/param/WorkOrderStatusParam.java

@@ -23,7 +23,7 @@
    /**
     * 操作类型：1接单，2拒接接单
     */
    @ApiModelProperty(value = "操作类型：1接单，2拒接接单，3申请取消，4申请修改， 5同意取消  6不同意取消 7.同意修改 8.不同意修改 ", required = true)
    @ApiModelProperty(value = "操作类型：1接单，2拒接接单，3申请取消，4申请修改， 5同意取消  6不同意取消 7.同意修改 8.不同意修改 9.协商修改 10.同意修改 ", required = true)
    @NotNull(message = "操作类型不能为空")
    private Integer operationType;


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

@@ -18,6 +18,7 @@

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import org.sxkj.gd.workorder.entity.GdPatrolTaskEntity;
import org.sxkj.gd.workorder.enums.PatrolTaskStatusEnum;
import org.sxkj.gd.workorder.param.GdPatrolTaskAuditParam;
import org.sxkj.gd.workorder.param.GdPatrolTaskPageParam;
import org.sxkj.gd.workorder.vo.GdPatrolTaskVO;
@@ -64,4 +65,12 @@
     * @return
     */
    boolean auditPatrolTask(GdPatrolTaskAuditParam auditParam);

    /**
     * 更新单个巡查任务信息
     * @param taskEntity 巡查任务实体
     * @return 更新后的任务状态枚举
     */
    boolean republishPatrolTask(GdPatrolTaskEntity taskEntity);

}

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

@@ -16,13 +16,16 @@
 */
package org.sxkj.gd.workorder.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.BeanUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.sxkj.common.constant.WordOrderConstant;
import org.sxkj.common.utils.OrderNumUtils;
import org.sxkj.gd.workorder.entity.GdPatrolTaskEntity;
import org.sxkj.gd.workorder.entity.GdWorkOrderEntity;
import org.sxkj.gd.workorder.entity.GdWorkOrderFlowEntity;
import org.sxkj.gd.workorder.enums.PatrolTaskStatusEnum;
import org.sxkj.gd.workorder.enums.WorkOrderStatusEnum;
@@ -30,6 +33,7 @@
import org.sxkj.gd.workorder.param.GdPatrolTaskAuditParam;
import org.sxkj.gd.workorder.param.GdPatrolTaskPageParam;
import org.sxkj.gd.workorder.service.IGdWorkOrderFlowService;
import org.sxkj.gd.workorder.service.IGdWorkOrderService;
import org.sxkj.gd.workorder.vo.GdPatrolTaskVO;
import org.sxkj.gd.workorder.excel.GdPatrolTaskExcel;
import org.sxkj.gd.workorder.mapper.GdPatrolTaskMapper;
@@ -53,6 +57,9 @@

    @Autowired
    private IGdWorkOrderFlowService gdWorkOrderFlowService;

    @Autowired
    private IGdWorkOrderService gdWorkOrderService;

    @Override
    public IPage<GdPatrolTaskVO> selectGdPatrolTaskPage(IPage<GdPatrolTaskVO> page, GdPatrolTaskPageParam gdPatrolTask, List<Long> deptIdList) {
@@ -80,6 +87,10 @@
                String timestamp = OrderNumUtils.initOrderNum(WordOrderConstant.PATROL_TASK_KEY);
                gdPatrolTaskEntity.setTaskNo(WordOrderConstant.PATROL_TASK_PREFIX + timestamp);
            }

            // 设置初始状态为待签收（对应流程图：等待接单）
            gdPatrolTaskEntity.setTaskStatus(PatrolTaskStatusEnum.PENDING_SIGNING.getValue());

            // 保存巡逻任务
            boolean save = save(gdPatrolTaskEntity);
            if (!save) {
@@ -87,12 +98,12 @@
                throw new RuntimeException("保存巡逻任务失败：" + gdPatrolTaskEntity.toString());
            }

            // 保存流转记录
            // 保存流转记录（发布任务，等待接单）
            GdWorkOrderFlowEntity gdWorkOrderFlowEntity = new GdWorkOrderFlowEntity();
            gdWorkOrderFlowEntity.setCreateUser(AuthUtil.getUserId());
            gdWorkOrderFlowEntity.setWorkOrderId(gdPatrolTaskEntity.getId());
            gdWorkOrderFlowEntity.setFlowName(PatrolTaskStatusEnum.PENDING_SIGNING.getDesc());
            gdWorkOrderFlowEntity.setFlowDesc(AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
            gdWorkOrderFlowEntity.setFlowName("任务发布");
            gdWorkOrderFlowEntity.setFlowDesc(AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " 发布任务，等待接单");
            gdWorkOrderFlowEntity.setOperator(AuthUtil.getUserName());
            gdWorkOrderFlowEntity.setType(WorkOrderTypeEnum.PATROL_TASK.getValue());
            gdWorkOrderFlowEntity.setAreaCode(gdPatrolTaskEntity.getAreaCode());
@@ -108,118 +119,296 @@
        return true;
    }

    /**
     * 审核巡查任务
     *
     * @param auditParam 审核参数，包含任务ID、审核状态和拒绝原因
     * @return 是否审核成功
     * @throws RuntimeException 当任务不存在、状态不允许转换或操作失败时抛出
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean auditPatrolTask(GdPatrolTaskAuditParam auditParam) {
        Long id = auditParam.getId();
        String auditStatus = auditParam.getAuditStatus();
        String rejectReason = auditParam.getRejectReason();
        // 1. 获取巡查任务
        GdPatrolTaskEntity task = getById(id);
        GdPatrolTaskEntity task = getById(auditParam.getId());
        if (task == null) {
            throw new RuntimeException("巡查任务不存在");
        }

        // 2. 检查任务状态是否为待审核
        if (!PatrolTaskStatusEnum.PENDING_AUDIT.getValue().equals(task.getTaskStatus().toString())) {
            throw new RuntimeException("任务当前状态无法审核");
        // 2. 状态权限校验
        PatrolTaskStatusEnum currentStatus = PatrolTaskStatusEnum.getByValue(task.getTaskStatus());
        Integer auditStatus = auditParam.getAuditStatus();
        if (currentStatus == null ||  !currentStatus.isAllowedTransition(auditStatus)) {
            throw new RuntimeException("当前任务状态无法进行该操作");
        }

        // 3. 如果审核拒绝，检查拒绝原因是否为空
        if (PatrolTaskStatusEnum.REJECTED_SIGNING.getValue().equals(auditStatus) && (rejectReason == null || rejectReason.trim().isEmpty())) {
            throw new RuntimeException("拒绝签收时必须填写拒绝原因");
        }

        // 4. 检查其他需要拒绝原因的状态
        if ((PatrolTaskStatusEnum.AUDIT_REJECTED.getValue().equals(auditStatus) || PatrolTaskStatusEnum.REJECTED_ACCEPTANCE.getValue().equals(auditStatus)) && (rejectReason == null || rejectReason.trim().isEmpty())) {
            throw new RuntimeException("审核驳回或拒绝验收时必须填写拒绝原因");
        // 1.同意签收、2.拒绝签收 、3.撤回任务 、4.同意审核、 5.拒绝审核、 6.验收通过、 7.验收拒绝
        // 3. 确定新状态和流转名称
        PatrolTaskStatusEnum newStatusEnum;
        switch (auditStatus) {
            case 1: // 接单
                newStatusEnum = PatrolTaskStatusEnum.PENDING_AUDIT;
                break;
            case 2: // 拒接接单
                newStatusEnum = PatrolTaskStatusEnum.REJECTED_SIGNING;
                break;
            case 3: // 撤回任务
                newStatusEnum = PatrolTaskStatusEnum.WITHDRAWN;
                break;
            case 4: // 同意审核
                newStatusEnum = PatrolTaskStatusEnum.AUDIT_PASSED;
                break;
            case 5: // 拒绝审核
                newStatusEnum = PatrolTaskStatusEnum.AUDIT_REJECTED;
                break;
            case 6: // 验收通过
                newStatusEnum = PatrolTaskStatusEnum.ACCEPTANCE_PASSED;
                break;
            case 7: // 验收拒绝
                newStatusEnum = PatrolTaskStatusEnum.REJECTED_ACCEPTANCE;
                break;
            default: // 无效操作类型
                return false;
        }

        // 4. 更新任务状态
        task.setTaskStatus(auditStatus);
        Date now = new Date();
        task.setTaskStatus(newStatusEnum.getValue());
        task.setUpdateUser(AuthUtil.getUserId());
        task.setUpdateTime(now);
        boolean updateResult = updateById(task);
        if (!updateResult) {
            throw new RuntimeException("更新任务状态失败");
        }

        // 5. 保存流转记录
        GdWorkOrderFlowEntity flowEntity = new GdWorkOrderFlowEntity();
        flowEntity.setCreateUser(AuthUtil.getUserId());
        flowEntity.setWorkOrderId(id);
        boolean b = saveWorkOrderFlow(task.getId(), newStatusEnum, auditParam.getRejectReason(), task.getAreaCode());
        // 6. 判断是否审核成功，如果是，需要判断是否整个订单的子任务都审核成功了，除了被撤回和验收拒绝的
        if (auditStatus == 4) {
            // 查询同一个工单下的所有子任务
            List<GdPatrolTaskEntity> subTasks = list(Wrappers.<GdPatrolTaskEntity>lambdaQuery()
                    .eq(GdPatrolTaskEntity::getWorkOrderId, task.getWorkOrderId()));

        // 设置流转名称和描述
        String[] flowInfo = buildFlowInfo(auditStatus, rejectReason);
        String flowName = flowInfo[0];
        String flowDesc = AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss") + flowInfo[1];

        flowEntity.setFlowName(flowName);
        flowEntity.setFlowDesc(flowDesc);
        flowEntity.setOperator(AuthUtil.getUserName());
        flowEntity.setType(WorkOrderTypeEnum.PATROL_TASK.getValue());
        flowEntity.setAreaCode(task.getAreaCode());
        flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));

        boolean saveFlowResult = gdWorkOrderFlowService.save(flowEntity);
        if (!saveFlowResult) {
            throw new RuntimeException("保存流转记录失败");
            // 检查是否所有子任务都审核成功（除了被撤回和验收拒绝的）
            boolean allSubTasksAudited = checkAllSubTasksAudited(subTasks);
            // 这里可以根据allSubTasksAudited的结果执行后续逻辑，比如更新工单状态等
            // 示例：如果所有子任务都审核成功，可以更新工单状态为已完成
            if (allSubTasksAudited) {
                // 执行工单状态更新逻辑
                // 注意：需要注入工单相关的Service才能执行更新
                GdWorkOrderEntity gdWorkOrderEntity = new GdWorkOrderEntity();
                gdWorkOrderEntity.setId(task.getWorkOrderId());
                gdWorkOrderEntity.setWorkOrderStatus(WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED.getCode());
                boolean b1 = gdWorkOrderService.updateById(gdWorkOrderEntity);
                if (b1) {
                     // 6. 保存流转记录：使用枚举设置flowName
                    GdWorkOrderFlowEntity flowEntity = new GdWorkOrderFlowEntity();
                    flowEntity.setCreateUser(AuthUtil.getUserId());
                    flowEntity.setWorkOrderId(task.getWorkOrderId());
                    flowEntity.setFlowName(WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED.getDesc());
                    flowEntity.setFlowDesc(AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " 更新了任务信息，状态转换为：" + WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED.getDesc());
                    flowEntity.setOperator(AuthUtil.getUserName());
                    flowEntity.setType(WorkOrderTypeEnum.PATROL_TASK.getValue());
                    flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));
                    return gdWorkOrderFlowService.save(flowEntity);
                }
            }
        }
        // 7. 验收拒绝
        if (auditStatus == 7) {
            GdWorkOrderEntity gdWorkOrderEntity = new GdWorkOrderEntity();
            gdWorkOrderEntity.setId(task.getWorkOrderId());
            gdWorkOrderEntity.setWorkOrderStatus(WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED.getCode());
            boolean b1 = gdWorkOrderService.updateById(gdWorkOrderEntity);
            if (b1) {
                // 6. 保存流转记录：使用枚举设置flowName
                GdWorkOrderFlowEntity flowEntity = new GdWorkOrderFlowEntity();
                flowEntity.setCreateUser(AuthUtil.getUserId());
                flowEntity.setWorkOrderId(task.getWorkOrderId());
                flowEntity.setFlowName(WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED.getDesc());
                flowEntity.setFlowDesc(AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " 更新了任务信息，状态转换为：" + WorkOrderStatusEnum.EXECUTING_TO_BE_COMPLETED.getDesc());
                flowEntity.setOperator(AuthUtil.getUserName());
                flowEntity.setType(WorkOrderTypeEnum.PATROL_TASK.getValue());
                flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));
                return gdWorkOrderFlowService.save(flowEntity);
            }
        }
        return b;
    }


    /**
     * 检查是否所有子任务都审核成功（除了被撤回和验收拒绝的）
     *
     * @param subTasks 子任务列表
     * @return 是否所有子任务都审核成功
     */
    private boolean checkAllSubTasksAudited(List<GdPatrolTaskEntity> subTasks) {
        for (GdPatrolTaskEntity subTask : subTasks) {
            String taskStatus = subTask.getTaskStatus();
            PatrolTaskStatusEnum statusEnum = PatrolTaskStatusEnum.getByValue(taskStatus);

            // 如果任务状态不是审核成功状态，且不是被撤回和验收拒绝的，则返回false
            if (!isTaskAuditSuccess(statusEnum) &&
                statusEnum != PatrolTaskStatusEnum.WITHDRAWN &&
                statusEnum != PatrolTaskStatusEnum.REJECTED_ACCEPTANCE) {
                return false;
            }
        }
        return true;
    }

    /**
     * 构建流转信息
     * @param status 状态值
     * @param rejectReason 拒绝原因
     * @return 包含流转名称和描述的数组 [flowName, flowDescSuffix]
     * 判断单个任务是否审核成功
     *
     * @param statusEnum 任务状态枚举
     * @return 是否审核成功
     */
    private String[] buildFlowInfo(String status, String rejectReason) {
        String flowName;
        String flowDescSuffix;
    private boolean isTaskAuditSuccess(PatrolTaskStatusEnum statusEnum) {
        // 审核成功的任务状态包括：审核通过
        return  statusEnum == PatrolTaskStatusEnum.AUDIT_PASSED  ;
    }

        switch (status) {
            case "0":
                flowName = PatrolTaskStatusEnum.PENDING_SIGNING.getDesc();
                flowDescSuffix = " 待签收";
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean republishPatrolTask(GdPatrolTaskEntity taskEntity) {
        if (taskEntity == null || taskEntity.getId() == null) {
            throw new RuntimeException("任务信息或ID不能为空");
        }

        // 1. 验证任务是否存在
        GdPatrolTaskEntity existingTask = getById(taskEntity.getId());
        taskEntity.setId(existingTask.getId());
        if (existingTask == null) {
            throw new RuntimeException("巡查任务不存在");
        }

        // 2. 先确定枚举状态：根据当前状态确定新的枚举状态
        PatrolTaskStatusEnum targetStatus;
        String currentStatus = existingTask.getTaskStatus();
        // 1.发布中_拒绝接单 、 4.响应中_审核驳回
        switch (currentStatus) {
            case "1": // 发布中_拒绝接单 → 发布中_接单中
                targetStatus = PatrolTaskStatusEnum.PENDING_SIGNING;
                break;
            case "1":
                flowName = PatrolTaskStatusEnum.REJECTED_SIGNING.getDesc();
                flowDescSuffix = " 拒绝签收：" + rejectReason;
                break;
            case "2":
                flowName = PatrolTaskStatusEnum.WITHDRAWN.getDesc();
                flowDescSuffix = " 已撤回";
                break;
            case "3":
                flowName = PatrolTaskStatusEnum.PENDING_AUDIT.getDesc();
                flowDescSuffix = " 待审核";
                break;
            case "4":
                flowName = PatrolTaskStatusEnum.AUDIT_REJECTED.getDesc();
                flowDescSuffix = " 审核驳回：" + rejectReason;
                break;
            case "5":
                flowName = PatrolTaskStatusEnum.AUDIT_PASSED.getDesc();
                flowDescSuffix = " 审核通过";
                break;
            case "6":
                flowName = PatrolTaskStatusEnum.PENDING_ACCEPTANCE.getDesc();
                flowDescSuffix = " 待验收";
                break;
            case "7":
                flowName = PatrolTaskStatusEnum.REJECTED_ACCEPTANCE.getDesc();
                flowDescSuffix = " 拒绝验收：" + rejectReason;
                break;
            case "8":
                flowName = PatrolTaskStatusEnum.ACCEPTANCE_PASSED.getDesc();
                flowDescSuffix = " 验收通过";
            case "4": // 响应中_审核驳回 → 响应中_待审核
                targetStatus = PatrolTaskStatusEnum.PENDING_AUDIT;
                break;
            default:
                flowName = "未知状态";
                flowDescSuffix = " 未知状态";
                // 其他状态，保持原有状态
                targetStatus = PatrolTaskStatusEnum.getByValue(currentStatus);
                // 如果无法获取枚举，使用待签收作为默认状态
                if (targetStatus == null) {
                    targetStatus = PatrolTaskStatusEnum.PENDING_SIGNING;
                }
                break;
        }

        return new String[]{flowName, flowDescSuffix};
        // 3. 设置任务状态：使用枚举设置任务状态
        taskEntity.setTaskStatus(targetStatus.getValue());

        // 4. 更新任务信息：合并传入的任务信息
        taskEntity.setUpdateUser(AuthUtil.getUserId());
        taskEntity.setUpdateTime(new Date());

        // 5. 更新数据库
        boolean updateResult = updateById(taskEntity);
        if (!updateResult) {
            throw new RuntimeException("更新任务信息失败");
        }

        // 6. 保存流转记录：使用枚举设置flowName
        GdWorkOrderFlowEntity flowEntity = new GdWorkOrderFlowEntity();
        flowEntity.setCreateUser(AuthUtil.getUserId());
        flowEntity.setWorkOrderId(taskEntity.getId());
        flowEntity.setFlowName(targetStatus.getDesc());
        flowEntity.setFlowDesc(AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " 更新了任务信息，状态转换为：" + targetStatus.getDesc());
        flowEntity.setOperator(AuthUtil.getUserName());
        flowEntity.setType(WorkOrderTypeEnum.PATROL_TASK.getValue());
        flowEntity.setAreaCode(existingTask.getAreaCode());
        flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));

        return gdWorkOrderFlowService.save(flowEntity);
    }


    /**
     * 检查拒绝原因是否必填
     *
     * @param newStatus     新状态
     * @param rejectReason  拒绝原因
     * @throws RuntimeException 当需要拒绝原因但未提供时抛出
     */
    // private void checkRejectReason(PatrolTaskStatusEnum newStatus, String rejectReason) {
    //     // 拒绝类状态需要填写拒绝原因
    //     if ((newStatus == PatrolTaskStatusEnum.REJECTED_SIGNING ||
    //          newStatus == PatrolTaskStatusEnum.AUDIT_REJECTED ||
    //          newStatus == PatrolTaskStatusEnum.REJECTED_ACCEPTANCE) &&
    //         (rejectReason == null || rejectReason.trim().isEmpty())) {
    //         throw new RuntimeException("拒绝操作时必须填写拒绝原因");
    //     }
    // }

    /**
     * 保存工单流转记录
     *
     * @param workOrderId   工单ID
     * @param newStatus     新状态
     * @param rejectReason  拒绝原因
     * @param areaCode      区域编码
     * @return 是否保存成功
     * @throws RuntimeException 当保存失败时抛出
     */
    private boolean saveWorkOrderFlow(Long workOrderId, PatrolTaskStatusEnum newStatus,
                                      String rejectReason, String areaCode) {
        GdWorkOrderFlowEntity flowEntity = new GdWorkOrderFlowEntity();
        flowEntity.setCreateUser(AuthUtil.getUserId());
        flowEntity.setWorkOrderId(workOrderId);
        flowEntity.setFlowName(newStatus.getDesc());

        // 构建流转描述
        String flowDesc = buildFlowDesc(newStatus, rejectReason);
        flowEntity.setFlowDesc(flowDesc);

        flowEntity.setOperator(AuthUtil.getUserName());
        flowEntity.setType(WorkOrderTypeEnum.PATROL_TASK.getValue());
        flowEntity.setAreaCode(areaCode);
        flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));

        boolean saveResult = gdWorkOrderFlowService.save(flowEntity);
        if (!saveResult) {
            throw new RuntimeException("保存流转记录失败");
        }
        return true;
    }

    /**
     * 构建流转描述
     *
     * @param newStatus     新状态
     * @param rejectReason  拒绝原因
     * @return 流转描述
     */
    private String buildFlowDesc(PatrolTaskStatusEnum newStatus, String rejectReason) {
        String baseDesc = AuthUtil.getUserName() + " " +
                          org.springblade.core.tool.utils.DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " ";

        switch (newStatus) {
            case REJECTED_SIGNING:
                return baseDesc + "拒绝签收：" + rejectReason;
            case PENDING_AUDIT:
                return baseDesc + "待审核";
            case AUDIT_REJECTED:
                return baseDesc + "审核驳回：" + rejectReason;
            case AUDIT_PASSED:
                return baseDesc + "审核通过";
            case REJECTED_ACCEPTANCE:
                return baseDesc + "拒绝验收：" + rejectReason;
            case ACCEPTANCE_PASSED:
                return baseDesc + "验收通过";
            default:
                return baseDesc + newStatus.getDesc();
        }
    }


}

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

@@ -2,6 +2,7 @@

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.secure.utils.AuthUtil;
@@ -13,8 +14,10 @@
import org.sxkj.common.constant.WordOrderConstant;
import org.sxkj.common.utils.GeomUtils;
import org.sxkj.common.utils.OrderNumUtils;
import org.sxkj.gd.workorder.entity.GdPatrolTaskEntity;
import org.sxkj.gd.workorder.entity.GdWorkOrderEntity;
import org.sxkj.gd.workorder.entity.GdWorkOrderFlowEntity;
import org.sxkj.gd.workorder.enums.PatrolTaskStatusEnum;
import org.sxkj.gd.workorder.enums.WorkOrderStatusEnum;
import org.sxkj.gd.workorder.enums.WorkOrderTypeEnum;
import org.sxkj.gd.workorder.excel.GdWorkOrderExcel;
@@ -22,6 +25,7 @@
import org.sxkj.gd.workorder.param.WorkOrderAddParam;
import org.sxkj.gd.workorder.param.WorkOrderPageParam;
import org.sxkj.gd.workorder.param.WorkOrderStatusParam;
import org.sxkj.gd.workorder.service.IGdPatrolTaskService;
import org.sxkj.gd.workorder.service.IGdWorkOrderFlowService;
import org.sxkj.gd.workorder.service.IGdWorkOrderService;
import org.sxkj.gd.workorder.vo.GdWorkOrderVO;
@@ -41,6 +45,8 @@

    @Autowired
    private IGdWorkOrderFlowService gdWorkOrderFlowService;
    @Autowired
    private IGdPatrolTaskService gdPatrolTaskService;

    @Override
    public GdWorkOrderEntity getWorkOrderDetail(GdWorkOrderEntity gdWorkOrder) {
@@ -94,7 +100,7 @@
            // 更新操作
            entity.setUpdateUser(AuthUtil.getUserId());
            entity.setUpdateTime(now);
			

            // 状态转换：拒绝状态修改后自动转换为待处理状态
            switch (entity.getWorkOrderStatus()) {
                case "11": // 发布中_拒绝接单 → 发布中_接单中
@@ -103,6 +109,7 @@
                case "24": // 响应中_拒绝取消 → 响应中_申请取消
                    entity.setWorkOrderStatus(WorkOrderStatusEnum.RESPONDING_APPLY_CANCEL.getCode());
                    break;
                case "20": // 响应中_待拆分 → 响应中_申请修改
                case "25": // 响应中_拒绝修改 → 响应中_申请修改
                    entity.setWorkOrderStatus(WorkOrderStatusEnum.RESPONDING_APPLY_MODIFY.getCode());
                    break;
@@ -157,7 +164,7 @@
        if (currentStatus == null || !currentStatus.isAllowedOperation(operationType)) {
            return false;
        }

        // 1接单，2拒接接单，3申请取消，4申请修改， 5同意取消  6不同意取消 7.同意修改 8.不同意修改 9.协商修改 10.同意修改
        // 3. 确定新状态和流转名称
        WorkOrderStatusEnum newStatusEnum;
        switch (operationType) {
@@ -183,6 +190,12 @@
            case 8: // 不同意修改
                newStatusEnum = WorkOrderStatusEnum.RESPONDING_REJECT_MODIFY;
                break;
            case 9: // 协商修改 --> 协商修改
                newStatusEnum = WorkOrderStatusEnum.EXECUTING_NEGOTIATE_MODIFY;
                break;
            case 10: // 同意协商修改 --> 待拆分
                newStatusEnum = WorkOrderStatusEnum.RESPONDING_TO_BE_SPLIT;
                break;
            default: // 无效操作类型
                return false;
        }
@@ -191,6 +204,7 @@
        Date now = new Date();
        workOrder.setWorkOrderStatus(newStatusEnum.getCode());
        workOrder.setUpdateUser(AuthUtil.getUserId());
        workOrder.setGeom(null);
        workOrder.setUpdateTime(now);
        boolean updateResult = updateById(workOrder);

@@ -207,6 +221,14 @@
            flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));
            return gdWorkOrderFlowService.save(flowEntity);
        }
        // 6. 把待验收的都改为待签收状态
        if (operationType == 10) {
            boolean update = gdPatrolTaskService.update(Wrappers.<GdPatrolTaskEntity>lambdaUpdate()
                .set(GdPatrolTaskEntity::getTaskStatus, PatrolTaskStatusEnum.PENDING_SIGNING.getValue())
                .eq(GdPatrolTaskEntity::getWorkOrderId, workOrder.getId())
                .eq(GdPatrolTaskEntity::getTaskStatus, PatrolTaskStatusEnum.PENDING_ACCEPTANCE.getValue())
            );
        }

        return false;
    }