feature：市平台项目

xusd

2025-06-07 36306491396230522fa20585c2621a7fc899849a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package cn.huge.module.client.api.impl;
 
import cn.huge.base.common.bo.ReturnBO;
import cn.huge.base.common.constant.ReturnConsts;
import cn.huge.base.common.exception.ClientException;
import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.module.client.api.CaseClient;
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.griddata.domain.CaseAgent;
import cn.huge.module.griddata.domain.CaseInfo;
import cn.huge.module.griddata.domain.CaseInfoUnfold;
import cn.huge.module.griddata.domain.CasePerson;
import cn.huge.module.griddata.domain.vo.CaseVo;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
 
/**
 * 获取案件数据同步给亿迅
 */
@Slf4j
@Component
public class CaseClientImpl {
    @Autowired
    private CaseClient caseClient;
 
    @Autowired
    public CaseClientImpl(CaseClient caseClient) {
        this.caseClient = caseClient;
    }
 
    /**
     * ObjectMapper工具类
     */
    private ObjectMapper objectMapper = new ObjectMapper();
 
    public List<CaseInfo> getCaseInfo(CaseVo caseVo) {
        try {
            List<CaseInfo> caseInfoList = new ArrayList<>();
            ReturnBO returnBo = caseClient.getCaseList(caseVo);
            if (ReturnConsts.OK == returnBo.getCode()) {
                if (ObjectUtils.isNotEmpty(returnBo.getData())){
                    List<LinkedHashMap> list = (List<LinkedHashMap>) returnBo.getData();
                    for (LinkedHashMap map : list) {
                        CaseInfo ctUnitDTO = JSON.parseObject(JSON.toJSONString(map), CaseInfo.class);
                        caseInfoList.add(ctUnitDTO);
                    }
                }
 
                return caseInfoList;
            } else {
                log.error("Client外服务接口[CaseClientImpl.getCaseInfo]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
                throw new ClientException("CaseClientImpl.getCaseInfo", returnBo.getMsg());
            }
        } catch (Exception e) {
            log.error("service方法[CaseClientImpl.getCaseInfo]调用异常：" + e, e);
            throw new ServiceException("CaseClientImpl.getCaseInfo", e);
        }
    }
 
    public List<CaseInfoUnfold> getCaseInfoUnfold(String caseId) {
        try {
            ReturnBO returnBo = caseClient.getCaseUnfoldList(caseId);
            List<CaseInfoUnfold> caseInfoList = new ArrayList<>();
            if (ReturnConsts.OK == returnBo.getCode()) {
                if (ObjectUtils.isNotEmpty(returnBo.getData())){
                    List<LinkedHashMap> list = (List<LinkedHashMap>) returnBo.getData();
                    for (LinkedHashMap map : list) {
                        CaseInfoUnfold ctUnitDTO = JSON.parseObject(JSON.toJSONString(map), CaseInfoUnfold.class);
                        caseInfoList.add(ctUnitDTO);
                    }
                }
                return caseInfoList;
            } else {
                log.error("Client外服务接口[CaseClientImpl.getCaseInfoUnfold]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
                throw new ClientException("CaseClientImpl.getCaseInfoUnfold", returnBo.getMsg());
            }
        } catch (Exception e) {
            log.error("service方法[CaseClientImpl.getCaseInfoUnfold]调用异常：" + e, e);
            throw new ServiceException("CaseClientImpl.getCaseInfoUnfold", e);
        }
    }
 
    public List<CasePerson> getCasePerson(String caseId) {
        try {
            List<CasePerson> caseInfoList = new ArrayList<>();
            ReturnBO returnBo = caseClient.getCasePersonList(caseId);
            if (ReturnConsts.OK == returnBo.getCode()) {
                if (ObjectUtils.isNotEmpty(returnBo.getData())){
                    List<LinkedHashMap> list = (List<LinkedHashMap>) returnBo.getData();
                    for (LinkedHashMap map : list) {
                        CasePerson ctUnitDTO = JSON.parseObject(JSON.toJSONString(map), CasePerson.class);
                        caseInfoList.add(ctUnitDTO);
                    }
                }
                return caseInfoList;
            } else {
                log.error("Client外服务接口[CaseClientImpl.getCasePerson]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
                throw new ClientException("CaseClientImpl.getCasePerson", returnBo.getMsg());
            }
        } catch (Exception e) {
            log.error("service方法[CaseClientImpl.getCasePerson]调用异常：" + e, e);
            throw new ServiceException("CaseClientImpl.getCasePerson", e);
        }
    }
 
    public List<CaseAgent> getCaseAgent(String caseId) {
        try {
            List<CaseAgent> caseInfoList = new ArrayList<>();
            ReturnBO returnBo = caseClient.getCaseAgentList(caseId);
            if (ReturnConsts.OK == returnBo.getCode()) {
                if (ObjectUtils.isNotEmpty(returnBo.getData())){
                    List<LinkedHashMap> list = (List<LinkedHashMap>) returnBo.getData();
                    for (LinkedHashMap map : list) {
                        CaseAgent ctUnitDTO = JSON.parseObject(JSON.toJSONString(map), CaseAgent.class);
                        caseInfoList.add(ctUnitDTO);
                    }
                }
                return caseInfoList;
            } else {
                log.error("Client外服务接口[CaseClientImpl.getCaseAgent]请求异常：" + returnBo.getMsg(), returnBo.getMsg());
                throw new ClientException("CaseClientImpl.getCaseAgent", returnBo.getMsg());
            }
        } catch (Exception e) {
            log.error("service方法[CaseClientImpl.getCaseAgent]调用异常：" + e, e);
            throw new ServiceException("CaseClientImpl.getCaseAgent", e);
        }
    }
}