家庭组逻辑导致支付失败

internal/logic/public/user/deleteAccountLogic.go

@@ -2,9 +2,8 @@ package user
 
 import (
 	"context"
-	"crypto/rand"
-	"encoding/hex"
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/perfect-panel/server/internal/config"
@@ -13,7 +12,6 @@ import (
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/constant"
 	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/uuidx"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
@@ -34,379 +32,255 @@ func NewDeleteAccountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Del
 	}
 }
 
-// DeleteAccount 注销当前设备账号逻辑 (改为精准解绑)
+// DeleteAccount 保留兼容入口，统一走全量注销登录逻辑
 func (l *DeleteAccountLogic) DeleteAccount() (resp *types.DeleteAccountResponse, err error) {
-	// 获取当前用户
-	currentUser, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
-	if !ok {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
-	}
-
-	// 获取当前调用设备 ID
-	currentDeviceId, _ := l.ctx.Value(constant.CtxKeyDeviceID).(int64)
-
-	resp = &types.DeleteAccountResponse{}
-	var newUserId int64
-
-	// 如果没有识别到设备 ID (可能是旧版 Token)，则执行安全注销：仅清除 Session
-	if currentDeviceId == 0 {
-		l.Infow("未识别到设备 ID，仅清理当前会话", logger.Field("user_id", currentUser.Id))
-		l.clearCurrentSession(currentUser.Id)
-		resp.Success = true
-		resp.Message = "会话已清除"
-		return resp, nil
-	}
-
-	// 开始数据库事务
-	err = l.svcCtx.UserModel.Transaction(l.ctx, func(tx *gorm.DB) error {
-		// 1. 查找当前设备
-		var currentDevice user.Device
-		if err := tx.Where("id = ? AND user_id = ?", currentDeviceId, currentUser.Id).First(&currentDevice).Error; err != nil {
-			l.Infow("当前请求设备记录不存在或归属不匹配", logger.Field("device_id", currentDeviceId), logger.Field("error", err.Error()))
-			return nil // 不抛错，直接走清理 Session 流程
-		}
-
-		// 2. 检查用户是否有其他认证方式 (如邮箱) 或 其他设备
-		var authMethodsCount int64
-		tx.Model(&user.AuthMethods{}).Where("user_id = ?", currentUser.Id).Count(&authMethodsCount)
-
-		var devicesCount int64
-		tx.Model(&user.Device{}).Where("user_id = ?", currentUser.Id).Count(&devicesCount)
-
-		// 判定是否是主账号解绑：如果除了当前设备外，还有邮箱或其他设备，则只解绑当前设备
-		isMainAccount := authMethodsCount > 1 || devicesCount > 1
-
-		if isMainAccount {
-			l.Infow("主账号解绑，仅迁移当前设备", logger.Field("user_id", currentUser.Id), logger.Field("device_id", currentDeviceId))
-
-			// 【重要】先删除旧的认证记录，再创建新用户，避免唯一键冲突
-			// 从原用户删除当前设备的认证方式 (按 Identifier 准确删除)
-			if err := tx.Where("user_id = ? AND auth_type = ? AND auth_identifier = ?", currentUser.Id, "device", currentDevice.Identifier).Delete(&user.AuthMethods{}).Error; err != nil {
-				return errors.Wrap(err, "删除原设备认证失败")
-			}
-
-			// 从原用户删除当前设备记录
-			if err := tx.Where("id = ?", currentDeviceId).Delete(&user.Device{}).Error; err != nil {
-				return errors.Wrap(err, "删除原设备记录失败")
-			}
-
-			// 为当前设备创建新用户并迁移
-			newUser, err := l.registerUserAndDevice(tx, currentDevice.Identifier, currentDevice.Ip, currentDevice.UserAgent)
-			if err != nil {
-				return err
-			}
-			newUserId = newUser.Id
-
-		} else {
-			l.Infow("纯设备账号注销，执行物理删除并重置", logger.Field("user_id", currentUser.Id), logger.Field("device_id", currentDeviceId))
-
-			exitHelper := newFamilyExitHelper(l.ctx, l.svcCtx)
-			if err := exitHelper.removeUserFromActiveFamily(tx, currentUser.Id, true); err != nil {
-				return err
-			}
-
-			// 完全删除原用户相关资产
-			tx.Where("user_id = ?", currentUser.Id).Delete(&user.AuthMethods{})
-			tx.Where("user_id = ?", currentUser.Id).Delete(&user.Device{})
-			tx.Where("user_id = ?", currentUser.Id).Delete(&user.Subscribe{})
-			tx.Delete(&user.User{}, currentUser.Id)
-
-			// 重新注册一个新用户
-			newUser, err := l.registerUserAndDevice(tx, currentDevice.Identifier, currentDevice.Ip, currentDevice.UserAgent)
-			if err != nil {
-				return err
-			}
-			newUserId = newUser.Id
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		return nil, err
-	}
-
-	// 最终清理当前 Session
-	l.clearCurrentSession(currentUser.Id)
-
-	resp.Success = true
-	resp.Message = "注销成功"
-	resp.UserId = newUserId
-	resp.Code = 200
-
-	return resp, nil
+	return l.DeleteAccountAll()
 }
 
-// DeleteAccountAll 注销账号逻辑 (全部解绑默认创建账号)
+// DeleteAccountAll 注销登录 + 退出家庭/解散家庭，不删除账号主体
 func (l *DeleteAccountLogic) DeleteAccountAll() (resp *types.DeleteAccountResponse, err error) {
-	// 获取当前用户
 	currentUser, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
-	if !ok {
+	if !ok || currentUser == nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
 
-	// 获取当前调用设备 ID
-	currentDeviceId, _ := l.ctx.Value(constant.CtxKeyDeviceID).(int64)
-	currentIdentifier, _ := l.ctx.Value(constant.CtxKeyIdentifier).(string)
-	currentIdentifier = strings.TrimSpace(currentIdentifier)
-
-	if currentDeviceId == 0 && currentIdentifier != "" {
-		deviceInfo, deviceErr := l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, currentIdentifier)
-		switch {
-		case deviceErr == nil:
-			if deviceInfo.UserId == currentUser.Id {
-				currentDeviceId = deviceInfo.Id
-			} else {
-				l.Infow("当前标识符设备归属与用户不匹配",
-					logger.Field("user_id", currentUser.Id),
-					logger.Field("device_id", deviceInfo.Id),
-					logger.Field("identifier", currentIdentifier),
-				)
-			}
-		case errors.Is(deviceErr, gorm.ErrRecordNotFound):
-			l.Infow("未通过标识符找到当前设备", logger.Field("user_id", currentUser.Id), logger.Field("identifier", currentIdentifier))
-		default:
-			l.Errorw("通过标识符查找当前设备失败",
-				logger.Field("user_id", currentUser.Id),
-				logger.Field("identifier", currentIdentifier),
-				logger.Field("error", deviceErr.Error()),
-			)
-		}
-	}
-
-	resp = &types.DeleteAccountResponse{}
-	var newUserId int64
-	var firstMigratedUserId int64
-
-	// 开始数据库事务
+	affectedUserIDs := []int64{currentUser.Id}
 	err = l.svcCtx.UserModel.Transaction(l.ctx, func(tx *gorm.DB) error {
-		// 1. 预先查找该用户下的所有设备记录 (因为稍后要迁移)
-		var userDevices []user.Device
-		if err := tx.Where("user_id = ?", currentUser.Id).Find(&userDevices).Error; err != nil {
-			l.Errorw("查询用户设备列表失败", logger.Field("user_id", currentUser.Id), logger.Field("error", err.Error()))
-			return err
-		}
-
-		// 如果没有识别到调用设备 ID，记录日志但继续执行 (全量注销不应受限)
-		if currentDeviceId == 0 {
-			l.Infow("未识别到当前设备 ID，将执行全量注销并尝试迁移所有已知设备", logger.Field("user_id", currentUser.Id), logger.Field("found_devices", len(userDevices)))
+		familyUserIDs, collectErr := l.collectAffectedFamilyUserIDs(tx, currentUser.Id)
+		if collectErr != nil {
+			return collectErr
 		}
+		affectedUserIDs = familyUserIDs
 
 		exitHelper := newFamilyExitHelper(l.ctx, l.svcCtx)
-		if err := exitHelper.removeUserFromActiveFamily(tx, currentUser.Id, true); err != nil {
-			return err
+		if removeErr := exitHelper.removeUserFromActiveFamily(tx, currentUser.Id, true); removeErr != nil {
+			return removeErr
 		}
-
-		l.Infow("执行账号全量注销-迁移设备并删除旧数据", logger.Field("user_id", currentUser.Id), logger.Field("device_count", len(userDevices)))
-
-		// 2. 循环为每个设备创建新用户并迁移记录 (保留设备ID)
-		for _, dev := range userDevices {
-			// A. 创建新匿名用户
-			newUser, err := l.createAnonymousUser(tx)
-			if err != nil {
-				l.Errorw("为设备分配新用户主体失败", logger.Field("device_id", dev.Id), logger.Field("error", err.Error()))
-				return err
-			}
-			if firstMigratedUserId == 0 {
-				firstMigratedUserId = newUser.Id
-			}
-
-			// B. 迁移设备记录 (Update user_id)
-			if err := tx.Model(&user.Device{}).Where("id = ?", dev.Id).Update("user_id", newUser.Id).Error; err != nil {
-				l.Errorw("迁移设备记录失败", logger.Field("device_id", dev.Id), logger.Field("error", err.Error()))
-				return errors.Wrap(err, "迁移设备记录失败")
-			}
-
-			// C. 迁移设备认证方式 (Update user_id)
-			if err := tx.Model(&user.AuthMethods{}).
-				Where("user_id = ? AND auth_type = ? AND auth_identifier = ?", currentUser.Id, "device", dev.Identifier).
-				Update("user_id", newUser.Id).Error; err != nil {
-				l.Errorw("迁移设备认证失败", logger.Field("device_id", dev.Id), logger.Field("error", err.Error()))
-				return errors.Wrap(err, "迁移设备认证失败")
-			}
-
-			// 如果是当前请求的设备，记录其新 UserID 返回给前端
-			isCurrentRequestDevice := currentDeviceId > 0 && dev.Id == currentDeviceId
-			if !isCurrentRequestDevice && currentIdentifier != "" {
-				isCurrentRequestDevice = dev.Identifier == currentIdentifier
-			}
-			if isCurrentRequestDevice {
-				newUserId = newUser.Id
-			}
-			l.Infow("旧设备已迁移至新匿名账号",
-				logger.Field("old_user_id", currentUser.Id),
-				logger.Field("new_user_id", newUser.Id),
-				logger.Field("device_id", dev.Id),
-				logger.Field("identifier", dev.Identifier))
-		}
-
-		// 3. 删除旧账号的剩余数据
-		// 删除剩余的认证方式 (排除已迁移的device类型，剩下的如email/mobile等)
-		// 注意：刚才已经把由currentUser拥有的device类型auth都迁移走了，所以这里直接删剩下的即可
-		if err := tx.Where("user_id = ?", currentUser.Id).Delete(&user.AuthMethods{}).Error; err != nil {
-			return errors.Wrap(err, "删除剩余认证方式失败")
-		}
-
-		// 设备记录已经全部迁移，理论上 user_id = currentUser.Id 的 device 应该没了，但为了保险可以删一下(或者是0)
-		if err := tx.Where("user_id = ?", currentUser.Id).Delete(&user.Device{}).Error; err != nil {
-			return errors.Wrap(err, "删除残留设备记录失败")
-		}
-
-		// 删除所有订阅
-		if err := tx.Where("user_id = ?", currentUser.Id).Delete(&user.Subscribe{}).Error; err != nil {
-			return errors.Wrap(err, "删除订阅失败")
-		}
-
-		// 删除用户主体
-		if err := tx.Delete(&user.User{}, currentUser.Id).Error; err != nil {
-			return errors.Wrap(err, "删除用户失败")
-		}
-
 		return nil
 	})
-
 	if err != nil {
 		return nil, err
 	}
 
-	// 最终清理所有 Session (踢掉所有设备)
 	l.clearAllSessions(currentUser.Id)
-	if newUserId == 0 {
-		newUserId = firstMigratedUserId
+	if cacheErr := l.clearUserAndSubscribeCaches(affectedUserIDs); cacheErr != nil {
+		l.Errorw("clear user related cache failed",
+			logger.Field("user_id", currentUser.Id),
+			logger.Field("affected_user_ids", affectedUserIDs),
+			logger.Field("error", cacheErr.Error()),
+		)
 	}
 
-	resp.Success = true
-	resp.Message = "注销成功"
-	resp.UserId = newUserId
-	resp.Code = 200
-
-	return resp, nil
+	return &types.DeleteAccountResponse{
+		Success: true,
+		Message: "注销成功",
+		UserId:  currentUser.Id,
+		Code:    200,
+	}, nil
 }
 
-// 辅助方法：通过 ID 查找 Identifier (以防 currentDeviceId 只是 ID)
-func (l *DeleteAccountLogic) getIdentifierByDeviceID(devices []user.Device, id int64) string {
-	for _, d := range devices {
-		if d.Id == id {
-			return d.Identifier
+func (l *DeleteAccountLogic) collectAffectedFamilyUserIDs(tx *gorm.DB, userID int64) ([]int64, error) {
+	affected := []int64{userID}
+
+	var relation struct {
+		FamilyId int64 `gorm:"column:family_id"`
+	}
+	err := tx.Model(&user.UserFamilyMember{}).
+		Select("user_family_member.family_id").
+		Joins("JOIN user_family ON user_family.id = user_family_member.family_id AND user_family.deleted_at IS NULL AND user_family.status = ?", user.FamilyStatusActive).
+		Where("user_family_member.user_id = ? AND user_family_member.status = ? AND user_family_member.deleted_at IS NULL", userID, user.FamilyMemberActive).
+		First(&relation).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return affected, nil
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query family relation failed")
+	}
+
+	var memberIDs []int64
+	if err = tx.Model(&user.UserFamilyMember{}).
+		Where("family_id = ? AND status = ? AND deleted_at IS NULL", relation.FamilyId, user.FamilyMemberActive).
+		Pluck("user_id", &memberIDs).Error; err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query family members failed")
+	}
+
+	affected = append(affected, memberIDs...)
+	idSet := make(map[int64]struct{}, len(affected))
+	unique := make([]int64, 0, len(affected))
+	for _, id := range affected {
+		if id <= 0 {
+			continue
+		}
+		if _, exists := idSet[id]; exists {
+			continue
+		}
+		idSet[id] = struct{}{}
+		unique = append(unique, id)
+	}
+
+	if len(unique) == 0 {
+		return []int64{userID}, nil
+	}
+	return unique, nil
+}
+
+func (l *DeleteAccountLogic) clearUserAndSubscribeCaches(userIDs []int64) error {
+	if len(userIDs) == 0 {
+		return nil
+	}
+
+	idSet := make(map[int64]struct{}, len(userIDs))
+	uniqueIDs := make([]int64, 0, len(userIDs))
+	for _, userID := range userIDs {
+		if userID <= 0 {
+			continue
+		}
+		if _, exists := idSet[userID]; exists {
+			continue
+		}
+		idSet[userID] = struct{}{}
+		uniqueIDs = append(uniqueIDs, userID)
+	}
+	if len(uniqueIDs) == 0 {
+		return nil
+	}
+
+	userModels := make([]*user.User, 0, len(uniqueIDs))
+	subscribeModels := make([]*user.Subscribe, 0, len(uniqueIDs))
+	for _, userID := range uniqueIDs {
+		u, findErr := l.svcCtx.UserModel.FindOne(l.ctx, userID)
+		switch {
+		case findErr == nil:
+			userModels = append(userModels, u)
+		case errors.Is(findErr, gorm.ErrRecordNotFound):
+			// no-op
+		default:
+			l.Errorw("find user for cache clearing failed",
+				logger.Field("user_id", userID),
+				logger.Field("error", findErr.Error()),
+			)
+		}
+
+		subscribeModels = append(subscribeModels, &user.Subscribe{UserId: userID})
+		subscribes, queryErr := l.svcCtx.UserModel.QueryUserSubscribe(l.ctx, userID)
+		if queryErr != nil {
+			l.Errorw("query user subscribes for cache clearing failed",
+				logger.Field("user_id", userID),
+				logger.Field("error", queryErr.Error()),
+			)
+			continue
+		}
+		for _, subscribe := range subscribes {
+			subscribeModels = append(subscribeModels, &user.Subscribe{
+				Id:          subscribe.Id,
+				UserId:      subscribe.UserId,
+				SubscribeId: subscribe.SubscribeId,
+				Token:       subscribe.Token,
+			})
 		}
 	}
-	return ""
-}
 
-// clearCurrentSession 清理当前请求的会话
-func (l *DeleteAccountLogic) clearCurrentSession(userId int64) {
-	if sessionId, ok := l.ctx.Value(constant.CtxKeySessionID).(string); ok && sessionId != "" {
-		sessionKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
-		_ = l.svcCtx.Redis.Del(l.ctx, sessionKey).Err()
-		// 从用户会话集合中移除当前session
-		sessionsKey := fmt.Sprintf("%s%v", config.UserSessionsKeyPrefix, userId)
-		_ = l.svcCtx.Redis.ZRem(l.ctx, sessionsKey, sessionId).Err()
-
-		l.Infow("[SessionMonitor] 注销账号清除 Session",
-			logger.Field("user_id", userId),
-			logger.Field("session_id", sessionId))
+	if len(userModels) > 0 {
+		if err := l.svcCtx.UserModel.ClearUserCache(l.ctx, userModels...); err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "clear user cache failed")
+		}
 	}
+	if len(subscribeModels) > 0 {
+		if err := l.svcCtx.UserModel.ClearSubscribeCache(l.ctx, subscribeModels...); err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "clear subscribe cache failed")
+		}
+	}
+
+	return nil
 }
 
 // clearAllSessions 清理指定用户的所有会话
 func (l *DeleteAccountLogic) clearAllSessions(userId int64) {
 	sessionsKey := fmt.Sprintf("%s%v", config.UserSessionsKeyPrefix, userId)
+	sessionSet := make(map[string]struct{})
 
-	// 获取所有 session id
 	sessions, err := l.svcCtx.Redis.ZRange(l.ctx, sessionsKey, 0, -1).Result()
 	if err != nil {
-		l.Errorw("获取用户会话列表失败", logger.Field("user_id", userId), logger.Field("error", err.Error()))
-		return
+		l.Errorw("获取用户会话索引失败", logger.Field("user_id", userId), logger.Field("error", err.Error()))
+	} else {
+		for _, sessionID := range sessions {
+			if sessionID != "" {
+				sessionSet[sessionID] = struct{}{}
+			}
+		}
 	}
 
-	// 删除每个 session 的详情 key
-	for _, sid := range sessions {
-		sessionKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sid)
-		_ = l.svcCtx.Redis.Del(l.ctx, sessionKey).Err()
+	userIDText := strconv.FormatInt(userId, 10)
+	pattern := fmt.Sprintf("%s:*", config.SessionIdKey)
+	var cursor uint64
+	for {
+		keys, nextCursor, scanErr := l.svcCtx.Redis.Scan(l.ctx, cursor, pattern, 200).Result()
+		if scanErr != nil {
+			l.Errorw("扫描会话键失败", logger.Field("user_id", userId), logger.Field("error", scanErr.Error()))
+			break
+		}
 
-		// 同时尝试删除 detail key (如果存在)
-		detailKey := fmt.Sprintf("%s:detail:%s", config.SessionIdKey, sid)
-		_ = l.svcCtx.Redis.Del(l.ctx, detailKey).Err()
+		for _, sessionKey := range keys {
+			value, getErr := l.svcCtx.Redis.Get(l.ctx, sessionKey).Result()
+			if getErr != nil || value != userIDText {
+				continue
+			}
+			sessionID := strings.TrimPrefix(sessionKey, config.SessionIdKey+":")
+			if sessionID == "" || strings.HasPrefix(sessionID, "detail:") {
+				continue
+			}
+			sessionSet[sessionID] = struct{}{}
+		}
+
+		cursor = nextCursor
+		if cursor == 0 {
+			break
+		}
 	}
 
-	// 删除用户的 session 集合 key
-	_ = l.svcCtx.Redis.Del(l.ctx, sessionsKey).Err()
+	deviceKeySet := make(map[string]struct{})
+	devicePattern := fmt.Sprintf("%s:*", config.DeviceCacheKeyKey)
+	cursor = 0
+	for {
+		keys, nextCursor, scanErr := l.svcCtx.Redis.Scan(l.ctx, cursor, devicePattern, 200).Result()
+		if scanErr != nil {
+			l.Errorw("扫描设备会话映射失败", logger.Field("user_id", userId), logger.Field("error", scanErr.Error()))
+			break
+		}
+		for _, deviceKey := range keys {
+			sessionID, getErr := l.svcCtx.Redis.Get(l.ctx, deviceKey).Result()
+			if getErr != nil {
+				continue
+			}
+			if _, exists := sessionSet[sessionID]; exists {
+				deviceKeySet[deviceKey] = struct{}{}
+			}
+		}
+		cursor = nextCursor
+		if cursor == 0 {
+			break
+		}
+	}
 
-	l.Infow("[SessionMonitor] 注销账号-清除所有Session", logger.Field("user_id", userId), logger.Field("count", len(sessions)))
-}
-
-// generateReferCode 生成推荐码
-func generateReferCode() string {
-	bytes := make([]byte, 4)
-	rand.Read(bytes)
-	return hex.EncodeToString(bytes)
-}
-
-func (l *DeleteAccountLogic) registerUserAndDevice(tx *gorm.DB, identifier, ip, userAgent string) (*user.User, error) {
-	// 1. 创建新用户
-	userInfo := &user.User{
-		Salt:              "default",
-		OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
-	}
-	if err := tx.Create(userInfo).Error; err != nil {
-		l.Errorw("failed to create user", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user failed: %v", err)
-	}
-
-	// 2. 更新推荐码
-	userInfo.ReferCode = uuidx.UserInviteCode(userInfo.Id)
-	if err := tx.Model(&user.User{}).Where("id = ?", userInfo.Id).Update("refer_code", userInfo.ReferCode).Error; err != nil {
-		l.Errorw("failed to update refer code", logger.Field("user_id", userInfo.Id), logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
-	}
-
-	// 3. 创建设备认证方式
-	authMethod := &user.AuthMethods{
-		UserId:         userInfo.Id,
-		AuthType:       "device",
-		AuthIdentifier: identifier,
-		Verified:       true,
-	}
-	if err := tx.Create(authMethod).Error; err != nil {
-		l.Errorw("failed to create device auth method", logger.Field("user_id", userInfo.Id), logger.Field("identifier", identifier), logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create device auth method failed: %v", err)
-	}
-
-	// 4. 插入设备记录
-	deviceInfo := &user.Device{
-		Ip:         ip,
-		UserId:     userInfo.Id,
-		UserAgent:  userAgent,
-		Identifier: identifier,
-		Enabled:    true,
-		Online:     false,
-	}
-	if err := tx.Create(deviceInfo).Error; err != nil {
-		l.Errorw("failed to insert device", logger.Field("user_id", userInfo.Id), logger.Field("identifier", identifier), logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert device failed: %v", err)
-	}
-
-	return userInfo, nil
-}
-
-// createAnonymousUser 创建一个新的匿名用户主体 (仅User表)
-func (l *DeleteAccountLogic) createAnonymousUser(tx *gorm.DB) (*user.User, error) {
-	// 1. 创建新用户
-	userInfo := &user.User{
-		Salt:              "default",
-		OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
-	}
-	if err := tx.Create(userInfo).Error; err != nil {
-		l.Errorw("failed to create user", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user failed: %v", err)
-	}
-
-	// 2. 更新推荐码
-	userInfo.ReferCode = uuidx.UserInviteCode(userInfo.Id)
-	if err := tx.Model(&user.User{}).Where("id = ?", userInfo.Id).Update("refer_code", userInfo.ReferCode).Error; err != nil {
-		l.Errorw("failed to update refer code", logger.Field("user_id", userInfo.Id), logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
-	}
-
-	return userInfo, nil
+	pipe := l.svcCtx.Redis.TxPipeline()
+	for sessionID := range sessionSet {
+		sessionKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionID)
+		pipe.Del(l.ctx, sessionKey)
+		pipe.Del(l.ctx, fmt.Sprintf("%s:detail:%s", config.SessionIdKey, sessionID))
+		pipe.ZRem(l.ctx, sessionsKey, sessionID)
+	}
+	pipe.Del(l.ctx, sessionsKey)
+
+	for deviceKey := range deviceKeySet {
+		pipe.Del(l.ctx, deviceKey)
+	}
+
+	if _, err = pipe.Exec(l.ctx); err != nil {
+		l.Errorw("清理会话缓存失败", logger.Field("user_id", userId), logger.Field("error", err.Error()))
+	}
+
+	l.Infow("[SessionMonitor] 注销账号-清除所有Session",
+		logger.Field("user_id", userId),
+		logger.Field("count", len(sessionSet)),
+	)
 }