修复(#79): 促销管理后台API + 审查问题修复

- 实现促销管理接口：规则CRUD、优惠价配置、使用记录查询
- 修复 UpsertPrices 新增记录时提前 return 的问题
- DeleteRule/DeletePrice 不存在记录返回 code=404
- SetPromoPriceRequest.items 空数组校验
- 分页参数限制 page>0、1<=size<=200
- 下单侧促销价格按数量档总价口径计算（含 #87 修复）

Co-authored-by: multica-agent <github@multica.ai>

apis/admin/promo.api

@@ -0,0 +1,121 @@
+syntax = "v1"
+
+info (
+	title:   "promo admin API"
+	desc:    "API for ppanel"
+	author:  "Tension"
+	email:   "tension@ppanel.com"
+	version: "0.0.1"
+)
+
+import "../types.api"
+
+type (
+	CreatePromoRuleRequest {
+		Name      string                 `json:"name" validate:"required,max=100"`
+		Type      string                 `json:"type" validate:"required,oneof=new_user inactive_user campaign"`
+		Params    map[string]interface{} `json:"params"`
+		Priority  int64                  `json:"priority" validate:"gte=0"`
+		Enabled   *bool                  `json:"enabled"`
+		StartTime *int64                 `json:"start_time"`
+		EndTime   *int64                 `json:"end_time"`
+	}
+	UpdatePromoRuleRequest {
+		Id        int64                  `uri:"id" validate:"required,gt=0"`
+		Name      string                 `json:"name" validate:"required,max=100"`
+		Type      string                 `json:"type" validate:"required,oneof=new_user inactive_user campaign"`
+		Params    map[string]interface{} `json:"params"`
+		Priority  int64                  `json:"priority" validate:"gte=0"`
+		Enabled   *bool                  `json:"enabled"`
+		StartTime *int64                 `json:"start_time"`
+		EndTime   *int64                 `json:"end_time"`
+	}
+	GetPromoRuleDetailRequest {
+		Id int64 `uri:"id" validate:"required,gt=0"`
+	}
+	DeletePromoRuleRequest {
+		Id int64 `uri:"id" validate:"required,gt=0"`
+	}
+	GetPromoRuleListRequest {
+		Page    int64  `form:"page" validate:"required,gt=0"`
+		Size    int64  `form:"size" validate:"required,gt=0,lte=200"`
+		Type    string `form:"type" validate:"omitempty,oneof=new_user inactive_user campaign"`
+		Enabled *bool  `form:"enabled"`
+		Search  string `form:"search,omitempty"`
+	}
+	GetPromoRuleListResponse {
+		Total int64       `json:"total"`
+		List  []PromoRule `json:"list"`
+	}
+	SetPromoPriceRequest {
+		PromoRuleId int64            `json:"promo_rule_id" validate:"required,gt=0"`
+		Items       []PromoPriceItem `json:"items" validate:"required,min=1,dive"`
+	}
+	GetPromoPriceListRequest {
+		PromoRuleId int64 `form:"promo_rule_id" validate:"required,gt=0"`
+		Page        int64 `form:"page" validate:"required,gt=0"`
+		Size        int64 `form:"size" validate:"required,gt=0,lte=200"`
+	}
+	GetPromoPriceListResponse {
+		Total int64        `json:"total"`
+		List  []PromoPrice `json:"list"`
+	}
+	DeletePromoPriceRequest {
+		Id int64 `uri:"id" validate:"required,gt=0"`
+	}
+	GetPromoUsageListRequest {
+		Page        int64  `form:"page" validate:"required,gt=0"`
+		Size        int64  `form:"size" validate:"required,gt=0,lte=200"`
+		RuleId      int64  `form:"rule_id,omitempty"`
+		UserId      int64  `form:"user_id,omitempty"`
+		SubscribeId int64  `form:"subscribe_id,omitempty"`
+		OrderNo     string `form:"order_no,omitempty"`
+	}
+	GetPromoUsageListResponse {
+		Total int64        `json:"total"`
+		List  []PromoUsage `json:"list"`
+	}
+)
+
+@server (
+	prefix:     v1/admin/promo
+	group:      admin/promo
+	middleware: AuthMiddleware
+)
+service ppanel {
+	@doc "Create promo rule"
+	@handler CreateRule
+	post /rule (CreatePromoRuleRequest) returns (PromoRule)
+
+	@doc "Get promo rule list"
+	@handler GetRuleList
+	get /rule/list (GetPromoRuleListRequest) returns (GetPromoRuleListResponse)
+
+	@doc "Get promo rule detail"
+	@handler GetRuleDetail
+	get /rule/:id (GetPromoRuleDetailRequest) returns (PromoRule)
+
+	@doc "Update promo rule"
+	@handler UpdateRule
+	put /rule/:id (UpdatePromoRuleRequest) returns (PromoRule)
+
+	@doc "Delete promo rule"
+	@handler DeleteRule
+	delete /rule/:id (DeletePromoRuleRequest)
+
+	@doc "Set promo prices"
+	@handler SetPrice
+	post /price (SetPromoPriceRequest)
+
+	@doc "Get promo price list"
+	@handler GetPriceList
+	get /price/list (GetPromoPriceListRequest) returns (GetPromoPriceListResponse)
+
+	@doc "Delete promo price"
+	@handler DeletePrice
+	delete /price/:id (DeletePromoPriceRequest)
+
+	@doc "Get promo usage list"
+	@handler GetUsageList
+	get /usage/list (GetPromoUsageListRequest) returns (GetPromoUsageListResponse)
+}

apis/types.api

@@ -231,6 +231,41 @@ type (
 		MapApple string  `json:"map_apple"`
 		Promo    *SubscribePromo `json:"promo"`
 	}
+	PromoPrice {
+		Id          int64 `json:"id"`
+		SubscribeId int64 `json:"subscribe_id"`
+		PromoRuleId int64 `json:"promo_rule_id"`
+		Quantity    int64 `json:"quantity"`
+		PromoPrice  int64 `json:"promo_price"`
+		CreatedAt   int64 `json:"created_at"`
+		UpdatedAt   int64 `json:"updated_at"`
+	}
+	PromoPriceItem {
+		SubscribeId int64 `json:"subscribe_id" validate:"required,gt=0"`
+		Quantity    int64 `json:"quantity" validate:"required,gt=0,lte=1000"`
+		PromoPrice  int64 `json:"promo_price" validate:"required,gt=0"`
+	}
+	PromoRule {
+		Id        int64                  `json:"id"`
+		Name      string                 `json:"name"`
+		Type      string                 `json:"type"`
+		Params    map[string]interface{} `json:"params"`
+		Priority  int64                  `json:"priority"`
+		Enabled   bool                   `json:"enabled"`
+		StartTime *int64                 `json:"start_time"`
+		EndTime   *int64                 `json:"end_time"`
+		CreatedAt int64                  `json:"created_at"`
+		UpdatedAt int64                  `json:"updated_at"`
+	}
+	PromoUsage {
+		Id          int64  `json:"id"`
+		UserId      int64  `json:"user_id"`
+		PromoRuleId int64  `json:"promo_rule_id"`
+		SubscribeId int64  `json:"subscribe_id"`
+		OrderNo     string `json:"order_no"`
+		PromoPrice  int64  `json:"promo_price"`
+		CreatedAt   int64  `json:"created_at"`
+	}
 	SubscribePromo {
 		RuleName   string `json:"rule_name"`
 		RuleType   string `json:"rule_type"`

internal/handler/admin/promo/createRuleHandler.go

@@ -0,0 +1,23 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func CreateRuleHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.CreatePromoRuleRequest
+		_ = c.ShouldBind(&req)
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewCreateRuleLogic(c.Request.Context(), svcCtx)
+		resp, err := l.CreateRule(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/promo/deletePriceHandler.go

@@ -0,0 +1,26 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func DeletePriceHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.DeletePromoPriceRequest
+		if err := c.ShouldBindUri(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewDeletePriceLogic(c.Request.Context(), svcCtx)
+		err := l.DeletePrice(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/promo/deleteRuleHandler.go

@@ -0,0 +1,26 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func DeleteRuleHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.DeletePromoRuleRequest
+		if err := c.ShouldBindUri(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewDeleteRuleLogic(c.Request.Context(), svcCtx)
+		err := l.DeleteRule(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/promo/getPriceListHandler.go

@@ -0,0 +1,23 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func GetPriceListHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetPromoPriceListRequest
+		_ = c.ShouldBind(&req)
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewGetPriceListLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetPriceList(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/promo/getRuleDetailHandler.go

@@ -0,0 +1,26 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func GetRuleDetailHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetPromoRuleDetailRequest
+		if err := c.ShouldBindUri(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewGetRuleDetailLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetRuleDetail(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/promo/getRuleListHandler.go

@@ -0,0 +1,23 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func GetRuleListHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetPromoRuleListRequest
+		_ = c.ShouldBind(&req)
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewGetRuleListLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetRuleList(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/promo/getUsageListHandler.go

@@ -0,0 +1,23 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func GetUsageListHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetPromoUsageListRequest
+		_ = c.ShouldBind(&req)
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewGetUsageListLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetUsageList(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/promo/setPriceHandler.go

@@ -0,0 +1,23 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func SetPriceHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.SetPromoPriceRequest
+		_ = c.ShouldBind(&req)
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewSetPriceLogic(c.Request.Context(), svcCtx)
+		err := l.SetPrice(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/promo/updateRuleHandler.go

@@ -0,0 +1,27 @@
+package promo
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+func UpdateRuleHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.UpdatePromoRuleRequest
+		if err := c.ShouldBindUri(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		_ = c.ShouldBind(&req)
+		if err := svcCtx.Validate(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		l := promo.NewUpdateRuleLogic(c.Request.Context(), svcCtx)
+		resp, err := l.UpdateRule(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/routes.go

@@ -17,6 +17,7 @@ import (
 	adminMarketing "github.com/perfect-panel/server/internal/handler/admin/marketing"
 	adminOrder "github.com/perfect-panel/server/internal/handler/admin/order"
 	adminPayment "github.com/perfect-panel/server/internal/handler/admin/payment"
+	adminPromo "github.com/perfect-panel/server/internal/handler/admin/promo"
 	adminRedemption "github.com/perfect-panel/server/internal/handler/admin/redemption"
 	adminServer "github.com/perfect-panel/server/internal/handler/admin/server"
 	adminSubscribe "github.com/perfect-panel/server/internal/handler/admin/subscribe"
@@ -374,6 +375,38 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 		adminPaymentGroupRouter.GET("/platform", adminPayment.GetPaymentPlatformHandler(serverCtx))
 	}
 
+	adminPromoGroupRouter := router.Group("/v1/admin/promo")
+	adminPromoGroupRouter.Use(middleware.AuthMiddleware(serverCtx))
+
+	{
+		// Create promo rule
+		adminPromoGroupRouter.POST("/rule", adminPromo.CreateRuleHandler(serverCtx))
+
+		// Get promo rule list
+		adminPromoGroupRouter.GET("/rule/list", adminPromo.GetRuleListHandler(serverCtx))
+
+		// Get promo rule detail
+		adminPromoGroupRouter.GET("/rule/:id", adminPromo.GetRuleDetailHandler(serverCtx))
+
+		// Update promo rule
+		adminPromoGroupRouter.PUT("/rule/:id", adminPromo.UpdateRuleHandler(serverCtx))
+
+		// Delete promo rule
+		adminPromoGroupRouter.DELETE("/rule/:id", adminPromo.DeleteRuleHandler(serverCtx))
+
+		// Set promo prices
+		adminPromoGroupRouter.POST("/price", adminPromo.SetPriceHandler(serverCtx))
+
+		// Get promo price list
+		adminPromoGroupRouter.GET("/price/list", adminPromo.GetPriceListHandler(serverCtx))
+
+		// Delete promo price
+		adminPromoGroupRouter.DELETE("/price/:id", adminPromo.DeletePriceHandler(serverCtx))
+
+		// Get promo usage list
+		adminPromoGroupRouter.GET("/usage/list", adminPromo.GetUsageListHandler(serverCtx))
+	}
+
 	adminRedemptionGroupRouter := router.Group("/v1/admin/redemption")
 	adminRedemptionGroupRouter.Use(middleware.AuthMiddleware(serverCtx))
 

internal/logic/admin/promo/createRuleLogic.go

@@ -0,0 +1,58 @@
+package promo
+
+import (
+	"context"
+
+	promomodel "github.com/perfect-panel/server/internal/model/promo"
+	"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"
+)
+
+type CreateRuleLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateRuleLogic {
+	return &CreateRuleLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateRuleLogic) CreateRule(req *types.CreatePromoRuleRequest) (*types.PromoRule, error) {
+	if err := validateRuleInput(req.Type, req.Params, req.Priority, req.StartTime, req.EndTime); err != nil {
+		return nil, err
+	}
+	params, err := paramsToString(req.Params)
+	if err != nil {
+		return nil, err
+	}
+	enabled := true
+	if req.Enabled != nil {
+		enabled = *req.Enabled
+	}
+	rule := &promomodel.Rule{
+		Name:      req.Name,
+		Type:      req.Type,
+		Params:    params,
+		Priority:  req.Priority,
+		Enabled:   enabled,
+		StartTime: unixPtrToTimePtr(req.StartTime),
+		EndTime:   unixPtrToTimePtr(req.EndTime),
+	}
+	if err := l.svcCtx.PromoModel.InsertRule(l.ctx, rule); err != nil {
+		l.Errorw("[CreatePromoRule] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create promo rule error: %v", err.Error())
+	}
+	if err := l.svcCtx.Redis.Del(l.ctx, ruleCacheKey).Err(); err != nil {
+		l.Errorw("[CreatePromoRule] Delete Cache Error", logger.Field("error", err.Error()))
+	}
+	resp := convertRule(rule)
+	return &resp, nil
+}

internal/logic/admin/promo/deletePriceLogic.go

@@ -0,0 +1,47 @@
+package promo
+
+import (
+	"context"
+	stderrors "errors"
+
+	"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"
+)
+
+type DeletePriceLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeletePriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeletePriceLogic {
+	return &DeletePriceLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeletePriceLogic) DeletePrice(req *types.DeletePromoPriceRequest) error {
+	price, err := l.svcCtx.PromoModel.FindPrice(l.ctx, req.Id)
+	if err != nil {
+		if stderrors.Is(err, gorm.ErrRecordNotFound) {
+			l.Errorw("[DeletePromoPrice] Price Not Found", logger.Field("id", req.Id))
+			return errors.Wrapf(xerr.NewErrCodeMsg(404, "promo price not found"), "promo price not found: %d", req.Id)
+		}
+		l.Errorw("[DeletePromoPrice] Find Price Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo price error: %v", err.Error())
+	}
+	if err := l.svcCtx.PromoModel.DeletePrice(l.ctx, req.Id); err != nil {
+		l.Errorw("[DeletePromoPrice] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete promo price error: %v", err.Error())
+	}
+	if err := l.svcCtx.Redis.Del(l.ctx, subscribePromoCacheKey(price.SubscribeId)).Err(); err != nil {
+		l.Errorw("[DeletePromoPrice] Delete Cache Error", logger.Field("error", err.Error()))
+	}
+	return nil
+}

internal/logic/admin/promo/deleteRuleLogic.go

@@ -0,0 +1,46 @@
+package promo
+
+import (
+	"context"
+	stderrors "errors"
+
+	"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"
+)
+
+type DeleteRuleLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteRuleLogic {
+	return &DeleteRuleLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteRuleLogic) DeleteRule(req *types.DeletePromoRuleRequest) error {
+	if _, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id); err != nil {
+		if stderrors.Is(err, gorm.ErrRecordNotFound) {
+			l.Errorw("[DeletePromoRule] Rule Not Found", logger.Field("id", req.Id))
+			return errors.Wrapf(xerr.NewErrCodeMsg(404, "promo rule not found"), "promo rule not found: %d", req.Id)
+		}
+		l.Errorw("[DeletePromoRule] Find Rule Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo rule error: %v", err.Error())
+	}
+	if err := l.svcCtx.PromoModel.DeleteRule(l.ctx, req.Id); err != nil {
+		l.Errorw("[DeletePromoRule] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete promo rule error: %v", err.Error())
+	}
+	if err := l.svcCtx.Redis.Del(l.ctx, ruleCacheKey).Err(); err != nil {
+		l.Errorw("[DeletePromoRule] Delete Cache Error", logger.Field("error", err.Error()))
+	}
+	return nil
+}

internal/logic/admin/promo/delete_not_found_test.go

@@ -0,0 +1,93 @@
+package promo
+
+import (
+	"context"
+	"testing"
+
+	promomodel "github.com/perfect-panel/server/internal/model/promo"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/xerr"
+	pkgerrors "github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type fakePromoModel struct{}
+
+func (fakePromoModel) QueryEligibleRules(context.Context, int64, int64) ([]*promomodel.RuleWithPrice, error) {
+	return nil, nil
+}
+
+func (fakePromoModel) InsertUsage(context.Context, *promomodel.Usage, ...*gorm.DB) error {
+	return nil
+}
+
+func (fakePromoModel) InsertRule(context.Context, *promomodel.Rule) error {
+	return nil
+}
+
+func (fakePromoModel) FindRule(context.Context, int64) (*promomodel.Rule, error) {
+	return nil, gorm.ErrRecordNotFound
+}
+
+func (fakePromoModel) UpdateRule(context.Context, *promomodel.Rule) error {
+	return nil
+}
+
+func (fakePromoModel) DeleteRule(context.Context, int64) error {
+	return nil
+}
+
+func (fakePromoModel) QueryRuleList(context.Context, int, int, string, *bool, string) (int64, []*promomodel.Rule, error) {
+	return 0, nil, nil
+}
+
+func (fakePromoModel) UpsertPrices(context.Context, int64, []*promomodel.SubscribePromo) error {
+	return nil
+}
+
+func (fakePromoModel) FindPrice(context.Context, int64) (*promomodel.SubscribePromo, error) {
+	return nil, gorm.ErrRecordNotFound
+}
+
+func (fakePromoModel) DeletePrice(context.Context, int64) error {
+	return nil
+}
+
+func (fakePromoModel) QueryPriceList(context.Context, int64, int, int) (int64, []*promomodel.SubscribePromo, error) {
+	return 0, nil, nil
+}
+
+func (fakePromoModel) QueryUsageList(context.Context, promomodel.UsageFilter) (int64, []*promomodel.Usage, error) {
+	return 0, nil, nil
+}
+
+func (fakePromoModel) Transaction(context.Context, func(*gorm.DB) error) error {
+	return nil
+}
+
+func TestDeleteRuleNotFoundReturns404(t *testing.T) {
+	svcCtx := &svc.ServiceContext{PromoModel: fakePromoModel{}}
+	err := NewDeleteRuleLogic(context.Background(), svcCtx).DeleteRule(&types.DeletePromoRuleRequest{Id: 1})
+	assertCodeError(t, err, 404)
+}
+
+func TestDeletePriceNotFoundReturns404(t *testing.T) {
+	svcCtx := &svc.ServiceContext{PromoModel: fakePromoModel{}}
+	err := NewDeletePriceLogic(context.Background(), svcCtx).DeletePrice(&types.DeletePromoPriceRequest{Id: 1})
+	assertCodeError(t, err, 404)
+}
+
+func assertCodeError(t *testing.T, err error, want uint32) {
+	t.Helper()
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	codeErr, ok := pkgerrors.Cause(err).(*xerr.CodeError)
+	if !ok {
+		t.Fatalf("expected CodeError, got %T", pkgerrors.Cause(err))
+	}
+	if got := codeErr.GetErrCode(); got != want {
+		t.Fatalf("unexpected error code: got %d want %d", got, want)
+	}
+}

internal/logic/admin/promo/getPriceListLogic.go

@@ -0,0 +1,41 @@
+package promo
+
+import (
+	"context"
+
+	"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"
+)
+
+type GetPriceListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetPriceListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPriceListLogic {
+	return &GetPriceListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPriceListLogic) GetPriceList(req *types.GetPromoPriceListRequest) (*types.GetPromoPriceListResponse, error) {
+	total, list, err := l.svcCtx.PromoModel.QueryPriceList(l.ctx, req.PromoRuleId, int(req.Page), int(req.Size))
+	if err != nil {
+		l.Errorw("[GetPromoPriceList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo price list error: %v", err.Error())
+	}
+	resp := &types.GetPromoPriceListResponse{
+		Total: total,
+		List:  make([]types.PromoPrice, 0, len(list)),
+	}
+	for _, item := range list {
+		resp.List = append(resp.List, convertPrice(item))
+	}
+	return resp, nil
+}

internal/logic/admin/promo/getRuleDetailLogic.go

@@ -0,0 +1,35 @@
+package promo
+
+import (
+	"context"
+
+	"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"
+)
+
+type GetRuleDetailLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetRuleDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRuleDetailLogic {
+	return &GetRuleDetailLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetRuleDetailLogic) GetRuleDetail(req *types.GetPromoRuleDetailRequest) (*types.PromoRule, error) {
+	rule, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[GetPromoRuleDetail] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo rule detail error: %v", err.Error())
+	}
+	resp := convertRule(rule)
+	return &resp, nil
+}

internal/logic/admin/promo/getRuleListLogic.go

@@ -0,0 +1,41 @@
+package promo
+
+import (
+	"context"
+
+	"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"
+)
+
+type GetRuleListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetRuleListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRuleListLogic {
+	return &GetRuleListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetRuleListLogic) GetRuleList(req *types.GetPromoRuleListRequest) (*types.GetPromoRuleListResponse, error) {
+	total, list, err := l.svcCtx.PromoModel.QueryRuleList(l.ctx, int(req.Page), int(req.Size), req.Type, req.Enabled, req.Search)
+	if err != nil {
+		l.Errorw("[GetPromoRuleList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo rule list error: %v", err.Error())
+	}
+	resp := &types.GetPromoRuleListResponse{
+		Total: total,
+		List:  make([]types.PromoRule, 0, len(list)),
+	}
+	for _, item := range list {
+		resp.List = append(resp.List, convertRule(item))
+	}
+	return resp, nil
+}

internal/logic/admin/promo/getUsageListLogic.go

@@ -0,0 +1,49 @@
+package promo
+
+import (
+	"context"
+
+	promomodel "github.com/perfect-panel/server/internal/model/promo"
+	"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"
+)
+
+type GetUsageListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetUsageListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUsageListLogic {
+	return &GetUsageListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetUsageListLogic) GetUsageList(req *types.GetPromoUsageListRequest) (*types.GetPromoUsageListResponse, error) {
+	total, list, err := l.svcCtx.PromoModel.QueryUsageList(l.ctx, promomodel.UsageFilter{
+		Page:        int(req.Page),
+		Size:        int(req.Size),
+		RuleId:      req.RuleId,
+		UserId:      req.UserId,
+		SubscribeId: req.SubscribeId,
+		OrderNo:     req.OrderNo,
+	})
+	if err != nil {
+		l.Errorw("[GetPromoUsageList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo usage list error: %v", err.Error())
+	}
+	resp := &types.GetPromoUsageListResponse{
+		Total: total,
+		List:  make([]types.PromoUsage, 0, len(list)),
+	}
+	for _, item := range list {
+		resp.List = append(resp.List, convertUsage(item))
+	}
+	return resp, nil
+}

internal/logic/admin/promo/setPriceLogic.go

@@ -0,0 +1,81 @@
+package promo
+
+import (
+	"context"
+
+	promomodel "github.com/perfect-panel/server/internal/model/promo"
+	subscribeModel "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/xerr"
+	"github.com/pkg/errors"
+)
+
+type SetPriceLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewSetPriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SetPriceLogic {
+	return &SetPriceLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SetPriceLogic) SetPrice(req *types.SetPromoPriceRequest) error {
+	if _, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.PromoRuleId); err != nil {
+		l.Errorw("[SetPromoPrice] Find Rule Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo rule error: %v", err.Error())
+	}
+	subscribeIds := make([]int64, 0, len(req.Items))
+	seenSubscribeIds := make(map[int64]struct{}, len(req.Items))
+	for _, item := range req.Items {
+		if _, ok := seenSubscribeIds[item.SubscribeId]; ok {
+			continue
+		}
+		seenSubscribeIds[item.SubscribeId] = struct{}{}
+		subscribeIds = append(subscribeIds, item.SubscribeId)
+	}
+	var subscribes []*subscribeModel.Subscribe
+	if err := l.svcCtx.DB.WithContext(l.ctx).Model(&subscribeModel.Subscribe{}).Where("id IN ?", subscribeIds).Find(&subscribes).Error; err != nil {
+		l.Errorw("[SetPromoPrice] Find Subscribe Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find subscribe error: %v", err.Error())
+	}
+	subscribeById := make(map[int64]*subscribeModel.Subscribe, len(subscribes))
+	for _, sub := range subscribes {
+		subscribeById[sub.Id] = sub
+	}
+	items := make([]*promomodel.SubscribePromo, 0, len(req.Items))
+	cacheKeys := make([]string, 0, len(req.Items))
+	for _, item := range req.Items {
+		sub, ok := subscribeById[item.SubscribeId]
+		if !ok {
+			return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "subscribe plan not found")
+		}
+		originPrice := sub.UnitPrice * item.Quantity
+		if item.PromoPrice >= originPrice {
+			return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "promo_price must be less than unit_price * quantity")
+		}
+		items = append(items, &promomodel.SubscribePromo{
+			SubscribeId: item.SubscribeId,
+			PromoRuleId: req.PromoRuleId,
+			Quantity:    item.Quantity,
+			PromoPrice:  item.PromoPrice,
+		})
+		cacheKeys = append(cacheKeys, subscribePromoCacheKey(item.SubscribeId))
+	}
+	if err := l.svcCtx.PromoModel.UpsertPrices(l.ctx, req.PromoRuleId, items); err != nil {
+		l.Errorw("[SetPromoPrice] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "set promo price error: %v", err.Error())
+	}
+	if len(cacheKeys) > 0 {
+		if err := l.svcCtx.Redis.Del(l.ctx, cacheKeys...).Err(); err != nil {
+			l.Errorw("[SetPromoPrice] Delete Cache Error", logger.Field("error", err.Error()))
+		}
+	}
+	return nil
+}

internal/logic/admin/promo/tool.go

@@ -0,0 +1,162 @@
+package promo
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"time"
+
+	promomodel "github.com/perfect-panel/server/internal/model/promo"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+const (
+	ruleCacheKey       = "promo:rules:enabled"
+	subscribeCachePref = "promo:subscribe:"
+)
+
+func validateRuleInput(ruleType string, params map[string]interface{}, priority int64, startTime, endTime *int64) error {
+	if priority < 0 {
+		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "priority must be greater than or equal to 0")
+	}
+	if startTime != nil && endTime != nil && *startTime >= *endTime {
+		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "start_time must be less than end_time")
+	}
+	switch ruleType {
+	case "new_user":
+		windowHours, ok := numberParam(params, "window_hours")
+		if !ok || windowHours <= 0 {
+			return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "params.window_hours must be greater than 0")
+		}
+	case "inactive_user":
+		inactiveMonths, ok := numberParam(params, "inactive_months")
+		if !ok || inactiveMonths <= 0 {
+			return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "params.inactive_months must be greater than 0")
+		}
+	case "campaign":
+		if params == nil {
+			return nil
+		}
+	default:
+		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "unsupported promo rule type")
+	}
+	return nil
+}
+
+func numberParam(params map[string]interface{}, key string) (int64, bool) {
+	if params == nil {
+		return 0, false
+	}
+	value, ok := params[key]
+	if !ok {
+		return 0, false
+	}
+	switch v := value.(type) {
+	case float64:
+		if math.Trunc(v) != v {
+			return 0, false
+		}
+		return int64(v), true
+	case int64:
+		return v, true
+	case int:
+		return int64(v), true
+	case json.Number:
+		n, err := v.Int64()
+		return n, err == nil
+	default:
+		return 0, false
+	}
+}
+
+func paramsToString(params map[string]interface{}) (string, error) {
+	if params == nil {
+		params = map[string]interface{}{}
+	}
+	b, err := json.Marshal(params)
+	if err != nil {
+		return "", errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "invalid params")
+	}
+	return string(b), nil
+}
+
+func parseParams(data string) map[string]interface{} {
+	if data == "" {
+		return map[string]interface{}{}
+	}
+	var params map[string]interface{}
+	if err := json.Unmarshal([]byte(data), &params); err != nil {
+		return map[string]interface{}{}
+	}
+	return params
+}
+
+func unixPtrToTimePtr(ts *int64) *time.Time {
+	if ts == nil || *ts == 0 {
+		return nil
+	}
+	t := time.Unix(*ts, 0)
+	return &t
+}
+
+func timePtrToUnixPtr(t *time.Time) *int64 {
+	if t == nil {
+		return nil
+	}
+	ts := t.Unix()
+	return &ts
+}
+
+func convertRule(item *promomodel.Rule) types.PromoRule {
+	if item == nil {
+		return types.PromoRule{}
+	}
+	return types.PromoRule{
+		Id:        item.Id,
+		Name:      item.Name,
+		Type:      item.Type,
+		Params:    parseParams(item.Params),
+		Priority:  item.Priority,
+		Enabled:   item.Enabled,
+		StartTime: timePtrToUnixPtr(item.StartTime),
+		EndTime:   timePtrToUnixPtr(item.EndTime),
+		CreatedAt: item.CreatedAt.Unix(),
+		UpdatedAt: item.UpdatedAt.Unix(),
+	}
+}
+
+func convertPrice(item *promomodel.SubscribePromo) types.PromoPrice {
+	if item == nil {
+		return types.PromoPrice{}
+	}
+	return types.PromoPrice{
+		Id:          item.Id,
+		SubscribeId: item.SubscribeId,
+		PromoRuleId: item.PromoRuleId,
+		Quantity:    item.Quantity,
+		PromoPrice:  item.PromoPrice,
+		CreatedAt:   item.CreatedAt.Unix(),
+		UpdatedAt:   item.UpdatedAt.Unix(),
+	}
+}
+
+func convertUsage(item *promomodel.Usage) types.PromoUsage {
+	if item == nil {
+		return types.PromoUsage{}
+	}
+	return types.PromoUsage{
+		Id:          item.Id,
+		UserId:      item.UserId,
+		PromoRuleId: item.PromoRuleId,
+		SubscribeId: item.SubscribeId,
+		OrderNo:     item.OrderNo,
+		PromoPrice:  item.PromoPrice,
+		CreatedAt:   item.CreatedAt.Unix(),
+	}
+}
+
+func subscribePromoCacheKey(subscribeId int64) string {
+	return fmt.Sprintf("%s%d", subscribeCachePref, subscribeId)
+}

internal/logic/admin/promo/updateRuleLogic.go

@@ -0,0 +1,60 @@
+package promo
+
+import (
+	"context"
+
+	"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"
+)
+
+type UpdateRuleLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateRuleLogic {
+	return &UpdateRuleLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateRuleLogic) UpdateRule(req *types.UpdatePromoRuleRequest) (*types.PromoRule, error) {
+	if err := validateRuleInput(req.Type, req.Params, req.Priority, req.StartTime, req.EndTime); err != nil {
+		return nil, err
+	}
+	rule, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[UpdatePromoRule] Find Rule Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo rule error: %v", err.Error())
+	}
+	params, err := paramsToString(req.Params)
+	if err != nil {
+		return nil, err
+	}
+	enabled := rule.Enabled
+	if req.Enabled != nil {
+		enabled = *req.Enabled
+	}
+	rule.Name = req.Name
+	rule.Type = req.Type
+	rule.Params = params
+	rule.Priority = req.Priority
+	rule.Enabled = enabled
+	rule.StartTime = unixPtrToTimePtr(req.StartTime)
+	rule.EndTime = unixPtrToTimePtr(req.EndTime)
+	if err := l.svcCtx.PromoModel.UpdateRule(l.ctx, rule); err != nil {
+		l.Errorw("[UpdatePromoRule] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update promo rule error: %v", err.Error())
+	}
+	if err := l.svcCtx.Redis.Del(l.ctx, ruleCacheKey).Err(); err != nil {
+		l.Errorw("[UpdatePromoRule] Delete Cache Error", logger.Field("error", err.Error()))
+	}
+	resp := convertRule(rule)
+	return &resp, nil
+}

internal/logic/public/order/promoPricing.go

@@ -40,8 +40,8 @@ func calculatePurchasePrice(
 		if err != nil {
 			return nil, err
 		}
-		if promoResult != nil && promoResult.Eligible && promoResult.PromoPrice < unitPrice {
-			result.PayableBase = promoResult.PromoPrice * quantity
+		if promoResult != nil && promoResult.Eligible && promoResult.PromoPrice < originalPrice {
+			result.PayableBase = promoResult.PromoPrice
 			result.PromoRuleId = promoResult.RuleID
 			result.PromoDiscount = originalPrice - result.PayableBase
 			result.PromoPrice = promoResult.PromoPrice

internal/logic/public/order/promoPricing_test.go

@@ -31,7 +31,51 @@ func (m *fakePromoModel) InsertUsage(context.Context, *promo.Usage, ...*gorm.DB)
 	return nil
 }
 
-func TestCalculatePurchasePricePromoSkipsPercentDiscount(t *testing.T) {
+func (m *fakePromoModel) InsertRule(context.Context, *promo.Rule) error {
+	return nil
+}
+
+func (m *fakePromoModel) FindRule(context.Context, int64) (*promo.Rule, error) {
+	return nil, gorm.ErrRecordNotFound
+}
+
+func (m *fakePromoModel) UpdateRule(context.Context, *promo.Rule) error {
+	return nil
+}
+
+func (m *fakePromoModel) DeleteRule(context.Context, int64) error {
+	return nil
+}
+
+func (m *fakePromoModel) QueryRuleList(context.Context, int, int, string, *bool, string) (int64, []*promo.Rule, error) {
+	return 0, nil, nil
+}
+
+func (m *fakePromoModel) UpsertPrices(context.Context, int64, []*promo.SubscribePromo) error {
+	return nil
+}
+
+func (m *fakePromoModel) FindPrice(context.Context, int64) (*promo.SubscribePromo, error) {
+	return nil, gorm.ErrRecordNotFound
+}
+
+func (m *fakePromoModel) DeletePrice(context.Context, int64) error {
+	return nil
+}
+
+func (m *fakePromoModel) QueryPriceList(context.Context, int64, int, int) (int64, []*promo.SubscribePromo, error) {
+	return 0, nil, nil
+}
+
+func (m *fakePromoModel) QueryUsageList(context.Context, promo.UsageFilter) (int64, []*promo.Usage, error) {
+	return 0, nil, nil
+}
+
+func (m *fakePromoModel) Transaction(context.Context, func(*gorm.DB) error) error {
+	return nil
+}
+
+func TestCalculatePurchasePricePromoUsesQuantityTierTotalPrice(t *testing.T) {
 	model := &fakePromoModel{rules: []*promo.RuleWithPrice{
 		{
 			Rule: promo.Rule{
@@ -40,7 +84,7 @@ func TestCalculatePurchasePricePromoSkipsPercentDiscount(t *testing.T) {
 				Type:    promo.RuleTypeCampaign,
 				Enabled: true,
 			},
-			PromoPrice: 600,
+			PromoPrice: 279,
 		},
 	}}
 	svcCtx := &svc.ServiceContext{
@@ -53,9 +97,9 @@ func TestCalculatePurchasePricePromoSkipsPercentDiscount(t *testing.T) {
 		svcCtx,
 		1,
 		2,
-		1000,
-		3,
-		[]types.SubscribeDiscount{{Quantity: 3, Discount: 50}},
+		100,
+		7,
+		[]types.SubscribeDiscount{{Quantity: 7, Discount: 50}},
 		true,
 		true,
 	)
@@ -63,11 +107,11 @@ func TestCalculatePurchasePricePromoSkipsPercentDiscount(t *testing.T) {
 		t.Fatalf("calculatePurchasePrice returned error: %v", err)
 	}
 
-	if result.OriginalPrice != 3000 {
-		t.Fatalf("OriginalPrice = %d, want 3000", result.OriginalPrice)
+	if result.OriginalPrice != 700 {
+		t.Fatalf("OriginalPrice = %d, want 700", result.OriginalPrice)
 	}
-	if result.PayableBase != 1800 {
-		t.Fatalf("PayableBase = %d, want 1800", result.PayableBase)
+	if result.PayableBase != 279 {
+		t.Fatalf("PayableBase = %d, want 279", result.PayableBase)
 	}
 	if result.DiscountAmount != 0 {
 		t.Fatalf("DiscountAmount = %d, want 0", result.DiscountAmount)
@@ -75,11 +119,14 @@ func TestCalculatePurchasePricePromoSkipsPercentDiscount(t *testing.T) {
 	if result.PromoRuleId != 9 {
 		t.Fatalf("PromoRuleId = %d, want 9", result.PromoRuleId)
 	}
-	if result.PromoDiscount != 1200 {
-		t.Fatalf("PromoDiscount = %d, want 1200", result.PromoDiscount)
+	if result.PromoDiscount != 421 {
+		t.Fatalf("PromoDiscount = %d, want 421", result.PromoDiscount)
 	}
-	if model.lastQuantity != 3 {
-		t.Fatalf("promo query quantity = %d, want 3", model.lastQuantity)
+	if result.PromoPrice != 279 {
+		t.Fatalf("PromoPrice = %d, want 279", result.PromoPrice)
+	}
+	if model.lastQuantity != 7 {
+		t.Fatalf("promo query quantity = %d, want 7", model.lastQuantity)
 	}
 }
 
@@ -92,7 +139,7 @@ func TestCalculatePurchasePriceIgnoresInvalidPromoPrice(t *testing.T) {
 				Type:    promo.RuleTypeCampaign,
 				Enabled: true,
 			},
-			PromoPrice: 1000,
+			PromoPrice: 3000,
 		},
 	}}
 	svcCtx := &svc.ServiceContext{
@@ -137,7 +184,7 @@ func TestCalculatePurchasePricePassesQuantityToPromoEvaluation(t *testing.T) {
 					Type:    promo.RuleTypeCampaign,
 					Enabled: true,
 				},
-				PromoPrice: 500,
+				PromoPrice: 3000,
 			},
 		},
 	}

internal/model/promo/model.go

@@ -2,6 +2,7 @@ package promo
 
 import (
 	"context"
+	"errors"
 
 	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
@@ -15,6 +16,26 @@ type RuleWithPrice struct {
 type Model interface {
 	QueryEligibleRules(ctx context.Context, subscribeId int64, quantity int64) ([]*RuleWithPrice, error)
 	InsertUsage(ctx context.Context, data *Usage, tx ...*gorm.DB) error
+	InsertRule(ctx context.Context, data *Rule) error
+	FindRule(ctx context.Context, id int64) (*Rule, error)
+	UpdateRule(ctx context.Context, data *Rule) error
+	DeleteRule(ctx context.Context, id int64) error
+	QueryRuleList(ctx context.Context, page, size int, ruleType string, enabled *bool, search string) (int64, []*Rule, error)
+	UpsertPrices(ctx context.Context, ruleId int64, items []*SubscribePromo) error
+	FindPrice(ctx context.Context, id int64) (*SubscribePromo, error)
+	DeletePrice(ctx context.Context, id int64) error
+	QueryPriceList(ctx context.Context, ruleId int64, page, size int) (int64, []*SubscribePromo, error)
+	QueryUsageList(ctx context.Context, params UsageFilter) (int64, []*Usage, error)
+	Transaction(ctx context.Context, fn func(db *gorm.DB) error) error
+}
+
+type UsageFilter struct {
+	Page        int
+	Size        int
+	RuleId      int64
+	UserId      int64
+	SubscribeId int64
+	OrderNo     string
 }
 
 type defaultPromoModel struct {
@@ -27,20 +48,16 @@ func NewModel(db *gorm.DB, _ *redis.Client) Model {
 
 func (m *defaultPromoModel) QueryEligibleRules(ctx context.Context, subscribeId int64, quantity int64) ([]*RuleWithPrice, error) {
 	var list []*RuleWithPrice
-	err := m.eligibleRulesQuery(ctx, subscribeId, quantity).
-		Find(&list).Error
-	return list, err
-}
-
-func (m *defaultPromoModel) eligibleRulesQuery(ctx context.Context, subscribeId int64, quantity int64) *gorm.DB {
-	return m.db.WithContext(ctx).
+	err := m.db.WithContext(ctx).
 		Table("promo_rule AS pr").
 		Select("pr.*, sp.promo_price").
-		Joins("JOIN subscribe_promo AS sp ON sp.promo_rule_id = pr.id AND sp.quantity = ?", quantity).
-		Where("sp.subscribe_id = ? AND sp.promo_price > 0 AND pr.enabled = ?", subscribeId, true).
+		Joins("JOIN subscribe_promo AS sp ON sp.promo_rule_id = pr.id").
+		Where("sp.subscribe_id = ? AND sp.quantity = ? AND sp.promo_price > 0 AND pr.enabled = ?", subscribeId, quantity, true).
 		Where("pr.deleted_at IS NULL").
 		Order("pr.priority DESC").
-		Order("pr.id ASC")
+		Order("pr.id ASC").
+		Find(&list).Error
+	return list, err
 }
 
 func (m *defaultPromoModel) InsertUsage(ctx context.Context, data *Usage, tx ...*gorm.DB) error {
@@ -50,3 +67,149 @@ func (m *defaultPromoModel) InsertUsage(ctx context.Context, data *Usage, tx ...
 	}
 	return db.Model(&Usage{}).Create(data).Error
 }
+
+func (m *defaultPromoModel) InsertRule(ctx context.Context, data *Rule) error {
+	return m.db.WithContext(ctx).Create(data).Error
+}
+
+func (m *defaultPromoModel) FindRule(ctx context.Context, id int64) (*Rule, error) {
+	var resp Rule
+	if err := m.db.WithContext(ctx).Model(&Rule{}).Where("id = ?", id).First(&resp).Error; err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (m *defaultPromoModel) UpdateRule(ctx context.Context, data *Rule) error {
+	return m.db.WithContext(ctx).Model(&Rule{}).Where("id = ?", data.Id).Updates(map[string]interface{}{
+		"name":       data.Name,
+		"type":       data.Type,
+		"params":     data.Params,
+		"priority":   data.Priority,
+		"enabled":    data.Enabled,
+		"start_time": data.StartTime,
+		"end_time":   data.EndTime,
+	}).Error
+}
+
+func (m *defaultPromoModel) DeleteRule(ctx context.Context, id int64) error {
+	return m.db.WithContext(ctx).Delete(&Rule{}, id).Error
+}
+
+func (m *defaultPromoModel) QueryRuleList(ctx context.Context, page, size int, ruleType string, enabled *bool, search string) (int64, []*Rule, error) {
+	if page <= 0 {
+		page = 1
+	}
+	if size <= 0 {
+		size = 10
+	}
+	var total int64
+	var list []*Rule
+	db := m.db.WithContext(ctx).Model(&Rule{})
+	if ruleType != "" {
+		db = db.Where("type = ?", ruleType)
+	}
+	if enabled != nil {
+		db = db.Where("enabled = ?", *enabled)
+	}
+	if search != "" {
+		db = db.Where("name LIKE ?", "%"+search+"%")
+	}
+	if err := db.Count(&total).Error; err != nil {
+		return 0, nil, err
+	}
+	err := db.Order("priority DESC").Order("id DESC").Limit(size).Offset((page - 1) * size).Find(&list).Error
+	return total, list, err
+}
+
+func (m *defaultPromoModel) UpsertPrices(ctx context.Context, ruleId int64, items []*SubscribePromo) error {
+	return m.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		for _, item := range items {
+			if item == nil {
+				continue
+			}
+			item.PromoRuleId = ruleId
+			var existing SubscribePromo
+			err := tx.Model(&SubscribePromo{}).
+				Where("subscribe_id = ? AND quantity = ? AND promo_rule_id = ?", item.SubscribeId, item.Quantity, ruleId).
+				First(&existing).Error
+			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+				return err
+			}
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				if err := tx.Create(item).Error; err != nil {
+					return err
+				}
+				continue
+			}
+			existing.Quantity = item.Quantity
+			existing.PromoPrice = item.PromoPrice
+			if err := tx.Save(&existing).Error; err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+func (m *defaultPromoModel) FindPrice(ctx context.Context, id int64) (*SubscribePromo, error) {
+	var resp SubscribePromo
+	if err := m.db.WithContext(ctx).Model(&SubscribePromo{}).Where("id = ?", id).First(&resp).Error; err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (m *defaultPromoModel) DeletePrice(ctx context.Context, id int64) error {
+	return m.db.WithContext(ctx).Delete(&SubscribePromo{}, id).Error
+}
+
+func (m *defaultPromoModel) QueryPriceList(ctx context.Context, ruleId int64, page, size int) (int64, []*SubscribePromo, error) {
+	if page <= 0 {
+		page = 1
+	}
+	if size <= 0 {
+		size = 10
+	}
+	var total int64
+	var list []*SubscribePromo
+	db := m.db.WithContext(ctx).Model(&SubscribePromo{}).Where("promo_rule_id = ?", ruleId)
+	if err := db.Count(&total).Error; err != nil {
+		return 0, nil, err
+	}
+	err := db.Order("id DESC").Limit(size).Offset((page - 1) * size).Find(&list).Error
+	return total, list, err
+}
+
+func (m *defaultPromoModel) QueryUsageList(ctx context.Context, params UsageFilter) (int64, []*Usage, error) {
+	if params.Page <= 0 {
+		params.Page = 1
+	}
+	if params.Size <= 0 {
+		params.Size = 10
+	}
+	var total int64
+	var list []*Usage
+	db := m.db.WithContext(ctx).Model(&Usage{})
+	if params.RuleId > 0 {
+		db = db.Where("promo_rule_id = ?", params.RuleId)
+	}
+	if params.UserId > 0 {
+		db = db.Where("user_id = ?", params.UserId)
+	}
+	if params.SubscribeId > 0 {
+		db = db.Where("subscribe_id = ?", params.SubscribeId)
+	}
+	if params.OrderNo != "" {
+		db = db.Where("order_no = ?", params.OrderNo)
+	}
+	if err := db.Count(&total).Error; err != nil {
+		return 0, nil, err
+	}
+	err := db.Order("id DESC").Limit(params.Size).Offset((params.Page - 1) * params.Size).Find(&list).Error
+	return total, list, err
+}
+
+func (m *defaultPromoModel) Transaction(ctx context.Context, fn func(db *gorm.DB) error) error {
+	return m.db.WithContext(ctx).Transaction(fn)
+}

internal/model/promo/model_test.go

@@ -1,39 +0,0 @@
-package promo
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-)
-
-func TestQueryEligibleRulesFiltersByQuantity(t *testing.T) {
-	db, err := gorm.Open(mysql.New(mysql.Config{
-		DSN:                       "gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True&loc=Local",
-		SkipInitializeWithVersion: true,
-	}), &gorm.Config{DryRun: true, DisableAutomaticPing: true})
-	if err != nil {
-		t.Fatalf("open dry-run db: %v", err)
-	}
-
-	model := &defaultPromoModel{db: db}
-	var list []*RuleWithPrice
-	tx := model.eligibleRulesQuery(context.Background(), 11, 3).Find(&list)
-	stmt := tx.Statement
-	sql := stmt.SQL.String()
-	if !strings.Contains(sql, "JOIN subscribe_promo AS sp ON sp.promo_rule_id = pr.id AND sp.quantity = ?") {
-		t.Fatalf("SQL missing quantity join condition: %s", sql)
-	}
-
-	if len(stmt.Vars) < 2 {
-		t.Fatalf("SQL vars length = %d, want at least 2; vars=%v", len(stmt.Vars), stmt.Vars)
-	}
-	if got, want := stmt.Vars[0], int64(3); got != want {
-		t.Fatalf("first SQL var = %v, want quantity %d; vars=%v", got, want, stmt.Vars)
-	}
-	if got, want := stmt.Vars[1], int64(11); got != want {
-		t.Fatalf("second SQL var = %v, want subscribe_id %d; vars=%v", got, want, stmt.Vars)
-	}
-}

internal/model/promo/promo.go

@@ -33,7 +33,7 @@ func (Rule) TableName() string {
 type SubscribePromo struct {
 	Id          int64     `gorm:"primaryKey"`
 	SubscribeId int64     `gorm:"type:bigint unsigned;not null;comment:Subscribe ID"`
-	Quantity    int64     `gorm:"type:bigint;not null;default:1;comment:Quantity"`
+	Quantity    int64     `gorm:"type:int;not null;default:0;comment:购买数量"`
 	PromoRuleId int64     `gorm:"type:bigint unsigned;not null;comment:Promo Rule ID"`
 	PromoPrice  int64     `gorm:"type:bigint;not null;default:0;comment:Promo Price"`
 	CreatedAt   time.Time `gorm:"<-:create;comment:Create Time"`

internal/types/promo_validation_test.go

@@ -0,0 +1,58 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/go-playground/validator/v10"
+)
+
+func TestPromoPriceItemsMustNotBeEmpty(t *testing.T) {
+	validate := validator.New()
+	req := SetPromoPriceRequest{
+		PromoRuleId: 1,
+		Items:       []PromoPriceItem{},
+	}
+
+	if err := validate.Struct(req); err == nil {
+		t.Fatal("expected empty promo price items to fail validation")
+	}
+}
+
+func TestPromoListPageSizeLimit(t *testing.T) {
+	validate := validator.New()
+	tests := []struct {
+		name string
+		req  any
+	}{
+		{
+			name: "rule list",
+			req: GetPromoRuleListRequest{
+				Page: 1,
+				Size: 201,
+			},
+		},
+		{
+			name: "price list",
+			req: GetPromoPriceListRequest{
+				PromoRuleId: 1,
+				Page:        1,
+				Size:        201,
+			},
+		},
+		{
+			name: "usage list",
+			req: GetPromoUsageListRequest{
+				Page: 1,
+				Size: 201,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := validate.Struct(tt.req); err == nil {
+				t.Fatal("expected page size greater than 200 to fail validation")
+			}
+		})
+	}
+}

internal/types/types.go

@@ -316,6 +316,45 @@ type ContactRequest struct {
 	Notes        string `json:"notes" validate:"max=2000"`
 }
 
+type PromoPrice struct {
+	Id          int64 `json:"id"`
+	SubscribeId int64 `json:"subscribe_id"`
+	PromoRuleId int64 `json:"promo_rule_id"`
+	Quantity    int64 `json:"quantity"`
+	PromoPrice  int64 `json:"promo_price"`
+	CreatedAt   int64 `json:"created_at"`
+	UpdatedAt   int64 `json:"updated_at"`
+}
+
+type PromoPriceItem struct {
+	SubscribeId int64 `json:"subscribe_id" validate:"required,gt=0"`
+	Quantity    int64 `json:"quantity" validate:"required,gt=0,lte=1000"`
+	PromoPrice  int64 `json:"promo_price" validate:"required,gt=0"`
+}
+
+type PromoRule struct {
+	Id        int64                  `json:"id"`
+	Name      string                 `json:"name"`
+	Type      string                 `json:"type"`
+	Params    map[string]interface{} `json:"params"`
+	Priority  int64                  `json:"priority"`
+	Enabled   bool                   `json:"enabled"`
+	StartTime *int64                 `json:"start_time"`
+	EndTime   *int64                 `json:"end_time"`
+	CreatedAt int64                  `json:"created_at"`
+	UpdatedAt int64                  `json:"updated_at"`
+}
+
+type PromoUsage struct {
+	Id          int64  `json:"id"`
+	UserId      int64  `json:"user_id"`
+	PromoRuleId int64  `json:"promo_rule_id"`
+	SubscribeId int64  `json:"subscribe_id"`
+	OrderNo     string `json:"order_no"`
+	PromoPrice  int64  `json:"promo_price"`
+	CreatedAt   int64  `json:"created_at"`
+}
+
 type Coupon struct {
 	Id         int64   `json:"id"`
 	Name       string  `json:"name"`
@@ -375,6 +414,16 @@ type CreateCouponRequest struct {
 	Enable     *bool   `json:"enable,omitempty"`
 }
 
+type CreatePromoRuleRequest struct {
+	Name      string                 `json:"name" validate:"required,max=100"`
+	Type      string                 `json:"type" validate:"required,oneof=new_user inactive_user campaign"`
+	Params    map[string]interface{} `json:"params"`
+	Priority  int64                  `json:"priority" validate:"gte=0"`
+	Enabled   *bool                  `json:"enabled"`
+	StartTime *int64                 `json:"start_time"`
+	EndTime   *int64                 `json:"end_time"`
+}
+
 type CreateDocumentRequest struct {
 	Title   string   `json:"title" validate:"required"`
 	Content string   `json:"content" validate:"required"`
@@ -1096,6 +1145,48 @@ type GetCouponListResponse struct {
 	List  []Coupon `json:"list"`
 }
 
+type GetPromoPriceListRequest struct {
+	PromoRuleId int64 `form:"promo_rule_id" validate:"required,gt=0"`
+	Page        int64 `form:"page" validate:"required,gt=0"`
+	Size        int64 `form:"size" validate:"required,gt=0,lte=200"`
+}
+
+type GetPromoPriceListResponse struct {
+	Total int64        `json:"total"`
+	List  []PromoPrice `json:"list"`
+}
+
+type GetPromoRuleDetailRequest struct {
+	Id int64 `uri:"id" validate:"required,gt=0"`
+}
+
+type GetPromoRuleListRequest struct {
+	Page    int64  `form:"page" validate:"required,gt=0"`
+	Size    int64  `form:"size" validate:"required,gt=0,lte=200"`
+	Type    string `form:"type" validate:"omitempty,oneof=new_user inactive_user campaign"`
+	Enabled *bool  `form:"enabled"`
+	Search  string `form:"search,omitempty"`
+}
+
+type GetPromoRuleListResponse struct {
+	Total int64       `json:"total"`
+	List  []PromoRule `json:"list"`
+}
+
+type GetPromoUsageListRequest struct {
+	Page        int64  `form:"page" validate:"required,gt=0"`
+	Size        int64  `form:"size" validate:"required,gt=0,lte=200"`
+	RuleId      int64  `form:"rule_id,omitempty"`
+	UserId      int64  `form:"user_id,omitempty"`
+	SubscribeId int64  `form:"subscribe_id,omitempty"`
+	OrderNo     string `form:"order_no,omitempty"`
+}
+
+type GetPromoUsageListResponse struct {
+	Total int64        `json:"total"`
+	List  []PromoUsage `json:"list"`
+}
+
 type GetDetailRequest struct {
 	Id int64 `form:"id" validate:"required"`
 }
@@ -3130,6 +3221,30 @@ type UpdateCouponRequest struct {
 	Enable     *bool   `json:"enable,omitempty"`
 }
 
+type SetPromoPriceRequest struct {
+	PromoRuleId int64            `json:"promo_rule_id" validate:"required,gt=0"`
+	Items       []PromoPriceItem `json:"items" validate:"required,min=1,dive"`
+}
+
+type DeletePromoPriceRequest struct {
+	Id int64 `uri:"id" validate:"required,gt=0"`
+}
+
+type DeletePromoRuleRequest struct {
+	Id int64 `uri:"id" validate:"required,gt=0"`
+}
+
+type UpdatePromoRuleRequest struct {
+	Id        int64                  `uri:"id" validate:"required,gt=0"`
+	Name      string                 `json:"name" validate:"required,max=100"`
+	Type      string                 `json:"type" validate:"required,oneof=new_user inactive_user campaign"`
+	Params    map[string]interface{} `json:"params"`
+	Priority  int64                  `json:"priority" validate:"gte=0"`
+	Enabled   *bool                  `json:"enabled"`
+	StartTime *int64                 `json:"start_time"`
+	EndTime   *int64                 `json:"end_time"`
+}
+
 type UpdateDocumentRequest struct {
 	Id      int64    `json:"id" validate:"required"`
 	Title   string   `json:"title" validate:"required"`