2020-01-11 20:58:46 +01:00
|
|
|
package persistence
|
|
|
|
|
2020-01-15 17:11:33 +01:00
|
|
|
import (
|
2020-01-27 15:41:33 +01:00
|
|
|
"context"
|
2021-08-01 02:15:20 +02:00
|
|
|
"database/sql"
|
2020-01-15 17:11:33 +01:00
|
|
|
"reflect"
|
|
|
|
|
|
|
|
"github.com/astaxie/beego/orm"
|
2020-02-01 19:46:03 +01:00
|
|
|
"github.com/navidrome/navidrome/db"
|
2020-01-24 01:44:08 +01:00
|
|
|
"github.com/navidrome/navidrome/log"
|
|
|
|
"github.com/navidrome/navidrome/model"
|
2020-01-15 17:11:33 +01:00
|
|
|
)
|
|
|
|
|
2020-02-01 18:25:05 +01:00
|
|
|
type SQLStore struct {
|
2020-01-19 21:37:41 +01:00
|
|
|
orm orm.Ormer
|
2021-08-01 02:15:20 +02:00
|
|
|
db *sql.DB
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2021-08-01 02:15:20 +02:00
|
|
|
func New(db *sql.DB) model.DataStore {
|
|
|
|
return &SQLStore{db: db}
|
2020-01-28 14:22:17 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) Album(ctx context.Context) model.AlbumRepository {
|
|
|
|
return NewAlbumRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) Artist(ctx context.Context) model.ArtistRepository {
|
|
|
|
return NewArtistRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) MediaFile(ctx context.Context) model.MediaFileRepository {
|
|
|
|
return NewMediaFileRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) MediaFolder(ctx context.Context) model.MediaFolderRepository {
|
|
|
|
return NewMediaFolderRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) Genre(ctx context.Context) model.GenreRepository {
|
|
|
|
return NewGenreRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-07-31 19:07:39 +02:00
|
|
|
func (s *SQLStore) PlayQueue(ctx context.Context) model.PlayQueueRepository {
|
|
|
|
return NewPlayQueueRepository(ctx, s.getOrmer())
|
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) Playlist(ctx context.Context) model.PlaylistRepository {
|
|
|
|
return NewPlaylistRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) Property(ctx context.Context) model.PropertyRepository {
|
|
|
|
return NewPropertyRepository(ctx, s.getOrmer())
|
2020-01-15 17:11:33 +01:00
|
|
|
}
|
|
|
|
|
2021-06-23 22:47:32 +02:00
|
|
|
func (s *SQLStore) UserProps(ctx context.Context) model.UserPropsRepository {
|
|
|
|
return NewUserPropsRepository(ctx, s.getOrmer())
|
|
|
|
}
|
|
|
|
|
2021-05-30 17:50:35 +02:00
|
|
|
func (s *SQLStore) Share(ctx context.Context) model.ShareRepository {
|
|
|
|
return NewShareRepository(ctx, s.getOrmer())
|
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) User(ctx context.Context) model.UserRepository {
|
|
|
|
return NewUserRepository(ctx, s.getOrmer())
|
2020-01-19 21:37:41 +01:00
|
|
|
}
|
|
|
|
|
2020-03-01 02:01:09 +01:00
|
|
|
func (s *SQLStore) Transcoding(ctx context.Context) model.TranscodingRepository {
|
|
|
|
return NewTranscodingRepository(ctx, s.getOrmer())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *SQLStore) Player(ctx context.Context) model.PlayerRepository {
|
|
|
|
return NewPlayerRepository(ctx, s.getOrmer())
|
|
|
|
}
|
|
|
|
|
2021-06-24 06:01:05 +02:00
|
|
|
func (s *SQLStore) ScrobbleBuffer(ctx context.Context) model.ScrobbleBufferRepository {
|
|
|
|
return NewScrobbleBufferRepository(ctx, s.getOrmer())
|
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) Resource(ctx context.Context, m interface{}) model.ResourceRepository {
|
2020-01-28 14:22:17 +01:00
|
|
|
switch m.(type) {
|
|
|
|
case model.User:
|
2020-02-28 20:16:15 +01:00
|
|
|
return s.User(ctx).(model.ResourceRepository)
|
2020-03-01 02:01:09 +01:00
|
|
|
case model.Transcoding:
|
|
|
|
return s.Transcoding(ctx).(model.ResourceRepository)
|
|
|
|
case model.Player:
|
|
|
|
return s.Player(ctx).(model.ResourceRepository)
|
2020-01-28 14:22:17 +01:00
|
|
|
case model.Artist:
|
2020-02-28 20:16:15 +01:00
|
|
|
return s.Artist(ctx).(model.ResourceRepository)
|
2020-01-28 14:22:17 +01:00
|
|
|
case model.Album:
|
2020-02-28 20:16:15 +01:00
|
|
|
return s.Album(ctx).(model.ResourceRepository)
|
2020-01-28 14:22:17 +01:00
|
|
|
case model.MediaFile:
|
2020-02-28 20:16:15 +01:00
|
|
|
return s.MediaFile(ctx).(model.ResourceRepository)
|
2021-07-17 01:41:49 +02:00
|
|
|
case model.Genre:
|
|
|
|
return s.Genre(ctx).(model.ResourceRepository)
|
2020-05-04 02:05:03 +02:00
|
|
|
case model.Playlist:
|
|
|
|
return s.Playlist(ctx).(model.ResourceRepository)
|
2021-06-08 22:30:19 +02:00
|
|
|
case model.Share:
|
|
|
|
return s.Share(ctx).(model.ResourceRepository)
|
2020-01-28 14:22:17 +01:00
|
|
|
}
|
2020-03-28 23:50:18 +01:00
|
|
|
log.Error("Resource not implemented", "model", reflect.TypeOf(m).Name())
|
2020-01-28 14:22:17 +01:00
|
|
|
return nil
|
2020-01-20 02:40:18 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) WithTx(block func(tx model.DataStore) error) error {
|
2021-08-01 02:15:20 +02:00
|
|
|
o, err := orm.NewOrmWithDB(db.Driver, "default", s.db)
|
2020-02-28 20:16:15 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
err = o.Begin()
|
2020-01-15 17:11:33 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-02-01 18:25:05 +01:00
|
|
|
newDb := &SQLStore{orm: o}
|
2020-01-19 21:37:41 +01:00
|
|
|
err = block(newDb)
|
|
|
|
|
2020-01-15 17:11:33 +01:00
|
|
|
if err != nil {
|
|
|
|
err2 := o.Rollback()
|
|
|
|
if err2 != nil {
|
|
|
|
return err2
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err2 := o.Commit()
|
|
|
|
if err2 != nil {
|
|
|
|
return err2
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2020-01-12 23:32:06 +01:00
|
|
|
|
2020-10-02 22:18:45 +02:00
|
|
|
func (s *SQLStore) GC(ctx context.Context, rootFolder string) error {
|
|
|
|
err := s.MediaFile(ctx).(*mediaFileRepository).deleteNotInPath(rootFolder)
|
|
|
|
if err != nil {
|
|
|
|
log.Error(ctx, "Error removing dangling tracks", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
err = s.Album(ctx).(*albumRepository).purgeEmpty()
|
2020-02-01 02:17:36 +01:00
|
|
|
if err != nil {
|
2020-06-26 16:23:05 +02:00
|
|
|
log.Error(ctx, "Error removing empty albums", err)
|
2020-02-01 02:17:36 +01:00
|
|
|
return err
|
|
|
|
}
|
2020-05-19 02:32:01 +02:00
|
|
|
err = s.Artist(ctx).(*artistRepository).purgeEmpty()
|
2020-02-01 02:17:36 +01:00
|
|
|
if err != nil {
|
2020-06-26 16:23:05 +02:00
|
|
|
log.Error(ctx, "Error removing empty artists", err)
|
2020-02-01 02:17:36 +01:00
|
|
|
return err
|
|
|
|
}
|
2020-02-28 20:16:15 +01:00
|
|
|
err = s.MediaFile(ctx).(*mediaFileRepository).cleanAnnotations()
|
2020-02-01 18:15:12 +01:00
|
|
|
if err != nil {
|
2020-06-26 16:23:05 +02:00
|
|
|
log.Error(ctx, "Error removing orphan mediafile annotations", err)
|
2020-02-01 18:15:12 +01:00
|
|
|
return err
|
|
|
|
}
|
2020-02-28 20:16:15 +01:00
|
|
|
err = s.Album(ctx).(*albumRepository).cleanAnnotations()
|
2020-02-01 18:15:12 +01:00
|
|
|
if err != nil {
|
2020-06-26 16:23:05 +02:00
|
|
|
log.Error(ctx, "Error removing orphan album annotations", err)
|
2020-02-01 18:15:12 +01:00
|
|
|
return err
|
|
|
|
}
|
2020-05-19 02:32:01 +02:00
|
|
|
err = s.Artist(ctx).(*artistRepository).cleanAnnotations()
|
|
|
|
if err != nil {
|
2020-06-26 16:23:05 +02:00
|
|
|
log.Error(ctx, "Error removing orphan artist annotations", err)
|
2020-05-19 02:32:01 +02:00
|
|
|
return err
|
|
|
|
}
|
2020-08-01 18:17:06 +02:00
|
|
|
err = s.MediaFile(ctx).(*mediaFileRepository).cleanBookmarks()
|
|
|
|
if err != nil {
|
|
|
|
log.Error(ctx, "Error removing orphan bookmarks", err)
|
|
|
|
return err
|
|
|
|
}
|
2020-06-26 16:23:05 +02:00
|
|
|
err = s.Playlist(ctx).(*playlistRepository).removeOrphans()
|
|
|
|
if err != nil {
|
|
|
|
log.Error(ctx, "Error tidying up playlists", err)
|
|
|
|
}
|
2021-07-17 00:32:22 +02:00
|
|
|
err = s.Genre(ctx).(*genreRepository).purgeEmpty()
|
|
|
|
if err != nil {
|
|
|
|
log.Error(ctx, "Error removing unused genres", err)
|
|
|
|
return err
|
|
|
|
}
|
2020-06-26 16:23:05 +02:00
|
|
|
return err
|
2020-02-01 02:17:36 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 20:16:15 +01:00
|
|
|
func (s *SQLStore) getOrmer() orm.Ormer {
|
|
|
|
if s.orm == nil {
|
2021-08-01 02:15:20 +02:00
|
|
|
o, err := orm.NewOrmWithDB(db.Driver, "default", s.db)
|
2020-02-28 20:16:15 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error("Error obtaining new orm instance", err)
|
|
|
|
}
|
|
|
|
return o
|
2020-01-12 23:32:06 +01:00
|
|
|
}
|
2020-02-28 20:16:15 +01:00
|
|
|
return s.orm
|
2020-01-12 23:32:06 +01:00
|
|
|
}
|