From 80cc7fd5df68a78df4921379a4909a8025febdfc Mon Sep 17 00:00:00 2001
From: xusd <hugeinfo123>
Date: Sun, 27 Oct 2024 16:09:03 +0800
Subject: [PATCH] Merge branch 'gzdyh_test' into gzdyh_grid
---
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/SyCause.java | 71
dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java | 13
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/web/SyCauseWebController.java | 175 ++
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/SyncBydyhController.java | 45
dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/service/CaseInfoService.java | 284 +++
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/SyncBydyhClient.java | 18
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/ThirdCause.java | 83 +
dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseTaskMapper.java | 6
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/impl/SyncBydyhClientImpl.java | 53
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/ThirdCauseBO.java | 17
dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseTaskMapper.xml | 7
dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/domain/dto/GZCaseDTO.java | 3
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/GZCaseDTO.java | 2
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/ThirdCauseMapper.java | 64
dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/CustClient.java | 9
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/ByCaseTaskDTO.java | 317 ++++
dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/dao/mapper/xml/CaseInfoMapper.xml | 5
dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/impl/CustClientImpl.java | 23
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/ThirdCauseMapper.xml | 157 ++
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/SyCauseMapper.java | 64
dyh-service/dyh-disp/src/main/java/cn/huge/module/casedisp/service/SysDispService.java | 6
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/SyCauseBO.java | 17
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/SyCauseService.java | 133 +
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzCaseTaskService.java | 2199 ++++++++++++++++++++++++++++++
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ThirdCauseService.java | 113 +
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzService.java | 215 ++
dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/controller/SyncCaseController.java | 37
dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/SyCauseMapper.xml | 145 ++
28 files changed, 4,257 insertions(+), 24 deletions(-)
diff --git a/dyh-service/dyh-disp/src/main/java/cn/huge/module/casedisp/service/SysDispService.java b/dyh-service/dyh-disp/src/main/java/cn/huge/module/casedisp/service/SysDispService.java
index 8311cfd..5a7fefe 100644
--- a/dyh-service/dyh-disp/src/main/java/cn/huge/module/casedisp/service/SysDispService.java
+++ b/dyh-service/dyh-disp/src/main/java/cn/huge/module/casedisp/service/SysDispService.java
@@ -11,6 +11,7 @@
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.constant.BaseConsts;
import cn.huge.module.cust.constant.UserBaseConsts;
+import cn.huge.module.cust.dto.CtUnitDTO;
import cn.huge.module.disp.constant.DispBaseConsts;
import cn.huge.module.disp.constant.DispBaseConstsEnum;
import cn.huge.module.disp.dto.CaseDispBaseDTO;
@@ -50,6 +51,8 @@
@Autowired
private UtilsClientImpl utilsClient;
+ @Autowired
+ private CustClientImpl custClient;
/**
* 系统自动调度
@@ -109,6 +112,9 @@
caseDisp.setTargetTypeName(DispBaseConstsEnum.TARGET_TYPE_1.getDes());
caseDisp.setTargetId(dispCaseBaseDTO.getWantUnitId());
caseDisp.setTargetName(dispCaseBaseDTO.getWantUnitName());
+ CtUnitDTO ctUnitDTO = custClient.getUnitById(dispCaseBaseDTO.getWantUnitId());
+ caseDisp.setTargetUnitGrade(ctUnitDTO.getUnitGrade());
+ caseDisp.setTargetUnitType(ctUnitDTO.getUnitType());
}
caseDispService.save(caseDisp);
return caseDisp;
diff --git a/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/CustClient.java b/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/CustClient.java
index e3380e9..51cb455 100644
--- a/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/CustClient.java
+++ b/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/CustClient.java
@@ -43,4 +43,13 @@
@GetMapping("/api/client/paUser/clientGetUserAll")
ReturnBO paclientGetUser(@RequestParam("userId") String userId);
+ /**
+ * 根据id查询组织信息
+ * @url {ctx}/api/client/ctUnit/getUnitById
+ * @param unitId 组织编号
+ * @return Object
+ */
+ @GetMapping("/api/client/ctUnit/getUnitById")
+ ReturnBO getUnitById(@RequestParam("unitId") String unitId);
+
}
diff --git a/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/impl/CustClientImpl.java b/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/impl/CustClientImpl.java
index 5f5609c..6611471 100644
--- a/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/impl/CustClientImpl.java
+++ b/dyh-service/dyh-disp/src/main/java/cn/huge/module/client/api/impl/CustClientImpl.java
@@ -5,6 +5,7 @@
import cn.huge.base.common.exception.ClientException;
import cn.huge.base.common.exception.ServiceException;
import cn.huge.module.client.api.CustClient;
+import cn.huge.module.cust.dto.CtUnitDTO;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.cust.dto.PaUserDTO;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -99,4 +100,26 @@
}
}
+ /**
+ * 根据id查询组织信息
+ * @url {ctx}/api/client/ctUnit/getUnitById
+ * @param unitId 组织编号
+ * @return Object
+ */
+ public CtUnitDTO getUnitById(String unitId){
+ try{
+ ReturnBO returnBo = custClient.getUnitById(unitId);
+ if (ReturnConsts.OK == returnBo.getCode()){
+ CtUnitDTO ctUnitDTO = objectMapper.convertValue(returnBo.getData(), CtUnitDTO.class);
+ return ctUnitDTO;
+ }else{
+ log.error("Client外服务接口[CustClientImpl.getUnitById]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
+ throw new ClientException("CustClientImpl.getUnitById", returnBo.getMsg());
+ }
+ }catch (Exception e){
+ log.error("service方法[CustClientImpl.getUnitById]调用异常："+e, e);
+ throw new ServiceException("CustClientImpl.getUnitById", e);
+ }
+ }
+
}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseTaskMapper.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseTaskMapper.java
index b1d4bf8..12e290f 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseTaskMapper.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseTaskMapper.java
@@ -173,4 +173,10 @@
*/
List<FrontPageListYBDTO> pageMyTaskYb(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);
+ /**
+ * 根据编号物理删除
+ * @param caseId
+ */
+ void deleteByCaseId(@Param("caseId") String caseId);
+
}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseTaskMapper.xml b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseTaskMapper.xml
index 32e04b0..66804ba 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseTaskMapper.xml
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseTaskMapper.xml
@@ -817,4 +817,11 @@
limit #{page.offset}, #{page.size}
</select>
+ <!-- 根据编号物理删除 -->
+ <delete id="deleteByCaseId">
+ delete from
+ <include refid="table-name" />
+ where case_id = #{caseId}
+ </delete>
+
</mapper>
\ No newline at end of file
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java
index 510d94f..fb758dd 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java
@@ -3319,6 +3319,19 @@
}
}
+ /**
+ * 根据编号物理删除
+ * @param caseId
+ */
+ public void deleteByCaseId(String caseId){
+ try{
+ mapper.deleteByCaseId(caseId);
+ }catch (Exception e){
+ log.error("[CaseTaskService.deleteByCaseId]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.deleteByCaseId", e);
+ }
+ }
+
public void deleteGridTodo(CaseTask caseTask) {
try {
//删除网格待办任务
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/SyncBydyhClient.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/SyncBydyhClient.java
index 2e577cd..703e8de 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/SyncBydyhClient.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/SyncBydyhClient.java
@@ -34,4 +34,22 @@
@GetMapping("/api/client/syncCase/countEndCase")
ReturnBO countEndCase();
+ /**
+ * 数据割接-进行中的纠纷案件信息
+ * @url {ctx}/api/client/syncCase/byToGzTodoCase
+ * @param page
+ * @param size
+ * @return
+ */
+ @GetMapping("/api/client/syncCase/byToGzTodoCase")
+ ReturnBO byToGzTodoCase(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size);
+
+ /**
+ * 数据割接-统计进行中的纠纷案件信息
+ * @url {ctx}/api/client/syncCase/countTodoCase
+ * @return
+ */
+ @GetMapping("/api/client/syncCase/countTodoCase")
+ ReturnBO countTodoCase();
+
}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/impl/SyncBydyhClientImpl.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/impl/SyncBydyhClientImpl.java
index daaaacf..2f2583c 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/impl/SyncBydyhClientImpl.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/client/api/impl/SyncBydyhClientImpl.java
@@ -44,7 +44,7 @@
/**
* 数据割接-已结束的纠纷案件信息
- * @url {ctx}/api/client/syncCust/byToGzCtUnit
+ * @url {ctx}/api/client/syncCust/byToGzEndCase
* @return Object
*/
public List<GZCaseDTO> byToGzEndCase(int page, int size){
@@ -93,4 +93,55 @@
return 0;
}
+ /**
+ * 数据割接-进行中的纠纷案件信息
+ * @url {ctx}/api/client/syncCust/byToGzTodoCase
+ * @return Object
+ */
+ public List<GZCaseDTO> byToGzTodoCase(int page, int size){
+ List<GZCaseDTO> resultList = new ArrayList<>();
+ try{
+ ReturnBO returnBo = syncBydyhClient.byToGzTodoCase(page, size);
+ if (ReturnConsts.OK == returnBo.getCode()){
+ if (ObjectUtils.isNotEmpty(returnBo.getData())){
+ List<LinkedHashMap> list = (List<LinkedHashMap>) returnBo.getData();
+ for (LinkedHashMap map : list) {
+ GZCaseDTO result = JSON.parseObject(JSON.toJSONString(map), GZCaseDTO.class);
+ resultList.add(result);
+ }
+ }
+ }else{
+ log.error("Client外服务接口[SyncBydyhClient.byToGzTodoCase]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
+ throw new ClientException("SyncBydyhClient.byToGzTodoCase", returnBo.getMsg());
+ }
+ }catch (Exception e){
+ log.error("service方法[SyncBydyhClient.byToGzTodoCase]调用异常："+e, e);
+ }
+ return resultList;
+ }
+
+ /**
+ * 数据割接-统计进行中的纠纷案件信息
+ * @url {ctx}/api/client/syncCust/countTodoCase
+ * @return Object
+ */
+ public int countTodoCase(){
+ try{
+ ReturnBO returnBo = syncBydyhClient.countTodoCase();
+ if (ReturnConsts.OK == returnBo.getCode()) {
+ if (ObjectUtils.isNotEmpty(returnBo.getData())){
+ return (Integer) returnBo.getData();
+ }else {
+ return 0;
+ }
+ } else {
+ log.error("Client外服务接口[SyncBydyhClient.countTodoCase]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
+ throw new ClientException("SyncBydyhClient.countTodoCase", returnBo.getMsg());
+ }
+ }catch (Exception e){
+ log.error("service方法[SyncBydyhClient.countTodoCase]调用异常："+e, e);
+ }
+ return 0;
+ }
+
}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/SyncBydyhController.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/SyncBydyhController.java
index 5f15a75..d530f57 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/SyncBydyhController.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/SyncBydyhController.java
@@ -44,4 +44,49 @@
return ReturnFailUtils.getRepInfo();
}
}
+
+ /**
+ * 白云区矛盾纠纷多元化解平台数据割接-进行中的纠纷案件信息
+ * @url {ctx}/api/syncBydyh/byToGzTodoCase
+ * @return Object
+ */
+ @GetMapping("/byToGzTodoCase")
+ public Object byToGzTodoCase() {
+ try {
+ service.byToGzTodoCase();
+ return ReturnSucUtils.getRepInfo();
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+ /**
+ * 白云区矛盾纠纷多元化解平台数据割接-更新纠纷类型
+ * @url {ctx}/api/syncBydyh/upThirdCause
+ * @return Object
+ */
+ @GetMapping("/upThirdCause")
+ public Object upThirdCause() {
+ try {
+ service.upThirdCause();
+ return ReturnSucUtils.getRepInfo();
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+ /**
+ * 白云区矛盾纠纷多元化解平台数据割接-更新问题属地的村级社区
+ * @url {ctx}/api/syncBydyh/upThirdCause
+ * @return Object
+ */
+ @GetMapping("/upQueAddr")
+ public Object upQueAddr() {
+ try {
+ service.upQueAddr();
+ return ReturnSucUtils.getRepInfo();
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/web/SyCauseWebController.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/web/SyCauseWebController.java
new file mode 100644
index 0000000..7021a1c
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/controller/web/SyCauseWebController.java
@@ -0,0 +1,175 @@
+package cn.huge.module.syncbydyh.controller.web;
+
+import cn.huge.base.common.utils.ReturnFailUtils;
+import cn.huge.base.common.utils.ReturnSucUtils;
+import cn.huge.module.syncbydyh.domain.po.SyCause;
+import cn.huge.module.syncbydyh.service.SyCauseService;
+import com.google.common.collect.Maps;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * @title: 纠纷类型信息表接口api-web端
+ * @description: 纠纷类型信息表接口api-web端
+ * @company: hugeinfo
+ * @author: liyj
+ * @time: 2024-10-21 22:18:51
+ * @version: 1.0.0
+ */
+@Slf4j
+@RestController
+@RequestMapping("/api/web/syCause")
+public class SyCauseWebController {
+
+ @Autowired(required = false)
+ private HttpServletRequest request;
+
+ @Autowired
+ private SyCauseService service;
+
+ /**
+ * 获取请求URL参数
+ * @return Map<String, Object>
+ */
+ private Map<String, Object> getParameter(){
+ Map<String, Object> terms = Maps.newHashMap();
+ // 编码
+ String id = request.getParameter("id");
+ if (StringUtils.isNotBlank(id)){
+ terms.put("id", id);
+ }
+ // 名称
+ String name = request.getParameter("name");
+ if (StringUtils.isNotBlank(name)){
+ terms.put("name", name);
+ }
+ // 层级
+ String level = request.getParameter("level");
+ if (StringUtils.isNotBlank(level)){
+ terms.put("level", level);
+ }
+ // 父级编码
+ String parentId = request.getParameter("parentId");
+ if (StringUtils.isNotBlank(parentId)){
+ terms.put("parentId", parentId);
+ }
+ // 调解类型
+ String issueId = request.getParameter("issueId");
+ if (StringUtils.isNotBlank(issueId)){
+ terms.put("issueId", issueId);
+ }
+ // 展示图标
+ String icon = request.getParameter("icon");
+ if (StringUtils.isNotBlank(icon)){
+ terms.put("icon", icon);
+ }
+ // 创建时间区间
+ String createStart = request.getParameter("createStart");
+ String createEnd = request.getParameter("createEnd");
+ if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
+ terms.put("createStart", createStart);
+ terms.put("createEnd", createEnd);
+ }
+ // 更新时间区间
+ String updateStart = request.getParameter("updateStart");
+ String updateEnd = request.getParameter("updateEnd");
+ if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
+ terms.put("updateStart", updateStart);
+ terms.put("updateEnd", updateEnd);
+ }
+ return terms;
+ }
+
+ /**
+ * 条件查询多个
+ * @url {ctx}/api/web/syCause/listQuery
+ * @return Object
+ */
+ @GetMapping("/listQuery")
+ public Object listQuery() {
+ try {
+ Map<String, Object> terms = getParameter();
+ return ReturnSucUtils.getRepInfo(service.listTerms(terms));
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+ /**
+ * 条件分页查询
+ * @url {ctx}/api/web/syCause/pageQuery
+ * @param page 页码
+ * @param size 每页数量
+ * @return Object
+ */
+ @GetMapping("/pageQuery")
+ public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
+ try {
+ Map<String, Object> terms = getParameter();
+ Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
+ PageRequest pageRequest = PageRequest.of(page-1, size, sort);
+ Page<SyCause> syCausePage = service.pageQuery(pageRequest, terms);
+ return ReturnSucUtils.getRepInfo( "处理成功", syCausePage);
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+ /**
+ * 根据编号查询单个
+ * @url {ctx}/api/web/syCause/getById
+ * @param id 主键编号
+ * @return Object
+ */
+ @GetMapping("/getById")
+ public Object getById(@RequestParam(value = "id") String id) {
+ try {
+ return ReturnSucUtils.getRepInfo(service.getById(id));
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+ /**
+ * 根据主键单个
+ * @url {ctx}/api/web/syCause/deleteById
+ * @param id 主键编号
+ * @return Object
+ */
+ @GetMapping("/deleteById")
+ public Object deleteById(@RequestParam(value = "id") String id) {
+ try {
+ service.removeById(id);
+ return ReturnSucUtils.getRepInfo();
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+ /**
+ * 新增或更新对象
+ * @url {ctx}/api/web/syCause/saveSyCause
+ * @param syCause 实体对象
+ * @return Object
+ */
+ @PostMapping("/saveSyCause")
+ public Object saveSyCause(@RequestBody SyCause syCause) {
+ try {
+ service.saveSyCause(syCause);
+ return ReturnSucUtils.getRepInfo();
+ } catch (Exception e) {
+ return ReturnFailUtils.getRepInfo();
+ }
+ }
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/SyCauseMapper.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/SyCauseMapper.java
new file mode 100644
index 0000000..ec2cea6
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/SyCauseMapper.java
@@ -0,0 +1,64 @@
+package cn.huge.module.syncbydyh.dao.mapper;
+
+import cn.huge.module.syncbydyh.domain.po.SyCause;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @title: 纠纷类型信息表持久层业务处理
+* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
+* @company: hugeinfo
+* @author: liyj
+* @time: 2024-10-21 22:18:51
+* @version 1.0.0
+*/
+@Repository
+public interface SyCauseMapper extends BaseMapper<SyCause>{
+
+ /**
+ * 更新对象
+ * @param entity 对象
+ */
+ void updateSyCause(@Param("entity") SyCause entity);
+
+ /**
+ * 条件更新对象
+ * @param entity 对象
+ * @param terms 条件
+ */
+ void updateSyCauseTerms(@Param("entity") SyCause entity, @Param("terms") Map<String, Object> terms);
+
+ /**
+ * 根据编号物理删除
+ * @param id 查询条件集合
+ */
+ void deleteSyCause(@Param("id") String id);
+
+ /**
+ * 按条件查询结果集
+ * @param terms 查询条件集合
+ * @return List<SyCause>
+ */
+ List<SyCause> listTerms(@Param("terms") Map<String, Object> terms);
+
+ /**
+ * 按条件查询实体总数
+ * @param terms 查询条件集合
+ * @return long
+ */
+ long countTerms(@Param("terms") Map<String, Object> terms);
+
+ /**
+ * 按条件查询实体分页结果集
+ * @param page 分页对象
+ * @param terms 查询条件集合
+ * @return List<SyCause>
+ */
+ List<SyCause> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/ThirdCauseMapper.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/ThirdCauseMapper.java
new file mode 100644
index 0000000..3afe3c8
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/ThirdCauseMapper.java
@@ -0,0 +1,64 @@
+package cn.huge.module.syncbydyh.dao.mapper;
+
+import cn.huge.module.syncbydyh.domain.po.ThirdCause;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @title: 第三方纠纷类型映射表持久层业务处理
+* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
+* @company: hugeinfo
+* @author: liyj
+* @time: 2024-10-21 22:04:49
+* @version 1.0.0
+*/
+@Repository
+public interface ThirdCauseMapper extends BaseMapper<ThirdCause>{
+
+ /**
+ * 更新对象
+ * @param entity 对象
+ */
+ void updateThirdCause(@Param("entity") ThirdCause entity);
+
+ /**
+ * 条件更新对象
+ * @param entity 对象
+ * @param terms 条件
+ */
+ void updateThirdCauseTerms(@Param("entity") ThirdCause entity, @Param("terms") Map<String, Object> terms);
+
+ /**
+ * 根据编号物理删除
+ * @param id 查询条件集合
+ */
+ void deleteThirdCause(@Param("id") String id);
+
+ /**
+ * 按条件查询结果集
+ * @param terms 查询条件集合
+ * @return List<ThirdCause>
+ */
+ List<ThirdCause> listTerms(@Param("terms") Map<String, Object> terms);
+
+ /**
+ * 按条件查询实体总数
+ * @param terms 查询条件集合
+ * @return long
+ */
+ long countTerms(@Param("terms") Map<String, Object> terms);
+
+ /**
+ * 按条件查询实体分页结果集
+ * @param page 分页对象
+ * @param terms 查询条件集合
+ * @return List<ThirdCause>
+ */
+ List<ThirdCause> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/SyCauseMapper.xml b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/SyCauseMapper.xml
new file mode 100644
index 0000000..36bfcbe
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/SyCauseMapper.xml
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!--
+ * @title: 纠纷类型信息表
+ * @description: 自定义sql，请自行实现业务逻辑
+ * @company: hugeinfo
+ * @author: liyj
+ * @time:2024-10-21 22:18:51
+ * @version 1.0.0
+-->
+<mapper namespace="cn.huge.module.syncbydyh.dao.mapper.SyCauseMapper">
+ <!-- 结果集 -->
+ <resultMap id="dataResult" type="cn.huge.module.syncbydyh.domain.po.SyCause">
+ <result property="id" column="id"/>
+ <result property="name" column="name"/>
+ <result property="level" column="level"/>
+ <result property="parentId" column="parent_id"/>
+ <result property="issueId" column="issue_id"/>
+ <result property="createTime" column="create_time"/>
+ <result property="updateTime" column="update_time"/>
+ <result property="icon" column="icon"/>
+ </resultMap>
+ <!-- 表 -->
+ <sql id='table-name'>dyh_sy_cause</sql>
+ <!-- 字段 -->
+ <sql id="column-part">
+ id,
+ name,
+ level,
+ parent_id,
+ issue_id,
+ create_time,
+ update_time,
+ icon
+ </sql>
+ <!-- 更新实体字段 -->
+ <sql id="set-part">
+ <if test="entity.name != null">name = #{entity.name},</if>
+ <if test="entity.level != null">level = #{entity.level},</if>
+ <if test="entity.parentId != null">parent_id = #{entity.parentId},</if>
+ <if test="entity.issueId != null">issue_id = #{entity.issueId},</if>
+ <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
+ <if test="entity.updateTime != null">update_time = #{entity.updateTime},</if>
+ <if test="entity.icon != null">icon = #{entity.icon}</if>
+ </sql>
+ <!-- 条件 -->
+ <sql id="where-part">
+ <if test="terms != null">
+ <where>
+ <if test="terms.id != null and terms.id !=''">
+ and id = #{terms.id}
+ </if>
+ <if test="terms.name != null and terms.name !=''">
+ and name = #{terms.name}
+ </if>
+ <if test="terms.level != null and terms.level !=''">
+ and level = #{terms.level}
+ </if>
+ <if test="terms.parentId != null and terms.parentId !=''">
+ and parent_id = #{terms.parentId}
+ </if>
+ <if test="terms.issueId != null and terms.issueId !=''">
+ and issue_id = #{terms.issueId}
+ </if>
+ <if test="terms.createTime != null and terms.createTime !=''">
+ and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
+ </if>
+ <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
+ and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
+ and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
+ </if>
+ <if test="terms.updateTime != null and terms.updateTime !=''">
+ and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
+ </if>
+ <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
+ and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
+ and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
+ </if>
+ <if test="terms.icon != null and terms.icon !=''">
+ and icon = #{terms.icon}
+ </if>
+ </where>
+ </if>
+ </sql>
+ <!-- 更新对象 -->
+ <update id="updateSyCause">
+ update
+ <include refid="table-name"/>
+ <set>
+ <include refid="set-part"/>
+ </set>
+ <where>
+ id = #{entity.id}
+ </where>
+ </update>
+ <!-- 条件更新对象 -->
+ <update id="updateSyCauseTerms">
+ update
+ <include refid="table-name"/>
+ <set>
+ <include refid="set-part"/>
+ </set>
+ <include refid="where-part"/>
+ </update>
+ <!-- 根据编号物理删除 -->
+ <delete id="deleteSyCause">
+ delete from
+ <include refid="table-name" />
+ where id = #{id}
+ </delete>
+ <!-- 根据条件查询 -->
+ <select id="listTerms" resultMap="dataResult">
+ select
+ <include refid="column-part"/>
+ from
+ <include refid="table-name" />
+ <include refid="where-part"/>
+ </select>
+ <!-- 根据条件统计 -->
+ <select id="countTerms" resultType="java.lang.Long">
+ select
+ COUNT(1)
+ from
+ <include refid="table-name" />
+ <include refid="where-part"/>
+ </select>
+ <!-- 根据条件分页查询 -->
+ <select id="pageTerms" resultMap="dataResult">
+ SELECT
+ <include refid="column-part"/>
+ FROM
+ <include refid="table-name" />
+ <include refid="where-part"/>
+ <if test="page.sort != null">
+ <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
+ isnull(${s.property}), ${s.property} ${s.direction}
+ </foreach>
+ </if>
+ <if test="page.sort == null">
+ order by isnull(create_time), create_time desc
+ </if>
+ limit #{page.offset}, #{page.size}
+ </select>
+
+</mapper>
\ No newline at end of file
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/ThirdCauseMapper.xml b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/ThirdCauseMapper.xml
new file mode 100644
index 0000000..03e7f31
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/dao/mapper/xml/ThirdCauseMapper.xml
@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!--
+ * @title: 第三方纠纷类型映射表
+ * @description: 自定义sql，请自行实现业务逻辑
+ * @company: hugeinfo
+ * @author: liyj
+ * @time:2024-10-21 22:04:49
+ * @version 1.0.0
+-->
+<mapper namespace="cn.huge.module.syncbydyh.dao.mapper.ThirdCauseMapper">
+ <!-- 结果集 -->
+ <resultMap id="dataResult" type="cn.huge.module.syncbydyh.domain.po.ThirdCause">
+ <result property="id" column="id"/>
+ <result property="thirdSysId" column="third_sys_id"/>
+ <result property="thirdSysName" column="third_sys_name"/>
+ <result property="thirdCode" column="third_code"/>
+ <result property="thirdName" column="third_name"/>
+ <result property="thirdParentCode" column="third_parent_code"/>
+ <result property="causeCode" column="cause_code"/>
+ <result property="level" column="level"/>
+ <result property="createTime" column="create_time"/>
+ <result property="updateTime" column="update_time"/>
+ </resultMap>
+ <!-- 表 -->
+ <sql id='table-name'>dyh_th_third_cause</sql>
+ <!-- 字段 -->
+ <sql id="column-part">
+ id,
+ third_sys_id,
+ third_sys_name,
+ third_code,
+ third_name,
+ third_parent_code,
+ cause_code,
+ level,
+ create_time,
+ update_time
+ </sql>
+ <!-- 更新实体字段 -->
+ <sql id="set-part">
+ <if test="entity.thirdSysId != null">third_sys_id = #{entity.thirdSysId},</if>
+ <if test="entity.thirdSysName != null">third_sys_name = #{entity.thirdSysName},</if>
+ <if test="entity.thirdCode != null">third_code = #{entity.thirdCode},</if>
+ <if test="entity.thirdName != null">third_name = #{entity.thirdName},</if>
+ <if test="entity.thirdParentCode != null">third_parent_code = #{entity.thirdParentCode},</if>
+ <if test="entity.causeCode != null">cause_code = #{entity.causeCode},</if>
+ <if test="entity.level != null">level = #{entity.level},</if>
+ <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
+ <if test="entity.updateTime != null">update_time = #{entity.updateTime}</if>
+ </sql>
+ <!-- 条件 -->
+ <sql id="where-part">
+ <if test="terms != null">
+ <where>
+ <if test="terms.id != null and terms.id !=''">
+ and id = #{terms.id}
+ </if>
+ <if test="terms.thirdSysId != null and terms.thirdSysId !=''">
+ and third_sys_id = #{terms.thirdSysId}
+ </if>
+ <if test="terms.thirdSysName != null and terms.thirdSysName !=''">
+ and third_sys_name = #{terms.thirdSysName}
+ </if>
+ <if test="terms.thirdCode != null and terms.thirdCode !=''">
+ and third_code = #{terms.thirdCode}
+ </if>
+ <if test="terms.thirdName != null and terms.thirdName !=''">
+ and third_name = #{terms.thirdName}
+ </if>
+ <if test="terms.thirdParentCode != null and terms.thirdParentCode !=''">
+ and third_parent_code = #{terms.thirdParentCode}
+ </if>
+ <if test="terms.causeCode != null and terms.causeCode !=''">
+ and cause_code = #{terms.causeCode}
+ </if>
+ <if test="terms.level != null and terms.level !=''">
+ and level = #{terms.level}
+ </if>
+ <if test="terms.createTime != null and terms.createTime !=''">
+ and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
+ </if>
+ <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
+ and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
+ and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
+ </if>
+ <if test="terms.updateTime != null and terms.updateTime !=''">
+ and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
+ </if>
+ <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
+ and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
+ and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
+ </if>
+ </where>
+ </if>
+ </sql>
+ <!-- 更新对象 -->
+ <update id="updateThirdCause">
+ update
+ <include refid="table-name"/>
+ <set>
+ <include refid="set-part"/>
+ </set>
+ <where>
+ id = #{entity.id}
+ </where>
+ </update>
+ <!-- 条件更新对象 -->
+ <update id="updateThirdCauseTerms">
+ update
+ <include refid="table-name"/>
+ <set>
+ <include refid="set-part"/>
+ </set>
+ <include refid="where-part"/>
+ </update>
+ <!-- 根据编号物理删除 -->
+ <delete id="deleteThirdCause">
+ delete from
+ <include refid="table-name" />
+ where id = #{id}
+ </delete>
+ <!-- 根据条件查询 -->
+ <select id="listTerms" resultMap="dataResult">
+ select
+ <include refid="column-part"/>
+ from
+ <include refid="table-name" />
+ <include refid="where-part"/>
+ </select>
+ <!-- 根据条件统计 -->
+ <select id="countTerms" resultType="java.lang.Long">
+ select
+ COUNT(1)
+ from
+ <include refid="table-name" />
+ <include refid="where-part"/>
+ </select>
+ <!-- 根据条件分页查询 -->
+ <select id="pageTerms" resultMap="dataResult">
+ SELECT
+ <include refid="column-part"/>
+ FROM
+ <include refid="table-name" />
+ <include refid="where-part"/>
+ <if test="page.sort != null">
+ <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
+ isnull(${s.property}), ${s.property} ${s.direction}
+ </foreach>
+ </if>
+ <if test="page.sort == null">
+ order by isnull(create_time), create_time desc
+ </if>
+ limit #{page.offset}, #{page.size}
+ </select>
+
+</mapper>
\ No newline at end of file
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/SyCauseBO.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/SyCauseBO.java
new file mode 100644
index 0000000..a23022b
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/SyCauseBO.java
@@ -0,0 +1,17 @@
+package cn.huge.module.syncbydyh.domain.bo;
+
+import cn.huge.module.syncbydyh.domain.po.SyCause;
+
+/**
+ * @title: 纠纷类型信息表业务扩展类
+ * @description: 纠纷类型信息表业务扩展类
+ * @company: hugeinfo
+ * @author: liyj
+ * @time: 2024-10-21 22:18:51
+ * @version: 1.0.0
+ * @see cn.huge.module.syncbydyh.domain.po.SyCause
+ */
+public class SyCauseBO extends SyCause {
+
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/ThirdCauseBO.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/ThirdCauseBO.java
new file mode 100644
index 0000000..13d614b
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/bo/ThirdCauseBO.java
@@ -0,0 +1,17 @@
+package cn.huge.module.syncbydyh.domain.bo;
+
+import cn.huge.module.syncbydyh.domain.po.ThirdCause;
+
+/**
+ * @title: 第三方纠纷类型映射表业务扩展类
+ * @description: 第三方纠纷类型映射表业务扩展类
+ * @company: hugeinfo
+ * @author: liyj
+ * @time: 2024-10-21 22:04:49
+ * @version: 1.0.0
+ * @see cn.huge.module.syncbydyh.domain.po.ThirdCause
+ */
+public class ThirdCauseBO extends ThirdCause {
+
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/ByCaseTaskDTO.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/ByCaseTaskDTO.java
new file mode 100644
index 0000000..294689c
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/ByCaseTaskDTO.java
@@ -0,0 +1,317 @@
+package cn.huge.module.syncbydyh.domain.dto;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * @title: 白云区矛盾纠纷多元化解平台-纠纷任务
+ * @description: 白云区矛盾纠纷多元化解平台-纠纷任务
+ * @company:hugeinfo
+ * @author: liyj
+ * @time: 2024-10-21 08:46:40
+ * @version 1.0.0
+ */
+@Data
+public class ByCaseTaskDTO {
+
+ /**
+ * 纠纷任务编号
+ */
+ private String id;
+
+ /**
+ * 纠纷编号
+ */
+ private String caseId;
+
+ /**
+ * 系列案状态，1：正常案件，2：系列案
+ */
+ private String serieStatus;
+
+ /**
+ * 流程编号
+ */
+ private String flowId;
+
+ /**
+ * 流程实例编号
+ */
+ private String processInstanceId;
+
+ /**
+ * 当前流程任务编号
+ */
+ private String processTaskId;
+
+ /**
+ * 任务节点
+ */
+ private String taskNode;
+
+ /**
+ * 任务节点名称
+ */
+ private String taskNodeName;
+
+ /**
+ * 任务节点类型，1：首节点，2：普通节点，3：结束节点
+ */
+ private String taskNodeType;
+
+ /**
+ * 任务类型，1：正常任务，2：退回任务
+ */
+ private String taskType;
+
+ /**
+ * 经办人组织编号
+ */
+ private String handlerUnitId;
+
+ /**
+ * 经办人组织名称
+ */
+ private String handlerUnitName;
+
+ /**
+ * 经办人部门编号
+ */
+ private String handlerDeptId;
+
+ /**
+ * 经办人部门名称
+ */
+ private String handlerDeptName;
+
+ /**
+ * 经办人角色代码编号
+ */
+ private String handlerRoleCode;
+
+ /**
+ * 经办人角色名称
+ */
+ private String handlerRoleName;
+
+ /**
+ * 经办人编号
+ */
+ private String handlerUserId;
+
+ /**
+ * 经办人名称
+ */
+ private String handlerUserName;
+
+ /**
+ * 到期时间
+ */
+ private Date expireTime;
+
+ /**
+ * 任务进度，1：进行中，2：已完成
+ */
+ private String status;
+
+ /**
+ * 处理结果，1：通过，2：退回，3：终止流程
+ */
+ private String handleResult;
+
+ /**
+ * 异常原因（退回、终止流程是异常）
+ */
+ private String errorCause;
+
+ /**
+ * 异常原因名称
+ */
+ private String errorCauseName;
+
+ /**
+ * 处理说明
+ */
+ private String handleContent;
+
+ /**
+ * 任务完成时间，进度为已完成才有
+ */
+ private Date finishTime;
+
+ /**
+ * 调解结果
+ */
+ private String mediResult;
+
+ /**
+ * 调解结果名称
+ */
+ private String mediResultName;
+
+ /**
+ * 履行情况，22_00008-1：未履行，22_00008-2：当场履行，22_00008-3：分期履行
+ */
+ private String fulfilSitu;
+
+ /**
+ * 履行情况名称
+ */
+ private String fulfilSituName;
+
+ /**
+ * 已达成协议
+ */
+ private String agreeContent;
+
+ /**
+ * 调解不成功原因，22_00019-1：当事人未能就调解协议达成一致，22_00019-2：当事人拒绝调解，22_00019-3：提前终止调解，22_00019-4：当事人撤销调解请求
+ */
+ private String mediFalse;
+
+ /**
+ * 调解不成功原因名称
+ */
+ private String mediFalseName;
+
+ /**
+ * 是否转诉讼案件（调解不成功才有），1：不转诉讼，2：转诉讼
+ */
+ private String civilStatus;
+
+ /**
+ * 诉讼案号
+ */
+ private String civilNo;
+
+ /**
+ * 诉讼法院编号
+ */
+ private String courtId;
+
+ /**
+ * 诉讼法院名称
+ */
+ private String courtName;
+
+ /**
+ * 民诉前调号
+ */
+ private String mediateNo;
+
+ /**
+ * 民诉前调书号
+ */
+ private String mediateBookNo;
+
+ /**
+ * 档案年度
+ */
+ private String fileYear;
+
+ /**
+ * 档案卷名
+ */
+ private String fileBookName;
+
+ /**
+ * 档案卷号
+ */
+ private String fileBookNo;
+
+ /**
+ * 档案编号
+ */
+ private String fileNo;
+
+ /**
+ * 档案保管年限，单位：年
+ */
+ private Integer fileLimitYear;
+
+ /**
+ * 档案存档位置
+ */
+ private String fileAddr;
+
+ /**
+ * 卷宗情况说明
+ */
+ private String fileContent;
+
+ /**
+ * 删除状态，1：未删除（默认值），99：已删除
+ */
+ private String deleteStatus;
+
+ /**
+ * 顾客编号
+ */
+ private String custId;
+
+ /**
+ * 创建时间
+ */
+ private Date createTime;
+
+ /**
+ * 更新时间
+ */
+ private Date updateTime;
+
+ /**
+ * 下一级处理人编号，已完成才有，冗余显示
+ */
+ private String nextUserId;
+
+ /**
+ * 下一级处理人名称，已完成才有，冗余显示
+ */
+ private String nextUserName;
+
+ /**
+ * 上一任务编号，冗余显示
+ */
+ private String lastTaskId;
+
+ /**
+ * 上一任务经办单位编号，冗余显示
+ */
+ private String lastUnitId;
+
+ /**
+ * 上一任务经办单位名称，冗余显示
+ */
+ private String lastUnitName;
+
+ /**
+ * 上一任务经办部门编号，冗余显示
+ */
+ private String lastDeptId;
+
+ /**
+ * 上一任务经办部门名称，冗余显示
+ */
+ private String lastDeptName;
+
+ /**
+ * 上一任务经办人编号，冗余显示
+ */
+ private String lastUserId;
+
+ /**
+ * 上一任务经办人名称，冗余显示
+ */
+ private String lastUserName;
+
+ /**
+ * 上一任务处理说明，冗余显示
+ */
+ private String lastContent;
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/GZCaseDTO.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/GZCaseDTO.java
index 30f5530..6558600 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/GZCaseDTO.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/dto/GZCaseDTO.java
@@ -26,4 +26,6 @@
private List<CaseTask> gzCaseTaskDTOList;
+ private List<ByCaseTaskDTO> byCaseTaskDTOList;
+
}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/SyCause.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/SyCause.java
new file mode 100644
index 0000000..964e76b
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/SyCause.java
@@ -0,0 +1,71 @@
+package cn.huge.module.syncbydyh.domain.po;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * @title: 纠纷类型信息表数据库对应关系类
+ * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
+ * @company:hugeinfo
+ * @author: liyj
+ * @time: 2024-10-21 22:18:51
+ * @version 1.0.0
+ */
+@TableName(value = "dyh_sy_cause")
+@Data
+public class SyCause {
+
+ /**
+ * 编码
+ */
+ @TableId(value = "id")
+ private String id;
+
+ /**
+ * 名称
+ */
+ @TableField(value = "name")
+ private String name;
+
+ /**
+ * 层级
+ */
+ @TableField(value = "level")
+ private Integer level;
+
+ /**
+ * 父级编码
+ */
+ @TableField(value = "parent_id")
+ private String parentId;
+
+ /**
+ * 调解类型
+ */
+ @TableField(value = "issue_id")
+ private String issueId;
+
+ /**
+ * 创建时间
+ */
+ @TableField(value = "create_time")
+ private Date createTime;
+
+ /**
+ * 更新时间
+ */
+ @TableField(value = "update_time")
+ private Date updateTime;
+
+ /**
+ * 展示图标
+ */
+ @TableField(value = "icon")
+ private String icon;
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/ThirdCause.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/ThirdCause.java
new file mode 100644
index 0000000..9dd4b7b
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/domain/po/ThirdCause.java
@@ -0,0 +1,83 @@
+package cn.huge.module.syncbydyh.domain.po;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * @title: 第三方纠纷类型映射表数据库对应关系类
+ * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
+ * @company:hugeinfo
+ * @author: liyj
+ * @time: 2024-10-21 22:04:49
+ * @version 1.0.0
+ */
+@TableName(value = "dyh_th_third_cause")
+@Data
+public class ThirdCause {
+
+ /**
+ * 主键编号
+ */
+ @TableId(value = "id")
+ private Integer id;
+
+ /**
+ * 第三方平台编号
+ */
+ @TableField(value = "third_sys_id")
+ private String thirdSysId;
+
+ /**
+ * 第三方平台名称
+ */
+ @TableField(value = "third_sys_name")
+ private String thirdSysName;
+
+ /**
+ * 第三方纠纷类型代码
+ */
+ @TableField(value = "third_code")
+ private String thirdCode;
+
+ /**
+ * 第三方纠纷类型名称
+ */
+ @TableField(value = "third_name")
+ private String thirdName;
+
+ /**
+ * 第三方纠纷类型父级代码
+ */
+ @TableField(value = "third_parent_code")
+ private String thirdParentCode;
+
+ /**
+ * 本平台纠纷类型代码
+ */
+ @TableField(value = "cause_code")
+ private String causeCode;
+
+ /**
+ * 层级
+ */
+ @TableField(value = "level")
+ private Integer level;
+
+ /**
+ * 创建时间
+ */
+ @TableField(value = "create_time")
+ private Date createTime;
+
+ /**
+ * 状态时间
+ */
+ @TableField(value = "update_time")
+ private Date updateTime;
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzCaseTaskService.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzCaseTaskService.java
new file mode 100644
index 0000000..282b407
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzCaseTaskService.java
@@ -0,0 +1,2199 @@
+package cn.huge.module.syncbydyh.service;
+
+import cn.huge.base.common.exception.ServiceException;
+import cn.huge.base.common.utils.DateUtils;
+import cn.huge.base.common.utils.ObjectUtils;
+import cn.huge.module.cases.consts.CaseTaskConsts;
+import cn.huge.module.cases.dao.mapper.CaseTaskMapper;
+import cn.huge.module.cases.domain.dto.*;
+import cn.huge.module.cases.domain.po.*;
+import cn.huge.module.cases.service.*;
+import cn.huge.module.cases.utils.TaskUsetimeUtils;
+import cn.huge.module.client.api.impl.CustClientImpl;
+import cn.huge.module.client.api.impl.DispClientImpl;
+import cn.huge.module.client.api.impl.SysClientImpl;
+import cn.huge.module.client.api.impl.UtilsClientImpl;
+import cn.huge.module.constant.BaseConsts;
+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.disp.constant.DispBaseConstsEnum;
+import cn.huge.module.disp.dto.CaseDispBaseDTO;
+import cn.huge.module.disp.dto.DispCaseBaseDTO;
+import cn.huge.module.flow.consts.FlowNodeEnum;
+import cn.huge.module.flow.consts.FlowableConsts;
+import cn.huge.module.flow.domain.po.FlowNode;
+import cn.huge.module.flow.service.FlowInfoService;
+import cn.huge.module.mediate.constant.*;
+import cn.huge.module.sys.constant.SyTimeEnum;
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @title: 纠纷任务表业务逻辑处理
+ * @Description 纠纷任务表业务逻辑处理
+ * @company hugeinfo
+ * @author liyj
+ * @Time 2024-09-06 15:50:06
+ * @version 1.0.0
+ */
+@Slf4j
+@Service
+@Transactional(rollbackFor = Exception.class)
+public class ByToGzCaseTaskService {
+
+ @Autowired
+ private CaseTaskMapper mapper;
+ @Autowired
+ private UtilsClientImpl utilsClient;
+ @Autowired
+ private CustClientImpl custClient;
+ @Autowired
+ private DispClientImpl dispClient;
+ @Autowired
+ private FlowInfoService flowInfoService;
+ @Autowired
+ private CaseInfoService caseInfoService;
+ @Autowired
+ private SysClientImpl sysClient;
+ @Autowired
+ private CaseInfoUnfoldService caseInfoUnfoldService;
+ @Autowired
+ private CaseWindupApplyService caseWindupApplyService;
+ @Autowired
+ private CaseAssistApplyService caseAssistApplyService;
+ @Autowired
+ private CaseAppearService caseAppearService;
+ @Autowired
+ private CaseReturnService caseReturnService;
+ @Autowired
+ private CaseAssistInfoService caseAssistInfoService;
+ @Autowired
+ private CaseDismissService caseDismissService;
+ @Autowired
+ private CasePersonService casePersonService;
+
+ /**
+ * 根据纠纷编号查询进行中的配合组织任务
+ * @param caseId
+ * @return
+ */
+ public List<CaseTask> listAssistTasking(String caseId){
+ // 查询配合组织的任务
+ QueryWrapper<CaseTask> caseTaskQueryWrapper = new QueryWrapper<>();
+ caseTaskQueryWrapper.eq("case_task_type", CaseTaskConsts.CASE_TASK_TYPE_2).eq("case_id", caseId)
+ .eq("status", CaseTaskConsts.TASK_STATUS_1);
+ List<CaseTask> assistCaseTaskList = mapper.selectList(caseTaskQueryWrapper);
+ return assistCaseTaskList;
+ }
+
+ /**
+ * web端大厅来访登记-提交纠纷事件-通过自动调度启动工作流
+ * @param caseInfo
+ */
+ public String webStartFlowLFDJ(CaseInfo caseInfo, DispCaseBaseDTO dispCaseBaseDTO){
+ try{
+ String caseTaskId = null;
+ CaseDispBaseDTO caseDispBaseDTO = dispClient.sysDisp(dispCaseBaseDTO);
+ log.info(JSON.toJSONString(caseDispBaseDTO));
+ // 目前平台只能调度给组织
+ if (DispBaseConstsEnum.TARGET_TYPE_1.getIndex().equals(caseDispBaseDTO.getTargetType())) {
+ // 目前平台只做镇街、村居级别的调度，
+ // 启动来访登记工作流
+ FlowNode firstFlowNode = flowInfoService.startFlow(FlowableConsts.getJbFlow(caseInfo.getCanal()), caseInfo.getId());
+ if (UserBaseConsts.UNIT_TYPE_101 == caseDispBaseDTO.getTargetUnitType()){
+ // 调度给镇街综治中心，进入第1个任务节点-镇街综治中心待分派
+ CaseTask dfpCaseTask = new CaseTask();
+ dfpCaseTask.setId(utilsClient.getNewTimeId());
+ dfpCaseTask.setCaseId(caseInfo.getId());
+ dfpCaseTask.setFlowableId(firstFlowNode.getFlowableId());
+ dfpCaseTask.setProcessInstanceId(firstFlowNode.getProcessInstanceId());
+ dfpCaseTask.setProcessTaskId(firstFlowNode.getProcessTaskId());
+ dfpCaseTask.setNodeType(firstFlowNode.getNodeType());
+ dfpCaseTask.setNodeId(firstFlowNode.getNodeId());
+ dfpCaseTask.setNodeName(firstFlowNode.getNodeName());
+ dfpCaseTask.setFlowId(firstFlowNode.getFlowId());
+ dfpCaseTask.setNodeShowName(firstFlowNode.getNodeShowName());
+ dfpCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属组织：调度目标
+ dfpCaseTask.setCandeUnitId(caseDispBaseDTO.getTargetId());
+ dfpCaseTask.setCandeUnitName(caseDispBaseDTO.getTargetName());
+ // 系统调度给镇街综治中心，不需要签收
+ dfpCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (firstFlowNode.getExpire() != 0) {
+ dfpCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), firstFlowNode.getExpire()));
+ }
+ dfpCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ dfpCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dfpCaseTask.setCustId(caseInfo.getCustId());
+ dfpCaseTask.setCreateTime(caseInfo.getCreateTime());
+ dfpCaseTask.setUpdateTime(caseInfo.getUpdateTime());
+ mapper.insert(dfpCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(caseInfo.getId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_1.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_1.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ caseTaskId = dfpCaseTask.getId();
+ }else {
+ // 调度给调解组织，默认通过第1个任务节点-镇街综治中心待分派
+ CaseTask dfpCaseTask = new CaseTask();
+ dfpCaseTask.setId(utilsClient.getNewTimeId());
+ dfpCaseTask.setCaseId(caseInfo.getId());
+ dfpCaseTask.setFlowableId(firstFlowNode.getFlowableId());
+ dfpCaseTask.setProcessInstanceId(firstFlowNode.getProcessInstanceId());
+ dfpCaseTask.setProcessTaskId(firstFlowNode.getProcessTaskId());
+ dfpCaseTask.setNodeType(firstFlowNode.getNodeType());
+ dfpCaseTask.setNodeId(firstFlowNode.getNodeId());
+ dfpCaseTask.setNodeName(firstFlowNode.getNodeName());
+ dfpCaseTask.setFlowId(firstFlowNode.getFlowId());
+ dfpCaseTask.setNodeShowName(firstFlowNode.getNodeShowName());
+ dfpCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属组织：系统
+ dfpCaseTask.setCandeUnitName("系统派单");
+ // 调度给调解组织，不需要签收
+ dfpCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (firstFlowNode.getExpire() != 0) {
+ dfpCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), firstFlowNode.getExpire()));
+ }
+ dfpCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ dfpCaseTask.setHandleUnitName("系统派单");
+ dfpCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ dfpCaseTask.setHandleIllust("派单至："+caseDispBaseDTO.getTargetName());
+ dfpCaseTask.setHandleTime(caseInfo.getCreateTime());
+ dfpCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dfpCaseTask.setCustId(caseInfo.getCustId());
+ dfpCaseTask.setCreateTime(caseInfo.getCreateTime());
+ dfpCaseTask.setUpdateTime(caseInfo.getCreateTime());
+ // 计算任务耗时、是否超时、超时多少
+ dfpCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(dfpCaseTask.getHandleTime(), dfpCaseTask.getCreateTime()));
+ dfpCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(dfpCaseTask.getHandleTime(), dfpCaseTask.getExpireTime()));
+ dfpCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(dfpCaseTask.getHandleTime(), dfpCaseTask.getExpireTime()));
+ mapper.insert(dfpCaseTask);
+ // 完成第1个工作流节点任务，进入第2个节点任务
+ FlowNode secondFlowNode = flowInfoService.completeTask(dfpCaseTask.getFlowableId(), dfpCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jb_zszz, "系统派单");
+ // 创建第2个节点任务-调解组织待受理
+ CaseTask dslCaseTask = new CaseTask();
+ dslCaseTask.setId(utilsClient.getNewTimeId());
+ dslCaseTask.setCaseId(caseInfo.getId());
+ dslCaseTask.setFlowableId(secondFlowNode.getFlowableId());
+ dslCaseTask.setProcessInstanceId(secondFlowNode.getProcessInstanceId());
+ dslCaseTask.setProcessTaskId(secondFlowNode.getProcessTaskId());
+ dslCaseTask.setNodeType(secondFlowNode.getNodeType());
+ dslCaseTask.setNodeId(secondFlowNode.getNodeId());
+ dslCaseTask.setNodeName(secondFlowNode.getNodeName());
+ dslCaseTask.setFlowId(secondFlowNode.getFlowId());
+ dslCaseTask.setNodeShowName(secondFlowNode.getNodeShowName());
+ dslCaseTask.setCaseTaskType(dfpCaseTask.getCaseTaskType());
+ // 任务所属组织：调度目标
+ dslCaseTask.setCandeUnitId(caseDispBaseDTO.getTargetId());
+ dslCaseTask.setCandeUnitName(caseDispBaseDTO.getTargetName());
+ // 系统调度给调解组织，需要签收
+ dslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
+ dslCaseTask.setSignExpireTime(sysClient.getExpireTime(caseInfo.getCreateTime(), SyTimeEnum.SY_TIME_2.getIndex()));
+ // 任务处理时限
+ if (firstFlowNode.getExpire() != 0) {
+ dslCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), firstFlowNode.getExpire()));
+ }
+ dslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ dslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dslCaseTask.setCustId(caseInfo.getCustId());
+ dslCaseTask.setCreateTime(caseInfo.getCreateTime());
+ dslCaseTask.setUpdateTime(caseInfo.getUpdateTime());
+ mapper.insert(dslCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(caseInfo.getId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_2.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_2.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ caseTaskId = dslCaseTask.getId();
+ }
+ }
+ return caseTaskId;
+ }catch (Exception e){
+ log.error("[CaseTaskService.webStartFlowLFDJ]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webStartFlowLFDJ", e);
+ }
+ }
+
+ /**
+ * web端大厅来访登记-自行受理-启动自行受理流程
+ * @param caseInfo
+ * @param loginUser
+ */
+ public String webStartFlowZXSL(CaseInfo caseInfo, CtUserDTO loginUser){
+ try{
+ // 启动自行受理工作流，进入待受理任务节点
+ FlowNode dslFlowNode = flowInfoService.startFlow(FlowableConsts.getZxslFlow(caseInfo.getCanal()), caseInfo.getId());
+ // 创建并完成待受理节点任务
+ CaseTask dslCaseTask = new CaseTask();
+ dslCaseTask.setId(utilsClient.getNewTimeId());
+ dslCaseTask.setCaseId(caseInfo.getId());
+ dslCaseTask.setFlowableId(dslFlowNode.getFlowableId());
+ dslCaseTask.setProcessInstanceId(dslFlowNode.getProcessInstanceId());
+ dslCaseTask.setProcessTaskId(dslFlowNode.getProcessTaskId());
+ dslCaseTask.setNodeType(dslFlowNode.getNodeType());
+ dslCaseTask.setNodeId(dslFlowNode.getNodeId());
+ dslCaseTask.setNodeName(dslFlowNode.getNodeName());
+ dslCaseTask.setFlowId(dslFlowNode.getFlowId());
+ dslCaseTask.setNodeShowName(dslFlowNode.getNodeShowName());
+ dslCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属组织：当前登记组织
+ dslCaseTask.setCandeUnitId(loginUser.getUnitId());
+ dslCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 自行受理，不需要签收
+ dslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (dslFlowNode.getExpire() != 0) {
+ dslCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), dslFlowNode.getExpire()));
+ }
+ dslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ dslCaseTask.setHandleUnitId(loginUser.getUnitId());
+ dslCaseTask.setHandleUnitName(loginUser.getUnitName());
+ dslCaseTask.setHandleDeptId(loginUser.getDeptId());
+ dslCaseTask.setHandleDeptName(loginUser.getDeptName());
+ dslCaseTask.setHandleUserId(loginUser.getId());
+ dslCaseTask.setHandleUserName(loginUser.getTrueName());
+ dslCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ dslCaseTask.setHandleIllust("自行受理");
+ dslCaseTask.setHandleTime(caseInfo.getCreateTime());
+ dslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dslCaseTask.setCustId(caseInfo.getCustId());
+ dslCaseTask.setCreateTime(caseInfo.getCreateTime());
+ dslCaseTask.setUpdateTime(caseInfo.getCreateTime());
+ // 计算任务耗时、是否超时、超时多少
+ dslCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(dslCaseTask.getHandleTime(), dslCaseTask.getCreateTime()));
+ dslCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(dslCaseTask.getHandleTime(), dslCaseTask.getExpireTime()));
+ dslCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(dslCaseTask.getHandleTime(), dslCaseTask.getExpireTime()));
+ mapper.insert(dslCaseTask);
+ // 完成待受理工作流节点任务，进入办理反馈任务节点
+ FlowNode blfkFlowNode = flowInfoService.completeTask(dslCaseTask.getFlowableId(), dslCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_forward, loginUser.getId());
+ // 创建办理反馈节点任务
+ CaseTask blfkCaseTask = new CaseTask();
+ blfkCaseTask.setId(utilsClient.getNewTimeId());
+ blfkCaseTask.setCaseId(caseInfo.getId());
+ blfkCaseTask.setFlowableId(blfkFlowNode.getFlowableId());
+ blfkCaseTask.setProcessInstanceId(blfkFlowNode.getProcessInstanceId());
+ blfkCaseTask.setProcessTaskId(blfkFlowNode.getProcessTaskId());
+ blfkCaseTask.setNodeType(blfkFlowNode.getNodeType());
+ blfkCaseTask.setNodeId(blfkFlowNode.getNodeId());
+ blfkCaseTask.setNodeName(blfkFlowNode.getNodeName());
+ blfkCaseTask.setFlowId(blfkFlowNode.getFlowId());
+ blfkCaseTask.setNodeShowName(blfkFlowNode.getNodeShowName());
+ blfkCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属组织：当前登记组织
+ blfkCaseTask.setCandeUnitId(loginUser.getUnitId());
+ blfkCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务节点，不需要签收
+ blfkCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (blfkFlowNode.getExpire() != 0) {
+ blfkCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), blfkFlowNode.getExpire()));
+ }
+ blfkCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ blfkCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ blfkCaseTask.setCustId(caseInfo.getCustId());
+ blfkCaseTask.setCreateTime(caseInfo.getCreateTime());
+ blfkCaseTask.setUpdateTime(caseInfo.getUpdateTime());
+ mapper.insert(blfkCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(caseInfo.getId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(blfkCaseTask.getCaseId());
+ caseInfoUnfoldPO.setAcceptTime(blfkCaseTask.getCreateTime());
+ caseInfoUnfoldPO.setMediateUnitId(blfkCaseTask.getCandeUnitId());
+ caseInfoUnfoldPO.setMediateUnitName(blfkCaseTask.getCandeUnitName());
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ return blfkCaseTask.getId();
+ }catch (Exception e){
+ log.error("[CaseTaskService.webStartFlowZXSL]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webStartFlowZXSL", e);
+ }
+ }
+
+ /**
+ * web端任务处理-不予受理
+ * @param caseDismiss 不予受理表单
+ * @param userId 当前登录用户
+ */
+ public void webDismiss(CaseDismiss caseDismiss, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 查询当前节点任务
+ CaseTask caseTask = mapper.selectById(caseDismiss.getCaseTaskId());
+ // 结束当前节点任务
+ CaseTask caseTaskPO = new CaseTask();
+ caseTaskPO.setId(caseDismiss.getCaseTaskId());
+ caseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ caseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ caseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ caseTaskPO.setHandleUserId(loginUser.getId());
+ caseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ caseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ caseTaskPO.setHandleUserName(loginUser.getTrueName());
+ caseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_3);
+ caseTaskPO.setHandleContent(caseDismiss.getDisContent());
+ caseTaskPO.setHandleTime(nowDate);
+ caseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ caseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(caseTaskPO.getHandleTime(), caseTask.getCreateTime()));
+ caseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(caseTaskPO.getHandleTime(), caseTask.getExpireTime()));
+ caseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(caseTaskPO.getHandleTime(), caseTask.getExpireTime()));
+ mapper.updateCaseTask(caseTaskPO);
+ // 结束当前工作流
+ flowInfoService.endFlow(caseTask.getProcessInstanceId());
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(caseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_8.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_8.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ // 有配合组织，也结束配合组织工作流
+ List<CaseTask> assistCaseTaskList = this.listAssistTasking(caseDismiss.getCaseId());
+ for (CaseTask assistCaseTask: assistCaseTaskList){
+ // 完成配合组织当前节点任务
+ assistCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ assistCaseTask.setHandleUnitId(loginUser.getUnitId());
+ assistCaseTask.setHandleUnitName(loginUser.getUnitName()+"（承办部门）");
+ assistCaseTask.setHandleDeptId(loginUser.getDeptId());
+ assistCaseTask.setHandleDeptName(loginUser.getDeptName()+"（承办部门）");
+ assistCaseTask.setHandleUserId(loginUser.getId());
+ assistCaseTask.setHandleUserName(loginUser.getTrueName()+"（承办部门）");
+ assistCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_3);
+ assistCaseTask.setHandleTime(nowDate);
+ assistCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ assistCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(assistCaseTask.getHandleTime(), assistCaseTask.getCreateTime()));
+ assistCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(assistCaseTask.getHandleTime(), assistCaseTask.getExpireTime()));
+ assistCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(assistCaseTask.getHandleTime(), assistCaseTask.getExpireTime()));
+ mapper.updateCaseTask(assistCaseTask);
+ // 结束配合组织当前工作流
+ flowInfoService.endFlow(assistCaseTask.getProcessInstanceId());
+ }
+ // 新增不予受理信息
+ caseDismiss.setCaseTaskTime(caseTask.getCreateTime());
+ caseDismiss.setDisUnitId(loginUser.getUnitId());
+ caseDismiss.setDisUnitName(loginUser.getUnitName());
+ caseDismiss.setDisUserId(loginUser.getId());
+ caseDismiss.setDisUserName(loginUser.getTrueName());
+ caseDismiss.setDisTime(nowDate);
+ caseDismiss.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ caseDismiss.setCustId(caseTask.getCustId());
+ caseDismiss.setCreateTime(nowDate);
+ caseDismiss.setUpdateTime(nowDate);
+ caseDismissService.save(caseDismiss);
+ }catch (Exception e){
+ log.error("[CaseTaskService.webAssign]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webAssign", e);
+ }
+ }
+
+ /**
+ * web端任务处理-交办
+ * @param assignTaskDTO 交办任务表单
+ * @param userId 当前登录用户
+ */
+ public void webAssign(AssignTaskDTO assignTaskDTO, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 查询交办的组织信息
+ CtUnitDTO dslUnitDTO = custClient.getUnitById(assignTaskDTO.getHandleUnitId());
+ // 查询当前待分派节点任务
+ CaseTask dfpCaseTask = mapper.selectById(assignTaskDTO.getCaseTaskId());
+ // 完成当前待分派节点任务
+ CaseTask dfpCaseTaskPO = new CaseTask();
+ dfpCaseTaskPO.setId(assignTaskDTO.getCaseTaskId());
+ dfpCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ dfpCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ dfpCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ dfpCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ dfpCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ dfpCaseTaskPO.setHandleUserId(loginUser.getId());
+ dfpCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ dfpCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ dfpCaseTaskPO.setHandleContent(assignTaskDTO.getAssignContent());
+ dfpCaseTaskPO.setHandleIllust("派单至："+assignTaskDTO.getHandleUnitName());
+ dfpCaseTaskPO.setHandleTime(nowDate);
+ dfpCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ dfpCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(dfpCaseTaskPO.getHandleTime(), dfpCaseTask.getCreateTime()));
+ dfpCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(dfpCaseTaskPO.getHandleTime(), dfpCaseTask.getExpireTime()));
+ dfpCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(dfpCaseTaskPO.getHandleTime(), dfpCaseTask.getExpireTime()));
+ mapper.updateCaseTask(dfpCaseTaskPO);
+ String flowOperation = null;
+ // 镇街综治中心待分派节点
+ if (FlowNodeEnum.FLOW_NODE_ZJ_DFP.getIndex().equals(dfpCaseTask.getNodeId())){
+ flowOperation = FlowableConsts.OPERATION_jb_zszz;
+ }
+ // 区综治中心待分派节点
+ if (FlowNodeEnum.FLOW_NODE_QJ_DFP.getIndex().equals(dfpCaseTask.getNodeId())){
+ // 查询承办组织信息
+ if (UserBaseConsts.UNIT_GRADE_2 == dslUnitDTO.getUnitGrade()) {
+ flowOperation = FlowableConsts.OPERATION_jb_zszz;
+ }else {
+ flowOperation = FlowableConsts.OPERATION_jb_zzzx;
+ }
+
+ }
+ // 市综治中心待分派节点
+ if (FlowNodeEnum.FLOW_NODE_SJ_DFP.getIndex().equals(dfpCaseTask.getNodeId())){
+ if (UserBaseConsts.UNIT_GRADE_1 == dslUnitDTO.getUnitGrade()) {
+ flowOperation = FlowableConsts.OPERATION_jb_zszz;
+ }else {
+ flowOperation = FlowableConsts.OPERATION_jb_zzzx;
+ }
+
+ }
+ // 完成当前待分派工作流节点任务，进入待受理任务节点
+ FlowNode newFlowNode = flowInfoService.completeTask(dfpCaseTask.getFlowableId(), dfpCaseTask.getProcessTaskId(),
+ flowOperation, userId);
+ // 新建待受理节点任务
+ CaseTask dslCaseTask = new CaseTask();
+ dslCaseTask.setId(utilsClient.getNewTimeId());
+ dslCaseTask.setCaseId(dfpCaseTask.getCaseId());
+ dslCaseTask.setFlowableId(newFlowNode.getFlowableId());
+ dslCaseTask.setProcessInstanceId(newFlowNode.getProcessInstanceId());
+ dslCaseTask.setProcessTaskId(newFlowNode.getProcessTaskId());
+ dslCaseTask.setNodeType(newFlowNode.getNodeType());
+ dslCaseTask.setNodeId(newFlowNode.getNodeId());
+ dslCaseTask.setNodeName(newFlowNode.getNodeName());
+ dslCaseTask.setFlowId(newFlowNode.getFlowId());
+ dslCaseTask.setNodeShowName(newFlowNode.getNodeShowName());
+ dslCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属组织：交办的组织
+ dslCaseTask.setCandeUnitId(dslUnitDTO.getId());
+ dslCaseTask.setCandeUnitName(dslUnitDTO.getUnitName());
+ // 交办的待受理节点任务，需要签收
+ dslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
+ dslCaseTask.setSignExpireTime(sysClient.getExpireTime(nowDate, SyTimeEnum.SY_TIME_2.getIndex()));
+ // 任务处理时限
+ if (newFlowNode.getExpire() != 0) {
+ dslCaseTask.setExpireTime(DateUtils.addDay(nowDate, newFlowNode.getExpire()));
+ }
+ dslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ dslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dslCaseTask.setCustId(dfpCaseTask.getCustId());
+ dslCaseTask.setCreateTime(nowDate);
+ dslCaseTask.setUpdateTime(nowDate);
+ mapper.insert(dslCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(dslCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_3.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_3.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+
+ // 交办配合组织
+ if (CollectionUtils.isNotEmpty(assignTaskDTO.getAssistUnitList())){
+ // 拼接配合组织编号和名称
+ String assistUnitId = assignTaskDTO.getAssistUnitList().stream().map(AssignAssistUnitDTO::getUitId).
+ collect(Collectors.joining(BaseConsts.COMMA));
+ String assistUnitName = assignTaskDTO.getAssistUnitList().stream().map(AssignAssistUnitDTO::getUitName).
+ collect(Collectors.joining(BaseConsts.COMMA));
+ for (AssignAssistUnitDTO assignAssistUnitDTO: assignTaskDTO.getAssistUnitList()){
+ // 启动联合处置工作流
+ FlowNode lhczdfpFlowNode = flowInfoService.startFlow(FlowableConsts.GZDYH_LHCZ_V1, dfpCaseTask.getCaseId());
+ // 新建并完成待分派节点任务
+ CaseTask lhczdfpCaseTask = new CaseTask();
+ lhczdfpCaseTask.setId(utilsClient.getNewTimeId());
+ lhczdfpCaseTask.setCaseId(dfpCaseTask.getCaseId());
+ lhczdfpCaseTask.setFlowableId(lhczdfpFlowNode.getFlowableId());
+ lhczdfpCaseTask.setProcessInstanceId(lhczdfpFlowNode.getProcessInstanceId());
+ lhczdfpCaseTask.setProcessTaskId(lhczdfpFlowNode.getProcessTaskId());
+ lhczdfpCaseTask.setNodeType(lhczdfpFlowNode.getNodeType());
+ lhczdfpCaseTask.setNodeId(lhczdfpFlowNode.getNodeId());
+ lhczdfpCaseTask.setNodeName(lhczdfpFlowNode.getNodeName());
+ lhczdfpCaseTask.setFlowId(lhczdfpFlowNode.getFlowId());
+ lhczdfpCaseTask.setNodeShowName(lhczdfpFlowNode.getNodeShowName());
+ lhczdfpCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_2);
+ // 任务所属单位：当前操作组织
+ lhczdfpCaseTask.setCandeUnitId(loginUser.getUnitId());
+ lhczdfpCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 待分派节点任务，不需要签收
+ lhczdfpCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ lhczdfpCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ lhczdfpCaseTask.setHandleUnitId(loginUser.getUnitId());
+ lhczdfpCaseTask.setHandleUnitName(loginUser.getUnitName());
+ lhczdfpCaseTask.setHandleDeptId(loginUser.getDeptId());
+ lhczdfpCaseTask.setHandleDeptName(loginUser.getDeptName());
+ lhczdfpCaseTask.setHandleUserId(loginUser.getId());
+ lhczdfpCaseTask.setHandleUserName(loginUser.getTrueName());
+ lhczdfpCaseTask.setHandleContent(assignTaskDTO.getAssignContent());
+ lhczdfpCaseTask.setHandleIllust("交办至："+assistUnitName);
+ // 任务处理时限
+ if (lhczdfpFlowNode.getExpire() != 0) {
+ lhczdfpCaseTask.setExpireTime(DateUtils.addDay(nowDate, lhczdfpFlowNode.getExpire()));
+ }
+ lhczdfpCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ lhczdfpCaseTask.setCustId(dfpCaseTask.getCustId());
+ lhczdfpCaseTask.setCreateTime(nowDate);
+ lhczdfpCaseTask.setUpdateTime(nowDate);
+ mapper.insert(lhczdfpCaseTask);
+ // 完成待分派节点任务，进去待受理节点
+ FlowNode lhczdslFlowNode = flowInfoService.completeTask(lhczdfpCaseTask.getFlowableId(), lhczdfpCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_forward, loginUser.getId());
+ // 创建待受理节点任务
+ CaseTask lhczdslCaseTask = new CaseTask();
+ lhczdslCaseTask.setId(utilsClient.getNewTimeId());
+ lhczdslCaseTask.setCaseId(lhczdfpCaseTask.getCaseId());
+ lhczdslCaseTask.setFlowableId(lhczdslFlowNode.getFlowableId());
+ lhczdslCaseTask.setProcessInstanceId(lhczdslFlowNode.getProcessInstanceId());
+ lhczdslCaseTask.setProcessTaskId(lhczdslFlowNode.getProcessTaskId());
+ lhczdslCaseTask.setNodeType(lhczdslFlowNode.getNodeType());
+ lhczdslCaseTask.setNodeId(lhczdslFlowNode.getNodeId());
+ lhczdslCaseTask.setNodeName(lhczdslFlowNode.getNodeName());
+ lhczdslCaseTask.setFlowId(lhczdslFlowNode.getFlowId());
+ lhczdslCaseTask.setNodeShowName(lhczdslFlowNode.getNodeShowName());
+ lhczdslCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_2);
+ // 任务所属单位：交办的配合组织
+ lhczdslCaseTask.setCandeUnitId(assignAssistUnitDTO.getUitId());
+ lhczdslCaseTask.setCandeUnitName(assignAssistUnitDTO.getUitName());
+ // 交办的待受理节点任务，需要签收
+ lhczdslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
+ lhczdslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ // 任务处理时限
+ if (lhczdslFlowNode.getExpire() != 0) {
+ lhczdslCaseTask.setExpireTime(DateUtils.addDay(nowDate, lhczdslFlowNode.getExpire()));
+ }
+ lhczdslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ lhczdslCaseTask.setCustId(lhczdfpCaseTask.getCustId());
+ lhczdslCaseTask.setCreateTime(nowDate);
+ lhczdslCaseTask.setUpdateTime(nowDate);
+ mapper.insert(lhczdslCaseTask);
+ // 新增联合处置信息
+ CaseAssistInfo caseAssistInfoPO = new CaseAssistInfo();
+ caseAssistInfoPO.setId(utilsClient.getNewTimeId());
+ caseAssistInfoPO.setCaseId(lhczdslCaseTask.getCaseId());
+ caseAssistInfoPO.setProcessInstanceId(lhczdslCaseTask.getProcessInstanceId());
+ caseAssistInfoPO.setAssistUnitId(assignAssistUnitDTO.getUitId());
+ caseAssistInfoPO.setAssistUnitName(assignAssistUnitDTO.getUitName());
+ caseAssistInfoPO.setAssistStatus(CaseTaskConsts.ASSIST_STATUS_0);
+ caseAssistInfoPO.setCustId(lhczdslCaseTask.getCustId());
+ caseAssistInfoPO.setCreateTime(nowDate);
+ caseAssistInfoPO.setUpdateTime(nowDate);
+ caseAssistInfoService.save(caseAssistInfoPO);
+ }
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(dslCaseTask.getCaseId());
+ caseInfoUnfoldPO.setAssistUnitId(assistUnitId);
+ caseInfoUnfoldPO.setAssistUnitName(assistUnitName);
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ }
+ }catch (Exception e){
+ log.error("[CaseTaskService.webAssign]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webAssign", e);
+ }
+ }
+
+ /**
+ * web端任务处理-签收
+ * @param signTaskDTOList 签收任务表单
+ * @param userId 当前登录用户
+ */
+ public void webSign(List<SignTaskDTO> signTaskDTOList, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ for (SignTaskDTO signTaskDTO: signTaskDTOList){
+ CaseTask qsCaseTask = mapper.selectById(signTaskDTO.getCaseTaskId());
+ // 更新纠纷任务信息
+ CaseTask caseTaskPO = new CaseTask();
+ caseTaskPO.setId(qsCaseTask.getId());
+ caseTaskPO.setSignStatus(CaseTaskConsts.SIGN_STATUS_2);
+ caseTaskPO.setSignTime(nowDate);
+ caseTaskPO.setSignUserId(loginUser.getId());
+ caseTaskPO.setSignUserName(loginUser.getTrueName());
+ caseTaskPO.setHandleIllust("已签收");
+ caseTaskPO.setUpdateTime(nowDate);
+ mapper.updateCaseTask(caseTaskPO);
+ // 承办组织签收才更新纠纷信息
+ if (CaseTaskConsts.CASE_TASK_TYPE_1 == qsCaseTask.getCaseTaskType()) {
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(qsCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_3.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_3.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ }
+ }catch (Exception e){
+ log.error("[CaseTaskService.webSign]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webSign", e);
+ }
+ }
+
+ /**
+ * web端任务处理-受理
+ * @param acceptTaskDTO 受理任务表单
+ * @param userId 当前登录用户
+ */
+ public String webAccept(AcceptTaskDTO acceptTaskDTO, String userId, Date nowDate){
+ try{
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 查询当前待受理节点任务
+ CaseTask dslCaseTask = mapper.selectById(acceptTaskDTO.getCaseTaskId());
+ // 完成当前待受理节点任务
+ CaseTask dslCaseTaskPO = new CaseTask();
+ dslCaseTaskPO.setId(acceptTaskDTO.getCaseTaskId());
+ dslCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ dslCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ dslCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ dslCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ dslCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ dslCaseTaskPO.setHandleUserId(loginUser.getId());;
+ dslCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ dslCaseTaskPO.setHandleIllust("已受理");
+ dslCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ dslCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ dslCaseTaskPO.setHandleTime(nowDate);
+ dslCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ dslCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(dslCaseTaskPO.getHandleTime(), dslCaseTask.getCreateTime()));
+ dslCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(dslCaseTaskPO.getHandleTime(), dslCaseTask.getExpireTime()));
+ dslCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(dslCaseTaskPO.getHandleTime(), dslCaseTask.getExpireTime()));
+ mapper.updateCaseTask(dslCaseTaskPO);
+ // 完成当前待受理工作流节点任务，机内办理反馈节点
+ String operation = FlowableConsts.OPERATION_sl;
+ if (CaseTaskConsts.CASE_TASK_TYPE_2 == dslCaseTask.getCaseTaskType()) {
+ // 配合组织受理条件改为通过
+ operation = FlowableConsts.OPERATION_forward;
+ }
+ FlowNode newFlowNode = flowInfoService.completeTask(dslCaseTask.getFlowableId(), dslCaseTask.getProcessTaskId(),
+ operation, userId);
+ // 新建办理反馈节点任务
+ CaseTask blfkCaseTask = new CaseTask();
+ blfkCaseTask.setId(utilsClient.getNewTimeId());
+ blfkCaseTask.setCaseId(dslCaseTask.getCaseId());
+ blfkCaseTask.setFlowableId(newFlowNode.getFlowableId());
+ blfkCaseTask.setProcessInstanceId(newFlowNode.getProcessInstanceId());
+ blfkCaseTask.setProcessTaskId(newFlowNode.getProcessTaskId());
+ blfkCaseTask.setNodeType(newFlowNode.getNodeType());
+ blfkCaseTask.setNodeId(newFlowNode.getNodeId());
+ blfkCaseTask.setNodeName(newFlowNode.getNodeName());
+ blfkCaseTask.setFlowId(newFlowNode.getFlowId());
+ blfkCaseTask.setNodeShowName(newFlowNode.getNodeShowName());
+ blfkCaseTask.setCaseTaskType(dslCaseTask.getCaseTaskType());
+ // 任务所属单位：当前受理单位
+ blfkCaseTask.setCandeUnitId(loginUser.getUnitId());
+ blfkCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ blfkCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ blfkCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ // 任务处理时限
+ if (newFlowNode.getExpire() != 0) {
+ blfkCaseTask.setExpireTime(DateUtils.addDay(nowDate, newFlowNode.getExpire()));
+ }
+ blfkCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ blfkCaseTask.setCustId(dslCaseTask.getCustId());
+ blfkCaseTask.setCreateTime(nowDate);
+ blfkCaseTask.setUpdateTime(nowDate);
+ mapper.insert(blfkCaseTask);
+ // 承办组织受理才更新纠纷信息
+ if (CaseTaskConsts.CASE_TASK_TYPE_1 == dslCaseTask.getCaseTaskType()) {
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(blfkCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(blfkCaseTask.getCaseId());
+ caseInfoUnfoldPO.setAcceptTime(nowDate);
+ caseInfoUnfoldPO.setMediateUnitId(blfkCaseTask.getCandeUnitId());
+ caseInfoUnfoldPO.setMediateUnitName(blfkCaseTask.getCandeUnitName());
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ }else {
+ // 更新配合组织联合处置信息
+ QueryWrapper<CaseAssistInfo> caseAssistInfoQueryWrapper = new QueryWrapper<>();
+ caseAssistInfoQueryWrapper.eq("case_id", blfkCaseTask.getCaseId())
+ .eq("assist_unit_id", loginUser.getUnitId()).eq("assist_status", CaseTaskConsts.ASSIST_STATUS_0);
+ CaseAssistInfo caseAssistInfoPO = caseAssistInfoService.getOne(caseAssistInfoQueryWrapper);
+ caseAssistInfoPO.setCaseTaskId(blfkCaseTask.getId());
+ caseAssistInfoPO.setAcceptTime(nowDate);
+ caseAssistInfoService.updateCaseAssistInfo(caseAssistInfoPO);
+ }
+ return blfkCaseTask.getId();
+ }catch (Exception e){
+ log.error("[CaseTaskService.webAccept]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webAccept", e);
+ }
+ }
+
+ /**
+ * web端任务处理-结案申请
+ * @param caseWindupApply 结案申请表单
+ * @param userId 当前登录用户
+ */
+ public void webWindupApply(CaseWindupApply caseWindupApply, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 新增结案申请信息
+ caseWindupApply.setApplyUnitId(loginUser.getUnitId());
+ caseWindupApply.setApplyUnitName(loginUser.getUnitName());
+ caseWindupApply.setApplyUserId(loginUser.getId());
+ caseWindupApply.setApplyUserName(loginUser.getTrueName());
+ caseWindupApply.setApplyTime(nowDate);
+ caseWindupApply.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ caseWindupApply.setCreateTime(nowDate);
+ caseWindupApply.setUpdateTime(nowDate);
+ // 查询办理反馈节点任务
+ CaseTask blfkCaseTask = mapper.selectById(caseWindupApply.getCaseTaskId());
+ // 完成当前办理反馈节点任务
+ CaseTask blfkCaseTaskPO = new CaseTask();
+ blfkCaseTaskPO.setId(caseWindupApply.getCaseTaskId());
+ blfkCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ blfkCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ blfkCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ blfkCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ blfkCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ blfkCaseTaskPO.setHandleUserId(loginUser.getId());
+ blfkCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ blfkCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ blfkCaseTaskPO.setHandleTime(nowDate);
+ blfkCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ blfkCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(blfkCaseTaskPO.getHandleTime(), blfkCaseTask.getCreateTime()));
+ blfkCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(blfkCaseTaskPO.getHandleTime(), blfkCaseTask.getExpireTime()));
+ blfkCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(blfkCaseTaskPO.getHandleTime(), blfkCaseTask.getExpireTime()));
+ mapper.updateCaseTask(blfkCaseTaskPO);
+ // 完成当前待受理工作流节点任务，进入结案申请节点
+ FlowNode jasqFlowNode = flowInfoService.completeTask(blfkCaseTask.getFlowableId(), blfkCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_forward, userId);
+ // 新建并自动完成结案申请节点任务
+ CaseTask jasqCaseTask = new CaseTask();
+ jasqCaseTask.setId(utilsClient.getNewTimeId());
+ jasqCaseTask.setCaseId(blfkCaseTask.getCaseId());
+ jasqCaseTask.setFlowableId(jasqFlowNode.getFlowableId());
+ jasqCaseTask.setProcessInstanceId(jasqFlowNode.getProcessInstanceId());
+ jasqCaseTask.setProcessTaskId(jasqFlowNode.getProcessTaskId());
+ jasqCaseTask.setNodeType(jasqFlowNode.getNodeType());
+ jasqCaseTask.setNodeId(jasqFlowNode.getNodeId());
+ jasqCaseTask.setNodeName(jasqFlowNode.getNodeName());
+ jasqCaseTask.setFlowId(jasqFlowNode.getFlowId());
+ jasqCaseTask.setNodeShowName(jasqFlowNode.getNodeShowName());
+ jasqCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：当前结案申请组织
+ jasqCaseTask.setCandeUnitId(loginUser.getUnitId());
+ jasqCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ jasqCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (jasqFlowNode.getExpire() != 0) {
+ jasqCaseTask.setExpireTime(DateUtils.addDay(nowDate, jasqFlowNode.getExpire()));
+ }
+ jasqCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jasqCaseTask.setHandleUnitId(loginUser.getUnitId());
+ jasqCaseTask.setHandleUnitName(loginUser.getUnitName());
+ jasqCaseTask.setHandleDeptId(loginUser.getDeptId());
+ jasqCaseTask.setHandleDeptName(loginUser.getDeptName());
+ jasqCaseTask.setHandleUserId(loginUser.getId());
+ jasqCaseTask.setHandleUserName(loginUser.getTrueName());
+ jasqCaseTask.setHandleContent(caseWindupApply.getWindupContent());
+ jasqCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ jasqCaseTask.setHandleTime(nowDate);
+ jasqCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jasqCaseTask.setCustId(blfkCaseTask.getCustId());
+ jasqCaseTask.setCreateTime(nowDate);
+ jasqCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ jasqCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jasqCaseTask.getHandleTime(), jasqCaseTask.getCreateTime()));
+ jasqCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jasqCaseTask.getHandleTime(), jasqCaseTask.getExpireTime()));
+ jasqCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jasqCaseTask.getHandleTime(), jasqCaseTask.getExpireTime()));
+ mapper.insert(jasqCaseTask);
+ // 化解成功，自动结案审核通过
+ if (MediResultBaseConstsEnum.MEDI_RESULT_1.getIndex().equals(caseWindupApply.getMediResult())){
+ // 完成当前结案申请工作流节点任务，走结案审核任务
+ FlowNode jashFlowNode = flowInfoService.completeTask(jasqCaseTask.getFlowableId(), jasqCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_forward, userId);
+ // 新建并自动完成结案审核任务
+ CaseTask jashCaseTask = new CaseTask();
+ jashCaseTask.setId(utilsClient.getNewTimeId());
+ jashCaseTask.setCaseId(jasqCaseTask.getCaseId());
+ jashCaseTask.setFlowableId(jashFlowNode.getFlowableId());
+ jashCaseTask.setProcessInstanceId(jashFlowNode.getProcessInstanceId());
+ jashCaseTask.setProcessTaskId(jashFlowNode.getProcessTaskId());
+ jashCaseTask.setNodeType(jashFlowNode.getNodeType());
+ jashCaseTask.setNodeId(jashFlowNode.getNodeId());
+ jashCaseTask.setNodeName(jashFlowNode.getNodeName());
+ jashCaseTask.setFlowId(jashFlowNode.getFlowId());
+ jashCaseTask.setNodeShowName(jashFlowNode.getNodeShowName());
+ jashCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：结案申请操作组织
+ jashCaseTask.setCandeUnitId(loginUser.getUnitId());
+ jashCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ jashCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (jashFlowNode.getExpire() != 0) {
+ jashCaseTask.setExpireTime(DateUtils.addDay(nowDate, jashFlowNode.getExpire()));
+ }
+ jashCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jashCaseTask.setHandleUnitId(loginUser.getUnitId());
+ jashCaseTask.setHandleUnitName(loginUser.getUnitName());
+ jashCaseTask.setHandleDeptId(loginUser.getDeptId());
+ jashCaseTask.setHandleDeptName(loginUser.getDeptName());
+ jashCaseTask.setHandleUserId(loginUser.getId());
+ jashCaseTask.setHandleUserName(loginUser.getTrueName());
+ jashCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
+ jashCaseTask.setHandleTime(DateUtils.addMinute(nowDate, 1));
+ jashCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jashCaseTask.setCustId(jasqCaseTask.getCustId());
+ jashCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 1));
+ jashCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 1));
+ // 计算任务耗时、是否超时、超时多少
+ jashCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jashCaseTask.getHandleTime(), jashCaseTask.getCreateTime()));
+ jashCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jashCaseTask.getHandleTime(), jashCaseTask.getExpireTime()));
+ jashCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jashCaseTask.getHandleTime(), jashCaseTask.getExpireTime()));
+ mapper.insert(jashCaseTask);
+ // 完成当前结案审核工作流任务，走下一个节点
+ FlowNode nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty, userId);
+ // 下一个节点是当事人评价节点，进入当事人评价节点任务
+ if (FlowNodeEnum.FLOW_NODE_DSRPJ.getIndex().equals(nextFlowNode.getNodeId())){
+ // 新建当事人评价节点任务
+ CaseTask dsrpjCaseTask = new CaseTask();
+ dsrpjCaseTask.setId(utilsClient.getNewTimeId());
+ dsrpjCaseTask.setCaseId(jashCaseTask.getCaseId());
+ dsrpjCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ dsrpjCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ dsrpjCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ dsrpjCaseTask.setNodeType(nextFlowNode.getNodeType());
+ dsrpjCaseTask.setNodeId(nextFlowNode.getNodeId());
+ dsrpjCaseTask.setNodeName(nextFlowNode.getNodeName());
+ dsrpjCaseTask.setFlowId(nextFlowNode.getFlowId());
+ dsrpjCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ dsrpjCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属人：当事人
+ EvaluatePersonDTO evaluatePersonDTO = casePersonService.getEvaluatePerson(jashCaseTask.getCaseId());
+ dsrpjCaseTask.setCandeUserId(evaluatePersonDTO.getId());
+ dsrpjCaseTask.setCandeUserId(evaluatePersonDTO.getName());
+ // 受理后的节点任务，不需要签收
+ dsrpjCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ dsrpjCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ dsrpjCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ dsrpjCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dsrpjCaseTask.setCustId(jashCaseTask.getCustId());
+ dsrpjCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 2));
+ dsrpjCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 2));
+ mapper.insert(dsrpjCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_6.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_6.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ // 下一个节点是结案归档节点，进入结案归档节点任务
+ if (FlowNodeEnum.FLOW_NODE_JAGD.getIndex().equals(nextFlowNode.getNodeId())){
+ // 创建并完成结案归档节点任务
+ CaseTask jagdCaseTask = new CaseTask();
+ jagdCaseTask.setId(utilsClient.getNewTimeId());
+ jagdCaseTask.setCaseId(jashCaseTask.getCaseId());
+ jagdCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ jagdCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ jagdCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ jagdCaseTask.setNodeType(nextFlowNode.getNodeType());
+ jagdCaseTask.setNodeId(nextFlowNode.getNodeId());
+ jagdCaseTask.setNodeName(nextFlowNode.getNodeName());
+ jagdCaseTask.setFlowId(nextFlowNode.getFlowId());
+ jagdCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ jagdCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：结案申请操作组织
+ jagdCaseTask.setCandeUnitId(loginUser.getUnitId());
+ jagdCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ jagdCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ jagdCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ jagdCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jashCaseTask.setHandleUnitId(loginUser.getUnitId());
+ jashCaseTask.setHandleUnitName(loginUser.getUnitName());
+ jashCaseTask.setHandleDeptId(loginUser.getDeptId());
+ jashCaseTask.setHandleDeptName(loginUser.getDeptName());
+ jashCaseTask.setHandleUserId(loginUser.getId());
+ jashCaseTask.setHandleUserName(loginUser.getTrueName());
+ jagdCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ jagdCaseTask.setHandleTime(nowDate);
+ jagdCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jagdCaseTask.setCustId(jashCaseTask.getCustId());
+ jagdCaseTask.setCreateTime(nowDate);
+ jagdCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ jagdCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jagdCaseTask.getHandleTime(), jagdCaseTask.getCreateTime()));
+ jagdCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jagdCaseTask.getHandleTime(), jagdCaseTask.getExpireTime()));
+ jagdCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jagdCaseTask.getHandleTime(), jagdCaseTask.getExpireTime()));
+ mapper.insert(jagdCaseTask);
+ // 完成结案归档工作流节点任务，结束流程
+ flowInfoService.completeTask(jagdCaseTask.getFlowableId(), jagdCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jb_zszz, loginUser.getId());
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_7.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_7.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ // 更新结案申请信息
+ caseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_1);
+ caseWindupApply.setCaseTaskId(jashCaseTask.getId());
+ caseWindupApply.setAuditUnitId(jashCaseTask.getHandleUnitId());
+ caseWindupApply.setAuditUnitName(jashCaseTask.getHandleUnitName());
+ caseWindupApply.setAuditUserId(jashCaseTask.getHandleUserId());
+ caseWindupApply.setAuditUserName(jashCaseTask.getHandleUserName());
+ caseWindupApply.setAuditTime(nowDate);
+ caseWindupApply.setAuditResult(AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex());
+ caseWindupApply.setAuditResultName(AuditBaseConstsEnum.AUDIT_RESULT_1.getDes());
+ caseWindupApply.setCustId(jashCaseTask.getCustId());
+ caseWindupApplyService.save(caseWindupApply);
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(jashCaseTask.getCaseId());
+ caseInfoUnfoldPO.setMediResult(caseWindupApply.getMediResult());
+ caseInfoUnfoldPO.setMediResultName(caseWindupApply.getMediResultName());
+ caseInfoUnfoldPO.setAgreeType(caseWindupApply.getAgreeType());
+ caseInfoUnfoldPO.setAgreeTypeName(caseWindupApply.getAgreeTypeName());
+ caseInfoUnfoldPO.setAgreeContent(caseWindupApply.getAgreeContent());
+ caseInfoUnfoldPO.setWindupContent(caseWindupApply.getWindupContent());
+ caseInfoUnfoldPO.setCloseTime(nowDate);
+ caseInfoUnfoldPO.setUpdateTime(nowDate);
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ }else {// 化解不成功
+ // 完成当前结案申请工作流节点任务
+ FlowNode jashFlowNode = flowInfoService.completeTask(jasqCaseTask.getFlowableId(), jasqCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_forward, userId);
+ // 判断是否自行受理
+ CaseInfo caseInfo = caseInfoService.getById(jasqCaseTask.getCaseId());
+ if (CaseBaseConsts.ZXSL_STATUS_1 == caseInfo.getZxslStatus()){
+ // 自行受理，自行完成结案审核节点，直接进入下一个节点
+ // 新建并自动完成结案审核任务
+ CaseTask jashCaseTask = new CaseTask();
+ jashCaseTask.setId(utilsClient.getNewTimeId());
+ jashCaseTask.setCaseId(jasqCaseTask.getCaseId());
+ jashCaseTask.setFlowableId(jashFlowNode.getFlowableId());
+ jashCaseTask.setProcessInstanceId(jashFlowNode.getProcessInstanceId());
+ jashCaseTask.setProcessTaskId(jashFlowNode.getProcessTaskId());
+ jashCaseTask.setNodeType(jashFlowNode.getNodeType());
+ jashCaseTask.setNodeId(jashFlowNode.getNodeId());
+ jashCaseTask.setNodeName(jashFlowNode.getNodeName());
+ jashCaseTask.setFlowId(jashFlowNode.getFlowId());
+ jashCaseTask.setNodeShowName(jashFlowNode.getNodeShowName());
+ jashCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：结案申请操作组织
+ jashCaseTask.setCandeUnitId(loginUser.getUnitId());
+ jashCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ jashCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (jashFlowNode.getExpire() != 0) {
+ jashCaseTask.setExpireTime(DateUtils.addDay(nowDate, jashFlowNode.getExpire()));
+ }
+ jashCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jashCaseTask.setHandleUnitId(loginUser.getUnitId());
+ jashCaseTask.setHandleUnitName(loginUser.getUnitName());
+ jashCaseTask.setHandleDeptId(loginUser.getDeptId());
+ jashCaseTask.setHandleDeptName(loginUser.getDeptName());
+ jashCaseTask.setHandleUserId(loginUser.getId());
+ jashCaseTask.setHandleUserName(loginUser.getTrueName());
+ jashCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
+ jashCaseTask.setHandleTime(DateUtils.addMinute(nowDate, 1));
+ jashCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jashCaseTask.setCustId(jasqCaseTask.getCustId());
+ jashCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 1));
+ jashCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 1));
+ // 计算任务耗时、是否超时、超时多少
+ jashCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jashCaseTask.getHandleTime(), jashCaseTask.getCreateTime()));
+ jashCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jashCaseTask.getHandleTime(), jashCaseTask.getExpireTime()));
+ jashCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jashCaseTask.getHandleTime(), jashCaseTask.getExpireTime()));
+ mapper.insert(jashCaseTask);
+ // 完成当前结案审核工作流任务，走下一个节点
+ FlowNode nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty, userId);
+ // 下一个节点是当事人评价节点，进入当事人评价节点任务
+ if (FlowNodeEnum.FLOW_NODE_DSRPJ.getIndex().equals(nextFlowNode.getNodeId())){
+ // 新建当事人评价节点任务
+ CaseTask dsrpjCaseTask = new CaseTask();
+ dsrpjCaseTask.setId(utilsClient.getNewTimeId());
+ dsrpjCaseTask.setCaseId(jashCaseTask.getCaseId());
+ dsrpjCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ dsrpjCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ dsrpjCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ dsrpjCaseTask.setNodeType(nextFlowNode.getNodeType());
+ dsrpjCaseTask.setNodeId(nextFlowNode.getNodeId());
+ dsrpjCaseTask.setNodeName(nextFlowNode.getNodeName());
+ dsrpjCaseTask.setFlowId(nextFlowNode.getFlowId());
+ dsrpjCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ dsrpjCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属人：当事人
+ EvaluatePersonDTO evaluatePersonDTO = casePersonService.getEvaluatePerson(jashCaseTask.getCaseId());
+ dsrpjCaseTask.setCandeUserId(evaluatePersonDTO.getId());
+ dsrpjCaseTask.setCandeUserId(evaluatePersonDTO.getName());
+ // 受理后的节点任务，不需要签收
+ dsrpjCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ dsrpjCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ dsrpjCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ dsrpjCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dsrpjCaseTask.setCustId(jashCaseTask.getCustId());
+ dsrpjCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 2));
+ dsrpjCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 2));
+ mapper.insert(dsrpjCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_6.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_6.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ // 下一个节点是结案归档节点，进入结案归档节点任务
+ if (FlowNodeEnum.FLOW_NODE_JAGD.getIndex().equals(nextFlowNode.getNodeId())){
+ // 创建并完成结案归档节点任务
+ CaseTask jagdCaseTask = new CaseTask();
+ jagdCaseTask.setId(utilsClient.getNewTimeId());
+ jagdCaseTask.setCaseId(jashCaseTask.getCaseId());
+ jagdCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ jagdCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ jagdCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ jagdCaseTask.setNodeType(nextFlowNode.getNodeType());
+ jagdCaseTask.setNodeId(nextFlowNode.getNodeId());
+ jagdCaseTask.setNodeName(nextFlowNode.getNodeName());
+ jagdCaseTask.setFlowId(nextFlowNode.getFlowId());
+ jagdCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ jagdCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：结案申请操作组织
+ jagdCaseTask.setCandeUnitId(loginUser.getUnitId());
+ jagdCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ jagdCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ jagdCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ jagdCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jagdCaseTask.setHandleUnitId(loginUser.getUnitId());
+ jagdCaseTask.setHandleUnitName(loginUser.getUnitName());
+ jagdCaseTask.setHandleDeptId(loginUser.getDeptId());
+ jagdCaseTask.setHandleDeptName(loginUser.getDeptName());
+ jagdCaseTask.setHandleUserId(loginUser.getId());
+ jagdCaseTask.setHandleUserName(loginUser.getTrueName());
+ jagdCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ jagdCaseTask.setHandleTime(nowDate);
+ jagdCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jagdCaseTask.setCustId(jashCaseTask.getCustId());
+ jagdCaseTask.setCreateTime(nowDate);
+ jagdCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ jagdCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jagdCaseTask.getHandleTime(), jagdCaseTask.getCreateTime()));
+ jagdCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jagdCaseTask.getHandleTime(), jagdCaseTask.getExpireTime()));
+ jagdCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jagdCaseTask.getHandleTime(), jagdCaseTask.getExpireTime()));
+ mapper.insert(jagdCaseTask);
+ // 完成结案归档工作流节点任务，结束流程
+ flowInfoService.completeTask(jagdCaseTask.getFlowableId(), jagdCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jb_zszz, loginUser.getId());
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_7.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_7.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ // 更新结案申请信息
+ caseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_1);
+ caseWindupApply.setCaseTaskId(jashCaseTask.getId());
+ caseWindupApply.setAuditUnitId(jashCaseTask.getHandleUnitId());
+ caseWindupApply.setAuditUnitName(jashCaseTask.getHandleUnitName());
+ caseWindupApply.setAuditUserId(jashCaseTask.getHandleUserId());
+ caseWindupApply.setAuditUserName(jashCaseTask.getHandleUserName());
+ caseWindupApply.setAuditTime(nowDate);
+ caseWindupApply.setAuditResult(AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex());
+ caseWindupApply.setAuditResultName(AuditBaseConstsEnum.AUDIT_RESULT_1.getDes());
+ caseWindupApply.setCustId(jashCaseTask.getCustId());
+ caseWindupApplyService.save(caseWindupApply);
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(jashCaseTask.getCaseId());
+ caseInfoUnfoldPO.setMediResult(caseWindupApply.getMediResult());
+ caseInfoUnfoldPO.setMediResultName(caseWindupApply.getMediResultName());
+ caseInfoUnfoldPO.setAgreeType(caseWindupApply.getAgreeType());
+ caseInfoUnfoldPO.setAgreeTypeName(caseWindupApply.getAgreeTypeName());
+ caseInfoUnfoldPO.setAgreeContent(caseWindupApply.getAgreeContent());
+ caseInfoUnfoldPO.setWindupContent(caseWindupApply.getWindupContent());
+ caseInfoUnfoldPO.setCloseTime(nowDate);
+ caseInfoUnfoldPO.setUpdateTime(nowDate);
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ }else {
+ // 正常流程，进入结案审核节点
+ // 新建结案审核任务
+ CaseTask jashCaseTask = new CaseTask();
+ jashCaseTask.setId(utilsClient.getNewTimeId());
+ jashCaseTask.setCaseId(jasqCaseTask.getCaseId());
+ jashCaseTask.setFlowableId(jashFlowNode.getFlowableId());
+ jashCaseTask.setProcessInstanceId(jashFlowNode.getProcessInstanceId());
+ jashCaseTask.setProcessTaskId(jashFlowNode.getProcessTaskId());
+ jashCaseTask.setNodeType(jashFlowNode.getNodeType());
+ jashCaseTask.setNodeId(jashFlowNode.getNodeId());
+ jashCaseTask.setNodeName(jashFlowNode.getNodeName());
+ jashCaseTask.setFlowId(jashFlowNode.getFlowId());
+ jashCaseTask.setNodeShowName(jashFlowNode.getNodeShowName());
+ jashCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：本级综治中心审核
+ CtUnitDTO zzzxCtUnitDTO = custClient.getBjZzzx(loginUser.getUnitId());
+ jashCaseTask.setCandeUnitId(zzzxCtUnitDTO.getId());
+ jashCaseTask.setCandeUnitName(zzzxCtUnitDTO.getUnitName());
+ // 受理后的节点任务，不需要签收
+ jashCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (jashFlowNode.getExpire() != 0) {
+ jashCaseTask.setExpireTime(DateUtils.addDay(nowDate, jashFlowNode.getExpire()));
+ }
+ jashCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ jashCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jashCaseTask.setCustId(jasqCaseTask.getCustId());
+ jashCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 1));
+ jashCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 1));
+ mapper.insert(jashCaseTask);
+ // 更新结案申请信息
+ caseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_0);
+ caseWindupApply.setCaseTaskId(jashCaseTask.getId());
+ caseWindupApply.setAuditUnitId(jashCaseTask.getCandeUnitId());
+ caseWindupApply.setAuditUnitName(jashCaseTask.getCandeUnitName());
+ caseWindupApply.setCustId(jashCaseTask.getCustId());
+ caseWindupApplyService.save(caseWindupApply);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_5.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_5.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(jashCaseTask.getCaseId());
+ caseInfoUnfoldPO.setMediResult(caseWindupApply.getMediResult());
+ caseInfoUnfoldPO.setMediResultName(caseWindupApply.getMediResultName());
+ caseInfoUnfoldPO.setAgreeType(caseWindupApply.getAgreeType());
+ caseInfoUnfoldPO.setAgreeTypeName(caseWindupApply.getAgreeTypeName());
+ caseInfoUnfoldPO.setAgreeContent(caseWindupApply.getAgreeContent());
+ caseInfoUnfoldPO.setWindupContent(caseWindupApply.getWindupContent());
+ caseInfoUnfoldPO.setUpdateTime(nowDate);
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ }
+ }
+ // 查询联合处置申请单，全部结束申请单
+ QueryWrapper<CaseAssistApply> caseAssistApplyQueryWrapper = new QueryWrapper<>();
+ caseAssistApplyQueryWrapper.eq("case_id", jasqCaseTask.getCaseId()).eq("apply_status", AuditBaseConsts.AUDIT_STATUS_0);
+ List<CaseAssistApply> caseAssistApplyList = caseAssistApplyService.list(caseAssistApplyQueryWrapper);
+ for (CaseAssistApply caseAssistApply: caseAssistApplyList){
+ caseAssistApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_2);
+ caseAssistApply.setUpdateTime(nowDate);
+ caseAssistApplyService.updateCaseAssistApply(caseAssistApply);
+ }
+ // 查询配合组织的任务，全部结束流程
+ List<CaseTask> assistCaseTaskList = this.listAssistTasking(jasqCaseTask.getCaseId());
+ for (CaseTask assistCaseTask: assistCaseTaskList){
+ // 完成配合组织当前任务
+ assistCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ assistCaseTask.setHandleUnitId(loginUser.getUnitId());
+ assistCaseTask.setHandleUnitName(loginUser.getUnitName());
+ assistCaseTask.setHandleDeptId(loginUser.getDeptId());
+ assistCaseTask.setHandleDeptName(loginUser.getDeptName());
+ assistCaseTask.setHandleUserId(loginUser.getId());
+ assistCaseTask.setHandleUserName(loginUser.getTrueName());
+ assistCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ assistCaseTask.setHandleTime(nowDate);
+ assistCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ assistCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(assistCaseTask.getHandleTime(), assistCaseTask.getCreateTime()));
+ assistCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(assistCaseTask.getHandleTime(), assistCaseTask.getExpireTime()));
+ assistCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(assistCaseTask.getHandleTime(), assistCaseTask.getExpireTime()));
+ mapper.updateCaseTask(assistCaseTask);
+ // 结束配合组织当前工作流任务
+ flowInfoService.endFlow(assistCaseTask.getProcessInstanceId());
+ }
+ }catch (Exception e){
+ log.error("[CaseTaskService.webWindupApply]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webWindupApply", e);
+ }
+ }
+
+ /**
+ * web端任务处理-结案审核
+ * @param caseWindupApply 结案审核表单
+ * @param userId 当前登录用户
+ */
+ public void webWindupAudit(CaseWindupApply caseWindupApply, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 查询结案申请信息
+ CaseWindupApply oldCaseWindupApply = caseWindupApplyService.getById(caseWindupApply.getId());
+ // 更新结案申请信息
+ caseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_1);
+ caseWindupApply.setAuditUserId(loginUser.getId());
+ caseWindupApply.setAuditUserName(loginUser.getTrueName());
+ caseWindupApply.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ caseWindupApply.setCustId(loginUser.getCustId());
+ caseWindupApply.setAuditTime(nowDate);
+ caseWindupApply.setUpdateTime(nowDate);
+ caseWindupApplyService.updateCaseWindupApply(caseWindupApply);
+ // 查询结案审核任务
+ CaseTask jashCaseTask = mapper.selectById(caseWindupApply.getCaseTaskId());
+ // 审核通过，
+ if (AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex().equals(caseWindupApply.getAuditResult())){
+ // 完成当前结案审核节点任务
+ CaseTask jashCaseTaskPO = new CaseTask();
+ jashCaseTaskPO.setId(caseWindupApply.getCaseTaskId());
+ jashCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jashCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ jashCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ jashCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ jashCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ jashCaseTaskPO.setHandleUserId(loginUser.getId());
+ jashCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ jashCaseTaskPO.setHandleContent(caseWindupApply.getAuditContent());
+ jashCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
+ jashCaseTaskPO.setHandleTime(nowDate);
+ jashCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ jashCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jashCaseTaskPO.getHandleTime(), jashCaseTask.getCreateTime()));
+ jashCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jashCaseTaskPO.getHandleTime(), jashCaseTask.getExpireTime()));
+ jashCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jashCaseTaskPO.getHandleTime(), jashCaseTask.getExpireTime()));
+ mapper.updateCaseTask(jashCaseTaskPO);
+ // 根据事项等级，判断是否要上级综治中心审核
+ FlowNode nextFlowNode = null;
+ CaseInfo caseInfo = caseInfoService.getById(jashCaseTask.getCaseId());
+ if (CaseBaseConsts.CASE_LEVEL_1 == caseInfo.getCaseLevel()){
+ // 一级事件，本级+上级+上上级审核
+ if (FlowNodeEnum.FLOW_NODE_JASH.getIndex().equals(jashCaseTask.getNodeId())){
+ // 完成本级综治中心审核，进入上级综治中心审核节点
+ nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty_sq, userId);
+
+ }else if (FlowNodeEnum.FLOW_NODE_JASH_YJ.getIndex().equals(jashCaseTask.getNodeId())){
+ // 完成上级综治中心审核，进入上上级综治中心审核节点
+ nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty_sq, userId);
+ }else {
+ // 完成上上级综治中心审核，审核流程结束，进入下一节点
+ nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty, userId);
+ }
+
+ }else if (CaseBaseConsts.CASE_LEVEL_2 == caseInfo.getCaseLevel()){
+ // 二级事件，本级+上级审核
+ String operation = FlowableConsts.OPERATION_jash_ty;
+ if (FlowNodeEnum.FLOW_NODE_JASH.getIndex().equals(jashCaseTask.getNodeId())){
+ // 完成本级综治中心审核，进入上级综治中心审核节点
+ nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty_sq, userId);
+ }else {
+ // 完成上级综治中心审核，审核流程结束，进入下一节点
+ nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty, userId);
+ }
+ }else {
+ // 三级事件，自办自结，即本级综治中心审核就行，完成本级综治中心审核，审核流程结束，进入下一节点
+ nextFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_ty, userId);
+ }
+
+ // 下一个节点是一级结案审核节点，进入一级结案审核节点任务
+ if (FlowNodeEnum.FLOW_NODE_JASH_YJ.getIndex().equals(nextFlowNode.getNodeId())){
+ // 新建结案审核节点任务
+ CaseTask yjJashCaseTask = new CaseTask();
+ yjJashCaseTask.setId(utilsClient.getNewTimeId());
+ yjJashCaseTask.setCaseId(jashCaseTask.getCaseId());
+ yjJashCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ yjJashCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ yjJashCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ yjJashCaseTask.setNodeType(nextFlowNode.getNodeType());
+ yjJashCaseTask.setNodeId(nextFlowNode.getNodeId());
+ yjJashCaseTask.setNodeName(nextFlowNode.getNodeName());
+ yjJashCaseTask.setFlowId(nextFlowNode.getFlowId());
+ yjJashCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ yjJashCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：上级级综治中心审核
+ CtUnitDTO zzzxCtUnitDTO = custClient.getParentZzzxUnit(loginUser.getUnitId());
+ yjJashCaseTask.setCandeUnitId(zzzxCtUnitDTO.getId());
+ yjJashCaseTask.setCandeUnitName(zzzxCtUnitDTO.getUnitName());
+ // 受理后的节点任务，不需要签收
+ yjJashCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ yjJashCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ yjJashCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ yjJashCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ yjJashCaseTask.setCustId(jashCaseTask.getCustId());
+ yjJashCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 1));
+ yjJashCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 1));
+ mapper.insert(yjJashCaseTask);
+ // 创建新的结案申请记录
+ CaseWindupApply newCaseWindupApply = new CaseWindupApply();
+ BeanUtils.copyProperties(oldCaseWindupApply, newCaseWindupApply);
+ newCaseWindupApply.setId(utilsClient.getNewTimeId());
+ newCaseWindupApply.setApplyTime(nowDate);
+ newCaseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_0);
+ newCaseWindupApply.setCaseTaskId(yjJashCaseTask.getId());
+ newCaseWindupApply.setAuditUnitId(yjJashCaseTask.getCandeUnitId());
+ newCaseWindupApply.setAuditUnitName(yjJashCaseTask.getCandeUnitName());
+ newCaseWindupApply.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ newCaseWindupApply.setCreateTime(nowDate);
+ newCaseWindupApply.setUpdateTime(nowDate);
+ newCaseWindupApply.setCustId(yjJashCaseTask.getCustId());
+ caseWindupApplyService.save(newCaseWindupApply);
+ }
+ // 下一个节点是二级结案审核节点，进入二级结案审核节点任务
+ if (FlowNodeEnum.FLOW_NODE_JASH_EJ.getIndex().equals(nextFlowNode.getNodeId())){
+ // 新建结案审核节点任务
+ CaseTask ejJashCaseTask = new CaseTask();
+ ejJashCaseTask.setId(utilsClient.getNewTimeId());
+ ejJashCaseTask.setCaseId(jashCaseTask.getCaseId());
+ ejJashCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ ejJashCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ ejJashCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ ejJashCaseTask.setNodeType(nextFlowNode.getNodeType());
+ ejJashCaseTask.setNodeId(nextFlowNode.getNodeId());
+ ejJashCaseTask.setNodeName(nextFlowNode.getNodeName());
+ ejJashCaseTask.setFlowId(nextFlowNode.getFlowId());
+ ejJashCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ ejJashCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：上级级综治中心审核
+ CtUnitDTO zzzxCtUnitDTO = custClient.getParentZzzxUnit(loginUser.getUnitId());
+ ejJashCaseTask.setCandeUnitId(zzzxCtUnitDTO.getId());
+ ejJashCaseTask.setCandeUnitName(zzzxCtUnitDTO.getUnitName());
+ // 受理后的节点任务，不需要签收
+ ejJashCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ ejJashCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ ejJashCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ ejJashCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ ejJashCaseTask.setCustId(jashCaseTask.getCustId());
+ ejJashCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 1));
+ ejJashCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 1));
+ mapper.insert(ejJashCaseTask);
+ // 创建新的结案申请记录
+ CaseWindupApply newCaseWindupApply = new CaseWindupApply();
+ BeanUtils.copyProperties(oldCaseWindupApply, newCaseWindupApply);
+ newCaseWindupApply.setId(utilsClient.getNewTimeId());
+ newCaseWindupApply.setApplyTime(nowDate);
+ newCaseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_0);
+ newCaseWindupApply.setCaseTaskId(ejJashCaseTask.getId());
+ newCaseWindupApply.setAuditUnitId(ejJashCaseTask.getCandeUnitId());
+ newCaseWindupApply.setAuditUnitName(ejJashCaseTask.getCandeUnitName());
+ newCaseWindupApply.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ newCaseWindupApply.setCreateTime(nowDate);
+ newCaseWindupApply.setUpdateTime(nowDate);
+ newCaseWindupApply.setCustId(ejJashCaseTask.getCustId());
+ caseWindupApplyService.save(newCaseWindupApply);
+ }
+ // 下一个节点是当事人评价节点，进入当事人评价节点任务
+ if (FlowNodeEnum.FLOW_NODE_DSRPJ.getIndex().equals(nextFlowNode.getNodeId())){
+ // 新建当事人评价节点任务
+ CaseTask dsrpjCaseTask = new CaseTask();
+ dsrpjCaseTask.setId(utilsClient.getNewTimeId());
+ dsrpjCaseTask.setCaseId(jashCaseTask.getCaseId());
+ dsrpjCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ dsrpjCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ dsrpjCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ dsrpjCaseTask.setNodeType(nextFlowNode.getNodeType());
+ dsrpjCaseTask.setNodeId(nextFlowNode.getNodeId());
+ dsrpjCaseTask.setNodeName(nextFlowNode.getNodeName());
+ dsrpjCaseTask.setFlowId(nextFlowNode.getFlowId());
+ dsrpjCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ dsrpjCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属人：当事人
+ EvaluatePersonDTO evaluatePersonDTO = casePersonService.getEvaluatePerson(jashCaseTask.getCaseId());
+ dsrpjCaseTask.setCandeUserId(evaluatePersonDTO.getId());
+ dsrpjCaseTask.setCandeUserId(evaluatePersonDTO.getName());
+ // 受理后的节点任务，不需要签收
+ dsrpjCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ dsrpjCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ dsrpjCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ dsrpjCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dsrpjCaseTask.setCustId(jashCaseTask.getCustId());
+ dsrpjCaseTask.setCreateTime(DateUtils.addMinute(nowDate, 2));
+ dsrpjCaseTask.setUpdateTime(DateUtils.addMinute(nowDate, 2));
+ mapper.insert(dsrpjCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_6.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_6.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ // 下一个节点是结案归档节点，进入结案归档节点任务
+ if (FlowNodeEnum.FLOW_NODE_JAGD.getIndex().equals(nextFlowNode.getNodeId())){
+ // 创建并完成结案归档节点任务
+ CaseTask jagdCaseTask = new CaseTask();
+ jagdCaseTask.setId(utilsClient.getNewTimeId());
+ jagdCaseTask.setCaseId(jashCaseTask.getCaseId());
+ jagdCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ jagdCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ jagdCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ jagdCaseTask.setNodeType(nextFlowNode.getNodeType());
+ jagdCaseTask.setNodeId(nextFlowNode.getNodeId());
+ jagdCaseTask.setNodeName(nextFlowNode.getNodeName());
+ jagdCaseTask.setFlowId(nextFlowNode.getFlowId());
+ jagdCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ jagdCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：结案申请操作组织
+ jagdCaseTask.setCandeUnitId(oldCaseWindupApply.getApplyUnitId());
+ jagdCaseTask.setCandeUnitName(oldCaseWindupApply.getApplyUnitName());
+ // 受理后的节点任务，不需要签收
+ jagdCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ jagdCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ jagdCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jashCaseTask.setHandleUnitId(loginUser.getUnitId());
+ jashCaseTask.setHandleUnitName(loginUser.getUnitName());
+ jashCaseTask.setHandleDeptId(loginUser.getDeptId());
+ jashCaseTask.setHandleDeptName(loginUser.getDeptName());
+ jashCaseTask.setHandleUserId(loginUser.getId());
+ jashCaseTask.setHandleUserName(loginUser.getTrueName());
+ jagdCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ jagdCaseTask.setHandleTime(nowDate);
+ jagdCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ jagdCaseTask.setCustId(jashCaseTask.getCustId());
+ jagdCaseTask.setCreateTime(nowDate);
+ jagdCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ jagdCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jagdCaseTask.getHandleTime(), jagdCaseTask.getCreateTime()));
+ jagdCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jagdCaseTask.getHandleTime(), jagdCaseTask.getExpireTime()));
+ jagdCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jagdCaseTask.getHandleTime(), jagdCaseTask.getExpireTime()));
+ mapper.insert(jagdCaseTask);
+ // 完成结案归档工作流节点任务，结束流程
+ flowInfoService.completeTask(jagdCaseTask.getFlowableId(), jagdCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jb_zszz, loginUser.getId());
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(jashCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_7.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_7.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+
+ }
+ // 更新纠纷扩展信息
+ CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
+ caseInfoUnfoldPO.setId(jashCaseTask.getCaseId());
+ caseInfoUnfoldPO.setCloseTime(nowDate);
+ caseInfoUnfoldPO.setUpdateTime(nowDate);
+ caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
+ }else {
+ // 审核不通过，回退办理反馈节点任务
+ // 完成当前结案审核节点任务
+ CaseTask jashCaseTaskPO = new CaseTask();
+ jashCaseTaskPO.setId(caseWindupApply.getCaseTaskId());
+ jashCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ jashCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ jashCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ jashCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ jashCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ jashCaseTaskPO.setHandleUserId(loginUser.getId());
+ jashCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ jashCaseTaskPO.setHandleContent(caseWindupApply.getAuditContent());
+ jashCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
+ jashCaseTaskPO.setHandleTime(nowDate);
+ jashCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ jashCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(jashCaseTaskPO.getHandleTime(), jashCaseTask.getCreateTime()));
+ jashCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(jashCaseTaskPO.getHandleTime(), jashCaseTask.getExpireTime()));
+ jashCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(jashCaseTaskPO.getHandleTime(), jashCaseTask.getExpireTime()));
+ mapper.updateCaseTask(jashCaseTaskPO);
+ // 完成当前结案审核工作流节点任务，走办理反馈节点任务
+ FlowNode blfkFlowNode = flowInfoService.completeTask(jashCaseTask.getFlowableId(), jashCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_jash_bty, userId);
+ // 新建办理反馈节点任务
+ CaseTask blfkCaseTask = new CaseTask();
+ blfkCaseTask.setId(utilsClient.getNewTimeId());
+ blfkCaseTask.setCaseId(jashCaseTask.getCaseId());
+ blfkCaseTask.setFlowableId(blfkFlowNode.getFlowableId());
+ blfkCaseTask.setProcessInstanceId(blfkFlowNode.getProcessInstanceId());
+ blfkCaseTask.setProcessTaskId(blfkFlowNode.getProcessTaskId());
+ blfkCaseTask.setNodeType(blfkFlowNode.getNodeType());
+ blfkCaseTask.setNodeId(blfkFlowNode.getNodeId());
+ blfkCaseTask.setNodeName(blfkFlowNode.getNodeName());
+ blfkCaseTask.setFlowId(blfkFlowNode.getFlowId());
+ blfkCaseTask.setNodeShowName(blfkFlowNode.getNodeShowName());
+ blfkCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：结案申请操作组织
+ blfkCaseTask.setCandeUnitId(oldCaseWindupApply.getApplyUnitId());
+ blfkCaseTask.setCandeUnitName(oldCaseWindupApply.getApplyUnitName());
+ // 受理后的节点任务，不需要签收
+ blfkCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ blfkCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ // 任务处理时限
+ if (blfkFlowNode.getExpire() != 0) {
+ blfkCaseTask.setExpireTime(DateUtils.addDay(nowDate, blfkFlowNode.getExpire()));
+ }
+ blfkCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ blfkCaseTask.setCustId(jashCaseTask.getCustId());
+ blfkCaseTask.setCreateTime(nowDate);
+ blfkCaseTask.setUpdateTime(nowDate);
+ mapper.insert(blfkCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(blfkCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }
+ }catch (Exception e){
+ log.error("[CaseTaskService.webWindupApply]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webWindupApply", e);
+ }
+ }
+
+ /**
+ * web端任务处理-回退申请
+ * @param caseReturn 回退申请表单
+ * @param userId 当前登录用户
+ */
+ public void webReturnApply(CaseReturn caseReturn, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 创建回退申请信息
+ caseReturn.setReturnUnitId(loginUser.getUnitId());
+ caseReturn.setReturnUnitName(loginUser.getUnitName());
+ caseReturn.setReturnUserId(loginUser.getId());
+ caseReturn.setReturnUserName(loginUser.getTrueName());
+ caseReturn.setReturnTime(nowDate);
+ CtUnitDTO zzzxUnit = custClient.getParentZzzxUnit(loginUser.getUnitId());
+ caseReturn.setAuditUnitId(zzzxUnit.getId());
+ caseReturn.setAuditUnitName(zzzxUnit.getUnitName());
+ caseReturn.setReturnStatus(AuditBaseConsts.AUDIT_STATUS_0);
+ caseReturn.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ caseReturn.setCustId(loginUser.getCustId());
+ caseReturn.setCreateTime(nowDate);
+ caseReturn.setUpdateTime(nowDate);
+ // 查询待节点任务
+ CaseTask thisCaseTask = mapper.selectById(caseReturn.getCaseTaskId());
+ // 完成当前节点任务
+ CaseTask thisCaseTaskPO = new CaseTask();
+ thisCaseTaskPO.setId(caseReturn.getCaseTaskId());
+ thisCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ thisCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ thisCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ thisCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ thisCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ thisCaseTaskPO.setHandleUserId(loginUser.getId());
+ thisCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ thisCaseTaskPO.setHandleContent(caseReturn.getReturnContent());
+ thisCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_4);
+ thisCaseTaskPO.setHandleTime(nowDate);
+ thisCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ thisCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(thisCaseTaskPO.getHandleTime(), thisCaseTask.getCreateTime()));
+ thisCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(thisCaseTaskPO.getHandleTime(), thisCaseTask.getExpireTime()));
+ thisCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(thisCaseTaskPO.getHandleTime(), thisCaseTask.getExpireTime()));
+ mapper.updateCaseTask(thisCaseTaskPO);
+ // 完成当前节点工作流任务，走回退审核任务
+ FlowNode htshFlowNode = flowInfoService.completeTask(thisCaseTask.getFlowableId(), thisCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_htsq, userId);
+ // 新建回退审核节点任务
+ CaseTask htshCaseTask = new CaseTask();
+ htshCaseTask.setId(utilsClient.getNewTimeId());
+ htshCaseTask.setCaseId(thisCaseTask.getCaseId());
+ htshCaseTask.setFlowableId(htshFlowNode.getFlowableId());
+ htshCaseTask.setProcessInstanceId(htshFlowNode.getProcessInstanceId());
+ htshCaseTask.setProcessTaskId(htshFlowNode.getProcessTaskId());
+ htshCaseTask.setNodeType(htshFlowNode.getNodeType());
+ htshCaseTask.setNodeId(htshFlowNode.getNodeId());
+ htshCaseTask.setNodeName(htshFlowNode.getNodeName());
+ htshCaseTask.setFlowId(htshFlowNode.getFlowId());
+ htshCaseTask.setNodeShowName(htshFlowNode.getNodeShowName());
+ htshCaseTask.setCaseTaskType(thisCaseTask.getCaseTaskType());
+ // 任务所属单位：上级综治中心
+ htshCaseTask.setCandeUnitId(zzzxUnit.getId());
+ htshCaseTask.setCandeUnitName(zzzxUnit.getUnitName());
+ // 受理后的节点任务，不需要签收
+ htshCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (htshFlowNode.getExpire() != 0) {
+ htshCaseTask.setExpireTime(DateUtils.addDay(nowDate, htshFlowNode.getExpire()));
+ }
+ htshCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ htshCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ htshCaseTask.setCustId(htshCaseTask.getCustId());
+ htshCaseTask.setCreateTime(nowDate);
+ htshCaseTask.setUpdateTime(nowDate);
+ mapper.insert(htshCaseTask);
+ // 新增回退申请信息
+ caseReturn.setCaseTaskId(htshCaseTask.getId());
+ caseReturn.setCaseTaskType(htshCaseTask.getCaseTaskType());
+ caseReturnService.save(caseReturn);
+ }catch (Exception e){
+ log.error("[CaseTaskService.webReturnApply]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webReturnApply", e);
+ }
+ }
+
+ /**
+ * web端任务处理-回退审核
+ * @param caseReturn 回退审核表单
+ * @param userId 当前登录用户
+ */
+ public void webReturnAudit(CaseReturn caseReturn, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 更新回退申请信息
+ caseReturn.setReturnStatus(AuditBaseConsts.AUDIT_STATUS_1);
+ caseReturn.setAuditUserId(loginUser.getId());
+ caseReturn.setAuditUserName(loginUser.getTrueName());
+ caseReturn.setAuditTime(nowDate);
+ caseReturn.setUpdateTime(nowDate);
+ caseReturnService.updateCaseReturn(caseReturn);
+ // 查询回退审核节点任务
+ CaseTask htshCaseTask = mapper.selectById(caseReturn.getCaseTaskId());
+ // 审核通过
+ if (AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex().equals(caseReturn.getAuditResult())){
+ // 完成当前回退审核节点任务
+ CaseTask htshCaseTaskPO = new CaseTask();
+ htshCaseTaskPO.setId(caseReturn.getCaseTaskId());
+ htshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ htshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ htshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ htshCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ htshCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ htshCaseTaskPO.setHandleUserId(loginUser.getId());
+ htshCaseTaskPO.setHandleContent(caseReturn.getAuditContent());
+ htshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ htshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
+ htshCaseTaskPO.setHandleTime(nowDate);
+ htshCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ htshCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(htshCaseTaskPO.getHandleTime(), htshCaseTask.getCreateTime()));
+ htshCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(htshCaseTaskPO.getHandleTime(), htshCaseTask.getExpireTime()));
+ htshCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(htshCaseTaskPO.getHandleTime(), htshCaseTask.getExpireTime()));
+ mapper.updateCaseTask(htshCaseTaskPO);
+ // 完成当前回退审核工作流节点任务，承办组织走待分派节点任务，配合组织结束工作流流程
+ FlowNode nextFlowNode = flowInfoService.completeTask(htshCaseTask.getFlowableId(), htshCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_htsh_ty, userId);
+ if (CaseTaskConsts.CASE_TASK_TYPE_1 == htshCaseTask.getCaseTaskType()) {
+ // 新建下一个节点任务
+ CaseTask nextCaseTask = new CaseTask();
+ nextCaseTask.setId(utilsClient.getNewTimeId());
+ nextCaseTask.setCaseId(htshCaseTask.getCaseId());
+ nextCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ nextCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ nextCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ nextCaseTask.setNodeType(nextFlowNode.getNodeType());
+ nextCaseTask.setNodeId(nextFlowNode.getNodeId());
+ nextCaseTask.setNodeName(nextFlowNode.getNodeName());
+ nextCaseTask.setFlowId(nextFlowNode.getFlowId());
+ nextCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ nextCaseTask.setCaseTaskType(htshCaseTask.getCaseTaskType());
+ // 任务所属单位：回退审核操作组织
+ nextCaseTask.setCandeUnitId(loginUser.getUnitId());
+ nextCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ nextCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ nextCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ nextCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ nextCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ nextCaseTask.setCustId(nextCaseTask.getCustId());
+ nextCaseTask.setCreateTime(nowDate);
+ nextCaseTask.setUpdateTime(nowDate);
+ mapper.insert(nextCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(htshCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_1.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_1.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ // 有配合组织，结束配合组织工作流程
+ List<CaseTask> assistCaseTaskList = this.listAssistTasking(htshCaseTask.getCaseId());
+ for (CaseTask assistCaseTask: assistCaseTaskList){
+ // 完成配合组织当前任务
+ assistCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ assistCaseTask.setHandleUnitId(loginUser.getUnitId());
+ assistCaseTask.setHandleUnitName(loginUser.getUnitName()+"（承办部门）");
+ assistCaseTask.setHandleDeptId(loginUser.getDeptId());
+ assistCaseTask.setHandleDeptName(loginUser.getDeptName()+"（承办部门）");
+ assistCaseTask.setHandleUserId(loginUser.getId());
+ assistCaseTask.setHandleUserName(loginUser.getTrueName()+"（承办部门）");
+ assistCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
+ assistCaseTask.setHandleTime(nowDate);
+ assistCaseTask.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ assistCaseTask.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(assistCaseTask.getHandleTime(), assistCaseTask.getCreateTime()));
+ assistCaseTask.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(assistCaseTask.getHandleTime(), assistCaseTask.getExpireTime()));
+ assistCaseTask.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(assistCaseTask.getHandleTime(), assistCaseTask.getExpireTime()));
+ mapper.updateCaseTask(assistCaseTask);
+ // 结束配合组织当前工作流任务
+ flowInfoService.endFlow(assistCaseTask.getProcessInstanceId());
+ // 更新联合处置信息
+ UpdateWrapper<CaseAssistInfo> caseAssistInfoUpdateWrapper = new UpdateWrapper<>();
+ caseAssistInfoUpdateWrapper.eq("case_id", htshCaseTask.getCaseId())
+ .eq("process_instance_id", assistCaseTask.getProcessInstanceId())
+ .eq("assist_status", CaseTaskConsts.ASSIST_STATUS_0).set("assist_status", CaseTaskConsts.ASSIST_STATUS_2);
+ caseAssistInfoService.update(caseAssistInfoUpdateWrapper);
+ }
+ }else {
+ // 更新联合处置信息
+ QueryWrapper<CaseAssistInfo> caseAssistInfoQueryWrapper = new QueryWrapper<>();
+ caseAssistInfoQueryWrapper.eq("case_id", htshCaseTask.getCaseId())
+ .eq("assist_unit_id", htshCaseTask.getCandeUnitId())
+ .eq("assist_status", CaseTaskConsts.ASSIST_STATUS_0);
+ CaseAssistInfo caseAssistInfo = caseAssistInfoService.getOne(caseAssistInfoQueryWrapper);
+ if (ObjectUtils.isNotEmpty(caseAssistInfo)){
+ caseAssistInfo.setAssistStatus(CaseTaskConsts.ASSIST_STATUS_1);
+ caseAssistInfoService.updateCaseAssistInfo(caseAssistInfo);
+ }
+ }
+ }else {
+ // 审核不通过
+ // 完成当前回退审核节点任务
+ CaseTask htshCaseTaskPO = new CaseTask();
+ htshCaseTaskPO.setId(caseReturn.getCaseTaskId());
+ htshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ htshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ htshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ htshCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ htshCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ htshCaseTaskPO.setHandleUserId(loginUser.getId());
+ htshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ htshCaseTaskPO.setHandleContent(caseReturn.getAuditContent());
+ htshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
+ htshCaseTaskPO.setHandleTime(nowDate);
+ htshCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ htshCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(htshCaseTaskPO.getHandleTime(), htshCaseTask.getCreateTime()));
+ htshCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(htshCaseTaskPO.getHandleTime(), htshCaseTask.getExpireTime()));
+ htshCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(htshCaseTaskPO.getHandleTime(), htshCaseTask.getExpireTime()));
+ mapper.updateCaseTask(htshCaseTaskPO);
+ // 查询回退申请信息
+ CaseReturn btyCaseReturn = caseReturnService.getById(caseReturn.getId());
+ // 查询回退申请组织信息
+ CtUnitDTO returnUnit = custClient.getUnitById(btyCaseReturn.getReturnUnitId());
+ FlowNode nextFlowNode = null;
+ if (UserBaseConsts.UNIT_GRADE_2 == returnUnit.getUnitGrade()){
+ // 区级组织回退，完成当前回退审核节点任务，进入下一个节点
+ nextFlowNode = flowInfoService.completeTask(htshCaseTask.getFlowableId(), htshCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_htsh_bty_qj, userId);
+ }else if(UserBaseConsts.UNIT_GRADE_1 == returnUnit.getUnitGrade()){
+ // 市级组织回退，完成当前回退审核节点任务，进入下一个节点
+ nextFlowNode = flowInfoService.completeTask(htshCaseTask.getFlowableId(), htshCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_htsh_bty_sj, userId);
+ }else {
+ // 完成当前回退审核节点任务，进入下一个节点
+ nextFlowNode = flowInfoService.completeTask(htshCaseTask.getFlowableId(), htshCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_htsh_bty, userId);
+ }
+ // 新建下一个节点任务
+ CaseTask nextCaseTask = new CaseTask();
+ nextCaseTask.setId(utilsClient.getNewTimeId());
+ nextCaseTask.setCaseId(htshCaseTask.getCaseId());
+ nextCaseTask.setFlowableId(nextFlowNode.getFlowableId());
+ nextCaseTask.setProcessInstanceId(nextFlowNode.getProcessInstanceId());
+ nextCaseTask.setProcessTaskId(nextFlowNode.getProcessTaskId());
+ nextCaseTask.setNodeType(nextFlowNode.getNodeType());
+ nextCaseTask.setNodeId(nextFlowNode.getNodeId());
+ nextCaseTask.setNodeName(nextFlowNode.getNodeName());
+ nextCaseTask.setFlowId(nextFlowNode.getFlowId());
+ nextCaseTask.setNodeShowName(nextFlowNode.getNodeShowName());
+ nextCaseTask.setCaseTaskType(htshCaseTask.getCaseTaskType());
+ // 任务所属组织：回退申请组织
+ nextCaseTask.setCandeUnitId(btyCaseReturn.getReturnUnitId());
+ nextCaseTask.setCandeUnitName(btyCaseReturn.getReturnUnitName());
+ // 受理后的节点任务，不需要签收
+ nextCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (nextFlowNode.getExpire() != 0) {
+ nextCaseTask.setExpireTime(DateUtils.addDay(nowDate, nextFlowNode.getExpire()));
+ }
+ nextCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ nextCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ nextCaseTask.setCustId(htshCaseTask.getCustId());
+ nextCaseTask.setCreateTime(nowDate);
+ nextCaseTask.setUpdateTime(nowDate);
+ mapper.insert(nextCaseTask);
+ }
+ }catch (Exception e){
+ log.error("[CaseTaskService.webReturnAudit]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webReturnAudit", e);
+ }
+ }
+
+ /**
+ * web端任务处理-上报
+ * @param caseAppear 上报表单
+ * @param userId 当前登录用户
+ */
+ public void webAppearApply(CaseAppear caseAppear, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 创建上报信息
+ caseAppear.setAppearUnitId(loginUser.getUnitId());
+ caseAppear.setAppearUnitName(loginUser.getUnitName());
+ caseAppear.setAppearUserId(loginUser.getId());
+ caseAppear.setAppearUserName(loginUser.getTrueName());
+ caseAppear.setAppearTime(nowDate);
+ caseAppear.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_0);
+ caseAppear.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ caseAppear.setCustId(loginUser.getCustId());
+ caseAppear.setCreateTime(nowDate);
+ caseAppear.setUpdateTime(nowDate);
+ // 查询当前节点任务
+ CaseTask thisCaseTask = mapper.selectById(caseAppear.getCaseTaskId());
+ // 完成当前当前节点任务
+ CaseTask thisCaseTaskPO = new CaseTask();
+ thisCaseTaskPO.setId(caseAppear.getCaseTaskId());
+ thisCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ thisCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ thisCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ thisCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ thisCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ thisCaseTaskPO.setHandleUserId(loginUser.getId());
+ thisCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ thisCaseTaskPO.setHandleContent(caseAppear.getAppearContent());
+ thisCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_5);
+ thisCaseTaskPO.setHandleTime(nowDate);
+ thisCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ thisCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(thisCaseTaskPO.getHandleTime(), thisCaseTask.getCreateTime()));
+ thisCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(thisCaseTaskPO.getHandleTime(), thisCaseTask.getExpireTime()));
+ thisCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(thisCaseTaskPO.getHandleTime(), thisCaseTask.getExpireTime()));
+ mapper.updateCaseTask(thisCaseTaskPO);
+ // 完成当前待受理工作流节点任务，走上报审核任务
+ FlowNode sbshFlowNode = flowInfoService.completeTask(thisCaseTask.getFlowableId(), thisCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_sb, userId);
+ // 新建上报审核任务
+ CaseTask sbshCaseTask = new CaseTask();
+ sbshCaseTask.setId(utilsClient.getNewTimeId());
+ sbshCaseTask.setCaseId(thisCaseTask.getCaseId());
+ sbshCaseTask.setFlowableId(sbshFlowNode.getFlowableId());
+ sbshCaseTask.setProcessInstanceId(sbshFlowNode.getProcessInstanceId());
+ sbshCaseTask.setProcessTaskId(sbshFlowNode.getProcessTaskId());
+ sbshCaseTask.setNodeType(sbshFlowNode.getNodeType());
+ sbshCaseTask.setNodeId(sbshFlowNode.getNodeId());
+ sbshCaseTask.setNodeName(sbshFlowNode.getNodeName());
+ sbshCaseTask.setFlowId(sbshFlowNode.getFlowId());
+ sbshCaseTask.setNodeShowName(sbshFlowNode.getNodeShowName());
+ sbshCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位，上报审核组织
+ sbshCaseTask.setCandeUnitId(caseAppear.getAuditUnitId());
+ sbshCaseTask.setCandeUnitName(caseAppear.getAuditUnitName());
+ // 受理后的节点任务，不需要签收
+ sbshCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ // 任务处理时限
+ if (sbshFlowNode.getExpire() != 0) {
+ sbshCaseTask.setExpireTime(DateUtils.addDay(nowDate, sbshFlowNode.getExpire()));
+ }
+ sbshCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ sbshCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ sbshCaseTask.setCustId(sbshCaseTask.getCustId());
+ sbshCaseTask.setCreateTime(nowDate);
+ sbshCaseTask.setUpdateTime(nowDate);
+ mapper.insert(sbshCaseTask);
+ // 新增上报申请信息
+ caseAppear.setCaseTaskId(sbshCaseTask.getId());
+ caseAppearService.save(caseAppear);
+ }catch (Exception e){
+ log.error("[CaseTaskService.webAppearApply]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webAppearApply", e);
+ }
+ }
+
+ /**
+ * web端任务处理-上报审核
+ * @param caseAppear 上报审核表单
+ * @param userId 当前登录用户
+ */
+ public void webAppearAudit(CaseAppear caseAppear, String userId){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 获取当前登录用户
+ CtUserDTO loginUser = custClient.clientGetUserAll(userId);
+ // 更新上报信息
+ caseAppear.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_1);
+ caseAppear.setAuditUserId(loginUser.getId());
+ caseAppear.setAuditUserName(loginUser.getTrueName());
+ caseAppear.setAuditTime(nowDate);
+ caseAppear.setUpdateTime(nowDate);
+ caseAppearService.updateCaseAppear(caseAppear);
+ // 查询上报审核节点任务
+ CaseTask sbshCaseTask = mapper.selectById(caseAppear.getCaseTaskId());
+ // 审核通过
+ if (AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex().equals(caseAppear.getAuditResult())){
+ // 完成当前上报审核节点任务
+ CaseTask sbshCaseTaskPO = new CaseTask();
+ sbshCaseTaskPO.setId(caseAppear.getCaseTaskId());
+ sbshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ sbshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ sbshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ sbshCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ sbshCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ sbshCaseTaskPO.setHandleUserId(loginUser.getId());
+ sbshCaseTaskPO.setHandleContent(caseAppear.getAuditContent());
+ sbshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ sbshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
+ sbshCaseTaskPO.setHandleTime(nowDate);
+ sbshCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ sbshCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(sbshCaseTaskPO.getHandleTime(), sbshCaseTask.getCreateTime()));
+ sbshCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(sbshCaseTaskPO.getHandleTime(), sbshCaseTask.getExpireTime()));
+ sbshCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(sbshCaseTaskPO.getHandleTime(), sbshCaseTask.getExpireTime()));
+ mapper.updateCaseTask(sbshCaseTaskPO);
+ // 完成当前上报审核任务，走待分派任务
+ FlowNode dfpFlowNode = flowInfoService.completeTask(sbshCaseTask.getFlowableId(), sbshCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_sbsh_ty, userId);
+ // 新建待分派任务
+ CaseTask dfphCaseTask = new CaseTask();
+ dfphCaseTask.setId(utilsClient.getNewTimeId());
+ dfphCaseTask.setCaseId(sbshCaseTask.getCaseId());
+ dfphCaseTask.setFlowableId(dfpFlowNode.getFlowableId());
+ dfphCaseTask.setProcessInstanceId(dfpFlowNode.getProcessInstanceId());
+ dfphCaseTask.setProcessTaskId(dfpFlowNode.getProcessTaskId());
+ dfphCaseTask.setNodeType(dfpFlowNode.getNodeType());
+ dfphCaseTask.setNodeId(dfpFlowNode.getNodeId());
+ dfphCaseTask.setNodeName(dfpFlowNode.getNodeName());
+ dfphCaseTask.setFlowId(dfpFlowNode.getFlowId());
+ dfphCaseTask.setNodeShowName(dfpFlowNode.getNodeShowName());
+ dfphCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：上报审核组织
+ dfphCaseTask.setCandeUnitId(loginUser.getUnitId());
+ dfphCaseTask.setCandeUnitName(loginUser.getUnitName());
+ // 受理后的节点任务，不需要签收
+ dfphCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ dfphCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ // 任务处理时限
+ if (dfpFlowNode.getExpire() != 0) {
+ dfphCaseTask.setExpireTime(DateUtils.addDay(nowDate, dfpFlowNode.getExpire()));
+ }
+ dfphCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dfphCaseTask.setCustId(dfphCaseTask.getCustId());
+ dfphCaseTask.setCreateTime(nowDate);
+ dfphCaseTask.setUpdateTime(nowDate);
+ mapper.insert(dfphCaseTask);
+ // 更新纠纷信息
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(sbshCaseTask.getCaseId());
+ caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_1.getIndex());
+ caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_1.getDes());
+ caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
+ caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
+ caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
+ caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
+ caseInfoPO.setUpdateTime(nowDate);
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }else {
+ // 审核不通过
+ // 完成当前上报审核任务
+ CaseTask sbshCaseTaskPO = new CaseTask();
+ sbshCaseTaskPO.setId(caseAppear.getCaseTaskId());
+ sbshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
+ sbshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
+ sbshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
+ sbshCaseTaskPO.setHandleDeptId(loginUser.getDeptId());
+ sbshCaseTaskPO.setHandleDeptName(loginUser.getDeptName());
+ sbshCaseTaskPO.setHandleUserId(loginUser.getId());
+ sbshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
+ sbshCaseTaskPO.setHandleContent(caseAppear.getAuditContent());
+ sbshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
+ sbshCaseTaskPO.setHandleTime(nowDate);
+ sbshCaseTaskPO.setUpdateTime(nowDate);
+ // 计算任务耗时、是否超时、超时多少
+ sbshCaseTaskPO.setUsetimeHour(TaskUsetimeUtils.getUsetimeHour(sbshCaseTaskPO.getHandleTime(), sbshCaseTask.getCreateTime()));
+ sbshCaseTaskPO.setOvertimeStatus(TaskUsetimeUtils.getOvertimeStatus(sbshCaseTaskPO.getHandleTime(), sbshCaseTask.getExpireTime()));
+ sbshCaseTaskPO.setOvertimeHour(TaskUsetimeUtils.getOvertimeHour(sbshCaseTaskPO.getHandleTime(), sbshCaseTask.getExpireTime()));
+ mapper.updateCaseTask(sbshCaseTaskPO);
+ // 完成当前上报审核任务，走待分派任务
+ FlowNode dfpFlowNode = flowInfoService.completeTask(sbshCaseTask.getFlowableId(), sbshCaseTask.getProcessTaskId(),
+ FlowableConsts.OPERATION_sbsh_bty, userId);
+ // 新建待分派任务
+ CaseTask dfphCaseTask = new CaseTask();
+ dfphCaseTask.setId(utilsClient.getNewTimeId());
+ dfphCaseTask.setCaseId(sbshCaseTask.getCaseId());
+ dfphCaseTask.setFlowableId(dfpFlowNode.getFlowableId());
+ dfphCaseTask.setProcessInstanceId(dfpFlowNode.getProcessInstanceId());
+ dfphCaseTask.setProcessTaskId(dfpFlowNode.getProcessTaskId());
+ dfphCaseTask.setNodeType(dfpFlowNode.getNodeType());
+ dfphCaseTask.setNodeId(dfpFlowNode.getNodeId());
+ dfphCaseTask.setNodeName(dfpFlowNode.getNodeName());
+ dfphCaseTask.setFlowId(dfpFlowNode.getFlowId());
+ dfphCaseTask.setNodeShowName(dfpFlowNode.getNodeShowName());
+ dfphCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
+ // 任务所属单位：上报申请组织
+ CaseAppear caseAppearBO = caseAppearService.getById(caseAppear.getId());
+ dfphCaseTask.setCandeUnitId(caseAppearBO.getAppearUnitId());
+ dfphCaseTask.setCandeUnitName(caseAppearBO.getAppearUnitName());
+ // 受理后的节点任务，不需要签收
+ dfphCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
+ dfphCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
+ // 任务处理时限
+ if (dfpFlowNode.getExpire() != 0) {
+ dfphCaseTask.setExpireTime(DateUtils.addDay(nowDate, dfpFlowNode.getExpire()));
+ }
+ dfphCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ dfphCaseTask.setCustId(dfphCaseTask.getCustId());
+ dfphCaseTask.setCreateTime(nowDate);
+ dfphCaseTask.setUpdateTime(nowDate);
+ mapper.insert(dfphCaseTask);
+ }
+ }catch (Exception e){
+ log.error("[CaseTaskService.webAppearAudit]调用失败，异常信息："+e, e);
+ throw new ServiceException("CaseTaskService.webAppearAudit", e);
+ }
+ }
+
+ /**
+ * 按条件查询
+ * @param terms 条件
+ * @return List
+ */
+ public List<SignTaskDTO> listIdByTerms(Map<String, Object> terms){
+ return mapper.listIdByTerms(terms);
+ }
+
+ /**
+ * web端-工作台-已办事项
+ * @param page 分页对象
+ * @param terms 条件
+ * @return Page
+ */
+ public Page<FrontPageListYBDTO> pageMyTaskYb(PageRequest page, Map<String, Object> terms){
+ try {
+ long total = mapper.countMyTaskYb(terms);
+ List<FrontPageListYBDTO> frontPageListYBDTOList = mapper.pageMyTaskYb(page, terms);
+ return new PageImpl<FrontPageListYBDTO>(frontPageListYBDTOList, page, total);
+ }catch (Exception e) {
+ log.error("[CaseTaskService.pageMyTaskYb]调用失败，异常信息：" + e, e);
+ throw new ServiceException("CaseTaskService.pageMyTaskYb", e);
+ }
+ }
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzService.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzService.java
index 726ba7e..b091d6a 100644
--- a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzService.java
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ByToGzService.java
@@ -1,27 +1,36 @@
package cn.huge.module.syncbydyh.service;
import cn.huge.base.common.exception.ServiceException;
-import cn.huge.module.cases.domain.po.CaseAgent;
-import cn.huge.module.cases.domain.po.CaseInfo;
-import cn.huge.module.cases.domain.po.CasePerson;
-import cn.huge.module.cases.domain.po.CaseTask;
+import cn.huge.base.common.utils.ObjectUtils;
+import cn.huge.module.cases.domain.dto.AcceptTaskDTO;
+import cn.huge.module.cases.domain.po.*;
import cn.huge.module.cases.service.*;
+import cn.huge.module.client.api.impl.CustClientImpl;
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.disp.dto.DispCaseBaseDTO;
import cn.huge.module.syncbydyh.client.api.impl.SyncBydyhClientImpl;
+import cn.huge.module.syncbydyh.domain.dto.ByCaseTaskDTO;
import cn.huge.module.syncbydyh.domain.dto.GZCaseDTO;
+import cn.huge.module.syncbydyh.domain.po.SyCause;
+import cn.huge.module.syncbydyh.domain.po.ThirdCause;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
+import java.util.ArrayList;
import java.util.List;
/**
- * @title: 白云数据割接为广州数据的业务逻辑处理
- * @Description 白云数据割接为广州数据的业务逻辑处理
+ * @title: 白云区矛盾纠纷多元化解平台数据割接-公共逻辑处理
+ * @Description 白云区矛盾纠纷多元化解平台数据割接-公共逻辑处理
* @company hugeinfo
* @author liyj
* @Time 2024-08-19 20:04:19
@@ -43,49 +52,67 @@
private CaseAgentService caseAgentService;
@Autowired
private CaseTaskService caseTaskService;
+ @Autowired
+ private ThirdCauseService thirdCauseService;
+ @Autowired
+ private SyCauseService syCauseService;
+ @Autowired
+ private CustClientImpl custClient;
+ @Autowired
+ private ByToGzCaseTaskService byToGzCaseTaskService;
/**
* 白云区矛盾纠纷多元化解平台数据割接-已结束的纠纷案件信息
*/
public void byToGzEndCase(){
try{
+ List<CaseInfo> errorCaseList = new ArrayList<>();
int operSize = 100;
// int endCaseCount = 1000;
int endCaseCount = syncBydyhClient.countEndCase();
if (endCaseCount > 0) {
- int allPage = (endCaseCount/operSize);
-// int allPage = 1;
+// int allPage = (endCaseCount/operSize);
+ int allPage = 20;
for (int operPage=1; operPage<=allPage; operPage++) {
- try{
- List<GZCaseDTO> byToGzDTOList = syncBydyhClient.byToGzEndCase(operPage, operSize);
- for (GZCaseDTO byToGzDTO: byToGzDTOList){
- caseInfoService.saveOrUpdate(byToGzDTO.getGzCaseInfoDTO());
-
+ List<GZCaseDTO> byToGzDTOList = syncBydyhClient.byToGzEndCase(operPage, operSize);
+ for (GZCaseDTO byToGzDTO: byToGzDTOList){
+ // 新增案件信息
+ CaseInfo caseInfo = byToGzDTO.getGzCaseInfoDTO();
+ try {
+ if (caseInfo.getCaseClaim().length() > 200) {
+ caseInfo.setCaseClaim("详见申请材料");
+ }
+ if (caseInfo.getCaseDes().length() > 200) {
+ caseInfo.setCaseDes("详见申请材料");
+ }
+ caseInfoService.saveOrUpdate(caseInfo);
+ // 新增案件扩展信息
caseInfoUnfoldService.saveOrUpdate(byToGzDTO.getGzCaseInfoUnfoldDTO());
-
+ // 新增当事人信息
List<CasePerson> casePersonList = byToGzDTO.getGzCasePersonDTOList();
if (CollectionUtils.isNotEmpty(casePersonList)) {
for (CasePerson casePerson : casePersonList) {
casePersonService.saveOrUpdate(casePerson);
}
}
-
+ // 新增当事人代理人信息
List<CaseAgent> caseAgentList = byToGzDTO.getGzCaseAgentDTOList();
if (CollectionUtils.isNotEmpty(caseAgentList)) {
for (CaseAgent caseAgent : caseAgentList) {
caseAgentService.saveOrUpdate(caseAgent);
}
}
-
+ // 新增纠纷任务信息
List<CaseTask> caseTaskList = byToGzDTO.getGzCaseTaskDTOList();
if (CollectionUtils.isNotEmpty(caseTaskList)) {
for (CaseTask caseTask : caseTaskList) {
caseTaskService.saveOrUpdate(caseTask);
}
}
+ }catch (Exception e){
+ log.error("[ByToGzService.byToGzEndCase]调用失败，异常信息："+e, e);
+ errorCaseList.add(byToGzDTO.getGzCaseInfoDTO());
}
- }catch (Exception e){
- log.error("[ByToGzService.byToGzEndCase]调用失败，异常信息："+e, e);
}
}
}
@@ -94,4 +121,156 @@
throw new ServiceException("ByToGzService.byToGzEndCase", e);
}
}
+
+ /**
+ * 白云区矛盾纠纷多元化解平台数据割接-进行中的纠纷案件信息
+ */
+ public void byToGzTodoCase(){
+ try{
+ int operSize = 100;
+ int endCaseCount = syncBydyhClient.countTodoCase();
+ if (endCaseCount > 0) {
+ int allPage = (endCaseCount/operSize);
+ for (int operPage=1; operPage<=allPage; operPage++) {
+ List<GZCaseDTO> byToGzDTOList = syncBydyhClient.byToGzTodoCase(operPage, operSize);
+ for (GZCaseDTO byToGzDTO: byToGzDTOList){
+ try {
+ // 新增案件信息
+ CaseInfo caseInfo = byToGzDTO.getGzCaseInfoDTO();
+ if (caseInfo.getCaseClaim().length() > 200) {
+ caseInfo.setCaseClaim("详见申请材料");
+ }
+ if (caseInfo.getCaseDes().length() > 200) {
+ caseInfo.setCaseDes("详见申请材料");
+ }
+ caseInfoService.saveOrUpdate(caseInfo);
+ // 新增案件扩展信息
+ CaseInfoUnfold caseInfoUnfold = byToGzDTO.getGzCaseInfoUnfoldDTO();
+ caseInfoUnfoldService.saveOrUpdate(caseInfoUnfold);
+ // 新增当事人信息
+ List<CasePerson> casePersonList = byToGzDTO.getGzCasePersonDTOList();
+ if (CollectionUtils.isNotEmpty(casePersonList)) {
+ for (CasePerson casePerson : casePersonList) {
+ casePersonService.saveOrUpdate(casePerson);
+ }
+ }
+ // 新增当事人代理人信息
+ List<CaseAgent> caseAgentList = byToGzDTO.getGzCaseAgentDTOList();
+ if (CollectionUtils.isNotEmpty(caseAgentList)) {
+ for (CaseAgent caseAgent : caseAgentList) {
+ caseAgentService.saveOrUpdate(caseAgent);
+ }
+ }
+ // 启动流程
+ caseTaskService.deleteByCaseId(caseInfo.getId());
+ if (StringUtils.isNotEmpty(caseInfoUnfold.getMediateUnitId())
+ && StringUtils.isNotEmpty(caseInfo.getWantUnitId())
+ && caseInfo.getWantUnitId().equals(caseInfoUnfold.getMediateUnitId())) {
+ CtUserDTO ctUserDTO = custClient.clientGetUserAll(caseInfo.getInputUserId());
+ byToGzCaseTaskService.webStartFlowZXSL(caseInfo, ctUserDTO);
+ } else {
+ DispCaseBaseDTO dispCaseBaseDTO = new DispCaseBaseDTO();
+ BeanUtils.copyProperties(caseInfo, dispCaseBaseDTO);
+ dispCaseBaseDTO.setWantUserId(null);
+ dispCaseBaseDTO.setWantUserName(null);
+ if (StringUtils.isNotEmpty(caseInfoUnfold.getMediateUnitId())) {
+ dispCaseBaseDTO.setWantUnitId(caseInfoUnfold.getMediateUnitId());
+ dispCaseBaseDTO.setWantUnitName(caseInfoUnfold.getMediateUnitName());
+ String dslCaseTaskId = byToGzCaseTaskService.webStartFlowLFDJ(caseInfo, dispCaseBaseDTO);
+
+ List<ByCaseTaskDTO> byCaseTaskDTOList = byToGzDTO.getByCaseTaskDTOList();
+ if (CollectionUtils.isNotEmpty(byCaseTaskDTOList)) {
+ for (ByCaseTaskDTO byCaseTaskDTO : byCaseTaskDTOList) {
+ if ("F22_00019-2".equals(byCaseTaskDTO.getTaskNode())) {
+ AcceptTaskDTO acceptTaskDTO = new AcceptTaskDTO();
+ acceptTaskDTO.setCaseTaskId(dslCaseTaskId);
+ try {
+ byToGzCaseTaskService.webAccept(acceptTaskDTO, byCaseTaskDTO.getHandlerUserId(), byCaseTaskDTO.getCreateTime());
+ } catch (Exception e) {
+ log.error(e.getMessage(), e);
+ }
+ }
+ }
+ }
+ } else {
+ byToGzCaseTaskService.webStartFlowLFDJ(caseInfo, dispCaseBaseDTO);
+ }
+ }
+ }catch (Exception e){
+ log.error("[ByToGzService.byToGzEndCase]调用失败，异常信息："+e, e);
+ }
+ }
+ }
+ }
+ }catch (Exception e){
+ log.error("[ByToGzService.byToGzEndCase]调用失败，异常信息："+e, e);
+ throw new ServiceException("ByToGzService.byToGzEndCase", e);
+ }
+ }
+
+ /**
+ * 白云区矛盾纠纷多元化解平台数据割接-更新纠纷类型
+ */
+ public void upThirdCause(){
+ try{
+ List<CaseInfo> caseInfoList = caseInfoService.list();
+ QueryWrapper<ThirdCause> thirdCauseQueryWrapper = new QueryWrapper<>();
+ for (CaseInfo caseInfo: caseInfoList){
+ thirdCauseQueryWrapper.clear();
+ thirdCauseQueryWrapper.eq("third_code", caseInfo.getCaseType());
+ ThirdCause thirdCause = thirdCauseService.getOne(thirdCauseQueryWrapper);
+ if (ObjectUtils.isNotEmpty(thirdCause)){
+ SyCause syCause = syCauseService.getById(thirdCause.getCauseCode());
+ if (ObjectUtils.isNotEmpty(syCause)){
+ // 查询父级
+ SyCause syCausePanrent = syCauseService.getById(syCause.getParentId());
+ if (ObjectUtils.isNotEmpty(syCausePanrent)){
+ try{
+ CaseInfo caseInfoPO = new CaseInfo();
+ caseInfoPO.setId(caseInfo.getId());
+ caseInfoPO.setCaseType(syCause.getId());
+ caseInfoPO.setCaseTypeName(syCause.getName());
+ caseInfoPO.setCaseTypeFirst(syCausePanrent.getId());
+ caseInfoPO.setCaseTypeFirstName(syCausePanrent.getName());
+ caseInfoService.updateCaseInfo(caseInfoPO);
+ }catch (Exception e){
+ log.error("[ByToGzService.upThirdCause]调用失败，异常信息："+e, e);
+ }
+ }
+ }
+ }
+ }
+ }catch (Exception e){
+ log.error("[ByToGzService.byToGzEndCase]调用失败，异常信息："+e, e);
+ throw new ServiceException("ByToGzService.byToGzEndCase", e);
+ }
+
+ }
+
+ /**
+ * 白云区矛盾纠纷多元化解平台数据割接-更新问题属地的村级社区
+ */
+ public void upQueAddr(){
+ try{
+ List<CaseInfoUnfold> caseInfoUnfoldList = caseInfoUnfoldService.list();
+ for (CaseInfoUnfold caseInfoUnfold: caseInfoUnfoldList){
+ if (StringUtils.isNotEmpty(caseInfoUnfold.getMediateUnitId())) {
+ CtUnitDTO ctUnitDTO = custClient.getUnitById(caseInfoUnfold.getMediateUnitId());
+ if (ObjectUtils.isNotEmpty(ctUnitDTO)){
+ if (StringUtils.isNotEmpty(ctUnitDTO.getVillage())) {
+ CaseInfo caseInfo = new CaseInfo();
+ caseInfo.setId(caseInfoUnfold.getId());
+ caseInfo.setQueVillage(ctUnitDTO.getVillage());
+ caseInfo.setQueVillageName(ctUnitDTO.getVillageName());
+ caseInfoService.updateCaseInfo(caseInfo);
+ }
+ }
+ }
+ }
+ }catch (Exception e){
+ log.error("[ByToGzService.upQueAddr]调用失败，异常信息："+e, e);
+ throw new ServiceException("ByToGzService.upQueAddr", e);
+ }
+
+ }
}
\ No newline at end of file
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/SyCauseService.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/SyCauseService.java
new file mode 100644
index 0000000..7e08db7
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/SyCauseService.java
@@ -0,0 +1,133 @@
+package cn.huge.module.syncbydyh.service;
+
+import cn.huge.base.common.exception.ServiceException;
+import cn.huge.base.common.utils.DateUtils;
+import cn.huge.base.common.utils.IdUtils;
+import cn.huge.module.client.api.impl.UtilsClientImpl;
+import cn.huge.module.syncbydyh.dao.mapper.SyCauseMapper;
+import cn.huge.module.syncbydyh.domain.po.SyCause;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+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 javax.annotation.PostConstruct;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @title: 纠纷类型信息表业务逻辑处理
+ * @Description 纠纷类型信息表业务逻辑处理
+ * @company hugeinfo
+ * @author liyj
+ * @Time 2024-10-21 22:18:51
+ * @version 1.0.0
+ */
+@Slf4j
+@Service
+@Transactional(rollbackFor = Exception.class)
+public class SyCauseService extends ServiceImpl<SyCauseMapper, SyCause>{
+
+ @Autowired
+ private SyCauseMapper mapper;
+
+ @Autowired
+ private UtilsClientImpl utilsClient;
+
+ /**
+ * 更新对象
+ * @param entity 对象
+ */
+ public void updateSyCause(SyCause entity){
+ try{
+ mapper.updateSyCause(entity);
+ }catch (Exception e){
+ log.error("[SyCauseService.updateSyCause]调用失败，异常信息："+e, e);
+ throw new ServiceException("SyCauseService.updateSyCause", e);
+ }
+ }
+
+ /**
+ * 条件更新对象
+ * @param entity 对象
+ * @param terms 条件
+ */
+ public void updateSyCauseTerms(SyCause entity, Map<String, Object> terms){
+ try{
+ mapper.updateSyCauseTerms(entity, terms);
+ }catch (Exception e){
+ log.error("[SyCauseService.updateSyCauseTerms]调用失败，异常信息："+e, e);
+ throw new ServiceException("SyCauseService.updateSyCauseTerms", e);
+ }
+ }
+
+ /**
+ * 根据编号物理删除
+ * @param id 查询条件集合
+ */
+ public void deleteSyCause(String id){
+ try{
+ mapper.deleteSyCause(id);
+ }catch (Exception e){
+ log.error("[SyCauseService.deleteSyCause]调用失败，异常信息："+e, e);
+ throw new ServiceException("SyCauseService.deleteSyCause", e);
+ }
+ }
+
+ /**
+ * 按条件查询
+ * @param terms 条件
+ * @return List
+ */
+ public List<SyCause> 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<SyCause> pageQuery(PageRequest page, Map<String, Object> terms){
+ long total = mapper.countTerms(terms);
+ List<SyCause> content = mapper.pageTerms(page, terms);
+ return new PageImpl<SyCause>(content, page, total);
+ }
+
+ /**
+ * 新增或更新对象
+ * @param syCause 实体对象
+ */
+ public void saveSyCause(SyCause syCause){
+ try{
+ Date nowDate = DateUtils.getNowDate();
+ // 判断是否新增
+ if (IdUtils.checkNewId(syCause.getId())){
+ syCause.setId(utilsClient.getNewTimeId());
+ syCause.setCreateTime(nowDate);
+ }
+ syCause.setUpdateTime(nowDate);
+ this.saveOrUpdate(syCause);
+ }catch (Exception e){
+ log.error("[SyCauseService.saveSyCause]调用失败，异常信息："+e, e);
+ throw new ServiceException("SyCauseService.saveSyCause", e);
+ }
+ }
+
+}
diff --git a/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ThirdCauseService.java b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ThirdCauseService.java
new file mode 100644
index 0000000..d18271f
--- /dev/null
+++ b/dyh-service/dyh-mediate/src/main/java/cn/huge/module/syncbydyh/service/ThirdCauseService.java
@@ -0,0 +1,113 @@
+package cn.huge.module.syncbydyh.service;
+
+import cn.huge.base.common.exception.ServiceException;
+import cn.huge.base.common.utils.DateUtils;
+import cn.huge.base.common.utils.IdUtils;
+import cn.huge.module.client.api.impl.UtilsClientImpl;
+import cn.huge.module.syncbydyh.dao.mapper.ThirdCauseMapper;
+import cn.huge.module.syncbydyh.domain.po.ThirdCause;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+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 javax.annotation.PostConstruct;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @title: 第三方纠纷类型映射表业务逻辑处理
+ * @Description 第三方纠纷类型映射表业务逻辑处理
+ * @company hugeinfo
+ * @author liyj
+ * @Time 2024-10-21 22:04:49
+ * @version 1.0.0
+ */
+@Slf4j
+@Service
+@Transactional(rollbackFor = Exception.class)
+public class ThirdCauseService extends ServiceImpl<ThirdCauseMapper, ThirdCause>{
+
+ @Autowired
+ private ThirdCauseMapper mapper;
+
+ @Autowired
+ private UtilsClientImpl utilsClient;
+
+ /**
+ * 更新对象
+ * @param entity 对象
+ */
+ public void updateThirdCause(ThirdCause entity){
+ try{
+ mapper.updateThirdCause(entity);
+ }catch (Exception e){
+ log.error("[ThirdCauseService.updateThirdCause]调用失败，异常信息："+e, e);
+ throw new ServiceException("ThirdCauseService.updateThirdCause", e);
+ }
+ }
+
+ /**
+ * 条件更新对象
+ * @param entity 对象
+ * @param terms 条件
+ */
+ public void updateThirdCauseTerms(ThirdCause entity, Map<String, Object> terms){
+ try{
+ mapper.updateThirdCauseTerms(entity, terms);
+ }catch (Exception e){
+ log.error("[ThirdCauseService.updateThirdCauseTerms]调用失败，异常信息："+e, e);
+ throw new ServiceException("ThirdCauseService.updateThirdCauseTerms", e);
+ }
+ }
+
+ /**
+ * 根据编号物理删除
+ * @param id 查询条件集合
+ */
+ public void deleteThirdCause(String id){
+ try{
+ mapper.deleteThirdCause(id);
+ }catch (Exception e){
+ log.error("[ThirdCauseService.deleteThirdCause]调用失败，异常信息："+e, e);
+ throw new ServiceException("ThirdCauseService.deleteThirdCause", e);
+ }
+ }
+
+ /**
+ * 按条件查询
+ * @param terms 条件
+ * @return List
+ */
+ public List<ThirdCause> 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<ThirdCause> pageQuery(PageRequest page, Map<String, Object> terms){
+ long total = mapper.countTerms(terms);
+ List<ThirdCause> content = mapper.pageTerms(page, terms);
+ return new PageImpl<ThirdCause>(content, page, total);
+ }
+
+}
diff --git a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/controller/SyncCaseController.java b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/controller/SyncCaseController.java
index fc05648..eb8f350 100644
--- a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/controller/SyncCaseController.java
+++ b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/controller/SyncCaseController.java
@@ -45,7 +45,7 @@
public Object countEndCase() {
try {
Map<String, Object> terms = Maps.newHashMap();
- terms.put("EndProcess", "EndProcess");
+ terms.put("endProcess", "endProcess");
return ReturnSucUtils.getRepInfo(caseInfoService.countTerms(terms));
} catch (Exception e) {
log.error("[SyncCustController.countEndCase]请求失败，异常信息："+e, e);
@@ -71,4 +71,39 @@
}
}
+ /**
+ * 数据割接-统计进行中的纠纷案件信息
+ * @url {ctx}/api/client/syncCase/countTodoCase
+ * @return
+ */
+ @GetMapping("/countTodoCase")
+ public Object countTodoCase() {
+ try {
+ Map<String, Object> terms = Maps.newHashMap();
+ terms.put("todoProcess", "todoProcess");
+ return ReturnSucUtils.getRepInfo(caseInfoService.countTerms(terms));
+ } catch (Exception e) {
+ log.error("[SyncCustController.countTodoCase]请求失败，异常信息："+e, e);
+ return ReturnFailUtils.getRepInfo(e.getMessage());
+ }
+ }
+
+ /**
+ * 数据割接-进行中的纠纷案件信息
+ * @url {ctx}/api/client/syncCase/byToGzTodoCase
+ * @param page
+ * @param size
+ * @return
+ */
+ @GetMapping("/byToGzTodoCase")
+ public Object byToGzTodoCase(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
+ try {
+ List<GZCaseDTO> gzCaseDTOList = caseInfoService.byToGzTodoCase(page, size);
+ return ReturnSucUtils.getRepInfo(gzCaseDTOList);
+ } catch (Exception e) {
+ log.error("[SyncCustController.byToGzTodoCase]请求失败，异常信息："+e, e);
+ return ReturnFailUtils.getRepInfo(e.getMessage());
+ }
+ }
+
}
diff --git a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/dao/mapper/xml/CaseInfoMapper.xml b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/dao/mapper/xml/CaseInfoMapper.xml
index be8b21a..62d84c7 100644
--- a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/dao/mapper/xml/CaseInfoMapper.xml
+++ b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/dao/mapper/xml/CaseInfoMapper.xml
@@ -670,9 +670,12 @@
and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
</if>
- <if test="terms.EndProcess != null and terms.EndProcess !=''">
+ <if test="terms.endProcess != null and terms.endProcess !=''">
and process in ('22_00006-4', '22_00006-5', '22_00006-6', '22_00006-7')
</if>
+ <if test="terms.todoProcess != null and terms.todoProcess !=''">
+ and process in ('22_00006-1', '22_00006-2', '22_00006-3')
+ </if>
</where>
</if>
</sql>
diff --git a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/domain/dto/GZCaseDTO.java b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/domain/dto/GZCaseDTO.java
index db23953..a6203a7 100644
--- a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/domain/dto/GZCaseDTO.java
+++ b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/domain/dto/GZCaseDTO.java
@@ -1,5 +1,6 @@
package cn.huge.module.bycase.domain.dto;
+import cn.huge.module.bycase.domain.po.CaseTask;
import lombok.Data;
import java.util.List;
@@ -25,4 +26,6 @@
private List<GZCaseTaskDTO> gzCaseTaskDTOList;
+ private List<CaseTask> byCaseTaskDTOList;
+
}
diff --git a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/service/CaseInfoService.java b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/service/CaseInfoService.java
index 92cb758..e328a56 100644
--- a/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/service/CaseInfoService.java
+++ b/dyh-service/dyh-sync-bydyh/src/main/java/cn/huge/module/bycase/service/CaseInfoService.java
@@ -133,7 +133,7 @@
public List<GZCaseDTO> byToGzEndCase(int page, int size){
List<GZCaseDTO> gzCaseDTOList = new ArrayList<>();
Map<String, Object> terms = Maps.newHashMap();
- terms.put("EndProcess", "EndProcess");
+ terms.put("endProcess", "endProcess");
Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
PageRequest pageRequest = PageRequest.of(page-1, size, sort);
Page<CaseInfo> caseInfoPage = this.pageQuery(pageRequest, terms);
@@ -445,7 +445,7 @@
}
// 结案归档节点
if (ByFlowNodeEnum.FLOW_NODE_4.getIndex().equals(caseTask.getTaskNode())
- || ByFlowNodeEnum.FLOW_NODE_5.getIndex().equals(caseTask.getTaskNode()) ){
+ || ByFlowNodeEnum.FLOW_NODE_5.getIndex().equals(caseTask.getTaskNode())){
gzCaseTaskDTO.setNodeId(GZFlowNodeEnum.FLOW_NODE_JAGD.getIndex());
gzCaseTaskDTO.setNodeName(GZFlowNodeEnum.FLOW_NODE_JAGD.getDes());
gzCaseTaskDTO.setNodeShowName("结案归档");
@@ -462,7 +462,7 @@
gzCaseTaskDTO.setCandeUserId(caseTask.getHandlerUserId());
gzCaseTaskDTO.setCandeUserName(caseTask.getHandlerUserName());
// 任务处理
- if ("2".equals(caseTask.getStatus())) {
+ if ("2".equals(caseTask.getStatus())){
gzCaseTaskDTO.setStatus(GZCaseTaskConsts.TASK_STATUS_2);
}else {
gzCaseTaskDTO.setStatus(GZCaseTaskConsts.TASK_STATUS_1);
@@ -502,4 +502,282 @@
return gzCaseDTOList;
}
+ /**
+ * 数据割接-进行中的纠纷案件信息
+ * @return
+ */
+ public List<GZCaseDTO> byToGzTodoCase(int page, int size){
+ List<GZCaseDTO> gzCaseDTOList = new ArrayList<>();
+ Map<String, Object> terms = Maps.newHashMap();
+ terms.put("todoProcess", "todoProcess");
+ Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
+ PageRequest pageRequest = PageRequest.of(page-1, size, sort);
+ Page<CaseInfo> caseInfoPage = this.pageQuery(pageRequest, terms);
+ for (CaseInfo caseInfo: caseInfoPage){
+ if ("2105191835025741".equals(caseInfo.getWantUnitId()) || "2105191835025741".equals(caseInfo.getMediateUnitId())){
+ log.info("过滤演示案件");
+ }else {
+ GZCaseDTO gzCaseDTO = new GZCaseDTO();
+ // 封装案件信息
+ GZCaseInfoDTO gzCaseInfoDTO = new GZCaseInfoDTO();
+ BeanUtils.copyProperties(caseInfo, gzCaseInfoDTO);
+ // 生成事项编号
+ gzCaseInfoDTO.setCaseRef(utilsClient.createCaseRef());
+ // 都是3级事件
+ gzCaseInfoDTO.setCaseLevel(CaseBaseConsts.CASE_LEVEL_3);
+ // 映射来访时间
+ gzCaseInfoDTO.setVisitTime(caseInfo.getAcceptTime());
+ // 映射来访人数
+ gzCaseInfoDTO.setVisitPeopleNum(caseInfo.getPeopleNum());
+ // 映射纠纷类型
+// gzCaseInfoDTO.setCaseTypeFirst();
+// gzCaseInfoDTO.setCaseTypeFirstName();
+// gzCaseInfoDTO.setCaseType();
+// gzCaseInfoDTO.setCaseTypeName();
+ // 映射问题属地
+ gzCaseInfoDTO.setQueProv(GzRegionEnum.PROV_1.getIndex());
+ gzCaseInfoDTO.setQueProvName(GzRegionEnum.PROV_1.getDes());
+ gzCaseInfoDTO.setQueCity(GzRegionEnum.CITY_1.getIndex());
+ gzCaseInfoDTO.setQueCityName(GzRegionEnum.CITY_1.getDes());
+ gzCaseInfoDTO.setQueArea(GzRegionEnum.AREA_7.getIndex());
+ gzCaseInfoDTO.setQueAreaName(GzRegionEnum.AREA_7.getDes());
+ if (StringUtils.isNotEmpty(caseInfo.getRoad())) {
+ if (ByRegionEnum.getGZRegion(caseInfo.getRoad()) != null) {
+ gzCaseInfoDTO.setQueRoad(ByRegionEnum.getGZRegion(caseInfo.getRoad()).getIndex());
+ gzCaseInfoDTO.setQueRoadName(ByRegionEnum.getGZRegion(caseInfo.getRoad()).getDes());
+ }
+ }
+ gzCaseInfoDTO.setQueVillage(null);
+ gzCaseInfoDTO.setQueVillageName(null);
+ if ("2".equals(caseInfo.getInputWay())) {
+ gzCaseInfoDTO.setInputWay(2);
+ } else {
+ gzCaseInfoDTO.setInputWay(1);
+ }
+ // 映射事项来源、来访形式
+ if (ByCaseConstsEnum.CASE_CANAL_1.getIndex().equals(caseInfo.getCanal())) {
+ if (caseInfo.getMediateUnitId().equals(caseInfo.getInputUnitId())) {
+ // 事项来源
+ gzCaseInfoDTO.setCanal(CaseBaseConstsEnum.CASE_CANAL_3.getIndex());
+ gzCaseInfoDTO.setCanalName(CaseBaseConstsEnum.CASE_CANAL_3.getDes());
+ // 来访形式
+ gzCaseInfoDTO.setVisitWay(CaseBaseConstsEnum.getVisitWayByCanal(gzCaseInfoDTO.getCanal()).getIndex());
+ gzCaseInfoDTO.setVisitWayName(CaseBaseConstsEnum.getVisitWayByCanal(gzCaseInfoDTO.getCanal()).getDes());
+ } else {
+ // 事项来源
+ gzCaseInfoDTO.setCanal(CaseBaseConstsEnum.CASE_CANAL_1.getIndex());
+ gzCaseInfoDTO.setCanalName(CaseBaseConstsEnum.CASE_CANAL_1.getDes());
+ // 来访形式
+ gzCaseInfoDTO.setVisitWay(CaseBaseConstsEnum.getVisitWayByCanal(gzCaseInfoDTO.getCanal()).getIndex());
+ gzCaseInfoDTO.setVisitWayName(CaseBaseConstsEnum.getVisitWayByCanal(gzCaseInfoDTO.getCanal()).getDes());
+ }
+ } else if (ByCaseConstsEnum.CASE_CANAL_2.getIndex().equals(caseInfo.getCanal())) {
+ // 事项来源
+ gzCaseInfoDTO.setCanal(CaseBaseConstsEnum.CASE_CANAL_2.getIndex());
+ gzCaseInfoDTO.setCanalName(CaseBaseConstsEnum.CASE_CANAL_2.getDes());
+ // 来访形式
+ gzCaseInfoDTO.setVisitWay(CaseBaseConstsEnum.getVisitWayByCanal(gzCaseInfoDTO.getCanal()).getIndex());
+ gzCaseInfoDTO.setVisitWayName(CaseBaseConstsEnum.getVisitWayByCanal(gzCaseInfoDTO.getCanal()).getDes());
+ }
+ // 映射是否自行受理
+ gzCaseInfoDTO.setZxslStatus(CaseBaseConsts.ZXSL_STATUS_0);
+ // 是否重大矛盾纠纷
+ gzCaseInfoDTO.setMajorStatus(CaseBaseConsts.MAJOR_STATUS_0);
+ // 映射事项状态、事项进度、对外展示事项进度
+ if (ByCaseConstsEnum.CASE_PROCESS_1.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_3.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_3.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ } else if (ByCaseConstsEnum.CASE_PROCESS_2.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_3.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_3.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ } else if (ByCaseConstsEnum.CASE_PROCESS_3.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ } else if (ByCaseConstsEnum.CASE_PROCESS_4.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_7.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_7.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ } else if (ByCaseConstsEnum.CASE_PROCESS_5.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_8.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_8.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ } else if (ByCaseConstsEnum.CASE_PROCESS_6.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_8.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_8.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ } else if (ByCaseConstsEnum.CASE_PROCESS_7.getIndex().equals(caseInfo.getProcess())) {
+ // 事项状态
+ gzCaseInfoDTO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_8.getIndex());
+ gzCaseInfoDTO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_8.getDes());
+ // 事项进度
+ gzCaseInfoDTO.setProcess(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getIndex());
+ gzCaseInfoDTO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(gzCaseInfoDTO.getStatus()).getDes());
+ // 对外展示事项进度
+ gzCaseInfoDTO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getIndex());
+ gzCaseInfoDTO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(gzCaseInfoDTO.getProcess()).getDes());
+ }
+ // 映射小程序是否可见
+ gzCaseInfoDTO.setPartyShow(CaseBaseConsts.PARTY_SHOW_1);
+ // 映射删除状态
+ if (ByBaseConsts.DELETE_STATUS_99.equals(caseInfo.getDeleteStatus())) {
+ gzCaseInfoDTO.setDeleteStatus(BaseConsts.DELETE_STATUS_1);
+ } else {
+ gzCaseInfoDTO.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ }
+ gzCaseDTO.setGzCaseInfoDTO(gzCaseInfoDTO);
+
+ // 封装案件扩展信息
+ GZCaseInfoUnfoldDTO gzCaseInfoUnfoldDTO = new GZCaseInfoUnfoldDTO();
+ BeanUtils.copyProperties(caseInfo, gzCaseInfoUnfoldDTO);
+ // 映射调解结果名称
+ gzCaseInfoUnfoldDTO.setMediResultName(MediResultBaseConstsEnum.getDes(caseInfo.getMediResult()));
+ // 映射达成协议类型
+ if (ByCaseConstsEnum.CASE_PROCESS_4.getIndex().equals(caseInfo.getProcess())) {
+ // 调解成功
+ if (ByCaseConstsEnum.MEDI_RESULT_1.getIndex().equals(caseInfo.getMediResult())) {
+ if (StringUtils.isNotEmpty(caseInfo.getAgreeContent())) {
+ gzCaseInfoUnfoldDTO.setAgreeType(CaseBaseConstsEnum.AGREE_TYPE_1.getIndex());
+ gzCaseInfoUnfoldDTO.setAgreeTypeName(CaseBaseConstsEnum.AGREE_TYPE_1.getDes());
+ } else {
+ gzCaseInfoUnfoldDTO.setAgreeType(CaseBaseConstsEnum.AGREE_TYPE_2.getIndex());
+ gzCaseInfoUnfoldDTO.setAgreeTypeName(CaseBaseConstsEnum.AGREE_TYPE_2.getDes());
+ }
+ }
+ }
+ // 映射结案意见
+ gzCaseInfoUnfoldDTO.setWindupContent(caseInfo.getMediContent());
+ // 映射是否转诉讼案件
+ if (ByCaseConsts.CIVIL_STATUS_2 == caseInfo.getCivilStatus()) {
+ gzCaseInfoUnfoldDTO.setCivilStatus(CaseBaseConsts.CIVIL_STATUS_1);
+ } else {
+ gzCaseInfoUnfoldDTO.setCivilStatus(CaseBaseConsts.CIVIL_STATUS_0);
+ }
+ // 映射办结时间
+ if (ObjectUtils.isNotEmpty(caseInfo.getFileTime())) {
+ gzCaseInfoUnfoldDTO.setCloseTime(caseInfo.getFileTime());
+ } else if (ObjectUtils.isNotEmpty(caseInfo.getMediEndTime())) {
+ gzCaseInfoUnfoldDTO.setCloseTime(caseInfo.getMediEndTime());
+ } else {
+ gzCaseInfoUnfoldDTO.setCloseTime(caseInfo.getUpdateTime());
+ }
+ // 映射是否申请司法确认
+ if (ByCaseConsts.JUDIC_APPLY_2 == caseInfo.getCivilStatus()) {
+ gzCaseInfoUnfoldDTO.setJudicApply(CaseBaseConsts.JUDIC_APPLY_1);
+ } else {
+ gzCaseInfoUnfoldDTO.setJudicApply(CaseBaseConsts.JUDIC_APPLY_0);
+ }
+ // 映射是否已归档
+ if (ByCaseConsts.FILE_STATUS_2 == caseInfo.getCivilStatus()) {
+ gzCaseInfoUnfoldDTO.setFileStatus(CaseBaseConsts.FILE_STATUS_1);
+ } else {
+ gzCaseInfoUnfoldDTO.setFileStatus(CaseBaseConsts.FILE_STATUS_0);
+ }
+ // 映射是否已回访
+ if (ByCaseConsts.VISIT_STATUS_2 == caseInfo.getCivilStatus()) {
+ gzCaseInfoUnfoldDTO.setVisitUpStatus(CaseBaseConsts.VISIT_UP_STATUS_1);
+ } else {
+ gzCaseInfoUnfoldDTO.setVisitUpStatus(CaseBaseConsts.VISIT_UP_STATUS_0);
+ }
+ // 映射当事人是否满意
+ if (ByCaseConsts.PARTY_JOY_2 == caseInfo.getCivilStatus()) {
+ gzCaseInfoUnfoldDTO.setPartyJoy(CaseBaseConsts.PARTY_JOY_1);
+ } else {
+ gzCaseInfoUnfoldDTO.setPartyJoy(CaseBaseConsts.PARTY_JOY_0);
+ }
+ gzCaseDTO.setGzCaseInfoUnfoldDTO(gzCaseInfoUnfoldDTO);
+
+ // 封装当事人信息
+ QueryWrapper<CasePerson> casePersonQueryWrapper = new QueryWrapper<>();
+ casePersonQueryWrapper.eq("case_id", caseInfo.getId());
+ List<CasePerson> casePersonList = casePersonService.list(casePersonQueryWrapper);
+ if (CollectionUtils.isNotEmpty(casePersonList)) {
+ List<GZCasePersonDTO> gzCasePersonDTOList = new ArrayList<>();
+ for (CasePerson casePerson : casePersonList) {
+ GZCasePersonDTO gzCasePersonDTO = new GZCasePersonDTO();
+ BeanUtils.copyProperties(casePerson, gzCasePersonDTO);
+ // 映射是否有个人极端倾向
+ gzCasePersonDTO.setExtreme(CaseBaseConsts.EXTREME_0);
+ // 映射删除状态
+ if (ByBaseConsts.DELETE_STATUS_99.equals(casePerson.getDeleteStatus())) {
+ gzCasePersonDTO.setDeleteStatus(BaseConsts.DELETE_STATUS_1);
+ } else {
+ gzCasePersonDTO.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ }
+ gzCasePersonDTOList.add(gzCasePersonDTO);
+ }
+ gzCaseDTO.setGzCasePersonDTOList(gzCasePersonDTOList);
+ }
+
+ // 封装当事人代理人信息
+ QueryWrapper<CaseAgent> caseAgentQueryWrapper = new QueryWrapper<>();
+ caseAgentQueryWrapper.eq("case_id", caseInfo.getId());
+ List<CaseAgent> caseAgentList = caseAgentService.list(caseAgentQueryWrapper);
+ if (CollectionUtils.isNotEmpty(caseAgentList)) {
+ List<GZCaseAgentDTO> gzCaseAgentDTOList = new ArrayList<>();
+ for (CaseAgent caseAgent : caseAgentList) {
+ GZCaseAgentDTO gzCaseAgentDTO = new GZCaseAgentDTO();
+ BeanUtils.copyProperties(caseAgent, gzCaseAgentDTO);
+ // 映射是否有个人极端倾向
+ gzCaseAgentDTO.setExtreme(CaseBaseConsts.EXTREME_0);
+ // 映射删除状态
+ if (ByBaseConsts.DELETE_STATUS_99.equals(caseAgent.getDeleteStatus())) {
+ gzCaseAgentDTO.setDeleteStatus(BaseConsts.DELETE_STATUS_1);
+ } else {
+ gzCaseAgentDTO.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
+ }
+ gzCaseAgentDTOList.add(gzCaseAgentDTO);
+ }
+ gzCaseDTO.setGzCaseAgentDTOList(gzCaseAgentDTOList);
+ }
+
+ // 封装案件任务信息
+ QueryWrapper<CaseTask> caseTaskQueryWrapper = new QueryWrapper<>();
+ caseTaskQueryWrapper.eq("case_id", caseInfo.getId()).orderByAsc("create_time");
+ List<CaseTask> caseTaskList = caseTaskService.list(caseTaskQueryWrapper);
+ gzCaseDTO.setByCaseTaskDTOList(caseTaskList);
+ gzCaseDTOList.add(gzCaseDTO);
+ }
+ }
+ return gzCaseDTOList;
+ }
+
}
--
Gitblit v1.8.0