WS
2023-05-10 561bbb85896810c8a2595d3d58fa32325dcdfdf9
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
package com.fzzy.push.shjdjw2023;
 
import com.alibaba.fastjson.JSON;
import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiCommonService;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.utils.ContextUtil;
import com.fzzy.api.utils.RedisUtil;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.shjdjw2023.dto.*;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.*;
 
/**
 * 上海嘉定纪委监管平台-上传数据服务类
 *
 * @author czt
 * @date 2023/5/9  14:09
 */
@Slf4j
@Data
@Service
public class ShjdjwApiRemoteService2023 implements ApiRemoteService {
 
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private ApiCommonService apiCommonService;
    @Autowired
    private ApiLogRep apiLogRep;
    @Autowired
    private Api1101Rep api1101Rep;
    @Autowired
    private Api1102Rep api1102Rep;
    @Autowired
    private Api1103Rep api1103Rep;
    @Autowired
    private Api1202Rep api1202Rep;
 
    @Override
    public String getProtocol() {
        return PushProtocol.SB_SHJdJW_2023.getCode();
    }
 
    @Override
    public ResponseDto pushData(ApiParam param, Object data) {
        return pushData(param, null, data);
    }
 
    @Override
    public ResponseDto pushData(ApiParam param, ApiConfs conf, Object data) {
        String inteId = param.getInteId();
        String kqdm = param.getKqdm();
        String bizId = param.getBizId();
 
        try {
            if (null == conf) {
                conf = apiCommonService.getConf(kqdm);
            }
            //添加日志
            ApiLog apiLog = new ApiLog();
            apiLog.setId(ContextUtil.getUUID());
            apiLog.setInteId(param.getInteId());
 
            //获取接口编码
            String interfaceId = getDataId(inteId);
 
            //获取json数据
            String jsonData = getJsonData(inteId, data, interfaceId);
 
            if (StringUtils.isEmpty(interfaceId)) {
                ResponseDto responseDto = new ResponseDto(99, "没有获取到接口", bizId);
                apiLog.setStatus(99);
                apiLog.setResult("没有获取到接口");
                apiLogRep.save(apiLog);
                return responseDto;
            }
            apiLog.setData(jsonData);
            apiLog.setKqdm(kqdm);
            apiLog.setUploadTime(new Date());
 
            if (conf == null) {
                ResponseDto responseDto = new ResponseDto(99, "没有获取到上传配置", bizId);
                apiLog.setStatus(99);
                apiLog.setResult("没有获取到上传配置");
                apiLogRep.save(apiLog);
                return responseDto;
            }
 
            ShjdjwRespDto responseDto = Shjdjw2023HttpClientUtil.postPushData(conf.getApiUrl(), jsonData, conf);
            responseDto.setBizId(bizId);
            apiLog.setStatus(responseDto.getCode() == 1 ? 0 : responseDto.getCode());
            apiLog.setResult(responseDto.getDescription());
            apiLogRep.save(apiLog);
            ResponseDto resd = new ResponseDto();
            resd.setSuccess(responseDto.getCode() == 1 ? 0 : responseDto.getCode());
            resd.setMsg(responseDto.getDescription());
 
            return resd;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return new ResponseDto(99, e.getMessage());
        }
    }
 
    /**
     * 调整数据封装,获取json数据
     *
     * @param inteId
     * @param data
     * @return
     * @throws Exception
     */
    private String getJsonData(String inteId, Object data, String interfaceId) {
        ShjdjwReqDto<Object> dto = new ShjdjwReqDto<>();
        dto.setId(getDataId(interfaceId));
        List<Object> list = new ArrayList<>();
        //转换封装
        if (Constant.API_CODE_1102.equals(inteId)) {
            //单位接口数据封装
            ShjdjwApi1101 shjdjwApi1101 = new ShjdjwApi1101();
            BeanUtils.copyProperties(data, shjdjwApi1101);
            //查询单位信息
            List<Api1101> listApi1101 = api1101Rep.findPushData(shjdjwApi1101.getKqdm());
            Api1101 api1101 = null;
            if(null != listApi1101 && listApi1101.size() > 0){
                api1101 = listApi1101.get(0);
            }
            if(null != api1101){
                shjdjwApi1101.setDwmc(api1101.getDwmc());
                shjdjwApi1101.setKqs(api1101.getKqs());
            }
            //查询仓房信息
            List<Api1103> listApi1103 = api1103Rep.findPushData(shjdjwApi1101.getKqdm());
            if(null != listApi1103 && listApi1103.size() > 0){
                for(int i = 0; i < listApi1103.size(); i++){
                    if(i == 0){
                        shjdjwApi1101.setCfmc(listApi1103.get(i).getCfmc());
                    }else {
                        shjdjwApi1101.setCfmc(shjdjwApi1101.getCfmc() + "#" + listApi1103.get(i).getCfmc());
                    }
                }
            }
            //单位信息封装
            list.add(shjdjwApi1101);
        } else if (Constant.API_CODE_1202.equals(inteId)) {
            //粮食入库数据封装
            ShjdjwApi1202 shjdjwApi1202 = new ShjdjwApi1202();
            Api1202 api1202 = (Api1202) data;
            copyApi1202(api1202, shjdjwApi1202);
            list.add(shjdjwApi1202);
        } else if (Constant.API_CODE_1203.equals(inteId)) {
            //粮食入库检验数据封装
            ShjdjwApi1203 shjdjwApi1203 = new ShjdjwApi1203();
            Api1203 api1203 = (Api1203) data;
            BeanUtils.copyProperties(api1203, shjdjwApi1203);
 
            shjdjwApi1203.setQydbh(api1203.getRkjydh());
            shjdjwApi1203.setHwbm(api1203.getHwdm());
            shjdjwApi1203.setYpbm(api1203.getRkywdh());
            shjdjwApi1203.setJyjg(api1203.getJyz());
            shjdjwApi1203.setJyjl(api1203.getJyjg());
            shjdjwApi1203.setPzbm(api1203.getLspzdm());
            //TODO 标记位
            shjdjwApi1203.setPch("0");
 
            list.add(shjdjwApi1203);
        } else if (Constant.API_CODE_1205.equals(inteId)) {
            //粮食出库数据封装
            ShjdjwApi1205 shjdjwApi1205 = new ShjdjwApi1205();
            Api1205 api1205 = (Api1205) data;
 
            BeanUtils.copyProperties(api1205, shjdjwApi1205);
 
            shjdjwApi1205.setYwdh(api1205.getCkywdh());
            shjdjwApi1205.setHtbm(api1205.getHth());
            shjdjwApi1205.setPzbm(api1205.getLspzdm());
            shjdjwApi1205.setDjbm(api1205.getLsdjdm());
            shjdjwApi1205.setLqxzbm(api1205.getLsxzdm());
            shjdjwApi1205.setCzbz(api1205.getCzbz());
            shjdjwApi1205.setLrfs("0");
            shjdjwApi1205.setPzbm("0");
            //TODO 单位名称 仓房名称 单据类型 品种名称 地址 到库时间 离库时间 轮换年度
            shjdjwApi1205.setPch("0");
 
            list.add(shjdjwApi1205);
        } else if (Constant.API_CODE_1208.equals(inteId)) {
            //粮食库存数据封装
            ShjdjwApi1208 shjdjwApi1208 = new ShjdjwApi1208();
            Api1208 api1208 = (Api1208) data;
 
            BeanUtils.copyProperties(api1208, shjdjwApi1208);
 
            shjdjwApi1208.setLspzbm(api1208.getLspzdm());
            shjdjwApi1208.setLsxzbm(api1208.getLsxzdm());
            shjdjwApi1208.setDjbm(api1208.getLsdjdm());
            shjdjwApi1208.setLqgsdwbm(api1208.getLqgsdwdm());
            shjdjwApi1208.setPch("0");
            //TODO 单位名称 仓房名称 廒间名称 库存监测时间
 
            list.add(shjdjwApi1208);
        } else if (Constant.API_CODE_1209.equals(inteId)) {
            //损益单数据封装
            ShjdjwApi1209 shjdjwApi1209 = new ShjdjwApi1209();
            Api1209 api1209 = (Api1209) data;
 
            BeanUtils.copyProperties(api1209, shjdjwApi1209);
 
            shjdjwApi1209.setSydbh(api1209.getSydh());
            shjdjwApi1209.setHwbm(api1209.getHwdm());
            shjdjwApi1209.setRksl(api1209.getRkjz());
            shjdjwApi1209.setCksl(api1209.getCkjz());
            shjdjwApi1209.setSysl(api1209.getJzsysl());
            //TODO 单位名称 库点名称 年限 辅损溢数量 损益类型
 
            list.add(shjdjwApi1209);
        } else {
 
            list.add(data);
        }
        dto.setData(list);
        return JSON.toJSONString(dto);
    }
 
 
 
    /**
     * 获取接口编码
     *
     * @param inteId
     * @return
     */
    private String getDataId(String inteId) {
        switch (inteId) {
            case "1102":
                //单位接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1101;
            case "1202":
                //粮食入库接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1302;
            case "1203":
                //粮食入库检验接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1303;
            case "1205":
                //粮食出库接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1306;
            case "1208":
                //粮食库存接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1310;
            case "1209":
                //损益单接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1311;
            default:
                return inteId;
        }
 
    }
 
    //装换封装
    private void copyApi1202(Api1202 api1202, ShjdjwApi1202 shjdjwApi1202) {
        BeanUtils.copyProperties(api1202,shjdjwApi1202);
        String ywdh = api1202.getRkywdh();
        shjdjwApi1202.setYwdh(ywdh);
        shjdjwApi1202.setHwbm(api1202.getHwdm());
        shjdjwApi1202.setPzbm(api1202.getLspzdm());
        shjdjwApi1202.setLqxzbm(api1202.getLsxzdm());
        shjdjwApi1202.setZjkl(api1202.getZjklxj());
        //轮换计划单号
        shjdjwApi1202.setJhbh(null);
        //顺序号
        shjdjwApi1202.setSxh(ywdh.substring(ywdh.length() - 4));
        shjdjwApi1202.setDjzt("2");
        //业务单号
        shjdjwApi1202.setJydbh(null);
        //轮换年度
        shjdjwApi1202.setLhnd(null);
        //批次号
        shjdjwApi1202.setPch("0");
    }
}