修复(#84): 补齐促销管理API实现文件

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

internal/logic/admin/promo/common.go

@@ -0,0 +1,128 @@
+package promo
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	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"
+	"github.com/pkg/errors"
+)
+
+const (
+	enabledRulesCacheKey = "promo:rules:enabled"
+	subscribePromoKeyFmt = "promo:subscribe:%d"
+)
+
+type ruleParams struct {
+	WindowHours    int `json:"window_hours"`
+	InactiveMonths int `json:"inactive_months"`
+}
+
+func validateRulePayload(ruleType string, params json.RawMessage, priority, startTime, endTime int64) error {
+	if priority < 0 {
+		return xerr.NewErrCodeMsg(xerr.InvalidParams, "priority must be greater than or equal to 0")
+	}
+	if startTime >= endTime {
+		return xerr.NewErrCodeMsg(xerr.InvalidParams, "start_time must be less than end_time")
+	}
+
+	var p ruleParams
+	if len(params) == 0 || !json.Valid(params) {
+		return xerr.NewErrCodeMsg(xerr.InvalidParams, "params must be valid json")
+	}
+	if err := json.Unmarshal(params, &p); err != nil {
+		return xerr.NewErrCodeMsg(xerr.InvalidParams, "params must be valid json object")
+	}
+
+	switch ruleType {
+	case promoModel.RuleTypeNewUser:
+		if p.WindowHours <= 0 {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "params.window_hours must be greater than 0")
+		}
+	case promoModel.RuleTypeInactiveUser:
+		if p.InactiveMonths <= 0 {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "params.inactive_months must be greater than 0")
+		}
+	case promoModel.RuleTypeCampaign:
+		return nil
+	default:
+		return xerr.NewErrCodeMsg(xerr.InvalidParams, "type must be new_user, inactive_user or campaign")
+	}
+	return nil
+}
+
+func toRuleResponse(data *promoModel.Rule) types.PromoRule {
+	resp := types.PromoRule{
+		Id:        data.Id,
+		Name:      data.Name,
+		Type:      data.Type,
+		Params:    json.RawMessage(data.Params),
+		Priority:  data.Priority,
+		Enabled:   data.Enabled,
+		CreatedAt: data.CreatedAt.UnixMilli(),
+		UpdatedAt: data.UpdatedAt.UnixMilli(),
+	}
+	if data.StartTime != nil {
+		resp.StartTime = data.StartTime.UnixMilli()
+	}
+	if data.EndTime != nil {
+		resp.EndTime = data.EndTime.UnixMilli()
+	}
+	return resp
+}
+
+func toPriceResponse(data *promoModel.SubscribePromo, unitPrice int64) types.PromoPrice {
+	return types.PromoPrice{
+		Id:          data.Id,
+		SubscribeId: data.SubscribeId,
+		PromoRuleId: data.PromoRuleId,
+		PromoPrice:  data.PromoPrice,
+		UnitPrice:   unitPrice,
+		CreatedAt:   data.CreatedAt.UnixMilli(),
+		UpdatedAt:   data.UpdatedAt.UnixMilli(),
+	}
+}
+
+func toUsageResponse(data *promoModel.Usage) types.PromoUsage {
+	return types.PromoUsage{
+		Id:          data.Id,
+		UserId:      data.UserId,
+		PromoRuleId: data.PromoRuleId,
+		SubscribeId: data.SubscribeId,
+		OrderNo:     data.OrderNo,
+		PromoPrice:  data.PromoPrice,
+		CreatedAt:   data.CreatedAt.UnixMilli(),
+	}
+}
+
+func ruleTimes(startTime, endTime int64) (*time.Time, *time.Time) {
+	start := time.UnixMilli(startTime)
+	end := time.UnixMilli(endTime)
+	return &start, &end
+}
+
+func clearRuleCache(ctx context.Context, svcCtx *svc.ServiceContext) {
+	if svcCtx != nil && svcCtx.Redis != nil {
+		_ = svcCtx.Redis.Del(ctx, enabledRulesCacheKey).Err()
+	}
+}
+
+func clearSubscribePromoCache(ctx context.Context, svcCtx *svc.ServiceContext, ids ...int64) {
+	if svcCtx == nil || svcCtx.Redis == nil || len(ids) == 0 {
+		return
+	}
+	keys := make([]string, 0, len(ids))
+	for _, id := range ids {
+		keys = append(keys, fmt.Sprintf(subscribePromoKeyFmt, id))
+	}
+	_ = svcCtx.Redis.Del(ctx, keys...).Err()
+}
+
+func wrapQueryError(msg string, err error) error {
+	return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "%s: %v", msg, err.Error())
+}

internal/logic/admin/promo/createPromoPriceLogic.go

@@ -0,0 +1,62 @@
+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 CreatePromoPriceLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Batch set promo price
+func NewCreatePromoPriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreatePromoPriceLogic {
+	return &CreatePromoPriceLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreatePromoPriceLogic) CreatePromoPrice(req *types.CreatePromoPriceRequest) error {
+	if _, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.PromoRuleId); err != nil {
+		if promoModel.IsNotFound(err) {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "promo rule not found")
+		}
+		l.Errorw("[CreatePromoPrice] Query Rule Error", logger.Field("error", err.Error()))
+		return wrapQueryError("get promo rule failed", err)
+	}
+
+	data := make([]*promoModel.SubscribePromo, 0, len(req.Items))
+	subscribeIds := make([]int64, 0, len(req.Items))
+	for _, item := range req.Items {
+		sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, item.SubscribeId)
+		if err != nil {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "subscribe not found")
+		}
+		if item.PromoPrice >= sub.UnitPrice {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "promo_price must be less than unit_price")
+		}
+		data = append(data, &promoModel.SubscribePromo{
+			SubscribeId: item.SubscribeId,
+			PromoRuleId: req.PromoRuleId,
+			PromoPrice:  item.PromoPrice,
+		})
+		subscribeIds = append(subscribeIds, item.SubscribeId)
+	}
+
+	if err := l.svcCtx.PromoModel.UpsertSubscribePromos(l.ctx, data); err != nil {
+		l.Errorw("[CreatePromoPrice] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "set promo price failed: %v", err.Error())
+	}
+	clearSubscribePromoCache(l.ctx, l.svcCtx, subscribeIds...)
+	return nil
+}

internal/logic/admin/promo/createPromoRuleLogic.go

@@ -0,0 +1,51 @@
+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 CreatePromoRuleLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create promo rule
+func NewCreatePromoRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreatePromoRuleLogic {
+	return &CreatePromoRuleLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreatePromoRuleLogic) CreatePromoRule(req *types.CreatePromoRuleRequest) (*types.PromoRule, error) {
+	if err := validateRulePayload(req.Type, req.Params, req.Priority, req.StartTime, req.EndTime); err != nil {
+		return nil, err
+	}
+
+	start, end := ruleTimes(req.StartTime, req.EndTime)
+	data := &promoModel.Rule{
+		Name:      req.Name,
+		Type:      req.Type,
+		Params:    string(req.Params),
+		Priority:  req.Priority,
+		Enabled:   *req.Enabled,
+		StartTime: start,
+		EndTime:   end,
+	}
+	if err := l.svcCtx.PromoModel.InsertRule(l.ctx, data); err != nil {
+		l.Errorw("[CreatePromoRule] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create promo rule failed: %v", err.Error())
+	}
+	clearRuleCache(l.ctx, l.svcCtx)
+	resp := toRuleResponse(data)
+	return &resp, nil
+}

internal/logic/admin/promo/deletePromoPriceLogic.go

@@ -0,0 +1,45 @@
+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 DeletePromoPriceLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete promo price
+func NewDeletePromoPriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeletePromoPriceLogic {
+	return &DeletePromoPriceLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeletePromoPriceLogic) DeletePromoPrice(req *types.DeletePromoPriceRequest) error {
+	data, err := l.svcCtx.PromoModel.FindSubscribePromo(l.ctx, req.Id)
+	if err != nil {
+		if promoModel.IsNotFound(err) {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "promo price not found")
+		}
+		l.Errorw("[DeletePromoPrice] Database Query Error", logger.Field("error", err.Error()))
+		return wrapQueryError("get promo price failed", err)
+	}
+
+	if err = l.svcCtx.PromoModel.DeleteSubscribePromo(l.ctx, req.Id); err != nil {
+		l.Errorw("[DeletePromoPrice] Database Delete Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete promo price failed: %v", err.Error())
+	}
+	clearSubscribePromoCache(l.ctx, l.svcCtx, data.SubscribeId)
+	return nil
+}

internal/logic/admin/promo/deletePromoRuleLogic.go

@@ -0,0 +1,39 @@
+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 DeletePromoRuleLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete promo rule
+func NewDeletePromoRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeletePromoRuleLogic {
+	return &DeletePromoRuleLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeletePromoRuleLogic) DeletePromoRule(req *types.DeletePromoRuleRequest) error {
+	if err := l.svcCtx.PromoModel.DeleteRule(l.ctx, req.Id); err != nil {
+		if promoModel.IsNotFound(err) {
+			return xerr.NewErrCodeMsg(xerr.InvalidParams, "promo rule not found")
+		}
+		l.Errorw("[DeletePromoRule] Database Delete Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete promo rule failed: %v", err.Error())
+	}
+	clearRuleCache(l.ctx, l.svcCtx)
+	return nil
+}

internal/logic/admin/promo/getPromoPriceListLogic.go

@@ -0,0 +1,50 @@
+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"
+)
+
+type GetPromoPriceListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get promo price list
+func NewGetPromoPriceListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPromoPriceListLogic {
+	return &GetPromoPriceListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPromoPriceListLogic) GetPromoPriceList(req *types.GetPromoPriceListRequest) (*types.GetPromoPriceListResponse, error) {
+	total, list, err := l.svcCtx.PromoModel.QuerySubscribePromoList(l.ctx, promoModel.SubscribePromoFilter{
+		Page:        int(req.Page),
+		Size:        int(req.Size),
+		PromoRuleId: req.PromoRuleId,
+	})
+	if err != nil {
+		l.Errorw("[GetPromoPriceList] Database Error", logger.Field("error", err.Error()))
+		return nil, wrapQueryError("get promo price list failed", err)
+	}
+	resp := &types.GetPromoPriceListResponse{
+		Total: total,
+		List:  make([]types.PromoPrice, 0, len(list)),
+	}
+	for _, item := range list {
+		var unitPrice int64
+		sub, subErr := l.svcCtx.SubscribeModel.FindOne(l.ctx, item.SubscribeId)
+		if subErr == nil {
+			unitPrice = sub.UnitPrice
+		}
+		resp.List = append(resp.List, toPriceResponse(item, unitPrice))
+	}
+	return resp, nil
+}

internal/logic/admin/promo/getPromoRuleDetailLogic.go

@@ -0,0 +1,39 @@
+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"
+)
+
+type GetPromoRuleDetailLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get promo rule detail
+func NewGetPromoRuleDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPromoRuleDetailLogic {
+	return &GetPromoRuleDetailLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPromoRuleDetailLogic) GetPromoRuleDetail(req *types.GetPromoRuleDetailRequest) (*types.PromoRule, error) {
+	data, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id)
+	if err != nil {
+		if promoModel.IsNotFound(err) {
+			return nil, xerr.NewErrCodeMsg(xerr.InvalidParams, "promo rule not found")
+		}
+		l.Errorw("[GetPromoRuleDetail] Database Error", logger.Field("error", err.Error()))
+		return nil, wrapQueryError("get promo rule detail failed", err)
+	}
+	resp := toRuleResponse(data)
+	return &resp, nil
+}

internal/logic/admin/promo/getPromoRuleListLogic.go

@@ -0,0 +1,47 @@
+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"
+)
+
+type GetPromoRuleListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get promo rule list
+func NewGetPromoRuleListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPromoRuleListLogic {
+	return &GetPromoRuleListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPromoRuleListLogic) GetPromoRuleList(req *types.GetPromoRuleListRequest) (*types.GetPromoRuleListResponse, error) {
+	total, list, err := l.svcCtx.PromoModel.QueryRuleList(l.ctx, promoModel.RuleFilter{
+		Page:    int(req.Page),
+		Size:    int(req.Size),
+		Type:    req.Type,
+		Enabled: req.Enabled,
+		Search:  req.Search,
+	})
+	if err != nil {
+		l.Errorw("[GetPromoRuleList] Database Error", logger.Field("error", err.Error()))
+		return nil, wrapQueryError("get promo rule list failed", err)
+	}
+	resp := &types.GetPromoRuleListResponse{
+		Total: total,
+		List:  make([]types.PromoRule, 0, len(list)),
+	}
+	for _, item := range list {
+		resp.List = append(resp.List, toRuleResponse(item))
+	}
+	return resp, nil
+}

internal/logic/admin/promo/getPromoUsageListLogic.go

@@ -0,0 +1,48 @@
+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"
+)
+
+type GetPromoUsageListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get promo usage list
+func NewGetPromoUsageListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPromoUsageListLogic {
+	return &GetPromoUsageListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPromoUsageListLogic) GetPromoUsageList(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),
+		PromoRuleId: req.PromoRuleId,
+		UserId:      req.UserId,
+		SubscribeId: req.SubscribeId,
+		OrderNo:     req.OrderNo,
+	})
+	if err != nil {
+		l.Errorw("[GetPromoUsageList] Database Error", logger.Field("error", err.Error()))
+		return nil, wrapQueryError("get promo usage list failed", err)
+	}
+	resp := &types.GetPromoUsageListResponse{
+		Total: total,
+		List:  make([]types.PromoUsage, 0, len(list)),
+	}
+	for _, item := range list {
+		resp.List = append(resp.List, toUsageResponse(item))
+	}
+	return resp, nil
+}

internal/logic/admin/promo/updatePromoRuleLogic.go

@@ -0,0 +1,59 @@
+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 UpdatePromoRuleLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update promo rule
+func NewUpdatePromoRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdatePromoRuleLogic {
+	return &UpdatePromoRuleLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdatePromoRuleLogic) UpdatePromoRule(req *types.UpdatePromoRuleRequest) (*types.PromoRule, error) {
+	if err := validateRulePayload(req.Type, req.Params, req.Priority, req.StartTime, req.EndTime); err != nil {
+		return nil, err
+	}
+
+	data, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id)
+	if err != nil {
+		if promoModel.IsNotFound(err) {
+			return nil, xerr.NewErrCodeMsg(xerr.InvalidParams, "promo rule not found")
+		}
+		l.Errorw("[UpdatePromoRule] Database Query Error", logger.Field("error", err.Error()))
+		return nil, wrapQueryError("get promo rule failed", err)
+	}
+
+	start, end := ruleTimes(req.StartTime, req.EndTime)
+	data.Name = req.Name
+	data.Type = req.Type
+	data.Params = string(req.Params)
+	data.Priority = req.Priority
+	data.Enabled = *req.Enabled
+	data.StartTime = start
+	data.EndTime = end
+
+	if err = l.svcCtx.PromoModel.UpdateRule(l.ctx, data); err != nil {
+		l.Errorw("[UpdatePromoRule] Database Update Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update promo rule failed: %v", err.Error())
+	}
+	clearRuleCache(l.ctx, l.svcCtx)
+	resp := toRuleResponse(data)
+	return &resp, nil
+}