refactor: 更新项目引用路径从perfect-panel/ppanel-server到perfect-panel/server

feat: 添加版本和构建时间变量
fix: 修正短信队列类型注释错误
style: 清理未使用的代码和测试文件
docs: 更新安装文档中的下载链接
chore: 迁移数据库脚本添加日志和订阅配置

internal/logic/public/portal/getAvailablePaymentMethodsLogic.go

@@ -3,11 +3,11 @@ package portal
 import (
 	"context"
 
-	"github.com/perfect-panel/ppanel-server/internal/svc"
-	"github.com/perfect-panel/ppanel-server/internal/types"
-	"github.com/perfect-panel/ppanel-server/pkg/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/tool"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
 

internal/logic/public/portal/getSubscriptionLogic.go

@@ -4,11 +4,12 @@ import (
 	"context"
 	"encoding/json"
 
-	"github.com/perfect-panel/ppanel-server/internal/svc"
-	"github.com/perfect-panel/ppanel-server/internal/types"
-	"github.com/perfect-panel/ppanel-server/pkg/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/tool"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/internal/model/subscribe"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
 
@@ -27,12 +28,18 @@ func NewGetSubscriptionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *G
 	}
 }
 
-func (l *GetSubscriptionLogic) GetSubscription() (resp *types.GetSubscriptionResponse, err error) {
+func (l *GetSubscriptionLogic) GetSubscription(req *types.GetSubscriptionRequest) (resp *types.GetSubscriptionResponse, err error) {
 	resp = &types.GetSubscriptionResponse{
 		List: make([]types.Subscribe, 0),
 	}
 	// Get the subscription list
-	data, err := l.svcCtx.SubscribeModel.QuerySubscribeListByShow(l.ctx)
+	_, data, err := l.svcCtx.SubscribeModel.FilterList(l.ctx, &subscribe.FilterParams{
+		Page:            1,
+		Size:            9999,
+		Show:            true,
+		Language:        req.Language,
+		DefaultLanguage: true,
+	})
 	if err != nil {
 		l.Errorw("[Site GetSubscription]", logger.Field("err", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscription list error: %v", err.Error())

internal/logic/public/portal/prePurchaseOrderLogic.go

@@ -4,10 +4,12 @@ import (
 	"context"
 	"encoding/json"
 
-	"github.com/perfect-panel/ppanel-server/internal/svc"
-	"github.com/perfect-panel/ppanel-server/internal/types"
-	"github.com/perfect-panel/ppanel-server/pkg/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/pkg/tool"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
 )
@@ -52,9 +54,15 @@ func (l *PrePurchaseOrderLogic) PrePurchaseOrder(req *types.PrePurchaseOrderRequ
 			}
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find coupon error: %v", err.Error())
 		}
-		if couponInfo.Count <= couponInfo.UsedCount {
-			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponUsed), "coupon used")
+		if couponInfo.Count != 0 && couponInfo.Count <= couponInfo.UsedCount {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponInsufficientUsage), "coupon used")
 		}
+		subs := tool.StringToInt64Slice(couponInfo.Subscribe)
+
+		if len(subs) > 0 && !tool.Contains(subs, req.SubscribeId) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponNotApplicable), "coupon not match")
+		}
+
 		coupon = calculateCoupon(amount, couponInfo)
 	}
 	amount -= coupon

internal/logic/public/portal/purchaseCheckoutLogic.go

@@ -3,39 +3,43 @@ package portal
 import (
 	"context"
 	"encoding/json"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/payssion"
 	"strconv"
+	"time"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/pkg/constant"
 
-	paymentPlatform "github.com/perfect-panel/ppanel-server/pkg/payment"
+	paymentPlatform "github.com/perfect-panel/server/pkg/payment"
 
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	queueType "github.com/perfect-panel/ppanel-server/queue/types"
+	"github.com/perfect-panel/server/internal/model/user"
+	queueType "github.com/perfect-panel/server/queue/types"
 	"gorm.io/gorm"
 
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
-	"github.com/perfect-panel/ppanel-server/internal/model/payment"
-	"github.com/perfect-panel/ppanel-server/internal/svc"
-	"github.com/perfect-panel/ppanel-server/internal/types"
-	"github.com/perfect-panel/ppanel-server/pkg/exchangeRate"
-	"github.com/perfect-panel/ppanel-server/pkg/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/alipay"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/epay"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/stripe"
-	"github.com/perfect-panel/ppanel-server/pkg/tool"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/payment"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/exchangeRate"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/payment/alipay"
+	"github.com/perfect-panel/server/pkg/payment/epay"
+	"github.com/perfect-panel/server/pkg/payment/stripe"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
 
+// PurchaseCheckoutLogic handles the checkout process for various payment methods
+// including EPay, Stripe, Alipay F2F, and balance payments
 type PurchaseCheckoutLogic struct {
 	logger.Logger
 	ctx    context.Context
 	svcCtx *svc.ServiceContext
 }
 
-// NewPurchaseCheckoutLogic Purchase Checkout
+// NewPurchaseCheckoutLogic creates a new instance of PurchaseCheckoutLogic
+// for handling purchase checkout operations across different payment platforms
 func NewPurchaseCheckoutLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PurchaseCheckoutLogic {
 	return &PurchaseCheckoutLogic{
 		Logger: logger.WithContext(ctx),
@@ -44,98 +48,116 @@ func NewPurchaseCheckoutLogic(ctx context.Context, svcCtx *svc.ServiceContext) *
 	}
 }
 
+// PurchaseCheckout processes the checkout for an order using the specified payment method
+// It validates the order, retrieves payment configuration, and routes to the appropriate payment handler
 func (l *PurchaseCheckoutLogic) PurchaseCheckout(req *types.CheckoutOrderRequest) (resp *types.CheckoutOrderResponse, err error) {
-	// Find order
+	// Validate and retrieve order information
 	orderInfo, err := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
 	if err != nil {
 		l.Logger.Error("[PurchaseCheckout] Find order failed", logger.Field("error", err.Error()), logger.Field("orderNo", req.OrderNo))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderNotExist), "order not exist: %v", req.OrderNo)
 	}
 
+	// Verify order is in pending payment status (status = 1)
 	if orderInfo.Status != 1 {
 		l.Logger.Error("[PurchaseCheckout] Order status error", logger.Field("status", orderInfo.Status))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderStatusError), "order status error: %v", orderInfo.Status)
 	}
 
-	// find payment method
+	// Retrieve payment method configuration
 	paymentConfig, err := l.svcCtx.PaymentModel.FindOne(l.ctx, orderInfo.PaymentId)
 	if err != nil {
-		l.Logger.Error("[Purchase] Database query error", logger.Field("error", err.Error()), logger.Field("payment", orderInfo.Method))
+		l.Logger.Error("[PurchaseCheckout] Database query error", logger.Field("error", err.Error()), logger.Field("payment", orderInfo.Method))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find payment method error: %v", err.Error())
 	}
+	// Route to appropriate payment handler based on payment platform
 	switch paymentPlatform.ParsePlatform(orderInfo.Method) {
 	case paymentPlatform.EPay:
+		// Process EPay payment - generates payment URL for redirect
 		url, err := l.epayPayment(paymentConfig, orderInfo, req.ReturnUrl)
 		if err != nil {
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "epayPayment error: %v", err.Error())
 		}
 		resp = &types.CheckoutOrderResponse{
 			CheckoutUrl: url,
-			Type:        "url",
+			Type:        "url", // Client should redirect to URL
 		}
+
 	case paymentPlatform.Stripe:
+		// Process Stripe payment - creates payment sheet for client-side processing
 		stripePayment, err := l.stripePayment(paymentConfig.Config, orderInfo, "")
 		if err != nil {
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "stripePayment error: %v", err.Error())
 		}
 		resp = &types.CheckoutOrderResponse{
-			Type:   "stripe",
+			Type:   "stripe", // Client should use Stripe SDK
 			Stripe: stripePayment,
 		}
+
 	case paymentPlatform.AlipayF2F:
+		// Process Alipay Face-to-Face payment - generates QR code
 		url, err := l.alipayF2fPayment(paymentConfig, orderInfo)
 		if err != nil {
-			l.Errorw("[CheckoutOrderLogic] alipayF2fPayment error", logger.Field("error", err.Error()))
+			l.Errorw("[PurchaseCheckout] alipayF2fPayment error", logger.Field("error", err.Error()))
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "alipayF2fPayment error: %v", err.Error())
 		}
 		resp = &types.CheckoutOrderResponse{
-			Type:        "qr",
+			Type:        "qr", // Client should display QR code
 			CheckoutUrl: url,
 		}
-	case paymentPlatform.Payssion:
-		url, err := l.payssionPayment(paymentConfig, orderInfo, req.ReturnUrl)
+
+	case paymentPlatform.CryptoSaaS:
+		// Process EPay payment - generates payment URL for redirect
+		url, err := l.CryptoSaaSPayment(paymentConfig, orderInfo, req.ReturnUrl)
 		if err != nil {
-			l.Errorw("[CheckoutOrderLogic] payssionPayment error", logger.Field("error", err.Error()))
-			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "paymentPayment error: %v", err.Error())
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "epayPayment error: %v", err.Error())
 		}
 		resp = &types.CheckoutOrderResponse{
 			CheckoutUrl: url,
-			Type:        "url",
+			Type:        "url", // Client should redirect to URL
 		}
+
 	case paymentPlatform.Balance:
+		// Process balance payment - validate user and process payment immediately
 		if orderInfo.UserId == 0 {
-			l.Errorw("[CheckoutOrderLogic] user not found", logger.Field("userId", orderInfo.UserId))
+			l.Errorw("[PurchaseCheckout] user not found", logger.Field("userId", orderInfo.UserId))
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user not found")
 		}
-		// find user
+
+		// Retrieve user information for balance validation
 		userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, orderInfo.UserId)
 		if err != nil {
-			l.Errorw("[CheckoutOrderLogic] FindOne User error", logger.Field("error", err.Error()))
+			l.Errorw("[PurchaseCheckout] FindOne User error", logger.Field("error", err.Error()))
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOne error: %s", err.Error())
 		}
 
-		// balance
+		// Process balance payment with gift amount priority logic
 		if err = l.balancePayment(userInfo, orderInfo); err != nil {
 			return nil, err
 		}
+
 		resp = &types.CheckoutOrderResponse{
-			Type: "balance",
+			Type: "balance", // Payment completed immediately
 		}
 
 	default:
-		l.Errorw("[CheckoutOrderLogic] payment method not found", logger.Field("method", orderInfo.Method))
+		l.Errorw("[PurchaseCheckout] payment method not found", logger.Field("method", orderInfo.Method))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "payment method not found")
 	}
 	return
 }
 
-// alipay f2f payment
+// alipayF2fPayment processes Alipay Face-to-Face payment by generating a QR code
+// It handles currency conversion and creates a pre-payment trade for QR code scanning
 func (l *PurchaseCheckoutLogic) alipayF2fPayment(pay *payment.Payment, info *order.Order) (string, error) {
-	f2FConfig := payment.AlipayF2FConfig{}
-	if err := json.Unmarshal([]byte(pay.Config), &f2FConfig); err != nil {
-		l.Errorw("[PurchaseCheckoutLogic] Unmarshal error", logger.Field("error", err.Error()))
+	// Parse Alipay F2F configuration from payment settings
+	f2FConfig := &payment.AlipayF2FConfig{}
+	if err := f2FConfig.Unmarshal([]byte(pay.Config)); err != nil {
+		l.Errorw("[PurchaseCheckout] Unmarshal Alipay config error", logger.Field("error", err.Error()))
 		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Unmarshal error: %s", err.Error())
 	}
+
+	// Build notification URL for payment status callbacks
 	notifyUrl := ""
 	if pay.Domain != "" {
 		notifyUrl = pay.Domain + "/v1/notify/" + pay.Platform + "/" + pay.Token
@@ -146,6 +168,8 @@ func (l *PurchaseCheckoutLogic) alipayF2fPayment(pay *payment.Payment, info *ord
 		}
 		notifyUrl = "https://" + host + "/v1/notify/" + pay.Platform + "/" + pay.Token
 	}
+
+	// Initialize Alipay client with configuration
 	client := alipay.NewClient(alipay.Config{
 		AppId:       f2FConfig.AppId,
 		PrivateKey:  f2FConfig.PrivateKey,
@@ -153,46 +177,54 @@ func (l *PurchaseCheckoutLogic) alipayF2fPayment(pay *payment.Payment, info *ord
 		InvoiceName: f2FConfig.InvoiceName,
 		NotifyURL:   notifyUrl,
 	})
-	// Calculate the amount with exchange rate
+
+	// Convert order amount to CNY using current exchange rate
 	amount, err := l.queryExchangeRate("CNY", info.Amount)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] queryExchangeRate error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] queryExchangeRate error", logger.Field("error", err.Error()))
 		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "queryExchangeRate error: %s", err.Error())
 	}
-	convertAmount := int64(amount * 100)
-	// create payment
+	convertAmount := int64(amount * 100) // Convert to cents for API
+
+	// Create pre-payment trade and generate QR code
 	QRCode, err := client.PreCreateTrade(l.ctx, alipay.Order{
 		OrderNo: info.OrderNo,
 		Amount:  convertAmount,
 	})
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] PreCreateTrade error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] PreCreateTrade error", logger.Field("error", err.Error()))
 		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "PreCreateTrade error: %s", err.Error())
 	}
 	return QRCode, nil
 }
 
-// Stripe Payment
+// stripePayment processes Stripe payment by creating a payment sheet
+// It supports various payment methods including WeChat Pay and Alipay through Stripe
 func (l *PurchaseCheckoutLogic) stripePayment(config string, info *order.Order, identifier string) (*types.StripePayment, error) {
-	// stripe WeChat pay or stripe alipay
-	stripeConfig := payment.StripeConfig{}
-	if err := json.Unmarshal([]byte(config), &stripeConfig); err != nil {
-		l.Errorw("[CheckoutOrderLogic] Unmarshal error", logger.Field("error", err.Error()))
+	// Parse Stripe configuration from payment settings
+	stripeConfig := &payment.StripeConfig{}
+
+	if err := stripeConfig.Unmarshal([]byte(config)); err != nil {
+		l.Errorw("[PurchaseCheckout] Unmarshal Stripe config error", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Unmarshal error: %s", err.Error())
 	}
+
+	// Initialize Stripe client with API credentials
 	client := stripe.NewClient(stripe.Config{
 		SecretKey:     stripeConfig.SecretKey,
 		PublicKey:     stripeConfig.PublicKey,
 		WebhookSecret: stripeConfig.WebhookSecret,
 	})
-	// Calculate the amount with exchange rate
+
+	// Convert order amount to CNY using current exchange rate
 	amount, err := l.queryExchangeRate("CNY", info.Amount)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] queryExchangeRate error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] queryExchangeRate error", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "queryExchangeRate error: %s", err.Error())
 	}
-	convertAmount := int64(amount * 100)
-	// create payment
+	convertAmount := int64(amount * 100) // Convert to cents for Stripe API
+
+	// Create Stripe payment sheet for client-side processing
 	result, err := client.CreatePaymentSheet(&stripe.Order{
 		OrderNo:   info.OrderNo,
 		Subscribe: strconv.FormatInt(info.SubscribeId, 10),
@@ -204,37 +236,46 @@ func (l *PurchaseCheckoutLogic) stripePayment(config string, info *order.Order,
 			Email: identifier,
 		})
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] CreatePaymentSheet error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] CreatePaymentSheet error", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "CreatePaymentSheet error: %s", err.Error())
 	}
-	tradeNo := result.TradeNo
+
+	// Prepare response data for client-side Stripe integration
 	stripePayment := &types.StripePayment{
 		PublishableKey: stripeConfig.PublicKey,
 		ClientSecret:   result.ClientSecret,
 		Method:         stripeConfig.Payment,
 	}
-	// save payment
-	info.TradeNo = tradeNo
+
+	// Save Stripe trade number to order for tracking
+	info.TradeNo = result.TradeNo
 	err = l.svcCtx.OrderModel.Update(l.ctx, info)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] Update error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] Update order error", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Update error: %s", err.Error())
 	}
 	return stripePayment, nil
 }
 
+// epayPayment processes EPay payment by generating a payment URL for redirect
+// It handles currency conversion and creates a payment URL for external payment processing
 func (l *PurchaseCheckoutLogic) epayPayment(config *payment.Payment, info *order.Order, returnUrl string) (string, error) {
-	epayConfig := payment.EPayConfig{}
-	if err := json.Unmarshal([]byte(config.Config), &epayConfig); err != nil {
-		l.Errorw("[CheckoutOrderLogic] Unmarshal error", logger.Field("error", err.Error()))
+	// Parse EPay configuration from payment settings
+	epayConfig := &payment.EPayConfig{}
+	if err := epayConfig.Unmarshal([]byte(config.Config)); err != nil {
+		l.Errorw("[PurchaseCheckout] Unmarshal EPay config error", logger.Field("error", err.Error()))
 		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Unmarshal error: %s", err.Error())
 	}
+	// Initialize EPay client with merchant credentials
 	client := epay.NewClient(epayConfig.Pid, epayConfig.Url, epayConfig.Key)
-	// Calculate the amount with exchange rate
+
+	// Convert order amount to CNY using current exchange rate
 	amount, err := l.queryExchangeRate("CNY", info.Amount)
 	if err != nil {
 		return "", err
 	}
+
+	// Build notification URL for payment status callbacks
 	notifyUrl := ""
 	if config.Domain != "" {
 		notifyUrl = config.Domain + "/v1/notify/" + config.Platform + "/" + config.Token
@@ -245,7 +286,8 @@ func (l *PurchaseCheckoutLogic) epayPayment(config *payment.Payment, info *order
 		}
 		notifyUrl = "https://" + host + "/v1/notify/" + config.Platform + "/" + config.Token
 	}
-	// create payment
+
+	// Create payment URL for user redirection
 	url := client.CreatePayUrl(epay.Order{
 		Name:      l.svcCtx.Config.Site.SiteName,
 		Amount:    amount,
@@ -257,19 +299,25 @@ func (l *PurchaseCheckoutLogic) epayPayment(config *payment.Payment, info *order
 	return url, nil
 }
 
-func (l *PurchaseCheckoutLogic) payssionPayment(config *payment.Payment, info *order.Order, returnUrl string) (string, error) {
-	payssionConfig := payment.PayssionConfig{}
-	if err := json.Unmarshal([]byte(config.Config), &payssionConfig); err != nil {
-		l.Errorw("[CheckoutOrderLogic] payssionPayment Unmarshal error", logger.Field("error", err.Error()))
-		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), " payssionPaymentUnmarshal error: %s", err.Error())
+// CryptoSaaSPayment processes CryptoSaaSPayment payment by generating a payment URL for redirect
+// It handles currency conversion and creates a payment URL for external payment processing
+func (l *PurchaseCheckoutLogic) CryptoSaaSPayment(config *payment.Payment, info *order.Order, returnUrl string) (string, error) {
+	// Parse EPay configuration from payment settings
+	epayConfig := &payment.CryptoSaaSConfig{}
+	if err := epayConfig.Unmarshal([]byte(config.Config)); err != nil {
+		l.Errorw("[PurchaseCheckout] Unmarshal EPay config error", logger.Field("error", err.Error()))
+		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Unmarshal error: %s", err.Error())
 	}
-	client := payssion.NewClient(payssionConfig.ApiKey, payssionConfig.SecretKey, payssionConfig.PmId, payssionConfig.Currency, payssionConfig.QueryUrl, payssionConfig.CreateUrl)
-	// Calculate the amount with exchange rate
+	// Initialize EPay client with merchant credentials
+	client := epay.NewClient(epayConfig.AccountID, epayConfig.Endpoint, epayConfig.SecretKey)
+
+	// Convert order amount to CNY using current exchange rate
 	amount, err := l.queryExchangeRate("CNY", info.Amount)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] payssionPayment queryExchangeRate error", logger.Field("error", err.Error()))
 		return "", err
 	}
+
+	// Build notification URL for payment status callbacks
 	notifyUrl := ""
 	if config.Domain != "" {
 		notifyUrl = config.Domain + "/v1/notify/" + config.Platform + "/" + config.Token
@@ -280,37 +328,47 @@ func (l *PurchaseCheckoutLogic) payssionPayment(config *payment.Payment, info *o
 		}
 		notifyUrl = "https://" + host + "/v1/notify/" + config.Platform + "/" + config.Token
 	}
-	// create payment
-	url, err := client.CreateOrder(payssion.Order{
+
+	// Create payment URL for user redirection
+	url := client.CreatePayUrl(epay.Order{
 		Name:      l.svcCtx.Config.Site.SiteName,
 		Amount:    amount,
 		OrderNo:   info.OrderNo,
+		SignType:  "MD5",
 		NotifyUrl: notifyUrl,
 		ReturnUrl: returnUrl,
 	})
-	return url, err
+	return url, nil
 }
 
-// Query exchange rate
+// queryExchangeRate converts the order amount from system currency to target currency
+// It retrieves the current exchange rate and performs currency conversion if needed
 func (l *PurchaseCheckoutLogic) queryExchangeRate(to string, src int64) (amount float64, err error) {
+	// Convert cents to decimal amount
 	amount = float64(src) / float64(100)
-	// query system currency
+
+	// Retrieve system currency configuration
 	currency, err := l.svcCtx.SystemModel.GetCurrencyConfig(l.ctx)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] GetCurrencyConfig error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] GetCurrencyConfig error", logger.Field("error", err.Error()))
 		return 0, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetCurrencyConfig error: %s", err.Error())
 	}
+
+	// Parse currency configuration
 	configs := struct {
 		CurrencyUnit   string
 		CurrencySymbol string
 		AccessKey      string
 	}{}
 	tool.SystemConfigSliceReflectToStruct(currency, &configs)
+
+	// Skip conversion if no exchange rate API key configured
 	if configs.AccessKey == "" {
 		return amount, nil
 	}
+
+	// Convert currency if system currency differs from target currency
 	if configs.CurrencyUnit != to {
-		// query exchange rate
 		result, err := exchangeRate.GetExchangeRete(configs.CurrencyUnit, to, configs.AccessKey, 1)
 		if err != nil {
 			return 0, err
@@ -320,59 +378,149 @@ func (l *PurchaseCheckoutLogic) queryExchangeRate(to string, src int64) (amount
 	return amount, nil
 }
 
-// Balance payment
+// balancePayment processes balance payment with gift amount priority logic
+// It prioritizes using gift amount first, then regular balance, and creates proper audit logs
 func (l *PurchaseCheckoutLogic) balancePayment(u *user.User, o *order.Order) error {
 	var userInfo user.User
-	err := l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
+	var err error
+	if o.Amount == 0 {
+		// No payment required for zero-amount orders
+		l.Logger.Info(
+			"[PurchaseCheckout] No payment required for zero-amount order",
+			logger.Field("orderNo", o.OrderNo),
+			logger.Field("userId", u.Id),
+		)
+		err = l.svcCtx.OrderModel.UpdateOrderStatus(l.ctx, o.OrderNo, 2)
+		if err != nil {
+			l.Errorw("[PurchaseCheckout] Update order status error",
+				logger.Field("error", err.Error()),
+				logger.Field("orderNo", o.OrderNo),
+				logger.Field("userId", u.Id))
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Update order status error: %s", err.Error())
+		}
+		goto activation
+	}
+
+	err = l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		// Retrieve latest user information with row-level locking
 		err := db.Model(&user.User{}).Where("id = ?", u.Id).First(&userInfo).Error
 		if err != nil {
 			return err
 		}
 
-		if userInfo.Balance < o.Amount {
-			return errors.Wrapf(xerr.NewErrCode(xerr.InsufficientBalance), "Insufficient balance")
+		// Check if user has sufficient total balance (regular + gift)
+		totalAvailable := userInfo.Balance + userInfo.GiftAmount
+		if totalAvailable < o.Amount {
+			return errors.Wrapf(xerr.NewErrCode(xerr.InsufficientBalance),
+				"Insufficient balance: required %d, available %d", o.Amount, totalAvailable)
 		}
-		// deduct balance
-		userInfo.Balance -= o.Amount
+
+		// Calculate payment distribution: prioritize gift amount first
+		var giftUsed, balanceUsed int64
+		remainingAmount := o.Amount
+
+		if userInfo.GiftAmount >= remainingAmount {
+			// Gift amount covers the entire payment
+			giftUsed = remainingAmount
+			balanceUsed = 0
+		} else {
+			// Use all available gift amount, then regular balance
+			giftUsed = userInfo.GiftAmount
+			balanceUsed = remainingAmount - giftUsed
+		}
+
+		// Update user balances
+		userInfo.GiftAmount -= giftUsed
+		userInfo.Balance -= balanceUsed
+
+		// Save updated user information
 		err = l.svcCtx.UserModel.Update(l.ctx, &userInfo)
 		if err != nil {
 			return err
 		}
-		// create balance log
-		balanceLog := &user.BalanceLog{
-			Id:      0,
-			UserId:  u.Id,
-			Amount:  o.Amount,
-			Type:    3,
-			OrderId: o.Id,
-			Balance: userInfo.Balance,
+
+		// Create gift amount log if gift amount was used
+		if giftUsed > 0 {
+			giftLog := &log.Gift{
+				OrderNo: o.OrderNo,
+				Type:    log.GiftTypeReduce, // Type 2 represents gift amount decrease/usage
+				Amount:  giftUsed,
+				Balance: userInfo.GiftAmount,
+				Remark:  "Purchase payment",
+			}
+			content, _ := giftLog.Marshal()
+
+			err = db.Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				ObjectID: userInfo.Id,
+				Date:     time.Now().Format(time.DateOnly),
+				Content:  string(content),
+			}).Error
+			if err != nil {
+				return err
+			}
 		}
-		err = db.Create(balanceLog).Error
+
+		// Create balance log if regular balance was used
+		if balanceUsed > 0 {
+			balanceLog := &log.Balance{
+				Amount:    balanceUsed,
+				Type:      log.BalanceTypePayment, // Type 3 represents payment deduction
+				OrderNo:   o.OrderNo,
+				Balance:   userInfo.Balance,
+				Timestamp: time.Now().UnixMilli(),
+			}
+			content, _ := balanceLog.Marshal()
+			err = db.Create(&log.SystemLog{
+				Type:     log.TypeBalance.Uint8(),
+				ObjectID: userInfo.Id,
+				Date:     time.Now().Format(time.DateOnly),
+				Content:  string(content),
+			}).Error
+			if err != nil {
+				return err
+			}
+		}
+
+		// Store gift amount used in order for potential refund tracking
+		o.GiftAmount = giftUsed
+		err = l.svcCtx.OrderModel.Update(l.ctx, o, db)
 		if err != nil {
 			return err
 		}
-		return l.svcCtx.OrderModel.UpdateOrderStatus(l.ctx, o.OrderNo, 2)
+
+		// Mark order as paid (status = 2)
+		return l.svcCtx.OrderModel.UpdateOrderStatus(l.ctx, o.OrderNo, 2, db)
 	})
+
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] Transaction error", logger.Field("error", err.Error()), logger.Field("orderNo", o.OrderNo))
+		l.Errorw("[PurchaseCheckout] Balance payment transaction error",
+			logger.Field("error", err.Error()),
+			logger.Field("orderNo", o.OrderNo),
+			logger.Field("userId", u.Id))
 		return err
 	}
-	// create activity order task
+
+activation:
+	// Enqueue order activation task for immediate processing
 	payload := queueType.ForthwithActivateOrderPayload{
 		OrderNo: o.OrderNo,
 	}
 	bytes, err := json.Marshal(payload)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] Marshal error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] Marshal activation payload error", logger.Field("error", err.Error()))
 		return err
 	}
 
 	task := asynq.NewTask(queueType.ForthwithActivateOrder, bytes)
 	_, err = l.svcCtx.Queue.EnqueueContext(l.ctx, task)
 	if err != nil {
-		l.Errorw("[CheckoutOrderLogic] Enqueue error", logger.Field("error", err.Error()))
+		l.Errorw("[PurchaseCheckout] Enqueue activation task error", logger.Field("error", err.Error()))
 		return err
 	}
-	l.Logger.Info("[CheckoutOrderLogic] Enqueue success", logger.Field("orderNo", o.OrderNo))
+
+	l.Logger.Info("[PurchaseCheckout] Balance payment completed successfully",
+		logger.Field("orderNo", o.OrderNo),
+		logger.Field("userId", u.Id))
 	return nil
 }

internal/logic/public/portal/purchaseLogic.go

@@ -6,18 +6,17 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/perfect-panel/ppanel-server/pkg/payment"
-
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/payment"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
+	queue "github.com/perfect-panel/server/queue/types"
 
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
-	"github.com/perfect-panel/ppanel-server/internal/svc"
-	"github.com/perfect-panel/ppanel-server/internal/types"
-	"github.com/perfect-panel/ppanel-server/pkg/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/tool"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
-	queue "github.com/perfect-panel/ppanel-server/queue/types"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
 )
@@ -71,7 +70,7 @@ func (l *PurchaseLogic) Purchase(req *types.PortalPurchaseRequest) (resp *types.
 	amount := int64(float64(price) * discount)
 	discountAmount := price - amount
 
-	var coupon int64 = 0
+	var couponAmount int64 = 0
 	// Calculate the coupon deduction
 	if req.Coupon != "" {
 		couponInfo, err := l.svcCtx.CouponModel.FindOneByCode(l.ctx, req.Coupon)
@@ -81,18 +80,18 @@ func (l *PurchaseLogic) Purchase(req *types.PortalPurchaseRequest) (resp *types.
 			}
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find coupon error: %v", err.Error())
 		}
-		if couponInfo.Count <= couponInfo.UsedCount {
-			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponUsed), "coupon used")
+		if couponInfo.Count != 0 && couponInfo.Count <= couponInfo.UsedCount {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponInsufficientUsage), "coupon used")
 		}
 		couponSub := tool.StringToInt64Slice(couponInfo.Subscribe)
 		if len(couponSub) > 0 && !tool.Contains(couponSub, req.SubscribeId) {
-			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponNotMatch), "coupon not match")
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponNotApplicable), "coupon not match")
 		}
-		coupon = calculateCoupon(amount, couponInfo)
+
+		couponAmount = calculateCoupon(amount, couponInfo)
 	}
 	// Calculate the handling fee
-	amount -= coupon
-	var deductionAmount int64
+	amount -= couponAmount
 	// find payment method
 	paymentConfig, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.Payment)
 	if err != nil {
@@ -117,9 +116,9 @@ func (l *PurchaseLogic) Purchase(req *types.PortalPurchaseRequest) (resp *types.
 		Price:          price,
 		Amount:         amount,
 		Discount:       discountAmount,
-		GiftAmount:     deductionAmount,
+		GiftAmount:     0,
 		Coupon:         req.Coupon,
-		CouponDiscount: coupon,
+		CouponDiscount: couponAmount,
 		PaymentId:      req.Payment,
 		Method:         paymentConfig.Platform,
 		FeeAmount:      feeAmount,
@@ -135,14 +134,17 @@ func (l *PurchaseLogic) Purchase(req *types.PortalPurchaseRequest) (resp *types.
 			Identifier: req.Identifier,
 			AuthType:   req.AuthType,
 			Password:   req.Password,
+			InviteCode: req.InviteCode,
 		}
-		if _, err = l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf(constant.TempOrderCacheKey, orderInfo.OrderNo), tempOrder.Marshal(), CloseOrderTimeMinutes*time.Minute).Result(); err != nil {
+		content, _ := tempOrder.Marshal()
+
+		if _, err = l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf(constant.TempOrderCacheKey, orderInfo.OrderNo), string(content), CloseOrderTimeMinutes*time.Minute).Result(); err != nil {
 			l.Errorw("[Purchase] Redis set error", logger.Field("error", err.Error()), logger.Field("order_no", orderInfo.OrderNo))
 			return err
 		}
 		l.Infow("[Purchase] Guest order", logger.Field("order_no", orderInfo.OrderNo), logger.Field("identifier", req.Identifier))
 		// save guest order
-		if err := l.svcCtx.OrderModel.Insert(l.ctx, orderInfo, tx); err != nil {
+		if err = l.svcCtx.OrderModel.Insert(l.ctx, orderInfo, tx); err != nil {
 			return err
 		}
 		return nil

internal/logic/public/portal/queryPurchaseOrderLogic.go

@@ -6,18 +6,18 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/order"
 
-	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/tool"
 
-	"github.com/perfect-panel/ppanel-server/internal/config"
-	"github.com/perfect-panel/ppanel-server/internal/svc"
-	"github.com/perfect-panel/ppanel-server/internal/types"
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
-	"github.com/perfect-panel/ppanel-server/pkg/jwt"
-	"github.com/perfect-panel/ppanel-server/pkg/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/uuidx"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/internal/config"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/jwt"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/uuidx"
+	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
 
@@ -95,7 +95,7 @@ func (l *QueryPurchaseOrderLogic) handleTemporaryOrder(orderInfo *order.Order, r
 	}
 
 	// Validate user and email
-	if err := l.validateUserAndEmail(orderInfo, req.Identifier, req.Identifier); err != nil {
+	if err = l.validateUserAndEmail(orderInfo, req.AuthType, req.Identifier); err != nil {
 		return "", err
 	}
 

internal/logic/public/portal/tool.go

@@ -1,9 +1,9 @@
 package portal
 
 import (
-	"github.com/perfect-panel/ppanel-server/internal/model/coupon"
-	"github.com/perfect-panel/ppanel-server/internal/model/payment"
-	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/server/internal/model/coupon"
+	"github.com/perfect-panel/server/internal/model/payment"
+	"github.com/perfect-panel/server/internal/types"
 )
 
 func getDiscount(discounts []types.SubscribeDiscount, inputMonths int64) float64 {