On time (moved to .utc)

db/apikey/apikey.go

···
 	}
 	apiKeyID := base64.URLEncoding.EncodeToString(b)
 
-	now := time.Now()
+	now := time.Now().UTC()
 	expiresAt := now.AddDate(0, 0, validityDays) // Default to validityDays days validity
 
 	apiKey := &ApiKey{
···
 
 	if exists {
 		// Check if API key is expired
-		if time.Now().After(apiKey.ExpiresAt) {
+		if time.Now().UTC().After(apiKey.ExpiresAt) {
 			am.DeleteApiKey(apiKeyID)
 			return nil, false
 		}
···
 		return nil, false
 	}
 
-	if time.Now().After(apiKey.ExpiresAt) {
+	if time.Now().UTC().After(apiKey.ExpiresAt) {
 		am.DeleteApiKey(apiKeyID)
 		return nil, false
 	}

db/atproto.go

···
 		did).Scan(&user.ID, &user.ATProtoDID, &user.CreatedAt, &user.UpdatedAt)
 
 	if err == sql.ErrNoRows {
-		now := time.Now()
+		now := time.Now().UTC()
 		// create user!
 		result, insertErr := db.Exec(`
 			INSERT INTO users (atproto_did, created_at, updated_at)
···
 // create or update the current user's ATproto session data.
 func (db *DB) SaveATprotoSession(tokenResp *oauth.TokenResponse, authserverIss string, dpopPrivateJWK jwk.Key, pdsUrl string) error {
 	fmt.Printf("Saving session with PDS url %s", pdsUrl)
-	expiryTime := time.Now().Add(time.Second * time.Duration(tokenResp.ExpiresIn))
-	now := time.Now()
+	expiryTime := time.Now().UTC().Add(time.Second * time.Duration(tokenResp.ExpiresIn))
+	now := time.Now().UTC()
 
 	dpopPrivateJWKBytes, err := json.Marshal(dpopPrivateJWK)
 	if err != nil {
···
 	}
 
 	// printout the session details
-	fmt.Printf("Session details from DB: %+v\n", oauthSession)
+	fmt.Printf("Getting session details for the did: %+v\n", oauthSession.DID)
 
 	// if token is expired, refresh it
-	if time.Now().After(oauthSession.TokenExpiry) {
+	if time.Now().UTC().After(oauthSession.TokenExpiry) {
 
 		resp, err := oauthClient.RefreshTokenRequest(ctx, oauthSession.RefreshToken, authserverIss, oauthSession.DpopAuthServerNonce, privateJwk)
 		if err != nil {
···
 			DpopPdsNonce:        oauthSession.DpopPdsNonce,
 			DpopAuthServerNonce: resp.DpopAuthserverNonce,
 			DpopPrivateJWK:      privateJwk,
-			TokenExpiry:         time.Now().Add(time.Duration(resp.ExpiresIn) * time.Second),
+			TokenExpiry:         time.Now().UTC().Add(time.Duration(resp.ExpiresIn) * time.Second),
 		}
 
 	}

db/db.go

···
 
 // create user without spotify id
 func (db *DB) CreateUser(user *models.User) (int64, error) {
-	now := time.Now()
+	now := time.Now().UTC()
 
 	result, err := db.Exec(`
 	INSERT INTO users (username, email, created_at, updated_at)
···
 
 // add spotify session to user, returning the updated user
 func (db *DB) AddSpotifySession(userID int64, username, email, spotifyId, accessToken, refreshToken string, tokenExpiry time.Time) (*models.User, error) {
-	now := time.Now()
+	now := time.Now().UTC()
 
 	_, err := db.Exec(`
 	UPDATE users SET username = ?, email = ?, spotify_id = ?, access_token = ?, refresh_token = ?, token_expiry = ?, created_at = ?, updated_at = ?
···
 }
 
 func (db *DB) UpdateUserToken(userID int64, accessToken, refreshToken string, expiry time.Time) error {
-	now := time.Now()
+	now := time.Now().UTC()
 
 	_, err := db.Exec(`
 	UPDATE users
···
     SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at
     FROM users
     WHERE refresh_token IS NOT NULL AND token_expiry < ?
-    ORDER BY id`, time.Now())
+    ORDER BY id`, time.Now().UTC())
 
 	if err != nil {
 		return nil, err
···
     SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, created_at, updated_at
     FROM users
     WHERE access_token IS NOT NULL AND token_expiry > ?
-    ORDER BY id`, time.Now())
+    ORDER BY id`, time.Now().UTC())
 
 	if err != nil {
 		return nil, err

service/apikey/apikey.go

···
 			}
 			keyName := reqBody.Name
 			if keyName == "" {
-				keyName = fmt.Sprintf("API Key (via API) - %s", time.Now().Format(time.RFC3339))
+				keyName = fmt.Sprintf("API Key (via API) - %s", time.Now().UTC().Format(time.RFC3339))
 			}
 			validityDays := 30 // Default, could be made configurable via request body
 
···
 
 		keyName := r.FormValue("name")
 		if keyName == "" {
-			keyName = fmt.Sprintf("API Key - %s", time.Now().Format(time.RFC3339))
+			keyName = fmt.Sprintf("API Key - %s", time.Now().UTC().Format(time.RFC3339))
 		}
 		validityDays := 1024
 

service/lastfm/lastfm.go

···
 	}
 
 	// printout the session details
-	fmt.Printf("Session details: %+v\n", sess)
+	fmt.Printf("Submitting track for the did: %+v\n", sess.DID)
 
 	// horrible no good very bad for now
 	artistArr := []string{}

service/musicbrainz/musicbrainz.go

···
 	params.Artist, _ = s.cleaner.CleanArtist(params.Artist)
 
 	cacheKey := generateCacheKey(params)
-	now := time.Now()
+	now := time.Now().UTC()
 
 	// --- Check Cache (Read Lock) ---
 	s.cacheMutex.RLock()
···
 	s.cacheMutex.Lock()
 	s.searchCache[cacheKey] = cacheEntry{
 		recordings: result.Recordings,
-		expiresAt:  time.Now().Add(s.cacheTTL),
+		expiresAt:  time.Now().UTC().Add(s.cacheTTL),
 	}
 	s.cacheMutex.Unlock()
 	log.Printf("Cached MusicBrainz search result for key=%s, TTL=%s", cacheKey, s.cacheTTL)

service/spotify/spotify.go

···
 		return 0, err
 	}
 
-	tokenExpiryTime := time.Now().Add(1 * time.Hour) // Spotify tokens last ~1 hour
+	tokenExpiryTime := time.Now().UTC().Add(1 * time.Hour) // Spotify tokens last ~1 hour
 
 	// We don't intend users to log in via spotify!
 	if user == nil {
···
 	count := 0
 	for _, user := range users {
 		// load users with valid tokens
-		if user.AccessToken != nil && user.TokenExpiry.After(time.Now()) {
+		if user.AccessToken != nil && user.TokenExpiry.After(time.Now().UTC()) {
 			s.userTokens[user.ID] = *user.AccessToken
 			count++
 		}
···
 		delete(s.userTokens, userID)
 		s.mu.Unlock()
 		// Also clear the bad refresh token from the DB
-		updateErr := s.DB.UpdateUserToken(userID, "", "", time.Now()) // Clear tokens
+		updateErr := s.DB.UpdateUserToken(userID, "", "", time.Now().UTC()) // Clear tokens
 		if updateErr != nil {
 			log.Printf("Failed to clear bad refresh token for user %d: %v", userID, updateErr)
 		}
···
 		return "", fmt.Errorf("failed to decode refresh response: %w", err)
 	}
 
-	newExpiry := time.Now().Add(time.Duration(tokenResponse.ExpiresIn) * time.Second)
+	newExpiry := time.Now().UTC().Add(time.Duration(tokenResponse.ExpiresIn) * time.Second)
 	newRefreshToken := *user.RefreshToken // Default to old one
 	if tokenResponse.RefreshToken != "" {
 		newRefreshToken = tokenResponse.RefreshToken // Use new one if provided

session/session.go

···
 	rand.Read(b)
 	sessionID := base64.URLEncoding.EncodeToString(b)
 
-	now := time.Now()
+	now := time.Now().UTC()
 	expiresAt := now.Add(24 * time.Hour) // 24-hour session
 
 	session := &Session{
···
 
 	if exists {
 		// Check if session is expired
-		if time.Now().After(session.ExpiresAt) {
+		if time.Now().UTC().After(session.ExpiresAt) {
 			sm.DeleteSession(sessionID)
 			return nil, false
 		}
···
 			return nil, false
 		}
 
-		if time.Now().After(session.ExpiresAt) {
+		if time.Now().UTC().After(session.ExpiresAt) {
 			sm.DeleteSession(sessionID)
 			return nil, false
 		}