public virtual RefoundResult Refound(RefoundParameter parameter)
{
WxPayConfig config = new WxPayAPI.WxPayConfig(PayFactory.GetInterfaceXmlConfig(PayInterfaceType.WeiXinBarcode, parameter.TradeID));
WxPayData data = new WxPayData();
data.SetValue("out_trade_no", parameter.TradeID);
data.SetValue("total_fee", (int)(parameter.TotalAmount * 100)); //订单总金额
data.SetValue("refund_fee", (int)(parameter.Amount * 100)); //退款金额
data.SetValue("out_refund_no", Guid.NewGuid().ToString()); //随机生成商户退款单号
data.SetValue("op_user_id", config.MCHID); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data, config); //提交退款申请给API，接收返回数据
string err = result.GetValue("err_code_des") as string;
RefoundResult finallyResult = new RefoundResult();
if (result.GetValue("return_code").ToString() == "SUCCESS" &&
result.GetValue("result_code").ToString() == "SUCCESS")
{
//退款成功
finallyResult.Result = RefoundResult.ResultEnum.SUCCESS;
}
else
{
finallyResult.Result = RefoundResult.ResultEnum.FAIL;
}
finallyResult.Error = err;
finallyResult.ServerMessage = result.ToXml();
return(finallyResult);
}
/// <summary>
/// 微信申请退款接口
/// </summary>
/// <param name="requestModel">请求参数</param>
/// <returns></returns>
public static RefundResponseModel Refund(RefundModel requestModel)
{
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(requestModel.transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", requestModel.transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", requestModel.out_trade_no);
}
data.SetValue("total_fee", requestModel.total_fee); //订单总金额
data.SetValue("refund_fee", requestModel.refund_fee); //退款金额
data.SetValue("out_refund_no", WxPayApi.GenerateOutTradeNo()); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID); //操作员，默认为商户号
LogUtil.WriteWxpayLog("申请退款请求", "请求参数", data.ToJson());
WxPayData result = WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
LogUtil.WriteWxpayLog("申请退款响应", "响应参数", result.ToJson());
RefundResponseModel response = LitJson.JsonMapper.ToObject <RefundResponseModel>(result.ToJson());
//Log.Info("OrderQuery", "OrderQuery process complete, result : " + result.ToXml());
return(response);
}
/// <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, 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", WxPayConfig.GetConfig().GetMchID()); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
Log.Info("Refund", "Refund process complete, result : " + result.ToXml());
return(result.ToPrintStr());
}
public static string SendRequest(RefundInfo info, PayConfig config)
{
WxPayData wxPayData = new WxPayData();
if (!string.IsNullOrEmpty(info.transaction_id))
{
wxPayData.SetValue("transaction_id", info.transaction_id);
}
else
{
wxPayData.SetValue("out_trade_no", info.out_trade_no);
}
wxPayData.SetValue("total_fee", (int)info.TotalFee.Value);
wxPayData.SetValue("refund_fee", (int)info.RefundFee.Value);
wxPayData.SetValue("out_refund_no", info.out_refund_no);
wxPayData.SetValue("op_user_id", config.MchID);
wxPayData.SetValue("sub_appid", config.sub_appid);
wxPayData.SetValue("sub_mch_id", config.sub_mch_id);
wxPayData.SetValue("refund_account", "REFUND_SOURCE_RECHARGE_FUNDS");
WxPayData wxPayData2 = WxPayApi.Refund(wxPayData, config, 60);
SortedDictionary <string, object> values = wxPayData2.GetValues();
if (values["return_code"].ToString() == "SUCCESS" && values["result_code"].ToString() == "SUCCESS")
{
return("SUCCESS");
}
if (values["return_code"].ToString() == "SUCCESS")
{
return(values["err_code_des"].ToString());
}
return(values["return_msg"].ToString());
}
/// <summary>
/// 微信退款申请
/// </summary>
/// <param name="refundData">退款申请参数</param>
/// <returns></returns>
public RequestResult RefundApply(RefundApplyData refundData)
{
#region
RequestResult result = new RequestResult
{
retCode = ReqResultCode.failed,
retMsg = ""
};
if (refundData == null)
{
result.retMsg = "请求参数不能为空";
}
try
{
Log.Info("Refund", "Refund is processing...");
WxPayData data = new WxPayData();
if (!string.IsNullOrEmpty(refundData.transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", refundData.transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", refundData.out_trade_no);
}
data.SetValue("total_fee", int.Parse(refundData.total_fee)); //订单总金额
data.SetValue("refund_fee", int.Parse(refundData.refund_fee)); //退款金额
data.SetValue("out_refund_no", refundData.out_refund_no); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.GetConfig().GetMchID()); //操作员，默认为商户号
WxPayData ret = WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
Log.Info("Refund", "Refund process complete, result : " + ret.ToXml());
if (ret.GetValue("return_code").ToString() == "SUCCESS" && ret.GetValue("result_code").ToString() == "SUCCESS")
{
result.retCode = ReqResultCode.success;
result.retMsg = "请求成功";
result.objectData = ret;//把结果返回到业务层
}
else
{
Log.Error(this.GetType().ToString(), "微信退款申请失败!");
result.retMsg = "微信退款申请失败";
}
}
catch (Exception ex)
{
Log.Error(this.GetType().ToString(), $"微信退款申请发生异常：{ex.Message}");
throw new WxPayException($"微信退款申请发生异常：{ex.Message}");
}
return(result);
#endregion
}
/// <summary>
/// 发起订单退款
/// </summary>
/// <param name="refundRequest">退款申请参数</param>
/// <returns></returns>
public override ApiResultModel <string> RefundPay(RefundBaseRequest refundRequest)
{
ApiResultModel <string> res = new ApiResultModel <string> {
Code = ApiResultCode.Fail
};
//处理退款金额，不能超过支付金额
var orderRefund = refundRequest.OrderMoney;
var orderRefundCode = refundRequest.RefundRemark;
//2、实际退款请求
string total_fee = (refundRequest.OrderMoney * 100).ToString("f0");
int.TryParse(total_fee, out int _total_fee);
string refund_fee = (refundRequest.RefundMoney * 100).ToString("f0");
int.TryParse(refund_fee, out int _refund_fee);
WxPayData data = new WxPayData();
data.SetValue("transaction_id", refundRequest.TradeNo);
data.SetValue("out_trade_no", refundRequest.OrderCode);
data.SetValue("total_fee", _total_fee);
data.SetValue("refund_fee", _refund_fee);
data.SetValue("refund_desc", "用户申请退款");
data.SetValue("out_refund_no", orderRefundCode);
data.SetValue("appid", AppId);
data.SetValue("mch_id", MchId);
//2.1、实际退款请求
var result = WxPayApi.Refund(data, key: Key);
//2.2、记录请求日志
//记录微信退款调用的日志
//string url = "https://api.mch.weixin.qq.com/secapi/pay/refund";
//WritePostThirdApi(ThirdPlatformBusinessType.Payment, orderRefund.OrderCode, ThirdPlatformType.WechatPay, url, data.ToXml(), DateTime.Now, result.ToXml(), DateTime.Now, true);
//3、退款结果验证
if (result.GetValue("return_code").ToString() != "SUCCESS")
{
res.Message = string.Format("{0}（{1}）", result.GetValue("return_msg").ToString(), result.GetValue("return_code").ToString());
return(res);
}
if (result.GetValue("result_code").ToString() != "SUCCESS")
{
res.Message = string.Format("{0}（{1}）", result.GetValue("err_code_des").ToString(), result.GetValue("result_code").ToString());
return(res);
}
res.Code = ApiResultCode.Success;
return(res);
}
public static string SendRequest(RefundInfo info, PayConfig config, out string WxRefundNum)
{
WxPayData wxPayData = new WxPayData();
if (!string.IsNullOrEmpty(info.transaction_id))
{
wxPayData.SetValue("transaction_id", info.transaction_id);
}
else
{
wxPayData.SetValue("out_trade_no", info.out_trade_no);
}
wxPayData.SetValue("total_fee", (int)info.TotalFee.Value);
wxPayData.SetValue("refund_fee", (int)info.RefundFee.Value);
wxPayData.SetValue("out_refund_no", info.out_refund_no);
wxPayData.SetValue("op_user_id", config.MchID);
if (!string.IsNullOrEmpty(config.sub_appid))
{
wxPayData.SetValue("sub_appid", config.sub_appid);
wxPayData.SetValue("sub_mch_id", config.sub_mch_id);
}
WxPayData wxPayData2 = WxPayApi.Refund(wxPayData, config, 60);
SortedDictionary <string, object> values = wxPayData2.GetValues();
string result;
if (values.ContainsKey("return_code") && values["return_code"].ToString() == "SUCCESS" && values.ContainsKey("result_code") && values["result_code"].ToString() == "SUCCESS")
{
WxRefundNum = "";
result = "SUCCESS";
}
else
{
HttpService.WxDebuglog(JsonConvert.SerializeObject(values), "_wxpay.txt");
string str = "";
if (values.ContainsKey("err_code_des"))
{
str = values["err_code_des"].ToString();
}
if (values.ContainsKey("refund_id"))
{
WxRefundNum = values["refund_id"].ToString();
}
else
{
WxRefundNum = "";
}
result = str + values["return_msg"].ToString();
}
return(result);
}
/// <summary>
/// 申请退款
/// </summary>
/// <returns></returns>
public WxPayData GetRefundOrderResult()
{
WxPayData data = new WxPayData();
data.SetValue("out_trade_no", order_no); //商户订单号
data.SetValue("out_refund_no", out_refund_no); //商户退款单号
data.SetValue("total_fee", total_fee);
data.SetValue("refund_fee", refund_fee);
data.SetValue("op_user_id", op_user_id);
WxPayData result = WxPayApi.Refund(data);
if (!result.IsSet("return_code") || result.GetValue("return_code").ToString() != "SUCCESS")
{
Log.Error(this.GetType().ToString(), "RefundOrder response error!");
throw new WxPayException("RefundOrder response error!");
}
return(result);
}
/***
* 申请退款完整业务流程逻辑
* @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());
}
/// <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());
}
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);
}
/**********************************微信退款*******************************/
public int PostRefundW(List <SaleModel> lstSaleModel)
{
try
{
if (lstSaleModel.Count == 0)
{
return(1);
}
//移动支付配置赋值
PayService pay = new PayService();
WxPayConfig payConfig = pay.GenerateConfigModelW(lstSaleModel[0].MachineId);
foreach (SaleModel saleModel in lstSaleModel)
{
WxPayData data = new WxPayData();
data.SetValue("out_trade_no", saleModel.TradeNo);
data.SetValue("total_fee", int.Parse((saleModel.TradeAmount * 100).ToString()));//订单总金额
if (saleModel.RealitySaleNumber == 0)
{
data.SetValue("refund_fee", int.Parse((saleModel.TradeAmount * 100).ToString()));//退款金额
}
else
{
data.SetValue("refund_fee", int.Parse(((saleModel.TradeAmount * 100) * ((saleModel.SalesNumber - saleModel.RealitySaleNumber) / saleModel.SalesNumber)).ToString()));//退款金额
}
data.SetValue("out_refund_no", WxPayApi.GenerateOutTradeNo(payConfig)); //随机生成商户退款单号
data.SetValue("op_user_id", payConfig.MCHID); //操作员，默认为商户号
//Log.Write("wwwww", "开始退款");
WxPayData result = WxPayApi.Refund(data, payConfig); //提交退款申请给API，接收返回数据
//更新销售状态
if (result.GetValue("result_code").ToString().ToUpper() == "SUCCESS")
{
SaleModel salInfo = new SaleModel();
salInfo.MachineId = saleModel.MachineId;
salInfo.GoodsId = saleModel.GoodsId;
salInfo.TradeNo = saleModel.TradeNo;
if (saleModel.RealitySaleNumber == 0)
{
salInfo.TradeStatus = 6;
//更新成6
}
else
{
//更新成3
salInfo.TradeStatus = 3;
}
MachineHelper.ClearCacheOrder(saleModel.TradeNo);
UpdateRefundResult(salInfo);
RefundModel refundInfo = new RefundModel();
refundInfo.OutTradeNo = salInfo.TradeNo;
refundInfo.RefundDetail = result.ToJson();
PostRefundDetail(refundInfo);
}
}
return(1);
}
catch (Exception ex)
{
return(0);
}
}
/// <summary>
/// 改签退款
/// </summary>
/// <param name="dicPar"></param>
public void Refund(Dictionary <string, object> dicPar)
{
List <string> pra = new List <string>()
{
"GUID", "refund_fee", "orderno"
};
//检测方法需要的参数
if (!CheckActionParameters(dicPar, pra))
{
return;
}
var refund_fee = dicPar["refund_fee"].ToString(); //退款金额 如果空，则为退所有
var orderno = dicPar["orderno"].ToString();
WxPayData data = new WxPayData();
var sql = "SELECT money,transaction_id,out_trade_no FROM dbo.Wx_Pay WHERE out_trade_no=(SELECT out_trade_no FROM dbo.WX_orderdetails WHERE orderno='" + orderno + "')";
var orderInfo = SQL.SQLTool.ExecuteDataTable(sql);
if (orderInfo.Rows.Count > 0) //如果数据库返回了数据才进行退款
{
var total_fee = Convert.ToString(orderInfo.Rows[0]["money"]); //
if (refund_fee == "0")
{
refund_fee = total_fee;
}
var transaction_id = Convert.ToString(orderInfo.Rows[0]["transaction_id"]);
var out_trade_no = Convert.ToString(orderInfo.Rows[0]["out_trade_no"]);
if (!string.IsNullOrEmpty(transaction_id))//微信订单号存在的条件下，则已微信订单号为准
{
data.SetValue("transaction_id", transaction_id);
}
else//微信订单号不存在，才根据商户订单号去退款
{
data.SetValue("out_trade_no", out_trade_no);
}
// SetParam.SetParams(stocode);
var out_refund_no = WxPayApi.GenerateOutTradeNo(); //退款单号
data.SetValue("total_fee", int.Parse(total_fee)); //订单总金额
data.SetValue("refund_fee", int.Parse(refund_fee)); //退款金额
data.SetValue("out_refund_no", out_refund_no); //随机生成商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID); //操作员，默认为商户号
WxPayData result = WxPayApi.Refund(data); //提交退款申请给API，接收返回数据
var pResult = result.ToPrintStr();
var v = pResult.Split('|');
var strWhere = string.Empty;
var result_code = string.Empty;
for (int i = 0; i < v.Count(); i++)
{
if (v[i].Contains("refund_id"))
{
strWhere += "refund_id='" + Convert.ToString(v[i].Split('=')[1]) + "',";
}
else if (v[i].Contains("result_code"))
{
result_code = Convert.ToString(v[i].Split('=')[1]);
strWhere += "result_code='" + result_code + "',";
}
else if (v[i].Contains("err_code_des"))
{
strWhere += "err_code_des='" + Convert.ToString(v[i].Split('=')[1]) + "',";
}
}
try
{
sql = "update WX_orderdetails SET " + strWhere + " out_refund_no='" + out_refund_no + "',status='7' WHERE orderno='" + Tools.SafeSql(orderno) + "'";
SQLTool.ExecuteScalar(sql);
ToCustomerJson("0", result_code);
}
catch (Exception ex)
{
ToCustomerJson("1", "退款失败");
}
}
else
{
ToCustomerJson("2", "未查询到该订单号的付款信息");
}
}
/// <summary>
/// 退款
/// </summary>
/// <param name="refund">退款实体</param>
/// <param name="refundBack">退款返回实体</param>
/// <param name="message">错误信息</param>
/// <returns>交易是否成功</returns>
internal bool Refund(Refund refund, out RefundBack refundBack, out string message)
{
_log.Info("退款 Refund 开始执行");
var data = new WxPayData();
if (string.IsNullOrEmpty(refund.Out_Trade_No) || string.IsNullOrEmpty(WxPayConfig.MCHID) || string.IsNullOrEmpty(refund.Out_Refund_No))
{
message = "商户订单号，操作员，退款单号 不能为空";
_log.Error(message);
refundBack = null;
return(false);
}
if (refund.Total_Fee < 0 || refund.Refund_Fee < 0)
{
message = "订单总金额或退款金额不能为0";
_log.Error(message);
refundBack = null;
return(false);
}
data.SetValue("out_trade_no", refund.Out_Trade_No);
data.SetValue("total_fee", refund.Total_Fee); //订单总金额
data.SetValue("refund_fee", refund.Refund_Fee); //退款金额
data.SetValue("out_refund_no", refund.Out_Refund_No); //商户退款单号
data.SetValue("op_user_id", WxPayConfig.MCHID); //操作员，默认为商户号
//退款
_log.Info("退款 WxPayApi.Refund");
var result = WxPayApi.Refund(data);
_log.Info("Refund", "Refund process complete, result : " + result.ToXml());
var return_code = result.GetValue("return_code")?.ToString().ToUpper();
var result_code = result.GetValue("result_code")?.ToString().ToUpper();
if (return_code == "SUCCESS" && result_code == "SUCCESS")
{
_log.Info("退款处理成功");
refundBack = new RefundBack()
{
Out_Trade_No = result.GetValue("out_trade_no")?.ToString(),
Out_Refund_No = result.GetValue("out_refund_no")?.ToString(),
Refund_Id = result.GetValue("refund_id")?.ToString(),
Refund_Channel = result.GetValue("refund_channel")?.ToString(),
Refund_Fee = Convert.ToInt32(result.GetValue("refund_fee")),
Settlement_Refund_Fee = result.GetValue("settlement_refund_fee") == null ? 0 : Convert.ToInt32(result.GetValue("settlement_refund_fee")),
Total_Fee = Convert.ToInt32(result.GetValue("total_fee")),
Settlement_Total_Fee = Convert.ToInt32(result.GetValue("settlement_total_fee")),
Fee_Type = result.GetValue("fee_type")?.ToString(),
Cash_Fee = Convert.ToInt32(result.GetValue("cash_fee")),
Cash_Fee_Type = result.GetValue("cash_fee_type ")?.ToString(),
Cash_Refund_Fee = result.GetValue("cash_refund_fee") == null ? 0 : Convert.ToInt32(result.GetValue("cash_refund_fee")),
Coupon_Type_Sn = result.GetValue("coupon_type_$n")?.ToString(),
Coupon_Refund_Fee = result.GetValue("coupon_refund_fee") == null ? 0 : Convert.ToInt32(result.GetValue("coupon_refund_fee")),
Coupon_Refund_Fee_Sn = result.GetValue("coupon_refund_fee_$n") == null ? 0 : Convert.ToInt32(result.GetValue("coupon_refund_fee_$n")),
Coupon_Refund_Count = result.GetValue("coupon_refund_count") == null ? 0 : Convert.ToInt32(result.GetValue("coupon_refund_count")),
Coupon_Refund_Id_Sn = result.GetValue("coupon_refund_id_$n")?.ToString()
};
message = "";
return(true);
}
else
{
var return_msg = result.GetValue("return_msg");
var err_code_des = result.GetValue("err_code_des");
message = $"{return_msg},{err_code_des}";
_log.Error($"退款处理失败:{message}");
refundBack = null;
return(false);
}
}
public ActionResult RunRefund(int orderId, int tradeId)
{
var trade = YunClient.Instance.Execute(new GetTradeRequest {
Id = tradeId
}).Trade;
if (trade != null && trade.Orders.Any(e => e.Id == orderId))
{
var order = trade.Orders.Single(e => e.Id == orderId);
var result =
YunClient.Instance.Execute(
new CreateRefundRequest {
OnlineMoney = order.Money, OrderId = orderId, Reason = "全额退款"
}, Token)
.RefundData;
if (result.Key <= 0)
{
return(Json(new { error = result.Key, result = false }));
}
var detail =
YunClient.Instance.Execute(new GetRefundDetailRequest {
OrderId = orderId
}, Token)
.Refund;
if (trade.Money <= 0)
{
YunClient.Instance.Execute(
new ChangeRefundStatusRequest {
OrderRefundId = detail.Id, Remark = "", Status = "SUCCESS"
},
Token);
return(Json(new { error = result.Key, result = true }));
}
var setting =
YunClient.Instance.Execute(new GetOnlinePaymentRequest {
PayMethod = "MOBILE", CompanyId = 0
}, Token)
.Setting.Weixinpay;
//进入微信退款流程
//微信退款
var wxRefundInit = WxPayApi.Refund(detail.OrderInfo.Money, detail.Online, detail.RefundBatchNo,
trade.PaymentInfo.OnlinePayResult.TradeNo, setting.Key, setting.AppId, setting.MchId,
trade.PaymentInfo.Flowid.ToString());
if (wxRefundInit.GetValue("result_code").Equals("SUCCESS"))
{
YunClient.Instance.Execute(new CompleteRefundRequest {
RefundId = detail.RefundId
}, Token);
//退款成功
return(Json(new { error = "", result = true }));
}
return(Json(new { error = wxRefundInit.ToPrintStr(), result = false }));
}
return(Json(new { error = "-1", result = false }));
}
public ActionResult DoWxRefund(int orderId, int tradeId)
{
var detail =
YunClient.Instance.Execute(new GetRefundDetailRequest {
OrderId = orderId
}, Token)
.Refund;
if (detail != null)
{
var trade = YunClient.Instance.Execute(new GetTradeRequest {
Id = tradeId
}).Trade;
if (trade.Money <= 0)
{
var r = YunClient.Instance.Execute(
new ChangeRefundStatusRequest {
OrderRefundId = detail.Id, Remark = "", Status = "SUCCESS"
},
Token).Result;
//退款成功
return(Content("0元退款成功,代码：" + r));
}
if (trade.PaymentInfo.OnlinePayResult == null)
{
return(Content("错误，在线付款信息不存在"));
}
var setting =
YunClient.Instance.Execute(new GetOnlinePaymentRequest {
PayMethod = "MOBILE", CompanyId = 0
}, Token)
.Setting.Weixinpay;
//微信退款
var exRefund = WxPayApi.Refund(detail.OrderInfo.Money, detail.Online, detail.RefundBatchNo,
trade.PaymentInfo.OnlinePayResult.TradeNo, setting.Key, setting.AppId, setting.MchId,
trade.PaymentInfo.Flowid.ToString());
if (exRefund.GetValue("result_code").Equals("SUCCESS"))
{
var r = YunClient.Instance.Execute(new CompleteRefundRequest {
RefundId = detail.RefundId
}, Token).Result;
//退款成功
return(Content("退款成功,代码：" + r));
}
ViewData["RefundResult"] = exRefund.ToPrintStr();
return(View());
}
return(Content("订单不存在"));
}
