merge album and folder models
This commit is contained in:
sentriz
183
scanner/walk.go
183
scanner/walk.go
@@ -1,7 +1,6 @@
|
||||
package scanner
|
||||
|
||||
import (
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"os"
|
||||
"path"
|
||||
@@ -14,182 +13,146 @@ import (
|
||||
"github.com/sentriz/gonic/model"
|
||||
)
|
||||
|
||||
type trackItem struct {
|
||||
mime string
|
||||
ext string
|
||||
}
|
||||
|
||||
type item struct {
|
||||
path string
|
||||
relPath string
|
||||
stat os.FileInfo
|
||||
track *trackItem
|
||||
//
|
||||
// common
|
||||
fullPath string
|
||||
relPath string
|
||||
directory string
|
||||
filename string
|
||||
stat os.FileInfo
|
||||
//
|
||||
// track only
|
||||
ext string
|
||||
mime string
|
||||
}
|
||||
|
||||
func (s *Scanner) callbackItem(path string, info *godirwalk.Dirent) error {
|
||||
stat, err := os.Stat(path)
|
||||
func (s *Scanner) callbackItem(fullPath string, info *godirwalk.Dirent) error {
|
||||
stat, err := os.Stat(fullPath)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "stating")
|
||||
}
|
||||
relPath, err := filepath.Rel(s.musicPath, path)
|
||||
relPath, err := filepath.Rel(s.musicPath, fullPath)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "getting relative path")
|
||||
}
|
||||
directory, filename := path.Split(relPath)
|
||||
it := &item{
|
||||
path: path,
|
||||
relPath: relPath,
|
||||
stat: stat,
|
||||
fullPath: fullPath,
|
||||
relPath: relPath,
|
||||
directory: directory,
|
||||
filename: filename,
|
||||
stat: stat,
|
||||
}
|
||||
if info.IsDir() {
|
||||
return s.handleFolder(it)
|
||||
}
|
||||
if isCover(path) {
|
||||
return s.handleCover(it)
|
||||
if _, ok := coverFilenames[filename]; ok {
|
||||
s.curCover = filename
|
||||
return nil
|
||||
}
|
||||
if mime, ext, ok := isTrack(path); ok {
|
||||
s.seenTracks[relPath] = true
|
||||
it.track = &trackItem{mime: mime, ext: ext}
|
||||
ext := path.Ext(filename)[1:]
|
||||
if mime, ok := mimeTypes[ext]; ok {
|
||||
it.ext = ext
|
||||
it.mime = mime
|
||||
return s.handleTrack(it)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Scanner) callbackPost(path string, info *godirwalk.Dirent) error {
|
||||
// in general in this function - if a model is not nil, then it
|
||||
// has at least been looked up. if it has a id of 0, then it is
|
||||
// a new record and needs to be inserted
|
||||
if s.curCover.IsNew {
|
||||
s.tx.Save(&s.curCover)
|
||||
}
|
||||
if s.curAlbum.IsNew {
|
||||
s.curAlbum.CoverID = s.curCover.ID
|
||||
s.tx.Save(&s.curAlbum)
|
||||
}
|
||||
func (s *Scanner) callbackPost(fullPath string, info *godirwalk.Dirent) error {
|
||||
folder := s.curFolders.Pop()
|
||||
if folder.IsNew {
|
||||
folder.ParentID = s.curFolders.PeekID()
|
||||
folder.CoverID = s.curCover.ID
|
||||
folder.HasTracks = len(s.curTracks) > 1
|
||||
folder.ParentID = s.curFolderID()
|
||||
folder.Cover = s.curCover
|
||||
s.tx.Save(&folder)
|
||||
}
|
||||
for _, t := range s.curTracks {
|
||||
t.FolderID = folder.ID
|
||||
t.AlbumID = s.curAlbum.ID
|
||||
s.tx.Save(&t)
|
||||
}
|
||||
//
|
||||
s.curTracks = make([]model.Track, 0)
|
||||
s.curCover = model.Cover{}
|
||||
s.curAlbum = model.Album{}
|
||||
s.curAArtist = model.Artist{}
|
||||
//
|
||||
log.Printf("processed folder `%s`\n", path)
|
||||
s.curCover = ""
|
||||
log.Printf("processed folder `%s`\n", fullPath)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Scanner) handleFolder(it *item) error {
|
||||
// TODO:
|
||||
var folder model.Folder
|
||||
err := s.tx.
|
||||
Where("path = ?", it.relPath).
|
||||
Where(model.Folder{
|
||||
LeftPath: it.directory,
|
||||
RightPath: it.filename,
|
||||
}).
|
||||
First(&folder).
|
||||
Error
|
||||
if !gorm.IsRecordNotFoundError(err) &&
|
||||
it.stat.ModTime().Before(folder.UpdatedAt) {
|
||||
// we found the record but it hasn't changed
|
||||
s.curFolders.Push(folder)
|
||||
s.curFolders.Push(&folder)
|
||||
return nil
|
||||
}
|
||||
folder.Path = it.relPath
|
||||
folder.Name = it.stat.Name()
|
||||
folder.LeftPath = it.directory
|
||||
folder.RightPath = it.filename
|
||||
s.tx.Save(&folder)
|
||||
folder.IsNew = true
|
||||
s.curFolders.Push(folder)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Scanner) handleCover(it *item) error {
|
||||
err := s.tx.
|
||||
Where("path = ?", it.relPath).
|
||||
First(&s.curCover).
|
||||
Error
|
||||
if !gorm.IsRecordNotFoundError(err) &&
|
||||
it.stat.ModTime().Before(s.curCover.UpdatedAt) {
|
||||
// we found the record but it hasn't changed
|
||||
return nil
|
||||
}
|
||||
s.curCover.Path = it.relPath
|
||||
image, err := ioutil.ReadFile(it.path)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "reading cover")
|
||||
}
|
||||
s.curCover.Image = image
|
||||
s.curCover.IsNew = true
|
||||
s.curFolders.Push(&folder)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Scanner) handleTrack(it *item) error {
|
||||
//
|
||||
// set track basics
|
||||
track := model.Track{}
|
||||
var track model.Track
|
||||
err := s.tx.
|
||||
Where("path = ?", it.relPath).
|
||||
Where(model.Track{
|
||||
FolderID: s.curFolderID(),
|
||||
Filename: it.filename,
|
||||
Ext: it.ext,
|
||||
}).
|
||||
First(&track).
|
||||
Error
|
||||
if !gorm.IsRecordNotFoundError(err) &&
|
||||
it.stat.ModTime().Before(track.UpdatedAt) {
|
||||
s.seenTracks[track.ID] = struct{}{}
|
||||
// we found the record but it hasn't changed
|
||||
return nil
|
||||
}
|
||||
tags, err := readTags(it.path)
|
||||
track.Filename = it.filename
|
||||
track.Ext = it.ext
|
||||
track.ContentType = it.mime
|
||||
track.Size = int(it.stat.Size())
|
||||
track.FolderID = s.curFolderID()
|
||||
track.Duration = -1
|
||||
track.Bitrate = -1
|
||||
tags, err := readTags(it.fullPath)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "reading tags")
|
||||
}
|
||||
trackNumber, totalTracks := tags.Track()
|
||||
discNumber, totalDiscs := tags.Disc()
|
||||
track.DiscNumber = discNumber
|
||||
track.TotalDiscs = totalDiscs
|
||||
track.TotalTracks = totalTracks
|
||||
track.TrackNumber = trackNumber
|
||||
track.Path = it.relPath
|
||||
track.Suffix = it.track.ext
|
||||
track.ContentType = it.track.mime
|
||||
track.Size = int(it.stat.Size())
|
||||
track.Title = tags.Title()
|
||||
track.TrackArtist = tags.Artist()
|
||||
track.Year = tags.Year()
|
||||
track.FolderID = s.curFolders.PeekID()
|
||||
track.TagDiscNumber = discNumber
|
||||
track.TagTotalDiscs = totalDiscs
|
||||
track.TagTotalTracks = totalTracks
|
||||
track.TagTrackNumber = trackNumber
|
||||
track.TagTitle = tags.Title()
|
||||
track.TagTrackArtist = tags.Artist()
|
||||
track.TagYear = tags.Year()
|
||||
//
|
||||
// set album artist basics
|
||||
var artist model.Artist
|
||||
err = s.tx.Where("name = ?", tags.AlbumArtist()).
|
||||
First(&s.curAArtist).
|
||||
First(&artist).
|
||||
Error
|
||||
if gorm.IsRecordNotFoundError(err) {
|
||||
s.curAArtist.Name = tags.AlbumArtist()
|
||||
s.tx.Save(&s.curAArtist)
|
||||
artist.Name = tags.AlbumArtist()
|
||||
s.tx.Save(&artist)
|
||||
}
|
||||
track.ArtistID = s.curAArtist.ID
|
||||
track.ArtistID = artist.ID
|
||||
s.tx.Save(&track)
|
||||
s.seenTracks[track.ID] = struct{}{}
|
||||
//
|
||||
// set album if this is the first track in the folder
|
||||
if len(s.curTracks) > 0 {
|
||||
s.curTracks = append(s.curTracks, track)
|
||||
if !s.curFolder().IsNew {
|
||||
return nil
|
||||
}
|
||||
s.curTracks = append(s.curTracks, track)
|
||||
//
|
||||
directory, _ := path.Split(it.relPath)
|
||||
err = s.tx.
|
||||
Where("path = ?", directory).
|
||||
First(&s.curAlbum).
|
||||
Error
|
||||
if !gorm.IsRecordNotFoundError(err) {
|
||||
// we found the record
|
||||
return nil
|
||||
}
|
||||
s.curAlbum.Path = directory
|
||||
s.curAlbum.Title = tags.Album()
|
||||
s.curAlbum.Year = tags.Year()
|
||||
s.curAlbum.ArtistID = s.curAArtist.ID
|
||||
s.curAlbum.IsNew = true
|
||||
s.curFolder().AlbumTitle = tags.Album()
|
||||
s.curFolder().AlbumYear = tags.Year()
|
||||
s.curFolder().AlbumArtistID = artist.ID
|
||||
return nil
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user