调整广东省平台市局推送-增加指令推送，测试使用

czt

2024-04-22 f3d2007e78e8df1064ee7a3b4b9b4c790717fba7

调整广东省平台市局推送-增加指令推送，测试使用

 src/main/java/com/fzzy/api/Constant.java

@@ -203,9 +203,9 @@
    public static String API_CODE_1405 = "1405";

    //财务报表接口
    public static String API_CODE_1501 = "1501";
    public static String API_CODE_1502 = "1502";
    public static String API_CODE_1503 = "1503";
    public static String API_CODE_1114_1501 = "1501";
    public static String API_CODE_1114_1502 = "1502";
    public static String API_CODE_1114_1503 = "1503";
    /**
     * å›½æ ‡å‡ºå…¥åº“类型
     */

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

@@ -124,7 +124,7 @@
        String result = "";

        //封装参数
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1501);
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1114_1501);
        Api1501 d;
        for (Api1501 data : items) {
            d = new Api1501();
@@ -153,7 +153,7 @@
    private String pushDataList(List<Api1501> items, ApiRemoteService apiRemoteService, ApiConfs apiConf) {

        //封装参数
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1501);
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1114_1501);

        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, apiConf, items);

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

@@ -122,7 +122,7 @@
        String result = "";

        //封装参数
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1502);
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1114_1502);
        Api1502 d;
        for (Api1502 data : items) {
            d = new Api1502();
@@ -151,7 +151,7 @@
    private String pushDataList(List<Api1502> items, ApiRemoteService apiRemoteService, ApiConfs apiConf) {

        //封装参数
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1502);
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1114_1502);

        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, apiConf, items);

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

@@ -4,21 +4,17 @@
import com.bstek.dorado.annotation.DataResolver;
import com.bstek.dorado.annotation.Expose;
import com.fzzy.api.data.ApiParam;
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.dto.ResponseDto;
import com.fzzy.api.entity.Api1503;
import com.fzzy.api.entity.ApiParent;
import com.fzzy.api.view.repository.Api1503Rep;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
@@ -124,7 +120,7 @@
        String result = "";

        //封装参数
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1503);
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1114_1503);
        Api1503 d;
        for (Api1503 data : items) {
            d = new Api1503();
@@ -153,7 +149,7 @@
    private String pushDataList(List<Api1503> items, ApiRemoteService apiRemoteService, ApiConfs apiConf) {

        //封装参数
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1503);
        ApiParam param = new ApiParam(apiConf, Constant.API_CATEGORY_11, Constant.API_CODE_1114_1503);

        //推送，数据为集合形式
        ResponseDto responseDto = apiRemoteService.pushData(param, apiConf, items);

 src/main/java/com/fzzy/push/gd2022/GD2022ApiRemoteService2022.java

@@ -70,9 +70,9 @@

    @Override
    public ResponseDto pushData(ApiParam param, ApiConfs conf, Object data) {
        if (Constant.API_CODE_1501.equals(param.getInteId())
                || Constant.API_CODE_1502.equals(param.getInteId())
                || Constant.API_CODE_1503.equals(param.getInteId())) {
        if (Constant.API_CODE_1114_1501.equals(param.getInteId())
                || Constant.API_CODE_1114_1502.equals(param.getInteId())
                || Constant.API_CODE_1114_1503.equals(param.getInteId())) {
            return pushFinanceData(param, conf, data);
        }

@@ -193,11 +193,11 @@
            }

            List<GDFinanceDto> list = null;
            if (Constant.API_CODE_1501.equals(param.getInteId())) {
            if (Constant.API_CODE_1114_1501.equals(param.getInteId())) {
                list = copyApi1501((Api1501) data);
            } else if (Constant.API_CODE_1502.equals(param.getInteId())) {
            } else if (Constant.API_CODE_1114_1502.equals(param.getInteId())) {
                list = copyApi1502((Api1502) data);
            } else if (Constant.API_CODE_1503.equals(param.getInteId())) {
            } else if (Constant.API_CODE_1114_1503.equals(param.getInteId())) {
                list = copyApi1503((Api1503) data);
            }
            GD2022ResponseDto responseDto;

 src/main/java/com/fzzy/push/gd2022/GD2022OrderApiServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,209 @@
package com.fzzy.push.gd2022;

import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.entity.ApiConfs;
import com.fzzy.order.OrderApiService;
import com.fzzy.order.data.OrderConstant;
import com.fzzy.order.data.OrderData;
import com.fzzy.push.impl.ComPushService11;
import com.fzzy.push.impl.ComPushService12;
import com.fzzy.push.impl.ComPushService13;
import com.fzzy.push.impl.ComPushService14;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.ParseException;

/**
 * å¹¿ä¸œçœå¹³å°æŒ‡ä»¤ä¸ŠæŠ¥-仅测试使用
 *
 * @author czt
 * @date 2024/04/22
 */
@Slf4j
@Service
public class GD2022OrderApiServiceImpl implements OrderApiService {

    @Autowired
    private GD2022ApiRemoteService2022 apiRemoteService;
    @Autowired
    private ComPushService11 pushService11;
    @Autowired
    private ComPushService12 pushService12;
    @Autowired
    private ComPushService13 pushService13;
    @Autowired
    private ComPushService14 pushService14;

    @Override
    public String getProtocol() {
        return PushProtocol.SB_GD_2022.getCode();
    }


    @Override
    public void execute(OrderData req, String orderType, ApiConfs conf, String orderid) throws ParseException {

        // è‹¥æŒ‡ä»¤ç±»åž‹ä¸ä¸º1，则返回
        if(!OrderConstant.ORDER_TYPE_1.equals(orderType)){
            log.error("指令类型不为1，不进行数据上报={}", req);
            return;
        }
        String ids = req.getContent();
        if(StringUtils.isEmpty(ids)){
            log.error("指令接口为空，不进行数据上报={}", req);
            return;
        }

        ApiParam param = new ApiParam();
        param.setPushProtocol(conf.getPushProtocol());
        param.setKqdm(conf.getKqdm());
        param.setStart(DateUtils.parseDate(req.getStarttime(), new String[]{"yyyy-MM-dd HH:mm:ss"}));
        param.setEnd(DateUtils.parseDate(req.getEndtime(), new String[]{"yyyy-MM-dd HH:mm:ss"}));
        param.setDeptId(conf.getDeptId());

        log.info("接收的指令中接口内容为={}", req.getContent());
        String[] interfaces = ids.split(";");
        for (String inteId : interfaces) {
            log.info("执行接口={}的数据上报", inteId);
//            getDataToPush(param, inteId);
        }

    }

    private void getDataToPush(ApiParam param, String inteId) {

        switch (inteId) {
            case "1101":
                pushService11.pushData1101(apiRemoteService, param);
                break;
            case "1102":
                pushService11.pushData1102(apiRemoteService, param);
                break;
            case "1103":
                pushService11.pushData1103(apiRemoteService, param);
                break;
            case "1104":
                pushService11.pushData1104(apiRemoteService, param);
                break;
            case "1105":
                pushService11.pushData1105(apiRemoteService, param);
                break;
            case "1106":
                pushService11.pushData1106(apiRemoteService, param);
                break;
            case "1107":
                pushService11.pushData1107(apiRemoteService, param);
                break;
            case "1108":
                pushService11.pushData1108(apiRemoteService, param);
                break;
            case "1109":
                pushService12.pushData1109(apiRemoteService, param);
                break;
            case "1110":
                pushService11.pushData1110(apiRemoteService, param);
                break;
            case "1111":
                pushService11.pushData1111(apiRemoteService, param);
                break;
            case "1112":
                pushService11.pushData1112(apiRemoteService, param);
                break;
            case "1113":
                pushService11.pushData1113(apiRemoteService, param);
                break;
            case "1114":
                pushService11.pushData1114(apiRemoteService, param);
                break;
            case "1201":
                pushService12.pushData1201(apiRemoteService, param);
                break;
            case "1202":
                pushService12.pushData1202(apiRemoteService, param);
                break;
            case "1203":
                pushService12.pushData1203(apiRemoteService, param);
                break;
            case "1204":
                pushService12.pushData1204(apiRemoteService, param);
                break;
            case "1205":
                pushService12.pushData1205(apiRemoteService, param);
                break;
            case "1206":
                pushService12.pushData1206(apiRemoteService, param);
                break;
            case "1207":
                pushService12.pushData1207(apiRemoteService, param);
                break;
            case "1208":
                pushService12.pushData1208(apiRemoteService, param);
                break;
            case "1209":
                pushService12.pushData1209(apiRemoteService, param);
                break;
            case "1210":
                pushService12.pushData1210(apiRemoteService, param);
                break;
            case "1211":
                pushService12.pushData1211(apiRemoteService, param);
                break;
            case "1212":
                pushService12.pushData1212(apiRemoteService, param);
                break;
            case "1301":
                pushService13.pushData1301(apiRemoteService, param);
                break;
            case "1302":
                pushService13.pushData1302(apiRemoteService, param);
                break;
            case "1303":
                pushService13.pushData1303(apiRemoteService, param);
                break;
            case "1304":
                pushService13.pushData1304(apiRemoteService, param);
                break;
            case "1305":
                pushService13.pushData1305(apiRemoteService, param);
                break;
            case "1306":
                pushService13.pushData1306(apiRemoteService, param);
                break;
            case "1307":
                pushService13.pushData1307(apiRemoteService, param);
                break;
            case "1308":
                pushService13.pushData1308(apiRemoteService, param);
                break;
            case "1309":
                pushService13.pushData1309(apiRemoteService, param);
                break;
            case "1310":
                pushService13.pushData1310(apiRemoteService, param);
                break;
            case "1401":
                pushService14.pushData1401(apiRemoteService, param);
                break;
            case "1402":
                pushService14.pushData1402(apiRemoteService, param);
                break;
            case "1403":
                pushService14.pushData1403(apiRemoteService, param);
                break;
            case "1404":
                log.error("-----广东省平台：计划明细跟随计划推送-----");
                break;
            case "1405":
                pushService14.pushData1405(apiRemoteService, param);
                break;
            default:
                log.error("-----广东省平台：未匹配到接口编码，不推送-----");
                break;
        }
    }
}

 src/main/java/com/fzzy/push/gd2022/GD2022PushService11.java

@@ -57,8 +57,9 @@
        pushService.pushData1112(apiRemoteService, param);
        //企业信用信息
        pushService.pushData1113(apiRemoteService, param);

        //文件信息推送，转移到12大类进行推送
    }

        //财务报表数据推送
        pushService.pushData1114(apiRemoteService, param);
    }
}

 src/main/java/com/fzzy/push/gd2022/GD2022PushService13.java

@@ -31,6 +31,7 @@

    @Override
    public void pushData(ApiParam param) {
        pushService.pushData1301(apiRemoteService, param);
        //粮情
        pushService.pushData1302(apiRemoteService, param);

@@ -40,9 +41,6 @@
        //虫害
        pushService.pushData1303(apiRemoteService, param);

        //质检
        pushService.pushData1310(apiRemoteService, param);

        //通风
        pushService.pushData1305(apiRemoteService, param);

@@ -50,6 +48,13 @@
        pushService.pushData1306(apiRemoteService, param);
        //熏蒸
        pushService.pushData1307(apiRemoteService, param);

        pushService.pushData1308(apiRemoteService, param);

        pushService.pushData1309(apiRemoteService, param);

        //质检
        pushService.pushData1310(apiRemoteService, param);
    }

}

 src/main/java/com/fzzy/push/gd2022/GD2022PushService14.java

@@ -30,11 +30,14 @@

    @Override
    public void pushData(ApiParam param) {

        pushService.pushData1401(apiRemoteService, param);

        pushService.pushData1402(apiRemoteService, param);
        //轮换计划
        pushService.pushData1403(apiRemoteService, param);

        //轮换计划明细
        pushService.pushData1404(apiRemoteService, param);
        pushService.pushData1405(apiRemoteService, param);
    }



 src/main/java/com/fzzy/push/gd2022/GD2022PushService15.java

ÎļþÒÑɾ³ý

 src/main/java/com/fzzy/push/impl/ComPushService11.java

@@ -6,6 +6,7 @@
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.view.repository.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@@ -16,6 +17,7 @@
 * @author: andy.jia
 * @update-time: 2022/10/28 2:02
 */
@Slf4j
@Service
public class ComPushService11 {

@@ -43,6 +45,12 @@
    private Api1112Rep api1112Rep;
    @Autowired
    private Api1113Rep api1113Rep;
    @Autowired
    private Api1501Rep api1501Rep;
    @Autowired
    private Api1502Rep api1502Rep;
    @Autowired
    private Api1503Rep api1503Rep;
    /**
     * 1101 å•ä½ä¿¡æ¯
     */
@@ -50,8 +58,10 @@

        List<Api1101> items = api1101Rep.getDataByTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到单位信息，不推送-----");
            return;
        }


        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(Constant.API_CODE_1101);
@@ -76,6 +86,7 @@

        List<Api1102> items = api1102Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到库区信息，不推送-----");
            return;
        }

@@ -102,6 +113,7 @@

        List<Api1103> items = api1103Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到仓房信息，不推送-----");
            return;
        }

@@ -115,8 +127,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    data.setCzbz("u");
                    api1103Rep.save(data);
                    api1103Rep.updateStatus(data.getCfdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -129,6 +140,7 @@

        List<Api1104> items = api1104Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到廒间信息，不推送-----");
            return;
        }

@@ -142,8 +154,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    data.setCzbz("u");
                    api1104Rep.save(data);
                    api1104Rep.updateStatus(data.getAjdh(), Constant.CZBZ_U);
                }
            }
        }
@@ -156,6 +167,7 @@

        List<Api1105> items = api1105Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到货位信息，不推送-----");
            return;
        }

@@ -169,8 +181,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    data.setCzbz("u");
                    api1105Rep.save(data);
                    api1105Rep.updateStatus(data.getHwdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -183,6 +194,7 @@

        List<Api1106> items = api1106Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到油罐信息，不推送-----");
            return;
        }

@@ -196,8 +208,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    data.setCzbz("u");
                    api1106Rep.save(data);
                    api1106Rep.updateStatus(data.getYgdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -210,6 +221,7 @@

        List<Api1107> items = api1107Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到设备信息，不推送-----");
            return;
        }

@@ -223,7 +235,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1107Rep.updateStatus(data.getDwdm(), Constant.CZBZ_U);
                    api1107Rep.updateStatus(data.getSbbh(), Constant.CZBZ_U);
                }
            }
        }
@@ -236,6 +248,7 @@

        List<Api1108> items = api1108Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到药剂信息，不推送-----");
            return;
        }

@@ -249,8 +262,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    data.setCzbz("u");
                    api1108Rep.save(data);
                    api1108Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                }
            }
        }
@@ -263,6 +275,7 @@

        List<Api1110> items = api1110Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到库区图仓房点位标注，不推送-----");
            return;
        }

@@ -276,8 +289,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    data.setCzbz("u");
                    api1110Rep.save(data);
                    api1110Rep.updateStatus(data.getHwdm(), Constant.CZBZ_U);
                }
            }
        }
@@ -290,6 +302,7 @@

        List<Api1111> items = api1111Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到库区图视频监控设备点位标注，不推送-----");
            return;
        }

@@ -317,6 +330,7 @@

        List<Api1112> items = api1112Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到人员信息，不推送-----");
            return;
        }

@@ -344,6 +358,7 @@

        List<Api1113> items = api1113Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());
        if (null == items || items.isEmpty()) {
            log.error("-----未获取到企业信用信息，不推送-----");
            return;
        }

@@ -363,4 +378,97 @@
            }
        }
    }

    /**
     * è´¢åŠ¡æŠ¥è¡¨
     * @param apiRemoteService
     * @param param
     */
    public void pushData1114(ApiRemoteService apiRemoteService, ApiParam param) {
        this.pushData1501(apiRemoteService, param);
        this.pushData1502(apiRemoteService, param);
        this.pushData1503(apiRemoteService, param);

    }
    /**
     * 1501  è´¢åŠ¡æŠ¥è¡¨-资产负债--单条上传
     */
    public void pushData1501(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1501> list = api1501Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----未获取到资产负债信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(Constant.API_CODE_1114_1501);
        ResponseDto responseDto;
        for (Api1501 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1501Rep.save(data);
                }
            }
        }
    }

    /**
     * 1502  è´¢åŠ¡æŠ¥è¡¨-现金流
     */
    public void pushData1502(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1502> list = api1502Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----未获取到现金流信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(Constant.API_CODE_1114_1502);
        ResponseDto responseDto;
        for (Api1502 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1502Rep.save(data);
                }
            }
        }
    }

    /**
     * 1503  è´¢åŠ¡æŠ¥è¡¨-利润信息
     */
    public void pushData1503(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1503> list = api1503Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----未获取到利润信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(Constant.API_CODE_1114_1503);
        ResponseDto responseDto;
        Api1503 d;
        for (Api1503 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1503Rep.save(data);
                }
            }
        }
    }
}

 src/main/java/com/fzzy/push/impl/ComPushService12.java

@@ -70,7 +70,7 @@

            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {
                    api1201Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                    api1109Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                }
            }
        }

 src/main/java/com/fzzy/push/impl/ComPushService13.java

@@ -6,11 +6,9 @@
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.shjdjw2023.ShjdjwApiRemoteService2023;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
@@ -42,7 +40,37 @@
    private Api1309Rep apiRep1309;
    @Autowired
    private Api1310Rep apiRep1310;
    @Autowired
    private ApiInfoDataRep apiInfoDataRep;


    public void pushData1301(ApiRemoteService apiRemoteService, ApiParam param) {

        //获取需要推送的数据
        List<Api1301> items = apiRep1301.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == items || items.isEmpty()) {
            log.info("-------------没有安全信息数据需要推送-----------");
            return;
        }

        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(Constant.API_CODE_1301);

        ResponseDto responseDto;

        for (Api1301 data : items) {
            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);
                    apiRep1301.save(data);
                }
            }
        }
    }

    public void pushData1302(ApiRemoteService apiRemoteService, ApiParam param) {

@@ -82,7 +110,7 @@
        }

        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(Constant.API_CODE_1302);
        param.setInteId(Constant.API_CODE_1303);

        ResponseDto responseDto;

@@ -108,7 +136,7 @@
        }

        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(Constant.API_CODE_1302);
        param.setInteId(Constant.API_CODE_1304);

        ResponseDto responseDto;


 src/main/java/com/fzzy/push/impl/ComPushService14.java

@@ -3,12 +3,9 @@
import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.Api1403;
import com.fzzy.api.entity.Api1404;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.view.repository.Api1403Rep;
import com.fzzy.api.view.repository.Api1404Rep;
import com.fzzy.push.gd2020.GDApiRemoteService;
import com.fzzy.api.view.repository.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -24,13 +21,72 @@
@Service
public class ComPushService14 {


    @Autowired
    private Api1401Rep api1401Rep;
    @Autowired
    private Api1402Rep api1402Rep;
    @Autowired
    private Api1403Rep api1403Rep;

    @Autowired
    private Api1404Rep api1404Rep;
    @Autowired
    private Api1405Rep api1405Rep;


    public void pushData1401(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取需要推送的数据
        List<Api1401> items = api1401Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == items || items.isEmpty()) {
            log.info("-------------没有轮换计划需要推送-----------");
            return;
        }

        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(Constant.API_CODE_1401);

        ResponseDto responseDto;

        for (Api1401 data : items) {
            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);
                    api1401Rep.save(data);
                }
            }
        }
    }

    public void pushData1402(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取需要推送的数据
        List<Api1402> items = api1402Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == items || items.isEmpty()) {
            log.info("-------------没有轮换计划需要推送-----------");
            return;
        }

        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(Constant.API_CODE_1402);

        ResponseDto responseDto;

        for (Api1402 data : items) {
            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);
                    api1402Rep.save(data);
                }
            }
        }
    }

    public void pushData1403(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取需要推送的数据
@@ -83,4 +139,31 @@
            }
        }
    }

    public void pushData1405(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取需要推送的数据
        List<Api1405> items = api1405Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == items || items.isEmpty()) {
            log.info("-------------没有轮换计划需要推送-----------");
            return;
        }

        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(Constant.API_CODE_1403);

        ResponseDto responseDto;

        for (Api1405 data : items) {
            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);
                    api1405Rep.save(data);
                }
            }
        }
    }
}

 src/main/java/com/fzzy/push/impl/ComPushService99.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,138 @@
package com.fzzy.push.impl;

import com.alibaba.fastjson.JSONObject;
import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.ApiInfoData;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.view.repository.ApiInfoDataRep;
import com.fzzy.push.sh2023.SH2023Constant;
import com.fzzy.push.sh2023.dto.SH2023Api1311;
import com.fzzy.push.sh2023.dto.SH2023Api2103;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description å„省省平台定制接口
 * @Author CZT
 * @Date 2024/4/22 15:31
 */
@Slf4j
@Service
public class ComPushService99 {
    @Autowired
    private ApiInfoDataRep apiInfoDataRep;

    /*==========上海市平台定制接口==========*/
    /**
     * 2101 æ£€æ–¤å•--上海市平台
     */
    public void pushData2101(ApiRemoteService apiRemoteService, ApiParam param) {
        log.error("-----上海市平台2023版：定化水检验暂未实现，不推送-----");
        //TODO

    }

    /**
     * 2102 å€’仓倒入--上海市平台
     */
    public void pushData2102(ApiRemoteService apiRemoteService, ApiParam param) {
        log.error("-----上海市平台2023版：定化水检验暂未实现，不推送-----");
        //TODO

    }

    /**
     * 2104  å¸‚储驳运单--上海市平台
     */
    public void pushData2104(ApiRemoteService apiRemoteService, ApiParam param) {
        log.error("-----上海市平台2023版：定化水检验暂未实现，不推送-----");
        //TODO

    }


    /**
     * 1311 è§†é¢‘监控接口--上海市平台
     */
    public void pushData1311(ApiRemoteService apiRemoteService, ApiParam param) {
        // èŽ·å– è§†é¢‘监控接口数据
        List<ApiInfoData> items = apiInfoDataRep.getDataByInteId(SH2023Constant.SH_2023_API_CODE_1311);

        if (null == items || items.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到视频监控，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1311);

        SH2023Api1311 shApi1311;
        ResponseDto responseDto;
        for (ApiInfoData infoData : items) {
            shApi1311 = JSONObject.parseObject(infoData.getData(), SH2023Api1311.class);
            shApi1311.setZhgxsj(infoData.getUpdateTime());

            param.setBizId(infoData.getDataId());
            responseDto = apiRemoteService.pushData(param, shApi1311);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(infoData.getCzbz())) {
                    infoData.setCzbz(Constant.CZBZ_U);
                    apiInfoDataRep.save(infoData);
                }
            }
        }
    }

    /**
     * 2103 ç²®æƒ…设备配置--上海市平台
     */
    public void pushData2103(ApiRemoteService apiRemoteService, ApiParam param) {

        // èŽ·å–粮情设备配置数据
        List<ApiInfoData> items = apiInfoDataRep.getDataByInteId(SH2023Constant.SH_2023_API_CODE_2103);

        if (null == items || items.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮情设备配置，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_2103);

        SH2023Api2103 shApi2103;
        ResponseDto responseDto;
        for (ApiInfoData infoData : items) {
            shApi2103 = JSONObject.parseObject(infoData.getData(), SH2023Api2103.class);
            shApi2103.setZhgxsj(infoData.getUpdateTime());
            param.setBizId(infoData.getDataId());
            responseDto = apiRemoteService.pushData(param, shApi2103);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(infoData.getCzbz())) {

                    infoData.setCzbz(Constant.CZBZ_U);
                    apiInfoDataRep.save(infoData);
                }
            }
        }
    }

    /**
     * 2203 äº¤æ˜“中心合同
     */
    public void pushData2203(ApiRemoteService apiRemoteService, ApiParam param) {
        log.error("-----上海市平台2023版：定化水检验暂未实现，不推送-----");
        //TODO
    }

    /**
     * 2204 å®šåŒ–水检验
     */
    public void pushData2204(ApiRemoteService apiRemoteService, ApiParam param) {
        log.error("-----上海市平台2023版：定化水检验暂未实现，不推送-----");
        //TODO

    }
}

 src/main/java/com/fzzy/push/nx2023/NX2023OrderApiServiceImpl.java

@@ -8,6 +8,10 @@
import com.fzzy.order.OrderApiService;
import com.fzzy.order.data.OrderConstant;
import com.fzzy.order.data.OrderData;
import com.fzzy.push.impl.ComPushService11;
import com.fzzy.push.impl.ComPushService12;
import com.fzzy.push.impl.ComPushService13;
import com.fzzy.push.impl.ComPushService14;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
@@ -30,13 +34,13 @@
    @Autowired
    private NX2023ApiRemoteService apiRemoteService;
    @Autowired
    private NX2023PushService11 nX2023PushService11;
    private ComPushService11 pushService11;
    @Autowired
    private NX2023PushService12 nX2023PushService12;
    private ComPushService12 pushService12;
    @Autowired
    private NX2023PushService13 nX2023PushService13;
    private ComPushService13 pushService13;
    @Autowired
    private NX2023PushService14 nX2023PushService14;
    private ComPushService14 pushService14;

    @Override
    public String getProtocol() {
@@ -81,115 +85,115 @@
    private void getDataToPush(ApiParam param, String inteId) {
        switch (inteId) {
            case "1101":
                nX2023PushService11.pushData1101(apiRemoteService, param);
                pushService11.pushData1101(apiRemoteService, param);
                break;
            case "1102":
                nX2023PushService11.pushData1102(apiRemoteService, param);
                pushService11.pushData1102(apiRemoteService, param);
                break;
            case "1103":
                nX2023PushService11.pushData1103(apiRemoteService, param);
                pushService11.pushData1103(apiRemoteService, param);
                break;
            case "1104":
                nX2023PushService11.pushData1104(apiRemoteService, param);
                pushService11.pushData1104(apiRemoteService, param);
                break;
            case "1105":
                nX2023PushService11.pushData1105(apiRemoteService, param);
                pushService11.pushData1105(apiRemoteService, param);
                break;
            case "1106":
                nX2023PushService11.pushData1106(apiRemoteService, param);
                pushService11.pushData1106(apiRemoteService, param);
                break;
            case "1107":
                nX2023PushService11.pushData1107(apiRemoteService, param);
                pushService11.pushData1107(apiRemoteService, param);
                break;
            case "1108":
                nX2023PushService11.pushData1108(apiRemoteService, param);
                pushService11.pushData1108(apiRemoteService, param);
                break;
            case "1109":
                nX2023PushService12.pushData1109(apiRemoteService, param);
                pushService12.pushData1109(apiRemoteService, param);
                break;
            case "1110":
                nX2023PushService11.pushData1110(apiRemoteService, param);
                pushService11.pushData1110(apiRemoteService, param);
                break;
            case "1111":
                nX2023PushService11.pushData1111(apiRemoteService, param);
                pushService11.pushData1111(apiRemoteService, param);
                break;
            case "1112":
                nX2023PushService11.pushData1112(apiRemoteService, param);
                pushService11.pushData1112(apiRemoteService, param);
                break;
            case "1114":
                nX2023PushService11.pushData1114(apiRemoteService, param);
                pushService11.pushData1114(apiRemoteService, param);
                break;
            case "1201":
                nX2023PushService12.pushData1201(apiRemoteService, param);
                pushService12.pushData1201(apiRemoteService, param);
                break;
            case "1202":
                nX2023PushService12.pushData1202(apiRemoteService, param);
                pushService12.pushData1202(apiRemoteService, param);
                break;
            case "1203":
                nX2023PushService12.pushData1203(apiRemoteService, param);
                pushService12.pushData1203(apiRemoteService, param);
                break;
            case "1204":
                nX2023PushService12.pushData1204(apiRemoteService, param);
                pushService12.pushData1204(apiRemoteService, param);
                break;
            case "1205":
                nX2023PushService12.pushData1205(apiRemoteService, param);
                pushService12.pushData1205(apiRemoteService, param);
                break;
            case "1206":
                nX2023PushService12.pushData1206(apiRemoteService, param);
                pushService12.pushData1206(apiRemoteService, param);
                break;
            case "1207":
                nX2023PushService12.pushData1207(apiRemoteService, param);
                pushService12.pushData1207(apiRemoteService, param);
                break;
            case "1208":
                nX2023PushService12.pushData1208(apiRemoteService, param);
                pushService12.pushData1208(apiRemoteService, param);
                break;
            case "1209":
                nX2023PushService12.pushData1209(apiRemoteService, param);
                pushService12.pushData1209(apiRemoteService, param);
                break;
            case "1210":
                nX2023PushService12.pushData1210(apiRemoteService, param);
                pushService12.pushData1210(apiRemoteService, param);
                break;
            case "1211":
                nX2023PushService12.pushData1211(apiRemoteService, param);
                pushService12.pushData1211(apiRemoteService, param);
                break;
            case "1212":
                nX2023PushService12.pushData1212(apiRemoteService, param);
                pushService12.pushData1212(apiRemoteService, param);
                break;
            case "1301":
                nX2023PushService13.pushData1301(apiRemoteService, param);
                pushService13.pushData1301(apiRemoteService, param);
                break;
            case "1302":
                nX2023PushService13.pushData1302(apiRemoteService, param);
                pushService13.pushData1302(apiRemoteService, param);
                break;
            case "1303":
                nX2023PushService13.pushData1303(apiRemoteService, param);
                pushService13.pushData1303(apiRemoteService, param);
                break;
            case "1304":
                nX2023PushService13.pushData1304(apiRemoteService, param);
                pushService13.pushData1304(apiRemoteService, param);
                break;
            case "1305":
                nX2023PushService13.pushData1305(apiRemoteService, param);
                pushService13.pushData1305(apiRemoteService, param);
                break;
            case "1306":
                nX2023PushService13.pushData1306(apiRemoteService, param);
                pushService13.pushData1306(apiRemoteService, param);
                break;
            case "1307":
                nX2023PushService13.pushData1307(apiRemoteService, param);
                pushService13.pushData1307(apiRemoteService, param);
                break;
            case "1308":
                nX2023PushService13.pushData1308(apiRemoteService, param);
                pushService13.pushData1308(apiRemoteService, param);
                break;
            case "1309":
                nX2023PushService13.pushData1309(apiRemoteService, param);
                pushService13.pushData1309(apiRemoteService, param);
                break;
            case "1310":
                nX2023PushService13.pushData1310(apiRemoteService, param);
                pushService13.pushData1310(apiRemoteService, param);
                break;
            case "1403":
                nX2023PushService14.pushData1403(apiRemoteService, param);
                pushService14.pushData1403(apiRemoteService, param);
                break;
            case "1404":
                nX2023PushService14.pushData1404(apiRemoteService, param);
                pushService14.pushData1404(apiRemoteService, param);
                break;
            default:
                log.error("-----宁夏省平台：未匹配到接口编码，不推送-----");

 src/main/java/com/fzzy/push/nx2023/NX2023PushService11.java

@@ -1,17 +1,12 @@
package com.fzzy.push.nx2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService11;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService11;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * å®å¤çœå¹³å°2023版-基础数据上传
@@ -26,34 +21,7 @@
    @Autowired
    private NX2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1101Rep api1101Rep;
    @Autowired
    private Api1102Rep api1102Rep;
    @Autowired
    private Api1103Rep api1103Rep;
    @Autowired
    private Api1104Rep api1104Rep;
    @Autowired
    private Api1105Rep api1105Rep;
    @Autowired
    private Api1106Rep api1106Rep;
    @Autowired
    private Api1107Rep api1107Rep;
    @Autowired
    private Api1108Rep api1108Rep;

    @Autowired
    private Api1110Rep api1110Rep;
    @Autowired
    private Api1111Rep api1111Rep;
    @Autowired
    private Api1112Rep api1112Rep;
    @Autowired
    private Api1501Rep api1501Rep;
    @Autowired
    private Api1502Rep api1502Rep;
    @Autowired
    private Api1503Rep api1503Rep;
    private ComPushService11 pushService11;

    @Override
    public String getProtocol() {
@@ -63,424 +31,39 @@
    @Override
    public void pushData(ApiParam param) {

        log.info("------->>>>上海2023接口不主动上报");
        log.info("------->>>>宁夏2023接口主动上报");

        //推送单位信息
        this.pushData1101(apiRemoteService, param);
        //单位信息
        pushService11.pushData1101(apiRemoteService, param);
        //库区信息
        this.pushData1102(apiRemoteService, param);
        pushService11.pushData1102(apiRemoteService, param);
        //仓房信息
        this.pushData1103(apiRemoteService, param);
        pushService11.pushData1103(apiRemoteService, param);
        //廒间信息
        this.pushData1104(apiRemoteService, param);
        pushService11.pushData1104(apiRemoteService, param);
        //货位信息
        this.pushData1105(apiRemoteService, param);
        pushService11.pushData1105(apiRemoteService, param);
        //油罐信息
        this.pushData1106(apiRemoteService, param);
        pushService11.pushData1106(apiRemoteService, param);
        //设备信息
        this.pushData1107(apiRemoteService, param);
        pushService11.pushData1107(apiRemoteService, param);
        //药剂信息
        this.pushData1108(apiRemoteService, param);
        pushService11.pushData1108(apiRemoteService, param);
        //库区图仓房点位信息
        pushService11.pushData1110(apiRemoteService, param);

        //库区图仓房点位标注
        this.pushData1110(apiRemoteService, param);
        //库区图视频监控设备点位标注
        this.pushData1111(apiRemoteService, param);
        //库区图视频监控设备点位数据
        pushService11.pushData1111(apiRemoteService, param);

        //人员信息
        this.pushData1112(apiRemoteService, param);
        //财务报表
        this.pushData1114(apiRemoteService, param);
        pushService11.pushData1112(apiRemoteService, param);
        //企业信用信息
        pushService11.pushData1113(apiRemoteService, param);
        //文件信息推送，转移到12大类进行推送

        //财务报表数据推送
        pushService11.pushData1114(apiRemoteService, param);

        log.info("------->>>>基础信息 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1101 å•ä½ä¿¡æ¯
     */
    public void pushData1101(ApiRemoteService apiRemoteService, ApiParam param) {

        //获取单位信息
        List<Api1101> list = api1101Rep.getDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到单位信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1101);

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

    /**
     * 1102 åº“区信息
     */
    public void pushData1102(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取库区信息
        List<Api1102> list = api1102Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到库区信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1102);

        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())) {
                    api1102Rep.updateStatus(data.getKqdm(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1103  ä»“房信息
     */
    public void pushData1103(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取仓房信息
        List<Api1103> list = api1103Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到仓房信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1103);

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

    }

    /**
     * 1104  å»’间信息
     */
    public void pushData1104(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取廒间信息
        List<Api1104> list = api1104Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到廒间信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1104);

        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())) {
                    api1103Rep.updateStatus(data.getAjdh(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1105 è´§ä½ä¿¡æ¯
     */
    public void pushData1105(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取货位信息
        List<Api1105> list = api1105Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到货位信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1105);

        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())) {
                    api1105Rep.updateStatus(data.getHwdm(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1106 æ²¹ç½ä¿¡æ¯
     */
    public void pushData1106(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取油罐信息
        List<Api1106> list = api1106Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到油罐信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1106);

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

    }

    /**
     * 1107  è®¾å¤‡ä¿¡æ¯
     */
    public void pushData1107(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取设备信息
        List<Api1107> list = api1107Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到设备信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1107);

        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())) {
                    api1107Rep.updateStatus(data.getSbbh(), Constant.CZBZ_U);
                }
            }
        }

    }

    /**
     * 1108  è¯å‰‚信息
     */
    public void pushData1108(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取药剂信息
        List<Api1108> list = api1108Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到药剂信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1108);

        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())) {
                    api1108Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                }
            }
        }
    }



    /**
     * 1110 åº“区图仓房点位标注
     */
    public void pushData1110(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取库区图仓房点位标注
        List<Api1110> list = api1110Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到库区图仓房点位标注，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1110);

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

    }

    /**
     * 1111 åº“区图视频监控设备点位标注
     */
    public void pushData1111(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取库区图视频监控设备点位标注
        List<Api1111> list = api1111Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到库区图视频监控设备点位标注，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1111);

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

    /**
     * 1112  äººå‘˜ä¿¡æ¯
     */
    public void pushData1112(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取人员信息
        List<Api1112> list = api1112Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到人员信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1112);
        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())) {
                    api1112Rep.updateStatus(data.getSfzhm(), Constant.CZBZ_U);
                }
            }
        }
    }
    

    /**
     * 1114  è´¢åŠ¡æŠ¥è¡¨
     */
    public void pushData1114(ApiRemoteService apiRemoteService, ApiParam param) {
        this.pushData1501(apiRemoteService, param);
        this.pushData1502(apiRemoteService, param);
        this.pushData1503(apiRemoteService, param);

    }

    /**
     * 1501  è´¢åŠ¡æŠ¥è¡¨-资产负债--单条上传
     */
    public void pushData1501(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1501> list = api1501Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到资产负债信息，不推送-----");
            return;
        }
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1114_1501);
        ResponseDto responseDto;
        Api1501 d;
        for (Api1501 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1501Rep.save(data);
                }
            }
        }
    }

    /**
     * 1502  è´¢åŠ¡æŠ¥è¡¨-现金流
     */
    public void pushData1502(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1502> list = api1502Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到现金流信息，不推送-----");
            return;
        }
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1114_1502);
        ResponseDto responseDto;
        for (Api1502 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1502Rep.save(data);
                }
            }
        }
    }

    /**
     * 1503  è´¢åŠ¡æŠ¥è¡¨-利润信息
     */
    public void pushData1503(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1503> list = api1503Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到利润信息，不推送-----");
            return;
        }
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1114_1503);
        ResponseDto responseDto;
        Api1503 d;
        for (Api1503 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1503Rep.save(data);
                }
            }
        }
    }
}

 src/main/java/com/fzzy/push/nx2023/NX2023PushService12.java

@@ -1,18 +1,12 @@
package com.fzzy.push.nx2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService12;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService12;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * å®å¤çœå¹³å°2023版-基础数据上传
@@ -28,31 +22,7 @@
    @Autowired
    private NX2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1109Rep api1109Rep;
    @Autowired
    private Api1201Rep api1201Rep;
    @Autowired
    private Api1202Rep api1202Rep;
    @Autowired
    private Api1203Rep api1203Rep;
    @Autowired
    private Api1204Rep api1204Rep;
    @Autowired
    private Api1205Rep api1205Rep;
    @Autowired
    private Api1206Rep api1206Rep;
    @Autowired
    private Api1207Rep api1207Rep;
    @Autowired
    private Api1208Rep api1208Rep;
    @Autowired
    private Api1209Rep api1209Rep;
    @Autowired
    private Api1210Rep api1210Rep;
    @Autowired
    private Api1211Rep api1211Rep;
    @Autowired
    private Api1212Rep api1212Rep;
    private ComPushService12 pushService12;

    @Override
    public String getProtocol() {
@@ -63,400 +33,46 @@
    public void pushData(ApiParam param) {
        log.info("------->>>>粮食购销 æŽ¥å£æ¨¡å—上报开始");

        //推送合同信息
        this.pushData1201(apiRemoteService, param);
        //粮食入库信息
        this.pushData1202(apiRemoteService, param);
        //粮食入库检验信息
        this.pushData1203(apiRemoteService, param);
        //粮食入库结算信息
        this.pushData1204(apiRemoteService, param);
        //粮食出库信息
        this.pushData1205(apiRemoteService, param);
        //粮食出库结算信息
        this.pushData1206(apiRemoteService, param);
        //倒仓倒出
        this.pushData1207(apiRemoteService, param);
        //粮食库存
        this.pushData1208(apiRemoteService, param);
        //损溢单
        this.pushData1209(apiRemoteService, param);
        //粮食性质转变单
        this.pushData1210(apiRemoteService, param);
        //账面库存
        this.pushData1211(apiRemoteService, param);
        //客户信息
        this.pushData1212(apiRemoteService, param);
        //文件信息
        this.pushData1109(apiRemoteService, param);
        pushService12.pushData1212(apiRemoteService, param);

        //合同
        pushService12.pushData1201(apiRemoteService, param);

        //入库数据 + å…¥åº“过磅
        pushService12.pushData1202(apiRemoteService, param);

        //入库质检
        pushService12.pushData1203(apiRemoteService, param);

        //入库结算
        pushService12.pushData1204(apiRemoteService, param);

        //出库数据 + å‡ºåº“过磅
        pushService12.pushData1205(apiRemoteService, param);

        //出库结算
        pushService12.pushData1206(apiRemoteService, param);

        //倒仓
        pushService12.pushData1207(apiRemoteService, param);

        //损溢单
        pushService12.pushData1209(apiRemoteService, param);

        //粮食库存数据
        pushService12.pushData1208(apiRemoteService, param);

        //性质转变
        pushService12.pushData1210(apiRemoteService, param);

        //账面库存
        pushService12.pushData1211(apiRemoteService, param);

        //文件
        pushService12.pushData1109(apiRemoteService, param);

        log.info("------->>>>粮食购销 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1201 åˆåŒä¿¡æ¯
     */
    public void pushData1201(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取合同信息
        List<Api1201> list = api1201Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到合同信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1201);

        ResponseDto responseDto;
        for (Api1201 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);
                    api1201Rep.save(data);
                }
            }
        }
    }

    /**
     * 1202 ç²®é£Ÿå…¥åº“信息
     */
    public void pushData1202(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食入库信息
        List<Api1202> list = api1202Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食入库信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1202);

        ResponseDto responseDto;
        for (Api1202 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);
                    //更新状态
                    api1202Rep.save(data);
                }
            }
        }
    }

    /**
     * 1203 ç²®é£Ÿå…¥åº“检验信息
     */
    public void pushData1203(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食入库检验信息
        List<Api1203> list = api1203Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食入库检验信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1203);

        ResponseDto responseDto;
        for (Api1203 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);
                    //更新状态
                    api1203Rep.save(data);
                }
            }
        }

    }

    /**
     * 1204 ç²®é£Ÿå…¥åº“结算信息
     */
    public void pushData1204(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食入库结算信息
        List<Api1204> list = api1204Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食入库结算信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1204);

        ResponseDto responseDto;
        for (Api1204 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);
                    //更新状态
                    api1204Rep.save(data);
                }
            }
        }
    }

    /**
     * 1205 ç²®é£Ÿå‡ºåº“信息
     */
    public void pushData1205(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食出库信息
        List<Api1205> list = api1205Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食出库信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1205);

        ResponseDto responseDto;
        for (Api1205 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);
                    //更新状态
                    api1205Rep.save(data);
                }
            }
        }
    }

    /**
     * 1206 ç²®é£Ÿå‡ºåº“结算信息
     */
    public void pushData1206(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食出库结算信息
        List<Api1206> list = api1206Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食出库结算信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1206);
        ResponseDto responseDto;
        for (Api1206 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);
                    //更新状态
                    api1206Rep.save(data);
                }
            }
        }
    }

    /**
     * 1207 å€’仓数据
     */
    public void pushData1207(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取倒仓信息
        List<Api1207> list = api1207Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到倒仓信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1207);

        ResponseDto responseDto;
        for (Api1207 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);
                    //更新状态
                    api1207Rep.save(data);
                }
            }
        }
    }

    /**
     * 1208 ç²®é£Ÿåº“å­˜
     */
    public void pushData1208(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食库存信息
        List<Api1208> list = api1208Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1208);

        ResponseDto responseDto;
        for (Api1208 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);
                    //更新状态
                    api1208Rep.save(data);
                }
            }
        }
    }

    /**
     * 1209 æŸæº¢å•
     */
    public void pushData1209(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取损益单信息
        List<Api1209> list = api1209Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1209);

        ResponseDto responseDto;
        for (Api1209 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);
                    //更新状态
                    api1209Rep.save(data);
                }
            }
        }
    }

    /**
     * 1210 ç²®é£Ÿæ€§è´¨è½¬å˜å•
     */
    public void pushData1210(ApiRemoteService apiRemoteService, ApiParam param) {
        //粮食性质转变单
        List<Api1210> list = api1210Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1210);

        ResponseDto responseDto;
        for (Api1210 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);
                    //更新状态
                    api1210Rep.save(data);
                }
            }
        }
    }

    /**
     * 1211 è´¦é¢åº“å­˜
     */
    public void pushData1211(ApiRemoteService apiRemoteService, ApiParam param) {
        //账面库存
        List<Api1211> list = api1211Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1210);

        ResponseDto responseDto;
        for (Api1211 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);
                    //更新状态
                    api1211Rep.save(data);
                }
            }
        }
    }

    /**
     * 1212 å®¢æˆ·ä¿¡æ¯
     */
    public void pushData1212(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取客户信息
        List<Api1212> list = api1212Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到客户信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1212);

        ResponseDto responseDto;
        for (Api1212 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);
                    //更新状态
                    api1212Rep.save(data);
                }
            }
        }
    }

    /**
     * 1109  æ–‡ä»¶ä¿¡æ¯
     */
    public void pushData1109(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取文件信息
        List<Api1109> list = api1109Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到文件信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1109);

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

    }

}

 src/main/java/com/fzzy/push/nx2023/NX2023PushService13.java

@@ -1,18 +1,12 @@
package com.fzzy.push.nx2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService13;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService13;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * å®å¤çœå¹³å°2023版-基础数据上传
@@ -28,25 +22,7 @@
    @Autowired
    private NX2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1301Rep api1301Rep;
    @Autowired
    private Api1302Rep api1302Rep;
    @Autowired
    private Api1303Rep api1303Rep;
    @Autowired
    private Api1304Rep api1304Rep;
    @Autowired
    private Api1305Rep api1305Rep;
    @Autowired
    private Api1306Rep api1306Rep;
    @Autowired
    private Api1307Rep api1307Rep;
    @Autowired
    private Api1308Rep api1308Rep;
    @Autowired
    private Api1309Rep api1309Rep;
    @Autowired
    private Api1310Rep api1310Rep;
    private ComPushService13 pushService13;

    @Override
    public String getProtocol() {
@@ -57,303 +33,32 @@
    public void pushData(ApiParam param) {
        log.info("------->>>>粮库管理 æŽ¥å£æ¨¡å—上报开始");

        this.pushData1301(apiRemoteService, param);
        this.pushData1302(apiRemoteService, param);
        this.pushData1303(apiRemoteService, param);
        this.pushData1304(apiRemoteService, param);
        this.pushData1305(apiRemoteService, param);
        this.pushData1306(apiRemoteService, param);
        this.pushData1307(apiRemoteService, param);
        this.pushData1308(apiRemoteService, param);
        this.pushData1309(apiRemoteService, param);
        this.pushData1310(apiRemoteService, param);
        pushService13.pushData1301(apiRemoteService, param);
        //粮情
        pushService13.pushData1302(apiRemoteService, param);

        //气体
        pushService13.pushData1304(apiRemoteService, param);

        //虫害
        pushService13.pushData1303(apiRemoteService, param);

        //通风
        pushService13.pushData1305(apiRemoteService, param);

        //熏蒸
        pushService13.pushData1306(apiRemoteService, param);
        //熏蒸
        pushService13.pushData1307(apiRemoteService, param);

        pushService13.pushData1308(apiRemoteService, param);

        pushService13.pushData1309(apiRemoteService, param);

        //质检
        pushService13.pushData1310(apiRemoteService, param);

        log.info("------->>>>粮库管理 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1301 å®‰å…¨ç®¡ç†
     */
    public void pushData1301(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取安全管理
        List<Api1301> list = api1301Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到安全管理，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1301);

        ResponseDto responseDto;
        for (Api1301 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);
                    //更新状态
                    api1301Rep.save(data);
                }
            }
        }
    }

    /**
     * 1302 æ¸©æ¹¿åº¦æ£€æµ‹
     */
    public void pushData1302(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取温湿度检测
        List<Api1302> list = api1302Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到温湿度检测，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1302);

        ResponseDto responseDto;
        for (Api1302 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);
                    //更新状态
                    api1302Rep.save(data);
                }
            }
        }
    }

    /**
     * 1303 å®³è™«æ£€æµ‹
     */
    public void pushData1303(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取害虫检测
        List<Api1303> list = api1303Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到害虫检测，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1303);

        ResponseDto responseDto;
        for (Api1303 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);
                    //更新状态
                    api1303Rep.save(data);
                }
            }
        }
    }

    /**
     * 1304 æ°”体检测
     */
    public void pushData1304(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取气体检测
        List<Api1304> list = api1304Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到气体检测，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1304);

        ResponseDto responseDto;
        for (Api1304 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);
                    //更新状态
                    api1304Rep.save(data);
                }
            }
        }

    }

    /**
     * 1305 é€šé£Žä½œä¸š
     */
    public void pushData1305(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取通风作业
        List<Api1305> list = api1305Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到通风作业，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1305);

        ResponseDto responseDto;
        for (Api1305 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);
                    //更新状态
                    api1305Rep.save(data);
                }
            }
        }
    }

    /**
     * 1306 ç†è’¸ä½œä¸š
     */
    public void pushData1306(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取熏蒸作业
        List<Api1306> list = api1306Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到熏蒸作业，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1306);

        ResponseDto responseDto;
        for (Api1306 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);
                    //更新状态
                    api1306Rep.save(data);
                }
            }
        }
    }

    /**
     * 1307 ä»“内视频图像
     */
    public void pushData1307(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取仓内视频图像
        List<Api1307> list = api1307Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到仓内视频图像，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1307);

        ResponseDto responseDto;
        for (Api1307 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);
                    //更新状态
                    api1307Rep.save(data);
                }
            }
        }

    }

    /**
     * 1308 è§†é¢‘监控异常事件告警
     */
    public void pushData1308(ApiRemoteService apiRemoteService, ApiParam param) {
        //视频监控异常事件告警
        List<Api1308> list = api1308Rep.findAll();

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到视频监控异常事件告警，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1308);

        ResponseDto responseDto;
        for (Api1308 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);
                    //更新状态
                    api1308Rep.save(data);
                }
            }
        }

    }

    /**
     * 1309 è¿è§„预警信息
     */
    public void pushData1309(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取仓内视频图像
        List<Api1309> list = api1309Rep.findAll();

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到违规预警信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1307);

        ResponseDto responseDto;
        for (Api1309 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);
                    //更新状态
                    api1309Rep.save(data);
                }
            }
        }

    }

    /**
     * 1310 è´¨æ£€æ•°æ®
     */
    public void pushData1310(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取质检数据
        List<Api1310> list = api1310Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到质检数据，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1310);

        ResponseDto responseDto;
        for (Api1310 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);
                    //更新状态
                    api1310Rep.save(data);
                }
            }
        }
    }
}

 src/main/java/com/fzzy/push/nx2023/NX2023PushService14.java

@@ -1,19 +1,12 @@
package com.fzzy.push.nx2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.Api1403;
import com.fzzy.api.entity.Api1404;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService14;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService14;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * å®å¤çœå¹³å°2023版-基础数据上传
@@ -28,9 +21,7 @@
    @Autowired
    private NX2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1403Rep api1403Rep;
    @Autowired
    private Api1404Rep api1404Rep;
    private ComPushService14 pushService14;


    @Override
@@ -42,68 +33,16 @@
    public void pushData(ApiParam param) {
        log.info("------->>>>行政管理 æŽ¥å£æ¨¡å—上报开始");

        pushService14.pushData1401(apiRemoteService, param);

        pushService14.pushData1402(apiRemoteService, param);
        //轮换计划
        this.pushData1403(apiRemoteService, param);
        pushService14.pushData1403(apiRemoteService, param);
        //轮换计划明细
        this.pushData1404(apiRemoteService, param);
        pushService14.pushData1404(apiRemoteService, param);

        pushService14.pushData1405(apiRemoteService, param);

        log.info("------->>>>行政管理 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1403 è½®æ¢è®¡åˆ’信息
     */
    public void pushData1403(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取轮换计划
        List<Api1403> list = api1403Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到轮换计划，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1403);

        ResponseDto responseDto;
        for (Api1403 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);
                    //更新状态
                    api1403Rep.save(data);
                }
            }
        }
    }

    /**
     * 1404 è½®æ¢è®¡åˆ’明细信息
     */
    public void pushData1404(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取轮换计划明细
        List<Api1404> list = api1404Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----宁夏省平台2023版：未获取到轮换计划明细，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(NX2023Constant.NX_2023_API_CODE_1404);

        ResponseDto responseDto;
        for (Api1404 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);
                    //更新状态
                    api1404Rep.save(data);
                }
            }
        }
    }

}

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

@@ -1,6 +1,5 @@
package com.fzzy.push.sh2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.entity.ApiConfs;
@@ -9,6 +8,7 @@
import com.fzzy.order.OrderApiService;
import com.fzzy.order.data.OrderConstant;
import com.fzzy.order.data.OrderData;
import com.fzzy.push.impl.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
@@ -32,13 +32,15 @@
    @Autowired
    private SH2023ApiRemoteService apiRemoteService;
    @Autowired
    private SH2023PushService11 sh2023PushService11;
    private ComPushService11 pushService11;
    @Autowired
    private SH2023PushService12 sh2023PushService12;
    private ComPushService12 pushService12;
    @Autowired
    private SH2023PushService13 sh2023PushService13;
    private ComPushService13 pushService13;
    @Autowired
    private SH2023PushService14 sh2023PushService14;
    private ComPushService14 pushService14;
    @Autowired
    private ComPushService99 pushService99;

    @Override
    public String getProtocol() {
@@ -84,148 +86,148 @@

        switch (inteId) {
            case "1101":
                sh2023PushService11.pushData1101(apiRemoteService, param);
                pushService11.pushData1101(apiRemoteService, param);
                break;
            case "1102":
                sh2023PushService11.pushData1102(apiRemoteService, param);
                pushService11.pushData1102(apiRemoteService, param);
                break;
            case "1103":
                sh2023PushService11.pushData1103(apiRemoteService, param);
                pushService11.pushData1103(apiRemoteService, param);
                break;
            case "1104":
                sh2023PushService11.pushData1104(apiRemoteService, param);
                pushService11.pushData1104(apiRemoteService, param);
                break;
            case "1105":
                sh2023PushService11.pushData1105(apiRemoteService, param);
                pushService11.pushData1105(apiRemoteService, param);
                break;
            case "1106":
                sh2023PushService11.pushData1106(apiRemoteService, param);
                pushService11.pushData1106(apiRemoteService, param);
                break;
            case "1107":
                sh2023PushService11.pushData1107(apiRemoteService, param);
                pushService11.pushData1107(apiRemoteService, param);
                break;
            case "1108":
                sh2023PushService11.pushData1108(apiRemoteService, param);
                pushService11.pushData1108(apiRemoteService, param);
                break;
            case "1109":
                sh2023PushService11.pushData1109(apiRemoteService, param);
                pushService12.pushData1109(apiRemoteService, param);
                break;
            case "1110":
                sh2023PushService11.pushData1110(apiRemoteService, param);
                pushService11.pushData1110(apiRemoteService, param);
                break;
            case "1111":
                sh2023PushService11.pushData1111(apiRemoteService, param);
                pushService11.pushData1111(apiRemoteService, param);
                break;
            case "1112":
                sh2023PushService11.pushData1112(apiRemoteService, param);
                pushService11.pushData1112(apiRemoteService, param);
                break;
            case "1113":
                sh2023PushService11.pushData1113(apiRemoteService, param);
                pushService11.pushData1113(apiRemoteService, param);
                break;
            case "1114":
                sh2023PushService11.pushData1114(apiRemoteService, param);
                pushService11.pushData1114(apiRemoteService, param);
                break;
            case "1201":
                sh2023PushService12.pushData1201(apiRemoteService, param);
                pushService12.pushData1201(apiRemoteService, param);
                break;
            case "1202":
                sh2023PushService12.pushData1202(apiRemoteService, param);
                pushService12.pushData1202(apiRemoteService, param);
                break;
            case "1203":
                sh2023PushService12.pushData1203(apiRemoteService, param);
                pushService12.pushData1203(apiRemoteService, param);
                break;
            case "1204":
                sh2023PushService12.pushData1204(apiRemoteService, param);
                pushService12.pushData1204(apiRemoteService, param);
                break;
            case "1205":
                sh2023PushService12.pushData1205(apiRemoteService, param);
                pushService12.pushData1205(apiRemoteService, param);
                break;
            case "1206":
                sh2023PushService12.pushData1206(apiRemoteService, param);
                pushService12.pushData1206(apiRemoteService, param);
                break;
            case "1207":
                sh2023PushService12.pushData1207(apiRemoteService, param);
                pushService12.pushData1207(apiRemoteService, param);
                break;
            case "1208":
                sh2023PushService12.pushData1208(apiRemoteService, param);
                pushService12.pushData1208(apiRemoteService, param);
                break;
            case "1209":
                sh2023PushService12.pushData1209(apiRemoteService, param);
                pushService12.pushData1209(apiRemoteService, param);
                break;
            case "1210":
                sh2023PushService12.pushData1210(apiRemoteService, param);
                pushService12.pushData1210(apiRemoteService, param);
                break;
            case "1211":
                sh2023PushService12.pushData1211(apiRemoteService, param);
                pushService12.pushData1211(apiRemoteService, param);
                break;
            case "1212":
                sh2023PushService12.pushData1212(apiRemoteService, param);
                pushService12.pushData1212(apiRemoteService, param);
                break;
            case "2101":
                sh2023PushService12.pushData2101(apiRemoteService, param);
                pushService99.pushData2101(apiRemoteService, param);
                break;
            case "2102":
                sh2023PushService12.pushData2102(apiRemoteService, param);
                pushService99.pushData2102(apiRemoteService, param);
                break;
            case "2104":
                sh2023PushService12.pushData2104(apiRemoteService, param);
                pushService99.pushData2104(apiRemoteService, param);
                break;
            case "1301":
                sh2023PushService13.pushData1301(apiRemoteService, param);
                pushService13.pushData1301(apiRemoteService, param);
                break;
            case "1302":
                sh2023PushService13.pushData1302(apiRemoteService, param);
                pushService13.pushData1302(apiRemoteService, param);
                break;
            case "1303":
                sh2023PushService13.pushData1303(apiRemoteService, param);
                pushService13.pushData1303(apiRemoteService, param);
                break;
            case "1304":
                sh2023PushService13.pushData1304(apiRemoteService, param);
                pushService13.pushData1304(apiRemoteService, param);
                break;
            case "1305":
                sh2023PushService13.pushData1305(apiRemoteService, param);
                pushService13.pushData1305(apiRemoteService, param);
                break;
            case "1306":
                sh2023PushService13.pushData1306(apiRemoteService, param);
                pushService13.pushData1306(apiRemoteService, param);
                break;
            case "1307":
                sh2023PushService13.pushData1307(apiRemoteService, param);
                pushService13.pushData1307(apiRemoteService, param);
                break;
            case "1308":
                sh2023PushService13.pushData1308(apiRemoteService, param);
                pushService13.pushData1308(apiRemoteService, param);
                break;
            case "1309":
                sh2023PushService13.pushData1309(apiRemoteService, param);
                pushService13.pushData1309(apiRemoteService, param);
                break;
            case "1310":
                sh2023PushService13.pushData1310(apiRemoteService, param);
                pushService13.pushData1310(apiRemoteService, param);
                break;
            case "1311":
                sh2023PushService13.pushData1311(apiRemoteService, param);
                pushService99.pushData1311(apiRemoteService, param);
                break;
            case "2103":
                sh2023PushService13.pushData2103(apiRemoteService, param);
                pushService99.pushData2103(apiRemoteService, param);
                break;
            case "1401":
                sh2023PushService14.pushData1401(apiRemoteService, param);
                pushService14.pushData1401(apiRemoteService, param);
                break;
            case "1402":
                sh2023PushService14.pushData1402(apiRemoteService, param);
                pushService14.pushData1402(apiRemoteService, param);
                break;
            case "1403":
                sh2023PushService14.pushData1403(apiRemoteService, param);
                pushService14.pushData1403(apiRemoteService, param);
                break;
            case "1404":
                sh2023PushService14.pushData1404(apiRemoteService, param);
                pushService14.pushData1404(apiRemoteService, param);
                break;
            case "1405":
                sh2023PushService14.pushData1405(apiRemoteService, param);
                pushService14.pushData1405(apiRemoteService, param);
                break;
            case "2203":
                sh2023PushService14.pushData2203(apiRemoteService, param);
                pushService99.pushData2203(apiRemoteService, param);
                break;
            case "2204":
                sh2023PushService14.pushData2204(apiRemoteService, param);
                pushService99.pushData2204(apiRemoteService, param);
                break;
            default:
                log.error("-----上海市平台：未匹配到接口编码，不推送-----");

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

@@ -1,17 +1,12 @@
package com.fzzy.push.sh2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService11;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService11;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * ä¸Šæµ·å¸‚平台2023版-基础数据上传
@@ -24,37 +19,9 @@
public class SH2023PushService11 implements PushService11 {

    @Autowired
    private Api1101Rep api1101Rep;
    private SH2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1102Rep api1102Rep;
    @Autowired
    private Api1103Rep api1103Rep;
    @Autowired
    private Api1104Rep api1104Rep;
    @Autowired
    private Api1105Rep api1105Rep;
    @Autowired
    private Api1106Rep api1106Rep;
    @Autowired
    private Api1107Rep api1107Rep;
    @Autowired
    private Api1108Rep api1108Rep;
    @Autowired
    private Api1109Rep api1109Rep;
    @Autowired
    private Api1110Rep api1110Rep;
    @Autowired
    private Api1111Rep api1111Rep;
    @Autowired
    private Api1112Rep api1112Rep;
    @Autowired
    private Api1113Rep api1113Rep;
    @Autowired
    private Api1501Rep api1501Rep;
    @Autowired
    private Api1502Rep api1502Rep;
    @Autowired
    private Api1503Rep api1503Rep;
    private ComPushService11 pushService11;

    @Override
    public String getProtocol() {
@@ -66,476 +33,37 @@

        log.info("------->>>>上海2023接口不主动上报");

//        //推送单位信息
//        this.pushData1101(apiRemoteService, param);
//        //库区信息
//        this.pushData1102(apiRemoteService, param);
//        //仓房信息
//        this.pushData1103(apiRemoteService, param);
//        //廒间信息
//        this.pushData1104(apiRemoteService, param);
//        //货位信息
//        this.pushData1105(apiRemoteService, param);
//        //油罐信息
//        this.pushData1106(apiRemoteService, param);
//        //设备信息
//        this.pushData1107(apiRemoteService, param);
//        //药剂信息
//        this.pushData1108(apiRemoteService, param);
//        //文件信息
//        this.pushData1109(apiRemoteService, param);
//        //库区图仓房点位标注
//        this.pushData1110(apiRemoteService, param);
//        //库区图视频监控设备点位标注
//        this.pushData1111(apiRemoteService, param);
//        //人员信息
//        this.pushData1112(apiRemoteService, param);
//        //企业信用信息
//        this.pushData1113(apiRemoteService, param);
//        //财务报表
//        this.pushData1114(apiRemoteService, param);
        //单位信息
        pushService11.pushData1101(apiRemoteService, param);
        //库区信息
        pushService11.pushData1102(apiRemoteService, param);
        //仓房信息
        pushService11.pushData1103(apiRemoteService, param);
        //廒间信息
        pushService11.pushData1104(apiRemoteService, param);
        //货位信息
        pushService11.pushData1105(apiRemoteService, param);
        //油罐信息
        pushService11.pushData1106(apiRemoteService, param);
        //设备信息
        pushService11.pushData1107(apiRemoteService, param);
        //药剂信息
        pushService11.pushData1108(apiRemoteService, param);
        //库区图仓房点位信息
        pushService11.pushData1110(apiRemoteService, param);

        //库区图视频监控设备点位数据
        pushService11.pushData1111(apiRemoteService, param);

        //人员信息
        pushService11.pushData1112(apiRemoteService, param);
        //企业信用信息
        pushService11.pushData1113(apiRemoteService, param);
        //文件信息推送，转移到12大类进行推送

        //财务报表数据推送
        pushService11.pushData1114(apiRemoteService, param);

        log.info("------->>>>基础信息 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1101 å•ä½ä¿¡æ¯
     */
    public void pushData1101(ApiRemoteService apiRemoteService, ApiParam param) {

        //获取单位信息
        List<Api1101> list = api1101Rep.getDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到单位信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1101);

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

    /**
     * 1102 åº“区信息
     */
    public void pushData1102(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取库区信息
        List<Api1102> list = api1102Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到库区信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1102);

        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())) {
                    api1102Rep.updateStatus(data.getKqdm(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1103  ä»“房信息
     */
    public void pushData1103(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取仓房信息
        List<Api1103> list = api1103Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到仓房信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1103);

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

    }

    /**
     * 1104  å»’间信息
     */
    public void pushData1104(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取廒间信息
        List<Api1104> list = api1104Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到廒间信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1104);

        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())) {
                    api1103Rep.updateStatus(data.getAjdh(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1105 è´§ä½ä¿¡æ¯
     */
    public void pushData1105(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取货位信息
        List<Api1105> list = api1105Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到货位信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1105);

        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())) {
                    api1105Rep.updateStatus(data.getHwdm(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1106 æ²¹ç½ä¿¡æ¯
     */
    public void pushData1106(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取油罐信息
        List<Api1106> list = api1106Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到油罐信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1106);

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

    }

    /**
     * 1107  è®¾å¤‡ä¿¡æ¯
     */
    public void pushData1107(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取设备信息
        List<Api1107> list = api1107Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到设备信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1107);

        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())) {
                    api1107Rep.updateStatus(data.getSbbh(), Constant.CZBZ_U);
                }
            }
        }

    }

    /**
     * 1108  è¯å‰‚信息
     */
    public void pushData1108(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取药剂信息
        List<Api1108> list = api1108Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到药剂信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1108);

        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())) {
                    api1108Rep.updateStatus(data.getId(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1109  æ–‡ä»¶ä¿¡æ¯
     */
    public void pushData1109(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取文件信息
        List<Api1109> list = api1109Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到文件信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1109);

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

    }

    /**
     * 1110 åº“区图仓房点位标注
     */
    public void pushData1110(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取库区图仓房点位标注
        List<Api1110> list = api1110Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到库区图仓房点位标注，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1110);

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

    }

    /**
     * 1111 åº“区图视频监控设备点位标注
     */
    public void pushData1111(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取库区图视频监控设备点位标注
        List<Api1111> list = api1111Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到库区图视频监控设备点位标注，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1111);

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

    /**
     * 1112  äººå‘˜ä¿¡æ¯
     */
    public void pushData1112(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取人员信息
        List<Api1112> list = api1112Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到人员信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1112);
        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())) {
                    api1112Rep.updateStatus(data.getSfzhm(), Constant.CZBZ_U);
                }
            }
        }
    }

    /**
     * 1113  ä¼ä¸šä¿¡ç”¨ä¿¡æ¯
     */
    public void pushData1113(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取企业信用信息
        List<Api1113> list = api1113Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到企业信用信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_11);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1113);

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

    }

    /**
     * 1114  è´¢åŠ¡æŠ¥è¡¨
     */
    public void pushData1114(ApiRemoteService apiRemoteService, ApiParam param) {
        this.pushData1501(apiRemoteService, param);
        this.pushData1502(apiRemoteService, param);
        this.pushData1503(apiRemoteService, param);

    }

    /**
     * 1501  è´¢åŠ¡æŠ¥è¡¨-资产负债--单条上传
     */
    public void pushData1501(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1501> list = api1501Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到资产负债信息，不推送-----");
            return;
        }
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1114_1501);
        ResponseDto responseDto;
        Api1501 d;
        for (Api1501 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1501Rep.save(data);
                }
            }
        }
    }

    /**
     * 1502  è´¢åŠ¡æŠ¥è¡¨-现金流
     */
    public void pushData1502(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1502> list = api1502Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到现金流信息，不推送-----");
            return;
        }
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1114_1502);
        ResponseDto responseDto;
        for (Api1502 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1502Rep.save(data);
                }
            }
        }
    }

    /**
     * 1503  è´¢åŠ¡æŠ¥è¡¨-利润信息
     */
    public void pushData1503(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取财务报表-资产负债
        List<Api1503> list = api1503Rep.findPushDataTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到利润信息，不推送-----");
            return;
        }
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1114_1503);
        ResponseDto responseDto;
        Api1503 d;
        for (Api1503 data : list) {
            responseDto = apiRemoteService.pushData(param, data);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(data.getCzbz())) {

                    data.setCzbz(Constant.CZBZ_U);
                    //更新状态
                    api1503Rep.save(data);
                }
            }
        }
    }
}

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

@@ -1,17 +1,13 @@
package com.fzzy.push.sh2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService12;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService12;
import com.fzzy.push.impl.ComPushService99;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * ä¸Šæµ·å¸‚平台2023版-基础数据上传
@@ -27,32 +23,9 @@
    @Autowired
    private SH2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1201Rep api1201Rep;
    private ComPushService12 pushService12;
    @Autowired
    private Api1202Rep api1202Rep;
    @Autowired
    private Api1203Rep api1203Rep;
    @Autowired
    private Api1204Rep api1204Rep;
    @Autowired
    private Api1205Rep api1205Rep;
    @Autowired
    private Api1206Rep api1206Rep;
    @Autowired
    private Api1207Rep api1207Rep;
    @Autowired
    private Api1208Rep api1208Rep;
    @Autowired
    private Api1209Rep api1209Rep;
    @Autowired
    private Api1210Rep api1210Rep;
    @Autowired
    private Api1211Rep api1211Rep;
    @Autowired
    private Api1212Rep api1212Rep;
    @Autowired
    private ApiInfoDataRep apiInfoDataRep;

    private ComPushService99 pushService99;
    @Override
    public String getProtocol() {
        return PushProtocol.SB_SH_2023.getCode();
@@ -62,434 +35,49 @@
    public void pushData(ApiParam param) {
        log.info("------->>>>粮食购销 æŽ¥å£æ¨¡å—上报开始");

//        //推送合同信息
//        this.pushData1201(apiRemoteService, param);
//        //粮食入库信息
//        this.pushData1202(apiRemoteService, param);
//        //粮食入库检验信息
//        this.pushData1203(apiRemoteService, param);
//        //粮食入库结算信息
//        this.pushData1204(apiRemoteService, param);
//        //粮食出库信息
//        this.pushData1205(apiRemoteService, param);
//        //粮食出库结算信息
//        this.pushData1206(apiRemoteService, param);
//        //倒仓倒出
//        this.pushData1207(apiRemoteService, param);
//        //粮食库存
//        this.pushData1208(apiRemoteService, param);
//        //损溢单
//        this.pushData1209(apiRemoteService, param);
//        //粮食性质转变单
//        this.pushData1210(apiRemoteService, param);
//        //账面库存
//        this.pushData1211(apiRemoteService, param);
//        //客户信息
//        this.pushData1212(apiRemoteService, param);
        //客户信息
        pushService12.pushData1212(apiRemoteService, param);

        //合同
        pushService12.pushData1201(apiRemoteService, param);

        //入库数据 + å…¥åº“过磅
        pushService12.pushData1202(apiRemoteService, param);

        //入库质检
        pushService12.pushData1203(apiRemoteService, param);

        //入库结算
        pushService12.pushData1204(apiRemoteService, param);

        //出库数据 + å‡ºåº“过磅
        pushService12.pushData1205(apiRemoteService, param);

        //出库结算
        pushService12.pushData1206(apiRemoteService, param);

        //倒仓
        pushService12.pushData1207(apiRemoteService, param);

        //损溢单
        pushService12.pushData1209(apiRemoteService, param);

        //粮食库存数据
        pushService12.pushData1208(apiRemoteService, param);

        //性质转变
        pushService12.pushData1210(apiRemoteService, param);

        //账面库存
        pushService12.pushData1211(apiRemoteService, param);

        //文件
        pushService12.pushData1109(apiRemoteService, param);

        pushService99.pushData2101(apiRemoteService, param);
        pushService99.pushData2102(apiRemoteService, param);
        pushService99.pushData2104(apiRemoteService, param);

        log.info("------->>>>粮食购销 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1201 åˆåŒä¿¡æ¯
     */
    public void pushData1201(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取合同信息
        List<Api1201> list = api1201Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到合同信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1201);

        ResponseDto responseDto;
        for (Api1201 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);
                    api1201Rep.save(data);
                }
            }
        }
    }

    /**
     * 1202 ç²®é£Ÿå…¥åº“信息
     */
    public void pushData1202(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食入库信息
        List<Api1202> list = api1202Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食入库信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1202);

        ResponseDto responseDto;
        for (Api1202 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);
                    //更新状态
                    api1202Rep.save(data);
                }
            }
        }
    }

    /**
     * 1203 ç²®é£Ÿå…¥åº“检验信息
     */
    public void pushData1203(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食入库检验信息
        List<Api1203> list = api1203Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食入库检验信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1203);

        ResponseDto responseDto;
        for (Api1203 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);
                    //更新状态
                    api1203Rep.save(data);
                }
            }
        }

    }

    /**
     * 1204 ç²®é£Ÿå…¥åº“结算信息
     */
    public void pushData1204(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食入库结算信息
        List<Api1204> list = api1204Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食入库结算信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1204);

        ResponseDto responseDto;
        for (Api1204 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);
                    //更新状态
                    api1204Rep.save(data);
                }
            }
        }
    }

    /**
     * 1205 ç²®é£Ÿå‡ºåº“信息
     */
    public void pushData1205(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食出库信息
        List<Api1205> list = api1205Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食出库信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1205);

        ResponseDto responseDto;
        for (Api1205 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);
                    //更新状态
                    api1205Rep.save(data);
                }
            }
        }
    }

    /**
     * 1206 ç²®é£Ÿå‡ºåº“结算信息
     */
    public void pushData1206(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食出库结算信息
        List<Api1206> list = api1206Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食出库结算信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1206);
        ResponseDto responseDto;
        for (Api1206 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);
                    //更新状态
                    api1206Rep.save(data);
                }
            }
        }
    }

    /**
     * 1207 å€’仓倒出
     */
    public void pushData1207(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取倒仓信息
        List<Api1207> list = api1207Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到倒仓信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1207);

        ResponseDto responseDto;
        for (Api1207 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);
                    //更新状态
                    api1207Rep.save(data);
                }
            }
        }
    }

    /**
     * 1208 ç²®é£Ÿåº“å­˜
     */
    public void pushData1208(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取粮食库存信息
        List<Api1208> list = api1208Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1208);

        ResponseDto responseDto;
        for (Api1208 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);
                    //更新状态
                    api1208Rep.save(data);
                }
            }
        }
    }

    /**
     * 1209 æŸæº¢å•
     */
    public void pushData1209(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取损益单信息
        List<Api1209> list = api1209Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1209);

        ResponseDto responseDto;
        for (Api1209 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);
                    //更新状态
                    api1209Rep.save(data);
                }
            }
        }
    }

    /**
     * 1210 ç²®é£Ÿæ€§è´¨è½¬å˜å•
     */
    public void pushData1210(ApiRemoteService apiRemoteService, ApiParam param) {
        //粮食性质转变单
        List<Api1210> list = api1210Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1210);

        ResponseDto responseDto;
        for (Api1210 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);
                    //更新状态
                    api1210Rep.save(data);
                }
            }
        }
    }

    /**
     * 1211 è´¦é¢åº“å­˜
     */
    public void pushData1211(ApiRemoteService apiRemoteService, ApiParam param) {
        //TODO
        //粮食性质转变单
        List<Api1211> list = api1211Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮食库存信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1210);

        ResponseDto responseDto;
        for (Api1211 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);
                    //更新状态
                    api1211Rep.save(data);
                }
            }
        }
    }

    /**
     * 1212 å®¢æˆ·ä¿¡æ¯
     */
    public void pushData1212(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取客户信息
        List<Api1212> list = api1212Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到客户信息，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_12);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1212);

        ResponseDto responseDto;
        for (Api1212 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);
                    //更新状态
                    api1212Rep.save(data);
                }
            }
        }
    }

    /**
     * 2101 æ£€æ–¤å•
     */
    public void pushData2101(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取 æ£€æ–¤å•ä¿¡æ¯
//        List<ApiInfoData> items = apiInfoDataRep.getDataByInteId(SH2023Constant.SH_2023_API_CODE_2101);
//
//        param.setInteCategory(Constant.API_CATEGORY_12);
//        param.setInteId(SH2023Constant.SH_2023_API_CODE_2101);
//
//        ResponseDto responseDto;
//        SH2023Api2101 shApi2101;
//        for (ApiInfoData infoData : items) {
//            shApi2101 = JSONObject.parseObject(infoData.getData(), SH2023Api2101.class);
//            shApi2101.setCzbz(infoData.getCzbz());
//            shApi2101.setZhgxsj(infoData.getUpdateTime());
//            param.setBizId(infoData.getDataId());
//            responseDto = apiRemoteService.pushData(param, shApi2101);
//            if (responseDto.getSuccess() == 0) {
//                if (Constant.CZBZ_I.equals(infoData.getCzbz())) {
//                    infoData.setCzbz(Constant.CZBZ_U);
//                    apiInfoDataRep.save(infoData);
//                }
//            }
//        }
    }

    /**
     * 2102 å€’仓倒入
     */
    public void pushData2102(ApiRemoteService apiRemoteService, ApiParam param) {
        //TODO

    }

    /**
     * 2104  å¸‚储驳运单
     */
    public void pushData2104(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取 æ£€æ–¤å•ä¿¡æ¯
//        List<ApiInfoData> items = apiInfoDataRep.getDataByInteId(SH2023Constant.SH_2023_API_CODE_2104);

//        param.setInteCategory(Constant.API_CATEGORY_12);
//        param.setInteId(SH2023Constant.SH_2023_API_CODE_2104);
//
//        ResponseDto responseDto;
//        SH2023Api2104 shApi2104;
//        for (ApiInfoData infoData : items) {
//            shApi2104 = JSONObject.parseObject(infoData.getData(), SH2023Api2104.class);
//            shApi2104.setCzbz(infoData.getCzbz());
//            shApi2104.setZhgxsj(infoData.getUpdateTime());
//
//            param.setBizId(infoData.getDataId());
//            responseDto = apiRemoteService.pushData(param, shApi2104);
//            if (responseDto.getSuccess() == 0) {
//                if (Constant.CZBZ_I.equals(infoData.getCzbz())) {
//                    infoData.setCzbz(Constant.CZBZ_U);
//                    apiInfoDataRep.save(infoData);
//                }
//            }
//        }
    }
}

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

@@ -1,20 +1,13 @@
package com.fzzy.push.sh2023;

import com.alibaba.fastjson.JSONObject;
import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService13;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.sh2023.dto.SH2023Api1311;
import com.fzzy.push.sh2023.dto.SH2023Api2103;
import com.fzzy.push.impl.ComPushService13;
import com.fzzy.push.impl.ComPushService99;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * ä¸Šæµ·å¸‚平台2023版-基础数据上传
@@ -30,27 +23,10 @@
    @Autowired
    private SH2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1301Rep api1301Rep;
    private ComPushService13 pushService13;
    @Autowired
    private Api1302Rep api1302Rep;
    @Autowired
    private Api1303Rep api1303Rep;
    @Autowired
    private Api1304Rep api1304Rep;
    @Autowired
    private Api1305Rep api1305Rep;
    @Autowired
    private Api1306Rep api1306Rep;
    @Autowired
    private Api1307Rep api1307Rep;
    @Autowired
    private Api1308Rep api1308Rep;
    @Autowired
    private Api1309Rep api1309Rep;
    @Autowired
    private Api1310Rep api1310Rep;
    @Autowired
    private ApiInfoDataRep apiInfoDataRep;
    private ComPushService99 pushService99;


    @Override
    public String getProtocol() {
@@ -61,325 +37,35 @@
    public void pushData(ApiParam param) {
        log.info("------->>>>粮库管理 æŽ¥å£æ¨¡å—上报开始");

//        this.pushData1301(apiRemoteService, param);
//        this.pushData1302(apiRemoteService, param);
//        this.pushData1303(apiRemoteService, param);
//        this.pushData1304(apiRemoteService, param);
//        this.pushData1305(apiRemoteService, param);
//        this.pushData1306(apiRemoteService, param);
//        this.pushData1307(apiRemoteService, param);
//        this.pushData1308(apiRemoteService, param);
//        this.pushData1309(apiRemoteService, param);
//        this.pushData1310(apiRemoteService, param);
//        this.pushData1311(apiRemoteService, param);
        pushService13.pushData1301(apiRemoteService, param);
        //粮情
        pushService13.pushData1302(apiRemoteService, param);

        //气体
        pushService13.pushData1304(apiRemoteService, param);

        //虫害
        pushService13.pushData1303(apiRemoteService, param);

        //通风
        pushService13.pushData1305(apiRemoteService, param);

        //熏蒸
        pushService13.pushData1306(apiRemoteService, param);
        //熏蒸
        pushService13.pushData1307(apiRemoteService, param);

        pushService13.pushData1308(apiRemoteService, param);

        pushService13.pushData1309(apiRemoteService, param);

        //质检
        pushService13.pushData1310(apiRemoteService, param);

        pushService99.pushData1311(apiRemoteService, param);
        pushService99.pushData2103(apiRemoteService, param);

        log.info("------->>>>粮库管理 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1301 å®‰å…¨ç®¡ç†
     */
    public void pushData1301(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取安全管理
        List<Api1301> list = api1301Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到安全管理，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1301);

        ResponseDto responseDto;
        for (Api1301 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);
                    //更新状态
                    api1301Rep.save(data);
                }
            }
        }
    }

    /**
     * 1302 æ¸©æ¹¿åº¦æ£€æµ‹
     */
    public void pushData1302(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取温湿度检测
        List<Api1302> list = api1302Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到温湿度检测，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1302);

        ResponseDto responseDto;
        for (Api1302 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);
                    //更新状态
                    api1302Rep.save(data);
                }
            }
        }
    }

    /**
     * 1303 å®³è™«æ£€æµ‹
     */
    public void pushData1303(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取害虫检测
        List<Api1303> list = api1303Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到害虫检测，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1303);

        ResponseDto responseDto;
        for (Api1303 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);
                    //更新状态
                    api1303Rep.save(data);
                }
            }
        }
    }

    /**
     * 1304 æ°”体检测
     */
    public void pushData1304(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取气体检测
        List<Api1304> list = api1304Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到气体检测，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1304);

        ResponseDto responseDto;
        for (Api1304 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);
                    //更新状态
                    api1304Rep.save(data);
                }
            }
        }

    }

    /**
     * 1305 é€šé£Žä½œä¸š
     */
    public void pushData1305(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取通风作业
        List<Api1305> list = api1305Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到通风作业，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1305);

        ResponseDto responseDto;
        for (Api1305 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);
                    //更新状态
                    api1305Rep.save(data);
                }
            }
        }
    }

    /**
     * 1306 ç†è’¸ä½œä¸š
     */
    public void pushData1306(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取熏蒸作业
        List<Api1306> list = api1306Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到熏蒸作业，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1306);

        ResponseDto responseDto;
        for (Api1306 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);
                    //更新状态
                    api1306Rep.save(data);
                }
            }
        }
    }

    /**
     * 1307 ä»“内视频图像
     */
    public void pushData1307(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取仓内视频图像
        List<Api1307> list = api1307Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到仓内视频图像，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1307);

        ResponseDto responseDto;
        for (Api1307 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);
                    //更新状态
                    api1307Rep.save(data);
                }
            }
        }

    }

    /**
     * 1308 è§†é¢‘监控异常事件告警
     */
    public void pushData1308(ApiRemoteService apiRemoteService, ApiParam param) {
        //TODO

    }

    /**
     * 1309 è¿è§„预警信息
     */
    public void pushData1309(ApiRemoteService apiRemoteService, ApiParam param) {
        //TODO

    }

    /**
     * 1310 è´¨æ£€æ•°æ®
     */
    public void pushData1310(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取质检数据
        List<Api1310> list = api1310Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到质检数据，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1310);

        ResponseDto responseDto;
        for (Api1310 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);
                    //更新状态
                    api1310Rep.save(data);
                }
            }
        }
    }

    /**
     * 1311 è§†é¢‘监控接口
     */
    public void pushData1311(ApiRemoteService apiRemoteService, ApiParam param) {
        // èŽ·å– è§†é¢‘监控接口数据
        List<ApiInfoData> items = apiInfoDataRep.getDataByInteId(SH2023Constant.SH_2023_API_CODE_1311);

        if (null == items || items.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到视频监控，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1311);

        SH2023Api1311 shApi1311;
        ResponseDto responseDto;
        for (ApiInfoData infoData : items) {
            shApi1311 = JSONObject.parseObject(infoData.getData(), SH2023Api1311.class);
            shApi1311.setZhgxsj(infoData.getUpdateTime());

            param.setBizId(infoData.getDataId());
            responseDto = apiRemoteService.pushData(param, shApi1311);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(infoData.getCzbz())) {
                    infoData.setCzbz(Constant.CZBZ_U);
                    apiInfoDataRep.save(infoData);
                }
            }
        }
    }

    /**
     * 2103 ç²®æƒ…设备配置
     */
    public void pushData2103(ApiRemoteService apiRemoteService, ApiParam param) {

        // èŽ·å–粮情设备配置数据
        List<ApiInfoData> items = apiInfoDataRep.getDataByInteId(SH2023Constant.SH_2023_API_CODE_2103);

        if (null == items || items.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到粮情设备配置，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_13);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_2103);

        SH2023Api2103 shApi2103;
        ResponseDto responseDto;
        for (ApiInfoData infoData : items) {
            shApi2103 = JSONObject.parseObject(infoData.getData(), SH2023Api2103.class);
            shApi2103.setZhgxsj(infoData.getUpdateTime());
            param.setBizId(infoData.getDataId());
            responseDto = apiRemoteService.pushData(param, shApi2103);
            if (responseDto.getSuccess() == 0) {
                if (Constant.CZBZ_I.equals(infoData.getCzbz())) {

                    infoData.setCzbz(Constant.CZBZ_U);
                    apiInfoDataRep.save(infoData);
                }
            }
        }
    }
}

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

@@ -1,17 +1,13 @@
package com.fzzy.push.sh2023;

import com.fzzy.api.Constant;
import com.fzzy.api.data.ApiParam;
import com.fzzy.api.data.PushProtocol;
import com.fzzy.api.dto.ResponseDto;
import com.fzzy.api.entity.*;
import com.fzzy.api.service.ApiRemoteService;
import com.fzzy.api.service.PushService14;
import com.fzzy.api.view.repository.*;
import com.fzzy.push.impl.ComPushService14;
import com.fzzy.push.impl.ComPushService99;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * ä¸Šæµ·å¸‚平台2023版-基础数据上传
@@ -27,19 +23,9 @@
    @Autowired
    private SH2023ApiRemoteService apiRemoteService;
    @Autowired
    private Api1401Rep api1401Rep;
    private ComPushService14 pushService14;
    @Autowired
    private Api1402Rep api1402Rep;
    @Autowired
    private Api1403Rep api1403Rep;
    @Autowired
    private Api1404Rep api1404Rep;
    @Autowired
    private Api1405Rep api1405Rep;
    @Autowired
    private Api1201Rep api1201Rep;
    @Autowired
    private Api1310Rep api1310Rep;
    private ComPushService99 pushService99;

    @Override
    public String getProtocol() {
@@ -50,209 +36,22 @@
    public void pushData(ApiParam param) {
        log.info("------->>>>行政管理 æŽ¥å£æ¨¡å—上报开始");

        //储备规模
        this.pushData1401(apiRemoteService, param);
        pushService14.pushData1401(apiRemoteService, param);

        pushService14.pushData1402(apiRemoteService, param);
        //轮换计划
        pushService14.pushData1403(apiRemoteService, param);
        //轮换计划明细
        pushService14.pushData1404(apiRemoteService, param);

        pushService14.pushData1405(apiRemoteService, param);

        //其他接口
        pushService99.pushData2203(apiRemoteService, param);
        pushService99.pushData2204(apiRemoteService, param);


        log.info("------->>>>行政管理 æŽ¥å£æ¨¡å—上报结束");
    }

    /**
     * 1401 å‚¨å¤‡è§„模
     */
    public void pushData1401(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取储备规模
        List<Api1401> list = api1401Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到储备规模，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1401);

        ResponseDto responseDto;
        for (Api1401 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);
                    //更新状态
                    api1401Rep.save(data);
                }
            }
        }
    }

    /**
     * 1402 å‚¨å¤‡è®¡åˆ’信息
     */
    public void pushData1402(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取储备计划
        List<Api1402> list = api1402Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到储备计划，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1402);

        ResponseDto responseDto;
        for (Api1402 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);
                    //更新状态
                    api1402Rep.save(data);
                }
            }
        }
    }

    /**
     * 1403 è½®æ¢è®¡åˆ’信息
     */
    public void pushData1403(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取轮换计划
        List<Api1403> list = api1403Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到轮换计划，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1403);

        ResponseDto responseDto;
        for (Api1403 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);
                    //更新状态
                    api1403Rep.save(data);
                }
            }
        }
    }

    /**
     * 1404 è½®æ¢è®¡åˆ’明细信息
     */
    public void pushData1404(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取轮换计划明细
        List<Api1404> list = api1404Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());

        if (null == list || list.isEmpty()) {
            log.error("-----上海市平台2023版：未获取到轮换计划明细，不推送-----");
            return;
        }
        param.setInteCategory(Constant.API_CATEGORY_14);
        param.setInteId(SH2023Constant.SH_2023_API_CODE_1404);

        ResponseDto responseDto;
        for (Api1404 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);
                    //更新状态
                    api1404Rep.save(data);
                }
            }
        }
    }

    /**
     * 1405 é¡¹ç›®ä¿¡æ¯
     */
    public void pushData1405(ApiRemoteService apiRemoteService, ApiParam param) {
//        TODO é¡¹ç›®ä¿¡æ¯ å¾…定
//        //获取项目信息
//        List<Api1405> list = api1405Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());
//
//        if (null == list || list.isEmpty()) {
//            log.error("-----上海市平台2023版：未获取到项目信息，不推送-----");
//            return;
//        }
//        param.setInteId(SH2023Constant.SH_2023_API_CODE_1405);
//        //推送，数据为集合形式
//        ResponseDto responseDto = apiRemoteService.pushData(param, list);
//        if (responseDto.getSuccess() == 0) {
//            //推送成功，更新数据上传状态
//            for (Api1405 data : list) {
//                if (Constant.CZBZ_I.equals(data.getCzbz())) {
//
//                    data.setCzbz(Constant.CZBZ_U);
//                    //更新状态
//                    api1405Rep.save(data);
//                }
//            }
//        }

    }

    /**
     * 2203 äº¤æ˜“中心合同
     */
    public void pushData2203(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取交易中心合同
//        List<Api1201> list = api1201Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());
//
//        if (null == list || list.isEmpty()) {
//            log.error("-----上海市平台2023版：未获取到轮换计划明细，不推送-----");
//            return;
//        }
//        param.setInteCategory(Constant.API_CATEGORY_14);
//        param.setInteId(SH2023Constant.SH_2023_API_CODE_2203);
//
//        ResponseDto responseDto;
//        for (Api1201 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);
//                    //更新状态
//                    api1201Rep.save(data);
//                }
//            }
//        }
    }

    /**
     * 2204 å®šåŒ–水检验
     */
    public void pushData2204(ApiRemoteService apiRemoteService, ApiParam param) {
        //获取定化水检验
//        List<Api1310> list = api1310Rep.findPushDataByTime(param.getKqdm(), param.getStart(), param.getEnd());
//
//        if (null == list || list.isEmpty()) {
//            log.error("-----上海市平台2023版：未获取到定化水检验，不推送-----");
//            return;
//        }
//        param.setInteCategory(Constant.API_CATEGORY_14);
//        param.setInteId(SH2023Constant.SH_2023_API_CODE_2204);
//
//        ResponseDto responseDto;
//        for (Api1310 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);
//                    //更新状态
//                    api1310Rep.save(data);
//                }
//            }
//        }
    }
}

 src/main/java/com/fzzy/test/ApiTest.view.xml

ÎļþÒÑɾ³ý

 src/main/java/com/fzzy/test/ApiTestPR.java

ÎļþÒÑɾ³ý

 src/main/resources/application-dev.yml

@@ -6,17 +6,18 @@
    #主数据源
    primary:
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5016?useUnicode=true&useSSL=false&characterEncoding=utf-8     #大湾区
      url: jdbc:mysql://127.0.0.1:3306/igds_api_5303?useUnicode=true&useSSL=false&characterEncoding=utf-8     #上海嘉定
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5303?useUnicode=true&useSSL=false&characterEncoding=utf-8     #上海嘉定
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5306?useUnicode=true&useSSL=false&characterEncoding=utf-8     #宁夏石嘴山
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5311?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广澳
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5317?useUnicode=true&useSSL=false&characterEncoding=utf-8     #潮阳库
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5317_002?useUnicode=true&useSSL=false&characterEncoding=utf-8     #潮阳库
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5320?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广东台山
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5321?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广东韶关
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5322?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广东徐闻
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5326?useUnicode=true&useSSL=false&characterEncoding=utf-8     #惠州惠新
      url: jdbc:mysql://127.0.0.1:3306/igds_api_5326?useUnicode=true&useSSL=false&characterEncoding=utf-8     #惠州惠新
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5327?useUnicode=true&useSSL=false&characterEncoding=utf-8     #武汉黄陂军粮
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5329?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广东佛山禅城区
      url: jdbc:mysql://127.0.0.1:3306/igds_api_5348?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广东汕头潮南
#      url: jdbc:mysql://127.0.0.1:3306/igds_api_5348?useUnicode=true&useSSL=false&characterEncoding=utf-8     #广东汕头潮南
      username: root
      password: Abc123..
      driver-class-name: com.mysql.jdbc.Driver
@@ -30,9 +31,9 @@
#      url: jdbc:mysql://127.0.0.1:3306/igds_3.5_5320?useUnicode=true&useSSL=false&characterEncoding=utf-8
#      url: jdbc:mysql://127.0.0.1:3306/igds_3.5_5321?useUnicode=true&useSSL=false&characterEncoding=utf-8
#      url: jdbc:mysql://127.0.0.1:3306/igds_4.0_5322?useUnicode=true&useSSL=false&characterEncoding=utf-8  #广东徐闻
#      url: jdbc:mysql://127.0.0.1:3306/igds_4.0_5326?useUnicode=true&useSSL=false&characterEncoding=utf-8  #惠州惠新
      url: jdbc:mysql://127.0.0.1:3306/igds_4.0_5326?useUnicode=true&useSSL=false&characterEncoding=utf-8  #惠州惠新
#      url: jdbc:mysql://127.0.0.1:3306/igds_4.0_5327?useUnicode=true&useSSL=false&characterEncoding=utf-8  #武汉黄陂军粮
      url: jdbc:mysql://127.0.0.1:3306/igds_4.0_5348?useUnicode=true&useSSL=false&characterEncoding=utf-8  #广东汕头潮南
#      url: jdbc:mysql://127.0.0.1:3306/igds_4.0_5348?useUnicode=true&useSSL=false&characterEncoding=utf-8  #广东汕头潮南
      username: root
      password: Abc123..
      driver-class-name: com.mysql.jdbc.Driver

 src/main/resources/application-pro.yml

@@ -1,4 +1,4 @@
##########################  ä¸Šæµ·å˜‰å®š -C盘 pro2   ##########################
##########################  ä¸Šæµ·å˜‰å®š -C盘 pro   ##########################
server:
  port: 8090
  jetty: