szwlServer/src/main/java/com/szwl/service/impl/THuifuMchServiceImpl.java

package com.szwl.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.huifu.bspay.sdk.opps.core.exception.BasePayException;
import com.huifu.bspay.sdk.opps.core.utils.DateTools;
import com.huifu.bspay.sdk.opps.core.utils.OkHttpClientTools;
import com.huifu.bspay.sdk.opps.core.utils.SequenceTools;
import com.szwl.common.myAnnotation.HuifuBaseCommon;
import com.szwl.config.OppsMerchantConfig;
import com.szwl.constant.HuifuConstant;
import com.szwl.model.bo.R;
import com.szwl.model.entity.TAdmin;
import com.szwl.model.entity.THuifuMch;
import com.szwl.mapper.THuifuMchMapper;
import com.szwl.model.entity.THuifuMchCheck;
import com.szwl.service.TAdminService;
import com.szwl.service.THuifuMchCheckService;
import com.szwl.service.THuifuMchService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.szwl.util.HuifuUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.charset.Charset;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;

import static com.szwl.util.HuifuUtils.base64ToTempImage;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wuhs
 * @since 2023-07-12
 */
@Slf4j
@Service
public class THuifuMchServiceImpl extends ServiceImpl<THuifuMchMapper, THuifuMch> implements THuifuMchService {

    @Autowired
    private THuifuMchCheckService tHuifuMchCheckService;

    @Autowired
    private THuifuMchService tHuifuMchService;

    @Autowired
    private TAdminService tAdminService;

    /**
     * 汇付用户开户
     * @param tHuifuMchCheck
     * @return
     * @throws Exception
     */
    @Override
    public String openAccount(THuifuMchCheck tHuifuMchCheck) throws Exception {
        // 请求接口
        String url = "https://api.huifu.com/v2/user/basicdata/indv";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        // 请求参数：Data
        JSONObject request = new JSONObject();
        // 请求流水号
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        // 请求日期
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        // 判断商户类型，“0”为个人，“1”为企业
        if(tHuifuMchCheck.getType().equals("0")) {
            // 个人姓名
            request.put("name", tHuifuMchCheck.getRegName());
            // 个人证件类型
            request.put("cert_type", "00");
            // 个人证件号码
            request.put("cert_no", tHuifuMchCheck.getCertNo());
            // 个人证件有效期类型，1：长期有效；0：非长期有效
            request.put("cert_validity_type", tHuifuMchCheck.getCertValidityType());
            // 个人证件有效期开始日期
            request.put("cert_begin_date", tHuifuMchCheck.getCertBeginDate());
            // 个人证件有效期截止日期
            if (StrUtil.isNotEmpty(tHuifuMchCheck.getCertEndDate())) {
                request.put("cert_end_date", tHuifuMchCheck.getCertEndDate());
            }
            // 手机号
            request.put("mobile_no", tHuifuMchCheck.getPhone());
        } else {
            url = "https://api.huifu.com/v2/user/basicdata/ent";
            // 企业用户名称
            request.put("reg_name", tHuifuMchCheck.getRegName());
            // 营业执照编号
            request.put("license_code", tHuifuMchCheck.getLicenseCode());
            // 营业执照有效期类型，0：非长期有效 ,1：长期有效
            request.put("license_validity_type", tHuifuMchCheck.getLicenseValidityType());
            // 营业执照有效期开始日期
            request.put("license_begin_date", tHuifuMchCheck.getLicenseBeginDate());
            // 营业执照有效期截止日期
            if (StrUtil.isNotEmpty(tHuifuMchCheck.getLicenseEndDate())) {
                request.put("license_end_date", tHuifuMchCheck.getLicenseEndDate());
            }
            // 注册省
            request.put("reg_prov_id", tHuifuMchCheck.getRegProvId());
            // 注册市
            request.put("reg_area_id", tHuifuMchCheck.getRegAreaId());
            // 注册区
            request.put("reg_district_id", tHuifuMchCheck.getRegDistrictId());
            // 注册详细地址
            request.put("reg_detail", tHuifuMchCheck.getRegDetail());
            // 法人姓名
            request.put("legal_name", tHuifuMchCheck.getName());
            // 法人证件类型
            request.put("legal_cert_type", "00");
            // 法人证件号码
            request.put("legal_cert_no", tHuifuMchCheck.getCertNo());
            // 法人证件有效期类型，1：长期有效；0：非长期有效 ；
            request.put("legal_cert_validity_type", tHuifuMchCheck.getCertValidityType());
            // 法人证件有效期开始日期
            request.put("legal_cert_begin_date", tHuifuMchCheck.getCertBeginDate());
            // 法人证件有效期截止日期
            if (StrUtil.isNotEmpty(tHuifuMchCheck.getCertEndDate())) {
                request.put("legal_cert_end_date", tHuifuMchCheck.getCertEndDate());
            }
            // 联系人姓名
            request.put("contact_name", tHuifuMchCheck.getRegName());
            // 联系人手机号
            request.put("contact_mobile", tHuifuMchCheck.getPhone());
        }

        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);

        String result = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        JSONObject dataObject = jsonObject.getJSONObject("data");
        String code = dataObject.getString("resp_code");
        if(code.equals(HuifuConstant.RESP_CODE)) {
            String huifuId = dataObject.getString("huifu_id");
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("1");
            tHuifuMchCheck.setHuifuId(huifuId);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return HuifuConstant.SUCCESS;
        }else {
            String respDesc = dataObject.getString("resp_desc");
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("3");
            tHuifuMchCheck.setAuditDesc(respDesc);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return respDesc;
        }
    }

    /**
     * 用户业务入驻
     * @param tHuifuMchCheck
     * @return
     * @throws Exception
     */
    @Override
    public String openBusiness(THuifuMchCheck tHuifuMchCheck) throws Exception {
        // 请求接口
        String url = "https://api.huifu.com/v2/user/busi/open";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        // 请求参数：Data
        JSONObject request = new JSONObject();
        // 请求流水号
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        // 请求日期
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        // 汇付ID
        request.put("huifu_id", tHuifuMchCheck.getHuifuId());
        // 上级汇付Id：判断是申泽还是七云
        TAdmin tAdmin = tAdminService.getById(tHuifuMchCheck.getAdminId());
        if (StringUtils.isNotEmpty(tAdmin.getCompanyType()) && tAdmin.getCompanyType().equals("1")) {
            request.put("upper_huifu_id", HuifuConstant.SC_DIV_HUIFU_ID);
        } else {
            request.put("upper_huifu_id", HuifuConstant.SZ_DIV_HUIFU_ID);
        }
        // 结算卡信息配置
        JSONObject cardInfo = new JSONObject();
        // 卡类型
        cardInfo.put("card_type", tHuifuMchCheck.getCardType());
        // 卡户名
        cardInfo.put("card_name", tHuifuMchCheck.getCardName());
        // 结算账号
        cardInfo.put("card_no", tHuifuMchCheck.getCardNo());
        // 银行所在省
        cardInfo.put("prov_id", tHuifuMchCheck.getCardProvId());
        // 银行所在市
        cardInfo.put("area_id", tHuifuMchCheck.getCardAreaId());
        // 如果是对私
        if (StringUtils.isNotEmpty(tHuifuMchCheck.getCardType()) && tHuifuMchCheck.getCardType().equals("1")) {
            // 持卡人证件类型
            cardInfo.put("cert_type", "00");
            // 持卡人证件号码
            cardInfo.put("cert_no", tHuifuMchCheck.getCertNo());
            // 持卡人证件有效期类型，1:长期有效，0:非长期有效；
            cardInfo.put("cert_validity_type", tHuifuMchCheck.getCertValidityType());
            // 持卡人证件有效期开始
            cardInfo.put("cert_begin_date", tHuifuMchCheck.getCertBeginDate());
            // 持卡人证件有效期截止日期
            if (StringUtils.isNotEmpty(tHuifuMchCheck.getCertEndDate())) {
                cardInfo.put("cert_end_date", tHuifuMchCheck.getCertEndDate());
            }
        }
        if (StringUtils.isNotEmpty(tHuifuMchCheck.getCardType()) && tHuifuMchCheck.getCardType().equals("0")) {
            // 银行号
            cardInfo.put("bank_code", tHuifuMchCheck.getBankCode());
            // 支行联行号
            cardInfo.put("branch_code", tHuifuMchCheck.getBranchCode());
        }
        request.put("card_info", cardInfo);
        JSONObject settleConfig = new JSONObject();
        // 如果是修改接口
        if (tHuifuMchCheck.getStatus().equals("4")) {
            url = "https://api.huifu.com/v2/user/busi/modify";
            // 结算周期
            settleConfig.put("settle_status", "1");
        }
        settleConfig.put("settle_cycle", "T1");
        request.put("settle_config", settleConfig);

        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);

        String result = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        JSONObject dataObject = jsonObject.getJSONObject("data");
        String code = dataObject.getString("resp_code");
        if(code.equals(HuifuConstant.RESP_CODE)) {
            String huifuId = dataObject.getString("huifu_id");
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("2");
            tHuifuMchCheck.setHuifuId(huifuId);
            LambdaQueryWrapper<THuifuMch> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(THuifuMch::getAdminId, tHuifuMchCheck.getAdminId());
            THuifuMch huifuMch = tHuifuMchService.getOne(wrapper);
            if (huifuMch != null) {
                String[] ignoreProperties = {"id", "createDate","adminId"};
                BeanUtil.copyProperties(tHuifuMchCheck, huifuMch, ignoreProperties);
                huifuMch.setModifyDate(new Date());
                tHuifuMchService.updateById(huifuMch);
            } else {
                THuifuMch tHuifuMch = new THuifuMch();
                BeanUtil.copyProperties(tHuifuMchCheck, tHuifuMch);
                // 判断持卡人证件有效期类型，1:长期有效，0:非长期有效
                if(tHuifuMchCheck.getCertValidityType().equals("0")) {
                    LocalDate date = LocalDate.parse(tHuifuMchCheck.getCertEndDate(), DateTimeFormatter.ofPattern("yyyyMMdd"));
                    String certEndDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                    tHuifuMch.setCertDate(certEndDate);
                } else {
                    tHuifuMch.setCertDate("长期");
                }
                tHuifuMch.setCreateDate(new Date());
                tHuifuMch.setModifyDate(new Date());
                tHuifuMch.setHuifuId(huifuId);
                tHuifuMchService.save(tHuifuMch);
            }
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return HuifuConstant.SUCCESS;
        }else {
            String respDesc = dataObject.getString("resp_desc");
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("3");
            tHuifuMchCheck.setAuditDesc(respDesc);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return respDesc;
        }
    }

    /**
     * 汇付个人商户入驻
     * @param tHuifuMchCheck
     * @return
     * @throws Exception
     */
    @Override
    public String addPersonage(THuifuMchCheck tHuifuMchCheck) throws Exception {
        // 请求接口
        String url = "https://api.huifu.com/v2/merchant/basicdata/indv";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        // 请求参数：Data
        JSONObject request = new JSONObject();
        // 请求流水号
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        // 请求日期
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        // 上级主体ID
        request.put("upper_huifu_id", HuifuConstant.HUIFU_ID);
        // 商户名称
        request.put("reg_name", tHuifuMchCheck.getRegName());
        // 商户简称
        if(StrUtil.isNotEmpty(tHuifuMchCheck.getShortName())) {
            request.put("short_name", tHuifuMchCheck.getShortName());
        }
        // 经营省
        request.put("prov_id", tHuifuMchCheck.getProvId());
        // 经营市
        request.put("area_id", tHuifuMchCheck.getAreaId());
        // 经营区
        request.put("district_id", tHuifuMchCheck.getDistrictId());
        // 经营详细地址
        request.put("detail_addr", tHuifuMchCheck.getDetailAddr());
        // 联系人姓名
        request.put("contact_name", tHuifuMchCheck.getRegName());
        // 联系人手机号
        request.put("contact_mobile_no", tHuifuMchCheck.getPhone());
        // 联系人电子邮箱
        request.put("contact_email", tHuifuMchCheck.getEmail());
        // 商户名
        request.put("sms_send_flag", "M");
        // 异步通知地址：审核结果消息接收地址
//        request.put("async_return_url", "异步通知地址");
        // 法人证件号码
        request.put("legal_cert_no", tHuifuMchCheck.getCertNo());
        // 结算卡正面
        request.put("settle_card_front_pic", tHuifuMchCheck.getCardFrontPic());
        // 法人身份证国徽面
        request.put("legal_cert_back_pic", tHuifuMchCheck.getLegalCertBackPic());
        // 法人身份证人像面
        request.put("legal_cert_front_pic", tHuifuMchCheck.getLegalCertFrontPic());
        // 结算卡信息配置
        JSONObject cardInfo = new JSONObject();
        // 卡户名
        cardInfo.put("card_name", tHuifuMchCheck.getCardName());
        // 结算账号
        cardInfo.put("card_no", tHuifuMchCheck.getCardNo());
        // 银行所在省
        cardInfo.put("prov_id", tHuifuMchCheck.getCardProvId());
        // 银行所在市
        cardInfo.put("area_id", tHuifuMchCheck.getCardAreaId());
        // 持卡人证件类型
        cardInfo.put("cert_type", "00");
        // 持卡人证件号码
        cardInfo.put("cert_no", tHuifuMchCheck.getCertNo());
        // 持卡人证件有效期类型，1:长期有效，0:非长期有效；
        cardInfo.put("cert_validity_type", tHuifuMchCheck.getCertValidityType());
        // 持卡人证件有效期开始
        cardInfo.put("cert_begin_date", tHuifuMchCheck.getCertBeginDate());
        // 持卡人证件有效期截止日期
        if (StrUtil.isNotEmpty(tHuifuMchCheck.getCertEndDate())) {
            cardInfo.put("cert_end_date", tHuifuMchCheck.getCertEndDate());
        }
        // 结算人手机号
        cardInfo.put("mp", tHuifuMchCheck.getMp());
        request.put("card_info", cardInfo);
        // 结算规则配置
        JSONObject settleConfig = new JSONObject();
        // 结算周期
        settleConfig.put("settle_cycle", "T1");
        request.put("settle_config", settleConfig);

        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);

        String result = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        JSONObject dataObject = jsonObject.getJSONObject("data");
        String code = dataObject.getString("resp_code");
        if(code.equals("90000000")) {
            THuifuMch tHuifuMch = new THuifuMch();
            BeanUtil.copyProperties(tHuifuMchCheck, tHuifuMch);
            String huifuId = dataObject.getString("huifu_id");
            // 判断持卡人证件有效期类型，1:长期有效，0:非长期有效
            if(tHuifuMchCheck.getCertValidityType().equals("0")) {
                LocalDate date = LocalDate.parse(tHuifuMchCheck.getCertEndDate(), DateTimeFormatter.ofPattern("yyyyMMdd"));
                String certEndDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                tHuifuMch.setCertDate(certEndDate);
            } else {
                tHuifuMch.setCertDate("长期");
            }
            tHuifuMch.setCreateDate(new Date());
            tHuifuMch.setModifyDate(new Date());
            tHuifuMch.setHuifuId(huifuId);
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("2");
            tHuifuMchCheck.setHuifuId(huifuId);
            tHuifuMchService.save(tHuifuMch);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return "success";
        }else {
            String respDesc = dataObject.getString("resp_desc");
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("3");
            tHuifuMchCheck.setAuditDesc(respDesc);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return respDesc;
        }
    }

    /**
     * 汇付企业商户入驻
     * @param tHuifuMchCheck
     * @return
     * @throws Exception
     */
    @Override
    public String addEnterprise(THuifuMchCheck tHuifuMchCheck) throws Exception {
        // 请求接口
        String url = "https://api.huifu.com/v2/merchant/basicdata/ent";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        // 请求参数：Data
        JSONObject request = new JSONObject();
        // 请求流水号
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        // 请求日期
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        // 上级主体ID
        request.put("upper_huifu_id", HuifuConstant.HUIFU_ID);
        // 商户名称
        request.put("reg_name", tHuifuMchCheck.getRegName());
        // 商户简称
        if(StrUtil.isNotEmpty(tHuifuMchCheck.getShortName())) {
            request.put("short_name", tHuifuMchCheck.getShortName());
        }
        // 公司类型
        request.put("ent_type", "3");
        // 营业执照编号
        request.put("license_code", tHuifuMchCheck.getLicenseCode());
        // 营业执照有效期类型，0：非长期有效 ,1：长期有效
        request.put("license_validity_type", tHuifuMchCheck.getLicenseValidityType());
        // 营业执照有效期开始日期
        request.put("license_begin_date", tHuifuMchCheck.getLicenseBeginDate());
        // 营业执照有效期截止日期
        if (StrUtil.isNotEmpty(tHuifuMchCheck.getLicenseEndDate())) {
            request.put("license_end_date", tHuifuMchCheck.getLicenseEndDate());
        }
        // 注册省
        request.put("reg_prov_id", tHuifuMchCheck.getRegProvId());
        // 注册市
        request.put("reg_area_id", tHuifuMchCheck.getRegAreaId());
        // 注册区
        request.put("reg_district_id", tHuifuMchCheck.getRegDistrictId());
        // 注册详细地址
        request.put("reg_detail", tHuifuMchCheck.getRegDetail());
        // 法人姓名
        request.put("legal_name", tHuifuMchCheck.getName());
        // 法人证件类型
        request.put("legal_cert_type", "00");
        // 法人证件号码
        request.put("legal_cert_no", tHuifuMchCheck.getCertNo());
        // 法人证件有效期类型，1：长期有效；0：非长期有效 ；
        request.put("legal_cert_validity_type", tHuifuMchCheck.getCertValidityType());
        // 法人证件有效期开始日期
        request.put("legal_cert_begin_date", tHuifuMchCheck.getCertBeginDate());
        // 法人证件有效期截止日期
        if (StrUtil.isNotEmpty(tHuifuMchCheck.getCertEndDate())) {
            request.put("legal_cert_end_date", tHuifuMchCheck.getCertEndDate());
        }
        // 经营省
        request.put("prov_id", tHuifuMchCheck.getProvId());
        // 经营市
        request.put("area_id", tHuifuMchCheck.getAreaId());
        // 经营区
        request.put("district_id", tHuifuMchCheck.getDistrictId());
        // 经营详细地址
        request.put("detail_addr", tHuifuMchCheck.getDetailAddr());
        // 联系人姓名
        request.put("contact_name", tHuifuMchCheck.getRegName());
        // 联系人手机号
        request.put("contact_mobile_no", tHuifuMchCheck.getPhone());
        // 联系人电子邮箱
        request.put("contact_email", tHuifuMchCheck.getEmail());
        // 客服电话
        request.put("service_phone", tHuifuMchCheck.getServicePhone());
        // 经营类型，1：实体，2：虚拟 ；
        request.put("busi_type", "1");
        // 小票名称
        request.put("receipt_name", tHuifuMchCheck.getRegName());
        // 所属行业
        request.put("mcc", "6071");
        // 基本存款账户编号或核准号
        if(StrUtil.isNotEmpty(tHuifuMchCheck.getOpenLicenceNo())){
            request.put("open_licence_no", tHuifuMchCheck.getOpenLicenceNo());
        }
        // 开户许可证
        if(StrUtil.isNotEmpty(tHuifuMchCheck.getRegAcctPic())){
            request.put("reg_acct_pic", tHuifuMchCheck.getRegAcctPic());
        }
        if(tHuifuMchCheck.getCardType().equals("1")) {
            // 结算卡正面
            request.put("settle_card_front_pic", tHuifuMchCheck.getCardFrontPic());
            // 法人身份证人像面
            request.put("settle_cert_back_pic", tHuifuMchCheck.getCertBackPic());
            // 法人身份证国徽面
            request.put("settle_cert_front_pic", tHuifuMchCheck.getCertFrontPic());
        } else {
            // 法人身份证人像面
            request.put("legal_cert_back_pic", tHuifuMchCheck.getLegalCertBackPic());
            // 法人身份证国徽面
            request.put("legal_cert_front_pic", tHuifuMchCheck.getLegalCertFrontPic());
        }
        // 营业执照图片
        request.put("license_pic", tHuifuMchCheck.getLicensePic());
        // 成立时间
        request.put("found_date", tHuifuMchCheck.getFoundDate());
        // 法人手机号
        request.put("legal_mobile_no", tHuifuMchCheck.getPhone());
        // 法人身份证地址
        request.put("legal_addr", tHuifuMchCheck.getCertAddress());
        // 结算卡信息配置
        JSONObject cardInfo = new JSONObject();
        // 结算账户类型
        cardInfo.put("card_type", tHuifuMchCheck.getCardType());
        // 卡户名
        cardInfo.put("card_name", tHuifuMchCheck.getCardName());
        // 结算账号
        cardInfo.put("card_no", tHuifuMchCheck.getCardNo());
        // 银行所在省
        if (StrUtil.isNotEmpty(tHuifuMchCheck.getCardProvId())) {
            cardInfo.put("prov_id", tHuifuMchCheck.getCardProvId());
        }
        // 银行所在市
        if (StrUtil.isNotEmpty(tHuifuMchCheck.getCardAreaId())) {
            cardInfo.put("area_id", tHuifuMchCheck.getCardAreaId());
        }
        // 联行号
        if(StrUtil.isNotEmpty(tHuifuMchCheck.getBranchCode())){
            cardInfo.put("branch_code", tHuifuMchCheck.getBranchCode());
        }
        if(StrUtil.isNotEmpty(tHuifuMchCheck.getMp())){
            cardInfo.put("mp", tHuifuMchCheck.getMp());
        }
        request.put("card_info", cardInfo);
        // 结算规则配置
        JSONObject settleConfig = new JSONObject();
        // 结算周期
        settleConfig.put("settle_cycle", "T1");
        request.put("settle_config", settleConfig);

        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);
        System.out.println("请求体："+ requestData);

        String result = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        JSONObject dataObject = jsonObject.getJSONObject("data");
        String code = dataObject.getString("resp_code");
        if(code.equals("90000000")) {
            THuifuMch tHuifuMch = new THuifuMch();
            BeanUtil.copyProperties(tHuifuMchCheck, tHuifuMch);
            String huifuId = dataObject.getString("huifu_id");
            // 判断持卡人证件有效期类型，1:长期有效，0:非长期有效
            if(tHuifuMchCheck.getCertValidityType().equals("0")) {
                LocalDate date = LocalDate.parse(tHuifuMchCheck.getCertEndDate(), DateTimeFormatter.ofPattern("yyyyMMdd"));
                String certEndDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                tHuifuMch.setCertDate(certEndDate);
            } else {
                tHuifuMch.setCertDate("长期");
            }
            tHuifuMch.setCreateDate(new Date());
            tHuifuMch.setModifyDate(new Date());
            tHuifuMch.setHuifuId(huifuId);
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("2");
            tHuifuMchCheck.setHuifuId(huifuId);
            tHuifuMchService.save(tHuifuMch);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return "success";
        }else {
            String respDesc = dataObject.getString("resp_desc");
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("3");
            tHuifuMchCheck.setAuditDesc(respDesc);
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return respDesc;
        }
    }

    /**
     * 汇付商户基本信息修改
     * @param huifuMchCheck
     * @return
     */
    @Override
    public String updateMerchant(THuifuMchCheck huifuMchCheck) throws Exception {
        // 请求接口
        String url = "https://api.huifu.com/v2/merchant/basicdata/modify";
        // 请求参数：Data
        JSONObject request = new JSONObject();
        // 请求流水号
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        // 请求日期
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        // 上级主体ID
        request.put("upper_huifu_id", HuifuConstant.HUIFU_ID);
        // 汇付客户Id
        request.put("huifu_id", huifuMchCheck.getHuifuId());
        // 商户名称
        request.put("reg_name", huifuMchCheck.getRegName());
        // 商户简称
        if(StrUtil.isNotEmpty(huifuMchCheck.getShortName())) {
            request.put("short_name", huifuMchCheck.getShortName());
        }
        // 经营省
        request.put("prov_id", huifuMchCheck.getProvId());
        // 经营市
        request.put("area_id", huifuMchCheck.getAreaId());
        // 经营区
        request.put("district_id", huifuMchCheck.getDistrictId());
        // 经营详细地址
        request.put("detail_addr", huifuMchCheck.getDetailAddr());
        // 联系人姓名
        request.put("contact_name", huifuMchCheck.getRegName());
        // 联系人手机号
        request.put("contact_mobile_no", huifuMchCheck.getPhone());
        // 联系人电子邮箱
        request.put("contact_email", huifuMchCheck.getEmail());
//        // 联系人电子邮箱
//        request.put("async_return_url", "http://598ef306.r10.cpolar.top/tHuifuMch/auditNotify");
        // 取现信息配置
        JSONObject cardInfo = new JSONObject();
        cardInfo.put("card_type", huifuMchCheck.getCardType());
        cardInfo.put("card_name", huifuMchCheck.getCardName());
        cardInfo.put("card_no", huifuMchCheck.getCardNo());
        if(StrUtil.isNotEmpty(huifuMchCheck.getCardProvId())) {
            cardInfo.put("prov_id", huifuMchCheck.getCardProvId());
        }
        if(StrUtil.isNotEmpty(huifuMchCheck.getCardAreaId())) {
            cardInfo.put("area_id", huifuMchCheck.getCardAreaId());
        }
        cardInfo.put("cert_type", "00");
        cardInfo.put("cert_no", huifuMchCheck.getCertNo());
        cardInfo.put("cert_validity_type", huifuMchCheck.getCertValidityType());
        cardInfo.put("cert_begin_date", huifuMchCheck.getCertBeginDate());
        cardInfo.put("cert_end_date", huifuMchCheck.getCertEndDate());
        if(StrUtil.isNotEmpty(huifuMchCheck.getMp())) {
            cardInfo.put("mp", huifuMchCheck.getMp());
        }
        cardInfo.put("settle_card_front_pic", huifuMchCheck.getCardFrontPic());
        cardInfo.put("settle_cert_front_pic", huifuMchCheck.getCertFrontPic());
        cardInfo.put("settle_cert_back_pic", huifuMchCheck.getCertBackPic());
        cardInfo.put("legal_cert_front_pic", huifuMchCheck.getLegalCertFrontPic());
        cardInfo.put("legal_cert_back_pic", huifuMchCheck.getLegalCertBackPic());
        if(StrUtil.isNotEmpty(huifuMchCheck.getSms())) {
            cardInfo.put("verify_code", huifuMchCheck.getSms());
        }
        request.put("card_info", cardInfo);
        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);
        System.out.println("请求体："+ requestData);

        String result = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        JSONObject dataObject = jsonObject.getJSONObject("data");
        String code = dataObject.getString("resp_code");
        if(code.equals("90000000")) {
            LambdaQueryWrapper<THuifuMch> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(THuifuMch::getAdminId,huifuMchCheck.getAdminId());
            THuifuMch tHuifuMch = tHuifuMchService.getOne(queryWrapper);
            // 排除掉不复制的属性
            String[] ignoreProperties = {"id", "createDate","adminId","huifuId"};
            BeanUtil.copyProperties(huifuMchCheck, tHuifuMch, ignoreProperties);
            // 判断持卡人证件有效期类型，1:长期有效，0:非长期有效
            if(huifuMchCheck.getCertValidityType().equals("0")) {
                LocalDate date = LocalDate.parse(huifuMchCheck.getCertEndDate(), DateTimeFormatter.ofPattern("yyyyMMdd"));
                String certEndDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                tHuifuMch.setCertDate(certEndDate);
            } else {
                tHuifuMch.setCertDate("长期");
            }
            tHuifuMch.setModifyDate(new Date());
            huifuMchCheck.setStatus("2");
            huifuMchCheck.setSms(null);
            huifuMchCheck.setModifyDate(new Date());
            tHuifuMchService.updateById(tHuifuMch);
            tHuifuMchCheckService.updateById(huifuMchCheck);
            return "success";
        }else {
            String respDesc = dataObject.getString("resp_desc");
            huifuMchCheck.setStatus("3");
            huifuMchCheck.setSms(null);
            huifuMchCheck.setAuditDesc(respDesc);
            huifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheckService.updateById(huifuMchCheck);
            return respDesc;
        }
    }

    /**
     * 汇付上传图片
     * @param file
     * @return
     */
    @Override
    public String uploadPic(MultipartFile file, HuifuConstant.fileType fileType) {
        String url = "https://api.huifu.com/v2/supplementary/picture";
        // 请求参数
        Map<String, Object> params = new HashMap<String, Object>();
        // 请求流水号，需保证当天商户下唯一，推荐采用日期时间+几位流水号的形式
        params.put("req_seq_id", SequenceTools.getReqSeqId32());
        params.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        params.put("file_type", fileType);
        params.put("picture", fileType.toValue());
        String data = JSON.toJSONString(params);


        CloseableHttpClient httpclient1 = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String result = null;

        try {
            // 获取原始文件名
            String fileName = file.getOriginalFilename();
            // 取得文件扩展名
            String extension = fileName.substring(fileName.lastIndexOf("."));
            // 创建临时文件
            File tempFile = File.createTempFile("temp", extension);
            file.transferTo(tempFile);

            HttpPost httpPost = new HttpPost(url);
            ContentType contentType = ContentType.create("text/plain", Charset.forName("UTF-8"));
            MultipartEntityBuilder mEntityBuilder = MultipartEntityBuilder.create();
            mEntityBuilder.addTextBody("sys_id", HuifuConstant.SYS_ID, contentType);
            mEntityBuilder.addTextBody("product_id", HuifuConstant.PRODUCT_ID, contentType);
            mEntityBuilder.addTextBody("data", data, contentType);
            mEntityBuilder.addBinaryBody("file", tempFile);

            httpPost.setEntity(mEntityBuilder.build());
            response = httpclient1.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_OK) {
                HttpEntity resEntity = response.getEntity();
                result = EntityUtils.toString(resEntity);
                System.out.print(result);
                JSONObject jsonObject = JSONObject.parseObject(result);
                JSONObject dataObject = jsonObject.getJSONObject("data");
                result = dataObject.getString("file_id");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public String refund(String sn, BigDecimal price, String payDate, String remark, String acctSplitBunch, String companyType) throws Exception {
        String url = "https://api.huifu.com/v2/trade/payment/scanpay/refund";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        JSONObject request = new JSONObject();
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        if(StrUtil.isNotEmpty(companyType) && companyType.equals("1")) {
            request.put("huifu_id", HuifuConstant.SC_DIV_HUIFU_ID);
        } else {
            request.put("huifu_id", HuifuConstant.SZ_DIV_HUIFU_ID);
        }
        request.put("ord_amt", price);
        request.put("org_req_date", payDate);
        request.put("org_req_seq_id", sn);
        // 分账明细
        request.put("acct_split_bunch", acctSplitBunch);
        request.put("notify_url", HuifuConstant.Notify_Refund_Url);


        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);
        log.info("退款请求参数：{}", requestData);
        String success = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ success);
        // 拿到返回参数
        JSONObject result = JSONObject.parseObject(success);
        log.info("汇付返回参数：{}", result);
        JSONObject data = result.getJSONObject("data");
        String transStat = data.getString("trans_stat");
        String respCode = data.getString("resp_code");
        String respDesc = data.getString("resp_desc");
        if(respCode.equals("00000000") || respCode.equals("00000100")) {
            return transStat;
        } else {
            return respDesc;
        }
    }

    /**
     * 汇付发送验证码
     * @param tHuifuMch
     * @return
     * @throws Exception
     */
    @Override
    public String sendSms(THuifuMch tHuifuMch) throws Exception {
        String url = "https://api.huifu.com/v2/merchant/basicdata/sms/send";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        JSONObject request = new JSONObject();
        request.put("req_seq_id", HuifuUtils.initReqSeqId());
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        request.put("huifu_id", tHuifuMch.getHuifuId());
        request.put("phone", tHuifuMch.getPhone());
        request.put("verify_type", "settleBankChange");


        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);
        System.out.println("请求体："+ requestData);

        String success = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ success);
        // 拿到返回参数
        JSONObject result = JSONObject.parseObject(success);
        log.info("汇付返回参数：{}", result);
        JSONObject data = result.getJSONObject("data");
        String respCode = data.getString("resp_code");
        return respCode;
    }

    /**
     * 汇付上传图片
     * @param base64Str
     * @return
     */
    @Override
    public String newUploadPic(String base64Str, HuifuConstant.fileType fileType, String huifuId) {
        String url = "https://api.huifu.com/v2/supplementary/picture";
        // 请求参数
        Map<String, Object> params = new HashMap<String, Object>();
        // 请求流水号，需保证当天商户下唯一，推荐采用日期时间+几位流水号的形式
        params.put("req_seq_id", SequenceTools.getReqSeqId32());
        params.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        params.put("file_type", fileType);
        if(StringUtils.isNotEmpty(huifuId)) {
        params.put("huifu_id", huifuId);
        }
        String data = JSON.toJSONString(params);


        CloseableHttpClient httpclient1 = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String result = null;
        File tempFile = new File("");
        try {
            tempFile = base64ToTempImage(base64Str);

            HttpPost httpPost = new HttpPost(url);
            ContentType contentType = ContentType.create("text/plain", Charset.forName("UTF-8"));
            MultipartEntityBuilder mEntityBuilder = MultipartEntityBuilder.create();
            mEntityBuilder.addTextBody("sys_id", HuifuConstant.SYS_ID, contentType);
            mEntityBuilder.addTextBody("product_id", HuifuConstant.PRODUCT_ID, contentType);
            mEntityBuilder.addTextBody("data", data, contentType);
            mEntityBuilder.addBinaryBody("file", tempFile);

            httpPost.setEntity(mEntityBuilder.build());
            response = httpclient1.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_OK) {
                HttpEntity resEntity = response.getEntity();
                result = EntityUtils.toString(resEntity);
                System.out.print(result);
                JSONObject jsonObject = JSONObject.parseObject(result);
                JSONObject dataObject = jsonObject.getJSONObject("data");
                result = dataObject.getString("file_id");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            tempFile.delete();
        }
        return result;
    }

    @Override
    public String updateConStat(THuifuMchCheck tHuifuMchCheck) throws BasePayException {
        // 请求接口
        String url = "https://api.huifu.com/v2/merchant/basicdata/query";
        // 请求参数：Data
        JSONObject request = new JSONObject();
        request.put("req_seq_id", SequenceTools.getReqSeqId32());
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        request.put("huifu_id", tHuifuMchCheck.getHuifuId());


        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);
        System.out.println("请求体："+ requestData);

        String success = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        JSONObject result = JSONObject.parseObject(success);
        log.info("汇付返回参数：{}", result);
        JSONObject data = result.getJSONObject("data");
        String respCode = data.getString("resp_code");
        if(respCode.equals("00000000") || respCode.equals("00000100")) {
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode rootNode = objectMapper.readTree(success);
                JsonNode agreementInfoList = rootNode.path("data").path("agreement_info_list");
                JsonNode agreementNode = objectMapper.readTree(agreementInfoList.asText()).get(0);
                String conStatValue = agreementNode.path("con_stat").asText();
                System.out.println("con_stat value: " + conStatValue);
                tHuifuMchCheck.setConStat(conStatValue);
                tHuifuMchCheckService.updateById(tHuifuMchCheck);
                return conStatValue;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public String checkBalance(THuifuMch tHuifuMch) throws Exception {
        // 请求接口
        String url = "https://api.huifu.com/v2/trade/acctpayment/balance/query";
        HuifuBaseCommon.doInit(OppsMerchantConfig.getMerchantConfig());
        // 请求参数：Data
        JSONObject request = new JSONObject();
        // 请求流水号
        request.put("req_seq_id", SequenceTools.getReqSeqId32());
        // 请求日期
        request.put("req_date", DateTools.getCurrentDateYYYYMMDD());
        // 汇付ID
        request.put("huifu_id", tHuifuMch.getHuifuId());

        // 签名：sign
        String s = JSON.toJSONString(request);
        String s1 = JSON.toJSONString(JSONObject.parseObject(s, TreeMap.class));
        String sign = HuifuUtils.sign(s1, HuifuConstant.RSA_PRIVATE_KEY);

        // 公共参数
        System.out.println("请求参数："+ request);
        JSONObject requestData = new JSONObject();
        requestData.put("sys_id", HuifuConstant.SYS_ID);
        requestData.put("product_id", HuifuConstant.PRODUCT_ID);
        requestData.put("sign", sign);
        requestData.put("data", request);

        String result = OkHttpClientTools.httpPost(url, requestData.toString(), HuifuConstant.PRODUCT_ID);
        System.out.println("返回的数据："+ result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        JSONObject dataObject = jsonObject.getJSONObject("data");
        String acctInfoList = dataObject.getString("acctInfo_list");
        JSONArray acctInfoArray = JSONArray.parseArray(acctInfoList);

        // 如果 "acctInfo_list" 是数组，遍历数组并获取 "balance_amt" 字段的值
        String balanceAmt = "0";
        for (int i = 0; i < acctInfoArray.size(); i++) {
            JSONObject acctInfoObject = acctInfoArray.getJSONObject(i);
            balanceAmt = acctInfoObject.getString("balance_amt");
        }
        return balanceAmt;
    }
}