dave/go-eve-pi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor "Token" to "Character" which is what it actually is

Browse Source
This commit is contained in:
PhatPhuckDave
2025-10-10 21:56:42 +02:00
parent acec39ad76
commit bc77158507
2 changed files with 40 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
db.go
View File

@@ -12,8 +12,8 @@ import (
type DB interface {
DB() *gorm.DB
Raw(sql string, args ...any) *gorm.DB
GetTokenForCharacter(characterName string) (*Token, error)
SaveTokenForCharacter(token *Token) error
GetCharacterByName(characterName string) (*Character, error)
SaveCharacter(character *Character) error
AutoMigrate(dst ...interface{}) error
}
@@ -55,25 +55,25 @@ func (db *DBWrapper) DB() *gorm.DB {
return db.db
}
func (db *DBWrapper) GetTokenForCharacter(characterName string) (*Token, error) {
func (db *DBWrapper) GetCharacterByName(characterName string) (*Character, error) {
logger.Debug("Fetching token for character %s from database", characterName)
var token Token
err := db.db.Where("character_name = ?", characterName).First(&token).Error
var char Character
err := db.db.Where("character_name = ?", characterName).First(&char).Error
if err != nil {
logger.Debug("No token found for character %s: %v", characterName, err)
return nil, err
}
logger.Debug("Token found for character %s, expires at %v", characterName, token.ExpiresAt)
return &token, nil
logger.Debug("Token found for character %s, expires at %v", characterName, char.ExpiresAt)
return &char, nil
}
func (db *DBWrapper) SaveTokenForCharacter(token *Token) error {
logger.Debug("Saving token for character %s to database", token.CharacterName)
err := db.db.Save(token).Error
func (db *DBWrapper) SaveCharacter(character *Character) error {
logger.Debug("Saving token for character %s to database", character.CharacterName)
err := db.db.Save(character).Error
if err != nil {
return err
}
logger.Debug("Token saved successfully for character %s", token.CharacterName)
logger.Debug("Token saved successfully for character %s", character.CharacterName)
return nil
}

58
esi_sso.go
View File

@@ -28,7 +28,7 @@ const (
issuerTokenURL = "https://login.eveonline.com/v2/oauth/token"
)
type Token struct {
type Character struct {
ID uint `gorm:"primaryKey"`
CharacterName string `gorm:"uniqueIndex"`
AccessToken string
@@ -88,7 +88,7 @@ func (s *SSO) SetRouter(r *router.Router) {
func (s *SSO) initDB() error {
logger.Debug("Initializing SSO database schema")
err := s.db.AutoMigrate(&Token{})
err := s.db.AutoMigrate(&Character{})
if err != nil {
logger.Error("Failed to migrate Token table %v", err)
return err
@@ -100,46 +100,46 @@ func (s *SSO) initDB() error {
// GetToken returns a valid access token for the given character name
// If no token exists, it will start the OAuth flow
// If token is expired, it will refresh it automatically
func (s *SSO) GetToken(ctx context.Context, characterName string) (string, error) {
func (s *SSO) GetCharacter(ctx context.Context, characterName string) (Character, error) {
logger.Debug("Getting token for character %s", characterName)
s.mu.Lock()
defer s.mu.Unlock()
// Try to get existing token from DB
token, err := s.db.GetTokenForCharacter(characterName)
char, err := s.db.GetCharacterByName(characterName)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
logger.Info("No existing token found for character %s, starting authentication flow", characterName)
// No token exists, need to authenticate
if err := s.startAuthFlow(ctx, characterName); err != nil {
return "", err
return Character{}, err
}
// After authentication, fetch the token from DB
token, err = s.db.GetTokenForCharacter(characterName)
char, err = s.db.GetCharacterByName(characterName)
if err != nil {
return "", err
return Character{}, err
}
logger.Info("Successfully authenticated character %s", characterName)
} else {
return "", err
return Character{}, err
}
} else {
logger.Debug("Found existing token for character %s, expires at %v", characterName, token.ExpiresAt)
logger.Debug("Found existing token for character %s, expires at %v", characterName, char.ExpiresAt)
}
// Check if token needs refresh
if time.Now().After(token.ExpiresAt.Add(-60 * time.Second)) {
if time.Now().After(char.ExpiresAt.Add(-12 * time.Hour)) {
logger.Info("Token for character %s is expired or expiring soon, refreshing", characterName)
if err := s.refreshToken(ctx, token); err != nil {
if err := s.refreshToken(ctx, char); err != nil {
logger.Warning("Token refresh failed for character %s, re-authenticating: %v", characterName, err)
// Refresh failed, need to re-authenticate
if err := s.startAuthFlow(ctx, characterName); err != nil {
return "", err
return Character{}, err
}
// After re-authentication, fetch the token from DB
token, err = s.db.GetTokenForCharacter(characterName)
char, err = s.db.GetCharacterByName(characterName)
if err != nil {
return "", err
return Character{}, err
}
logger.Info("Successfully re-authenticated character %s", characterName)
} else {
@@ -150,7 +150,7 @@ func (s *SSO) GetToken(ctx context.Context, characterName string) (string, error
}
logger.Debug("Returning valid token for character %s", characterName)
return token.AccessToken, nil
return *char, nil
}
func (s *SSO) startAuthFlow(ctx context.Context, characterName string) error {
@@ -196,15 +196,15 @@ func (s *SSO) startAuthFlow(ctx context.Context, characterName string) error {
logger.Debug("Received valid callback, exchanging code for token")
// Exchange code for token
token, err := s.exchangeCodeForToken(ctx, code, verifier)
char, err := s.exchangeCodeForToken(ctx, code, verifier)
if err != nil {
return err
}
// Save token to DB
token.CharacterName = characterName
char.CharacterName = characterName
logger.Debug("Saving token to database for character %s", characterName)
if err := s.db.SaveTokenForCharacter(token); err != nil {
if err := s.db.SaveCharacter(char); err != nil {
return err
}
@@ -303,7 +303,7 @@ func (s *SSO) waitForCallback() (code, state string, err error) {
}
}
func (s *SSO) exchangeCodeForToken(ctx context.Context, code, verifier string) (*Token, error) {
func (s *SSO) exchangeCodeForToken(ctx context.Context, code, verifier string) (*Character, error) {
logger.Debug("Exchanging authorization code for access token")
form := url.Values{}
form.Set("grant_type", "authorization_code")
@@ -339,7 +339,7 @@ func (s *SSO) exchangeCodeForToken(ctx context.Context, code, verifier string) (
name, _ := parseTokenCharacter(tr.AccessToken)
logger.Info("Successfully exchanged code for token, character: %s", name)
return &Token{
return &Character{
CharacterName: name,
AccessToken: tr.AccessToken,
RefreshToken: tr.RefreshToken,
@@ -347,11 +347,11 @@ func (s *SSO) exchangeCodeForToken(ctx context.Context, code, verifier string) (
}, nil
}
func (s *SSO) refreshToken(ctx context.Context, token *Token) error {
logger.Debug("Refreshing token for character %s", token.CharacterName)
func (s *SSO) refreshToken(ctx context.Context, char *Character) error {
logger.Debug("Refreshing token for character %s", char.CharacterName)
form := url.Values{}
form.Set("grant_type", "refresh_token")
form.Set("refresh_token", token.RefreshToken)
form.Set("refresh_token", char.RefreshToken)
form.Set("client_id", s.clientID)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, issuerTokenURL, strings.NewReader(form.Encode()))
@@ -379,20 +379,20 @@ func (s *SSO) refreshToken(ctx context.Context, token *Token) error {
}
// Update token
token.AccessToken = tr.AccessToken
char.AccessToken = tr.AccessToken
if tr.RefreshToken != "" {
token.RefreshToken = tr.RefreshToken
char.RefreshToken = tr.RefreshToken
}
if tr.ExpiresIn > 0 {
token.ExpiresAt = time.Now().Add(time.Duration(tr.ExpiresIn-30) * time.Second)
char.ExpiresAt = time.Now().Add(time.Duration(tr.ExpiresIn-30) * time.Second)
}
logger.Debug("Saving refreshed token to database for character %s", token.CharacterName)
if err := s.db.SaveTokenForCharacter(token); err != nil {
logger.Debug("Saving refreshed token to database for character %s", char.CharacterName)
if err := s.db.SaveCharacter(char); err != nil {
return err
}
logger.Info("Token refreshed successfully for character %s", token.CharacterName)
logger.Info("Token refreshed successfully for character %s", char.CharacterName)
return nil
}