.NetCore微信支付+服务商模式(saas)

置顶 已于 2022-06-20 11:22:10 修改
阅读量1.6k 收藏 1
点赞数
分类专栏： 技术 支付 文章标签： 微信 .netcore 小程序
于 2022-06-20 11:06:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ml344739968/article/details/125368026
版权

准备工作

介绍

微信服务商模式，可以替商户完成收款功能，商户无需自己研发即可完成收款功能。基于saas企业开发可以采用此种模式替商户完成支付流程

引入如下Nuget包依赖

<PackageReference Include="Essensoft.AspNetCore.Payment.WeChatPay" Version="2.4.6" />
<PackageReference Include="SKIT.FlurlHttpClient.Wechat.TenpayV3" Version="1.8.0" />

支付宝子商户配置

  "WechatPayPartnerPayConfig": { // 微信服务商配置
    "AppId": "wx*************", // 服务商appid
    "MerchantId": "*********", //服务商编号
    "MerchantV3Secret": "***********",
    "MerchantCertSerialNumber": "***********",
    "MerchantCertPrivateKey": "***********",
    "MerchantAppId": "wxf***********",  // 服务商公众号appid
    "MerchantAppSecret": "***********", //公众号秘钥
    "PayExpireTime": "35", //支付过期时间（单位：分）
    "GoldPlanReceiptLink": "https://xxxxx.xxx.com/succeed" // 点金小票前端地址
  },

代码实现

微信支付入口，H5支付和JSAPI支付

 //微信支付
 var wechatPayRequest = new WechatPayCreateRequest {
     MemberCode = memberCode,
     OutTradeNo = orderInfo.OutOrderId,
     Body = orderInfo.ProductName,
     TotalFee = (int)(orderInfo.OrderAmount * 100),
     CallbackUrl = $"{_apiUrlConfigOption.NotifyUrl}/api/Cashier/wechatPayCallback",
     ReturnUrl = request.ReturnUrl,
     OpenId = request.OpenId,
     PayType = request.PayType,
     SubAppId = request.SubAppId,
 };
 if (request.PayType == 20) {
     // 微信h5页面
     wechatPayRequest.ReturnUrl += "?out_trade_no=" + orderInfo.OutOrderId;
 }
 _logger.LogInformation($"微信支付，调服务层基础服务接口，入参：{wechatPayRequest.ToJson()}");
 var rsWechat = request.PayType == 20
     ? await _partnerPaymentService.WechatH5PayCreate(wechatPayRequest)
     : await _partnerPaymentService.WechatJsApiPayCreate(wechatPayRequest);
 _logger.LogInformation($"微信支付，调服务层基础服务接口，结果：{rsWechat?.ToJson()}");
 if (rsWechat == null || rsWechat.Code != "0") {
     return (false, rsWechat?.Message ?? "微信支付失败");
 }
 return (true, rsWechat.Data);

PartnerPaymentService.cs 服务商支付模式核心代码

    /// <summary>
    /// 服务商模式支付
    /// </summary>
    public class PartnerPaymentService : IPartnerPaymentService
    {
        /// <summary>
        /// 实体映射
        /// </summary>
        protected IMapper _mapper;

        private readonly ILogger _logger;
        private readonly ITracer _tracer;

        private readonly IHttpContextAccessor _httpContextAccessor;

        private readonly IAliPaymentService _aliPaymentService;
        private readonly IOptions<AlipayOptions> _optionsAccessor;
        private readonly IOptions<WechatPayPartnerPayConfigOption> _wechatPayPartnerPayConfig;
        private readonly IOptions<AlipayPartnerPayConfigOption> _AlipayPartnerPayConfig;
        private readonly IProxyHttpClient _proxyHttpClient;
        private readonly AppSettings _appSettings;
        private readonly ApiUrlConfigOption _apiUrlConfigOption;

        /// <summary>
        /// 初始化一个<see cref="PartnerPaymentService"/>类型的实例
        /// </summary>
        /// <param name="mapper">实体映射</param>
        /// <param name="logger"></param>
        /// <param name="tracer"></param>
        /// <param name="aliPaymentService"></param>
        /// <param name="optionsAccessor"></param>
        /// <param name="apiEndpoints"></param>
        /// <param name="httpContextAccessor"></param>
        public PartnerPaymentService(IMapper mapper, ILogger<PartnerPaymentService> logger, ITracer tracer, IHttpContextAccessor httpContextAccessor,
            IOptions<WechatPayPartnerPayConfigOption> wechatPayPartnerPayConfig,
            IOptions<AlipayPartnerPayConfigOption> alipayPartnerPayConfig, 
            IAliPaymentService aliPaymentService,
            IOptions<AlipayOptions> optionsAccessor,
            IOptions<ApiUrlConfigOption> apiUrlConfigOption,
            IProxyHttpClient proxyHttpClient,
            AppSettings appSettings) {
            _mapper = mapper;
            _logger = logger;
            _tracer = tracer;
            _httpContextAccessor = httpContextAccessor;
            _wechatPayPartnerPayConfig = wechatPayPartnerPayConfig;
            _AlipayPartnerPayConfig = alipayPartnerPayConfig;
            _aliPaymentService = aliPaymentService;
            _optionsAccessor = optionsAccessor;
            _proxyHttpClient = proxyHttpClient;
            _appSettings = appSettings;
            _apiUrlConfigOption = apiUrlConfigOption.Value;
        }
        #region 微信
        /// <summary>
        /// 微信h5支付
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResponse<string>> WechatH5PayCreate(WechatPayCreateRequest request) {
            _logger.LogInformation($"微信h5支付，入参：{request.ToJson()}");

            var payConfig = await GetWechatPayConfig("WechatPayPartnerPay", request.MemberCode);

            /* 平台证书管理器，具体用法请参见文档 */
            var certManager = new InMemoryCertificateManager();
            /* 仅列出必须配置项。也包含一些诸如超时时间、UserAgent 等的配置项 */
            var options = new WechatTenpayClientOptions() {
                MerchantId = payConfig.MerchantId,
                MerchantV3Secret = payConfig.MerchantV3Secret,
                MerchantCertSerialNumber = payConfig.MerchantCertSerialNumber,
                MerchantCertPrivateKey = payConfig.MerchantCertPrivateKey,
                CertificateManager = certManager
            };
            var client = new WechatTenpayClient(options);

            var ip = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
            if (ip == "127.0.0.1") {
                string hostName = Dns.GetHostName();
                IPHostEntry iPHostEntry = Dns.GetHostEntry(hostName);
                var addressV = iPHostEntry.AddressList.FirstOrDefault(q => q.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);//ip4地址
                ip = addressV?.ToString();
            }
            var payRequest = new CreatePayPartnerTransactionH5Request {
                AppId = payConfig.AppId,
                SubMerchantId = payConfig.SubMerchantId,

                OutTradeNumber = request.OutTradeNo,
                Description = request.Body,
                ExpireTime = DateTime.Now.AddMinutes(payConfig.PayExpireTime),
                NotifyUrl = request.CallbackUrl,
                Amount = new CreatePayPartnerTransactionH5Request.Types.Amount {
                    Total = request.TotalFee
                },
                Scene = new CreatePayPartnerTransactionH5Request.Types.Scene {
                    ClientIp = ip,
                    H5 = new CreatePayTransactionH5Request.Types.Scene.Types.H5 {
                        Type = "Wap"
                    }
                }
            };
            var response = await client.ExecuteCreatePayPartnerTransactionH5Async(payRequest);
            if (response.IsSuccessful()) {
                var redirectUrl = request.ReturnUrl;
                if (redirectUrl.Contains("%2F")) {
                    redirectUrl = HttpUtility.UrlDecode(redirectUrl);
                }

                var responseResult = $"{response.H5Url}&redirect_url={HttpUtility.UrlEncode(request.ReturnUrl)}";

                _logger.LogInformation($"微信h5支付，结果：{responseResult}");
                return ResponseResult.Execute(responseResult);
            }

            _logger.LogInformation($"微信h5支付，结果：{response.ErrorCode}_{response.ErrorMessage}");
            return new DataResponse<string> { Code = "-1", Message = response.ErrorMessage };
        }

        /// <summary>
        /// 微信JsApi支付
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResponse<string>> WechatJsApiPayCreate(WechatPayCreateRequest request) {
            _logger.LogInformation($"微信JsApi支付，入参：{request.ToJson()}");

            var (options, wechatConfig) = await GetWechatPayOptions(request.MemberCode);
            var client = new WechatTenpayClient(options);

            var payRequest = new CreatePayPartnerTransactionJsapiRequest {
                AppId = wechatConfig.AppId,
                SubMerchantId = wechatConfig.SubMerchantId,

                OutTradeNumber = request.OutTradeNo,
                Description = request.Body,
                ExpireTime = DateTime.Now.AddMinutes(wechatConfig.PayExpireTime),
                NotifyUrl = request.CallbackUrl,
                Amount = new CreatePayPartnerTransactionJsapiRequest.Types.Amount() {
                    Total = request.TotalFee
                },
                Payer = new CreatePayPartnerTransactionJsapiRequest.Types.Payer() {
                    OpenId = request.OpenId
                }
            };
            // 微信小程序支付
            if (request.PayType == 40) {
                payRequest.Payer.OpenId = null;
                payRequest.SubAppId = request.SubAppId;
                payRequest.Payer.SubOpenId = request.OpenId;
            }
            var response = await client.ExecuteCreatePayPartnerTransactionJsapiAsync(payRequest);
            if (response.IsSuccessful()) {
                IDictionary<string, string> parameter = new Dictionary<string, string>();
                if (request.PayType == 40) {
                    // https://pay.weixin.qq.com/wiki/doc/api/wxa/wxa_sl_api.php?chapter=7_7&index=5
                    // 服务商模式下应为当前调起支付小程序的appid
                    parameter = client.GenerateParametersForJsapiPayRequest(request.SubAppId, response.PrepayId);
                } else {
                    parameter = client.GenerateParametersForJsapiPayRequest(wechatConfig.AppId, response.PrepayId);
                }

                var responseResult = JsonConvert.SerializeObject(parameter);
                _logger.LogInformation($"微信JsApi支付，结果：{responseResult}");
                return ResponseResult.Execute(responseResult);
            }

            _logger.LogInformation($"微信JsApi支付，结果：{response.ErrorCode}_{response.ErrorMessage}");
            return new DataResponse<string> { Code = "-1", Message = response.ErrorMessage };
        }

        /// <summary>
        /// 微信支付查询
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResponse<PayQueryResponse>> WechatPayQuery(WechatPayQueryRequest request) {
            _logger.LogInformation($"微信支付查询，入参：{request.ToJson()}");

            var (options, wechatConfig) = await GetWechatPayOptions(request.MemberCode);
            var client = new WechatTenpayClient(options);

            var payRequest = new GetPayPartnerTransactionByOutTradeNumberRequest {
                SubMerchantId = wechatConfig.SubMerchantId,
                OutTradeNumber = request.OutTradeNo
            };
            var response = await client.ExecuteGetPayPartnerTransactionByOutTradeNumberAsync(payRequest);
            if (response.IsSuccessful()) {
                var responseResult = new PayQueryResponse {
                    TradeState = response.TradeState,
                    PayNumber = response.TransactionId
                };
                _logger.LogInformation($"微信支付查询，结果：{responseResult.ToJson()}");
                return ResponseResult.Execute(responseResult);
            }

            _logger.LogInformation($"微信支付查询，结果：{response.ErrorCode}_{response.ErrorMessage}");
            return new DataResponse<PayQueryResponse> { Code = "-1", Message = response.ErrorMessage };
        }

        /// <summary>
        /// 微信支付退款
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResponse<bool>> WechatPayRefund(WechatPayRefundRequest request) {
            _logger.LogInformation($"微信支付退款，入参：{request.ToJson()}");

            var (options, wechatConfig) = await GetWechatPayOptions(request.MemberCode);
            var client = new WechatTenpayClient(options);

            var payRequest = new CreateRefundDomesticRefundRequest {
                SubMerchantId = wechatConfig.SubMerchantId,
                OutTradeNumber = request.OutTradeNo,
                OutRefundNumber = $"{request.MemberCode}" + DateTimeOffset.Now.ToString("yyyyMMddHHmmssfff"),
                Amount = new CreateRefundDomesticRefundRequest.Types.Amount() {
                    Total = request.TotalFee,
                    Refund = request.RefundFee
                },
                //Reason = request.RefundDesc
            };
            var response = await client.ExecuteCreateRefundDomesticRefundAsync(payRequest);
            if (response.IsSuccessful()) {
                var responseResult = response.Status;
                _logger.LogInformation($"微信支付退款，结果：{responseResult}");
                return ResponseResult.Execute(true);
            }

            _logger.LogInformation($"微信支付退款，结果：{response.ErrorCode}_{response.ErrorMessage}");
            return new DataResponse<bool> { Code = "-1", Message = response.ErrorMessage };
        }

        /// <summary>
        /// 获得微信公众号静默登录后的openid
        /// </summary>
        /// <returns></returns>
        public async Task<DataResponse<string>> GetWechatOpenId(GetWechatOpenIdRequest request) {
            _logger.LogInformation($"获得得微信公众号静默登录后的openid流程开始");
            try {
                _logger.LogInformation($"获得得微信公众号静默登录后的openid，入参：{request.ToJson()}");
                var payConfig = await this.GetWechatPayConfig("WechatPayPartnerPay");
                var openId = string.Empty;
                //从微信接口获得opeanId
                var url =
                    $"https://api.weixin.qq.com/sns/oauth2/access_token?appid={payConfig.MerchantAppId}&secret={payConfig.MerchantAppSecret}&code={request.Code}&grant_type=authorization_code";

                var proxyHttpClient = _proxyHttpClient.Create(url, HttpMethod.Get);
                var rs = await proxyHttpClient.SendAsString(false);
                _logger.LogInformation($"获得得微信公众号静默登录后的openid，调微信获取结果：{rs?.ToJson()}");

                if (rs.Contains("openid")) {
                    var callData = rs.ToObject<GetWechatOpenIdModel>();
                    openId = callData.Openid;
                }
                _logger.LogInformation($"获得得微信公众号静默登录后的openid，获取的opeanId为：{openId}");
                if (string.IsNullOrWhiteSpace(openId)) {
                    return ResponseResult.Execute(string.Empty, "-1", "没有获取到opeanId");
                }

                return ResponseResult.Execute(openId);
            } catch (Exception e) {
                _logger.LogInformation($"获得得微信公众号静默登录后的openid，系统异常：{e.Message}");
                return ResponseResult.Execute(string.Empty, "-1", $"系统异常：{e.Message}");
            } finally {
                _logger.LogInformation("获得得微信公众号静默登录后的openid流程结束");
            }
        }
        #endregion

        #region 获取支付配置

        /// <summary>
        /// 支付宝服务商支付options
        /// </summary>
        /// <param name="tenantId"></param>
        /// <returns></returns>
        private async Task<(AlipayOptions, AlipayPayPartnerPayConfigModel)> GetAlipayPayOptions(string tenantId = null) {
            var payConfig = await GetAlipayPayConfig("AlipayPartnerPay", tenantId);

            var options = new AlipayOptions {
                AppId = payConfig.AppId,
                AlipayPublicKey = payConfig.AlipayPublicKey,
                AppPrivateKey = payConfig.AppPrivateKey
            };

            return (options, payConfig);
        }

        /// <summary>
        /// 微信服务商支付options
        /// </summary>
        /// <param name="tenantId"></param>
        /// <returns></returns>
        private async Task<(WechatTenpayClientOptions, WechatPayPartnerPayConfigModel)> GetWechatPayOptions(string tenantId = null) {
            var payConfig = await GetWechatPayConfig("WechatPayPartnerPay", tenantId);

            /* 平台证书管理器，具体用法请参见文档 */
            var certManager = new InMemoryCertificateManager();
            /* 仅列出必须配置项。也包含一些诸如超时时间、UserAgent 等的配置项 */
            var options = new WechatTenpayClientOptions() {
                MerchantId = payConfig.MerchantId,
                MerchantV3Secret = payConfig.MerchantV3Secret,
                MerchantCertSerialNumber = payConfig.MerchantCertSerialNumber,
                MerchantCertPrivateKey = payConfig.MerchantCertPrivateKey,
                CertificateManager = certManager
            };

            return (options, payConfig);
        }
        /// <summary>
        /// 获取微信支付配置
        /// </summary>
        /// <param name="parameterCode">系统配置名称</param>
        /// <param name="memberCode">租户编号</param>
        /// <returns></returns>
        public async Task<WechatPayPartnerPayConfigModel> GetWechatPayConfig(string parameterCode, string memberCode = null) {
            var payConfig = new WechatPayPartnerPayConfigModel {
                AppId = _wechatPayPartnerPayConfig.Value.AppId,
                MerchantId = _wechatPayPartnerPayConfig.Value.MerchantId,
                MerchantV3Secret = _wechatPayPartnerPayConfig.Value.MerchantV3Secret,
                MerchantCertSerialNumber = _wechatPayPartnerPayConfig.Value.MerchantCertSerialNumber,
                MerchantCertPrivateKey = _wechatPayPartnerPayConfig.Value.MerchantCertPrivateKey,
                MerchantAppId = _wechatPayPartnerPayConfig.Value.MerchantAppId,
                MerchantAppSecret = _wechatPayPartnerPayConfig.Value.MerchantAppSecret,
                PayExpireTime = _wechatPayPartnerPayConfig.Value.PayExpireTime,
                GoldPlanReceiptLink = _wechatPayPartnerPayConfig.Value.GoldPlanReceiptLink,
            };

            if (!string.IsNullOrWhiteSpace(memberCode)) {
                payConfig.SubMerchantId = "******"; // 子商户号
            }

            return payConfig;
        }
        #endregion
    }

WechatPaymentService.cs底层微信支付核心代码

using System;
using System.Threading.Tasks;
using Essensoft.AspNetCore.Payment.WeChatPay;
using Essensoft.AspNetCore.Payment.WeChatPay.Request;
using Essensoft.AspNetCore.Payment.WeChatPay.Response;
using ICH.Util.Extension;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using Payment.WeChatPay.Model;

namespace Payment.WeChatPay
{
    public class WechatPaymentService: IWechatPaymentService
    {
        private readonly IWeChatPayClient _client ;
        public IOptions<WeChatPayOptions> OptionsAccessor { get; set; }
        private readonly ILogger _logger;

        public WechatPaymentService(IOptions<WeChatPayOptions> optionsAccessor, ILogger<WechatPaymentService> logger, IWeChatPayClient client)
        {
            OptionsAccessor = optionsAccessor;
            _logger = logger;
            _client = client;
        }

        public async Task<WeChatPayUnifiedOrderResponse> H5Pay(WeChatPayH5PayModel model)
        {
            _logger.LogInformation($"微信H5支付入参:{model.ToJson()}");

            var request = new WeChatPayUnifiedOrderRequest()
            {
                Body = model.Body,
                OutTradeNo = model.OutTradeNo,
                TotalFee = model.TotalFee,
                SpBillCreateIp = model.SpbillCreateIp,
                NotifyUrl = model.NotifyUrl,
                Attach = model.Attach,
                TradeType = "MWEB",
                TimeStart = DateTime.Now.ToString("yyyyMMddHHmmss"),
                TimeExpire = DateTime.Now.AddMinutes(15).ToString("yyyyMMddHHmmss")
            };
            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);
            _logger.LogInformation($"WeChatPayUnifiedOrderH5Pay:{response.ToJson()}");
            return response;
        }

        public async Task<WeChatPayUnifiedOrderResponse> NativePay(WeChatPayH5PayModel model)
        {
            _logger.LogInformation($"微信 Native支付入参:{model.ToJson()}");

            var request = new WeChatPayUnifiedOrderRequest()
            {
                Body = model.Body,
                OutTradeNo = model.OutTradeNo,
                TotalFee = model.TotalFee,
                SpBillCreateIp = model.SpbillCreateIp,
                NotifyUrl = model.NotifyUrl,
                Attach = model.Attach,
                TradeType = "NATIVE",
                TimeStart = DateTime.Now.ToString("yyyyMMddHHmmss"),
                TimeExpire = DateTime.Now.AddMinutes(15).ToString("yyyyMMddHHmmss")
            };
            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);
            _logger.LogInformation($"WeChatPayUnifiedOrderNativePay:{response.ToJson()}");
            return response;
        }

        public async Task<string> AppPay(WeChatPayAppPayModel model)
        {
            _logger.LogInformation($"微信APP支付入参:{model.ToJson()}");

            var request = new WeChatPayUnifiedOrderRequest()
            {
                Body = model.Body,
                OutTradeNo = model.OutTradeNo,
                TotalFee = model.TotalFee,
                SpBillCreateIp = model.SpbillCreateIp,
                NotifyUrl = model.NotifyUrl,
                TradeType = "APP",
                TimeStart = DateTime.Now.ToString("yyyyMMddHHmmss"),
                TimeExpire = DateTime.Now.AddMinutes(15).ToString("yyyyMMddHHmmss")
            };
            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);

            _logger.LogInformation($"wechatAPPPayResponse:{response.ToJson()}");

            if (response.ReturnCode == "SUCCESS" && response.ResultCode == "SUCCESS")
            {
                var req = new WeChatPayAppSdkRequest()
                {
                    PrepayId = response.PrepayId,
                };
                var parameter = await _client.ExecuteAsync(req, OptionsAccessor.Value);

                return JsonConvert.SerializeObject(parameter);
            }
            return "";
        }

        public async Task<(WeChatPayUnifiedOrderResponse, string)> AppletPay(WeChatPayAppletPayModel model)
        {
            _logger.LogInformation($"微信Applet支付入参:{model.ToJson()}");

            var request = new WeChatPayUnifiedOrderRequest()
            {
                OpenId = model.OpenId,
                Body = model.Body,
                OutTradeNo = model.OutTradeNo,
                TotalFee = model.TotalFee,
                SpBillCreateIp = model.SpbillCreateIp,
                NotifyUrl = model.NotifyUrl,
                Attach = model.Attach,
                TradeType = "JSAPI",
                TimeStart = DateTime.Now.ToString("yyyyMMddHHmmss"),
                TimeExpire = DateTime.Now.AddMinutes(15).ToString("yyyyMMddHHmmss")
            };
            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);

            _logger.LogInformation($"wechatAppletPayResponse:{response.ToJson()}");

            if (response.ReturnCode == "SUCCESS" && response.ResultCode == "SUCCESS")
            {
                var req = new WeChatPayJsApiSdkRequest()
                {
                    Package = $"prepay_id={response.PrepayId}"
                };
                var parameter = await _client.ExecuteAsync(req, OptionsAccessor.Value);

                return (response, JsonConvert.SerializeObject(parameter));
            }

            return (response, string.Empty);
        }

        public async Task<(bool, WeChatPayRefundResponse)> Refund(WeChatPayRefundModel model)
        {
            _logger.LogInformation($"微信退款申请入参:{model.ToJson()}");

            var request = new WeChatPayRefundRequest()
            {
                OutRefundNo = model.OutRefundNo,
                TransactionId = model.TransactionId,
                OutTradeNo = model.OutTradeNo,
                TotalFee = model.TotalFee,
                RefundFee = model.RefundFee,
                RefundDesc = model.RefundDesc,
                NotifyUrl = model.NotifyUrl,
            };
            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);

            _logger.LogInformation($"wechatRefundResponse:{response.ToJson()}");

            return (response.ReturnCode == "SUCCESS" && response.ResultCode == "SUCCESS", response);
        }

        public async Task<WeChatPayOrderQueryResponse> Query(WeChatPayOrderQueryModel model)
        {
            var request = new WeChatPayOrderQueryRequest
            {
                TransactionId = model.TransactionId,
                OutTradeNo = model.OutTradeNo
            };

            _logger.LogInformation($"微信查询:{request.ToJson()}");

            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);

            _logger.LogInformation($"wechatQueryResponse:{response.ToJson()}");

            return response;
        }

        public async Task<WeChatPayRefundQueryResponse> RefundQuery(WeChatPayRefundQueryModel model)
        {
            var request = new WeChatPayRefundQueryRequest
            {
                RefundId = model.RefundId,
                OutRefundNo = model.OutRefundNo,
                TransactionId = model.TransactionId,
                OutTradeNo = model.OutTradeNo
            };

            _logger.LogInformation($"微信退款查询:{request.ToJson()}");

            var response = await _client.ExecuteAsync(request, OptionsAccessor.Value);

            _logger.LogInformation($"微信退款查询返回:{response.ToJson()}");

            return response;
        }
    }
}

总结

  1. 微信支付区分H5支付和JSAPI支付（微信环境打开H5页面支付）
  2. 微信H5支付，需要配置微信子商户H5支付域名地址
  3. 微信JSAPI支付，需要配置微信公众号获取得到openId
  4. 微信JSAPI支付，需要配置点金计划地址
  5. 微信支付金额单位：分
  6. 商户签约为子商户后，得到{“subMerchantId”:“******”}
Simon.m
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NetCoreSaaS:使用#SaaSKit的Asp.Net Core多租户应用程序示例
05-11
NetCoreSaaS 使用#SaaSKit的Asp.Net Core多租户应用程序示例 .Net Core 2.1支持！！！ 此应用程序已升级为支持.Net Core 2.1。 已知问题 当前不支持HTTPS重定向。 应用架构 没什么复杂的。 我遵循每个租户的独立数据库方法。 在NetCoreSaaS.Data项目中，我们具有三个不同的上下文。 SystemDbContext保存应用程序/系统级数据 CatalogDbContext保存租户级别的数据，如租户配置 TenantDbContext保存特定TenantDbContext租户的数据，如租户用户，其他租户数据 运行应用程序的步骤 如果未创建迁移文件，则创建迁移文件（但是已经在NetCoreSaaS.WebHost Data文件夹下创建了迁移文件）。 如果你想重新创建迁移后检查TempFiles的文件夹中NetCoreSa
Saas框架实例(.net)
01-24
多租户框架，.NET平台下的SaaS开发框架，附带技术文档
netCore 接入微信支付，V3服务商模式支付，分账，退款，支付回写等
02-23
1/netCore 接入微信支付，内含普通支付，微信V3支付，服务商模式 2、【普通支付，支付回写，退款，分账给个人，服务商模式支付，服务商模式支付回写，服务商模式分账给子商户，V3支付退款】 3、源码分享
微信支付--网页版-V3-(3)
Seven_cm
04-14 5853
接上篇，现在已经获取到微信的openid了，下步需要获取prepay_id。 1、继续微信支付的接口API：把必传的参数列出来： 公众账号ID appid 商户号 mch_id 随机字符串 nonce_str 签名 sign 商品描述 body 商户订单号 out_trade_no 总金额 total_fee 注意单位是分 终端IP spbill_create_ip 通知地址
微信支付v3 Wechatpay-Serial错误
qq_36437991的博客
05-17 477
微信支付v3 Wechatpay-Serial错误
SaaS系统 .netcore webapi
lgl1170479655的专栏
01-27 695
1.什么是SaaS SaaS系统，软件即服务，租户系统，相对于传统软件，SaaS不需要租户购买服务器，不需要安装，也不需要花费大量的时间和成本去维护，只需要购买使用权，租用即可 2.首先要有租户表 /// <summary> /// 租户 /// </summary> public class SysTenant { [Key] [DatabaseGenerated(DatabaseGeneratedOp
SAAS云平台搭建札记: (二) Linux Ubutu下.Net Core整套运行环境的搭建
weixin_30794851的博客
04-02 235
最近做的项目，由于预算有限，公司决定不采购Windows服务器，而采购基于Linux的服务器。 一般的VPS服务器，如果使用Windows系统，那么Windows Server2012\2016安装好后，就占用1GB的内存了；只要运行起来，2G的内存就用掉了；装上SqlServer、跑个.net，4G内存是标配，用户数量稍微多些4G内存也捉襟见肘了；分配2个VCpu，在...
weiit-saas第四篇《企业申请微信支付注意事项》
年少有为
12-11 281
微信支付申请 点击下面链接。进入下面图片页面 1：https://pay.weixin.qq.com/index.php/core/home/login?return_url=%2F 2：点击接入微信支付 3.点击注册微信支付商户号 4.用微信账户扫一扫 5.填写超级管理员信息 6.填写商户资料信息 填写完所有信息后提交。等待验证打款。验证通过后微信支付就跟自己的小程序绑定就好了。我们可以登陆微信支付后台 配置支付参数配置了。开源地址：https://gitee.com/wei-it/weiit
asp.netCore3.1微信登录
12-08
asp.netCore3.1+微信登录 WechatHelper 是主要代码。第1步：请求code（前端） 第2步：前端通过获取的code请求API获取access_token（第2步之后都是后台API写代码） 第3步：API通过access_token调用接口 第4步：获取...
.netcore 微信公众号支付
01-10
C# 微信公众号后端的支付代码，可以直接使用
.NetCore+Consul+Ocelot服务网关和服务注册与发现
05-11
《.NetCore+Consul+Ocelot：构建服务网关和服务注册与发现的实践指南》 在微服务架构中，服务网关和服务注册与发现是至关重要的组件。本示例项目".NetCore+Consul+Ocelot服务网关和服务注册与发现"为我们提供了一种...
c#/.net支付宝支付和jsapi微信支付和app微信支付项目代码（源码和整个项目已上线）
08-29
支付项目源码，本项目已上线，内容包含（支付宝支付，微信支付，微信app支付都有。并且全部通过。源码，如果需要修改webconfig文件 里面的参数都是配置参数，通过微信和支付宝申请就可以得到）
.NET Core之微信支付之公众号、H5支付详解
10-17
主要介绍了.NET Core之微信支付之公众号、H5支付篇，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
DotNetCore.SKIT.FlurlHttpClient.Wechat-main.zip
03-24
可能是全网最完整的 C# 版微信 SDK，封装全部已知的微信 API，包含微信公众平台（订阅号+服务号+小程序+小游戏+小商店+视频号）、微信开放平台、微信商户平台（微信支付+微企付）、企业微信、微信广告平台、微信智能对话开放平台等模块，可跨平台。持续随官方更新，欢迎 Star / Fork。
C#微信企业号发送消息Sample
02-22
C#开发微信企业号主动推送消息的功能,支持发送文本消息/图片/语音/视频/图文消息等. C#开发微信企业号主动推送消息的功能,支持发送文本消息/图片/语音/视频/图文消息等.
paylink:一套基于 .NET Core 开发的支付SDK集，它极大简化了API调用及通知的处理流程
04-27
Paylink 一套基于 .NET Core 开发的支付SDK集，它极大简化了API调用及通知的处理流程。 Paylink NuGet 包 Package NuGet Downloads TargetFrameworks Essensoft.Paylink.Security Payment NuGet 包 后续不再维护 Payment 包，请迁移至 Paylink 包。 Package NuGet Downloads Essensoft.AspNetCore.Payment.Alipay Essensoft.AspNetCore.Payment.WeChatPay Essensoft.AspNetCore.Payment.Security 开发环境 Windows 10 Visual Studio 2019 16.9 .NET 5.0 运行环境 .NET Core 3.1 .NET 5 使
微信支付服务商接入指引
03-29
微信支付服务商接入指引 本文主要针对服务商下特约商户的小程序支付进行讲解。（扫码支付， h5支付大致流程都差不多，了解了小程序支付能够很快接入其他支付类型） 说明：本文中的支付都是指在服务商模式下 支付主体...
支付宝服务商模式下的支付开发
热门推荐
tm7796的专栏
03-26 1万+
微信的服务商模式开发，文档有很明确的说明，也有详细的开发文档，以及操作步骤。其实支付宝也是支付服务商模式的，只是比较影藏，今天在这里梳理一下。 一、如何选择支付类型？？ 在实现支付宝支付的时候，我们要先选择一种支付方式，这里和微信是一样的。 一般的作为后台开发者，我们首选手机网站支付，因为这个不仅是H5页面可以发起支付，以后也可以嵌套在APP里面，这样APP就不用二次开发了。 ...
探索ASP.NET Core构建SaaS应用的卓越资源库
最新发布
gitblog_00016的博客
05-28 337
探索ASP.NET Core构建SaaS应用的卓越资源库 项目地址:https://gitcode.com/bharatdwarkani/awesome-libraries-to-build-sass-application-dotnet-core 在这个高度竞争的技术环境中，高效且灵活的软件开发框架对于构建成功的SaaS应用至关重要。今天，我们向您推荐一个宝藏级别的开源项目——一个精心策划的AS...
linux .netcore微信支付v3
11-07
Linux .Net Core 微信支付V3 是一种在Linux操作系统上使用.Net Core框架实现微信支付的解决方案。 首先，Linux是一个开源的操作系统，因此可以在其上部署.Net Core框架来开发和运行应用程序。Net Core框架是微软...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值