refactor: 调整项目结构为单向依赖

backend/internal/repository/user_subscription_repo.go

@@ -4,111 +4,113 @@ import (
 	"context"
 	"time"
 
-	"github.com/Wei-Shaw/sub2api/internal/model"
 	"github.com/Wei-Shaw/sub2api/internal/pkg/pagination"
 	"github.com/Wei-Shaw/sub2api/internal/service"
 
 	"gorm.io/gorm"
 )
 
-// UserSubscriptionRepository 用户订阅仓库
 type userSubscriptionRepository struct {
 	db *gorm.DB
 }
 
-// NewUserSubscriptionRepository 创建用户订阅仓库
 func NewUserSubscriptionRepository(db *gorm.DB) service.UserSubscriptionRepository {
 	return &userSubscriptionRepository{db: db}
 }
 
-// Create 创建订阅
-func (r *userSubscriptionRepository) Create(ctx context.Context, sub *model.UserSubscription) error {
-	err := r.db.WithContext(ctx).Create(sub).Error
+func (r *userSubscriptionRepository) Create(ctx context.Context, sub *service.UserSubscription) error {
+	m := userSubscriptionModelFromService(sub)
+	err := r.db.WithContext(ctx).Create(m).Error
+	if err == nil {
+		applyUserSubscriptionModelToService(sub, m)
+	}
 	return translatePersistenceError(err, nil, service.ErrSubscriptionAlreadyExists)
 }
 
-// GetByID 根据ID获取订阅
-func (r *userSubscriptionRepository) GetByID(ctx context.Context, id int64) (*model.UserSubscription, error) {
-	var sub model.UserSubscription
+func (r *userSubscriptionRepository) GetByID(ctx context.Context, id int64) (*service.UserSubscription, error) {
+	var m userSubscriptionModel
 	err := r.db.WithContext(ctx).
 		Preload("User").
 		Preload("Group").
 		Preload("AssignedByUser").
-		First(&sub, id).Error
+		First(&m, id).Error
 	if err != nil {
 		return nil, translatePersistenceError(err, service.ErrSubscriptionNotFound, nil)
 	}
-	return &sub, nil
+	return userSubscriptionModelToService(&m), nil
 }
 
-// GetByUserIDAndGroupID 根据用户ID和分组ID获取订阅
-func (r *userSubscriptionRepository) GetByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (*model.UserSubscription, error) {
-	var sub model.UserSubscription
+func (r *userSubscriptionRepository) GetByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (*service.UserSubscription, error) {
+	var m userSubscriptionModel
 	err := r.db.WithContext(ctx).
 		Preload("Group").
 		Where("user_id = ? AND group_id = ?", userID, groupID).
-		First(&sub).Error
+		First(&m).Error
 	if err != nil {
 		return nil, translatePersistenceError(err, service.ErrSubscriptionNotFound, nil)
 	}
-	return &sub, nil
+	return userSubscriptionModelToService(&m), nil
 }
 
-// GetActiveByUserIDAndGroupID 获取用户对特定分组的有效订阅
-func (r *userSubscriptionRepository) GetActiveByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (*model.UserSubscription, error) {
-	var sub model.UserSubscription
+func (r *userSubscriptionRepository) GetActiveByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (*service.UserSubscription, error) {
+	var m userSubscriptionModel
 	err := r.db.WithContext(ctx).
 		Preload("Group").
 		Where("user_id = ? AND group_id = ? AND status = ? AND expires_at > ?",
-			userID, groupID, model.SubscriptionStatusActive, time.Now()).
-		First(&sub).Error
+			userID, groupID, service.SubscriptionStatusActive, time.Now()).
+		First(&m).Error
 	if err != nil {
 		return nil, translatePersistenceError(err, service.ErrSubscriptionNotFound, nil)
 	}
-	return &sub, nil
+	return userSubscriptionModelToService(&m), nil
 }
 
-// Update 更新订阅
-func (r *userSubscriptionRepository) Update(ctx context.Context, sub *model.UserSubscription) error {
+func (r *userSubscriptionRepository) Update(ctx context.Context, sub *service.UserSubscription) error {
 	sub.UpdatedAt = time.Now()
-	return r.db.WithContext(ctx).Save(sub).Error
+	m := userSubscriptionModelFromService(sub)
+	err := r.db.WithContext(ctx).Save(m).Error
+	if err == nil {
+		applyUserSubscriptionModelToService(sub, m)
+	}
+	return err
 }
 
-// Delete 删除订阅
 func (r *userSubscriptionRepository) Delete(ctx context.Context, id int64) error {
-	return r.db.WithContext(ctx).Delete(&model.UserSubscription{}, id).Error
+	return r.db.WithContext(ctx).Delete(&userSubscriptionModel{}, id).Error
 }
 
-// ListByUserID 获取用户的所有订阅
-func (r *userSubscriptionRepository) ListByUserID(ctx context.Context, userID int64) ([]model.UserSubscription, error) {
-	var subs []model.UserSubscription
+func (r *userSubscriptionRepository) ListByUserID(ctx context.Context, userID int64) ([]service.UserSubscription, error) {
+	var subs []userSubscriptionModel
 	err := r.db.WithContext(ctx).
 		Preload("Group").
 		Where("user_id = ?", userID).
 		Order("created_at DESC").
 		Find(&subs).Error
-	return subs, err
+	if err != nil {
+		return nil, err
+	}
+	return userSubscriptionModelsToService(subs), nil
 }
 
-// ListActiveByUserID 获取用户的所有有效订阅
-func (r *userSubscriptionRepository) ListActiveByUserID(ctx context.Context, userID int64) ([]model.UserSubscription, error) {
-	var subs []model.UserSubscription
+func (r *userSubscriptionRepository) ListActiveByUserID(ctx context.Context, userID int64) ([]service.UserSubscription, error) {
+	var subs []userSubscriptionModel
 	err := r.db.WithContext(ctx).
 		Preload("Group").
 		Where("user_id = ? AND status = ? AND expires_at > ?",
-			userID, model.SubscriptionStatusActive, time.Now()).
+			userID, service.SubscriptionStatusActive, time.Now()).
 		Order("created_at DESC").
 		Find(&subs).Error
-	return subs, err
+	if err != nil {
+		return nil, err
+	}
+	return userSubscriptionModelsToService(subs), nil
 }
 
-// ListByGroupID 获取分组的所有订阅（分页）
-func (r *userSubscriptionRepository) ListByGroupID(ctx context.Context, groupID int64, params pagination.PaginationParams) ([]model.UserSubscription, *pagination.PaginationResult, error) {
-	var subs []model.UserSubscription
+func (r *userSubscriptionRepository) ListByGroupID(ctx context.Context, groupID int64, params pagination.PaginationParams) ([]service.UserSubscription, *pagination.PaginationResult, error) {
+	var subs []userSubscriptionModel
 	var total int64
 
-	query := r.db.WithContext(ctx).Model(&model.UserSubscription{}).Where("group_id = ?", groupID)
-
+	query := r.db.WithContext(ctx).Model(&userSubscriptionModel{}).Where("group_id = ?", groupID)
 	if err := query.Count(&total).Error; err != nil {
 		return nil, nil, err
 	}
@@ -124,26 +126,14 @@ func (r *userSubscriptionRepository) ListByGroupID(ctx context.Context, groupID
 		return nil, nil, err
 	}
 
-	pages := int(total) / params.Limit()
-	if int(total)%params.Limit() > 0 {
-		pages++
-	}
-
-	return subs, &pagination.PaginationResult{
-		Total:    total,
-		Page:     params.Page,
-		PageSize: params.Limit(),
-		Pages:    pages,
-	}, nil
+	return userSubscriptionModelsToService(subs), paginationResultFromTotal(total, params), nil
 }
 
-// List 获取所有订阅（分页，支持筛选）
-func (r *userSubscriptionRepository) List(ctx context.Context, params pagination.PaginationParams, userID, groupID *int64, status string) ([]model.UserSubscription, *pagination.PaginationResult, error) {
-	var subs []model.UserSubscription
+func (r *userSubscriptionRepository) List(ctx context.Context, params pagination.PaginationParams, userID, groupID *int64, status string) ([]service.UserSubscription, *pagination.PaginationResult, error) {
+	var subs []userSubscriptionModel
 	var total int64
 
-	query := r.db.WithContext(ctx).Model(&model.UserSubscription{})
-
+	query := r.db.WithContext(ctx).Model(&userSubscriptionModel{})
 	if userID != nil {
 		query = query.Where("user_id = ?", *userID)
 	}
@@ -170,22 +160,87 @@ func (r *userSubscriptionRepository) List(ctx context.Context, params pagination
 		return nil, nil, err
 	}
 
-	pages := int(total) / params.Limit()
-	if int(total)%params.Limit() > 0 {
-		pages++
-	}
-
-	return subs, &pagination.PaginationResult{
-		Total:    total,
-		Page:     params.Page,
-		PageSize: params.Limit(),
-		Pages:    pages,
-	}, nil
+	return userSubscriptionModelsToService(subs), paginationResultFromTotal(total, params), nil
+}
+
+func (r *userSubscriptionRepository) ExistsByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (bool, error) {
+	var count int64
+	err := r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("user_id = ? AND group_id = ?", userID, groupID).
+		Count(&count).Error
+	return count > 0, err
+}
+
+func (r *userSubscriptionRepository) ExtendExpiry(ctx context.Context, subscriptionID int64, newExpiresAt time.Time) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", subscriptionID).
+		Updates(map[string]any{
+			"expires_at": newExpiresAt,
+			"updated_at": time.Now(),
+		}).Error
+}
+
+func (r *userSubscriptionRepository) UpdateStatus(ctx context.Context, subscriptionID int64, status string) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", subscriptionID).
+		Updates(map[string]any{
+			"status":     status,
+			"updated_at": time.Now(),
+		}).Error
+}
+
+func (r *userSubscriptionRepository) UpdateNotes(ctx context.Context, subscriptionID int64, notes string) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", subscriptionID).
+		Updates(map[string]any{
+			"notes":      notes,
+			"updated_at": time.Now(),
+		}).Error
+}
+
+func (r *userSubscriptionRepository) ActivateWindows(ctx context.Context, id int64, start time.Time) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", id).
+		Updates(map[string]any{
+			"daily_window_start":   start,
+			"weekly_window_start":  start,
+			"monthly_window_start": start,
+			"updated_at":           time.Now(),
+		}).Error
+}
+
+func (r *userSubscriptionRepository) ResetDailyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", id).
+		Updates(map[string]any{
+			"daily_usage_usd":    0,
+			"daily_window_start": newWindowStart,
+			"updated_at":         time.Now(),
+		}).Error
+}
+
+func (r *userSubscriptionRepository) ResetWeeklyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", id).
+		Updates(map[string]any{
+			"weekly_usage_usd":    0,
+			"weekly_window_start": newWindowStart,
+			"updated_at":          time.Now(),
+		}).Error
+}
+
+func (r *userSubscriptionRepository) ResetMonthlyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("id = ?", id).
+		Updates(map[string]any{
+			"monthly_usage_usd":    0,
+			"monthly_window_start": newWindowStart,
+			"updated_at":           time.Now(),
+		}).Error
 }
 
-// IncrementUsage 增加使用量
 func (r *userSubscriptionRepository) IncrementUsage(ctx context.Context, id int64, costUSD float64) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
+	return r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
 		Where("id = ?", id).
 		Updates(map[string]any{
 			"daily_usage_usd":   gorm.Expr("daily_usage_usd + ?", costUSD),
@@ -195,131 +250,150 @@ func (r *userSubscriptionRepository) IncrementUsage(ctx context.Context, id int6
 		}).Error
 }
 
-// ResetDailyUsage 重置日使用量
-func (r *userSubscriptionRepository) ResetDailyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"daily_usage_usd":    0,
-			"daily_window_start": newWindowStart,
-			"updated_at":         time.Now(),
-		}).Error
-}
-
-// ResetWeeklyUsage 重置周使用量
-func (r *userSubscriptionRepository) ResetWeeklyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"weekly_usage_usd":    0,
-			"weekly_window_start": newWindowStart,
-			"updated_at":          time.Now(),
-		}).Error
-}
-
-// ResetMonthlyUsage 重置月使用量
-func (r *userSubscriptionRepository) ResetMonthlyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"monthly_usage_usd":    0,
-			"monthly_window_start": newWindowStart,
-			"updated_at":           time.Now(),
-		}).Error
-}
-
-// ActivateWindows 激活所有窗口（首次使用时）
-func (r *userSubscriptionRepository) ActivateWindows(ctx context.Context, id int64, activateTime time.Time) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"daily_window_start":   activateTime,
-			"weekly_window_start":  activateTime,
-			"monthly_window_start": activateTime,
-			"updated_at":           time.Now(),
-		}).Error
-}
-
-// UpdateStatus 更新订阅状态
-func (r *userSubscriptionRepository) UpdateStatus(ctx context.Context, id int64, status string) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"status":     status,
-			"updated_at": time.Now(),
-		}).Error
-}
-
-// ExtendExpiry 延长订阅过期时间
-func (r *userSubscriptionRepository) ExtendExpiry(ctx context.Context, id int64, newExpiresAt time.Time) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"expires_at": newExpiresAt,
-			"updated_at": time.Now(),
-		}).Error
-}
-
-// UpdateNotes 更新订阅备注
-func (r *userSubscriptionRepository) UpdateNotes(ctx context.Context, id int64, notes string) error {
-	return r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"notes":      notes,
-			"updated_at": time.Now(),
-		}).Error
-}
-
-// ListExpired 获取所有已过期但状态仍为active的订阅
-func (r *userSubscriptionRepository) ListExpired(ctx context.Context) ([]model.UserSubscription, error) {
-	var subs []model.UserSubscription
-	err := r.db.WithContext(ctx).
-		Where("status = ? AND expires_at <= ?", model.SubscriptionStatusActive, time.Now()).
-		Find(&subs).Error
-	return subs, err
-}
-
-// BatchUpdateExpiredStatus 批量更新过期订阅状态
 func (r *userSubscriptionRepository) BatchUpdateExpiredStatus(ctx context.Context) (int64, error) {
-	result := r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("status = ? AND expires_at <= ?", model.SubscriptionStatusActive, time.Now()).
+	result := r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
+		Where("status = ? AND expires_at <= ?", service.SubscriptionStatusActive, time.Now()).
 		Updates(map[string]any{
-			"status":     model.SubscriptionStatusExpired,
+			"status":     service.SubscriptionStatusExpired,
 			"updated_at": time.Now(),
 		})
 	return result.RowsAffected, result.Error
 }
 
-// ExistsByUserIDAndGroupID 检查用户是否已有该分组的订阅
-func (r *userSubscriptionRepository) ExistsByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (bool, error) {
-	var count int64
-	err := r.db.WithContext(ctx).Model(&model.UserSubscription{}).
-		Where("user_id = ? AND group_id = ?", userID, groupID).
-		Count(&count).Error
-	return count > 0, err
+// Extra repository helpers (currently used only by integration tests).
+
+func (r *userSubscriptionRepository) ListExpired(ctx context.Context) ([]service.UserSubscription, error) {
+	var subs []userSubscriptionModel
+	err := r.db.WithContext(ctx).
+		Where("status = ? AND expires_at <= ?", service.SubscriptionStatusActive, time.Now()).
+		Find(&subs).Error
+	if err != nil {
+		return nil, err
+	}
+	return userSubscriptionModelsToService(subs), nil
 }
 
-// CountByGroupID 获取分组的订阅数量
 func (r *userSubscriptionRepository) CountByGroupID(ctx context.Context, groupID int64) (int64, error) {
 	var count int64
-	err := r.db.WithContext(ctx).Model(&model.UserSubscription{}).
+	err := r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
 		Where("group_id = ?", groupID).
 		Count(&count).Error
 	return count, err
 }
 
-// CountActiveByGroupID 获取分组的有效订阅数量
 func (r *userSubscriptionRepository) CountActiveByGroupID(ctx context.Context, groupID int64) (int64, error) {
 	var count int64
-	err := r.db.WithContext(ctx).Model(&model.UserSubscription{}).
+	err := r.db.WithContext(ctx).Model(&userSubscriptionModel{}).
 		Where("group_id = ? AND status = ? AND expires_at > ?",
-			groupID, model.SubscriptionStatusActive, time.Now()).
+			groupID, service.SubscriptionStatusActive, time.Now()).
 		Count(&count).Error
 	return count, err
 }
 
-// DeleteByGroupID 删除分组相关的所有订阅记录
 func (r *userSubscriptionRepository) DeleteByGroupID(ctx context.Context, groupID int64) (int64, error) {
-	result := r.db.WithContext(ctx).Where("group_id = ?", groupID).Delete(&model.UserSubscription{})
+	result := r.db.WithContext(ctx).Where("group_id = ?", groupID).Delete(&userSubscriptionModel{})
 	return result.RowsAffected, result.Error
 }
+
+type userSubscriptionModel struct {
+	ID      int64 `gorm:"primaryKey"`
+	UserID  int64 `gorm:"index;not null"`
+	GroupID int64 `gorm:"index;not null"`
+
+	StartsAt  time.Time `gorm:"not null"`
+	ExpiresAt time.Time `gorm:"not null"`
+	Status    string    `gorm:"size:20;default:active;not null"`
+
+	DailyWindowStart   *time.Time
+	WeeklyWindowStart  *time.Time
+	MonthlyWindowStart *time.Time
+
+	DailyUsageUSD   float64 `gorm:"type:decimal(20,10);default:0;not null"`
+	WeeklyUsageUSD  float64 `gorm:"type:decimal(20,10);default:0;not null"`
+	MonthlyUsageUSD float64 `gorm:"type:decimal(20,10);default:0;not null"`
+
+	AssignedBy *int64    `gorm:"index"`
+	AssignedAt time.Time `gorm:"not null"`
+	Notes      string    `gorm:"type:text"`
+
+	CreatedAt time.Time `gorm:"not null"`
+	UpdatedAt time.Time `gorm:"not null"`
+
+	User           *userModel  `gorm:"foreignKey:UserID"`
+	Group          *groupModel `gorm:"foreignKey:GroupID"`
+	AssignedByUser *userModel  `gorm:"foreignKey:AssignedBy"`
+}
+
+func (userSubscriptionModel) TableName() string { return "user_subscriptions" }
+
+func userSubscriptionModelToService(m *userSubscriptionModel) *service.UserSubscription {
+	if m == nil {
+		return nil
+	}
+	return &service.UserSubscription{
+		ID:                 m.ID,
+		UserID:             m.UserID,
+		GroupID:            m.GroupID,
+		StartsAt:           m.StartsAt,
+		ExpiresAt:          m.ExpiresAt,
+		Status:             m.Status,
+		DailyWindowStart:   m.DailyWindowStart,
+		WeeklyWindowStart:  m.WeeklyWindowStart,
+		MonthlyWindowStart: m.MonthlyWindowStart,
+		DailyUsageUSD:      m.DailyUsageUSD,
+		WeeklyUsageUSD:     m.WeeklyUsageUSD,
+		MonthlyUsageUSD:    m.MonthlyUsageUSD,
+		AssignedBy:         m.AssignedBy,
+		AssignedAt:         m.AssignedAt,
+		Notes:              m.Notes,
+		CreatedAt:          m.CreatedAt,
+		UpdatedAt:          m.UpdatedAt,
+		User:               userModelToService(m.User),
+		Group:              groupModelToService(m.Group),
+		AssignedByUser:     userModelToService(m.AssignedByUser),
+	}
+}
+
+func userSubscriptionModelsToService(models []userSubscriptionModel) []service.UserSubscription {
+	out := make([]service.UserSubscription, 0, len(models))
+	for i := range models {
+		if s := userSubscriptionModelToService(&models[i]); s != nil {
+			out = append(out, *s)
+		}
+	}
+	return out
+}
+
+func userSubscriptionModelFromService(s *service.UserSubscription) *userSubscriptionModel {
+	if s == nil {
+		return nil
+	}
+	return &userSubscriptionModel{
+		ID:                 s.ID,
+		UserID:             s.UserID,
+		GroupID:            s.GroupID,
+		StartsAt:           s.StartsAt,
+		ExpiresAt:          s.ExpiresAt,
+		Status:             s.Status,
+		DailyWindowStart:   s.DailyWindowStart,
+		WeeklyWindowStart:  s.WeeklyWindowStart,
+		MonthlyWindowStart: s.MonthlyWindowStart,
+		DailyUsageUSD:      s.DailyUsageUSD,
+		WeeklyUsageUSD:     s.WeeklyUsageUSD,
+		MonthlyUsageUSD:    s.MonthlyUsageUSD,
+		AssignedBy:         s.AssignedBy,
+		AssignedAt:         s.AssignedAt,
+		Notes:              s.Notes,
+		CreatedAt:          s.CreatedAt,
+		UpdatedAt:          s.UpdatedAt,
+	}
+}
+
+func applyUserSubscriptionModelToService(sub *service.UserSubscription, m *userSubscriptionModel) {
+	if sub == nil || m == nil {
+		return
+	}
+	sub.ID = m.ID
+	sub.CreatedAt = m.CreatedAt
+	sub.UpdatedAt = m.UpdatedAt
+}