package com.nova.sankuai.domain.api.yinsheng;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.nova.sankuai.domain.api.yinsheng.config.YinShengProperties;
|
import com.nova.sankuai.domain.api.yinsheng.dto.*;
|
import com.nova.sankuai.domain.api.yinsheng.enums.BusinessTypeEnum;
|
import com.nova.sankuai.domain.api.yinsheng.enums.YinShengMethodEnum;
|
import com.nova.sankuai.domain.api.yinsheng.response.*;
|
import com.nova.sankuai.domain.entity.PayRecord;
|
import com.nova.sankuai.infra.config.CommonException;
|
import com.nova.sankuai.infra.utils.MoneyUtil;
|
import com.nova.sankuai.service.IPayRecordService;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.commons.lang.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.scheduling.annotation.Async;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.PlatformTransactionManager;
|
import org.springframework.transaction.TransactionDefinition;
|
import org.springframework.transaction.TransactionStatus;
|
import org.springframework.transaction.support.DefaultTransactionDefinition;
|
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.HashMap;
|
import java.util.Map;
|
|
import static com.nova.sankuai.domain.api.yinsheng.enums.YinShengMethodEnum.*;
|
|
/**
|
* 银盛快捷协议支付工具类
|
*
|
* @author ephemeral
|
*/
|
@Component
|
@RequiredArgsConstructor
|
public class YinShengFastProtocolUtils {
|
|
@Value("${yinsheng.notify_url}")
|
private String notifyUrl;
|
|
private static final Logger log = LoggerFactory.getLogger("payLogger");
|
|
private static final String METHOD = "method";
|
private static final String PARTNER_ID = "partner_id";
|
private static final String TIMESTAMP = "timestamp";
|
private static final String CHARSET = "charset";
|
private static final String SIGN_TYPE = "sign_type";
|
private static final String SIGN = "sign";
|
private static final String VERSION = "version";
|
private static final String BIZ_CONTENT = "biz_content";
|
|
private static final String UTF_8 = "utf-8";
|
private static final String GM = "SM";
|
private static final String VERSION_NUM = "3.0";
|
|
private final YinShengProperties yinShengProperties;
|
|
private final static String TIMEOUT_EXPRESS = "30m";
|
|
public final static String STATUS_SUCCESS = "10000";
|
|
// 于2022-11-17号
|
private final IPayRecordService payRecordService;
|
|
/**
|
* 准备公共请求参数
|
*
|
* @param method
|
* @return
|
*/
|
private Map<String, String> prepareCommonParam(YinShengMethodEnum method) {
|
Map<String, String> mapData = new HashMap<>();
|
mapData.put(METHOD, method.getCode());
|
mapData.put(PARTNER_ID, yinShengProperties.getPartnerId());
|
mapData.put(TIMESTAMP, DateUtil.getDateNow());
|
mapData.put(CHARSET, UTF_8);
|
mapData.put(SIGN_TYPE, GM);
|
mapData.put(VERSION, VERSION_NUM);
|
log.debug("准备公共请求参数：{}", mapData);
|
return mapData;
|
}
|
|
public Map<String, String> prepareSignParam(FastProtocolSignDTO signDTO) {
|
Map<String, String> mapData = prepareCommonParam(SIGN_PROTOCOL_METHOD);
|
JSONObject json = new JSONObject();
|
json.put("out_trade_no", signDTO.getOutTradeNo());
|
json.put("seller_id", yinShengProperties.getSellerId()); //收款方银盛支付用户号
|
json.put("seller_name", yinShengProperties.getSellerName()); //收款方银盛支付客户名
|
json.put("buyer_name", encryptData(signDTO.getBuyerName()));
|
json.put("buyer_card_number", encryptData(signDTO.getBuyerCardNumber()));
|
json.put("buyer_mobile", encryptData(signDTO.getBuyerMobile()));
|
json.put("pyerIDNo", encryptData(signDTO.getPayerIDNo()));
|
json.put("user_id", signDTO.getUserId());
|
if (StringUtils.isNotEmpty(signDTO.getImei())) {
|
json.put("imei", signDTO.getImei());
|
}
|
if (StringUtils.isNotEmpty(signDTO.getActionScope())) {
|
json.put("actionScope", signDTO.getActionScope());
|
}
|
if (signDTO.getTotalAmount() != null) {
|
json.put("total_amount", MoneyUtil.toYuan(signDTO.getTotalAmount()));
|
}
|
mapData.put(BIZ_CONTENT, json.toString());
|
mapData.put(SIGN, sign(mapData));
|
return mapData;
|
}
|
|
public Map<String, String> prepareSignQueryParam(String protocolNo) {
|
Map<String, String> mapData = prepareCommonParam(QUERY_PROTOCOL_METHOD);
|
JSONObject json = new JSONObject();
|
json.put("protocol_no", protocolNo);
|
mapData.put(BIZ_CONTENT, json.toString());
|
mapData.put(SIGN, sign(mapData));
|
return mapData;
|
}
|
|
public Map<String, String> prepareSignConfirmParam(FastProtocolSignConfirmDTO confirmDTO) {
|
Map<String, String> mapData = prepareCommonParam(SIGN_CONFIRM_METHOD);
|
JSONObject json = new JSONObject();
|
json.put("out_trade_no", confirmDTO.getOutTradeNo());
|
json.put("mobile_verify_code", confirmDTO.getMobileVerifyCode());
|
if (StringUtils.isNotEmpty(confirmDTO.getCardCvn2())) {
|
json.put("cardCvn2", encryptData(confirmDTO.getCardCvn2()));
|
}
|
if (StringUtils.isNotEmpty(confirmDTO.getCardExprDt())) {
|
json.put("cardExprDt", encryptData(confirmDTO.getCardExprDt()));
|
}
|
mapData.put(BIZ_CONTENT, json.toString());
|
mapData.put(SIGN, sign(mapData));
|
return mapData;
|
}
|
|
public Map<String, String> prepareSmsResendParam(String paySn) {
|
Map<String, String> mapData = prepareCommonParam(FAST_PROTOCOL_SMS_RESEND);
|
JSONObject json = new JSONObject();
|
json.put("paysn", paySn);
|
mapData.put(BIZ_CONTENT, json.toString());
|
mapData.put(SIGN, sign(mapData));
|
return mapData;
|
}
|
|
public Map<String, String> prepareSmsConfirmParam(SmsConfirmDTO confirmDTO) {
|
Map<String, String> mapData = prepareCommonParam(FAST_PROTOCOL_SMS_CONFIRM);
|
JSONObject json = new JSONObject();
|
json.put("paysn", confirmDTO.getPaySn());
|
json.put("mobile_verify_code", confirmDTO.getMobileVerifyCode());
|
mapData.put(BIZ_CONTENT, json.toString());
|
mapData.put(SIGN, sign(mapData));
|
return mapData;
|
}
|
|
public Map<String, String> preparePayParam(FastProtocolPayDTO payDTO) {
|
Map<String, String> mapData = prepareCommonParam(FAST_PROTOCOL_PAY);
|
|
mapData.put("notify_url", notifyUrl + "/api/v1/vipCardOrder/notifyByYinSheng");
|
|
JSONObject json = new JSONObject();
|
json.put("out_trade_no", payDTO.getOutTradeNo());//商户生成的订单号，生成规则前8位为交易日期，如20180525，范围跨度支持包含当天在内的前后一天，且只能由大小写英文字母、数字、下划线及横杠组成
|
json.put("shopdate", DateUtil.getDateNowYmd());//商户日期(该参数做交易与查询时需要一致) 该日期需在当日的前后一天时间范围之内
|
json.put("subject", payDTO.getSubject());//商品的标题/交易标题/订单标题/订单关键字等。该参数最长为250个汉字。
|
json.put("total_amount", MoneyUtil.toYuan(payDTO.getTotalAmount()));//该笔订单的资金总额，单位为RMB-Yuan。取值范围为[0.01，100000000.00]，精确到小数点后两位。Number(10,2)指10位长度，2位精度
|
if (StringUtils.isNotEmpty(payDTO.getCurrency())) {
|
json.put("currency", payDTO.getCurrency());//支持币种：CNY（人民币）、HKD（港币）、USD（美元）、EUR（欧元）、JPY（日元）。注：不填默认是CNY（人民币），如是非跨境商户，币种不能填HKD（港币）、USD（美元）、EUR（欧元）、JPY（日元）中的任意一种外币币种。
|
} else {
|
json.put("currency", "CNY");
|
}
|
json.put("seller_id", yinShengProperties.getSellerId());//收款方银盛支付用户号
|
json.put("seller_name", yinShengProperties.getSellerName());//收款方银盛支付客户名
|
json.put("timeout_express", TIMEOUT_EXPRESS);//设置未付款交易的超时时间，一旦超时，该笔交易就会自动被关闭。取值范围：1m～15d。m-分钟，h-小时，d-天。该参数数值不接受小数点，如1.5h，可转换为90m。
|
if (StringUtils.isNotEmpty(payDTO.getExtendParams())) {
|
json.put("extend_params", payDTO.getExtendParams());//业务扩展参数，一个json字符串,order_mode订单模式，暂时可选的值为:00 代表购物车模式;seller_list参与分账的收款方信息数组，每个元素包含seller_id收款方银盛支付用户号。实时分账业务，order_mode和seller_list均不能为空，order_mode的值必须为00。
|
}
|
if (StringUtils.isNotEmpty(payDTO.getExtraCommonParam())) {
|
json.put("extra_common_param", payDTO.getExtraCommonParam());//公用回传参数
|
}
|
json.put("business_code", yinShengProperties.getBusinessCode());//业务代码
|
json.put("user_id", Long.toString(payDTO.getUserId()));//唯一客户标识，商户旗下客户号。签约时的user_id
|
json.put("protocol_no", payDTO.getProtocolNo());//银盛支付平台的签约流水号：商户签约确认接口（mercSignConfirm）返回的protocol_no
|
if (StringUtils.isNotEmpty(payDTO.getCardCvn2())) {
|
json.put("cardCvn2", payDTO.getCardCvn2());//贷记卡必传，如果签名方式为RSA，则用DES加密，密钥为商户号前8位，不足8位在商户号前补空格;如果签名方式为SM，则用SM加密
|
}
|
if (StringUtils.isNotEmpty(payDTO.getCardExprDt())) {
|
json.put("cardExprDt", payDTO.getCardExprDt());//贷记卡必传，如果签名方式为RSA，则用DES加密，密钥为商户号前8位，不足8位在商户号前补空格，格式为MMYY; 如果签名方式为SM，则用SM加密
|
}
|
|
SubMerchantInfoDTO subMerchant = payDTO.getSubMerchant();
|
if (subMerchant != null) {
|
JSONObject subMerchantObj = new JSONObject();
|
subMerchantObj.put("merName", subMerchant.getMerName());//二级商户名称,支持25个中文
|
subMerchantObj.put("merShortName", subMerchant.getMerShortName());//二级商户简称,支持25个中文
|
subMerchantObj.put("merAddr", subMerchant.getMerAddr());//二级商户地址,支持100个中文
|
subMerchantObj.put("telephone", subMerchant.getTelephone());//固定电话/手机号码二选一
|
subMerchantObj.put("merNo", subMerchant.getMerNo());//二级商户编号
|
subMerchantObj.put("category", subMerchant.getCategory());//类目，按附件内容输入类目编号
|
subMerchantObj.put("mrchntCertId", subMerchant
|
.getMerchantCertId());//身份证号,只支持身份证格式如果签名方式为RSA，则用DES加密，密钥为商户号前8位，不足8位在商户号前补空格; 如果签名方式为SM，则用SM加密)
|
json.put("sub_merchant", subMerchantObj);
|
}
|
ConsigeeInfoDTO consigneeInfo = payDTO.getConsigneeInfo();
|
if (consigneeInfo != null) {
|
JSONObject consigneeInfoObj = new JSONObject();
|
consigneeInfoObj.put("consigneeName", consigneeInfo.getConsigneeName());//收货人姓名
|
consigneeInfoObj.put("consigneeAddr", consigneeInfo.getConsigneeAddr());//收货地址
|
consigneeInfoObj.put("transportationInfo", consigneeInfo.getTransportationInfo());//物流配送信息（物流名称+订单号）
|
consigneeInfoObj.put("commodityName", consigneeInfo.getCommodityName());//商品名称
|
consigneeInfoObj.put("commodityNumber", consigneeInfo.getCommodityNumber());//商品数量,
|
json.put("consignee_info", consigneeInfoObj);
|
}
|
if (StringUtils.isNotEmpty(payDTO.getMccs())) {
|
json.put("mccs", payDTO.getMccs());//Mcc码（支持上传多个，多个用|分割）
|
}
|
if (StringUtils.isNotEmpty(payDTO.getMerNo())) {
|
json.put("mer_no", payDTO.getMerNo());//第三方商户号
|
}
|
if (StringUtils.isNotEmpty(payDTO.getSubmerIp())) {
|
json.put("submer_ip", payDTO.getSubmerIp());//子商户ip
|
}
|
mapData.put(BIZ_CONTENT, json.toString());
|
mapData.put(SIGN, sign(mapData));
|
return mapData;
|
}
|
|
private String post(Map<String, String> mapData) {
|
try {
|
return HttpRequest.sendPost(yinShengProperties.getApiUrl(), CommonUtil.mapToString(mapData));
|
} catch (Exception e) {
|
log.error("\n【请求地址】: {}\n【请求参数】：{}\n【异常信息】：{}", yinShengProperties.getApiUrl(), CommonUtil.mapToString(mapData), e.getMessage());
|
throw new CommonException(e);
|
}
|
}
|
|
public FastProtocolResponse constructFastProtocolResponse(JSONObject jsonObj) {
|
if (jsonObj == null) {
|
return null;
|
}
|
String code = jsonObj.getString("code");
|
String msg = jsonObj.getString("msg");
|
String outTradeNo = jsonObj.getString("out_trade_no");
|
String protocolNo = jsonObj.getString("protocol_no");
|
String tradeStatus = jsonObj.getString("trade_status");
|
String subMsg = jsonObj.getString("sub_msg");
|
String bankType = jsonObj.getString("banktype");
|
|
FastProtocolResponse response = new FastProtocolResponse();
|
response.setCode(code);
|
response.setMsg(msg);
|
response.setOutTradeNo(outTradeNo);
|
response.setTradeStatus(tradeStatus);
|
response.setProtocolNo(protocolNo);
|
response.setBankType(bankType);
|
response.setSubMsg(subMsg);
|
return response;
|
}
|
|
public FastProtocolQueryResponse constructFastProtocolQueryResponse(JSONObject jsonObj) {
|
if (jsonObj == null) {
|
return null;
|
}
|
String code = jsonObj.getString("code");
|
String msg = jsonObj.getString("msg");
|
String protocolNo = jsonObj.getString("protocol_no");
|
String tradeStatus = jsonObj.getString("trade_status");
|
String bankType = jsonObj.getString("banktype");
|
|
FastProtocolQueryResponse response = new FastProtocolQueryResponse();
|
response.setCode(code);
|
response.setMsg(msg);
|
response.setTradeStatus(tradeStatus);
|
response.setProtocolNo(protocolNo);
|
response.setBankType(bankType);
|
return response;
|
}
|
|
public SmsResendResponse constructSmsResendResponse(JSONObject jsonObj) {
|
if (jsonObj == null) {
|
return null;
|
}
|
String code = jsonObj.getString("code");
|
String msg = jsonObj.getString("msg");
|
String payStatus = jsonObj.getString("pay_status");
|
|
SmsResendResponse response = new SmsResendResponse();
|
response.setCode(code);
|
response.setMsg(msg);
|
response.setPayStatus(payStatus);
|
return response;
|
}
|
|
public FastProtocolPayResponse constructFastProtocolPayResponse(JSONObject jsonObj) {
|
if (jsonObj == null) {
|
return null;
|
}
|
String code = jsonObj.getString("code");
|
String msg = jsonObj.getString("msg");
|
String outTradeNo = jsonObj.getString("out_trade_no");
|
String tradeNo = jsonObj.getString("trade_no");
|
String tradeStatus = jsonObj.getString("trade_status");
|
String totalAmount = jsonObj.getString("total_amount");
|
String accountDate = jsonObj.getString("account_date");
|
String needSign = jsonObj.getString("need_sign");
|
String needSmsConfirm = jsonObj.getString("need_sms_confirm");
|
String paySn = jsonObj.getString("paysn");
|
String subMsg = jsonObj.getString("sub_msg");
|
String payStatus = jsonObj.getString("pay_status");
|
String merDiscountFee = jsonObj.getString("mer_discount_fee");
|
|
FastProtocolPayResponse response = new FastProtocolPayResponse();
|
response.setCode(code);
|
response.setMsg(msg);
|
response.setOutTradeNo(outTradeNo);
|
response.setTradeNo(tradeNo);
|
response.setTradeStatus(tradeStatus);
|
response.setTotalAmount(totalAmount);
|
response.setAccountDate(accountDate);
|
response.setNeedSign(needSign);
|
response.setNeedSmsConfirm(needSmsConfirm);
|
response.setPaySn(paySn);
|
response.setSubMsg(subMsg);
|
response.setPayStatus(payStatus);
|
response.setMerDiscountFee(merDiscountFee);
|
|
JSONObject installmentResp = jsonObj.getJSONObject("installment_resp");
|
if (installmentResp != null) {
|
String installmentNum = installmentResp.getString("installment_num");
|
String installmentFeeTotal = installmentResp.getString("installment_fee_total");
|
String installmentFeePayMode = installmentResp.getString("installment_fee_pay_mode");
|
String firstFee = installmentResp.getString("first_fee");
|
String eachFee = installmentResp.getString("each_fee");
|
String firstBackAmount = installmentResp.getString("first_back_amount");
|
String realDiscountFeeRate = installmentResp.getString("real_discount_fee_rate");
|
|
InstallmentResponse installmentResponse = new InstallmentResponse();
|
installmentResponse.setInstallmentNum(installmentNum);
|
installmentResponse.setInstallmentFeeTotal(installmentFeeTotal);
|
installmentResponse.setInstallmentFeePayMode(installmentFeePayMode);
|
installmentResponse.setFirstFee(firstFee);
|
installmentResponse.setEachFee(eachFee);
|
installmentResponse.setFirstBackAmount(firstBackAmount);
|
installmentResponse.setRealDiscountFeeRate(realDiscountFeeRate);
|
|
response.setInstallmentResp(installmentResponse);
|
}
|
|
return response;
|
}
|
|
private String sign(Map<String, String> mapData) {
|
try {
|
String signContent = CommonUtil.mapToString(mapData);
|
return GMSignUtils.signMsgSM2(yinShengProperties.getPrivateKeyPath(), yinShengProperties.getPassword(), signContent);
|
} catch (Exception e) {
|
log.error("国密签名失败", e);
|
throw new CommonException(e);
|
}
|
}
|
|
private String encryptData(String data) {
|
try {
|
return GMSignUtils.encryptData(yinShengProperties.getPublicKeyPath(), data);
|
} catch (Exception e) {
|
log.error("参数加密失败，加密数据：{}", data, e);
|
throw new CommonException(e);
|
}
|
}
|
|
public FastProtocolResponse fastProtocolSign(FastProtocolSignDTO fastProtocolSignDTO) {
|
|
try {
|
Map<String, String> mapData = prepareSignParam(fastProtocolSignDTO);
|
log.info("银盛快捷协议支付签约申请入参为:{}", mapData.toString());
|
String result = post(mapData);
|
log.info("银盛快捷协议支付签约申请响应参数为:{}", result);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
JSONObject signObj = jsonObject.getJSONObject(BusinessTypeEnum.SIGN.getCode());
|
log.info("银盛快捷协议支付签约申请响应解密参数为:{}", signObj);
|
|
FastProtocolResponse response = constructFastProtocolResponse(signObj);
|
|
// 于2022-11-18新增
|
payRecordImpl(mapData, signObj);
|
// 完
|
return response;
|
} catch (Exception e) {
|
log.error("银盛快捷协议支付签约申请失败", e);
|
}
|
return null;
|
}
|
|
@Autowired
|
private PlatformTransactionManager transactionManager;// 引入 (平台)事务管理器，Spring 事务策略的核心。
|
|
/**
|
* 于2022-11-18新增：录入支付记录表
|
*/
|
@Async
|
public void payRecordImpl(Map<String, String> mapData, JSONObject signObj) {
|
// 业务请求参数的集合
|
String biz_content = mapData.get("biz_content");
|
if (StringUtils.isBlank(biz_content)) {
|
log.error("没有biz_content参数");
|
return;
|
}
|
JSONObject jsonObject = JSONObject.parseObject(biz_content);
|
String method = mapData.get("method");
|
// 用户ID号
|
String user_id_str = jsonObject.getString("user_id");
|
Long user_id = StringUtils.isBlank(user_id_str) ? 0L : Long.parseLong(user_id_str);
|
|
PayRecord payRecord = new PayRecord();
|
// ys 银盛支付 st闪态支付 al支付宝支付 yp 银盛签约 sp闪态签约 yd银盛获取短信验证 ys epay.trusteeship.sign.confirm sd闪态获取短信验证码 yc银盛签约确认 sc闪态签约确认
|
|
Integer payStatus = null;// 交易状态：支付、签约、短信等状态码，1成功 2失败 3 签约成功需再次确认
|
String trade_status = signObj.getString("trade_status");
|
String succ = "SUCCESS";// 成功；
|
String failed = "FAILED"; // FAILED：签约失败
|
if (StringUtils.isBlank(trade_status)) {// 若trade_status参数为空
|
String code = signObj.getString("code");
|
String msg = signObj.getString("msg");
|
log.info("没有trade_status参数:{} code:{} msg:{}", user_id, code, msg);
|
if ("10000".equals(code) && "Success".equals(msg)) {
|
trade_status = "ysepay.trusteeship.fastPay".equals(method) ? "TRADE_SUCCESS" : succ;
|
} else {
|
trade_status = "ysepay.trusteeship.fastPay".equals(method) ? "TRADE_FAILED" : failed;
|
}
|
// return;
|
}
|
|
if ("ysepay.trusteeship.sign.confirm".equals(method)) {// 签约确认
|
payRecord.setPayType("yc");
|
if (succ.equals(trade_status)) {
|
payStatus = 1;
|
} else {// 失败
|
payStatus = 2;
|
}
|
} else if ("ysepay.trusteeship.sign".equals(method)) {// 签约
|
payRecord.setPayType("yp");
|
if (succ.equals(trade_status)) {
|
payStatus = 1;
|
} else if (failed.equals(trade_status)){// 失败
|
payStatus = 2;
|
} else {
|
payStatus = 3;
|
}
|
} else if ("ysepay.trusteeship.fastPay".equals(method)) {// 快捷支付
|
payRecord.setPayType("ys");
|
String pay_status = signObj.getString("pay_status");
|
trade_status = StringUtils.isNotBlank(pay_status) ? pay_status : trade_status;
|
|
switch (trade_status) {
|
case "TRADE_SUCCESS":
|
payStatus = 1;
|
break;
|
case "TRADE_FAILED": // 失败
|
payStatus = 2;
|
break;
|
case "WAIT_BUYER_PAY": // 交易创建，等待买家付款
|
payStatus = 4;
|
break;
|
case "TRADE_CLOSED": // 在指定时间段内未支付时关闭的交易；客户主动关闭订单
|
payStatus = 5;
|
break;
|
case "TRADE_CANCEL": // 订单已撤销
|
payStatus = 7;
|
break;
|
case "TRADE_PROCESS": // 交易正在处理中，可对该交易做查询，避免重复支付
|
payStatus = 8;
|
break;
|
}
|
} else {
|
log.error("method参数不正确:{}", user_id);
|
return;
|
}
|
|
if (payStatus == null) {
|
log.error("交易状态参数不正确:{}", user_id);
|
return;
|
}
|
|
payRecord.setPayStatus(payStatus);
|
if (payStatus != 1) {// 交易状态不为1，成功
|
String sub_msg = signObj.getString("sub_msg");
|
payRecord.setPayError(sub_msg);
|
payRecord.setPayErrorCode(trade_status);
|
}
|
|
// 订单号
|
String out_trade_no = jsonObject.getString("out_trade_no");
|
if (StringUtils.isBlank(out_trade_no)) {
|
log.error("交易订单号不能为空:{}", user_id);
|
return;
|
}
|
payRecord.setOutTradeNo(out_trade_no);
|
|
// 交易时间
|
String timestamp = mapData.get("timestamp");
|
if (StringUtils.isBlank(timestamp)) {
|
LocalDateTime payDate = LocalDateTime.now();
|
payRecord.setPayDate(payDate);
|
} else {
|
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
LocalDateTime payDate = LocalDateTime.parse(timestamp, df);
|
payRecord.setPayDate(payDate);
|
}
|
|
// 短信验证码
|
String mobileVerifyCode = jsonObject.getString("mobile_verify_code");
|
payRecord.setMobileVerifyCode(mobileVerifyCode);
|
|
// 若是银盛签约确认
|
if ("yc".equals(payRecord.getPayType())) {
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
TransactionStatus defStatus = transactionManager.getTransaction(def);// 获得事务状态
|
// 获取获取验证码的数据
|
// payRecordService.lambdaQuery().eq(PayRecord::getOutTradeNo, out_trade_no).eq(PayRecord::getPayType, "yp");
|
LambdaQueryWrapper<PayRecord> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(PayRecord::getOutTradeNo, out_trade_no).eq(PayRecord::getPayType, "yp");
|
PayRecord ypPayRecord = payRecordService.getOne(wrapper);
|
if (ypPayRecord != null) {
|
payRecord.setUserId(ypPayRecord.getUserId());
|
payRecord.setId(ypPayRecord.getId());
|
payRecord.setMobileVerifyCode(ypPayRecord.getMobileVerifyCode());
|
payRecordService.updateById(payRecord);
|
}
|
transactionManager.commit(defStatus);// 手动提交事务
|
|
return;
|
}
|
|
if (user_id_str == null) {
|
log.error("没有用户ID号");
|
return;
|
}
|
payRecord.setUserId(user_id);
|
|
// 交易金额
|
String total_amount = jsonObject.getString("total_amount");
|
payRecord.setTotalAmount(total_amount);
|
|
// 流水号
|
String tradeNo = signObj.getString("trade_no");
|
payRecord.setTradeNo(tradeNo);
|
|
// 发起一个新事务
|
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
|
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);//新发起一个事务
|
TransactionStatus defStatus = transactionManager.getTransaction(def);// 获得事务状态
|
payRecordService.save(payRecord);
|
transactionManager.commit(defStatus);// 手动提交事务
|
}
|
|
public FastProtocolQueryResponse fastProtocolQuery(String protocolNo) {
|
try {
|
Map<String, String> mapData = prepareSignQueryParam(protocolNo);
|
log.info("银盛快捷协议支付签约查询请求入参为:{}", mapData.toString());
|
String result = post(mapData);
|
log.info("银盛快捷协议支付签约查询请求响应参数为:{}", result);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
JSONObject signObj = jsonObject.getJSONObject(BusinessTypeEnum.SIGN_QUERY.getCode());
|
log.info("银盛快捷协议支付签约查询请求响应解密参数为:{}", signObj);
|
FastProtocolQueryResponse response = constructFastProtocolQueryResponse(signObj);
|
return response;
|
} catch (Exception e) {
|
log.error("银盛快捷协议支付签约查询请求失败", e);
|
}
|
return null;
|
}
|
|
public FastProtocolResponse fastProtocolSignConfirm(FastProtocolSignConfirmDTO confirmDTO) {
|
|
try {
|
Map<String, String> mapData = prepareSignConfirmParam(confirmDTO);
|
log.info("银盛快捷协议支付签约确认请求入参为:{}", mapData.toString());
|
String result = post(mapData);
|
log.info("银盛快捷协议支付签约确认请求响应参数为:{}", result);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
JSONObject confirmObj = jsonObject.getJSONObject(BusinessTypeEnum.CONFIRM.getCode());
|
log.info("银盛快捷协议支付签约确认请求响应解密参数为:{}", confirmObj);
|
FastProtocolResponse response = constructFastProtocolResponse(confirmObj);
|
payRecordImpl(mapData, confirmObj);
|
return response;
|
} catch (Exception e) {
|
log.error("银盛快捷协议支付签约确认请求失败", e);
|
}
|
return null;
|
}
|
|
public SmsResendResponse smsResend(String paySn) {
|
try {
|
Map<String, String> mapData = prepareSmsResendParam(paySn);
|
log.info("银盛快捷协议支付重新发送支付验证短信请求入参为:{}", mapData.toString());
|
String result = post(mapData);
|
log.info("银盛快捷协议支付重新发送支付验证短信请求响应参数为:{}", result);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
JSONObject payObj = jsonObject.getJSONObject(BusinessTypeEnum.SMS_RESEND.getCode());
|
log.info("银盛快捷协议支付重新发送支付验证短信请求解密参数为:{}", payObj);
|
SmsResendResponse ret = constructSmsResendResponse(payObj);
|
return ret;
|
} catch (Exception e) {
|
log.error("银盛快捷协议支付重新发送支付验证短信请求失败", e);
|
}
|
return null;
|
}
|
|
public FastProtocolPayResponse smsConfirm(SmsConfirmDTO confirmDTO) {
|
|
try {
|
Map<String, String> mapData = prepareSmsConfirmParam(confirmDTO);
|
log.info("银盛快捷协议支付短信确认支付请求入参为:{}", mapData.toString());
|
String result = post(mapData);
|
log.info("银盛快捷协议支付短信确认支付请求响应参数为:{}", result);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
JSONObject payObj = jsonObject.getJSONObject(BusinessTypeEnum.PAY.getCode());
|
log.info("银盛快捷协议支付短信确认支付请求响应解密参数为:{}", payObj);
|
|
FastProtocolPayResponse ret = constructFastProtocolPayResponse(payObj);
|
// 于2022-11-18新增
|
payRecordImpl(mapData, payObj);
|
// 完
|
return ret;
|
} catch (Exception e) {
|
log.error("银盛快捷协议支付短信确认支付失败", e);
|
}
|
return null;
|
}
|
|
public FastProtocolPayResponse fastProtocolPay(FastProtocolPayDTO payDTO) {
|
try {
|
Map<String, String> mapData = preparePayParam(payDTO);
|
log.info("银盛快捷协议支付请求入参为:{}", mapData.toString());
|
String result = post(mapData);
|
log.info("银盛快捷协议支付请求响应参数为:{}", result);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
JSONObject payObj = jsonObject.getJSONObject(BusinessTypeEnum.PAY.getCode());
|
log.info("银盛快捷协议支付请求响应解密参数为:{}", payObj);
|
|
FastProtocolPayResponse ret = constructFastProtocolPayResponse(payObj);
|
// 于2022-11-18新增
|
payRecordImpl(mapData, payObj);
|
// 完
|
return ret;
|
} catch (Exception e) {
|
log.error("银盛快捷协议支付失败", e);
|
}
|
return null;
|
}
|
}
|
