支付服务设计：从微信支付到打赏功能与记账

package payment

// PrepayReq 预支付请求：只暴露业务方该关心的字段
type PrepayReq struct {
    BizTradeNO  string // 业务方唯一凭证，用于去重
    Description string // 商品描述
    Amount      int64  // 金额，单位：分
}

// PrepayResp 预支付响应
type PrepayResp struct {
    CodeURL string // 微信返回的二维码链接
}

// PaymentService 支付服务接口
// 如果将来接入支付宝，可以拆成 WePayment 和 AliPayment
// 两者有公共字段可以组合 basePayment
type PaymentService interface {
    Prepay(ctx context.Context, req PrepayReq) (PrepayResp, error)
}

package payment

import (
    "context"
    "github.com/wechatpay-apiv3/wechatpay-go"
    "github.com/wechatpay-apiv3/wechatpay-go/services/payments/native"
)

// NativePaymentService 微信 native 支付实现
type NativePaymentService struct {
    client    *native.NativeApiService
    appid     string // 小程序/公众号 ID
    mchid     string // 商户号
    notifyURL string // 回调地址
    db        PaymentDAO
}

func (s *NativePaymentService) Prepay(ctx context.Context, req PrepayReq) (PrepayResp, error) {
    // 步骤 1：先初始化一条支付记录——目的是去重
    // 即便不去重，BizTradeNO 透传给微信，微信也会用它去重
    err := s.db.Insert(ctx, Payment{
        BizTradeNO: req.BizTradeNO,
        Status:     StatusInit,
        Amount:     req.Amount,
    })
    if err != nil {
        // 唯一索引冲突说明已经创建过，可以直接查询返回 code_url
        // 这里简化处理，实际要区分是重复还是真的 DB 错误
    }

    // 步骤 2：调用微信下单接口
    resp, err := s.client.Prepay(ctx, native.PrepayRequest{
        Appid:       core.String(s.appid),
        Mchid:       core.String(s.mchid),
        Description: core.String(req.Description),
        OutTradeNo:  core.String(req.BizTradeNO),
        NotifyUrl:   core.String(s.notifyURL),
        Amount: &native.Amount{
            Total:    core.Int64(req.Amount),
            Currency: core.String("CNY"),
        },
    })
    if err != nil {
        return PrepayResp{}, err
    }
    // 步骤 3：返回微信给的二维码链接
    return PrepayResp{CodeURL: *resp.CodeUrl}, nil
}

CREATE TABLE `payment` (
    `id`           BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    `biz_trade_no` VARCHAR(64) NOT NULL COMMENT '业务方唯一凭证',
    `status`       TINYINT NOT NULL COMMENT '支付状态：0初始 1成功 2失败',
    `amount`       BIGINT NOT NULL COMMENT '金额，单位分',
    `txn_id`       VARCHAR(64) DEFAULT '' COMMENT '微信支付订单号',
    `ctime`        DATETIME NOT NULL,
    `utime`        DATETIME NOT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_biz_trade_no` (`biz_trade_no`) -- 关键：唯一索引保证去重
);

package payment

import (
    "net/http"
    "github.com/wechatpay-apiv3/wechatpay-go/pkg/notify"
)

// WechatHandler 微信回调处理器
type WechatHandler struct {
    handler *notify.Handler
    svc     *NativePaymentService
}

func (h *WechatHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    // 步骤 1：微信 SDK 帮我们验签 + 解密
    transaction := new(native.Transaction)
    _, err := h.handler.ParseNotifyRequest(req.Context(), req, transaction)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    // 步骤 2：在 Web 层把微信状态转成内部状态
    var internalStatus int8
    switch *transaction.TradeState {
    case native.TRADESTATE_SUCCESS:
        internalStatus = StatusSuccess
    case native.TRADESTATE_CLOSED, native.TRADESTATE_REVOKED:
        internalStatus = StatusFailed
    default:
        internalStatus = StatusInit
    }

    // 步骤 3：更新本地状态，并告诉微信已收到（否则微信会重试）
    err = h.svc.HandleCallback(req.Context(), transaction.OutTradeNo, *transaction.TransactionId, internalStatus)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusOK)
}

// SyncOrderStatus 主动查询微信订单状态，更新本地
func (s *NativePaymentService) SyncOrderStatus(ctx context.Context, bizTradeNO string) error {
    // 步骤 1：调用微信查询接口
    resp, err := s.client.QueryOrderByOutTradeNo(ctx, native.QueryOrderByOutTradeNoRequest{
        OutTradeNo: core.String(bizTradeNO),
        Mchid:      core.String(s.mchid),
    })
    if err != nil {
        return err
    }
    // 步骤 2：转换状态并更新本地
    var status int8
    switch *resp.TradeState {
    case native.TRADESTATE_SUCCESS:
        status = StatusSuccess
    case native.TRADESTATE_CLOSED, native.TRADESTATE_REVOKED:
        status = StatusFailed
    default:
        status = StatusInit
    }
    return s.db.UpdateStatus(ctx, bizTradeNO, *resp.TransactionId, status)
}

// ScheduleReconcile 定时对账任务
// 借助分布式锁可以让任务全局唯一，但没特别大必要
func (s *NativePaymentService) ScheduleReconcile() {
    // 步骤 1：找 31 分钟前的订单（Prepay 超时 30 分钟，多留 1 分钟缓冲）
    orders, err := s.db.FindTimeoutOrders(context.Background(), 31*time.Minute)
    if err != nil {
        return
    }
    // 步骤 2：逐单主动去微信查状态并更新本地
    for _, o := range orders {
        _ = s.SyncOrderStatus(context.Background(), o.BizTradeNO)
    }
}

// ArticleHandler 打赏接口（放在 ArticleHandler 下因为是打赏文章）
func (h *ArticleHandler) Reward(ctx *gin.Context) {
    // 步骤 1：查询文章信息，获得作者、标题
    art, err := h.articleSvc.GetById(ctx, req.Aid)
    // 步骤 2：构建打赏请求
    resp, err := h.rewardSvc.Reward(ctx, reward.RewardReq{
        Biz:     "article",
        BizId:   req.Aid,
        Uid:     req.Uid,
        Amount:  1, // 打赏一分钱（抠门示例，正常应是用户输入金额）
        Title:   art.Title,
        Author:  art.AuthorId,
    })
    // 步骤 3：返回二维码 + rid
    ctx.JSON(http.StatusOK, gin.H{
        "codeURL": resp.CodeURL,
        "rid":     resp.Rid,
    })
}

service RewardService {
    // 打赏接口：返回支付二维码和打赏记录 ID
    rpc Reward(RewardReq) returns (RewardResp);
    // 查询打赏结果
    rpc GetReward(GetRewardReq) returns (GetRewardResp);
}

message RewardReq {
    string biz = 1;       // 业务标识，如 "article"
    int64  biz_id = 2;    // 业务 ID，如文章 ID
    int64  uid = 3;       // 打赏者 UID
    int64  amount = 4;    // 金额，单位分
    string title = 5;     // 文章标题（用于微信商品描述）
    int64  author = 6;    // 创作者 UID
}

message RewardResp {
    string code_url = 1;  // 支付二维码链接
    int64  rid = 2;       // 打赏记录 ID
}

func (s *RewardService) Reward(ctx context.Context, req *RewardReq) (*RewardResp, error) {
    // Step 1: 查询是否有缓存的二维码
    // 如果有，说明用户之前准备打赏但没支付，直接复用
    codeURL, err := s.cache.GetCodeURL(ctx, req.Uid, req.Biz, req.BizId)
    if err == nil && codeURL != "" {
        rid, _ := s.cache.GetRid(ctx, req.Uid, req.Biz, req.BizId)
        return &RewardResp{CodeUrl: codeURL, Rid: rid}, nil
    }

    // Step 2: 创建打赏记录
    rid, err := s.dao.Create(ctx, Reward{
        Biz:    req.Biz,
        BizId:  req.BizId,
        Uid:    req.Uid,
        Amount: req.Amount,
        Status: StatusPending,
        Author: req.Author,
    })
    if err != nil {
        return nil, err
    }

    // Step 3: 调用 Payment 服务获得二维码
    // BizTradeNO 用 rid 编码，保证唯一性
    bizTradeNO := fmt.Sprintf("reward:%d", rid)
    prepay, err := s.paymentSvc.Prepay(ctx, payment.PrepayReq{
        BizTradeNO:  bizTradeNO,
        Description: fmt.Sprintf("打赏文章:%s", req.Title),
        Amount:      req.Amount,
    })
    if err != nil {
        return nil, err
    }

    // Step 4: 缓存二维码，避免重复调用支付
    _ = s.cache.SetCodeURL(ctx, req.Uid, req.Biz, req.BizId, prepay.CodeURL, 30*time.Minute)
    _ = s.cache.SetRid(ctx, req.Uid, req.Biz, req.BizId, rid, 30*time.Minute)

    return &RewardResp{CodeUrl: prepay.CodeURL, Rid: rid}, nil
}

// GetReward 查询打赏结果
// uid 往后传是为了让 Reward 服务校验：rid 是不是这个登录用户创建的
// 打赏的人和查询的人必须是同一个人
func (s *RewardService) GetReward(ctx context.Context, req *GetRewardReq) (*GetRewardResp, error) {
    // 步骤 1：查本地打赏记录
    r, err := s.dao.GetById(ctx, req.Rid)
    if err != nil {
        return nil, err
    }
    // 步骤 2：权限校验——rid 必须属于该 uid
    if r.Uid != req.Uid {
        return nil, ErrPermissionDenied
    }

    // 步骤 3：快慢路径。pending 时主动查 Payment（慢路径）
    if r.Status == StatusPending {
        // 正常可以触发降级时跳过此查询
        status, err := s.paymentSvc.GetStatus(ctx, r.BizTradeNO)
        if err == nil && status != StatusPending {
            _ = s.dao.UpdateStatus(ctx, r.Id, status)
            r.Status = status
        }
    }

    return &GetRewardResp{Status: r.Status}, nil
}

func (s *NativePaymentService) HandleCallback(ctx context.Context, bizTradeNO, txnID string, status int8) error {
    // 步骤 1：更新本地状态
    err := s.db.UpdateStatus(ctx, bizTradeNO, txnID, status)
    if err != nil {
        return err
    }
    // 步骤 2：发送消息到 Kafka
    err = s.producer.Produce(ctx, PaymentEvent{
        BizTradeNO: bizTradeNO,
        Status:     status,
        TxnID:      txnID,
    })
    // 关键问题：处理结果成功，但发送消息失败怎么办？
    // 解决思路：重试 + 监控 + 告警 + 异步补偿（本地消息表）
    return err
}

func (c *RewardConsumer) Consume(msg *PaymentEvent) error {
    // 步骤 1：从 bizTradeNO 解析出 rid，例如 "reward:123" → 123
    parts := strings.Split(msg.BizTradeNO, ":")
    if len(parts) != 2 || parts[0] != "reward" {
        return nil // 不是打赏的消息，跳过
    }
    rid, _ := strconv.ParseInt(parts[1], 10, 64)

    // 步骤 2：更新本地状态——这个操作是幂等的
    return c.dao.UpdateStatus(context.Background(), rid, msg.Status)
}

service AccountService {
    // 分账：把一笔账分成多笔
    rpc Split(SplitReq) returns (SplitResp);
}

message SplitReq {
    string biz = 1;          // 业务标识
    int64  biz_id = 2;       // 业务 ID
    int64  total = 3;        // 总金额
    repeated SplitItem items = 4; // 分账明细
}

message SplitItem {
    int64 uid = 1;          // 账号 UID
    int64 amount = 2;       // 分到的金额
    string account_type = 3; // 账号类型：收入/支出
}

CREATE TABLE `account` (
    `id`         BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    `uid`        BIGINT NOT NULL,
    `balance`    BIGINT NOT NULL COMMENT '余额，单位分',
    `currency`   VARCHAR(8) NOT NULL DEFAULT 'CNY' COMMENT '币种',
    `ctime`      DATETIME NOT NULL,
    `utime`      DATETIME NOT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_uid_currency` (`uid`, `currency`)
);

CREATE TABLE `account_activity` (
    `id`           BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    `uid`          BIGINT NOT NULL,
    `biz`          VARCHAR(32) NOT NULL,
    `biz_id`       BIGINT NOT NULL,
    `amount`       BIGINT NOT NULL COMMENT '变动金额，正数收入负数支出',
    `balance_after` BIGINT NOT NULL COMMENT '变动后余额，便于审计',
    `ctime`        DATETIME NOT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_biz_bizid_uid` (`biz`, `biz_id`, `uid`) -- 关键：幂等保证
);

func (s *AccountService) Split(ctx context.Context, req *SplitReq) (*SplitResp, error) {
    // 步骤 1：开启事务
    tx, err := s.db.BeginTx(ctx, nil)
    if err != nil {
        return nil, err
    }
    defer tx.Rollback() // 失败时回滚

    for _, item := range req.Items {
        // 步骤 2：更新账号余额
        _, err := tx.ExecContext(ctx,
            "UPDATE account SET balance = balance + ?, utime = NOW() WHERE uid = ? AND currency = 'CNY'",
            item.Amount, item.Uid)
        if err != nil {
            return nil, err
        }

        // 步骤 3：记录账号活动（唯一索引保证幂等：biz+bizId+uid 唯一）
        var balanceAfter int64
        _ = tx.QueryRowContext(ctx,
            "SELECT balance FROM account WHERE uid = ?", item.Uid).Scan(&balanceAfter)
        _, err = tx.ExecContext(ctx,
            "INSERT INTO account_activity (uid, biz, biz_id, amount, balance_after, ctime) VALUES (?, ?, ?, ?, ?, NOW())",
            item.Uid, req.Biz, req.BizId, item.Amount, balanceAfter)
        if err != nil {
            // 唯一索引冲突说明已经分过账，直接返回（幂等）
            return nil, err
        }
    }

    // 步骤 4：提交事务
    if err = tx.Commit(); err != nil {
        return nil, err
    }
    return &SplitResp{Success: true}, nil
}

func (s *RewardService) handlePaymentSuccess(ctx context.Context, rid int64) error {
    // 步骤 1：查出打赏记录
    r, err := s.dao.GetById(ctx, rid)
    if err != nil {
        return err
    }
    // 步骤 2：计算分成：作者 80%，平台 20%（示例比例）
    authorAmount := r.Amount * 8 / 10
    platformAmount := r.Amount - authorAmount

    // 步骤 3：调用账号服务分账
    // 注意：这里没有处理幂等——是作业中的一个选项
    _, err = s.accountSvc.Split(ctx, &account.SplitReq{
        Biz:    "reward",
        BizId:  r.Id,
        Total:  r.Amount,
        Items: []*account.SplitItem{
            {Uid: r.Author, Amount: authorAmount, AccountType: "income"},
            {Uid: PlatformUID, Amount: platformAmount, AccountType: "income"},
        },
    })
    return err
}