/// <summary>
/// 查询支付结果记录
/// </summary>
/// <param name="sysNo"></param>
/// <returns></returns>
public static PayResultInfo GetPayResult(int sysNo)
{
string sql = @"SELECT * FROM Pay_Result WHERE SysNo=@sysNo";
PayResultInfo resultInfo = DbHelper.QuerySingle <PayResultInfo>(sql, new { sysNo = sysNo });
return(resultInfo);
}
/// <summary>
/// 校验支付结果请求
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult CheckRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult();
result.Status = ResultStatus.Success;
return(result);
}
/// <summary>
/// 校验支付结果请求
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult CheckRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult();
var paramsData = new ParameterData();
paramsData.FromUrl(data);
var paramsDict = paramsData.GetValues();
//判断是否有带返回参数
if (paramsDict.Count == 0)
{
result.Status = ResultStatus.Failure;
result.Message = resultInfo.ResultDesc = "支付结果无通知参数";
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
PayResultDAL.Update(resultInfo);
return(result);
}
//校验请求报文
resultInfo.OrderId = paramsData.GetValue("out_trade_no");
var aliNotify = new AlipayNotify();
bool verifyResult = aliNotify.Verify(paramsDict, paramsData.GetValue("notify_id"), paramsData.GetValue("sign"));
if (!verifyResult)
{
result.Status = ResultStatus.Failure;
result.Message = resultInfo.ResultDesc = "verify failed";
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
PayResultDAL.Update(resultInfo);
return(result);
}
result.Status = ResultStatus.Success;
return(result);
}
/// <summary>
/// 解析支付结果
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult <PayNotifyInfo> ResolveRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult <PayNotifyInfo>();
try
{
var paramsData = new ParameterData();
paramsData.FromUrl(data);
resultInfo.OrderId = paramsData.GetValue("out_trade_no");
resultInfo.TradeNo = paramsData.GetValue("trade_no");
resultInfo.PaymentAmt = Convert.ToDecimal(paramsData.GetValue("total_fee"));
string tradeStatus = paramsData.GetValue("trade_status");
var tradeResult = (tradeStatus == "TRADE_FINISHED" || tradeStatus == "TRADE_SUCCESS") ? ResultStatus.Success : ResultStatus.Failure;
resultInfo.ResultDesc = tradeStatus;
resultInfo.ExecuteResult = (int)tradeResult;
result.Data = this.GetPayNotifyInfo(resultInfo);
result.Status = ResultStatus.Success;
}
catch
{
result.Status = ResultStatus.Error;
resultInfo.ResultDesc = result.Message = "解析支付结果参数失败";
resultInfo.ExecuteResult = (int)ResultStatus.Error;
PayResultDAL.Update(resultInfo);
}
return(result);
}
/// <summary>
/// 校验支付结果请求
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult CheckRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult();
var notifyData = new AllinpayData(AllinpayDataType.PayResult);
notifyData.FromUrl(data);
//校验参数个数
if (notifyData.GetValues().Count == 0)
{
result.Status = ResultStatus.Failure;
result.Message = resultInfo.ResultDesc = "支付结果无通知参数";
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
PayResultDAL.Update(resultInfo);
return(result);
}
//校验参数合法性
resultInfo.OrderId = notifyData.GetValue("orderNo");
bool verifyResult = AllinpayCore.VerifyResultSign(notifyData);
if (!verifyResult)
{
result.Status = ResultStatus.Failure;
result.Message = resultInfo.ResultDesc = "verify failed";
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
PayResultDAL.Update(resultInfo);
return(result);
}
result.Status = ResultStatus.Success;
return(result);
}
/// <summary>
/// 解析支付结果
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult <PayNotifyInfo> ResolveRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult <PayNotifyInfo>();
try
{
var notifyData = new ParameterData();
notifyData.FromUrl(data);
resultInfo.OrderId = notifyData.GetValue("orderNo");
resultInfo.TradeNo = notifyData.GetValue("paymentOrderId");
resultInfo.PaymentAmt = Convert.ToDecimal(notifyData.GetValue("payAmount")) / 100;//通联支付金额单位为“分”，所以除以100
string tradeStatus = notifyData.GetValue("payResult");
var tradeResult = tradeStatus == "1" ? ResultStatus.Success : ResultStatus.Failure;
resultInfo.ResultDesc = tradeStatus;
resultInfo.ExecuteResult = (int)tradeResult;
result.Data = this.GetPayNotifyInfo(resultInfo);
result.Status = ResultStatus.Success;
}
catch
{
result.Status = ResultStatus.Error;
result.Message = "解析支付结果参数失败";
}
return(result);
}
/// <summary>
/// 解析支付结果
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult <PayNotifyInfo> ResolveRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult <PayNotifyInfo>();
try
{
var notifyData = new ParameterData();
notifyData.FromXml(data);
resultInfo.OrderId = notifyData.GetValue("out_trade_no");
resultInfo.TradeNo = notifyData.GetValue("transaction_id");
resultInfo.PaymentAmt = Convert.ToDecimal(notifyData.GetValue("total_fee")) / 100;//微信支付金额的单位为“分”，所以要除以100
resultInfo.ExtTradeNo = notifyData.GetValue("out_transaction_id");
string tradeStatus = notifyData.GetValue("pay_result");
var tradeResult = ResultStatus.Success;//由于在校验支付结果请求时已经验证了是否支付成功，所以此处肯定是支付成功的
resultInfo.ResultDesc = tradeStatus;
resultInfo.ExecuteResult = (int)tradeResult;
result.Data = this.GetPayNotifyInfo(resultInfo);
result.Status = ResultStatus.Success;
}
catch
{
resultInfo.ResultDesc = "解析支付结果参数失败";
resultInfo.ExecuteResult = (int)ResultStatus.Error;
PayResultDAL.Update(resultInfo);
result.Message = resultInfo.ResultDesc;
result.Status = ResultStatus.Error;
}
return(result);
}
/// <summary>
/// 更新支付结果记录并关联支付请求记录
/// </summary>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public virtual PayRequestInfo RelateRequestInfo(PayResultInfo resultInfo)
{
//判断是否存在有效的支付结果记录，如果存在，则当前支付结果记录不执行
bool exist = PayResultDAL.ExistValidPayResult(resultInfo.OrderId, resultInfo.TradeNo, (AppEnum.PayType)resultInfo.PayType);
if (exist)
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "已存在有效的支付结果记录";
}
PayRequestInfo requestInfo = null;
if (resultInfo.ExecuteResult == (int)ResultStatus.Success)
{
requestInfo = PayRequestDAL.GetValidPayRequest(resultInfo.OrderId, (AppEnum.PayType)resultInfo.PayType);
if (requestInfo != null && requestInfo.SysNo > 0)
{
resultInfo.RequestSysNo = requestInfo.SysNo;
}
}
//更新支付结果记录信息
PayResultDAL.Update(resultInfo);
return(requestInfo);
}
/// <summary>
/// 校验支付结果请求
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult CheckRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult();
var errorData = new WxPayData();
try
{
//校验请求报文
var notifyData = new ParameterData();
notifyData.FromXml(data);
//检查支付结果中transaction_id是否存在
resultInfo.OrderId = notifyData.GetValue("out_trade_no") as string;
resultInfo.TradeNo = notifyData.GetValue("transaction_id") as string;
if (string.IsNullOrEmpty(resultInfo.TradeNo))
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "支付结果中微信支付单号不存在";
PayResultDAL.Update(resultInfo);
errorData.SetValue("return_code", "FAIL");
errorData.SetValue("return_msg", resultInfo.ResultDesc);
result.Message = errorData.ToXml();
result.Status = ResultStatus.Failure;
return(result);
}
//查询支付单，判断支付单真实性
var req = new WxPayData();
req.SetValue("transaction_id", resultInfo.TradeNo);
var queryData = WxPayApi.OrderQuery(req);
if (queryData.GetValue("return_code").ToString() != "SUCCESS" || queryData.GetValue("result_code").ToString() != "SUCCESS")
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "微信支付单查询失败";
PayResultDAL.Update(resultInfo);
errorData.SetValue("return_code", "FAIL");
errorData.SetValue("return_msg", resultInfo.ResultDesc);
result.Message = errorData.ToXml();
result.Status = ResultStatus.Failure;
return(result);
}
}
catch (WxPayException wex)
{
resultInfo.ExecuteResult = (int)ResultStatus.Error;
resultInfo.ResultDesc = wex.Message;
PayResultDAL.Update(resultInfo);
errorData.SetValue("return_code", "FAIL");
errorData.SetValue("return_msg", resultInfo.ResultDesc);
result.Message = errorData.ToXml();
result.Status = ResultStatus.Error;
return(result);
}
result.Status = ResultStatus.Success;
return(result);
}
/// <summary>
/// 插入支付结果回执记录
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public static int Insert(PayResultInfo info)
{
string sql = @"
INSERT INTO Pay_Result
(RequestSysNo,OrderId,PaymentAmt,PayType,RequestData,ExecuteResult,ResultDesc,NotifyStatus,CreateTime,ExtTradeNo)
VALUES (@RequestSysNo,@OrderId,@PaymentAmt,@PayType,@RequestData,@ExecuteResult,@ResultDesc,@NotifyStatus,@CreateTime,@ExtTradeNo);
SELECT LAST_INSERT_ID();"; //mysql SELECT LAST_INSERT_ID() , sql=SCOPE_IDENTITY
info.SysNo = DbHelper.QueryScalar <int>(sql, info);
return(info.SysNo);
}
public bool payResult1(ref PayParam p)
{
PayResultInfo payResultInfo = payStart(p);
p.payResultInfo = payResultInfo;
string recode = payResultInfo.code;
log.Write("我方支付返回码：" + recode);
if ("0000".Equals(recode))
{
//支付成功
return(true);
}
else if ("9999".Equals(payResultInfo.msgCode) && "9900".Equals(recode))
{
//退款
exitRefund(SqlLiteHelper.SqlLiteHelper.query("refund9999")[0].FormalValue);
return(false);
}
else if ("0028".Equals(payResultInfo.msgCode) && "9900".Equals(recode))
{
//退款
exitRefund(SqlLiteHelper.SqlLiteHelper.query("refund0028")[0].FormalValue);
return(false);
}
else if ("9991".Equals(recode))
{
//发起冲正
exit("缴费失败，请重新缴费或退卡");
return(false);
}
else if ("9999".Equals(recode))
{
//支付失败，异常
exit("缴费失败，请重新缴费或退卡");
return(false);
}
else if ("9955".Equals(recode))
{
//密码错误
Util.JumpUtil.jumpCommonPage("FormInputPassword");
return(false);
}
else if ("9951".Equals(recode))
{
//余额不足
exit("余额不足");
return(false);
}
//退款成功 9999
//正在缴费 其他
exit("缴费失败，请重新缴费或退卡");
return(false);
}
private void button5_Click_1(object sender, EventArgs e)
{
PropSecOrderParam param = new PropSecOrderParam();
param.shopType = "1";
param.AMOUNT = "12";
param.paymentAmout = "0";
param.SC10009 = "W000000001";
param.SC10010 = "01";
param.SC10007 = "XQ00000221";
param.SC10008 = SC10008;
param.merchantNo = merchantNo;
PropSecOrderInfo info = access.order(param);
PayAccess payAccess = new PayAccess();
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("serviceType", "5_2");
parameters.Add("realAmout", info.msgrsp.realAmout);
parameters.Add("tr.shop_type", "1");
parameters.Add("tr.cloud_no", info.msgrsp.orderNo);
parameters.Add("terminalNo", SysConfigHelper.readerNode("ClientNo"));
parameters.Add("ipAddress", SysConfigHelper.readerNode("PayName"));
PayResultInfo payinfo = payAccess.PayResNewAcc(parameters);
StringBuilder result1 = new StringBuilder(2048);
StringBuilder result2 = new StringBuilder(2048);
IntPtr status = PropSwwyBLL.WF002(
new StringBuilder("02"), //业务类型
new StringBuilder("01"), //卡片种类
new StringBuilder("01"), //卡片版本
new StringBuilder(""), //，业务步骤
new StringBuilder(""), //卡片唯一识别号
new StringBuilder(""), //物业公司编号
new StringBuilder(""), //小区编号
new StringBuilder("W000000001"), //表具产商编号
new StringBuilder("8"), //端口号
result1, //返回说明
new StringBuilder(payinfo.SC20003.ToString()), //业务输入信息
result2 //业务返回信息
);
string result = Marshal.PtrToStringAnsi(status);
MessageBox.Show(result);
PropSecCardJson card = new PropSec().JsonToModel(result2.ToString());
//SC10007 = card.G_0806;
SC10008 = card.G_1802;
listViewAdd("写卡：" + "状态:" + result.ToString() + "返回说明:" + result1.ToString() + "返回信息：" + result2.ToString());
//IntPtr intPtr = ReturnString();
//string str = Marshal.PtrToStringAnsi(intPtr);
}
/// <summary>
/// 获取支付结果通知对象
/// </summary>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
protected PayNotifyInfo GetPayNotifyInfo(PayResultInfo resultInfo)
{
var notifyInfo = new PayNotifyInfo()
{
OrderId = resultInfo.OrderId,
TradeNo = resultInfo.TradeNo,
PaymentAmt = resultInfo.PaymentAmt.ToString(),
ExtTradeNo = resultInfo.ExtTradeNo,
Result = resultInfo.ExecuteResult.ToString(),
};
return(notifyInfo);
}
/// <summary>
/// 保存支付结果请求
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="payType">支付方式</param>
/// <returns></returns>
public virtual PayResultInfo SaveRequest(string data, AppEnum.PayType payType)
{
var resultInfo = new PayResultInfo()
{
PayType = (int)payType,
RequestData = data,
ExecuteResult = (int)ResultStatus.None,
NotifyStatus = (int)AppEnum.NotifyStatus.Original,
CreateTime = DateTime.Now,
};
resultInfo.SysNo = PayResultDAL.Insert(resultInfo);
return(resultInfo);
}
/// <summary>
/// 保存支付结果异步回执记录
/// </summary>
/// <param name="data"></param>
/// <param name="payType"></param>
/// <returns></returns>
public static PayResultInfo SavePayResult(string data, AppEnum.PayType payType)
{
var payResult = new PayResultInfo()
{
PayType = (int)payType,
RequestData = data,
ExecuteResult = (int)ResultStatus.None,
NotifyStatus = (int)AppEnum.GlobalStatus.Invalid,
CreateTime = DateTime.Now,
};
payResult.SysNo = PayResultDAL.Insert(payResult);
return(payResult);
}
/// <summary>
/// 解析支付结果
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult <PayNotifyInfo> ResolveRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult <PayNotifyInfo>();
var orderInfo = JsonHelper.Deserialize <PayOrderInfo>(data);
resultInfo.OrderId = orderInfo.OrderId;
resultInfo.TradeNo = DateTime.Now.ToString("yyyyMMddHHmmssfff") + RandomHelper.CreateRandomCode(3);
resultInfo.PaymentAmt = Convert.ToDecimal(orderInfo.PaymentAmt);
resultInfo.ExecuteResult = (int)ResultStatus.Success;
result.Data = this.GetPayNotifyInfo(resultInfo);
result.Status = ResultStatus.Success;
return(result);
}
/// <summary>
/// 支付完成返回页面
/// </summary>
/// <returns></returns>
public ActionResult OnlinePayReturn()
{
//请求参数报文
string requestParams = string.Empty;
//支付完成通知对象
var notifyInfo = new PayNotifyInfo();
try
{
var resultInterface = Builder.BuildAllinpayResult();
requestParams = HttpUtility.UrlDecode(Request.Form.ToString());
var resultInfo = new PayResultInfo();
//校验请求报文
var checkResult = resultInterface.CheckRequest(requestParams, resultInfo);
if (checkResult.Status != ResultStatus.Success)
{
ViewBag.ErrorMsg = checkResult.Message;
return(View());
}
//解析支付结果
var resolveResult = resultInterface.ResolveRequest(requestParams, resultInfo);
if (resolveResult.Status != ResultStatus.Success)
{
ViewBag.ErrorMsg = resolveResult.Message;
return(View());
}
//获取支付完成返回地址，如果有值，则跳转到该地址去
notifyInfo = resolveResult.Data;
var requestInfo = PayRequestDAL.GetValidPayRequest(notifyInfo.OrderId, this._payType);
var returnUrl = resultInterface.GetReturnUrl(requestInfo, notifyInfo);
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
}
catch (Exception ex)
{
string log = string.Format(@"支付完成返回发生异常！{0}异常描述：{1}{0}异常堆栈：{2}{0}请求参数：{3}",
Environment.NewLine, ex.Message, ex.StackTrace, requestParams);
LogWriter.WriteLog(log, AppConfig.Global.AllinpayLogFolder, ExceptionHelper.ExceptionLevel.Exception);
ViewBag.ErrorMsg = "系统执行发生异常：" + ex.Message;
}
ViewBag.NotifyInfo = notifyInfo;
return(View());
}
/// <summary>
/// 退款
/// </summary>
/// <param name="orderinfo"></param>
/// <param name="payResultInfo"></param>
/// <param name="p"></param>
public void refund(ref PayResultInfo payResultInfo, PayParam p)
{
try
{
RefundParam refundParam = new RefundParam();
//交易类型
refundParam.serviceType = p.serviceType;
//是否写卡成功
refundParam.rqFlushesCode = p.rqFlushesCode;
//交易类型
refundParam.shop_type = isWtLkl(p.icParams);
//云平台订单号
refundParam.cloud_no = p.orderNo;
//交易金额
payResultInfo.map["4"] = p.rechageAmount;
//退款
if (p.icParams == null)
{
//万通退款
refundParam.data = Wanton.wtRefund(payResultInfo.map, p.MERCHANTNO_shopNo);
}
else
{
//银行卡退款
refundParam.data = LKLProcedure.wtPayRevoke(payResultInfo.map, p);
}
PayAccess payAccess = new PayAccess();
//发起退款
PayResultInfo result = payAccess.RefundAcc(refundParam);
if ("0000".Equals(result.code))
{
log.Write("退款成功！");
}
else
{
log.Write("退款失败！");
}
}
catch (Exception ex)
{
log.Write("error:退款异常：" + ex.Message + ex.InnerException);
}
}
public string refundStr(PayResultInfo payResultInfo, PayParam p)
{
try
{
//退款
if (p.icParams == null)
{
//万通退款
return(Wanton.wtRefund(payResultInfo.map, p.MERCHANTNO_shopNo));
}
else
{
//银行卡退款
return(LKLProcedure.wtPayRevoke(payResultInfo.map, p));
}
}
catch (Exception ex)
{
log.Write("error:退款异常：" + ex.Message + ex.InnerException);
return(null);
}
}
/// <summary>
/// 更新支付结果回执记录（不更新PayType、RequestData字段）
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public static bool Update(PayResultInfo info)
{
if (info.SysNo <= 0)
{
return(false);
}
string sql = @"
UPDATE Pay_Result
SET RequestSysNo=@RequestSysNo,
OrderId=@OrderId,
TradeNo=@TradeNo,
PaymentAmt=@PaymentAmt,
ExecuteResult=@ExecuteResult,
ResultDesc=@ResultDesc,
NotifyStatus=@NotifyStatus,
ExtTradeNo=@ExtTradeNo
WHERE SysNo=@SysNo";
int count = DbHelper.Execute(sql, info);
return(count > 0);
}
/// <summary>
/// 支付
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public PayResultInfo PayResNewAcc(Dictionary <String, String> parameters)
{
PayResultInfo info = null;
parameters.Add("loginId", SysBLL.getCpuNo());
parameters.Add("reqsn", SysBLL.getSerialNum());
parameters.Add("authcode", SysBLL.Authcode);
parameters.Add("tr.message_type", "2");
//设备编号
parameters.Add("tr.t_id", ConfigurationManager.AppSettings["MechineNo"]);
string address = "";
if (PayStaticParam.payType == -1)
{
//电子现金
address = parameters["ipAddress"];
}
else
{
//识币器
address = SysConfigHelper.readerNode("cashPayName");
}
string jsonText = HttpHelper.getHttp(address, parameters, null);
info = JsonConvert.DeserializeObject <PayResultInfo>(jsonText);
log.Write("支付返回：" + jsonText);
JObject jsonObj = (JObject)JsonConvert.DeserializeObject(jsonText);
JObject data = (JObject)JsonConvert.DeserializeObject(jsonObj["data"].ToString());
if (data != null)
{
info.map = JsonConvert.DeserializeObject <Dictionary <string, string> >(data.ToString());
}
//反序列化JSON字符串,将JSON字符串转换成LIST列表
return(info);
}
/// <summary>
/// 执行条码支付
/// </summary>
/// <param name="orderInfo">支付订单</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public virtual ExecuteResult <PayNotifyInfo> ExecuteBarcodePay(PayOrderInfo orderInfo, PayResultInfo resultInfo)
{
return(new ExecuteResult <PayNotifyInfo>());
}
/// <summary>
/// 校验支付结果请求
/// </summary>
/// <param name="data">业务数据报文</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult CheckRequest(string data, PayResultInfo resultInfo)
{
var result = new ExecuteResult();
try
{
//校验请求报文
var notifyData = new ParameterData();
notifyData.FromXml(data);
resultInfo.OrderId = notifyData.GetValue("out_trade_no");
if (notifyData.GetValue("status") != "0") //校验返回状态
{
throw new BizException("返回状态错误代码：" + notifyData.GetValue("status") + "，错误信息：" + notifyData.GetValue("message"));
}
if (!SwiftPassCore.CheckSign(notifyData)) //校验数据签名
{
throw new BizException("签名校验未通过");
}
if (notifyData.GetValue("result_code") != "0") //校验业务结果
{
throw new BizException("业务结果错误代码：" + notifyData.GetValue("err_code") + "，错误信息：" + notifyData.GetValue("err_msg"));
}
if (notifyData.GetValue("pay_result") != "0") //校验支付结果
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "用户支付失败：" + notifyData.GetValue("pay_info");
PayResultDAL.Update(resultInfo);
result.Message = resultInfo.ResultDesc;
result.Status = ResultStatus.Failure;
return(result);
}
//检查支付结果中transaction_id是否存在
resultInfo.TradeNo = notifyData.GetValue("transaction_id");
if (string.IsNullOrEmpty(resultInfo.TradeNo))
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "支付结果中平台交易单号不存在";
PayResultDAL.Update(resultInfo);
result.Message = resultInfo.ResultDesc;
result.Status = ResultStatus.Failure;
return(result);
}
//查询支付单，判断支付单真实性
var queryData = SwiftPassPayApi.OrderQuery(resultInfo.OrderId, resultInfo.TradeNo);
if (queryData.GetValue("status") != "0" || //校验返回状态
queryData.GetValue("result_code") != "0" || //校验业务结果
!SwiftPassCore.CheckSign(queryData) || //校验数据签名
queryData.GetValue("trade_state") != "SUCCESS") //校验交易状态
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "平台交易单号查询失败";
PayResultDAL.Update(resultInfo);
result.Message = resultInfo.ResultDesc;
result.Status = ResultStatus.Failure;
return(result);
}
}
catch (BizException wex)
{
resultInfo.ExecuteResult = (int)ResultStatus.Error;
resultInfo.ResultDesc = wex.Message;
PayResultDAL.Update(resultInfo);
result.Message = resultInfo.ResultDesc;
result.Status = ResultStatus.Error;
return(result);
}
result.Status = ResultStatus.Success;
return(result);
}
/// <summary> /// 解析支付结果 /// </summary> /// <param name="data">业务数据报文</param> /// <param name="resultInfo">支付结果记录</param> /// <returns></returns> public abstract ExecuteResult <PayNotifyInfo> ResolveRequest(string data, PayResultInfo resultInfo);
/// <summary>
/// 支付
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public PayResultInfo payStart(PayParam p)
{
//密码键盘工具类
PasswordBLL pwdBLL = new PasswordBLL();
//交易数据访问类
PayAccess payAccess = new PayAccess();
//支付结果
PayResultInfo payResultInfo = null;
try
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
//缴费类型
parameters.Add("serviceType", p.serviceType);
//交易金额
parameters.Add("realAmout", p.rechageAmount);
//交易类型，纸币，银行卡，万通卡
parameters.Add("tr.shop_type", isWtLkl(p.icParams));
if (PayStaticParam.payType == -1)
{//电子现金支付相关参数
//获取批次号
p.batchNo = LKLProcedure.GetBatchNo();
//获取支付报文
parameters.Add("tr.data", PayBLL.PayMessage(ref p));
//批次流水号
parameters.Add("dzls", p.batchNo + p.WtLklorderNo);
}
//云平台交易流水号
parameters.Add("tr.cloud_no", p.orderNo);
if ("4".Equals(p.serviceType))
{
//万通卡支付相关参数
if (SysBLL.IsTest.Equals("正式"))
{
parameters.Add("terminalno", "XNJ00002");
parameters.Add("terminal", ConfigurationManager.AppSettings["MechineNo"]);
}
else
{
parameters.Add("terminalno", "UU000002");
parameters.Add("terminal", ConfigurationManager.AppSettings["MechineNo"]);
}
}
else
{
parameters.Add("terminalNo", p.terminalNo);
}
//设置其余参数
initParam(parameters, p);
//发起支付
payResultInfo = payAccess.PayResNewAcc(parameters);
//纸币交易到此为止
if (PayStaticParam.payType == 0)
{
if ("0000".Equals(payResultInfo.code))
{
//支付成功
log.Write("--------------------交易结束--------------------");
return(payResultInfo);
}
else
{
payResultInfo.code = "9999";
log.Write("--------------------交易结束--------------------");
return(payResultInfo);
}
}
if (isNull(payResultInfo) || ("9991".Equals(payResultInfo.code)))
{
//冲正
CorrectParam correctParam = new CorrectParam();
//缴费类型
correctParam.serviceType = p.serviceType;
//支付类型
correctParam.shop_type = isWtLkl(p.icParams);
//云平台交易流水
correctParam.cloud_no = p.orderNo;
for (int i = 1; i <= 3; i++)
{
//获取冲正报文
correctParam.data = Util.JumpUtil.CorrectJump(p);
//发起冲正
PayResultInfo payResultInfoacc = payAccess.CorrectAcc(correctParam);
if ("0000".Equals(payResultInfoacc.code))
{
break;
}
}
payResultInfo.code = "9991";
return(payResultInfo);
}
else if ("9955".Equals(payResultInfo.code))
{
//密码错误
SysBLL.PasswordErrorInfo = "密码错误，请重新输入！";
log.Write("密码错误");
log.Write("--------------------交易结束--------------------");
if (p.icParams == null)
{
//打开键盘，同时交易页面跳转到输入密码页面,万通
pwdBLL.OpenKeyboard(SysConfigHelper.readerNode("ZT598Port"), "9600", p.WtNo);
return(payResultInfo);
}
else
{
//打开键盘，同时交易页面跳转到输入密码页面,银行卡
pwdBLL.OpenKeyboard(SysConfigHelper.readerNode("ZT598Port"), "9600", p.icParams["cardNo"]);
return(payResultInfo);
}
}
else if ("9951".Equals(payResultInfo.code))
{
//余额不足
log.Write("余额不足");
return(payResultInfo);
}
else if ("9900".Equals(payResultInfo.code))
{
//发起退款
refund(ref payResultInfo, p);
return(payResultInfo);
}
else if ("0000".Equals(payResultInfo.code))
{
//支付成功
log.Write("--------------------交易结束--------------------");
//银行卡给万通卡充值成功后，测试环境下会在其他服务页面中显示银行卡退款按钮，可进行退款操作
if (SysBLL.IsTest.Equals("测试"))
{
if (p.serviceType.Equals("4"))
{
//发起退款
RefundTest refundTest = new RefundTest();
refundTest.refundPayResultInfo = payResultInfo;
refundTest.refundPayParam = p;
PayStaticParam.refundTest.Add(refundTest);
}
}
return(payResultInfo);
}
else
{
return(payResultInfo);
}
}
catch (Exception ex)
{
log.Write("error:99:支付失败：" + ex.Message + ex.InnerException);
return(payResultInfo);
}
}
/// <summary> /// 校验支付结果请求 /// </summary> /// <param name="data">业务数据报文</param> /// <param name="resultInfo">支付结果记录</param> /// <returns></returns> public abstract ExecuteResult CheckRequest(string data, PayResultInfo resultInfo);
/// <summary>
/// 执行条码支付
/// </summary>
/// <param name="orderInfo">支付订单</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult <PayNotifyInfo> ExecuteBarcodePay(PayOrderInfo orderInfo, PayResultInfo resultInfo)
{
var result = new ExecuteResult <PayNotifyInfo>();
try
{
int paymentAmt = (int)(Convert.ToDecimal(orderInfo.PaymentAmt) * 100);//微信支付金额的单位为“分”，所以要乘以100
WxPayData runData = MicroPay.Run(orderInfo.OrderId, paymentAmt, orderInfo.Barcode);
if (runData.GetValue("return_code").ToString() != "SUCCESS")
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "微信条码支付请求失败：" + runData.GetValue("return_msg").ToString();
PayResultDAL.Update(resultInfo);
result.Status = ResultStatus.Failure;
result.Message = resultInfo.ResultDesc;
return(result);
}
else if (runData.GetValue("result_code").ToString() != "SUCCESS")
{
resultInfo.ExecuteResult = (int)ResultStatus.Failure;
resultInfo.ResultDesc = "微信条码支付失败：" + runData.GetValue("err_code_des").ToString();
PayResultDAL.Update(resultInfo);
result.Status = ResultStatus.Failure;
result.Message = resultInfo.ResultDesc;
return(result);
}
//支付成功，更新支付结果记录
resultInfo.OrderId = orderInfo.OrderId;
resultInfo.TradeNo = runData.GetValue("transaction_id").ToString();
resultInfo.PaymentAmt = Convert.ToDecimal(runData.GetValue("total_fee")) / 100; //微信支付金额的单位为“分”，所以要除以100
resultInfo.ExecuteResult = (int)ResultStatus.Success;
result.Data = this.GetPayNotifyInfo(resultInfo);
result.Status = ResultStatus.Success;
}
catch (WxPayException wex)
{
resultInfo.ExecuteResult = (int)ResultStatus.Error;
resultInfo.ResultDesc = wex.Message;
PayResultDAL.Update(resultInfo);
result.Status = ResultStatus.Error;
result.Message = resultInfo.ResultDesc;
}
catch (Exception ex)
{
resultInfo.ExecuteResult = (int)ResultStatus.Error;
resultInfo.ResultDesc = ex.ToString();
PayResultDAL.Update(resultInfo);
result.Status = ResultStatus.Error;
result.Message = ex.Message;
}
return(result);
}
/// <summary>
/// 开始支付过程并响应支付结果，由支付页面发起
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public bool payResult(ref PayParam p)
{
//发起支付
PayResultInfo payResultInfo = payStart(p);
p.payResultInfo = payResultInfo;
try
{
p.propSecSC20003 = payResultInfo.SC20003.ToString();
}catch (Exception e)
{
log.Write("error:100:" + e.Message + e.InnerException);
}
//纸币交易到此为止
if (PayStaticParam.payType == 0)
{
if ("0000".Equals(payResultInfo.code))
{
//支付成功
return(true);
}
else
{
//支付失败，异常
exit(payResultInfo.msg);
return(false);
}
}
string recode = payResultInfo.code;
log.Write("恒篮支付返回码：" + recode);
log.Write("云平台返回码：" + payResultInfo.msgCode);
if ("0000".Equals(recode))
{
//支付成功
return(true);
}
else if ("9999".Equals(payResultInfo.msgCode) && "9900".Equals(recode))
{
//退款
exitRefund(payResultInfo.msg);
return(false);
}
else if ("0028".Equals(payResultInfo.msgCode) && "9900".Equals(recode))
{
//退款
exitRefund(payResultInfo.msg);
return(false);
}
else if ("9991".Equals(recode))
{
//发起冲正
exit(payResultInfo.msg);
return(false);
}
else if (("17".Equals(payResultInfo.map["39"])) || ("18".Equals(payResultInfo.map["39"])) || ("32".Equals(payResultInfo.map["39"])) || ("45".Equals(payResultInfo.map["39"])) || ("46".Equals(payResultInfo.map["39"])) || ("47".Equals(payResultInfo.map["39"])) || ("48".Equals(payResultInfo.map["39"])) || ("50".Equals(payResultInfo.map["39"])))
{
exitRefund("此卡已挂失，无法缴费");
return(false);
}
else if ("9999".Equals(recode))
{
//支付失败，异常
exit(payResultInfo.msg);
return(false);
}
else if ("9955".Equals(recode))
{
//密码错误
Util.JumpUtil.jumpCommonPage("FormInputPassword");
return(false);
}
else if ("9951".Equals(recode))
{
//余额不足
exit(payResultInfo.msg);
return(false);
}
//退款成功 9999
//正在缴费 其他
exit("缴费失败，请重新缴费或退卡");
return(false);
}
/// <summary>
/// 通知业务系统支付结果
/// </summary>
/// <param name="resultInfo">支付结果记录</param>
/// <param name="requestInfo">支付请求记录</param>
/// <returns></returns>
public virtual ExecuteResult NotifyBack(PayResultInfo resultInfo, PayRequestInfo requestInfo)
{
var result = new ExecuteResult()
{
Status = ResultStatus.Failure
};
//支付结果记录对象无效，则不执行
if (resultInfo == null || resultInfo.SysNo <= 0)
{
result.Message = "支付结果记录对象无效";
return(result);
}
//支付请求记录对象无效，则不执行
if (requestInfo == null || requestInfo.SysNo <= 0)
{
result.Message = "支付请求记录对象无效";
return(result);
}
//支付结果记录与支付请求记录不对应，则不执行
if (requestInfo.SysNo != resultInfo.RequestSysNo)
{
result.Message = "支付结果记录与支付请求记录不对应";
return(result);
}
//支付结果记录未成功执行，或者已通知，则不执行
if (resultInfo.ExecuteResult != (int)ResultStatus.Success || resultInfo.NotifyStatus == (int)AppEnum.NotifyStatus.Finished)
{
result.Message = "支付结果记录未成功执行或已通知成功";
return(result);
}
//支付请求记录中不存在有效的通知地址，则不执行
if (!requestInfo.NotifyUrl.IsUrl())
{
result.Message = "支付请求记录中不存在有效的通知地址";
return(result);
}
var notifyInfo = this.GetPayNotifyInfo(resultInfo);
var setting = JsonHelper.GetDefaultSettings();
setting.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
string data = JsonHelper.Serialize(notifyInfo, setting);
string sign = SignManager.CreateSign(requestInfo.AppId, data).Data;
string param = string.Format("appId={0}&sign={1}&data={2}", requestInfo.AppId, sign, data);
var response = HttpHelper.HttpRequest("POST", requestInfo.NotifyUrl, param, 10000);
string status = JsonHelper.GetJsonNode(response, "status");
string msg = JsonHelper.GetJsonNode(response, "msg");
result.Message = msg;
var backInfo = new NotifyBackInfo()
{
ResultSysNo = resultInfo.SysNo,
Status = (int)AppEnum.GlobalStatus.Invalid,
Msg = msg,
CreateTime = DateTime.Now,
ResponseData = response,
};
if (status == "1")
{
backInfo.Status = (int)AppEnum.GlobalStatus.Valid;
resultInfo.NotifyStatus = (int)AppEnum.NotifyStatus.Finished;
PayResultDAL.Update(resultInfo);
result.Status = ResultStatus.Success;
}
PayResultDAL.InsertNotifyBack(backInfo);
return(result);
}
/// <summary>
/// 执行条码支付
/// </summary>
/// <param name="orderInfo">支付订单</param>
/// <param name="resultInfo">支付结果记录</param>
/// <returns></returns>
public override ExecuteResult <PayNotifyInfo> ExecuteBarcodePay(PayOrderInfo orderInfo, PayResultInfo resultInfo)
{
var result = new ExecuteResult <PayNotifyInfo>();
resultInfo.OrderId = orderInfo.OrderId;
resultInfo.TradeNo = DateTime.Now.ToString("yyyyMMddHHmmssfff") + RandomHelper.CreateRandomCode(3);
resultInfo.PaymentAmt = Convert.ToDecimal(orderInfo.PaymentAmt);
resultInfo.ExecuteResult = (int)ResultStatus.Success;
result.Data = this.GetPayNotifyInfo(resultInfo);
result.Status = ResultStatus.Success;
return(result);
}
