WS
2023-08-15 db11361d175266a95c4cc058f1daf25c08b7dc12
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
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
package com.fzzy.push.shjdjw2023;
 
import com.alibaba.fastjson.JSON;
import com.bstek.dorado.util.DateUtils;
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.service.ApiTriggerService;
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.apache.commons.lang.time.DateFormatUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.text.DateFormat;
import java.text.DecimalFormat;
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 ApiTriggerService apiTriggerService;
    @Autowired
    private ApiLogRep apiLogRep;
    @Autowired
    private Api1101Rep api1101Rep;
    @Autowired
    private Api1102Rep api1102Rep;
    @Autowired
    private Api1103Rep api1103Rep;
    @Autowired
    private Api1105Rep api1105Rep;
    @Autowired
    private Api1202Rep api1202Rep;
    @Autowired
    private Api1104Rep api1104Rep;
    @Autowired
    private Api1208Rep api1208Rep;
    @Autowired
    private Api1404Rep api1404Rep;
 
 
    @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());
 
            if (Constant.API_CODE_1403.equals(inteId)) {
                //轮换计划完成情况数据封装
                Shjdjw1502 shjdjw1502 = copy1502((Api1403) data);
                ShjdjwReqDto<Object> dto = new ShjdjwReqDto<>();
                dto.setId(getDataId(ShjdjwApiCodeConstant.API_CODE_LS1502));
                List<Object> list = new ArrayList<>();
                list.add(shjdjw1502);
                dto.setData(list);
                String json = JSON.toJSONString(dto);
 
                //轮换计划完成情况数据上传
                apiLog.setData(json);
                apiLog.setKqdm(kqdm);
                apiLog.setUploadTime(new Date());
                ShjdjwRespDto shjdjwresponseDto = Shjdjw2023HttpClientUtil.postPushData(conf.getApiUrl(), json, conf);
                responseDto.setBizId(bizId);
                apiLog.setStatus(shjdjwresponseDto.getCode() == 1 ? 0 : shjdjwresponseDto.getCode());
                apiLog.setResult(shjdjwresponseDto.getDescription());
                apiLogRep.save(apiLog);
                ResponseDto response = new ResponseDto();
                response.setSuccess(shjdjwresponseDto.getCode() == 1 ? 0 : shjdjwresponseDto.getCode());
                response.setMsg(shjdjwresponseDto.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 = copyApi1203((Api1203) data);
 
            list.add(shjdjwApi1203);
        } else if (Constant.API_CODE_1205.equals(inteId)) {
            //粮食出库数据封装
            ShjdjwApi1205 shjdjwApi1205 = copyApi1205((Api1205) data);
 
            list.add(shjdjwApi1205);
        } else if (Constant.API_CODE_1208.equals(inteId)) {
            //粮食库存数据封装
            ShjdjwApi1208 shjdjwApi1208 = copyApi1208((Api1208) data);
 
            list.add(shjdjwApi1208);
        } else if (Constant.API_CODE_1209.equals(inteId)) {
            //损益单数据封装
            ShjdjwApi1209 shjdjwApi1209 = copyApi1209((Api1209) data);
 
            list.add(shjdjwApi1209);
        } else if (Constant.API_CODE_1310.equals(inteId)) {
            //质检数据封装
            ShjdjwApi1310 shjdjwApi1310 = copyApi1310((Api1310) data);
 
            list.add(shjdjwApi1310);
        } else if (Constant.API_CODE_1403.equals(inteId)) {
            //轮换计划数据封装
            ShjdjwApi1403 shjdjwApi1403 = copyApi1403((Api1403) data);
 
            list.add(shjdjwApi1403);
        } else {
 
            list.add(data);
        }
        dto.setData(list);
        return JSON.toJSONString(dto);
    }
 
    private ShjdjwApi1403 copyApi1403(Api1403 api1403) {
        ShjdjwApi1403 shjdjwApi1403 = new ShjdjwApi1403();
        BeanUtils.copyProperties(api1403, shjdjwApi1403);
 
        List<Double> lhsl = getLhsl(api1403);
        if (null != lhsl && lhsl.size() > 0) {
            shjdjwApi1403.setLrsl(lhsl.get(1));
            shjdjwApi1403.setLrsl(lhsl.get(0));
        }
 
        shjdjwApi1403.setJhbm(api1403.getLhjhdh());
        shjdjwApi1403.setPch("0");
        return shjdjwApi1403;
    }
 
    /**
     * 获取轮入和轮出重量
     *
     * @param api1403
     * @return
     */
    private List<Double> getLhsl(Api1403 api1403) {
        List<Api1404> api1404List = api1404Rep.getDataByLhjhdh(api1403.getLhjhdh());
        List<Double> lhsl = new ArrayList<>();
        if (null != api1404List && api1404List.size() > 0) {
//            double sum = api1404List.stream().mapToDouble(Api1404::getLhsl).summaryStatistics().getSum();
            double lcSum = api1404List.stream()
                    .filter(x -> x.getLhlx().equals("1"))
                    .mapToDouble(Api1404::getLhsl)
                    .summaryStatistics().getSum();
            double lrSum = api1404List.stream()
                    .filter(x -> x.getLhlx().equals("2"))
                    .mapToDouble(Api1404::getLhsl)
                    .summaryStatistics().getSum();
            lhsl.add(lcSum);
            lhsl.add(lrSum);
        }
        return lhsl;
    }
 
    private Shjdjw1502 copy1502(Api1403 api1403) {
        Shjdjw1502 shjdjw1502 = new Shjdjw1502();
        shjdjw1502.setDwmc(api1403.getLhjhdh());
        shjdjw1502.setJhnd(api1403.getJhnd());
 
        // 计划数量
        List<Double> lhsl = getLhsl(api1403);
        Double sum = 0.0;
        if (null != lhsl && lhsl.size() > 0) {
            sum = lhsl.stream().reduce(0d, Double::sum);
        }
        // 已执行数量
        List<Api1202> api1202List = api1202Rep.getDataByTime(api1403.getKszxrq(), api1403.getJzzxrq());
 
        Double yzxsl = api1202List.stream()
                .mapToDouble(Api1202::getJz)
                .summaryStatistics().getSum();
        shjdjw1502.setJhsl(new DecimalFormat("0.00").format(sum));
        shjdjw1502.setYzxsl(new DecimalFormat("0.00").format(yzxsl));
        //执行比例
        shjdjw1502.setZxbl(String.valueOf((yzxsl / sum * 100)));
 
        // 招标/竞价比例
        shjdjw1502.setZbjjbl("100");
        shjdjw1502.setCzbz(api1403.getCzbz());
 
        return shjdjw1502;
    }
 
    private ShjdjwApi1203 copyApi1203(Api1203 api1203) {
        ShjdjwApi1203 shjdjwApi1203 = new ShjdjwApi1203();
 
        BeanUtils.copyProperties(api1203, shjdjwApi1203);
 
        shjdjwApi1203.setQydbh(api1203.getRkjydh());
        shjdjwApi1203.setHwbm(api1203.getHwdm());
        List<Api1105> list = api1105Rep.findPushDataByHwdm(api1203.getHwdm());
        if(null != list && list.size() > 0){
            shjdjwApi1203.setHwbm(list.get(0).getHwmc());
        }
        shjdjwApi1203.setYpbm(api1203.getRkywdh());
        shjdjwApi1203.setJyjg(api1203.getJyz());
        shjdjwApi1203.setJyjl(api1203.getJyjg());
        shjdjwApi1203.setPzbm(api1203.getLspzdm());
        shjdjwApi1203.setBjw("jiading");
        shjdjwApi1203.setPch("0");
        return shjdjwApi1203;
    }
 
    private ShjdjwApi1310 copyApi1310(Api1310 api1310) {
        ShjdjwApi1310 shjdjwApi1310 = new ShjdjwApi1310();
 
        BeanUtils.copyProperties(api1310, shjdjwApi1310);
 
        shjdjwApi1310.setZjbgdbh(api1310.getZjbgdh());
        shjdjwApi1310.setPznm(api1310.getLspzdm());
        shjdjwApi1310.setSkdjbm(api1310.getLsdjdm());
        shjdjwApi1310.setJylbbm(api1310.getJylb());
//        if (StringUtils.isNotEmpty(shjdjwApi1310.getJyxm())) {
//            String[] split = shjdjwApi1310.getJyxm().split(",");
//            StringBuilder jyjl = new StringBuilder();
//            for (String s : split) {
//                jyjl.append(",合格");
//            }
//            shjdjwApi1310.setJyjl(jyjl.toString().substring(1));
//        }
        //调整为传递检验值
        shjdjwApi1310.setJyjl(api1310.getJyxmz());
        shjdjwApi1310.setZlzbjgpd(api1310.getZbjgpd());
        //查询单位信息
        List<Api1101> listApi1101 = api1101Rep.findPushData(api1310.getKqdm());
        if (null != listApi1101 && listApi1101.size() > 0) {
            shjdjwApi1310.setDwmc(listApi1101.get(0).getDwmc());
        }
 
        //查询仓房信息
        List<Api1103> listApi1103 = api1103Rep.findPushDataByCfdm(api1310.getHwdm().substring(0, 25));
        if (null != listApi1103 && listApi1103.size() > 0) {
            shjdjwApi1310.setCfmc(listApi1103.get(0).getCfmc());
        }
 
        //查询廒间信息
        List<Api1104> listApi1104 = api1104Rep.findDataByAjdh(api1310.getHwdm().substring(0, 28));
        if (null != listApi1104 && listApi1104.size() > 0) {
            shjdjwApi1310.setAjmc(listApi1104.get(0).getAjmc());
        }
 
        //查询库区信息
        List<Api1102> listApi1102 = api1102Rep.findPushData(api1310.getKqdm());
        if (null != listApi1102 && listApi1102.size() > 0) {
            shjdjwApi1310.setKdmc(listApi1102.get(0).getKqmc());
        }
        //查询粮食库存
        List<Api1208> listApi1208 = api1208Rep.getDataByHwdm(api1310.getHwdm());
        if (null != listApi1208 && listApi1208.size() > 0) {
            shjdjwApi1310.setKdmc(listApi1208.get(0).getLsxzdm());
        }
        shjdjwApi1310.setPch("0");
        return shjdjwApi1310;
    }
 
    private ShjdjwApi1209 copyApi1209(Api1209 api1209) {
        ShjdjwApi1209 shjdjwApi1209 = new ShjdjwApi1209();
 
        BeanUtils.copyProperties(api1209, shjdjwApi1209);
 
        shjdjwApi1209.setSydbh(api1209.getSydh());
 
        shjdjwApi1209.setRksl(api1209.getRkjz());
        shjdjwApi1209.setCksl(api1209.getCkjz());
        shjdjwApi1209.setSysl(api1209.getJzsysl());
        //查询单位信息
        List<Api1101> listApi1101 = api1101Rep.findPushData(api1209.getKqdm());
        if (null != listApi1101 && listApi1101.size() > 0) {
            shjdjwApi1209.setDwmc(listApi1101.get(0).getDwmc());
        }
        //查询库区信息
        List<Api1102> listApi1102 = api1102Rep.findPushData(api1209.getKqdm());
        if (null != listApi1102 && listApi1102.size() > 0) {
            shjdjwApi1209.setKdmc(listApi1102.get(0).getKqmc());
        }
        //货位信息
        shjdjwApi1209.setHwbm(api1209.getHwdm());
        List<Api1105> list = api1105Rep.findPushDataByHwdm(api1209.getHwdm());
        if(null != list && list.size() > 0){
            shjdjwApi1209.setHwbm(list.get(0).getHwmc());
        }
 
        shjdjwApi1209.setNx(api1209.getYwrq());
        //辅损益数量
        shjdjwApi1209.setFsysl(0.0);
        //损益类型
        shjdjwApi1209.setSylx(api1209.getJzsysl() > 0 ? "0" : "1");
        return shjdjwApi1209;
    }
 
    private ShjdjwApi1208 copyApi1208(Api1208 api1208) {
        ShjdjwApi1208 shjdjwApi1208 = new ShjdjwApi1208();
 
        BeanUtils.copyProperties(api1208, shjdjwApi1208);
 
        shjdjwApi1208.setLspzbm(api1208.getLspzdm());
        shjdjwApi1208.setLsxzbm(api1208.getLsxzdm());
        shjdjwApi1208.setDjbm(api1208.getLsdjdm());
        shjdjwApi1208.setLqgsdwbm(api1208.getLqgsdwdm());
 
        //查询单位信息
        List<Api1101> listApi1101 = api1101Rep.findPushData(api1208.getKqdm());
        if (null != listApi1101 && listApi1101.size() > 0) {
            shjdjwApi1208.setDwmc(listApi1101.get(0).getDwmc());
        }
 
        //查询仓房信息
        List<Api1103> listApi1103 = api1103Rep.findPushDataByCfdm(api1208.getHwdm().substring(0, 25));
        if (null != listApi1103 && listApi1103.size() > 0) {
            shjdjwApi1208.setCfmc(listApi1103.get(0).getCfmc());
        }
 
        //查询廒间信息
        List<Api1104> listApi1104 = api1104Rep.findDataByAjdh(api1208.getHwdm().substring(0, 28));
        if (null != listApi1104 && listApi1104.size() > 0) {
            shjdjwApi1208.setAjmc(listApi1104.get(0).getAjmc());
        }
 
        shjdjwApi1208.setKcjcsj(api1208.getZhgxsj());
 
        shjdjwApi1208.setPch("0");
        return shjdjwApi1208;
    }
 
    private ShjdjwApi1205 copyApi1205(Api1205 api1205) {
        ShjdjwApi1205 shjdjwApi1205 = new ShjdjwApi1205();
 
        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(api1205.getLspzdm());
 
        //查询单位信息
        List<Api1101> listApi1101 = api1101Rep.findPushData(api1205.getKqdm());
        if (null != listApi1101 && listApi1101.size() > 0) {
            shjdjwApi1205.setDwmc(listApi1101.get(0).getDwmc());
        }
 
        //查询货位信息
        List<Api1105> listApi1105 = api1105Rep.findPushDataByHwdm(api1205.getHwdm());
        if (null != listApi1105 && listApi1105.size() > 0) {
            shjdjwApi1205.setCfmc(listApi1105.get(0).getHwmc());
        }
 
        shjdjwApi1205.setDjlx("0");
 
        //查询字典数据
        ApiTrigger apiTrigger = apiTriggerService.findNameByCode(api1205.getLspzdm(), Constant.TRIGGER_P_LSPZ);
        shjdjwApi1205.setWlmc(null == apiTrigger ? api1205.getLspzdm() : apiTrigger.getName());
        shjdjwApi1205.setDz(StringUtils.isNotEmpty(api1205.getXldd()) ? api1205.getXldd() : "库内");
 
        shjdjwApi1205.setDksj(api1205.getDjsj());
        shjdjwApi1205.setLksj(api1205.getCmsj());
        shjdjwApi1205.setLhnd(DateFormatUtils.format(api1205.getCmsj(), "yyyy"));
        shjdjwApi1205.setPch("0");
        return shjdjwApi1205;
    }
 
 
    /**
     * 获取接口编码
     *
     * @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;
            case "1310":
                //质检接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1201;
            case "1403":
                //轮换计划接口编码
                return ShjdjwApiCodeConstant.API_CODE_LS1501;
            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());
        List<Api1105> list = api1105Rep.findPushDataByHwdm(api1202.getHwdm());
        if(null != list && list.size() > 0){
            shjdjwApi1202.setHwbm(list.get(0).getHwmc());
        }
        shjdjwApi1202.setPzbm(api1202.getLspzdm());
        shjdjwApi1202.setLqxzbm(api1202.getLsxzdm());
        shjdjwApi1202.setZjkl(api1202.getZjklxj());
        //轮换计划单号
        shjdjwApi1202.setJhbh(api1202.getJhmxh());
        //顺序号
        shjdjwApi1202.setSxh(ywdh.substring(ywdh.length() - 4));
        shjdjwApi1202.setDjzt("2");
        //业务单号
        shjdjwApi1202.setJydbh(api1202.getRkywdh());
        //轮换年度
        shjdjwApi1202.setLhnd(api1202.getShnd());
        //到库时间、离库时间
        shjdjwApi1202.setDksj(api1202.getDjsj());
        shjdjwApi1202.setLksj(api1202.getCmsj());
        //批次号
        shjdjwApi1202.setPch("0");
    }
}