init commit

cmd/scanner/main.go

@@ -0,0 +1,199 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/sentriz/gonic/db"
+	"github.com/sentriz/gonic/model"
+
+	"github.com/dhowden/tag"
+	"github.com/jinzhu/gorm"
+	_ "github.com/jinzhu/gorm/dialects/sqlite"
+	"github.com/karrick/godirwalk"
+)
+
+var (
+	orm             *gorm.DB
+	tx              *gorm.DB
+	cLastAlbum      = &lastAlbum{}
+	audioExtensions = map[string]bool{
+		".mp3":  true,
+		".flac": true,
+		".aac":  true,
+		".m4a":  true,
+	}
+	coverFilenames = map[string]bool{
+		"cover.png":   true,
+		"cover.jpg":   true,
+		"cover.jpeg":  true,
+		"folder.png":  true,
+		"folder.jpg":  true,
+		"folder.jpeg": true,
+		"album.png":   true,
+		"album.jpg":   true,
+		"album.jpeg":  true,
+		"front.png":   true,
+		"front.jpg":   true,
+		"front.jpeg":  true,
+	}
+)
+
+type lastAlbum struct {
+	coverModTime time.Time // 1st needed for cover insertion
+	coverPath    string    // 2rd needed for cover insertion
+	id           string    // 3nd needed for cover insertion
+}
+
+func (l *lastAlbum) isEmpty() bool {
+	return l.coverPath == ""
+}
+
+func isAudio(filename string) bool {
+	ext := strings.ToLower(filepath.Ext(filename))
+	_, ok := audioExtensions[ext]
+	return ok
+}
+
+func isCover(filename string) bool {
+	_, ok := coverFilenames[strings.ToLower(filename)]
+	return ok
+}
+
+func readTags(fullPath string) (tag.Metadata, error) {
+	trackData, err := os.Open(fullPath)
+	if err != nil {
+		return nil, fmt.Errorf("when tags from disk: %v\n", err)
+	}
+	defer trackData.Close()
+	tags, err := tag.ReadFrom(trackData)
+	if err != nil {
+		return nil, err
+	}
+	return tags, nil
+}
+
+func handleFolderCompletion(fullPath string, info *godirwalk.Dirent) error {
+	log.Printf("processed folder `%s`\n", fullPath)
+	if cLastAlbum.isEmpty() {
+		return nil
+	}
+	cover := model.Cover{
+		Path: cLastAlbum.coverPath,
+	}
+	err := tx.Where(cover).First(&cover).Error
+	if !gorm.IsRecordNotFoundError(err) &&
+		!cLastAlbum.coverModTime.After(cover.UpdatedAt) {
+		return nil
+	}
+	image, err := ioutil.ReadFile(cLastAlbum.coverPath)
+	if err != nil {
+		return fmt.Errorf("when reading cover: %v\n", err)
+	}
+	cover.Image = image
+	cover.AlbumID = cLastAlbum.id
+	tx.Save(&cover)
+	cLastAlbum = &lastAlbum{}
+	return nil
+}
+
+func processFile(fullPath string, info *godirwalk.Dirent) error {
+	if info.IsDir() {
+		return nil
+	}
+	stat, err := os.Stat(fullPath)
+	if err != nil {
+		return fmt.Errorf("when stating file: %v\n", err)
+	}
+	modTime := stat.ModTime()
+	_, filename := path.Split(fullPath)
+	if isCover(filename) {
+		cLastAlbum.coverModTime = modTime // 1st needed for cover insertion
+		cLastAlbum.coverPath = fullPath   // 2nd needed for cover insertion
+		return nil
+	}
+	if !isAudio(filename) {
+		return nil
+	}
+	// set track basics
+	track := model.Track{
+		Path: fullPath,
+	}
+	err = tx.Where(track).First(&track).Error
+	if !gorm.IsRecordNotFoundError(err) && !modTime.After(track.UpdatedAt) {
+		return nil
+	}
+	tags, err := readTags(fullPath)
+	if err != nil {
+		return fmt.Errorf("when reading tags: %v\n", err)
+	}
+	trackNumber, totalTracks := tags.Track()
+	discNumber, TotalDiscs := tags.Disc()
+	track.Path = fullPath
+	track.Title = tags.Title()
+	track.DiscNumber = discNumber
+	track.TotalDiscs = TotalDiscs
+	track.TotalTracks = totalTracks
+	track.TrackNumber = trackNumber
+	track.Year = tags.Year()
+	// set artist
+	artist := model.Artist{
+		Name: tags.AlbumArtist(),
+	}
+	err = tx.Where(artist).First(&artist).Error
+	if gorm.IsRecordNotFoundError(err) {
+		artist.Name = tags.AlbumArtist()
+		tx.Save(&artist)
+	}
+	track.ArtistID = artist.ID
+	// set album
+	album := model.Album{
+		ArtistID: artist.ID,
+		Title:    tags.Album(),
+	}
+	err = tx.Where(album).First(&album).Error
+	if gorm.IsRecordNotFoundError(err) {
+		album.Title = tags.Album()
+		album.ArtistID = artist.ID
+		tx.Save(&album)
+	}
+	track.AlbumID = album.ID
+	// set the _3rd_ variable for cover insertion.
+	// it will be used by the `handleFolderCompletion` function
+	cLastAlbum.id = album.ID
+	// save track
+	tx.Save(&track)
+	return nil
+}
+
+func main() {
+	if len(os.Args) != 2 {
+		log.Fatalf("usage: %s <path to music>", os.Args[0])
+	}
+	orm = db.New()
+	orm.SetLogger(log.New(os.Stdout, "gorm ", 0))
+	orm.AutoMigrate(
+		&model.Album{},
+		&model.Artist{},
+		&model.Track{},
+		&model.Cover{},
+	)
+	startTime := time.Now()
+	tx = orm.Begin()
+	err := godirwalk.Walk(os.Args[1], &godirwalk.Options{
+		Callback:             processFile,
+		PostChildrenCallback: handleFolderCompletion,
+		Unsorted:             true,
+	})
+	if err != nil {
+		log.Fatalf("error when walking: %v\n", err)
+	}
+	tx.Commit()
+	log.Printf("scanned in %s\n", time.Since(startTime))
+}

cmd/server/main.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"log"
+
+	"github.com/sentriz/gonic/db"
+	"github.com/sentriz/gonic/handler"
+	"github.com/sentriz/gonic/router"
+)
+
+func main() {
+	d := db.New()
+	r := router.New()
+	h := &handler.Handler{
+		DB:     d,
+		Router: r,
+	}
+	rest := r.Group("/rest")
+	rest.GET("", h.GetTest)
+	log.Fatal(r.Start("127.0.0.1:5001"))
+}