555 lines
19 KiB
Python
555 lines
19 KiB
Python
import os
|
|
import sqlite3
|
|
import logging
|
|
from hashlib import sha512
|
|
from time import time
|
|
from contextlib import closing
|
|
from collections import Iterable
|
|
|
|
|
|
from pysonic.scanner import PysonicFilesystemScanner
|
|
|
|
|
|
logger = logging.getLogger("database")
|
|
|
|
|
|
LETTER_GROUPS = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
|
|
"u", "v", "w", "xyz", "0123456789"]
|
|
|
|
|
|
keys_in_table = ["title", "album", "artist", "type", "size"]
|
|
|
|
|
|
def dict_factory(c, row):
|
|
d = {}
|
|
for idx, col in enumerate(c.description):
|
|
d[col[0]] = row[idx]
|
|
return d
|
|
|
|
|
|
class NotFoundError(Exception):
|
|
pass
|
|
|
|
|
|
class DuplicateRootException(Exception):
|
|
pass
|
|
|
|
|
|
def hash_password(unicode_string):
|
|
return sha512(unicode_string.encode('UTF-8')).hexdigest()
|
|
|
|
|
|
def cursor(func):
|
|
"""
|
|
Provides a cursor to the wrapped method as the first arg.
|
|
"""
|
|
def wrapped(*args, **kwargs):
|
|
self = args[0]
|
|
if len(args) >= 2 and isinstance(args[1], sqlite3.Cursor):
|
|
return func(*args, **kwargs)
|
|
else:
|
|
with closing(self.db.cursor()) as c:
|
|
return func(self, c, *args[1:], **kwargs)
|
|
return wrapped
|
|
|
|
|
|
class PysonicDatabase(object):
|
|
def __init__(self, path):
|
|
self.sqlite_opts = dict(check_same_thread=False)
|
|
self.path = path
|
|
self.db = None
|
|
self.open()
|
|
self.migrate()
|
|
self.scanner = PysonicFilesystemScanner(self)
|
|
|
|
def open(self):
|
|
with open(self.path, "rb"): # sqlite doesn't give very descriptive permission errors, but this does
|
|
pass
|
|
self.db = sqlite3.connect(self.path, **self.sqlite_opts)
|
|
self.db.row_factory = dict_factory
|
|
|
|
def update(self):
|
|
"""
|
|
Start the library media scanner ands
|
|
"""
|
|
self.scanner.init_scan()
|
|
|
|
def migrate(self):
|
|
# Create db
|
|
queries = ["""CREATE TABLE 'libraries' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'name' TEXT,
|
|
'path' TEXT UNIQUE);""",
|
|
"""CREATE TABLE 'dirs' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'library' INTEGER,
|
|
'parent' INTEGER,
|
|
'name' TEXT,
|
|
UNIQUE(parent, name)
|
|
)""",
|
|
"""CREATE TABLE 'genres' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'name' TEXT UNIQUE)""",
|
|
"""CREATE TABLE 'artists' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'libraryid' INTEGER,
|
|
'dir' INTEGER UNIQUE,
|
|
'name' TEXT)""",
|
|
"""CREATE TABLE 'albums' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'artistid' INTEGER,
|
|
'coverid' INTEGER,
|
|
'dir' INTEGER,
|
|
'name' TEXT,
|
|
'added' INTEGER NOT NULL DEFAULT -1,
|
|
'played' INTEGER,
|
|
'plays' INTEGER NOT NULL DEFAULT 0,
|
|
UNIQUE (artistid, dir));""",
|
|
"""CREATE TABLE 'songs' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'library' INTEGER,
|
|
'albumid' BOOLEAN,
|
|
'genre' INTEGER DEFAULT NULL,
|
|
'file' TEXT UNIQUE, -- path from the library root
|
|
'size' INTEGER NOT NULL DEFAULT -1,
|
|
'title' TEXT NOT NULL,
|
|
'lastscan' INTEGER NOT NULL DEFAULT -1,
|
|
'format' TEXT,
|
|
'length' INTEGER,
|
|
'bitrate' INTEGER,
|
|
'track' INTEGER,
|
|
'year' INTEGER,
|
|
'plays' INTEGER NOT NULL DEFAULT 0
|
|
)""",
|
|
"""CREATE TABLE 'covers' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
'library' INTEGER,
|
|
'type' TEXT,
|
|
'size' TEXT,
|
|
'path' TEXT UNIQUE);""",
|
|
"""CREATE TABLE 'users' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
|
|
'username' TEXT UNIQUE NOT NULL,
|
|
'password' TEXT NOT NULL,
|
|
'admin' BOOLEAN DEFAULT 0,
|
|
'email' TEXT)""",
|
|
"""CREATE TABLE 'stars' (
|
|
'userid' INTEGER,
|
|
'songid' INTEGER,
|
|
primary key ('userid', 'songid'))""",
|
|
"""CREATE TABLE 'playlists' (
|
|
'id' INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
|
|
'ownerid' INTEGER,
|
|
'name' TEXT,
|
|
'public' BOOLEAN,
|
|
'created' INTEGER,
|
|
'changed' INTEGER,
|
|
'cover' INTEGER,
|
|
UNIQUE ('ownerid', 'name'))""",
|
|
"""CREATE TABLE 'playlist_entries' (
|
|
'playlistid' INTEGER,
|
|
'songid' INTEGER,
|
|
'order' FLOAT)""",
|
|
"""CREATE TABLE 'meta' (
|
|
'key' TEXT PRIMARY KEY NOT NULL,
|
|
'value' TEXT);""",
|
|
"""INSERT INTO meta VALUES ('db_version', '1');"""]
|
|
|
|
with closing(self.db.cursor()) as c:
|
|
c.execute("SELECT * FROM sqlite_master WHERE type='table' AND name='meta'")
|
|
|
|
# Initialize DB
|
|
if len(c.fetchall()) == 0:
|
|
logger.warning("Initializing database")
|
|
for query in queries:
|
|
c.execute(query)
|
|
c.execute("COMMIT")
|
|
else:
|
|
# Migrate if old db exists
|
|
# c.execute("""UPDATE meta SET value=? WHERE key="db_version";""", (str(version), ))
|
|
# logger.warning("db schema is version {}".format(version))
|
|
pass
|
|
|
|
def get_artist_info(self, item_id):
|
|
#TODO
|
|
return {"biography": "placeholder biography",
|
|
"musicBrainzId": "playerholder",
|
|
"lastFmUrl": "https://www.last.fm/music/Placeholder",
|
|
"smallImageUrl": "",
|
|
"mediumImageUrl": "",
|
|
"largeImageUrl": "",
|
|
"similarArtists": []}
|
|
|
|
@cursor
|
|
def get_stats(self, c):
|
|
songs = c.execute("SELECT COUNT(*) as cnt FROM songs").fetchone()['cnt']
|
|
artists = c.execute("SELECT COUNT(*) as cnt FROM artists").fetchone()['cnt']
|
|
albums = c.execute("SELECT COUNT(*) as cnt FROM albums").fetchone()['cnt']
|
|
return dict(songs=songs, artists=artists, albums=albums)
|
|
|
|
# Music related
|
|
@cursor
|
|
def add_root(self, c, path, name="Library"):
|
|
"""
|
|
Add a new library root. Returns the root ID or raises on collision
|
|
:param path: normalized absolute path to add to the library
|
|
:type path: str:
|
|
:return: int
|
|
:raises: sqlite3.IntegrityError
|
|
"""
|
|
path = os.path.abspath(os.path.normpath(path))
|
|
try:
|
|
c.execute("INSERT INTO libraries ('name', 'path') VALUES (?, ?)", (name, path, ))
|
|
c.execute("COMMIT")
|
|
return c.lastrowid
|
|
except sqlite3.IntegrityError:
|
|
raise DuplicateRootException("Root '{}' already exists".format(path))
|
|
|
|
@cursor
|
|
def get_libraries(self, c, id=None):
|
|
libs = []
|
|
q = "SELECT * FROM libraries"
|
|
params = []
|
|
conditions = []
|
|
if id:
|
|
conditions.append("id = ?")
|
|
params.append(id)
|
|
if conditions:
|
|
q += " WHERE " + " AND ".join(conditions)
|
|
c.execute(q, params)
|
|
for row in c:
|
|
libs.append(row)
|
|
return libs
|
|
|
|
@cursor
|
|
def get_artists(self, c, id=None, dirid=None, sortby="name", order=None, name_contains=None):
|
|
assert order in ["asc", "desc", None]
|
|
artists = []
|
|
q = "SELECT * FROM artists"
|
|
params = []
|
|
conditions = []
|
|
if id:
|
|
conditions.append("id = ?")
|
|
params.append(id)
|
|
if dirid:
|
|
conditions.append("dir = ?")
|
|
params.append(dirid)
|
|
if name_contains:
|
|
conditions.append("name LIKE ?")
|
|
params.append("%{}%".format(name_contains))
|
|
if conditions:
|
|
q += " WHERE " + " AND ".join(conditions)
|
|
if sortby:
|
|
q += " ORDER BY {} {}".format(sortby, order.upper() if order else "ASC")
|
|
c.execute(q, params)
|
|
for row in c:
|
|
artists.append(row)
|
|
return artists
|
|
|
|
@cursor
|
|
def get_albums(self, c, id=None, artist=None, sortby="name", order=None, limit=None, name_contains=None):
|
|
"""
|
|
:param limit: int or tuple of int, int. translates directly to sql logic.
|
|
"""
|
|
if order:
|
|
order = {"asc": "ASC", "desc": "DESC"}[order]
|
|
|
|
if sortby == "random":
|
|
sortby = "RANDOM()"
|
|
|
|
albums = []
|
|
|
|
q = """
|
|
SELECT
|
|
alb.*,
|
|
art.name as artistname,
|
|
dirs.parent as artistdir
|
|
FROM albums as alb
|
|
INNER JOIN artists as art
|
|
on alb.artistid = art.id
|
|
INNER JOIN dirs
|
|
on dirs.id = alb.dir
|
|
"""
|
|
params = []
|
|
|
|
conditions = []
|
|
if id:
|
|
conditions.append("id = ?")
|
|
params.append(id)
|
|
if artist:
|
|
conditions.append("artistid = ?")
|
|
params.append(artist)
|
|
if name_contains:
|
|
conditions.append("alb.name LIKE ?")
|
|
params.append("%{}%".format(name_contains))
|
|
if conditions:
|
|
q += " WHERE " + " AND ".join(conditions)
|
|
|
|
if sortby:
|
|
q += " ORDER BY {}".format(sortby)
|
|
if order:
|
|
q += " {}".format(order)
|
|
|
|
if limit:
|
|
q += " LIMIT {}".format(limit) if isinstance(limit, int) \
|
|
else " LIMIT {}, {}".format(*limit)
|
|
|
|
c.execute(q, params)
|
|
for row in c:
|
|
albums.append(row)
|
|
return albums
|
|
|
|
@cursor
|
|
def get_songs(self, c, id=None, genre=None, sortby="title", order=None, limit=None, title_contains=None):
|
|
# TODO make this query massively uglier by joining albums and artists so that artistid etc can be a filter
|
|
# or maybe lookup those IDs in the library layer?
|
|
if order:
|
|
order = {"asc": "ASC", "desc": "DESC"}[order]
|
|
|
|
if sortby == "random":
|
|
sortby = "RANDOM()"
|
|
|
|
songs = []
|
|
|
|
q = """
|
|
SELECT
|
|
s.*,
|
|
lib.path as root,
|
|
alb.name as albumname,
|
|
alb.coverid as albumcoverid,
|
|
art.name as artistname,
|
|
g.name as genrename,
|
|
albdir.id as albumdir
|
|
FROM songs as s
|
|
INNER JOIN libraries as lib
|
|
on s.library == lib.id
|
|
INNER JOIN albums as alb
|
|
on s.albumid == alb.id
|
|
INNER JOIN dirs as albdir
|
|
on albdir.id = alb.dir
|
|
INNER JOIN artists as art
|
|
on alb.artistid = art.id
|
|
LEFT JOIN genres as g
|
|
on s.genre == g.id
|
|
"""
|
|
|
|
params = []
|
|
|
|
conditions = []
|
|
if id and isinstance(id, int):
|
|
conditions.append("s.id = ?")
|
|
params.append(id)
|
|
elif id and isinstance(id, Iterable):
|
|
conditions.append("s.id IN ({})".format(",".join("?" * len(id))))
|
|
params += id
|
|
if genre:
|
|
conditions.append("g.name = ?")
|
|
params.append(genre)
|
|
if title_contains:
|
|
conditions.append("s.title LIKE ?")
|
|
params.append("%{}%".format(title_contains))
|
|
if conditions:
|
|
q += " WHERE " + " AND ".join(conditions)
|
|
|
|
if sortby:
|
|
q += " ORDER BY {}".format(sortby)
|
|
if order:
|
|
q += " {}".format(order)
|
|
|
|
if limit:
|
|
q += " LIMIT {}".format(limit) # TODO support limit pagination
|
|
|
|
c.execute(q, params)
|
|
for row in c:
|
|
songs.append(row)
|
|
return songs
|
|
|
|
@cursor
|
|
def get_genres(self, c, genre_id=None):
|
|
genres = []
|
|
q = "SELECT * FROM genres"
|
|
params = []
|
|
conditions = []
|
|
if genre_id:
|
|
conditions.append("id = ?")
|
|
params.append(genre_id)
|
|
if conditions:
|
|
q += " WHERE " + " AND ".join(conditions)
|
|
c.execute(q, params)
|
|
for row in c:
|
|
genres.append(row)
|
|
return genres
|
|
|
|
@cursor
|
|
def get_cover(self, c, cover_id):
|
|
cover = None
|
|
for cover in c.execute("SELECT * FROM covers WHERE id = ?", (cover_id, )):
|
|
return cover
|
|
|
|
def get_cover_path(self, cover_id):
|
|
cover = self.get_cover(cover_id)
|
|
library = self.get_libraries(cover["library"])[0]
|
|
return os.path.join(library["path"], cover["path"])
|
|
|
|
@cursor
|
|
def get_subsonic_musicdir(self, c, dirid):
|
|
"""
|
|
The world is a harsh place.
|
|
Again, this bullshit exists only to serve subsonic clients. Given a directory ID it returns a dict containing:
|
|
- the directory itself
|
|
- its parent
|
|
- its child dirs
|
|
- its child media
|
|
|
|
that's a lie, it's a tuple and it's full of BS. read the code
|
|
"""
|
|
# find directory
|
|
dirinfo = None
|
|
for dirinfo in c.execute("SELECT * FROM dirs WHERE id = ?", (dirid, )):
|
|
pass
|
|
assert dirinfo
|
|
|
|
ret = None
|
|
|
|
# see if it matches the artists or albums table
|
|
artist = None
|
|
for artist in c.execute("SELECT * FROM artists WHERE dir = ?", (dirid, )):
|
|
pass
|
|
|
|
# if artist:
|
|
# get child albums
|
|
if artist:
|
|
ret = ("artist", dirinfo, artist)
|
|
children = []
|
|
for album in c.execute("SELECT * FROM albums WHERE artistid = ?", (artist["id"], )):
|
|
children.append(("album", album))
|
|
ret[2]['children'] = children
|
|
return ret
|
|
|
|
# else if album:
|
|
# get child tracks
|
|
album = None
|
|
for album in c.execute("SELECT * FROM albums WHERE dir = ?", (dirid, )):
|
|
pass
|
|
if album:
|
|
ret = ("album", dirinfo, album)
|
|
|
|
artist_info = c.execute("SELECT * FROM artists WHERE id = ?", (album["artistid"], )).fetchall()[0]
|
|
|
|
children = []
|
|
for song in c.execute("SELECT * FROM songs WHERE albumid = ? ORDER BY track, title ASC;", (album["id"], )):
|
|
song["_artist"] = artist_info
|
|
children.append(("song", song))
|
|
ret[2]['children'] = children
|
|
return ret
|
|
|
|
# Playlist related
|
|
@cursor
|
|
def add_playlist(self, c, ownerid, name, song_ids, public=False):
|
|
"""
|
|
Create a playlist
|
|
"""
|
|
now = time()
|
|
c.execute("INSERT INTO playlists (ownerid, name, public, created, changed) VALUES (?, ?, ?, ?, ?)",
|
|
(ownerid, name, public, now, now))
|
|
plid = c.lastrowid
|
|
for song_id in song_ids:
|
|
self.add_to_playlist(c, plid, song_id)
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def add_to_playlist(self, c, playlist_id, song_id):
|
|
# TODO deal with order column
|
|
c.execute("INSERT INTO playlist_entries (playlistid, songid) VALUES (?, ?)", (playlist_id, song_id))
|
|
|
|
@cursor
|
|
def get_playlist(self, c, playlist_id):
|
|
return c.execute("SELECT * FROM playlists WHERE id=?", (playlist_id, )).fetchone()
|
|
|
|
@cursor
|
|
def get_playlist_songs(self, c, playlist_id):
|
|
songs = []
|
|
q = """
|
|
SELECT
|
|
s.*,
|
|
alb.name as albumname,
|
|
alb.coverid as albumcoverid,
|
|
art.name as artistname,
|
|
art.name as artistid,
|
|
g.name as genrename
|
|
FROM playlist_entries as pe
|
|
INNER JOIN songs as s
|
|
on pe.songid == s.id
|
|
INNER JOIN albums as alb
|
|
on s.albumid == alb.id
|
|
INNER JOIN artists as art
|
|
on alb.artistid = art.id
|
|
LEFT JOIN genres as g
|
|
on s.genre == g.id
|
|
WHERE pe.playlistid = ?
|
|
ORDER BY pe.'order' ASC;
|
|
"""
|
|
for row in c.execute(q, (playlist_id, )):
|
|
songs.append(row)
|
|
return songs
|
|
|
|
@cursor
|
|
def get_playlists(self, c, user_id):
|
|
playlists = []
|
|
for row in c.execute("SELECT * FROM playlists WHERE ownerid=? or public=1", (user_id, )):
|
|
playlists.append(row)
|
|
return playlists
|
|
|
|
@cursor
|
|
def remove_index_from_playlist(self, c, playlist_id, index):
|
|
c.execute("DELETE FROM playlist_entries WHERE playlistid=? LIMIT ?, 1", (playlist_id, index, ))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def empty_playlist(self, c, playlist_id):
|
|
#TODO combine with delete_playlist
|
|
c.execute("DELETE FROM playlist_entries WHERE playlistid=?", (playlist_id, ))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def delete_playlist(self, c, playlist_id):
|
|
c.execute("DELETE FROM playlist_entries WHERE playlistid=?", (playlist_id, ))
|
|
c.execute("DELETE FROM playlists WHERE id=?", (playlist_id, ))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def update_album_played(self, c, album_id, last_played=None):
|
|
c.execute("UPDATE albums SET played=? WHERE id=?", (last_played, album_id, ))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def increment_album_plays(self, c, album_id):
|
|
c.execute("UPDATE albums SET plays = plays + 1 WHERE id=?", (album_id, ))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def increment_track_plays(self, c, track_id):
|
|
c.execute("UPDATE songs SET plays = plays + 1 WHERE id=?", (track_id, ))
|
|
c.execute("COMMIT")
|
|
|
|
# User related
|
|
@cursor
|
|
def add_user(self, c, username, password, is_admin=False):
|
|
c.execute("INSERT INTO users (username, password, admin) VALUES (?, ?, ?)",
|
|
(username, hash_password(password), is_admin))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def update_user(self, c, username, password, is_admin=False):
|
|
c.execute("UPDATE users SET password=?, admin=? WHERE username=?;",
|
|
(hash_password(password), is_admin, username))
|
|
c.execute("COMMIT")
|
|
|
|
@cursor
|
|
def get_user(self, c, user):
|
|
try:
|
|
column = "id" if type(user) is int else "username"
|
|
return c.execute("SELECT * FROM users WHERE {}=?;".format(column), (user, )).fetchall()[0]
|
|
except IndexError:
|
|
raise NotFoundError("User doesn't exist")
|