Files
hfb_sys/backend/internal/modules/adminmgr/repository.go
T

433 lines
12 KiB
Go

package adminmgr
import (
"context"
"errors"
"fmt"
"hfb_sys/backend/internal/auditlog"
"hfb_sys/backend/internal/logging"
"hfb_sys/backend/internal/model"
"hfb_sys/backend/internal/modules/adminrole"
"hfb_sys/backend/internal/tenancy"
"github.com/redis/go-redis/v9"
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
type Repository struct {
db *gorm.DB
redis *redis.Client
}
func NewRepository(db *gorm.DB, redis *redis.Client) *Repository {
return &Repository{db: db, redis: redis}
}
func (r *Repository) List(ctx context.Context, page, pageSize int) (*PaginatedResult, error) {
db := r.scopedAdminQuery(ctx)
var total int64
if err := db.Model(&model.AdminUser{}).Count(&total).Error; err != nil {
return nil, err
}
offset := (page - 1) * pageSize
var admins []model.AdminUser
if err := db.Order("id DESC").Offset(offset).Limit(pageSize).Find(&admins).Error; err != nil {
return nil, err
}
items := make([]AdminUserDTO, 0, len(admins))
for _, admin := range admins {
roles, _ := r.getAdminRoles(ctx, admin.ID)
items = append(items, AdminUserDTO{
ID: admin.ID,
Username: admin.Username,
Nickname: admin.Nickname,
Status: admin.Status,
Roles: roles,
LastLoginAt: admin.LastLoginAt,
CreatedAt: admin.CreatedAt,
UpdatedAt: admin.UpdatedAt,
})
}
return &PaginatedResult{Items: items, Total: total, Page: page, PageSize: pageSize}, nil
}
func (r *Repository) FindByID(ctx context.Context, id uint64) (*AdminUserDTO, error) {
var admin model.AdminUser
if err := r.scopedAdminQuery(ctx).Where("admin_users.id = ?", id).First(&admin).Error; err != nil {
return nil, err
}
roles, _ := r.getAdminRoles(ctx, admin.ID)
dto := AdminUserDTO{
ID: admin.ID,
Username: admin.Username,
Nickname: admin.Nickname,
Status: admin.Status,
Roles: roles,
LastLoginAt: admin.LastLoginAt,
CreatedAt: admin.CreatedAt,
UpdatedAt: admin.UpdatedAt,
}
return &dto, nil
}
func (r *Repository) Create(ctx context.Context, req CreateAdminRequest) (*AdminUserDTO, error) {
hash, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
if err != nil {
return nil, err
}
// 仅部署 bootstrap 首个超级管理员会强制改密;后台新建账号不强制。
admin := model.AdminUser{
Username: req.Username,
PasswordHash: string(hash),
Nickname: req.Nickname,
Status: "active",
TokenVersion: 1,
PasswordMustChange: false,
}
if err := r.db.WithContext(ctx).Create(&admin).Error; err != nil {
return nil, err
}
return &AdminUserDTO{
ID: admin.ID,
Username: admin.Username,
Nickname: admin.Nickname,
Status: admin.Status,
Roles: []adminrole.RoleDTO{},
LastLoginAt: admin.LastLoginAt,
CreatedAt: admin.CreatedAt,
UpdatedAt: admin.UpdatedAt,
}, nil
}
func (r *Repository) Update(ctx context.Context, id uint64, req UpdateAdminRequest) (*AdminUserDTO, error) {
db := r.db.WithContext(ctx)
var admin model.AdminUser
if err := r.scopedAdminQuery(ctx).Where("admin_users.id = ?", id).First(&admin).Error; err != nil {
return nil, err
}
if req.Nickname != "" {
admin.Nickname = req.Nickname
}
if req.Status != "" {
admin.Status = req.Status
}
if err := db.Save(&admin).Error; err != nil {
return nil, err
}
if req.Status != "" {
if err := r.bumpTokenVersion(db, ctx, id, "admin_status_changed"); err != nil {
return nil, err
}
r.invalidatePermCache(ctx, id)
}
return r.FindByID(ctx, id)
}
func (r *Repository) Delete(ctx context.Context, id uint64, currentAdminID uint64) error {
if id == currentAdminID {
return ErrCannotDeleteSelf
}
db := r.db.WithContext(ctx)
var admin model.AdminUser
if err := r.scopedAdminQuery(ctx).Where("admin_users.id = ?", id).First(&admin).Error; err != nil {
return err
}
tenantID := tenancy.IDFromContext(ctx)
if tenantID > 0 {
isSuper, err := r.adminHasRoleCode(ctx, id, "super_admin")
if err != nil {
return err
}
if isSuper {
return ErrLastSuperAdmin
}
err = db.Transaction(func(tx *gorm.DB) error {
if err := tx.Where("admin_user_id = ? AND tenant_id = ?", id, tenantID).
Delete(&model.AdminUserRole{}).Error; err != nil {
return err
}
var remaining int64
if err := tx.Model(&model.AdminUserRole{}).
Where("admin_user_id = ?", id).Count(&remaining).Error; err != nil {
return err
}
if remaining == 0 {
if err := tx.Delete(&model.AdminUser{}, id).Error; err != nil {
return err
}
} else if err := r.bumpTokenVersion(tx, ctx, id, "tenant_roles_removed"); err != nil {
return err
}
return nil
})
if err != nil {
return err
}
r.invalidatePermCache(ctx, id)
return nil
}
// 检查是否是最后一个 super_admin
isLastSuper, err := r.isLastSuperAdmin(ctx, id)
if err != nil {
return err
}
if isLastSuper {
return ErrLastSuperAdmin
}
err = db.Transaction(func(tx *gorm.DB) error {
if err := tx.Where("admin_user_id = ?", id).Delete(&model.AdminUserRole{}).Error; err != nil {
return err
}
if err := tx.Delete(&model.AdminUser{}, id).Error; err != nil {
return err
}
return nil
})
if err == nil {
r.invalidatePermCache(ctx, id)
}
return err
}
func (r *Repository) AssignRoles(ctx context.Context, adminID uint64, roleIDs []uint64) error {
db := r.db.WithContext(ctx)
tenantID := tenancy.IDFromContext(ctx)
var admin model.AdminUser
if err := db.First(&admin, adminID).Error; err != nil {
return err
}
roleIDs, err := r.validateTenantRoleIDs(ctx, roleIDs)
if err != nil {
return err
}
err = db.Transaction(func(tx *gorm.DB) error {
deleteQuery := tx.Where("admin_user_id = ?", adminID)
if tenantID > 0 {
deleteQuery = deleteQuery.Where("tenant_id = ?", tenantID)
}
if err := deleteQuery.Delete(&model.AdminUserRole{}).Error; err != nil {
return err
}
for _, rid := range roleIDs {
aur := model.AdminUserRole{AdminID: adminID, RoleID: rid, TenantID: tenantID}
if err := tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&aur).Error; err != nil {
return err
}
}
return r.bumpTokenVersion(tx, ctx, adminID, "roles_changed")
})
if err != nil {
return err
}
r.invalidatePermCache(ctx, adminID)
return nil
}
func (r *Repository) ChangeOwnPassword(ctx context.Context, id uint64, oldPwd, newPwd string) error {
var admin model.AdminUser
if err := r.db.WithContext(ctx).First(&admin, id).Error; err != nil {
return err
}
if err := bcrypt.CompareHashAndPassword([]byte(admin.PasswordHash), []byte(oldPwd)); err != nil {
return ErrWrongPassword
}
hash, err := bcrypt.GenerateFromPassword([]byte(newPwd), bcrypt.DefaultCost)
if err != nil {
return err
}
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Model(&admin).Updates(map[string]any{
"password_hash": string(hash),
"password_must_change": false,
}).Error; err != nil {
return err
}
return r.bumpTokenVersion(tx, ctx, id, "password_changed")
})
}
func (r *Repository) ResetPassword(ctx context.Context, id uint64, newPwd string) error {
var admin model.AdminUser
if err := r.scopedAdminQuery(ctx).Where("admin_users.id = ?", id).First(&admin).Error; err != nil {
return err
}
hash, err := bcrypt.GenerateFromPassword([]byte(newPwd), bcrypt.DefaultCost)
if err != nil {
return err
}
// 管理员重置密码后直接可用,不再二次强制改密(强制改密仅用于 bootstrap 初始账号)。
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Model(&admin).Updates(map[string]any{
"password_hash": string(hash),
"password_must_change": false,
}).Error; err != nil {
return err
}
return r.bumpTokenVersion(tx, ctx, id, "password_reset")
})
}
func (r *Repository) GetPermissionCodes(ctx context.Context, adminID uint64) ([]string, error) {
isSuper, err := r.adminHasRoleCode(ctx, adminID, "super_admin")
if err != nil {
return nil, err
}
if isSuper {
return []string{"*"}, nil
}
var codes []string
query := r.db.WithContext(ctx).Table("admin_user_roles aur").
Select("DISTINCT p.code").
Joins("JOIN role_permissions rp ON rp.role_id = aur.role_id").
Joins("JOIN permissions p ON p.id = rp.permission_id").
Where("aur.admin_user_id = ?", adminID)
if tenantID := tenancy.IDFromContext(ctx); tenantID > 0 {
query = query.Where("aur.tenant_id = ?", tenantID)
}
err = query.Pluck("code", &codes).Error
return codes, err
}
func (r *Repository) getAdminRoles(ctx context.Context, adminID uint64) ([]adminrole.RoleDTO, error) {
var roles []model.Role
query := r.db.WithContext(ctx).Table("roles").
Joins("JOIN admin_user_roles aur ON aur.role_id = roles.id").
Where("aur.admin_user_id = ?", adminID)
if tenantID := tenancy.IDFromContext(ctx); tenantID > 0 {
query = query.Where("(aur.tenant_id = ? OR roles.code = ?)", tenantID, "super_admin")
}
err := query.Find(&roles).Error
if err != nil {
return nil, err
}
result := make([]adminrole.RoleDTO, 0, len(roles))
for _, role := range roles {
result = append(result, adminrole.RoleDTO{
ID: role.ID, Code: role.Code, Name: role.Name, Description: role.Description,
})
}
return result, nil
}
func (r *Repository) isLastSuperAdmin(ctx context.Context, adminID uint64) (bool, error) {
var superRole model.Role
db := r.db.WithContext(ctx)
if err := db.Where("code = ?", "super_admin").First(&superRole).Error; err != nil {
return false, nil // 没有 super_admin 角色,不限制
}
var count int64
err := db.Model(&model.AdminUserRole{}).
Where("role_id = ? AND admin_user_id != ?", superRole.ID, adminID).
Count(&count).Error
return count == 0, err
}
func (r *Repository) invalidatePermCache(ctx context.Context, adminID uint64) {
if r.redis == nil {
return
}
patterns := []string{
permCacheKey(adminID),
fmt.Sprintf("admin:perms:%d:*", adminID),
}
for _, pattern := range patterns {
var cursor uint64
for {
keys, next, err := r.redis.Scan(ctx, cursor, pattern, 100).Result()
if err != nil {
return
}
if len(keys) > 0 {
_ = r.redis.Del(ctx, keys...).Err()
}
cursor = next
if cursor == 0 {
break
}
}
}
}
func (r *Repository) bumpTokenVersion(db *gorm.DB, ctx context.Context, adminID uint64, reason string) error {
if err := db.Model(&model.AdminUser{}).
Where("id = ?", adminID).
UpdateColumn("token_version", gorm.Expr("token_version + 1")).Error; err != nil {
return err
}
bizID := adminID
return auditlog.Append(db, auditlog.Entry{
ActorType: "admin",
ActorID: logging.AdminIDFromContext(ctx),
Action: "auth.token_version.bump",
BizType: "admin_user",
BizID: &bizID,
Meta: auditlog.Meta{RequestID: logging.RequestIDFromContext(ctx)},
Detail: map[string]any{
"target_admin_id": adminID,
"reason": reason,
},
})
}
func permCacheKey(adminID uint64) string {
return fmt.Sprintf("admin:perms:%d", adminID)
}
func (r *Repository) scopedAdminQuery(ctx context.Context) *gorm.DB {
query := r.db.WithContext(ctx).Model(&model.AdminUser{})
tenantID := tenancy.IDFromContext(ctx)
if tenantID > 0 {
query = query.Where(`EXISTS (
SELECT 1 FROM admin_user_roles aur
JOIN roles r ON r.id = aur.role_id
WHERE aur.admin_user_id = admin_users.id
AND (aur.tenant_id = ? OR r.code = ?)
)`, tenantID, "super_admin")
}
return query
}
func (r *Repository) validateTenantRoleIDs(ctx context.Context, roleIDs []uint64) ([]uint64, error) {
tenantID := tenancy.IDFromContext(ctx)
if tenantID == 0 || len(roleIDs) == 0 {
return roleIDs, nil
}
var count int64
if err := r.db.WithContext(ctx).Model(&model.Role{}).
Where("id IN ? AND code <> ?", roleIDs, "super_admin").
Count(&count).Error; err != nil {
return nil, err
}
unique := make(map[uint64]struct{}, len(roleIDs))
for _, id := range roleIDs {
unique[id] = struct{}{}
}
if count != int64(len(unique)) {
return nil, ErrRoleOutsideTenant
}
return roleIDs, nil
}
func (r *Repository) adminHasRoleCode(ctx context.Context, adminID uint64, code string) (bool, error) {
var count int64
err := r.db.WithContext(ctx).Table("admin_user_roles AS aur").
Joins("JOIN roles AS r ON r.id = aur.role_id").
Where("aur.admin_user_id = ? AND r.code = ?", adminID, code).
Count(&count).Error
return count > 0, err
}
var (
ErrCannotDeleteSelf = errors.New("cannot delete self")
ErrLastSuperAdmin = errors.New("cannot delete the last super admin")
ErrWrongPassword = errors.New("wrong password")
ErrRoleOutsideTenant = errors.New("role is not available in current tenant")
)
func IsNotFound(err error) bool {
return errors.Is(err, gorm.ErrRecordNotFound)
}