lucasjensen/TheGrapefruitsDuo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #15 from ljensen505/sql-syntax-highlighting

Browse Source 
enabled syntax highlighting for queries
This commit is contained in:
Lucas Jensen
2024-05-25 18:34:32 -07:00
committed by GitHub
parent b35e8406a6 32f9a02528
commit 70304595eb
14 changed files with 198 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
server/.gitignore vendored
View File

@@ -175,4 +175,5 @@ pyrightconfig.json
# End of https://www.toptal.com/developers/gitignore/api/python
*.log
*.log
.vscode/

2
server/app/controllers/events.py
View File

@@ -50,7 +50,7 @@ class EventController(BaseController):
:raises HTTPException: If any error occurs (status code 500)
:return list[EventSeries]: A list of EventSeries objects suitable for a response body
"""
series_data = self.db.select_all_series()
series_data = self.db.select_all()
try:
return [series for series in self._all_series(series_data).values()]

2
server/app/controllers/musicians.py
View File

@@ -32,7 +32,7 @@ class MusicianController(BaseController):
:raises HTTPException: If any error occurs during the retrieval process (status code 500)
:return list[Musician]: A list of Musician objects suitable for a response body
"""
data = self.db.select_all_series()
data = self.db.select_all()
try:
return [Musician(**m) for m in data]
except Exception as e:

2
server/app/controllers/users.py
View File

@@ -30,7 +30,7 @@ class UserController(BaseController):
:raises HTTPException: If any error occurs during the retrieval process (status code 500)
:return list[User]: A list of User objects suitable for a response body
"""
data = self.db.select_all_series()
data = self.db.select_all()
try:
return [User(**e) for e in data]
except Exception as e:

48
server/app/db/base_queries.py
View File

@@ -1,6 +1,8 @@
from typing import Callable
from icecream import ic
from mysql.connector.connection import MySQLConnection
from mysql.connector.cursor import MySQLCursor
from app.db.conn import connect_db
@@ -15,25 +17,39 @@ class BaseQueries:
def __init__(self) -> None:
self.table: str = None # type: ignore
self.connect_db: Callable = connect_db
self.connect_db: Callable[[], MySQLConnection] = connect_db
def select_all_series(self) -> list[dict]:
query = f"SELECT * FROM {self.table}"
db = connect_db()
cursor = db.cursor(dictionary=True)
def select_all(self) -> list[dict]:
query = f"""-- sql
SELECT * FROM {self.table}
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query)
data = cursor.fetchall()
cursor.close()
db.close()
return data # type: ignore
data: list[dict] = cursor.fetchall() # type: ignore
self.close_cursor_and_conn(cursor, conn)
fake_query = f"""-- sql
select * from dogs
"""
return data
def select_one_by_id(self, id: int) -> dict | None:
query = f"SELECT * FROM {self.table} WHERE id = %s"
db = self.connect_db()
cursor = db.cursor(dictionary=True)
query = f"""-- sql
SELECT * FROM {self.table} WHERE id = %s
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (id,))
data = cursor.fetchone()
cursor.close()
db.close()
data: dict | None = cursor.fetchone() # type: ignore
self.close_cursor_and_conn(cursor, conn)
return data # type: ignore
return data
def get_cursor_and_conn(self) -> tuple[MySQLCursor, MySQLConnection]:
conn = self.connect_db()
cursor = conn.cursor(dictionary=True)
return cursor, conn
def close_cursor_and_conn(self, cursor: MySQLCursor, conn: MySQLConnection) -> None:
cursor.close()
conn.close()

122
server/app/db/events.py
View File

@@ -1,5 +1,3 @@
from asyncio import gather
from icecream import ic
from app.constants import EVENT_TABLE, SERIES_TABLE
@@ -15,52 +13,46 @@ class EventQueries(BaseQueries):
def __init__(self) -> None:
super().__init__()
self.table = SERIES_TABLE
def select_one_by_id(self, series_id: int) -> list[dict] | None:
query = f"""
SELECT s.series_id , s.name , s.description , s.poster_id , e.event_id , e.location , e.`time` , e.ticket_url , e.map_url
FROM {SERIES_TABLE} s
LEFT JOIN {EVENT_TABLE} e
ON s.series_id = e.series_id
WHERE s.series_id = %s
"""
db = self.connect_db()
cursor = db.cursor(dictionary=True)
query = f"""-- sql
SELECT s.series_id , s.name , s.description , s.poster_id , e.event_id , e.location , e.`time` , e.ticket_url , e.map_url
FROM {SERIES_TABLE} s
LEFT JOIN {EVENT_TABLE} e
ON s.series_id = e.series_id
WHERE s.series_id = %s
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (series_id,))
data = cursor.fetchall()
cursor.close()
db.close()
data: list[dict] = cursor.fetchall() # type: ignore
self.close_cursor_and_conn(cursor, conn)
return data
def select_all_series(self) -> list[dict]:
def select_all(self) -> list[dict]:
"""
Queries for all Series and Event info and returns a list of dictionaries.
Data is gathered with a LEFT JOIN on the Event table to ensure all Series are returned.
A Series with no Events is valid.
"""
query = f"""
query = f"""-- sql
SELECT s.series_id , s.name , s.description , s.poster_id , e.event_id , e.location , e.`time` , e.ticket_url , e.map_url
FROM {SERIES_TABLE} s
LEFT JOIN {EVENT_TABLE} e
ON s.series_id = e.series_id
"""
db = self.connect_db()
cursor = db.cursor(dictionary=True)
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query)
data = cursor.fetchall()
cursor.close()
db.close()
data: list[dict] = cursor.fetchall() # type: ignore
self.close_cursor_and_conn(cursor, conn)
return data
def insert_one_series(self, series: NewEventSeries) -> int:
query = f"""
INSERT INTO {self.table} (name, description)
query = f"""-- sql
INSERT INTO {SERIES_TABLE} (name, description)
VALUES (%s, %s)
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
cursor.execute(
query,
(
@@ -69,91 +61,87 @@ class EventQueries(BaseQueries):
),
)
inserted_id = cursor.lastrowid
db.commit()
cursor.close()
db.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)
if inserted_id is None:
raise Exception("insertion error")
return inserted_id
def insert_one_event(self, event: NewEvent, series_id: int) -> int:
query = f"""
query = f"""-- sql
INSERT INTO {EVENT_TABLE} (series_id, location, time, ticket_url, map_url)
VALUES (%s, %s, %s, %s, %s)
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
ticket_url = str(event.ticket_url) if event.ticket_url else None
map_url = str(event.map_url) if event.map_url else None
cursor.execute(
query, (series_id, event.location, event.time, ticket_url, map_url)
)
iserted_id = cursor.lastrowid
db.commit()
cursor.close()
db.close()
return iserted_id
inserted_id = cursor.lastrowid
conn.commit()
self.close_cursor_and_conn(cursor, conn)
if inserted_id is None:
raise Exception("error inserting event")
return inserted_id
def delete_events_by_series(self, series: EventSeries) -> None:
query = f"""
query = f"""-- sql
DELETE FROM {EVENT_TABLE}
WHERE series_id = %s
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (series.series_id,))
db.commit()
cursor.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)
def delete_one_series(self, series: EventSeries) -> None:
query = f"""
DELETE FROM {self.table}
query = f"""-- sql
DELETE FROM {SERIES_TABLE}
WHERE series_id = %s
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (series.series_id,))
db.commit()
cursor.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)
def update_series_poster(self, series: EventSeries) -> None:
query = f"""
UPDATE {self.table}
query = f"""-- sql
UPDATE {SERIES_TABLE}
SET poster_id = %s
WHERE series_id = %s
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (series.poster_id, series.series_id))
db.commit()
cursor.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)
def replace_event(self, event: Event) -> None:
query = f"""
query = f"""-- sql
UPDATE {EVENT_TABLE}
SET location = %s, time = %s, ticket_url = %s, map_url = %s
WHERE event_id = %s
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
ticket_url = str(event.ticket_url) if event.ticket_url else None
map_url = str(event.map_url) if event.map_url else None
cursor.execute(
query, (event.location, event.time, ticket_url, map_url, event.event_id)
)
db.commit()
cursor.close()
db.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)
def replace_series(self, series: EventSeries) -> None:
query = f"""
UPDATE {self.table}
query = f"""-- sql
UPDATE {SERIES_TABLE}
SET name = %s, description = %s, poster_id = %s
WHERE series_id = %s
"""
db = self.connect_db()
cursor = db.cursor()
cursor, conn = self.get_cursor_and_conn()
cursor.execute(
query, (series.name, series.description, series.poster_id, series.series_id)
)
db.commit()
cursor.close()
db.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)

26
server/app/db/group.py
View File

@@ -8,29 +8,29 @@ class GroupQueries(BaseQueries):
self.table = GROUP_TABLE
def select_one_by_id(self) -> dict:
query = f"SELECT * FROM {self.table}"
db = self.connect_db()
cursor = db.cursor(dictionary=True)
query = f"""-- sql
SELECT * FROM {self.table}
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query)
data = cursor.fetchone()
cursor.close()
db.close()
data: dict = cursor.fetchone() # type: ignore
self.close_cursor_and_conn(cursor, conn)
if not data:
raise Exception("error retrieving group")
return data
def select_all_series(self) -> None:
def select_all(self) -> None:
raise NotImplementedError(
"get_all method not implemented for GroupQueries. There's only one row in the table."
)
def update_group_bio(self, bio: str) -> None:
db = self.connect_db()
cursor = db.cursor()
query = f"UPDATE {self.table} SET bio = %s WHERE id = 1" # only one row in the table
cursor, conn = self.get_cursor_and_conn()
query = f"""-- sql
UPDATE {self.table} SET bio = %s WHERE id = 1
""" # only one row in the table
cursor.execute(query, (bio,))
db.commit()
cursor.close()
db.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)

8
server/app/db/musicians.py
View File

@@ -20,7 +20,9 @@ class MusicianQueries(BaseQueries):
"""
db = connect_db()
cursor = db.cursor()
query = f"UPDATE {self.table} SET bio = %s WHERE id = %s"
query = f"""-- sql
UPDATE {self.table} SET bio = %s WHERE id = %s
"""
cursor.execute(query, (bio, musician.id))
db.commit()
cursor.close()
@@ -36,7 +38,9 @@ class MusicianQueries(BaseQueries):
"""
db = connect_db()
cursor = db.cursor()
query = f"UPDATE {self.table} SET headshot_id = %s WHERE id = %s"
query = f"""-- sql
UPDATE {self.table} SET headshot_id = %s WHERE id = %s
"""
cursor.execute(query, (headshot_id, musician.id))
db.commit()
cursor.close()

61
server/app/db/users.py
View File

@@ -3,40 +3,59 @@ from app.db.base_queries import BaseQueries
class UserQueries(BaseQueries):
"""
Used for quering the database for User related data
"""
def __init__(self) -> None:
super().__init__()
self.table = USER_TABLE
def select_one_by_email(self, email: str) -> dict | None:
query = f"SELECT * FROM {self.table} WHERE email = %s"
db = self.connect_db()
cursor = db.cursor(dictionary=True)
"""
Select one user by their email address
:param str email: user email
:return dict | None: a dictionary of found data, or None if no user found
"""
query = f"""-- sql
SELECT * FROM {USER_TABLE} WHERE email = %s
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (email,))
data = cursor.fetchone()
cursor.close()
db.close()
data: dict = cursor.fetchone() # type: ignore
self.close_cursor_and_conn(cursor, conn)
return data
def select_one_by_sub(self, sub: str) -> dict | None:
query = f"SELECT * FROM {self.table} WHERE sub = %s"
db = self.connect_db()
cursor = db.cursor(dictionary=True)
cursor.execute(query, (sub,))
data = cursor.fetchone()
cursor.close()
db.close()
"""
Select one user by their unique sub identifier
if not data:
return None
:param str sub: user sub
:return dict | None: a dict of user data
"""
query = f"""-- sql
SELECT * FROM {USER_TABLE} WHERE sub = %s
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (sub,))
data: dict = cursor.fetchone() # type: ignore
self.close_cursor_and_conn(cursor, conn)
return data
def update_sub(self, email: str, sub: str) -> None:
query = f"UPDATE {self.table} SET sub = %s WHERE email = %s"
db = self.connect_db()
cursor = db.cursor()
"""
Update user sub. Used when a user logs in for the first time.
:param str email: user email
:param str sub: the new unique sub identifier
"""
query = f"""-- sql
UPDATE {USER_TABLE} SET sub = %s WHERE email = %s
"""
cursor, conn = self.get_cursor_and_conn()
cursor.execute(query, (sub, email))
db.commit()
cursor.close()
db.close()
conn.commit()
self.close_cursor_and_conn(cursor, conn)

71
server/app/scripts/seed.py
View File

@@ -82,32 +82,13 @@ series1 = EventSeries(
series_id=0,
)
# series2 = EventSeries(
# name="The Grapefruits Duo Features: Solos for Bass Trombone",
# description="Pieces by Ewazen, Bozza, and more!",
# events=[
# Event(
# location="Eugene Family YMCA",
# time=datetime(2024, 7, 1, 17, 30),
# event_id=0,
# ),
# Event(
# location="Tobi's Crate",
# time=datetime(2024, 7, 2, 20),
# event_id=0,
# ticket_url="http://www.example.com", # type: ignore
# ),
# ],
# id=0,
# )
def seed():
confirmation = input(
"Are you sure you want to seed the database? Data will be lost. [Y/n]: "
)
if confirmation.lower() not in ["y", "yes", ""]:
print("Exiting")
print("Exiting without changes")
return
print("Seeding database")
add_musicians()
@@ -121,10 +102,12 @@ def add_group():
db = connect_db()
cursor = db.cursor()
cursor.execute(
f"DROP TABLE IF EXISTS {GROUP_TABLE};",
f"""-- sql
DROP TABLE IF EXISTS {GROUP_TABLE};
""",
)
cursor.execute(
f"""
f"""-- sql
CREATE TABLE {GROUP_TABLE} (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
@@ -134,7 +117,9 @@ def add_group():
"""
)
cursor.execute(
f"INSERT INTO {GROUP_TABLE} (name, bio) VALUES (%s, %s);",
f"""-- sql
INSERT INTO {GROUP_TABLE} (name, bio) VALUES (%s, %s);
""",
(tgd.name, tgd.bio),
)
db.commit()
@@ -146,10 +131,12 @@ def add_users():
db = connect_db()
cursor = db.cursor()
cursor.execute(
f"DROP TABLE IF EXISTS {USER_TABLE};",
f"""-- sql
DROP TABLE IF EXISTS {USER_TABLE};
""",
)
cursor.execute(
f"""
f"""-- sql
CREATE TABLE {USER_TABLE} (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
@@ -161,7 +148,9 @@ def add_users():
)
for u in [coco_user, margarite_user, lucas_user, tgd_user, tgd_website]:
cursor.execute(
f"INSERT INTO {USER_TABLE} (name, email, sub) VALUES (%s, %s, %s);",
f"""-- sql
INSERT INTO {USER_TABLE} (name, email, sub) VALUES (%s, %s, %s);
""",
(u.name, u.email, u.sub),
)
@@ -175,10 +164,12 @@ def add_musicians():
db = connect_db()
cursor = db.cursor()
cursor.execute(
f"DROP TABLE IF EXISTS {MUSICIAN_TABLE};",
f"""-- sql
DROP TABLE IF EXISTS {MUSICIAN_TABLE};
""",
)
cursor.execute(
f"""
f"""-- sql
CREATE TABLE {MUSICIAN_TABLE} (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
@@ -190,7 +181,9 @@ def add_musicians():
)
for m in [margarite, coco]:
cursor.execute(
f"INSERT INTO {MUSICIAN_TABLE} (name, bio, headshot_id) VALUES (%s, %s, %s);",
f"""-- sql
INSERT INTO {MUSICIAN_TABLE} (name, bio, headshot_id) VALUES (%s, %s, %s);
""",
(m.name, m.bio, m.headshot_id),
)
@@ -204,13 +197,17 @@ def add_events():
db = connect_db()
cursor = db.cursor()
cursor.execute(
f"DROP TABLE IF EXISTS {EVENT_TABLE};",
f"""-- sql
DROP TABLE IF EXISTS {EVENT_TABLE};
""",
)
cursor.execute(
f"DROP TABLE IF EXISTS {SERIES_TABLE};",
f"""-- sql
DROP TABLE IF EXISTS {SERIES_TABLE};
""",
)
cursor.execute(
f"""
f"""-- sql
CREATE TABLE {SERIES_TABLE} (
series_id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(255) NOT NULL UNIQUE,
@@ -221,7 +218,7 @@ def add_events():
"""
)
cursor.execute(
f"""
f"""-- sql
CREATE TABLE {EVENT_TABLE} (
event_id INT NOT NULL AUTO_INCREMENT,
series_id INT NOT NULL,
@@ -237,7 +234,9 @@ def add_events():
for series in [series1]:
cursor.execute(
f"INSERT INTO {SERIES_TABLE} (name, description, poster_id) VALUES (%s, %s, %s);",
f"""-- sql
INSERT INTO {SERIES_TABLE} (name, description, poster_id) VALUES (%s, %s, %s);
""",
(
series.name,
series.description,
@@ -252,7 +251,9 @@ def add_events():
ticket_url = str(event.ticket_url) if event.ticket_url else None
map_url = str(event.map_url) if event.map_url else None
cursor.execute(
f"INSERT INTO {EVENT_TABLE} (series_id, location, time, ticket_url, map_url) VALUES (%s, %s, %s, %s, %s);",
f"""-- sql
INSERT INTO {EVENT_TABLE} (series_id, location, time, ticket_url, map_url) VALUES (%s, %s, %s, %s, %s);
""",
(
series.series_id,
event.location,

2
server/pyproject.toml
View File

@@ -1,6 +1,6 @@
[tool.poetry]
name = "thegrapefruitsduo"
version = "0.4.1"
version = "0.4.2"
package-mode = false
description = "FastAPI backend for thegrapefruitsduo.com"
authors = ["Lucas Jensen <lucas.p.jensen10@gmail.com>"]

10
server/tests/controllers/test_event_controller.py
View File

@@ -28,7 +28,7 @@ def test_all_series_with_no_data():
def no_series() -> list[dict]:
return []
mock_queries.select_all_series = no_series
mock_queries.select_all = no_series
result = ec.get_all_series()
assert result == []
@@ -46,7 +46,7 @@ def test_all_series_with_basic_data():
}
]
mock_queries.select_all_series = one_series_with_no_events
mock_queries.select_all = one_series_with_no_events
result = ec.get_all_series()
assert isinstance(result, list)
assert len(result) == 1
@@ -104,7 +104,7 @@ def test_all_series_with_detailed_data():
row_3,
]
mock_queries.select_all_series = one_series_with_events
mock_queries.select_all = one_series_with_events
result = ec.get_all_series()
assert isinstance(result, list)
assert len(result) == 1
@@ -170,7 +170,7 @@ def test_all_series_with_many_series():
},
]
mock_queries.select_all_series = many_series
mock_queries.select_all = many_series
result = ec.get_all_series()
assert isinstance(result, list)
assert len(result) == 3
@@ -195,7 +195,7 @@ def test_all_series_with_error():
}
]
mock_queries.select_all_series = invalid_series
mock_queries.select_all = invalid_series
with pytest.raises(Exception):
ec.get_all_series()
MagicMock.assert_called_once(mock_log_error)

6
server/tests/controllers/test_musician_controller.py
View File

@@ -50,7 +50,7 @@ def mock_select_one_by_id(musician_id: int):
return None
mock_queries.select_all_series = mock_select_all_series
mock_queries.select_all = mock_select_all_series
mock_queries.select_one_by_id = mock_select_one_by_id
@@ -85,10 +85,10 @@ def test_happy_get_musicians():
def test_sad_get_musicians():
mock_queries.select_all_series = mock_select_all_series_sad
mock_queries.select_all = mock_select_all_series_sad
with pytest.raises(HTTPException) as e:
mc.get_musicians()
mock_queries.select_all_series = mock_select_all_series
mock_queries.select_all = mock_select_all_series
assert isinstance(e.value, HTTPException)
assert e.value.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR

4
server/tests/controllers/test_user_controller.py
View File

@@ -60,7 +60,7 @@ def test_type():
def test_get_users():
"""Tests the retrieval of users from the database."""
mock_queries.select_all_series.return_value = valid_user_data
mock_queries.select_all.return_value = valid_user_data
users = uc.get_users()
assert isinstance(users, list)
assert len(users) == 2
@@ -85,7 +85,7 @@ def test_get_users():
def test_get_users_sad():
"""Tests the retrieval of users from the database with invalid data."""
mock_queries.select_all_series.return_value = invalid_user_data
mock_queries.select_all.return_value = invalid_user_data
with pytest.raises(HTTPException) as e:
uc.get_users()
assert isinstance(e.value, HTTPException)