Refactored logic from getMusicDirectory.view to the new engine layer.

This reveled a nasty bug in the DI code. Tests are broken

engine/browser.go

@@ -3,26 +3,37 @@ package engine
 import (
 	"errors"
 	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/astaxie/beego"
 	"github.com/deluan/gosonic/consts"
 	"github.com/deluan/gosonic/domain"
 	"github.com/deluan/gosonic/utils"
-	"strconv"
-	"time"
+)
+
+var (
+	DataNotFound = errors.New("Data Not Found")
 )
 
 type Browser interface {
 	MediaFolders() (domain.MediaFolders, error)
 	Indexes(ifModifiedSince time.Time) (domain.ArtistIndexes, time.Time, error)
+	Directory(id string) (*DirectoryInfo, error)
 }
 
-func NewBrowser(propRepo domain.PropertyRepository, folderRepo domain.MediaFolderRepository, indexRepo domain.ArtistIndexRepository) Browser {
-	return browser{propRepo, folderRepo, indexRepo}
+func NewBrowser(pr domain.PropertyRepository, fr domain.MediaFolderRepository, ir domain.ArtistIndexRepository,
+	ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository) Browser {
+	return browser{pr, fr, ir, ar, alr, mr}
 }
 
 type browser struct {
 	propRepo   domain.PropertyRepository
 	folderRepo domain.MediaFolderRepository
 	indexRepo  domain.ArtistIndexRepository
+	artistRepo domain.ArtistRepository
+	albumRepo  domain.AlbumRepository
+	mfileRepo  domain.MediaFileRepository
 }
 
 func (b browser) MediaFolders() (domain.MediaFolders, error) {
@@ -45,3 +56,148 @@ func (b browser) Indexes(ifModifiedSince time.Time) (domain.ArtistIndexes, time.
 
 	return domain.ArtistIndexes{}, lastModified, nil
 }
+
+type Child struct {
+	Id          string
+	Title       string
+	IsDir       bool
+	Parent      string
+	Album       string
+	Year        int
+	Artist      string
+	Genre       string
+	CoverArt    string
+	Starred     time.Time
+	Track       int
+	Duration    int
+	Size        string
+	Suffix      string
+	BitRate     int
+	ContentType string
+}
+
+type DirectoryInfo struct {
+	Id       string
+	Name     string
+	Children []Child
+}
+
+func (c browser) Directory(id string) (*DirectoryInfo, error) {
+	var dir *DirectoryInfo
+	switch {
+	case c.isArtist(id):
+		beego.Info("Found Artist with id", id)
+		a, albums, err := c.retrieveArtist(id)
+		if err != nil {
+			return nil, err
+		}
+		dir = c.buildArtistDir(a, albums)
+	case c.isAlbum(id):
+		beego.Info("Found Album with id", id)
+		al, tracks, err := c.retrieveAlbum(id)
+		if err != nil {
+			return nil, err
+		}
+		dir = c.buildAlbumDir(al, tracks)
+	default:
+		beego.Info("Id", id, "not found")
+		return nil, DataNotFound
+	}
+
+	return dir, nil
+}
+
+func (c browser) buildArtistDir(a *domain.Artist, albums []domain.Album) *DirectoryInfo {
+	dir := &DirectoryInfo{Id: a.Id, Name: a.Name}
+
+	dir.Children = make([]Child, len(albums))
+	for i, al := range albums {
+		dir.Children[i].Id = al.Id
+		dir.Children[i].Title = al.Name
+		dir.Children[i].IsDir = true
+		dir.Children[i].Parent = al.ArtistId
+		dir.Children[i].Album = al.Name
+		dir.Children[i].Year = al.Year
+		dir.Children[i].Artist = al.AlbumArtist
+		dir.Children[i].Genre = al.Genre
+		dir.Children[i].CoverArt = al.CoverArtId
+		if al.Starred {
+			dir.Children[i].Starred = al.UpdatedAt
+		}
+
+	}
+	return dir
+}
+
+func (c browser) buildAlbumDir(al *domain.Album, tracks []domain.MediaFile) *DirectoryInfo {
+	dir := &DirectoryInfo{Id: al.Id, Name: al.Name}
+
+	dir.Children = make([]Child, len(tracks))
+	for i, mf := range tracks {
+		dir.Children[i].Id = mf.Id
+		dir.Children[i].Title = mf.Title
+		dir.Children[i].IsDir = false
+		dir.Children[i].Parent = mf.AlbumId
+		dir.Children[i].Album = mf.Album
+		dir.Children[i].Year = mf.Year
+		dir.Children[i].Artist = mf.Artist
+		dir.Children[i].Genre = mf.Genre
+		dir.Children[i].Track = mf.TrackNumber
+		dir.Children[i].Duration = mf.Duration
+		dir.Children[i].Size = mf.Size
+		dir.Children[i].Suffix = mf.Suffix
+		dir.Children[i].BitRate = mf.BitRate
+		if mf.Starred {
+			dir.Children[i].Starred = mf.UpdatedAt
+		}
+		if mf.HasCoverArt {
+			dir.Children[i].CoverArt = mf.Id
+		}
+		dir.Children[i].ContentType = mf.ContentType()
+	}
+	return dir
+}
+
+func (c browser) isArtist(id string) bool {
+	found, err := c.artistRepo.Exists(id)
+	if err != nil {
+		beego.Error(fmt.Errorf("Error searching for Artist %s: %v", id, err))
+		return false
+	}
+	return found
+}
+
+func (c browser) isAlbum(id string) bool {
+	found, err := c.albumRepo.Exists(id)
+	if err != nil {
+		beego.Error(fmt.Errorf("Error searching for Album %s: %v", id, err))
+		return false
+	}
+	return found
+}
+
+func (c browser) retrieveArtist(id string) (a *domain.Artist, as []domain.Album, err error) {
+	a, err = c.artistRepo.Get(id)
+	if err != nil {
+		err = fmt.Errorf("Error reading Artist %s from DB: %v", id, err)
+		return
+	}
+
+	if as, err = c.albumRepo.FindByArtist(id); err != nil {
+		err = fmt.Errorf("Error reading %s's albums from DB: %v", a.Name, err)
+	}
+	return
+}
+
+func (c browser) retrieveAlbum(id string) (al *domain.Album, mfs []domain.MediaFile, err error) {
+	al, err = c.albumRepo.Get(id)
+	if err != nil {
+		err = fmt.Errorf("Error reading Album %s from DB: %v", id, err)
+		return
+	}
+
+	if mfs, err = c.mfileRepo.FindByAlbum(id); err != nil {
+		err = fmt.Errorf("Error reading %s's tracks from DB: %v", al.Name, err)
+	}
+	return
+}