go mod init spotifydownloaderbot

go get -u github.com/spf13/cobra@latest

go get github.com/kkdai/youtube/v2

go get github.com/zmb3/spotify/v2

go get golang.org/x/oauth2

go get -u github.com/bogem/id3v2/v2

go get -u github.com/buger/jsonparser

go get -u github.com/inancgumus/screen

package src

const (
	AppName             = "Spotify Downloader"
	AppUse              = "spotifydownloaderbot"
	AppVersion          = "0.0.1"
	AppShortDescription = AppName + " is a awesome music downloader"
	AppLongDescription  = AppName + " is a awesome music downloader"
)

const (
	SpotifyClientID = "YOUR SPOTIFY CLIENT ID" 
	SpotifyClientSecret = "YOUR SPOTIFY CLIENT SECRET"
)

package src

  

import (

"context"

"github.com/zmb3/spotify/v2"

spotifyauth "github.com/zmb3/spotify/v2/auth"

"golang.org/x/oauth2/clientcredentials"

"log"

)

  

// UserData is a struct to hold all variables

type UserData struct {

	UserClient *spotify.Client
	
	TrackList []spotify.FullTrack
	
	SimpleTrackList []spotify.SimpleTrack
	
	YoutubeIDList []string

}

  

// InitAuth starts Authentication

func InitAuth() *spotify.Client {

ctx := context.Background()

config := &clientcredentials.Config{

	ClientID: SpotifyClientID,
	
	ClientSecret: SpotifyClientSecret,
	
	TokenURL: spotifyauth.TokenURL,

}

token, err := config.Token(context.Background())

if err != nil {

log.Fatalf("couldn't get token: %v", err)

}

  

httpClient := spotifyauth.New().Client(ctx, token)

client := spotify.New(httpClient)

  

return client

}

package src

import (
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/buger/jsonparser"
)

var httpClient = &http.Client{}
var durationMatchThreshold = 5

type SearchResult struct {
	Title, Uploader, URL, Duration, ID string
	Live                               bool
	SourceName                         string
	Extra                              []string
}

func convertStringDurationToSeconds(durationStr string) int {
	splitEntities := strings.Split(durationStr, ":")
	if len(splitEntities) == 1 {
		seconds, _ := strconv.Atoi(splitEntities[0])
		return seconds
	} else if len(splitEntities) == 2 {
		seconds, _ := strconv.Atoi(splitEntities[1])
		minutes, _ := strconv.Atoi(splitEntities[0])
		return (minutes * 60) + seconds
	} else if len(splitEntities) == 3 {
		seconds, _ := strconv.Atoi(splitEntities[2])
		minutes, _ := strconv.Atoi(splitEntities[1])
		hours, _ := strconv.Atoi(splitEntities[0])
		return ((hours * 60) * 60) + (minutes * 60) + seconds
	} else {
		return 0
	}
}

// GetYoutubeId takes the query as string and returns the search results video ID's
func GetYoutubeId(searchQuery string, songDurationInSeconds int) (string, error) {
	searchResults, err := ytSearch(searchQuery, 10)
	if err != nil {
		return "", err
	}
	if len(searchResults) == 0 {
		errorMessage := fmt.Sprintf("no songs found for %s", searchQuery)
		return "", errors.New(errorMessage)
	}
	// Try for the closest match timestamp wise
	for _, result := range searchResults {
		allowedDurationRangeStart := songDurationInSeconds - durationMatchThreshold
		allowedDurationRangeEnd := songDurationInSeconds + durationMatchThreshold
		resultSongDuration := convertStringDurationToSeconds(result.Duration)
		if resultSongDuration >= allowedDurationRangeStart && resultSongDuration <= allowedDurationRangeEnd {
			return result.ID, nil
		}
	}
	// Else return the first result if nothing is found
	return searchResults[0].ID, nil
}

func getContent(data []byte, index int) []byte {
	id := fmt.Sprintf("[%d]", index)
	contents, _, _, _ := jsonparser.Get(data, "contents", "twoColumnSearchResultsRenderer", "primaryContents", "sectionListRenderer", "contents", id, "itemSectionRenderer", "contents")
	return contents
}

// shamelessly ripped off from https://github.com/Pauloo27/tuner/blob/11dd4c37862c1c26521a01c8345c22c29ab12749/search/youtube.go#L27

func ytSearch(searchTerm string, limit int) (results []*SearchResult, err error) {
	ytSearchUrl := fmt.Sprintf(
		"https://www.youtube.com/results?search_query=%s", url.QueryEscape(searchTerm),
	)

	req, err := http.NewRequest("GET", ytSearchUrl, nil)
	if err != nil {
		return nil, errors.New("cannot get youtube page")
	}
	req.Header.Add("Accept-Language", "en")
	res, err := httpClient.Do(req)
	if err != nil {
		return nil, errors.New("cannot get youtube page")
	}

	defer func(Body io.ReadCloser) {
		_ = Body.Close()
	}(res.Body)

	if res.StatusCode != 200 {
		return nil, errors.New("failed to make a request to youtube")
	}

	buffer, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, errors.New("cannot read response from youtube")
	}

	body := string(buffer)
	splitScript := strings.Split(body, `window["ytInitialData"] = `)
	if len(splitScript) != 2 {
		splitScript = strings.Split(body, `var ytInitialData = `)
	}

	if len(splitScript) != 2 {
		return nil, errors.New("invalid response from youtube")
	}
	splitScript = strings.Split(splitScript[1], `window["ytInitialPlayerResponse"] = null;`)
	jsonData := []byte(splitScript[0])

	index := 0
	var contents []byte

	for {
		contents = getContent(jsonData, index)
		_, _, _, err = jsonparser.Get(contents, "[0]", "carouselAdRenderer")

		if err == nil {
			index++
		} else {
			break
		}
	}

	_, err = jsonparser.ArrayEach(contents, func(value []byte, t jsonparser.ValueType, i int, err error) {
		if err != nil {
			return
		}

		if limit > 0 && len(results) >= limit {
			return
		}

		id, err := jsonparser.GetString(value, "videoRenderer", "videoId")
		if err != nil {
			return
		}

		title, err := jsonparser.GetString(value, "videoRenderer", "title", "runs", "[0]", "text")
		if err != nil {
			return
		}

		uploader, err := jsonparser.GetString(value, "videoRenderer", "ownerText", "runs", "[0]", "text")
		if err != nil {
			return
		}

		live := false
		duration, err := jsonparser.GetString(value, "videoRenderer", "lengthText", "simpleText")

		if err != nil {
			duration = ""
			live = true
		}

		results = append(results, &SearchResult{
			Title:      title,
			Uploader:   uploader,
			Duration:   duration,
			ID:         id,
			URL:        fmt.Sprintf("https://youtube.com/watch?v=%s", id),
			Live:       live,
			SourceName: "youtube",
		})
	})

	if err != nil {
		return results, err
	}

	return results, nil
}

id, err := GetYoutubeId("قلبم گرفته", 3)

url := fmt.Sprintf("https://youtube.com/watch?v=%s", id)

package src

import (
	"fmt"
	"github.com/kkdai/youtube/v2"
	"github.com/zmb3/spotify/v2"
	"io"
	gourl "net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

// Downloader is a function to download files
func Downloader(url string, track spotify.FullTrack) {

	videonameTag := fmt.Sprintf("%s.mp4", track.Name)
	nameTag := fmt.Sprintf("%s.mp3", track.Name)

	u, err := gourl.ParseRequestURI(url)
	if err != nil {
		fmt.Println("=> An error occured while trying to parse url")
		fmt.Println(err.Error())
		fmt.Println(url)
		os.Exit(1)
	}

	watchId := strings.Split(u.String(), "v=")[1]

	videoID := watchId
	client := youtube.Client{}

	video, err := client.GetVideo(videoID)
	if err != nil {
		fmt.Println("=> An error occured while trying to download")
		fmt.Println(err.Error())
		os.Exit(1)
	}

	formats := video.Formats.WithAudioChannels() // only get videos with audio
	fmt.Println("=> Select format: ")
	for index, format := range formats {
		fmt.Println("=> Format:", index, " - Audi Quality: ", format.AudioQuality)
	}
	formatNumber := 0
	fmt.Print("Enter Your Format Number: ")
	fmt.Scan(&formatNumber)

	fmt.Println("=> Start Downloading ", videonameTag, " ...")
	stream, _, err := client.GetStream(video, &formats[formatNumber])
	if err != nil {
		fmt.Println("=> An error occured while trying to download")
		fmt.Println(err.Error())
		os.Exit(1)
	}

	file, err := os.Create(videonameTag)
	if err != nil {
		fmt.Println("=> An error occured while trying to download")
		fmt.Println(err.Error())
		os.Exit(1)
	}
	defer file.Close()

	_, err = io.Copy(file, stream)
	if err != nil {
		fmt.Println("=> An error occured while trying to download")
		fmt.Println(err.Error())
		os.Exit(1)
	}

	fmt.Println("=> ", videonameTag, "downloaded successfully")
	fmt.Println("=> Extract audio from video")

	currentDirectory, _ := os.Getwd()
	input := strings.TrimSpace(filepath.Join(currentDirectory, videonameTag))

	output := strings.TrimSpace(filepath.Join(currentDirectory, nameTag))

	cmd, err := exec.Command("ffmpeg", "-y", "-i", input, output).CombinedOutput()
	if err != nil {
		fmt.Println("=> An error occured while trying to extract audio from video")
		fmt.Println(err.Error())
		fmt.Println(string(cmd))
		fmt.Println(err)
		os.Exit(1)
	}

	//utils.TagFileWithSpotifyMetadata(nameTag, track)

}

package src

import (
	"context"
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/zmb3/spotify/v2"
)

// DownloadPlaylist Start initializes complete program
func DownloadPlaylist(ctx context.Context, pid string) {
	user := InitAuth()
	cli := UserData{
		UserClient: user,
	}
	playlistID := spotify.ID(pid)

	trackListJSON, err := cli.UserClient.GetPlaylistTracks(ctx, playlistID)
	if err != nil {
		fmt.Println("Playlist not found!")
		os.Exit(1)
	}
	for _, val := range trackListJSON.Tracks {
		cli.TrackList = append(cli.TrackList, val.Track)
	}

	for page := 0; ; page++ {
		err := cli.UserClient.NextPage(ctx, trackListJSON)
		if err == spotify.ErrNoMorePages {
			break
		}
		if err != nil {
			log.Fatal(err)
		}

		for _, val := range trackListJSON.Tracks {
			cli.TrackList = append(cli.TrackList, val.Track)
		}
	}

	DownloadTrackList(cli)
}

// DownloadAlbum Download album according to
func DownloadAlbum(ctx context.Context, aid string) {
	user := InitAuth()
	cli := UserData{
		UserClient: user,
	}
	albumID := spotify.ID(aid)
	album, err := user.GetAlbum(ctx, albumID)
	if err != nil {
		fmt.Println("Album not found!")
		os.Exit(1)
	}
	for _, val := range album.Tracks.Tracks {
		cli.TrackList = append(cli.TrackList, spotify.FullTrack{
			SimpleTrack: val,
			Album:       album.SimpleAlbum,
		})
	}
	DownloadTrackList(cli)
}

// DownloadSong will download a song with its identifier
func DownloadSong(ctx context.Context, sid string) {
	user := InitAuth()
	cli := UserData{
		UserClient: user,
	}
	songID := spotify.ID(sid)
	song, err := user.GetTrack(ctx, songID)
	if err != nil {
		log.Fatal(err)
		fmt.Println("Song not found!")
		os.Exit(1)
	}
	cli.TrackList = append(cli.TrackList, spotify.FullTrack{
		SimpleTrack: song.SimpleTrack,
		Album:       song.Album,
	})
	DownloadTrackList(cli)
}

// DownloadTrackList Start downloading given list of tracks
func DownloadTrackList(cli UserData) {
	fmt.Println("Found", len(cli.TrackList), "tracks")
	fmt.Println("Searching and downloading tracks")
	for _, val := range cli.TrackList {
		var artistNames []string
		for _, artistInfo := range val.Artists {
			artistNames = append(artistNames, artistInfo.Name)
		}
		searchTerm := strings.Join(artistNames, " ") + " " + val.Name
		youtubeID, err := GetYoutubeId(searchTerm, val.Duration/1000)
		if err != nil {
			log.Printf("Error occured for %s error: %s", val.Name, err)
			continue
		}
		cli.YoutubeIDList = append(cli.YoutubeIDList, youtubeID)
	}
	for index, track := range cli.YoutubeIDList {
		fmt.Println()
		ytURL := "https://www.youtube.com/watch?v=" + track
		fmt.Println("⇓ Downloading " + cli.TrackList[index].Name)
		Downloader(ytURL, cli.TrackList[index])
		fmt.Println()
	}
	fmt.Println("Download complete!")
}

package main

import (
	"context"
	"fmt"
	"os"
	"spotifydownloaderbot/src"
	"strings"

	"github.com/inancgumus/screen"
	"github.com/spf13/cobra"
)

func main() {
	var trackID string
	var playlistID string
	var albumID string
	var spotifyURL string

	var rootCmd = &cobra.Command{
		Use:     src.AppUse,
		Version: src.AppVersion,
		Short:   src.AppShortDescription,
		Long:    src.AppLongDescription,
		Run: func(cmd *cobra.Command, args []string) {

			screen.Clear()

			ctx := context.Background()

			if len(args) == 0 {
				_ = cmd.Help()
				fmt.Println("")
				os.Exit(0)
			}

			spotifyURL = args[0]

			if len(spotifyURL) == 0 {
				fmt.Println("=> Spotify URL required.")
				_ = cmd.Help()
				return
			}

			splitURL := strings.Split(spotifyURL, "/")

			if len(splitURL) < 2 {
				fmt.Println("=> Please enter the url copied from the spotify client.")
				os.Exit(1)
			}

			spotifyID := splitURL[len(splitURL)-1]
			if strings.Contains(spotifyID, "?") {
				spotifyID = strings.Split(spotifyID, "?")[0]
			}

			if strings.Contains(spotifyURL, "album") {
				albumID = spotifyID
				src.DownloadAlbum(ctx, albumID)
			} else if strings.Contains(spotifyURL, "playlist") {
				playlistID = spotifyID
				src.DownloadPlaylist(ctx, playlistID)
			} else if strings.Contains(spotifyURL, "track") {
				trackID = spotifyID
				src.DownloadSong(ctx, trackID)
			} else {
				fmt.Println("=> Only Spotify Album/Playlist/Track URL's are supported.")
				_ = cmd.Help()
			}

		},
	}

	rootCmd.SetUsageTemplate(fmt.Sprintf("%s [spotify_url] \n", src.AppUse))

	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

package utils

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
)

// DownloadFile will get a url and return bytes
func DownloadFile(url string) ([]byte, error) {
	resp, err := http.Get(url)
	if err != nil {
		panic(err)
	}
	defer func(Body io.ReadCloser) {
		_ = Body.Close()
	}(resp.Body)
	buffer, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Failed to download album art!")
		return nil, err
	}
	return buffer, nil
}

package utils

import (
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
)

// DownloadFile will get a url and return bytes
func DownloadFile(url string) ([]byte, error) {

resp, err := http.Get(url)

if err != nil {
    panic(err)
}

defer func(Body io.ReadCloser) {
    _ = Body.Close()
}(resp.Body)

buffer, err := ioutil.ReadAll(resp.Body)

if err != nil {
    fmt.Println("Failed to download album art!")
    return nil, err
}

return buffer, nil

package utils

import (
"fmt"
"github.com/bogem/id3v2"
"github.com/zmb3/spotify/v2"
"log"
"strconv"
"strings"
"time"
)

// TagFileWithSpotifyMetadata takes in a filename as a string and spotify metadata and uses it to tag the music
func TagFileWithSpotifyMetadata(fileName string, trackData spotify.FullTrack) {

	albumTag := trackData.Album.Name
	var trackArtist []string
	for _, Artist := range trackData.Album.Artists {
		trackArtist = append(trackArtist, Artist.Name)
	}
	artistTag := strings.Join(trackArtist[:], ",")
	dateObject, _ := time.Parse("2006-01-02", trackData.Album.ReleaseDate)
	yearTag := dateObject.Year()
	albumArtImages := trackData.Album.Images

	mp3File, err := id3v2.Open(fileName, id3v2.Options{Parse: true})
	if err != nil {
		panic(err)
	}
	defer func(mp3File *id3v2.Tag) {
		err := mp3File.Close()
		if err != nil {
			panic(err)
		}
	}(mp3File)

	mp3File.SetTitle(trackData.Name)
	mp3File.SetArtist(artistTag)
	mp3File.SetAlbum(albumTag)
	mp3File.SetYear(strconv.Itoa(yearTag))

	if len(albumArtImages) > 0 {
		albumArtURL := albumArtImages[0].URL
		albumArt, albumArtDownloadErr := DownloadFile(albumArtURL)
		if albumArtDownloadErr == nil {
			pic := id3v2.PictureFrame{
				Encoding:    id3v2.EncodingUTF8,
				MimeType:    "image/jpeg",
				PictureType: id3v2.PTFrontCover,
				Description: "Front cover",
				Picture:     albumArt,
			}
			mp3File.AddAttachedPicture(pic)
		} else {
			fmt.Println("An error occured while downloading album art ", err)
		}
	} else {
		fmt.Println("No album art found for ", trackData.Name)
	}

	if err = mp3File.Save(); err != nil {
		log.Fatal("Error while saving a tag: ", err)
	}

}

go build .

./spotifydownloaderbot

./spotifydownloaderbot https://open.spotify.com/track/5Z01UMMf7V1o0MzF86s6WJ