修复(#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>

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
+}