package config

import (
	"os"
)

type WechatPayConfig struct {
	AppID          string // 公众账号ID
	MchID          string // 商户号
	APIv3Key       string // APIv3密钥
	CertSerialNo   string // 商户证书序列号
	PrivateKeyPath string // 商户私钥文件路径
	PublicKeyID    string // 微信支付公钥ID
	PublicKeyPath  string // 微信支付公钥文件路径
	NotifyURL      string // 支付结果回调地址
}

func LoadConfig() *WechatPayConfig {
	return &WechatPayConfig{
		AppID:          os.Getenv("WXPAY_APPID"),
		MchID:          os.Getenv("WXPAY_MCHID"),
		APIv3Key:       os.Getenv("WXPAY_APIV3_KEY"),
		CertSerialNo:   os.Getenv("WXPAY_CERT_SERIAL_NO"),
		PrivateKeyPath: os.Getenv("WXPAY_PRIVATE_KEY_PATH"),
		PublicKeyID:    os.Getenv("WXPAY_PUBLIC_KEY_ID"),
		PublicKeyPath:  os.Getenv("WXPAY_PUBLIC_KEY_PATH"),
		NotifyURL:      os.Getenv("WXPAY_NOTIFY_URL"),
	}
}

package service

import (
	"context"
	"fmt"

	"wechatpay-native-demo/config"

	"github.com/wechatpay-apiv3/wechatpay-go/core"
	"github.com/wechatpay-apiv3/wechatpay-go/core/option"
	"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/native"
	"github.com/wechatpay-apiv3/wechatpay-go/services/refunddomestic"
	"github.com/wechatpay-apiv3/wechatpay-go/utils"
)

type WechatPayService struct {
	client *core.Client
	config *config.WechatPayConfig
}

// NewWechatPayService 创建微信支付服务（使用微信支付公钥模式）
func NewWechatPayService(cfg *config.WechatPayConfig) (*WechatPayService, error) {
	// 加载商户私钥
	privateKey, err := utils.LoadPrivateKeyWithPath(cfg.PrivateKeyPath)
	if err != nil {
		return nil, fmt.Errorf("加载商户私钥失败: %v", err)
	}

	// 加载微信支付公钥（用于验签）
	wechatPayPublicKey, err := utils.LoadPublicKeyWithPath(cfg.PublicKeyPath)
	if err != nil {
		return nil, fmt.Errorf("加载微信支付公钥失败: %v", err)
	}

	// 创建商户配置（使用公钥模式）
	opts := []core.ClientOption{
		// 使用商户私钥进行请求签名，使用微信支付公钥验证响应
		option.WithWechatPayPublicKeyAuthCipher(
			cfg.MchID,          // 商户号
			cfg.CertSerialNo,   // 商户证书序列号
			privateKey,         // 商户私钥
			cfg.PublicKeyID,    // 微信支付公钥ID
			wechatPayPublicKey, // 微信支付公钥
		),
	}

	// 创建客户端
	client, err := core.NewClient(context.Background(), opts...)
	if err != nil {
		return nil, fmt.Errorf("创建微信支付客户端失败: %v", err)
	}

	return &WechatPayService{
		client: client,
		config: cfg,
	}, nil
}

// CreateNativeOrder 创建Native支付订单
func (s *WechatPayService) CreateNativeOrder(outTradeNo, description string, totalFee int64) (string, error) {
	svc := native.NativeApiService{Client: s.client}

	resp, result, err := svc.Prepay(context.Background(), native.PrepayRequest{
		Appid:       core.String(s.config.AppID),
		Mchid:       core.String(s.config.MchID),
		Description: core.String(description),
		OutTradeNo:  core.String(outTradeNo),
		NotifyUrl:   core.String(s.config.NotifyURL),
		Amount: &native.Amount{
			Total: core.Int64(totalFee),
		},
	})
	if err != nil {
		return "", fmt.Errorf("创建订单失败: %v, result: %+v", err, result)
	}

	return *resp.CodeUrl, nil
}

// QueryOrder 查询订单
func (s *WechatPayService) QueryOrder(outTradeNo string) (*payments.Transaction, error) {
	svc := native.NativeApiService{Client: s.client}

	resp, result, err := svc.QueryOrderByOutTradeNo(context.Background(), native.QueryOrderByOutTradeNoRequest{
		OutTradeNo: core.String(outTradeNo),
		Mchid:      core.String(s.config.MchID),
	})
	if err != nil {
		return nil, fmt.Errorf("查询订单失败: %v, result: %+v", err, result)
	}

	return resp, nil
}

package handler

import (
	"fmt"
	"net/http"
	"time"

	"wechatpay-native-demo/service"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

type PaymentHandler struct {
	wechatPay *service.WechatPayService
}

func NewPaymentHandler(wechatPay *service.WechatPayService) *PaymentHandler {
	return &PaymentHandler{wechatPay: wechatPay}
}

// CreateOrderRequest 创建订单请求
type CreateOrderRequest struct {
	ProductName string `json:"product_name" binding:"required"`
	Amount      int64  `json:"amount" binding:"required,min=1"` // 单位：分
}

// CreateOrderResponse 创建订单响应
type CreateOrderResponse struct {
	OrderID     string `json:"order_id"`
	CodeURL     string `json:"code_url"`
	Amount      int64  `json:"amount"`
	ProductName string `json:"product_name"`
}

// CreateOrder 创建支付订单
func (h *PaymentHandler) CreateOrder(c *gin.Context) {
	var req CreateOrderRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 生成订单号（实际项目中应使用更严谨的订单号生成策略）
	outTradeNo := fmt.Sprintf("NATIVE%s%s", time.Now().Format("20060102150405"), uuid.New().String()[:8])

	// 调用微信支付接口创建订单
	codeURL, err := h.wechatPay.CreateNativeOrder(outTradeNo, req.ProductName, req.Amount)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// 保存订单信息到数据库（实际项目中应持久化存储）
	// TODO: 保存订单到数据库

	c.JSON(http.StatusOK, CreateOrderResponse{
		OrderID:     outTradeNo,
		CodeURL:     codeURL,
		Amount:      req.Amount,
		ProductName: req.ProductName,
	})
}

// QueryOrder 查询订单状态
func (h *PaymentHandler) QueryOrder(c *gin.Context) {
	orderID := c.Param("order_id")
	// TODO: 从数据库查询订单状态

	// 调用微信支付查询接口
	resp, err := h.wechatPay.QueryOrder(orderID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": err.Error(),
		})
		return
	}

	// 构建响应
	result := gin.H{
		"order_id": orderID,
		"status":   "NOTPAY", // 默认未支付
	}

	if resp.TradeState != nil {
		result["status"] = *resp.TradeState

		// 如果支付成功，返回更多信息
		if *resp.TradeState == "SUCCESS" {
			if resp.TransactionId != nil {
				result["transaction_id"] = *resp.TransactionId
			}
			if resp.SuccessTime != nil {
				result["success_time"] = *resp.SuccessTime
			}
			if resp.Amount != nil && resp.Amount.Total != nil {
				result["total_amount"] = *resp.Amount.Total
			}
			if resp.Payer != nil && resp.Payer.Openid != nil {
				result["payer_openid"] = *resp.Payer.Openid
			}
		}
	}

	// 添加交易状态描述
	if resp.TradeStateDesc != nil {
		result["trade_state_desc"] = *resp.TradeStateDesc
	}

	c.JSON(http.StatusOK, result)
}

<body>
  <div class="container">
    <div class="header">
      <h1>微信扫码支付</h1>
      <p id="product-name">商品名称加载中...</p>
    </div>

    <div class="amount"><span>¥</span><span id="amount">0.00</span></div>

    <div class="qrcode-container">
      <div id="qrcode"></div>
    </div>

    <div class="tips">
      <p>请使用微信扫一扫扫描二维码完成支付</p>
      <p class="highlight">注意：不支持长按识别或从相册识别</p>
    </div>

    <div class="countdown" id="countdown">
      二维码有效期：<span id="timer">30:00</span>
    </div>

    <button class="refresh-btn" onclick="refreshOrder()">刷新二维码</button>

    <div id="status" class="status"></div>
  </div>

  <script>
    let orderId = "";
    let codeUrl = "";
    let checkInterval = null;
    let countdownInterval = null;
    let remainingTime = 30 * 60; // 30分钟（秒）

    // 页面加载时执行
    window.onload = function () {
      createOrder();
    };

    // 创建订单
    function createOrder() {
      const productName =
        new URLSearchParams(window.location.search).get("product") ||
        "测试商品";
      const amount =
        new URLSearchParams(window.location.search).get("amount") || 1;

      fetch("/api/order", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          product_name: productName,
          amount: parseInt(amount),
        }),
      })
        .then((response) => response.json())
        .then((data) => {
          if (data.error) {
            showStatus("error", "创建订单失败：" + data.error);
            return;
          }

          orderId = data.order_id;
          codeUrl = data.code_url;

          // 更新页面信息
          document.getElementById("product-name").textContent =
            data.product_name;
          document.getElementById("amount").textContent = (
            data.amount / 100
          ).toFixed(2);

          // 生成二维码
          generateQRCode(codeUrl);

          // 开始倒计时
          startCountdown();

          // 开始轮询查询订单状态
          startPolling();
        })
        .catch((error) => {
          showStatus("error", "网络错误：" + error.message);
        });
    }

    // 生成二维码
    function generateQRCode(url) {
      // 清空之前的二维码
      const container = document.getElementById("qrcode");
      container.innerHTML = "";

      // 生成新二维码
      new QRCode(container, {
        text: url,
        width: 256,
        height: 256,
        colorDark: "#000000",
        colorLight: "#ffffff",
        correctLevel: QRCode.CorrectLevel.M,
      });
    }

    // 开始倒计时
    function startCountdown() {
      remainingTime = 30 * 60; // 重置为30分钟

      if (countdownInterval) {
        clearInterval(countdownInterval);
      }

      countdownInterval = setInterval(function () {
        remainingTime--;

        if (remainingTime <= 0) {
          clearInterval(countdownInterval);
          document.getElementById("timer").textContent = "已过期";
          document.getElementById("countdown").style.background = "#f8d7da";
          document.getElementById("countdown").style.color = "#721c24";
          return;
        }

        const minutes = Math.floor(remainingTime / 60);
        const seconds = remainingTime % 60;
        document.getElementById("timer").textContent =
          minutes.toString().padStart(2, "0") +
          ":" +
          seconds.toString().padStart(2, "0");
      }, 1000);
    }

    // 开始轮询查询订单状态
    function startPolling() {
      if (checkInterval) {
        clearInterval(checkInterval);
      }

      // 每3秒查询一次
      checkInterval = setInterval(function () {
        checkOrderStatus();
      }, 3000);
    }

    // 查询订单状态
    function checkOrderStatus() {
      if (!orderId) return;

      fetch("/api/order/" + orderId)
        .then((response) => response.json())
        .then((data) => {
          if (data.status === "SUCCESS") {
            // 支付成功
            clearInterval(checkInterval);
            clearInterval(countdownInterval);
            showStatus("success", "支付成功！即将跳转...");

            // 2秒后跳转到成功页面
            setTimeout(function () {
              window.location.href = "/success?order_id=" + orderId;
            }, 2000);
          } else if (data.status === "CLOSED") {
            // 订单已关闭
            clearInterval(checkInterval);
            showStatus("error", "订单已关闭，请重新下单");
          }
        })
        .catch((error) => {
          console.error("查询订单状态失败:", error);
        });
    }

    // 刷新订单
    function refreshOrder() {
      clearInterval(checkInterval);
      clearInterval(countdownInterval);
      createOrder();
    }

    // 显示状态信息
    function showStatus(type, message) {
      const statusDiv = document.getElementById("status");
      statusDiv.className = "status " + type;
      statusDiv.textContent = message;
    }

    // 页面关闭时清理定时器
    window.onbeforeunload = function () {
      if (checkInterval) clearInterval(checkInterval);
      if (countdownInterval) clearInterval(countdownInterval);
    };
  </script>
</body>

package handler

import (
	"context"
	"fmt"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
	"github.com/wechatpay-apiv3/wechatpay-go/utils"
)

// NotifyHandler 支付回调处理器
type NotifyHandler struct {
	handler  *notify.Handler
	apiV3Key string
}

// NewNotifyHandler 创建支付回调处理器
func NewNotifyHandler(apiV3Key, wechatPayPublicKeyID, publicKeyPath string) (*NotifyHandler, error) {
	// 加载微信支付公钥
	wechatPayPublicKey, err := utils.LoadPublicKeyWithPath(publicKeyPath)
	if err != nil {
		return nil, fmt.Errorf("加载微信支付公钥失败: %v", err)
	}

	// 初始化 notify.Handler，使用 SDK 提供的验签方法
	handler := notify.NewNotifyHandler(
		apiV3Key,
		verifiers.NewSHA256WithRSAPubkeyVerifier(wechatPayPublicKeyID, *wechatPayPublicKey),
	)

	return &NotifyHandler{
		handler:  handler,
		apiV3Key: apiV3Key,
	}, nil
}

// PaymentNotify 支付结果回调
func (h *NotifyHandler) PaymentNotify(c *gin.Context) {
	// 使用 SDK 的 Handler 解析通知
	transaction := new(Transaction)
	notifyReq, err := h.handler.ParseNotifyRequest(context.Background(), c.Request, transaction)
	if err != nil {
		fmt.Printf("[Notify] 解析通知失败: %v\n", err)
		c.JSON(http.StatusUnauthorized, gin.H{"code": "FAIL", "message": "验签未通过，或者解密失败"})
		return
	}

	// 记录日志
	fmt.Printf("[Notify] 收到支付通知: EventType=%s, OrderID=%s\n",
		notifyReq.EventType, transaction.OutTradeNo)

	// 检查事件类型
	if notifyReq.EventType != "TRANSACTION.SUCCESS" {
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "非支付成功通知"})
		return
	}

	// 异步处理业务逻辑
	go func() {
		processPaymentSuccess(*transaction)
	}()

	// 返回成功响应
	c.Status(http.StatusNoContent)
}

// Transaction 支付通知中的订单信息
type Transaction struct {
	AppID          string `json:"appid"`
	MchID          string `json:"mchid"`
	OutTradeNo     string `json:"out_trade_no"`
	TransactionID  string `json:"transaction_id"`
	TradeType      string `json:"trade_type"`
	TradeState     string `json:"trade_state"`
	TradeStateDesc string `json:"trade_state_desc"`
	BankType       string `json:"bank_type"`
	Attach         string `json:"attach"`
	SuccessTime    string `json:"success_time"`
	Payer          struct {
		OpenID string `json:"openid"`
	} `json:"payer"`
	Amount struct {
		Total         int    `json:"total"`
		PayerTotal    int    `json:"payer_total"`
		Currency      string `json:"currency"`
		PayerCurrency string `json:"payer_currency"`
	} `json:"amount"`
}

// processPaymentSuccess 处理支付成功业务逻辑
func processPaymentSuccess(result Transaction) {
	fmt.Printf("[Process] 处理支付成功订单: %s, 微信支付订单号: %s, 支付金额: %d分\n",
		result.OutTradeNo, result.TransactionID, result.Amount.Total)

	// TODO: 实现订单状态更新、库存扣减、发货通知等业务逻辑
	// 注意：需要处理重复通知的情况（幂等性）
}

// CloseOrder 关闭订单
func (s *WechatPayService) CloseOrder(outTradeNo string) error {
    svc := native.NativeApiService{Client: s.client}

    result, err := svc.CloseOrder(context.Background(), native.CloseOrderRequest{
        OutTradeNo: core.String(outTradeNo),
        Mchid:      core.String(s.config.MchID),
    })

    if err != nil {
        return fmt.Errorf("关闭订单失败: %v, result: %+v", err, result)
    }

    return nil
}

// ApplyRefund 申请退款
func (s *WechatPayService) ApplyRefund(outTradeNo, outRefundNo string, refundFee int64, reason string) (*refund.Refund, error) {
    svc := refund.RefundsApiService{Client: s.client}

    resp, result, err := svc.Create(context.Background(), refund.CreateRequest{
        OutTradeNo:  core.String(outTradeNo),
        OutRefundNo: core.String(outRefundNo),
        Reason:      core.String(reason),
        Amount: &refund.AmountReq{
            Refund: core.Int64(refundFee),
            Total:  core.Int64(refundFee), // 原订单金额，这里简化处理
            Currency: core.String("CNY"),
        },
    })

    if err != nil {
        return nil, fmt.Errorf("申请退款失败: %v, result: %+v", err, result)
    }

    return resp, nil
}

package main

import (
	"log"
	"os"

	"wechatpay-native-demo/config"
	"wechatpay-native-demo/handler"
	"wechatpay-native-demo/service"

	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
)

func main() {
	// 加载环境变量
	if err := godotenv.Load(); err != nil {
		log.Println("未找到.env文件，使用系统环境变量")
	}

	// 加载配置
	cfg := config.LoadConfig()

	// 验证必要配置
	if cfg.AppID == "" || cfg.MchID == "" || cfg.APIv3Key == "" || cfg.PublicKeyID == "" {
		log.Fatal("缺少必要的微信支付配置，请检查环境变量")
	}

	// 创建微信支付服务
	wechatPay, err := service.NewWechatPayService(cfg)
	if err != nil {
		log.Fatalf("初始化微信支付服务失败: %v", err)
	}

	// 创建处理器
	paymentHandler := handler.NewPaymentHandler(wechatPay)
	notifyHandler, err := handler.NewNotifyHandler(cfg.APIv3Key, cfg.PublicKeyID, cfg.PublicKeyPath)
	if err != nil {
		log.Fatalf("初始化通知处理器失败: %v", err)
	}

	// 创建Gin路由
	r := gin.Default()

	// 加载HTML模板
	r.LoadHTMLGlob("templates/*")

	// 静态文件服务
	r.Static("/static", "./static")

	// 页面路由
	r.GET("/", func(c *gin.Context) {
		c.HTML(200, "index.html", nil)
	})

	r.GET("/pay", func(c *gin.Context) {
		c.HTML(200, "pay.html", nil)
	})

	r.GET("/success", func(c *gin.Context) {
		c.HTML(200, "success.html", gin.H{
			"order_id": c.Query("order_id"),
		})
	})

	// API路由
	api := r.Group("/api")
	{
		api.POST("/order", paymentHandler.CreateOrder)
		api.GET("/order/:order_id", paymentHandler.QueryOrder)
		api.POST("/notify", notifyHandler.PaymentNotify)
	}

	// 启动服务器
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("服务器启动在 http://localhost:%s", port)
	if err := r.Run(":" + port); err != nil {
		log.Fatalf("启动服务器失败: %v", err)
	}
}

<body>
  <div class="container">
    <h1>微信支付 Native支付 Demo</h1>

    <div class="products">
      <div class="product-card">
        <div class="product-image">📱</div>
        <div class="product-info">
          <div class="product-name">高级会员 1个月</div>
          <div class="product-desc">
            解锁全部高级功能，享受VIP专属服务，无限制使用所有特性。
          </div>
          <div class="product-footer">
            <div class="price"><span>¥</span>29.90</div>
            <button class="buy-btn" onclick="buy('高级会员 1个月', 2990)">
              立即购买
            </button>
          </div>
        </div>
      </div>

      <div class="product-card">
        <div class="product-image">💎</div>
        <div class="product-info">
          <div class="product-name">高级会员 1年</div>
          <div class="product-desc">
            年度会员更优惠，相当于每月仅需19.9元，节省33%。
          </div>
          <div class="product-footer">
            <div class="price"><span>¥</span>199.00</div>
            <button class="buy-btn" onclick="buy('高级会员 1年', 19900)">
              立即购买
            </button>
          </div>
        </div>
      </div>

      <div class="product-card">
        <div class="product-image">🎁</div>
        <div class="product-info">
          <div class="product-name">测试商品 0.01元</div>
          <div class="product-desc">
            用于测试支付流程，实际支付0.01元，支付后可申请退款。
          </div>
          <div class="product-footer">
            <div class="price"><span>¥</span>0.01</div>
            <button class="buy-btn" onclick="buy('测试商品', 1)">
              立即购买
            </button>
          </div>
        </div>
      </div>
    </div>
  </div>

  <script>
    function buy(productName, amount) {
      // 跳转到支付页面
      window.location.href =
        "/pay?product=" + encodeURIComponent(productName) + "&amount=" + amount;
    }
  </script>
</body>

# 微信支付配置

# 公众账号ID（服务号/小程序/移动应用的AppID）
WXPAY_APPID=wx1234567890abcdef

# 商户号
WXPAY_MCHID=1234567890

# APIv3密钥（32位字符，在商户平台-API安全设置）
WXPAY_APIV3_KEY=YourAPIv3KeyHere

# 商户证书序列号
# 获取命令：openssl x509 -in apiclient_cert.pem -noout -serial | cut -d= -f2 | tr '[:upper:]' '[:lower:]'
WXPAY_CERT_SERIAL_NO=1234567890ABCDEF1234567890ABCDEF

# 商户私钥路径
WXPAY_PRIVATE_KEY_PATH=./cert/apiclient_key.pem

# 微信支付公钥模式（2024年后新商户默认使用）
# 公钥ID在商户平台获取，格式如：PUB_KEY_ID_xxxxxxxxxxxxxxxx
# 获取路径：商户平台 → API安全 → 微信支付公钥 → 查看公钥ID
WXPAY_PUBLIC_KEY_ID=PUB_KEY_ID_xxxxxxxxxxxxxxxx
WXPAY_PUBLIC_KEY_PATH=./cert/pub_key.pem

# 在商户号上配置的Native支付回调地址（必须外网可访问）
WXPAY_NOTIFY_URL=https://yourdomain.com/api/notify

# 服务器配置
PORT=8080

openssl x509 -in ./cert/apiclient_cert.pem -noout -serial | cut -d= -f2 | tr '[:upper:]' '[:lower:]'