arian/navidrome
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Rename domain to model

Browse Source
This commit is contained in:
Deluan
2020-01-14 22:22:34 -05:00
parent 25686c1742
commit 0ea2bd79d9
54 changed files with 404 additions and 404 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scanner_legacy/importer.go
+26 -26
View File
@@ -8,35 +8,35 @@ import (
"time"
"github.com/cloudsonic/sonic-server/conf"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/log"
"github.com/cloudsonic/sonic-server/model"
"github.com/cloudsonic/sonic-server/utils"
)
type Scanner interface {
ScanLibrary(lastModifiedSince time.Time, path string) (int, error)
MediaFiles() map[string]*domain.MediaFile
Albums() map[string]*domain.Album
Artists() map[string]*domain.Artist
Playlists() map[string]*domain.Playlist
MediaFiles() map[string]*model.MediaFile
Albums() map[string]*model.Album
Artists() map[string]*model.Artist
Playlists() map[string]*model.Playlist
}
type tempIndex map[string]domain.ArtistInfo
type tempIndex map[string]model.ArtistInfo
type Importer struct {
scanner Scanner
mediaFolder string
mfRepo domain.MediaFileRepository
albumRepo domain.AlbumRepository
artistRepo domain.ArtistRepository
idxRepo domain.ArtistIndexRepository
plsRepo domain.PlaylistRepository
propertyRepo domain.PropertyRepository
mfRepo model.MediaFileRepository
albumRepo model.AlbumRepository
artistRepo model.ArtistRepository
idxRepo model.ArtistIndexRepository
plsRepo model.PlaylistRepository
propertyRepo model.PropertyRepository
lastScan time.Time
lastCheck time.Time
}
func NewImporter(mediaFolder string, scanner Scanner, mfRepo domain.MediaFileRepository, albumRepo domain.AlbumRepository, artistRepo domain.ArtistRepository, idxRepo domain.ArtistIndexRepository, plsRepo domain.PlaylistRepository, propertyRepo domain.PropertyRepository) *Importer {
func NewImporter(mediaFolder string, scanner Scanner, mfRepo model.MediaFileRepository, albumRepo model.AlbumRepository, artistRepo model.ArtistRepository, idxRepo model.ArtistIndexRepository, plsRepo model.PlaylistRepository, propertyRepo model.PropertyRepository) *Importer {
return &Importer{
scanner: scanner,
mediaFolder: mediaFolder,
@@ -103,7 +103,7 @@ func (i *Importer) scan() {
}
func (i *Importer) lastModifiedSince() time.Time {
ms, err := i.propertyRepo.Get(domain.PropLastScan)
ms, err := i.propertyRepo.Get(model.PropLastScan)
if err != nil {
log.Warn("Couldn't read LastScan", err)
return time.Time{}
@@ -161,15 +161,15 @@ func (i *Importer) importLibrary() (err error) {
if err == nil {
millis := time.Now().UnixNano() / int64(time.Millisecond)
i.propertyRepo.Put(domain.PropLastScan, fmt.Sprint(millis))
i.propertyRepo.Put(model.PropLastScan, fmt.Sprint(millis))
log.Debug("LastScan", "timestamp", millis)
}
return err
}
func (i *Importer) importMediaFiles() (domain.MediaFiles, int) {
mfs := make(domain.MediaFiles, len(i.scanner.MediaFiles()))
func (i *Importer) importMediaFiles() (model.MediaFiles, int) {
mfs := make(model.MediaFiles, len(i.scanner.MediaFiles()))
updates := 0
j := 0
for _, mf := range i.scanner.MediaFiles() {
@@ -197,8 +197,8 @@ func (i *Importer) importMediaFiles() (domain.MediaFiles, int) {
return mfs, updates
}
func (i *Importer) importAlbums() (domain.Albums, int) {
als := make(domain.Albums, len(i.scanner.Albums()))
func (i *Importer) importAlbums() (model.Albums, int) {
als := make(model.Albums, len(i.scanner.Albums()))
updates := 0
j := 0
for _, al := range i.scanner.Albums() {
@@ -226,8 +226,8 @@ func (i *Importer) importAlbums() (domain.Albums, int) {
return als, updates
}
func (i *Importer) importArtists() domain.Artists {
ars := make(domain.Artists, len(i.scanner.Artists()))
func (i *Importer) importArtists() model.Artists {
ars := make(model.Artists, len(i.scanner.Artists()))
j := 0
for _, ar := range i.scanner.Artists() {
ars[j] = *ar
@@ -252,8 +252,8 @@ func (i *Importer) importArtistIndex() {
}
}
func (i *Importer) importPlaylists() domain.Playlists {
pls := make(domain.Playlists, len(i.scanner.Playlists()))
func (i *Importer) importPlaylists() model.Playlists {
pls := make(model.Playlists, len(i.scanner.Playlists()))
j := 0
for _, pl := range i.scanner.Playlists() {
pl.Public = true
@@ -268,7 +268,7 @@ func (i *Importer) importPlaylists() domain.Playlists {
return pls
}
func (i *Importer) collectIndex(ig utils.IndexGroups, a *domain.Artist, artistIndex map[string]tempIndex) {
func (i *Importer) collectIndex(ig utils.IndexGroups, a *model.Artist, artistIndex map[string]tempIndex) {
name := a.Name
indexName := strings.ToLower(utils.NoArticle(name))
if indexName == "" {
@@ -280,7 +280,7 @@ func (i *Importer) collectIndex(ig utils.IndexGroups, a *domain.Artist, artistIn
artists = make(tempIndex)
artistIndex[group] = artists
}
artists[indexName] = domain.ArtistInfo{ArtistID: a.ID, Artist: a.Name, AlbumCount: a.AlbumCount}
artists[indexName] = model.ArtistInfo{ArtistID: a.ID, Artist: a.Name, AlbumCount: a.AlbumCount}
}
func (i *Importer) findGroup(ig utils.IndexGroups, name string) string {
@@ -296,7 +296,7 @@ func (i *Importer) findGroup(ig utils.IndexGroups, name string) string {
func (i *Importer) saveIndex(artistIndex map[string]tempIndex) error {
i.idxRepo.DeleteAll()
for k, temp := range artistIndex {
idx := &domain.ArtistIndex{ID: k}
idx := &model.ArtistIndex{ID: k}
for _, v := range temp {
idx.Artists = append(idx.Artists, v)
}
scanner_legacy/importer_test.go
+5 -5
View File
@@ -3,7 +3,7 @@ package scanner_legacy
import (
"testing"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
"github.com/cloudsonic/sonic-server/tests"
"github.com/cloudsonic/sonic-server/utils"
. "github.com/smartystreets/goconvey/convey"
@@ -17,7 +17,7 @@ func TestCollectIndex(t *testing.T) {
importer := &Importer{}
Convey("Simple Name", t, func() {
a := &domain.Artist{Name: "Björk"}
a := &model.Artist{Name: "Björk"}
artistIndex := make(map[string]tempIndex)
importer.collectIndex(ig, a, artistIndex)
@@ -31,7 +31,7 @@ func TestCollectIndex(t *testing.T) {
})
Convey("Name not in the index", t, func() {
a := &domain.Artist{Name: "Kraftwerk"}
a := &model.Artist{Name: "Kraftwerk"}
artistIndex := make(map[string]tempIndex)
importer.collectIndex(ig, a, artistIndex)
@@ -45,7 +45,7 @@ func TestCollectIndex(t *testing.T) {
})
Convey("Name starts with an article", t, func() {
a := &domain.Artist{Name: "The The"}
a := &model.Artist{Name: "The The"}
artistIndex := make(map[string]tempIndex)
importer.collectIndex(ig, a, artistIndex)
@@ -59,7 +59,7 @@ func TestCollectIndex(t *testing.T) {
})
Convey("Name match a multichar entry", t, func() {
a := &domain.Artist{Name: "Tom Waits"}
a := &model.Artist{Name: "Tom Waits"}
artistIndex := make(map[string]tempIndex)
importer.collectIndex(ig, a, artistIndex)
scanner_legacy/itunes_scanner.go
+24 -24
View File
@@ -14,25 +14,25 @@ import (
"time"
"github.com/cloudsonic/sonic-server/conf"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/log"
"github.com/cloudsonic/sonic-server/model"
"github.com/dhowden/itl"
"github.com/dhowden/tag"
)
type ItunesScanner struct {
mediaFiles map[string]*domain.MediaFile
albums map[string]*domain.Album
artists map[string]*domain.Artist
playlists map[string]*domain.Playlist
mediaFiles map[string]*model.MediaFile
albums map[string]*model.Album
artists map[string]*model.Artist
playlists map[string]*model.Playlist
pplaylists map[string]plsRelation
pmediaFiles map[int]*domain.MediaFile
pmediaFiles map[int]*model.MediaFile
lastModifiedSince time.Time
checksumRepo domain.CheckSumRepository
checksumRepo model.CheckSumRepository
newSums map[string]string
}
func NewItunesScanner(checksumRepo domain.CheckSumRepository) *ItunesScanner {
func NewItunesScanner(checksumRepo model.CheckSumRepository) *ItunesScanner {
return &ItunesScanner{checksumRepo: checksumRepo}
}
@@ -52,12 +52,12 @@ func (s *ItunesScanner) ScanLibrary(lastModifiedSince time.Time, path string) (i
log.Debug("Loaded tracks", "total", len(l.Tracks))
s.lastModifiedSince = lastModifiedSince
s.mediaFiles = make(map[string]*domain.MediaFile)
s.albums = make(map[string]*domain.Album)
s.artists = make(map[string]*domain.Artist)
s.playlists = make(map[string]*domain.Playlist)
s.mediaFiles = make(map[string]*model.MediaFile)
s.albums = make(map[string]*model.Album)
s.artists = make(map[string]*model.Artist)
s.playlists = make(map[string]*model.Playlist)
s.pplaylists = make(map[string]plsRelation)
s.pmediaFiles = make(map[int]*domain.MediaFile)
s.pmediaFiles = make(map[int]*model.MediaFile)
s.newSums = make(map[string]string)
songsPerAlbum := make(map[string]int)
albumsPerArtist := make(map[string]map[string]bool)
@@ -117,16 +117,16 @@ func (s *ItunesScanner) ScanLibrary(lastModifiedSince time.Time, path string) (i
return len(l.Tracks), nil
}
func (s *ItunesScanner) MediaFiles() map[string]*domain.MediaFile {
func (s *ItunesScanner) MediaFiles() map[string]*model.MediaFile {
return s.mediaFiles
}
func (s *ItunesScanner) Albums() map[string]*domain.Album {
func (s *ItunesScanner) Albums() map[string]*model.Album {
return s.albums
}
func (s *ItunesScanner) Artists() map[string]*domain.Artist {
func (s *ItunesScanner) Artists() map[string]*model.Artist {
return s.artists
}
func (s *ItunesScanner) Playlists() map[string]*domain.Playlist {
func (s *ItunesScanner) Playlists() map[string]*model.Playlist {
return s.playlists
}
@@ -169,7 +169,7 @@ func (s *ItunesScanner) skipPlaylist(p *itl.Playlist, ignFolders bool, ignPatter
}
func (s *ItunesScanner) collectPlaylists(p *itl.Playlist, fullPath string) {
pl := &domain.Playlist{}
pl := &model.Playlist{}
pl.ID = p.PlaylistPersistentID
pl.Name = unescape(p.Name)
pl.FullPath = fullPath
@@ -227,8 +227,8 @@ func (s *ItunesScanner) calcCheckSum(t *itl.Track) string {
return sum
}
func (s *ItunesScanner) collectMediaFiles(t *itl.Track) *domain.MediaFile {
mf := &domain.MediaFile{}
func (s *ItunesScanner) collectMediaFiles(t *itl.Track) *model.MediaFile {
mf := &model.MediaFile{}
mf.ID = t.PersistentID
mf.Album = unescape(t.Album)
mf.AlbumID = albumId(t)
@@ -276,11 +276,11 @@ func (s *ItunesScanner) collectMediaFiles(t *itl.Track) *domain.MediaFile {
return mf
}
func (s *ItunesScanner) collectAlbums(t *itl.Track, mf *domain.MediaFile, ar *domain.Artist) *domain.Album {
func (s *ItunesScanner) collectAlbums(t *itl.Track, mf *model.MediaFile, ar *model.Artist) *model.Album {
id := albumId(t)
_, found := s.albums[id]
if !found {
s.albums[id] = &domain.Album{}
s.albums[id] = &model.Album{}
}
al := s.albums[id]
@@ -322,11 +322,11 @@ func (s *ItunesScanner) collectAlbums(t *itl.Track, mf *domain.MediaFile, ar *do
return al
}
func (s *ItunesScanner) collectArtists(t *itl.Track) *domain.Artist {
func (s *ItunesScanner) collectArtists(t *itl.Track) *model.Artist {
id := artistId(t)
_, found := s.artists[id]
if !found {
s.artists[id] = &domain.Artist{}
s.artists[id] = &model.Artist{}
}
ar := s.artists[id]
ar.ID = id