277 lines
7.6 KiB
Go
277 lines
7.6 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"github.com/user-management-system/internal/domain"
|
|
"github.com/user-management-system/internal/repository"
|
|
)
|
|
|
|
// DeviceService 设备服务
|
|
type DeviceService struct {
|
|
deviceRepo *repository.DeviceRepository
|
|
userRepo *repository.UserRepository
|
|
}
|
|
|
|
// NewDeviceService 创建设备服务
|
|
func NewDeviceService(
|
|
deviceRepo *repository.DeviceRepository,
|
|
userRepo *repository.UserRepository,
|
|
) *DeviceService {
|
|
return &DeviceService{
|
|
deviceRepo: deviceRepo,
|
|
userRepo: userRepo,
|
|
}
|
|
}
|
|
|
|
// CreateDeviceRequest 创建设备请求
|
|
type CreateDeviceRequest struct {
|
|
DeviceID string `json:"device_id" binding:"required"`
|
|
DeviceName string `json:"device_name"`
|
|
DeviceType int `json:"device_type"`
|
|
DeviceOS string `json:"device_os"`
|
|
DeviceBrowser string `json:"device_browser"`
|
|
IP string `json:"ip"`
|
|
Location string `json:"location"`
|
|
}
|
|
|
|
// UpdateDeviceRequest 更新设备请求
|
|
type UpdateDeviceRequest struct {
|
|
DeviceName string `json:"device_name"`
|
|
DeviceType int `json:"device_type"`
|
|
DeviceOS string `json:"device_os"`
|
|
DeviceBrowser string `json:"device_browser"`
|
|
IP string `json:"ip"`
|
|
Location string `json:"location"`
|
|
Status int `json:"status"`
|
|
}
|
|
|
|
// CreateDevice 创建设备
|
|
func (s *DeviceService) CreateDevice(ctx context.Context, userID int64, req *CreateDeviceRequest) (*domain.Device, error) {
|
|
// 检查用户是否存在
|
|
_, err := s.userRepo.GetByID(ctx, userID)
|
|
if err != nil {
|
|
return nil, errors.New("用户不存在")
|
|
}
|
|
|
|
// 检查设备是否已存在
|
|
exists, err := s.deviceRepo.Exists(ctx, userID, req.DeviceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if exists {
|
|
// 设备已存在，更新最后活跃时间
|
|
device, err := s.deviceRepo.GetByDeviceID(ctx, userID, req.DeviceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
device.LastActiveTime = time.Now()
|
|
return device, s.deviceRepo.Update(ctx, device)
|
|
}
|
|
|
|
// 创建设备
|
|
device := &domain.Device{
|
|
UserID: userID,
|
|
DeviceID: req.DeviceID,
|
|
DeviceName: req.DeviceName,
|
|
DeviceType: domain.DeviceType(req.DeviceType),
|
|
DeviceOS: req.DeviceOS,
|
|
DeviceBrowser: req.DeviceBrowser,
|
|
IP: req.IP,
|
|
Location: req.Location,
|
|
Status: domain.DeviceStatusActive,
|
|
}
|
|
|
|
if err := s.deviceRepo.Create(ctx, device); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return device, nil
|
|
}
|
|
|
|
// UpdateDevice 更新设备
|
|
func (s *DeviceService) UpdateDevice(ctx context.Context, deviceID int64, req *UpdateDeviceRequest) (*domain.Device, error) {
|
|
device, err := s.deviceRepo.GetByID(ctx, deviceID)
|
|
if err != nil {
|
|
return nil, errors.New("设备不存在")
|
|
}
|
|
|
|
// 更新字段
|
|
if req.DeviceName != "" {
|
|
device.DeviceName = req.DeviceName
|
|
}
|
|
if req.DeviceType >= 0 {
|
|
device.DeviceType = domain.DeviceType(req.DeviceType)
|
|
}
|
|
if req.DeviceOS != "" {
|
|
device.DeviceOS = req.DeviceOS
|
|
}
|
|
if req.DeviceBrowser != "" {
|
|
device.DeviceBrowser = req.DeviceBrowser
|
|
}
|
|
if req.IP != "" {
|
|
device.IP = req.IP
|
|
}
|
|
if req.Location != "" {
|
|
device.Location = req.Location
|
|
}
|
|
if req.Status >= 0 {
|
|
device.Status = domain.DeviceStatus(req.Status)
|
|
}
|
|
|
|
if err := s.deviceRepo.Update(ctx, device); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return device, nil
|
|
}
|
|
|
|
// DeleteDevice 删除设备
|
|
func (s *DeviceService) DeleteDevice(ctx context.Context, deviceID int64) error {
|
|
return s.deviceRepo.Delete(ctx, deviceID)
|
|
}
|
|
|
|
// GetDevice 获取设备信息
|
|
func (s *DeviceService) GetDevice(ctx context.Context, deviceID int64) (*domain.Device, error) {
|
|
return s.deviceRepo.GetByID(ctx, deviceID)
|
|
}
|
|
|
|
// GetUserDevices 获取用户设备列表
|
|
func (s *DeviceService) GetUserDevices(ctx context.Context, userID int64, page, pageSize int) ([]*domain.Device, int64, error) {
|
|
offset := (page - 1) * pageSize
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
if pageSize <= 0 {
|
|
pageSize = 20
|
|
}
|
|
|
|
return s.deviceRepo.ListByUserID(ctx, userID, offset, pageSize)
|
|
}
|
|
|
|
// UpdateDeviceStatus 更新设备状态
|
|
func (s *DeviceService) UpdateDeviceStatus(ctx context.Context, deviceID int64, status domain.DeviceStatus) error {
|
|
return s.deviceRepo.UpdateStatus(ctx, deviceID, status)
|
|
}
|
|
|
|
// UpdateLastActiveTime 更新最后活跃时间
|
|
func (s *DeviceService) UpdateLastActiveTime(ctx context.Context, deviceID int64) error {
|
|
return s.deviceRepo.UpdateLastActiveTime(ctx, deviceID)
|
|
}
|
|
|
|
// GetActiveDevices 获取活跃设备
|
|
func (s *DeviceService) GetActiveDevices(ctx context.Context, page, pageSize int) ([]*domain.Device, int64, error) {
|
|
offset := (page - 1) * pageSize
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
if pageSize <= 0 {
|
|
pageSize = 20
|
|
}
|
|
|
|
return s.deviceRepo.ListByStatus(ctx, domain.DeviceStatusActive, offset, pageSize)
|
|
}
|
|
|
|
// TrustDevice 设置设备为信任状态
|
|
func (s *DeviceService) TrustDevice(ctx context.Context, deviceID int64, trustDuration time.Duration) error {
|
|
device, err := s.deviceRepo.GetByID(ctx, deviceID)
|
|
if err != nil {
|
|
return errors.New("设备不存在")
|
|
}
|
|
|
|
var trustExpiresAt *time.Time
|
|
if trustDuration > 0 {
|
|
expiresAt := time.Now().Add(trustDuration)
|
|
trustExpiresAt = &expiresAt
|
|
}
|
|
|
|
return s.deviceRepo.TrustDevice(ctx, device.ID, trustExpiresAt)
|
|
}
|
|
|
|
// TrustDeviceByDeviceID 根据设备标识字符串设置设备为信任状态
|
|
func (s *DeviceService) TrustDeviceByDeviceID(ctx context.Context, userID int64, deviceID string, trustDuration time.Duration) error {
|
|
device, err := s.deviceRepo.GetByDeviceID(ctx, userID, deviceID)
|
|
if err != nil {
|
|
return errors.New("设备不存在")
|
|
}
|
|
|
|
var trustExpiresAt *time.Time
|
|
if trustDuration > 0 {
|
|
expiresAt := time.Now().Add(trustDuration)
|
|
trustExpiresAt = &expiresAt
|
|
}
|
|
|
|
return s.deviceRepo.TrustDevice(ctx, device.ID, trustExpiresAt)
|
|
}
|
|
|
|
// UntrustDevice 取消设备信任状态
|
|
func (s *DeviceService) UntrustDevice(ctx context.Context, deviceID int64) error {
|
|
device, err := s.deviceRepo.GetByID(ctx, deviceID)
|
|
if err != nil {
|
|
return errors.New("设备不存在")
|
|
}
|
|
|
|
return s.deviceRepo.UntrustDevice(ctx, device.ID)
|
|
}
|
|
|
|
// LogoutAllOtherDevices 登出所有其他设备
|
|
func (s *DeviceService) LogoutAllOtherDevices(ctx context.Context, userID int64, currentDeviceID int64) error {
|
|
return s.deviceRepo.DeleteAllByUserIDExcept(ctx, userID, currentDeviceID)
|
|
}
|
|
|
|
// GetTrustedDevices 获取用户的信任设备列表
|
|
func (s *DeviceService) GetTrustedDevices(ctx context.Context, userID int64) ([]*domain.Device, error) {
|
|
return s.deviceRepo.GetTrustedDevices(ctx, userID)
|
|
}
|
|
|
|
// GetAllDevicesRequest 获取所有设备请求参数
|
|
type GetAllDevicesRequest struct {
|
|
Page int
|
|
PageSize int
|
|
UserID int64 `form:"user_id"`
|
|
Status int `form:"status"`
|
|
IsTrusted *bool `form:"is_trusted"`
|
|
Keyword string `form:"keyword"`
|
|
}
|
|
|
|
// GetAllDevices 获取所有设备（管理员用）
|
|
func (s *DeviceService) GetAllDevices(ctx context.Context, req *GetAllDevicesRequest) ([]*domain.Device, int64, error) {
|
|
if req.Page <= 0 {
|
|
req.Page = 1
|
|
}
|
|
if req.PageSize <= 0 {
|
|
req.PageSize = 20
|
|
}
|
|
if req.PageSize > 100 {
|
|
req.PageSize = 100
|
|
}
|
|
|
|
offset := (req.Page - 1) * req.PageSize
|
|
|
|
params := &repository.ListDevicesParams{
|
|
UserID: req.UserID,
|
|
Keyword: req.Keyword,
|
|
Offset: offset,
|
|
Limit: req.PageSize,
|
|
}
|
|
|
|
// 处理状态筛选
|
|
if req.Status >= 0 {
|
|
params.Status = domain.DeviceStatus(req.Status)
|
|
}
|
|
|
|
// 处理信任状态筛选
|
|
if req.IsTrusted != nil {
|
|
params.IsTrusted = req.IsTrusted
|
|
}
|
|
|
|
return s.deviceRepo.ListAll(ctx, params)
|
|
}
|
|
|
|
// GetDeviceByDeviceID 根据设备标识获取设备（用于设备信任检查）
|
|
func (s *DeviceService) GetDeviceByDeviceID(ctx context.Context, userID int64, deviceID string) (*domain.Device, error) {
|
|
return s.deviceRepo.GetByDeviceID(ctx, userID, deviceID)
|
|
}
|