anna/emmental
anna
/
emmental
1
0
Fork 0
Code Issues 11 Pull Requests Projects 1 Releases 12 Wiki Activity

db: Give MappedPlaylists add_track() and remove_track() functions 

Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>
This commit is contained in:
Anna Schumaker 2021-10-15 16:06:02 -04:00
parent 0688088318
commit 5ff03cf33f
6 changed files with 114 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
db/playlist.py
View File

@ -40,6 +40,16 @@ class MappedPlaylist(Playlist):
@GObject.Property
def map_table(self): return self._map_table
def add_track(self, track):
return sql.execute(f"INSERT OR IGNORE INTO {self.map_table} "
f"({self.rowkey}, trackid) VALUES (?, ?)",
[ self.rowid, track.rowid ]).rowcount == 1
def remove_track(self, track):
return sql.execute(f"DELETE FROM {self.map_table} "
f"WHERE {self.rowkey}=? AND trackid=?",
[ self.rowid, track.rowid ]).rowcount == 1
class ParentPlaylist(Playlist):
def has_children(self): return True

13
db/test_genre.py
View File

@ -3,6 +3,7 @@ import db
import sqlite3
import unittest
from gi.repository import GObject
from . import sql
class TestGenre(unittest.TestCase):
@ -22,6 +23,18 @@ class TestGenre(unittest.TestCase):
genre.delete()
self.assertIsNone(db.genre.Table.lookup("Test Genre"))
def test_add_remove_track(self):
genre = db.genre.Table.find("Test Genre")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertTrue(genre.add_track(track))
row = sql.execute("SELECT * FROM genre_map WHERE genreid=?",
[ genre.rowid ]).fetchone()
self.assertEqual(row["trackid"], track.rowid)
self.assertEqual(row["genreid"], genre.rowid)
self.assertTrue(genre.remove_track(track))
self.assertFalse(genre.remove_track(track))
class TestGenreTable(unittest.TestCase):
def setUp(self):

69
db/test_user.py
View File

@ -3,6 +3,7 @@ import db
import sqlite3
import unittest
from gi.repository import GObject
from . import sql
class TestCollection(unittest.TestCase):
def test_init(self):
@ -15,6 +16,8 @@ class TestCollection(unittest.TestCase):
class TestFavorites(unittest.TestCase):
def setUp(self): db.reset()
def test_init(self):
favorites = db.user.Table.find("Favorites")
self.assertIsInstance(favorites, db.playlist.MappedPlaylist)
@ -24,8 +27,18 @@ class TestFavorites(unittest.TestCase):
self.assertEqual(favorites.map_table, "playlist_map")
self.assertFalse(favorites.plist_state.loop)
def test_add_remove_track(self):
favorites = db.user.Table.find("Favorites")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertTrue(favorites.add_track(track))
self.assertFalse(favorites.add_track(track))
self.assertTrue(favorites.remove_track(track))
self.assertFalse(favorites.remove_track(track))
class TestNewTracks(unittest.TestCase):
def setUp(self): db.reset()
def test_init(self):
new = db.user.Table.find("New Tracks")
self.assertIsInstance(new, db.playlist.MappedPlaylist)
@ -35,20 +48,54 @@ class TestNewTracks(unittest.TestCase):
self.assertEqual(new.map_table, "temp_playlist_map")
self.assertFalse(new.plist_state.loop)
def test_add_remove_track(self):
new = db.user.Table.find("New Tracks")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
cur = sql.execute("SELECT * FROM temp_playlist_map "
"WHERE trackid=? AND playlistid=?",
[ track.rowid, new.rowid ])
self.assertEqual(cur.fetchone()["trackid"], track.rowid)
self.assertTrue(new.remove_track(track))
self.assertFalse(new.remove_track(track))
class TestPrevious(unittest.TestCase):
def setUp(self): db.reset()
def test_init(self):
previous = db.user.Table.find("Previous")
self.assertIsInstance(previous, db.playlist.MappedPlaylist)
self.assertIsInstance(previous, db.user.UserPlaylist)
self.assertIsInstance(previous, db.user.Previous)
self.assertEqual(previous.name, "Previous")
self.assertEqual(previous.icon_name, "edit-undo")
self.assertEqual(previous.map_table, "temp_playlist_map")
self.assertEqual(previous.plist_state.sort, [ "temp_playlist_map.rowid DESC" ])
self.assertFalse(previous.plist_state.loop)
def test_add_remove_track(self):
previous = db.user.Table.find("Previous")
track1 = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertTrue(previous.add_track(track1))
cur = sql.execute("SELECT *,rowid FROM temp_playlist_map "
"WHERE trackid=? AND playlistid=?",
[ track1.rowid, previous.rowid ])
self.assertEqual(cur.fetchone()["rowid"], 2)
db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
self.assertTrue(previous.add_track(track1))
cur = sql.execute("SELECT *,rowid FROM temp_playlist_map "
"WHERE trackid=? AND playlistid=?",
[ track1.rowid, previous.rowid ])
self.assertEqual(cur.fetchone()["rowid"], 4)
self.assertTrue(previous.remove_track(track1))
self.assertFalse(previous.remove_track(track1))
class TestQueuedTracks(unittest.TestCase):
def setUp(self): db.reset()
def test_init(self):
queued = db.user.Table.find("Queued Tracks")
self.assertIsInstance(queued, db.playlist.MappedPlaylist)
@ -59,8 +106,18 @@ class TestQueuedTracks(unittest.TestCase):
self.assertEqual(queued.plist_state.sort, [ "playlist_map.rowid ASC" ])
self.assertFalse(queued.plist_state.loop)
def test_add_remove_track(self):
queued = db.user.Table.find("Queued Tracks")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertTrue(queued.add_track(track))
self.assertFalse(queued.add_track(track))
self.assertTrue(queued.remove_track(track))
self.assertFalse(queued.remove_track(track))
class TestUserPlaylist(unittest.TestCase):
def setUp(self): db.reset()
def test_init(self):
plist = db.user.Table.find("Test Playlist")
self.assertIsInstance(plist, db.playlist.MappedPlaylist)
@ -75,6 +132,14 @@ class TestUserPlaylist(unittest.TestCase):
plist.delete()
self.assertIsNone(db.user.Table.lookup("Test Playlist"))
def test_add_remove_track(self):
plist = db.user.Table.find("Test Playlist")
track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
self.assertTrue(plist.add_track(track))
self.assertFalse(plist.add_track(track))
self.assertTrue(plist.remove_track(track))
self.assertFalse(plist.remove_track(track))
class TestUserTable(unittest.TestCase):
def setUp(self):
@ -124,7 +189,7 @@ class TestPlaylistMap(unittest.TestCase):
self.assertIsInstance(db.user.TempMap, db.user.PlaylistMap)
self.assertEqual(db.user.Map.map_lhs, db.user.Table.get)
self.assertEqual(db.user.Map.map_rhs, db.track.Table.get)
self.assertEqual(db.user.Map.map_rhs, db.user.Map.get_track)
self.assertFalse(db.user.Map.temporary)
self.assertTrue( db.user.TempMap.temporary)

6
db/track.py
View File

@ -21,6 +21,7 @@ from . import disc
from . import library
from . import sql
from . import table
from . import user
from . import year
class Track(GObject.GObject):
@ -138,5 +139,10 @@ class TrackTable(table.Table):
def find(self, *args):
raise NotImplementedError
def insert(self, *args):
track = super().insert(*args)
user.Table.find("New Tracks").add_track(track)
return track
Table = TrackTable()

20
db/user.py
View File

@ -14,7 +14,6 @@ from . import objects
from . import playlist
from . import sql
from . import state
from . import track
class Collection(playlist.Playlist):
@ -37,6 +36,17 @@ class UserPlaylist(playlist.MappedPlaylist):
def name(self): return self._name
class Previous(UserPlaylist):
def __init__(self, row):
UserPlaylist.__init__(self, row, "edit-undo", "temp_playlist_map")
def add_track(self, track):
if super().add_track(track):
return True
self.remove_track(track)
return super().add_track(track)
class UserTable(playlist.Model):
def __init__(self):
playlist.Model.__init__(self, "playlists", "sort")
@ -64,7 +74,7 @@ class UserTable(playlist.Model):
elif row["name"] == "New Tracks":
return UserPlaylist(row, "starred", "temp_playlist_map")
elif row["name"] == "Previous":
return UserPlaylist(row, "edit-undo", "temp_playlist_map")
return Previous(row)
elif row["name"] == "Queued Tracks":
return UserPlaylist(row, "edit-redo", "playlist_map")
return UserPlaylist(row, "audio-x-generic", "playlist_map")
@ -87,10 +97,14 @@ class PlaylistMap(objects.Map):
name = "playlist_map" if temp==False else "temp_playlist_map"
self.temporary = temp
objects.Map.__init__(self, name, Table.get, track.Table.get)
objects.Map.__init__(self, name, Table.get, self.get_track)
self.lookup_tracks = self.lookup_rhs
self.lookup_playlists = self.lookup_lhs
def get_track(self, rowid):
from . import track
return track.Table.get(rowid)
def do_create(self):
temp = "" if self.temporary == False else "TEMPORARY"
sql.execute(f"CREATE {temp} TABLE IF NOT EXISTS {self.map_name} "

3
scanner/task.py
View File

@ -33,8 +33,7 @@ class FileTask(Task):
meta.length(), meta.title(),
self.filepath)
for genre in meta.genres():
db.genre.Map.insert(db.genre.Table.find(genre), track)
db.user.TempMap.insert(db.user.Table.find("New Tracks"), track)
db.genre.Table.find(genre).add_track(track)
class ImportTask(FileTask):