slogan/styleagent/service/payment_order_service.go

package service

import (
	"context"
	"crypto/md5"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"

	"slogan-agent/styleagent/consts"
	"slogan-agent/styleagent/dao"
	"slogan-agent/styleagent/model/entity"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
)

type paymentOrderService struct{}

var PaymentOrderService = new(paymentOrderService)

// ==================== 虎皮棋聚合支付适配器（签名/HTTP 细节收敛在本文件，业务层不感知） ====================
// 注意：签名规则与字段名以官方最新文档为准（当前实现为经典 md5 约定）。

type paymentConfig struct {
	AppId     string
	AppSecret string
	NotifyUrl string
	Channel   string // 逗号分隔，如 "alipay,wechat"
	ApiBase   string
	Enabled   bool
}

func (s *paymentOrderService) getPaymentConfig(ctx context.Context) paymentConfig {
	cfg := paymentConfig{
		AppId:     g.Cfg().MustGet(ctx, "payment.xunhu_appid", "").String(),
		AppSecret: g.Cfg().MustGet(ctx, "payment.xunhu_appsecret", "").String(),
		NotifyUrl: g.Cfg().MustGet(ctx, "payment.notify_url", "").String(),
		Channel:   g.Cfg().MustGet(ctx, "payment.channel", "alipay").String(),
		ApiBase:   g.Cfg().MustGet(ctx, "payment.api_base", "https://api.xunhupay.com").String(),
	}
	cfg.Enabled = cfg.AppId != "" && cfg.AppSecret != ""
	return cfg
}

// CreateOrder 创建支付单，返回收银台/支付 URL（金额单位：分）
func (s *paymentOrderService) CreateOrder(ctx context.Context, orderNo string, amountFen int) (payURL string, err error) {
	cfg := s.getPaymentConfig(ctx)
	if !cfg.Enabled {
		return "", errors.New("支付未开通，请在 config.yml 配置 payment")
	}
	channel := "alipay"
	if first := strings.Split(cfg.Channel, ",")[0]; first != "" {
		channel = first
	}
	params := map[string]string{
		"appid":          cfg.AppId,
		"trade_order_id": orderNo,
		"total_fee":      fmt.Sprintf("%.2f", float64(amountFen)/100),
		"title":          "形象会员",
		"notify_url":     cfg.NotifyUrl,
		"type":           channel,
		"version":        "1.1",
		"nonce_str":      paymentNonce(),
	}
	params["hash"] = paymentSign(params, cfg.AppSecret)

	var resp struct {
		Errcode int    `json:"errcode"`
		Errmsg  string `json:"errmsg"`
		Url     string `json:"url"`
	}
	// 注意：Post 的最后一个参数不会自动解析响应体，需手动读取后反序列化
	respRaw, err := g.Client().SetTimeout(10*time.Second).Post(context.Background(), cfg.ApiBase+"/payment/do.html", params)
	if err != nil {
		return "", fmt.Errorf("虎皮棋下单失败: %w", err)
	}
	defer respRaw.Close()
	if err := json.Unmarshal(respRaw.ReadAll(), &resp); err != nil {
		return "", fmt.Errorf("虎皮棋下单失败: %w", err)
	}
	if resp.Errcode != 0 {
		return "", fmt.Errorf("虎皮棋下单失败: %s", resp.Errmsg)
	}
	if resp.Url == "" {
		return "", errors.New("虎皮棋下单失败: 返回为空")
	}
	return resp.Url, nil
}

// VerifyNotify 验签：复制参数去掉 hash 后重算签名比较
func (s *paymentOrderService) VerifyNotify(params map[string]string, hash, secret string) bool {
	if hash == "" || secret == "" {
		return false
	}
	cp := make(map[string]string, len(params))
	for k, v := range params {
		if k != "hash" {
			cp[k] = v
		}
	}
	return paymentSign(cp, secret) == strings.ToLower(hash)
}

// paymentSign 参数名升序拼接 key=value，追加 secret 后 md5 hex
func paymentSign(params map[string]string, secret string) string {
	keys := make([]string, 0, len(params))
	for k := range params {
		if params[k] == "" {
			continue
		}
		keys = append(keys, k)
	}
	sort.Strings(keys)
	var sb strings.Builder
	for i, k := range keys {
		if i > 0 {
			sb.WriteString("&")
		}
		sb.WriteString(k)
		sb.WriteString("=")
		sb.WriteString(params[k])
	}
	sb.WriteString(secret)
	sum := md5.Sum([]byte(sb.String()))
	return hex.EncodeToString(sum[:])
}

func paymentNonce() string {
	b := make([]byte, 8)
	_, _ = rand.Read(b)
	return hex.EncodeToString(b)
}

// ==================== 订单业务 ====================

// CreateMemberOrder 下单：生成业务订单号 → 虎皮棋下单 → 返回支付 URL
func (s *paymentOrderService) CreateMemberOrder(ctx context.Context, userId, planId int64) (*entity.PaymentOrder, string, error) {
	plan, err := dao.MemberPlan.GetOne(ctx, planId)
	if err != nil {
		return nil, "", err
	}
	if plan == nil {
		return nil, "", errors.New("套餐不存在")
	}
	order := &entity.PaymentOrder{
		OrderNo:   fmt.Sprintf("M%d%d", time.Now().UnixNano()/1e6, userId%1000),
		UserId:    userId,
		PlanId:    planId,
		AmountFen: plan.PriceFen,
		Channel:   "alipay",
		Status:    consts.PayStatusPending,
	}
	if _, err := dao.PaymentOrder.Insert(ctx, order); err != nil {
		return nil, "", err
	}
	payURL, err := s.CreateOrder(ctx, order.OrderNo, plan.PriceFen)
	if err != nil {
		return nil, "", err
	}
	return order, payURL, nil
}

func (s *paymentOrderService) OrderStatus(ctx context.Context, orderNo string) (*entity.PaymentOrder, error) {
	return dao.PaymentOrder.GetByOrderNo(ctx, orderNo)
}

// HandlePaidNotify 验签已在 handler 完成；状态机 pending→paid 幂等，成功开通/续期
func (s *paymentOrderService) HandlePaidNotify(ctx context.Context, orderNo, tradeNo, notifyRaw string) (string, error) {
	order, err := dao.PaymentOrder.GetByOrderNo(ctx, orderNo)
	if err != nil {
		return "no_order", err
	}
	if order == nil {
		return "no_order", nil
	}
	ok, err := dao.PaymentOrder.MarkPaid(ctx, orderNo, tradeNo, notifyRaw)
	if err != nil {
		return "no_order", err
	}
	if !ok {
		return "duplicate", nil // 已是 paid 或已关闭
	}
	days := 30
	if plan, _ := dao.MemberPlan.GetOne(ctx, order.PlanId); plan != nil {
		days = plan.DurationDays
	}
	um, _ := dao.UserMember.GetByUser(ctx, order.UserId)
	var oldExpire *gtime.Time
	if um != nil {
		oldExpire = um.ExpireAt
	}
	expireAt := NextExpire(oldExpire, days)
	if err := dao.UserMember.Upsert(ctx, order.UserId, order.PlanId, expireAt, consts.MemberSourceVipPay); err != nil {
		return "no_order", err
	}
	g.Log().Infof(ctx, "会员开通成功 user=%d order=%s expire=%s", order.UserId, orderNo, expireAt)
	return "ok", nil
}

// NextExpire 续期计算：未过期在原有效期上叠加，过期/无记录从现在起算
func NextExpire(old *gtime.Time, days int) string {
	base := time.Now()
	if old != nil && old.Time.After(base) {
		base = old.Time
	}
	return base.Add(time.Duration(days) * 24 * time.Hour).Format("2006-01-02 15:04:05")
}