47a183aa65
- Added WEKNORA_BOOTSTRAP_SYSTEM_ADMIN_EMAIL environment variable to promote a specified user to system admin on startup. - Introduced a new bootstrap process in `bootstrap.go` to handle the promotion logic. - Updated `.env.example` to document the new environment variable and its behavior. - Created new views for managing system administrators and system settings, including listing, promoting, and revoking admin privileges. - Enhanced the frontend to reflect the new system admin features, including UI elements for admin management and settings configuration. - Updated API interfaces to support system admin functionalities, ensuring proper data handling and user management.
240 lines
7.5 KiB
Go
240 lines
7.5 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var (
|
|
ErrUserNotFound = errors.New("user not found")
|
|
ErrUserAlreadyExists = errors.New("user already exists")
|
|
ErrTokenNotFound = errors.New("token not found")
|
|
)
|
|
|
|
// userRepository implements user repository interface
|
|
type userRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewUserRepository creates a new user repository
|
|
func NewUserRepository(db *gorm.DB) interfaces.UserRepository {
|
|
return &userRepository{db: db}
|
|
}
|
|
|
|
// CreateUser creates a user
|
|
func (r *userRepository) CreateUser(ctx context.Context, user *types.User) error {
|
|
return r.db.WithContext(ctx).Create(user).Error
|
|
}
|
|
|
|
// GetUserByID gets a user by ID
|
|
func (r *userRepository) GetUserByID(ctx context.Context, id string) (*types.User, error) {
|
|
var user types.User
|
|
if err := r.db.WithContext(ctx).Where("id = ?", id).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrUserNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// GetUsersByIDs batch-fetches users by id with a single SELECT … WHERE id IN (…)
|
|
// and projects the result into a map keyed by user id. Returns an empty
|
|
// map for an empty input slice. Missing ids are silently absent from
|
|
// the result (consistent with the interface contract used by tenant
|
|
// member hydration).
|
|
func (r *userRepository) GetUsersByIDs(ctx context.Context, ids []string) (map[string]*types.User, error) {
|
|
out := make(map[string]*types.User, len(ids))
|
|
if len(ids) == 0 {
|
|
return out, nil
|
|
}
|
|
var users []*types.User
|
|
if err := r.db.WithContext(ctx).Where("id IN ?", ids).Find(&users).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
for _, u := range users {
|
|
out[u.ID] = u
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GetUserByEmail gets a user by email
|
|
func (r *userRepository) GetUserByEmail(ctx context.Context, email string) (*types.User, error) {
|
|
var user types.User
|
|
if err := r.db.WithContext(ctx).Where("email = ?", email).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrUserNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// GetUserByUsername gets a user by username
|
|
func (r *userRepository) GetUserByUsername(ctx context.Context, username string) (*types.User, error) {
|
|
var user types.User
|
|
if err := r.db.WithContext(ctx).Where("username = ?", username).First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrUserNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// GetUserByTenantID gets the first user (owner) of a tenant
|
|
func (r *userRepository) GetUserByTenantID(ctx context.Context, tenantID uint64) (*types.User, error) {
|
|
var user types.User
|
|
if err := r.db.WithContext(ctx).Where("tenant_id = ?", tenantID).Order("created_at ASC").First(&user).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrUserNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// UpdateUser updates a user
|
|
func (r *userRepository) UpdateUser(ctx context.Context, user *types.User) error {
|
|
return r.db.WithContext(ctx).Save(user).Error
|
|
}
|
|
|
|
// DeleteUser deletes a user
|
|
func (r *userRepository) DeleteUser(ctx context.Context, id string) error {
|
|
return r.db.WithContext(ctx).Where("id = ?", id).Delete(&types.User{}).Error
|
|
}
|
|
|
|
// ListUsers lists users with pagination
|
|
func (r *userRepository) ListUsers(ctx context.Context, offset, limit int) ([]*types.User, error) {
|
|
var users []*types.User
|
|
query := r.db.WithContext(ctx).Order("created_at DESC")
|
|
|
|
if limit > 0 {
|
|
query = query.Limit(limit)
|
|
}
|
|
|
|
if offset > 0 {
|
|
query = query.Offset(offset)
|
|
}
|
|
|
|
if err := query.Find(&users).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
// ListSystemAdmins lists users where is_system_admin = true.
|
|
//
|
|
// Walks idx_users_is_system_admin (created in migration 000052), so the
|
|
// query stays cheap even on a large users table — only the small subset
|
|
// of system admins is scanned. Returns total count alongside the page so
|
|
// the management UI can render pagination without a second roundtrip.
|
|
//
|
|
// Ordered by created_at DESC for stable, newest-first listing; ties are
|
|
// further broken by id to keep paging deterministic across boundaries.
|
|
// limit <= 0 means "no limit" (matches ListUsers semantics); callers in
|
|
// production pass a sane page size.
|
|
func (r *userRepository) ListSystemAdmins(ctx context.Context, offset, limit int) ([]*types.User, int64, error) {
|
|
var users []*types.User
|
|
var total int64
|
|
|
|
base := r.db.WithContext(ctx).Model(&types.User{}).Where("is_system_admin = ?", true)
|
|
if err := base.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
query := base.Order("created_at DESC, id ASC")
|
|
if limit > 0 {
|
|
query = query.Limit(limit)
|
|
}
|
|
if offset > 0 {
|
|
query = query.Offset(offset)
|
|
}
|
|
if err := query.Find(&users).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return users, total, nil
|
|
}
|
|
|
|
// SearchUsers searches users by username or email
|
|
func (r *userRepository) SearchUsers(ctx context.Context, query string, limit int) ([]*types.User, error) {
|
|
var users []*types.User
|
|
searchPattern := "%" + query + "%"
|
|
|
|
dbQuery := r.db.WithContext(ctx).
|
|
Where("username ILIKE ? OR email ILIKE ?", searchPattern, searchPattern).
|
|
Where("is_active = ?", true).
|
|
Order("username ASC")
|
|
|
|
if limit > 0 {
|
|
dbQuery = dbQuery.Limit(limit)
|
|
} else {
|
|
dbQuery = dbQuery.Limit(20) // default limit
|
|
}
|
|
|
|
if err := dbQuery.Find(&users).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
// authTokenRepository implements auth token repository interface
|
|
type authTokenRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewAuthTokenRepository creates a new auth token repository
|
|
func NewAuthTokenRepository(db *gorm.DB) interfaces.AuthTokenRepository {
|
|
return &authTokenRepository{db: db}
|
|
}
|
|
|
|
// CreateToken creates an auth token
|
|
func (r *authTokenRepository) CreateToken(ctx context.Context, token *types.AuthToken) error {
|
|
return r.db.WithContext(ctx).Create(token).Error
|
|
}
|
|
|
|
// GetTokenByValue gets a token by its value
|
|
func (r *authTokenRepository) GetTokenByValue(ctx context.Context, tokenValue string) (*types.AuthToken, error) {
|
|
var token types.AuthToken
|
|
if err := r.db.WithContext(ctx).Where("token = ?", tokenValue).First(&token).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrTokenNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &token, nil
|
|
}
|
|
|
|
// GetTokensByUserID gets all tokens for a user
|
|
func (r *authTokenRepository) GetTokensByUserID(ctx context.Context, userID string) ([]*types.AuthToken, error) {
|
|
var tokens []*types.AuthToken
|
|
if err := r.db.WithContext(ctx).Where("user_id = ?", userID).Find(&tokens).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return tokens, nil
|
|
}
|
|
|
|
// UpdateToken updates a token
|
|
func (r *authTokenRepository) UpdateToken(ctx context.Context, token *types.AuthToken) error {
|
|
return r.db.WithContext(ctx).Save(token).Error
|
|
}
|
|
|
|
// DeleteToken deletes a token
|
|
func (r *authTokenRepository) DeleteToken(ctx context.Context, id string) error {
|
|
return r.db.WithContext(ctx).Where("id = ?", id).Delete(&types.AuthToken{}).Error
|
|
}
|
|
|
|
// DeleteExpiredTokens deletes all expired tokens
|
|
func (r *authTokenRepository) DeleteExpiredTokens(ctx context.Context) error {
|
|
return r.db.WithContext(ctx).Where("expires_at < NOW()").Delete(&types.AuthToken{}).Error
|
|
}
|
|
|
|
// RevokeTokensByUserID revokes all tokens for a user
|
|
func (r *authTokenRepository) RevokeTokensByUserID(ctx context.Context, userID string) error {
|
|
return r.db.WithContext(ctx).Model(&types.AuthToken{}).Where("user_id = ?", userID).Update("is_revoked", true).Error
|
|
}
|