third-party-mirrors/navidrome
1
0
Fork 0
mirror of https://github.com/navidrome/navidrome.git synced 2025-06-04 01:21:19 +03:00
Code Issues Packages Projects Releases Wiki Activity

Using pointers for the receivers

Browse Source
This commit is contained in:
Deluan 2016-03-21 23:11:57 -04:00
parent 36160be32a
commit 23cf069100
5 changed files with 49 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
engine/browser.go
View File

@ -20,7 +20,7 @@ type Browser interface {
func NewBrowser(pr PropertyRepository, fr domain.MediaFolderRepository, ir domain.ArtistIndexRepository, func NewBrowser(pr PropertyRepository, fr domain.MediaFolderRepository, ir domain.ArtistIndexRepository,
ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository) Browser { ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository) Browser {
return browser{pr, fr, ir, ar, alr, mr} return &browser{pr, fr, ir, ar, alr, mr}
} }
type browser struct { type browser struct {
@ -32,11 +32,11 @@ type browser struct {
mfileRepo domain.MediaFileRepository mfileRepo domain.MediaFileRepository
} }
func (b browser) MediaFolders() (domain.MediaFolders, error) { func (b *browser) MediaFolders() (domain.MediaFolders, error) {
return b.folderRepo.GetAll() return b.folderRepo.GetAll()
} }
func (b browser) Indexes(ifModifiedSince time.Time) (domain.ArtistIndexes, time.Time, error) { func (b *browser) Indexes(ifModifiedSince time.Time) (domain.ArtistIndexes, time.Time, error) {
l, err := b.propRepo.DefaultGet(consts.LastScan, "-1") l, err := b.propRepo.DefaultGet(consts.LastScan, "-1")
ms, _ := strconv.ParseInt(l, 10, 64) ms, _ := strconv.ParseInt(l, 10, 64)
lastModified := utils.ToTime(ms) lastModified := utils.ToTime(ms)
@ -63,23 +63,23 @@ type DirectoryInfo struct {
UserRating int UserRating int
} }
func (c browser) Directory(id string) (*DirectoryInfo, error) { func (b *browser) Directory(id string) (*DirectoryInfo, error) {
var dir *DirectoryInfo var dir *DirectoryInfo
switch { switch {
case c.isArtist(id): case b.isArtist(id):
beego.Debug("Found Artist with id", id) beego.Debug("Found Artist with id", id)
a, albums, err := c.retrieveArtist(id) a, albums, err := b.retrieveArtist(id)
if err != nil { if err != nil {
return nil, err return nil, err
} }
dir = c.buildArtistDir(a, albums) dir = b.buildArtistDir(a, albums)
case c.isAlbum(id): case b.isAlbum(id):
beego.Debug("Found Album with id", id) beego.Debug("Found Album with id", id)
al, tracks, err := c.retrieveAlbum(id) al, tracks, err := b.retrieveAlbum(id)
if err != nil { if err != nil {
return nil, err return nil, err
} }
dir = c.buildAlbumDir(al, tracks) dir = b.buildAlbumDir(al, tracks)
default: default:
beego.Debug("Id", id, "not found") beego.Debug("Id", id, "not found")
return nil, ErrDataNotFound return nil, ErrDataNotFound
@ -88,7 +88,7 @@ func (c browser) Directory(id string) (*DirectoryInfo, error) {
return dir, nil return dir, nil
} }
func (c browser) buildArtistDir(a *domain.Artist, albums domain.Albums) *DirectoryInfo { func (b *browser) buildArtistDir(a *domain.Artist, albums domain.Albums) *DirectoryInfo {
dir := &DirectoryInfo{Id: a.Id, Name: a.Name} dir := &DirectoryInfo{Id: a.Id, Name: a.Name}
dir.Entries = make(Entries, len(albums)) dir.Entries = make(Entries, len(albums))
@ -99,7 +99,7 @@ func (c browser) buildArtistDir(a *domain.Artist, albums domain.Albums) *Directo
return dir return dir
} }
func (c browser) buildAlbumDir(al *domain.Album, tracks domain.MediaFiles) *DirectoryInfo { func (b *browser) buildAlbumDir(al *domain.Album, tracks domain.MediaFiles) *DirectoryInfo {
dir := &DirectoryInfo{ dir := &DirectoryInfo{
Id: al.Id, Id: al.Id,
Name: al.Name, Name: al.Name,
@ -118,8 +118,8 @@ func (c browser) buildAlbumDir(al *domain.Album, tracks domain.MediaFiles) *Dire
return dir return dir
} }
func (c browser) isArtist(id string) bool { func (b *browser) isArtist(id string) bool {
found, err := c.artistRepo.Exists(id) found, err := b.artistRepo.Exists(id)
if err != nil { if err != nil {
beego.Debug(fmt.Errorf("Error searching for Artist %s: %v", id, err)) beego.Debug(fmt.Errorf("Error searching for Artist %s: %v", id, err))
return false return false
@ -127,8 +127,8 @@ func (c browser) isArtist(id string) bool {
return found return found
} }
func (c browser) isAlbum(id string) bool { func (b *browser) isAlbum(id string) bool {
found, err := c.albumRepo.Exists(id) found, err := b.albumRepo.Exists(id)
if err != nil { if err != nil {
beego.Debug(fmt.Errorf("Error searching for Album %s: %v", id, err)) beego.Debug(fmt.Errorf("Error searching for Album %s: %v", id, err))
return false return false
@ -136,27 +136,27 @@ func (c browser) isAlbum(id string) bool {
return found return found
} }
func (c browser) retrieveArtist(id string) (a *domain.Artist, as domain.Albums, err error) { func (b *browser) retrieveArtist(id string) (a *domain.Artist, as domain.Albums, err error) {
a, err = c.artistRepo.Get(id) a, err = b.artistRepo.Get(id)
if err != nil { if err != nil {
err = fmt.Errorf("Error reading Artist %s from DB: %v", id, err) err = fmt.Errorf("Error reading Artist %s from DB: %v", id, err)
return return
} }
if as, err = c.albumRepo.FindByArtist(id); err != nil { if as, err = b.albumRepo.FindByArtist(id); err != nil {
err = fmt.Errorf("Error reading %s's albums from DB: %v", a.Name, err) err = fmt.Errorf("Error reading %s's albums from DB: %v", a.Name, err)
} }
return return
} }
func (c browser) retrieveAlbum(id string) (al *domain.Album, mfs domain.MediaFiles, err error) { func (b *browser) retrieveAlbum(id string) (al *domain.Album, mfs domain.MediaFiles, err error) {
al, err = c.albumRepo.Get(id) al, err = b.albumRepo.Get(id)
if err != nil { if err != nil {
err = fmt.Errorf("Error reading Album %s from DB: %v", id, err) err = fmt.Errorf("Error reading Album %s from DB: %v", id, err)
return return
} }
if mfs, err = c.mfileRepo.FindByAlbum(id); err != nil { if mfs, err = b.mfileRepo.FindByAlbum(id); err != nil {
err = fmt.Errorf("Error reading %s's tracks from DB: %v", al.Name, err) err = fmt.Errorf("Error reading %s's tracks from DB: %v", al.Name, err)
} }
return return

4
engine/cover.go
View File

@ -23,10 +23,10 @@ type cover struct {
} }
func NewCover(mr domain.MediaFileRepository) Cover { func NewCover(mr domain.MediaFileRepository) Cover {
return cover{mr} return &cover{mr}
} }
func (c cover) Get(id string, size int, out io.Writer) error { func (c *cover) Get(id string, size int, out io.Writer) error {
mf, err := c.mfileRepo.Get(id) mf, err := c.mfileRepo.Get(id)
if err != nil && err != domain.ErrNotFound { if err != nil && err != domain.ErrNotFound {
return err return err

22
engine/list_generator.go
View File

@ -21,7 +21,7 @@ type ListGenerator interface {
} }
func NewListGenerator(alr domain.AlbumRepository, mfr domain.MediaFileRepository, npr NowPlayingRepository) ListGenerator { func NewListGenerator(alr domain.AlbumRepository, mfr domain.MediaFileRepository, npr NowPlayingRepository) ListGenerator {
return listGenerator{alr, mfr, npr} return &listGenerator{alr, mfr, npr}
} }
type listGenerator struct { type listGenerator struct {
@ -30,7 +30,7 @@ type listGenerator struct {
npRepo NowPlayingRepository npRepo NowPlayingRepository
} }
func (g listGenerator) query(qo domain.QueryOptions, offset int, size int) (Entries, error) { func (g *listGenerator) query(qo domain.QueryOptions, offset int, size int) (Entries, error) {
qo.Offset = offset qo.Offset = offset
qo.Size = size qo.Size = size
albums, err := g.albumRepo.GetAll(qo) albums, err := g.albumRepo.GetAll(qo)
@ -38,37 +38,37 @@ func (g listGenerator) query(qo domain.QueryOptions, offset int, size int) (Entr
return FromAlbums(albums), err return FromAlbums(albums), err
} }
func (g listGenerator) GetNewest(offset int, size int) (Entries, error) { func (g *listGenerator) GetNewest(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{SortBy: "CreatedAt", Desc: true, Alpha: true} qo := domain.QueryOptions{SortBy: "CreatedAt", Desc: true, Alpha: true}
return g.query(qo, offset, size) return g.query(qo, offset, size)
} }
func (g listGenerator) GetRecent(offset int, size int) (Entries, error) { func (g *listGenerator) GetRecent(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{SortBy: "PlayDate", Desc: true, Alpha: true} qo := domain.QueryOptions{SortBy: "PlayDate", Desc: true, Alpha: true}
return g.query(qo, offset, size) return g.query(qo, offset, size)
} }
func (g listGenerator) GetFrequent(offset int, size int) (Entries, error) { func (g *listGenerator) GetFrequent(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{SortBy: "PlayCount", Desc: true} qo := domain.QueryOptions{SortBy: "PlayCount", Desc: true}
return g.query(qo, offset, size) return g.query(qo, offset, size)
} }
func (g listGenerator) GetHighest(offset int, size int) (Entries, error) { func (g *listGenerator) GetHighest(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{SortBy: "Rating", Desc: true} qo := domain.QueryOptions{SortBy: "Rating", Desc: true}
return g.query(qo, offset, size) return g.query(qo, offset, size)
} }
func (g listGenerator) GetByName(offset int, size int) (Entries, error) { func (g *listGenerator) GetByName(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{SortBy: "Name", Alpha: true} qo := domain.QueryOptions{SortBy: "Name", Alpha: true}
return g.query(qo, offset, size) return g.query(qo, offset, size)
} }
func (g listGenerator) GetByArtist(offset int, size int) (Entries, error) { func (g *listGenerator) GetByArtist(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{SortBy: "Artist", Alpha: true} qo := domain.QueryOptions{SortBy: "Artist", Alpha: true}
return g.query(qo, offset, size) return g.query(qo, offset, size)
} }
func (g listGenerator) GetRandom(offset int, size int) (Entries, error) { func (g *listGenerator) GetRandom(offset int, size int) (Entries, error) {
ids, err := g.albumRepo.GetAllIds() ids, err := g.albumRepo.GetAllIds()
if err != nil { if err != nil {
return nil, err return nil, err
@ -88,7 +88,7 @@ func (g listGenerator) GetRandom(offset int, size int) (Entries, error) {
return r, nil return r, nil
} }
func (g listGenerator) GetStarred(offset int, size int) (Entries, error) { func (g *listGenerator) GetStarred(offset int, size int) (Entries, error) {
qo := domain.QueryOptions{Offset: offset, Size: size} qo := domain.QueryOptions{Offset: offset, Size: size}
albums, err := g.albumRepo.GetStarred(qo) albums, err := g.albumRepo.GetStarred(qo)
if err != nil { if err != nil {
@ -98,7 +98,7 @@ func (g listGenerator) GetStarred(offset int, size int) (Entries, error) {
return FromAlbums(albums), nil return FromAlbums(albums), nil
} }
func (g listGenerator) GetNowPlaying() (Entries, error) { func (g *listGenerator) GetNowPlaying() (Entries, error) {
npInfo, err := g.npRepo.GetAll() npInfo, err := g.npRepo.GetAll()
if err != nil { if err != nil {
return nil, err return nil, err

6
engine/playlists.go
View File

@ -10,7 +10,7 @@ type Playlists interface {
} }
func NewPlaylists(pr domain.PlaylistRepository, mr domain.MediaFileRepository) Playlists { func NewPlaylists(pr domain.PlaylistRepository, mr domain.MediaFileRepository) Playlists {
return playlists{pr, mr} return &playlists{pr, mr}
} }
type playlists struct { type playlists struct {
@ -18,7 +18,7 @@ type playlists struct {
mfileRepo domain.MediaFileRepository mfileRepo domain.MediaFileRepository
} }
func (p playlists) GetAll() (domain.Playlists, error) { func (p *playlists) GetAll() (domain.Playlists, error) {
return p.plsRepo.GetAll(domain.QueryOptions{}) return p.plsRepo.GetAll(domain.QueryOptions{})
} }
@ -32,7 +32,7 @@ type PlaylistInfo struct {
Owner string Owner string
} }
func (p playlists) Get(id string) (*PlaylistInfo, error) { func (p *playlists) Get(id string) (*PlaylistInfo, error) {
pl, err := p.plsRepo.Get(id) pl, err := p.plsRepo.Get(id)
if err == domain.ErrNotFound { if err == domain.ErrNotFound {
return nil, ErrDataNotFound return nil, ErrDataNotFound

22
engine/search.go
View File

@ -37,7 +37,7 @@ type search struct {
} }
func NewSearch(ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository, db gomate.DB) Search { func NewSearch(ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository, db gomate.DB) Search {
s := search{artistRepo: ar, albumRepo: alr, mfileRepo: mr} s := &search{artistRepo: ar, albumRepo: alr, mfileRepo: mr}
s.idxArtist = gomate.NewIndexer(db, "gomate-artist-idx") s.idxArtist = gomate.NewIndexer(db, "gomate-artist-idx")
s.sArtist = gomate.NewSearcher(db, "gomate-artist-idx") s.sArtist = gomate.NewSearcher(db, "gomate-artist-idx")
s.idxAlbum = gomate.NewIndexer(db, "gomate-album-idx") s.idxAlbum = gomate.NewIndexer(db, "gomate-album-idx")
@ -47,37 +47,37 @@ func NewSearch(ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain
return s return s
} }
func (s search) ClearAll() error { func (s *search) ClearAll() error {
return s.idxArtist.Clear() return s.idxArtist.Clear()
return s.idxAlbum.Clear() return s.idxAlbum.Clear()
return s.idxSong.Clear() return s.idxSong.Clear()
} }
func (s search) IndexArtist(ar *domain.Artist) error { func (s *search) IndexArtist(ar *domain.Artist) error {
return s.idxArtist.Index(ar.Id, sanitize.Accents(strings.ToLower(ar.Name))) return s.idxArtist.Index(ar.Id, sanitize.Accents(strings.ToLower(ar.Name)))
} }
func (s search) IndexAlbum(al *domain.Album) error { func (s *search) IndexAlbum(al *domain.Album) error {
return s.idxAlbum.Index(al.Id, sanitize.Accents(strings.ToLower(al.Name))) return s.idxAlbum.Index(al.Id, sanitize.Accents(strings.ToLower(al.Name)))
} }
func (s search) IndexMediaFile(mf *domain.MediaFile) error { func (s *search) IndexMediaFile(mf *domain.MediaFile) error {
return s.idxSong.Index(mf.Id, sanitize.Accents(strings.ToLower(mf.Title))) return s.idxSong.Index(mf.Id, sanitize.Accents(strings.ToLower(mf.Title)))
} }
func (s search) RemoveArtist(ids []string) error { func (s *search) RemoveArtist(ids []string) error {
return s.idxArtist.Remove(ids...) return s.idxArtist.Remove(ids...)
} }
func (s search) RemoveAlbum(ids []string) error { func (s *search) RemoveAlbum(ids []string) error {
return s.idxAlbum.Remove(ids...) return s.idxAlbum.Remove(ids...)
} }
func (s search) RemoveMediaFile(ids []string) error { func (s *search) RemoveMediaFile(ids []string) error {
return s.idxSong.Remove(ids...) return s.idxSong.Remove(ids...)
} }
func (s search) SearchArtist(q string, offset int, size int) (Entries, error) { func (s *search) SearchArtist(q string, offset int, size int) (Entries, error) {
q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*"))) q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
min := offset min := offset
max := min + size - 1 max := min + size - 1
@ -98,7 +98,7 @@ func (s search) SearchArtist(q string, offset int, size int) (Entries, error) {
return res, nil return res, nil
} }
func (s search) SearchAlbum(q string, offset int, size int) (Entries, error) { func (s *search) SearchAlbum(q string, offset int, size int) (Entries, error) {
q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*"))) q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
min := offset min := offset
max := min + size - 1 max := min + size - 1
@ -119,7 +119,7 @@ func (s search) SearchAlbum(q string, offset int, size int) (Entries, error) {
return res, nil return res, nil
} }
func (s search) SearchSong(q string, offset int, size int) (Entries, error) { func (s *search) SearchSong(q string, offset int, size int) (Entries, error) {
q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*"))) q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
min := offset min := offset
max := min + size - 1 max := min + size - 1