处理结果3个接口

zhubaomin

2024-11-08 d9fa51fbd30841d807a8eb3bac552c125404f4a5

处理结果3个接口

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/daoOp/OpeProcessingResultMapper.java

@@ -2,7 +2,9 @@

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dy.pipIrrGlobal.pojoOp.OpeProcessingResult;
import com.dy.pipIrrGlobal.voOp.VoProcessingResult;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * @author ZhuBaoMin
@@ -26,9 +28,31 @@
    int updateByPrimaryKey(OpeProcessingResult record);

    /**
     * 根据workOrderId获取未删除的处理结果数量，添加结果上报前判断使用
     * 根据工单ID获取未删除的工单对象
     * @param workOrderId
     * @return
     */
    Integer getValidResultCount(Long workOrderId);
    OpeProcessingResult getByWorkOrderId(Long workOrderId);

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

    /**
     * 逻辑删除一个未删除的处理结果记录
     * @param proResultId
     * @return
     */
    Integer deleteProResult(Long proResultId);

    /**
     * 根据主键获取处理结果视图对象
     * @param proResultId
     * @return
     */
    VoProcessingResult getProResultById(Long proResultId);
}

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/daoOp/OpeWorkOrderMapper.java

@@ -39,11 +39,11 @@

    /**
     * 获取指定派单人的指定未删除工单，删除工单前判断使用使用
     * @param dispatcherId
     * @param workOrderId
     * @param dispatcherId
     * @return
     */
    OpeWorkOrder getWorkOrder(@Param("dispatcherId")Long dispatcherId, @Param("workOrderId")Long workOrderId);
    OpeWorkOrder getWorkOrder(@Param("workOrderId")Long workOrderId, @Param("dispatcherId")Long dispatcherId);

    /**
     * 逻辑删除一个未删除的工单

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/voOp/VoProcessingResult.java

New file
@@ -0,0 +1,94 @@
package com.dy.pipIrrGlobal.voOp;

import com.alibaba.fastjson2.annotation.JSONField;
import com.alibaba.fastjson2.writer.ObjectWriterImplToString;
import com.dy.common.po.BaseEntity;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.Data;

import java.math.BigDecimal;
import java.util.Date;

/**
 * @author ZhuBaoMin
 * @date 2024-11-08 14:59
 * @LastEditTime 2024-11-08 14:59
 * @Description
 */

@Data
@JsonPropertyOrder({"proResultId","workOrderId","inspector","content"," images"," audios"," videos","lng","lat","completeTime","reportTime","state","stateName"})
public class VoProcessingResult implements BaseEntity {
    public static final long serialVersionUID = 202411081500001L;

    /**
     * 问题结果ID
     */
    @JSONField(serializeUsing= ObjectWriterImplToString.class)
    private Long proResultId;

    /**
     * 工单ID
     */
    @JSONField(serializeUsing= ObjectWriterImplToString.class)
    private Long workOrderId;

    /**
     * 巡检员ID
     */
    private String inspector;

    /**
     * 结果内容
     */
    private String content;

    /**
     * 照片列表
     */
    private String images;

    /**
     * 音频列表
     */
    private String audios;

    /**
     * 视频列表
     */
    private String videos;

    /**
     * 经度
     */
    private BigDecimal lng;

    /**
     * 纬度
     */
    private BigDecimal lat;

    /**
     * 任务完成时间;精确到分
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm")
    private Date completeTime;

    /**
     * 上报时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date reportTime;

    /**
     * 状态;1-已上报，2-已通过，3-已驳回
     */
    private Byte state;

    /**
     * 状态名称
     */
    private String stateName;

}

 pipIrr-platform/pipIrr-global/src/main/resources/mapper/OpeProcessingResultMapper.xml

@@ -195,8 +195,44 @@
    where id = #{id,jdbcType=BIGINT}
  </update>

  <!--根据workOrderId获取未删除的处理结果数量，添加结果上报前判断使用-->
  <select id="getValidResultCount" resultType="java.lang.Integer">
    SELECT COUNT(*) FROM  ope_processing_result WHERE deleted = 0 AND work_order_id = #{workOrderId}
  <!--根据工单ID获取未删除的工单对象-->
  <select id="getByWorkOrderId" resultType="com.dy.pipIrrGlobal.pojoOp.OpeProcessingResult">
    SELECT * FROM ope_processing_result WHERE deleted = 0 AND work_order_id = #{workOrderId} LIMIT 1
  </select>

  <!--获取指定巡检员的指定未删除且未审批的处理结果上报，删除处理结果前判断使用使用-->
  <select id="getProResult" resultType="com.dy.pipIrrGlobal.pojoOp.OpeProcessingResult">
    SELECT * FROM ope_processing_result
    WHERE deleted = 0 AND state = 1 AND id = #{proResultId} AND inspector_id = #{inspectorId} LIMIT 1
  </select>

  <!--逻辑删除一个未删除的处理结果记录-->
  <update id="deleteProResult">
    UPDATE ope_processing_result SET deleted = UNIX_TIMESTAMP() WHERE deleted = 0 AND id = #{proResultId}
  </update>

  <!--根据主键获取处理结果视图对象-->
  <select id="getProResultById" resultType="com.dy.pipIrrGlobal.voOp.VoProcessingResult">
    SELECT
        res.id AS proResultId,
        res.work_order_id AS workOrderId,
        us.name AS inspector,
        res.content,
        res.images,
        res.audios,
        res.videos,
        res.lng,
        res.lat,
        res.complete_time AS completeTime,
        res.report_time AS reportTime,
        res.state,
        CASE
            WHEN res.state = 1 THEN '已上报'
            WHEN res.state = 2 THEN '已通过'
            WHEN res.state = 3 THEN '已驳回'
        END AS stateName
    FROM ope_processing_result res
        INNER JOIN ba_user us ON us.id = res.inspector_id
    WHERE res.deleted = 0 AND res.id = #{proResultId}
  </select>
</mapper>

 pipIrr-platform/pipIrr-global/src/main/resources/mapper/OpeWorkOrderMapper.xml

@@ -242,10 +242,14 @@
    WHERE ord.deleted = 0 AND ord.id = #{workOrderId}
  </select>

  <!--获取指定派单人的指定未删除工单，删除工单前判断使用使用-->
  <!--获取指定派单人的、未上报的指定未删除工单，删除工单前判断使用使用-->
  <select id="getWorkOrder" resultType="com.dy.pipIrrGlobal.pojoOp.OpeWorkOrder">
    SELECT * FROM ope_work_order
    WHERE deleted = 0 AND id = #{workOrderId} AND dispatcher_id = #{dispatcherId} LIMIT 1
    SELECT
        *
    FROM ope_work_order ord
    WHERE deleted = 0
        AND NOT EXISTS(SELECT * FROM ope_processing_result res WHERE res.work_order_id = ord.id)
        AND id = #{workOrderId} AND dispatcher_id = #{dispatcherId} LIMIT 1
  </select>

  <!--逻辑删除一个未删除的工单-->

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

@@ -1,13 +1,16 @@
package com.dy.pipIrrApp.workOrder;

import com.alibaba.fastjson2.JSON;
import com.dy.common.aop.SsoAop;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrApp.workOrder.dto.DtoDeleteProResult;
import com.dy.pipIrrApp.workOrder.dto.DtoDeleteWorkOrder;
import com.dy.pipIrrApp.workOrder.qo.QoWorkOrder;
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 jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@@ -133,7 +136,7 @@
            return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        OpeWorkOrder workOrder = workOrderSv.getWorkOrder(deleteWorkOrder.getDispatcherId(), deleteWorkOrder.getWorkOrderId());
        OpeWorkOrder workOrder = workOrderSv.getWorkOrder(deleteWorkOrder.getWorkOrderId(), deleteWorkOrder.getDispatcherId());
        if(workOrder == null) {
            return BaseResponseUtils.buildErrorMsg("您要删除的工单不存在");
        }
@@ -141,7 +144,6 @@
        if(workOrderSv.deleteWorkOrder(deleteWorkOrder.getWorkOrderId()) == 0) {
            return BaseResponseUtils.buildErrorMsg("工单删除失败");
        }


        return BaseResponseUtils.buildSuccess();
    }
@@ -178,8 +180,10 @@

    /**
     * 上报工单处理结果
     *      判断该工单是否存在有效的处理结果，如果存在则提示用户该工单已存在处理结果
     *      添加处理结果回复
     *      1.未上报的，直接上报
     *      2. 已上报的的，提示用户不能重复上报
     *      3. 已通过的，提示用户处理结果处理结果已通过
     *      4. 驳回的，逻辑删除原处理结果，上报新的处理结果
     * @param po
     * @param bindingResult
     * @return
@@ -191,16 +195,53 @@
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        if(workOrderSv.hasValidProcessingResult(po.getWorkOrderId())) {
            return BaseResponseUtils.buildErrorMsg("该工单存在有效的处理结果");
        }

        Long processingResultId = workOrderSv.insertProcessingResult(po);
        if(processingResultId == null) {
            return BaseResponseUtils.buildErrorMsg("上报工单处理结果失败");
        String result = workOrderSv.addProcessingResult(po);
        if(!result.equals("success")) {
            return BaseResponseUtils.buildErrorMsg(result);
        }

        return BaseResponseUtils.buildSuccess(true) ;
    }

    /**
     * 逻辑删除一个处理结果
     * @param deleteProResult
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "deleteProResult")
    @SsoAop()
    public BaseResponse<Boolean> deleteProResult(@RequestBody @Valid DtoDeleteProResult deleteProResult, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        OpeProcessingResult proResult = workOrderSv.getProResult(deleteProResult.getProResultId(), deleteProResult.getInspectorId());
        if(proResult == null) {
            return BaseResponseUtils.buildErrorMsg("您要删除的处理结果不存在");
        }

        if(workOrderSv.deleteProResult(deleteProResult.getProResultId()) == 0) {
            return BaseResponseUtils.buildErrorMsg("处理结果删除失败");
        }

        return BaseResponseUtils.buildSuccess();
    }

    /**
     * 获取处理结果详情
     * @param proResultId
     * @return
     */
    @GetMapping(path = "/getProResult")
    public BaseResponse<VoProcessingResult> getProResult(@RequestParam("proResultId") Long proResultId) {
        try {
            String  aa = JSON.toJSONString(workOrderSv.getProResultById(proResultId));
            System.out.println(aa);
            return BaseResponseUtils.buildSuccess(workOrderSv.getProResultById(proResultId));
        } catch (Exception e) {
            log.error("获取处理结果详情异常", e);
            return BaseResponseUtils.buildException(e.getMessage());
        }
    }
}

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

@@ -6,6 +6,7 @@
import com.dy.pipIrrGlobal.daoOp.OpeWorkOrderMapper;
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;
@@ -53,8 +54,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 +97,76 @@
    }

    /**
     * 根据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);
        po.setDeleted(0L);
        opeProcessingResultMapper.insert(po);
        return po.getId();
    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);
    }
}

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

New file
@@ -0,0 +1,28 @@
package com.dy.pipIrrApp.workOrder.dto;

import jakarta.validation.constraints.NotNull;
import lombok.Data;

/**
 * @author ZhuBaoMin
 * @date 2024-11-08 11:43
 * @LastEditTime 2024-11-08 11:43
 * @Description 删除处理结果传输类
 */

@Data
public class DtoDeleteProResult {
    public static final long serialVersionUID = 202411081144001L;

    /**
     * 处理结果ID
     */
    @NotNull(message = "处理结果不能为空")
    private Long proResultId;

    /**
     * 巡检员ID
     */
    @NotNull(message = "巡检员不能为空")
    private Long inspectorId;
}