package com.jeequan.jeepay.mgr.ctrl.payconfig;

import cn.hutool.core.codec.Base64;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jeequan.jeepay.components.mq.model.ResetIsvMchAppInfoConfigMQ;
import com.jeequan.jeepay.components.mq.vender.IMQSender;
import com.jeequan.jeepay.core.aop.MethodLog;
import com.jeequan.jeepay.core.constants.ApiCodeEnum;
import com.jeequan.jeepay.core.constants.CS;
import com.jeequan.jeepay.core.entity.IsvUserConn;
import com.jeequan.jeepay.core.model.ApiRes;
import com.jeequan.jeepay.core.model.params.IsvParams;
import com.jeequan.jeepay.core.model.params.NormalMchParams;
import com.jeequan.jeepay.core.utils.StringKit;
import com.jeequan.jeepay.db.entity.*;
import com.jeequan.jeepay.mgr.ctrl.CommonCtrl;
import com.jeequan.jeepay.service.impl.IsvInfoService;
import com.jeequan.jeepay.service.impl.MchAppService;
import com.jeequan.jeepay.service.impl.PayInterfaceConfigService;
import com.jeequan.jeepay.service.impl.RateConfigService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/***
 * 支付配置
 *
 * @author terrfly
 *
 * @date 2022/3/21 0:13
 */
@RestController
@RequestMapping("/api/payConfig")
public class PayConfigController extends CommonCtrl {

    @Autowired
    private MchAppService mchAppService;
    @Autowired
    private PayInterfaceConfigService payInterfaceConfigService;
    @Autowired
    private RateConfigService rateConfigService;
    @Autowired
    private IMQSender mqSender;
    @Autowired
    private IsvInfoService isvInfoService;


    /**
     * 查询可用的支付接口
     * <p>
     * 使用功能项目：  参数及费率的填写
     * 服务商查询全部支付接口
     * 服务商查询服务商开启的支付接口
     **/
    @GetMapping("/ifCodes")
    public ApiRes ifCodes() {

        // 搜索条件
        String ifName = getValString("ifName");
        // infoId    运营平台 发起 商户进件， 此时infoId是商户的所属 商户ID
        String infoId = getValStringRequired("infoId");
        // 设置类型
        String configMode = getValStringRequired("configMode");

        // 支付接口列表
        LambdaQueryWrapper<PayInterfaceDefine> lambdaQueryWrapper = PayInterfaceDefine.gw();
        lambdaQueryWrapper.eq(PayInterfaceDefine::getState, CS.YES); // 查询可用的支付接口列表

        lambdaQueryWrapper.like(StringUtils.isNotEmpty(ifName), PayInterfaceDefine::getIfName, ifName);


        String infoType = null;

        // 配置服务商 支付参数
        if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
            lambdaQueryWrapper.eq(PayInterfaceDefine::getIsIsvMode, CS.YES); // 查询支持服务商的接口。

            //查询全部
            infoType = CS.SYS_ROLE_TYPE.ISV;
        } else if (RateConfig.CONFIG_MODE_MGRAGENT.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.AGENT;
        }

        final List<String> ifCodes = new ArrayList<>();

        // 进件 支付参数
        if (RateConfig.CONFIG_MODE_MGRAPPLYMENT.equals(configMode)) {

            lambdaQueryWrapper.eq(PayInterfaceDefine::getIsSupportApplyment, CS.YES); // 查询支持进件的接口

            MchInfo mchInfo = mchInfoService.getById(infoId);

            // CURRENT 查询将返回空
            if (mchInfo == null || StringUtils.isEmpty(mchInfo.getAgentNo())) {
                return ApiRes.ok();
            }

            // 根据渠道号获取ifCode
            Map<String, IsvUserConn> ifCodeMap = isvInfoService.getIsvUserConn(CS.SYS_ROLE_TYPE.MCH, mchInfo.getMchNo(), CS.YES);

            ifCodes.addAll(ifCodeMap.keySet());

//            if (ifCodes.isEmpty()) { // 没有可用的接口
//                return ApiRes.ok(ifCodes);
//            }
//
//            lambdaQueryWrapper.in(PayInterfaceDefine::getIfCode, ifCodes);
        }

        // 运营平台 配置 服务商费率 【显示  服务商的所有接口】
        if (RateConfig.CONFIG_MODE_MGRAGENT.equals(configMode)) {

            lambdaQueryWrapper.eq(PayInterfaceDefine::getIsIsvMode, CS.YES); // 查询支持服务商的接口。

            // 查询当前服务商
            AgentInfo agentInfo = agentInfoService.getById(infoId);

            Map<String, IsvUserConn> ifCodeMap = isvInfoService.getIsvUserConn(CS.SYS_ROLE_TYPE.AGENT, agentInfo.getAgentNo(), null);
            ifCodes.addAll(ifCodeMap.keySet());

//            if (ifCodes.isEmpty()) { // 没有可用的接口
//                return ApiRes.ok(ifCodes);
//            }
//            lambdaQueryWrapper.in(PayInterfaceDefine::getIfCode, ifCodes);
        }

        // 是否是进件
        boolean isProcessApplyment = RateConfig.CONFIG_MODE_MGRAPPLYMENT.equals(configMode)
                || RateConfig.CONFIG_MODE_AGENTAPPLYMENT.equals(configMode)
                || RateConfig.CONFIG_MODE_MCHAPPLYMENT.equals(configMode);

        // 运营平台 配置 商户费率 【显示  服务商的所有接口】
        if (RateConfig.CONFIG_MODE_MGRMCH.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.MCH;

            // 查询当前用户/商户
//            MchAppEntity mchAppEntity = mchAppService.getById(infoId);
            MchInfo mchInfo = mchInfoService.getById(infoId);

            // 特约商户
            if (mchInfo.getType() != CS.MCH_TYPE_ISVSUB) {
                // 普通商户
                lambdaQueryWrapper.eq(PayInterfaceDefine::getIsMchMode, CS.YES); // 查询支持普通商户的接口。
            }
        }

        // 进件操作，只显示关联的通道信息
        if (isProcessApplyment) {
            infoType = CS.SYS_ROLE_TYPE.MCH;
            Map<String, IsvUserConn> ifCodeStateMap = isvInfoService.getIsvUserConn(infoType, infoId, CS.YES);
            if (!ifCodeStateMap.isEmpty()) {
                lambdaQueryWrapper.in(PayInterfaceDefine::getIfCode, ifCodes);
            }
        }

        lambdaQueryWrapper.orderByAsc(PayInterfaceDefine::getCreatedAt);
        List<PayInterfaceDefine> list = payInterfaceDefineService.list(lambdaQueryWrapper);

        if (list.isEmpty()) {
            return ApiRes.ok(list);
        }

        Map<String, IsvUserConn> ifCodeStateMap = isvInfoService.getIsvUserConn(infoType, infoId, null);
        if (CollUtil.isEmpty(ifCodeStateMap)) {
            return ApiRes.ok(list);
        }

        // 是否已配置
        list.forEach(r -> {
            String ifCode = r.getIfCode();
            Optional.ofNullable(ifCodeStateMap.get(ifCode)).ifPresent(it -> {
                r.addExt("configState", CS.YES);
            });
        });

        return ApiRes.ok(list);
    }

    /**
     * 查询已经配置的参数信息
     */
    @GetMapping(value = "/interfaceSavedConfigs")
    public ApiRes interfaceSavedConfigs() {

        String ifCode = getValStringRequired("ifCode"); // ifCode
        String infoId = getValStringRequired("infoId"); // infoId
        String configMode = getValStringRequired("configMode"); // 设置类型

        // 是否查询真实配置信息
        boolean queryConfigRealInfos = getValByteDefault("qcreals", CS.NO) == CS.YES;

        PayInterfaceDefine payInterfaceDefine = payInterfaceDefineService.getById(ifCode);

        String infoType = null;
        JSONArray ifDefineArray = null;

        Byte mchType = null; // 商户类型
        Byte isvIsOpenApplyment = 0; // 服务商是否开启进件

        // 运营平台 配置服务商信息  --》
        if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.ISV;
            try {
                ifDefineArray = JSON.parseArray(payInterfaceDefine.getIsvParams());
            } catch (Exception e) {
                ifDefineArray = new JSONArray();
            }

        }
        // 运营平台 配置商户应用信息
        else if (RateConfig.CONFIG_MODE_MGRMCH.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.MCH_APP;

            MchInfo mchInfo = mchInfoService.getById(infoId);
            mchType = mchInfo.getType();

            ifDefineArray = JSON.parseArray(mchType == CS.MCH_TYPE_NORMAL ? payInterfaceDefine.getNormalMchParams() : payInterfaceDefine.getIsvsubMchParams());
        }
        // 运营平台 配置服务商信息
        else if (RateConfig.CONFIG_MODE_MGRAGENT.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.AGENT;

            AgentInfo agentInfo = agentInfoService.getById(infoId);
            if (agentInfo != null && !ObjectUtils.isEmpty(agentInfo.getIsvNo())) {
                PayInterfaceConfig isvIfConfig = payInterfaceConfigService.getByInfoIdAndIfCode(CS.SYS_ROLE_TYPE.ISV, agentInfo.getIsvNo(), ifCode);
                isvIsOpenApplyment = isvIfConfig != null ? isvIfConfig.getIsOpenApplyment() : 0;
            }
        }

        // 查询已经配置的信息
        PayInterfaceConfig payInterfaceConfig = payInterfaceConfigService.getByInfoIdAndIfCode(infoType, infoId, ifCode);
        payInterfaceConfig = Optional.ofNullable(payInterfaceConfig).orElse(new PayInterfaceConfig());

        // 处理脱敏数据
        if (StringUtils.isNotEmpty(payInterfaceConfig.getIfParams())) {

            // 查询真实数据 && base64脱敏
            if (queryConfigRealInfos) {
                payInterfaceConfig.setIfParams(Base64.encode(payInterfaceConfig.getIfParams()));
            } else {

                if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
                    IsvParams isvParams = IsvParams.factory(ifCode, payInterfaceConfig.getIfParams());
                    if (isvParams != null) {
                        payInterfaceConfig.setIfParams(isvParams.deSenData());
                    }
                } else if (RateConfig.CONFIG_MODE_MGRMCH.equals(configMode) && mchType == CS.MCH_TYPE_NORMAL) {
                    NormalMchParams isvParams = NormalMchParams.factory(ifCode, payInterfaceConfig.getIfParams());
                    if (isvParams != null) {
                        payInterfaceConfig.setIfParams(isvParams.deSenData());
                    }
                }
            }
        }

        payInterfaceConfig.addExt("ifDefineArray", ifDefineArray);
        payInterfaceConfig.addExt("mchType", mchType);
        payInterfaceConfig.addExt("configPageType", payInterfaceDefine.getConfigPageType());
        payInterfaceConfig.addExt("isSupportApplyment", payInterfaceDefine.getIsSupportApplyment()); // 支付接口是否支持进件
        payInterfaceConfig.addExt("isSupportCheckBill", payInterfaceDefine.getIsSupportCheckBill()); // 支付接口是否支持对账
        payInterfaceConfig.addExt("isSupportCashout", payInterfaceDefine.getIsSupportCashout()); // 支付接口是否支持提现
        payInterfaceConfig.addExt("isvIsOpenApplyment", isvIsOpenApplyment); // 上级服务商是否开启进件

        Map<String, String> channelTypeMap = new HashMap<>();
        // 默认禁用
        channelTypeMap.put("type_0", "-1");
        channelTypeMap.put("type_1", "-1");
        channelTypeMap.put("type_2", "-1");

        if (payInterfaceDefine.getChannelTypes() != null) {
            for (String s : payInterfaceDefine.getChannelTypes().split(",")) {
                if (s.equals("0")) {
                    // 可选
                    channelTypeMap.put("type_0", "0");
                }

                if (s.equals("1")) {
                    // 可选
                    channelTypeMap.put("type_1", "0");
                }

                if (s.equals("2")) {
                    // 可选
                    channelTypeMap.put("type_2", "0");
                }
            }
        }

        if (payInterfaceConfig.getChannelTypes() != null) {
            for (String s : payInterfaceConfig.getChannelTypes().split(",")) {
                if (s.equals("0")) {
                    // 可选
                    channelTypeMap.put("type_0", "1");
                }

                if (s.equals("1")) {
                    // 可选
                    channelTypeMap.put("type_1", "1");
                }

                if (s.equals("2")) {
                    // 可选
                    channelTypeMap.put("type_2", "1");
                }
            }
        }

        payInterfaceConfig.addExt("channelTypeOption", channelTypeMap);

        return ApiRes.ok(payInterfaceConfig);
    }


    /**
     * 更新支付参数
     **/
    @PostMapping("/interfaceParams")
    @MethodLog(remark = "更新支付参数")
    public ApiRes saveOrUpdate() {

        PayInterfaceConfig payInterfaceConfig = getObject(PayInterfaceConfig.class);

        String configMode = payInterfaceConfig.extv().getString("configMode");  // 设置类型

        String infoType = null;

        // 运营平台 配置服务商信息  --》
        if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.ISV;
        }
        // 运营平台 配置商户应用
        else if (RateConfig.CONFIG_MODE_MGRMCH.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.MCH_APP;
        }
        // 运营平台 配置服务商
        else if (RateConfig.CONFIG_MODE_MGRAGENT.equals(configMode)) {
            infoType = CS.SYS_ROLE_TYPE.AGENT;
        }

        payInterfaceConfig.setInfoType(infoType);

        //添加更新者信息
        Long userId = getCurrentUser().getSysUser().getSysUserId();
        String realName = getCurrentUser().getSysUser().getRealname();
        payInterfaceConfig.setUpdatedUid(userId);
        payInterfaceConfig.setUpdatedBy(realName);

        //根据 服务商号、接口类型 获取商户参数配置
        PayInterfaceConfig dbRecord = payInterfaceConfigService.getByInfoIdAndIfCode(payInterfaceConfig.getInfoType(), payInterfaceConfig.getInfoId(), payInterfaceConfig.getIfCode());
        //若配置存在，为saveOrUpdate添加ID，第一次配置添加创建者
        if (dbRecord != null) {
            payInterfaceConfig.setId(dbRecord.getId());

            // 合并支付参数
            payInterfaceConfig.setIfParams(StringKit.marge(dbRecord.getIfParams(), payInterfaceConfig.getIfParams(), dbRecord.getIfCode()));
        } else {
            payInterfaceConfig.setCreatedUid(userId);
            payInterfaceConfig.setCreatedBy(realName);
        }

        boolean result = payInterfaceConfigService.saveOrUpdate(payInterfaceConfig);
        if (!result) {
            return ApiRes.fail(ApiCodeEnum.SYSTEM_ERROR, "配置失败");
        }

        // 推送mq到目前节点进行更新数据

        // 运营平台 配置服务商信息  --》
        if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
            mqSender.send(ResetIsvMchAppInfoConfigMQ.build(ResetIsvMchAppInfoConfigMQ.RESET_TYPE_ISV_INFO, payInterfaceConfig.getInfoId(), null, null));
        }

        return ApiRes.ok();
    }

    /**
     * 查询商户应用支付参数、费率是否配置
     * 用于发起进件  自动配置到应用时的提示
     */
    @GetMapping("/existPayParams/{appId}/{ifCode}")
    public ApiRes existPayParams(@PathVariable("appId") String appId, @PathVariable("ifCode") String ifCode) {

//        Integer range = getValInteger("range");
//        String mccCode = getValString("mccCode");
//        String isvNo = getValString("isvNo");
//
//        // 应用参数配置
//        PayInterfaceConfig interfaceConfig = payInterfaceConfigService.getByInfoIdAndIfCode(CS.SYS_ROLE_TYPE.MCH_APP, appId, ifCode);
//        if (interfaceConfig == null) {
//            return ApiRes.ok();
//        }
//
//        if (StringUtils.isNotBlank(interfaceConfig.getIfParams()) && !interfaceConfig.getIfParams().equals("{}")) {
//            return ApiRes.ok(JsonKit.newJson("existMchParams", CS.YES));
//        }
//
//        // 费率配置
//        Map<String, PaywayFee> paywayFeeMap = rateConfigService.queryPaywayFeeMap(appId + "_" + RateConfig.MCHRATE, CS.SYS_ROLE_TYPE.MCH_APP, ifCode, range, mccCode, isvNo);
//        if (paywayFeeMap != null && StringUtils.isNotBlank(interfaceConfig.getIfParams()) && !interfaceConfig.getIfParams().equals("{}")) {
//            return ApiRes.ok(JsonKit.newJson("existMchParams", CS.YES));
//        }

        return ApiRes.ok();
    }

//    /**
//     * @author deng
//     * 保存支付参数实例
//     */
//    @PostMapping("/saveConfigAlternative")
//    public ApiRes saveConfigAlternative() {
//        com.jeequan.jeepay.db.entity.MchPayInterfaceConfig mchPayInterfaceConfig = getObject(com.jeequan.jeepay.db.entity.MchPayInterfaceConfig.class);
//
//        String configMode = mchPayInterfaceConfig.extv().getString("configMode");  // 设置类型
//
//        String infoType = CS.SYS_ROLE_TYPE.ISV;
//
//        mchPayInterfaceConfig.setInfoType(infoType);
//
//        //添加更新者信息
//        Long userId = getCurrentUser().getSysUser().getSysUserId();
//        String realName = getCurrentUser().getSysUser().getRealname();
//        mchPayInterfaceConfig.setUpdatedUid(userId);
//        mchPayInterfaceConfig.setUpdatedBy(realName);
//        if (mchPayInterfaceConfig.getId() != null) {
//            com.jeequan.jeepay.db.entity.MchPayInterfaceConfig existData = this.mchPayInterfaceConfig.getById(mchPayInterfaceConfig.getId());
//            mchPayInterfaceConfig.setIfParams(StringKit.marge(mchPayInterfaceConfig.getIfParams(), existData.getIfParams(), mchPayInterfaceConfig.getIfCode()));
//        }
//
//        boolean result = this.mchPayInterfaceConfig.saveOrUpdate(mchPayInterfaceConfig);
//        if (!result) {
//            return ApiRes.fail(ApiCodeEnum.SYSTEM_ERROR, "配置失败");
//        }
//
//        //根据 服务商号、接口类型获取正在使用的通道配置信息，如果存在并且修改的是这一个
//        PayInterfaceConfig existPayInterfaceConfig = payInterfaceConfigService.getByInfoIdAndIfCode(mchPayInterfaceConfig.getInfoType(), mchPayInterfaceConfig.getInfoId(), mchPayInterfaceConfig.getIfCode());
//        //若配置存在，为saveOrUpdate添加ID，第一次配置添加创建者
//
//        if (existPayInterfaceConfig != null
//                && mchPayInterfaceConfig.getId().equals(existPayInterfaceConfig.getAltId())) {
//            existPayInterfaceConfig.setIfParams(mchPayInterfaceConfig.getIfParams());
//            payInterfaceConfigService.updateById(existPayInterfaceConfig);
//        }
//
//        // 运营平台 配置服务商信息  --》
//        mqSender.send(ResetIsvMchAppInfoConfigMQ.build(ResetIsvMchAppInfoConfigMQ.RESET_TYPE_ISV_INFO, mchPayInterfaceConfig.getInfoId(), null, null));
//
////        if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
////            mqSender.send(ResetIsvMchAppInfoConfigMQ.build(ResetIsvMchAppInfoConfigMQ.RESET_TYPE_ISV_INFO, payInterfaceConfigAlternative.getInfoId(), null, null));
////        } else if (RateConfig.CONFIG_MODE_MGRMCH.equals(configMode)) { // 配置商户参数
////            MchAppEntity mchAppEntity = mchAppService.getById(payInterfaceConfigAlternative.getInfoId());
////            mqSender.send(ResetIsvMchAppInfoConfigMQ.build(ResetIsvMchAppInfoConfigMQ.RESET_TYPE_MCH_APP, null, mchAppEntity.getMchNo(), payInterfaceConfigAlternative.getInfoId()));
////        }
//
//        return ApiRes.ok();
//    }
//
//    /**
//     * @author deng
//     * 返回支付参数实例的分页数据
//     */
//    @GetMapping("/configAlternativeList")
//    public ApiRes configAlternativeList() {
//        // 渠道编码必传
//        String ifCode = getValStringRequired("ifCode");
//        // 服务商(原服务商)编号
//        String isvNo = getValStringRequired("isvNo");
//
//        String alias = getValString("alias");
//
//        Page<com.jeequan.jeepay.db.entity.MchPayInterfaceConfig> iPage = getIPage(false);
//
//        Page<com.jeequan.jeepay.db.entity.MchPayInterfaceConfig> page = mchPayInterfaceConfig
//                .wrapperByIsvNo(isvNo, ifCode)
//                .eq(!ObjectUtils.isEmpty(alias), com.jeequan.jeepay.db.entity.MchPayInterfaceConfig::getAlias, alias)
//                .orderByDesc(com.jeequan.jeepay.db.entity.MchPayInterfaceConfig::getId)
//                .page(iPage);
//
//        PayInterfaceConfig payInterfaceConfigUse = payInterfaceConfigService.getByInfoIdAndIfCode(CS.SYS_ROLE_TYPE.ISV, isvNo, ifCode);
//
//        page.getRecords().forEach(item -> {
//            int inUseFlag = (payInterfaceConfigUse != null && Objects.equals(payInterfaceConfigUse.getAltId(), item.getId())) ? 1 : 0;
//            item.setInUseFlag(inUseFlag);
//        });
//
//        return ApiRes.ok(page);
//    }
//
//    @PostMapping("/chosenConfigAlternative")
//    public ApiRes configAlternativeUse() {
//        Long altId = getValLongRequired("altId");
//        // 渠道编码必传
//        String ifCode = getValStringRequired("ifCode");
//        // 服务商(原服务商)编号
//        String isvNo = getValStringRequired("isvNo");
//
//        com.jeequan.jeepay.db.entity.MchPayInterfaceConfig alternativeData = mchPayInterfaceConfig.getById(altId);
//        Assert.notNull(alternativeData, "渠道实例不存在");
//
//        PayInterfaceConfig payInterfaceConfig = mchInfoConverter.toConfig(alternativeData);
//        payInterfaceConfig.setAltId(alternativeData.getId());
//
//        //添加更新者信息
//        Long userId = getCurrentUser().getSysUser().getSysUserId();
//        String realName = getCurrentUser().getSysUser().getRealname();
//        payInterfaceConfig.setUpdatedUid(userId);
//        payInterfaceConfig.setUpdatedBy(realName);
//
//        //根据 服务商号、接口类型 获取商户参数配置
//        PayInterfaceConfig configData = payInterfaceConfigService.getByInfoIdAndIfCode(CS.SYS_ROLE_TYPE.ISV, isvNo, ifCode);
//        //若配置存在，为saveOrUpdate添加ID，第一次配置添加创建者
//        if (configData != null) {
//            // 合并支付参数
//            payInterfaceConfig.setIfParams(StringKit.marge(configData.getIfParams(), payInterfaceConfig.getIfParams(), configData.getIfCode()));
//            payInterfaceConfig.setId(configData.getId());
//        } else {
//            payInterfaceConfig.setIfParams(alternativeData.getIfParams());
//            payInterfaceConfig.setCreatedUid(userId);
//            payInterfaceConfig.setCreatedBy(realName);
//        }
//
//        boolean result = payInterfaceConfigService.saveOrUpdate(payInterfaceConfig);
//        if (!result) {
//            return ApiRes.fail(ApiCodeEnum.SYSTEM_ERROR, "配置失败");
//        }
//
////        isvUserConnService.getSuperiorConnInfo()
//
//        // 推送mq到目前节点进行更新数据
//
//        // 运营平台 配置服务商信息  --》
////        mqSender.send(ResetIsvMchAppInfoConfigMQ.build(ResetIsvMchAppInfoConfigMQ.RESET_TYPE_ISV_INFO, payInterfaceConfig.getInfoId(), null, null));
//
////        if (RateConfig.CONFIG_MODE_MGRISV.equals(configMode)) {
////
////        } else if (RateConfig.CONFIG_MODE_MGRMCH.equals(configMode)) { // 配置商户参数
////
////            MchAppEntity mchAppEntity = mchAppService.getById(payInterfaceConfig.getInfoId());
////            mqSender.send(ResetIsvMchAppInfoConfigMQ.build(ResetIsvMchAppInfoConfigMQ.RESET_TYPE_MCH_APP, null, mchAppEntity.getMchNo(), payInterfaceConfig.getInfoId()));
////        }
//
//        return ApiRes.ok();
//    }
}
