/**
*
* 网页授权获取用户基本信息的全部过程
* 详情请参看网页授权获取用户基本信息：http://mp.weixin.qq.com/wiki/17/c0f37d5704f0b64713d5d2c37b468d75.html
* 第一步：利用url跳转获取code
* 第二步：利用code去获取openid和access_token
*
*/
public void GetOpenidAndAccessToken()
{
if (!string.IsNullOrEmpty(page.Request.QueryString["code"]))
{
//获取code码，以获取openid和access_token
string code = page.Request.QueryString["code"];
Log.Debug(this.GetType().ToString(), "Get code : " + code);
GetOpenidAndAccessTokenFromCode(code);
}
else
{
//构造网页授权获取code的URL
string host = page.Request.Url.Host;
string path = page.Request.Path;
string redirect_uri = HttpUtility.UrlEncode("http://" + host + path);
WxPayData data = new WxPayData();
data.SetValue("appid", Config.APPID);
data.SetValue("redirect_uri", redirect_uri);
data.SetValue("response_type", "code");
data.SetValue("scope", "snsapi_base");
data.SetValue("state", "STATE" + "#wechat_redirect");
string url = "https://open.weixin.qq.com/connect/oauth2/authorize?" + data.ToUrl();
Log.Debug(this.GetType().ToString(), "Will Redirect to URL : " + url);
try
{
//触发微信返回code码
page.Response.Redirect(url);//Redirect函数会抛出ThreadAbortException异常，不用处理这个异常
}
catch(System.Threading.ThreadAbortException ex)
{
}
}
}
/***
* 退款查询完整业务流程逻辑
* @param refund_id 微信退款单号（优先使用）
* @param out_refund_no 商户退款单号
* @param transaction_id 微信订单号
* @param out_trade_no 商户订单号
* @return 退款查询结果（xml格式）
*/
public static string Run(string refund_id, string out_refund_no, string transaction_id, string out_trade_no)
{
Log.Info("RefundQuery", "RefundQuery is processing...");
WxPayData data = new WxPayData();
if(!string.IsNullOrEmpty(refund_id))
{
data.SetValue("refund_id", refund_id);//微信退款单号，优先级最高
}
else if(!string.IsNullOrEmpty(out_refund_no))
{
data.SetValue("out_refund_no", out_refund_no);//商户退款单号，优先级第二
}
else if(!string.IsNullOrEmpty(transaction_id))
{
data.SetValue("transaction_id", transaction_id);//微信订单号，优先级第三
}
else
{
data.SetValue("out_trade_no", out_trade_no);//商户订单号，优先级最低
}
WxPayData result = WxPayApi.RefundQuery(data);//提交退款查询给API，接收返回数据
Log.Info("RefundQuery", "RefundQuery process complete, result : " + result.ToXml());
return result.ToPrintStr();
}
public override void ProcessNotify()
{
WxPayData notifyData = GetNotifyData();
//检查openid和product_id是否返回
if (!notifyData.IsSet("openid") || !notifyData.IsSet("product_id"))
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "回调数据异常");
Log.Info(this.GetType().ToString(), "The data WeChat post is error : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//调统一下单接口，获得下单结果
string openid = notifyData.GetValue("openid").ToString();
string product_id = notifyData.GetValue("product_id").ToString();
WxPayData unifiedOrderResult = new WxPayData();
try
{
unifiedOrderResult = UnifiedOrder(openid, product_id);
}
catch(Exception ex)//若在调统一下单接口时抛异常，立即返回结果给微信支付后台
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "统一下单失败");
Log.Error(this.GetType().ToString(), "UnifiedOrder failure : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//若下单失败，则立即返回结果给微信支付后台
if (!unifiedOrderResult.IsSet("appid") || !unifiedOrderResult.IsSet("mch_id") || !unifiedOrderResult.IsSet("prepay_id"))
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "统一下单失败");
Log.Error(this.GetType().ToString(), "UnifiedOrder failure : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//统一下单成功,则返回成功结果给微信支付后台
WxPayData data = new WxPayData();
data.SetValue("return_code", "SUCCESS");
data.SetValue("return_msg", "OK");
data.SetValue("appid", Config.APPID);
data.SetValue("mch_id", Config.MCHID);
data.SetValue("nonce_str", WxPayApi.GenerateNonceStr());
data.SetValue("prepay_id", unifiedOrderResult.GetValue("prepay_id"));
data.SetValue("result_code", "SUCCESS");
data.SetValue("err_code_des", "OK");
data.SetValue("sign", data.MakeSign());
Log.Info(this.GetType().ToString(), "UnifiedOrder success , send data to WeChat : " + data.ToXml());
page.Response.Write(data.ToXml());
page.Response.End();
}
/***
* 下载对账单完整业务流程逻辑
* @param bill_date 下载对账单的日期（格式：20140603，一次只能下载一天的对账单）
* @param bill_type 账单类型
* ALL，返回当日所有订单信息，默认值
* SUCCESS，返回当日成功支付的订单
* REFUND，返回当日退款订单
* REVOKED，已撤销的订单
* @return 对账单结果（xml格式）
*/
public static string Run(string bill_date, string bill_type)
{
Log.Info("DownloadBill", "DownloadBill is processing...");
WxPayData data = new WxPayData();
data.SetValue("bill_date", bill_date);//账单日期
data.SetValue("bill_type", bill_type);//账单类型
WxPayData result = WxPayApi.DownloadBill(data);//提交下载对账单请求给API，接收返回结果
Log.Info("DownloadBill", "DownloadBill process complete, result : " + result.ToXml());
return result.ToPrintStr();
}
private WxPayData UnifiedOrder(string openId,string productId)
{
//统一下单
WxPayData req = new WxPayData();
req.SetValue("body", "test");
req.SetValue("attach", "test");
req.SetValue("out_trade_no", WxPayApi.GenerateOutTradeNo());
req.SetValue("total_fee", 1);
req.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss"));
req.SetValue("time_expire", DateTime.Now.AddMinutes(10).ToString("yyyyMMddHHmmss"));
req.SetValue("goods_tag", "test");
req.SetValue("trade_type", "NATIVE");
req.SetValue("openid", openId);
req.SetValue("product_id", productId);
WxPayData result = WxPayApi.UnifiedOrder(req);
return result;
}
/***
* 订单查询完整业务流程逻辑
* @param transaction_id 微信订单号（优先使用）
* @param out_trade_no 商户订单号
* @return 订单查询结果（xml格式）
*/
public static string Run(string transaction_id, string out_trade_no)
{
Log.Info("OrderQuery", "OrderQuery is processing...");
WxPayData data = new WxPayData();
if(!string.IsNullOrEmpty(transaction_id))//如果微信订单号存在，则以微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去查单
{
data.SetValue("out_trade_no", out_trade_no);
}
WxPayData result = WxPayApi.OrderQuery(data);//提交订单查询请求给API，接收返回数据
Log.Info("OrderQuery", "OrderQuery process complete, result : " + result.ToXml());
return result.ToPrintStr();
}
public override void ProcessNotify()
{
WxPayData notifyData = GetNotifyData();
//检查支付结果中transaction_id是否存在
if (!notifyData.IsSet("transaction_id"))
{
//若transaction_id不存在，则立即返回结果给微信支付后台
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "支付结果中微信订单号不存在");
Log.Error(this.GetType().ToString(), "The Pay result is error : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
string transaction_id = notifyData.GetValue("transaction_id").ToString();
//查询订单，判断订单真实性
if (!QueryOrder(transaction_id))
{
//若订单查询失败，则立即返回结果给微信支付后台
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "订单查询失败");
Log.Error(this.GetType().ToString(), "Order query failure : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//查询订单成功
else
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "SUCCESS");
res.SetValue("return_msg", "OK");
Log.Info(this.GetType().ToString(), "order query success : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
}
/// <summary>
/// 接收从微信支付后台发送过来的数据并验证签名
/// </summary>
/// <returns>微信支付后台返回的数据</returns>
public WxPayData GetNotifyData()
{
//接收从微信后台POST过来的数据
System.IO.Stream s = page.Request.InputStream;
int count = 0;
byte[] buffer = new byte[1024];
StringBuilder builder = new StringBuilder();
while ((count = s.Read(buffer, 0, 1024)) > 0)
{
builder.Append(Encoding.UTF8.GetString(buffer, 0, count));
}
s.Flush();
s.Close();
s.Dispose();
Log.Info(this.GetType().ToString(), "Receive data from WeChat : " + builder.ToString());
//转换数据格式并验证签名
WxPayData data = new WxPayData();
try
{
data.FromXml(builder.ToString());
}
catch(WxPayException ex)
{
//若签名错误，则立即返回结果给微信支付后台
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", ex.Message);
Log.Error(this.GetType().ToString(), "Sign check error : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
Log.Info(this.GetType().ToString(), "Check sign success");
return data;
}
//查询订单
private bool QueryOrder(string transaction_id)
{
WxPayData req = new WxPayData();
req.SetValue("transaction_id", transaction_id);
WxPayData res = WxPayApi.OrderQuery(req);
if (res.GetValue("return_code").ToString() == "SUCCESS" &&
res.GetValue("result_code").ToString() == "SUCCESS")
{
return true;
}
else
{
return false;
}
}
/**
* 生成直接支付url，支付url有效期为2小时,模式二
* @param productId 商品ID
* @return 模式二URL
*/
public string GetPayUrl(string productId)
{
Log.Info(this.GetType().ToString(), "Native pay mode 2 url is producing...");
WxPayData data = new WxPayData();
data.SetValue("body", "test");//商品描述
data.SetValue("attach", "test");//附加数据
data.SetValue("out_trade_no", WxPayApi.GenerateOutTradeNo());//随机字符串
data.SetValue("total_fee", 1);//总金额
data.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss"));//交易起始时间
data.SetValue("time_expire", DateTime.Now.AddMinutes(10).ToString("yyyyMMddHHmmss"));//交易结束时间
data.SetValue("goods_tag", "jjj");//商品标记
data.SetValue("trade_type", "NATIVE");//交易类型
data.SetValue("product_id", productId);//商品ID
WxPayData result = WxPayApi.UnifiedOrder(data);//调用统一下单接口
string url = result.GetValue("code_url").ToString();//获得统一下单接口返回的二维码链接
Log.Info(this.GetType().ToString(), "Get native pay mode 2 url : " + url);
return url;
}
/**
* 生成扫描支付模式一URL
* @param productId 商品ID
* @return 模式一URL
*/
public string GetPrePayUrl(string productId)
{
Log.Info(this.GetType().ToString(), "Native pay mode 1 url is producing...");
WxPayData data = new WxPayData();
data.SetValue("appid", Config.APPID);//公众帐号id
data.SetValue("mch_id", Config.MCHID);//商户号
data.SetValue("time_stamp", WxPayApi.GenerateTimeStamp());//时间戳
data.SetValue("nonce_str", WxPayApi.GenerateNonceStr());//随机字符串
data.SetValue("product_id", productId);//商品ID
data.SetValue("sign", data.MakeSign());//签名
string str = ToUrlParams(data.GetValues());//转换为URL串
string url = "weixin://wxpay/bizpayurl?" + str;
Log.Info(this.GetType().ToString(), "Get native pay mode 1 url : " + url);
return url;
}
/**
*
* 查询订单情况
* @param string out_trade_no 商户订单号
* @param int succCode 查询订单结果：0表示订单不成功，1表示订单成功，2表示继续查询
* @return 订单查询接口返回的数据，参见协议接口
*/
public static WxPayData Query(string out_trade_no, out int succCode)
{
WxPayData queryOrderInput = new WxPayData();
queryOrderInput.SetValue("out_trade_no", out_trade_no);
WxPayData result = WxPayApi.OrderQuery(queryOrderInput);
if (result.GetValue("return_code").ToString() == "SUCCESS" &&
result.GetValue("result_code").ToString() == "SUCCESS")
{
//支付成功
if (result.GetValue("trade_state").ToString() == "SUCCESS")
{
succCode = 1;
return(result);
}
//用户支付中，需要继续查询
else if (result.GetValue("trade_state").ToString() == "USERPAYING")
{
succCode = 2;
return(result);
}
}
//如果返回错误码为“此交易订单号不存在”则直接认定失败
if (result.GetValue("err_code").ToString() == "ORDERNOTEXIST")
{
succCode = 0;
}
else
{
//如果是系统错误，则后续继续
succCode = 2;
}
return(result);
}
/// <summary>
/// 生成扫描支付模式一URL
/// </summary>
/// <param name="productId">商品ID</param>
/// <returns>模式一URL</returns>
public string GetPrePayUrl(string productId)
{
LogHelper.Info(this.GetType().ToString(), "Native pay mode 1 url is producing...");
WxPayData data = new WxPayData();
data.SetValue("appid", WxPayConfig.AppId); //公众帐号id
data.SetValue("mch_id", WxPayConfig.MchId); //商户号
data.SetValue("time_stamp", WxPayApi.GenerateTimeStamp()); //时间戳
data.SetValue("nonce_str", WxPayApi.GenerateNonceStr()); //随机字符串
data.SetValue("product_id", productId); //商品ID
data.SetValue("sign", data.MakeSign()); //签名
string str = ToUrlParams(data.GetValues()); //转换为URL串
string url = "weixin://wxpay/bizpayurl?" + str;
//weixin://wxpay/bizpayurl?appid=wx426b3015555a46be&mch_id=1900009851&nonce_str=lz2gmz19sbeteufbg2onmbt9sabv0kef&product_id=123456789&time_stamp=1531917401&sign=69C6AEFFF6943AADCF84C4FA372BE60D
LogHelper.Info(this.GetType().ToString(), "Get native pay mode 1 url : " + url);
return(url);
}
/**
* 生成扫描支付模式一URL
* @param productId 商品ID
* @return 模式一URL
*/
public string GetPrePayUrl(string productId)
{
//Log.Info(this.GetType().ToString(), "Native pay mode 1 url is producing...");
WxPayData data = new WxPayData();
data.SetValue("appid", WxPayConfig.APPID); //公众帐号id
data.SetValue("mch_id", WxPayConfig.MCHID); //商户号
data.SetValue("time_stamp", WxPayApi.GenerateTimeStamp()); //时间戳
data.SetValue("nonce_str", WxPayApi.GenerateNonceStr()); //随机字符串
data.SetValue("product_id", productId); //商品ID
data.SetValue("sign", data.MakeSign()); //签名
// data.SetValue("total_fee", 2);//总金额
string str = ToUrlParams(data.GetValues()); //转换为URL串
string url = "weixin://wxpay/bizpayurl?" + str;
// Log.Info(this.GetType().ToString(), "Get native pay mode 1 url : " + url);
return(url);
}
/**
*
* 从统一下单成功返回的数据中获取微信浏览器调起jsapi支付所需的参数，
* 微信浏览器调起JSAPI时的输入参数格式如下：
* {
* "appId" : "wx2421b1c4370ec43b", //公众号名称，由商户传入
* "timeStamp":" 1395712654", //时间戳，自1970年以来的秒数
* "nonceStr" : "e61463f8efa94090b1f366cccfbbb444", //随机串
* "package" : "prepay_id=u802345jgfjsdfgsdg888",
* "signType" : "MD5", //微信签名方式:
* "paySign" : "70EA570631E4BB79628FBCA90534C63FF7FADD89" //微信签名
* }
* @return string 微信浏览器调起JSAPI时的输入参数，json格式可以直接做参数用
* 更详细的说明请参考网页端调起支付API：http://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_7
*
*/
public string GetJsApiParameters()
{
Log <T> .Debug(this.GetType().ToString(), "JsApiPay::GetJsApiParam is processing...");
WxPayData <T> jsApiParam = new WxPayData <T>();
jsApiParam.SetValue("appId", unifiedOrderResult.GetValue("appid"));
jsApiParam.SetValue("timeStamp", WxPayApi <T> .GenerateTimeStamp());
jsApiParam.SetValue("nonceStr", WxPayApi <T> .GenerateNonceStr());
jsApiParam.SetValue("package", "prepay_id=" + unifiedOrderResult.GetValue("prepay_id"));
jsApiParam.SetValue("signType", "MD5");
jsApiParam.SetValue("paySign", jsApiParam.MakeSign());
string parameters = jsApiParam.ToJson();
Log <T> .Debug(this.GetType().ToString(), "Get jsApiParam : " + parameters);
return(parameters);
}
/**
* 生成直接支付url，支付url有效期为2小时,模式二
* @param productId 商品ID
* @return 模式二URL
*/
public async Task <string> GetPayUrl(string body, string outTradeNo, int totalFee, string productId)
{
//Log.Info(this.GetType().ToString(), "Native pay mode 2 url is producing...");
var data = new WxPayData();
data.SetValue("body", body); //商品描述
//data.SetValue("attach", outTradeIds);//附加数据
data.SetValue("out_trade_no", outTradeNo); //随机字符串
data.SetValue("total_fee", totalFee); //总金额
data.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss")); //交易起始时间
data.SetValue("time_expire", DateTime.Now.AddMinutes(10).ToString("yyyyMMddHHmmss")); //交易结束时间
//data.SetValue("goods_tag", "jjj");//商品标记
data.SetValue("trade_type", "NATIVE"); //交易类型
data.SetValue("product_id", productId); //商品ID
var result = await WxPayApi.UnifiedOrder(data); //调用统一下单接口
string url = result.GetValue("code_url").ToString(); //获得统一下单接口返回的二维码链接
//Log.Info(this.GetType().ToString(), "Get native pay mode 2 url : " + url);
return(url);
}
public void ProcessRequest(HttpContext context)
{
HttpRequest request = context.Request;
Stream stream = request.InputStream;
if (stream.Length != 0)
{
int total_fee = Convert.ToInt32(request["total_fee"]);
string out_trade_no = request["out_trade_no"];
WxPayData data = new WxPayData();
data.SetValue("body", "微特众包-商家充值");//商品描述
//data.SetValue("attach", "test");//附加数据
//data.SetValue("out_trade_no", WxPayApi.GenerateOutTradeNo());//订单号
data.SetValue("out_trade_no", out_trade_no); //订单号
data.SetValue("total_fee", total_fee); //总金额
data.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss")); //交易起始时间
data.SetValue("time_expire", DateTime.Now.AddMinutes(10).ToString("yyyyMMddHHmmss")); //交易结束时间
data.SetValue("trade_type", "APP"); //交易类型
WxPayData result = WxPayApi.UnifiedOrder(data); //调用统一下单接口
if (result.IsSet("prepay_id"))
{
WxPayData order = new WxPayData();
order.SetValue("appid", WxPayConfig.APPID);
order.SetValue("partnerid", WxPayConfig.MCHID);
order.SetValue("noncestr", WxPayApi.GenerateNonceStr());
order.SetValue("prepayid", result.GetValue("prepay_id"));
order.SetValue("timestamp", WxPayApi.GenerateTimeStamp());
order.SetValue("package", "Sign=WXPay");
order.SetValue("sign", order.MakeSign());
context.Response.Write(order.ToJson());
}
}
else
{
context.Response.Write("");
}
}
/// <summary>
/// 获取收货地址js函数入口参数,详情请参考收货地址共享接口：http://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_9
/// </summary>
/// <returns>共享收货地址js函数需要的参数，json格式可以直接做参数使用</returns>
public string GetEditAddressParameters()
{
string parameter = "";
try
{
string host = Request.Url.Host;
string path = Request.Path;
string queryString = Request.Url.Query;
//这个地方要注意，参与签名的是网页授权获取用户信息时微信后台回传的完整url
string url = "http://" + host + path + queryString;
//构造需要用SHA1算法加密的数据
WxPayData signData = new WxPayData();
signData.SetValue("appid", GlobalContext.AppID);
signData.SetValue("url", url);
signData.SetValue("timestamp", CommonHelper.CreateTimestamp());
signData.SetValue("noncestr", CommonHelper.CreateNonceStr());
signData.SetValue("accesstoken", access_token);
string param = signData.ToUrl();
//SHA1加密
string addrSign = FormsAuthentication.HashPasswordForStoringInConfigFile(param, "SHA1");
//获取收货地址js函数入口参数
WxPayData afterData = new WxPayData();
afterData.SetValue("appId", GlobalContext.AppID);
afterData.SetValue("scope", "jsapi_address");
afterData.SetValue("signType", "sha1");
afterData.SetValue("addrSign", addrSign);
afterData.SetValue("timeStamp", signData.GetValue("timestamp"));
afterData.SetValue("nonceStr", signData.GetValue("noncestr"));
//转为json格式
parameter = afterData.ToJson();
}
catch (Exception ex)
{
throw new WxPayException(ex.ToString());
}
return(parameter);
}
/***
* 申请退款完整业务流程逻辑
* @param transaction_id 微信订单号（优先使用）
* @param out_trade_no 商户订单号
* @param total_fee 订单总金额
* @param refund_fee 退款金额
* @return 退款结果（xml格式）
*/
public static async Task <string> Run(string transactionId, string outTradeNo, int totalFee, int refundFee, string outRefundNo)
{
var data = new WxPayData();
if (!string.IsNullOrEmpty(transactionId)) //微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transactionId);
}
else //微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", outTradeNo);
}
data.SetValue("total_fee", totalFee); //订单总金额
data.SetValue("refund_fee", refundFee); //退款金额
data.SetValue("out_refund_no", outRefundNo); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID); //操作员，默认为商户号
var result = await WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
return(result.ToJson());
}
/**
*
* 从统一下单成功返回的数据中获取微信浏览器调起jsapi支付所需的参数，
* 微信浏览器调起JSAPI时的输入参数格式如下：
* {
* "appId" : "wx2421b1c4370ec43b", //公众号名称，由商户传入
* "timeStamp":" 1395712654", //时间戳，自1970年以来的秒数
* "nonceStr" : "e61463f8efa94090b1f366cccfbbb444", //随机串
* "package" : "prepay_id=u802345jgfjsdfgsdg888",
* "signType" : "MD5", //微信签名方式:
* "paySign" : "70EA570631E4BB79628FBCA90534C63FF7FADD89" //微信签名
* }
* @return string 微信浏览器调起JSAPI时的输入参数，json格式可以直接做参数用
* 更详细的说明请参考网页端调起支付API：http://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_7
*
*/
public string GetJsApiParameters(string appId)
{
var WxPayConfig = Configuration.GetAppPayConfig <Config.Sections.Pay.WXPay>(appId);
Log.Debug(this.GetType().ToString(), "JsApiPay::GetJsApiParam is processing...");
WxPayData jsApiParam = new WxPayData();
jsApiParam.SetValue("appId", unifiedOrderResult.GetValue("appid"));
jsApiParam.SetValue("timeStamp", WxPayApi.GenerateTimeStamp());
jsApiParam.SetValue("nonceStr", WxPayApi.GenerateNonceStr());
jsApiParam.SetValue("package", "prepay_id=" + unifiedOrderResult.GetValue("prepay_id"));
jsApiParam.SetValue("signType", "MD5");
jsApiParam.SetValue("paySign", jsApiParam.MakeSign(WxPayConfig.KEY));
string parameters = jsApiParam.ToJson();
Log.Debug(this.GetType().ToString(), "Get jsApiParam : " + parameters);
return(parameters);
}
/***
* 申请退款完整业务流程逻辑
* @param transaction_id 微信订单号（优先使用）
* @param out_trade_no 商户订单号
* @param total_fee 订单总金额
* @param refund_fee 退款金额
* @return 退款结果（xml格式）
*/
public static string Run(string transaction_id, string out_trade_no, string total_fee, string refund_fee, string AdminHotelid, int hotelid)
{
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", out_trade_no);
}
data.SetValue("total_fee", int.Parse(total_fee)); //订单总金额
data.SetValue("refund_fee", int.Parse(refund_fee)); //退款金额
data.SetValue("out_refund_no", WxPayApi.GenerateOutTradeNo(AdminHotelid, hotelid)); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID(AdminHotelid, hotelid)); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data, AdminHotelid, hotelid); //提交退款申请给API，接收返回数据
//Log.Info("Refund", "Refund process complete, result : " + result.ToXml());
return(result.ToXml());
}
/**
*
* 从统一下单成功返回的数据中获取微信浏览器调起jsapi支付所需的参数，
* 微信浏览器调起JSAPI时的输入参数格式如下：
* {
* "appId" : "wx2421b1c4370ec43b", //公众号名称，由商户传入
* "timeStamp":" 1395712654", //时间戳，自1970年以来的秒数
* "nonceStr" : "e61463f8efa94090b1f366cccfbbb444", //随机串
* "package" : "prepay_id=u802345jgfjsdfgsdg888",
* "signType" : "MD5", //微信签名方式:
* "paySign" : "70EA570631E4BB79628FBCA90534C63FF7FADD89" //微信签名
* }
* @return string 微信浏览器调起JSAPI时的输入参数，json格式可以直接做参数用
* 更详细的说明请参考网页端调起支付API：http://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_7
*
*/
public string GetJsApiParameters()
{
WxPayData jsApiParam = new WxPayData();
jsApiParam.SetValue("appId", this.unifiedOrderResult.GetValue("appid"));
jsApiParam.SetValue("timeStamp", PayApi.GenerateTimeStamp());
jsApiParam.SetValue("nonceStr", PayApi.GenerateNonceStr());
jsApiParam.SetValue("package", "prepay_id=" + this.unifiedOrderResult.GetValue("prepay_id"));
jsApiParam.SetValue("signType", "MD5");
jsApiParam.SetValue("paySign", jsApiParam.MakeSign());
return(Newtonsoft.Json.JsonConvert.SerializeObject(new
{
appId = jsApiParam.GetValue("appId"),
timeStamp = jsApiParam.GetValue("timeStamp"),
nonceStr = jsApiParam.GetValue("nonceStr"),
package = jsApiParam.GetValue("package"),
signType = jsApiParam.GetValue("signType"),
paySign = jsApiParam.GetValue("paySign")
}));
}
public JsonResult GetPaySign(string openid)
{
string nonceStr = WxPayApi.GenerateNonceStr(); //随机字符串，不长于32位
string outTradeNo = WxPayApi.GenerateOutTradeNo(); //订单号：32个字符内、不得重复
string spbillCreateIp = WxPayConfig.GetIP(System.Web.HttpContext.Current); //用户端IP
int total_fee = 1; //订单金额（单位：分），整数
string trade_type = "JSAPI"; //JSAPI,NATIVE,APP,WAP
#region 调用统一支付接口获得prepay_id（预支付交易会话标识）
WxPayData wxPayData = new WxPayData();
wxPayData.SetValue("appid", WxPayConfig.APPID); //appid
wxPayData.SetValue("body", WxPayConfig.BODY); //支付描述
wxPayData.SetValue("mch_id", WxPayConfig.MCHID); //商户id
wxPayData.SetValue("nonce_str", nonceStr); //随机字符串
wxPayData.SetValue("notify_url", WxPayConfig.NOTIFY_URL); //回调地址
wxPayData.SetValue("openid", openid); //openid
wxPayData.SetValue("out_trade_no", outTradeNo); //订单号
wxPayData.SetValue("spbill_create_ip", spbillCreateIp); //客户端ip地址
wxPayData.SetValue("total_fee", total_fee.ToString()); //订单金额（单位：分），整数
wxPayData.SetValue("trade_type", trade_type); //交易类型
wxPayData.SetValue("sign", wxPayData.MakeSign()); //签名
string data = wxPayData.ToXml();
string prepayId = WeChatTools.UnifiedOrder(data);
#endregion
#region 支付参数
string timeStamp = WxPayApi.GenerateTimeStamp();
nonceStr = WxPayApi.GenerateNonceStr();
WxPayData wxPaySign = new WxPayData();
wxPaySign.SetValue("appId", WxPayConfig.APPID);
wxPaySign.SetValue("timeStamp", timeStamp);
wxPaySign.SetValue("nonceStr", nonceStr);
wxPaySign.SetValue("package", string.Format("prepay_id={0}", prepayId));
wxPaySign.SetValue("signType", "MD5");
string paysign = wxPaySign.MakeSign();
wxPaySign.SetValue("paySign", paysign);
#endregion
return(Json(new { data = wxPaySign.GetValues(), openid = openid }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 获取前端 WeixinJSBridge.invoke 使用的支付参数的 json 字符串
/// </summary>
/// <returns></returns>
public ActionResult GetBrandWCPayRequestArgs()
{
string strPayOrderId = Request.QueryString["payOrderId"];
Guid payOrderId = Guid.Empty;
if (String.IsNullOrEmpty(strPayOrderId) || Guid.TryParse(strPayOrderId, out payOrderId) == false)
{
return(RespondResult(false, "参数无效。"));
}
PayOrderEntity payOrder = _payManager.GetPayOrder(payOrderId);
if (payOrder == null)
{
return(RespondResult(false, "指定的支付订单不存在。"));
}
if (payOrder.Member != MemberContext.Member.Id)
{
return(RespondResult(false, "订单不属于您。"));
}
if (payOrder.TradeState != EnumPayTradeState.NOTPAY)
{
return(RespondResult(false, "订单状态不是待支付状态。"));
}
WxPayData jsApiParam = new WxPayData(DomainContext.AuthorizerPay.Key);
jsApiParam.SetValue("appId", DomainContext.AppId);
jsApiParam.SetValue("timeStamp", WeixinApiHelper.GetTimesTamp().ToString());
jsApiParam.SetValue("nonceStr", WeixinApiHelper.GetNonceStr());
jsApiParam.SetValue("package", "prepay_id=" + payOrder.PrepayId);
jsApiParam.SetValue("signType", "MD5");
jsApiParam.SetValue("paySign", jsApiParam.MakeSign());
string parameters = jsApiParam.ToJson();
return(RespondDataResult(parameters));
}
/// <summary>
/// 调用外部红包发送接口
/// </summary>
/// <param name="redPack">红包</param>
/// <param name="re_openid_"></param>
/// <param name="amount_"></param>
/// <param name="wishing_"></param>
/// <param name="send_name_"></param>
/// <param name="act_name_"></param>
/// <param name="remark_"></param>
/// <returns></returns>
/// <summary>
/// 一段时间发出的红包
/// </summary>
/// <param name="fromDate">开始日期</param>
/// <param name="toDate">结束日期</param>
/// <returns></returns>
private bool Request(RedPack redPack, string re_openid_,
decimal amount_,
string wishing_,
string send_name_,
string act_name_,
string remark_)
{
WxPayData redPackRequest = new WxPayData();
redPackRequest.SetValue("re_openid", re_openid_);
redPackRequest.SetValue("total_amount", (int)(amount_ * 100));
redPackRequest.SetValue("wishing", wishing_);
redPackRequest.SetValue("send_name", send_name_);
redPackRequest.SetValue("act_name", act_name_);
redPackRequest.SetValue("remark", remark_);
WxPayData res = WxPayApi.WxRedPack(redPackRequest);
if (res.GetValue("return_code").ToString() == "SUCCESS")
{
redPack.Err_code = res.GetValue("err_code").ToString();
}
else
{
redPack.Err_code = "requestFail";
}
if (res.GetValue("return_code").ToString() == "SUCCESS" &&
res.GetValue("result_code").ToString() == "SUCCESS")
{
redPack.Send_listid = res.GetValue("send_listid").ToString();
redPack.WeixinName = res.GetValue("re_openid").ToString();
redPack.Amount = decimal.Parse(res.GetValue("total_amount").ToString()) / 100;
redPack.Mch_billno = res.GetValue("mch_billno").ToString();
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 申请退款完整业务流程逻辑
/// </summary>
/// <param name="transaction_id">微信订单号</param>
/// <param name="out_trade_no">商户订单号</param>
/// <param name="total_fee">订单总金额</param>
/// <param name="refund_fee">退款金额</param>
/// <returns> 退款结果（xml格式）</returns>
public static string Run(string transaction_id, string out_trade_no, int total_fee, int refund_fee, string appID = WxPayConfig.APPID, string mchID = WxPayConfig.MCHID, string key = WxPayConfig.KEY, string sSLCERT_PASSWORD = WxPayConfig.SSLCERT_PASSWORD, string sSLCERT_PATH = WxPayConfig.SSLCERT_PATH)
{
Log.Info("Refund", "Refund is processing...");
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", out_trade_no);
}
data.SetValue("total_fee", total_fee); //订单总金额
data.SetValue("refund_fee", refund_fee); //退款金额
data.SetValue("out_refund_no", WxPayApi.GenerateOutTradeNo()); //随机生成商户退款单号
data.SetValue("op_user_id", mchID); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data, 6, appID, mchID, key, sSLCERT_PASSWORD, sSLCERT_PATH); //提交退款申请给API，接收返回数据
Log.Info("Refund", "Refund process complete, result : " + result.ToXml());
return(result.ToPrintStr());
}
/***
* 申请退款完整业务流程逻辑
* @param transaction_id 微信订单号（优先使用）
* @param out_trade_no 商户订单号
* @param total_fee 订单总金额
* @param refund_fee 退款金额
* @return 退款结果（xml格式）
*/
public static string Run(string transaction_id, string out_trade_no, string total_fee, string refund_fee)
{
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", out_trade_no);
}
data.SetValue("total_fee", int.Parse(total_fee)); //订单总金额
data.SetValue("refund_fee", int.Parse(refund_fee)); //退款金额
data.SetValue("out_refund_no", out_trade_no); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
return(result.ToPrintStr());
}
/// <summary>
/// 测速上报接口实现
/// </summary>
/// <param name="inputObj">提交给测速上报接口的参数</param>
/// <returns>成功时返回测速上报接口返回的结果，其他抛异常</returns>
public static WxPayData Report(WxPayData inputObj)
{
//检测必填参数
if (!inputObj.IsSet("interface_url"))
{
throw new WxPayException("接口URL，缺少必填参数interface_url！");
}
if (!inputObj.IsSet("return_code"))
{
throw new WxPayException("返回状态码，缺少必填参数return_code！");
}
if (!inputObj.IsSet("result_code"))
{
throw new WxPayException("业务结果，缺少必填参数result_code！");
}
if (!inputObj.IsSet("user_ip"))
{
throw new WxPayException("访问接口IP，缺少必填参数user_ip！");
}
if (!inputObj.IsSet("execute_time_"))
{
throw new WxPayException("接口耗时，缺少必填参数execute_time_！");
}
inputObj.SetValue("appid", GlobalContext.AppID); //公众账号ID
inputObj.SetValue("mch_id", GlobalContext.MCHId); //商户号
inputObj.SetValue("user_ip", GlobalContext.SpbillCreateIp); //终端ip
inputObj.SetValue("time", DateTime.Now.ToString("yyyyMMddHHmmss")); //商户上报时间
inputObj.SetValue("nonce_str", CommonHelper.CreateNonceStr()); //随机字符串
inputObj.SetValue("sign", inputObj.MakeSign()); //签名
string xml = inputObj.ToXml();
var _url = ApiUrlHelper.MPApiUrl.ReportOrder;
string response = HttpClientHelper.HttpClientPostStringAsync(_url, xml);
WxPayData result = new WxPayData();
result.FromXml(response);
return(result);
}
private CommonReturn SendMoney(M_WX_APPID appMod, string openid, double amount, string desc)
{
WxPayData wxdata = new WxPayData();
wxdata.SetValue("partner_trade_no", B_OrderList.CreateOrderNo(M_OrderList.OrderEnum.Normal));
wxdata.SetValue("openid", openid);
wxdata.SetValue("check_name", "NO_CHECK");//OPTION_CHECK NO_CHECK
//wxdata.SetValue("re_user_name", trueName.Trim());
wxdata.SetValue("amount", (int)amount * 100);
wxdata.SetValue("desc", desc);
wxdata.SetValue("spbill_create_ip", Request.ServerVariables["LOCAl_ADDR"]);//必须填写
WxPayData result = WxPayApi.Pay_Transfer(wxdata, appMod);
if (result.GetValue("result_code").ToString().ToUpper().Equals("SUCCESS"))
{
return(CommonReturn.Success());
}
else
{
string err = result.GetValue("return_msg").ToString();
return(CommonReturn.Failed(err));
}
}
public RefundReturn Refund(string transaction_id, string out_trade_no, string total_fee, string refund_fee)
{
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", out_trade_no);
}
data.SetValue("total_fee", int.Parse(total_fee)); //订单总金额
data.SetValue("refund_fee", int.Parse(refund_fee)); //退款金额
data.SetValue("out_refund_no", WxPayApi.GenerateOutTradeNo()); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
RefundReturn refreturn = new RefundReturn();
string result_code = result.GetValue("result_code").ToString();
if (result_code == "SUCCESS")
{
refreturn.ResultCode = result_code;
refreturn.ErrCode = "";
refreturn.ErrCodeDes = "";
}
else
{
refreturn.ResultCode = result_code;
refreturn.ErrCode = result.GetValue("err_code").ToString();
refreturn.ErrCodeDes = result.GetValue("err_code_des").ToString();
}
return(refreturn);
}
/**
* 调用统一下单，获得下单结果
* @return 统一下单结果
* @失败时抛异常WxPayException
*/
private string GetUnifiedOrderResult(PayInfo info)
{
string subject;
string body;
PayHelper.GetSubjectAndBody(info, out subject, out body);
//统一下单
WxPayData data = new WxPayData();
data.SetValue("body", subject);
data.SetValue("out_trade_no", info.BillId);
//金额单位分
data.SetValue("total_fee", (int)info.PayAmount * 100);
data.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss"));
data.SetValue("time_expire", DateTime.Now.AddMinutes(10).ToString("yyyyMMddHHmmss"));
data.SetValue("trade_type", "APP");
WxPayData result = WxPayApi.UnifiedOrder(data);
if (!result.IsSet("appid") || !result.IsSet("prepay_id") || result.GetValue("prepay_id").ToString() == "")
{
throw new WxPayException("UnifiedOrder response error!");
}
//客户端调起支付接口需要参数
WeixinPayReq req = new WeixinPayReq();
req.Appid = result.GetValue("appid").ToString();
req.Partnerid = result.GetValue("mch_id").ToString();
req.Prepayid = result.GetValue("prepay_id").ToString();
req.Noncestr = WxPayAPI.WxPayApi.GenerateNonceStr();
req.Timestamp = WxPayAPI.WxPayApi.GenerateTimeStamp();
req.Sign = MakeSecondSign(req);
return(JsonConvert.SerializeObject(req));
}
/// <summary>
/// 支付结果回调地址
/// </summary>
/// <returns></returns>
public string PayNotifyUrl()
{
WxPayData resultInfo = new WxPayData();
try
{
ResultNotify resultNotify = new ResultNotify();
WxPayData notifyData = resultNotify.GetNotifyData(); //获取微信返回的数据
string accessToken = WeChatTools.GetAccessoken();
var userInfoStr = WeChatTools.ConvertToUserIdByOpenid(accessToken, notifyData.GetValue("openid").ToString());
var userInfo = Common.JsonHelper.JsonToModel <U_WechatUserInfo>(userInfoStr);
var userid = userInfo.userid;
var personInfoModel = _wl.GetUserInfo(userid); //获取人员表信息
var paymentHistoryInfo = new Business_PaymentHistory_Information();
paymentHistoryInfo.PaymentPersonnel = personInfoModel.Vguid; //付款人vguid
_weChatRevenueLogic.UpdatePaymentHistory(personInfoModel, paymentHistoryInfo, notifyData);
if (notifyData.GetValue("return_code").ToString() == "SUCCESS" && notifyData.GetValue("result_code").ToString() == "SUCCESS")
{
resultInfo.SetValue("return_code", "SUCCESS");
resultInfo.SetValue("return_msg", "OK");
}
else
{
resultInfo.SetValue("return_code", notifyData.GetValue("return_code").ToString());
resultInfo.SetValue("return_msg", notifyData.GetValue("return_msg").ToString());
}
}
catch (Exception ex)
{
LogHelper.WriteLog(ex.ToString());
resultInfo.SetValue("return_code", "FAIL");
resultInfo.SetValue("return_msg", "交易失败");
}
return(resultInfo.ToXml());
}
/// <summary>
/// 获取审核结果
/// </summary>
/// <param name="business_code"></param>
/// <returns></returns>
public static string Getstate(string business_code)
{
WxPayData inputObj = new WxPayData();
inputObj.SetValue("version", "1.0"); //接口版本号
inputObj.SetValue("mch_id", WxPayConfig.GetConfig().GetMchID()); //商户号
inputObj.SetValue("nonce_str", WxPayApi.GenerateNonceStr()); //随机字符串
inputObj.SetValue("business_code", business_code); //
inputObj.SetValue("sign_type", WxPayData.SIGN_TYPE_HMAC_SHA256); //签名类型
inputObj.SetValue("sign", inputObj.MakeSign()); //签名
string xml = inputObj.ToXml();
string url = "https://api.mch.weixin.qq.com/applyment/micro/getstate";
int timeOut = 10;
Log.Debug("申请入驻", "request : " + xml);
string response = HttpService.Post(xml, url, true, timeOut);//调用HTTP通信接口以提交数据到API
Log.Debug("申请入驻", "response : " + response);
return(response);
}
//
// GET: /WeixinPayBackUrl/
/// <summary>
/// 微信支付回调地址
/// add by fruitchan
/// 2017-1-18 21:10:30
/// </summary>
/// <returns>Content</returns>
public ActionResult Index()
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "业务异常");
WxPayData notifyData = GetNotifyData();
if (!notifyData.IsSet("return_code"))
{
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "回调数据异常");
Log.Info(this.GetType().ToString(), "The data WeChat post is error : " + res.ToXml());
return(Content(res.ToXml()));
}
else
{
string return_code = notifyData.GetValue("return_code").ToString();
string result_code = notifyData.GetValue("result_code").ToString();
if (return_code == "SUCCESS" && result_code == "SUCCESS")
{
string out_trade_no = notifyData.GetValue("out_trade_no").ToString();
string transaction_id = notifyData.GetValue("transaction_id").ToString();
// 处理订单
UpdateOrderState(out_trade_no, transaction_id);
res.SetValue("return_code", "SUCCESS");
res.SetValue("return_msg", "OK");
}
}
return(Content(res.ToXml()));
}
/***
* 申请退款完整业务流程逻辑
* @param transaction_id 微信订单号（优先使用）
* @param out_trade_no 商户订单号
* @param total_fee 订单总金额
* @param refund_fee 退款金额
* @return 退款结果（xml格式）
*/
public static string Run(string transaction_id, string out_trade_no, string total_fee, string refund_fee)
{
Log.Info("Refund", "Refund is processing...");
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", out_trade_no);
}
data.SetValue("total_fee", int.Parse(total_fee));//订单总金额
data.SetValue("refund_fee", int.Parse(refund_fee));//退款金额
data.SetValue("out_refund_no", WxPayApi.GenerateOutTradeNo());//随机生成商户退款单号
data.SetValue("op_user_id", Config.MCHID);//操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data);//提交退款申请给API，接收返回数据
Log.Info("Refund", "Refund process complete, result : " + result.ToXml());
return result.ToPrintStr();
}
private PrepayInfoModel PreparePrepayInfo(string prepayId, int orderId)
{
var payData = new WxPayData(_WeixinPaymentSetting.MchKey);
payData.SetValue("appId", _WeixinPaymentSetting.AppId);
payData.SetValue("timeStamp", WxPayData.GenerateTimeStamp());
payData.SetValue("nonceStr", WxPayData.GenerateNonceStr());
payData.SetValue("package", $"prepay_id={prepayId}");
payData.SetValue("signType", "MD5");
payData.SetValue("paySign", payData.MakeSign());
var model = new PrepayInfoModel()
{
AppId = payData.GetValue("appId"),
TimeStamp = payData.GetValue("timeStamp"),
NonceStr = payData.GetValue("nonceStr"),
Package = payData.GetValue("package"),
SignType = payData.GetValue("signType"),
PaySign = payData.GetValue("paySign"),
PrepayId = prepayId,
OrderId = orderId,
};
return(model);
}
/**
*
* 撤销订单，如果失败会重复调用10次
* @param string out_trade_no 商户订单号
* @param depth 调用次数，这里用递归深度表示
* @return false表示撤销失败，true表示撤销成功
*/
public static bool Cancel(string out_trade_no, int depth = 0)
{
if(depth > 10)
{
return false;
}
WxPayData reverseInput = new WxPayData();
reverseInput.SetValue("out_trade_no",out_trade_no);
WxPayData result = WxPayApi.Reverse(reverseInput);
//接口调用失败
if(result.GetValue("return_code").ToString() != "SUCCESS")
{
return false;
}
//如果结果为success且不需要重新调用撤销，则表示撤销成功
if(result.GetValue("result_code").ToString() != "SUCCESS" && result.GetValue("recall").ToString() == "N")
{
return true;
}
else if(result.GetValue("recall").ToString() == "Y")
{
return Cancel(out_trade_no, ++depth);
}
return false;
}
/**
*
* 通过code换取网页授权access_token和openid的返回数据，正确时返回的JSON数据包如下：
* {
* "access_token":"ACCESS_TOKEN",
* "expires_in":7200,
* "refresh_token":"REFRESH_TOKEN",
* "openid":"OPENID",
* "scope":"SCOPE",
* "unionid": "o6_bmasdasdsad6_2sgVt7hMZOPfL"
* }
* 其中access_token可用于获取共享收货地址
* openid是微信支付jsapi支付接口统一下单时必须的参数
* 更详细的说明请参考网页授权获取用户基本信息：http://mp.weixin.qq.com/wiki/17/c0f37d5704f0b64713d5d2c37b468d75.html
* @失败时抛异常WxPayException
*/
public void GetOpenidAndAccessTokenFromCode(string code)
{
try
{
//构造获取openid及access_token的url
WxPayData data = new WxPayData();
data.SetValue("appid", Config.APPID);
data.SetValue("secret", Config.APPSECRET);
data.SetValue("code", code);
data.SetValue("grant_type", "authorization_code");
string url = "https://api.weixin.qq.com/sns/oauth2/access_token?" + data.ToUrl();
//请求url以获取数据
string result = HttpService.Get(url);
Log.Debug(this.GetType().ToString(), "GetOpenidAndAccessTokenFromCode response : " + result);
//保存access_token，用于收货地址获取
JsonData jd = JsonMapper.ToObject(result);
access_token = (string)jd["access_token"];
//获取用户openid
openid = (string)jd["openid"];
Log.Debug(this.GetType().ToString(), "Get openid : " + openid);
Log.Debug(this.GetType().ToString(), "Get access_token : " + access_token);
}
catch (Exception ex)
{
Log.Error(this.GetType().ToString(), ex.ToString());
throw new WxPayException(ex.ToString());
}
}
/**
* 调用统一下单，获得下单结果
* @return 统一下单结果
* @失败时抛异常WxPayException
*/
public WxPayData GetUnifiedOrderResult()
{
//统一下单
WxPayData data = new WxPayData();
data.SetValue("body", "test");
data.SetValue("attach", "test");
data.SetValue("out_trade_no", WxPayApi.GenerateOutTradeNo());
data.SetValue("total_fee", total_fee);
data.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss"));
data.SetValue("time_expire", DateTime.Now.AddMinutes(10).ToString("yyyyMMddHHmmss"));
data.SetValue("goods_tag", "test");
data.SetValue("trade_type", "JSAPI");
data.SetValue("openid", openid);
WxPayData result = WxPayApi.UnifiedOrder(data);
if (!result.IsSet("appid") || !result.IsSet("prepay_id") || result.GetValue("prepay_id").ToString() == "")
{
Log.Error(this.GetType().ToString(), "UnifiedOrder response error!");
throw new WxPayException("UnifiedOrder response error!");
}
unifiedOrderResult = result;
return result;
}
public virtual string StartPay(PayParameter parameter)
{
try
{
WxPayConfig config = new WxPayAPI.WxPayConfig(PayFactory.GetInterfaceXmlConfig(PayInterfaceType.WeiXinBarcode, parameter.TradeID));
WxPayData data = new WxPayData();
data.SetValue("auth_code", parameter.AuthCode); //授权码
data.SetValue("body", parameter.TradeName == null ? parameter.Description : parameter.TradeName); //商品描述
data.SetValue("total_fee", Convert.ToInt32(parameter.Amount * 100)); //总金额,以分为单位
data.SetValue("out_trade_no", parameter.TradeID); //产生随机的商户订单号
WxPayData result = WxPayApi.Micropay(data, config, 20); //提交被扫支付，接收返回结果
string xml = result.ToXml();
PayFactory.OnLog(parameter.TradeID, xml);
string returnMsg = result.IsSet("return_msg") ? result.GetValue("return_msg").ToSafeString() : result.GetValue("err_code_des").ToSafeString();
//如果提交被扫支付接口调用失败，则抛异常
if (!result.IsSet("return_code") || result.GetValue("return_code").ToString() == "FAIL")
{
//触发回调函数
PayFactory.OnPayFailed(parameter.TradeID, returnMsg, xml);
return(null);
}
//签名验证
result.CheckSign(config);
//刷卡支付直接成功
if (result.GetValue("return_code").ToString() == "SUCCESS" &&
result.GetValue("result_code").ToString() == "SUCCESS")
{
//触发回调函数
PayFactory.OnPaySuccessed(parameter.TradeID, result.ToXml());
return(null);
}
//1）业务结果明确失败
if (result.GetValue("err_code").ToString() != "USERPAYING" &&
result.GetValue("err_code").ToString() != "SYSTEMERROR")
{
//触发回调函数
PayFactory.OnPayFailed(parameter.TradeID, result.GetValue("err_code_des").ToSafeString(), xml);
return(null);
}
//到这里，不能确定支付结果，循环30秒确定
int checkTimes = parameter.Timeout / 2;
Thread.Sleep(1000);
for (int i = 0; i < checkTimes; i++)
{
if (checkPayStateByConfig(parameter, config))
{
break;
}
if (i + 1 == checkTimes)
{
break;
}
Thread.Sleep(2000);
}
}
catch (Exception ex)
{
throw ex;
}
return(null);
}
/**
* 刷卡支付完整业务流程逻辑
* @param body 商品描述
* @param total_fee 总金额
* @param auth_code 支付授权码
* @throws WxPayException
* @return 刷卡支付结果
*/
public WxPayData BarcodePay(string orderId, string body, decimal total_fee, string auth_code)
{
Log.Info("MicroPay", "Micropay is processing...");
WxPayData data = new WxPayData();
data.SetValue("auth_code", auth_code); //授权码
data.SetValue("body", body); //商品描述
data.SetValue("total_fee", Convert.ToInt32(total_fee * 100)); //总金额
data.SetValue("out_trade_no", orderId); //产生随机的商户订单号
WxPayData result = WxPayApi.Micropay(data, 10); //提交被扫支付，接收返回结果
//如果提交被扫支付接口调用失败，则抛异常
if (!result.IsSet("return_code") || result.GetValue("return_code").ToString() == "FAIL")
{
string returnMsg = result.IsSet("return_msg") ? result.GetValue("return_msg").ToString() : "";
Log.Error("MicroPay", "Micropay API interface call failure, result : " + result.ToXml());
throw new WxPayException("Micropay API interface call failure, return_msg : " + returnMsg);
}
//签名验证
result.CheckSign();
Log.Debug("MicroPay", "Micropay response check sign success");
//刷卡支付直接成功
if (result.GetValue("return_code").ToString() == "SUCCESS" &&
result.GetValue("result_code").ToString() == "SUCCESS")
{
Log.Debug("MicroPay", "Micropay business success, result : " + result.ToXml());
return(result);
}
/******************************************************************
* 剩下的都是接口调用成功，业务失败的情况
* ****************************************************************/
//1）业务结果明确失败
if (result.GetValue("err_code").ToString() != "USERPAYING" &&
result.GetValue("err_code").ToString() != "SYSTEMERROR")
{
Log.Error("MicroPay", "micropay API interface call success, business failure, result : " + result.ToXml());
return(result);
}
//2）不能确定是否失败，需查单
//用商户订单号去查单
string out_trade_no = data.GetValue("out_trade_no").ToString();
//确认支付是否成功,每隔一段时间查询一次订单，共查询10次
int queryTimes = 10;//查询次数计数器
while (queryTimes-- > 0)
{
int succResult = 0;//查询结果
WxPayData queryResult = Query(out_trade_no, out succResult);
//如果需要继续查询，则等待2s后继续
if (succResult == 2)
{
Thread.Sleep(2000);
continue;
}
//查询成功,返回订单查询接口返回的数据
else if (succResult == 1)
{
Log.Debug("MicroPay", "Mircopay success, return order query result : " + queryResult.ToXml());
return(queryResult);
}
//订单交易失败，直接返回刷卡支付接口返回的结果，失败原因会在err_code中描述
else
{
Log.Error("MicroPay", "Micropay failure, return micropay result : " + result.ToXml());
return(result);
}
}
//确认失败，则撤销订单
Log.Error("MicroPay", "Micropay failure, Reverse order is processing...");
if (!Cancel(out_trade_no))
{
Log.Error("MicroPay", "Reverse order failure");
throw new WxPayException("Reverse order failure！");
}
return(result);
}
public override void ProcessNotify(Action <NotifyModel> action)
{
WxPayData notifyData = GetNotifyData();
//检查openid和product_id是否返回
if (!notifyData.IsSet("openid") || !notifyData.IsSet("product_id"))
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "回调数据异常");
Log.Info(this.GetType().ToString(), "The data WeChat post is error : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//调统一下单接口，获得下单结果
string openid = notifyData.GetValue("openid").ToString();
string product_id = notifyData.GetValue("product_id").ToString();
WxPayData unifiedOrderResult = new WxPayData();
try
{
unifiedOrderResult = UnifiedOrder(openid, product_id);
}
catch (Exception ex)//若在调统一下单接口时抛异常，立即返回结果给微信支付后台
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "统一下单失败");
Log.Error(this.GetType().ToString(), "UnifiedOrder failure : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//若下单失败，则立即返回结果给微信支付后台
if (!unifiedOrderResult.IsSet("appid") || !unifiedOrderResult.IsSet("mch_id") || !unifiedOrderResult.IsSet("prepay_id"))
{
WxPayData res = new WxPayData();
res.SetValue("return_code", "FAIL");
res.SetValue("return_msg", "统一下单失败");
Log.Error(this.GetType().ToString(), "UnifiedOrder failure : " + res.ToXml());
page.Response.Write(res.ToXml());
page.Response.End();
}
//统一下单成功,则返回成功结果给微信支付后台
WxPayData data = new WxPayData();
data.SetValue("return_code", "SUCCESS");
data.SetValue("return_msg", "OK");
data.SetValue("appid", WxPayConfig.APPID);
data.SetValue("mch_id", WxPayConfig.MCHID);
data.SetValue("nonce_str", WxPayApi.GenerateNonceStr());
data.SetValue("prepay_id", unifiedOrderResult.GetValue("prepay_id"));
data.SetValue("result_code", "SUCCESS");
data.SetValue("err_code_des", "OK");
data.SetValue("sign", data.MakeSign());
Log.Info(this.GetType().ToString(), "UnifiedOrder success , send data to WeChat : " + data.ToXml());
page.Response.Write(data.ToXml());
page.Response.End();
}
/**
*
* 查询订单情况
* @param string out_trade_no 商户订单号
* @param int succCode 查询订单结果：0表示订单不成功，1表示订单成功，2表示继续查询
* @return 订单查询接口返回的数据，参见协议接口
*/
public static WxPayData Query(string out_trade_no, out int succCode)
{
WxPayData queryOrderInput = new WxPayData();
queryOrderInput.SetValue("out_trade_no",out_trade_no);
WxPayData result = WxPayApi.OrderQuery(queryOrderInput);
if(result.GetValue("return_code").ToString() == "SUCCESS"
&& result.GetValue("result_code").ToString() == "SUCCESS")
{
//支付成功
if(result.GetValue("trade_state").ToString() == "SUCCESS")
{
succCode = 1;
return result;
}
//用户支付中，需要继续查询
else if(result.GetValue("trade_state").ToString() == "USERPAYING")
{
succCode = 2;
return result;
}
}
//如果返回错误码为“此交易订单号不存在”则直接认定失败
if(result.GetValue("err_code").ToString() == "ORDERNOTEXIST")
{
succCode = 0;
}
else
{
//如果是系统错误，则后续继续
succCode = 2;
}
return result;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!base.IsPostBack)
{
if (this.Session["MemID"] != null)
{
int memID = int.Parse(this.Session["MemID"].ToString());
this.txtMemID.Value = memID.ToString();
if (base.Request.QueryString["MoneyID"] != null)
{
this.txtMoneyID.Value = base.Request.QueryString["MoneyID"].ToString();
this.BindWeiXinMoney(int.Parse(this.txtMoneyID.Value));
}
if (int.Parse(this.MemCount.Value) > 0)
{
string openid = new Chain.BLL.Mem().GetModel(memID).MemWeiXinCard;
if (string.IsNullOrEmpty(openid))
{
base.Response.Write("<span style='color:#FF0000;font-size:20px'>页面传参出错,请返回重试</span>");
}
else
{
double getmoney = double.Parse(this.txtgetmoney.Value);
Chain.BLL.WeiXinMoney bllWeiXinMoney = new Chain.BLL.WeiXinMoney();
Chain.Model.WeiXinMoney modelWeiXinMoney = bllWeiXinMoney.GetModel(int.Parse(this.txtMoneyID.Value));
string mch_billno = DateTime.Now.ToString("yyMMddHHmmssffff");
int total_amount = int.Parse((getmoney * 100.0).ToString(""));
string wishing = modelWeiXinMoney.MoneyWish;
string remark = modelWeiXinMoney.MoneyDesc;
string act_name = modelWeiXinMoney.MoneyTitle;
string re_openid = openid;
WxPayData data = new WxPayData();
data.SetValue("mch_billno", mch_billno);
data.SetValue("mch_id", PubFunction.curParameter.strMchid);
data.SetValue("wxappid", PubFunction.curParameter.strWeiXinAppID);
data.SetValue("send_name", "智络");
data.SetValue("re_openid", re_openid);
data.SetValue("total_amount", total_amount);
data.SetValue("total_num", 1);
data.SetValue("wishing", wishing);
data.SetValue("client_ip", PubFunction.ipAdress);
data.SetValue("act_name", act_name);
data.SetValue("remark", remark);
WxPayData result = WxPayApi.Sendredpack(data, PubFunction.curParameter.strMchKey, "cert\\apiclient_cert.p12", PubFunction.curParameter.strMchid, 10);
if (!result.IsSet("return_code") || result.GetValue("return_code").ToString() == "FAIL")
{
string arg_2DD_0 = result.IsSet("return_msg") ? result.GetValue("return_msg").ToString() : "";
this.spGetMoney.InnerHtml = "";
this.spResultInfo.InnerHtml = "红包接口调用失败！" + result.GetValue("return_msg").ToString();
}
else if (result.GetValue("return_code").ToString() == "SUCCESS" && result.GetValue("result_code").ToString() == "SUCCESS")
{
if (int.Parse(this.MemCount.Value) > 0)
{
Chain.BLL.WeiXinGiveMoney bllWeiXinGiveMoney = new Chain.BLL.WeiXinGiveMoney();
bllWeiXinGiveMoney.Add(new Chain.Model.WeiXinGiveMoney
{
MemID = int.Parse(this.txtMemID.Value),
MoneyID = int.Parse(this.txtMoneyID.Value),
GiveMoney = decimal.Parse(getmoney.ToString()),
GiveTime = DateTime.Now,
IsWin = 1
});
bllWeiXinMoney.UpdateGiveMoney(int.Parse(this.txtMoneyID.Value), decimal.Parse(getmoney.ToString()));
this.spResultInfo.InnerHtml = "红包发放成功！";
this.spGetMoney.InnerHtml = getmoney.ToString("#0.00");
this.moneyInfo.Visible = true;
}
else
{
this.spGetMoney.InnerHtml = "";
this.spResultInfo.InnerHtml = "您的红包领取次数已用完！";
}
}
else
{
this.spGetMoney.InnerHtml = "";
this.spResultInfo.InnerHtml = "红包发放失败！" + result.GetValue("return_msg").ToString();
}
}
}
}
else
{
base.Response.Redirect("login.aspx");
}
}
}
/**
*
* 获取收货地址js函数入口参数,详情请参考收货地址共享接口：http://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_9
* @return string 共享收货地址js函数需要的参数，json格式可以直接做参数使用
*/
public string GetEditAddressParameters()
{
string parameter = "";
try
{
string host = page.Request.Url.Host;
string path = page.Request.Path;
string queryString = page.Request.Url.Query;
//这个地方要注意，参与签名的是网页授权获取用户信息时微信后台回传的完整url
string url = "http://" + host + path + queryString;
//构造需要用SHA1算法加密的数据
WxPayData signData = new WxPayData();
signData.SetValue("appid",Config.APPID);
signData.SetValue("url", url);
signData.SetValue("timestamp",WxPayApi.GenerateTimeStamp());
signData.SetValue("noncestr",WxPayApi.GenerateNonceStr());
signData.SetValue("accesstoken",access_token);
string param = signData.ToUrl();
Log.Debug(this.GetType().ToString(), "SHA1 encrypt param : " + param);
//SHA1加密
string addrSign = FormsAuthentication.HashPasswordForStoringInConfigFile(param, "SHA1");
Log.Debug(this.GetType().ToString(), "SHA1 encrypt result : " + addrSign);
//获取收货地址js函数入口参数
WxPayData afterData = new WxPayData();
afterData.SetValue("appId",Config.APPID);
afterData.SetValue("scope","jsapi_address");
afterData.SetValue("signType","sha1");
afterData.SetValue("addrSign",addrSign);
afterData.SetValue("timeStamp",signData.GetValue("timestamp"));
afterData.SetValue("nonceStr",signData.GetValue("noncestr"));
//转为json格式
parameter = afterData.ToJson();
Log.Debug(this.GetType().ToString(), "Get EditAddressParam : " + parameter);
}
catch (Exception ex)
{
Log.Error(this.GetType().ToString(), ex.ToString());
throw new WxPayException(ex.ToString());
}
return parameter;
}
/// <summary>
/// 微信支付通道安卓调用方式
/// </summary>
/// <param name="appid">应用id</param>
/// <param name="code">订单编号</param>
/// <param name="goodsname">商品名称</param>
/// <param name="price">商品价格</param>
/// <param name="orderid">订单id</param>
/// <param name="apptype">风控配置表id</param>
/// <returns></returns>
private InnerResponse PayWxAz(int appid, string code, string goodsname, decimal price, int orderid, string ip, int apptype, int infoTimes)
{
InnerResponse inn = new InnerResponse();
SelectInterface SeIn = new SelectInterface();
try
{
string wxappidzfjk = "wxappidzfjk" + appid;//组装缓存key值
SeIn = SelectUserInfo(wxappidzfjk, appid, apptype, infoTimes);
if (SeIn == null || SeIn.PayId <= 0)
{
inn = inn.ToResponse(ErrorCode.Code106);
return(inn);
}
if (SeIn.PayId > 0)
{
WxPayConfig wx = new WxPayConfig(SeIn.PayId);
JMP.BLL.jmp_order bll = new JMP.BLL.jmp_order();
if (!UpdateOrde.OrdeUpdateInfo(orderid, SeIn.PayId))
{
inn = inn.ToResponse(ErrorCode.Code101);
return(inn);
}
if (!JudgeMoney.JudgeMinimum(price, SeIn.minmun))
{
inn = inn.ToResponse(ErrorCode.Code8990);
return(inn);
}
if (!JudgeMoney.JudgeMaximum(price, SeIn.maximum))
{
inn = inn.ToResponse(ErrorCode.Code8989);
return(inn);
}
WxPayData data = new WxPayData();
data.SetValue("body", goodsname); //商品名称
data.SetValue("out_trade_no", code); //我们的订单号
data.SetValue("total_fee", (Convert.ToInt32(price * 100)).ToString()); //价格
data.SetValue("notify_url", ConfigurationManager.AppSettings["WxTokenUrl"].ToString().Replace("{0}", SeIn.PayId.ToString())); //回调地址
data.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss"));
data.SetValue("time_expire", DateTime.Now.AddMinutes(30).ToString("yyyyMMddHHmmss"));
data.SetValue("trade_type", "APP");
WxPayData result = WxPayApi.UnifiedOrder(data, SeIn.PayId);
string noncestr = WxPayApi.GenerateNonceStr();
string timestamp = WxPayApi.GenerateTimeStamp();
WxPayData data1 = new WxPayData();
data1.SetValue("appid", wx.APPID);
data1.SetValue("noncestr", noncestr);
data1.SetValue("package", "Sign=WXPay");
data1.SetValue("partnerid", wx.MCHID);
data1.SetValue("prepayid", result.GetValue("prepay_id"));
data1.SetValue("timestamp", timestamp);
string sign = data1.MakeSign(SeIn.PayId);
string wxstr = "{\"appid\":\"" + result.GetValue("appid") + "\",\"partnerid\":\"" + result.GetValue("mch_id") + "\",\"prepayid\":\"" + result.GetValue("prepay_id") + "\",\"pkg\":\"Sign=WXPay\",\"noncestr\":\"" + noncestr + "\",\"timestamp\":\"" + timestamp + "\",\"sign\":\"" + sign + "\",\"PaymentType\":\"5\",\"SubType\":\"1\",\"IsH5\":\"0\"}";
// str = "{\"message\":\"成功\",\"result\":100,\"data\":" + wxstr + "}";
inn = inn.ToResponse(ErrorCode.Code100);
inn.ExtraData = JMP.TOOL.AesHelper.AesEncrypt(wxstr, ConfigurationManager.AppSettings["encryption"].ToString());
}
else
{
PayApiDetailErrorLogger.UpstreamPaymentErrorLog("报错信息：支付通道异常", summary: "微信appid支付接口错误信息", channelId: SeIn.PayId);
inn = inn.ToResponse(ErrorCode.Code104);
}
}
catch (Exception E)
{
PayApiDetailErrorLogger.UpstreamPaymentErrorLog("报错信息：" + E.ToString(), summary: "微信appid支付接口错误信息", channelId: SeIn.PayId);
inn = inn.ToResponse(ErrorCode.Code104);
}
return(inn);
}
/**
*
* 从统一下单成功返回的数据中获取微信浏览器调起jsapi支付所需的参数，
* 微信浏览器调起JSAPI时的输入参数格式如下：
* {
* "appId" : "wx2421b1c4370ec43b", //公众号名称，由商户传入
* "timeStamp":" 1395712654", //时间戳，自1970年以来的秒数
* "nonceStr" : "e61463f8efa94090b1f366cccfbbb444", //随机串
* "package" : "prepay_id=u802345jgfjsdfgsdg888",
* "signType" : "MD5", //微信签名方式:
* "paySign" : "70EA570631E4BB79628FBCA90534C63FF7FADD89" //微信签名
* }
* @return string 微信浏览器调起JSAPI时的输入参数，json格式可以直接做参数用
* 更详细的说明请参考网页端调起支付API：http://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_7
*
*/
public string GetJsApiParameters()
{
Log.Debug(this.GetType().ToString(), "JsApiPay::GetJsApiParam is processing...");
WxPayData jsApiParam = new WxPayData();
jsApiParam.SetValue("appId", unifiedOrderResult.GetValue("appid"));
jsApiParam.SetValue("timeStamp", WxPayApi.GenerateTimeStamp());
jsApiParam.SetValue("nonceStr", WxPayApi.GenerateNonceStr());
jsApiParam.SetValue("package", "prepay_id=" + unifiedOrderResult.GetValue("prepay_id"));
jsApiParam.SetValue("signType", "MD5");
jsApiParam.SetValue("paySign", jsApiParam.MakeSign());
string parameters = jsApiParam.ToJson();
Log.Debug(this.GetType().ToString(), "Get jsApiParam : " + parameters);
return parameters;
}
/// <summary>
/// 检查订单状态
/// </summary>
/// <param name="parameter"></param>
/// <param name="config"></param>
/// <returns>只要有结果，无论成功或者失败，返回true，不确定支付结果返回false</returns>
bool checkPayStateByConfig(PayParameter parameter, WxPayConfig config)
{
try
{
WxPayData queryOrderInput = new WxPayData();
queryOrderInput.SetValue("out_trade_no", parameter.TradeID);
WxPayData result = WxPayApi.OrderQuery(queryOrderInput, config);
string xml = result.ToXml();
PayFactory.OnLog(parameter.TradeID, xml);
if (result.GetValue("return_code").ToString() == "SUCCESS" &&
result.GetValue("result_code").ToString() == "SUCCESS")
{
//支付成功
if (result.GetValue("trade_state").ToString() == "SUCCESS")
{
//触发回调函数
PayFactory.OnPaySuccessed(parameter.TradeID, result.ToXml());
return(true);
}
//用户支付中，需要继续查询
else if (result.GetValue("trade_state").ToString() == "USERPAYING")
{
return(false);
}
else if (result.GetValue("trade_state").ToString() == "NOTPAY")
{
//触发回调函数
PayFactory.OnPayFailed(parameter.TradeID, "放弃支付", xml);
return(true);
}
}
string returnMsg = result.GetValue("err_code_des").ToSafeString();
if (string.IsNullOrEmpty(returnMsg))
{
returnMsg = result.GetValue("return_msg").ToSafeString();
}
//如果返回错误码为“此交易订单号不存在”，直接失败
if (result.GetValue("err_code").ToString() == "ORDERNOTEXIST")
{
//触发回调函数
PayFactory.OnPayFailed(parameter.TradeID, returnMsg, xml);
return(true);
}
else if (result.GetValue("err_code").ToString() == "SYSTEMERROR")
{
//如果是系统错误，则后续继续
return(false);
}
else if (result.GetValue("return_code").ToString() == "FAIL" ||
result.GetValue("result_code").ToString() == "FAIL")
{
//FAIL
//触发回调函数
PayFactory.OnPayFailed(parameter.TradeID, returnMsg, xml);
return(true);
}
}
catch
{
}
return(false);
}
/**
* 刷卡支付完整业务流程逻辑
* @param body 商品描述
* @param total_fee 总金额
* @param auth_code 支付授权码
* @throws WxPayException
* @return 刷卡支付结果
*/
public static string Run(string body, string total_fee, string auth_code)
{
Log.Info("MicroPay", "Micropay is processing...");
WxPayData data = new WxPayData();
data.SetValue("auth_code", auth_code);//授权码
data.SetValue("body", body);//商品描述
data.SetValue("total_fee", int.Parse(total_fee));//总金额
data.SetValue("out_trade_no", WxPayApi.GenerateOutTradeNo());//产生随机的商户订单号
WxPayData result = WxPayApi.Micropay(data, 10); //提交被扫支付，接收返回结果
//如果提交被扫支付接口调用失败，则抛异常
if (!result.IsSet("return_code") || result.GetValue("return_code").ToString() == "FAIL")
{
string returnMsg = result.IsSet("return_msg") ? result.GetValue("return_msg").ToString() : "";
Log.Error("MicroPay", "Micropay API interface call failure, result : " + result.ToXml());
throw new WxPayException("Micropay API interface call failure, return_msg : " + returnMsg);
}
//签名验证
result.CheckSign();
Log.Debug("MicroPay", "Micropay response check sign success");
//刷卡支付直接成功
if(result.GetValue("return_code").ToString() == "SUCCESS" &&
result.GetValue("result_code").ToString() == "SUCCESS")
{
Log.Debug("MicroPay", "Micropay business success, result : " + result.ToXml());
return result.ToPrintStr();
}
/******************************************************************
* 剩下的都是接口调用成功，业务失败的情况
* ****************************************************************/
//1）业务结果明确失败
if(result.GetValue("err_code").ToString() != "USERPAYING" &&
result.GetValue("err_code").ToString() != "SYSTEMERROR")
{
Log.Error("MicroPay", "micropay API interface call success, business failure, result : " + result.ToXml());
return result.ToPrintStr();
}
//2）不能确定是否失败，需查单
//用商户订单号去查单
string out_trade_no = data.GetValue("out_trade_no").ToString();
//确认支付是否成功,每隔一段时间查询一次订单，共查询10次
int queryTimes = 10;//查询次数计数器
while(queryTimes-- > 0)
{
int succResult = 0;//查询结果
WxPayData queryResult = Query(out_trade_no, out succResult);
//如果需要继续查询，则等待2s后继续
if(succResult == 2)
{
Thread.Sleep(2000);
continue;
}
//查询成功,返回订单查询接口返回的数据
else if(succResult == 1)
{
Log.Debug("MicroPay", "Mircopay success, return order query result : " + queryResult.ToXml());
return queryResult.ToPrintStr();
}
//订单交易失败，直接返回刷卡支付接口返回的结果，失败原因会在err_code中描述
else
{
Log.Error("MicroPay", "Micropay failure, return micropay result : " + result.ToXml());
return result.ToPrintStr();
}
}
//确认失败，则撤销订单
Log.Error("MicroPay", "Micropay failure, Reverse order is processing...");
if(!Cancel(out_trade_no))
{
Log.Error("MicroPay", "Reverse order failure");
throw new WxPayException("Reverse order failure！");
}
return result.ToPrintStr();
}
