SQL/Orm MediaFileRepository complete

persistence/db_sql/mediafile_repository.go

@@ -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{})

persistence/db_sql/sql.go

@@ -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)

persistence/db_sql/sql_repository.go

@@ -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 {
+func (r *sqlRepository) newQuery(o orm.Ormer, options ...domain.QueryOptions) orm.QuerySeter {
-	return o.QueryTable(r.entityName)
+	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()

persistence/db_sql/wire_provider.go

@@ -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")),
 )

wire_gen.go

@@ -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:

wire_injectors.go

@@ -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,