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

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

internal/logic/public/order/calculateCoupon.go

@@ -1,7 +1,7 @@
 package order
 
 import (
-	"github.com/perfect-panel/ppanel-server/internal/model/coupon"
+	"github.com/perfect-panel/server/internal/model/coupon"
 )
 
 func calculateCoupon(amount int64, couponInfo *coupon.Coupon) int64 {

internal/logic/public/order/calculateFee.go

@@ -1,6 +1,6 @@
 package order
 
-import "github.com/perfect-panel/ppanel-server/internal/model/payment"
+import "github.com/perfect-panel/server/internal/model/payment"
 
 func calculateFee(amount int64, config *payment.Payment) int64 {
 	var fee float64

internal/logic/public/order/closeOrderLogic.go

@@ -3,17 +3,19 @@ package order
 import (
 	"context"
 	"encoding/json"
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/payssion"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/stripe"
+	"time"
+
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/pkg/payment/stripe"
 	"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/logger"
-	"github.com/perfect-panel/ppanel-server/pkg/payment/alipay"
+	"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/logger"
+	"github.com/perfect-panel/server/pkg/payment/alipay"
 )
 
 type CloseOrderLogic struct {
@@ -82,7 +84,7 @@ func (l *CloseOrderLogic) CloseOrder(req *types.CloseOrderRequest) error {
 				return err
 			}
 			deduction := userInfo.GiftAmount + orderInfo.GiftAmount
-			err = tx.Model(&user.User{}).Where("id = ?", orderInfo.UserId).Update("deduction", deduction).Error
+			err = tx.Model(&user.User{}).Where("id = ?", orderInfo.UserId).Update("gift_amount", deduction).Error
 			if err != nil {
 				l.Errorw("[CloseOrder] Refund deduction amount failed",
 					logger.Field("error", err.Error()),
@@ -92,15 +94,25 @@ func (l *CloseOrderLogic) CloseOrder(req *types.CloseOrderRequest) error {
 				return err
 			}
 			// Record the deduction refund log
-			giftAmountLog := &user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    1,
-				Balance: deduction,
-				Remark:  "Order cancellation refund",
+
+			giftLog := log.Gift{
+				Type:        log.GiftTypeIncrease,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     deduction,
+				Remark:      "Order cancellation refund",
+				Timestamp:   time.Now().UnixMilli(),
 			}
-			err = tx.Model(&user.GiftAmountLog{}).Create(giftAmountLog).Error
+			content, _ := giftLog.Marshal()
+
+			err = tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Id:       0,
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: userInfo.Id,
+				Content:  string(content),
+			}).Error
 			if err != nil {
 				l.Errorw("[CloseOrder] Record cancellation refund log failed",
 					logger.Field("error", err.Error()),
@@ -134,8 +146,8 @@ func (l *CloseOrderLogic) confirmationPayment(order *order.Order) bool {
 		if l.queryAlipay(paymentConfig, order.TradeNo) {
 			return true
 		}
-	case Payssion:
-		if l.queryPayssion(paymentConfig, order.TradeNo) {
+	case StripeAlipay:
+		if l.queryStripe(paymentConfig, order.TradeNo) {
 			return true
 		}
 	case StripeWeChatPay:
@@ -195,25 +207,3 @@ func (l *CloseOrderLogic) queryStripe(paymentConfig *payment.Payment, TradeNo st
 	}
 	return status
 }
-
-// queryPayssion Query Stripe payment status
-//
-//nolint:unused
-func (l *CloseOrderLogic) queryPayssion(paymentConfig *payment.Payment, TradeNo string) bool {
-	l.Infof("[CloseOrder]1 Query Payssion called")
-	payssionConfig := payment.PayssionConfig{}
-	if err := json.Unmarshal([]byte(paymentConfig.Config), &payssionConfig); err != nil {
-		l.Errorw("[CloseOrder] Unmarshal error", logger.Field("error", err.Error()))
-		return false
-	}
-	l.Infof("[CloseOrder]2 Query Payssion called")
-	client := payssion.NewClient(payssionConfig.ApiKey, payssionConfig.SecretKey, payssionConfig.PmId, payssionConfig.Currency, payssionConfig.QueryUrl, payssionConfig.CreateUrl)
-	// create payment
-	result, err := client.QueryOrder(TradeNo)
-	if err != nil {
-		l.Errorw("[CloseOrder] Query order status failed", logger.Field("error", err.Error()), logger.Field("TradeNo", TradeNo))
-		return false
-	}
-	l.Infof("[CloseOrder]3 Query Payssion called")
-	return result.Transaction.State == "completed"
-}

internal/logic/public/order/constant.go

@@ -2,7 +2,6 @@ package order
 
 const (
 	Epay            = "epay"
-	Payssion        = "Payssion"
 	AlipayF2f       = "alipay_f2f"
 	StripeAlipay    = "stripe_alipay"
 	StripeWeChatPay = "stripe_wechat_pay"

internal/logic/public/order/getDiscount.go

@@ -1,6 +1,6 @@
 package order
 
-import "github.com/perfect-panel/ppanel-server/internal/types"
+import "github.com/perfect-panel/server/internal/types"
 
 func getDiscount(discounts []types.SubscribeDiscount, inputMonths int64) float64 {
 	var finalDiscount int64 = 100
@@ -10,5 +10,6 @@ func getDiscount(discounts []types.SubscribeDiscount, inputMonths int64) float64
 			finalDiscount = discount.Discount
 		}
 	}
+
 	return float64(finalDiscount) / float64(100)
 }

internal/logic/public/order/preCreateOrderLogic.go

@@ -4,13 +4,16 @@ import (
 	"context"
 	"encoding/json"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/pkg/tool"
 
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"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/constant"
+
+	"github.com/perfect-panel/server/internal/model/user"
+	"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"
 )
@@ -21,7 +24,8 @@ type PreCreateOrderLogic struct {
 	svcCtx *svc.ServiceContext
 }
 
-// Pre create order
+// NewPreCreateOrderLogic creates a new pre-create order logic instance for order preview operations.
+// It initializes the logger with context and sets up the service context for database operations.
 func NewPreCreateOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PreCreateOrderLogic {
 	return &PreCreateOrderLogic{
 		Logger: logger.WithContext(ctx),
@@ -30,12 +34,21 @@ func NewPreCreateOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Pr
 	}
 }
 
+// PreCreateOrder calculates order pricing preview including discounts, coupons, gift amounts, and fees
+// without actually creating an order. It validates subscription plans, coupons, and payment methods
+// to provide accurate pricing information for the frontend order preview.
 func (l *PreCreateOrderLogic) PreCreateOrder(req *types.PurchaseOrderRequest) (resp *types.PreOrderResponse, err error) {
 	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
 	if !ok {
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
+
+	if req.Quantity <= 0 {
+		l.Debugf("[PreCreateOrder] Quantity is less than or equal to 0, setting to 1")
+		req.Quantity = 1
+	}
+
 	// find subscribe plan
 	sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, req.SubscribeId)
 	if err != nil {
@@ -49,9 +62,10 @@ func (l *PreCreateOrderLogic) PreCreateOrder(req *types.PurchaseOrderRequest) (r
 		discount = getDiscount(dis, req.Quantity)
 	}
 	price := sub.UnitPrice * req.Quantity
+
 	amount := int64(float64(price) * discount)
 	discountAmount := price - amount
-	var coupon int64
+	var couponAmount int64
 	if req.Coupon != "" {
 		couponInfo, err := l.svcCtx.CouponModel.FindOneByCode(l.ctx, req.Coupon)
 		if err != nil {
@@ -60,12 +74,30 @@ func (l *PreCreateOrderLogic) PreCreateOrder(req *types.PurchaseOrderRequest) (r
 			}
 			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.CouponAlreadyUsed), "coupon used")
 		}
-		coupon = calculateCoupon(amount, couponInfo)
+		var count int64
+		err = l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+			return tx.Model(&order.Order{}).Where("user_id = ? and coupon = ?", u.Id, req.Coupon).Count(&count).Error
+		})
+
+		if err != nil {
+			l.Errorw("[PreCreateOrder] Database query error", logger.Field("error", err.Error()), logger.Field("user_id", u.Id), logger.Field("coupon", req.Coupon))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find coupon error: %v", err.Error())
+		}
+
+		if couponInfo.UserLimit > 0 && count >= couponInfo.UserLimit {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponInsufficientUsage), "coupon limit exceeded")
+		}
+
+		couponSub := tool.StringToInt64Slice(couponInfo.Subscribe)
+		if len(couponSub) > 0 && !tool.Contains(couponSub, req.SubscribeId) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponNotApplicable), "coupon not match")
+		}
+		couponAmount = calculateCoupon(amount, couponInfo)
 	}
-	amount -= coupon
+	amount -= couponAmount
 
 	var deductionAmount int64
 	// Check user deduction amount
@@ -82,7 +114,7 @@ func (l *PreCreateOrderLogic) PreCreateOrder(req *types.PurchaseOrderRequest) (r
 	if req.Payment != 0 {
 		payment, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.Payment)
 		if err != nil {
-			l.Logger.Error("[PreCreateOrder] Database query error", logger.Field("error", err.Error()), logger.Field("payment", req.Payment))
+			l.Errorw("[PreCreateOrder] Database query error", logger.Field("error", err.Error()), logger.Field("payment", req.Payment))
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find payment method error: %v", err.Error())
 		}
 		// Calculate the handling fee
@@ -98,7 +130,7 @@ func (l *PreCreateOrderLogic) PreCreateOrder(req *types.PurchaseOrderRequest) (r
 		Discount:       discountAmount,
 		GiftAmount:     deductionAmount,
 		Coupon:         req.Coupon,
-		CouponDiscount: coupon,
+		CouponDiscount: couponAmount,
 		FeeAmount:      feeAmount,
 	}
 	return

internal/logic/public/order/purchaseLogic.go

@@ -5,20 +5,21 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"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/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
+	queue "github.com/perfect-panel/server/queue/types"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
 
-	"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/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
 )
 
 type PurchaseLogic struct {
@@ -31,7 +32,8 @@ const (
 	CloseOrderTimeMinutes = 15
 )
 
-// NewPurchaseLogic purchase Subscription
+// NewPurchaseLogic creates a new purchase logic instance for subscription purchase operations.
+// It initializes the logger with context and sets up the service context for database operations.
 func NewPurchaseLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PurchaseLogic {
 	return &PurchaseLogic{
 		Logger: logger.WithContext(ctx),
@@ -40,6 +42,9 @@ func NewPurchaseLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Purchase
 	}
 }
 
+// Purchase processes new subscription purchase orders including validation, discount calculation,
+// coupon processing, gift amount deduction, fee calculation, and order creation with database transaction.
+// It handles the complete purchase workflow from user validation to order creation and task scheduling.
 func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.PurchaseOrderResponse, err error) {
 
 	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
@@ -47,6 +52,12 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
+
+	if req.Quantity <= 0 {
+		l.Debugf("[Purchase] Quantity is less than or equal to 0, setting to 1")
+		req.Quantity = 1
+	}
+
 	// find user subscription
 	userSub, err := l.svcCtx.UserModel.QueryUserSubscribe(l.ctx, u.Id)
 	if err != nil {
@@ -103,12 +114,24 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 			}
 			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")
+		}
+		var count int64
+		err = l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+			return tx.Model(&order.Order{}).Where("user_id = ? and coupon = ?", u.Id, req.Coupon).Count(&count).Error
+		})
+
+		if err != nil {
+			l.Errorw("[Purchase] Database query error", logger.Field("error", err.Error()), logger.Field("user_id", u.Id), logger.Field("coupon", req.Coupon))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find coupon error: %v", err.Error())
+		}
+		if count >= couponInfo.UserLimit {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponInsufficientUsage), "coupon limit exceeded")
 		}
 		coupon = calculateCoupon(amount, couponInfo)
 	}
@@ -120,7 +143,7 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 		if u.GiftAmount >= amount {
 			deductionAmount = amount
 			amount = 0
-			u.GiftAmount -= amount
+			u.GiftAmount -= deductionAmount
 		} else {
 			deductionAmount = u.GiftAmount
 			amount -= u.GiftAmount
@@ -130,13 +153,14 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 	// find payment method
 	payment, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.Payment)
 	if err != nil {
-		l.Logger.Error("[Purchase] Database query error", logger.Field("error", err.Error()), logger.Field("payment", req.Payment))
+		l.Errorw("[Purchase] Database query error", logger.Field("error", err.Error()), logger.Field("payment", req.Payment))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find payment method error: %v", err.Error())
 	}
 	var feeAmount int64
 	// Calculate the handling fee
 	if amount > 0 {
 		feeAmount = calculateFee(amount, payment)
+		amount += feeAmount
 	}
 	// query user is new purchase or renewal
 	isNew, err := l.svcCtx.OrderModel.IsUserEligibleForNewOrder(l.ctx, u.Id)
@@ -168,23 +192,31 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 		// update user deduction && Pre deduction ,Return after canceling the order
 		if orderInfo.GiftAmount > 0 {
 			// update user deduction && Pre deduction ,Return after canceling the order
-			if e := l.svcCtx.UserModel.Update(l.ctx, u, db); err != nil {
-				l.Errorw("[Purchase] Database update error", logger.Field("error", err.Error()), logger.Field("user", u))
+			if e := l.svcCtx.UserModel.Update(l.ctx, u, db); e != nil {
+				l.Errorw("[Purchase] Database update error", logger.Field("error", e.Error()), logger.Field("user", u))
 				return e
 			}
 			// create deduction record
-			giftAmountLog := user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    2,
-				Balance: u.GiftAmount,
-				Remark:  "Purchase order deduction",
+			giftLog := log.Gift{
+				Type:        log.GiftTypeReduce,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     u.GiftAmount,
+				Remark:      "Purchase order deduction",
+				Timestamp:   time.Now().UnixMilli(),
 			}
-			if e := db.Model(&user.GiftAmountLog{}).Create(&giftAmountLog).Error; e != nil {
+			content, _ := giftLog.Marshal()
+
+			if e := db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; e != nil {
 				l.Errorw("[Purchase] Database insert error",
-					logger.Field("error", err.Error()),
-					logger.Field("deductionLog", giftAmountLog),
+					logger.Field("error", e.Error()),
+					logger.Field("deductionLog", giftLog),
 				)
 				return e
 			}
@@ -201,14 +233,14 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 	}
 	val, err := json.Marshal(payload)
 	if err != nil {
-		l.Errorw("[CreateOrder] Marshal payload error", logger.Field("error", err.Error()), logger.Field("payload", payload))
+		l.Errorw("[Purchase] Marshal payload error", logger.Field("error", err.Error()), logger.Field("payload", payload))
 	}
 	task := asynq.NewTask(queue.DeferCloseOrder, val, asynq.MaxRetry(3))
 	taskInfo, err := l.svcCtx.Queue.Enqueue(task, asynq.ProcessIn(CloseOrderTimeMinutes*time.Minute))
 	if err != nil {
-		l.Errorw("[CreateOrder] Enqueue task error", logger.Field("error", err.Error()), logger.Field("task", task))
+		l.Errorw("[Purchase] Enqueue task error", logger.Field("error", err.Error()), logger.Field("task", task))
 	} else {
-		l.Infow("[CreateOrder] Enqueue task success", logger.Field("TaskID", taskInfo.ID))
+		l.Infow("[Purchase] Enqueue task success", logger.Field("TaskID", taskInfo.ID))
 	}
 
 	return &types.PurchaseOrderResponse{

internal/logic/public/order/queryOrderDetailLogic.go

@@ -3,11 +3,11 @@ package order
 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/order/queryOrderListLogic.go

@@ -3,14 +3,14 @@ package order
 import (
 	"context"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/constant"
 
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"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/user"
+	"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/order/rechargeLogic.go

@@ -5,17 +5,17 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/xerr"
 
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"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"
-	queue "github.com/perfect-panel/ppanel-server/queue/types"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/user"
+	"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"
+	queue "github.com/perfect-panel/server/queue/types"
 	"github.com/pkg/errors"
 )
 

internal/logic/public/order/renewalLogic.go

@@ -5,19 +5,20 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/pkg/constant"
 
 	"gorm.io/gorm"
 
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"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/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/user"
+	"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"
+	queue "github.com/perfect-panel/server/queue/types"
 	"github.com/pkg/errors"
 )
 
@@ -27,7 +28,7 @@ type RenewalLogic struct {
 	svcCtx *svc.ServiceContext
 }
 
-// Renewal Subscription
+// NewRenewalLogic creates a new renewal logic instance for subscription renewal operations
 func NewRenewalLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RenewalLogic {
 	return &RenewalLogic{
 		Logger: logger.WithContext(ctx),
@@ -36,12 +37,19 @@ func NewRenewalLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RenewalLo
 	}
 }
 
+// Renewal processes subscription renewal orders including discount calculation,
+// coupon validation, gift amount deduction, fee calculation, and order creation
 func (l *RenewalLogic) Renewal(req *types.RenewalOrderRequest) (resp *types.RenewalOrderResponse, err error) {
 	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
 	if !ok {
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
+	if req.Quantity <= 0 {
+		l.Debugf("[Renewal] Quantity is less than or equal to 0, setting to 1")
+		req.Quantity = 1
+	}
+
 	orderNo := tool.GenerateTradeNo()
 	// find user subscribe
 	userSubscribe, err := l.svcCtx.UserModel.FindOneUserSubscribe(l.ctx, req.UserSubscribeID)
@@ -76,15 +84,31 @@ func (l *RenewalLogic) Renewal(req *types.RenewalOrderRequest) (resp *types.Rene
 			}
 			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, sub.Id) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponNotApplicable), "coupon not match")
+		}
+		var count int64
+		err = l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+			return tx.Model(&order.Order{}).Where("user_id = ? and coupon = ?", u.Id, req.Coupon).Count(&count).Error
+		})
+		if err != nil {
+			l.Errorw("[Renewal] Database query error", logger.Field("error", err.Error()), logger.Field("user_id", u.Id), logger.Field("coupon", req.Coupon))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find coupon error: %v", err.Error())
+		}
+		if count >= couponInfo.UserLimit {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.CouponInsufficientUsage), "coupon limit exceeded")
 		}
 		coupon = calculateCoupon(amount, couponInfo)
 	}
 	payment, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.Payment)
 	if err != nil {
 		l.Errorw("[Renewal] Database query error", logger.Field("error", err.Error()), logger.Field("payment", req.Payment))
-		return nil, errors.Wrapf(err, "find payment error: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find payment error: %v", err.Error())
 	}
 	amount -= coupon
 
@@ -93,8 +117,8 @@ func (l *RenewalLogic) Renewal(req *types.RenewalOrderRequest) (resp *types.Rene
 	if u.GiftAmount > 0 {
 		if u.GiftAmount >= amount {
 			deductionAmount = amount
+			u.GiftAmount -= deductionAmount
 			amount = 0
-			u.GiftAmount -= amount
 		} else {
 			deductionAmount = u.GiftAmount
 			amount -= u.GiftAmount
@@ -136,20 +160,28 @@ func (l *RenewalLogic) Renewal(req *types.RenewalOrderRequest) (resp *types.Rene
 		if orderInfo.GiftAmount > 0 {
 			// update user deduction && Pre deduction ,Return after canceling the order
 			if err := l.svcCtx.UserModel.Update(l.ctx, u, db); err != nil {
-				l.Errorw("[Purchase] Database update error", logger.Field("error", err.Error()), logger.Field("user", u))
+				l.Errorw("[Renewal] Database update error", logger.Field("error", err.Error()), logger.Field("user", u))
 				return err
 			}
 			// create deduction record
-			deductionLog := user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    2,
-				Balance: u.GiftAmount,
-				Remark:  "Renewal order deduction",
+			giftLog := log.Gift{
+				Type:        log.GiftTypeReduce,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     u.GiftAmount,
+				Remark:      "Renewal order deduction",
+				Timestamp:   time.Now().UnixMilli(),
 			}
-			if err := db.Model(&user.GiftAmountLog{}).Create(&deductionLog).Error; err != nil {
-				l.Errorw("[Renewal] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", deductionLog))
+			content, _ := giftLog.Marshal()
+
+			if err := db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; err != nil {
+				l.Errorw("[Renewal] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", giftLog))
 				return err
 			}
 		}

internal/logic/public/order/resetTrafficLogic.go

@@ -5,19 +5,20 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/perfect-panel/ppanel-server/pkg/constant"
-	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/xerr"
 
 	"gorm.io/gorm"
 
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/ppanel-server/internal/model/order"
-	"github.com/perfect-panel/ppanel-server/internal/model/user"
-	"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"
-	queue "github.com/perfect-panel/ppanel-server/queue/types"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/user"
+	"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"
+	queue "github.com/perfect-panel/server/queue/types"
 	"github.com/pkg/errors"
 )
 
@@ -104,16 +105,24 @@ func (l *ResetTrafficLogic) ResetTraffic(req *types.ResetTrafficOrderRequest) (r
 				return err
 			}
 			// create deduction record
-			deductionLog := user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    2,
-				Balance: u.GiftAmount,
-				Remark:  "ResetTraffic order deduction",
+			giftLog := log.Gift{
+				Type:        log.GiftTypeReduce,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     u.GiftAmount,
+				Remark:      "Renewal order deduction",
+				Timestamp:   time.Now().UnixMilli(),
 			}
-			if err := db.Model(&user.GiftAmountLog{}).Create(&deductionLog).Error; err != nil {
-				l.Errorw("[ResetTraffic] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", deductionLog))
+			content, _ := giftLog.Marshal()
+
+			if err = db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; err != nil {
+				l.Errorw("[ResetTraffic] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", content))
 				return err
 			}
 		}