Move server code to this repo (#95)

move server code to this repo

app/db/sqlite/playlists.py

@@ -0,0 +1,179 @@
+import json
+from collections import OrderedDict
+
+from app.db.sqlite.tracks import SQLiteTrackMethods
+from app.db.sqlite.utils import SQLiteManager, tuple_to_playlist, tuples_to_playlists
+from app.models import Artist
+from app.utils import background
+
+
+class SQLitePlaylistMethods:
+    """
+    This class contains methods for interacting with the playlists table.
+    """
+
+    @staticmethod
+    def insert_one_playlist(playlist: dict):
+        sql = """INSERT INTO playlists(
+            artisthashes,
+            banner_pos,
+            has_gif,
+            image,
+            last_updated,
+            name,
+            trackhashes
+            ) VALUES(?,?,?,?,?,?,?)
+            """
+
+        playlist = OrderedDict(sorted(playlist.items()))
+        params = (*playlist.values(),)
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, params)
+            pid = cur.lastrowid
+            params = (pid, *params)
+
+            return tuple_to_playlist(params)
+
+    @staticmethod
+    def get_playlist_by_name(name: str):
+        sql = "SELECT * FROM playlists WHERE name = ?"
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, (name,))
+
+            data = cur.fetchone()
+
+            if data is not None:
+                return tuple_to_playlist(data)
+
+            return None
+
+    @staticmethod
+    def count_playlist_by_name(name: str):
+        sql = "SELECT COUNT(*) FROM playlists WHERE name = ?"
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, (name,))
+
+            data = cur.fetchone()
+
+            return int(data[0])
+
+    @staticmethod
+    def get_all_playlists():
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute("SELECT * FROM playlists")
+            playlists = cur.fetchall()
+
+            if playlists is not None:
+                return tuples_to_playlists(playlists)
+
+            return []
+
+    @staticmethod
+    def get_playlist_by_id(playlist_id: int):
+        sql = "SELECT * FROM playlists WHERE id = ?"
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, (playlist_id,))
+
+            data = cur.fetchone()
+
+            if data is not None:
+                return tuple_to_playlist(data)
+
+            return None
+
+    # FIXME: Extract the "add_track_to_playlist" method to use it for both the artisthash and trackhash lists.
+
+    @staticmethod
+    def add_item_to_json_list(playlist_id: int, field: str, items: list[str]):
+        """
+        Adds a string item to a json dumped list using a playlist id and field name. Takes the playlist ID, a field name, an item to add to the field, and an error to raise if the item is already in the field.
+
+        Parameters
+        ----------
+        playlist_id : int
+            The ID of the playlist to add the item to.
+        field : str
+            The field in the database that you want to add the item to.
+        item : str
+            The item to add to the list.
+        error : Exception
+            The error to raise if the item is already in the list.
+
+        Returns
+        -------
+            A list of strings.
+
+        """
+        sql = f"SELECT {field} FROM playlists WHERE id = ?"
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, (playlist_id,))
+            data = cur.fetchone()
+
+            if data is not None:
+                db_items: list[str] = json.loads(data[0])
+
+                for item in items:
+                    if item in db_items:
+                        items.remove(item)
+
+                db_items.extend(items)
+
+                sql = f"UPDATE playlists SET {field} = ? WHERE id = ?"
+                cur.execute(sql, (json.dumps(db_items), playlist_id))
+                return len(items)
+
+    @classmethod
+    def add_tracks_to_playlist(cls, playlist_id: int, trackhashes: list[str]):
+        return cls.add_item_to_json_list(playlist_id, "trackhashes", trackhashes)
+
+    @classmethod
+    @background
+    def add_artist_to_playlist(cls, playlist_id: int, trackhash: str):
+        track = SQLiteTrackMethods.get_track_by_trackhash(trackhash)
+        if track is None:
+            return
+
+        artists: list[Artist] = track.artist  # type: ignore
+        artisthashes = [a.artisthash for a in artists]
+
+        cls.add_item_to_json_list(playlist_id, "artisthashes", artisthashes)
+
+    @staticmethod
+    def update_playlist(playlist_id: int, playlist: dict):
+        sql = """UPDATE playlists SET
+            has_gif = ?,
+            image = ?,
+            last_updated = ?,
+            name = ?
+            WHERE id = ?
+            """
+
+        del playlist["id"]
+        del playlist["trackhashes"]
+        del playlist["artisthashes"]
+        del playlist['banner_pos']
+
+        playlist = OrderedDict(sorted(playlist.items()))
+        params = (*playlist.values(), playlist_id)
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, params)
+
+    @staticmethod
+    def delete_playlist(pid: str):
+        sql = "DELETE FROM playlists WHERE id = ?"
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, (pid,))
+
+    @staticmethod
+    def update_banner_pos(playlistid: int, pos: int):
+        sql = """UPDATE playlists SET banner_pos = ? WHERE id = ?"""
+
+        with SQLiteManager(userdata_db=True) as cur:
+            cur.execute(sql, (pos, playlistid))