refactor: Remove Token management and integrate Redis for authentication
- Deleted the Token model and its repository, transitioning to a Redis-based token management system. - Updated the service layer to utilize Redis for token storage, enhancing performance and scalability. - Refactored the container to remove TokenRepository and integrate the new token service. - Cleaned up the Dockerfile and other files by removing unnecessary whitespace and comments. - Enhanced error handling and logging for Redis initialization and usage.
This commit is contained in:
lan
@@ -315,6 +315,18 @@ func (m *MockTextureRepository) FindByHash(ctx context.Context, hash string) (*m
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (m *MockTextureRepository) FindByHashAndUploaderID(ctx context.Context, hash string, uploaderID int64) (*model.Texture, error) {
|
||||
if m.FailFind {
|
||||
return nil, errors.New("mock find error")
|
||||
}
|
||||
for _, texture := range m.textures {
|
||||
if texture.Hash == hash && texture.UploaderID == uploaderID {
|
||||
return texture, nil
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (m *MockTextureRepository) FindByUploaderID(ctx context.Context, uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
|
||||
if m.FailFind {
|
||||
return nil, 0, errors.New("mock find error")
|
||||
@@ -462,101 +474,6 @@ func (m *MockTextureRepository) BatchDelete(ctx context.Context, ids []int64) (i
|
||||
return deleted, nil
|
||||
}
|
||||
|
||||
// MockTokenRepository 模拟TokenRepository
|
||||
type MockTokenRepository struct {
|
||||
tokens map[string]*model.Token
|
||||
userTokens map[int64][]*model.Token
|
||||
FailCreate bool
|
||||
FailFind bool
|
||||
FailDelete bool
|
||||
}
|
||||
|
||||
func NewMockTokenRepository() *MockTokenRepository {
|
||||
return &MockTokenRepository{
|
||||
tokens: make(map[string]*model.Token),
|
||||
userTokens: make(map[int64][]*model.Token),
|
||||
}
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) Create(ctx context.Context, token *model.Token) error {
|
||||
if m.FailCreate {
|
||||
return errors.New("mock create error")
|
||||
}
|
||||
m.tokens[token.AccessToken] = token
|
||||
m.userTokens[token.UserID] = append(m.userTokens[token.UserID], token)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) FindByAccessToken(ctx context.Context, accessToken string) (*model.Token, error) {
|
||||
if m.FailFind {
|
||||
return nil, errors.New("mock find error")
|
||||
}
|
||||
if token, ok := m.tokens[accessToken]; ok {
|
||||
return token, nil
|
||||
}
|
||||
return nil, errors.New("token not found")
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) GetByUserID(ctx context.Context, userId int64) ([]*model.Token, error) {
|
||||
if m.FailFind {
|
||||
return nil, errors.New("mock find error")
|
||||
}
|
||||
return m.userTokens[userId], nil
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) GetUUIDByAccessToken(ctx context.Context, accessToken string) (string, error) {
|
||||
if m.FailFind {
|
||||
return "", errors.New("mock find error")
|
||||
}
|
||||
if token, ok := m.tokens[accessToken]; ok {
|
||||
return token.ProfileId, nil
|
||||
}
|
||||
return "", errors.New("token not found")
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) GetUserIDByAccessToken(ctx context.Context, accessToken string) (int64, error) {
|
||||
if m.FailFind {
|
||||
return 0, errors.New("mock find error")
|
||||
}
|
||||
if token, ok := m.tokens[accessToken]; ok {
|
||||
return token.UserID, nil
|
||||
}
|
||||
return 0, errors.New("token not found")
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) DeleteByAccessToken(ctx context.Context, accessToken string) error {
|
||||
if m.FailDelete {
|
||||
return errors.New("mock delete error")
|
||||
}
|
||||
delete(m.tokens, accessToken)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) DeleteByUserID(ctx context.Context, userId int64) error {
|
||||
if m.FailDelete {
|
||||
return errors.New("mock delete error")
|
||||
}
|
||||
for _, token := range m.userTokens[userId] {
|
||||
delete(m.tokens, token.AccessToken)
|
||||
}
|
||||
m.userTokens[userId] = nil
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *MockTokenRepository) BatchDelete(ctx context.Context, accessTokens []string) (int64, error) {
|
||||
if m.FailDelete {
|
||||
return 0, errors.New("mock delete error")
|
||||
}
|
||||
var count int64
|
||||
for _, accessToken := range accessTokens {
|
||||
if _, ok := m.tokens[accessToken]; ok {
|
||||
delete(m.tokens, accessToken)
|
||||
count++
|
||||
}
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
|
||||
// MockSystemConfigRepository 模拟SystemConfigRepository
|
||||
type MockSystemConfigRepository struct {
|
||||
configs map[string]*model.SystemConfig
|
||||
@@ -956,90 +873,11 @@ func (m *MockTextureService) CheckUploadLimit(uploaderID int64, maxTextures int)
|
||||
return nil
|
||||
}
|
||||
|
||||
// MockTokenService 模拟TokenService
|
||||
type MockTokenService struct {
|
||||
tokens map[string]*model.Token
|
||||
FailCreate bool
|
||||
FailValidate bool
|
||||
FailRefresh bool
|
||||
}
|
||||
|
||||
func NewMockTokenService() *MockTokenService {
|
||||
return &MockTokenService{
|
||||
tokens: make(map[string]*model.Token),
|
||||
}
|
||||
}
|
||||
|
||||
func (m *MockTokenService) Create(userID int64, uuid, clientToken string) (*model.Profile, []*model.Profile, string, string, error) {
|
||||
if m.FailCreate {
|
||||
return nil, nil, "", "", errors.New("mock create error")
|
||||
}
|
||||
accessToken := "mock-access-token"
|
||||
if clientToken == "" {
|
||||
clientToken = "mock-client-token"
|
||||
}
|
||||
token := &model.Token{
|
||||
AccessToken: accessToken,
|
||||
ClientToken: clientToken,
|
||||
UserID: userID,
|
||||
ProfileId: uuid,
|
||||
Usable: true,
|
||||
}
|
||||
m.tokens[accessToken] = token
|
||||
return nil, nil, accessToken, clientToken, nil
|
||||
}
|
||||
|
||||
func (m *MockTokenService) Validate(accessToken, clientToken string) bool {
|
||||
if m.FailValidate {
|
||||
return false
|
||||
}
|
||||
if token, ok := m.tokens[accessToken]; ok {
|
||||
if clientToken == "" || token.ClientToken == clientToken {
|
||||
return token.Usable
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (m *MockTokenService) Refresh(accessToken, clientToken, selectedProfileID string) (string, string, error) {
|
||||
if m.FailRefresh {
|
||||
return "", "", errors.New("mock refresh error")
|
||||
}
|
||||
return "new-access-token", clientToken, nil
|
||||
}
|
||||
|
||||
func (m *MockTokenService) Invalidate(accessToken string) {
|
||||
delete(m.tokens, accessToken)
|
||||
}
|
||||
|
||||
func (m *MockTokenService) InvalidateUserTokens(userID int64) {
|
||||
for key, token := range m.tokens {
|
||||
if token.UserID == userID {
|
||||
delete(m.tokens, key)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *MockTokenService) GetUUIDByAccessToken(accessToken string) (string, error) {
|
||||
if token, ok := m.tokens[accessToken]; ok {
|
||||
return token.ProfileId, nil
|
||||
}
|
||||
return "", errors.New("token not found")
|
||||
}
|
||||
|
||||
func (m *MockTokenService) GetUserIDByAccessToken(accessToken string) (int64, error) {
|
||||
if token, ok := m.tokens[accessToken]; ok {
|
||||
return token.UserID, nil
|
||||
}
|
||||
return 0, errors.New("token not found")
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// CacheManager Mock - uses database.CacheManager with nil redis
|
||||
// CacheManager Mock - 使用 database.CacheManager 的内存版本
|
||||
// ============================================================================
|
||||
|
||||
// NewMockCacheManager 创建一个禁用的 CacheManager 用于测试
|
||||
// 通过设置 Enabled = false，缓存操作会被跳过，测试不依赖 Redis
|
||||
// NewMockCacheManager 创建一个内存 CacheManager 用于测试
|
||||
func NewMockCacheManager() *database.CacheManager {
|
||||
return database.NewCacheManager(nil, database.CacheConfig{
|
||||
Prefix: "test:",
|
||||
|
||||
Reference in New Issue
Block a user