mirrors
/
navidrome
mirror of https://github.com/navidrome/navidrome.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

SQL/Orm MediaFileRepository complete

This commit is contained in:
Deluan 2020-01-12 18:36:19 -05:00 committed by Deluan Quintão
parent d70af2c39d
commit 56273dd4d9
6 changed files with 182 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
persistence/db_sql/mediafile_repository.go Normal file
View File

@ -0,0 +1,115 @@
package db_sql
import (
"time"
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/persistence"
)
type MediaFile struct {
ID string `orm:"pk;column(id)"`
Path string ``
Title string `orm:"index"`
Album string ``
Artist string ``
ArtistID string `orm:"column(artist_id)"`
AlbumArtist string ``
AlbumID string `orm:"column(album_id);index"`
HasCoverArt bool ``
TrackNumber int ``
DiscNumber int ``
Year int ``
Size string ``
Suffix string ``
Duration int ``
BitRate int ``
Genre string ``
Compilation bool ``
PlayCount int ``
PlayDate time.Time `orm:"null"`
Rating int ``
Starred bool `orm:"index"`
StarredAt time.Time `orm:"null"`
CreatedAt time.Time `orm:"null"`
UpdatedAt time.Time `orm:"null"`
}
type mediaFileRepository struct {
sqlRepository
}
func NewMediaFileRepository() domain.MediaFileRepository {
r := &mediaFileRepository{}
r.entityName = "media_file"
return r
}
func (r *mediaFileRepository) Put(m *domain.MediaFile) error {
tm := MediaFile(*m)
return r.put(m.ID, &tm)
}
func (r *mediaFileRepository) Get(id string) (*domain.MediaFile, error) {
tm := MediaFile{ID: id}
err := Db().Read(&tm)
if err == orm.ErrNoRows {
return nil, domain.ErrNotFound
}
if err != nil {
return nil, err
}
a := domain.MediaFile(tm)
return &a, nil
}
func (r *mediaFileRepository) toMediaFiles(all []MediaFile) (domain.MediaFiles, error) {
result := make(domain.MediaFiles, len(all))
for i, m := range all {
result[i] = domain.MediaFile(m)
}
return result, nil
}
func (r *mediaFileRepository) FindByAlbum(albumId string) (domain.MediaFiles, error) {
var mfs []MediaFile
_, err := r.newQuery(Db()).Filter("album_id", albumId).OrderBy("disc_number", "track_number").All(&mfs)
if err != nil {
return nil, err
}
return r.toMediaFiles(mfs)
}
func (r *mediaFileRepository) GetStarred(options ...domain.QueryOptions) (domain.MediaFiles, error) {
var starred []MediaFile
_, err := r.newQuery(Db(), options...).Filter("starred", true).All(&starred)
if err != nil {
return nil, err
}
return r.toMediaFiles(starred)
}
func (r *mediaFileRepository) GetAllIds() ([]string, error) {
qs := r.newQuery(Db())
var values []orm.Params
num, err := qs.Values(&values, "id")
if num == 0 {
return nil, err
}
result := persistence.CollectValue(values, func(item interface{}) string {
return item.(orm.Params)["ID"].(string)
})
return result, nil
}
func (r *mediaFileRepository) PurgeInactive(activeList domain.MediaFiles) ([]string, error) {
return r.purgeInactive(activeList, func(item interface{}) string {
return item.(domain.MediaFile).ID
})
}
var _ domain.MediaFileRepository = (*mediaFileRepository)(nil)
var _ = domain.MediaFile(MediaFile{})

1
persistence/db_sql/sql.go
View File

@ -55,6 +55,7 @@ func WithTx(block func(orm.Ormer) error) error {
func initORM(dbPath string) error {
orm.Debug = true
orm.RegisterModel(new(Artist))
orm.RegisterModel(new(MediaFile))
err := orm.RegisterDataBase("default", "sqlite3", dbPath)
if err != nil {
panic(err)

26
persistence/db_sql/sql_repository.go
View File

@ -2,6 +2,7 @@ package db_sql
import (
"github.com/astaxie/beego/orm"
"github.com/cloudsonic/sonic-server/domain"
"github.com/cloudsonic/sonic-server/persistence"
)
@ -9,8 +10,23 @@ type sqlRepository struct {
entityName string
}
func (r *sqlRepository) newQuery(o orm.Ormer) orm.QuerySeter {
return o.QueryTable(r.entityName)
func (r *sqlRepository) newQuery(o orm.Ormer, options ...domain.QueryOptions) orm.QuerySeter {
q := o.QueryTable(r.entityName)
if len(options) > 0 {
opts := options[0]
q = q.Offset(opts.Offset)
if opts.Size > 0 {
q = q.Limit(opts.Size)
}
if opts.SortBy != "" {
if opts.Desc {
q = q.OrderBy("-" + opts.SortBy)
} else {
q = q.OrderBy(opts.SortBy)
}
}
}
return q
}
func (r *sqlRepository) CountAll() (int64, error) {
@ -22,9 +38,9 @@ func (r *sqlRepository) Exists(id string) (bool, error) {
return c == 1, err
}
func (r *artistRepository) put(id string, a interface{}) error {
func (r *sqlRepository) put(id string, a interface{}) error {
return WithTx(func(o orm.Ormer) error {
c, err := r.newQuery(Db()).Filter("id", id).Count()
c, err := r.newQuery(o).Filter("id", id).Count()
if err != nil {
return err
}
@ -41,7 +57,7 @@ func (r *sqlRepository) purgeInactive(activeList interface{}, getId func(item in
ids := persistence.CollectValue(activeList, getId)
var values []orm.Params
err := WithTx(func(o orm.Ormer) error {
qs := o.QueryTable(r.entityName).Exclude("id__in", ids)
qs := r.newQuery(o).Exclude("id__in", ids)
num, err := qs.Values(&values, "id")
if num > 0 {
_, err = qs.Delete()

9
persistence/db_sql/wire_provider.go
View File

@ -2,12 +2,19 @@ package db_sql
import (
"github.com/cloudsonic/sonic-server/persistence"
"github.com/cloudsonic/sonic-server/persistence/db_ledis"
"github.com/google/wire"
)
var Set = wire.NewSet(
NewArtistRepository,
NewMediaFileRepository,
db_ledis.NewPropertyRepository,
db_ledis.NewAlbumRepository,
db_ledis.NewArtistIndexRepository,
db_ledis.NewPlaylistRepository,
db_ledis.NewCheckSumRepository,
persistence.NewNowPlayingRepository,
persistence.NewMediaFolderRepository,
wire.Value(persistence.ProviderIdentifier("sqlite")),
wire.Value(persistence.ProviderIdentifier("sql")),
)

27
wire_gen.go
View File

@ -12,6 +12,7 @@ import (
"github.com/cloudsonic/sonic-server/itunesbridge"
"github.com/cloudsonic/sonic-server/persistence"
"github.com/cloudsonic/sonic-server/persistence/db_ledis"
"github.com/cloudsonic/sonic-server/persistence/db_sql"
"github.com/cloudsonic/sonic-server/persistence/db_storm"
"github.com/cloudsonic/sonic-server/scanner"
"github.com/deluan/gomate"
@ -61,6 +62,30 @@ func CreateSubsonicAPIRouter(p persistence.ProviderIdentifier) *api.Router {
return router
}
func createSQLProvider() *Provider {
albumRepository := db_ledis.NewAlbumRepository()
artistRepository := db_sql.NewArtistRepository()
checkSumRepository := db_ledis.NewCheckSumRepository()
artistIndexRepository := db_ledis.NewArtistIndexRepository()
mediaFileRepository := db_sql.NewMediaFileRepository()
mediaFolderRepository := persistence.NewMediaFolderRepository()
nowPlayingRepository := persistence.NewNowPlayingRepository()
playlistRepository := db_ledis.NewPlaylistRepository()
propertyRepository := db_ledis.NewPropertyRepository()
provider := &Provider{
AlbumRepository: albumRepository,
ArtistRepository: artistRepository,
CheckSumRepository: checkSumRepository,
ArtistIndexRepository: artistIndexRepository,
MediaFileRepository: mediaFileRepository,
MediaFolderRepository: mediaFolderRepository,
NowPlayingRepository: nowPlayingRepository,
PlaylistRepository: playlistRepository,
PropertyRepository: propertyRepository,
}
return provider
}
func createLedisDBProvider() *Provider {
albumRepository := db_ledis.NewAlbumRepository()
artistRepository := db_ledis.NewArtistRepository()
@ -130,6 +155,8 @@ var allProviders = wire.NewSet(itunesbridge.NewItunesControl, engine.Set, scanne
func createPersistenceProvider(provider persistence.ProviderIdentifier) *Provider {
switch provider {
case "sql":
return createSQLProvider()
case "storm":
return createStormProvider()
default:

10
wire_injectors.go
View File

@ -9,6 +9,7 @@ import (
"github.com/cloudsonic/sonic-server/itunesbridge"
"github.com/cloudsonic/sonic-server/persistence"
"github.com/cloudsonic/sonic-server/persistence/db_ledis"
"github.com/cloudsonic/sonic-server/persistence/db_sql"
"github.com/cloudsonic/sonic-server/persistence/db_storm"
"github.com/cloudsonic/sonic-server/scanner"
"github.com/deluan/gomate"
@ -53,6 +54,8 @@ func CreateSubsonicAPIRouter(p persistence.ProviderIdentifier) *api.Router {
func createPersistenceProvider(provider persistence.ProviderIdentifier) *Provider {
switch provider {
case "sql":
return createSQLProvider()
case "storm":
return createStormProvider()
default:
@ -60,6 +63,13 @@ func createPersistenceProvider(provider persistence.ProviderIdentifier) *Provide
}
}
func createSQLProvider() *Provider {
panic(wire.Build(
db_sql.Set,
wire.Struct(new(Provider), "*"),
))
}
func createLedisDBProvider() *Provider {
panic(wire.Build(
db_ledis.Set,