package info.aspirecn.iov.sjjh.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import info.aspirecn.iov.sjjh.commons.lang.ChannelTypeHandleResponseObject;
import info.aspirecn.iov.sjjh.commons.lang.Constant;
import info.aspirecn.iov.sjjh.config.SupplierConfig;
import info.aspirecn.iov.sjjh.constant.Constants;
import info.aspirecn.iov.sjjh.entity.*;
import info.aspirecn.iov.sjjh.enums.VehicleHistoryPositionQueryType;
import info.aspirecn.iov.sjjh.service.VehicleService;
import info.aspirecn.iov.sjjh.util.DateUtil;
import info.aspirecn.iov.sjjh.util.PostUtil;
import info.aspirecn.iov.sjjh.util.ValidateParamUtil;
import info.aspirecn.rdc.aspirecloud.node.except.utils.ErrorUtils;
import lombok.extern.slf4j.Slf4j;
import okhttp3.OkHttpClient;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author xusonglin
 * @version V1.0
 **/
@Slf4j
@Service
public class VehicleServiceImpl implements VehicleService {
    @Autowired
    private SupplierConfig supplierConfig;

    private OkHttpClient okHttpClient = new OkHttpClient.Builder().build();

    @Override
    public ChannelTypeHandleResponseObject vehicleHistoryPositionQuery(HttpServletRequest request, String customBody,
                                                                       int outTime, Integer type) {
        ChannelTypeHandleResponseObject ret = new ChannelTypeHandleResponseObject();
        ret.setIsCharge(Constant.INTERFACE_QUERY_NO_FEE);
        ret.setCode(Constant.SUCCESS);
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        if (outTime <= Constants.PARA_ZERO) {
            outTime = Constant.HTTPCLIENT_CONNECTTIMEOUT;
        }

        log.info("supplier-vehicle.vehicleHistoryPositionQuery---customBody={},outTime={}", customBody, outTime);
        // 解析参数
        ObjectMapper objectMapper = new ObjectMapper();
        VehicleHistoryPositionRequestParam requestParam;
        try {
            objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            requestParam = objectMapper.readValue(customBody, VehicleHistoryPositionRequestParam.class);
        } catch (IOException ioe) {
            log.info("supplier-vehicle.vehicleHistoryPositionQuery-解析参数Exception：{}", ioe);
            ErrorUtils.captureException(ioe);
            ret.setCode(Constant.FAIL);
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 参数校验
        if (!ValidateParamUtil.validateRequestParams(requestParam)) {
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        if (type.equals(VehicleHistoryPositionQueryType.VEHICLE_HISTORY_POSITION_QUERY.getValue())) {
            // 车辆轨迹核验
            upstreamCode = setVehicleHistoryPositionQueryResponse(ret, outTime, requestParam);

        } else {
            // 车辆线上线下一致性验证
            upstreamCode = vehiclePositionConsistencyTwoCheck(ret, outTime, requestParam);
        }

        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        return ret;
    }

    /*----------------------------------------------------新增开始----------------------------------------------------*/

    private String setVehicleHistoryPositionQueryResponse(ChannelTypeHandleResponseObject ret, int outTime,
                                                          VehicleHistoryPositionRequestParam requestParam){
        String upstreamCode = "";
        String result = vehiclePositionConsistencyTwoCheck(ret, outTime, requestParam);
        if (Constants.RESULT_CODE_0.equals(result)) {
            // 接口调用
            Response response = new Response();
            try {
                RequestObject requestObject = new RequestObject();
                requestObject.setVehicleNumber(requestParam.getPlateNumber());
                requestObject.setLicensePlateTypeCode(requestParam.getPlateColor());
                requestObject.setStartTime(DateUtil.addHours(requestParam.getStartTime(), supplierConfig.getReduceHours()));
                requestObject.setEndTime(DateUtil.addHours(requestParam.getEndTime(), supplierConfig.getAddHours()));
                requestObject.setPartyFunctionCode(supplierConfig.getPartyFunctionCode());
                response = PostUtil.postString(supplierConfig.getHistoryPositionUrl(), JSON.toJSONString(requestObject),
                        supplierConfig.getAppKey(), supplierConfig.getAppSecret(), outTime);
                log.info("supplier-vehicle.vehicleHistoryPositionQuery-responseStatus：{}", response.getStatusCode());
                log.info("supplier-vehicle.vehicleHistoryPositionQuery-responseBody：{}", response.getBody());
                if (response.getStatusCode() == Constants.STATUS_CODE_200) {
                    VehicleHistoryPositionResponse positionResponse = JSON.toJavaObject(JSON.parseObject(response.getBody()),
                            VehicleHistoryPositionResponse.class);
                    upstreamCode = positionResponse.getResultCode();
                    if (positionResponse.getResultCode().equals(Constants.RESULT_CODE_0)) {
                        if (positionResponse.getData() != null && positionResponse.getData().size() > 0) {
                            JSONObject vehicleLocationInfo = new JSONObject();
                            vehicleLocationInfo.put("vehicleLocationInfo", positionResponse.getData());
                            ret.setResultCode(Constant.MATCH_CODE);
                            ret.setResultBody(vehicleLocationInfo);
                            ret.setResultDesc(Constant.QUERY_SUCCESS);
                        } else {
                            ret.setResultCode(Constant.UN_FIND_NUM_CODE);
                            ret.setResultBody(Constants.NO_RESULT);
                            ret.setResultDesc(Constants.NO_RESULT);
                        }
                        ret.setIsCharge(Constant.IS_CHARGE);
                    } else if (positionResponse.getResultCode().equals(Constants.RESULT_CODE_110000)) {
                        ret.setResultCode(Constant.UN_FIND_NUM_CODE);
                        ret.setResultBody(Constants.NO_RESULT);
                        ret.setResultDesc(Constants.NO_RESULT);
                    } else {
                        ret.setResultCode(Constant.OTHER_ERROR_CODE);
                        ret.setResultBody(Constant.OTHER_ERROR);
                        ret.setResultDesc(Constant.OTHER_ERROR);
                    }
                } else {
                    ret.setResultCode(Constant.OTHER_ERROR_CODE);
                    ret.setResultBody(Constant.OTHER_ERROR);
                    ret.setResultDesc(Constant.OTHER_ERROR);
                    upstreamCode += response.getStatusCode();
                }
            } catch (IOException e) {
                log.info("supplier-vehicle.vehicleHistoryPositionQuery-IOException：{}", e);
                ErrorUtils.captureException(e);
                ret.setCode(Constant.REQUEST_TIMEOUT);
            } catch (Exception e) {
                log.info("supplier-vehicle.vehicleHistoryPositionQuery-Exception：{}", e);
                ErrorUtils.captureException(e);
                ret.setCode(Constant.FAIL);
            }
        }
        return upstreamCode;
    }

    private String vehiclePositionConsistencyTwoCheck(ChannelTypeHandleResponseObject ret, int outTime,
                                                      VehicleHistoryPositionRequestParam requestParam){
        ChannelTypeHandleResponseObject retA = new ChannelTypeHandleResponseObject();
        ChannelTypeHandleResponseObject retB = new ChannelTypeHandleResponseObject();
        String upstreamCodeA = "";
        String upstreamCodeB = "";
        String errMsgA = "loadingCountrySubdivisionCode";
        String errMsgB = "receiptCountrySubdivisionCode";
        /**
         * 1、云雁分调取A-到A+和B-到B+的轨迹，并取这两段轨迹中的每个点的行政区划代码合集X和合集Y
         * 2、将合集X分别与A点行政区划进行比对，只要有一点比对一致则视为此点核验通过
         * 3、将合集Y分别与B点行政区划进行比对，只要有一点比对一致则视为此点核验通过
         * 4、A点和B点均核验通过视为此核验项通过
         */
        // A-
        String startTimeA = DateUtil.addHours(requestParam.getStartTime(), supplierConfig.getReduceHours());
        // A+
        String endTimeA = DateUtil.addHours(requestParam.getStartTime(), supplierConfig.getAddHours());

        // B-
        String startTimeB = DateUtil.addHours(requestParam.getEndTime(), supplierConfig.getReduceHours());
        // B+
        String endTimeB = DateUtil.addHours(requestParam.getEndTime(), supplierConfig.getAddHours());

        // A段接口调用
        Response responseA = new Response();
        try {
            RequestObject requestObject = new RequestObject();
            requestObject.setVehicleNumber(requestParam.getPlateNumber());
            requestObject.setLicensePlateTypeCode(requestParam.getPlateColor());
            requestObject.setStartTime(startTimeA);
            requestObject.setEndTime(endTimeA);
            requestObject.setPartyFunctionCode(supplierConfig.getPartyFunctionCode());
            responseA = PostUtil.postString(supplierConfig.getHistoryPositionUrl(), JSON.toJSONString(requestObject),
                    supplierConfig.getAppKey(), supplierConfig.getAppSecret(), outTime);
        } catch (IOException e) {
            log.info("supplier-vehicle.vehicleHistoryAPositionQuery-IOException：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.REQUEST_TIMEOUT);
        } catch (Exception e) {
            log.info("supplier-vehicle.vehicleHistoryAPositionQuery-Exception：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.FAIL);
        }
        List<String> errList = new ArrayList<>();
        if (responseA.getStatusCode() == Constants.STATUS_CODE_200) {
            VehicleHistoryPositionResponse positionResponseA = JSON.toJavaObject(JSON.parseObject(responseA.getBody()),
                    VehicleHistoryPositionResponse.class);
            upstreamCodeA = positionResponseA.getResultCode();
            if (positionResponseA.getResultCode().equals(Constants.RESULT_CODE_0)) {
                if (positionResponseA.getData() != null && positionResponseA.getData().size() > 0) {
                    String resultA = vehiclePositionConsistencyACheck(positionResponseA.getData(), requestParam);
                    if (StringUtils.isBlank(resultA)) {
                        retA.setResultCode(Constant.MATCH_CODE);
                        retA.setResultBody(Constant.MATCH);
                        retA.setResultDesc(Constant.QUERY_SUCCESS);
                    } else {
                        errList.add(resultA);
                        retA.setResultCode(Constant.UN_MATCH_CODE);
                        retA.setResultBody(errList);
                        retA.setResultDesc(Constant.QUERY_SUCCESS);
                    }
                } else {
                    errList.add(errMsgA);
                    retA.setResultCode(Constant.UN_FIND_NUM_CODE);
                    retA.setResultBody(Constants.NO_RESULT);
                    retA.setResultDesc(Constants.NO_RESULT);
                }
                retA.setIsCharge(Constant.IS_CHARGE);
            } else if (positionResponseA.getResultCode().equals(Constants.RESULT_CODE_110000)) {
                errList.add(errMsgA);
                retA.setResultCode(Constant.UN_FIND_NUM_CODE);
                retA.setResultBody(Constants.NO_RESULT);
                retA.setResultDesc(Constants.NO_RESULT);
            } else {
                retA.setResultCode(Constant.OTHER_ERROR_CODE);
                retA.setResultBody(Constant.OTHER_ERROR);
                retA.setResultDesc(Constant.OTHER_ERROR);
            }
        } else {
            retA.setResultCode(Constant.OTHER_ERROR_CODE);
            retA.setResultBody(Constant.OTHER_ERROR);
            retA.setResultDesc(Constant.OTHER_ERROR);
            upstreamCodeA = Integer.toString(responseA.getStatusCode());
        }
        // B段接口调用
        Response responseB = new Response();
        try {
            RequestObject requestObject = new RequestObject();
            requestObject.setVehicleNumber(requestParam.getPlateNumber());
            requestObject.setLicensePlateTypeCode(requestParam.getPlateColor());
            requestObject.setStartTime(startTimeB);
            requestObject.setEndTime(endTimeB);
            requestObject.setPartyFunctionCode(supplierConfig.getPartyFunctionCode());
            responseB = PostUtil.postString(supplierConfig.getHistoryPositionUrl(), JSON.toJSONString(requestObject),
                    supplierConfig.getAppKey(), supplierConfig.getAppSecret(), outTime);
        } catch (IOException e) {
            log.info("supplier-vehicle.vehicleHistoryAPositionQuery-IOException：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.REQUEST_TIMEOUT);
        } catch (Exception e) {
            log.info("supplier-vehicle.vehicleHistoryAPositionQuery-Exception：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.FAIL);
        }

        if (responseB.getStatusCode() == Constants.STATUS_CODE_200) {
            VehicleHistoryPositionResponse positionResponseB = JSON.toJavaObject(JSON.parseObject(responseB.getBody()),
                    VehicleHistoryPositionResponse.class);
            upstreamCodeB = positionResponseB.getResultCode();
            if (positionResponseB.getResultCode().equals(Constants.RESULT_CODE_0)) {
                if (positionResponseB.getData() != null && positionResponseB.getData().size() > 0) {
                    String resultB = vehiclePositionConsistencyBCheck(positionResponseB.getData(), requestParam);
                    if (StringUtils.isBlank(resultB)) {
                        retB.setResultCode(Constant.MATCH_CODE);
                        retB.setResultBody(Constant.MATCH);
                        retB.setResultDesc(Constant.QUERY_SUCCESS);
                    } else {
                        errList.add(resultB);
                        retB.setResultCode(Constant.UN_MATCH_CODE);
                        retB.setResultBody(errList);
                        retB.setResultDesc(Constant.QUERY_SUCCESS);
                    }
                } else {
                    errList.add(errMsgB);
                    retB.setResultCode(Constant.UN_FIND_NUM_CODE);
                    retB.setResultBody(Constants.NO_RESULT);
                    retB.setResultDesc(Constants.NO_RESULT);
                }
                ret.setIsCharge(Constant.IS_CHARGE);
            } else if (positionResponseB.getResultCode().equals(Constants.RESULT_CODE_110000)) {
                errList.add(errMsgB);
                retB.setResultCode(Constant.UN_FIND_NUM_CODE);
                retB.setResultBody(Constants.NO_RESULT);
                retB.setResultDesc(Constants.NO_RESULT);
            } else {
                retB.setResultCode(Constant.OTHER_ERROR_CODE);
                retB.setResultBody(Constant.OTHER_ERROR);
                retB.setResultDesc(Constant.OTHER_ERROR);
            }
        } else {
            retB.setResultCode(Constant.OTHER_ERROR_CODE);
            retB.setResultBody(Constant.OTHER_ERROR);
            retB.setResultDesc(Constant.OTHER_ERROR);
            upstreamCodeB = Integer.toString(responseA.getStatusCode());
        }

        // A、B两点都比对通过
        if(retA.getResultCode()==Constant.MATCH_CODE&&retB.getResultCode()==Constant.MATCH_CODE){
            ret.setResultCode(Constant.MATCH_CODE);
            ret.setResultBody(Constant.MATCH);
            ret.setResultDesc(Constant.QUERY_SUCCESS);
            return upstreamCodeA;
        }

        // A点其他错误，直接返回A点错误
        if(retA.getResultCode()==Constant.OTHER_ERROR_CODE){
            ret.setResultCode(retA.getResultCode());
            ret.setResultDesc(retA.getResultDesc());
            ret.setResultBody(retA.getResultBody());
            return upstreamCodeA;
        }
        
        // B点其他错误，直接返回B点错误
        if(retB.getResultCode()==Constant.OTHER_ERROR_CODE){
            ret.setResultCode(retB.getResultCode());
            ret.setResultDesc(retB.getResultDesc());
            ret.setResultBody(retB.getResultBody());
            return upstreamCodeB;
        }

        // A、B点为无返回结果，状态码4
        if(retA.getResultCode()==Constant.UN_FIND_NUM_CODE && retB.getResultCode()==Constant.UN_FIND_NUM_CODE){
            ret.setResultCode(Constant.UN_FIND_NUM_CODE);
            ret.setResultBody(errList);
            ret.setResultDesc(Constant.QUERY_SUCCESS);
            return upstreamCodeA;
        }

        // errList有数据时，状态码2
        if(errList.size()>0){
            ret.setResultCode(Constant.UN_MATCH_CODE);
            ret.setResultBody(errList);
            ret.setResultDesc(Constant.QUERY_SUCCESS);
            return upstreamCodeA;
        }
        return "";
    }

    private String vehiclePositionConsistencyACheck(List<VehicleHistoryPositionResponse.Data> positionList,
                                                    VehicleHistoryPositionRequestParam requestParam) {
        boolean checkResultA = false;
        for (VehicleHistoryPositionResponse.Data position : positionList) {
            if (!requestParam.getLoadingCountrySubdivisionCode().equals(position.getPositionDescribe())) {
                checkResultA = true;
            }
            if (checkResultA) {
                break;
            }
        }
        if (!checkResultA) {
            return "loadingCountrySubdivisionCode";
        }
        return "";
    }

    private String vehiclePositionConsistencyBCheck(List<VehicleHistoryPositionResponse.Data> positionList,
                                                    VehicleHistoryPositionRequestParam requestParam) {
        boolean checkResultB = false;
        for (VehicleHistoryPositionResponse.Data position : positionList) {
            if (!requestParam.getReceiptCountrySubdivisionCode().equals(position.getPositionDescribe())) {
                checkResultB = true;
            }
            if (checkResultB) {
                break;
            }
        }
        if (!checkResultB) {
            return "receiptCountrySubdivisionCode";
        }
        return "";
    }

    /*----------------------------------------------------新增结束----------------------------------------------------*/

    private String setVehicleHistoryPositionQueryResponse(ChannelTypeHandleResponseObject ret, Response response,
                                                          VehicleHistoryPositionRequestParam requestParam) {
        String upstreamCode = "";
        log.info("supplier-vehicle.vehicleHistoryPositionQuery-responseStatus：{}", response.getStatusCode());
        log.info("supplier-vehicle.vehicleHistoryPositionQuery-responseBody：{}", response.getBody());
        if (response.getStatusCode() == Constants.STATUS_CODE_200) {
            VehicleHistoryPositionResponse positionResponse = JSON.toJavaObject(JSON.parseObject(response.getBody()),
                    VehicleHistoryPositionResponse.class);
            upstreamCode = positionResponse.getResultCode();
            if (positionResponse.getResultCode().equals(Constants.RESULT_CODE_0)) {
                if (positionResponse.getData() != null && positionResponse.getData().size() > 0) {
                    String result = vehicleHistoryPositionQuery(positionResponse.getData(), requestParam);
                    if (StringUtils.isBlank(result)) {
                        JSONObject vehicleLocationInfo = new JSONObject();
                        vehicleLocationInfo.put("vehicleLocationInfo", positionResponse.getData());
                        ret.setResultCode(Constant.MATCH_CODE);
                        ret.setResultBody(vehicleLocationInfo);
                        ret.setResultDesc(Constant.QUERY_SUCCESS);
                    } else {
                        ret.setResultCode(Constant.UN_MATCH_CODE);
                        ret.setResultBody(result);
                        ret.setResultDesc(Constant.QUERY_SUCCESS);
                    }
                } else {
                    ret.setResultCode(Constant.UN_FIND_NUM_CODE);
                    ret.setResultBody(Constants.NO_RESULT);
                    ret.setResultDesc(Constants.NO_RESULT);
                }
                ret.setIsCharge(Constant.IS_CHARGE);
            } else if (positionResponse.getResultCode().equals(Constants.RESULT_CODE_110000)) {
                ret.setResultCode(Constant.UN_FIND_NUM_CODE);
                ret.setResultBody(Constants.NO_RESULT);
                ret.setResultDesc(Constants.NO_RESULT);
            } else {
                ret.setResultCode(Constant.OTHER_ERROR_CODE);
                ret.setResultBody(Constant.OTHER_ERROR);
                ret.setResultDesc(Constant.OTHER_ERROR);
            }
        } else {
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
            upstreamCode += response.getStatusCode();
        }
        return upstreamCode;
    }

    private String vehicleHistoryPositionQuery(List<VehicleHistoryPositionResponse.Data> positionList,
                                               VehicleHistoryPositionRequestParam requestParam) {
        /**
         * 1、云雁调取A-到B+之间所有的车辆轨迹（每30秒有一个经纬度数据）。
         * 2、从A-到A+时间区间中每半个小时抽取一个点位信息的行政区划代码集合，将此集合与A点（起点）行政区划代码进行比对，只要有一点比对一致则视为此点核验通过。
         * 3、从B-到B+时间区间中每半个小时抽取一个点位信息并转化为行政区划代码集合，将此集合与B点（终点）行政区划代码进行比对，只要有一点比对一致则视为此点核验通过。
         * 4、A点到B点时间小于8小时情况依然按次逻辑处理，不做区分。
         * 5、A点和B点都核验通过下视为该条轨迹核验通过，否则为核验不通过。
         * 6、核验不通过情况下返回核验不通过。
         * 7、核验结果一致的情况下输出结果，并输出A点到B点轨迹信息。
         */
        // A-
        String startTimeA = DateUtil.addHours(requestParam.getStartTime(), supplierConfig.getReduceHours());
        // A+
        String endTimeA = DateUtil.addHours(requestParam.getStartTime(), supplierConfig.getAddHours());
        // B-
        String startTimeB = DateUtil.addHours(requestParam.getEndTime(), supplierConfig.getReduceHours());
        // B+
        String endTimeB = DateUtil.addHours(requestParam.getEndTime(), supplierConfig.getAddHours());

        // 4小时*2=8小时（A-A+间隔），8小时*2=16个点（每半个小时取1个点）
        int pointNumber = supplierConfig.getAddHours()*2*2;

        /**
         * A点，装货点，8小时16个点，进行处理各个点的时间点
         */
        List<String> checkTimeListA = new ArrayList<>();
        String tempStartTime = startTimeA;
        for (int i = 0; i < pointNumber+1; i++) {
            checkTimeListA.add(tempStartTime);
            tempStartTime = DateUtil.addMinutes(tempStartTime, 30);
        }

        List<String> checkTimeListB = new ArrayList<>();
        tempStartTime = startTimeB;
        for (int i = 0; i < pointNumber+1; i++) {
            checkTimeListB.add(tempStartTime);
            tempStartTime = DateUtil.addMinutes(tempStartTime, 30);
        }

        boolean checkResultA = false;
        // 这个集合为了查看位置是否正确
        List<VehicleHistoryPositionResponse.Data> verificationPositionListA = new ArrayList<>();
        for (int i = 0; i < checkTimeListA.size()-1; i++) {
            for (VehicleHistoryPositionResponse.Data position : positionList) {
                if (Long.parseLong(position.getPositionTime()) > Long.parseLong(checkTimeListA.get(i))
                        && Long.parseLong(position.getPositionTime()) <= Long.parseLong(checkTimeListA.get(i+1))) {
                    verificationPositionListA.add(position);
                    if (requestParam.getLoadingCountrySubdivisionCode().equals(position.getPositionDescribe())) {
                        checkResultA = true;
                    }
                    break;
                }
            }
            if (checkResultA) {
                break;
            }
        }
        if (!checkResultA) {
            return "loadingCountrySubdivisionCode与数据源不一致";
        }

        boolean checkResultB = false;
        // 这个集合为了查看位置是否正确
        List<VehicleHistoryPositionResponse.Data> verificationPositionListB = new ArrayList<>();
        for (int i = 0; i < checkTimeListB.size()-1; i++) {
            for (VehicleHistoryPositionResponse.Data position : positionList) {
                if (Long.parseLong(position.getPositionTime()) > Long.parseLong(checkTimeListB.get(i))
                        && Long.parseLong(position.getPositionTime()) <= Long.parseLong(checkTimeListB.get(i+1))) {
                    verificationPositionListB.add(position);
                    if (requestParam.getReceiptCountrySubdivisionCode().equals(position.getPositionDescribe())) {
                        checkResultB = true;
                    }
                    break;
                }
            }
            if (checkResultB) {
                break;
            }
        }

        if (checkResultA && checkResultB) {
            return "";
        } else {
            return  "receiptCountrySubdivisionCode与数据源不一致";
        }
    }

    private String setVehiclePositionConsistencyCheckResponse(ChannelTypeHandleResponseObject ret, Response response,
                                                              VehicleHistoryPositionRequestParam requestParam) {
        String upstreamCode = "";
        log.info("supplier-vehicle.vehicleHistoryPositionCheck-responseStatus：{}", response.getStatusCode());
        log.info("supplier-vehicle.vehicleHistoryPositionCheck-responseBody：{}", response.getBody());
        if (response.getStatusCode() == Constants.STATUS_CODE_200) {
            VehicleHistoryPositionResponse positionResponse = JSON.toJavaObject(JSON.parseObject(response.getBody()),
                    VehicleHistoryPositionResponse.class);
            upstreamCode = positionResponse.getResultCode();
            if (positionResponse.getResultCode().equals(Constants.RESULT_CODE_0)) {
                if (positionResponse.getData() != null && positionResponse.getData().size() > 0) {
                    String result = vehiclePositionConsistencyCheck(positionResponse.getData(), requestParam);
                    if (StringUtils.isBlank(result)) {
                        ret.setResultCode(Constant.MATCH_CODE);
                        ret.setResultBody(Constant.MATCH);
                        ret.setResultDesc(Constant.QUERY_SUCCESS);
                    } else {
                        ret.setResultCode(Constant.UN_MATCH_CODE);
                        ret.setResultBody(result);
                        ret.setResultDesc(Constant.QUERY_SUCCESS);
                    }
                } else {
                    ret.setResultCode(Constant.UN_FIND_NUM_CODE);
                    ret.setResultBody(Constants.NO_RESULT);
                    ret.setResultDesc(Constants.NO_RESULT);
                }
                ret.setIsCharge(Constant.IS_CHARGE);
            } else if (positionResponse.getResultCode().equals(Constants.RESULT_CODE_110000)) {
                ret.setResultCode(Constant.UN_FIND_NUM_CODE);
                ret.setResultBody(Constants.NO_RESULT);
                ret.setResultDesc(Constants.NO_RESULT);
            } else {
                ret.setResultCode(Constant.OTHER_ERROR_CODE);
                ret.setResultBody(Constant.OTHER_ERROR);
                ret.setResultDesc(Constant.OTHER_ERROR);
            }
        } else {
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
            upstreamCode += response.getStatusCode();
        }
        return upstreamCode;
    }

    private String vehiclePositionConsistencyCheck(List<VehicleHistoryPositionResponse.Data> positionList,
                                                   VehicleHistoryPositionRequestParam requestParam) {
        /**
         * 1、云雁调取A-到B+之间的车辆轨迹
         * 2、将B点与B-到B+时间点内的行政区划代码做对比，得出比对结果一
         *    将A点与A-到A+时间点内的行政区划代码做对比，得出比对结果二
         * 3、核验结果有一个不一致的情况下返回不一致结果
         * 4、核验结果一致的情况下一致结果
         */
        // A-
        String startTimeA = DateUtil.addHours(requestParam.getStartTime(), supplierConfig.getReduceHours());
        // B-
        String startTimeB = DateUtil.addHours(requestParam.getEndTime(), supplierConfig.getReduceHours());

        // 4小时*2=8小时（A-A+间隔），8小时*2=16个点（每半个小时取1个点）
        int pointNumber = supplierConfig.getAddHours()*2*2;

        List<String> checkTimeListA = new ArrayList<>();
        String tempStartTime = startTimeA;
        for (int i = 0; i < pointNumber+1; i++) {
            checkTimeListA.add(tempStartTime);
            tempStartTime = DateUtil.addMinutes(tempStartTime, 30);
        }

        List<String> checkTimeListB = new ArrayList<>();
        tempStartTime = startTimeB;
        for (int i = 0; i < pointNumber+1; i++) {
            checkTimeListB.add(tempStartTime);
            tempStartTime = DateUtil.addMinutes(tempStartTime, 30);
        }

        // 这个集合为了查看位置是否正确
        List<VehicleHistoryPositionResponse.Data> verificationPositionListA = new ArrayList<>();
        for (int i = 0; i < checkTimeListA.size()-1; i++) {
            for (VehicleHistoryPositionResponse.Data position : positionList) {
                if (Long.parseLong(position.getPositionTime()) > Long.parseLong(checkTimeListA.get(i))
                        && Long.parseLong(position.getPositionTime()) <= Long.parseLong(checkTimeListA.get(i+1))) {
                    verificationPositionListA.add(position);
                    if (!requestParam.getLoadingCountrySubdivisionCode().equals(position.getPositionDescribe())) {
                        return "loadingCountrySubdivisionCode";
                    }
                    break;
                }
            }
        }

        // 这个集合为了查看位置是否正确
        List<VehicleHistoryPositionResponse.Data> verificationPositionListB = new ArrayList<>();
        for (int i = 0; i < checkTimeListB.size()-1; i++) {
            for (VehicleHistoryPositionResponse.Data position : positionList) {
                if (Long.parseLong(position.getPositionTime()) > Long.parseLong(checkTimeListB.get(i))
                        && Long.parseLong(position.getPositionTime()) <= Long.parseLong(checkTimeListB.get(i+1))) {
                    verificationPositionListB.add(position);
                    if (!requestParam.getReceiptCountrySubdivisionCode().equals(position.getPositionDescribe())) {
                        return "receiptCountrySubdivisionCode";
                    }
                    break;
                }
            }
        }
        return "";
    }

    @Override
    public ChannelTypeHandleResponseObject checkVehicleRoadTransport(HttpServletRequest request, String customBody, int outTime) {
        ChannelTypeHandleResponseObject ret = new ChannelTypeHandleResponseObject();
        ret.setIsCharge(Constant.INTERFACE_QUERY_NO_FEE);
        ret.setCode(Constant.SUCCESS);
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        if (outTime <= Constants.PARA_ZERO) {
            outTime = Constant.HTTPCLIENT_CONNECTTIMEOUT;
        }

        log.info("supplier-vehicle.checkVehicleRoadTransport---customBody={},outTime={}", customBody, outTime);
        // 解析参数
        ObjectMapper objectMapper = new ObjectMapper();
        VehicleRoadTransportPermitRequestParam requestParam;
        try {
            requestParam = objectMapper.readValue(customBody, VehicleRoadTransportPermitRequestParam.class);
        } catch (IOException ioe) {
            log.info("supplier-vehicle.checkVehicleRoadTransport-解析参数Exception：{}", ioe);
            ErrorUtils.captureException(ioe);
            ret.setCode(Constant.FAIL);
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 参数校验
        if (!ValidateParamUtil.validateRequestParams(requestParam)) {
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 接口调用
        String responseContext = "";
        try {
            okhttp3.Response response = PostUtil.postString(supplierConfig.getVehicleRoadTransportUrl(), JSON.toJSONString(requestParam), outTime);
            if (response.body() != null) {
                responseContext = response.body().string();
                upstreamCode = setVehicleRoadTransportResponse(ret, responseContext);
            } else {
                ret.setCode(Constant.FAIL);
            }
            log.info("responseContext:{}", responseContext);
        } catch (IOException e) {
            log.info("supplier-vehicle.vehicleHistoryPositionQuery-IOException：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.REQUEST_TIMEOUT);
        } catch (Exception e) {
            log.info("supplier-vehicle.vehicleHistoryPositionQuery-Exception：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.FAIL);
        }

        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        return ret;
    }

    private String setVehicleRoadTransportResponse(ChannelTypeHandleResponseObject ret, String responseContext) {
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        RoadTransportPermitResponse responseObject = JSON.toJavaObject(JSON.parseObject(responseContext),
                RoadTransportPermitResponse.class);
        if (responseObject == null) {
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
            return upstreamCode;
        }

        String resultCode = responseObject.getResultCode();
        upstreamCode = resultCode;
        List<String> errorList = new ArrayList<>();
        if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_0)) {
            if (responseObject.getData().getVerifyResultSet().get(0).getResult().equals("0")) {
                // 一致
                ret.setResultCode(Constant.MATCH_CODE);
                ret.setResultBody(Constant.MATCH);
                ret.setResultDesc(Constant.QUERY_SUCCESS);
            } else {
                // 不一致，返回具体不一致项
                String errorInfo = responseObject.getData().getVerifyResultSet().get(0).getErrorInfo();
                if (errorInfo.equals(Constants.UN_MATCH_VEHICLE_NUMBER)) {
                    errorList.add("vehicleNumber");
                }
                if (errorInfo.equals(Constants.UN_MATCH_ROAD_TRANSPORT_CERTIFICATE_NUMBER)) {
                    errorList.add("roadTransportCertificateNumber");
                }
                if (errorInfo.equals(Constants.UN_MATCH_CERTIFICATE_VALID_PERIOD_FROM)) {
                    errorList.add("roadTransportCertificateValidPeriodFrom");
                }
                if (errorInfo.equals(Constants.UN_MATCH_CERTIFICATE_VALID_PERIOD_TO)){
                    errorList.add("roadTransportCertificateValidPeriodTo");
                }
                ret.setResultCode(Constant.UN_MATCH_CODE);
                ret.setResultBody(errorList);
                ret.setResultDesc(Constant.QUERY_SUCCESS);
            }
            // 查询成功
            ret.setIsCharge(Constant.IS_CHARGE);
            upstreamCode = resultCode + "-" + responseObject.getData().getVerifyResultSet().get(0).getResult();
        } else if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_110000)) {
            // 库无
            ret.setResultCode(Constant.UN_FIND_NUM_CODE);
            ret.setResultBody(Constants.NO_RESULT);
            ret.setResultDesc(Constants.NO_RESULT);
        } else if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_140001)
                || resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_140002)) {
            // 参数错误
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
        } else {
            // 其他错误
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
        }
        return upstreamCode;
    }

    @Override
    public ChannelTypeHandleResponseObject checkPersonQualificationCertificate(HttpServletRequest request, String customBody, int outTime) {
        ChannelTypeHandleResponseObject ret = new ChannelTypeHandleResponseObject();
        ret.setIsCharge(Constant.INTERFACE_QUERY_NO_FEE);
        ret.setCode(Constant.SUCCESS);
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        if (outTime <= Constants.PARA_ZERO) {
            outTime = Constant.HTTPCLIENT_CONNECTTIMEOUT;
        }

        log.info("supplier-vehicle.checkPersonQualificationCertificate---customBody={},outTime={}", customBody, outTime);
        // 解析参数
        ObjectMapper objectMapper = new ObjectMapper();
        PersonQualificationCertificateRequestParam requestParam;
        try {
            requestParam = objectMapper.readValue(customBody, PersonQualificationCertificateRequestParam.class);
        } catch (IOException ioe) {
            log.info("supplier-vehicle.checkPersonQualificationCertificate-解析参数Exception：{}", ioe);
            ErrorUtils.captureException(ioe);
            ret.setCode(Constant.FAIL);
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 参数校验
        if (!ValidateParamUtil.validateRequestParams(requestParam)) {
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 接口调用
        String responseContext = "";
        try {
            okhttp3.Response response = PostUtil.postString(supplierConfig.getPersonQualificationUrl(), JSON.toJSONString(requestParam), outTime);
            if (response.body() != null) {
                responseContext = response.body().string();
                upstreamCode = setPersonQualificationCertificateResponse(ret, responseContext);
            } else {
                ret.setCode(Constant.FAIL);
            }
            log.info("responseContext:{}", responseContext);
        } catch (IOException e) {
            log.info("supplier-vehicle.checkPersonQualificationCertificate-IOException：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.REQUEST_TIMEOUT);
        } catch (Exception e) {
            log.info("supplier-vehicle.checkPersonQualificationCertificate-Exception：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.FAIL);
        }

        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        return ret;
    }

    private String setPersonQualificationCertificateResponse(ChannelTypeHandleResponseObject ret, String responseContext) {
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        RoadTransportPermitResponse responseObject = JSON.toJavaObject(JSON.parseObject(responseContext),
                RoadTransportPermitResponse.class);
        if (responseObject == null) {
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
            return upstreamCode;
        }

        String resultCode = responseObject.getResultCode();
        upstreamCode = resultCode;
        List<String> errorList = new ArrayList<>();
        if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_0)) {
            if (responseObject.getData().getVerifyResultSet().get(0).getResult().equals("0")) {
                // 一致
                ret.setResultCode(Constant.MATCH_CODE);
                ret.setResultBody(Constant.MATCH);
                ret.setResultDesc(Constant.QUERY_SUCCESS);
            } else {
                // 不一致，返回具体不一致项
                String errorInfo = responseObject.getData().getVerifyResultSet().get(0).getErrorInfo();
                if (errorInfo.equals(Constants.UN_MATCH_DRIVER_NAME)) {
                    errorList.add("driverName");
                }
                if (errorInfo.equals(Constants.UN_MATCH_DRIVING_LICENSE)) {
                    errorList.add("drivingLicense");
                }
                if (errorInfo.equals(Constants.UN_MATCH_PROVINCE_CODE)) {
                    errorList.add("provinceCode");
                }
                if (errorInfo.equals(Constants.UN_MATCH_QUALIFICATION_CERTIFICATE)){
                    errorList.add("qualificationCertificate");
                }
                if (errorInfo.equals(Constants.UN_MATCH_QUALIFICATION_CERTIFICATE_FROM)){
                    errorList.add("qualificationCertificateValidPeriodFrom");
                }
                if (errorInfo.equals(Constants.UN_MATCH_QUALIFICATION_CERTIFICATE_TO)){
                    errorList.add("qualificationCertificateValidPeriodTo");
                }
                ret.setResultCode(Constant.UN_MATCH_CODE);
                ret.setResultBody(errorList);
                ret.setResultDesc(Constant.QUERY_SUCCESS);
            }
            // 查询成功
            ret.setIsCharge(Constant.IS_CHARGE);
            upstreamCode = resultCode + "-" + responseObject.getData().getVerifyResultSet().get(0).getResult();
        } else if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_110000)) {
            // 库无
            ret.setResultCode(Constant.UN_FIND_NUM_CODE);
            ret.setResultBody(Constants.NO_RESULT);
            ret.setResultDesc(Constants.NO_RESULT);
        } else if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_140001)
                || resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_140002)) {
            // 参数错误
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
        } else {
            // 其他错误
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
        }
        return upstreamCode;
    }

    @Override
    public ChannelTypeHandleResponseObject checkEnterpriseRoadTransport(HttpServletRequest request, String customBody, int outTime) {
        ChannelTypeHandleResponseObject ret = new ChannelTypeHandleResponseObject();
        ret.setIsCharge(Constant.INTERFACE_QUERY_NO_FEE);
        ret.setCode(Constant.SUCCESS);
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        if (outTime <= Constants.PARA_ZERO) {
            outTime = Constant.HTTPCLIENT_CONNECTTIMEOUT;
        }

        log.info("supplier-vehicle.checkEnterpriseRoadTransport---customBody={},outTime={}", customBody, outTime);
        // 解析参数
        ObjectMapper objectMapper = new ObjectMapper();
        EnterpriseRoadTransportPermitRequestParam requestParam;
        try {
            requestParam = objectMapper.readValue(customBody, EnterpriseRoadTransportPermitRequestParam.class);
        } catch (IOException ioe) {
            log.info("supplier-vehicle.checkEnterpriseRoadTransport-解析参数Exception：{}", ioe);
            ErrorUtils.captureException(ioe);
            ret.setCode(Constant.FAIL);
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 参数校验
        if (!ValidateParamUtil.validateRequestParams(requestParam)) {
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
            return ret;
        }

        // 接口调用
        String responseContext = "";
        try {
            okhttp3.Response response = PostUtil.postString(supplierConfig.getEnterpriseRoadTransportUrl(), JSON.toJSONString(requestParam), outTime);
            if (response.body() != null) {
                responseContext = response.body().string();
                upstreamCode = setEnterpriseRoadTransportResponse(ret, responseContext);
            } else {
                ret.setCode(Constant.FAIL);
            }
            log.info("responseContext:{}", responseContext);
        } catch (IOException e) {
            log.info("supplier-vehicle.checkEnterpriseRoadTransport-IOException：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.REQUEST_TIMEOUT);
        } catch (Exception e) {
            log.info("supplier-vehicle.checkEnterpriseRoadTransport-Exception：{}", e);
            ErrorUtils.captureException(e);
            ret.setCode(Constant.FAIL);
        }

        request.setAttribute(Constant.LOG_UPSTREAM_RESPONSE_CODE, upstreamCode);
        return ret;
    }

    private String setEnterpriseRoadTransportResponse(ChannelTypeHandleResponseObject ret, String responseContext) {
        String upstreamCode = "" + Constant.LOG_UPSTREAM_DEFAULT_RESPONSE_CODE;
        RoadTransportPermitResponse responseObject = JSON.toJavaObject(JSON.parseObject(responseContext),
                RoadTransportPermitResponse.class);
        if (responseObject == null) {
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
            return upstreamCode;
        }

        String resultCode = responseObject.getResultCode();
        upstreamCode = resultCode;
        List<String> errorList = new ArrayList<>();
        if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_0)) {
            if (responseObject.getData().getVerifyResultSet().get(0).getResult().equals("0")) {
                // 一致
                ret.setResultCode(Constant.MATCH_CODE);
                ret.setResultBody(Constant.MATCH);
                ret.setResultDesc(Constant.QUERY_SUCCESS);
            } else {
                // 不一致，返回具体不一致项
                String errorInfo = responseObject.getData().getVerifyResultSet().get(0).getErrorInfo();
                if (errorInfo.equals(Constants.UN_MATCH_CARRIER)) {
                    errorList.add("carrier");
                }
                if (errorInfo.equals(Constants.UN_MATCH_PERMIT_NUMBER)) {
                    errorList.add("permitNumber");
                }
                if (errorInfo.equals(Constants.UN_MATCH_PERMIT_VALID_PERIOD_FROM)) {
                    errorList.add("permitValidPeriodFrom");
                }
                if (errorInfo.equals(Constants.UN_MATCH_PERMIT_VALID_PERIOD_TO)){
                    errorList.add("permitValidPeriodTo");
                }
                ret.setResultCode(Constant.UN_MATCH_CODE);
                ret.setResultBody(errorList);
                ret.setResultDesc(Constant.QUERY_SUCCESS);
            }
            // 查询成功
            ret.setIsCharge(Constant.IS_CHARGE);
            upstreamCode = resultCode + "-" + responseObject.getData().getVerifyResultSet().get(0).getResult();
        } else if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_110000)) {
            // 库无
            ret.setResultCode(Constant.UN_FIND_NUM_CODE);
            ret.setResultBody(Constants.NO_RESULT);
            ret.setResultDesc(Constants.NO_RESULT);
        } else if (resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_140001)
                || resultCode.equals(Constants.CERTIFICATE_CHECK_RESULT_CODE_140002)) {
            // 参数错误
            ret.setResultCode(Constant.INVALID_PARAMETER_CODE);
            ret.setResultBody(Constant.INVALID_PARAMETER);
            ret.setResultDesc(Constant.INVALID_PARAMETER);
        } else {
            // 其他错误
            ret.setResultCode(Constant.OTHER_ERROR_CODE);
            ret.setResultBody(Constant.OTHER_ERROR);
            ret.setResultDesc(Constant.OTHER_ERROR);
        }
        return upstreamCode;
    }
}