emmental/db/playlist.py

# Copyright 2021 (c) Anna Schumaker.
from gi.repository import GObject
from . import sql
from . import state
from . import table

class Playlist(GObject.GObject):
    def __init__(self, row, icon_name):
        GObject.GObject.__init__(self)
        self._rowkey = row.keys()[0]
        self._rowid = row[self._rowkey]
        self._plstate = state.Table.get(row["plstateid"])
        self._icon_name = icon_name

    def delete(self): raise NotImplementedError

    def has_children(self): return False

    def get_n_tracks(self):
        cur = sql.execute(f"SELECT COUNT(*) FROM tracks "
                          f"WHERE {self._rowkey}=?", [ self._rowid ])
        return cur.fetchone()[0]

    @GObject.Property
    def name(self): raise NotImplementedError

    @GObject.Property
    def icon_name(self): return self._icon_name

    @GObject.Property
    def plist_state(self): return self._plstate

    @GObject.Property
    def rowid(self): return self._rowid

    @GObject.Property
    def rowkey(self): return self._rowkey


class MappedPlaylist(Playlist):
    def __init__(self, row, icon_name, map_table):
        Playlist.__init__(self, row, icon_name)
        self._map_table = map_table

    @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 clear(self):
        sql.execute(f"DELETE FROM {self.map_table} "
                    f"WHERE {self.rowkey}=?", [ self.rowid ])

    def get_n_tracks(self):
        cur = sql.execute(f"SELECT COUNT(*) FROM {self.map_table} "
                          f"WHERE {self._rowkey}=?", [ self._rowid ])
        return cur.fetchone()[0]

    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
    def get_child_table(self): raise NotImplementedError

    def get_n_children(self):
        return self.get_child_table().get_n_children(self)

    def get_child(self, n):
        return self.get_child_table().get_child(self, n)

    def get_child_index(self, child):
        return self.get_child_table().get_child_index(self, child)

    def find_child(self, *args):
        if (res := self.lookup_child(*args)) == None:
            res = self.get_child_table().insert(self, *args)
            self.emit("children-changed", self.get_child_index(res), 0, 1)
        return res

    def lookup_child(self, *args):
        return self.get_child_table().lookup(self, *args)

    @GObject.Signal(arg_types=(int,int,int))
    def children_changed(self, pos, rm, add): pass


class Model(table.Model):
    def insert(self, *args, **kwargs):
        loop = kwargs.pop("loop", False)
        sort = kwargs.pop("sort", state.DefaultSort)
        return super().insert(state.Table.insert(loop=loop,sort=sort), *args)

    def delete(self, plist):
        state.Table.delete(plist.plist_state)
        return super().delete(plist)


class ChildModel(table.Child):
    def insert(self, *args, **kwargs):
        return super().insert(state.Table.insert(), *args)

    def delete(self, plist):
        state.Table.delete(plist.plist_state)
        return super().delete(plist)