marc/folkugat-web
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Desacoblar playlists de sessions i afegir slow jams

Browse Source
This commit is contained in:
marc
2025-11-01 19:55:24 +01:00
parent 23337f8ab3
commit 2fbdbbf290
41 changed files with 705 additions and 1418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
folkugat_web/dal/sql/playlists/conversion.py
View File

@@ -2,12 +2,13 @@ from typing import TypedDict
from folkugat_web.model import playlists as model
PlaylistRowTuple = tuple[int, int, int, int | None]
PlaylistRowTuple = tuple[int, str | None]
PlaylistEntryRowTuple = tuple[int, int, int, int | None]
class PlaylistRowDict(TypedDict):
id: int | None
session_id: int
playlist_id: int
set_id: int
tema_id: int | None
@@ -15,16 +16,16 @@ class PlaylistRowDict(TypedDict):
def playlist_entry_to_row(tema_in_set: model.PlaylistEntry) -> PlaylistRowDict:
return {
'id': tema_in_set.id,
'session_id': tema_in_set.session_id,
'playlist_id': tema_in_set.playlist_id,
'set_id': tema_in_set.set_id,
'tema_id': tema_in_set.tema_id,
}
def row_to_playlist_entry(row: PlaylistRowTuple) -> model.PlaylistEntry:
def row_to_playlist_entry(row: PlaylistEntryRowTuple) -> model.PlaylistEntry:
return model.PlaylistEntry(
id=row[0],
session_id=row[1],
playlist_id=row[1],
set_id=row[2],
tema_id=row[3],
)

20
folkugat_web/dal/sql/playlists/ddl.py
View File

@@ -4,15 +4,29 @@ from folkugat_web.dal.sql import Connection, get_connection
def create_db(con: Connection | None = None):
with get_connection(con) as con:
create_playlists_table(con)
create_playlist_entries_table(con)
def create_playlists_table(con: Connection):
query = """
CREATE TABLE IF NOT EXISTS playlists (
id INTEGER PRIMARY KEY,
session_id INTEGER NOT NULL,
set_id INTEGER NOT NULL,
tema_id INTEGER
name TEXT
)
"""
cur = con.cursor()
_ = cur.execute(query)
def create_playlist_entries_table(con: Connection):
query = """
CREATE TABLE IF NOT EXISTS playlist_entries (
id INTEGER PRIMARY KEY,
playlist_id INTEGER NOT NULL,
set_id INTEGER NOT NULL,
tema_id INTEGER,
FOREIGN KEY (playlist_id) REFERENCES playlists(id) ON DELETE CASCADE,
FOREIGN KEY (tema_id) REFERENCES temes(id) ON DELETE CASCADE
)
"""
cur = con.cursor()

78
folkugat_web/dal/sql/playlists/query.py
View File

@@ -1,11 +1,9 @@
from collections.abc import Iterable, Iterator
from collections.abc import Iterator
from typing import TypedDict
from folkugat_web.dal.sql import Connection, get_connection
from folkugat_web.dal.sql.sessions import conversion as sessions_conversion
from folkugat_web.dal.sql.temes.conversion import row_to_tema
from folkugat_web.model import playlists as model
from folkugat_web.model import temes as temes_model
from folkugat_web.model.sessions import Session
from folkugat_web.utils import groupby
@@ -15,13 +13,13 @@ from . import conversion
class QueryData(TypedDict, total=False):
id: int
set_id: int
session_id: int
playlist_id: int
def _filter_clause(
entry_id: int | None = None,
set_id: int | None = None,
session_id: int | None = None,
playlist_id: int | None = None,
) -> tuple[str, QueryData]:
filter_clauses: list[str] = []
query_data: QueryData = {}
@@ -32,9 +30,9 @@ def _filter_clause(
if set_id is not None:
filter_clauses.append("set_id = :set_id")
query_data["set_id"] = set_id
if session_id is not None:
filter_clauses.append("session_id = :session_id")
query_data["session_id"] = session_id
if playlist_id is not None:
filter_clauses.append("playlist_id = :playlist_id")
query_data["playlist_id"] = playlist_id
return " AND ".join(filter_clauses), query_data
@@ -42,14 +40,14 @@ def _filter_clause(
def get_playlist_entries(
entry_id: int | None = None,
set_id: int | None = None,
session_id: int | None = None,
playlist_id: int | None = None,
con: Connection | None = None,
) -> Iterator[model.PlaylistEntry]:
filter_clause, data = _filter_clause(entry_id=entry_id, set_id=set_id, session_id=session_id)
filter_clause, data = _filter_clause(entry_id=entry_id, set_id=set_id, playlist_id=playlist_id)
query = f"""
SELECT
id, session_id, set_id, tema_id
FROM playlists
id, playlist_id, set_id, tema_id
FROM playlist_entries
WHERE {filter_clause}
ORDER BY id ASC
"""
@@ -57,59 +55,3 @@ def get_playlist_entries(
cur = con.cursor()
_ = cur.execute(query, data)
return map(conversion.row_to_playlist_entry, cur.fetchall())
GetTuneSessionsRow = tuple[int, int, str, str, str, str | None, str | None, str | None, str | None, bool]
def get_tune_sessions(tema_ids: list[int], con: Connection | None = None) -> dict[int, list[Session]]:
placeholders = ", ".join(["?" for _ in tema_ids])
query = f"""
SELECT
p.tema_id, s.id, s.date, s.start_time, s.end_time, s.venue_name,
s.venue_url, s.notes, s.cartell_url, s.is_live
FROM playlists p JOIN sessions s ON p.session_id = s.id
WHERE p.tema_id IN ({placeholders})
"""
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, tema_ids)
result_rows: Iterable[GetTuneSessionsRow] = cur.fetchall()
return dict(groupby(
result_rows,
key_fn=lambda row: row[0],
group_fn=lambda rows: list(sessions_conversion.row_to_session(row[1:]) for row in rows)
))
CommonlyPlayedTuneRow = tuple[int, str, str, str, str, int, int]
def get_commonly_played_tunes(
tema_id: int,
con: Connection | None = None,
) -> list[temes_model.CommonlyPlayedTema]:
query = """
SELECT
id, title, alternatives, creation_date, modification_date, hidden, count
FROM (
SELECT tema_id, count(*) count FROM playlists p JOIN (
SELECT session_id, set_id
FROM playlists
WHERE tema_id = ?
) s
ON p.session_id == s.session_id AND p.set_id == s.set_id
WHERE tema_id != ?
GROUP BY tema_id
) common JOIN temes t ON common.tema_id == t.id
"""
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, [tema_id, tema_id])
result_rows: Iterable[CommonlyPlayedTuneRow] = cur.fetchall()
return [
temes_model.CommonlyPlayedTema(
tema=row_to_tema(row[:6]),
count=row[6],
) for row in result_rows
]

72
folkugat_web/dal/sql/playlists/write.py
View File

@@ -4,27 +4,66 @@ from folkugat_web.model import playlists as model
from . import conversion
def insert_playlist_entry(pl_entry: model.PlaylistEntry, con: Connection | None = None) -> model.PlaylistEntry:
def create_playlist(
name: str | None = None,
con: Connection | None = None,
) -> int:
query = """
INSERT INTO playlists
(id, session_id, set_id, tema_id)
(name)
VALUES
(:id, :session_id, :set_id, :tema_id)
(:name)
RETURNING *
"""
data = dict(name=name)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
row: conversion.PlaylistRowTuple = cur.fetchone()
return row[0]
def delete_playlist(
playlist_id: int,
con: Connection | None = None,
) -> None:
query = """
DELETE FROM playlists
WHERE id = :id
"""
data = dict(playlist_id=playlist_id)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
def insert_playlist_entry(
pl_entry: model.PlaylistEntry,
con: Connection | None = None,
) -> model.PlaylistEntry:
query = """
INSERT INTO playlist_entries
(id, playlist_id, set_id, tema_id)
VALUES
(:id, :playlist_id, :set_id, :tema_id)
RETURNING *
"""
data = conversion.playlist_entry_to_row(pl_entry)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)
row: conversion.PlaylistRowTuple = cur.fetchone()
row: conversion.PlaylistEntryRowTuple = cur.fetchone()
return conversion.row_to_playlist_entry(row)
def update_playlist_entry(entry: model.PlaylistEntry, con: Connection | None = None):
def update_playlist_entry(
entry: model.PlaylistEntry,
con: Connection | None = None,
):
query = """
UPDATE playlists
UPDATE playlist_entries
SET
id = :id, session_id = :session_id, set_id = :set_id, tema_id = :tema_id
id = :id, playlist_id = :playlist_id, set_id = :set_id, tema_id = :tema_id
WHERE
id = :id
"""
@@ -35,9 +74,12 @@ def update_playlist_entry(entry: model.PlaylistEntry, con: Connection | None = N
return
def delete_playlist_entry(entry_id: int, con: Connection | None = None):
def delete_playlist_entry(
entry_id: int,
con: Connection | None = None,
):
query = """
DELETE FROM playlists
DELETE FROM playlist_entries
WHERE id = :id
"""
data = dict(id=entry_id)
@@ -47,12 +89,16 @@ def delete_playlist_entry(entry_id: int, con: Connection | None = None):
return
def delete_playlist_set(session_id: int, set_id: int, con: Connection | None = None):
def delete_playlist_set(
playlist_id: int,
set_id: int,
con: Connection | None = None,
):
query = """
DELETE FROM playlists
WHERE session_id = :session_id AND set_id = :set_id
DELETE FROM playlist_entries
WHERE playlist_id = :playlist_id AND set_id = :set_id
"""
data = dict(session_id=session_id, set_id=set_id)
data = dict(playlist_id=playlist_id, set_id=set_id)
with get_connection(con) as con:
cur = con.cursor()
_ = cur.execute(query, data)