156 lines
3.8 KiB
Go
156 lines
3.8 KiB
Go
package music
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"hugo-medialog/utils"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
spotifyAPIBaseURL = "https://api.spotify.com/v1/search"
|
|
spotifyTokenURL = "https://accounts.spotify.com/api/token"
|
|
)
|
|
|
|
func getSpotifyToken() (string, error) {
|
|
apiKey := os.Getenv("SPOTIFY_API_KEY")
|
|
apiSecret := os.Getenv("SPOTIFY_SECRET_ID")
|
|
|
|
// Prepare the request body
|
|
data := url.Values{}
|
|
data.Set("grant_type", "client_credentials")
|
|
|
|
// Prepare the request
|
|
req, err := http.NewRequest("POST", spotifyTokenURL, strings.NewReader(data.Encode()))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Add the headers
|
|
req.SetBasicAuth(apiKey, apiSecret)
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
|
|
// Send the request
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
// Read the response
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Parse the response
|
|
var result map[string]interface{}
|
|
if err := json.Unmarshal(body, &result); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Extract the access token
|
|
accessToken, ok := result["access_token"].(string)
|
|
if !ok {
|
|
return "", fmt.Errorf("could not retrieve access token")
|
|
}
|
|
|
|
return accessToken, nil
|
|
}
|
|
|
|
func SearchAlbumByTitle(title string, album *Album) error {
|
|
// Obtain the access token
|
|
accessToken, err := getSpotifyToken()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Search URL
|
|
titleEsc := url.QueryEscape(fmt.Sprintf("%s", title))
|
|
url := fmt.Sprintf("%s?q=%s&type=track&limit=1", spotifyAPIBaseURL, titleEsc)
|
|
|
|
// Prepare the request and add the auth header
|
|
req, _ := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Authorization", "Bearer "+accessToken)
|
|
|
|
// Send the request
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Decode the response
|
|
var result map[string]interface{}
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return err
|
|
}
|
|
|
|
tracks := result["tracks"].(map[string]interface{})["items"].([]interface{})
|
|
track := tracks[0].(map[string]interface{})
|
|
albumData := track["album"].(map[string]interface{})
|
|
|
|
album.Artist = track["artists"].([]interface{})[0].(map[string]interface{})["name"].(string)
|
|
album.ID = albumData["id"].(string)
|
|
album.Album = albumData["name"].(string)
|
|
album.Date = albumData["release_date"].(string)
|
|
album.Year, _ = strconv.Atoi(strings.Split(album.Date, "-")[0])
|
|
album.Subtitle = strconv.Itoa(album.Year)
|
|
album.Tracks = int(albumData["total_tracks"].(float64)) // Spotify envía números como float64
|
|
album.Link = albumData["href"].(string)
|
|
images := albumData["images"].([]interface{})
|
|
if len(images) > 0 {
|
|
firstImage := images[0].(map[string]interface{})
|
|
album.Image = firstImage["url"].(string)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func DownloadImage(url, slug string) error {
|
|
imageDir := filepath.Join(os.Getenv("MARKDOWN_OUTPUT_MUSIC_DIR"), os.Getenv("IMAGES_OUTPUT_DIR"))
|
|
if err := utils.CreateDirIfNotExists(imageDir); err != nil {
|
|
return err
|
|
}
|
|
filename := fmt.Sprintf("%s.jpg", slug)
|
|
filePath := filepath.Join(imageDir, filename)
|
|
|
|
resp, err := http.Get(url)
|
|
if err != nil {
|
|
return fmt.Errorf("error downloading image: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("non-200 response while downloading image: %d", resp.StatusCode)
|
|
}
|
|
|
|
file, err := os.Create(filePath)
|
|
if err != nil {
|
|
return fmt.Errorf("error creating image file: %w", err)
|
|
}
|
|
defer file.Close()
|
|
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return fmt.Errorf("error reading image data: %w", err)
|
|
}
|
|
|
|
_, err = file.Write(body)
|
|
if err != nil {
|
|
return fmt.Errorf("error writing image data: %w", err)
|
|
}
|
|
|
|
fmt.Printf(" - Image saved successfully at: %s\n", filePath)
|
|
return nil
|
|
}
|