Merge pull request #3 from fatfingers23/bugfix/SpotifySync

Bugfix: Small spotify bugfix

.gitignore

···
 **/piper.db
 jwk*.json
 **.bak
+.idea

db/db.go

···
 	user := &models.User{}
 
 	err := db.QueryRow(`
-	SELECT id, username, email, spotify_id, access_token, refresh_token, token_expiry, lastfm_username, created_at, updated_at
+	SELECT id, username, email, atproto_did, spotify_id, access_token, refresh_token, token_expiry, lastfm_username, created_at, updated_at
 	FROM users WHERE id = ?`, ID).Scan(
-		&user.ID, &user.Username, &user.Email, &user.SpotifyID,
+		&user.ID, &user.Username, &user.Email, &user.ATProtoDID, &user.SpotifyID,
 		&user.AccessToken, &user.RefreshToken, &user.TokenExpiry,
 		&user.LastFMUsername,
 		&user.CreatedAt, &user.UpdatedAt)

service/lastfm/lastfm.go

···
 		return nil
 	}
 
-	uts, err := strconv.ParseInt(lastNonNowPlaying.Date.UTS, 10, 64)
-	if err != nil {
-		log.Printf("error parsing timestamp '%s' for track %s - %s: %v",
-			lastNonNowPlaying.Date.UTS, lastNonNowPlaying.Artist.Text, lastNonNowPlaying.Name, err)
-	}
-	latestTrackTime := time.Unix(uts, 0)
+	latestTrackTime := lastNonNowPlaying.Date
 
 	// print both
 	fmt.Printf("latestTrackTime: %s\n", latestTrackTime)
 	fmt.Printf("lastKnownTimestamp: %s\n", lastKnownTimestamp)
 
-	if lastKnownTimestamp != nil && lastKnownTimestamp.Equal(latestTrackTime) {
+	if lastKnownTimestamp != nil && lastKnownTimestamp.Equal(latestTrackTime.Time) {
 		log.Printf("no new tracks to process for user %s.", username)
 		return nil
 	}
 
 	for _, track := range tracks {
-		if track.Date == nil || track.Date.UTS == "" {
+		if track.Date == nil {
 			log.Printf("skipping track without timestamp for %s: %s - %s", username, track.Artist.Text, track.Name)
 			continue
 		}
 
-		uts, err := strconv.ParseInt(track.Date.UTS, 10, 64)
-		if err != nil {
-			log.Printf("error parsing timestamp '%s' for track %s - %s: %v", track.Date.UTS, track.Artist.Text, track.Name, err)
-			continue
-		}
-		trackTime := time.Unix(uts, 0)
-
+		trackTime := track.Date.Time
 		// before or at last known
 		if lastKnownTimestamp != nil && (trackTime.Before(*lastKnownTimestamp) || trackTime.Equal(*lastKnownTimestamp)) {
 			if processedCount == 0 {

service/lastfm/model.go

···
 package lastfm
 
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+)
+
 // Structs to represent the Last.fm API response for user.getrecenttracks
 type RecentTracksResponse struct {
 	RecentTracks RecentTracks `json:"recenttracks"`
···
 	Name       string     `json:"name"`
 	URL        string     `json:"url"`
 	Date       *TrackDate `json:"date,omitempty"` // Use pointer for optional fields
-	Attr       *struct {  // Custom handling for @attr.nowplaying
+	Attr       *struct { // Custom handling for @attr.nowplaying
 		NowPlaying string `json:"nowplaying"` // Field name corrected to match struct tag
 	} `json:"@attr,omitempty"` // This captures the @attr object within the track
 }
···
 	Text string `json:"#text"` // Album name
 }
 
-type TrackDate struct {
+// ApiTrackDate This is the real structure returned from lastFM.
+// Represents a date associated with a track, including both a Unix timestamp and a human-readable string.
+// UTS is a Unix timestamp stored as a string.
+// Text contains the human-readable date string.
+type ApiTrackDate struct {
 	UTS  string `json:"uts"`   // Unix timestamp string
 	Text string `json:"#text"` // Human-readable date string
+}
+
+// TrackDate This is the struct we use to represent a date associated with a track.
+// It is a wrapper around time.Time that implements json.Unmarshaler.
+type TrackDate struct {
+	time.Time
+}
+
+// UnmarshalJSON Implements json.Unmarshaler.
+// Parses the UTS field from the API response and converts it to a time.Time.
+// The time.Time is stored in the Time field.
+// The Text field is ignored since it can be parsed from the Time field if needed.
+func (t *TrackDate) UnmarshalJSON(b []byte) (err error) {
+	var apiTrackDate ApiTrackDate
+	if err := json.Unmarshal(b, &apiTrackDate); err != nil {
+		return err
+	}
+	uts, err := strconv.ParseInt(apiTrackDate.UTS, 10, 64)
+	if err != nil {
+		return err
+	}
+	date := time.Unix(uts, 0).UTC()
+	t.Time = date
+	return
 }
 
 type TrackXMLAttr struct {

service/spotify/spotify.go

···
 		return nil, fmt.Errorf("failed to unmarshal spotify response: %w", err)
 	}
 
-	body, ioErr := io.ReadAll(resp.Body)
-	if ioErr != nil {
-		return nil, ioErr
-	}
-
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return nil, err
-	}
-
 	var artists []models.Artist
 	for _, artist := range response.Item.Artists {
 		artists = append(artists, models.Artist{
···
 		ServiceBaseUrl: "open.spotify.com",
 		ISRC:           response.Item.ExternalIDs.ISRC,
 		HasStamped:     false,
-		Timestamp:      time.Now(),
+		Timestamp:      time.Now().UTC(),
 	}
 
 	return track, nil