refactor(user): 重构设备解绑逻辑，改为迁移设备到新用户而非删除

修改设备解绑逻辑，不再删除设备而是将其迁移到新创建的用户账户下
同时优化了事务处理和错误日志记录

internal/logic/public/user/unbindDeviceLogic.go

@@ -32,148 +32,71 @@ 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")
 	}
-	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)
+	return l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+		newUser := &user.User{
+			Salt:              "default",
+			OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
 		}
-		err = tx.Delete(deleteDevice).Error
-		if err != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete device err: %v", err)
+		if err := tx.Create(newUser).Error; err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user 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
+		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)
 			}
-			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
-		err = tx.Model(user.AuthMethods{}).Where("user_id = ?", deleteDevice.UserId).Count(&count).Error
-		if err != nil {
+		if err := tx.Model(&user.AuthMethods{}).Where("user_id = ?", oldUserId).Count(&count).Error; err != nil {
 			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count user auth methods err: %v", err)
 		}
-
-		if count < 1 {
-			_ = tx.Where("id = ?", deleteDevice.UserId).Delete(&user.User{}).Error
+		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)
+			}
 		}
-
-		//remove device cache
-		deviceCacheKey := fmt.Sprintf("%v:%v", config.DeviceCacheKeyKey, deleteDevice.Identifier)
+		deviceCacheKey := fmt.Sprintf("%v:%v", config.DeviceCacheKeyKey, device.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()
 		}
-
-		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()),
+		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, 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
+		return nil
+	})
 }