hi-server/internal/logic/public/user/unbindDeviceLogic.go

package user

import (
	"context"
	"fmt"
	"time"

	"github.com/perfect-panel/server/internal/config"
	"github.com/perfect-panel/server/internal/model/log"
	"github.com/perfect-panel/server/internal/model/user"
	"github.com/perfect-panel/server/internal/svc"
	"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"
)

type UnbindDeviceLogic struct {
	logger.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

// Unbind Device
func NewUnbindDeviceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UnbindDeviceLogic {
	return &UnbindDeviceLogic{
		Logger: logger.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *UnbindDeviceLogic) UnbindDevice(req *types.UnbindDeviceRequest) error {
	// 获取当前 token 登录的用户
	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
	if !ok {
		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
	}
	// 查询解绑设备是否存在
	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 != u.Id {
		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "device not belong to user")
	}
	l.Infow("开始解绑设备",
		logger.Field("device_identifier", device.Identifier),
		logger.Field("user_id", u.Id))
	start := time.Now()
	err = l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
		var dev user.Device
		if err := tx.Model(&dev).Where("id = ?", req.Id).First(&dev).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.QueueEnqueueError), "find device err: %v", err)
		}
		var userAuth user.AuthMethods
		if err := tx.Model(&userAuth).Where("auth_identifier = ? and auth_type = ?", dev.Identifier, "device").First(&userAuth).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user auth method err: %v", err)
		}
		newUser := &user.User{
			Salt:              "default",
			OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
		}
		if err := tx.Create(newUser).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user failed: %v", err)
		}
		newUser.ReferCode = uuidx.UserInviteCode(newUser.Id)
		if err := tx.Model(&user.User{}).Where("id = ?", newUser.Id).Update("refer_code", newUser.ReferCode).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
		}
		registerLog := log.Register{
			AuthMethod: "device",
			Identifier: dev.Identifier,
			RegisterIP: dev.Ip,
			UserAgent:  dev.UserAgent,
			Timestamp:  time.Now().UnixMilli(),
		}
		content, _ := registerLog.Marshal()
		_ = tx.Create(&log.SystemLog{
			Type:     log.TypeRegister.Uint8(),
			Date:     time.Now().Format("2006-01-02"),
			ObjectID: newUser.Id,
			Content:  string(content),
		}).Error
		if err := tx.Model(&user.Device{}).Where("id = ?", dev.Id).Update("user_id", newUser.Id).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update device owner failed: %v", err)
		}
		if err := tx.Model(&user.AuthMethods{}).Where("id = ?", userAuth.Id).Update("user_id", newUser.Id).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update auth owner failed: %v", err)
		}
		var count int64
		if err := tx.Model(user.AuthMethods{}).Where("user_id = ?", dev.UserId).Count(&count).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count user auth methods err: %v", err)
		}
		if count < 1 {
			if err := tx.Where("id = ?", dev.UserId).Delete(&user.User{}).Error; err != nil {
				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete old user failed: %v", err)
			}
		}
		l.Infow("设备解绑并迁移成功",
			logger.Field("device_identifier", dev.Identifier),
			logger.Field("old_user_id", dev.UserId),
			logger.Field("new_user_id", newUser.Id))
		return nil
	})
	if err != nil {
		return err
	}
	duration := time.Since(start)
	identifier := device.Identifier
	ctx, cancel := context.WithTimeout(l.ctx, 2*time.Second)
	defer cancel()
	deviceCacheKey := fmt.Sprintf("%v:%v", config.DeviceCacheKeyKey, identifier)
	if sessionId, rerr := l.svcCtx.Redis.Get(ctx, deviceCacheKey).Result(); rerr == nil && sessionId != "" {
		_ = l.svcCtx.Redis.Del(ctx, deviceCacheKey).Err()
		sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
		_ = l.svcCtx.Redis.Del(ctx, sessionIdCacheKey).Err()
		// remove session from user sessions
		sessionsKey := fmt.Sprintf("%s%v", config.UserSessionsKeyPrefix, u.Id)
		_ = l.svcCtx.Redis.ZRem(ctx, sessionsKey, sessionId).Err()
	}
	l.svcCtx.DeviceManager.KickDevice(u.Id, identifier)
	l.Infow("设备解绑完成",
		logger.Field("device_identifier", identifier),
		logger.Field("elapsed_ms", duration.Milliseconds()))
	return nil
}