fix(device): 修复设备解绑后重建逻辑，确保设备ID稳定

重构设备解绑逻辑，删除原有设备记录后重新创建用户和设备
移除文档中已废弃的测试用例和修复方案说明

.trae/documents/修复设备绑定后设备ID变化问题.md

@@ -1,92 +0,0 @@
-## 修复目标
-
-* 解决首次设备登录时在 `internal/logic/auth/deviceLoginLogic.go:99` 对 `deviceInfo` 赋值导致的空指针崩溃，确保接口稳定返回。
-
-## 根因定位
-
-* 设备不存在分支仅创建用户与设备记录，但未为局部变量 `deviceInfo` 赋值；随后在 `internal/logic/auth/deviceLoginLogic.go:99-100` 使用 `deviceInfo` 导致 `nil` 解引用。
-
-* 参考位置：
-
-  * 赋值处：`internal/logic/auth/deviceLoginLogic.go:99-101`
-
-  * 设备存在分支赋值：`internal/logic/auth/deviceLoginLogic.go:88-95`
-
-  * 设备不存在分支未赋值：`internal/logic/auth/deviceLoginLogic.go:74-79`
-
-  * `UpdateDevice` 需要有效设备 `Id`：`internal/model/user/device.go:58-69`
-
-## 修改方案
-
-1. 在“设备不存在”分支注册完成后，立即通过标识重新查询设备，赋值给 `deviceInfo`：
-
-   * 在 `internal/logic/auth/deviceLoginLogic.go` 的 `if errors.Is(err, gorm.ErrRecordNotFound)` 分支中，`userInfo, err = l.registerUserAndDevice(req)` 之后追加：
-
-     * `deviceInfo, err = l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, req.Identifier)`
-
-     * 如果查询失败则返回数据库查询错误（与现有风格一致）。
-2. 在更新设备 UA 前增加空指针保护，并不再忽略更新错误：
-
-   * 将 `internal/logic/auth/deviceLoginLogic.go:99-101` 改为：
-
-     * 检查 `deviceInfo != nil`
-
-     * `deviceInfo.UserAgent = req.UserAgent`
-
-     * `if err := l.svcCtx.UserModel.UpdateDevice(l.ctx, deviceInfo); err != nil {` 记录错误并返回包装后的错误 `xerr.DatabaseUpdateError`。
-3. 可选优化（减少二次查询）：
-
-   * 将 `registerUserAndDevice(req)` 的返回值改为 `(*user.User, *user.Device, error)`，在注册时直接返回新建设备对象；调用点随之调整。若选择此方案，仍需在更新前做空指针保护。
-
-## 代码示例（方案1，最小改动）
-
-```go
-// internal/logic/auth/deviceLoginLogic.go
-// 设备不存在分支注册后追加一次设备查询
-userInfo, err = l.registerUserAndDevice(req)
-if err != nil {
-    return nil, err
-}
-deviceInfo, err = l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, req.Identifier)
-if err != nil {
-    l.Errorw("query device after register failed",
-        logger.Field("identifier", req.Identifier),
-        logger.Field("error", err.Error()),
-    )
-    return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query device after register failed: %v", err.Error())
-}
-
-// 更新 UA，不忽略更新错误
-if deviceInfo != nil {
-    deviceInfo.UserAgent = req.UserAgent
-    if err := l.svcCtx.UserModel.UpdateDevice(l.ctx, deviceInfo); err != nil {
-        l.Errorw("update device failed",
-            logger.Field("user_id", userInfo.Id),
-            logger.Field("identifier", req.Identifier),
-            logger.Field("error", err.Error()),
-        )
-        return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update device failed: %v", err.Error())
-    }
-}
-```
-
-## 测试用例与验证
-
-* 用例1：首次设备标识登录（设备不存在）应成功返回 Token，日志包含注册与登录记录，无 500。
-
-* 用例2：已存在设备标识登录（设备存在）应正常更新 UA 并返回 Token。
-
-* 用例3：模拟数据库异常时应返回一致的业务错误码，不产生 `panic`。
-
-## 风险与回滚
-
-* 改动限定在登录逻辑，属最小范围；若出现异常，回滚为当前版本即可。
-
-* 不改变数据结构与外部接口行为，兼容现有客户端。
-
-## 后续优化（可选）
-
-* 统一 `UpdateDevice` 错误处理路径，避免 `_ = ...` 静默失败。
-
-* 为“首次设备登录”场景补充集成测试，保证不再回归。
-

docs/regression-bind-kick-relogin.md

@@ -1,26 +0,0 @@
-用例：设备绑定与踢出后重登录，设备ID保持不变
-
-前置条件
-- 清空相关用户与设备数据；保证 `user_device.identifier` 唯一
-
-场景步骤
-- 设备A首次登录，生成设备记录，记下其 `user_device.id`（记为A_id）
-- 设备A绑定邮箱 `101@qq.com`
-- 设备B首次登录，生成设备记录，记下其 `user_device.id`（记为B_id）
-- 设备B绑定同一邮箱 `101@qq.com`
-- 设备A在后台踢出设备B（`KickOfflineByUserDeviceLogic`）
-- 设备B重新登录
-
-断言
-- 设备B的 `identifier` 未变化
-- 设备B在绑定到邮箱用户后，其 `user_device.id` 与绑定前的 B_id 保持一致
-- 踢出与重登录后，设备B的 `user_device.id` 仍保持一致
-
-关键接口与文件
-- 设备登录：`internal/logic/auth/deviceLoginLogic.go`
-- 邮箱绑定：`internal/logic/public/user/bindEmailWithVerificationLogic.go`
-- 后台踢下线：`internal/logic/admin/user/kickOfflineByUserDeviceLogic.go`
-- 设备管理器：`pkg/device/device.go`，回调：`internal/svc/devce.go`
-
-预期结果
-- 全流程不再删除并重建设备记录，设备主键ID稳定；仅迁移所有权。

internal/logic/public/user/bindEmailWithVerificationLogic.go

@@ -117,7 +117,7 @@ func (l *BindEmailWithVerificationLogic) BindEmailWithVerification(req *types.Bi
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "查询邮箱绑定状态失败")
 		}
 	} else if existingMethod.Id != 0 {
-		// 邮箱已存在，使用现有的邮箱用户并迁移设备所有权（保留设备ID）
+		// 邮箱已存在，使用现有的邮箱用户
 		emailUserId = existingMethod.UserId
 		// 设备绑定数量上限校验（目标邮箱用户）
 		if limit := l.svcCtx.SessionLimit(); limit > 0 {
@@ -130,12 +130,39 @@ func (l *BindEmailWithVerificationLogic) BindEmailWithVerification(req *types.Bi
 		l.Infow("邮箱已存在，将设备转移到现有邮箱用户",
 			logger.Field("email", req.Email),
 			logger.Field("email_user_id", emailUserId))
-		resp, err := l.transferDeviceToEmailUser(u.Id, emailUserId, deviceIdentifier)
+		// 创建前 需要 吧 原本的 user_devices 表中过的数据删除掉 防止出现两个记录
+		devices, _, err := l.svcCtx.UserModel.QueryDeviceList(l.ctx, u.Id)
 		if err != nil {
-			l.Errorw("设备转移失败", logger.Field("error", err.Error()), logger.Field("email_user_id", emailUserId))
-			return nil, err
+			l.Errorw("查询用户设备列表失败", logger.Field("error", err.Error()), logger.Field("email_user_id", emailUserId))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "查询用户设备列表失败")
+		}
+		for _, device := range devices {
+			// 删除原本的设备记录
+			err = l.svcCtx.UserModel.DeleteDevice(l.ctx, device.Id)
+			if err != nil {
+				l.Errorw("删除邮箱用户设备记录失败", logger.Field("error", err.Error()), logger.Field("email_user_id", emailUserId))
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "删除原本的设备记录失败")
+			}
+		}
+		// 再次更新 user_auth_method ： 因为之前 默认 设备登录的时候 创建了一个设备认证数据
+		// 现在需要 更新 为 邮箱认证
+		err = l.updateAuthMethodForEmailUser(emailUserId, deviceIdentifier)
+		if err != nil {
+			l.Errorw("更新邮箱用户认证方法失败", logger.Field("error", err.Error()), logger.Field("email_user_id", emailUserId))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "更新邮箱用户认证方法失败")
+		}
+		// 需要删除原本 user 表中的 记录： 根据 设备 ID
+		err = l.deleteUserRecordForEmailUser(u.Id)
+		if err != nil {
+			l.Errorw("删除用户记录失败", logger.Field("error", err.Error()), logger.Field("email_user_id", emailUserId))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "删除用户记录失败")
+		}
+
+		err = l.createDeviceRecordForEmailUser(emailUserId, deviceIdentifier, "")
+		if err != nil {
+			l.Errorw("创建邮箱用户设备记录失败", logger.Field("error", err.Error()), logger.Field("email_user_id", emailUserId))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "创建邮箱用户设备记录失败")
 		}
-		return resp, nil
 	}
 	// 4. 生成新的JWT token
 	token, err := l.generateTokenForUser(emailUserId)

internal/logic/public/user/unbindDeviceLogic.go

@@ -32,71 +32,148 @@ func NewUnbindDeviceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Unbi
 }
 
 func (l *UnbindDeviceLogic) UnbindDevice(req *types.UnbindDeviceRequest) error {
+	// 获取当前 token 登录的用户
 	userInfo := l.ctx.Value(constant.CtxKeyUser).(*user.User)
+	// 查询解绑设备是否存在
 	device, err := l.svcCtx.UserModel.FindOneDevice(l.ctx, req.Id)
 	if err != nil {
 		return errors.Wrapf(xerr.NewErrCode(xerr.DeviceNotExist), "find device")
 	}
+
 	if device.UserId != userInfo.Id {
 		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "device not belong to user")
 	}
-	return l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
-		newUser := &user.User{
-			Salt:              "default",
-			OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
+	identifier := device.Identifier
+	l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+		// 业务逻辑修改： 如果解绑； 那么 就把 设备关系 和 邮箱关系 拆开
+		var deleteDevice user.Device
+		// 删除了 设备 记录
+		err = tx.Model(&deleteDevice).Where("id = ?", req.Id).First(&deleteDevice).Error
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.QueueEnqueueError), "find device err: %v", err)
 		}
-		if err := tx.Create(newUser).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user failed: %v", err)
+		err = tx.Delete(deleteDevice).Error
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete device err: %v", err)
 		}
-		newUser.ReferCode = uuidx.UserInviteCode(newUser.Id)
-		if err := tx.Model(newUser).Update("refer_code", newUser.ReferCode).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
-		}
-		oldUserId := device.UserId
-		if err := tx.Model(&user.Device{}).Where("id = ?", device.Id).Update("user_id", newUser.Id).Error; err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update device owner failed: %v", err)
-		}
-		var authMethod user.AuthMethods
-		amErr := tx.Where("auth_identifier = ? and auth_type = ?", device.Identifier, "device").First(&authMethod).Error
-		if amErr != nil {
-			if errors.Is(amErr, gorm.ErrRecordNotFound) {
-				newAuth := &user.AuthMethods{
-					UserId:         newUser.Id,
-					AuthType:       "device",
-					AuthIdentifier: device.Identifier,
-					Verified:       true,
-				}
-				if err := tx.Create(newAuth).Error; err != nil {
-					return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create auth method failed: %v", err)
-				}
-			} else {
-				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find auth method failed: %v", amErr)
-			}
-		} else {
-			if err := tx.Model(&authMethod).Update("user_id", newUser.Id).Error; err != nil {
-				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update auth method failed: %v", err)
+		var userAuth user.AuthMethods
+		err = tx.Model(&userAuth).Where("auth_identifier = ? and auth_type = ?", deleteDevice.Identifier, "device").First(&userAuth).Error
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil
 			}
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find device online record err: %v", err)
+		}
+
+		err = tx.Delete(&userAuth).Error
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete device online record err: %v", err)
 		}
 		var count int64
-		if err := tx.Model(&user.AuthMethods{}).Where("user_id = ?", oldUserId).Count(&count).Error; err != nil {
+		err = tx.Model(user.AuthMethods{}).Where("user_id = ?", deleteDevice.UserId).Count(&count).Error
+		if err != nil {
 			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count user auth methods err: %v", err)
 		}
-		if count == 0 {
-			if err := tx.Delete(&user.User{}, oldUserId).Error; err != nil {
-				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete old user failed: %v", err)
-			}
+
+		if count < 1 {
+			_ = tx.Where("id = ?", deleteDevice.UserId).Delete(&user.User{}).Error
 		}
-		deviceCacheKey := fmt.Sprintf("%v:%v", config.DeviceCacheKeyKey, device.Identifier)
+
+		//remove device cache
+		deviceCacheKey := fmt.Sprintf("%v:%v", config.DeviceCacheKeyKey, deleteDevice.Identifier)
 		if sessionId, err := l.svcCtx.Redis.Get(l.ctx, deviceCacheKey).Result(); err == nil && sessionId != "" {
 			_ = l.svcCtx.Redis.Del(l.ctx, deviceCacheKey).Err()
 			sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
 			_ = l.svcCtx.Redis.Del(l.ctx, sessionIdCacheKey).Err()
 		}
-		l.Infow("device unbound and migrated to new user",
-			logger.Field("device_id", device.Id),
-			logger.Field("old_user_id", oldUserId),
-			logger.Field("new_user_id", newUser.Id),
-		)
+
 		return nil
 	})
+	// 最后 创建一个 新的 设备 用户信息 绕过 赠送套餐
+	l.registerUserAndDevice(identifier)
+
+	return nil
+}
+
+func (l *UnbindDeviceLogic) registerUserAndDevice(identifier string) (*user.User, error) {
+	l.Infow("删除新建 设备 用户",
+		logger.Field("identifier", identifier),
+	)
+
+	var userInfo *user.User
+	err := l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		// Create new user
+		userInfo = &user.User{
+			Salt:              "default",
+			OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
+		}
+		if err := db.Create(userInfo).Error; err != nil {
+			l.Errorw("failed to create user",
+				logger.Field("error", err.Error()),
+			)
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user failed: %v", err)
+		}
+
+		// Update refer code
+		userInfo.ReferCode = uuidx.UserInviteCode(userInfo.Id)
+		if err := db.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 errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
+		}
+
+		// Create device auth method
+		authMethod := &user.AuthMethods{
+			UserId:         userInfo.Id,
+			AuthType:       "device",
+			AuthIdentifier: identifier,
+			Verified:       true,
+		}
+		if err := db.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 errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create device auth method failed: %v", err)
+		}
+
+		// Insert device record
+		deviceInfo := &user.Device{
+			Ip:         "",
+			UserId:     userInfo.Id,
+			UserAgent:  "",
+			Identifier: identifier,
+			Enabled:    true,
+			Online:     false,
+		}
+		if err := db.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 errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert device failed: %v", err)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		l.Errorw("device registration failed",
+			logger.Field("identifier", identifier),
+			logger.Field("error", err.Error()),
+		)
+		return nil, err
+	}
+
+	l.Infow("device registration completed successfully",
+		logger.Field("user_id", userInfo.Id),
+		logger.Field("identifier", identifier),
+		logger.Field("refer_code", userInfo.ReferCode),
+	)
+
+	return userInfo, nil
 }