调整上海性质转变单接口

CZT

2024-01-09 6f06c861bffe6fcf5fb7cf9e2a7003fca856bac0

 src/main/java/com/fzzy/push/sh2023/SH2023ApiRemoteService.java

@@ -16,9 +16,12 @@
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateFormatUtils;
import com.fzzy.api.utils.NumberUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.lang.reflect.Field;
import java.util.*;

/**
@@ -41,15 +44,27 @@
    @Autowired
    private ApiLogRep apiLogRep;
    @Autowired
    private Api1101Rep api1101Rep;
    @Autowired
    private Api1102Rep api1102Rep;
    @Autowired
    private Api1103Rep api1103Rep;
    @Autowired
    private Api1104Rep api1104Rep;
    @Autowired
    private Api1208Rep api1208Rep;
    @Autowired
    private Api1210Rep api1210Rep;
    @Autowired
    private Api1109Rep api1109Rep;
    @Autowired
    private Api1202Rep api1202Rep;
    @Autowired
    private Api1205Rep api1205Rep;
    @Autowired
    private Api1403Rep api1403Rep;
    @Autowired
    private Api1404Rep api1404Rep;

    @Override
    public String getProtocol() {
@@ -75,7 +90,6 @@
            //添加日志
            ApiLog apiLog = new ApiLog();
            apiLog.setId(ContextUtil.getUUID());


            //若为财务1501、1502、1503接口，则接口编码填写1114
            if (SH2023Constant.SH_2023_API_CODE_1114_1501.equals(param.getInteId())
@@ -110,7 +124,7 @@
            //获取指令id
            String key = RedisConst.buildKey(RedisConst.KYE_ORDER, conf.getKqdm());
            OrderData orderData = (OrderData) redisUtil.get(key);
            if (StringUtils.isEmpty(orderData.getOrderid())) {
            if (null == orderData || StringUtils.isEmpty(orderData.getOrderid())) {
                log.error("指令id失效=" + jsonData);
                ResponseDto responseDto = new ResponseDto(99, "指令id失效");
                apiLog.setStatus(99);
@@ -129,21 +143,13 @@

            //身份签名，使用自有RSA私钥进行加密(地区行政区划代码_当天日期)
            reqData.setAccess_token(ShRSAUtils.sign(reqData.getUid() + "_" + DateFormatUtils.format(new Date(), "yyyy-MM-dd"), conf.getPassword()));
            //数据总条数
            if (SH2023Constant.SH_2023_API_CODE_1114_1501.equals(param.getInteId())
                    || SH2023Constant.SH_2023_API_CODE_1114_1502.equals(param.getInteId())
                    || SH2023Constant.SH_2023_API_CODE_1114_1503.equals(param.getInteId())) {
                reqData.setDatalength(1);
            }else {
                List<Object> list = (List<Object>) data;
                reqData.setDatalength(list.size());
            }
            reqData.setDatalength(1);

            //使用区级平台公钥对数据进行RSA加密
            reqData.setData(ShRSAUtils.encryptByPubKey(jsonData, conf.getPublicKey()));
            //摘要，数据主体的MD5值
            reqData.setDigst(MyMD5Util.encrypt(jsonData));

            log.info("上报数据信息=" + JSON.toJSONString(reqData));
            SH2023RespDto responseDto = SH2023HttpClientUtil.postPushData(conf.getApiUrl() + inteId, JSON.toJSONString(reqData), conf);

            apiLog.setStatus(responseDto.getCode() == 200 ? 0 : responseDto.getCode());
@@ -160,20 +166,11 @@
        }
    }

    /**
     * 推送财务数据接口
     *
     * @param param
     * @param conf
     * @param data
     * @return
     */
    private ResponseDto pushFinanceData(ApiParam param, ApiConfs conf, Object data) {

    @Override
    public ResponseDto pullData(ApiParam param, ApiConfs conf) {
        String inteId = param.getInteId();
        String kqdm = param.getKqdm();
        //查询库区信息行政区划码
        List<Api1102> api1102List = api1102Rep.findPushData(conf.getKqdm());

        try {
            if (null == conf) {
                conf = apiCommonService.getConf(kqdm);
@@ -182,9 +179,7 @@
            //添加日志
            ApiLog apiLog = new ApiLog();
            apiLog.setId(ContextUtil.getUUID());
            apiLog.setInteId("1114");
            String jsonData = getJsonData(inteId, data, api1102List.get(0).getXzqhdm());
            log.info("接口数据信息=" + jsonData);
            apiLog.setInteId(inteId);

            if (StringUtils.isEmpty(inteId)) {
                ResponseDto responseDto = new ResponseDto(99, "没有获取到接口");
@@ -193,9 +188,6 @@
                apiLogRep.save(apiLog);
                return responseDto;
            }
            apiLog.setData(jsonData);
            apiLog.setKqdm(kqdm);
            apiLog.setUploadTime(new Date());

            if (conf == null) {
                ResponseDto responseDto = new ResponseDto(99, "没有获取到上传配置");
@@ -205,44 +197,23 @@
                return responseDto;
            }

            //获取指令id
            String key = RedisConst.buildKey(RedisConst.KYE_ORDER, conf.getKqdm());
            OrderData orderData = (OrderData) redisUtil.get(key);
            if (StringUtils.isEmpty(orderData.getOrderid())) {
                ResponseDto responseDto = new ResponseDto(99, "指令id失效");
                apiLog.setStatus(99);
                apiLog.setResult("指令id失效");
                apiLogRep.save(apiLog);
                return responseDto;
            }
            //封装数据
            SH2023PullReqDto reqData = new SH2023PullReqDto();;

            //封装推送数据
            SH2023ReqDto reqData = new SH2023ReqDto();
            reqData.setId(ContextUtil.getUUID());
            //获取身份ID，即行政区划码
            reqData.setUid(conf.getUserName());
            //指令id
            reqData.setOrderid(orderData.getOrderid());
            //身份签名，使用自有RSA私钥进行加密(地区行政区划代码_当天日期)
            reqData.setAccess_token(ShRSAUtils.sign(reqData.getUid() + "_" + DateFormatUtils.format(new Date(), "yyyy-MM-dd"), conf.getPassword()));
            //数据总条数
            List<Object> list = (List<Object>) data;
            reqData.setDatalength(list.size());
            reqData.setName(conf.getUserName());
            reqData.setPwd(conf.getAppCode());
            log.info("拉取共享数据请求信息=" + JSON.toJSONString(reqData));

            //使用区级平台公钥对数据进行RSA加密
            reqData.setData(ShRSAUtils.encryptByPubKey(jsonData, conf.getPublicKey()));
            String url = conf.getApiUrl().replace("UPLOAD", "Shared");
            SH2023PullRespDto responseDto = SH2023HttpClientUtil.postPullData(url + inteId, JSON.toJSONString(reqData));

            //摘要，数据主体的MD5值
            reqData.setDigst(MyMD5Util.encrypt(jsonData));

            SH2023RespDto responseDto = SH2023HttpClientUtil.postPushData(conf.getApiUrl() + inteId, JSON.toJSONString(reqData), conf);
            apiLog.setStatus(responseDto.getCode() == 200 ? 0 : responseDto.getCode());
            apiLog.setResult(responseDto.getResult());
            apiLog.setStatus(responseDto.getRetcode() == 200 ? 0 : responseDto.getRetcode());
            apiLog.setResult(responseDto.getRetMsg());
            apiLogRep.save(apiLog);
            ResponseDto resd = new ResponseDto();
            resd.setSuccess(responseDto.getCode() == 200 ? 0 : responseDto.getCode());
            resd.setMsg(responseDto.getResult());

            resd.setSuccess(responseDto.getRetcode() == 200 ? 0 : responseDto.getRetcode());
            resd.setMsg(responseDto.getRetMsg());
            resd.setData(responseDto.getData());
            return resd;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
@@ -251,726 +222,903 @@
    }

    /**
     * 调整数据封装，获取json数据
     * 转为JSON
     *
     * @param inteId
     * @param data
     * @param code
     * @return
     */
    private String getJsonData(String inteId, Object data, String code) {
        //若为财务1501、1502、1503接口，则接口编码填写1114
        if (SH2023Constant.SH_2023_API_CODE_1114_1501.equals(inteId)
                || SH2023Constant.SH_2023_API_CODE_1114_1502.equals(inteId)
                || SH2023Constant.SH_2023_API_CODE_1114_1503.equals(inteId)) {
            Object object = getJsonFinanceData(inteId, data);
            return JSON.toJSONString(object);
        } else {
            List<Object> list = new ArrayList<>();
            Object object = getJsonApiData(inteId, data, code);
            list.add(object);
            return JSON.toJSONString(list);
        }
    }

    /**
     * 常规接口封装
     *
     * @param inteId
     * @param data
     * @param code
     * @return
     */
    private Object getJsonApiData(String inteId, Object data, String code) {
        //具体根据接口进行封装
        if (SH2023Constant.SH_2023_API_CODE_1101.equals(inteId)) {
            SH2023Api1101 api1101 = new SH2023Api1101();
            BeanUtils.copyProperties(data, api1101);

            //设置空属性为默认值
            changeObject(api1101);
            return api1101;
        }
        if (SH2023Constant.SH_2023_API_CODE_1102.equals(inteId)) {
            SH2023Api1102 api1102 = new SH2023Api1102();
            BeanUtils.copyProperties(data, api1102);

            //设置空属性为默认值
            changeObject(api1102);
            return api1102;
        }
        if (SH2023Constant.SH_2023_API_CODE_1103.equals(inteId)) {
            SH2023Api1103 api1103 = new SH2023Api1103();
            BeanUtils.copyProperties(data, api1103);

            //设置空属性为默认值
            changeObject(api1103);
            return api1103;
        }
        if (SH2023Constant.SH_2023_API_CODE_1104.equals(inteId)) {
            SH2023Api1104 api1104 = new SH2023Api1104();
            Api1104 apiData = (Api1104) data;

            //查询仓房信息
            List<Api1103> api1103List = api1103Rep.findPushDataByCfdm(apiData.getCfbh());
            List<Api1104> api1104List = api1104Rep.findDataByCfbh(apiData.getCfbh());
            int num = 2;
            if (null != api1104List && api1104List.size() > 0) {
                num = api1104List.size();
            }
            if (null != api1103List && api1103List.size() > 0) {
                Api1103 api1103 = api1103List.get(0);
                BeanUtils.copyProperties(api1103, api1104);
                api1104.setCwc(api1103.getCwc() / num);
                api1104.setCnc(api1103.getCnc() / num);
                api1104.setSjcr(api1103.getSjcr() / num);
            }
            BeanUtils.copyProperties(apiData, api1104);
            api1104.setAjdm(apiData.getAjdh());
            api1104.setCfdm(apiData.getCfbh());

            //设置粮食性质代码(查看廒间对应的最新库存进行赋值)
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1104.getAjdm() + "01");
            if (null != api1208List && api1208List.size() > 0) {
                api1104.setLsxzdm(api1208List.get(0).getLsxzdm());
            }

            //设置空属性为默认值
            changeObject(api1104);
            return api1104;
        }
        if (SH2023Constant.SH_2023_API_CODE_1105.equals(inteId)) {
            SH2023Api1105 api1105 = new SH2023Api1105();
            BeanUtils.copyProperties(data, api1105);

            //设置空属性为默认值
            changeObject(api1105);
            return api1105;
        }
        if (SH2023Constant.SH_2023_API_CODE_1106.equals(inteId)) {
            SH2023Api1106 api1106 = new SH2023Api1106();
            BeanUtils.copyProperties(data, api1106);
            api1106.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1106);
            return api1106;
        }
        if (SH2023Constant.SH_2023_API_CODE_1107.equals(inteId)) {
            SH2023Api1107 api1107 = new SH2023Api1107();
            BeanUtils.copyProperties(data, api1107);
            api1107.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1107);
            return api1107;
        }
        if (SH2023Constant.SH_2023_API_CODE_1108.equals(inteId)) {
            SH2023Api1108 api1108 = new SH2023Api1108();
            BeanUtils.copyProperties(data, api1108);
            api1108.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1108);
            return api1108;
        }
        if (SH2023Constant.SH_2023_API_CODE_1109.equals(inteId)) {
            SH2023Api1109 api1109 = new SH2023Api1109();
            Api1109 apiData = (Api1109) data;
            BeanUtils.copyProperties(apiData, api1109);
            api1109.setBjw(ShAreaBjw.getBjw(code));

            Map<String, String> map = new HashMap<>();
            map.put(apiData.getWjmc(), FileUtils.fileToByteString(apiData.getWjdz()));
            api1109.setWjl(JSON.toJSONString(map));
            //上海市平台文件名称规则：库区编码_业务流水号_分类码_顺序码.jpg，例如：91310114703439394M001_142211080101_GL_00.jpg
            api1109.setWjmc(getWjmc(api1109.getWjlx(), api1109.getWjmc()));
            //业务类型
            api1109.setYwdh(getYwdh(api1109.getWjlx(), api1109.getWjmc(), api1109.getYwdh()));
            //设置空属性为默认值
            changeObject(api1109);
            return api1109;
        }
        if (SH2023Constant.SH_2023_API_CODE_1110.equals(inteId)) {
            SH2023Api1110 api1110 = new SH2023Api1110();
            Api1110 apiData = (Api1110) data;
            BeanUtils.copyProperties(apiData, api1110);
            api1110.setBjw(ShAreaBjw.getBjw(code));
            api1110.setAjdm(apiData.getHwdm().substring(0, 28));
            api1110.setAjxdwz(apiData.getHwxdwz());
            api1110.setAjwzys(apiData.getHwwzys());

            //设置空属性为默认值
            changeObject(api1110);
            return api1110;
        }
        if (SH2023Constant.SH_2023_API_CODE_1111.equals(inteId)) {
            SH2023Api1111 api1111 = new SH2023Api1111();
            BeanUtils.copyProperties(data, api1111);
            api1111.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1111);
            return api1111;
        }
        if (SH2023Constant.SH_2023_API_CODE_1112.equals(inteId)) {
            SH2023Api1112 api1112 = new SH2023Api1112();
            BeanUtils.copyProperties(data, api1112);
            api1112.setHdrychsj(api1112.getQdzgzchzyzgsj());
            api1112.setBjw(ShAreaBjw.getBjw(code));
            api1112.setZy("01");

            //设置空属性为默认值
            changeObject(api1112);
            return api1112;
        }
        if (SH2023Constant.SH_2023_API_CODE_1113.equals(inteId)) {
            SH2023Api1113 api1113 = new SH2023Api1113();
            BeanUtils.copyProperties(data, api1113);
            api1113.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1113);
            return api1113;
        }
        if (SH2023Constant.SH_2023_API_CODE_1201.equals(inteId)) {
            SH2023Api1201 api1201 = new SH2023Api1201();
            BeanUtils.copyProperties(data, api1201);
            api1201.setBjw(ShAreaBjw.getBjw(code));
            api1201.setHtsfzz("0");
            //合同签订地点不能为空或填无
            if (StringUtils.isEmpty(api1201.getQddd())) {
                api1201.setQddd("签订地点");
            }
            //合同审核人不能为空或填无
            if (StringUtils.isEmpty(api1201.getShr())) {
                api1201.setShr("审批人");
            }
            //设置购销方式,默认客户统一信用码为空，则为产销，反之为竞价；(1-定向；2-竞价；3-产销)
            api1201.setGxfs("2");
            if(StringUtils.isEmpty(api1201.getKhtyshxydm())){
                api1201.setGxfs("3");
            }
            //设置空属性为默认值
            changeObject(api1201);
            return api1201;
        }
        if (SH2023Constant.SH_2023_API_CODE_1202.equals(inteId)) {
            SH2023Api1202 api1202 = new SH2023Api1202();
            Api1202 apiData = (Api1202) data;
            BeanUtils.copyProperties(apiData, api1202);
            api1202.setBjw(ShAreaBjw.getBjw(code));
            api1202.setJzrq(apiData.getCmsj());
            if (StringUtils.isEmpty(api1202.getCddm())) {
                api1202.setCddm(api1202.getHwdm().substring(2, 8));
            }
            if (StringUtils.isEmpty(api1202.getRkjsdh())) {
                api1202.setRkjsdh("0");
            }
            //设置粮食轮换年度,根据计划明细号查询计划明细，再根据计划明细查询轮换计划
            List<Api1404> api1404List = api1404Rep.getDataByJhmxdh(apiData.getJhmxh());
            if (null != api1404List && api1404List.size() > 0) {
                api1202.setShnd(api1404List.get(0).getShnd());
                List<Api1403> api1403List = api1403Rep.getDataByLhjhdh(api1404List.get(0).getLhjhdh());
                if(null != api1403List && api1403List.size() > 0){
                    if(StringUtils.isNotEmpty(api1403List.get(0).getJhnd())){
                        api1202.setLhnd(api1403List.get(0).getJhnd());
                    }
                }
            }
            //查询粮食性质转变单号(根据入库时间和货位代码查询粮食性质转变单)
            List<Api1210> api1210List = api1210Rep.findDataByHwdmAndTime(api1202.getHwdm(), api1202.getCmsj());
            if (null != api1210List && api1210List.size() > 0) {
                api1202.setLsxzzbdh(api1210List.get(0).getLsxzzbdh());
            }
            //设置批次号
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1202.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1202.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }
            //粮食性质
            api1202.setLsxzdm("200");

            //设置空属性为默认值
            changeObject(api1202);
            return api1202;
        }
        if (SH2023Constant.SH_2023_API_CODE_1203.equals(inteId)) {
            SH2023Api1203 api1203 = new SH2023Api1203();
            Api1203 apiData = (Api1203) data;
            BeanUtils.copyProperties(apiData, api1203);
            api1203.setBjw(ShAreaBjw.getBjw(code));
            if (StringUtils.isEmpty(api1203.getJyxm())) {
                api1203.setJyxm("0");
            }
            if (StringUtils.isEmpty(api1203.getJyz())) {
                api1203.setJyz("0");
            }
            if (StringUtils.isEmpty(api1203.getZkj())) {
                api1203.setZkj("0");
            }
            if (StringUtils.isEmpty(api1203.getZkl())) {
                api1203.setZkl("0");
            }
            //设置批次号
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1203.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1203.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }
            //设置质检编码(默认等同于入库质检单号),若为船运，则设置为系统内船运的单号
            api1203.setZjbh(api1203.getRkjydh());
            List<Api1202> api1202List = api1202Rep.getDataById(api1203.getRkywdh());
            if (null != api1202List && api1202List.size() > 0) {
                if(api1202List.get(0).getYsgj().equals("3")){
                    api1203.setZjbh(api1202List.get(0).getBizId().substring(2));
                }
            }
            //设置空属性为默认值
            changeObject(api1203);
            return api1203;
        }
        if (SH2023Constant.SH_2023_API_CODE_1204.equals(inteId)) {
            SH2023Api1204 api1204 = new SH2023Api1204();
            Api1204 apiData = (Api1204) data;
            BeanUtils.copyProperties(apiData, api1204);
            api1204.setBjw(ShAreaBjw.getBjw(code));

            //设置批次号
            if (StringUtils.isNotEmpty(api1204.getHth())) {
                List<Api1202> api1202List = api1202Rep.getDataByRkjsdh(api1204.getRkjsdh());
                if (null != api1202List && api1202List.size() > 0) {
                    List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1202List.get(0).getHwdm());
                    if (null != api1208List && api1208List.size() > 0) {
                        api1204.setPch(api1208List.get(0).getHwdm() + api1208List.get(0).getShnd());
                    }
                }
            }
            if (StringUtils.isNotEmpty(api1204.getHwdm())) {
                List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1204.getHwdm());
                if (null != api1208List && api1208List.size() > 0) {
                    api1204.setPch(api1208List.get(0).getHwdm() + api1208List.get(0).getShnd());
                }
            }

            //设置空属性为默认值
            changeObject(api1204);
            return api1204;
        }
        if (SH2023Constant.SH_2023_API_CODE_1205.equals(inteId)) {

            SH2023Api1205 api1205 = new SH2023Api1205();
            Api1205 apiData = (Api1205) data;
            BeanUtils.copyProperties(apiData, api1205);
            api1205.setBjw(ShAreaBjw.getBjw(code));

            api1205.setJzrq(apiData.getCmsj());
            if (StringUtils.isEmpty(api1205.getCddm())) {
                api1205.setCddm(api1205.getHwdm().substring(2, 8));
            }
            if (StringUtils.isEmpty(api1205.getCkjsdh())) {
                api1205.setCkjsdh("0");
            }

            //设置粮食轮换年度
            List<Api1404> api1404List = api1404Rep.getDataByJhmxdh(apiData.getJhmxh());
            if (null != api1404List && api1404List.size() > 0) {
                List<Api1403> api1403List = api1403Rep.getDataByLhjhdh(api1404List.get(0).getLhjhdh());
                if(null != api1403List && api1403List.size() > 0){
                    if(StringUtils.isNotEmpty(api1403List.get(0).getJhnd())){
                        api1205.setLhnd(api1403List.get(0).getJhnd());
                    }
                }
            }

            //设置批次号
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1205.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1205.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }

            //粮食性质
            api1205.setLsxzdm("200");
            //设置空属性为默认值
            changeObject(api1205);
            return api1205;
        }
        if (SH2023Constant.SH_2023_API_CODE_1206.equals(inteId)) {
            SH2023Api1206 api1206 = new SH2023Api1206();
            Api1206 apiData = (Api1206) data;
            BeanUtils.copyProperties(apiData, api1206);
            api1206.setBjw(ShAreaBjw.getBjw(code));
            //批次号
            if (StringUtils.isNotEmpty(api1206.getHth())) {
                List<Api1205> api1205List = api1205Rep.getDataByCkjsdh(api1206.getCkjsdh());
                if (null != api1205List && api1205List.size() > 0) {
                    List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1205List.get(0).getHwdm());
                    if (null != api1208List && api1208List.size() > 0) {
                        api1206.setPch(api1208List.get(0).getHwdm() + api1208List.get(0).getShnd());
                    }
                }
            }
            //设置空属性为默认值
            changeObject(api1206);
            return api1206;
        }
        if (SH2023Constant.SH_2023_API_CODE_1207.equals(inteId)) {
            //倒仓倒出
            SH2023Api1207 api1207 = new SH2023Api1207();
            Api1207 apiData = (Api1207) data;
            BeanUtils.copyProperties(apiData, api1207);

            api1207.setDcrq(apiData.getDcrq());
            api1207.setBjw(ShAreaBjw.getBjw(code));

            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1207.getDchwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1207.setPch(api1207.getDchwdm() + api1208List.get(0).getShnd());
            }

            //设置空属性为默认值
            changeObject(api1207);
            return api1207;
        }
        if (SH2023Constant.SH_2023_API_CODE_1208.equals(inteId)) {
            SH2023Api1208 api1208 = new SH2023Api1208();
            Api1208 apiData = (Api1208) data;
            BeanUtils.copyProperties(apiData, api1208);
            api1208.setZglkdm(api1208.getHwdm().substring(0, 21));

            api1208.setBjw(ShAreaBjw.getBjw(code));
            //设置批次号
            api1208.setPch(apiData.getHwdm() + apiData.getShnd());
            if (StringUtils.isEmpty(api1208.getCd())) {
                api1208.setCd(api1208.getHwdm().substring(2, 8));
            }
            //包装储粮是，核查包存粮包数
            if(null == apiData.getBclbs()){
                apiData.setBclbs(0);
            }
            if("2".equals(apiData.getClfs()) && apiData.getBclbs() == 0){
                apiData.setBclbs((int)(apiData.getSjsl()/25));
            }
            //设置空属性为默认值
            changeObject(api1208);
            return api1208;
        }
        if (SH2023Constant.SH_2023_API_CODE_1209.equals(inteId)) {

            SH2023Api1209 api1209 = new SH2023Api1209();
            Api1209 apiData = (Api1209) data;

            BeanUtils.copyProperties(apiData, api1209);
            api1209.setDjlx("2");
            api1209.setSzjl(apiData.getQzszkl());
            api1209.setZrshde(apiData.getQzzrshde());
            api1209.setBjw(ShAreaBjw.getBjw(code));
            api1209.setJzrq(apiData.getYwrq());
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1209.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1209.setPch(api1209.getHwdm() + api1208List.get(0).getShnd());
            }

            //粮食性质,暂时默认区级储备
            api1209.setLsxzdm("122");

            //设置空属性为默认值
            changeObject(api1209);
            return api1209;
        }
        if (SH2023Constant.SH_2023_API_CODE_1210.equals(inteId)) {
            SH2023Api1210 api1210 = new SH2023Api1210();
            Api1210 apiData = (Api1210) data;

            BeanUtils.copyProperties(apiData, api1210);
            api1210.setBjw(ShAreaBjw.getBjw(code));
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1210.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1210.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }

            //若计划明细号为空，设置计划明细号，根据划转性质查询出入库信息获取计划号
            if(StringUtils.isEmpty(api1210.getJhmxdh())){
                if("200".equals(api1210.getHzqlsxzdm())){
                    //若划转前性质为商品粮，则查询入库信息获取计划明细号
                    List<Api1202> api1202List = api1202Rep.getDataByHwdmAndTime(api1210.getHwdm(), api1210.getHzrq());
                    if (null != api1202List && api1202List.size() > 0) {
                        api1210.setJhmxdh(api1202List.get(0).getJhmxh());
                    }
                }
                if("200".equals(api1210.getHzhlsxzdm())){
                    //若划转后性质为商品粮，则查询出库信息获取计划明细号
                    List<Api1205> api1205List = api1205Rep.getDataByHwdmAndTime(api1210.getHwdm(), api1210.getHzrq());
                    if (null != api1205List && api1205List.size() > 0) {
                        api1210.setJhmxdh(api1205List.get(0).getJhmxh());
                    }
                }
            }

            //设置空属性为默认值
            changeObject(api1210);
            return api1210;
        }
        if (SH2023Constant.SH_2023_API_CODE_1211.equals(inteId)) {
            SH2023Api1211 api1211 = new SH2023Api1211();
            Api1211 apiData = (Api1211) data;

            BeanUtils.copyProperties(apiData, api1211);
            api1211.setZglkdm(api1211.getKqdm());
            api1211.setBjw(ShAreaBjw.getBjw(code));
            api1211.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getYwrq(), "yyyyMM"));
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1211.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1211.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }
            //主管粮库代码
            api1211.setZglkdm(apiData.getKqdm());
            //设置空属性为默认值
            changeObject(api1211);
            return api1211;
        }
        if (SH2023Constant.SH_2023_API_CODE_1212.equals(inteId)) {
            SH2023Api1212 api1212 = new SH2023Api1212();
            BeanUtils.copyProperties(data, api1212);
            api1212.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1212);
            return api1212;
        }
        if (SH2023Constant.SH_2023_API_CODE_1301.equals(inteId)) {
            SH2023Api1301 api1301 = new SH2023Api1301();
            BeanUtils.copyProperties(data, api1301);
            api1301.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1301);
            return api1301;
        }
        if (SH2023Constant.SH_2023_API_CODE_1302.equals(inteId)) {
            SH2023Api1302 api1302 = new SH2023Api1302();
            Api1302 apiData = (Api1302) data;
            BeanUtils.copyProperties(apiData, api1302);
            api1302.setBjw(ShAreaBjw.getBjw(code));
            api1302.setLqjs("1");
            //批次号
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1302.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1302.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }
            //统计层高、层低、层均温等信息
            api1302 = packageData1302(api1302);

            //设置空属性为默认值
            changeObject(api1302);
            return api1302;
        }
        if (SH2023Constant.SH_2023_API_CODE_1303.equals(inteId)) {
            SH2023Api1303 api1303 = new SH2023Api1303();
            Api1303 apiData = (Api1303) data;
            BeanUtils.copyProperties(apiData, api1303);
            api1303.setBjw(ShAreaBjw.getBjw(code));
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1303.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1303.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }
            //设置空属性为默认值
            changeObject(api1303);
            return api1303;
        }
        if (SH2023Constant.SH_2023_API_CODE_1304.equals(inteId)) {
            SH2023Api1304 api1304 = new SH2023Api1304();
            Api1304 apiData = (Api1304) data;
            BeanUtils.copyProperties(apiData, api1304);
            api1304.setBjw(ShAreaBjw.getBjw(code));
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(api1304.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                api1304.setPch(apiData.getHwdm() + api1208List.get(0).getShnd());
            }

            //设置空属性为默认值
            changeObject(api1304);
            return api1304;
        }
        if (SH2023Constant.SH_2023_API_CODE_1305.equals(inteId)) {
            SH2023Api1305 api1305 = new SH2023Api1305();
            Api1305 apiData = (Api1305) data;
            BeanUtils.copyProperties(apiData, api1305);
            api1305.setBjw(ShAreaBjw.getBjw(code));
            api1305.setAjdm(apiData.getTfzydh().substring(0, 28));
            //上海通风作业单号：廒间代码+yyyyMMdd+3位顺序号
            api1305.setAjdm(apiData.getTfzydh().substring(0, 28));
            api1305.setTfzydh(apiData.getTfzydh().substring(0, 28) + apiData.getTfzydh().substring(30));
            if (StringUtils.isEmpty(api1305.getTfmd())) {
                api1305.setTfmd("1"); //降温通风
            }
            //设置空属性为默认值
            changeObject(api1305);
            return api1305;
        }
        if (SH2023Constant.SH_2023_API_CODE_1306.equals(inteId)) {
            SH2023Api1306 api1306 = new SH2023Api1306();
            Api1306 apiData = (Api1306) data;
            BeanUtils.copyProperties(apiData, api1306);
            api1306.setBjw(ShAreaBjw.getBjw(code));
            api1306.setPch(apiData.getXzzydh().substring(0, 30) + DateFormatUtils.format(apiData.getXzkssj(), "yyyy"));
            api1306.setAjdm(apiData.getHwdm().substring(0, 28));
            //上海熏蒸作业单号：货位代码+yyyyMMdd + 3位顺序号
            api1306.setXzzydh(apiData.getHwdm() + apiData.getBizId());
            if (StringUtils.isEmpty(api1306.getSyff())) {
                api1306.setSyff("0"); //潮解法
            }
            //设置空属性为默认值
            changeObject(api1306);
            return api1306;
        }
        if (SH2023Constant.SH_2023_API_CODE_1307.equals(inteId)) {
            SH2023Api1307 api1307 = new SH2023Api1307();
            Api1307 apiData = (Api1307) data;
            BeanUtils.copyProperties(apiData, api1307);
            api1307.setBjw(ShAreaBjw.getBjw(code));
            api1307.setAjdm(apiData.getHwdm().substring(0, 28));

            //设置空属性为默认值
            changeObject(api1307);
            return api1307;
        }
        if (SH2023Constant.SH_2023_API_CODE_1308.equals(inteId)) {
            SH2023Api1308 api1308 = new SH2023Api1308();
            Api1308 apiData = (Api1308) data;

            BeanUtils.copyProperties(apiData, api1308);
            api1308.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1308);
            return api1308;
        }
        if (SH2023Constant.SH_2023_API_CODE_1309.equals(inteId)) {
            SH2023Api1309 api1309 = new SH2023Api1309();
            BeanUtils.copyProperties(data, api1309);
            api1309.setBjw(ShAreaBjw.getBjw(code));
            //设置空属性为默认值
            changeObject(api1309);
            return api1309;
        }
        if (SH2023Constant.SH_2023_API_CODE_1310.equals(inteId)) {
            SH2023Api1310 api1310 = new SH2023Api1310();
            Api1310 apiData = (Api1310) data;
            BeanUtils.copyProperties(apiData, api1310);
            api1310.setBjw(ShAreaBjw.getBjw(code));
            api1310.setJyrq(apiData.getJysj());

            if (StringUtils.isEmpty(api1310.getJyxm())) {
                api1310.setJyxm("0");
            }
            if (StringUtils.isEmpty(api1310.getJyxmz())) {
                api1310.setJyxmz("0");
            }
            String lsxzdm = "122";
            String pch = "";
            List<Api1208> api1208List = api1208Rep.getDataByHwdm(api1310.getHwdm());
            if (null != api1208List && api1208List.size() > 0) {
                if (StringUtils.isNotEmpty(api1208List.get(0).getLsxzdm())) {
                    lsxzdm = api1208List.get(0).getLsxzdm();
                    pch = apiData.getHwdm() + api1208List.get(0).getShnd();
                }
            }
            //设置批次号
            api1310.setPch(pch);
            api1310.setLsxzdm(lsxzdm);
            if (api1310.getYpsl() == 0.0) {
                api1310.setYpsl(5.0);
            }
            if (StringUtils.isEmpty(api1310.getQyrxm())) {
                api1310.setQyrxm("扦样人");
            }
            if (StringUtils.isEmpty(api1310.getJdrxm())) {
                api1310.setJdrxm("监督人");
            }
            if (StringUtils.isEmpty(api1310.getShrxm())) {
                api1310.setShrxm("审核人");
            }
            if (StringUtils.isEmpty(api1310.getBglx())) {
                api1310.setBglx("1");
            }

            //设置空属性为默认值
            changeObject(api1310);
            return api1310;
        }
        if (SH2023Constant.SH_2023_API_CODE_1311.equals(inteId)) {
            SH2023Api1311 api1311 = new SH2023Api1311();
            BeanUtils.copyProperties(data, api1311);
            api1311.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1311);
            return api1311;
        }
        if (SH2023Constant.SH_2023_API_CODE_1401.equals(inteId)) {
            SH2023Api1401 api1401 = new SH2023Api1401();
            BeanUtils.copyProperties(data, api1401);
            api1401.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1401);
            return api1401;
        }
        if (SH2023Constant.SH_2023_API_CODE_1402.equals(inteId)) {
            SH2023Api1402 api1402 = new SH2023Api1402();
            BeanUtils.copyProperties(data, api1402);
            api1402.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1402);
            return api1402;
        }
        if (SH2023Constant.SH_2023_API_CODE_1403.equals(inteId)) {
            SH2023Api1403 api1403 = new SH2023Api1403();
            Api1403 apiData = (Api1403) data;
            BeanUtils.copyProperties(apiData, api1403);
            List<Api1101> api1101List = api1101Rep.findDataByDwdm(apiData.getLhjhdh().substring(0, 18));

            api1403.setJhzxdw(api1101List.get(0).getDwdm());
            api1403.setJhzxdwmc(api1101List.get(0).getDwmc());
            api1403.setBjw(ShAreaBjw.getBjw(code));

            //查询轮换计划的轮入数量和轮出数量
            List<Api1404> list = api1404Rep.getDataByLhjhdh(api1403.getLhjhdh());
            Double lrsl = 0.0, lcsl = 0.0; //用于统计轮入数量和轮出数量
            if(null != list && list.size() > 0){
                for (Api1404 api1404 : list) {
                    if(null!= api1404.getLhlx() && "2".equals(api1404.getLhlx())){
                        lrsl += api1404.getLhsl();
                    }
                    if(null!= api1404.getLhlx() && "1".equals(api1404.getLhlx())){
                        lcsl += api1404.getLhsl();
                    }
                }
            }
            api1403.setLrsl(lrsl + "");
            api1403.setLcsl(lcsl + "");

            //设置空属性为默认值
            changeObject(api1403);
            return api1403;
        }
        if (SH2023Constant.SH_2023_API_CODE_1404.equals(inteId)) {
            SH2023Api1404 api1404 = new SH2023Api1404();
            BeanUtils.copyProperties(data, api1404);
            api1404.setMxzt("1");
            api1404.setBjw(ShAreaBjw.getBjw(code));

            //设置空属性为默认值
            changeObject(api1404);
            return api1404;
        }
        if (SH2023Constant.SH_2023_API_CODE_2101.equals(inteId)) {
            //设置空属性为默认值
            changeObject(data);
            return data;
        }
        if (SH2023Constant.SH_2023_API_CODE_2102.equals(inteId)) {
            SH2023Api2102 apiData = new SH2023Api2102();
            BeanUtils.copyProperties(data, apiData);
            List<Api1208> api1208List = api1208Rep.findDataByHwdm(apiData.getDrhwdm());
            if (null != api1208List && api1208List.size() > 0) {
                apiData.setPch(apiData.getDrhwdm() + api1208List.get(0).getShnd());
            }
            //设置空属性为默认值
            changeObject(apiData);
            return apiData;
        }
        if (SH2023Constant.SH_2023_API_CODE_2103.equals(inteId)) {
            SH2023Api2103 apiData = new SH2023Api2103();
            BeanUtils.copyProperties(data, apiData);
            //设置空属性为默认值
            changeObject(apiData);
            return apiData;
        }
        if (SH2023Constant.SH_2023_API_CODE_2104.equals(inteId)) {
            //设置空属性为默认值
            changeObject(data);
            return data;
        }
        if (SH2023Constant.SH_2023_API_CODE_2203.equals(inteId)) {

            //设置空属性为默认值
            changeObject(data);
            return data;
        }
        if (SH2023Constant.SH_2023_API_CODE_2204.equals(inteId)) {
            //设置空属性为默认值
            changeObject(data);
            return data;
        }
        //设置空属性为默认值
        changeObject(data);
        return data;
    }

    /**
     * 根据上海数据格式进行封装
     * 层均温：
     * 层高温：
     * 层低温：
     * 各范围均温：
     * 粮温明细：
     * 粮温状态：
     * 异常点个数：
     *
     * @param data
     * @return
     */
    private SH2023Api1302 packageData1302(SH2023Api1302 data) {
        if (StringUtils.isEmpty(data.getLswdzjh())) {
            return data;
        }
        String lswdzjh = data.getLswdzjh();
        String[] split = lswdzjh.split("\\|");
        Map<Integer, List<Double>> map = new HashMap<>();
        Integer ceng;
        Integer errorNum = 0;  //异常点个数
        String lwmx = "";   //粮温明细
        String lwzt = "0";  //粮温状态
        String gfwjw = "";  //各范围均温
        for (String s : split) {
            String[] grain = s.split(",");
            ceng = Integer.valueOf(grain[1]);
            if (null == map.get(ceng)) {
                map.put(ceng, new ArrayList<>());
            }
            map.get(ceng).add(Double.valueOf(grain[0]));
            lwmx +=  grain[2]  + ":" + grain[3]  +":" + grain[1] + "$" + grain[0];
            if (Double.valueOf(grain[0]) <= -100) {
                lwmx += "$" + "1" + "#";
                errorNum++;
            } else {
                lwmx += "$" + "5" + "#";
            }
        }
        String cpjw = "";  //层平均温
        String czgw = "";  //层最高温
        String czdw = "";  //层最低温

        List<Double> payPoints;
        Double sum;
        int num;
        Double tempH;
        Double tempL;
        Double tempA;
        Double tempValue1 = 0.0; //范围均温1
        Double tempValue2 = 0.0; //范围均温2
        Double tempValue3 = 0.0; //范围均温3
        Integer numValue = 0; //计算范围均温
        for (Integer cengNum : map.keySet()) {
            payPoints = map.get(cengNum);
            sum = 0.0;
            num = 0;
            tempH = null;
            tempL = null;
            tempA = 0.0;
            for (Double point : payPoints) {
                if(point > -100){
                    sum += point;
                    num++;
                    if (tempH == null) {
                        tempH = point;
                    }
                    if (tempL == null) {
                        tempL = point;
                    }
                    if (tempH < point) {
                        tempH = point;
                    }
                    if (tempL > point) {
                        tempL = point;
                    }
                }
            }
            if (num > 0) {
                tempA = sum / num;
            }
            cpjw += cengNum + "$" + NumberUtil.keepPrecision(tempA, 1) + "#";
            czgw += cengNum + "$" + tempH + "#";
            czdw += cengNum + "$" + tempL + "#";
            //范围均温封装
            if (cengNum == 1) {
                tempValue1 = NumberUtil.keepPrecision(tempA, 1);
            } else if (cengNum == map.keySet().size()) {
                tempValue3 = NumberUtil.keepPrecision(tempA, 1);
            } else {
                tempValue2 += tempA;
                numValue++;
            }
        }

        if (errorNum > 0) {
            lwzt = "2";
        }
        if (numValue > 0) {
            tempValue2 = NumberUtil.keepPrecision(tempValue2 / numValue, 1);
        }
        gfwjw += tempValue1 + "#";
        if (map.keySet().size() == 2) {
            gfwjw += tempValue3 + "#";
        }
        if (map.keySet().size() > 3) {
            gfwjw += tempValue2 + "#" + tempValue3 + "#";
        }
        data.setCpjw(cpjw);
        data.setCzgw(czgw);
        data.setCzdw(czdw);
        data.setGfwjw(gfwjw);
        data.setLwmx(lwmx);
        data.setLwzt(lwzt);
        data.setYcdgs(errorNum);

        return data;
    }

    /**
     * 获取财务数据json
     *
     * @param inteId
     * @param data
     * @return
     * @throws Exception
     */
    private String getJsonData(String inteId, Object data, String code) {
        //具体根据接口进行封装
        if (SH2023Constant.SH_2023_API_CODE_1101.equals(inteId)) {
            SH2023Api1101 api1101;
            //最后转换为json
            List<SH2023Api1101> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1101> api1101List = castList(data, Api1101.class);
            //查询廒间数
            List<Api1104> api1104List = api1104Rep.findPushData(api1101List.get(0).getKqdm());
            for (Api1101 apiData : api1101List) {
                api1101 = new SH2023Api1101();
                BeanUtils.copyProperties(apiData, api1101);
                api1101.setAjs(api1104List.size());
                api1101.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1101);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1102.equals(inteId)) {
            SH2023Api1102 api1102;
            //最后转换为json
            List<SH2023Api1102> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1102> api1101List = castList(data, Api1102.class);
            //查询廒间数
            List<Api1104> api1104List = api1104Rep.findPushData(api1101List.get(0).getKqdm());
            //计算储备仓容
            Double count = 0.0;
            for (Api1104 api1104 : api1104List) {
                count = count + api1104.getAjsjcrong();
            }
            for (Api1102 apiData : api1101List) {
                api1102 = new SH2023Api1102();
                BeanUtils.copyProperties(apiData, api1102);
                api1102.setAjs(api1104List.size());
                api1102.setBjw(ShAreaBjw.getBjw(code));
                api1102.setKqsx("2");
                api1102.setCbcr(count);
                list.add(api1102);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1103.equals(inteId)) {
            SH2023Api1103 api1103;
            //最后转换为json
            List<SH2023Api1103> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1103> api1103List = castList(data, Api1103.class);
            //查询廒间数
            List<Api1104> api1104List = api1104Rep.findPushData(api1103List.get(0).getKqdm());
            for (Api1103 apiData : api1103List) {
                api1103 = new SH2023Api1103();
                BeanUtils.copyProperties(apiData, api1103);
                api1103.setAjs(api1104List.size());
                api1103.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1103);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1104.equals(inteId)) {
            SH2023Api1104 api1104;
            //最后转换为json
            List<SH2023Api1104> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1104> api1104List = castList(data, Api1104.class);
            for (Api1104 apiData : api1104List) {
                api1104 = new SH2023Api1104();
                BeanUtils.copyProperties(apiData, api1104);
                api1104.setAjdm(apiData.getAjdh());
                api1104.setCfdm(apiData.getCfbh());
                api1104.setSykqdm(apiData.getKqdm());
                api1104.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1104);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1105.equals(inteId)) {
            SH2023Api1105 api1105;
            //最后转换为json
            List<SH2023Api1105> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1105> api1105List = castList(data, Api1105.class);
            for (Api1105 apiData : api1105List) {
                api1105 = new SH2023Api1105();
                BeanUtils.copyProperties(apiData, api1105);
                api1105.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1105);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1106.equals(inteId)) {
            SH2023Api1106 api1106;
            //最后转换为json
            List<SH2023Api1106> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1106> api1106List = castList(data, Api1106.class);
            for (Api1106 apiData : api1106List) {
                api1106 = new SH2023Api1106();
                BeanUtils.copyProperties(apiData, api1106);
                api1106.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1106);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1107.equals(inteId)) {
            SH2023Api1107 api1107;
            //最后转换为json
            List<SH2023Api1107> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1107> api1107List = castList(data, Api1107.class);
            for (Api1107 apiData : api1107List) {
                api1107 = new SH2023Api1107();
                BeanUtils.copyProperties(apiData, api1107);
                api1107.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1107);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1108.equals(inteId)) {
            SH2023Api1108 api1108;
            //最后转换为json
            List<SH2023Api1108> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1108> api1108List = castList(data, Api1108.class);
            for (Api1108 apiData : api1108List) {
                api1108 = new SH2023Api1108();
                BeanUtils.copyProperties(apiData, api1108);
                api1108.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1108);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1109.equals(inteId)) {
            SH2023Api1109 api1109;
            //最后转换为json
            List<SH2023Api1109> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1109> api1109List = castList(data, Api1109.class);
            Map<String, String> map;
            for (Api1109 apiData : api1109List) {
                api1109 = new SH2023Api1109();
                BeanUtils.copyProperties(apiData, api1109);
                api1109.setBjw(ShAreaBjw.getBjw(code));
                if ("1".equals(api1109.getWjlx())) {
                    api1109.setYwdh("无");
                }
                map = new HashMap<>();
                map.put(apiData.getWjmc(), FileUtils.fileToByteString(apiData.getWjdz()));
                api1109.setWjl(JSON.toJSONString(map));
                list.add(api1109);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1110.equals(inteId)) {
            SH2023Api1110 api1110;
            //最后转换为json
            List<SH2023Api1110> list = new ArrayList<>();
            HashSet<String> set = new HashSet<>();
            //把data转化成list集合
            List<Api1110> api1110List = castList(data, Api1110.class);
            for (Api1110 apiData : api1110List) {
                // 因为廒间是根据货位截取，所以要判断廒间是否重复
                if (!set.add(apiData.getHwdm().substring(0, 28))) {
                    continue;
                }
                api1110 = new SH2023Api1110();
                BeanUtils.copyProperties(apiData, api1110);
                api1110.setBjw(ShAreaBjw.getBjw(code));
                api1110.setAjdm(apiData.getHwdm().substring(0, 28));
                api1110.setAjxdwz(apiData.getHwxdwz());
                api1110.setAjwzys(apiData.getHwwzys());
                list.add(api1110);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1111.equals(inteId)) {
            SH2023Api1111 api1111;
            //最后转换为json
            List<SH2023Api1111> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1111> api1111List = castList(data, Api1111.class);
            for (Api1111 apiData : api1111List) {
                api1111 = new SH2023Api1111();
                BeanUtils.copyProperties(apiData, api1111);
                api1111.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1111);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1112.equals(inteId)) {
            SH2023Api1112 api1112;
            //最后转换为json
            List<SH2023Api1112> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1112> api1112List = castList(data, Api1112.class);
            for (Api1112 apiData : api1112List) {
                api1112 = new SH2023Api1112();
                BeanUtils.copyProperties(apiData, api1112);
                api1112.setHdrychsj(api1112.getQdzgzchzyzgsj());
                api1112.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1112);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1113.equals(inteId)) {
            SH2023Api1113 api1113;
            //最后转换为json
            List<SH2023Api1113> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1113> api1113List = castList(data, Api1113.class);
            for (Api1113 apiData : api1113List) {
                api1113 = new SH2023Api1113();
                BeanUtils.copyProperties(apiData, api1113);
                api1113.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1113);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1201.equals(inteId)) {
            SH2023Api1201 api1201;
            //最后转换为json
            List<SH2023Api1201> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1201> api1201List = castList(data, Api1201.class);
            for (Api1201 apiData : api1201List) {
                api1201 = new SH2023Api1201();
                BeanUtils.copyProperties(apiData, api1201);
                api1201.setBjw(ShAreaBjw.getBjw(code));
                api1201.setHtsfzz("0");
                list.add(api1201);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1202.equals(inteId)) {
            SH2023Api1202 api1202;
            //最后转换为json
            List<SH2023Api1202> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1202> api1202List = castList(data, Api1202.class);
            for (Api1202 apiData : api1202List) {
                api1202 = new SH2023Api1202();
                BeanUtils.copyProperties(apiData, api1202);
                api1202.setBjw(ShAreaBjw.getBjw(code));
                api1202.setPch(apiData.getHwdm() + apiData.getShnd());
                //todo 驳运单号(2104)  检斤单号(2101)   均为非必填
                api1202.setJzrq(apiData.getCmsj());
                list.add(api1202);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1203.equals(inteId)) {
            SH2023Api1203 api1203;
            //最后转换为json
            List<SH2023Api1203> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1203> api1203List = castList(data, Api1203.class);
            for (Api1203 apiData : api1203List) {
                api1203 = new SH2023Api1203();
                BeanUtils.copyProperties(apiData, api1203);
                api1203.setBjw(ShAreaBjw.getBjw(code));
                //查询收获年份
                List<Api1202> api1202List = api1202Rep.getDataById(apiData.getRkywdh());
                api1203.setPch(apiData.getHwdm() + api1202List.get(0).getShnd());
                list.add(api1203);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1204.equals(inteId)) {
            SH2023Api1204 api1204;
            //最后转换为json
            List<SH2023Api1204> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1204> api1204List = castList(data, Api1204.class);
            for (Api1204 apiData : api1204List) {
                api1204 = new SH2023Api1204();
                BeanUtils.copyProperties(apiData, api1204);
                api1204.setBjw(ShAreaBjw.getBjw(code));
                api1204.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJssj(), "yyyy"));
                list.add(api1204);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1205.equals(inteId)) {
            SH2023Api1205 api1205;
            //最后转换为json
            List<SH2023Api1205> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1205> api1205List = castList(data, Api1205.class);
            for (Api1205 apiData : api1205List) {
                api1205 = new SH2023Api1205();
                BeanUtils.copyProperties(apiData, api1205);
                api1205.setBjw(ShAreaBjw.getBjw(code));
                api1205.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getCmsj(), "yyyy"));
                api1205.setJzrq(apiData.getCmsj());
                api1205.setJhmxh("无");
                api1205.setJjlx("无");
                list.add(api1205);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1206.equals(inteId)) {
            SH2023Api1206 api1206;
            //最后转换为json
            List<SH2023Api1206> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1206> api1206List = castList(data, Api1206.class);
            for (Api1206 apiData : api1206List) {
                api1206 = new SH2023Api1206();
                BeanUtils.copyProperties(apiData, api1206);
                api1206.setBjw(ShAreaBjw.getBjw(code));
                List<Api1205> api1205List = api1205Rep.getDataById(apiData.getCkjsdh());
                api1206.setPch(api1205List.get(0).getHwdm() + DateFormatUtils.format(api1205List.get(0).getCmsj(), "yyyy"));
                list.add(api1206);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1207.equals(inteId)) {
            SH2023Api1207 api1207;
            //最后转换为json
            List<SH2023Api1207> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1207> api1207List = castList(data, Api1207.class);
            for (Api1207 apiData : api1207List) {
                api1207 = new SH2023Api1207();
                BeanUtils.copyProperties(apiData, api1207);

                api1207.setDcrq(apiData.getDcrq());
                api1207.setBjw(ShAreaBjw.getBjw(code));
                //TODO 库调单号

                list.add(api1207);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1208.equals(inteId)) {
            SH2023Api1208 api1208;
            //最后转换为json
            List<SH2023Api1208> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1208> api1208List = castList(data, Api1208.class);
            for (Api1208 apiData : api1208List) {
                api1208 = new SH2023Api1208();
                BeanUtils.copyProperties(apiData, api1208);
                api1208.setZglkdm(api1208.getHwdm().substring(0, 21));

                //TODO 来粮代码

                api1208.setBjw(ShAreaBjw.getBjw(code));
                api1208.setPch(apiData.getHwdm() + apiData.getShnd());
                list.add(api1208);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1209.equals(inteId)) {
            SH2023Api1209 api1209;
            //最后转换为json
            List<SH2023Api1209> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1209> api1209List = castList(data, Api1209.class);
            for (Api1209 apiData : api1209List) {
                api1209 = new SH2023Api1209();
                BeanUtils.copyProperties(apiData, api1209);

                api1209.setDjlx("2");
                api1209.setSzjl(apiData.getQzszkl());
                api1209.setZrshde(apiData.getQzzrshde());
                api1209.setBjw(ShAreaBjw.getBjw(code));
                api1209.setJzrq(apiData.getYwrq());
                api1209.setBz("无");
                api1209.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getYwrq(), "yyyy"));
                list.add(api1209);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1210.equals(inteId)) {
            SH2023Api1210 api1210;
            //最后转换为json
            List<SH2023Api1210> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1210> api1210List = castList(data, Api1210.class);
            for (Api1210 apiData : api1210List) {
                api1210 = new SH2023Api1210();
                BeanUtils.copyProperties(apiData, api1210);

                api1210.setBjw(ShAreaBjw.getBjw(code));
                api1210.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getHzrq(), "yyyy"));
                list.add(api1210);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1211.equals(inteId)) {
            SH2023Api1211 api1211;
            //最后转换为json
            List<SH2023Api1211> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1211> api1211List = castList(data, Api1211.class);
            for (Api1211 apiData : api1211List) {
                api1211 = new SH2023Api1211();
                BeanUtils.copyProperties(apiData, api1211);

                api1211.setZglkdm(api1211.getKqdm());
                api1211.setBjw(ShAreaBjw.getBjw(code));
                api1211.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getYwrq(), "yyyyMM"));
                if(StringUtils.isEmpty(api1211.getLldm())){
                    api1211.setLldm("无");
                }
                list.add(api1211);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1212.equals(inteId)) {
            SH2023Api1212 api1212;
            //最后转换为json
            List<SH2023Api1212> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1212> api1212List = castList(data, Api1212.class);
            for (Api1212 apiData : api1212List) {
                api1212 = new SH2023Api1212();
                BeanUtils.copyProperties(apiData, api1212);
                api1212.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1212);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1301.equals(inteId)) {
            SH2023Api1301 api1301;
            //最后转换为json
            List<SH2023Api1301> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1301> api1301List = castList(data, Api1301.class);
            for (Api1301 apiData : api1301List) {
                api1301 = new SH2023Api1301();
                BeanUtils.copyProperties(apiData, api1301);
                api1301.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1301);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1302.equals(inteId)) {
            SH2023Api1302 api1302;
            //最后转换为json
            List<SH2023Api1302> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1302> api1302List = castList(data, Api1302.class);
            for (Api1302 apiData : api1302List) {
                api1302 = new SH2023Api1302();
                BeanUtils.copyProperties(apiData, api1302);
                api1302.setBjw(ShAreaBjw.getBjw(code));
                api1302.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJcsj(), "yyyy"));
                api1302.setCpjw(String.valueOf(apiData.getLspjw()));
                api1302.setCzgw(String.valueOf(apiData.getLspjw()));
                api1302.setCzdw(String.valueOf(apiData.getLspjw()));
                api1302.setGfwjw(String.valueOf(apiData.getLspjw()));
                api1302.setLwmx(apiData.getLswdzjh());

                list.add(api1302);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1303.equals(inteId)) {
            SH2023Api1303 api1303;
            //最后转换为json
            List<SH2023Api1303> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1303> api1303List = castList(data, Api1303.class);
            for (Api1303 apiData : api1303List) {
                api1303 = new SH2023Api1303();
                BeanUtils.copyProperties(apiData, api1303);
                api1303.setBjw(ShAreaBjw.getBjw(code));
                api1303.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJcsj(), "yyyy"));
                list.add(api1303);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1304.equals(inteId)) {
            SH2023Api1304 api1304;
            //最后转换为json
            List<SH2023Api1304> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1304> api1304List = castList(data, Api1304.class);
            for (Api1304 apiData : api1304List) {
                api1304 = new SH2023Api1304();
                BeanUtils.copyProperties(apiData, api1304);
                api1304.setBjw(ShAreaBjw.getBjw(code));
                api1304.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJcsj(), "yyyy"));
                list.add(api1304);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1305.equals(inteId)) {
            SH2023Api1305 api1305;
            //最后转换为json
            List<SH2023Api1305> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1305> api1305List = castList(data, Api1305.class);
            for (Api1305 apiData : api1305List) {
                api1305 = new SH2023Api1305();
                BeanUtils.copyProperties(apiData, api1305);
                api1305.setBjw(ShAreaBjw.getBjw(code));
                api1305.setAjdm(apiData.getTfzydh().substring(0, 28));
                list.add(api1305);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1306.equals(inteId)) {
            SH2023Api1306 api1306;
            //最后转换为json
            List<SH2023Api1306> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1306> api1306List = castList(data, Api1306.class);
            for (Api1306 apiData : api1306List) {
                api1306 = new SH2023Api1306();
                BeanUtils.copyProperties(apiData, api1306);
                api1306.setBjw(ShAreaBjw.getBjw(code));
                api1306.setPch(apiData.getXzzydh().substring(0, 30) + DateFormatUtils.format(apiData.getXzkssj(), "yyyy"));
                api1306.setAjdm(apiData.getXzzydh().substring(0, 28));
                list.add(api1306);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1307.equals(inteId)) {
            SH2023Api1307 api1307;
            //最后转换为json
            List<SH2023Api1307> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1307> api1307List = castList(data, Api1307.class);
            for (Api1307 apiData : api1307List) {
                api1307 = new SH2023Api1307();
                BeanUtils.copyProperties(apiData, api1307);
                api1307.setBjw(ShAreaBjw.getBjw(code));
                api1307.setAjdm(apiData.getHwdm().substring(0, 28));
                List<Api1109> api1109List = api1109Rep.getDataByFileId(apiData.getFileStorageId());
                api1307.setTxbh(api1109List.get(0).getWjmc());
                list.add(api1307);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1310.equals(inteId)) {
            SH2023Api1310 api1310;
            //最后转换为json
            List<SH2023Api1310> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1310> api1310List = castList(data, Api1310.class);
            for (Api1310 apiData : api1310List) {
                api1310 = new SH2023Api1310();
                BeanUtils.copyProperties(apiData, api1310);
                api1310.setBjw(ShAreaBjw.getBjw(code));
                api1310.setJyrq(apiData.getJysj());
                api1310.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJysj(), "yyyy"));
                List<Api1202> api1202List = api1202Rep.getDataByHwdm(apiData.getHwdm());
                api1310.setLspzdm(api1202List.get(0).getLspzdm());
                list.add(api1310);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1401.equals(inteId)) {
            SH2023Api1401 api1401;
            //最后转换为json
            List<SH2023Api1401> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1401> api1401List = castList(data, Api1401.class);
            for (Api1401 apiData : api1401List) {
                api1401 = new SH2023Api1401();
                BeanUtils.copyProperties(apiData, api1401);
                list.add(api1401);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1402.equals(inteId)) {
            SH2023Api1402 api1402;
            //最后转换为json
            List<SH2023Api1402> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1402> api1402List = castList(data, Api1402.class);
            for (Api1402 apiData : api1402List) {
                api1402 = new SH2023Api1402();
                BeanUtils.copyProperties(apiData, api1402);
                api1402.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1402);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1403.equals(inteId)) {
            SH2023Api1403 api1403;
            //最后转换为json
            List<SH2023Api1403> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1403> api1403List = castList(data, Api1403.class);
            for (Api1403 apiData : api1403List) {
                api1403 = new SH2023Api1403();
                BeanUtils.copyProperties(apiData, api1403);
                api1403.setJhzxdw(apiData.getJhxddw());
                api1403.setJhzxdwmc(apiData.getJhxddwmc());
                list.add(api1403);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1404.equals(inteId)) {
            SH2023Api1404 api1404;
            //最后转换为json
            List<SH2023Api1404> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1404> api1404List = castList(data, Api1404.class);
            for (Api1404 apiData : api1404List) {
                api1404 = new SH2023Api1404();
                BeanUtils.copyProperties(apiData, api1404);
                //TODO 明细状态

                list.add(api1404);
            }
            return JSON.toJSONString(list);
        }

        if (SH2023Constant.SH_2023_API_CODE_2102.equals(inteId)) {
            SH2023Api2102 api2102;
            //最后转换为json
            List<SH2023Api2102> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1207> api1207List = castList(data, Api1207.class);
            for (Api1207 apiData : api1207List) {
                api2102 = new SH2023Api2102();
                BeanUtils.copyProperties(apiData, api2102);
                api2102.setDrdh(apiData.getDcdh());
                api2102.setDcrq(apiData.getDcrq());
                api2102.setPch(api2102.getDrhwdm() + DateFormatUtils.format(apiData.getDcrq(), "yyyy"));
                api2102.setBjw(ShAreaBjw.getBjw(code));
                //TODO 库调单号

                list.add(api2102);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_2203.equals(inteId)) {
            SH2023Api2203 api2203;
            //最后转换为json
            List<SH2023Api2203> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1201> api1201List = castList(data, Api1201.class);
            for (Api1201 apiData : api1201List) {
                api2203 = new SH2023Api2203();
                BeanUtils.copyProperties(apiData, api2203);
                api2203.setHtbh(apiData.getHth());

//                api2203.setBdh();
                api2203.setCjrq(apiData.getQdrq());
//                api2203.setJyzt();
//                api2203.setLsxz();
//                api2203.setLspzmx();
//                api2203.setScnf();
//                api2203.setKd();
                //
                list.add(api2203);
            }
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_2204.equals(inteId)) {
            SH2023Api2204 api2204;
            //最后转换为json
            List<SH2023Api2204> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1310> api1310List = castList(data, Api1310.class);
            for (Api1310 apiData : api1310List) {
                api2204 = new SH2023Api2204();
                BeanUtils.copyProperties(apiData, api2204);
//                api2204.setSf();
//                api2204.setRksf();
//                api2204.setlldm();
                api2204.setBjw(ShAreaBjw.getBjw(code));
                api2204.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJysj(), "yyyy"));
                list.add(api2204);
            }
            return JSON.toJSONString(list);
        }
    private Object getJsonFinanceData(String inteId, Object data) {
        //财务报表数据封装
        if (SH2023Constant.SH_2023_API_CODE_1114_1501.equals(inteId)){
            List<SHFinanceDto> list = copyApi1501((Api1501) data);
            return JSON.toJSONString(list);
        if (SH2023Constant.SH_2023_API_CODE_1114_1501.equals(inteId)) {
            return copyApi1501((Api1501) data);
        } else if (SH2023Constant.SH_2023_API_CODE_1114_1502.equals(inteId)) {
            return copyApi1502((Api1502) data);
        } else {
            return copyApi1503((Api1503) data);
        }
        if (SH2023Constant.SH_2023_API_CODE_1114_1502.equals(inteId)){
            List<SHFinanceDto> list = copyApi1502((Api1502) data);
            return JSON.toJSONString(list);
        }
        if (SH2023Constant.SH_2023_API_CODE_1114_1503.equals(inteId)){
            List<SHFinanceDto> list = copyApi1503((Api1503) data);
            return JSON.toJSONString(list);
        }

        return JSON.toJSONString(data);
    }

    /**
     * Object类型转变为List
     *
     * @param obj
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> castList(Object obj, Class<T> clazz) {
        List<T> result = new ArrayList<T>();
        if (obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                result.add(clazz.cast(o));
            }
            return result;
        }
        return null;
    }


    private List<SHFinanceDto> copyApi1503(Api1503 data) {
        Api1503 api1503 = data;
    private List<SHFinanceDto> copyApi1503(Api1503 api1503) {
        List<SHFinanceDto> list = new ArrayList<>();
        SHFinanceDto shFinanceDto = new SHFinanceDto();
        shFinanceDto.setDwdm(api1503.getDwdm());
@@ -1020,8 +1168,7 @@
        return list;
    }

    private List<SHFinanceDto> copyApi1502(Api1502 data) {
        Api1502 api1502 = data;
    private List<SHFinanceDto> copyApi1502(Api1502 api1502) {
        List<SHFinanceDto> list = new ArrayList<>();
        SHFinanceDto shFinanceDto = new SHFinanceDto();
        shFinanceDto.setDwdm(api1502.getDwdm());
@@ -1073,8 +1220,7 @@
        return list;
    }

    private List<SHFinanceDto> copyApi1501(Api1501 data) {
        Api1501 api1501 = data;
    private List<SHFinanceDto> copyApi1501(Api1501 api1501) {
        List<SHFinanceDto> list = new ArrayList<>();
        SHFinanceDto shFinanceDto = new SHFinanceDto();
        shFinanceDto.setDwdm(api1501.getDwdm());
@@ -1162,11 +1308,7 @@
        return list;
    }

    private void paddingData(SHFinanceDto common,
                             List<SHFinanceDto> list,
                             String zbmc,
                             String zbz1,
                             String zbz2) {
    private void paddingData(SHFinanceDto common, List<SHFinanceDto> list, String zbmc, String zbz1, String zbz2) {
        SHFinanceDto shFinanceDto = new SHFinanceDto();
        BeanUtils.copyProperties(common, shFinanceDto);
        shFinanceDto.setZbmc(zbmc);
@@ -1174,4 +1316,53 @@
        shFinanceDto.setZbz2(zbz2);
        list.add(shFinanceDto);
    }

    private String getWjmc(String wjlx, String wjmc) {
        if ("2".equals(wjlx) || "3".equals(wjlx) || "4".equals(wjlx) || "5".equals(wjlx)) {
            if (wjmc.endsWith(".jpg")) {
                wjmc = wjmc.replaceAll(".jpg", "_00.jpg");
            }
            if (wjmc.endsWith(".png")) {
                wjmc = wjmc.replaceAll(".png", "_00.png");
            }
        }
        return wjmc;
    }
    private String getYwdh(String wjlx, String wjmc, String ywdh) {
        String[] s = wjmc.split("_");
        if ("2".equals(wjlx) || "3".equals(wjlx)) {
            ywdh = s[1];
        }
        return ywdh;
    }

    private Object changeObject(Object object) {
        // 使用反射获取属性列表 vo为实体对象名
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                // 判断属性值是否为null
                if (field.get(object) == null || field.get(object) == "") {
                    //根据类型设置默认值
                    if (field.getType() == String.class) {
                        field.set(object, "无");
                    }
                    if (field.getType() == Integer.class) {
                        field.set(object, 0);
                    }
                    if (field.getType() == Double.class) {
                        field.set(object, 0.0);
                    }
                    if (field.getType() == Date.class) {
                        field.set(object, new Date());
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return object;
    }

}