mirror of
https://github.com/cgzirim/seek-tune.git
synced 2025-12-17 17:04:22 +00:00
352 lines
9.6 KiB
Go
352 lines
9.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"log/slog"
|
|
"net/http"
|
|
"song-recognition/shazam"
|
|
"song-recognition/spotify"
|
|
"song-recognition/utils"
|
|
"song-recognition/wav"
|
|
"strings"
|
|
|
|
"github.com/mdobak/go-xerrors"
|
|
|
|
socketio "github.com/googollee/go-socket.io"
|
|
"github.com/googollee/go-socket.io/engineio"
|
|
"github.com/googollee/go-socket.io/engineio/transport"
|
|
"github.com/googollee/go-socket.io/engineio/transport/polling"
|
|
"github.com/googollee/go-socket.io/engineio/transport/websocket"
|
|
)
|
|
|
|
const (
|
|
SONGS_DIR = "songs"
|
|
)
|
|
|
|
var allowOriginFunc = func(r *http.Request) bool {
|
|
return true
|
|
}
|
|
|
|
func downloadStatus(statusType, message string) string {
|
|
data := map[string]interface{}{"type": statusType, "message": message}
|
|
jsonData, err := json.Marshal(data)
|
|
if err != nil {
|
|
logger := utils.GetLogger()
|
|
ctx := context.Background()
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to marshal data.", slog.Any("error", err))
|
|
return ""
|
|
}
|
|
return string(jsonData)
|
|
}
|
|
|
|
type RecordData struct {
|
|
Audio string `json:"audio"`
|
|
Channels int `json:"channels"`
|
|
SampleRate int `json:"sampleRate"`
|
|
SampleSize int `json:"sampleSize"`
|
|
}
|
|
|
|
func main() {
|
|
|
|
server := socketio.NewServer(&engineio.Options{
|
|
Transports: []transport.Transport{
|
|
&polling.Transport{
|
|
CheckOrigin: allowOriginFunc,
|
|
},
|
|
&websocket.Transport{
|
|
CheckOrigin: allowOriginFunc,
|
|
},
|
|
},
|
|
})
|
|
|
|
logger := utils.GetLogger()
|
|
ctx := context.Background()
|
|
|
|
server.OnConnect("/", func(socket socketio.Conn) error {
|
|
socket.SetContext("")
|
|
log.Println("CONNECTED: ", socket.ID())
|
|
|
|
return nil
|
|
})
|
|
|
|
err := spotify.CreateFolder(SONGS_DIR)
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logMsg := fmt.Sprintf("failed to create directory %v", SONGS_DIR)
|
|
logger.ErrorContext(ctx, logMsg, slog.Any("error", err))
|
|
}
|
|
|
|
server.OnEvent("/", "totalSongs", func(socket socketio.Conn) {
|
|
db, err := utils.NewDbClient()
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "error connecting to DB", slog.Any("error", err))
|
|
return
|
|
}
|
|
defer db.Close()
|
|
|
|
totalSongs, err := db.TotalSongs()
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "Log error getting total songs", slog.Any("error", err))
|
|
return
|
|
}
|
|
|
|
socket.Emit("totalSongs", totalSongs)
|
|
})
|
|
|
|
server.OnEvent("/", "newDownload", func(socket socketio.Conn, spotifyURL string) {
|
|
if len(spotifyURL) == 0 {
|
|
logger.Debug("Spotify URL required.")
|
|
return
|
|
}
|
|
|
|
splitURL := strings.Split(spotifyURL, "/")
|
|
|
|
if len(splitURL) < 2 {
|
|
logger.Debug("invalid Spotify URL.")
|
|
return
|
|
}
|
|
|
|
spotifyID := splitURL[len(splitURL)-1]
|
|
if strings.Contains(spotifyID, "?") {
|
|
spotifyID = strings.Split(spotifyID, "?")[0]
|
|
}
|
|
|
|
// Handle album download
|
|
if strings.Contains(spotifyURL, "album") {
|
|
tracksInAlbum, err := spotify.AlbumInfo(spotifyURL)
|
|
if err != nil {
|
|
fmt.Println("log error: ", err)
|
|
if len(err.Error()) <= 25 {
|
|
socket.Emit("downloadStatus", downloadStatus("error", err.Error()))
|
|
logger.Info(err.Error())
|
|
} else {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "error getting album info", slog.Any("error", err))
|
|
}
|
|
return
|
|
}
|
|
|
|
statusMsg := fmt.Sprintf("%v songs found in album.", len(tracksInAlbum))
|
|
socket.Emit("downloadStatus", downloadStatus("info", statusMsg))
|
|
|
|
totalTracksDownloaded, err := spotify.DlAlbum(spotifyURL, SONGS_DIR)
|
|
if err != nil {
|
|
socket.Emit("downloadStatus", downloadStatus("error", "Couldn't to download album."))
|
|
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to download album.", slog.Any("error", err))
|
|
return
|
|
}
|
|
|
|
statusMsg = fmt.Sprintf("%d songs downloaded from album", totalTracksDownloaded)
|
|
socket.Emit("downloadStatus", downloadStatus("success", statusMsg))
|
|
|
|
}
|
|
|
|
// Handle playlist download
|
|
if strings.Contains(spotifyURL, "playlist") {
|
|
tracksInPL, err := spotify.PlaylistInfo(spotifyURL)
|
|
if err != nil {
|
|
if len(err.Error()) <= 25 {
|
|
socket.Emit("downloadStatus", downloadStatus("error", err.Error()))
|
|
logger.Info(err.Error())
|
|
} else {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "error getting album info", slog.Any("error", err))
|
|
}
|
|
return
|
|
}
|
|
|
|
statusMsg := fmt.Sprintf("%v songs found in playlist.", len(tracksInPL))
|
|
socket.Emit("downloadStatus", downloadStatus("info", statusMsg))
|
|
|
|
totalTracksDownloaded, err := spotify.DlPlaylist(spotifyURL, SONGS_DIR)
|
|
if err != nil {
|
|
socket.Emit("downloadStatus", downloadStatus("error", "Couldn't download playlist."))
|
|
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to download playlist.", slog.Any("error", err))
|
|
return
|
|
}
|
|
|
|
statusMsg = fmt.Sprintf("%d songs downloaded from playlist.", totalTracksDownloaded)
|
|
socket.Emit("downloadStatus", downloadStatus("success", statusMsg))
|
|
|
|
}
|
|
|
|
// Handle track download
|
|
if strings.Contains(spotifyURL, "track") {
|
|
trackInfo, err := spotify.TrackInfo(spotifyURL)
|
|
if err != nil {
|
|
if len(err.Error()) <= 25 {
|
|
socket.Emit("downloadStatus", downloadStatus("error", err.Error()))
|
|
logger.Info(err.Error())
|
|
} else {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "error getting album info", slog.Any("error", err))
|
|
}
|
|
return
|
|
}
|
|
|
|
// check if track already exist
|
|
db, err := utils.NewDbClient()
|
|
if err != nil {
|
|
fmt.Errorf("Log - error connecting to DB: %d", err)
|
|
}
|
|
defer db.Close()
|
|
|
|
song, songExists, err := db.GetSongByKey(utils.GenerateSongKey(trackInfo.Title, trackInfo.Artist))
|
|
if err == nil {
|
|
if songExists {
|
|
statusMsg := fmt.Sprintf(
|
|
"'%s' by '%s' already exists in the database (https://www.youtube.com/watch?v=%s)",
|
|
song.Title, song.Artist, song.YouTubeID)
|
|
|
|
socket.Emit("downloadStatus", downloadStatus("error", statusMsg))
|
|
return
|
|
}
|
|
} else {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to get song by key.", slog.Any("error", err))
|
|
}
|
|
|
|
totalDownloads, err := spotify.DlSingleTrack(spotifyURL, SONGS_DIR)
|
|
if err != nil {
|
|
if len(err.Error()) <= 25 {
|
|
socket.Emit("downloadStatus", downloadStatus("error", err.Error()))
|
|
logger.Info(err.Error())
|
|
} else {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "error getting album info", slog.Any("error", err))
|
|
}
|
|
return
|
|
}
|
|
|
|
statusMsg := ""
|
|
if totalDownloads != 1 {
|
|
statusMsg = fmt.Sprintf("'%s' by '%s' failed to download", trackInfo.Title, trackInfo.Artist)
|
|
socket.Emit("downloadStatus", downloadStatus("error", statusMsg))
|
|
} else {
|
|
statusMsg = fmt.Sprintf("'%s' by '%s' was downloaded", trackInfo.Title, trackInfo.Artist)
|
|
socket.Emit("downloadStatus", downloadStatus("success", statusMsg))
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
server.OnEvent("/", "record", func(socket socketio.Conn, recordData string) {
|
|
var recData RecordData
|
|
if err := json.Unmarshal([]byte(recordData), &recData); err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "Failed to unmarshal record data.", slog.Any("error", err))
|
|
return
|
|
}
|
|
|
|
// Decode base64 data
|
|
decodedAudioData, err := base64.StdEncoding.DecodeString(recData.Audio)
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to decode base64 data.", slog.Any("error", err))
|
|
return
|
|
}
|
|
|
|
// Save the decoded data to a file
|
|
channels := recData.Channels
|
|
sampleRate := recData.SampleRate
|
|
bitsPerSample := recData.SampleSize
|
|
fmt.Println(channels, sampleRate, bitsPerSample)
|
|
|
|
err = wav.WriteWavFile("blob.wav", decodedAudioData, sampleRate, channels, bitsPerSample)
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to write wav file.", slog.Any("error", err))
|
|
}
|
|
|
|
samples, err := wav.WavBytesToSamples(decodedAudioData)
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to convert decodedData to samples.", slog.Any("error", err))
|
|
}
|
|
|
|
matches, err := shazam.FindMatches(samples, 10.0, sampleRate)
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to get matches.", slog.Any("error", err))
|
|
}
|
|
fmt.Println("Matches! : ", matches)
|
|
|
|
jsonData, err := json.Marshal(matches)
|
|
if len(matches) > 10 {
|
|
jsonData, _ = json.Marshal(matches[:10])
|
|
}
|
|
|
|
if err != nil {
|
|
err := xerrors.New(err)
|
|
logger.ErrorContext(ctx, "failed to marshal matches.", slog.Any("error", err))
|
|
return
|
|
}
|
|
|
|
socket.Emit("matches", string(jsonData))
|
|
})
|
|
|
|
server.OnError("/", func(s socketio.Conn, e error) {
|
|
log.Println("meet error:", e)
|
|
})
|
|
|
|
server.OnDisconnect("/", func(s socketio.Conn, reason string) {
|
|
log.Println("closed", reason)
|
|
})
|
|
|
|
go func() {
|
|
if err := server.Serve(); err != nil {
|
|
log.Fatalf("socketio listen error: %s\n", err)
|
|
}
|
|
}()
|
|
defer server.Close()
|
|
|
|
SERVE_HTTPS := strings.ToLower(utils.GetEnv("SERVE_HTTPS"))
|
|
serveHTTPS := SERVE_HTTPS == "true"
|
|
|
|
serveHTTP(server, serveHTTPS)
|
|
}
|
|
|
|
func serveHTTP(socketServer *socketio.Server, serveHTTPS bool) {
|
|
http.Handle("/socket.io/", socketServer)
|
|
|
|
if serveHTTPS {
|
|
httpsAddr := ":443"
|
|
httpsServer := &http.Server{
|
|
Addr: httpsAddr,
|
|
TLSConfig: &tls.Config{
|
|
MinVersion: tls.VersionTLS12,
|
|
},
|
|
Handler: socketServer,
|
|
}
|
|
|
|
cert_key := utils.GetEnv("CERT_KEY")
|
|
cert_file := utils.GetEnv("CERT_FILE")
|
|
if cert_key == "" || cert_file == "" {
|
|
log.Fatal("Missing cert")
|
|
}
|
|
|
|
log.Printf("Starting HTTPS server on %s\n", httpsAddr)
|
|
if err := httpsServer.ListenAndServeTLS(cert_file, cert_key); err != nil {
|
|
log.Fatalf("HTTPS server ListenAndServeTLS: %v", err)
|
|
}
|
|
}
|
|
|
|
log.Printf("Starting HTTP server on port 80")
|
|
if err := http.ListenAndServe(":80", nil); err != nil {
|
|
log.Fatalf("HTTP server ListenAndServe: %v", err)
|
|
}
|
|
}
|