perms-system-server/internal/loaders/userDetailsLoader.go

package loaders

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"math"

	"perms-system-server/internal/consts"
	"perms-system-server/internal/model"
	"perms-system-server/internal/model/productmember"

	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"golang.org/x/sync/singleflight"
)

const (
	defaultCacheTTL = 300 // 5 分钟
	// negativeCacheTTL 控制"用户不存在/已删除"的短期负缓存窗口；必须显著短于 defaultCacheTTL，避免
	// 刚刚 createUser 的合法用户被误判为不存在，但又要足够长到能吸收一波由离职用户残留 token 带来的
	// 无效流量（审计 M-3 所说的 DB DoS 放大路径）。
	negativeCacheTTL = 30 // 30s
	// negativeCacheMarker 是写入 Redis 的哨兵字符串；选用非合法 JSON，确保任何升级带来的 schema
	// 变动都不会把它误解析为真实 UserDetails。
	negativeCacheMarker = "_NOT_FOUND_"
)

// -------- UserDetails 及子结构 --------

// UserDetails 用户完整信息，包含用户、部门、产品、成员、角色、权限等所有有效字段。
// 由 UserDetailsLoader 一次性加载，可用于中间件 context 注入、login/userInfo 响应、Claims 构造等。
type UserDetails struct {
	// 用户基本信息 (sys_user)
	UserId             int64  `json:"userId"`
	Username           string `json:"username"`
	Nickname           string `json:"nickname"`
	Avatar             string `json:"avatar"`
	Email              string `json:"email"`
	Phone              string `json:"phone"`
	Remark             string `json:"remark"`
	IsSuperAdmin       bool   `json:"isSuperAdmin"`
	IsSuperAdminRaw    int64  `json:"isSuperAdminRaw"`
	MustChangePassword bool   `json:"mustChangePassword"`
	MustChangePwdRaw   int64  `json:"mustChangePwdRaw"`
	Status             int64  `json:"status"`
	TokenVersion       int64  `json:"tokenVersion"`

	// 部门信息 (sys_dept)
	DeptId     int64  `json:"deptId"`
	DeptName   string `json:"deptName"`
	DeptPath   string `json:"deptPath"`
	DeptType   string `json:"deptType"`
	DeptStatus int64  `json:"deptStatus"`

	// 产品上下文 (sys_product)
	ProductCode   string `json:"productCode"`
	ProductName   string `json:"productName"`
	ProductStatus int64  `json:"productStatus"`

	// 成员信息 (sys_product_member)
	MemberType string `json:"memberType"`

	// 角色列表 (sys_role，当前产品下已启用的角色)
	Roles []RoleInfo `json:"roles"`

	// 权限列表 (计算后的权限 code 集合)
	Perms []string `json:"perms"`

	// 当前产品下最小 permsLevel（无角色时为 math.MaxInt64）
	MinPermsLevel int64 `json:"minPermsLevel"`
}

// RoleInfo 角色摘要信息。
type RoleInfo struct {
	Id         int64  `json:"id"`
	Name       string `json:"name"`
	Remark     string `json:"remark"`
	PermsLevel int64  `json:"permsLevel"`
}

// -------- UserDetailsLoader --------

// UserDetailsLoader 负责加载、缓存、失效用户详细信息。
// 优先从 Redis 读取完整 UserDetails，miss 时查 DB 并回填。
type UserDetailsLoader struct {
	rds       *redis.Redis
	keyPrefix string
	ttl       int
	models    *model.Models
	sf        singleflight.Group
}

func NewUserDetailsLoader(rds *redis.Redis, keyPrefix string, models *model.Models) *UserDetailsLoader {
	return &UserDetailsLoader{
		rds:       rds,
		keyPrefix: keyPrefix,
		ttl:       defaultCacheTTL,
		models:    models,
	}
}

func (l *UserDetailsLoader) cacheKey(userId int64, productCode string) string {
	return fmt.Sprintf("%s:ud:%d:%s", l.keyPrefix, userId, productCode)
}

func (l *UserDetailsLoader) userIndexKey(userId int64) string {
	return fmt.Sprintf("%s:ud:idx:u:%d", l.keyPrefix, userId)
}

func (l *UserDetailsLoader) productIndexKey(productCode string) string {
	return fmt.Sprintf("%s:ud:idx:p:%s", l.keyPrefix, productCode)
}

// Load 根据 userId 和 productCode 加载完整的 UserDetails。
func (l *UserDetailsLoader) Load(ctx context.Context, userId int64, productCode string) *UserDetails {
	key := l.cacheKey(userId, productCode)

	if val, err := l.rds.GetCtx(ctx, key); err == nil && val != "" {
		// 命中负缓存：该 userId/productCode 最近查询确认为不存在；直接返回空 UserDetails，
		// 避免离职/伪造账号的残余 token 持续压垮 DB（见审计 M-3）。
		if val == negativeCacheMarker {
			return &UserDetails{UserId: userId, ProductCode: productCode}
		}
		var ud UserDetails
		if err := json.Unmarshal([]byte(val), &ud); err == nil {
			return &ud
		}
	}

	v, sfErr, _ := l.sf.Do(key, func() (interface{}, error) {
		ud, err := l.loadFromDB(ctx, userId, productCode)
		if err != nil {
			return nil, err
		}
		if ud.Username == "" {
			// 写短 TTL 的负缓存哨兵；不走 registerCacheKey：负缓存短窗口自然过期即可，
			// 也避免 Clean/CleanByProduct 路径误当成真实 UserDetails key 进去全量扫。
			if err := l.rds.SetexCtx(ctx, key, negativeCacheMarker, negativeCacheTTL); err != nil {
				logx.WithContext(ctx).Errorf("set user details negative cache failed: %v", err)
			}
			return nil, nil
		}
		if val, err := json.Marshal(ud); err == nil {
			if err := l.rds.SetexCtx(ctx, key, string(val), l.ttl); err != nil {
				logx.WithContext(ctx).Errorf("set user details cache failed: %v", err)
			}
			l.registerCacheKey(ctx, key, userId, productCode)
		}
		return ud, nil
	})

	if sfErr != nil {
		logx.WithContext(ctx).Errorf("load user details from DB failed: %v", sfErr)
	}

	ud, ok := v.(*UserDetails)
	if !ok || ud == nil {
		return &UserDetails{UserId: userId, ProductCode: productCode}
	}
	return ud
}

// Del 删除指定用户在指定产品下的缓存。
func (l *UserDetailsLoader) Del(ctx context.Context, userId int64, productCode string) {
	key := l.cacheKey(userId, productCode)
	if _, err := l.rds.DelCtx(ctx, key); err != nil {
		logx.WithContext(ctx).Errorf("del user details cache [%s] failed: %v", key, err)
	}
	l.unregisterCacheKey(ctx, key, userId, productCode)
}

// Clean 清除指定用户所有产品下的缓存。
func (l *UserDetailsLoader) Clean(ctx context.Context, userId int64) {
	idxKey := l.userIndexKey(userId)
	l.cleanByIndex(ctx, idxKey)
}

// CleanByProduct 清除指定产品下所有用户的缓存。
func (l *UserDetailsLoader) CleanByProduct(ctx context.Context, productCode string) {
	idxKey := l.productIndexKey(productCode)
	l.cleanByIndex(ctx, idxKey)
}

// BatchDel 批量删除多个用户在指定产品下的缓存。
func (l *UserDetailsLoader) BatchDel(ctx context.Context, userIds []int64, productCode string) {
	if len(userIds) == 0 {
		return
	}
	keys := make([]string, 0, len(userIds))
	for _, uid := range userIds {
		keys = append(keys, l.cacheKey(uid, productCode))
	}
	if _, err := l.rds.DelCtx(ctx, keys...); err != nil {
		logx.WithContext(ctx).Errorf("batch del user details cache failed: %v", err)
	}
	for i, uid := range userIds {
		l.unregisterCacheKey(ctx, keys[i], uid, productCode)
	}
}

func (l *UserDetailsLoader) cleanByIndex(ctx context.Context, indexKey string) {
	keys, err := l.rds.SmembersCtx(ctx, indexKey)
	if err != nil {
		logx.WithContext(ctx).Errorf("smembers [%s] failed: %v", indexKey, err)
		return
	}
	if len(keys) > 0 {
		if _, err := l.rds.DelCtx(ctx, keys...); err != nil {
			logx.WithContext(ctx).Errorf("del cached keys failed: %v", err)
		}
	}
	if _, err := l.rds.DelCtx(ctx, indexKey); err != nil {
		logx.WithContext(ctx).Errorf("del index key [%s] failed: %v", indexKey, err)
	}
}

func (l *UserDetailsLoader) registerCacheKey(ctx context.Context, cacheKey string, userId int64, productCode string) {
	uIdxKey := l.userIndexKey(userId)
	if _, err := l.rds.SaddCtx(ctx, uIdxKey, cacheKey); err != nil {
		logx.WithContext(ctx).Errorf("sadd user index failed: %v", err)
	}
	if err := l.rds.ExpireCtx(ctx, uIdxKey, l.ttl+60); err != nil {
		logx.WithContext(ctx).Errorf("expire user index failed: %v", err)
	}

	if productCode != "" {
		pIdxKey := l.productIndexKey(productCode)
		if _, err := l.rds.SaddCtx(ctx, pIdxKey, cacheKey); err != nil {
			logx.WithContext(ctx).Errorf("sadd product index failed: %v", err)
		}
		if err := l.rds.ExpireCtx(ctx, pIdxKey, l.ttl+60); err != nil {
			logx.WithContext(ctx).Errorf("expire product index failed: %v", err)
		}
	}
}

func (l *UserDetailsLoader) unregisterCacheKey(ctx context.Context, cacheKey string, userId int64, productCode string) {
	if _, err := l.rds.SremCtx(ctx, l.userIndexKey(userId), cacheKey); err != nil {
		logx.WithContext(ctx).Errorf("srem user index failed: %v", err)
	}
	if productCode != "" {
		if _, err := l.rds.SremCtx(ctx, l.productIndexKey(productCode), cacheKey); err != nil {
			logx.WithContext(ctx).Errorf("srem product index failed: %v", err)
		}
	}
}

// -------- 内部加载逻辑 --------

func (l *UserDetailsLoader) loadFromDB(ctx context.Context, userId int64, productCode string) (*UserDetails, error) {
	ud := &UserDetails{
		UserId:        userId,
		ProductCode:   productCode,
		MinPermsLevel: math.MaxInt64,
	}

	if err := l.loadUser(ctx, ud); err != nil {
		return ud, err
	}
	if ud.Username == "" {
		return ud, nil
	}
	l.loadDept(ctx, ud)
	l.loadProduct(ctx, ud)
	l.loadMembership(ctx, ud)
	l.loadRoles(ctx, ud)
	l.loadPerms(ctx, ud)

	return ud, nil
}

func (l *UserDetailsLoader) loadUser(ctx context.Context, ud *UserDetails) error {
	u, err := l.models.SysUserModel.FindOne(ctx, ud.UserId)
	if err != nil {
		if errors.Is(err, sqlx.ErrNotFound) {
			return nil
		}
		logx.WithContext(ctx).Errorf("userDetailsLoader: query user %d failed: %v", ud.UserId, err)
		return err
	}
	ud.Username = u.Username
	ud.Nickname = u.Nickname
	ud.Avatar = u.Avatar.String
	ud.Email = u.Email
	ud.Phone = u.Phone
	ud.Remark = u.Remark
	ud.DeptId = u.DeptId
	ud.IsSuperAdminRaw = u.IsSuperAdmin
	ud.IsSuperAdmin = u.IsSuperAdmin == consts.IsSuperAdminYes
	ud.MustChangePwdRaw = u.MustChangePassword
	ud.MustChangePassword = u.MustChangePassword == consts.MustChangePasswordYes
	ud.Status = u.Status
	ud.TokenVersion = u.TokenVersion
	return nil
}

func (l *UserDetailsLoader) loadDept(ctx context.Context, ud *UserDetails) {
	if ud.DeptId == 0 {
		return
	}
	d, err := l.models.SysDeptModel.FindOne(ctx, ud.DeptId)
	if err != nil {
		logx.WithContext(ctx).Errorf("userDetailsLoader: query dept %d failed: %v", ud.DeptId, err)
		return
	}
	ud.DeptName = d.Name
	ud.DeptPath = d.Path
	ud.DeptType = d.DeptType
	ud.DeptStatus = d.Status
}

func (l *UserDetailsLoader) loadProduct(ctx context.Context, ud *UserDetails) {
	if ud.ProductCode == "" {
		return
	}
	p, err := l.models.SysProductModel.FindOneByCode(ctx, ud.ProductCode)
	if err != nil {
		logx.WithContext(ctx).Errorf("userDetailsLoader: query product %s failed: %v", ud.ProductCode, err)
		return
	}
	ud.ProductName = p.Name
	ud.ProductStatus = p.Status
}

func (l *UserDetailsLoader) loadMembership(ctx context.Context, ud *UserDetails) {
	if ud.IsSuperAdmin {
		ud.MemberType = consts.MemberTypeSuperAdmin
	}
	if ud.ProductCode == "" {
		return
	}
	if ud.IsSuperAdmin {
		return
	}
	member, err := l.models.SysProductMemberModel.FindOneByProductCodeUserId(ctx, ud.ProductCode, ud.UserId)
	if err != nil {
		if err != productmember.ErrNotFound {
			logx.WithContext(ctx).Errorf("userDetailsLoader: query member failed: %v", err)
		}
		return
	}
	if member.Status != consts.StatusEnabled {
		return
	}
	ud.MemberType = member.MemberType
}

func (l *UserDetailsLoader) loadRoles(ctx context.Context, ud *UserDetails) {
	if ud.ProductCode == "" {
		return
	}
	roleIds, err := l.models.SysUserRoleModel.FindRoleIdsByUserIdForProduct(ctx, ud.UserId, ud.ProductCode)
	if err != nil || len(roleIds) == 0 {
		return
	}
	roles, err := l.models.SysRoleModel.FindByIds(ctx, roleIds)
	if err != nil {
		logx.WithContext(ctx).Errorf("userDetailsLoader: query roles failed: %v", err)
		return
	}
	ud.Roles = make([]RoleInfo, 0)
	minLevel := int64(math.MaxInt64)
	for _, r := range roles {
		if r.Status == consts.StatusEnabled {
			ud.Roles = append(ud.Roles, RoleInfo{
				Id:         r.Id,
				Name:       r.Name,
				Remark:     r.Remark,
				PermsLevel: r.PermsLevel,
			})
			if r.PermsLevel < minLevel {
				minLevel = r.PermsLevel
			}
		}
	}
	if minLevel < math.MaxInt64 {
		ud.MinPermsLevel = minLevel
	}
}

func (l *UserDetailsLoader) loadPerms(ctx context.Context, ud *UserDetails) {
	if ud.ProductCode == "" {
		return
	}

	if ud.ProductStatus != consts.StatusEnabled {
		ud.Perms = nil
		return
	}

	if !ud.IsSuperAdmin && ud.MemberType == "" {
		ud.Perms = nil
		return
	}

	// 超管 / ADMIN / DEVELOPER / 研发部门的有效成员 → 全量权限
	if ud.IsSuperAdmin ||
		ud.MemberType == consts.MemberTypeAdmin ||
		ud.MemberType == consts.MemberTypeDeveloper ||
		(ud.MemberType != "" && ud.DeptType == consts.DeptTypeDev && ud.DeptStatus == consts.StatusEnabled) {
		codes, err := l.models.SysPermModel.FindAllCodesByProductCode(ctx, ud.ProductCode)
		if err != nil {
			logx.WithContext(ctx).Errorf("userDetailsLoader: query all perms failed: %v", err)
		}
		ud.Perms = codes
		return
	}

	// 普通成员：角色权限 + 用户附加权限 - 用户拒绝权限
	rolePermIds := make([]int64, 0)
	if len(ud.Roles) > 0 {
		roleIds := make([]int64, 0, len(ud.Roles))
		for _, r := range ud.Roles {
			roleIds = append(roleIds, r.Id)
		}
		ids, err := l.models.SysRolePermModel.FindPermIdsByRoleIds(ctx, roleIds)
		if err == nil {
			rolePermIds = ids
		}
	}

	allowIds, err := l.models.SysUserPermModel.FindPermIdsByUserIdAndEffectForProduct(ctx, ud.UserId, consts.PermEffectAllow, ud.ProductCode)
	if err != nil {
		logx.WithContext(ctx).Errorf("userDetailsLoader: load allow perms failed: %v", err)
		return
	}
	denyIds, err := l.models.SysUserPermModel.FindPermIdsByUserIdAndEffectForProduct(ctx, ud.UserId, consts.PermEffectDeny, ud.ProductCode)
	if err != nil {
		logx.WithContext(ctx).Errorf("userDetailsLoader: load deny perms failed: %v", err)
	}

	denySet := make(map[int64]bool, len(denyIds))
	for _, id := range denyIds {
		denySet[id] = true
	}

	permIdSet := make(map[int64]bool)
	for _, id := range rolePermIds {
		if !denySet[id] {
			permIdSet[id] = true
		}
	}
	for _, id := range allowIds {
		if !denySet[id] {
			permIdSet[id] = true
		}
	}

	finalIds := make([]int64, 0, len(permIdSet))
	for id := range permIdSet {
		finalIds = append(finalIds, id)
	}

	if len(finalIds) > 0 {
		perms, err := l.models.SysPermModel.FindByIds(ctx, finalIds)
		if err == nil {
			codes := make([]string, 0, len(perms))
			for _, p := range perms {
				if p.Status == consts.StatusEnabled {
					codes = append(codes, p.Code)
				}
			}
			ud.Perms = codes
		}
	}
}