433 lines
12 KiB
Go
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)
|
|
}
|