package com.dy.pipIrrApp.workOrder;
|
|
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;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* @author ZhuBaoMin
|
* @date 2024-11-04 9:29
|
* @LastEditTime 2024-11-04 9:29
|
* @Description 工单服务类
|
*/
|
|
@Slf4j
|
@Service
|
public class WorkOrderSv {
|
@Autowired
|
private OpeWorkOrderMapper opeWorkOrderMapper;
|
|
@Autowired
|
private OpeProcessingResultMapper opeProcessingResultMapper;
|
|
@Autowired
|
private OpeApproveResultMapper opeApproveResultMapper;
|
|
/**
|
* 添加工单记录
|
* @param po
|
* @return
|
*/
|
public Long insertWorkOrder(OpeWorkOrder po) {
|
po.setDispatchTime(new Date());
|
po.setState((byte) 1);
|
po.setRejectTimes(0);
|
po.setDeleted(0L);
|
|
opeWorkOrderMapper.insert(po);
|
return po.getId();
|
}
|
|
/**
|
* 获取指定派单人的指定未删除工单，删除工单前判断使用使用
|
* @param dispatcherId
|
* @param workOrderId
|
* @return
|
*/
|
public OpeWorkOrder getWorkOrder(Long workOrderId, Long dispatcherId) {
|
return opeWorkOrderMapper.getWorkOrder(workOrderId, dispatcherId);
|
}
|
|
/**
|
* 逻辑删除一个未删除的工单
|
* @param workOrderId
|
* @return
|
*/
|
public Integer deleteWorkOrder(Long workOrderId) {
|
return opeWorkOrderMapper.deleteWorkOrder(workOrderId);
|
}
|
|
/**
|
* 根据指定条件获取工单
|
* @param qo
|
* @return
|
*/
|
public QueryResultVo<List<VoWorkOrder>> getWorkOrders(QoWorkOrder qo) {
|
qo.completionTime() ;
|
|
Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo);
|
Long itemTotal = opeWorkOrderMapper.getWorkOrdersCount(params);
|
|
QueryResultVo<List<VoWorkOrder>> rsVo = new QueryResultVo<>() ;
|
rsVo.pageSize = qo.pageSize ;
|
rsVo.pageCurr = qo.pageCurr ;
|
|
rsVo.calculateAndSet(itemTotal, params);
|
rsVo.obj = opeWorkOrderMapper.getWorkOrders(params);
|
return rsVo ;
|
}
|
|
/**
|
* 根据工单主键获取工单视图对象
|
* @param workOrderId
|
* @return
|
*/
|
public VoWorkOrder getWorkOrderById(Long workOrderId) {
|
return opeWorkOrderMapper.getWorkOrderById(workOrderId);
|
}
|
|
/**
|
* 上报工单处理结果
|
* @param po
|
* @return
|
*/
|
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);
|
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";
|
}
|
}
|
