334 lines
8.4 KiB
Go
334 lines
8.4 KiB
Go
package lastfm
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"sort"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/andybalholm/cascadia"
|
|
"go.senan.xyz/gonic/db"
|
|
"go.senan.xyz/gonic/scrobble"
|
|
"golang.org/x/net/html"
|
|
)
|
|
|
|
var (
|
|
ErrLastFM = errors.New("last.fm error")
|
|
ErrNoUserSession = errors.New("no lastfm user session present")
|
|
)
|
|
|
|
type KeySecretFunc func() (apiKey, secret string, err error)
|
|
|
|
type Client struct {
|
|
httpClient *http.Client
|
|
keySecret KeySecretFunc
|
|
}
|
|
|
|
func NewClient(keySecret KeySecretFunc) *Client {
|
|
return NewClientCustom(http.DefaultClient, keySecret)
|
|
}
|
|
|
|
func NewClientCustom(httpClient *http.Client, keySecret KeySecretFunc) *Client {
|
|
return &Client{httpClient: httpClient, keySecret: keySecret}
|
|
}
|
|
|
|
const (
|
|
BaseURL = "https://ws.audioscrobbler.com/2.0/"
|
|
)
|
|
|
|
func (c *Client) ArtistGetInfo(artistName string) (Artist, error) {
|
|
apiKey, _, err := c.keySecret()
|
|
if err != nil {
|
|
return Artist{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "artist.getInfo")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("artist", artistName)
|
|
params.Add("autocorrect", "1")
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return Artist{}, fmt.Errorf("make request: %w", err)
|
|
}
|
|
|
|
return resp.Artist, nil
|
|
}
|
|
|
|
func (c *Client) AlbumGetInfo(artistName, albumName string) (Album, error) {
|
|
apiKey, _, err := c.keySecret()
|
|
if err != nil {
|
|
return Album{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "album.getInfo")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("artist", artistName)
|
|
params.Add("album", albumName)
|
|
params.Add("autocorrect", "1")
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return Album{}, fmt.Errorf("make request: %w", err)
|
|
}
|
|
|
|
return resp.Album, nil
|
|
}
|
|
|
|
func (c *Client) ArtistGetTopTracks(artistName string) (TopTracks, error) {
|
|
apiKey, _, err := c.keySecret()
|
|
if err != nil {
|
|
return TopTracks{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "artist.getTopTracks")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("artist", artistName)
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return TopTracks{}, fmt.Errorf("make request: %w", err)
|
|
}
|
|
return resp.TopTracks, nil
|
|
}
|
|
|
|
func (c *Client) TrackGetSimilarTracks(artistName, trackName string) (SimilarTracks, error) {
|
|
apiKey, _, err := c.keySecret()
|
|
if err != nil {
|
|
return SimilarTracks{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "track.getSimilar")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("track", trackName)
|
|
params.Add("artist", artistName)
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return SimilarTracks{}, fmt.Errorf("make request: %w", err)
|
|
}
|
|
return resp.SimilarTracks, nil
|
|
}
|
|
|
|
func (c *Client) ArtistGetSimilar(artistName string) (SimilarArtists, error) {
|
|
apiKey, _, err := c.keySecret()
|
|
if err != nil {
|
|
return SimilarArtists{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "artist.getSimilar")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("artist", artistName)
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return SimilarArtists{}, fmt.Errorf("making similar artists GET: %w", err)
|
|
}
|
|
return resp.SimilarArtists, nil
|
|
}
|
|
|
|
func (c *Client) UserGetLovedTracks(userName string) (LovedTracks, error) {
|
|
apiKey, _, err := c.keySecret()
|
|
if err != nil {
|
|
return LovedTracks{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "user.getLovedTracks")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("user", userName)
|
|
params.Add("limit", "1000") // TODO: paginate
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return LovedTracks{}, fmt.Errorf("making user get loved tracks GET: %w", err)
|
|
}
|
|
return resp.LovedTracks, nil
|
|
}
|
|
|
|
func (c *Client) GetSession(token string) (string, error) {
|
|
apiKey, secret, err := c.keySecret()
|
|
if err != nil {
|
|
return "", fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "auth.getSession")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("token", token)
|
|
params.Add("api_sig", GetParamSignature(params, secret))
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return "", fmt.Errorf("make request: %w", err)
|
|
}
|
|
return resp.Session.Key, nil
|
|
}
|
|
|
|
//nolint:gochecknoglobals
|
|
var artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
|
|
|
|
func (c *Client) StealArtistImage(artistURL string) (string, error) {
|
|
resp, err := c.httpClient.Get(artistURL) //nolint:gosec
|
|
if err != nil {
|
|
return "", fmt.Errorf("get artist url: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
node, err := html.Parse(resp.Body)
|
|
if err != nil {
|
|
return "", fmt.Errorf("parse html: %w", err)
|
|
}
|
|
|
|
n := cascadia.Query(node, artistOpenGraphQuery)
|
|
if n == nil {
|
|
return "", nil
|
|
}
|
|
|
|
var imageURL string
|
|
for _, attr := range n.Attr {
|
|
if attr.Key == "content" {
|
|
imageURL = attr.Val
|
|
break
|
|
}
|
|
}
|
|
|
|
return imageURL, nil
|
|
}
|
|
|
|
func (c *Client) IsUserAuthenticated(user db.User) bool {
|
|
return user.LastFMSession != ""
|
|
}
|
|
|
|
func (c *Client) Scrobble(user db.User, track scrobble.Track, stamp time.Time, submission bool) error {
|
|
apiKey, secret, err := c.keySecret()
|
|
if err != nil {
|
|
return fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
if !c.IsUserAuthenticated(user) {
|
|
return ErrNoUserSession
|
|
}
|
|
|
|
params := url.Values{}
|
|
if submission {
|
|
params.Add("method", "track.Scrobble")
|
|
params.Add("timestamp", strconv.Itoa(int(stamp.Unix()))) // last.fm wants the timestamp in seconds
|
|
} else {
|
|
params.Add("method", "track.updateNowPlaying")
|
|
}
|
|
|
|
params.Add("artist", track.Artist)
|
|
params.Add("track", track.Track)
|
|
params.Add("trackNumber", strconv.Itoa(int(track.TrackNumber)))
|
|
params.Add("album", track.Album)
|
|
params.Add("albumArtist", track.AlbumArtist)
|
|
params.Add("duration", strconv.Itoa(int(track.Duration.Seconds())))
|
|
|
|
if track.MusicBrainzID != "" {
|
|
params.Add("mbid", track.MusicBrainzID)
|
|
}
|
|
|
|
params.Add("sk", user.LastFMSession)
|
|
params.Add("api_key", apiKey)
|
|
params.Add("api_sig", GetParamSignature(params, secret))
|
|
|
|
_, err = c.makeRequest(http.MethodPost, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) LoveTrack(user *db.User, track *db.Track) error {
|
|
apiKey, secret, err := c.keySecret()
|
|
if err != nil {
|
|
return fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
if !c.IsUserAuthenticated(*user) {
|
|
return ErrNoUserSession
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "track.love")
|
|
params.Add("track", track.TagTitle)
|
|
params.Add("artist", track.TagTrackArtist)
|
|
params.Add("api_key", apiKey)
|
|
params.Add("sk", user.LastFMSession)
|
|
params.Add("api_sig", GetParamSignature(params, secret))
|
|
|
|
_, err = c.makeRequest(http.MethodPost, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) GetCurrentUser(user *db.User) (User, error) {
|
|
apiKey, secret, err := c.keySecret()
|
|
if err != nil {
|
|
return User{}, fmt.Errorf("get key and secret: %w", err)
|
|
}
|
|
if !c.IsUserAuthenticated(*user) {
|
|
return User{}, ErrNoUserSession
|
|
}
|
|
|
|
params := url.Values{}
|
|
params.Add("method", "user.getInfo")
|
|
params.Add("api_key", apiKey)
|
|
params.Add("sk", user.LastFMSession)
|
|
params.Add("api_sig", GetParamSignature(params, secret))
|
|
|
|
resp, err := c.makeRequest(http.MethodGet, params)
|
|
if err != nil {
|
|
return User{}, fmt.Errorf("make request: %w", err)
|
|
}
|
|
return resp.User, nil
|
|
}
|
|
|
|
func (c *Client) makeRequest(method string, params url.Values) (LastFM, error) {
|
|
req, err := http.NewRequest(method, BaseURL, nil)
|
|
if err != nil {
|
|
return LastFM{}, fmt.Errorf("create request: %w", err)
|
|
}
|
|
|
|
req.URL.RawQuery = params.Encode()
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return LastFM{}, fmt.Errorf("get: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var lastfm LastFM
|
|
if err := xml.NewDecoder(resp.Body).Decode(&lastfm); err != nil {
|
|
return LastFM{}, fmt.Errorf("decoding: %w", err)
|
|
}
|
|
|
|
if lastfm.Error.Code != 0 {
|
|
return LastFM{}, fmt.Errorf("%v: %w", lastfm.Error.Value, ErrLastFM)
|
|
}
|
|
return lastfm, nil
|
|
}
|
|
|
|
func GetParamSignature(params url.Values, secret string) string {
|
|
// the parameters must be in order before hashing
|
|
paramKeys := make([]string, 0, len(params))
|
|
for k := range params {
|
|
paramKeys = append(paramKeys, k)
|
|
}
|
|
sort.Strings(paramKeys)
|
|
toHash := ""
|
|
for _, k := range paramKeys {
|
|
toHash += k
|
|
toHash += params[k][0]
|
|
}
|
|
toHash += secret
|
|
hash := md5.Sum([]byte(toHash))
|
|
return hex.EncodeToString(hash[:])
|
|
}
|