Initial commit

Author: defsub

config/config.go

@@ -0,0 +1,54 @@
+package config
+
+import (
+	"github.com/spf13/viper"
+)
+
+type MusicBucket struct {
+	Endpoint        string
+	AccessKeyID     string
+	SecretAccessKey string
+	BucketName      string
+	ObjectPrefix    string
+	UseSSL          bool
+}
+
+type MusicDB struct {
+	Driver  string
+	Source  string
+	LogMode bool
+}
+
+type MusicConfig struct {
+	Bucket MusicBucket
+	DB     MusicDB
+}
+
+type LastFMAPIConfig struct {
+	Key    string
+	Secret string
+}
+
+type Config struct {
+	Music       MusicConfig
+	LastFM      LastFMAPIConfig
+	BindAddress string
+}
+
+func GetConfig() (*Config, error) {
+	var config Config
+	viper.SetConfigName("takeout")
+	viper.AddConfigPath(".")
+	viper.SetDefault("Music.Bucket.UseSSL", "true")
+	viper.SetDefault("Music.DB.Driver", "sqlite3")
+	viper.SetDefault("Music.DB.Source", "music.db")
+	viper.SetDefault("Music.DB.LogMode", "false")
+	viper.SetDefault("LastFM.Key", "77033164cfcda2acc4c58681dcba3cf8")
+	viper.SetDefault("LastFM.Secret", "8f43410e8e81c33d4542738ee84dc39b")
+	viper.SetDefault("BindAddress", "127.0.0.1:3000")
+	err := viper.ReadInConfig()
+	if err == nil {
+		err = viper.Unmarshal(&config)
+	}
+	return &config, err
+}

encoding/spiff/spiff.go

@@ -0,0 +1,82 @@
+package spiff
+
+import (
+	"encoding/xml"
+	"fmt"
+	"io"
+	"reflect"
+)
+
+const (
+	ContentType = "application/xspf+xml"
+)
+
+type StringTag struct {
+	Value string `xml:",chardata"`
+}
+
+type IntTag struct {
+	Value uint `xml:",chardata"`
+}
+
+type TrackTag struct {
+	XMLName  xml.Name  `xml:"track"`
+	Creator  StringTag `xml:"creator"`
+	Album    StringTag `xml:"album"`
+	Title    StringTag `xml:"title"`
+	TrackNum IntTag    `xml:"trackNum"`
+	Location StringTag `xml:"location"`
+}
+
+type Encoder struct {
+	xmlEncoder *xml.Encoder
+	writer io.Writer
+}
+
+func NewEncoder(w io.Writer) *Encoder {
+	e := &Encoder{writer: w, xmlEncoder: xml.NewEncoder(w)}
+	return e
+}
+
+func (e *Encoder) Header(title string) {
+	fmt.Fprint(e.writer, xml.Header)
+	fmt.Fprintf(e.writer, "<playlist version=\"1\" xmlns=\"http://xspf.org/ns/0/\">")
+	fmt.Fprintf(e.writer, "<title>%s</title>", title)
+	fmt.Fprintf(e.writer, "<trackList>")
+}
+
+func (e *Encoder) Encode(track interface{}) (err error) {
+	trackTag := &TrackTag{}
+
+	t := reflect.TypeOf(track)
+	v := reflect.ValueOf(track)
+	
+	switch v.Kind() {
+	case reflect.Struct:
+		for i := 0; i < t.NumField(); i++ {
+			typeField := t.Field(i)
+			valueField := v.Field(i)
+			if tag, ok := typeField.Tag.Lookup("spiff"); ok {
+				switch tag {
+				case "creator":
+					trackTag.Creator = StringTag{valueField.String()}
+				case "album":
+					trackTag.Album = StringTag{valueField.String()}
+				case "title":
+					trackTag.Title = StringTag{valueField.String()}
+				case "tracknum":
+					trackTag.TrackNum = IntTag{uint(valueField.Uint())}
+				case "location":
+					trackTag.Location = StringTag{valueField.String()}
+				}
+			}
+		}
+	}
+	err = e.xmlEncoder.Encode(trackTag)
+	return err
+}
+
+func (e *Encoder) Footer() {
+	fmt.Fprintf(e.writer, "</trackList>")
+	fmt.Fprintf(e.writer, "</playlist>\n")
+}

go.mod

@@ -0,0 +1,13 @@
+module github.com/defsub/takeout
+
+require (
+	github.com/go-ini/ini v1.52.0 // indirect
+	github.com/jinzhu/gorm v1.9.12
+	github.com/michiwend/gomusicbrainz v0.0.0-20181012083520-6c07e13dd396
+	github.com/minio/minio-go v6.0.14+incompatible
+	github.com/minio/minio-go/v6 v6.0.48
+	github.com/shkh/lastfm-go v0.0.0-20191215035245-89a801c244e0
+	github.com/spf13/viper v1.6.2
+)
+
+go 1.13

go.sum

@@ -0,0 +1,112 @@
+package music
+
+import (
+	"github.com/defsub/takeout/config"
+	_ "github.com/jinzhu/gorm/dialects/sqlite"
+	"github.com/minio/minio-go/v6"
+	"net/url"
+	"regexp"
+	"strconv"
+	"time"
+)
+
+func (m *Music) bucketConfig() config.MusicBucket {
+	return m.config.Music.Bucket
+}
+
+func (m *Music) openBucket() error {
+	bucket := m.bucketConfig()
+	minioClient, err := minio.New(bucket.Endpoint, bucket.AccessKeyID, bucket.SecretAccessKey, bucket.UseSSL)
+	if err == nil {
+		m.minio = minioClient
+	}
+	return err
+}
+
+func (m *Music) SyncFromBucket() (trackCh chan *Track, err error) {
+	trackCh = make(chan *Track)
+
+	go func() {
+		defer close(trackCh)
+
+		doneCh := make(chan struct{})
+		defer close(doneCh)
+
+		isRecursive := true
+		bucket := m.bucketConfig()
+		objectCh := m.minio.ListObjectsV2(bucket.BucketName, bucket.ObjectPrefix, isRecursive, doneCh)
+		for object := range objectCh {
+			if object.Err != nil {
+				break
+			}
+			checkObject(&object, trackCh)
+		}
+	}()
+
+	return
+}
+
+func checkObject(object *minio.ObjectInfo, trackCh chan *Track) {
+	matchPath(object.Key, trackCh, func(t *Track, trackCh chan *Track) {
+		t.Key = object.Key
+		t.ETag = object.ETag
+		t.Size = object.Size
+		t.LastModified = object.LastModified
+		trackCh <- t
+	})
+}
+
+// Examples:
+// The Raconteurs / Help Us Stranger (2019) / 01-Bored and Razed.flac
+// Tubeway Army / Replicas - The First Recordings (2019) / 1-01-You Are in My Vision (early version).flac
+// Tubeway Army / Replicas - The First Recordings (2019) / 2-01-Replicas (early version 2).flac
+var coverRegexp = regexp.MustCompile(`cover\.(png|jpg)$`)
+
+var pathRegexp = regexp.MustCompile(`([^\/]+)\/([^\/]+)\/([^\/]+)$`)
+
+func matchPath(path string, trackCh chan *Track, doMatch func(t *Track, music chan *Track)) {
+	matches := pathRegexp.FindStringSubmatch(path)
+	if matches != nil {
+		var t Track
+		t.Artist = matches[1]
+		t.Release = matchRelease(matches[2])
+		if matchTrack(matches[3], &t) {
+			doMatch(&t, trackCh)
+		}
+	}
+}
+
+var releaseRegexp = regexp.MustCompile(`(.+)\s+\(([\d]+)\)\s*$`)
+
+func matchRelease(release string) string {
+	matches := releaseRegexp.FindStringSubmatch(release)
+	if matches != nil {
+		release = matches[1]
+	}
+	return release
+}
+
+var trackRegexp = regexp.MustCompile(`(?:([\d]+)-)?([\d]+)-(.*)\.(mp3|flac|ogg|m4a)$`)
+
+func matchTrack(file string, t *Track) bool {
+	matches := trackRegexp.FindStringSubmatch(file)
+	if matches == nil {
+		return false
+	}
+	disc, _ := strconv.Atoi(matches[1])
+	track, _ := strconv.Atoi(matches[2])
+	t.DiscNum = uint(disc)
+	t.TrackNum = uint(track)
+	t.Title = matches[3]
+	if t.DiscNum == 0 {
+		t.DiscNum = 1
+	}
+	return true
+}
+
+func (m *Music) objectURL(t Track) *url.URL {
+	reqParams := make(url.Values)
+	// Generates a presigned url which expires in a day.
+	url, _ := m.minio.PresignedGetObject(m.config.Music.Bucket.BucketName, t.Key, time.Second*24*60*60, reqParams)
+	return url
+}

music/bucket.go

@@ -0,0 +1,31 @@
+package music
+
+import (
+	"fmt"
+	"time"
+)
+
+type DateRange struct {
+	after  time.Time
+	before time.Time
+}
+
+func NewDateRange(a, b time.Time) *DateRange {
+	return &DateRange{after: a, before: b}
+}
+
+func (d *DateRange) IsZero() bool {
+	return d.after.IsZero() && d.before.IsZero()
+}
+
+func (d *DateRange) AfterDate() string {
+	return ymd(d.after)
+}
+
+func (d *DateRange) BeforeDate() string {
+	return ymd(d.before)
+}
+
+func ymd(t time.Time) string {
+	return fmt.Sprintf("%04d-%02d-%02d", t.Year(), t.Month(), t.Day())
+}