完善用户管理与凭据事务处理

This commit is contained in:
xuans committed 2026-08-30 19:41:06 +08:00
1 parent 7f0af703ed
commit 0e2222bcfe
33 files changed
+2135 -68

No files matched your search

@@ -0,0 +1,300 @@
package repository
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"time"
"unicode"
"git.pcux.cn/xuans/Scert/backend/internal/auth"
"golang.org/x/crypto/bcrypt"
)
const (
UserRoleSuperAdmin = "super_admin"
UserRoleAdmin = "admin"
UserRoleUser = "user"
UserStatusActive = "active"
UserStatusDisabled = "disabled"
)
var ErrSuperAdminProtected = errors.New("超级管理员不能删除")
// User 表示一个可登录的管理后台用户。密码摘要不会被 JSON 输出。
type User struct {
ID string `json:"id"`
Username string `json:"username"`
Email string `json:"email"`
PasswordHash string `json:"-"`
Role string `json:"role"`
Status string `json:"status"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type UserRepository interface {
EnsureSuperAdmin(context.Context, User) error
FindByIdentifier(context.Context, string) (User, error)
ListUsers(context.Context) ([]User, error)
GetUserByID(context.Context, string) (User, error)
CreateUser(context.Context, User) error
UpdateUser(context.Context, User) error
DeleteUser(context.Context, string) error
}
type SQLUserRepository struct {
db *sql.DB
driver string
}
func NewSQLUserRepository(db *sql.DB, driver ...string) *SQLUserRepository {
selectedDriver := "sqlite"
if len(driver) > 0 && strings.TrimSpace(driver[0]) != "" {
selectedDriver = strings.ToLower(strings.TrimSpace(driver[0]))
}
return &SQLUserRepository{db: db, driver: selectedDriver}
}
func (r *SQLUserRepository) EnsureSuperAdmin(ctx context.Context, item User) error {
if err := r.ensureDB(); err != nil {
return err
}
item.Role = UserRoleSuperAdmin
item.Status = UserStatusActive
item = normalizeUser(item)
if item.ID == "" {
item.ID = "primary-super-admin"
}
if err := validateUser(item, false); err != nil {
return err
}
if err := r.upsert(ctx, item); err != nil {
return fmt.Errorf("同步超级管理员失败:%w", err)
}
return nil
}
func (r *SQLUserRepository) FindByIdentifier(ctx context.Context, identifier string) (User, error) {
if err := r.ensureDB(); err != nil {
return User{}, err
}
normalized, err := auth.NormalizeIdentifier(identifier)
if err != nil {
return User{}, err
}
row := r.db.QueryRowContext(ctx, userSelect+` WHERE LOWER(username) = ? OR (email IS NOT NULL AND LOWER(email) = ?) LIMIT 1`, normalized, normalized)
return scanUser(row)
}
func (r *SQLUserRepository) ListUsers(ctx context.Context) ([]User, error) {
if err := r.ensureDB(); err != nil {
return nil, err
}
rows, err := r.db.QueryContext(ctx, userSelect+` ORDER BY role, username, id`)
if err != nil {
return nil, fmt.Errorf("查询用户失败:%w", err)
}
defer rows.Close()
items := make([]User, 0)
for rows.Next() {
item, err := scanUser(rows)
if err != nil {
return nil, err
}
items = append(items, item)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("读取用户失败:%w", err)
}
return items, nil
}
func (r *SQLUserRepository) GetUserByID(ctx context.Context, id string) (User, error) {
if err := r.ensureDB(); err != nil {
return User{}, err
}
id = strings.TrimSpace(id)
if id == "" {
return User{}, errors.New("用户 ID 不能为空")
}
return scanUser(r.db.QueryRowContext(ctx, userSelect+` WHERE id = ?`, id))
}
func (r *SQLUserRepository) CreateUser(ctx context.Context, item User) error {
if err := r.ensureDB(); err != nil {
return err
}
item = normalizeUser(item)
if err := validateUser(item, false); err != nil {
return err
}
if item.CreatedAt.IsZero() {
item.CreatedAt = time.Now().UTC()
}
if item.UpdatedAt.IsZero() {
item.UpdatedAt = item.CreatedAt
}
_, err := r.db.ExecContext(ctx, `INSERT INTO users
(id, username, email, password_hash, role, status, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, item.ID, item.Username, r.emailValue(item.Email), item.PasswordHash,
item.Role, item.Status, item.CreatedAt, item.UpdatedAt)
if err != nil {
return fmt.Errorf("保存用户失败:%w", err)
}
return nil
}
func (r *SQLUserRepository) UpdateUser(ctx context.Context, item User) error {
if err := r.ensureDB(); err != nil {
return err
}
item = normalizeUser(item)
if err := validateUser(item, false); err != nil {
return err
}
result, err := r.db.ExecContext(ctx, `UPDATE users SET username = ?, email = ?, password_hash = ?, role = ?, status = ?, updated_at = ? WHERE id = ?`,
item.Username, r.emailValue(item.Email), item.PasswordHash, item.Role, item.Status, time.Now().UTC(), item.ID)
if err != nil {
return fmt.Errorf("更新用户失败:%w", err)
}
count, err := result.RowsAffected()
if err != nil {
return fmt.Errorf("读取用户更新结果失败:%w", err)
}
if count == 0 {
return sql.ErrNoRows
}
return nil
}
func (r *SQLUserRepository) DeleteUser(ctx context.Context, id string) error {
if err := r.ensureDB(); err != nil {
return err
}
id = strings.TrimSpace(id)
if id == "" {
return errors.New("用户 ID 不能为空")
}
if id == "primary-super-admin" {
return ErrSuperAdminProtected
}
result, err := r.db.ExecContext(ctx, `DELETE FROM users WHERE id = ?`, id)
if err != nil {
return fmt.Errorf("删除用户失败:%w", err)
}
count, err := result.RowsAffected()
if err != nil {
return fmt.Errorf("读取用户删除结果失败:%w", err)
}
if count == 0 {
return sql.ErrNoRows
}
return nil
}
func (r *SQLUserRepository) ensureDB() error {
if r == nil || r.db == nil {
return errors.New("数据库连接不能为空")
}
return nil
}
func (r *SQLUserRepository) upsert(ctx context.Context, item User) error {
now := time.Now().UTC()
if item.CreatedAt.IsZero() {
item.CreatedAt = now
}
item.UpdatedAt = now
result, err := r.db.ExecContext(ctx, `UPDATE users SET username = ?, email = ?, password_hash = ?, role = ?, status = ?, updated_at = ? WHERE id = ?`,
item.Username, r.emailValue(item.Email), item.PasswordHash, item.Role, item.Status, item.UpdatedAt, item.ID)
if err != nil {
return err
}
count, err := result.RowsAffected()
if err != nil {
return err
}
if count > 0 {
return nil
}
_, err = r.db.ExecContext(ctx, `INSERT INTO users
(id, username, email, password_hash, role, status, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, item.ID, item.Username, r.emailValue(item.Email), item.PasswordHash,
item.Role, item.Status, item.CreatedAt, item.UpdatedAt)
return err
}
func (r *SQLUserRepository) emailValue(email string) any {
if email == "" && r.driver == "mysql" {
return nil
}
return email
}
func normalizeUser(item User) User {
item.ID = strings.TrimSpace(item.ID)
item.Username = strings.TrimSpace(strings.ToLower(item.Username))
item.Email = strings.TrimSpace(strings.ToLower(item.Email))
item.Role = strings.TrimSpace(strings.ToLower(item.Role))
item.Status = strings.TrimSpace(strings.ToLower(item.Status))
return item
}
func validateUser(item User, allowEmptyID bool) error {
item = normalizeUser(item)
if item.ID == "" && !allowEmptyID {
return errors.New("用户 ID 不能为空")
}
if len([]byte(item.Username)) < 3 || len([]byte(item.Username)) > 64 {
return errors.New("用户名长度必须为 3 到 64 个字符")
}
if strings.Contains(item.Username, "@") {
return errors.New("用户名格式无效")
}
for _, char := range item.Username {
if unicode.IsSpace(char) || unicode.IsControl(char) {
return errors.New("用户名不能包含空格或控制字符")
}
}
switch item.Username {
case "admin", "administrator", "root", "system", "scert":
if item.Role != UserRoleSuperAdmin || item.Username != "admin" {
return errors.New("用户名为系统保留名称")
}
}
if item.Email != "" {
if _, err := auth.NormalizeIdentifier(item.Email); err != nil || !strings.Contains(item.Email, "@") {
return errors.New("邮箱格式无效")
}
}
if _, err := bcrypt.Cost([]byte(item.PasswordHash)); err != nil {
return errors.New("密码摘要无效")
}
if item.Role != UserRoleSuperAdmin && item.Role != UserRoleAdmin && item.Role != UserRoleUser {
return fmt.Errorf("用户角色无效:%s", item.Role)
}
if item.Status != UserStatusActive && item.Status != UserStatusDisabled {
return fmt.Errorf("用户状态无效:%s", item.Status)
}
return nil
}
const userSelect = `SELECT id, username, email, password_hash, role, status, created_at, updated_at FROM users`
func scanUser(row interface{ Scan(...any) error }) (User, error) {
var item User
var email sql.NullString
if err := row.Scan(&item.ID, &item.Username, &email, &item.PasswordHash, &item.Role, &item.Status, &item.CreatedAt, &item.UpdatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return User{}, sql.ErrNoRows
}
return User{}, fmt.Errorf("读取用户失败:%w", err)
}
if email.Valid {
item.Email = email.String
}
return normalizeUser(item), nil
}
@@ -0,0 +1,133 @@
package repository
import (
"context"
"encoding/json"
"errors"
"path/filepath"
"strings"
"testing"
"golang.org/x/crypto/bcrypt"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
)
func TestSQLUserRepositoryCRUDAndLookup(t *testing.T) {
db := openUserTestDatabase(t)
defer db.Close()
repo := NewSQLUserRepository(db.DB, "sqlite")
hash := userTestPasswordHash(t, "UserPass123")
item := User{ID: "user-1", Username: "Operator", Email: "Operator@Example.Test", PasswordHash: hash, Role: UserRoleUser, Status: UserStatusActive}
if err := repo.CreateUser(t.Context(), item); err != nil {
t.Fatalf("创建用户失败:%v", err)
}
byName, err := repo.FindByIdentifier(t.Context(), " operator ")
if err != nil || byName.ID != item.ID || byName.Username != "operator" {
t.Fatalf("按用户名查询用户失败:%v %+v", err, byName)
}
byEmail, err := repo.FindByIdentifier(t.Context(), "OPERATOR@EXAMPLE.TEST")
if err != nil || byEmail.ID != item.ID || byEmail.Email != "operator@example.test" {
t.Fatalf("按邮箱查询用户失败:%v %+v", err, byEmail)
}
encoded, err := json.Marshal(byName)
if err != nil || strings.Contains(string(encoded), hash) || strings.Contains(string(encoded), "password_hash") {
t.Fatalf("用户 JSON 不应包含密码摘要:%s", encoded)
}
updated := byName
updated.Role = UserRoleAdmin
updated.Status = UserStatusDisabled
if err := repo.UpdateUser(t.Context(), updated); err != nil {
t.Fatalf("更新用户失败:%v", err)
}
loaded, err := repo.GetUserByID(t.Context(), item.ID)
if err != nil || loaded.Role != UserRoleAdmin || loaded.Status != UserStatusDisabled {
t.Fatalf("读取更新后的用户失败:%v %+v", err, loaded)
}
if bcrypt.CompareHashAndPassword([]byte(loaded.PasswordHash), []byte("UserPass123")) != nil {
t.Fatal("更新用户不应改变原密码")
}
items, err := repo.ListUsers(t.Context())
if err != nil || len(items) != 1 {
t.Fatalf("列出用户失败:%v %+v", err, items)
}
if err := repo.DeleteUser(t.Context(), item.ID); err != nil {
t.Fatalf("删除用户失败:%v", err)
}
if _, err := repo.GetUserByID(t.Context(), item.ID); !errors.Is(err, context.Canceled) && !IsNotFound(err) {
t.Fatalf("删除用户后查询结果错误:%v", err)
}
}
func TestSQLUserRepositoryEnforcesIdentityAndSuperAdminRules(t *testing.T) {
db := openUserTestDatabase(t)
defer db.Close()
repo := NewSQLUserRepository(db.DB, "sqlite")
first := User{ID: "user-1", Username: "operator", Email: "operator@example.test", PasswordHash: userTestPasswordHash(t, "UserPass123"), Role: UserRoleUser, Status: UserStatusActive}
if err := repo.CreateUser(t.Context(), first); err != nil {
t.Fatal(err)
}
duplicateName := first
duplicateName.ID = "user-2"
duplicateName.Email = "second@example.test"
if err := repo.CreateUser(t.Context(), duplicateName); !IsConflict(err) {
t.Fatalf("重复用户名未被拒绝:%v", err)
}
duplicateEmail := first
duplicateEmail.ID = "user-3"
duplicateEmail.Username = "second"
if err := repo.CreateUser(t.Context(), duplicateEmail); !IsConflict(err) {
t.Fatalf("重复邮箱未被拒绝:%v", err)
}
if err := repo.EnsureSuperAdmin(t.Context(), User{ID: "primary-super-admin", Username: "admin", Email: "admin@example.test", PasswordHash: userTestPasswordHash(t, "AdminPass123")}); err != nil {
t.Fatalf("保存超级管理员失败:%v", err)
}
if err := repo.DeleteUser(t.Context(), "primary-super-admin"); !errors.Is(err, ErrSuperAdminProtected) {
t.Fatalf("主超级管理员不应被删除:%v", err)
}
secondAdmin := User{ID: "super-2", Username: "owner", PasswordHash: userTestPasswordHash(t, "OwnerPass123"), Role: UserRoleSuperAdmin, Status: UserStatusActive}
if err := repo.CreateUser(t.Context(), secondAdmin); err != nil {
t.Fatalf("创建第二个超级管理员失败:%v", err)
}
if err := repo.DeleteUser(t.Context(), secondAdmin.ID); err != nil {
t.Fatalf("删除第二个超级管理员失败:%v", err)
}
}
func TestSQLUserRepositoryNilDatabase(t *testing.T) {
var repo *SQLUserRepository
if err := repo.CreateUser(context.Background(), User{}); err == nil {
t.Fatal("空数据库连接应返回错误")
}
}
func openUserTestDatabase(t *testing.T) *database.Database {
t.Helper()
directory := t.TempDir()
cfg := config.Default(directory).Database
cfg.DSN = filepath.Join(directory, "data", "users.db")
db, err := database.Open(t.Context(), cfg)
if err != nil {
t.Fatalf("打开用户测试数据库失败:%v", err)
}
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
_ = db.Close()
t.Fatalf("迁移用户测试数据库失败:%v", err)
}
return db
}
func userTestPasswordHash(t *testing.T, password string) string {
t.Helper()
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.MinCost)
if err != nil {
t.Fatalf("生成测试密码摘要失败:%v", err)
}
return string(hash)
}