tnblog
首页
视频
资源
登录
原

.net6开发企业微信小程序支付流程

2210人阅读 2024/4/11 15:21 总访问：3663696 评论：0 收藏：1 手机
分类: .net后台框架

企业微信小程序支付流程

注册微信公众号


首先通过 https://mp.weixin.qq.com/ 链接进行企业级的小程序注册。


然后打开自己的邮箱，点击收到的邮件的链接进行继续注册。
需要填写如下信息：

  • 实体类型
  • 公司类型
  • 公司名称
  • 营业执照注册号
  • 身份证上的管理员姓名
  • 身份证上号码
  • 管理员的手机号码
  • 短信验证码
  • 小程序的付费验证300元


通过这些还点击继续，这里我就不继续了。
我已经注册好了

申请微信支付商户


我们登录好后点击微信支付—>接入微信支付—>点击申请接入（也就是这里：https://pay.weixin.qq.com/index.php/core/home/login ）


点击成为微信支付商户号


然后就开始填写商户信息，主要有下面：

  • 姓名
  • 手机号
  • 法人
  • 营业执照
  • 企业银行卡


这个只要慢慢弄一步步弄就好了。
然后关联我们的APP ID


也就是我们小程序中的AppID，复制到这里并进行提交就可以了。

开发配置


通过小程序登录后 https://mp.weixin.qq.com/ ，找到开发配置


1.需要APPID
2.生成AppSecret
3.配置服务器合法域名（前提服务器有证书，并且域名可访问）
4.添加业务域名（添加时，通过保存微信提供的txt）
5.添加消息推送（获取token和EncodingAESKey，如果提交时有系统错误就算了，这个不太重要）
6.查看商户号https://pay.weixin.qq.com/index.php/extend/pay_setting
7.开通申请API证书和APIv3密钥https://pay.weixin.qq.com/index.php/core/cert/api_cert#/

主要开通证书的时候，具体可以看官网的流程：https://kf.qq.com/faq/161222NneAJf161222U7fARv.html （证书重要的在于证书序列号，和privatekey）
开通APIv3密钥的时候可以查看这个教程：https://kf.qq.com/faq/180830E36vyQ180830AZFZvu.html

创建项目


创建一个.net6的项目，添加相关的包。

  1. <ItemGroup>
  2.   <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
  3.   <PackageReference Include="Autofac" Version="8.0.0" />
  4.   <PackageReference Include="Autofac.Extensions.DependencyInjection" Version="9.0.0" />
  5.   <PackageReference Include="SKIT.FlurlHttpClient.Wechat.TenpayV3" Version="3.1.0" />
  6.   <PackageReference Include="SKIT.FlurlHttpClient.Wechat.Api" Version="3.0.0" />
  7.   <PackageReference Include="NMemory" Version="3.1.6" />
  8.   <PackageReference Include="DistributedLock.Core" Version="1.0.6" />
  9.   <PackageReference Include="DistributedLock.FileSystem" Version="1.0.2" />
  10. </ItemGroup>


在appsettings.json添加相关配置。

  1. {
  2.   "Logging": {
  3.     "LogLevel": {
  4.       "Default": "Information",
  5.       "Microsoft.AspNetCore": "Warning"
  6.     }
  7.   },
  8.   "AllowedHosts": "*",
  10.   "TenpayOptions": {
  11.     "Merchants": [
  12.       {
  13.         "MerchantId": "商户号",
  14.         "SecretV3": "APIv3密钥",
  15.         "CertificateSerialNumber": "微信API证书的序列号",
  16.         "CertificatePrivateKey": "微信API证书的apiclient_key.pem文件"
  17.       }
  18.     ],
  19.     "SucceedNotifyUrl": "https:/你的域名/api/order/ReceiveSucceedMessage",
  20.     "FailNotifyUrl": "https://你的域名/api/order/RefundSucceedMessage"
  21.   },
  22.   "WechatOptions": {
  23.     "Accounts": [
  24.       {
  25.         "AppId": "企业微信的AppID",
  26.         "AppSecret": "企业微信的AppSecret"
  27.       }
  28.     ],
  29.     "CallbackEncodingAESKey": "企业微信的消息推送EncodingAESKey",
  30.     "CallbackToken": "企业微信的消息推送token"
  31.   }
  32. }


接下来我们要做三件事:
1.通过openid获取AccessToken去获取用户的openid，让我们知道对谁发起支付
2.后台自动刷新相关AccessToken和支付需要的相关证书
3.创建相关控制器

刷新AccessToken


通过微信接收相关参数。

  1. namespace IPayAI.WeChat.MINIPay.OptionTenpays
  2. {
  3.     public partial class WechatOptions : IOptions<WechatOptions>
  4.     {
  5.         WechatOptions IOptions<WechatOptions>.Value => this;
  7.         public Types.WechatAccount[] Accounts { get; set; } = Array.Empty<Types.WechatAccount>();
  9.         public string CallbackEncodingAESKey { get; set; } = string.Empty;
  11.         public string CallbackToken { get; set; } = string.Empty;
  12.     }
  14.     public partial class WechatOptions
  15.     {
  16.         public static class Types
  17.         {
  18.             public class WechatAccount
  19.             {
  20.                 public string? GhId { get; set; }
  22.                 public string AppId { get; set; } = string.Empty;
  24.                 public string AppSecret { get; set; } = string.Empty;
  25.             }
  26.         }
  27.     }
  28. }
  1. namespace IPayAI.WeChat.MINIPay.OptionTenpays
  2. {
  3.     public partial class TenpayOptions : IOptions<TenpayOptions>
  4.     {
  5.         TenpayOptions IOptions<TenpayOptions>.Value => this;
  7.         public Types.WechatMerchant[] Merchants { get; set; } = Array.Empty<Types.WechatMerchant>();
  9.         public string SucceedNotifyUrl { get; set; } = string.Empty;
  10.         public string FailNotifyUrl { get; set; } = string.Empty;
  11.     }
  13.     public partial class TenpayOptions
  14.     {
  15.         public static class Types
  16.         {
  17.             public class WechatMerchant
  18.             {
  19.                 public string MerchantId { get; set; } = string.Empty;
  21.                 public string SecretV3 { get; set; } = string.Empty;
  23.                 public string CertificateSerialNumber { get; set; } = string.Empty;
  25.                 public string CertificatePrivateKey { get; set; } = string.Empty;
  26.             }
  27.         }
  28.     }
  29. }
  2. Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
  4. var builder = WebApplication
  5.     .CreateBuilder(args);
  6. // Add services to the container.
  7. builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
  9. builder.Services.AddControllers();
  11. // 注入配置项（内容见 `appsettings.json` 文件）
  12. builder.Services.AddOptions();
  13. builder.Services.Configure<TenpayOptions>(builder.Configuration.GetSection(nameof(TenpayOptions)));
  14. builder.Services.Configure<WechatOptions>(builder.Configuration.GetSection(nameof(WechatOptions)));


在Models文件夹下面创建WechatAccessTokenEntity类，用于装AccessToken的类。

  1. public class WechatAccessTokenEntity
  2. {
  3.     /// <summary>
  4.     /// 企业AppId
  5.     /// </summary>
  6.     public string AppId { get; set; } = string.Empty;
  7.     /// <summary>
  8.     /// AccessToken
  9.     /// </summary>
  10.     public string AccessToken { get; set; } = string.Empty;
  12.     public long ExpireTimestamp { get; set; }
  14.     public long UpdateTimestamp { get; set; }
  16.     public long CreateTimestamp { get; set; }
  17. }


创建分布式锁，便于获取AccessToken时进行锁住其他请求来获取AccessToken。

  1. public interface IDistributedLockFactory
  2. {
  3.     IDistributedLock Create(string lockName);
  4. }
  1. internal class DistributedLockFactory : IDistributedLockFactory
  2. {
  3.     private readonly DirectoryInfo _lockFileDirectory = new DirectoryInfo(Environment.CurrentDirectory);
  5.     public IDistributedLock Create(string lockName)
  6.     {
  7.         // NOTICE:
  8.         //   单机演示基于文件实现分布式锁，生产项目请替换成其他实现。
  10.         return new FileDistributedLock(_lockFileDirectory, lockName);
  11.     }
  12. }
  1. // 注入分布式锁
  2. builder.Services.AddSingleton<IDistributedLockFactory, DistributedLockFactory>();


写一个简单的内存仓储，用于存储WechatAccessTokenEntity。

  1. internal class GlobalDatabase
  2. {
  3.     static GlobalDatabase()
  4.     {
  5.         Database db = new Database();
  7.         TableWechatAccessTokenEntity = db.Tables.Create<Models.WechatAccessTokenEntity, string>(e => e.AppId);
  8.     }
  9.     public static Table<WechatAccessTokenEntity, string> TableWechatAccessTokenEntity { get; }
  10. }
  1. public interface IWechatAccessTokenEntityRepository : IEnumerable<Models.WechatAccessTokenEntity>
  2. {
  3.     void Insert(Models.WechatAccessTokenEntity entity);
  5.     void Update(Models.WechatAccessTokenEntity entity);
  7.     void Delete(Models.WechatAccessTokenEntity entity);
  8. }
  1. public class WechatAccessTokenEntityRepository : IWechatAccessTokenEntityRepository
  2. {
  4.     public void Insert(Models.WechatAccessTokenEntity entity)
  5.     {
  6.         entity.CreateTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
  7.         entity.UpdateTimestamp = entity.CreateTimestamp;
  8.         GlobalDatabase.TableWechatAccessTokenEntity.Insert(entity);
  9.     }
  11.     public void Update(WechatAccessTokenEntity entity)
  12.     {
  13.         entity.UpdateTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
  14.         GlobalDatabase.TableWechatAccessTokenEntity.Update(entity);
  15.     }
  17.     public void Delete(WechatAccessTokenEntity entity)
  18.     {
  19.         GlobalDatabase.TableWechatAccessTokenEntity.Delete(entity);
  20.     }
  22.     IEnumerator<WechatAccessTokenEntity> IEnumerable<Models.WechatAccessTokenEntity>.GetEnumerator()
  23.     {
  24.         return GlobalDatabase.TableWechatAccessTokenEntity.GetEnumerator();
  25.     }
  27.     IEnumerator IEnumerable.GetEnumerator()
  28.     {
  29.         return GlobalDatabase.TableWechatAccessTokenEntity.GetEnumerator();
  30.     }
  31. }
  1. // 注入仓储类
  2. builder.Services.AddSingleton<IWechatAccessTokenEntityRepository, WechatAccessTokenEntityRepository>();


创建相关微信API请求工厂接口并进行依赖注入。

  1. public interface IWechatApiClientFactory
  2. {
  3.     WechatApiClient Create(string appId);
  4. }
  1. internal partial class WechatApiClientFactory : IWechatApiClientFactory
  2. {
  3.     private readonly IHttpClientFactory _httpClientFactory;
  4.     private readonly WechatOptions _wechatOptions;
  6.     public WechatApiClientFactory(
  7.         IHttpClientFactory httpClientFactory,
  8.         IOptions<WechatOptions> wechatOptions)
  9.     {
  10.         _httpClientFactory = httpClientFactory;
  11.         _wechatOptions = wechatOptions.Value;
  12.     }
  14.     public WechatApiClient Create(string appId)
  15.     {
  16.         // NOTICE:
  17.         //   这里的工厂方法是为了演示多租户而存在的，可根据 AppId 生成不同的 API 客户端。
  18.         //   如果你的项目只存在唯一一个租户，那么直接注入 `WechatApiClient` 即可。
  20.         var wechatAccountOptions = _wechatOptions.Accounts?.FirstOrDefault(e => string.Equals(appId, e.AppId));
  21.         if (wechatAccountOptions == null)
  22.             throw new Exception("未在配置项中找到该 AppId 对应的微信账号。");
  24.         var wechatApiClientOptions = new WechatApiClientOptions()
  25.         {
  26.             AppId = wechatAccountOptions.AppId,
  27.             AppSecret = wechatAccountOptions.AppSecret,
  28.             PushEncodingAESKey = _wechatOptions.CallbackEncodingAESKey,
  29.             PushToken = _wechatOptions.CallbackToken
  30.         };
  31.         var wechatApiClient = WechatApiClientBuilder.Create(wechatApiClientOptions)
  32.             .UseHttpClient(_httpClientFactory.CreateClient(), disposeClient: false)
  33.             .Build();
  34.         return wechatApiClient;
  35.     }
  36. }
  1. // 注入工厂 HTTP 客户端
  2. builder.Services.AddHttpClient();
  3. builder.Services.AddSingleton<Services.HttpClients.IWechatApiClientFactory, Services.HttpClients.Implements.WechatApiClientFactory>();


自动创建后台刷新AccessToken的服务

  1. internal class WechatAccessTokenRefreshingBackgroundService : BackgroundService
  2. {
  3.     private readonly ILogger _logger;
  4.     private readonly WechatOptions _wechatOptions;
  5.     private readonly DistributedLock.IDistributedLockFactory _distributedLockFactory;
  6.     private readonly HttpClients.IWechatApiClientFactory _wechatApiClientFactory;
  7.     private readonly Repositories.IWechatAccessTokenEntityRepository _wechatAccessTokenEntityRepository;
  9.     public WechatAccessTokenRefreshingBackgroundService(
  10.         ILoggerFactory loggerFactory,
  11.         IOptions<WechatOptions> wechatOptions,
  12.         DistributedLock.IDistributedLockFactory distributedLockFactory,
  13.         HttpClients.IWechatApiClientFactory wechatApiClientFactory,
  14.         Repositories.IWechatAccessTokenEntityRepository wechatAccessTokenEntityRepository)
  15.     {
  16.         _logger = loggerFactory.CreateLogger(GetType());
  17.         _wechatOptions = wechatOptions.Value;
  18.         _distributedLockFactory = distributedLockFactory;
  19.         _wechatApiClientFactory = wechatApiClientFactory;
  20.         _wechatAccessTokenEntityRepository = wechatAccessTokenEntityRepository;
  21.     }
  23.     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
  24.     {
  25.         while (!stoppingToken.IsCancellationRequested)
  26.         {
  27.             IList<Task> tasks = new List<Task>();
  28.             foreach (var wechatAccount in _wechatOptions.Accounts)
  29.             {
  30.                 Task task = TryRefreshWechatAccessTokenAsync(wechatAccount.AppId, stoppingToken);
  31.                 tasks.Add(task);
  32.             }
  34.             await Task.WhenAll(tasks);
  35.             await Task.Delay(1 * 60 * 1000); // 每隔 1 分钟轮询刷新
  36.         }
  37.     }
  39.     private async Task TryRefreshWechatAccessTokenAsync(string appId, CancellationToken cancellationToken = default)
  40.     {
  41.         if (string.IsNullOrEmpty(appId))
  42.             return; // 无效参数
  44.         var entity = _wechatAccessTokenEntityRepository.FirstOrDefault(e => e.AppId == appId);
  45.         if (entity?.ExpireTimestamp > DateTimeOffset.Now.ToUnixTimeSeconds())
  46.             return; // AccessToken 未过期
  48.         var locker = _distributedLockFactory.Create("accessToken:" + appId);
  49.         using var lockHandler = await locker.TryAcquireAsync(TimeSpan.FromSeconds(15), cancellationToken);
  50.         if (lockHandler == null)
  51.             return; // 未取得锁
  53.         var client = _wechatApiClientFactory.Create(appId);
  54.         var request = new CgibinTokenRequest();
  55.         var response = await client.ExecuteCgibinTokenAsync(request, cancellationToken);
  56.         if (!response.IsSuccessful())
  57.         {
  58.             _logger.LogWarning(
  59.                 "刷新 AppId 为 {0} 微信 AccessToken 失败（状态码：{1}，错误代码：{2}，错误描述：{3}）。",
  60.                 appId, response.GetRawStatus(), response.ErrorCode, response.ErrorMessage
  61.             );
  62.             return; // 请求失败
  63.         }
  65.         long nextExpireTimestamp = DateTimeOffset.Now
  66.             .AddSeconds(response.ExpiresIn)
  67.             .AddMinutes(-10)
  68.             .ToUnixTimeSeconds(); // 提前十分钟过期，以便于系统能及时刷新，防止因在过期临界点时出现问题
  69.         if (entity == null)
  70.         {
  71.             entity = new Models.WechatAccessTokenEntity()
  72.             {
  73.                 AppId = appId,
  74.                 AccessToken = response.AccessToken,
  75.                 ExpireTimestamp = nextExpireTimestamp
  76.             };
  77.             _wechatAccessTokenEntityRepository.Insert(entity);
  78.         }
  79.         else
  80.         {
  81.             entity.AccessToken = response.AccessToken;
  82.             entity.ExpireTimestamp = nextExpireTimestamp;
  83.             _wechatAccessTokenEntityRepository.Update(entity);
  84.         }
  86.         _logger.LogInformation("刷新 AppId 为 {0} 的微信 AccessToken 成功。", appId);
  87.     }
  88. }
  1. builder.Services.AddHostedService<Services.BackgroundServices.WechatAccessTokenRefreshingBackgroundService>();
  2. builder.Services.AddEndpointsApiExplorer();
  3. builder.Services.AddSwaggerGen();


创建获取微信用户OpenId的控制器

  1. [ApiController]
  2. [Route("api/wxuser")]
  3. public class WxUserController : ControllerBase
  4. {
  5.     private readonly ILogger _logger;
  6.     readonly IWechatApiClientFactory _httpfactory;
  7.     private readonly WechatOptions _wechatOptions;
  8.     private readonly IWechatAccessTokenEntityRepository _wechatAccessTokenEntityRepository;
  9.     public WxUserController(
  10.         ILoggerFactory loggerFactory,
  11.         IOptions<WechatOptions> wechatOptions,
  12.         IWechatApiClientFactory httpfactory,
  13.         IWechatAccessTokenEntityRepository wechatAccessTokenEntityRepository
  14.         )
  15.     {
  16.         _wechatOptions = wechatOptions.Value;
  17.         _wechatAccessTokenEntityRepository = wechatAccessTokenEntityRepository;
  18.         _httpfactory = httpfactory;
  19.         _logger = loggerFactory.CreateLogger(GetType());
  20.     }
  23.     [HttpGet("{code}")]
  24.     public async Task<IActionResult> Get(string code)
  25.     {
  26.         //读取微信支付配置文件
  27.         var tenpayAccountOptions = _wechatOptions.Accounts?.FirstOrDefault();
  28.         //创建微信支付客户端
  29.         var client = _httpfactory.Create(tenpayAccountOptions.AppId);
  30.         var entity = _wechatAccessTokenEntityRepository.FirstOrDefault(e => e.AppId == tenpayAccountOptions.AppId);
  31.         var response = await client.ExecuteSnsJsCode2SessionAsync(new SnsJsCode2SessionRequest() { JsCode = code, AccessToken = entity.AccessToken });
  32.         if (!response.IsSuccessful())
  33.         {
  34.             _logger.LogWarning(
  35.                 "获取用户基本信息失败（状态码：{0}，错误代码：{1}，错误描述：{2}）。",
  36.                 response.GetRawStatus(), response.ErrorCode, response.ErrorMessage
  37.             );
  38.         }
  40.         return new JsonResult(response);
  41.     }
  42. }

微信小程序支付与退款


创建支付类和退款类。

  1. public class CreateOrderByJsapiRequest
  2. {
  3.     /// <summary>
  4.     /// 商户号
  5.     /// </summary>
  6.     public string MerchantId { get; set; } = default!;
  7.     /// <summary>
  8.     /// 企业appid
  9.     /// </summary>
  10.     public string AppId { get; set; } = default!;
  11.     /// <summary>
  12.     /// 用户Openid
  13.     /// </summary>
  14.     public string OpenId { get; set; } = default!;
  15.     // NOTICE:
  16.     //   单机演示时金额来源于客户端请求，生产项目请改为服务端计算生成，切勿依赖客户端提供的金额结果。
  17.     public int Amount { get; set; }
  18. }
  1. public class CreateRefundRequest
  2. {
  3.     /// <summary>
  4.     /// 商户号
  5.     /// </summary>
  6.     public string MerchantId { get; set; } = default!;
  7.     /// <summary>
  8.     /// 订单号，商家自定义的订单号
  9.     /// </summary>
  10.     public string TransactionId { get; set; } = default!;
  11.     // NOTICE:
  12.     //   单机演示时金额来源于客户端请求，生产项目请改为服务端计算生成，切勿依赖客户端提供的金额结果。
  13.     public int OrderAmount { get; set; }
  14.     /// <summary>
  15.     /// 需要退还的金额
  16.     /// </summary>
  17.     public int RefundAmount { get; set; }
  18. }


创建支付需要的证书管理

  1. public interface IWechatTenpayCertificateManagerFactory
  2. {
  3.     ICertificateManager Create(string merchantId);
  4. }
  1. internal partial class WechatTenpayCertificateManagerFactory : IWechatTenpayCertificateManagerFactory
  2. {
  3.     private readonly ConcurrentDictionary<string, ICertificateManager> _dict;
  5.     public WechatTenpayCertificateManagerFactory()
  6.     {
  7.         _dict = new ConcurrentDictionary<string, ICertificateManager>();
  8.     }
  10.     public ICertificateManager Create(string merchantId)
  11.     {
  12.         return _dict.GetOrAdd(merchantId, new InMemoryCertificateManager());
  13.     }
  14. }


创建支付需要的证书请求的请求工厂类。

  1. public interface IWechatTenpayClientFactory
  2. {
  3.     WechatTenpayClient Create(string merchantId);
  4. }
  1. internal partial class WechatTenpayClientFactory : IWechatTenpayClientFactory
  2. {
  3.     private readonly IHttpClientFactory _httpClientFactory;
  4.     private readonly TenpayOptions _tenpayOptions;
  5.     private readonly IWechatTenpayCertificateManagerFactory _tenpayCertificateManagerFactory;
  7.     public WechatTenpayClientFactory(
  8.         IHttpClientFactory httpClientFactory,
  9.         IOptions<TenpayOptions> tenpayOptions,
  10.         IWechatTenpayCertificateManagerFactory tenpayCertificateManagerFactory)
  11.     {
  12.         _httpClientFactory = httpClientFactory;
  13.         _tenpayOptions = tenpayOptions.Value;
  14.         _tenpayCertificateManagerFactory = tenpayCertificateManagerFactory;
  15.     }
  17.     public WechatTenpayClient Create(string merchantId)
  18.     {
  19.         var tenpayMerchantConfig = _tenpayOptions.Merchants?.FirstOrDefault(e => string.Equals(merchantId, e.MerchantId));
  20.         if (tenpayMerchantConfig == null)
  21.             throw new Exception("未在配置项中找到该 MerchantId 对应的微信商户号。");
  23.         var wechatTenpayClientOptions = new WechatTenpayClientOptions()
  24.         {
  25.             MerchantId = tenpayMerchantConfig.MerchantId,
  26.             MerchantV3Secret = tenpayMerchantConfig.SecretV3,
  27.             MerchantCertificateSerialNumber = tenpayMerchantConfig.CertificateSerialNumber,
  28.             MerchantCertificatePrivateKey = tenpayMerchantConfig.CertificatePrivateKey,
  29.             PlatformCertificateManager = _tenpayCertificateManagerFactory.Create(tenpayMerchantConfig.MerchantId),
  30.             AutoEncryptRequestSensitiveProperty = false,
  31.             AutoDecryptResponseSensitiveProperty = false
  32.         };
  33.         var wechatTenpayClient = WechatTenpayClientBuilder.Create(wechatTenpayClientOptions)
  34.             .UseHttpClient(_httpClientFactory.CreateClient(), disposeClient: false)
  35.             .Build();
  36.         return wechatTenpayClient;
  37.     }
  38. }
  1. builder.Services.AddHostedService<Services.BackgroundServices.TenpayCertificateRefreshingBackgroundService>();


创建跨域设置

  1. public static class NetCoreExtend
  2. {
  3.     public static string corsname = "MyAllowSpecificOrigins";
  5.     public static void AddMyServiceCors(this IServiceCollection services)
  6.     {
  7.         services.AddCors(options =>
  8.         {
  9.             options.AddPolicy(name: corsname,
  10.                 builder =>
  11.                 {
  12.                     builder.AllowAnyOrigin()
  13.                            .AllowAnyHeader()
  14.                            .AllowAnyMethod();
  15.                 });
  16.         });
  17.     }
  18.     public static void UseMyServiceCors(this WebApplication app)
  19.     {
  20.         app.UseCors(corsname);
  21.     }
  22. }
  1. // 跨域设置
  2. builder.Services.AddMyServiceCors();
  3. var app = builder.Build();
  4. app.UseSwagger();
  5. app.UseSwaggerUI();
  6. app.UseMyServiceCors();
  7. app.UseHttpsRedirection();
  8. app.UseAuthorization();
  9. var s = File.ReadAllText(Path.Combine(app.Environment.ContentRootPath, "z3TAYpMYCs.txt"));
  10. // 验证业务域名
  11. app.MapGet("z3TAYpMYCs.txt",content => content.Response.WriteAsync(s));
  12. app.MapControllers();
  13. app.Run();


创建支付控制器

  1. [ApiController]
  2. [Route("api/order")]
  3. public class TenpayOrderController : ControllerBase
  4. {
  5.     private readonly ILogger _logger;
  6.     private readonly TenpayOptions _tenpayOptions;
  7.     private readonly Services.HttpClients.IWechatTenpayClientFactory _wechatTenpayClientFactory;
  9.     public TenpayOrderController(
  10.         ILoggerFactory loggerFactory,
  11.         IOptions<TenpayOptions> tenpayOptions,
  12.         Services.HttpClients.IWechatTenpayClientFactory wechatTenpayClientFactory)
  13.     {
  14.         _logger = loggerFactory.CreateLogger(GetType());
  15.         _tenpayOptions = tenpayOptions.Value;
  16.         _wechatTenpayClientFactory = wechatTenpayClientFactory;
  17.     }
  19.     /// <summary>
  20.     /// 发起订单操作
  21.     /// </summary>
  22.     /// <param name="requestModel"></param>
  23.     /// <returns></returns>
  24.     [HttpPost]
  25.     [Route("jsapi")]
  26.     public async Task<IActionResult> CreateOrderByJsapi([FromBody] Models.CreateOrderByJsapiRequest requestModel)
  27.     {
  28.         var client = _wechatTenpayClientFactory.Create(requestModel.MerchantId);
  29.         var request = new CreatePayTransactionJsapiRequest()
  30.         {
  31.             OutTradeNumber = "SAMPLE_OTN_" + DateTimeOffset.Now.ToString("yyyyMMddHHmmssfff"),
  32.             AppId = requestModel.AppId,
  33.             Description = "演示订单",
  34.             NotifyUrl = _tenpayOptions.SucceedNotifyUrl,
  35.             Amount = new CreatePayTransactionJsapiRequest.Types.Amount() { Total = requestModel.Amount },
  36.             Payer = new CreatePayTransactionJsapiRequest.Types.Payer() { OpenId = requestModel.OpenId }
  37.         };
  38.         var response = await client.ExecuteCreatePayTransactionJsapiAsync(request, cancellationToken: HttpContext.RequestAborted);
  39.         if (!response.IsSuccessful())
  40.         {
  41.             _logger.LogWarning(
  42.                 "JSAPI 下单失败（状态码：{0}，错误代码：{1}，错误描述：{2}）。",
  43.                 response.GetRawStatus(), response.ErrorCode, response.ErrorMessage
  44.             );
  45.             return new JsonResult(response);
  46.         }
  47.         //传入小程序的appid及微信返回的预支付ID获取想要返回给前端的数据
  49.         var paramMap = client.GenerateParametersForJsapiPayRequest(request.AppId, response.PrepayId);
  50.         return Ok(new { orderrequest = request, wxparam = paramMap });
  51.     }
  53.     /// <summary>
  54.     /// 查询订单的支付状态根据支付单号查询
  55.     /// </summary>
  56.     /// <returns></returns>
  57.     [HttpGet("{OutTradeNumber}")]
  58.     public async Task<IActionResult> QueryDisposeOrderAlipayState(string OutTradeNumber)
  59.     {
  60.         //读取微信支付配置文件
  61.         var tenpayAccountOptions = _tenpayOptions.Merchants?.FirstOrDefault();
  62.         //创建微信支付客户端
  63.         var client = _wechatTenpayClientFactory.Create(tenpayAccountOptions.MerchantId);
  64.         //创建请求数据
  65.         var request = new GetPayTransactionByOutTradeNumberRequest();
  66.         request.MerchantId = tenpayAccountOptions.MerchantId;//这里是商户号
  67.         request.OutTradeNumber = OutTradeNumber;
  68.         //发起请求
  69.         var response = await client.ExecuteGetPayTransactionByOutTradeNumberAsync(request);
  70.         if (response.IsSuccessful())
  71.         {
  72.             var eventType = response.TradeState?.ToUpper();
  73.             //当支付支付成功
  74.             if (eventType == "SUCCESS")
  75.             {
  76.                 //处理内部业务
  77.                 //微信支付订单号
  78.                 var payno = response.TransactionId;
  79.                 //支付时间
  80.                 var paytime = ((DateTimeOffset)response.SuccessTime).DateTime;
  81.                 _logger.LogInformation("查询到微信支付推送的订单支付成功，支付时间：{0}", ((DateTimeOffset)response.SuccessTime).DateTime);
  82.                 //实际支付金额
  83.                 var paymoney = (decimal)response.Amount.PayerTotal / 100;
  84.                 _logger.LogInformation("查询到微信支付推送的订单支付成功，支付金额 单位分：{0}", response.Amount.PayerTotal);
  85.                 return Ok("状态码：" + eventType + "，消息：" + response.TradeStateDescription);
  86.             }
  87.             else//当查询到的状态是支付不成功
  88.             {
  89.                 //处理系统内部业务
  90.                 return Ok("状态码：" + eventType + "，消息：" + response.TradeStateDescription);
  91.             }
  92.         }
  93.         else
  94.         {
  95.             return Ok("查询失败 状态码：" + response.GetRawStatus() + "，错误代码：" + response.ErrorCode + "，错误描述" + response.ErrorMessage);
  96.         }
  97.     }
  98.     /// <summary>
  99.     /// 支付成功回调接口
  100.     /// </summary>
  101.     /// <param name="dto"></param>
  102.     /// <returns></returns>
  103.     [HttpPost("ReceiveSucceedMessage")]
  104.     public async Task<IActionResult> ReceiveSucceedMessage(
  105.         [FromHeader(Name = "Wechatpay-Timestamp")] string timestamp,
  106.         [FromHeader(Name = "Wechatpay-Nonce")] string nonce,
  107.         [FromHeader(Name = "Wechatpay-Signature")] string signature,
  108.         [FromHeader(Name = "Wechatpay-Serial")] string serialNumber)
  109.     {
  110.         //读取微信支付配置文件
  111.         var tenpayAccountOptions = _tenpayOptions.Merchants?.FirstOrDefault();
  112.         using var reader = new StreamReader(Request.Body, Encoding.UTF8);
  113.         string content = await reader.ReadToEndAsync();
  114.         _logger.LogInformation("接收到微信支付推送的数据：{0}", content);
  115.         var client = _wechatTenpayClientFactory.Create(tenpayAccountOptions.MerchantId);
  116.         bool valid = client.VerifyEventSignature(
  117.            webhookTimestamp: timestamp,
  118.            webhookNonce: nonce,
  119.            webhookBody: content,
  120.            webhookSignature: signature,
  121.            webhookSerialNumber: serialNumber
  122.        );
  123.         //验证签名
  124.         if (!valid)
  125.         {
  126.             // NOTICE:
  127.             //   需提前注入 CertificateManager、并下载平台证书，才可以使用扩展方法执行验签操作。
  128.             //   请参考本示例项目 TenpayCertificateRefreshingBackgroundService 后台任务中的相关实现。
  129.             //   有关 CertificateManager 的完整介绍请参阅《开发文档 / 基础用法 / 如何验证回调通知事件签名？》。
  130.             //   后续如何解密并反序列化，请参阅《开发文档 / 基础用法 / 如何解密回调通知事件中的敏感数据？》。
  131.             _logger.LogInformation("验签失败", content);
  132.             return new JsonResult(new { code = "FAIL", message = "验签失败" });
  133.         }
  134.         //解密数据
  135.         var callbackModel = client.DeserializeEvent(content);
  136.         var eventType = callbackModel.EventType?.ToUpper();
  137.         //当支付成功
  138.         if (eventType == "TRANSACTION.SUCCESS")
  139.         {
  140.             //处理自己系统的业务
  141.             var callbackResource = client.DecryptEventResource<TransactionResource>(callbackModel);
  142.             _logger.LogInformation("接收到微信支付推送的订单支付成功通知，商户订单号：{0}", callbackResource.OutTradeNumber);
  143.             _logger.LogInformation("接收到微信支付推送的订单支付成功通知，微信支付订单号：{0}", callbackResource.TransactionId);
  144.             //订单号
  145.             var OutTradeNumber = callbackResource.OutTradeNumber;
  146.             //微信支付订单号
  147.             var Payno = callbackResource.TransactionId;
  148.             //支付时间
  149.             var Paytime = callbackResource.SuccessTime.DateTime;
  150.             _logger.LogInformation("接收到微信支付推送的订单支付成功通知，支付时间：{0}", callbackResource.SuccessTime.DateTime);
  151.             //实际支付金额
  152.             var Paymoney = (decimal)callbackResource.Amount.PayerTotal;//单位是分
  153.             _logger.LogInformation("接收到微信支付推送的订单支付成功通知，支付金额 单位分：{0}", callbackResource.Amount.PayerTotal);
  154.             return new JsonResult(new { code = "SUCCESS", message = "支付成功" });
  155.         }
  156.         else
  157.         {
  158.             // 其他情况略
  159.             _logger.LogInformation("支付回调发生严重错误eventType不等于TRANSACTION.SUCCESS：{0}", eventType);
  160.             return new JsonResult(new { code = "FAIL", message = "eventType不等于TRANSACTION.SUCCESS" });
  161.         }
  162.     }
  164.     /// <summary>
  165.     /// 退款成功回调接口
  166.     /// </summary>
  167.     /// <param name="dto"></param>
  168.     /// <returns></returns>
  169.     [HttpPost("RefundSucceedMessage")]
  170.     public async Task<IActionResult> RefundSucceedMessage(
  171.         [FromHeader(Name = "Wechatpay-Timestamp")] string timestamp,
  172.         [FromHeader(Name = "Wechatpay-Nonce")] string nonce,
  173.         [FromHeader(Name = "Wechatpay-Signature")] string signature,
  174.         [FromHeader(Name = "Wechatpay-Serial")] string serialNumber
  175.      )
  176.     {
  177.         //读取微信支付配置文件
  178.         var tenpayAccountOptions = _tenpayOptions.Merchants?.FirstOrDefault();
  179.         using var reader = new StreamReader(Request.Body, Encoding.UTF8);
  180.         string content = await reader.ReadToEndAsync();
  181.         _logger.LogInformation("接收到微信支付推送的退款通知数据：{0}", content);
  182.         var client = _wechatTenpayClientFactory.Create(tenpayAccountOptions.MerchantId);
  183.         bool valid = client.VerifyEventSignature(
  184.            webhookTimestamp: timestamp,
  185.            webhookNonce: nonce,
  186.            webhookBody: content,
  187.            webhookSignature: signature,
  188.            webhookSerialNumber: serialNumber
  189.        );
  190.         //验证签名
  191.         if (!valid)
  192.         {
  193.             // NOTICE:
  194.             //   需提前注入 CertificateManager、并下载平台证书，才可以使用扩展方法执行验签操作。
  195.             //   请参考本示例项目 TenpayCertificateRefreshingBackgroundService 后台任务中的相关实现。
  196.             //   有关 CertificateManager 的完整介绍请参阅《开发文档 / 基础用法 / 如何验证回调通知事件签名？》。
  197.             //   后续如何解密并反序列化，请参阅《开发文档 / 基础用法 / 如何解密回调通知事件中的敏感数据？》。
  198.             _logger.LogInformation("验签失败", content);
  199.             return new JsonResult(new { code = "FAIL", message = "验签失败" });
  200.         }
  201.         var callbackModel = client.DeserializeEvent(content);
  203.         var eventType = callbackModel.EventType?.ToUpper();
  204.         //解密数据
  205.         var callbackResource = client.DecryptEventResource<RefundResource>(callbackModel);
  206.         //退款成功通知
  207.         if (eventType == "REFUND.SUCCESS")
  208.         {
  209.             //获取状态码
  210.             var State = callbackResource.RefundStatus?.ToUpper();
  211.             //订单号
  212.             var OrderId = long.Parse(callbackResource.OutTradeNumber);
  213.             //退款单号
  214.             var OrderRefId = long.Parse(callbackResource.OutRefundNumber);
  215.             //微信支付的退款单号
  216.             var WxOrderRefId = callbackResource.RefundId;
  217.             //当退款成功
  218.             if (State == "SUCCESS")
  219.             {
  220.                 //处理自己系统内部业务
  221.                 //退款成功时间
  222.                 var SuccessTime = ((DateTimeOffset)callbackResource.SuccessTime).DateTime;
  223.                 //退款成功金额 单位分
  224.                 var Refund = (decimal)callbackResource.Amount.Refund;
  225.                 _logger.LogInformation("退款成功通知：{0}", callbackResource);
  226.                 return new JsonResult(new { code = "SUCCESS", message = "成功" });
  227.             }
  228.             else
  229.             {
  230.                 //当不成功的时候处理业务
  231.                 _logger.LogInformation("退款成功通知：{0}", callbackResource);
  232.                 return new JsonResult(new { code = "SUCCESS", message = "成功" });
  233.             }
  234.         }
  235.         else//其他情况重新查询退款单
  236.         {
  237.             //其他情况自己处理内部系统业务
  238.             return new JsonResult(new { code = "SUCCESS", message = "成功" });
  239.         }
  240.     }
  242.     [HttpPost]
  243.     [Route("getconfig")]
  244.     public async Task<IActionResult> GetConfig()
  245.     {
  246.         return Ok(_tenpayOptions);
  247.     }
  248. }


创建退款控制器

  1. [ApiController]
  2. [Route("api/refund")]
  3. public class TenpayRefundController : ControllerBase
  4. {
  5.     private readonly ILogger _logger;
  6.     private readonly TenpayOptions _tenpayOptions;
  7.     private readonly Services.HttpClients.IWechatTenpayClientFactory _wechatTenpayClientFactory;
  9.     public TenpayRefundController(
  10.         ILoggerFactory loggerFactory,
  11.         IOptions<TenpayOptions> tenpayOptions,
  12.         Services.HttpClients.IWechatTenpayClientFactory wechatTenpayClientFactory)
  13.     {
  14.         _logger = loggerFactory.CreateLogger(GetType());
  15.         _tenpayOptions = tenpayOptions.Value;
  16.         _wechatTenpayClientFactory = wechatTenpayClientFactory;
  17.     }
  19.     [HttpPost]
  20.     [Route("")]
  21.     public async Task<IActionResult> CreateRefund([FromBody] Models.CreateRefundRequest requestModel)
  22.     {
  23.         var client = _wechatTenpayClientFactory.Create(requestModel.MerchantId);
  24.         var request = new CreateRefundDomesticRefundRequest()
  25.         {
  26.             // TransactionId = requestModel.TransactionId,
  27.             OutTradeNumber = requestModel.TransactionId,
  28.             OutRefundNumber = "SAMPLE_ORN_" + DateTimeOffset.Now.ToString("yyyyMMddHHmmssfff"),
  29.             Amount = new CreateRefundDomesticRefundRequest.Types.Amount()
  30.             {
  31.                 Total = requestModel.OrderAmount,
  32.                 Refund = requestModel.RefundAmount
  33.             },
  34.             Reason = "示例退款",
  35.             NotifyUrl = _tenpayOptions.FailNotifyUrl
  36.         };
  37.         var response = await client.ExecuteCreateRefundDomesticRefundAsync(request, cancellationToken: HttpContext.RequestAborted);
  38.         if (!response.IsSuccessful())
  39.         {
  40.             _logger.LogWarning(
  41.                 "申请退款失败（状态码：{0}，错误代码：{1}，错误描述：{2}）。",
  42.                 response.GetRawStatus(), response.ErrorCode, response.ErrorMessage
  43.             );
  44.         }
  46.         return new JsonResult(response);
  47.     }
  48. }


创建接收通知的控制器

  1. [ApiController]
  2. [Route("api/notify")]
  3. public class TenpayNotifyController : ControllerBase
  4. {
  5.     private readonly ILogger _logger;
  6.     private readonly Services.HttpClients.IWechatTenpayClientFactory _wechatTenpayClientFactory;
  8.     public TenpayNotifyController(
  9.         ILoggerFactory loggerFactory,
  10.         Services.HttpClients.IWechatTenpayClientFactory wechatTenpayClientFactory)
  11.     {
  12.         _logger = loggerFactory.CreateLogger(GetType());
  13.         _wechatTenpayClientFactory = wechatTenpayClientFactory;
  14.     }
  17.     [HttpPost]
  18.     [Route("m-{merchant_id}/message-push")]
  19.     public async Task<IActionResult> ReceiveMessage(
  20.         [FromRoute(Name = "merchant_id")] string merchantId,
  21.         [FromHeader(Name = "Wechatpay-Timestamp")] string timestamp,
  22.         [FromHeader(Name = "Wechatpay-Nonce")] string nonce,
  23.         [FromHeader(Name = "Wechatpay-Signature")] string signature,
  24.         [FromHeader(Name = "Wechatpay-Serial")] string serialNumber)
  25.     {
  26.         using var reader = new StreamReader(Request.Body, Encoding.UTF8);
  27.         string content = await reader.ReadToEndAsync();
  28.         _logger.LogInformation("接收到微信支付推送的数据：{0}", content);
  30.         var client = _wechatTenpayClientFactory.Create(merchantId);
  31.         bool valid = client.VerifyEventSignature(
  32.             webhookTimestamp: timestamp,
  33.             webhookNonce: nonce,
  34.             webhookBody: content,
  35.             webhookSignature: signature,
  36.             webhookSerialNumber: serialNumber
  37.         );
  38.         if (!valid)
  39.         {
  40.             // NOTICE:
  41.             //   需提前注入 CertificateManager、并下载平台证书，才可以使用扩展方法执行验签操作。
  42.             //   请参考本示例项目 TenpayCertificateRefreshingBackgroundService 后台任务中的相关实现。
  43.             //   有关 CertificateManager 的完整介绍请参阅《开发文档 / 基础用法 / 如何验证回调通知事件签名？》。
  44.             //   后续如何解密并反序列化，请参阅《开发文档 / 基础用法 / 如何解密回调通知事件中的敏感数据？》。
  46.             return new JsonResult(new { code = "FAIL", message = "验签失败" });
  47.         }
  49.         var callbackModel = client.DeserializeEvent(content);
  50.         var eventType = callbackModel.EventType?.ToUpper();
  51.         switch (eventType)
  52.         {
  53.             case "TRANSACTION.SUCCESS":
  54.                 {
  55.                     var callbackResource = client.DecryptEventResource<SKIT.FlurlHttpClient.Wechat.TenpayV3.Events.TransactionResource>(callbackModel);
  56.                     _logger.LogInformation("接收到微信支付推送的订单支付成功通知，商户订单号：{0}", callbackResource.OutTradeNumber);
  57.                     // 后续处理略
  58.                 }
  59.                 break;
  61.             default:
  62.                 {
  63.                     // 其他情况略
  64.                 }
  65.                 break;
  66.         }
  67.         return new JsonResult(new { code = "SUCCESS", message = "成功" });
  68.     }
  69. }


可通过DockerFile进行发布与支持。

  1. FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
  2. WORKDIR /app
  3. EXPOSE 80
  5. FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
  6. WORKDIR /src
  7. COPY ["IPayAI.WeChat.MINIPay/IPayAI.WeChat.MINIPay.csproj", "IPayAI.WeChat.MINIPay/"]
  8. RUN dotnet restore "IPayAI.WeChat.MINIPay/IPayAI.WeChat.MINIPay.csproj"
  9. COPY . .
  10. WORKDIR "/src/IPayAI.WeChat.MINIPay"
  11. RUN dotnet build "IPayAI.WeChat.MINIPay.csproj" -c Release -o /app/build
  13. FROM build AS publish
  14. RUN dotnet publish "IPayAI.WeChat.MINIPay.csproj" -c Release -o /app/publish
  16. FROM base AS final
  17. WORKDIR /app
  18. COPY --from=publish /app/publish .
  19. # 设置环境变量，指定证书和密码（如果需要）
  20. ENTRYPOINT ["dotnet", "IPayAI.WeChat.MINIPay.dll"]


创建docker-compose.yml，通过docker-compose build来进行生成容器

  1. version: '3.4'
  3. services:
  4.   ipayai.wechat.minipay:
  5.     build:
  6.       context: .
  7.       dockerfile: IPayAI.WeChat.MINIPay/Dockerfile
  8.     image: 127.0.0.1:4443/ipay/ipayaiwechat_mini_pay
  9.     environment:
  10.       - ASPNETCORE_ENVIRONMENT=Development
  11.       - ASPNETCORE_Kestrel__Certificates__Default__Path=/https/certificate.pfx
  12.       - ASPNETCORE_Kestrel__Certificates__Default__Password=123456
  13.       - ASPNETCORE_URLS=http://+:80;https://+:443;
  14.     volumes:
  15.       - /home/ubuntu/aidasitop_yuming/aidasi.top.pfx:/https/certificate.pfx
  16.     ports:
  17.       - "80:80"
  18.       - "443:443"


并通过docker-compse up -d来运行代码

前端验证代码


首先在新创建的app.js，这里写入自己网站相关配置。

  1. // app.js
  2. App({
  3.   onLaunch() {
  4.   },
  5.   globalData: {
  6.       //MY_Url: "https://localhost:5001/",
  7.       MY_Url: "域名",
  8.       MY_MerchantId: "商户号",
  9.       MY_AppId: "企业Appid",
  10.       MY_Secret: "企业Secret",
  11.   }
  12. })


然后我通过我使用vant框架，所以我们需要初始化npm并安装该插件。

  1. npm init
  2. npm i @vant/weapp -S --production


安装好后在app.json中添加我们的button组件信息。

  1. "usingComponents": {
  2.   "van-button": "@vant/weapp/button/index"
  3. },


修改index.js

  1. // index.js
  3. Page({
  4.   data: {
  5.     useropenid: "",
  6.     appid: "",
  7.     secret: "",
  8.     merchantid: "",
  9.     url: "",
  10.     orderinfo: {},
  11.     orderrequestinfo: {},
  12.     orderAmount: 0,
  13.     refundAmount: 0,
  14.     paymessage: "",
  15.     refundmessage: "",
  16.   },
  17.   onLoad: function(params) {
  18.     const app = getApp();
  19.     var MY_AppId = app.globalData.MY_AppId
  20.     var MY_MerchantId = app.globalData.MY_MerchantId
  21.     var MY_Secret = app.globalData.MY_Secret
  22.     var MY_Url = app.globalData.MY_Url
  23.     this.setData({
  24.         appid: MY_AppId,
  25.         secret: MY_Secret,
  26.         merchantid: MY_MerchantId,
  27.         url: MY_Url,
  28.     })
  29.   },
  30.   sendrefund: function(event){
  31.     var data = {
  32.         MerchantId : this.data.merchantid,
  33.         TransactionId : this.data.orderrequestinfo.out_trade_no,
  34.         OrderAmount : this.data.orderAmount,
  35.         RefundAmount : this.data.refundAmount,
  36.     }
  37.     var e = this
  38.     var fullurl = this.data.url + "/api/refund"
  39.     wx.request({
  40.         url: fullurl, // 后端创建订单的接口
  41.         method: 'POST',
  42.         data,
  43.         success(res) {
  44.             e.setData({
  45.                 refundmessage: "msg: 退款成功 result:"+JSON.stringify(res)
  46.             });
  47.         },
  48.         fail(err) {
  49.             e.setData({
  50.                 refundmessage: "msg: 退款失败 result:"+JSON.stringify(err)
  51.             });
  52.         }
  53.     });
  55.   },
  56.   sendpay: function(event){
  57.     console.log("发起支付")
  58.     var openid = this.data.useropenid
  59.     var fullurl = this.data.url + "/api/order/jsapi"
  60.     console.log(fullurl)
  61.     // 金额0.01元
  62.     var amount = 1
  63.     var e = this
  64.     //前端调用后端接口创建订单并获取支付参数
  65.     wx.request({
  66.         url: fullurl, // 后端创建订单的接口
  67.         method: 'POST',
  68.         data: {
  69.             // 这些数据应根据实际情况获取
  70.             MerchantId: this.data.merchantid,
  71.             AppId: this.data.appid,
  72.             OpenId: openid,
  73.             Amount: amount // 例如，1.00元
  74.         },
  75.         success(res) {
  76.             var item = res.data.wxparam
  77.             if (item) { // 假设prepay_id在返回的data中
  78.                 // 使用返回的支付参数发起支付
  79.                 wx.requestPayment({
  80.                 ...item,
  81.                 success(payRes) {
  82.                     e.setData({
  83.                         orderinfo: item,
  84.                         orderAmount: amount,
  85.                         refundAmount: amount,
  86.                         paymessage: '支付成功',
  87.                         orderrequestinfo: res.data.orderrequest
  88.                     })
  89.                     console.log('支付成功', payRes);
  90.                 },
  91.                 fail(payErr) {
  92.                     e.setData({
  93.                         paymessage: '支付失败'
  94.                     })
  95.                     console.log('支付失败', payErr);
  96.                 }
  97.                 });
  98.             } else {
  99.                 console.log('创建订单失败', res);
  100.             }
  101.         },
  102.         fail(err) {
  103.         console.log('请求后端接口失败', err);
  104.         }
  105.     });
  107.   },
  108.   sendlogin: function(event){
  109.     console.log("发起登陆")
  110.     var e = this
  111.     wx.login({
  112.         success: function(res) {
  113.           if (res.code) {
  114.             e.setData({
  115.                 'useropenid': res.code
  116.             });
  117.             console.log("登录成功，临时登录凭证：" +e.data.useropenid);
  118.           } else {
  119.             console.log('登录失败！' + res.errMsg);
  120.           }
  121.         }
  122.       });
  123.   },
  124.   info(){
  125.     var e = this
  126.     wx.getUserInfo({
  127.       //成功后会返回
  128.       success:(res)=>{
  129.         console.log(res);
  130.         // 把你的用户信息存到一个变量中方便下面使用
  131.         let userInfo= res.userInfo
  132.         console.log("getUserInfo:",JSON.stringify(userInfo),e.data.appid,e.data.secret)
  133.         //获取openId（需要code来换取）这是用户的唯一标识符
  134.         // 获取code值
  135.         wx.login({
  136.           //成功放回
  137.           success:(res)=>{
  138.             console.log(res);
  139.             let code=res.code
  140.             console.log("getCode:",code)
  141.             // 通过code换取openId
  142.             var fullurl = this.data.url + "/api/wxuser/"+code
  143.             wx.request({
  144.               url: fullurl,
  145.               success:(res)=>{
  146.                 console.log(res);
  147.                 userInfo.openid=res.data.openid
  148.                 console.log("getOpenid:",userInfo)
  149.                 console.log(userInfo.openid);
  150.                 e.setData({
  151.                     'useropenid': res.data.openid
  152.                 });
  153.               }
  154.             })
  155.           }
  156.         })
  158.       }
  159.     })
  160.   }
  161. })


修改index.wxml文件，实现简单登陆、支付和退款功能。

  1. <van-button plain type="info" bind:tap="info">登录</van-button>
  2. <view>{{ useropenid }}</view> 
  3. <van-button plain type="info" bind:tap="sendpay">发起支付</van-button>
  4. <view style="margin: 10px;"></view>
  5. <view>TransactionId or prepay_id（商户号id）: {{ orderinfo.package }}</view>
  6. <view>OrderAmount（订单金额）:{{ orderAmount }} 分</view>
  7. <view>RefundAmount（退款金额）:{{ refundAmount }} 分</view>
  8. <view>Pay Message 支付消息:{{ paymessage }}</view>
  9. <view style="margin: 10px;"></view>
  10. <van-button plain type="info" bind:tap="sendrefund">发起退款</van-button>
  11. <view>Pay Refund 退款消息:{{ refundmessage }}</view>


欢迎加群讨论技术，1群：677373950(满了，可以加，但通过不了)，2群：656732739

评价

青春年华

2020/3/8 1:47:31

优秀

回复
这一世以无限游戏为使命！
博主信息
排名
11
文章
201
粉丝
10
评论
13
文章类别
最新文章
最新评价
docker中Sware集群与service
尘叶心繁 : 想学呀！我教你呀
一个bug让程序员走上法庭 索赔金额达400亿日元
叼着奶瓶逛酒吧 : 所以说做程序员也要懂点法律知识
.net core 塑形资源
剑轩 : 收藏收藏
映射AutoMapper
剑轩 : 好是好，这个对效率影响大不大哇,效率高不高
ASP.NET Core 服务注册生命周期
剑轩 : http://www.tnblog.net/aojiancc2/article/details/167
关于我们
ICP备案 ：渝ICP备18016597号-1
网站信息：2018-2025TNBLOG.NET
技术交流：群号656732739
联系我们：contact@tnblog.net
公网安备：50010702506256
欢迎加群
欢迎加群交流技术