PayOldApi.java
package com.foxinmy.weixin4j.mp.api;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.security.KeyStore;
import java.security.SecureRandom;
import java.security.cert.CertificateFactory;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.parser.Feature;
import com.foxinmy.weixin4j.cache.CacheStorager;
import com.foxinmy.weixin4j.cache.FileCacheStorager;
import com.foxinmy.weixin4j.exception.WeixinException;
import com.foxinmy.weixin4j.http.entity.FormUrlEntity;
import com.foxinmy.weixin4j.http.weixin.ApiResult;
import com.foxinmy.weixin4j.http.weixin.WeixinResponse;
import com.foxinmy.weixin4j.model.Token;
import com.foxinmy.weixin4j.mp.oldpayment.OrderV2;
import com.foxinmy.weixin4j.mp.oldpayment.PayPackageV2;
import com.foxinmy.weixin4j.mp.oldpayment.RefundRecordV2;
import com.foxinmy.weixin4j.mp.oldpayment.RefundResultV2;
import com.foxinmy.weixin4j.mp.oldpayment.WeixinOldPayAccount;
import com.foxinmy.weixin4j.mp.oldpayment.WeixinOldPaymentSignature;
import com.foxinmy.weixin4j.mp.token.WeixinTokenCreator;
import com.foxinmy.weixin4j.payment.PayRequest;
import com.foxinmy.weixin4j.sign.WeixinPaymentSignature;
import com.foxinmy.weixin4j.sign.WeixinSignature;
import com.foxinmy.weixin4j.token.TokenManager;
import com.foxinmy.weixin4j.type.IdQuery;
import com.foxinmy.weixin4j.type.SignType;
import com.foxinmy.weixin4j.type.mch.BillType;
import com.foxinmy.weixin4j.type.mch.RefundType;
import com.foxinmy.weixin4j.util.Consts;
import com.foxinmy.weixin4j.util.DateUtil;
import com.foxinmy.weixin4j.util.DigestUtil;
import com.foxinmy.weixin4j.util.MapUtil;
import com.foxinmy.weixin4j.util.RandomUtil;
import com.foxinmy.weixin4j.util.StringUtil;
import com.foxinmy.weixin4j.util.Weixin4jConfigUtil;
import com.foxinmy.weixin4j.xml.ListsuffixResultDeserializer;
/**
* V2老支付API
*
* @className PayOldApi
* @author jinyu(foxinmy@gmail.com)
* @date 2014年10月28日
* @since JDK 1.6
* @see
*/
public class PayOldApi extends MpApi {
private final WeixinOldPayAccount weixinPayAccount;
private final TokenManager tokenManager;
private final WeixinSignature weixinMD5Signature;
private final WeixinOldPaymentSignature weixinSignature;
/**
* 支付对象(使用weixin4j.properties配置的account商户信息,使用FileCacheStorager文件方式缓存TOKEN)
*/
public PayOldApi() {
this(new FileCacheStorager<Token>());
}
/**
* 支付对象(使用weixin4j.properties配置的account商户信息)
*/
public PayOldApi(CacheStorager<Token> cacheStorager) {
this(JSON.parseObject(Weixin4jConfigUtil.getValue("account"),
WeixinOldPayAccount.class), cacheStorager);
}
/**
* 支付对象
*
* @param weixinPayAccount
* 商户信息
* @param cacheStorager
* token管理
*/
public PayOldApi(WeixinOldPayAccount weixinPayAccount,
CacheStorager<Token> cacheStorager) {
if (weixinPayAccount == null) {
throw new IllegalArgumentException(
"weixinPayAccount must not be empty");
}
if (cacheStorager == null) {
throw new IllegalArgumentException(
"cacheStorager must not be empty");
}
this.weixinPayAccount = weixinPayAccount;
this.tokenManager = new TokenManager(new WeixinTokenCreator(
weixinPayAccount.getId(), weixinPayAccount.getSecret()),
cacheStorager);
this.weixinMD5Signature = new WeixinPaymentSignature(
weixinPayAccount.getPartnerKey());
this.weixinSignature = new WeixinOldPaymentSignature(
weixinPayAccount.getPaySignKey(),
weixinPayAccount.getPartnerKey());
}
/**
* 返回商户信息
*
* @return
*/
public WeixinOldPayAccount getWeixinPayAccount() {
return weixinPayAccount;
}
/**
* token管理
*
* @return
*/
public TokenManager getTokenManager() {
return this.tokenManager;
}
/**
* 返回签名对象
*
* @return
*/
public WeixinOldPaymentSignature getWeixinPaymentSignature() {
return this.weixinSignature;
}
/**
* 生成V2.x版本JSAPI支付字符串
*
* @param body
* 支付详情
* @param outTradeNo
* 订单号
* @param totalFee
* 订单总额(元)
* @param notifyUrl
* 支付回调URL
* @param createIp
* 订单生成的机器 IP
* @return 支付json串
*/
public String createPayJsRequestJson(String body, String outTradeNo,
double totalFee, String notifyUrl, String createIp) {
PayPackageV2 payPackage = new PayPackageV2(
weixinPayAccount.getPartnerId(), body, outTradeNo, totalFee,
notifyUrl, createIp);
return createPayJsRequestJson(payPackage);
}
/**
* 生成V2.x版本JSAPI支付字符串
*
* @param payPackage
* 支付信息
* @return 支付json串
*/
public String createPayJsRequestJson(PayPackageV2 payPackage) {
PayRequest payRequest = new PayRequest(weixinPayAccount.getId(),
weixinSignature.sign(payPackage));
payRequest.setPaySign(weixinSignature.sign(payRequest));
payRequest.setSignType(SignType.SHA1);
return JSON.toJSONString(payRequest);
}
/**
* 创建V2.x NativePay支付链接
*
* @param productId
* 与订单ID等价
* @return 支付链接
*/
public String createNativePayRequestURL(String productId) {
Map<String, String> map = new HashMap<String, String>();
String timestamp = DateUtil.timestamp2string();
String noncestr = RandomUtil.generateString(16);
map.put("appid", weixinPayAccount.getId());
map.put("timestamp", timestamp);
map.put("noncestr", noncestr);
map.put("productid", productId);
map.put("appkey", weixinPayAccount.getPaySignKey());
String sign = weixinSignature.sign(map);
String nativepay_uri = getRequestUri("nativepay_old_uri");
return String.format(nativepay_uri, sign, weixinPayAccount.getId(),
productId, timestamp, noncestr);
}
/**
* 订单查询
*
* @param idQuery
* 订单号
* @return 订单信息
* @see com.foxinmy.weixin4j.mp.oldpayment.OrderV2
* @since V2
* @throws WeixinException
*/
public OrderV2 queryOrder(IdQuery idQuery) throws WeixinException {
String orderquery_uri = getRequestUri("orderquery_old_uri");
Token token = tokenManager.getCache();
StringBuilder sb = new StringBuilder();
sb.append(idQuery.getType().getName()).append("=")
.append(idQuery.getId());
sb.append("&partner=").append(weixinPayAccount.getPartnerId());
String part = sb.toString();
sb.append("&key=").append(weixinPayAccount.getPartnerKey());
String sign = DigestUtil.MD5(sb.toString()).toUpperCase();
sb.delete(0, sb.length());
sb.append(part).append("&sign=").append(sign);
String timestamp = DateUtil.timestamp2string();
JSONObject obj = new JSONObject();
obj.put("appid", weixinPayAccount.getId());
obj.put("appkey", weixinPayAccount.getPaySignKey());
obj.put("package", sb.toString());
obj.put("timestamp", timestamp);
String signature = weixinSignature.sign(obj);
obj.clear();
obj.put("appid", weixinPayAccount.getId());
obj.put("package", sb.toString());
obj.put("timestamp", timestamp);
obj.put("app_signature", signature);
obj.put("sign_method", SignType.SHA1.name().toLowerCase());
WeixinResponse response = weixinExecutor.post(
String.format(orderquery_uri, token.getAccessToken()),
obj.toJSONString());
String order_info = response.getAsJson().getString("order_info");
OrderV2 order = JSON.parseObject(order_info, OrderV2.class,
Feature.IgnoreNotMatch);
if (order.getRetCode() != 0) {
throw new WeixinException(Integer.toString(order.getRetCode()),
order.getRetMsg());
}
return order;
}
/**
* 申请退款(需要证书)</br>
* <p style="color:red">
* 交易时间超过 1 年的订单无法提交退款; </br> 支持部分退款,部分退需要设置相同的订单号和不同的 out_refund_no。一笔退款失
* 败后重新提交,要采用原来的 out_refund_no。总退款金额不能超过用户实际支付金额。</br>
* </p>
*
* @param certificate
* 证书文件(V2版本后缀为*.pfx)
* @param idQuery
* 商户系统内部的订单号, transaction_id 、 out_trade_no 二选一,如果同时存在优先级:
* transaction_id> out_trade_no
* @param outRefundNo
* 商户系统内部的退款单号,商 户系统内部唯一,同一退款单号多次请求只退一笔
* @param totalFee
* 订单总金额,单位为元
* @param refundFee
* 退款总金额,单位为元,可以做部分退款
* @param opUserId
* 操作员帐号, 默认为商户号
* @param mopara
* 如 opUserPasswd
*
* @return 退款申请结果
* @see com.foxinmy.weixin4j.mp.oldpayment.RefundResultV2
* @since V2
* @throws WeixinException
*/
protected RefundResultV2 applyRefund(InputStream certificate,
IdQuery idQuery, String outRefundNo, double totalFee,
double refundFee, String opUserId, Map<String, String> mopara)
throws WeixinException {
String refund_uri = getRequestUri("refundapply_old_uri");
WeixinResponse response = null;
try {
Map<String, String> map = new HashMap<String, String>();
map.put("input_charset", Consts.UTF_8.name());
// 版本号
// 填写为 1.0 时,操作员密码为明文
// 填写为 1.1 时,操作员密码为 MD5(密码)值
map.put("service_version", "1.1");
map.put("partner", weixinPayAccount.getPartnerId());
map.put("out_refund_no", outRefundNo);
map.put("total_fee",
Integer.toString(DateUtil.formatYuan2Fen(totalFee)));
map.put("refund_fee",
Integer.toString(DateUtil.formatYuan2Fen(refundFee)));
map.put(idQuery.getType().getName(), idQuery.getId());
if (StringUtil.isBlank(opUserId)) {
opUserId = weixinPayAccount.getPartnerId();
}
map.put("op_user_id", opUserId);
if (mopara != null && !mopara.isEmpty()) {
map.putAll(mopara);
}
String sign = weixinMD5Signature.sign(map);
map.put("sign", sign.toUpperCase());
SSLContext ctx = null;
KeyStore ks = null;
String jksPwd = "";
File jksFile = new File(String.format("%s%stenpay_cacert.jks",
System.getProperty("java.io.tmpdir"), File.separator));
// create jks ca
if (!jksFile.exists()) {
CertificateFactory cf = CertificateFactory
.getInstance(Consts.X509);
java.security.cert.Certificate cert = cf
.generateCertificate(PayOldApi.class
.getResourceAsStream("cacert.pem"));
ks = KeyStore.getInstance(Consts.JKS);
ks.load(null, null);
ks.setCertificateEntry("tenpay", cert);
FileOutputStream os = new FileOutputStream(jksFile);
ks.store(os, jksPwd.toCharArray());
os.close();
}
// load jks ca
TrustManagerFactory tmf = TrustManagerFactory
.getInstance(Consts.SunX509);
ks = KeyStore.getInstance(Consts.JKS);
FileInputStream is = new FileInputStream(jksFile);
ks.load(is, jksPwd.toCharArray());
tmf.init(ks);
is.close();
// load pfx ca
KeyManagerFactory kmf = KeyManagerFactory
.getInstance(Consts.SunX509);
ks = KeyStore.getInstance(Consts.PKCS12);
ks.load(certificate, weixinPayAccount.getPartnerId().toCharArray());
kmf.init(ks, weixinPayAccount.getPartnerId().toCharArray());
ctx = SSLContext.getInstance(Consts.TLS);
ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(),
new SecureRandom());
response = weixinExecutor.createSSLRequestExecutor(ctx).get(
String.format("%s?%s", refund_uri,
FormUrlEntity.formatParameters(map)));
} catch (WeixinException e) {
throw e;
} catch (Exception e) {
throw new WeixinException(e);
} finally {
if (certificate != null) {
try {
certificate.close();
} catch (IOException e) {
;
}
}
}
return response.getAsObject(new TypeReference<RefundResultV2>() {
});
}
/**
* 退款申请
*
* @param certificate
* 证书文件(V2版本后缀为*.pfx)
* @param idQuery
* 商户系统内部的订单号, transaction_id 、 out_trade_no 二选一,如果同时存在优先级:
* transaction_id> out_trade_no
* @param outRefundNo
* 商户系统内部的退款单号,商 户系统内部唯一,同一退款单号多次请求只退一笔
* @param totalFee
* 订单总金额,单位为元
* @param refundFee
* 退款总金额,单位为元,可以做部分退款
* @param opUserId
* 操作员帐号, 默认为商户号
* @param opUserPasswd
* 操作员密码,默认为商户后台登录密码
* @see {@link #applyRefund(InputStream, IdQuery, String, double, double, String, Map)}
*/
public RefundResultV2 applyRefund(InputStream certificate, IdQuery idQuery,
String outRefundNo, double totalFee, double refundFee,
String opUserId, String opUserPasswd) throws WeixinException {
Map<String, String> mopara = new HashMap<String, String>();
mopara.put("op_user_passwd", DigestUtil.MD5(opUserPasswd));
return applyRefund(certificate, idQuery, outRefundNo, totalFee,
refundFee, opUserId, mopara);
}
/**
* 退款申请
*
* @param certificate
* 证书文件(V2版本后缀为*.pfx)
* @param idQuery
* 商户系统内部的订单号, transaction_id 、 out_trade_no 二选一,如果同时存在优先级:
* transaction_id> out_trade_no
* @param outRefundNo
* 商户系统内部的退款单号,商 户系统内部唯一,同一退款单号多次请求只退一笔
* @param totalFee
* 订单总金额,单位为元
* @param refundFee
* 退款总金额,单位为元,可以做部分退款
* @param opUserId
* 操作员帐号, 默认为商户号
* @param opUserPasswd
* 操作员密码,默认为商户后台登录密码
* @param recvUserId
* 转账退款接收退款的财付通帐号。 一般无需填写,只有退银行失败,资金转入商 户号现金账号时(即状态为转入代发,查询返 回的
* refund_status 是 7 或 11),填写原退款 单号并填写此字段,资金才会退到指定财付通
* 账号。其他情况此字段忽略
* @param reccvUserName
* 转账退款接收退款的姓名(需与接收退款的财 付通帐号绑定的姓名一致)
* @param refundType
* 为空或者填 1:商户号余额退款;2:现金帐号 退款;3:优先商户号退款,若商户号余额不足, 再做现金帐号退款。使用 2 或
* 3 时,需联系财 付通开通此功能
* @see {@link #applyRefund(InputStream, IdQuery, String, double, double, String, Map)}
* @return 退款结果
*/
public RefundResultV2 applyRefund(InputStream certificate, IdQuery idQuery,
String outRefundNo, double totalFee, double refundFee,
String opUserId, String opUserPasswd, String recvUserId,
String reccvUserName, RefundType refundType) throws WeixinException {
Map<String, String> mopara = new HashMap<String, String>();
mopara.put("op_user_passwd", DigestUtil.MD5(opUserPasswd));
if (StringUtil.isNotBlank(recvUserId)) {
mopara.put("recv_user_id", recvUserId);
}
if (StringUtil.isNotBlank(reccvUserName)) {
mopara.put("reccv_user_name", reccvUserName);
}
if (refundType != null) {
mopara.put("refund_type", Integer.toString(refundType.getVal()));
}
return applyRefund(certificate, idQuery, outRefundNo, totalFee,
refundFee, opUserId, mopara);
}
/**
* 下载对账单<br>
* 1.微信侧未成功下单的交易不会出现在对账单中。支付成功后撤销的交易会出现在对账 单中,跟原支付单订单号一致,bill_type 为
* REVOKED;<br>
* 2.微信在次日 9 点启动生成前一天的对账单,建议商户 9 点半后再获取;<br>
* 3.对账单中涉及金额的字段单位为“元”。<br>
*
* @param billDate
* 下载对账单的日期 为空则取前一天
* @param billType
* 下载对账单的类型 ALL,返回当日所有订单信息, 默认值 SUCCESS,返回当日成功支付的订单
* REFUND,返回当日退款订单
* @param billPath
* 对账单保存路径
* @return excel表格
* @since V2
* @throws WeixinException
*/
public File downloadBill(Date billDate, BillType billType, String billPath)
throws WeixinException {
if (billDate == null) {
Calendar now = Calendar.getInstance();
now.add(Calendar.DAY_OF_MONTH, -1);
billDate = now.getTime();
}
if (billType == null) {
billType = BillType.ALL;
}
String formatBillDate = DateUtil.fortmat2yyyyMMdd(billDate);
String fileName = String.format("weixin4j_bill_%s_%s_%s.txt",
formatBillDate, billType.name().toLowerCase(),
weixinPayAccount.getId());
File file = new File(String.format("%s%s%s", billPath, File.separator,
fileName));
if (file.exists()) {
return file;
}
String downloadbill_uri = getRequestUri("downloadbill_old_uri");
Map<String, String> map = new HashMap<String, String>();
map.put("spid", weixinPayAccount.getPartnerId());
map.put("trans_time", DateUtil.fortmat2yyyy_MM_dd(billDate));
map.put("stamp", DateUtil.timestamp2string());
map.put("cft_signtype", "0");
map.put("mchtype", Integer.toString(billType.getVal()));
map.put("key", weixinPayAccount.getPartnerKey());
String sign = DigestUtil.MD5(MapUtil.toJoinString(map, false, false));
map.put("sign", sign.toLowerCase());
WeixinResponse response = weixinExecutor.get(String.format("%s?%s",
downloadbill_uri, FormUrlEntity.formatParameters(map)));
BufferedReader reader = null;
BufferedWriter writer = null;
try {
writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(file), Consts.GBK));
reader = new BufferedReader(new InputStreamReader(
response.getBody(), com.foxinmy.weixin4j.util.Consts.GBK));
String line = null;
while ((line = reader.readLine()) != null) {
writer.write(line);
writer.newLine();
}
} catch (IOException e) {
throw new WeixinException(e);
} finally {
try {
if (reader != null) {
reader.close();
}
if (writer != null) {
writer.close();
}
} catch (IOException ignore) {
;
}
}
return file;
}
/**
* 退款查询</br> 退款有一定延时,用零钱支付的退款20分钟内到账,银行卡支付的退款 3 个工作日后重新查询退款状态
*
* @param idQuery
* 单号 refund_id、out_refund_no、 out_trade_no 、 transaction_id
* 四个参数必填一个,优先级为:
* refund_id>out_refund_no>transaction_id>out_trade_no
* @return 退款记录
* @see com.foxinmy.weixin4j.mp.oldpayment.RefundRecordV2
* @see com.foxinmy.weixin4j.mp.oldpayment.RefundDetailV2
* @since V2
* @throws WeixinException
*/
public RefundRecordV2 queryRefund(IdQuery idQuery) throws WeixinException {
String refundquery_uri = getRequestUri("refundquery_old_uri");
Map<String, String> map = new HashMap<String, String>();
map.put("input_charset", Consts.UTF_8.name());
map.put("partner", weixinPayAccount.getPartnerId());
map.put(idQuery.getType().getName(), idQuery.getId());
String sign = weixinMD5Signature.sign(map);
map.put("sign", sign.toLowerCase());
WeixinResponse response = weixinExecutor.get(String.format(
refundquery_uri, FormUrlEntity.formatParameters(map)));
return ListsuffixResultDeserializer.deserialize(response.getAsString(),
RefundRecordV2.class);
}
/**
* 发货通知
*
* @param openId
* 用户ID
* @param transid
* 交易单号
* @param outTradeNo
* 订单号
* @param status
* 成功|失败
* @param statusMsg
* status为失败时携带的信息
* @return 发货处理结果
* @throws WeixinException
*/
public ApiResult deliverNotify(String openId, String transid,
String outTradeNo, boolean status, String statusMsg)
throws WeixinException {
String delivernotify_uri = getRequestUri("delivernotify_old_uri");
Token token = tokenManager.getCache();
Map<String, String> map = new HashMap<String, String>();
map.put("appid", weixinPayAccount.getId());
map.put("appkey", weixinPayAccount.getPaySignKey());
map.put("openid", openId);
map.put("transid", transid);
map.put("out_trade_no", outTradeNo);
map.put("deliver_timestamp", DateUtil.timestamp2string());
map.put("deliver_status", status ? "1" : "0");
map.put("deliver_msg", statusMsg);
map.put("app_signature", weixinSignature.sign(map));
map.put("sign_method", SignType.SHA1.name().toLowerCase());
WeixinResponse response = weixinExecutor.post(
String.format(delivernotify_uri, token.getAccessToken()),
JSON.toJSONString(map));
return response.getAsResult();
}
/**
* 维权处理
*
* @param openId
* 用户ID
* @param feedbackId
* 维权单号
* @return 维权处理结果
* @throws WeixinException
*/
public ApiResult updateFeedback(String openId, String feedbackId)
throws WeixinException {
String payfeedback_uri = getRequestUri("payfeedback_old_uri");
Token token = tokenManager.getCache();
WeixinResponse response = weixinExecutor.get(String.format(
payfeedback_uri, token.getAccessToken(), openId, feedbackId));
return response.getAsResult();
}
}