148 lines
4.8 KiB
Python
148 lines
4.8 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
#
|
|
# Table: tracks
|
|
# +---------+-----------+------------+---------+--------+--------+
|
|
# | trackid | libraryid | artistid | albumid | discid | yearid |
|
|
# +---------+-----------+------------+---------+--------+--------+
|
|
# | number | playcount | lastplayed | length | title | path |
|
|
# +---------+-----------+------------+---------+--------+--------|
|
|
#
|
|
# Index: track_index
|
|
# +-----------------+
|
|
# | path -> trackid |
|
|
# +-----------------+
|
|
import datetime
|
|
import pathlib
|
|
from gi.repository import GObject
|
|
from . import artist
|
|
from . import album
|
|
from . import commit
|
|
from . import decade
|
|
from . import disc
|
|
from . import execute
|
|
from . import library
|
|
from . import objects
|
|
from . import year
|
|
|
|
class Track(objects.Row):
|
|
def do_get_column(self, column):
|
|
return execute(f"SELECT {column} FROM tracks "
|
|
"WHERE trackid=?", [ self.rowid ])
|
|
|
|
@GObject.Property
|
|
def library(self):
|
|
return library.Library(self.get_column("libraryid"))
|
|
|
|
@GObject.Property
|
|
def artist(self):
|
|
return artist.Artist(self.get_column("artistid"))
|
|
|
|
@GObject.Property
|
|
def album(self):
|
|
return album.Album(self.get_column("albumid"))
|
|
|
|
@GObject.Property
|
|
def disc(self):
|
|
return disc.Disc(self.get_column("discid"))
|
|
|
|
@GObject.Property
|
|
def decade(self):
|
|
return decade.Decade(self.get_column("decadeid"))
|
|
|
|
@GObject.Property
|
|
def year(self):
|
|
return year.Year(self.get_column("yearid"))
|
|
|
|
@GObject.Property
|
|
def number(self):
|
|
return self.get_column("number")
|
|
|
|
@GObject.Property
|
|
def playcount(self):
|
|
return self.get_column("playcount")
|
|
|
|
@GObject.Property
|
|
def lastplayed(self):
|
|
return self.get_column("lastplayed")
|
|
|
|
@GObject.Property
|
|
def length(self):
|
|
return self.get_column("length")
|
|
|
|
@GObject.Property
|
|
def title(self):
|
|
return self.get_column("title")
|
|
|
|
@GObject.Property
|
|
def path(self):
|
|
return pathlib.Path(self.get_column("path"))
|
|
|
|
def played(self):
|
|
execute("UPDATE tracks "
|
|
"SET playcount=playcount+1, lastplayed=? "
|
|
"WHERE trackid=?", [ datetime.datetime.now(), self.rowid ])
|
|
commit()
|
|
|
|
def last_played(self, playcount, lastplayed):
|
|
timestamp = datetime.datetime.combine(lastplayed, datetime.time())
|
|
execute("UPDATE tracks "
|
|
"SET playcount=?, lastplayed=? "
|
|
"WHERE trackid=?", [ playcount, timestamp, self.rowid ])
|
|
commit()
|
|
|
|
|
|
class TrackTable(objects.Table):
|
|
def __init__(self):
|
|
objects.Table.__init__(self, "tracks", Track)
|
|
|
|
def do_create(self):
|
|
execute("CREATE TABLE IF NOT EXISTS tracks "
|
|
"(trackid INTEGER PRIMARY KEY, "
|
|
" libraryid INTEGER, "
|
|
" artistid INTEGER, "
|
|
" albumid INTEGER, "
|
|
" discid INTEGER, "
|
|
" decadeid INTEGER, "
|
|
" yearid INTEGER, "
|
|
" number INTEGER, "
|
|
" playcount INTEGER DEFAULT 0,"
|
|
" lastplayed TIMESTAMP DEFAULT NULL, "
|
|
" length REAL, "
|
|
" title TEXT, "
|
|
" path TEXT UNIQUE, "
|
|
" FOREIGN KEY(libraryid) REFERENCES libraries(libraryid), "
|
|
" FOREIGN KEY(artistid) REFERENCES artists(artistid), "
|
|
" FOREIGN KEY(albumid) REFERENCES albums(albumid), "
|
|
" FOREIGN KEY(discid) REFERENCES discs(discid), "
|
|
" FOREIGN KEY(yearid) REFERENCES years(yearid))")
|
|
execute("CREATE INDEX IF NOT EXISTS track_index ON tracks(path)")
|
|
|
|
def do_insert(self, library, artist, album, disc, year, number, length, title, path):
|
|
return execute("INSERT INTO tracks (libraryid, artistid, albumid, discid, "
|
|
"decadeid, yearid, number, length, title, path) "
|
|
"VALUES (?,?,?,?,?,?,?,?,?,?)",
|
|
[ int(library), int(artist), int(album), int(disc),
|
|
int(year.decade), int(year), number, length, title, str(path) ])
|
|
|
|
def do_delete(self, track):
|
|
from . import genre
|
|
from . import playlist
|
|
genre.Map.delete_track(track)
|
|
playlist.Map.delete_track(track)
|
|
playlist.TempMap.delete_track(track)
|
|
return execute("DELETE FROM tracks WHERE trackid=?", [ int(track) ])
|
|
|
|
def do_get(self, rowid):
|
|
return execute("SELECT trackid FROM tracks "
|
|
"WHERE trackid=?", [ rowid ])
|
|
|
|
def do_lookup(self, path):
|
|
return execute("SELECT trackid FROM tracks "
|
|
"WHERE path=?", [ str(path) ])
|
|
|
|
def find(self, *args):
|
|
raise NotImplementedError
|
|
|
|
|
|
Table = TrackTable()
|