feat(设备管理): 添加设备在线记录查询功能并优化设备列表排序

添加FindLatestDeviceOnlineRecord接口用于查询设备最新在线记录
实现GetOnlineDeviceLoginTime方法获取设备登录时间
优化设备列表查询按最后活动时间排序
移除未使用的依赖项

internal/logic/auth/deviceLoginLogic.go

@@ -140,9 +140,9 @@ func (l *DeviceLoginLogic) DeviceLogin(req *types.DeviceLoginRequest) (resp *typ
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err.Error())
 	}
 
-	if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.Config.JwtAuth.MaxSessionsPerUser); err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
-	}
+    if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.SessionLimit()); err != nil {
+        return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
+    }
 	// Store session id in redis
 	sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
 	if err = l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
@@ -164,10 +164,10 @@ func (l *DeviceLoginLogic) DeviceLogin(req *types.DeviceLoginRequest) (resp *typ
 	}
 
 	loginStatus = true
-	return &types.LoginResponse{
-		Token: token,
-		Limit: l.svcCtx.Config.JwtAuth.MaxSessionsPerUser,
-	}, nil
+    return &types.LoginResponse{
+        Token: token,
+        Limit: l.svcCtx.SessionLimit(),
+    }, nil
 }
 
 func (l *DeviceLoginLogic) registerUserAndDevice(req *types.DeviceLoginRequest) (*user.User, error) {

internal/logic/auth/oauth/oAuthLoginGetTokenLogic.go

@@ -78,11 +78,11 @@ func (l *OAuthLoginGetTokenLogic) OAuthLoginGetToken(req *types.OAuthLoginGetTok
 		return nil, err
 	}
 
-	loginStatus = true
-	return &types.LoginResponse{
-		Token: token,
-		Limit: l.svcCtx.Config.JwtAuth.MaxSessionsPerUser,
-	}, nil
+    loginStatus = true
+    return &types.LoginResponse{
+        Token: token,
+        Limit: l.svcCtx.SessionLimit(),
+    }, nil
 }
 
 func (l *OAuthLoginGetTokenLogic) google(req *types.OAuthLoginGetTokenRequest, requestID, ip, userAgent string) (*user.User, error) {
@@ -590,9 +590,9 @@ func (l *OAuthLoginGetTokenLogic) generateToken(userInfo *user.User, requestID s
 		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err)
 	}
 
-	if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.Config.JwtAuth.MaxSessionsPerUser); err != nil {
-		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
-	}
+    if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.SessionLimit()); err != nil {
+        return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
+    }
 
 	sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
 	if err = l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {

internal/logic/auth/telephoneLoginLogic.go

@@ -156,16 +156,16 @@ func (l *TelephoneLoginLogic) TelephoneLogin(req *types.TelephoneLoginRequest, r
 		l.Logger.Error("[UserLogin] token generate error", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err.Error())
 	}
-	if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.Config.JwtAuth.MaxSessionsPerUser); err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
-	}
+    if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.SessionLimit()); err != nil {
+        return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
+    }
 	sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
 	if err = l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "set session id error: %v", err.Error())
 	}
 	loginStatus = true
-	return &types.LoginResponse{
-		Token: token,
-		Limit: l.svcCtx.Config.JwtAuth.MaxSessionsPerUser,
-	}, nil
+    return &types.LoginResponse{
+        Token: token,
+        Limit: l.svcCtx.SessionLimit(),
+    }, nil
 }

internal/logic/auth/userLoginLogic.go

@@ -111,16 +111,16 @@ func (l *UserLoginLogic) UserLogin(req *types.UserLoginRequest) (resp *types.Log
 		l.Logger.Error("[UserLogin] token generate error", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err.Error())
 	}
-	if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.Config.JwtAuth.MaxSessionsPerUser); err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
-	}
+    if err = l.svcCtx.EnforceUserSessionLimit(l.ctx, userInfo.Id, sessionId, l.svcCtx.SessionLimit()); err != nil {
+        return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "enforce session limit error: %v", err.Error())
+    }
 	sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
 	if err = l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "set session id error: %v", err.Error())
 	}
 	loginStatus = true
-	return &types.LoginResponse{
-		Token: token,
-		Limit: l.svcCtx.Config.JwtAuth.MaxSessionsPerUser,
-	}, nil
+    return &types.LoginResponse{
+        Token: token,
+        Limit: l.svcCtx.SessionLimit(),
+    }, nil
 }

internal/logic/public/user/bindEmailWithVerificationLogic.go

@@ -69,23 +69,23 @@ func (l *BindEmailWithVerificationLogic) BindEmailWithVerification(req *types.Bi
 	// 检查邮箱是否已被其他用户绑定
 	existingMethod, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "email", req.Email)
 	var emailUserId int64
-    if err != nil {
-        if errors.Is(err, gorm.ErrRecordNotFound) {
-            // 邮箱不存在，不创建新用户，直接将邮箱认证绑定到当前设备用户
-            l.Infow(" 为当前设备做 邮箱绑定操作； 在 user_auth_methods 中添加记录", logger.Field("email", req.Email))
-            err = l.addAuthMethodForEmailUser(u.Id, req.Email)
-            if err != nil {
-                l.Errorw("添加邮箱用户认证方法失败", logger.Field("error", err.Error()), logger.Field("user_id", u.Id))
-                return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "添加邮箱用户认证方法失败")
-            }
-            // 关键修复：为后续 token 生成与返回结果赋值绑定后的用户ID
-            emailUserId = u.Id
-        } else {
-            // 数据库查询错误
-            l.Errorw("查询邮箱绑定状态失败", logger.Field("error", err.Error()))
-            return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "查询邮箱绑定状态失败")
-        }
-    } else if existingMethod.Id != 0 {
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			// 邮箱不存在，不创建新用户，直接将邮箱认证绑定到当前设备用户
+			l.Infow(" 为当前设备做 邮箱绑定操作； 在 user_auth_methods 中添加记录", logger.Field("email", req.Email))
+			err = l.addAuthMethodForEmailUser(u.Id, req.Email)
+			if err != nil {
+				l.Errorw("添加邮箱用户认证方法失败", logger.Field("error", err.Error()), logger.Field("user_id", u.Id))
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "添加邮箱用户认证方法失败")
+			}
+			// 关键修复：为后续 token 生成与返回结果赋值绑定后的用户ID
+			emailUserId = u.Id
+		} else {
+			// 数据库查询错误
+			l.Errorw("查询邮箱绑定状态失败", logger.Field("error", err.Error()))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "查询邮箱绑定状态失败")
+		}
+	} else if existingMethod.Id != 0 {
 		// 邮箱已存在，使用现有的邮箱用户
 		emailUserId = existingMethod.UserId
 		l.Infow("邮箱已存在，将设备转移到现有邮箱用户",

internal/logic/public/user/getDeviceListLogic.go

@@ -1,14 +1,16 @@
 package user
 
 import (
-	"context"
+    "context"
+    "sort"
+    "time"
 
-	"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/tool"
+    "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/tool"
 )
 
 type GetDeviceListLogic struct {
@@ -27,13 +29,39 @@ func NewGetDeviceListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Get
 }
 
 func (l *GetDeviceListLogic) GetDeviceList() (resp *types.GetDeviceListResponse, err error) {
-	userInfo := l.ctx.Value(constant.CtxKeyUser).(*user.User)
-	list, count, err := l.svcCtx.UserModel.QueryDeviceList(l.ctx, userInfo.Id)
-	userRespList := make([]types.UserDevice, 0)
-	tool.DeepCopy(&userRespList, list)
-	resp = &types.GetDeviceListResponse{
-		Total: count,
-		List:  userRespList,
-	}
-	return
+    userInfo := l.ctx.Value(constant.CtxKeyUser).(*user.User)
+    list, count, err := l.svcCtx.UserModel.QueryDeviceList(l.ctx, userInfo.Id)
+    if err != nil {
+        return nil, err
+    }
+    type item struct {
+        dev  *user.Device
+        when time.Time
+    }
+    items := make([]item, 0, len(list))
+    for _, d := range list {
+        t, ok := l.svcCtx.DeviceManager.GetOnlineDeviceLoginTime(userInfo.Id, d.Identifier)
+        if !ok {
+            rec, recErr := l.svcCtx.UserModel.FindLatestDeviceOnlineRecord(l.ctx, userInfo.Id, d.Identifier)
+            if recErr == nil && rec != nil {
+                t = rec.OnlineTime
+            } else {
+                if d.UpdatedAt.After(d.CreatedAt) {
+                    t = d.UpdatedAt
+                } else {
+                    t = d.CreatedAt
+                }
+            }
+        }
+        items = append(items, item{dev: d, when: t})
+    }
+    sort.Slice(items, func(i, j int) bool { return items[i].when.After(items[j].when) })
+    userRespList := make([]types.UserDevice, 0, len(items))
+    for _, it := range items {
+        var ud types.UserDevice
+        tool.DeepCopy(&ud, it.dev)
+        userRespList = append(userRespList, ud)
+    }
+    resp = &types.GetDeviceListResponse{Total: count, List: userRespList}
+    return
 }

internal/model/user/device.go

@@ -40,7 +40,7 @@ func (m *customUserModel) QueryDevicePageList(ctx context.Context, userId, subsc
 	var list []*Device
 	var total int64
 	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
-		return conn.Model(&Device{}).Where("`user_id` = ? and `subscribe_id` = ?", userId, subscribeId).Count(&total).Limit(size).Offset((page - 1) * size).Find(&list).Error
+		return conn.Model(&Device{}).Where("`user_id` = ? and `subscribe_id` = ?", userId, subscribeId).Count(&total).Order("created_at DESC").Limit(size).Offset((page - 1) * size).Find(&list).Error
 	})
 	return list, total, err
 }
@@ -50,7 +50,7 @@ func (m *customUserModel) QueryDeviceList(ctx context.Context, userId int64) ([]
 	var list []*Device
 	var total int64
 	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
-		return conn.Model(&Device{}).Where("`user_id` = ?", userId).Count(&total).Find(&list).Error
+		return conn.Model(&Device{}).Where("`user_id` = ?", userId).Count(&total).Order("created_at DESC").Find(&list).Error
 	})
 	return list, total, err
 }
@@ -100,3 +100,14 @@ func (m *customUserModel) InsertDevice(ctx context.Context, data *Device, tx ...
 		return conn.Create(data).Error
 	})
 }
+
+func (m *customUserModel) FindLatestDeviceOnlineRecord(ctx context.Context, userId int64, identifier string) (*DeviceOnlineRecord, error) {
+	var rec DeviceOnlineRecord
+	err := m.QueryNoCacheCtx(ctx, &rec, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&DeviceOnlineRecord{}).Where("user_id = ? AND identifier = ?", userId, identifier).Order("online_time DESC").First(&rec).Error
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &rec, nil
+}

internal/model/user/model.go

@@ -103,6 +103,8 @@ type customUserLogicModel interface {
 	DeleteDevice(ctx context.Context, id int64, tx ...*gorm.DB) error
 	InsertDevice(ctx context.Context, data *Device, tx ...*gorm.DB) error
 
+	FindLatestDeviceOnlineRecord(ctx context.Context, userId int64, identifier string) (*DeviceOnlineRecord, error)
+
 	ClearSubscribeCache(ctx context.Context, data ...*Subscribe) error
 	ClearUserCache(ctx context.Context, data ...*User) error
 	BatchClearRelatedCache(ctx context.Context, user *User) error

internal/svc/serviceContext.go

@@ -1,36 +1,39 @@
 package svc
 
 import (
-    "context"
-    "fmt"
-    "time"
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
 
-    "github.com/perfect-panel/server/internal/model/client"
-    "github.com/perfect-panel/server/internal/model/node"
-    "github.com/perfect-panel/server/pkg/device"
+	"github.com/perfect-panel/server/internal/model/client"
+	"github.com/perfect-panel/server/internal/model/node"
+	"github.com/perfect-panel/server/pkg/device"
 
-    "github.com/perfect-panel/server/internal/config"
-    "github.com/perfect-panel/server/internal/model/ads"
-    "github.com/perfect-panel/server/internal/model/announcement"
-    "github.com/perfect-panel/server/internal/model/auth"
-    "github.com/perfect-panel/server/internal/model/coupon"
-    "github.com/perfect-panel/server/internal/model/document"
-    "github.com/perfect-panel/server/internal/model/log"
-    "github.com/perfect-panel/server/internal/model/order"
-    "github.com/perfect-panel/server/internal/model/payment"
-    "github.com/perfect-panel/server/internal/model/subscribe"
-    "github.com/perfect-panel/server/internal/model/system"
-    "github.com/perfect-panel/server/internal/model/ticket"
-    "github.com/perfect-panel/server/internal/model/traffic"
-    "github.com/perfect-panel/server/internal/model/user"
-    "github.com/perfect-panel/server/pkg/limit"
-    "github.com/perfect-panel/server/pkg/nodeMultiplier"
-    "github.com/perfect-panel/server/pkg/orm"
+	"github.com/perfect-panel/server/internal/config"
+	"github.com/perfect-panel/server/internal/model/ads"
+	"github.com/perfect-panel/server/internal/model/announcement"
+	"github.com/perfect-panel/server/internal/model/auth"
+	"github.com/perfect-panel/server/internal/model/coupon"
+	"github.com/perfect-panel/server/internal/model/document"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/payment"
+	"github.com/perfect-panel/server/internal/model/subscribe"
+	"github.com/perfect-panel/server/internal/model/system"
+	"github.com/perfect-panel/server/internal/model/ticket"
+	"github.com/perfect-panel/server/internal/model/traffic"
+	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/pkg/limit"
+	"github.com/perfect-panel/server/pkg/nodeMultiplier"
+	"github.com/perfect-panel/server/pkg/orm"
 
-    tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
-    "github.com/hibiken/asynq"
-    "github.com/redis/go-redis/v9"
-    "gorm.io/gorm"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+	"github.com/hibiken/asynq"
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
 )
 
 type ServiceContext struct {
@@ -110,34 +113,68 @@ func NewServiceContext(c config.Config) *ServiceContext {
 		TrafficLogModel:   traffic.NewModel(db),
 		AnnouncementModel: announcement.NewModel(db, rds),
 	}
-    srv.DeviceManager = NewDeviceManager(srv)
-    return srv
+	srv.DeviceManager = NewDeviceManager(srv)
+	return srv
 
 }
 
+func (srv *ServiceContext) SessionLimit() int64 {
+	cd := srv.Config.Site.CustomData
+	if cd != "" {
+		var obj map[string]interface{}
+		if json.Unmarshal([]byte(cd), &obj) == nil {
+			if v, ok := obj["deviceLimit"]; ok {
+				switch val := v.(type) {
+				case float64:
+					if val > 0 {
+						return int64(val)
+					}
+				case string:
+					if n, err := strconv.ParseInt(strings.TrimSpace(val), 10, 64); err == nil && n > 0 {
+						return n
+					}
+				}
+			}
+			if v, ok := obj["DeviceLimit"]; ok {
+				switch val := v.(type) {
+				case float64:
+					if val > 0 {
+						return int64(val)
+					}
+				case string:
+					if n, err := strconv.ParseInt(strings.TrimSpace(val), 10, 64); err == nil && n > 0 {
+						return n
+					}
+				}
+			}
+		}
+	}
+	return srv.Config.JwtAuth.MaxSessionsPerUser
+}
+
 func (srv *ServiceContext) EnforceUserSessionLimit(ctx context.Context, userId int64, newSessionId string, max int64) error {
-    if max <= 0 {
-        return nil
-    }
-    sessionsKey := fmt.Sprintf("%s%v", config.UserSessionsKeyPrefix, userId)
-    now := time.Now().Unix()
-    if err := srv.Redis.ZAdd(ctx, sessionsKey, redis.Z{Score: float64(now), Member: newSessionId}).Err(); err != nil {
-        return err
-    }
-    count, err := srv.Redis.ZCard(ctx, sessionsKey).Result()
-    if err != nil {
-        return err
-    }
-    if count > max {
-        popped, err := srv.Redis.ZPopMin(ctx, sessionsKey, count-max).Result()
-        if err != nil {
-            return err
-        }
-        for _, z := range popped {
-            sid := fmt.Sprintf("%v", z.Member)
-            _ = srv.Redis.Del(ctx, fmt.Sprintf("%v:%v", config.SessionIdKey, sid)).Err()
-        }
-    }
-    _ = srv.Redis.Expire(ctx, sessionsKey, time.Duration(srv.Config.JwtAuth.AccessExpire)*time.Second).Err()
-    return nil
+	if max <= 0 {
+		return nil
+	}
+	sessionsKey := fmt.Sprintf("%s%v", config.UserSessionsKeyPrefix, userId)
+	now := time.Now().Unix()
+	if err := srv.Redis.ZAdd(ctx, sessionsKey, redis.Z{Score: float64(now), Member: newSessionId}).Err(); err != nil {
+		return err
+	}
+	count, err := srv.Redis.ZCard(ctx, sessionsKey).Result()
+	if err != nil {
+		return err
+	}
+	if count > max {
+		popped, err := srv.Redis.ZPopMin(ctx, sessionsKey, count-max).Result()
+		if err != nil {
+			return err
+		}
+		for _, z := range popped {
+			sid := fmt.Sprintf("%v", z.Member)
+			_ = srv.Redis.Del(ctx, fmt.Sprintf("%v:%v", config.SessionIdKey, sid)).Err()
+		}
+	}
+	_ = srv.Redis.Expire(ctx, sessionsKey, time.Duration(srv.Config.JwtAuth.AccessExpire)*time.Second).Err()
+	return nil
 }