重构获取工单列表接口，查询条件中完成状态

zhubaomin

2024-11-27 6d64745bca5a75f31228fcd93b60677870ce2fa0

 pipIrr-platform/pipIrr-web/pipIrr-web-app/src/main/java/com/dy/pipIrrApp/workOrder/WorkOrderSv.java

@@ -2,10 +2,13 @@

import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrApp.workOrder.qo.QoWorkOrder;
import com.dy.pipIrrGlobal.daoOp.OpeApproveResultMapper;
import com.dy.pipIrrGlobal.daoOp.OpeProcessingResultMapper;
import com.dy.pipIrrGlobal.daoOp.OpeWorkOrderMapper;
import com.dy.pipIrrGlobal.pojoOp.OpeApproveResult;
import com.dy.pipIrrGlobal.pojoOp.OpeProcessingResult;
import com.dy.pipIrrGlobal.pojoOp.OpeWorkOrder;
import com.dy.pipIrrGlobal.voOp.VoProcessingResult;
import com.dy.pipIrrGlobal.voOp.VoWorkOrder;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.PojoUtils;
@@ -32,6 +35,9 @@
    @Autowired
    private OpeProcessingResultMapper opeProcessingResultMapper;

    @Autowired
    private OpeApproveResultMapper opeApproveResultMapper;

    /**
     * 添加工单记录
     * @param po
@@ -53,8 +59,8 @@
     * @param workOrderId
     * @return
     */
    public OpeWorkOrder getWorkOrder(Long dispatcherId, Long workOrderId) {
        return opeWorkOrderMapper.getWorkOrder(dispatcherId, workOrderId);
    public OpeWorkOrder getWorkOrder(Long workOrderId, Long dispatcherId) {
        return opeWorkOrderMapper.getWorkOrder(workOrderId, dispatcherId);
    }

    /**
@@ -96,27 +102,129 @@
    }

    /**
     * 根据workOrderId获取未删除的处理结果数量，添加结果上报前判断使用
     * @param workOrderId
     * @return
     */
    public Boolean hasValidProcessingResult(Long workOrderId) {
        if (opeProcessingResultMapper.getValidResultCount(workOrderId) == 0) {
            return false;
        }
        return true;
    }

    /**
     * 上报工单处理结果
     * @param po
     * @return
     */
    public Long insertProcessingResult(OpeProcessingResult po) {
        po.setReportTime(new Date());
        po.setState((byte)1);
    public String addProcessingResult(OpeProcessingResult po) {
        String result = "";
        OpeProcessingResult processingResult = opeProcessingResultMapper.getByWorkOrderId(po.getWorkOrderId());
        if(processingResult == null) {
            // 无处理结果上报处理结果
            po.setReportTime(new Date());
            po.setState((byte)1);
            po.setDeleted(0L);
            opeProcessingResultMapper.insert(po);
            if(po.getId() == 0) {
                result = "工单处理结果上报失败";
                return result;
            }

            result = "success";
            return result;
        }

        switch (processingResult.getState()) {
            case 1:
                result = "工单处理结果已上报，请勿重复上报";
                break;
            case 2:
                result = "工单处理结果已通过";
                break;
            case 3:
                // 处理结果被驳回时，删除当前处理结果，上报新的处理结果
                processingResult.setDeleted(System.currentTimeMillis()/1000);
                opeProcessingResultMapper.updateByPrimaryKeySelective(processingResult);

                po.setReportTime(new Date());
                po.setState((byte)1);
                po.setDeleted(0L);
                opeProcessingResultMapper.insert(po);
                result = "success";
                break;
        }

        return result;
    }

    /**
     * 获取指定巡检员的指定未删除且未审批的处理结果上报，删除处理结果前判断使用使用
     * @param proResultId
     * @param inspectorId
     * @return
     */
    public OpeProcessingResult getProResult(Long proResultId, Long inspectorId) {
        return opeProcessingResultMapper.getProResult(proResultId, inspectorId);
    }

    /**
     * 逻辑删除一个未删除的处理结果
     * @param proResultId
     * @return
     */
    public Integer deleteProResult(Long proResultId) {
        return opeProcessingResultMapper.deleteProResult(proResultId);
    }

    /**
     * 获取处理结果详情
     * @param proResultId
     * @return
     */
    public VoProcessingResult getProResultById(Long proResultId) {
        return opeProcessingResultMapper.getProResultById(proResultId);
    }

    /**
     * 审核工单处理结果
     *      1. 判断指定的工单及处理结果是否存在且未完成
     *      2. 添加审核记录
     *      3. 如果审核通过
     *          处理结果状态改为已通过
     *          工单补充任务完成时间
     *          工单状态改为已完成
     *      4. 如果驳回
     *          任务处理结果改为驳回
     *          工单驳回次数加1
     * @param po
     * @return
     */
    public String approveProResult(OpeApproveResult po) {

        OpeProcessingResult processingResult = opeProcessingResultMapper.selectByPrimaryKey(po.getProcessingResultId());
        if(processingResult == null || processingResult.getDeleted() != 0 || processingResult.getState() != 1) {
            return "处理结果不存在或已完成审核";
        }

        OpeWorkOrder workOrder = opeWorkOrderMapper.selectByPrimaryKey(po.getWorkOrderId());
        if(workOrder == null || workOrder.getDeleted() != 0 || workOrder.getState() == 2) {
            return "工单不存在或已完成";
        }

        po.setApproveTime(new Date());
        po.setDeleted(0L);
        opeProcessingResultMapper.insert(po);
        return po.getId();
        if(opeApproveResultMapper.insert(po) == 0) {
            return "审核记录添加失败";
        }

        if(po.getApproveResult() == 1) {
            // 审核通过
            processingResult.setState((byte)2);
            opeProcessingResultMapper.updateByPrimaryKeySelective(processingResult);

            workOrder.setCompleteTime(processingResult.getCompleteTime());
            workOrder.setState((byte)2);
            opeWorkOrderMapper.updateByPrimaryKeySelective(workOrder);

        } else {
            // 驳回
            processingResult.setState((byte)3);
            opeProcessingResultMapper.updateByPrimaryKeySelective(processingResult);

            workOrder.setRejectTimes(workOrder.getRejectTimes() + 1);
            opeWorkOrderMapper.updateByPrimaryKeySelective(workOrder);
        }

        return "success";
    }
}