优化调整上海接口1

CZT

2023-10-18 0ca04b760d5c78cc0388efc58e37f02892b2b475

优化调整上海接口1

 src/main/java/com/fzzy/api/view/pr/Api1101PR.java

@@ -115,11 +115,6 @@
            return "系统没有当前推送协议配置，执行失败";
        }

        //根据省份协议，判断是集合形式上报还是单条json上报
        if(PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return  pushDataList(items, apiRemoteService, apiConf);
        }

        return  pushDataSingle(items, apiRemoteService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1102PR.java

@@ -112,10 +112,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        //根据省份协议，判断是集合形式上报还是单条json上报,上海2023集合形式上报
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiRemoteService, apiConf);
        }
        return pushDataSingle(items, apiRemoteService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1103PR.java

@@ -112,9 +112,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiRemoteService, apiConf);
        }
        return pushDataSingle(items, apiRemoteService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1104PR.java

@@ -113,9 +113,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiRemoteService, apiConf);
        }
        return pushDataSingle(items, apiRemoteService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1105PR.java

@@ -115,9 +115,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1106PR.java

@@ -110,10 +110,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";


        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1107PR.java

@@ -110,9 +110,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1108PR.java

@@ -109,9 +109,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1109PR.java

@@ -172,9 +172,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1110PR.java

@@ -109,9 +109,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1111PR.java

@@ -108,9 +108,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1112PR.java

@@ -108,9 +108,6 @@
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiRemoteService,apiConf);
        }
        return pushDataSingle(items,apiRemoteService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1113PR.java

@@ -98,9 +98,6 @@
     */
    @Expose
    public String pushData(List<Api1113> items) {
        ResponseDto responseDto;
        String result = "";
        Api1113 d;
        //获取配置
        String kqdm = items.get(0).getKqdm();
        ApiConfs apiConf = apiCommonService.getConf(kqdm);
@@ -110,9 +107,7 @@
        //获取实现接口
        ApiRemoteService apiRemoteService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiRemoteService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiRemoteService, apiConf);
        }

        return pushDataSingle(items, apiRemoteService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1201PR.java

@@ -162,9 +162,6 @@
     */
    @Expose
    public String pushData(List<Api1201> items) {
        ResponseDto responseDto;
        String result = "";
        Api1201 d;
        String kqdm = items.get(0).getKqdm();
        ApiConfs apiConf = apiCommonService.getConf(kqdm);

@@ -175,9 +172,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())){
            return pushDataList(items,apiService,apiConf);
        }
        return pushDataSingle(items,apiService,apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1202PR.java

@@ -171,9 +171,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1203PR.java

@@ -173,9 +173,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1204PR.java

@@ -164,9 +164,6 @@
     */
    @Expose
    public String pushData(List<Api1204> items) {
        ResponseDto responseDto;
        String result = "";
        Api1204 d;
        String kqdm = items.get(0).getKqdm();
        ApiConfs apiConf = apiCommonService.getConf(kqdm);

@@ -176,9 +173,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }
    /**

 src/main/java/com/fzzy/api/view/pr/Api1205PR.java

@@ -172,9 +172,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1206PR.java

@@ -4,12 +4,10 @@
import com.bstek.dorado.annotation.DataResolver;
import com.bstek.dorado.annotation.Expose;
import com.bstek.dorado.data.provider.Page;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.entity.ApiConfs;
import com.fzzy.api.service.ApiCommonService;
import com.fzzy.api.service.ApiPushManager;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.push.gb2022.GBApiRemoteService;
import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.dto.ResponseDto;
@@ -25,7 +23,6 @@
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Component;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
@@ -171,9 +168,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1207PR.java

@@ -174,9 +174,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1208PR.java

@@ -174,9 +174,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1209PR.java

@@ -172,9 +172,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1210PR.java

@@ -172,9 +172,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1211PR.java

@@ -172,9 +172,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1212PR.java

@@ -175,9 +175,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1301PR.java

@@ -170,9 +170,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1302PR.java

@@ -168,9 +168,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1303PR.java

@@ -168,9 +168,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1304PR.java

@@ -167,9 +167,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1305PR.java

@@ -169,9 +169,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1306PR.java

@@ -168,9 +168,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1307PR.java

@@ -171,9 +171,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1308PR.java

@@ -169,9 +169,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1309PR.java

@@ -168,9 +168,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1310PR.java

@@ -167,9 +167,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1401PR.java

@@ -168,9 +168,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1402PR.java

@@ -168,9 +168,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1403PR.java

@@ -159,9 +159,7 @@
     */
    @Expose
    public String pushData(List<Api1403> items) {
        ResponseDto responseDto;
        String result = "";
        Api1403 d;

        String kqdm = items.get(0).getKqdm();
        ApiConfs apiConf = apiCommonService.getConf(kqdm);

@@ -174,9 +172,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(param.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/api/view/pr/Api1404PR.java

@@ -168,9 +168,7 @@
        //获取实现接口
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";
        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }

        return pushDataSingle(items, apiService, apiConf);
    }
    /**

 src/main/java/com/fzzy/api/view/pr/Api1405PR.java

@@ -168,9 +168,6 @@
        ApiRemoteService apiService = apiPushManager.getApiRemoteService(apiConf.getPushProtocol());
        if (null == apiService) return "系统没有当前推送协议配置，执行失败";

        if (PushProtocol.SB_SH_2023.getCode().equals(apiConf.getPushProtocol())) {
            return pushDataList(items, apiService, apiConf);
        }
        return pushDataSingle(items, apiService, apiConf);
    }


 src/main/java/com/fzzy/async/fzzy40/impl/Fzzy40Sync1212.java

@@ -91,7 +91,7 @@
                    apiData.setYzbm(sysData.getYzbm());
                }
                apiData.setDzyx(StringUtils.isEmpty(sysData.getDzyx()) ? "" :sysData.getDzyx());
//                apiData.setKhfkhh(StringUtils.isEmpty(sysData.getBank()) ? "" :sysData.getBank());
                apiData.setKhfkhh(StringUtils.isEmpty(sysData.getBank()) ? "999" :sysData.getBank());
                apiData.setKhfzh(StringUtils.isEmpty(sysData.getBankNum()) ? "" :sysData.getBankNum());
                apiData.setZhgxsj(sysData.getUpdateTime() == null ? new Date() : sysData.getUpdateTime());
                apiData.setBizId(sysData.getId());

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

@@ -19,6 +19,7 @@
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.*;

/**
@@ -76,7 +77,6 @@
            ApiLog apiLog = new ApiLog();
            apiLog.setId(ContextUtil.getUUID());


            //若为财务1501、1502、1503接口，则接口编码填写1114
            if (SH2023Constant.SH_2023_API_CODE_1114_1501.equals(param.getInteId())
                    || SH2023Constant.SH_2023_API_CODE_1114_1502.equals(param.getInteId())
@@ -129,15 +129,7 @@

            //身份签名，使用自有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());
            }

            //使用区级平台公钥对数据进行RSA加密
            reqData.setData(ShRSAUtils.encryptByPubKey(jsonData, conf.getPublicKey()));
@@ -161,524 +153,325 @@
    }

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

        String inteId = param.getInteId();
        String kqdm = param.getKqdm();
        //查询库区信息行政区划码
        List<Api1102> api1102List = api1102Rep.findPushData(conf.getKqdm());
        try {
            if (null == conf) {
                conf = apiCommonService.getConf(kqdm);
            }

            //添加日志
            ApiLog apiLog = new ApiLog();
            apiLog.setId(ContextUtil.getUUID());
            apiLog.setInteId("1114");
            String jsonData = getJsonData(inteId, data, api1102List.get(0).getXzqhdm());
            log.info("接口数据信息=" + jsonData);

            if (StringUtils.isEmpty(inteId)) {
                ResponseDto responseDto = new ResponseDto(99, "没有获取到接口");
                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, "没有获取到上传配置");
                apiLog.setStatus(99);
                apiLog.setResult("没有获取到上传配置");
                apiLogRep.save(apiLog);
                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;
            }

            //封装推送数据
            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());

            //使用区级平台公钥对数据进行RSA加密
            reqData.setData(ShRSAUtils.encryptByPubKey(jsonData, conf.getPublicKey()));

            //摘要，数据主体的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());
            apiLogRep.save(apiLog);
            ResponseDto resd = new ResponseDto();
            resd.setSuccess(responseDto.getCode() == 200 ? 0 : responseDto.getCode());
            resd.setMsg(responseDto.getResult());

            return resd;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return new ResponseDto(99, e.getMessage());
        }
    }

    /**
     * 调整数据封装，获取json数据
     *
     * 转为JSON
     * @param inteId
     * @param data
     * @param code
     * @return
     * @throws Exception
     */
    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) {
        List<Object> list = new ArrayList<>();
        //具体根据接口进行封装
        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);
            for (Api1101 apiData : api1101List) {
                api1101 = new SH2023Api1101();
                BeanUtils.copyProperties(apiData, api1101);
                list.add(api1101);
            }
            return JSON.toJSONString(list);
            SH2023Api1101 api1101 = new SH2023Api1101();
            BeanUtils.copyProperties(data, api1101);

            //设置空属性为默认值
            changeObject(api1101);
            return api1101;
        }
        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);
            for (Api1102 apiData : api1101List) {
                api1102 = new SH2023Api1102();
                BeanUtils.copyProperties(apiData, api1102);
                list.add(api1102);
            }
            return JSON.toJSONString(list);
            SH2023Api1102 api1102 = new SH2023Api1102();
            BeanUtils.copyProperties(data, api1102);

            //设置空属性为默认值
            changeObject(api1102);
            return api1102;
        }
        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);
            for (Api1103 apiData : api1103List) {
                api1103 = new SH2023Api1103();
                BeanUtils.copyProperties(apiData, api1103);
                list.add(api1103);
            }
            return JSON.toJSONString(list);
            SH2023Api1103 api1103 = new SH2023Api1103();
            BeanUtils.copyProperties(data, api1103);

            //设置空属性为默认值
            changeObject(api1103);
            return api1103;
        }
        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();
            SH2023Api1104 api1104 = new SH2023Api1104();
            Api1104 apiData = (Api1104) data;
                BeanUtils.copyProperties(apiData, api1104);
                api1104.setAjdm(apiData.getAjdh());
                api1104.setCfdm(apiData.getCfbh());
                list.add(api1104);
            }
            return JSON.toJSONString(list);

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

            //设置空属性为默认值
            changeObject(api1105);
            return api1105;
        }
        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);
            SH2023Api1106 api1106 = new SH2023Api1106();
            BeanUtils.copyProperties(data, api1106);
                api1106.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1106);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1106);
            return api1106;
        }
        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);
            SH2023Api1107 api1107 = new SH2023Api1107();
            BeanUtils.copyProperties(data, api1107);
                api1107.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1107);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1107);
            return api1107;
        }
        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);
            SH2023Api1108 api1108 = new SH2023Api1108();
            BeanUtils.copyProperties(data, api1108);
                api1108.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1108);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1108);
            return api1108;
        }
        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();
            SH2023Api1109 api1109 = new SH2023Api1109();
            Api1109 apiData = (Api1109) data;
                BeanUtils.copyProperties(apiData, api1109);
                api1109.setBjw(ShAreaBjw.getBjw(code));

                api1109.setYwdh("无");

                map = new HashMap<>();
            Map<String, String> map = new HashMap<>();
                map.put(apiData.getWjmc(), FileUtils.fileToByteString(apiData.getWjdz()));
                api1109.setWjl(JSON.toJSONString(map));
                list.add(api1109);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1109);
            return api1109;
        }
        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();
            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());
                list.add(api1110);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1110);
            return api1110;
        }
        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);
            SH2023Api1111 api1111 = new SH2023Api1111();
            BeanUtils.copyProperties(data, api1111);
                api1111.setBjw(ShAreaBjw.getBjw(code));
                if (StringUtils.isEmpty(api1111.getBz())) {
                    api1111.setBz("无");
                }
                list.add(api1111);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1111);
            return api1111;
        }
        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);
            SH2023Api1112 api1112 = new SH2023Api1112();
            BeanUtils.copyProperties(data, api1112);
                api1112.setHdrychsj(api1112.getQdzgzchzyzgsj());
                api1112.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1112);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1112);
            return api1112;
        }
        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);
            SH2023Api1113 api1113 = new SH2023Api1113();
            BeanUtils.copyProperties(data, api1113);
                api1113.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1113);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1113);
            return api1113;
        }
        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);
            SH2023Api1201 api1201 = new SH2023Api1201();
            BeanUtils.copyProperties(data, api1201);
                api1201.setBjw(ShAreaBjw.getBjw(code));
                api1201.setHtsfzz("0");
                list.add(api1201);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1201);
            return api1201;
        }
        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();
            SH2023Api1202 api1202 = new SH2023Api1202();
            Api1202 apiData = (Api1202) data;
                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);

            //设置空属性为默认值
            changeObject(api1202);
            return api1202;
        }
        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();
            SH2023Api1203 api1203 = new SH2023Api1203();
            Api1203 apiData = (Api1203) data;
                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);
            //设置空属性为默认值
            changeObject(api1203);
            return api1203;
        }
        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();
            SH2023Api1204 api1204 = new SH2023Api1204();
            Api1204 apiData = (Api1204) data;
                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);

            //设置空属性为默认值
            changeObject(api1204);
            return api1204;
        }
        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();

            SH2023Api1205 api1205 = new SH2023Api1205();
            Api1205 apiData = (Api1205) data;
                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);

            //设置空属性为默认值
            changeObject(api1205);
            return api1205;
        }
        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();
            SH2023Api1206 api1206 = new SH2023Api1206();
            Api1206 apiData = (Api1206) data;
                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);

            //设置空属性为默认值
            changeObject(api1206);
            return api1206;
        }
        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();
            SH2023Api1207 api1207 = new SH2023Api1207();
            Api1207 apiData = (Api1207) data;
                BeanUtils.copyProperties(apiData, api1207);

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

                api1207.setPch(apiData.getDchwdm() +  DateFormatUtils.format(apiData.getDcrq(), "yyyy"));
                api1207.setKddh(apiData.getDcdh().substring(21,33));
                list.add(api1207);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1207);
            return api1207;
        }
        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();
            SH2023Api1208 api1208 = new SH2023Api1208();
            Api1208 apiData = (Api1208) data;
                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);

            //设置空属性为默认值
            changeObject(api1208);
            return api1208;
        }
        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);

            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());
                api1209.setBz("无");
                api1209.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getYwrq(), "yyyy"));
                list.add(api1209);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1209);
            return api1209;
        }
        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);
            SH2023Api1210 api1210 = new SH2023Api1210();
            Api1210 apiData = (Api1210) data;

            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);

            //设置空属性为默认值
            changeObject(api1210);
            return api1210;
        }
        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();
            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"));
                api1211.setZglkdm(apiData.getKqdm());
                if(StringUtils.isEmpty(api1211.getLldm())){
                    api1211.setLldm("无");
                }
                list.add(api1211);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1211);
            return api1211;
        }
        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);
            SH2023Api1212 api1212 = new SH2023Api1212();
            BeanUtils.copyProperties(data, api1212);
                api1212.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1212);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1212);
            return api1212;
        }
        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);
            SH2023Api1301 api1301 = new SH2023Api1301();
            BeanUtils.copyProperties(data, api1301);
                api1301.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1301);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1301);
            return api1301;
        }
        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();
            SH2023Api1302 api1302 = new SH2023Api1302();
            Api1302 apiData = (Api1302) data;
                BeanUtils.copyProperties(apiData, api1302);
                api1302.setBjw(ShAreaBjw.getBjw(code));
                api1302.setPch(apiData.getHwdm() + DateFormatUtils.format(apiData.getJcsj(), "yyyy"));
@@ -688,311 +481,186 @@
                api1302.setGfwjw(String.valueOf(apiData.getLspjw()));
                api1302.setLwmx(apiData.getLswdzjh());

                list.add(api1302);
            }
            return JSON.toJSONString(list);
            //设置空属性为默认值
            changeObject(api1302);
            return api1302;
        }
        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();
            SH2023Api1303 api1303 = new SH2023Api1303();
            Api1303 apiData = (Api1303) data;
                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);

            //设置空属性为默认值
            changeObject(api1303);
            return api1303;
        }
        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();
            SH2023Api1304 api1304 = new SH2023Api1304();
            Api1304 apiData = (Api1304) data;
                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);

            //设置空属性为默认值
            changeObject(api1304);
            return api1304;
        }
        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();
            SH2023Api1305 api1305 = new SH2023Api1305();
            Api1305 apiData = (Api1305) data;
                BeanUtils.copyProperties(apiData, api1305);
                api1305.setBjw(ShAreaBjw.getBjw(code));
                api1305.setAjdm(apiData.getTfzydh().substring(0, 28));
                list.add(api1305);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1305);
            return api1305;
        }
        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();
            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.getXzzydh().substring(0, 28));
                list.add(api1306);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1306);
            return api1306;
        }
        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();
            SH2023Api1307 api1307 = new SH2023Api1307();
            Api1307 apiData = (Api1307) data;
                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);
        }

            //设置空属性为默认值
            changeObject(api1307);
            return api1307;
        }
        if (SH2023Constant.SH_2023_API_CODE_1308.equals(inteId)) {
            SH2023Api1308 api1308;
            //最后转换为json
            List<SH2023Api1308> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1308> api1308List = castList(data, Api1308.class);
            for (Api1308 apiData : api1308List) {
                api1308 = new SH2023Api1308();
            SH2023Api1308 api1308 = new SH2023Api1308();
            Api1308 apiData = (Api1308) data;

                BeanUtils.copyProperties(apiData, api1308);
                //TODO 货位代码 图像编号 视频编号
                api1308.setHwdm("无");
                api1308.setBjw(ShAreaBjw.getBjw(code));
                List<Api1109> api1109List = api1109Rep.getDataByFileId(apiData.getFileStorageId());
                api1308.setTxbh(api1109List.get(0).getWjmc());
                api1308.setSpbh(api1109List.get(0).getWjmc());
                list.add(api1308);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1308);
            return api1308;
        }
        if (SH2023Constant.SH_2023_API_CODE_1309.equals(inteId)) {
            SH2023Api1309 api1309;
            //最后转换为json
            List<SH2023Api1309> list = new ArrayList<>();
            //把data转化成list集合
            List<Api1309> api1308List = castList(data, Api1309.class);
            for (Api1309 apiData : api1308List) {
                api1309 = new SH2023Api1309();

                BeanUtils.copyProperties(apiData, api1309);
            SH2023Api1309 api1309 = new SH2023Api1309();
            BeanUtils.copyProperties(data, api1309);
                api1309.setBjw(ShAreaBjw.getBjw(code));

                list.add(api1309);
            }
            return JSON.toJSONString(list);
            //设置空属性为默认值
            changeObject(api1309);
            return api1309;
        }
        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();
            SH2023Api1310 api1310 = new SH2023Api1310();
            Api1310 apiData = (Api1310) data;
                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());
                api1310.setLsxzdm("002");
                list.add(api1310);
            }
            return JSON.toJSONString(list);
            api1310.setLsxzdm("123");

            //设置空属性为默认值
            changeObject(api1310);
            return api1310;
        }
        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);
            SH2023Api1401 api1401 = new SH2023Api1401();
            BeanUtils.copyProperties(data, api1401);
                api1401.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1401);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1401);
            return api1401;
        }
        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);
            SH2023Api1402 api1402 = new SH2023Api1402();
            BeanUtils.copyProperties(data, api1402);
                api1402.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1402);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1402);
            return api1402;
        }
        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();
            SH2023Api1403 api1403 = new SH2023Api1403();
            Api1403 apiData = (Api1403) data;
                BeanUtils.copyProperties(apiData, api1403);
                api1403.setJhzxdw(apiData.getJhxddw());
                api1403.setJhzxdwmc(apiData.getJhxddwmc());
                api1403.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1403);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1403);
            return api1403;
        }
        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 明细状态
            SH2023Api1404 api1404 = new SH2023Api1404();
            BeanUtils.copyProperties(data, api1404);
                api1404.setMxzt("1");
                api1404.setBjw(ShAreaBjw.getBjw(code));
                list.add(api1404);
            }
            return JSON.toJSONString(list);

            //设置空属性为默认值
            changeObject(api1404);
            return api1404;
        }
        if (SH2023Constant.SH_2023_API_CODE_2101.equals(inteId)) {
            SH2023Api2101 api2101;
            //最后转换为json
            //把data转化成list集合
            List<SH2023Api2101> list = castList(data, SH2023Api2101.class);

            return JSON.toJSONString(list);
            return data;
        }

        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);
//            }
            List<SH2023Api2102> list = castList(data, SH2023Api2102.class);
            return JSON.toJSONString(list);
            return data;
        }
        if (SH2023Constant.SH_2023_API_CODE_2103.equals(inteId)) {
            SH2023Api2103 api2103;
            //最后转换为json
            //把data转化成list集合

            List<SH2023Api2103> list = castList(data, SH2023Api2103.class);
            List<SH2023Api2103Item> listItems = castList(list.get(0).getDlqplxq(), SH2023Api2103Item.class);
            list.get(0).setCzbz("i");
            list.get(0).setSh2023Api2103Items(listItems);
            return JSON.toJSONString(list);
            SH2023Api2103 api2103 = new SH2023Api2103();
            BeanUtils.copyProperties(data, api2103);
            List<SH2023Api2103Item> listItems = castList(api2103.getDlqplxq(), SH2023Api2103Item.class);
            api2103.setSh2023Api2103Items(listItems);
            return api2103;
        }
        if (SH2023Constant.SH_2023_API_CODE_2104.equals(inteId)) {
            SH2023Api2104 api2104;
            //最后转换为json
            //把data转化成list集合
            List<SH2023Api2104> list = castList(data, SH2023Api2104.class);

            return JSON.toJSONString(list);
            return data;
        }

        if (SH2023Constant.SH_2023_API_CODE_2203.equals(inteId)) {
            SH2023Api2203 api2203;
            //最后转换为json
//            List<SH2023Api2203> list = new ArrayList<>();
            //把data转化成list集合
            List<SH2023Api2203> list = castList(data, SH2023Api2203.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);
            return data;
        }


        if (SH2023Constant.SH_2023_API_CODE_2204.equals(inteId)) {
            SH2023Api2204 api2204;
            //最后转换为json
//            List<SH2023Api2204> list = new ArrayList<>();
            //把data转化成list集合
            List<SH2023Api2204> list = castList(data, SH2023Api2204.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);
            return data;
        }
        return data;
    }

    /**
     * 获取财务数据json
     *
     * @param inteId
     * @param data
     * @return
     */
    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);
            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);
    }

    /**
@@ -1208,11 +876,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);
@@ -1220,4 +884,33 @@
        shFinanceDto.setZbz2(zbz2);
        list.add(shFinanceDto);
    }

    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;
    }
}

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

@@ -75,15 +75,12 @@
        String[] interfaces = ids.split(";");
        for (String inteId : interfaces) {
            log.info("执行接口={}的数据上报", inteId);
            param.setInteId(inteId);
            getDataToPush(param, inteId);
        }

    }

    private void getDataToPush(ApiParam param, String inteId) {
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(inteId);

        switch (inteId) {
            case "1101":

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

@@ -9,10 +9,8 @@
import com.fzzy.api.service.PushService11;
import com.fzzy.api.view.repository.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
@@ -25,9 +23,6 @@
@Component
public class SH2023PushService11 implements PushService11 {


    @Autowired
    private SH2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1101Rep api1101Rep;
    @Autowired
@@ -115,17 +110,17 @@
            log.error("-----上海市平台2023版：未获取到单位信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1101);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1101 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1101Rep.save(data);
        ResponseDto responseDto;
        for (Api1101 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1101Rep.updateStatus(data.getDwdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -142,21 +137,20 @@
            log.error("-----上海市平台2023版：未获取到库区信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1102);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态

        ResponseDto responseDto;
            for (Api1102 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1102Rep.save(data);
                    api1102Rep.updateStatus(data.getKqdm(), Constant.CZBZ_U);
                }
            }
        }

    }

    /**
@@ -170,17 +164,16 @@
            log.error("-----上海市平台2023版：未获取到仓房信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1103);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1103 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1103Rep.save(data);
        ResponseDto responseDto;
        for (Api1103 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1103Rep.updateStatus(data.getCfdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -198,17 +191,17 @@
            log.error("-----上海市平台2023版：未获取到廒间信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1104);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {

        ResponseDto responseDto;
            //推送成功，更新数据上传状态
            for (Api1104 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1104Rep.save(data);
                    api1103Rep.updateStatus(data.getAjdh(), Constant.CZBZ_U);
                }
            }
        }
@@ -225,21 +218,19 @@
            log.error("-----上海市平台2023版：未获取到货位信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1105);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态

        ResponseDto responseDto;
            for (Api1105 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1105Rep.save(data);
                    api1105Rep.updateStatus(data.getHwdm(), Constant.CZBZ_U);
                }
            }
        }

    }

    /**
@@ -253,17 +244,16 @@
            log.error("-----上海市平台2023版：未获取到油罐信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1106);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1106 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1106Rep.save(data);
        ResponseDto responseDto;
        for (Api1106 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1106Rep.updateStatus(data.getYgdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -281,17 +271,18 @@
            log.error("-----上海市平台2023版：未获取到设备信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1107);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {

        ResponseDto responseDto;

            //推送成功，更新数据上传状态
            for (Api1107 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1107Rep.save(data);
                    api1107Rep.updateStatus(data.getSbbh(), Constant.CZBZ_U);
                }
            }
        }
@@ -309,21 +300,19 @@
            log.error("-----上海市平台2023版：未获取到药剂信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1108);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态

        ResponseDto responseDto;
            for (Api1108 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1108Rep.save(data);
                    api1108Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                }
            }
        }

    }

    /**
@@ -337,17 +326,16 @@
            log.error("-----上海市平台2023版：未获取到文件信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1109);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1109 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1109Rep.save(data);
        ResponseDto responseDto;
        for (Api1109 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1109Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                }
            }
        }
@@ -365,17 +353,16 @@
            log.error("-----上海市平台2023版：未获取到库区图仓房点位标注，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1110);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1110 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1110Rep.save(data);
        ResponseDto responseDto;
        for (Api1110 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1110Rep.updateStatus(data.getHwdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -393,17 +380,16 @@
            log.error("-----上海市平台2023版：未获取到库区图视频监控设备点位标注，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1111);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1111 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1111Rep.save(data);
        ResponseDto responseDto;
        for (Api1111 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1111Rep.updateStatus(data.getSpjksbid(), Constant.CZBZ_U);
                }
            }
        }
@@ -420,21 +406,20 @@
            log.error("-----上海市平台2023版：未获取到人员信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1112);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
        ResponseDto responseDto;

            //推送成功，更新数据上传状态
            for (Api1112 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1112Rep.save(data);
                    api1112Rep.updateStatus(data.getSfzhm(), Constant.CZBZ_U);
                }
            }
        }

    }

    /**
@@ -448,17 +433,16 @@
            log.error("-----上海市平台2023版：未获取到企业信用信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1113);
        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, list);
        if (responseDto.getSuccess() == 0) {
            //推送成功，更新数据上传状态
            for (Api1113 data : list) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1113Rep.save(data);
        ResponseDto responseDto;
        for (Api1113 data : list) {
            param.setBizId(data.getBizId());
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1113Rep.updateStatus(data.getDwdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -501,6 +485,7 @@
            }
        }
    }

    /**
     * 1502  财务报表-现金流
     */
@@ -526,6 +511,7 @@
            }
        }
    }

    /**
     * 1503  财务报表-利润信息
     */

 src/main/java/com/fzzy/push/sh2023/dto/SH2023Api1212.java

@@ -9,7 +9,7 @@
import java.util.Date;

/**
 * 接口表-粮食库存信息
 * 接口表-客户信息
 */
@Data
@EqualsAndHashCode(callSuper = false)
@@ -41,31 +41,31 @@
    private String khmc;

    @PropertyDef(label = "法定代表人")
    private String fddbr;
    private String fddbr = "无";

    @PropertyDef(label = "通讯地址")
    private String txdz;
    private String txdz = "无";

    @PropertyDef(label = "邮政编码")
    private String yzbm;
    private String yzbm = "无";

    @PropertyDef(label = "联系人姓名")
    private String lxrxm;
    private String lxrxm = "无";

    @PropertyDef(label = "联系电话")
    private String lxrdh;
    private String lxrdh = "无";

    @PropertyDef(label = "联系人身份证号")
    private String lxrsfzh;
    private String lxrsfzh = "无";

    @PropertyDef(label = "电子信箱")
    private String dzyx;
    private String dzyx = "1";

    @PropertyDef(label = "客户方开户行")
    private String khfkhh;
    private String khfkhh = "999";

    @PropertyDef(label = "客户方账号")
    private String khfzh;
    private String khfzh = "0";

    @PropertyDef(label = "操作标志")
    private String czbz;