接单或拒接接单

linwei

2026-01-17 c2f2560287e9d71a472099ef868eaf919dc5ea1a

接单或拒接接单

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

@@ -33,6 +33,7 @@
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.sxkj.gd.workorder.entity.GdWorkOrderEntity;
import org.sxkj.gd.workorder.param.WorkOrderParam;
import org.sxkj.gd.workorder.param.WorkOrderStatusParam;
import org.sxkj.gd.workorder.vo.GdWorkOrderVO;
import org.sxkj.gd.workorder.excel.GdWorkOrderExcel;
import org.sxkj.gd.workorder.wrapper.GdWorkOrderWrapper;
@@ -86,12 +87,13 @@
    /**
     * 工单任务表 新增
     */
    @PostMapping("/submit")
    @PostMapping("/save")
    @ApiOperationSupport(order = 4)
    @ApiOperation(value = "新增", notes = "传入gdWorkOrder")
    public R save(@Valid @RequestBody WorkOrderParam workOrderParam) {
        return R.status(gdWorkOrderService.saveOrUpdateWorkOrder(workOrderParam));
        return R.status(gdWorkOrderService.saveWorkOrder(workOrderParam));
    }
    //

    /**
     * 工单任务表 删除
@@ -103,12 +105,23 @@
        return R.status(gdWorkOrderService.deleteLogic(Func.toLongList(ids)));
    }

    /**
     * 处理工单状态变更（接单或拒接接单）
     */
    @PostMapping("/handleStatus")
    @ApiOperationSupport(order = 8)
    @ApiOperation(value = "处理工单状态", notes = "传入workOrderStatusParam")
    public R handleStatus(@Valid @RequestBody WorkOrderStatusParam workOrderStatusParam) {
        return R.status(gdWorkOrderService.handleWorkOrderStatus(workOrderStatusParam));
    }


    /**
     * 导出数据
     */
    @GetMapping("/export-gdWorkOrder")
    @ApiOperationSupport(order = 9)
    @ApiIgnore
    @ApiOperation(value = "导出数据", notes = "传入gdWorkOrder")
    public void exportGdWorkOrder(@ApiIgnore @RequestParam Map<String, Object> gdWorkOrder, BladeUser bladeUser, HttpServletResponse response) {
        QueryWrapper<GdWorkOrderEntity> queryWrapper = Condition.getQueryWrapper(gdWorkOrder, GdWorkOrderEntity.class);

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

New file
@@ -0,0 +1,202 @@
package org.sxkj.gd.workorder.enums;

/**
 * 工单状态枚举
 * @author lw
 * @since 2026-01-17
 */
public enum WorkOrderStatusEnum {

    /**
     * 工单阶段：工单发布
     */
    STAGE_WORK_ORDER_RELEASE("工单发布"),

    /**
     * 工单阶段：接单响应
     */
    STAGE_ORDER_RESPONSE("接单响应"),

    /**
     * 工单阶段：执行中
     */
    STAGE_IN_EXECUTION("执行中"),

    /**
     * 工单阶段：完成待验
     */
    STAGE_COMPLETED_PENDING_INSPECTION("完成待验"),

    /**
     * 工单阶段：验收通过
     */
    STAGE_ACCEPTED("验收通过"),

    /**
     * 工单阶段：结算完成
     */
    STAGE_SETTLEMENT_COMPLETED("结算完成"),

    // ------------------ 以下是工单状态 ------------------

    /**
     * 草稿
     */
    DRAFT(0, "草稿", null),

    /**
     * 发布中_接单中
     */
    PUBLISHING_ACCEPTING(10, "发布中_接单中", "工单发布"),

    /**
     * 发布中_拒绝接单
     */
    PUBLISHING_REJECTING(11, "发布中_拒绝接单", "工单发布"),

    /**
     * 响应中_待拆分
     */
    RESPONDING_TO_BE_SPLIT(20, "响应中_待拆分", "接单响应"),

    /**
     * 响应中_申请取消
     */
    RESPONDING_APPLY_CANCEL(21, "响应中_申请取消", "接单响应"),

    /**
     * 响应中_申请修改
     */
    RESPONDING_APPLY_MODIFY(22, "响应中_申请修改", "接单响应"),

    /**
     * 响应中_已取消
     */
    RESPONDING_CANCELED(23, "响应中_已取消", "接单响应"),

    /**
     * 执行中_待全部完成
     */
    EXECUTING_TO_BE_COMPLETED(30, "执行中_待全部完成", "执行中"),

    /**
     * 执行中_协商修改
     */
    EXECUTING_NEGOTIATE_MODIFY(31, "执行中_协商修改", "执行中"),

    /**
     * 完成待验_待全部验收
     */
    COMPLETED_TO_BE_INSPECTED(40, "完成待验_待全部验收", "完成待验"),

    /**
     * 验收通过_待结算
     */
    ACCEPTED_TO_BE_SETTLED(50, "验收通过_待结算", "验收通过"),

    /**
     * 结算完成_已结算
     */
    SETTLEMENT_COMPLETED(60, "结算完成_已结算", "结算完成");

    private final Byte code;
    private final String desc;
    private final String stageDesc;
    private final boolean isStage;

    /**
     * 工单阶段构造函数
     */
    WorkOrderStatusEnum(String stageDesc) {
        this.code = null;
        this.desc = null;
        this.stageDesc = stageDesc;
        this.isStage = true;
    }

    /**
     * 工单状态构造函数
     */
    WorkOrderStatusEnum(int code, String desc, String stageDesc) {
        this.code = (byte) code;
        this.desc = desc;
        this.stageDesc = stageDesc;
        this.isStage = false;
    }

    /**
     * 获取状态码
     * @return 状态码
     */
    public Byte getCode() {
        return code;
    }

    /**
     * 获取状态描述
     * @return 状态描述
     */
    public String getDesc() {
        return desc;
    }

    /**
     * 获取工单阶段描述
     * @return 工单阶段描述
     */
    public String getStageDesc() {
        return stageDesc;
    }

    /**
     * 是否为工单阶段
     * @return 是否为工单阶段
     */
    public boolean isStage() {
        return isStage;
    }

    /**
     * 是否为工单状态
     * @return 是否为工单状态
     */
    public boolean isStatus() {
        return !isStage;
    }

    /**
     * 根据状态码获取枚举对象
     * @param code 状态码
     * @return 枚举对象
     */
    public static WorkOrderStatusEnum getByCode(Byte code) {
        if (code == null) {
            return null;
        }
        for (WorkOrderStatusEnum status : values()) {
            if (status.getCode().equals(code)) {
                return status;
            }
        }
        return null;
    }

    /**
     * 根据状态码获取状态描述
     * @param code 状态码
     * @return 状态描述
     */
    public static String getDescByCode(Byte code) {
        WorkOrderStatusEnum status = getByCode(code);
        return status != null ? status.getDesc() : null;
    }

    /**
     * 判断状态码是否有效
     * @param code 状态码
     * @return 是否有效
     */
    public static boolean isValid(Byte code) {
        return getByCode(code) != null;
    }
}

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

New file
@@ -0,0 +1,65 @@
package org.sxkj.gd.workorder.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonValue;
import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 工单类型枚举
 * 用于标识不同类型的工作订单
 *
 * @author Qoder
 * @date 2026-01-17
 */
@Getter
@AllArgsConstructor
public enum WorkOrderTypeEnum {

    /**
     * 工单任务 - 值为0
     */
    WORK_ORDER_TASK("0", "工单任务"),

    /**
     * 巡查任务 - 值为1
     */
    PATROL_TASK("1", "巡查任务");

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

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

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

    /**
     * 判断值是否为有效的工单类型
     *
     * @param value 待验证的值
     * @return 是否有效
     */
    public static boolean isValidValue(String value) {
        return getByValue(value) != null;
    }
}

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

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

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

import javax.validation.constraints.NotNull;

/**
 * 工单状态变更参数
 * @author lw
 * @since 2026-01-17
 */
@Data
public class WorkOrderStatusParam {

    /**
     * 工单ID
     */
    @ApiModelProperty(value = "工单ID", required = true)
    @NotNull(message = "工单ID不能为空")
    private Long workOrderId;

    /**
     * 操作类型：1接单，2拒接接单
     */
    @ApiModelProperty(value = "操作类型：1接单，2拒接接单", required = true)
    @NotNull(message = "操作类型不能为空")
    private Integer operationType;

    /**
     * 拒接原因（仅当操作类型为2时必填）
     */
    @ApiModelProperty(value = "拒接原因")
    private String rejectReason;

}

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

@@ -19,6 +19,7 @@
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import org.sxkj.gd.workorder.entity.GdWorkOrderEntity;
import org.sxkj.gd.workorder.param.WorkOrderParam;
import org.sxkj.gd.workorder.param.WorkOrderStatusParam;
import org.sxkj.gd.workorder.vo.GdWorkOrderVO;
import org.sxkj.gd.workorder.excel.GdWorkOrderExcel;
import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -57,5 +58,12 @@
     * @param workOrderParam
     * @return
     */
    boolean saveOrUpdateWorkOrder(@Valid WorkOrderParam workOrderParam);
    boolean saveWorkOrder(@Valid WorkOrderParam workOrderParam);

    /**
     * 处理工单状态变更（接单或拒接接单）
     * @param statusParam
     * @return
     */
    boolean handleWorkOrderStatus(@Valid WorkOrderStatusParam statusParam);
}

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

@@ -22,16 +22,26 @@
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.BeanUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.sxkj.common.constant.CommonConstant;
import org.sxkj.common.constant.WordOrderConstant;
import org.sxkj.common.utils.GeomUtils;
import org.sxkj.common.utils.OrderNumUtils;
import org.sxkj.gd.workorder.entity.GdWorkOrderEntity;
import org.sxkj.gd.workorder.entity.GdWorkOrderFlowEntity;
import org.sxkj.gd.workorder.enums.WorkOrderStatusEnum;
import org.sxkj.gd.workorder.enums.WorkOrderTypeEnum;
import org.sxkj.gd.workorder.excel.GdWorkOrderExcel;
import org.sxkj.gd.workorder.mapper.GdWorkOrderMapper;
import org.sxkj.gd.workorder.param.WorkOrderParam;
import org.sxkj.gd.workorder.param.WorkOrderStatusParam;
import org.sxkj.gd.workorder.service.IGdWorkOrderFlowService;
import org.sxkj.gd.workorder.service.IGdWorkOrderService;
import org.sxkj.gd.workorder.vo.GdWorkOrderVO;

import java.util.Date;
import java.util.List;
import java.util.Objects;

@@ -43,6 +53,9 @@
 */
@Service
public class GdWorkOrderServiceImpl extends BaseServiceImpl<GdWorkOrderMapper, GdWorkOrderEntity> implements IGdWorkOrderService {

    @Autowired
    private IGdWorkOrderFlowService gdWorkOrderFlowService;

    @Override
    public IPage<GdWorkOrderVO> selectGdWorkOrderPage(IPage<GdWorkOrderVO> page, GdWorkOrderVO gdWorkOrder) {
@@ -60,12 +73,13 @@
    }

    /**
     * 保存或更新工单任务表
     * 保存工单任务表
     * @param workOrderParam
     * @return
     */
    @Override
    public boolean saveOrUpdateWorkOrder(WorkOrderParam workOrderParam) {
    @Transactional(rollbackFor = Exception.class)
    public boolean saveWorkOrder(WorkOrderParam workOrderParam) {
        GdWorkOrderEntity entity = Objects.requireNonNull(BeanUtil.copy(workOrderParam, GdWorkOrderEntity.class));

        // 验证并格式化几何数据
@@ -81,11 +95,91 @@
        // 生成工单编号
        if (StringUtils.isBlank(entity.getWorkOrderCode())) {
            // 使用时间戳生成唯一工单编号
            String timestamp = OrderNumUtils.initOrderNum("gdTicketInfo");
            entity.setWorkOrderCode("GD" + timestamp);
            String timestamp = OrderNumUtils.initOrderNum(WordOrderConstant.ORDER_REDIS_KEY);
            entity.setWorkOrderCode(WordOrderConstant.ORDER_PREFIX + timestamp);
        }
        entity.setCreateUser(AuthUtil.getUserId());
        entity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));
        return saveOrUpdate(entity);
        boolean save = save(entity);
        // 保存成功
        if (save){
            // 保存流转记录
            GdWorkOrderFlowEntity gdWorkOrderFlowEntity = new GdWorkOrderFlowEntity();
            gdWorkOrderFlowEntity.setCreateUser(AuthUtil.getUserId());
            gdWorkOrderFlowEntity.setWorkOrderId(entity.getId());
            gdWorkOrderFlowEntity.setFlowName(WorkOrderStatusEnum.STAGE_WORK_ORDER_RELEASE.getStageDesc());
            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.WORK_ORDER_TASK.getValue());
            gdWorkOrderFlowEntity.setAreaCode(entity.getAreaCode());
            gdWorkOrderFlowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));
            boolean save1 = gdWorkOrderFlowService.save(gdWorkOrderFlowEntity);
            return save1;

        }
        return false;
    }

    /**
     * 处理工单状态变更（接单或拒接接单）
     * @param statusParam
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean handleWorkOrderStatus(WorkOrderStatusParam statusParam) {
        // 获取工单信息
        GdWorkOrderEntity workOrder = getById(statusParam.getWorkOrderId());
        if (workOrder == null) {
            return false;
        }

        // 检查工单当前状态是否为发布中_接单中（10）
        if (!workOrder.getWorkOrderStatus().equals(WorkOrderStatusEnum.PUBLISHING_ACCEPTING.getCode())) {
            return false;
        }

        // 操作类型：1接单，2拒接接单
        Integer operationType = statusParam.getOperationType();
        Byte newStatus = null;
        String flowName = null;
        String flowDesc = null;

        if (operationType == 1) {
            // 接单操作：更新状态为响应中_待拆分（20）
            newStatus = WorkOrderStatusEnum.RESPONDING_TO_BE_SPLIT.getCode();
            flowName = WorkOrderStatusEnum.RESPONDING_TO_BE_SPLIT.getStageDesc();
            flowDesc = AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), CommonConstant.YYYY_MM_DD_HH_MM_SS);
        } else if (operationType == 2) {
            // 拒接接单操作：更新状态为发布中_拒绝接单（11）
            newStatus = WorkOrderStatusEnum.PUBLISHING_REJECTING.getCode();
            flowName = WorkOrderStatusEnum.PUBLISHING_REJECTING.getStageDesc();
            flowDesc = AuthUtil.getUserName() + " " + org.springblade.core.tool.utils.DateUtil.format(new Date(), CommonConstant.YYYY_MM_DD_HH_MM_SS) ;
        } else {
            // 无效的操作类型
            return false;
        }

        // 更新工单状态
        workOrder.setWorkOrderStatus(newStatus);
        workOrder.setUpdateUser(AuthUtil.getUserId());
        workOrder.setUpdateTime(new Date());
        boolean update = updateById(workOrder);

        // 更新成功，保存流转记录
        if (update) {
            GdWorkOrderFlowEntity flowEntity = new GdWorkOrderFlowEntity();
            flowEntity.setCreateUser(AuthUtil.getUserId());
            flowEntity.setWorkOrderId(workOrder.getId());
            flowEntity.setFlowName(flowName);
            flowEntity.setFlowDesc(flowDesc);
            flowEntity.setOperator(AuthUtil.getUserName());
            flowEntity.setType(WorkOrderTypeEnum.WORK_ORDER_TASK.getValue());
            flowEntity.setAreaCode(workOrder.getAreaCode());
            flowEntity.setCreateDept(Long.valueOf(AuthUtil.getDeptId()));
            return gdWorkOrderFlowService.save(flowEntity);
        }

        return false;
    }
}