package cn.huge.module.thirdByRmtj.service;
|
|
import cn.huge.base.common.exception.ServiceException;
|
import cn.huge.base.common.utils.*;
|
import cn.huge.module.cases.domain.po.CaseInfo;
|
import cn.huge.module.cases.service.CaseInfoService;
|
import cn.huge.module.client.api.impl.CustClientImpl;
|
import cn.huge.module.client.api.impl.UtilsClientImpl;
|
import cn.huge.module.cust.constant.UserBaseConsts;
|
import cn.huge.module.cust.dto.CtUnitDTO;
|
import cn.huge.module.cust.dto.CtUserDTO;
|
import cn.huge.module.mediate.constant.AuditBaseConsts;
|
import cn.huge.module.mediate.constant.AuditBaseConstsEnum;
|
import cn.huge.module.mediate.constant.CaseBaseConsts;
|
import cn.huge.module.thirdByRmtj.consts.RmtjConsts;
|
import cn.huge.module.thirdByRmtj.dao.mapper.ThRmtjApplyMapper;
|
import cn.huge.module.thirdByRmtj.domain.dto.*;
|
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjApply;
|
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjAudit;
|
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjConfig;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.google.common.collect.Maps;
|
import net.sf.json.JSONObject;
|
import org.apache.commons.collections.CollectionUtils;
|
import org.apache.ibatis.annotations.Param;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.data.domain.Page;
|
import org.springframework.data.domain.PageImpl;
|
import org.springframework.data.domain.PageRequest;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* @title: 第三方系统对接-转人民调解系统申请表业务逻辑处理
|
* @Description 第三方系统对接-转人民调解系统申请表业务逻辑处理
|
* @company hugeinfo
|
* @author liyj
|
* @Time 2024-11-15 10:56:25
|
* @version 1.0.0
|
*/
|
@Slf4j
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
public class ThRmtjApplyService extends ServiceImpl<ThRmtjApplyMapper, ThRmtjApply>{
|
|
@Autowired
|
private ThRmtjApplyMapper mapper;
|
|
@Autowired
|
private UtilsClientImpl utilsClient;
|
@Autowired
|
private CustClientImpl custClient;
|
@Autowired
|
private CaseInfoService caseInfoService;
|
@Autowired
|
private ThRmtjAuditService thRmtjAuditService;
|
@Autowired
|
private ThRmtjService thRmtjService;
|
@Autowired
|
private ThRmtjConfigService thRmtjConfigService;
|
|
/**
|
* 更新对象
|
* @param entity 对象
|
*/
|
public void updateThRmtjApply(ThRmtjApply entity){
|
try{
|
mapper.updateThRmtjApply(entity);
|
}catch (Exception e){
|
log.error("[ThRmtjApplyService.updateThRmtjApply]调用失败，异常信息："+e, e);
|
throw new ServiceException("ThRmtjApplyService.updateThRmtjApply", e);
|
}
|
}
|
|
/**
|
* 条件更新对象
|
* @param entity 对象
|
* @param terms 条件
|
*/
|
public void updateThRmtjApplyTerms(ThRmtjApply entity, Map<String, Object> terms){
|
try{
|
mapper.updateThRmtjApplyTerms(entity, terms);
|
}catch (Exception e){
|
log.error("[ThRmtjApplyService.updateThRmtjApplyTerms]调用失败，异常信息："+e, e);
|
throw new ServiceException("ThRmtjApplyService.updateThRmtjApplyTerms", e);
|
}
|
}
|
|
/**
|
* 根据编号物理删除
|
* @param id 查询条件集合
|
*/
|
public void deleteThRmtjApply(String id){
|
try{
|
mapper.deleteThRmtjApply(id);
|
}catch (Exception e){
|
log.error("[ThRmtjApplyService.deleteThRmtjApply]调用失败，异常信息："+e, e);
|
throw new ServiceException("ThRmtjApplyService.deleteThRmtjApply", e);
|
}
|
}
|
|
/**
|
* 按条件查询
|
* @param terms 条件
|
* @return List
|
*/
|
public List<ThRmtjApply> listTerms(Map<String, Object> terms){
|
return mapper.listTerms(terms);
|
}
|
|
/**
|
* 按条件统计
|
* @param terms 条件
|
* @return long
|
*/
|
public long countTerms(Map<String, Object> terms){
|
return mapper.countTerms(terms);
|
}
|
|
/**
|
* 按条件分页查询
|
* @param page 分页对象
|
* @param terms 条件
|
* @return Page
|
*/
|
public Page<ThRmtjApply> pageQuery(PageRequest page, Map<String, Object> terms){
|
long total = mapper.countTerms(terms);
|
List<ThRmtjApply> content = mapper.pageTerms(page, terms);
|
return new PageImpl<ThRmtjApply>(content, page, total);
|
}
|
|
/**
|
* 新增或更新对象
|
* @param thRmtjApply 实体对象
|
*/
|
public void saveThRmtjApply(ThRmtjApply thRmtjApply){
|
try{
|
Date nowDate = DateUtils.getNowDate();
|
// 判断是否新增
|
if (IdUtils.checkNewId(thRmtjApply.getId())){
|
thRmtjApply.setId(utilsClient.getNewTimeId());
|
thRmtjApply.setCreateTime(nowDate);
|
}
|
thRmtjApply.setUpdateTime(nowDate);
|
this.saveOrUpdate(thRmtjApply);
|
}catch (Exception e){
|
log.error("[ThRmtjApplyService.saveThRmtjApply]调用失败，异常信息："+e, e);
|
throw new ServiceException("ThRmtjApplyService.saveThRmtjApply", e);
|
}
|
}
|
|
/**
|
* web端-转入人民调解系统-申请列表
|
* @param page 分页对象
|
* @param terms 条件
|
* @return Page
|
*/
|
public Page<RmtjApplyPageDTO> pageApply(PageRequest page, Map<String, Object> terms){
|
long total = mapper.countPageApply(terms);
|
List<RmtjApplyPageDTO> content = mapper.pageApply(page, terms);
|
return new PageImpl<RmtjApplyPageDTO>(content, page, total);
|
}
|
|
/**
|
* web端-转入人民调解系统-申请列表统计
|
* @param terms 条件
|
* @return List
|
*/
|
public Map countApply(Map<String, Object> terms){
|
return mapper.countApply(terms);
|
}
|
|
/**
|
* web端-转入人民调解系统-批量转入人民调解系统申请
|
* @param caseIdList 申请案件编号集合
|
* @param loginUser 当前登录用户
|
*/
|
public void batchSendApply(List<String> caseIdList, CtUserDTO loginUser){
|
try{
|
Date nowDate = DateUtils.getNowDate();
|
for (String caseId: caseIdList) {
|
CaseInfo caseInfo = caseInfoService.getById(caseId);
|
if (ObjectUtils.isNotEmpty(caseInfo)) {
|
QueryWrapper<ThRmtjApply> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("case_id", caseId).ne("process", RmtjConsts.APPLY_PROCESS_9);
|
ThRmtjApply thRmtjApply = this.getOne(queryWrapper);
|
if (ObjectUtils.isEmpty(thRmtjApply)) {
|
queryWrapper.clear();
|
queryWrapper.eq("case_id", caseId);
|
int applyIndex = this.count(queryWrapper);
|
|
CtUnitDTO ctUnitDTO = custClient.getUnitById(loginUser.getUnitId());
|
if (UserBaseConsts.UNIT_GRADE_2 == ctUnitDTO.getUnitGrade()) {
|
// 区级申请转入，无司法所初审，直接到司法局终审
|
thRmtjApply = new ThRmtjApply();
|
thRmtjApply.setId(utilsClient.getNewTimeId());
|
thRmtjApply.setCaseId(caseId);
|
thRmtjApply.setApplyIndex(applyIndex+1);
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_2);
|
thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_2);
|
// 申请信息
|
thRmtjApply.setApplyUserId(loginUser.getId());
|
thRmtjApply.setApplyUserName(loginUser.getTrueName());
|
thRmtjApply.setApplyUnitId(loginUser.getUnitId());
|
thRmtjApply.setApplyUnitName(loginUser.getUnitName());
|
thRmtjApply.setApplyTime(nowDate);
|
// 初审信息
|
thRmtjApply.setFirstAuditUnit(ctUnitDTO.getId());
|
thRmtjApply.setFirstAuditUnitName(ctUnitDTO.getUnitName());
|
thRmtjApply.setFirstAuditUser(loginUser.getId());
|
thRmtjApply.setFirstAuditUserName(loginUser.getTrueName());
|
thRmtjApply.setFirstAuditResult(RmtjConsts.AUDIT_RESULT_1);
|
thRmtjApply.setFirstAuditTime(nowDate);
|
// 终审单位为司法局
|
Map<String, Object> unitTerms = Maps.newHashMap();
|
unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_105);
|
List<CtUnitDTO> sfjUnitList = custClient.listByTerms(unitTerms);
|
if (CollectionUtils.isNotEmpty(sfjUnitList)) {
|
thRmtjApply.setEndAuditUnit(sfjUnitList.get(0).getId());
|
thRmtjApply.setEndAuditUnitName(sfjUnitList.get(0).getId());
|
}
|
thRmtjApply.setCreateTime(nowDate);
|
thRmtjApply.setUpdateTime(nowDate);
|
thRmtjApply.setCustId(loginUser.getCustId());
|
this.save(thRmtjApply);
|
} else {
|
// 普通调解单位申请转入
|
thRmtjApply = new ThRmtjApply();
|
thRmtjApply.setId(utilsClient.getNewTimeId());
|
thRmtjApply.setCaseId(caseId);
|
thRmtjApply.setApplyIndex(applyIndex+1);
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_1);
|
thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_1);
|
// 申请信息
|
thRmtjApply.setApplyUserId(loginUser.getId());
|
thRmtjApply.setApplyUserName(loginUser.getTrueName());
|
thRmtjApply.setApplyUnitId(loginUser.getUnitId());
|
thRmtjApply.setApplyUnitName(loginUser.getUnitName());
|
thRmtjApply.setApplyTime(nowDate);
|
// 司法所单位审核
|
Map<String, Object> unitTerms = Maps.newHashMap();
|
if (UserBaseConsts.UNIT_GRADE_4 == ctUnitDTO.getUnitGrade()) {
|
unitTerms.put("parentId", ctUnitDTO.getParentId());
|
unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_106);
|
} else {
|
// 综治中心
|
if (UserBaseConsts.UNIT_TYPE_101 == ctUnitDTO.getUnitType()){
|
unitTerms.put("parentId", ctUnitDTO.getId());
|
}else {
|
// 其他单位
|
unitTerms.put("parentId", ctUnitDTO.getParentId());
|
}
|
unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_106);
|
}
|
List<CtUnitDTO> sfsUnitList = custClient.listByTerms(unitTerms);
|
if (CollectionUtils.isNotEmpty(sfsUnitList)) {
|
thRmtjApply.setFirstAuditUnit(sfsUnitList.get(0).getId());
|
thRmtjApply.setFirstAuditUnitName(sfsUnitList.get(0).getUnitName());
|
}
|
thRmtjApply.setCustId(loginUser.getCustId());
|
thRmtjApply.setCreateTime(nowDate);
|
thRmtjApply.setUpdateTime(nowDate);
|
this.save(thRmtjApply);
|
}
|
}
|
}
|
}
|
}catch (Exception e){
|
log.error("service方法[ThRmtjApplyService.batchSendApply]调用异常："+e, e);
|
throw new ServiceException("ThRmtjApplyService.batchSendApply", e);
|
}
|
}
|
|
/**
|
* web端-转入人民调解系统-初审列表
|
* @param page 分页对象
|
* @param terms 条件
|
* @return Page
|
*/
|
public Page<RmtjAuditPageDTO> pageFirstAudit(PageRequest page, Map<String, Object> terms){
|
long total = mapper.countPageFirstAudit(terms);
|
List<RmtjAuditPageDTO> content = mapper.pageFirstAudit(page, terms);
|
return new PageImpl<RmtjAuditPageDTO>(content, page, total);
|
}
|
|
/**
|
* web端-转入人民调解系统-批量申请转入初审
|
* @param rmtjAuditDTO 审核信息对象
|
* @param loginUser 当前登录用户
|
*/
|
public void batchFirstAudit(RmtjAuditDTO rmtjAuditDTO, CtUserDTO loginUser){
|
try{
|
Date nowDate = DateUtils.getNowDate();
|
for (String applyId: rmtjAuditDTO.getApplyIdList()) {
|
ThRmtjApply thRmtjApply = this.getById(applyId);
|
if (ObjectUtils.isNotEmpty(thRmtjApply)) {
|
int nowAuditNode = thRmtjApply.getAuditNode();
|
// 初审
|
if (RmtjConsts.AUDIT_NODE_1 == nowAuditNode){
|
// 审核通过的不能重新申
|
if (RmtjConsts.FIRST_AUDIT_1 != thRmtjApply.getFirstAuditResult()) {
|
thRmtjApply.setFirstAuditUser(loginUser.getId());
|
thRmtjApply.setFirstAuditUserName(loginUser.getTrueName());
|
thRmtjApply.setFirstAuditResult(rmtjAuditDTO.getAuditResult());
|
thRmtjApply.setFirstAuditTime(nowDate);
|
// 同意
|
if (RmtjConsts.AUDIT_RESULT_1 == rmtjAuditDTO.getAuditResult()) {
|
// 初审同意，进入终审
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_2);
|
thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_2);
|
|
// 终审单位为司法局
|
Map<String, Object> unitTerms = Maps.newHashMap();
|
unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_105);
|
List<CtUnitDTO> sfjUnitList = custClient.listByTerms(unitTerms);
|
if (CollectionUtils.isNotEmpty(sfjUnitList)) {
|
thRmtjApply.setEndAuditUnit(sfjUnitList.get(0).getId());
|
thRmtjApply.setEndAuditUnitName(sfjUnitList.get(0).getId());
|
}
|
} else {
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_9);
|
}
|
thRmtjApply.setUpdateTime(nowDate);
|
this.updateThRmtjApply(thRmtjApply);
|
// 添加审核记录
|
ThRmtjAudit thRmtjAudit = new ThRmtjAudit();
|
thRmtjAudit.setId(utilsClient.getNewTimeId());
|
thRmtjAudit.setCaseId(thRmtjApply.getCaseId());
|
thRmtjAudit.setApplyId(applyId);
|
thRmtjAudit.setAuditNode(RmtjConsts.AUDIT_NODE_1);
|
thRmtjAudit.setAuditResult(rmtjAuditDTO.getAuditResult());
|
thRmtjAudit.setAuditResultName(rmtjAuditDTO.getAuditResultName());
|
thRmtjAudit.setAuditContent(rmtjAuditDTO.getAuditContent());
|
thRmtjAudit.setAuditerId(loginUser.getId());
|
thRmtjAudit.setAuditerName(loginUser.getTrueName());
|
thRmtjAudit.setAuditUnitId(loginUser.getUnitId());
|
thRmtjAudit.setAuditUnitName(loginUser.getUnitName());
|
thRmtjAudit.setAuditTime(nowDate);
|
thRmtjAudit.setCreateTime(nowDate);
|
thRmtjAudit.setUpdateTime(nowDate);
|
thRmtjAudit.setCustId(loginUser.getCustId());
|
thRmtjAuditService.save(thRmtjAudit);
|
}
|
}
|
}
|
}
|
}catch (Exception e){
|
log.error("service方法[ThRmtjApplyService.batchFirstAudit]调用异常："+e, e);
|
throw new ServiceException("ThRmtjApplyService.batchFirstAudit", e);
|
}
|
}
|
|
/**
|
* web端-转入人民调解系统-审核获取申请信息
|
* @param applyId
|
* @return
|
*/
|
public ToRmtjApplyDTO getApplyInfo(String applyId){
|
ToRmtjApplyDTO toRmtjApplyDTO = new ToRmtjApplyDTO();
|
ThRmtjApply thRmtjApply = this.getById(applyId);
|
if (ObjectUtils.isNotEmpty(thRmtjApply)){
|
toRmtjApplyDTO.setApplyId(applyId);
|
// 初审
|
if (RmtjConsts.AUDIT_NODE_1 == thRmtjApply.getAuditNode()){
|
toRmtjApplyDTO.setApplyTime(thRmtjApply.getApplyTime());
|
toRmtjApplyDTO.setApplyUserId(thRmtjApply.getApplyUserId());
|
toRmtjApplyDTO.setApplyUserName(thRmtjApply.getApplyUserName());
|
toRmtjApplyDTO.setApplyUnitName(thRmtjApply.getApplyUnitName());
|
}else {
|
// 终审
|
toRmtjApplyDTO.setApplyTime(thRmtjApply.getFirstAuditTime());
|
toRmtjApplyDTO.setApplyUserId(thRmtjApply.getFirstAuditUser());
|
toRmtjApplyDTO.setApplyUserName(thRmtjApply.getFirstAuditUserName());
|
toRmtjApplyDTO.setApplyUnitName(thRmtjApply.getFirstAuditUnitName());
|
}
|
// 审核记录
|
QueryWrapper<ThRmtjApply> thRmtjApplyQueryWrapper = new QueryWrapper<>();
|
thRmtjApplyQueryWrapper.eq("case_id", thRmtjApply.getCaseId()).orderByAsc("apply_index");
|
List<ThRmtjApply> thRmtjApplyList = this.list(thRmtjApplyQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjApplyList)){
|
List<ToRmtjApplyListDTO> toRmtjApplyListDTOList = new ArrayList<>();
|
int i = 1;
|
for (ThRmtjApply rmtjApply: thRmtjApplyList){
|
ToRmtjApplyListDTO toRmtjApplyListDTO = new ToRmtjApplyListDTO();
|
toRmtjApplyListDTO.setIndex(i);
|
toRmtjApplyListDTO.setIndexName("第"+i+"次");
|
i++;
|
// 封装审核进度
|
List<ToRmtjAuditListDTO> auditList = new ArrayList<>();
|
// 发起申请
|
ToRmtjAuditListDTO fqsq = new ToRmtjAuditListDTO();
|
fqsq.setId(rmtjApply.getId());
|
fqsq.setUnitName(rmtjApply.getApplyUnitName()+"（发起申请）");
|
fqsq.setUserId(rmtjApply.getApplyUserId());
|
fqsq.setUserName(rmtjApply.getApplyUserName());
|
fqsq.setHandleTime(rmtjApply.getApplyTime());
|
fqsq.setStatus(1);
|
auditList.add(fqsq);
|
// 申请单在初审阶段
|
if (RmtjConsts.APPLY_PROCESS_1 == rmtjApply.getProcess()){
|
// 初审进行中
|
ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
|
zs.setId(rmtjApply.getFirstAuditUnit());
|
zs.setUnitName(rmtjApply.getFirstAuditUnitName()+"（审核中）");
|
zs.setStatus(0);
|
auditList.add(zs);
|
|
}else if (RmtjConsts.APPLY_PROCESS_2 == rmtjApply.getProcess()){
|
// 申请单在终审阶段
|
QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
|
thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
|
List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
|
for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
|
ToRmtjAuditListDTO cs = new ToRmtjAuditListDTO();
|
cs.setId(thRmtjAudit.getId());
|
if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
|
cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
|
}else {
|
cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
|
}
|
cs.setUserId(thRmtjAudit.getAuditerId());
|
cs.setUserName(thRmtjAudit.getAuditerName());
|
cs.setHandleTime(thRmtjAudit.getAuditTime());
|
cs.setHandleContent(thRmtjAudit.getAuditContent());
|
cs.setStatus(1);
|
auditList.add(cs);
|
}
|
}
|
// 终审进行中
|
ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
|
zs.setId(rmtjApply.getEndAuditUnit());
|
zs.setUnitName(rmtjApply.getEndAuditUnitName()+"（审核中）");
|
zs.setStatus(0);
|
auditList.add(zs);
|
}else {
|
// 已完成审核
|
QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
|
thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
|
List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
|
for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
|
ToRmtjAuditListDTO audit = new ToRmtjAuditListDTO();
|
audit.setId(thRmtjAudit.getId());
|
if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
|
audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
|
}else {
|
audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
|
}
|
audit.setUserId(thRmtjAudit.getAuditerId());
|
audit.setUserName(thRmtjAudit.getAuditerName());
|
audit.setHandleTime(thRmtjAudit.getAuditTime());
|
audit.setHandleContent(thRmtjAudit.getAuditContent());
|
audit.setStatus(1);
|
auditList.add(audit);
|
}
|
}
|
}
|
toRmtjApplyListDTO.setAuditList(auditList);
|
toRmtjApplyListDTOList.add(toRmtjApplyListDTO);
|
}
|
toRmtjApplyDTO.setApplyList(toRmtjApplyListDTOList);
|
}
|
}
|
return toRmtjApplyDTO;
|
}
|
|
/**
|
* web端-转入人民调解系统-批量移除申请
|
* @param caseIdList 申请案件编号集合
|
* @param loginUser 当前登录用户
|
*/
|
public void batchDeleteApply(List<String> caseIdList, CtUserDTO loginUser){
|
try{
|
Date nowDate = DateUtils.getNowDate();
|
for (String caseId: caseIdList) {
|
QueryWrapper<ThRmtjApply> thRmtjApplyQueryWrapper = new QueryWrapper<>();
|
thRmtjApplyQueryWrapper.eq("case_id", caseId).select("id", "process");
|
List<ThRmtjApply> thRmtjApplyList = this.list(thRmtjApplyQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjApplyList)) {
|
for (ThRmtjApply thRmtjApply : thRmtjApplyList) {
|
if (RmtjConsts.APPLY_PROCESS_1 == thRmtjApply.getProcess()
|
|| RmtjConsts.APPLY_PROCESS_2 == thRmtjApply.getProcess()
|
|| RmtjConsts.APPLY_PROCESS_9 == thRmtjApply.getProcess()) {
|
// 删除申请记录
|
this.removeById(thRmtjApply.getId());
|
|
// 删除审核记录
|
UpdateWrapper<ThRmtjAudit> thRmtjAuditUpdateWrapper = new UpdateWrapper<>();
|
thRmtjAuditUpdateWrapper.eq("apply_id", thRmtjApply.getId());
|
thRmtjAuditService.remove(thRmtjAuditUpdateWrapper);
|
}
|
}
|
}
|
}
|
}catch (Exception e){
|
log.error("service方法[ThRmtjApplyService.batchDeleteApply]调用异常："+e, e);
|
throw new ServiceException("ThRmtjApplyService.batchDeleteApply", e);
|
}
|
}
|
|
/**
|
* web端-转入人民调解系统-终审列表
|
* @param page 分页对象
|
* @param terms 条件
|
* @return Page
|
*/
|
public Page<RmtjAuditPageDTO> pageEndAudit(PageRequest page, Map<String, Object> terms){
|
long total = mapper.countPageEndAudit(terms);
|
List<RmtjAuditPageDTO> content = mapper.pageEndAudit(page, terms);
|
return new PageImpl<RmtjAuditPageDTO>(content, page, total);
|
}
|
|
|
/**
|
* web端-转入人民调解系统-批量申请转入终审
|
* @param rmtjAuditDTO 审核信息对象
|
* @param loginUser 当前登录用户
|
*/
|
public void batchEndAudit(RmtjAuditDTO rmtjAuditDTO, CtUserDTO loginUser){
|
try{
|
Date nowDate = DateUtils.getNowDate();
|
for (String applyId: rmtjAuditDTO.getApplyIdList()) {
|
ThRmtjApply thRmtjApply = this.getById(applyId);
|
if (ObjectUtils.isNotEmpty(thRmtjApply)) {
|
Boolean sendRmtjFlag = false;
|
int nowAuditNode = thRmtjApply.getAuditNode();
|
// 终审
|
if (RmtjConsts.AUDIT_NODE_2 == nowAuditNode){
|
// 审核通过的不能重新申
|
if (RmtjConsts.END_AUDIT_1 != thRmtjApply.getEndAuditResult()) {
|
thRmtjApply.setEndAuditUser(loginUser.getId());
|
thRmtjApply.setEndAuditUserName(loginUser.getTrueName());
|
thRmtjApply.setEndAuditResult(rmtjAuditDTO.getAuditResult());
|
thRmtjApply.setEndAuditTime(nowDate);
|
// 同意
|
if (RmtjConsts.AUDIT_RESULT_1 == rmtjAuditDTO.getAuditResult()) {
|
// 初审同意，进入终审
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_3);
|
thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_3);
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_2);
|
// 转入人民调解系统
|
sendRmtjFlag = true;
|
} else {
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_9);
|
}
|
thRmtjApply.setUpdateTime(nowDate);
|
this.updateThRmtjApply(thRmtjApply);
|
// 添加审核记录
|
ThRmtjAudit thRmtjAudit = new ThRmtjAudit();
|
thRmtjAudit.setId(utilsClient.getNewTimeId());
|
thRmtjAudit.setCaseId(thRmtjApply.getCaseId());
|
thRmtjAudit.setApplyId(applyId);
|
thRmtjAudit.setAuditNode(RmtjConsts.AUDIT_NODE_2);
|
thRmtjAudit.setAuditResult(rmtjAuditDTO.getAuditResult());
|
thRmtjAudit.setAuditResultName(rmtjAuditDTO.getAuditResultName());
|
thRmtjAudit.setAuditContent(rmtjAuditDTO.getAuditContent());
|
thRmtjAudit.setAuditerId(loginUser.getId());
|
thRmtjAudit.setAuditerName(loginUser.getTrueName());
|
thRmtjAudit.setAuditUnitId(loginUser.getUnitId());
|
thRmtjAudit.setAuditUnitName(loginUser.getUnitName());
|
thRmtjAudit.setAuditTime(nowDate);
|
thRmtjAudit.setCreateTime(nowDate);
|
thRmtjAudit.setUpdateTime(nowDate);
|
thRmtjAudit.setCustId(loginUser.getCustId());
|
thRmtjAuditService.save(thRmtjAudit);
|
// 是否转入人民调解系统
|
if (sendRmtjFlag) {
|
// 异步转入人民调解系统
|
ThreadPoolUtils.executor(new AsynStartDyhtoRmtj(thRmtjApply.getId(), thRmtjApply.getCaseId()));
|
}
|
}else {
|
|
}
|
}
|
}
|
}
|
}catch (Exception e){
|
log.error("service方法[ThRmtjApplyService.batchEndAudit]调用异常："+e, e);
|
throw new ServiceException("ThRmtjApplyService.batchEndAudit", e);
|
}
|
}
|
|
/**
|
* 终审通过转入人民调解系统-异步实现
|
*/
|
private class AsynStartDyhtoRmtj implements Runnable {
|
private String applyId;
|
private String caseId;
|
public AsynStartDyhtoRmtj(String applyId, String caseId) {
|
this.applyId = applyId;
|
this.caseId = caseId;
|
}
|
|
@Override
|
public void run() {
|
try{
|
Date rmtjTime = DateUtils.getNowDate();
|
String rmtjTimeStr = thRmtjConfigService.getByKindAndCode(RmtjConsts.CONFIG_KIND_1, RmtjConsts.CONFIG_CODE_1);
|
if (org.apache.commons.lang3.StringUtils.isNotEmpty(rmtjTimeStr)) {
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
rmtjTime = sdf.parse(rmtjTimeStr);
|
}
|
ThRmtjApply thRmtjApply = new ThRmtjApply();
|
thRmtjApply.setId(applyId);
|
if (SpringContextUtil.checkProd()) {
|
String result = null;
|
// 请求传输案件
|
try {
|
result = thRmtjService.dyhToRmtj(caseId, rmtjTime);
|
}catch (Exception e){
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_4);
|
thRmtjApply.setRmtjFalseInfo("请求返回报文{"+result+"},报错信息{"+e.getMessage()+"}");
|
}
|
// 解析返回信息
|
if (result != null) {
|
JSONObject jsonObject = null;
|
Integer code = null;
|
try {
|
jsonObject = JSONObject.fromObject(result);
|
code = jsonObject.getInt("code");
|
}catch (Exception e){
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_4);
|
thRmtjApply.setRmtjFalseInfo("请求返回报文{"+result+"},报错信息{"+e.getMessage()+"}");
|
}
|
// 解析data
|
if (code != null) {
|
if (code == 200) {
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_4);
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_3);
|
try {
|
JSONObject dataJSONObject = jsonObject.getJSONObject("data");
|
String rmtjCaseId = dataJSONObject.getString("caseNo");
|
thRmtjApply.setRmtjCaseId(rmtjCaseId);
|
thRmtjApply.setRmtjTime(rmtjTime);
|
} catch (Exception e) {
|
thRmtjApply.setRmtjFalseInfo("请求返回报文{" + result + "},报错信息{" + e.getMessage() + "}");
|
}
|
} else {
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_4);
|
thRmtjApply.setRmtjFalseInfo(result);
|
}
|
}
|
}
|
mapper.updateThRmtjApply(thRmtjApply);
|
}else {
|
thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_4);
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_3);
|
thRmtjApply.setRmtjTime(rmtjTime);
|
mapper.updateThRmtjApply(thRmtjApply);
|
}
|
}catch (Exception e){
|
log.error(e.getMessage());
|
}
|
}
|
}
|
|
/**
|
* web端-转入人民调解系统-申请记录
|
* @param caseId
|
* @return
|
*/
|
public ToRmtjApplyDTO getCaseApplyRmtj(String caseId){
|
ToRmtjApplyDTO toRmtjApplyDTO = null;
|
// 审核记录
|
QueryWrapper<ThRmtjApply> thRmtjApplyQueryWrapper = new QueryWrapper<>();
|
thRmtjApplyQueryWrapper.eq("case_id", caseId).orderByAsc("apply_index");
|
List<ThRmtjApply> thRmtjApplyList = this.list(thRmtjApplyQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjApplyList)){
|
toRmtjApplyDTO = new ToRmtjApplyDTO();
|
toRmtjApplyDTO.setType("转入人民调解系统申请");
|
ThRmtjApply newRmtjApply = thRmtjApplyList.get(thRmtjApplyList.size()-1);
|
if (RmtjConsts.APPLY_PROCESS_1 == newRmtjApply.getProcess() || RmtjConsts.APPLY_PROCESS_2 == newRmtjApply.getProcess() ){
|
toRmtjApplyDTO.setApplyStatus(0);
|
}else if (RmtjConsts.APPLY_PROCESS_9 == newRmtjApply.getProcess()){
|
toRmtjApplyDTO.setApplyStatus(1);
|
toRmtjApplyDTO.setAuditResult(AuditBaseConstsEnum.AUDIT_RESULT_2.getIndex());
|
toRmtjApplyDTO.setAuditResultName("审核未通过");
|
}else {
|
toRmtjApplyDTO.setApplyStatus(1);
|
toRmtjApplyDTO.setAuditResult(AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex());
|
toRmtjApplyDTO.setAuditResultName("审核通过");
|
}
|
// 申请信息
|
toRmtjApplyDTO.setApplyId(thRmtjApplyList.get(0).getId());
|
toRmtjApplyDTO.setApplyTime(thRmtjApplyList.get(0).getApplyTime());
|
toRmtjApplyDTO.setApplyUserId(thRmtjApplyList.get(0).getApplyUserId());
|
toRmtjApplyDTO.setApplyUserName(thRmtjApplyList.get(0).getApplyUserName());
|
toRmtjApplyDTO.setApplyUnitName(thRmtjApplyList.get(0).getApplyUnitName());
|
// 审核进度
|
List<ToRmtjApplyListDTO> toRmtjApplyListDTOList = new ArrayList<>();
|
int i = 1;
|
for (ThRmtjApply rmtjApply: thRmtjApplyList){
|
ToRmtjApplyListDTO toRmtjApplyListDTO = new ToRmtjApplyListDTO();
|
toRmtjApplyListDTO.setIndex(i);
|
toRmtjApplyListDTO.setIndexName("第"+i+"次");
|
i++;
|
// 封装审核进度
|
List<ToRmtjAuditListDTO> auditList = new ArrayList<>();
|
// 发起申请
|
ToRmtjAuditListDTO fqsq = new ToRmtjAuditListDTO();
|
fqsq.setId(rmtjApply.getId());
|
fqsq.setUnitName(rmtjApply.getApplyUnitName()+"（发起申请）");
|
fqsq.setUserId(rmtjApply.getApplyUserId());
|
fqsq.setUserName(rmtjApply.getApplyUserName());
|
fqsq.setHandleTime(rmtjApply.getApplyTime());
|
fqsq.setStatus(1);
|
auditList.add(fqsq);
|
// 申请单在初审阶段
|
if (RmtjConsts.APPLY_PROCESS_1 == rmtjApply.getProcess()){
|
// 初审进行中
|
ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
|
zs.setId(rmtjApply.getFirstAuditUnit());
|
zs.setUnitName(rmtjApply.getFirstAuditUnitName()+"（审核中）");
|
zs.setStatus(0);
|
auditList.add(zs);
|
|
}else if (RmtjConsts.APPLY_PROCESS_2 == rmtjApply.getProcess()){
|
// 申请单在终审阶段
|
QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
|
thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
|
List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
|
for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
|
ToRmtjAuditListDTO cs = new ToRmtjAuditListDTO();
|
cs.setId(thRmtjAudit.getId());
|
if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
|
cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
|
}else {
|
cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
|
}
|
cs.setUserId(thRmtjAudit.getAuditerId());
|
cs.setUserName(thRmtjAudit.getAuditerName());
|
cs.setHandleTime(thRmtjAudit.getAuditTime());
|
cs.setHandleContent(thRmtjAudit.getAuditContent());
|
cs.setStatus(1);
|
auditList.add(cs);
|
}
|
}
|
// 终审进行中
|
ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
|
zs.setId(rmtjApply.getEndAuditUnit());
|
zs.setUnitName(rmtjApply.getEndAuditUnitName()+"（审核中）");
|
zs.setStatus(0);
|
auditList.add(zs);
|
}else {
|
// 已完成审核
|
QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
|
thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
|
List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
|
if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
|
for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
|
ToRmtjAuditListDTO audit = new ToRmtjAuditListDTO();
|
audit.setId(thRmtjAudit.getId());
|
if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
|
audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
|
}else {
|
audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
|
}
|
audit.setUserId(thRmtjAudit.getAuditerId());
|
audit.setUserName(thRmtjAudit.getAuditerName());
|
audit.setHandleTime(thRmtjAudit.getAuditTime());
|
audit.setHandleContent(thRmtjAudit.getAuditContent());
|
audit.setStatus(1);
|
auditList.add(audit);
|
}
|
}
|
}
|
toRmtjApplyListDTO.setAuditList(auditList);
|
toRmtjApplyListDTOList.add(toRmtjApplyListDTO);
|
}
|
toRmtjApplyDTO.setApplyList(toRmtjApplyListDTOList);
|
}
|
return toRmtjApplyDTO;
|
}
|
|
/**
|
* 批量重转入人民调解系统
|
* @param applyIdList 批量申请编号
|
*/
|
public void batchReSendRmtj(List<String> applyIdList, CtUserDTO loginUser){
|
try{
|
for (String applyId: applyIdList) {
|
ThRmtjApply thRmtjApply = this.getById(applyId);
|
if (RmtjConsts.AUDIT_NODE_3 ==thRmtjApply.getAuditNode() &&
|
RmtjConsts.RMTJ_STATUS_4 ==thRmtjApply.getRmtjStatus()) {
|
// 修改转入人民调解系统状态为转入中
|
thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_2);
|
this.updateThRmtjApply(thRmtjApply);
|
// 异步转入人民调解系统
|
ThreadPoolUtils.executor(new AsynStartDyhtoRmtj(thRmtjApply.getId(), thRmtjApply.getCaseId()));
|
}
|
}
|
}catch (Exception e){
|
log.error("service方法[ThRmtjApplyService.batchReSendRmtj]调用异常："+e, e);
|
throw new ServiceException("ThRmtjApplyService.batchReSendRmtj", e);
|
}
|
}
|
|
/**
|
* 查询某一单位的所有管辖单位id，包括自己
|
* @param parentId 父级单位编号
|
* @return String
|
*/
|
public List<String> listAllChild(@Param("parentId") String parentId){
|
return mapper.listAllUnitId(parentId);
|
}
|
|
}
|
