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

Refactor DB Album mapping to model.Album

Browse Source
This commit is contained in:
Deluan
2024-04-28 13:51:57 -04:00
parent 27875ba2dd
commit de90152a71
2 changed files with 101 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
persistence/album_repository.go
+26 -25
View File
@@ -27,11 +27,13 @@ type dbAlbum struct {
} }
func (a *dbAlbum) PostScan() error { func (a *dbAlbum) PostScan() error {
if a.Discs == "" { if conf.Server.AlbumPlayCountMode == consts.AlbumPlayCountModeNormalized && a.Album.SongCount != 0 {
a.Album.Discs = model.Discs{} a.Album.PlayCount = int64(math.Round(float64(a.Album.PlayCount) / float64(a.Album.SongCount)))
return nil
} }
return json.Unmarshal([]byte(a.Discs), &a.Album.Discs) if a.Discs != "" {
return json.Unmarshal([]byte(a.Discs), &a.Album.Discs)
}
return nil
} }
func (a *dbAlbum) PostMapArgs(m map[string]any) error { func (a *dbAlbum) PostMapArgs(m map[string]any) error {
@@ -47,6 +49,16 @@ func (a *dbAlbum) PostMapArgs(m map[string]any) error {
return nil return nil
} }
type dbAlbums []dbAlbum
func (dba dbAlbums) toModels() model.Albums {
res := make(model.Albums, len(dba))
for i := range dba {
res[i] = *dba[i].Album
}
return res
}
func NewAlbumRepository(ctx context.Context, db dbx.Builder) model.AlbumRepository { func NewAlbumRepository(ctx context.Context, db dbx.Builder) model.AlbumRepository {
r := &albumRepository{} r := &albumRepository{}
r.ctx = ctx r.ctx = ctx
@@ -91,15 +103,15 @@ func recentlyAddedSort() string {
return "created_at" return "created_at"
} }
func recentlyPlayedFilter(field string, value interface{}) Sqlizer { func recentlyPlayedFilter(string, interface{}) Sqlizer {
return Gt{"play_count": 0} return Gt{"play_count": 0}
} }
func hasRatingFilter(field string, value interface{}) Sqlizer { func hasRatingFilter(string, interface{}) Sqlizer {
return Gt{"rating": 0} return Gt{"rating": 0}
} }
func yearFilter(field string, value interface{}) Sqlizer { func yearFilter(_ string, value interface{}) Sqlizer {
return Or{ return Or{
And{ And{
Gt{"min_year": 0}, Gt{"min_year": 0},
@@ -110,7 +122,7 @@ func yearFilter(field string, value interface{}) Sqlizer {
} }
} }
func artistFilter(field string, value interface{}) Sqlizer { func artistFilter(_ string, value interface{}) Sqlizer {
return Like{"all_artist_ids": fmt.Sprintf("%%%s%%", value)} return Like{"all_artist_ids": fmt.Sprintf("%%%s%%", value)}
} }
@@ -142,14 +154,14 @@ func (r *albumRepository) selectAlbum(options ...model.QueryOptions) SelectBuild
func (r *albumRepository) Get(id string) (*model.Album, error) { func (r *albumRepository) Get(id string) (*model.Album, error) {
sq := r.selectAlbum().Where(Eq{"album.id": id}) sq := r.selectAlbum().Where(Eq{"album.id": id})
var dba []dbAlbum var dba dbAlbums
if err := r.queryAll(sq, &dba); err != nil { if err := r.queryAll(sq, &dba); err != nil {
return nil, err return nil, err
} }
if len(dba) == 0 { if len(dba) == 0 {
return nil, model.ErrNotFound return nil, model.ErrNotFound
} }
res := r.toModels(dba) res := dba.toModels()
err := r.loadAlbumGenres(&res) err := r.loadAlbumGenres(&res)
return &res[0], err return &res[0], err
} }
@@ -171,25 +183,14 @@ func (r *albumRepository) GetAll(options ...model.QueryOptions) (model.Albums, e
return res, err return res, err
} }
func (r *albumRepository) toModels(dba []dbAlbum) model.Albums {
res := model.Albums{}
for i := range dba {
if conf.Server.AlbumPlayCountMode == consts.AlbumPlayCountModeNormalized && dba[i].Album.SongCount != 0 {
dba[i].Album.PlayCount = int64(math.Round(float64(dba[i].Album.PlayCount) / float64(dba[i].Album.SongCount)))
}
res = append(res, *dba[i].Album)
}
return res
}
func (r *albumRepository) GetAllWithoutGenres(options ...model.QueryOptions) (model.Albums, error) { func (r *albumRepository) GetAllWithoutGenres(options ...model.QueryOptions) (model.Albums, error) {
sq := r.selectAlbum(options...) sq := r.selectAlbum(options...)
var dba []dbAlbum var dba dbAlbums
err := r.queryAll(sq, &dba) err := r.queryAll(sq, &dba)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return r.toModels(dba), err return dba.toModels(), err
} }
func (r *albumRepository) purgeEmpty() error { func (r *albumRepository) purgeEmpty() error {
@@ -204,12 +205,12 @@ func (r *albumRepository) purgeEmpty() error {
} }
func (r *albumRepository) Search(q string, offset int, size int) (model.Albums, error) { func (r *albumRepository) Search(q string, offset int, size int) (model.Albums, error) {
var dba []dbAlbum var dba dbAlbums
err := r.doSearch(q, offset, size, &dba, "name") err := r.doSearch(q, offset, size, &dba, "name")
if err != nil { if err != nil {
return nil, err return nil, err
} }
res := r.toModels(dba) res := dba.toModels()
err = r.loadAlbumGenres(&res) err = r.loadAlbumGenres(&res)
return res, err return res, err
} }
persistence/album_repository_test.go
+75 -80
View File
@@ -60,91 +60,86 @@ var _ = Describe("AlbumRepository", func() {
}) })
Describe("dbAlbum mapping", func() { Describe("dbAlbum mapping", func() {
var a *model.Album Describe("Album.Discs", func() {
BeforeEach(func() { var a *model.Album
a = &model.Album{ID: "1", Name: "name", ArtistID: "2"} BeforeEach(func() {
a = &model.Album{ID: "1", Name: "name", ArtistID: "2"}
})
It("maps empty discs field", func() {
a.Discs = model.Discs{}
dba := dbAlbum{Album: a}
m := structs.Map(dba)
Expect(dba.PostMapArgs(m)).To(Succeed())
Expect(m).To(HaveKeyWithValue("discs", `{}`))
other := dbAlbum{Album: &model.Album{ID: "1", Name: "name"}, Discs: "{}"}
Expect(other.PostScan()).To(Succeed())
Expect(other.Album.Discs).To(Equal(a.Discs))
})
It("maps the discs field", func() {
a.Discs = model.Discs{1: "disc1", 2: "disc2"}
dba := dbAlbum{Album: a}
m := structs.Map(dba)
Expect(dba.PostMapArgs(m)).To(Succeed())
Expect(m).To(HaveKeyWithValue("discs", `{"1":"disc1","2":"disc2"}`))
other := dbAlbum{Album: &model.Album{ID: "1", Name: "name"}, Discs: m["discs"].(string)}
Expect(other.PostScan()).To(Succeed())
Expect(other.Album.Discs).To(Equal(a.Discs))
})
}) })
It("maps empty discs field", func() { Describe("Album.PlayCount", func() {
a.Discs = model.Discs{} DescribeTable("normalizes play count when AlbumPlayCountMode is absolute",
dba := dbAlbum{Album: a} func(songCount, playCount, expected int) {
conf.Server.AlbumPlayCountMode = consts.AlbumPlayCountModeAbsolute
dba := dbAlbum{Album: &model.Album{ID: "1", Name: "name", SongCount: songCount, Annotations: model.Annotations{PlayCount: int64(playCount)}}}
Expect(dba.PostScan()).To(Succeed())
Expect(dba.Album.PlayCount).To(Equal(int64(expected)))
},
Entry("1 song, 0 plays", 1, 0, 0),
Entry("1 song, 4 plays", 1, 4, 4),
Entry("3 songs, 6 plays", 3, 6, 6),
Entry("10 songs, 6 plays", 10, 6, 6),
Entry("70 songs, 70 plays", 70, 70, 70),
Entry("10 songs, 50 plays", 10, 50, 50),
Entry("120 songs, 121 plays", 120, 121, 121),
)
m := structs.Map(dba) DescribeTable("normalizes play count when AlbumPlayCountMode is normalized",
Expect(dba.PostMapArgs(m)).To(Succeed()) func(songCount, playCount, expected int) {
Expect(m).To(HaveKeyWithValue("discs", `{}`)) conf.Server.AlbumPlayCountMode = consts.AlbumPlayCountModeNormalized
dba := dbAlbum{Album: &model.Album{ID: "1", Name: "name", SongCount: songCount, Annotations: model.Annotations{PlayCount: int64(playCount)}}}
other := dbAlbum{Album: &model.Album{ID: "1", Name: "name"}, Discs: "{}"} Expect(dba.PostScan()).To(Succeed())
Expect(other.PostScan()).To(Succeed()) Expect(dba.Album.PlayCount).To(Equal(int64(expected)))
},
Expect(other.Album.Discs).To(Equal(a.Discs)) Entry("1 song, 0 plays", 1, 0, 0),
}) Entry("1 song, 4 plays", 1, 4, 4),
It("maps the discs field", func() { Entry("3 songs, 6 plays", 3, 6, 2),
a.Discs = model.Discs{1: "disc1", 2: "disc2"} Entry("10 songs, 6 plays", 10, 6, 1),
dba := dbAlbum{Album: a} Entry("70 songs, 70 plays", 70, 70, 1),
Entry("10 songs, 50 plays", 10, 50, 5),
m := structs.Map(dba) Entry("120 songs, 121 plays", 120, 121, 1),
Expect(dba.PostMapArgs(m)).To(Succeed()) )
Expect(m).To(HaveKeyWithValue("discs", `{"1":"disc1","2":"disc2"}`))
other := dbAlbum{Album: &model.Album{ID: "1", Name: "name"}, Discs: m["discs"].(string)}
Expect(other.PostScan()).To(Succeed())
Expect(other.Album.Discs).To(Equal(a.Discs))
})
})
Describe("toModels", func() {
var repo *albumRepository
BeforeEach(func() {
ctx := request.WithUser(log.NewContext(context.TODO()), model.User{ID: "userid", UserName: "johndoe"})
repo = NewAlbumRepository(ctx, getDBXBuilder()).(*albumRepository)
}) })
It("converts dbAlbum to model.Album", func() { Describe("dbAlbums.toModels", func() {
dba := []dbAlbum{ It("converts dbAlbums to model.Albums", func() {
{Album: &model.Album{ID: "1", Name: "name", SongCount: 2, Annotations: model.Annotations{PlayCount: 4}}}, dba := dbAlbums{
{Album: &model.Album{ID: "2", Name: "name2", SongCount: 3, Annotations: model.Annotations{PlayCount: 6}}}, {Album: &model.Album{ID: "1", Name: "name", SongCount: 2, Annotations: model.Annotations{PlayCount: 4}}},
} {Album: &model.Album{ID: "2", Name: "name2", SongCount: 3, Annotations: model.Annotations{PlayCount: 6}}},
albums := repo.toModels(dba)
Expect(len(albums)).To(Equal(2))
Expect(albums[0].ID).To(Equal("1"))
Expect(albums[1].ID).To(Equal("2"))
})
DescribeTable("normalizes play count when AlbumPlayCountMode is absolute",
func(songCount, playCount, expected int) {
conf.Server.AlbumPlayCountMode = consts.AlbumPlayCountModeAbsolute
dba := []dbAlbum{
{Album: &model.Album{ID: "1", Name: "name", SongCount: songCount, Annotations: model.Annotations{PlayCount: int64(playCount)}}},
} }
albums := repo.toModels(dba) albums := dba.toModels()
Expect(albums[0].PlayCount).To(Equal(int64(expected))) for i := range dba {
}, Expect(albums[i].ID).To(Equal(dba[i].Album.ID))
Entry("1 song, 0 plays", 1, 0, 0), Expect(albums[i].Name).To(Equal(dba[i].Album.Name))
Entry("1 song, 4 plays", 1, 4, 4), Expect(albums[i].SongCount).To(Equal(dba[i].Album.SongCount))
Entry("3 songs, 6 plays", 3, 6, 6), Expect(albums[i].PlayCount).To(Equal(dba[i].Album.PlayCount))
Entry("10 songs, 6 plays", 10, 6, 6),
Entry("70 songs, 70 plays", 70, 70, 70),
Entry("10 songs, 50 plays", 10, 50, 50),
Entry("120 songs, 121 plays", 120, 121, 121),
)
DescribeTable("normalizes play count when AlbumPlayCountMode is normalized",
func(songCount, playCount, expected int) {
conf.Server.AlbumPlayCountMode = consts.AlbumPlayCountModeNormalized
dba := []dbAlbum{
{Album: &model.Album{ID: "1", Name: "name", SongCount: songCount, Annotations: model.Annotations{PlayCount: int64(playCount)}}},
} }
albums := repo.toModels(dba) })
Expect(albums[0].PlayCount).To(Equal(int64(expected))) })
},
Entry("1 song, 0 plays", 1, 0, 0),
Entry("1 song, 4 plays", 1, 4, 4),
Entry("3 songs, 6 plays", 3, 6, 2),
Entry("10 songs, 6 plays", 10, 6, 1),
Entry("70 songs, 70 plays", 70, 70, 1),
Entry("10 songs, 50 plays", 10, 50, 5),
Entry("120 songs, 121 plays", 120, 121, 1),
)
}) })
}) })