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

2025-12-26 15:40:24 +08:00
parent b3463769dc
commit e5a77853b0
98 changed files with 5503 additions and 3352 deletions
--- a/backend/internal/repository/user_repo.go
+++ b/backend/internal/repository/user_repo.go
@@ -2,12 +2,13 @@ package repository

 import (
 	"context"
+	"time"

 	"github.com/Wei-Shaw/sub2api/internal/service"

-	"github.com/Wei-Shaw/sub2api/internal/model"
 	"github.com/Wei-Shaw/sub2api/internal/pkg/pagination"

+	"github.com/lib/pq"
 	"gorm.io/gorm"
 )

@@ -19,48 +20,56 @@ func NewUserRepository(db *gorm.DB) service.UserRepository {
 	return &userRepository{db: db}
 }

-func (r *userRepository) Create(ctx context.Context, user *model.User) error {
-	err := r.db.WithContext(ctx).Create(user).Error
+func (r *userRepository) Create(ctx context.Context, user *service.User) error {
+	m := userModelFromService(user)
+	err := r.db.WithContext(ctx).Create(m).Error
+	if err == nil {
+		applyUserModelToService(user, m)
+	}
 	return translatePersistenceError(err, nil, service.ErrEmailExists)
 }

-func (r *userRepository) GetByID(ctx context.Context, id int64) (*model.User, error) {
-	var user model.User
-	err := r.db.WithContext(ctx).First(&user, id).Error
+func (r *userRepository) GetByID(ctx context.Context, id int64) (*service.User, error) {
+	var m userModel
+	err := r.db.WithContext(ctx).First(&m, id).Error
 	if err != nil {
 		return nil, translatePersistenceError(err, service.ErrUserNotFound, nil)
 	}
-	return &user, nil
+	return userModelToService(&m), nil
 }

-func (r *userRepository) GetByEmail(ctx context.Context, email string) (*model.User, error) {
-	var user model.User
-	err := r.db.WithContext(ctx).Where("email = ?", email).First(&user).Error
+func (r *userRepository) GetByEmail(ctx context.Context, email string) (*service.User, error) {
+	var m userModel
+	err := r.db.WithContext(ctx).Where("email = ?", email).First(&m).Error
 	if err != nil {
 		return nil, translatePersistenceError(err, service.ErrUserNotFound, nil)
 	}
-	return &user, nil
+	return userModelToService(&m), nil
 }

-func (r *userRepository) Update(ctx context.Context, user *model.User) error {
-	err := r.db.WithContext(ctx).Save(user).Error
+func (r *userRepository) Update(ctx context.Context, user *service.User) error {
+	m := userModelFromService(user)
+	err := r.db.WithContext(ctx).Save(m).Error
+	if err == nil {
+		applyUserModelToService(user, m)
+	}
 	return translatePersistenceError(err, nil, service.ErrEmailExists)
 }

 func (r *userRepository) Delete(ctx context.Context, id int64) error {
-	return r.db.WithContext(ctx).Delete(&model.User{}, id).Error
+	return r.db.WithContext(ctx).Delete(&userModel{}, id).Error
 }

-func (r *userRepository) List(ctx context.Context, params pagination.PaginationParams) ([]model.User, *pagination.PaginationResult, error) {
+func (r *userRepository) List(ctx context.Context, params pagination.PaginationParams) ([]service.User, *pagination.PaginationResult, error) {
 	return r.ListWithFilters(ctx, params, "", "", "")
 }

 // ListWithFilters lists users with optional filtering by status, role, and search query
-func (r *userRepository) ListWithFilters(ctx context.Context, params pagination.PaginationParams, status, role, search string) ([]model.User, *pagination.PaginationResult, error) {
-	var users []model.User
+func (r *userRepository) ListWithFilters(ctx context.Context, params pagination.PaginationParams, status, role, search string) ([]service.User, *pagination.PaginationResult, error) {
+	var users []userModel
 	var total int64

-	db := r.db.WithContext(ctx).Model(&model.User{})
+	db := r.db.WithContext(ctx).Model(&userModel{})

 	// Apply filters
 	if status != "" {
@@ -89,17 +98,20 @@ func (r *userRepository) ListWithFilters(ctx context.Context, params pagination.
 	// Batch load subscriptions for all users (avoid N+1)
 	if len(users) > 0 {
 		userIDs := make([]int64, len(users))
-		userMap := make(map[int64]*model.User, len(users))
+		userMap := make(map[int64]*service.User, len(users))
+		outUsers := make([]service.User, 0, len(users))
 		for i := range users {
 			userIDs[i] = users[i].ID
-			userMap[users[i].ID] = &users[i]
+			u := userModelToService(&users[i])
+			outUsers = append(outUsers, *u)
+			userMap[u.ID] = &outUsers[len(outUsers)-1]
 		}

 		// Query active subscriptions with groups in one query
-		var subscriptions []model.UserSubscription
+		var subscriptions []userSubscriptionModel
 		if err := r.db.WithContext(ctx).
 			Preload("Group").
-			Where("user_id IN ? AND status = ?", userIDs, model.SubscriptionStatusActive).
+			Where("user_id IN ? AND status = ?", userIDs, service.SubscriptionStatusActive).
 			Find(&subscriptions).Error; err != nil {
 			return nil, nil, err
 		}
@@ -107,32 +119,29 @@ func (r *userRepository) ListWithFilters(ctx context.Context, params pagination.
 		// Associate subscriptions with users
 		for i := range subscriptions {
 			if user, ok := userMap[subscriptions[i].UserID]; ok {
-				user.Subscriptions = append(user.Subscriptions, subscriptions[i])
+				user.Subscriptions = append(user.Subscriptions, *userSubscriptionModelToService(&subscriptions[i]))
 			}
 		}
+
+		return outUsers, paginationResultFromTotal(total, params), nil
 	}

-	pages := int(total) / params.Limit()
-	if int(total)%params.Limit() > 0 {
-		pages++
+	outUsers := make([]service.User, 0, len(users))
+	for i := range users {
+		outUsers = append(outUsers, *userModelToService(&users[i]))
 	}

-	return users, &pagination.PaginationResult{
-		Total:    total,
-		Page:     params.Page,
-		PageSize: params.Limit(),
-		Pages:    pages,
-	}, nil
+	return outUsers, paginationResultFromTotal(total, params), nil
 }

 func (r *userRepository) UpdateBalance(ctx context.Context, id int64, amount float64) error {
-	return r.db.WithContext(ctx).Model(&model.User{}).Where("id = ?", id).
+	return r.db.WithContext(ctx).Model(&userModel{}).Where("id = ?", id).
 		Update("balance", gorm.Expr("balance + ?", amount)).Error
 }

 // DeductBalance 扣减用户余额，仅当余额充足时执行
 func (r *userRepository) DeductBalance(ctx context.Context, id int64, amount float64) error {
-	result := r.db.WithContext(ctx).Model(&model.User{}).
+	result := r.db.WithContext(ctx).Model(&userModel{}).
 		Where("id = ? AND balance >= ?", id, amount).
 		Update("balance", gorm.Expr("balance - ?", amount))
 	if result.Error != nil {
@@ -145,34 +154,104 @@ func (r *userRepository) DeductBalance(ctx context.Context, id int64, amount flo
 }

 func (r *userRepository) UpdateConcurrency(ctx context.Context, id int64, amount int) error {
-	return r.db.WithContext(ctx).Model(&model.User{}).Where("id = ?", id).
+	return r.db.WithContext(ctx).Model(&userModel{}).Where("id = ?", id).
 		Update("concurrency", gorm.Expr("concurrency + ?", amount)).Error
 }

 func (r *userRepository) ExistsByEmail(ctx context.Context, email string) (bool, error) {
 	var count int64
-	err := r.db.WithContext(ctx).Model(&model.User{}).Where("email = ?", email).Count(&count).Error
+	err := r.db.WithContext(ctx).Model(&userModel{}).Where("email = ?", email).Count(&count).Error
 	return count > 0, err
 }

 // RemoveGroupFromAllowedGroups 从所有用户的 allowed_groups 数组中移除指定的分组ID
 // 使用 PostgreSQL 的 array_remove 函数
 func (r *userRepository) RemoveGroupFromAllowedGroups(ctx context.Context, groupID int64) (int64, error) {
-	result := r.db.WithContext(ctx).Model(&model.User{}).
+	result := r.db.WithContext(ctx).Model(&userModel{}).
 		Where("? = ANY(allowed_groups)", groupID).
 		Update("allowed_groups", gorm.Expr("array_remove(allowed_groups, ?)", groupID))
 	return result.RowsAffected, result.Error
 }

 // GetFirstAdmin 获取第一个管理员用户（用于 Admin API Key 认证）
-func (r *userRepository) GetFirstAdmin(ctx context.Context) (*model.User, error) {
-	var user model.User
+func (r *userRepository) GetFirstAdmin(ctx context.Context) (*service.User, error) {
+	var m userModel
 	err := r.db.WithContext(ctx).
-		Where("role = ? AND status = ?", model.RoleAdmin, model.StatusActive).
+		Where("role = ? AND status = ?", service.RoleAdmin, service.StatusActive).
 		Order("id ASC").
-		First(&user).Error
+		First(&m).Error
 	if err != nil {
 		return nil, translatePersistenceError(err, service.ErrUserNotFound, nil)
 	}
-	return &user, nil
+	return userModelToService(&m), nil
+}
+
+type userModel struct {
+	ID            int64          `gorm:"primaryKey"`
+	Email         string         `gorm:"uniqueIndex;size:255;not null"`
+	Username      string         `gorm:"size:100;default:''"`
+	Wechat        string         `gorm:"size:100;default:''"`
+	Notes         string         `gorm:"type:text;default:''"`
+	PasswordHash  string         `gorm:"size:255;not null"`
+	Role          string         `gorm:"size:20;default:user;not null"`
+	Balance       float64        `gorm:"type:decimal(20,8);default:0;not null"`
+	Concurrency   int            `gorm:"default:5;not null"`
+	Status        string         `gorm:"size:20;default:active;not null"`
+	AllowedGroups pq.Int64Array  `gorm:"type:bigint[]"`
+	CreatedAt     time.Time      `gorm:"not null"`
+	UpdatedAt     time.Time      `gorm:"not null"`
+	DeletedAt     gorm.DeletedAt `gorm:"index"`
+}
+
+func (userModel) TableName() string { return "users" }
+
+func userModelToService(m *userModel) *service.User {
+	if m == nil {
+		return nil
+	}
+	return &service.User{
+		ID:            m.ID,
+		Email:         m.Email,
+		Username:      m.Username,
+		Wechat:        m.Wechat,
+		Notes:         m.Notes,
+		PasswordHash:  m.PasswordHash,
+		Role:          m.Role,
+		Balance:       m.Balance,
+		Concurrency:   m.Concurrency,
+		Status:        m.Status,
+		AllowedGroups: []int64(m.AllowedGroups),
+		CreatedAt:     m.CreatedAt,
+		UpdatedAt:     m.UpdatedAt,
+	}
+}
+
+func userModelFromService(u *service.User) *userModel {
+	if u == nil {
+		return nil
+	}
+	return &userModel{
+		ID:            u.ID,
+		Email:         u.Email,
+		Username:      u.Username,
+		Wechat:        u.Wechat,
+		Notes:         u.Notes,
+		PasswordHash:  u.PasswordHash,
+		Role:          u.Role,
+		Balance:       u.Balance,
+		Concurrency:   u.Concurrency,
+		Status:        u.Status,
+		AllowedGroups: pq.Int64Array(u.AllowedGroups),
+		CreatedAt:     u.CreatedAt,
+		UpdatedAt:     u.UpdatedAt,
+	}
+}
+
+func applyUserModelToService(dst *service.User, src *userModel) {
+	if dst == nil || src == nil {
+		return
+	}
+	dst.ID = src.ID
+	dst.CreatedAt = src.CreatedAt
+	dst.UpdatedAt = src.UpdatedAt
 }