See Release Notes

listenbrainz.go

@@ -55,15 +55,7 @@ type Playlists struct {
 		Data struct {
 			Date       time.Time `json:"date"`
 			Identifier string    `json:"identifier"`
-			Extension  struct {
-				HTTPSMusicbrainzOrgDocJspfPlaylist struct {
-					AdditionalMetadata struct {
-						AlgorithmMetadata struct {
-							SourcePatch string `json:"source_patch"`
-						} `json:"algorithm_metadata"`
-					} `json:"additional_metadata"`
-				} `json:"https://musicbrainz.org/doc/jspf#playlist"`
-			} `json:"extension"`
+			Title      string    `json:"title"`
 		} `json:"playlist"`
 	} `json:"playlists"`
 }
@@ -78,7 +70,7 @@ type Exploration struct {
 		Tracks     []struct {
 			Album      string `json:"album"`
 			Creator    string `json:"creator"`
-			Identifier string `json:"identifier"`
+			Identifier []string `json:"identifier"`
 			Title      string `json:"title"`
 		} `json:"track"`
 	} `json:"playlist"`
@@ -96,10 +88,7 @@ func getReccs(cfg Listenbrainz) []string {
 
 	body := lbRequest(fmt.Sprintf("cf/recommendation/user/%s/recording", cfg.User))
 
-	err := json.Unmarshal(body, &reccs)
-	if err != nil {
-		log.Fatalf("Failed to unmarshal body: %s", err.Error())
-	}
+	json.Unmarshal(body, &reccs)
 
 	for _, rec := range reccs.Payload.Mbids {
 		mbids = append(mbids, rec.RecordingMbid)
@@ -120,9 +109,8 @@ func getTracks(mbids []string) Track {
 
 	err := json.Unmarshal(body, &recordings)
 	if err != nil {
-		log.Fatalf("Failed to unmarshal body: %s", err.Error())
+		log.Fatalf("failed to unmarshal body: %s", err.Error())
 	}
-
 	for _, recording := range recordings {
 		tracks = append(tracks, struct {
 			Album  string
@@ -147,21 +135,20 @@ func getWeeklyExploration(cfg Listenbrainz) (string, error) {
 
 	err := json.Unmarshal(body, &playlists)
 	if err != nil {
-		log.Fatalf("Failed to unmarshal body: %s", err.Error())
+		log.Fatalf("failed to unmarshal body: %s", err.Error())
 	}
 
 	for _, playlist := range playlists.Playlist {
 
 		_, currentWeek := time.Now().Local().ISOWeek()
 		_, creationWeek := playlist.Data.Date.ISOWeek()
 
-		if playlist.Data.Extension.HTTPSMusicbrainzOrgDocJspfPlaylist.AdditionalMetadata.AlgorithmMetadata.SourcePatch == "weekly-exploration" && currentWeek == creationWeek {
-			exploration := playlist.Data.Identifier
-			id := strings.Split(exploration, "/")
+		if strings.Contains(playlist.Data.Title, "Weekly Exploration") && currentWeek == creationWeek {
+			id := strings.Split(playlist.Data.Identifier, "/")
 			return id[len(id)-1], nil
 		}
 	}
-	return "", fmt.Errorf("failed to get exploration playlist")
+	return "", fmt.Errorf("failed to get new exploration playlist, check if ListenBrainz has generated one")
 }
 
 func parseWeeklyExploration(identifier string) Track {
@@ -174,7 +161,7 @@ func parseWeeklyExploration(identifier string) Track {
 
 	err := json.Unmarshal(body, &exploration)
 	if err != nil {
-		log.Fatalf("Failed to unmarshal body: %s", err.Error())
+		log.Fatalf("failed to unmarshal body: %s", err.Error())
 	}
 
 	for _, track := range exploration.Playlist.Tracks {
@@ -199,17 +186,17 @@ func lbRequest(path string) []byte { // Handle ListenBrainz API requests
 	reqString := fmt.Sprintf("https://api.listenbrainz.org/1/%s", path)
 	req, err := http.NewRequest(http.MethodGet, reqString, nil)
 	if err != nil {
-		log.Fatalf("Failed to initialize request: %s", err.Error())
+		log.Fatalf("Failed to initialize request: %v", err)
 	}
 
 	resp, err := client.Do(req)
 	if err != nil {
-		log.Fatalf("Failed to make request: %s", err.Error())
+		log.Fatalf("Failed to make request: %v", err)
 	}
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		log.Fatalf("Failed to read response body: %s", err.Error())
+		log.Fatalf("Failed to read response body: %v", err)
 	}
 	return body
 }

main.go

@@ -4,8 +4,9 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"time"
 	"path"
+	"time"
+
 	"github.com/ilyakaznacheev/cleanenv"
 )
 
@@ -39,21 +40,21 @@ type Listenbrainz struct {
 func readEnv() Config {
 	var cfg Config
 
-	err := cleanenv.ReadConfig("./local.env", &cfg)
+	err := cleanenv.ReadConfig("./local.env",&cfg)
 	if err != nil {
 		panic(err)
 	}
 	return cfg
 }
 
-func cleanUp(cfg Youtube, songs []string) { // Remove downloaded webms
+func cleanUp(cfg Config, songs []string) { // Remove downloaded webms
 
 	for _, song := range songs {
-		path := fmt.Sprintf("%s%s.webm", cfg.DownloadDir,song)
+		path := fmt.Sprintf("%s%s.webm", cfg.Youtube.DownloadDir,song)
 
 		err := os.Remove(path)
 		if err != nil {
-			log.Printf("Failed to remove file: %v", err.Error())
+			log.Printf("failed to remove file: %v", err)
 		}
 	}
 
@@ -66,10 +67,7 @@ func deleteSongs(cfg Youtube) { // Deletes all songs if persist equals false
 	}
 	for _, entry := range entries {
 		if !(entry.IsDir()) {
-			err := os.Remove(path.Join(cfg.DownloadDir, entry.Name()))
-			if err != nil {
-				log.Printf("failed to delete file: %v", err)
-			}
+			os.Remove(path.Join(cfg.DownloadDir, entry.Name()))
 		}
 	}
 }
@@ -78,46 +76,41 @@ func deleteSongs(cfg Youtube) { // Deletes all songs if persist equals false
 func main() {
 	cfg := readEnv()
 	cfg.Subsonic = genToken(cfg.Subsonic)
-	
+
 	if !(cfg.Persist) {
+
 		deleteSongs(cfg.Youtube)
 		playlists, err := getDiscoveryPlaylist(cfg.Subsonic)
-
 		if err != nil {
 			log.Fatal(err.Error())
 		}
 		delPlaylists(playlists, cfg.Subsonic)
 	}
-
 
-	var tracks Track
+	 var tracks Track
 
 	if cfg.Listenbrainz.Discovery == "playlist" {
 		id, err := getWeeklyExploration(cfg.Listenbrainz)
 		if err != nil {
 			log.Fatal(err.Error())
 		}
 		tracks = parseWeeklyExploration(id)
-	} else { // use recommendations from API
+	} else {
 		mbids := getReccs(cfg.Listenbrainz)
 		tracks = getTracks(mbids)
 	}
 	var files []string
 	var songs []string
 
 	for _, track := range tracks {
-		song, file := downloadAndFormat(track.Title, track.Artist, track.Album, cfg.Youtube)
+		song, file := gatherVideo(cfg.Youtube, track.Title, track.Artist, track.Album)
 		files = append(files, file)
 		songs = append(songs, song)
 	}
 
-	cleanUp(cfg.Youtube, files)
+	cleanUp(cfg, files)
 	scan(cfg.Subsonic)
-	log.Printf("Sleeping for %v minutes, to allow scan to complete..", cfg.Sleep)
+	log.Printf("sleeping for %v minutes, to allow scan to complete..", cfg.Sleep)
 	time.Sleep(time.Duration(cfg.Sleep) * time.Minute)
-	err := createPlaylist(cfg.Subsonic, songs, cfg.Persist)
-
-	if err != nil {
-		log.Fatalf("failed to create playlist: %s", err.Error())
-	}
+	createPlaylist(cfg.Subsonic, songs, cfg.Persist)
 }

subsonic.go

@@ -44,13 +44,15 @@ type Response struct {
 	} `json:"subsonic-response"`
 }
 
+
 func genToken(cfg Subsonic) Subsonic {
+
 	var salt = make([]byte, 6)
 
 
 	_, err := rand.Read(salt[:])
 	if err != nil {
-		log.Fatalf("failed to read salt: %s", err.Error())
+		log.Fatalf("failed to read salt: %v", err)
 	}
 
 	saltStr := base64.StdEncoding.EncodeToString(salt)
@@ -65,6 +67,7 @@ func genToken(cfg Subsonic) Subsonic {
 }
 
 func searchTrack(cfg Subsonic, track string) (string, error) {
+
     cleanedTrack := url.QueryEscape(track)
 
     reqParam := fmt.Sprintf("search3?query=%s&f=json", cleanedTrack)
@@ -83,48 +86,40 @@ func searchTrack(cfg Subsonic, track string) (string, error) {
     }
     return resp.SubsonicResponse.SearchResult3.Song[0].ID, nil
 }
+func createPlaylist(cfg Subsonic, tracks []string, persist bool) {
 
-func createPlaylist(cfg Subsonic, tracks []string, persist bool) error {
-	var trackIDs strings.Builder
+	var trackIDs string
 	var reqParam string
 
 	for _, track := range tracks { // Get track IDs from app and format them
 		ID, err := searchTrack(cfg, track)
-		if err != nil {
-            return err
-        }
-        if ID == "" { // If no ID is found, ignore track
-			log.Printf("can't find ID for %s", track)
-            continue
-        }
-        trackIDs.WriteString("&songId=" + ID)
+		if ID  == "" || err != nil  { // if ID is empty, skip song
+			continue
+		}
+		trackIDs += "&songId="+ID
 	}
 	if persist {
 		year, week := time.Now().ISOWeek()
-		reqParam = fmt.Sprintf("createPlaylist?name=Discover-Weekly-%v-Week%v&%s", year, week, trackIDs.String())
+		reqParam = fmt.Sprintf("createPlaylist?name=Discover-Weekly-%v-Week%v&%s", year, week, trackIDs)
 	} else {
-		// TODO: Delete/update playlist
-		reqParam = fmt.Sprintf("createPlaylist?name=Discover-Weekly&%s", trackIDs.String())
+		reqParam = fmt.Sprintf("createPlaylist?name=Discover-Weekly&%s", trackIDs)
 	}
-
-	_, err := subsonicRequest(reqParam, cfg)
-
-	return err
+	subsonicRequest(reqParam, cfg)
 }
 
 func scan(cfg Subsonic) {
 
 	reqParam := "startScan?f=json"
-	_, err := subsonicRequest(reqParam, cfg)
-	if err != nil {
-		log.Println("failed to initialize music folder scan")
-	}
+
+	subsonicRequest(reqParam, cfg)
 }
 
 func getDiscoveryPlaylist(cfg Subsonic) ([]string, error) {
-	reqParam := "getPlaylists?f=json"
+
 	var resp Response
 	var playlists []string
+	reqParam := "getPlaylists?f=json"
+
 	body, err := subsonicRequest(reqParam, cfg)
 	if err != nil {
 		return nil, err
@@ -147,14 +142,12 @@ func delPlaylists(playlists []string, cfg Subsonic) {
 
 	for _, id := range playlists {
 		reqParam := fmt.Sprintf("deletePlaylist?id=%s", id)
-		_, err := subsonicRequest(reqParam, cfg)
-		if err != nil {
-			log.Println("failed to delete playlist")
-		}
+		subsonicRequest(reqParam, cfg)
 	}
 }
 
 func subsonicRequest(reqParams string, cfg Subsonic) ([]byte, error) {
+
 	reqURL := fmt.Sprintf("%s/rest/%s&u=%s&t=%s&s=%s&v=%s&c=%s", cfg.URL, reqParams, cfg.User, cfg.Token, cfg.Salt, cfg.Version, cfg.ID)
 
 	req, err := http.NewRequest(http.MethodGet, reqURL, nil)