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
persistence/album_repository.go
+17 -17
View File
@@ -4,7 +4,7 @@ import (
"time"
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
type Album struct {
@@ -33,33 +33,33 @@ type albumRepository struct {
searchableRepository
}
func NewAlbumRepository() domain.AlbumRepository {
func NewAlbumRepository() model.AlbumRepository {
r := &albumRepository{}
r.tableName = "album"
return r
}
func (r *albumRepository) Put(a *domain.Album) error {
func (r *albumRepository) Put(a *model.Album) error {
ta := Album(*a)
return withTx(func(o orm.Ormer) error {
return r.put(o, a.ID, a.Name, &ta)
})
}
func (r *albumRepository) Get(id string) (*domain.Album, error) {
func (r *albumRepository) Get(id string) (*model.Album, error) {
ta := Album{ID: id}
err := Db().Read(&ta)
if err == orm.ErrNoRows {
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
if err != nil {
return nil, err
}
a := domain.Album(ta)
a := model.Album(ta)
return &a, err
}
func (r *albumRepository) FindByArtist(artistId string) (domain.Albums, error) {
func (r *albumRepository) FindByArtist(artistId string) (model.Albums, error) {
var albums []Album
_, err := r.newQuery(Db()).Filter("artist_id", artistId).OrderBy("year", "name").All(&albums)
if err != nil {
@@ -68,7 +68,7 @@ func (r *albumRepository) FindByArtist(artistId string) (domain.Albums, error) {
return r.toAlbums(albums), nil
}
func (r *albumRepository) GetAll(options ...domain.QueryOptions) (domain.Albums, error) {
func (r *albumRepository) GetAll(options ...model.QueryOptions) (model.Albums, error) {
var all []Album
_, err := r.newQuery(Db(), options...).All(&all)
if err != nil {
@@ -77,25 +77,25 @@ func (r *albumRepository) GetAll(options ...domain.QueryOptions) (domain.Albums,
return r.toAlbums(all), nil
}
func (r *albumRepository) toAlbums(all []Album) domain.Albums {
result := make(domain.Albums, len(all))
func (r *albumRepository) toAlbums(all []Album) model.Albums {
result := make(model.Albums, len(all))
for i, a := range all {
result[i] = domain.Album(a)
result[i] = model.Album(a)
}
return result
}
// TODO Remove []string from return
func (r *albumRepository) PurgeInactive(activeList domain.Albums) error {
func (r *albumRepository) PurgeInactive(activeList model.Albums) error {
return withTx(func(o orm.Ormer) error {
_, err := r.purgeInactive(o, activeList, func(item interface{}) string {
return item.(domain.Album).ID
return item.(model.Album).ID
})
return err
})
}
func (r *albumRepository) GetStarred(options ...domain.QueryOptions) (domain.Albums, error) {
func (r *albumRepository) GetStarred(options ...model.QueryOptions) (model.Albums, error) {
var starred []Album
_, err := r.newQuery(Db(), options...).Filter("starred", true).All(&starred)
if err != nil {
@@ -104,7 +104,7 @@ func (r *albumRepository) GetStarred(options ...domain.QueryOptions) (domain.Alb
return r.toAlbums(starred), nil
}
func (r *albumRepository) Search(q string, offset int, size int) (domain.Albums, error) {
func (r *albumRepository) Search(q string, offset int, size int) (model.Albums, error) {
if len(q) <= 2 {
return nil, nil
}
@@ -117,5 +117,5 @@ func (r *albumRepository) Search(q string, offset int, size int) (domain.Albums,
return r.toAlbums(results), nil
}
var _ domain.AlbumRepository = (*albumRepository)(nil)
var _ = domain.Album(Album{})
var _ model.AlbumRepository = (*albumRepository)(nil)
var _ = model.Album(Album{})
persistence/album_repository_test.go
+7 -7
View File
@@ -1,13 +1,13 @@
package persistence
import (
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("AlbumRepository", func() {
var repo domain.AlbumRepository
var repo model.AlbumRepository
BeforeEach(func() {
repo = NewAlbumRepository()
@@ -19,7 +19,7 @@ var _ = Describe("AlbumRepository", func() {
})
It("returns all records sorted", func() {
Expect(repo.GetAll(domain.QueryOptions{SortBy: "Name"})).To(Equal(domain.Albums{
Expect(repo.GetAll(model.QueryOptions{SortBy: "Name"})).To(Equal(model.Albums{
{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
@@ -27,7 +27,7 @@ var _ = Describe("AlbumRepository", func() {
})
It("returns all records sorted desc", func() {
Expect(repo.GetAll(domain.QueryOptions{SortBy: "Name", Desc: true})).To(Equal(domain.Albums{
Expect(repo.GetAll(model.QueryOptions{SortBy: "Name", Desc: true})).To(Equal(model.Albums{
{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
@@ -35,7 +35,7 @@ var _ = Describe("AlbumRepository", func() {
})
It("paginates the result", func() {
Expect(repo.GetAll(domain.QueryOptions{Offset: 1, Size: 1})).To(Equal(domain.Albums{
Expect(repo.GetAll(model.QueryOptions{Offset: 1, Size: 1})).To(Equal(model.Albums{
{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
}))
})
@@ -49,7 +49,7 @@ var _ = Describe("AlbumRepository", func() {
Describe("GetStarred", func() {
It("returns all starred records", func() {
Expect(repo.GetStarred(domain.QueryOptions{})).To(Equal(domain.Albums{
Expect(repo.GetStarred(model.QueryOptions{})).To(Equal(model.Albums{
{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
}))
})
@@ -57,7 +57,7 @@ var _ = Describe("AlbumRepository", func() {
Describe("FindByArtist", func() {
It("returns all records from a given ArtistID", func() {
Expect(repo.FindByArtist("1")).To(Equal(domain.Albums{
Expect(repo.FindByArtist("1")).To(Equal(model.Albums{
{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
}))
persistence/artist_repository.go
+14 -14
View File
@@ -2,7 +2,7 @@ package persistence
import (
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
// This is used to isolate Storm's struct tags from the domain, to keep it agnostic of persistence details
@@ -16,42 +16,42 @@ type artistRepository struct {
searchableRepository
}
func NewArtistRepository() domain.ArtistRepository {
func NewArtistRepository() model.ArtistRepository {
r := &artistRepository{}
r.tableName = "artist"
return r
}
func (r *artistRepository) Put(a *domain.Artist) error {
func (r *artistRepository) Put(a *model.Artist) error {
ta := Artist(*a)
return withTx(func(o orm.Ormer) error {
return r.put(o, a.ID, a.Name, &ta)
})
}
func (r *artistRepository) Get(id string) (*domain.Artist, error) {
func (r *artistRepository) Get(id string) (*model.Artist, error) {
ta := Artist{ID: id}
err := Db().Read(&ta)
if err == orm.ErrNoRows {
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
if err != nil {
return nil, err
}
a := domain.Artist(ta)
a := model.Artist(ta)
return &a, nil
}
func (r *artistRepository) PurgeInactive(activeList domain.Artists) error {
func (r *artistRepository) PurgeInactive(activeList model.Artists) error {
return withTx(func(o orm.Ormer) error {
_, err := r.purgeInactive(o, activeList, func(item interface{}) string {
return item.(domain.Artist).ID
return item.(model.Artist).ID
})
return err
})
}
func (r *artistRepository) Search(q string, offset int, size int) (domain.Artists, error) {
func (r *artistRepository) Search(q string, offset int, size int) (model.Artists, error) {
if len(q) <= 2 {
return nil, nil
}
@@ -65,13 +65,13 @@ func (r *artistRepository) Search(q string, offset int, size int) (domain.Artist
return r.toArtists(results), nil
}
func (r *artistRepository) toArtists(all []Artist) domain.Artists {
result := make(domain.Artists, len(all))
func (r *artistRepository) toArtists(all []Artist) model.Artists {
result := make(model.Artists, len(all))
for i, a := range all {
result[i] = domain.Artist(a)
result[i] = model.Artist(a)
}
return result
}
var _ domain.ArtistRepository = (*artistRepository)(nil)
var _ = domain.Artist(Artist{})
var _ model.ArtistRepository = (*artistRepository)(nil)
var _ = model.Artist(Artist{})
persistence/artist_repository_test.go
+8 -8
View File
@@ -1,30 +1,30 @@
package persistence
import (
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("ArtistRepository", func() {
var repo domain.ArtistRepository
var repo model.ArtistRepository
BeforeEach(func() {
repo = NewArtistRepository()
})
It("saves and retrieves data", func() {
Expect(repo.Get("1")).To(Equal(&domain.Artist{ID: "1", Name: "Saara Saara", AlbumCount: 2}))
Expect(repo.Get("1")).To(Equal(&model.Artist{ID: "1", Name: "Saara Saara", AlbumCount: 2}))
})
It("overrides data if ID already exists", func() {
Expect(repo.Put(&domain.Artist{ID: "1", Name: "Saara Saara is The Best!", AlbumCount: 3})).To(BeNil())
Expect(repo.Get("1")).To(Equal(&domain.Artist{ID: "1", Name: "Saara Saara is The Best!", AlbumCount: 3}))
Expect(repo.Put(&model.Artist{ID: "1", Name: "Saara Saara is The Best!", AlbumCount: 3})).To(BeNil())
Expect(repo.Get("1")).To(Equal(&model.Artist{ID: "1", Name: "Saara Saara is The Best!", AlbumCount: 3}))
})
It("returns ErrNotFound when the ID does not exist", func() {
_, err := repo.Get("999")
Expect(err).To(MatchError(domain.ErrNotFound))
Expect(err).To(MatchError(model.ErrNotFound))
})
Describe("PurgeInactive", func() {
@@ -35,7 +35,7 @@ var _ = Describe("ArtistRepository", func() {
})
It("purges inactive records", func() {
active := domain.Artists{{ID: "1"}, {ID: "3"}}
active := model.Artists{{ID: "1"}, {ID: "3"}}
Expect(repo.PurgeInactive(active)).To(BeNil())
@@ -44,7 +44,7 @@ var _ = Describe("ArtistRepository", func() {
})
It("doesn't delete anything if all is active", func() {
active := domain.Artists{{ID: "1"}, {ID: "2"}, {ID: "3"}}
active := model.Artists{{ID: "1"}, {ID: "2"}, {ID: "3"}}
Expect(repo.PurgeInactive(active)).To(BeNil())
persistence/checksum_repository.go
+3 -3
View File
@@ -2,8 +2,8 @@ package persistence
import (
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/log"
"github.com/cloudsonic/sonic-server/model"
)
type checkSumRepository struct {
@@ -17,7 +17,7 @@ type Checksum struct {
Sum string
}
func NewCheckSumRepository() domain.CheckSumRepository {
func NewCheckSumRepository() model.CheckSumRepository {
r := &checkSumRepository{}
return r
}
@@ -76,4 +76,4 @@ func (r *checkSumRepository) SetData(newSums map[string]string) error {
return nil
}
var _ domain.CheckSumRepository = (*checkSumRepository)(nil)
var _ model.CheckSumRepository = (*checkSumRepository)(nil)
persistence/checksum_repository_test.go
+2 -2
View File
@@ -1,13 +1,13 @@
package persistence
import (
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("ChecksumRepository", func() {
var repo domain.CheckSumRepository
var repo model.CheckSumRepository
BeforeEach(func() {
Db().Delete(&Checksum{ID: checkSumId})
persistence/index_repository.go
+13 -13
View File
@@ -4,7 +4,7 @@ import (
"sort"
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
type ArtistInfo struct {
@@ -19,7 +19,7 @@ type artistIndexRepository struct {
sqlRepository
}
func NewArtistIndexRepository() domain.ArtistIndexRepository {
func NewArtistIndexRepository() model.ArtistIndexRepository {
r := &artistIndexRepository{}
r.tableName = "artist_info"
return r
@@ -34,7 +34,7 @@ func (r *artistIndexRepository) CountAll() (int64, error) {
return count.Count, nil
}
func (r *artistIndexRepository) Put(idx *domain.ArtistIndex) error {
func (r *artistIndexRepository) Put(idx *model.ArtistIndex) error {
return withTx(func(o orm.Ormer) error {
_, err := r.newQuery(o).Filter("idx", idx.ID).Delete()
if err != nil {
@@ -56,17 +56,17 @@ func (r *artistIndexRepository) Put(idx *domain.ArtistIndex) error {
})
}
func (r *artistIndexRepository) Get(id string) (*domain.ArtistIndex, error) {
func (r *artistIndexRepository) Get(id string) (*model.ArtistIndex, error) {
var ais []ArtistInfo
_, err := r.newQuery(Db()).Filter("idx", id).All(&ais)
if err != nil {
return nil, err
}
idx := &domain.ArtistIndex{ID: id}
idx.Artists = make([]domain.ArtistInfo, len(ais))
idx := &model.ArtistIndex{ID: id}
idx.Artists = make([]model.ArtistInfo, len(ais))
for i, a := range ais {
idx.Artists[i] = domain.ArtistInfo{
idx.Artists[i] = model.ArtistInfo{
ArtistID: a.ArtistID,
Artist: a.Artist,
AlbumCount: a.AlbumCount,
@@ -75,27 +75,27 @@ func (r *artistIndexRepository) Get(id string) (*domain.ArtistIndex, error) {
return idx, err
}
func (r *artistIndexRepository) GetAll() (domain.ArtistIndexes, error) {
func (r *artistIndexRepository) GetAll() (model.ArtistIndexes, error) {
var all []ArtistInfo
_, err := r.newQuery(Db()).OrderBy("idx", "artist").All(&all)
if err != nil {
return nil, err
}
fullIdx := make(map[string]*domain.ArtistIndex)
fullIdx := make(map[string]*model.ArtistIndex)
for _, a := range all {
idx, ok := fullIdx[a.Idx]
if !ok {
idx = &domain.ArtistIndex{ID: a.Idx}
idx = &model.ArtistIndex{ID: a.Idx}
fullIdx[a.Idx] = idx
}
idx.Artists = append(idx.Artists, domain.ArtistInfo{
idx.Artists = append(idx.Artists, model.ArtistInfo{
ArtistID: a.ArtistID,
Artist: a.Artist,
AlbumCount: a.AlbumCount,
})
}
var result domain.ArtistIndexes
var result model.ArtistIndexes
for _, idx := range fullIdx {
result = append(result, *idx)
}
@@ -105,4 +105,4 @@ func (r *artistIndexRepository) GetAll() (domain.ArtistIndexes, error) {
return result, nil
}
var _ domain.ArtistIndexRepository = (*artistIndexRepository)(nil)
var _ model.ArtistIndexRepository = (*artistIndexRepository)(nil)
persistence/index_repository_test.go
+7 -7
View File
@@ -1,13 +1,13 @@
package persistence
import (
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Artist Index", func() {
var repo domain.ArtistIndexRepository
var repo model.ArtistIndexRepository
BeforeEach(func() {
repo = NewArtistIndexRepository()
@@ -18,16 +18,16 @@ var _ = Describe("Artist Index", func() {
})
It("successfully persists data", func() {
idx1 := domain.ArtistIndex{
idx1 := model.ArtistIndex{
ID: "D",
Artists: domain.ArtistInfos{
Artists: model.ArtistInfos{
{ArtistID: "4", Artist: "Doobie Brothers", AlbumCount: 2},
{ArtistID: "3", Artist: "The Doors", AlbumCount: 5},
},
}
idx2 := domain.ArtistIndex{
idx2 := model.ArtistIndex{
ID: "S",
Artists: domain.ArtistInfos{
Artists: model.ArtistInfos{
{ArtistID: "1", Artist: "Saara Saara", AlbumCount: 3},
{ArtistID: "2", Artist: "Seu Jorge", AlbumCount: 1},
},
@@ -37,7 +37,7 @@ var _ = Describe("Artist Index", func() {
Expect(repo.Put(&idx2)).To(BeNil())
Expect(repo.Get("D")).To(Equal(&idx1))
Expect(repo.Get("S")).To(Equal(&idx2))
Expect(repo.GetAll()).To(Equal(domain.ArtistIndexes{idx1, idx2}))
Expect(repo.GetAll()).To(Equal(model.ArtistIndexes{idx1, idx2}))
Expect(repo.CountAll()).To(Equal(int64(2)))
Expect(repo.DeleteAll()).To(BeNil())
Expect(repo.CountAll()).To(Equal(int64(0)))
persistence/mediafile_repository.go
+16 -16
View File
@@ -4,7 +4,7 @@ import (
"time"
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
type MediaFile struct {
@@ -39,41 +39,41 @@ type mediaFileRepository struct {
searchableRepository
}
func NewMediaFileRepository() domain.MediaFileRepository {
func NewMediaFileRepository() model.MediaFileRepository {
r := &mediaFileRepository{}
r.tableName = "media_file"
return r
}
func (r *mediaFileRepository) Put(m *domain.MediaFile) error {
func (r *mediaFileRepository) Put(m *model.MediaFile) error {
tm := MediaFile(*m)
return withTx(func(o orm.Ormer) error {
return r.put(o, m.ID, m.Title, &tm)
})
}
func (r *mediaFileRepository) Get(id string) (*domain.MediaFile, error) {
func (r *mediaFileRepository) Get(id string) (*model.MediaFile, error) {
tm := MediaFile{ID: id}
err := Db().Read(&tm)
if err == orm.ErrNoRows {
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
if err != nil {
return nil, err
}
a := domain.MediaFile(tm)
a := model.MediaFile(tm)
return &a, nil
}
func (r *mediaFileRepository) toMediaFiles(all []MediaFile) domain.MediaFiles {
result := make(domain.MediaFiles, len(all))
func (r *mediaFileRepository) toMediaFiles(all []MediaFile) model.MediaFiles {
result := make(model.MediaFiles, len(all))
for i, m := range all {
result[i] = domain.MediaFile(m)
result[i] = model.MediaFile(m)
}
return result
}
func (r *mediaFileRepository) FindByAlbum(albumId string) (domain.MediaFiles, error) {
func (r *mediaFileRepository) FindByAlbum(albumId string) (model.MediaFiles, error) {
var mfs []MediaFile
_, err := r.newQuery(Db()).Filter("album_id", albumId).OrderBy("disc_number", "track_number").All(&mfs)
if err != nil {
@@ -82,7 +82,7 @@ func (r *mediaFileRepository) FindByAlbum(albumId string) (domain.MediaFiles, er
return r.toMediaFiles(mfs), nil
}
func (r *mediaFileRepository) GetStarred(options ...domain.QueryOptions) (domain.MediaFiles, error) {
func (r *mediaFileRepository) GetStarred(options ...model.QueryOptions) (model.MediaFiles, error) {
var starred []MediaFile
_, err := r.newQuery(Db(), options...).Filter("starred", true).All(&starred)
if err != nil {
@@ -91,16 +91,16 @@ func (r *mediaFileRepository) GetStarred(options ...domain.QueryOptions) (domain
return r.toMediaFiles(starred), nil
}
func (r *mediaFileRepository) PurgeInactive(activeList domain.MediaFiles) error {
func (r *mediaFileRepository) PurgeInactive(activeList model.MediaFiles) error {
return withTx(func(o orm.Ormer) error {
_, err := r.purgeInactive(o, activeList, func(item interface{}) string {
return item.(domain.MediaFile).ID
return item.(model.MediaFile).ID
})
return err
})
}
func (r *mediaFileRepository) Search(q string, offset int, size int) (domain.MediaFiles, error) {
func (r *mediaFileRepository) Search(q string, offset int, size int) (model.MediaFiles, error) {
if len(q) <= 2 {
return nil, nil
}
@@ -113,5 +113,5 @@ func (r *mediaFileRepository) Search(q string, offset int, size int) (domain.Med
return r.toMediaFiles(results), nil
}
var _ domain.MediaFileRepository = (*mediaFileRepository)(nil)
var _ = domain.MediaFile(MediaFile{})
var _ model.MediaFileRepository = (*mediaFileRepository)(nil)
var _ = model.MediaFile(MediaFile{})
persistence/mediafolders_repository.go
+7 -7
View File
@@ -2,22 +2,22 @@ package persistence
import (
"github.com/cloudsonic/sonic-server/conf"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
type mediaFolderRepository struct {
domain.MediaFolderRepository
model.MediaFolderRepository
}
func NewMediaFolderRepository() domain.MediaFolderRepository {
func NewMediaFolderRepository() model.MediaFolderRepository {
return &mediaFolderRepository{}
}
func (*mediaFolderRepository) GetAll() (domain.MediaFolders, error) {
mediaFolder := domain.MediaFolder{ID: "0", Name: "iTunes Library", Path: conf.Sonic.MusicFolder}
result := make(domain.MediaFolders, 1)
func (*mediaFolderRepository) GetAll() (model.MediaFolders, error) {
mediaFolder := model.MediaFolder{ID: "0", Name: "iTunes Library", Path: conf.Sonic.MusicFolder}
result := make(model.MediaFolders, 1)
result[0] = mediaFolder
return result, nil
}
var _ domain.MediaFolderRepository = (*mediaFolderRepository)(nil)
var _ model.MediaFolderRepository = (*mediaFolderRepository)(nil)
persistence/mock_album_repo.go
+13 -13
View File
@@ -5,7 +5,7 @@ import (
"errors"
"fmt"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
func CreateMockAlbumRepo() *MockAlbum {
@@ -13,11 +13,11 @@ func CreateMockAlbumRepo() *MockAlbum {
}
type MockAlbum struct {
domain.AlbumRepository
data map[string]*domain.Album
all domain.Albums
model.AlbumRepository
data map[string]*model.Album
all model.Albums
err bool
Options domain.QueryOptions
Options model.QueryOptions
}
func (m *MockAlbum) SetError(err bool) {
@@ -25,8 +25,8 @@ func (m *MockAlbum) SetError(err bool) {
}
func (m *MockAlbum) SetData(j string, size int) {
m.data = make(map[string]*domain.Album)
m.all = make(domain.Albums, size)
m.data = make(map[string]*model.Album)
m.all = make(model.Albums, size)
err := json.Unmarshal([]byte(j), &m.all)
if err != nil {
fmt.Println("ERROR: ", err)
@@ -41,17 +41,17 @@ func (m *MockAlbum) Exists(id string) (bool, error) {
return found, nil
}
func (m *MockAlbum) Get(id string) (*domain.Album, error) {
func (m *MockAlbum) Get(id string) (*model.Album, error) {
if m.err {
return nil, errors.New("Error!")
}
if d, ok := m.data[id]; ok {
return d, nil
}
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
func (m *MockAlbum) GetAll(qo ...domain.QueryOptions) (domain.Albums, error) {
func (m *MockAlbum) GetAll(qo ...model.QueryOptions) (model.Albums, error) {
if len(qo) > 0 {
m.Options = qo[0]
}
@@ -61,11 +61,11 @@ func (m *MockAlbum) GetAll(qo ...domain.QueryOptions) (domain.Albums, error) {
return m.all, nil
}
func (m *MockAlbum) FindByArtist(artistId string) (domain.Albums, error) {
func (m *MockAlbum) FindByArtist(artistId string) (model.Albums, error) {
if m.err {
return nil, errors.New("Error!")
}
var res = make(domain.Albums, len(m.data))
var res = make(model.Albums, len(m.data))
i := 0
for _, a := range m.data {
if a.ArtistID == artistId {
@@ -77,4 +77,4 @@ func (m *MockAlbum) FindByArtist(artistId string) (domain.Albums, error) {
return res, nil
}
var _ domain.AlbumRepository = (*MockAlbum)(nil)
var _ model.AlbumRepository = (*MockAlbum)(nil)
persistence/mock_artist_repo.go
+8 -8
View File
@@ -5,7 +5,7 @@ import (
"errors"
"fmt"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
func CreateMockArtistRepo() *MockArtist {
@@ -13,8 +13,8 @@ func CreateMockArtistRepo() *MockArtist {
}
type MockArtist struct {
domain.ArtistRepository
data map[string]*domain.Artist
model.ArtistRepository
data map[string]*model.Artist
err bool
}
@@ -23,8 +23,8 @@ func (m *MockArtist) SetError(err bool) {
}
func (m *MockArtist) SetData(j string, size int) {
m.data = make(map[string]*domain.Artist)
var l = make([]domain.Artist, size)
m.data = make(map[string]*model.Artist)
var l = make([]model.Artist, size)
err := json.Unmarshal([]byte(j), &l)
if err != nil {
fmt.Println("ERROR: ", err)
@@ -39,14 +39,14 @@ func (m *MockArtist) Exists(id string) (bool, error) {
return found, nil
}
func (m *MockArtist) Get(id string) (*domain.Artist, error) {
func (m *MockArtist) Get(id string) (*model.Artist, error) {
if m.err {
return nil, errors.New("Error!")
}
if d, ok := m.data[id]; ok {
return d, nil
}
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
var _ domain.ArtistRepository = (*MockArtist)(nil)
var _ model.ArtistRepository = (*MockArtist)(nil)
persistence/mock_index_repo.go
+6 -6
View File
@@ -5,7 +5,7 @@ import (
"errors"
"fmt"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
func CreateMockArtistIndexRepo() *MockArtistIndex {
@@ -13,8 +13,8 @@ func CreateMockArtistIndexRepo() *MockArtistIndex {
}
type MockArtistIndex struct {
domain.ArtistIndexRepository
data domain.ArtistIndexes
model.ArtistIndexRepository
data model.ArtistIndexes
err bool
}
@@ -23,18 +23,18 @@ func (m *MockArtistIndex) SetError(err bool) {
}
func (m *MockArtistIndex) SetData(j string, length int) {
m.data = make(domain.ArtistIndexes, length)
m.data = make(model.ArtistIndexes, length)
err := json.Unmarshal([]byte(j), &m.data)
if err != nil {
fmt.Println("ERROR: ", err)
}
}
func (m *MockArtistIndex) GetAll() (domain.ArtistIndexes, error) {
func (m *MockArtistIndex) GetAll() (model.ArtistIndexes, error) {
if m.err {
return nil, errors.New("Error!")
}
return m.data, nil
}
var _ domain.ArtistIndexRepository = (*MockArtistIndex)(nil)
var _ model.ArtistIndexRepository = (*MockArtistIndex)(nil)
persistence/mock_mediafile_repo.go
+10 -10
View File
@@ -5,7 +5,7 @@ import (
"errors"
"fmt"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
func CreateMockMediaFileRepo() *MockMediaFile {
@@ -13,8 +13,8 @@ func CreateMockMediaFileRepo() *MockMediaFile {
}
type MockMediaFile struct {
domain.MediaFileRepository
data map[string]domain.MediaFile
model.MediaFileRepository
data map[string]model.MediaFile
err bool
}
@@ -23,8 +23,8 @@ func (m *MockMediaFile) SetError(err bool) {
}
func (m *MockMediaFile) SetData(j string, size int) {
m.data = make(map[string]domain.MediaFile)
var l = make(domain.MediaFiles, size)
m.data = make(map[string]model.MediaFile)
var l = make(model.MediaFiles, size)
err := json.Unmarshal([]byte(j), &l)
if err != nil {
fmt.Println("ERROR: ", err)
@@ -42,21 +42,21 @@ func (m *MockMediaFile) Exists(id string) (bool, error) {
return found, nil
}
func (m *MockMediaFile) Get(id string) (*domain.MediaFile, error) {
func (m *MockMediaFile) Get(id string) (*model.MediaFile, error) {
if m.err {
return nil, errors.New("Error!")
}
if d, ok := m.data[id]; ok {
return &d, nil
}
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
func (m *MockMediaFile) FindByAlbum(artistId string) (domain.MediaFiles, error) {
func (m *MockMediaFile) FindByAlbum(artistId string) (model.MediaFiles, error) {
if m.err {
return nil, errors.New("Error!")
}
var res = make(domain.MediaFiles, len(m.data))
var res = make(model.MediaFiles, len(m.data))
i := 0
for _, a := range m.data {
if a.AlbumID == artistId {
@@ -68,4 +68,4 @@ func (m *MockMediaFile) FindByAlbum(artistId string) (domain.MediaFiles, error)
return res, nil
}
var _ domain.MediaFileRepository = (*MockMediaFile)(nil)
var _ model.MediaFileRepository = (*MockMediaFile)(nil)
persistence/nowplaying_repository.go
+13 -13
View File
@@ -4,7 +4,7 @@ import (
"container/list"
"sync"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
var playerMap = sync.Map{}
@@ -12,7 +12,7 @@ var playerMap = sync.Map{}
type nowPlayingRepository struct{}
// TODO Make it persistent
func NewNowPlayingRepository() domain.NowPlayingRepository {
func NewNowPlayingRepository() model.NowPlayingRepository {
r := &nowPlayingRepository{}
return r
}
@@ -22,38 +22,38 @@ func (r *nowPlayingRepository) getList(id int) *list.List {
return l.(*list.List)
}
func (r *nowPlayingRepository) Enqueue(info *domain.NowPlayingInfo) error {
func (r *nowPlayingRepository) Enqueue(info *model.NowPlayingInfo) error {
l := r.getList(info.PlayerId)
l.PushFront(info)
return nil
}
func (r *nowPlayingRepository) Dequeue(playerId int) (*domain.NowPlayingInfo, error) {
func (r *nowPlayingRepository) Dequeue(playerId int) (*model.NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Back()
if e == nil {
return nil, nil
}
l.Remove(e)
return e.Value.(*domain.NowPlayingInfo), nil
return e.Value.(*model.NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Head(playerId int) (*domain.NowPlayingInfo, error) {
func (r *nowPlayingRepository) Head(playerId int) (*model.NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Front()
if e == nil {
return nil, nil
}
return e.Value.(*domain.NowPlayingInfo), nil
return e.Value.(*model.NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Tail(playerId int) (*domain.NowPlayingInfo, error) {
func (r *nowPlayingRepository) Tail(playerId int) (*model.NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Back()
if e == nil {
return nil, nil
}
return e.Value.(*domain.NowPlayingInfo), nil
return e.Value.(*model.NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Count(playerId int) (int64, error) {
@@ -61,15 +61,15 @@ func (r *nowPlayingRepository) Count(playerId int) (int64, error) {
return int64(l.Len()), nil
}
func (r *nowPlayingRepository) GetAll() ([]*domain.NowPlayingInfo, error) {
var all []*domain.NowPlayingInfo
func (r *nowPlayingRepository) GetAll() ([]*model.NowPlayingInfo, error) {
var all []*model.NowPlayingInfo
playerMap.Range(func(playerId, l interface{}) bool {
ll := l.(*list.List)
e := ll.Front()
all = append(all, e.Value.(*domain.NowPlayingInfo))
all = append(all, e.Value.(*model.NowPlayingInfo))
return true
})
return all, nil
}
var _ domain.NowPlayingRepository = (*nowPlayingRepository)(nil)
var _ model.NowPlayingRepository = (*nowPlayingRepository)(nil)
persistence/nowplaying_repository_test.go
+14 -14
View File
@@ -3,13 +3,13 @@ package persistence
import (
"sync"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("NowPlayingRepository", func() {
var repo domain.NowPlayingRepository
var repo model.NowPlayingRepository
BeforeEach(func() {
playerMap = sync.Map{}
@@ -17,26 +17,26 @@ var _ = Describe("NowPlayingRepository", func() {
})
It("enqueues and dequeues records", func() {
Expect(repo.Enqueue(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Tail(1)).To(Equal(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(1)).To(Equal(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"}))
Expect(repo.Tail(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"}))
Expect(repo.Count(1)).To(Equal(int64(2)))
Expect(repo.Dequeue(1)).To(Equal(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Dequeue(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Count(1)).To(Equal(int64(1)))
})
It("handles multiple players", func() {
Expect(repo.Enqueue(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Enqueue(&domain.NowPlayingInfo{PlayerId: 2, TrackID: "CCC"})).To(BeNil())
Expect(repo.Enqueue(&domain.NowPlayingInfo{PlayerId: 2, TrackID: "DDD"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 2, TrackID: "CCC"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 2, TrackID: "DDD"})).To(BeNil())
Expect(repo.GetAll()).To(ConsistOf([]*domain.NowPlayingInfo{
Expect(repo.GetAll()).To(ConsistOf([]*model.NowPlayingInfo{
{PlayerId: 1, TrackID: "BBB"},
{PlayerId: 2, TrackID: "DDD"},
}))
@@ -44,7 +44,7 @@ var _ = Describe("NowPlayingRepository", func() {
Expect(repo.Count(2)).To(Equal(int64(2)))
Expect(repo.Count(2)).To(Equal(int64(2)))
Expect(repo.Tail(1)).To(Equal(&domain.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(2)).To(Equal(&domain.NowPlayingInfo{PlayerId: 2, TrackID: "DDD"}))
Expect(repo.Tail(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(2)).To(Equal(&model.NowPlayingInfo{PlayerId: 2, TrackID: "DDD"}))
})
})
persistence/persistence_suite_test.go
+3 -3
View File
@@ -4,8 +4,8 @@ import (
"testing"
"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/onsi/ginkgo"
. "github.com/onsi/gomega"
)
@@ -16,12 +16,12 @@ func TestPersistence(t *testing.T) {
RunSpecs(t, "Persistence Suite")
}
var testAlbums = domain.Albums{
var testAlbums = model.Albums{
{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
}
var testArtists = domain.Artists{
var testArtists = model.Artists{
{ID: "1", Name: "Saara Saara", AlbumCount: 2},
{ID: "2", Name: "Kraftwerk"},
{ID: "3", Name: "The Beatles"},
persistence/playlist_repository.go
+14 -14
View File
@@ -4,7 +4,7 @@ import (
"strings"
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
type Playlist struct {
@@ -22,24 +22,24 @@ type playlistRepository struct {
sqlRepository
}
func NewPlaylistRepository() domain.PlaylistRepository {
func NewPlaylistRepository() model.PlaylistRepository {
r := &playlistRepository{}
r.tableName = "playlist"
return r
}
func (r *playlistRepository) Put(p *domain.Playlist) error {
func (r *playlistRepository) Put(p *model.Playlist) error {
tp := r.fromDomain(p)
return withTx(func(o orm.Ormer) error {
return r.put(o, p.ID, &tp)
})
}
func (r *playlistRepository) Get(id string) (*domain.Playlist, error) {
func (r *playlistRepository) Get(id string) (*model.Playlist, error) {
tp := &Playlist{ID: id}
err := Db().Read(tp)
if err == orm.ErrNoRows {
return nil, domain.ErrNotFound
return nil, model.ErrNotFound
}
if err != nil {
return nil, err
@@ -48,7 +48,7 @@ func (r *playlistRepository) Get(id string) (*domain.Playlist, error) {
return &a, err
}
func (r *playlistRepository) GetAll(options ...domain.QueryOptions) (domain.Playlists, error) {
func (r *playlistRepository) GetAll(options ...model.QueryOptions) (model.Playlists, error) {
var all []Playlist
_, err := r.newQuery(Db(), options...).All(&all)
if err != nil {
@@ -57,25 +57,25 @@ func (r *playlistRepository) GetAll(options ...domain.QueryOptions) (domain.Play
return r.toPlaylists(all)
}
func (r *playlistRepository) toPlaylists(all []Playlist) (domain.Playlists, error) {
result := make(domain.Playlists, len(all))
func (r *playlistRepository) toPlaylists(all []Playlist) (model.Playlists, error) {
result := make(model.Playlists, len(all))
for i, p := range all {
result[i] = r.toDomain(&p)
}
return result, nil
}
func (r *playlistRepository) PurgeInactive(activeList domain.Playlists) ([]string, error) {
func (r *playlistRepository) PurgeInactive(activeList model.Playlists) ([]string, error) {
return nil, withTx(func(o orm.Ormer) error {
_, err := r.purgeInactive(o, activeList, func(item interface{}) string {
return item.(domain.Playlist).ID
return item.(model.Playlist).ID
})
return err
})
}
func (r *playlistRepository) toDomain(p *Playlist) domain.Playlist {
return domain.Playlist{
func (r *playlistRepository) toDomain(p *Playlist) model.Playlist {
return model.Playlist{
ID: p.ID,
Name: p.Name,
Comment: p.Comment,
@@ -87,7 +87,7 @@ func (r *playlistRepository) toDomain(p *Playlist) domain.Playlist {
}
}
func (r *playlistRepository) fromDomain(p *domain.Playlist) Playlist {
func (r *playlistRepository) fromDomain(p *model.Playlist) Playlist {
return Playlist{
ID: p.ID,
Name: p.Name,
@@ -100,4 +100,4 @@ func (r *playlistRepository) fromDomain(p *domain.Playlist) Playlist {
}
}
var _ domain.PlaylistRepository = (*playlistRepository)(nil)
var _ model.PlaylistRepository = (*playlistRepository)(nil)
persistence/property_repository.go
+5 -5
View File
@@ -2,7 +2,7 @@ package persistence
import (
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
)
type Property struct {
@@ -14,7 +14,7 @@ type propertyRepository struct {
sqlRepository
}
func NewPropertyRepository() domain.PropertyRepository {
func NewPropertyRepository() model.PropertyRepository {
r := &propertyRepository{}
r.tableName = "property"
return r
@@ -36,14 +36,14 @@ func (r *propertyRepository) Get(id string) (string, error) {
p := &Property{ID: id}
err := Db().Read(p)
if err == orm.ErrNoRows {
return "", domain.ErrNotFound
return "", model.ErrNotFound
}
return p.Value, err
}
func (r *propertyRepository) DefaultGet(id string, defaultValue string) (string, error) {
value, err := r.Get(id)
if err == domain.ErrNotFound {
if err == model.ErrNotFound {
return defaultValue, nil
}
if err != nil {
@@ -52,4 +52,4 @@ func (r *propertyRepository) DefaultGet(id string, defaultValue string) (string,
return value, nil
}
var _ domain.PropertyRepository = (*propertyRepository)(nil)
var _ model.PropertyRepository = (*propertyRepository)(nil)
persistence/property_repository_test.go
+2 -2
View File
@@ -1,13 +1,13 @@
package persistence
import (
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("PropertyRepository", func() {
var repo domain.PropertyRepository
var repo model.PropertyRepository
BeforeEach(func() {
repo = NewPropertyRepository()
persistence/sql_repository.go
+2 -2
View File
@@ -2,15 +2,15 @@ package persistence
import (
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/log"
"github.com/cloudsonic/sonic-server/model"
)
type sqlRepository struct {
tableName string
}
func (r *sqlRepository) newQuery(o orm.Ormer, options ...domain.QueryOptions) orm.QuerySeter {
func (r *sqlRepository) newQuery(o orm.Ormer, options ...model.QueryOptions) orm.QuerySeter {
q := o.QueryTable(r.tableName)
if len(options) > 0 {
opts := options[0]