Initial commit

4 files changed, 716 insertions, 0 deletions

diff --git a/models/__init__.py b/models/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/models/__init__.py
diff --git a/models/album.py b/models/album.py
new file mode 100644
index 0000000..727156f
--- /dev/null
+++ b/models/album.py
@@ -0,0 +1,114 @@
+from common import utils
+from db.db_manager import DbManager
+
+
+class Album():
+    def __init__(self, id=None, **kwargs):
+        if id is not None:
+            db = DbManager()
+            for row in db.execute("""SELECT * FROM album WHERE id = ?""",
+                                  (id,)):
+                setattr(self, "id", id)
+                setattr(self, "name", row[1])
+                setattr(self, "date", row[2])
+        else:
+            for (key, value) in kwargs.items():
+                setattr(self, key, value)
+
+    def delete(self):
+        db = DbManager()
+
+        for track in self.tracks:
+            track.delete()
+
+        delete_sql = "DELETE FROM album WHERE id = ?"
+        db.execute(delete_sql, (self.id,))
+
+        delete_track_rel_sql = "DELETE FROM album_track WHERE album_id = ?"
+        db.execute(delete_track_rel_sql, (self.id,))
+
+        delete_artist_rel_sql = "DELETE FROM album_artist WHERE album_id = ?"
+        db.execute(delete_artist_rel_sql, (self.id,))
+
+        db.commit()
+
+        return True
+
+    @property
+    def artists(self):
+        from models.artist import Artist
+
+        if not hasattr(self, "_artists"):
+            setattr(self, "_artists", [])
+
+            db = DbManager()
+
+            for row in db.execute("""SELECT artist.* FROM artist INNER JOIN
+                                  album_artist ON artist.id =
+                                  album_artist.artist_id WHERE album_id = ?
+                                  ORDER BY name ASC""", (self.id,)):
+                artist = Artist(id=row[0], name=row[1], sortname=row[2],
+                                musicbrainz_artistid=row[3])
+                self._artists.append(artist)
+
+        return self._artists
+
+    @property
+    def tracks(self):
+        from models.track import Track
+
+        if not hasattr(self, "_tracks"):
+            setattr(self, "_tracks", [])
+
+            db = DbManager()
+
+            for row in db.execute("""SELECT track.* FROM track
+                                 INNER JOIN album_track ON track.id =
+                                 album_track.track_id WHERE album_id = ?
+                                 ORDER BY tracknumber ASC""", (self.id,)):
+
+                track = Track(id=row[0], tracknumber=row[1], name=row[2],
+                              grouping=row[3], filename=row[4])
+                self._tracks.append(track)
+
+        return self._tracks
+
+    def save(self):
+        dirty_attributes = {}
+
+        # check if the internal dict has been modified
+        for (attr, value) in self.__dict__.items():
+            if self.__data[attr] != getattr(self, attr):
+                dirty_attributes[attr] = value
+
+        if len(dirty_attributes) > 0:
+            db = DbManager()
+
+            set_clause = utils.update_clause_from_dict(dirty_attributes)
+
+            dirty_attributes[id] = self.id
+            
+            sql = " ".join(("UPDATE album"), set_clause, "WHERE id = :id")
+            db.execute(sql, dirty_attributes)
+            db.commit()
+
+    def search(**search_params):
+        albums = []
+
+        db = DbManager()
+
+        where_clause = utils.make_where_clause(search_params)
+
+        result = None
+        if where_clause:
+            statement = " ".join(("SELECT * FROM album", where_clause))
+            result = db.execute(statement, search_params)
+        else:
+            result = db.execute("SELECT * FROM album")
+
+        for row in result:
+            albums.append(
+                Album(id=row[0], name=row[1], date=row[2])
+            )
+
+        return albums
diff --git a/models/artist.py b/models/artist.py
new file mode 100644
index 0000000..eaae27e
--- /dev/null
+++ b/models/artist.py
@@ -0,0 +1,115 @@
+from common import utils
+from db.db_manager import DbManager
+
+
+class Artist:
+    def __init__(self, id=None, **kwargs):
+        if id is not None:
+            db = DbManager()
+            for row in db.execute("""SELECT * FROM artist WHERE id = ?""",
+                                  (id,)):
+                setattr(self, "id", id)
+                setattr(self, "name", row[1])
+                setattr(self, "sortname", row[2])
+                setattr(self, "musicbrainz_artistid", row[3])
+        else:
+            for (key, value) in kwargs.items():
+                setattr(self, key, value)
+
+    def delete(self):
+        db = DbManager()
+
+        for album in self.albums:
+            album.delete()
+
+        delete_sql = "DELETE FROM artist WHERE id = ?"
+        db.execute(delete_sql, (self.id,))
+
+        delete_track_rel_sql = "DELETE FROM artist_track WHERE artist_id = ?"
+        db.execute(delete_track_rel_sql, (self.id,))
+
+        delete_album_rel_sql = "DELETE FROM album_artist WHERE artist_id = ?"
+        db.execute(delete_album_rel_sql, (self.id,))
+
+        db.commit()
+
+        return True
+
+    @property
+    def tracks(self):
+        from models.track import Track
+
+        if not hasattr(self, "_tracks"):
+            setattr(self, "_tracks", [])
+
+            db = DbManager()
+
+            for row in db.execute("""SELECT track.* FROM track
+                                  INNER JOIN artist_track ON track.id =
+                                  artist_track.track_id WHERE artist_id = ?
+                                  ORDER BY name ASC""", (self.id,)):
+
+                track = Track(id=row[0], tracknumber=row[1], name=row[2],
+                              grouping=row[3], filename=row[4])
+                self._tracks.append(track)
+
+        return self._tracks
+
+    @property
+    def albums(self):
+        from models.album import Album
+
+        if not hasattr(self, "_albums"):
+            setattr(self, "_albums", [])
+
+            db = DbManager()
+
+            for row in db.execute("""SELECT album.* FROM album
+                                  INNER JOIN album_artist ON album.id =
+                                  album_artist.album_id WHERE artist_id = ?
+                                  ORDER BY date ASC""", (self.id,)):
+                album = Album(id=row[0], name=row[1], date=row[2])
+                self._albums.append(album)
+
+        return self._albums
+
+    def save(self):
+        dirty_attributes = {}
+
+        # check if the internal dict has been modified
+        for (attr, value) in self.__dict__.items():
+            if self.__data[attr] != getattr(self, attr):
+                dirty_attributes[attr] = value
+
+        if len(dirty_attributes) > 0:
+            db = DbManager()
+
+            set_clause = utils.update_clause_from_dict(dirty_attributes)
+
+            dirty_attributes[id] = self.id
+            
+            sql = " ".join(("UPDATE artist"), set_clause, "WHERE id = :id")
+            db.execute(sql, dirty_attributes)
+            db.commit()
+
+    def search(**search_params):
+        artists = []
+
+        db = DbManager()
+
+        where_clause = utils.make_where_clause(search_params)
+
+        result = []
+        if where_clause:
+            statement = " ".join(("SELECT * FROM artist", where_clause))
+            result = db.execute(statement, search_params)
+        else:
+            result = db.execute("SELECT * FROM artist")
+
+        for row in result:
+            artists.append(
+                Artist(id=row[0], name=row[1], sortname=row[2],
+                       musicbrainz_artistid=row[3])
+            )
+
+        return artists
diff --git a/models/track.py b/models/track.py
new file mode 100644
index 0000000..264db81
--- /dev/null
+++ b/models/track.py
@@ -0,0 +1,487 @@
+import sqlite3
+
+from common import utils
+from db.db_manager import DbManager
+from models.artist import Artist
+from models.album import Album
+
+
+class Track:
+
+    def __init__(self, id=None, **kwargs):
+
+        setattr(self, "__data", {})
+
+        if id is not None:
+            db = DbManager()
+            for row in db.execute("""SELECT * FROM track WHERE id = ?""",
+                                  (id,)):
+                setattr(self, "id", row[0])
+                setattr(self, "tracknumber", row[1])
+                setattr(self, "name", row[2])
+                setattr(self, "grouping", row[3])
+                setattr(self, "filename", row[4])
+        else:
+            for (key, value) in kwargs.items():
+                setattr(self, key, value)
+                self.__data[key] = value
+
+    def delete(self):
+        db = DbManager()
+
+        delete_sql = "DELETE FROM track WHERE id = ?"
+        db.execute(delete_sql, (self.id,))
+        db.commit()
+
+        return True
+
+    @property
+    def album(self):
+        if not hasattr(self, "_album"):
+            setattr(self, "_album", None)
+
+            db = DbManager()
+
+            for row in db.execute("""SELECT album.* FROM album INNER JOIN
+                                  album_track ON album.id =
+                                  album_track.album_id WHERE track_id = ?
+                                  LIMIT 1""", (self.id,)):
+                setattr(self, "_album", Album(row[0]))
+
+        return self._album
+
+    @property
+    def artists(self):
+        if not hasattr(self, "_artists"):
+            db = DbManager()
+
+            setattr(self, "_artists", [])
+            for row in db.execute("""SELECT artist.* FROM artist INNER JOIN
+                                  artist_track ON artist.id =
+                                  artist_track.artist_id WHERE
+                                  artist.id = ?""", (self.id,)):
+                self._artists.append(Artist(row[0]))
+
+        return self._artists
+
+    def update(self, metadata):
+        db = DbManager()
+        c = db.cursor()
+
+        artist_names = metadata["artist"]
+        musicbrainz_artist_ids = []
+        artistsorts = []
+        try:
+            musicbrainz_artist_ids = metadata["musicbrainz_artistid"]
+        except KeyError:
+            pass
+        try:
+            artistsorts = metadata["artistsort"]
+        except KeyError:
+            pass
+
+        i = 0
+        artists = []
+
+        for artist_name in artist_names:
+            musicbrainz_artistid = None
+            artistsort = None
+
+            try:
+                musicbrainz_artistid = musicbrainz_artist_ids[i]
+            except IndexError:
+                pass
+            try:
+                artistsort = artistsorts[i]
+            except IndexError:
+                pass
+
+            rows = None
+
+            if musicbrainz_artistid:
+                rows = c.execute("""SELECT * FROM artist WHERE
+                    musicbrainz_artist_id = ?""",
+                                 (musicbrainz_artistid,))
+            else:
+                rows = c.execute("""SELECT * FROM artist WHERE
+                    name = ?""", (artist_name,))
+
+            row = rows.fetchone()
+
+            if row:
+                artist = Artist(id=row[0], name=row[1],
+                                sortname=row[2],
+                                musicbrainz_artist_id=row[3])
+
+                if artist.name != artist_name:
+                    c.execute("""UPDATE artist SET name = ? WHERE id = ?""",
+                              (artist_name, artist.id))
+                    artist.name = artist_name
+
+                if artist.sortname != artistsort:
+                    c.execute("""UPDATE artist SET sortname = ? WHERE id =
+                              ? """, (artistsort, id))
+                    artist.sortname = artistsort
+
+            else:
+                c.execute("""INSERT INTO artist
+                    (name, sortname, musicbrainz_artist_id) VALUES(
+                    ?,?,?)""", (artist_name, artistsort,
+                                musicbrainz_artistid))
+
+                artist = Artist(
+                    id=c.lastrowid, name=artist_name,
+                    sortname=artistsort,
+                    musicbrainz_artist_id=musicbrainz_artistid
+                )
+
+                i += 1
+
+            artists.append(artist)
+
+        album_name = None
+        album_date = None
+        mb_albumid = None
+
+        album = None
+        try:
+            album_name = metadata["album"][0]
+        except KeyError:
+            pass
+        try:
+            album_date = metadata["date"][0]
+        except KeyError:
+            pass
+
+        try:
+            mb_albumid = metadata["musicbrainz_albumid"][0]
+        except KeyError:
+            pass
+
+        if mb_albumid:
+            rows = c.execute(
+                """SELECT * FROM album WHERE musicbrainz_albumid = ?""",
+                (mb_albumid,)
+            )
+
+            row = rows.fetchone()
+
+            if row:
+                album = Album(id=row[0], name=row[1], date=row[2],
+                              mb_albumid=row[3])
+            else:
+                c.execute("""INSERT INTO album (name, `date`,
+                          musicbrainz_albumid) VALUES (?,?,?)""",
+                          (album_name, album_date, mb_albumid))
+
+                album = Album(id=c.lastrowid, name=album_name,
+                              date=album_date, musicbrainz_albumid=mb_albumid)
+
+        elif album_name:
+            rows = c.execute(
+                """SELECT album.* FROM album INNER JOIN album_artist ON
+                album_artist.album_id = album.id WHERE album.name = ?
+                AND artist_id = ?""", (album_name, artist.id)
+            )
+            row = rows.fetchone()
+
+            if row:
+                album = Album(id=row[0], name=row[1], date=row[2])
+            else:
+                c.execute("""INSERT INTO album (name, `date`) VALUES
+                (?,?)""", (album_name, album_date))
+
+                album = Album(id=c.lastrowid, name=album_name,
+                              date=album_date)
+
+        if album:
+            if album.name != album_name:
+                c.execute("""UPDATE album SET name = ? WHERE id = ?""",
+                          (album_name, album.id))
+                album.name = album_name
+
+            if album.date != album_date:
+                c.execute("""UPDATE album SET date = ? WHERE id = ?""",
+                          (album_date, album.id))
+                album.date = album_date
+
+        for artist in artists:
+            if album:
+                try:
+                    c.execute(
+                        """INSERT INTO album_artist (artist_id,
+                        album_id) VALUES(?,?)""",
+                        (artist.id, album.id)
+                    )
+                except sqlite3.IntegrityError:
+                    pass
+
+        track_number = None
+        track_name = None
+        track_grouping = None
+        try:
+            track_number = metadata["tracknumber"][0]
+        except KeyError:
+            pass
+        try:
+            track_name = metadata["title"][0]
+        except KeyError:
+            pass
+        try:
+            track_grouping = metadata["grouping"][0]
+        except KeyError:
+            pass
+
+        c.execute("""UPDATE track SET tracknumber = ?, name = ?,
+                  grouping = ? WHERE id = ?""",
+                  (track_number, track_name, track_grouping,
+                   self.id))
+
+        if album:
+            try:
+                c.execute("""INSERT INTO album_track (album_id,
+                          track_id) VALUES(?,?)""",
+                          (album.id, self.id))
+            except sqlite3.IntegrityError:
+                pass
+
+        for artist in artists:
+            try:
+                c.execute("""INSERT INTO artist_track
+                          (artist_id, track_id) VALUES(?,?)""",
+                          (artist.id, self.id))
+            except sqlite3.IntegrityError:
+                pass
+
+        db.commit()
+        c.close()
+        return True
+
+    def save(self):
+        dirty_attributes = {}
+
+        # check if the internal dict has been modified
+        for (attr, value) in self.__dict__.items():
+            if self.__data[attr] != getattr(self, attr):
+                dirty_attributes[attr] = value
+
+        if len(dirty_attributes) > 0:
+            db = DbManager()
+
+            set_clause = utils.update_clause_from_dict(dirty_attributes)
+
+            dirty_attributes[id] = self.id
+            
+            sql = " ".join(("UPDATE track"), set_clause, "WHERE id = :id")
+            db.execute(sql, dirty_attributes)
+            db.commit()
+
+    def search(**search_params):
+        db = DbManager()
+        tracks = []
+
+        where_clause = utils.make_where_clause(search_params)
+
+        result = None
+        if where_clause:
+            statement = " ".join(("SELECT * FROM track", where_clause))
+            result = db.execute(statement, search_params)
+        else:
+            result = db.execute("SELECT * FROM track")
+
+        for row in result:
+            tracks.append(
+                Track(id=row[0], tracknumber=row[1], name=row[3],
+                      grouping=row[3], filename=row[4])
+            )
+
+        return tracks
+
+    def find_by_path(path):
+        db = DbManager()
+        track = None
+
+        for row in db.execute("SELECT * FROM track WHERE filename = ? LIMIT 1",
+                              (path,)):
+            track = Track(row[0])
+
+        return track
+
+    def store(filename, metadata):
+        db = DbManager()
+        c = db.cursor()
+
+        artist_names = metadata["artist"]
+        musicbrainz_artist_ids = []
+        artistsorts = []
+        try:
+            musicbrainz_artist_ids = metadata["musicbrainz_artistid"]
+        except KeyError:
+            pass
+        try:
+            artistsorts = metadata["artistsort"]
+        except KeyError:
+            pass
+
+        i = 0
+        artists = []
+
+        for artist_name in artist_names:
+            musicbrainz_artistid = None
+            artistsort = None
+            try:
+                musicbrainz_artistid = musicbrainz_artist_ids[i]
+            except IndexError:
+                pass
+            try:
+                artistsort = artistsorts[i]
+            except IndexError:
+                pass
+
+            rows = None
+            if musicbrainz_artistid:
+                rows = c.execute("""SELECT * FROM artist WHERE
+                    musicbrainz_artist_id = ?""",
+                                 (musicbrainz_artistid,))
+            else:
+                rows = c.execute("""SELECT * FROM artist WHERE
+                    name = ?""", (artist_name,))
+            row = rows.fetchone()
+            if row:
+                artist = Artist(id=row[0], name=row[1],
+                                sortname=row[2],
+                                musicbrainz_artist_id=row[3])
+            else:
+                c.execute("""INSERT INTO artist
+                    (name, sortname, musicbrainz_artist_id) VALUES(
+                    ?,?,?)""", (artist_name, artistsort,
+                                musicbrainz_artistid))
+
+                artist = Artist(
+                    id=c.lastrowid, name=artist_name,
+                    sortname=artistsort,
+                    musicbrainz_artist_id=musicbrainz_artistid
+                )
+
+                i += 1
+
+            artists.append(artist)
+
+        album_name = None
+        album_date = None
+        mb_albumid = None
+
+        album = None
+        try:
+            album_name = metadata["album"][0]
+        except KeyError:
+            pass
+        try:
+            album_date = metadata["date"][0]
+        except KeyError:
+            pass
+
+        try:
+            mb_albumid = metadata["musicbrainz_albumid"][0]
+        except KeyError:
+            pass
+
+        if mb_albumid:
+            rows = c.execute(
+                """SELECT * FROM album WHERE musicbrainz_albumid = ?""",
+                (mb_albumid,)
+            )
+
+            row = rows.fetchone()
+
+            if row:
+                album = Album(id=row[0], name=row[1], date=row[2],
+                              mb_albumid=row[3])
+            else:
+                c.execute("""INSERT INTO album (name, `date`,
+                          musicbrainz_albumid) VALUES (?,?,?)""",
+                          (album_name, album_date, mb_albumid))
+
+                album = Album(id=c.lastrowid, name=album_name,
+                              date=album_date, musicbrainz_albumid=mb_albumid)
+
+        elif album_name:
+            rows = c.execute(
+                """SELECT album.* FROM album INNER JOIN album_artist ON
+                album_artist.album_id = album.id WHERE album.name = ?
+                AND artist_id = ?""", (album_name, artist.id)
+            )
+            row = rows.fetchone()
+
+            if row:
+                album = Album(id=row[0], name=row[1], date=row[2])
+            else:
+                c.execute("""INSERT INTO album (name, `date`) VALUES
+                (?,?)""", (album_name, album_date))
+
+                album = Album(id=c.lastrowid, name=album_name,
+                              date=album_date)
+
+        for artist in artists:
+            if album:
+                try:
+                    c.execute(
+                        """INSERT INTO album_artist (artist_id,
+                        album_id) VALUES(?,?)""",
+                        (artist.id, album.id)
+                    )
+                except sqlite3.IntegrityError:
+                    pass
+
+        track_number = None
+        track_name = None
+        track_grouping = None
+        try:
+            track_number = metadata["tracknumber"][0]
+        except KeyError:
+            pass
+        try:
+            track_name = metadata["title"][0]
+        except KeyError:
+            pass
+        try:
+            track_grouping = metadata["grouping"][0]
+        except KeyError:
+            pass
+
+        track = None
+        rows = c.execute("""SELECT * FROM track WHERE filename = ?""",
+                         (filename,))
+        row = rows.fetchone()
+        if row:
+            track = Track(id=row[0], tracknumber=row[1], name=row[2],
+                          grouping=row[3], filename=row[4])
+        else:
+            c.execute("""INSERT INTO track (tracknumber, name,
+                grouping, filename) VALUES(?,?,?,?)""",
+                      (track_number, track_name, track_grouping,
+                       filename))
+
+            track = Track(id=c.lastrowid, tracknumber=track_number,
+                          name=track_name, grouping=track_grouping,
+                          filename=filename)
+
+        if album:
+            try:
+                c.execute("""INSERT INTO album_track (album_id,
+                          track_id) VALUES(?,?)""",
+                          (album.id, track.id))
+            except sqlite3.IntegrityError:
+                pass
+
+        for artist in artists:
+            try:
+                c.execute("""INSERT INTO artist_track
+                          (artist_id, track_id) VALUES(?,?)""",
+                          (artist.id, track.id))
+            except sqlite3.IntegrityError:
+                pass
+
+        db.commit()
+        c.close()
+        return True