rill/internal/api/users.go

package api

import (
	"context"
	"errors"
	"log/slog"
	"net/http"

	"github.com/gin-gonic/gin"
	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"

	"rill/internal/model"
)

const userGroupMembersTable = "user_group_members"

type userCreateRequest struct {
	Username string `json:"username" binding:"required,max=50"`
	Email    string `json:"email" binding:"required,email,max=255"`
	Password string `json:"password" binding:"required,min=6,max=72"`
	Nickname string `json:"nickname" binding:"max=50"`
	Avatar   string `json:"avatar" binding:"max=255"`
	Status   *int8  `json:"status" binding:"omitempty,oneof=0 1"`
	GroupIDs []uint `json:"group_ids"`
}

type userUpdateRequest struct {
	Nickname string  `json:"nickname" binding:"max=50"`
	Avatar   string  `json:"avatar" binding:"max=255"`
	Status   *int8   `json:"status" binding:"omitempty,oneof=0 1"`
	Password string  `json:"password" binding:"omitempty,min=6,max=72"`
	GroupIDs *[]uint `json:"group_ids"`
}

func listUsers(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		page, pageSize := parsePagination(c)
		ctx := c.Request.Context()

		var total int64
		if err := db.WithContext(ctx).Model(&model.User{}).Count(&total).Error; err != nil {
			respondDBError(c, err)
			return
		}

		var users []model.User
		if err := db.WithContext(ctx).
			Order("id DESC").
			Offset((page - 1) * pageSize).
			Limit(pageSize).
			Find(&users).Error; err != nil {
			respondDBError(c, err)
			return
		}
		if err := attachUserGroups(ctx, db, users); err != nil {
			respondDBError(c, err)
			return
		}

		c.JSON(http.StatusOK, gin.H{
			"items":     users,
			"total":     total,
			"page":      page,
			"page_size": pageSize,
		})
	}
}

func createUser(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		var req userCreateRequest
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "参数无效: " + err.Error()})
			return
		}

		ctx := c.Request.Context()
		hash, err := hashPassword(req.Password)
		if err != nil {
			respondHashError(c, err)
			return
		}

		status := int8(1)
		if req.Status != nil {
			status = *req.Status
		}

		groupIDs := req.GroupIDs
		if len(groupIDs) == 0 {
			groupIDs = []uint{model.GroupIDUser}
		}
		groups, err := findGroups(ctx, db, groupIDs)
		if err != nil {
			if errors.Is(err, errGroupsNotFound) {
				c.JSON(http.StatusBadRequest, gin.H{"error": errGroupsNotFound.Error()})
				return
			}
			respondDBError(c, err)
			return
		}

		user := model.User{
			Username:     req.Username,
			Email:        req.Email,
			PasswordHash: string(hash),
			Nickname:     req.Nickname,
			Avatar:       req.Avatar,
			Status:       status,
		}
		err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
			if err := tx.Create(&user).Error; err != nil {
				return err
			}
			return replaceUserGroups(tx, user.ID, groupIDs)
		})
		if err != nil {
			respondDuplicateOrDBError(c, err, "用户名或邮箱已存在")
			return
		}
		user.Groups = groups
		c.JSON(http.StatusCreated, user)
	}
}

func getUser(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id, ok := parseID(c)
		if !ok {
			return
		}

		ctx := c.Request.Context()
		var user model.User
		if err := db.WithContext(ctx).First(&user, id).Error; err != nil {
			respondGetError(c, err)
			return
		}

		groups, err := loadUserGroups(ctx, db, user.ID)
		if err != nil {
			respondDBError(c, err)
			return
		}
		user.Groups = groups
		c.JSON(http.StatusOK, user)
	}
}

func updateUser(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id, ok := parseID(c)
		if !ok {
			return
		}

		var req userUpdateRequest
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "参数无效: " + err.Error()})
			return
		}

		ctx := c.Request.Context()
		var user model.User
		if err := db.WithContext(ctx).First(&user, id).Error; err != nil {
			respondGetError(c, err)
			return
		}

		if req.GroupIDs != nil {
			if _, err := findGroups(ctx, db, *req.GroupIDs); err != nil {
				if errors.Is(err, errGroupsNotFound) {
					c.JSON(http.StatusBadRequest, gin.H{"error": errGroupsNotFound.Error()})
					return
				}
				respondDBError(c, err)
				return
			}
		}

		updates := map[string]any{
			"nickname": req.Nickname,
			"avatar":   req.Avatar,
		}
		if req.Status != nil {
			updates["status"] = *req.Status
		}
		if req.Password != "" {
			hash, err := hashPassword(req.Password)
			if err != nil {
				respondHashError(c, err)
				return
			}
			updates["password_hash"] = string(hash)
		}

		err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
			if err := tx.Model(&user).Updates(updates).Error; err != nil {
				return err
			}
			if req.GroupIDs != nil {
				return replaceUserGroups(tx, user.ID, *req.GroupIDs)
			}
			return nil
		})
		if err != nil {
			respondDBError(c, err)
			return
		}

		groups, err := loadUserGroups(ctx, db, user.ID)
		if err != nil {
			respondDBError(c, err)
			return
		}

		user.Nickname = req.Nickname
		user.Avatar = req.Avatar
		if req.Status != nil {
			user.Status = *req.Status
		}
		user.Groups = groups
		c.JSON(http.StatusOK, user)
	}
}

func deleteUser(db *gorm.DB) gin.HandlerFunc {
	return func(c *gin.Context) {
		id, ok := parseID(c)
		if !ok {
			return
		}

		ctx := c.Request.Context()
		var user model.User
		if err := db.WithContext(ctx).First(&user, id).Error; err != nil {
			respondGetError(c, err)
			return
		}

		err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
			if err := tx.Exec("DELETE FROM "+userGroupMembersTable+" WHERE user_id = ?", id).Error; err != nil {
				return err
			}
			return tx.Delete(&user).Error
		})
		if err != nil {
			respondDBError(c, err)
			return
		}
		c.Status(http.StatusNoContent)
	}
}

// replaceUserGroups 以给定的组 ID 整体替换用户的组成员关系。
func replaceUserGroups(tx *gorm.DB, userID uint, groupIDs []uint) error {
	if err := tx.Exec("DELETE FROM "+userGroupMembersTable+" WHERE user_id = ?", userID).Error; err != nil {
		return err
	}
	for _, groupID := range dedupeIDs(groupIDs) {
		if err := tx.Exec(
			"INSERT INTO "+userGroupMembersTable+" (user_id, user_group_id) VALUES (?, ?)",
			userID, groupID,
		).Error; err != nil {
			return err
		}
	}
	return nil
}

// loadUserGroups 查询单个用户所属的用户组。
func loadUserGroups(ctx context.Context, db *gorm.DB, userID uint) ([]model.UserGroup, error) {
	var groupIDs []uint
	if err := db.WithContext(ctx).Table(userGroupMembersTable).
		Where("user_id = ?", userID).
		Pluck("user_group_id", &groupIDs).Error; err != nil {
		return nil, err
	}

	groups := make([]model.UserGroup, 0, len(groupIDs))
	if len(groupIDs) == 0 {
		return groups, nil
	}
	if err := db.WithContext(ctx).Where("id IN ?", dedupeIDs(groupIDs)).Find(&groups).Error; err != nil {
		return nil, err
	}
	return groups, nil
}

// attachUserGroups 为一批用户批量填充所属用户组，避免逐条查询。
func attachUserGroups(ctx context.Context, db *gorm.DB, users []model.User) error {
	for i := range users {
		users[i].Groups = make([]model.UserGroup, 0)
	}
	if len(users) == 0 {
		return nil
	}

	ids := make([]uint, 0, len(users))
	positions := make(map[uint][]int, len(users))
	for i := range users {
		ids = append(ids, users[i].ID)
		positions[users[i].ID] = append(positions[users[i].ID], i)
	}

	var members []model.UserGroupMember
	if err := db.WithContext(ctx).Where("user_id IN ?", ids).Find(&members).Error; err != nil {
		return err
	}
	if len(members) == 0 {
		return nil
	}

	groupIDs := make([]uint, 0, len(members))
	for _, member := range members {
		groupIDs = append(groupIDs, member.UserGroupID)
	}
	var groups []model.UserGroup
	if err := db.WithContext(ctx).Where("id IN ?", dedupeIDs(groupIDs)).Find(&groups).Error; err != nil {
		return err
	}

	groupByID := make(map[uint]model.UserGroup, len(groups))
	for _, group := range groups {
		groupByID[group.ID] = group
	}
	for _, member := range members {
		group, ok := groupByID[member.UserGroupID]
		if !ok {
			continue
		}
		for _, i := range positions[member.UserID] {
			users[i].Groups = append(users[i].Groups, group)
		}
	}
	return nil
}

// findGroups 查询用户组并校验全部存在。
func findGroups(ctx context.Context, db *gorm.DB, ids []uint) ([]model.UserGroup, error) {
	unique := dedupeIDs(ids)
	var groups []model.UserGroup
	if err := db.WithContext(ctx).Where("id IN ?", unique).Find(&groups).Error; err != nil {
		return nil, err
	}
	if len(groups) != len(unique) {
		return nil, errGroupsNotFound
	}
	return groups, nil
}

func dedupeIDs(ids []uint) []uint {
	seen := make(map[uint]struct{}, len(ids))
	unique := make([]uint, 0, len(ids))
	for _, id := range ids {
		if _, ok := seen[id]; ok {
			continue
		}
		seen[id] = struct{}{}
		unique = append(unique, id)
	}
	return unique
}

func hashPassword(password string) (string, error) {
	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return "", err
	}
	return string(hash), nil
}

func respondHashError(c *gin.Context, err error) {
	slog.ErrorContext(c.Request.Context(), "生成密码哈希失败", "err", err)
	c.JSON(http.StatusInternalServerError, gin.H{"error": "服务器内部错误"})
}