Change result end point to output artist info

.dockerignore

@@ -1,4 +1,7 @@
 .git
 *.duckdb
 .env
-__pycache__
+__pycache__
+
+
+src/data/

.gitignore

@@ -16,4 +16,6 @@ wheels/
 *.log
 *.gz
 
+data
+
 .vscode/*

Dockerfile

@@ -6,10 +6,13 @@ WORKDIR /app
 COPY pyproject.toml uv.lock /app/
 RUN uv sync --frozen --no-install-project --no-dev
 COPY src /app
+# Ensure data directory exists but don't copy from host
 RUN uv sync --frozen --no-dev
 
 FROM base
 COPY --from=builder /app /app
 ENV PATH="/app/.venv/bin:$PATH"
 WORKDIR /app
+# Create data directory
+RUN mkdir -p /app/data && chmod 755 /app/data
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

src/app.py

@@ -3,7 +3,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
 # Import routers
-from routes import auth, admin, users, songs, reviews, results
+from routes import auth, admin, users, songs, reviews, results, contest
 
 from lib.logger import logger
 from lib.db import init_db
@@ -15,6 +15,15 @@ app = FastAPI(
     version="1.0rc2",
 )
 
+
+@app.middleware("http")
+async def log_requests(request, call_next):
+    body = await request.body()
+    logger.debug(f"Request body: {body.decode('utf-8')}")
+    response = await call_next(request)
+    return response
+
+
 # Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
@@ -51,3 +60,4 @@ app.include_router(users.router)
 app.include_router(songs.router)
 app.include_router(reviews.router)
 app.include_router(results.router)
+app.include_router(contest.router)

src/lib/database.sql

@@ -9,12 +9,16 @@ DROP TABLE IF EXISTS Review;
 DROP TABLE IF EXISTS Song;
 DROP TABLE IF EXISTS "User"; -- Quoted because USER is a reserved keyword
 DROP TABLE IF EXISTS Team;
+DROP TABLE IF EXISTS Contest;
 DROP TABLE IF EXISTS CountryCodes;
+DROP VIEW IF EXISTS ReviewSummary;
+DROP VIEW IF EXISTS ReviewSummaryByTeam;
 
 DROP SEQUENCE IF EXISTS group_id_seq;
 DROP SEQUENCE IF EXISTS user_id_seq;
 DROP SEQUENCE IF EXISTS song_id_seq;
 DROP SEQUENCE IF EXISTS review_id_seq;
+DROP SEQUENCE IF EXISTS contest_id_seq;
 
 -- =============================================================================
 -- Sequences for Primary Keys
@@ -23,6 +27,23 @@ CREATE SEQUENCE group_id_seq START 1;
 CREATE SEQUENCE user_id_seq START 1;
 CREATE SEQUENCE song_id_seq START 1;
 CREATE SEQUENCE review_id_seq START 1;
+CREATE SEQUENCE contest_id_seq START 1;
+
+-- =============================================================================
+-- Table: Contest
+-- Stores information about Eurovision contests by year.
+-- =============================================================================
+CREATE TABLE Contest (
+    id INTEGER PRIMARY KEY DEFAULT nextval('contest_id_seq'), -- Use sequence for auto-increment
+    year INTEGER DEFAULT EXTRACT(YEAR FROM CURRENT_DATE) NOT NULL, -- The year of the Eurovision contest
+    is_active BOOLEAN DEFAULT TRUE NOT NULL,                -- Flag indicating if this is the active contest
+    finals_date DATE NOT NULL,                                       -- Date of the finals
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,           -- Timestamp when the contest was created
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP            -- Timestamp when the contest was last updated
+);
+
+-- Add index for faster lookups by year
+CREATE INDEX idx_contest_year ON Contest (year);
 
 -- =============================================================================
 -- Table: Group
@@ -42,6 +63,8 @@ CREATE TABLE "Team" (
 CREATE TABLE "User" (
     id INTEGER PRIMARY KEY DEFAULT nextval('user_id_seq'), -- Use sequence for auto-increment
     username VARCHAR UNIQUE NOT NULL,                       -- The user's login name
+    first_name VARCHAR DEFAULT '',
+    last_name VARCHAR DEFAULT '',
     hashed_password VARCHAR NOT NULL,                       -- The securely hashed password
     email VARCHAR UNIQUE,                                   -- User's email address (nullable)
     team_id INTEGER NOT NULL,                              -- Foreign Key -> Group.id
@@ -115,6 +138,44 @@ CREATE TABLE CountryCodes (
     name_sv VARCHAR NOT NULL
 );
 
+CREATE VIEW ReviewSummaryGlobal AS
+SELECT 
+    song_id,
+    cc.name_fi AS country_fi,
+    cc.name_sv AS country_sv,
+    s.artist,
+    s.title,
+    COUNT(*) AS total_reviews,
+    AVG(score_song) AS avg_score_song,
+    AVG(score_show) AS avg_score_show,
+    AVG(score_costume) AS avg_score_costume,
+    AVG((score_song + score_show + score_costume)/3) AS avg_total_score
+FROM Review r
+JOIN Song s ON r.song_id = s.id
+JOIN CountryCodes cc ON s.country = cc.code
+GROUP BY song_id, cc.name_fi, cc.name_sv, s.artist, s.title
+ORDER BY avg_total_score DESC;
+
+CREATE VIEW ReviewSummaryByTeam AS
+SELECT 
+    r.song_id,
+    cc.name_fi AS country_fi,
+    cc.name_sv AS country_sv,
+    s.artist,
+    s.title,
+    u.team_id,
+    COUNT(*) AS total_reviews,
+    AVG(r.score_song) AS avg_score_song,
+    AVG(r.score_show) AS avg_score_show,
+    AVG(r.score_costume) AS avg_score_costume,
+    AVG((r.score_song + r.score_show + r.score_costume)/3) AS avg_total_score
+FROM Review r
+JOIN "User" u ON r.user_id = u.id
+JOIN Song s ON r.song_id = s.id
+JOIN CountryCodes cc ON s.country = cc.code
+GROUP BY r.song_id, u.team_id, cc.name_fi, cc.name_sv, s.artist, s.title
+ORDER BY avg_total_score DESC;
+
 -- Insert country codes data
 INSERT INTO CountryCodes (code, name_en, name_fi, name_sv) VALUES ('ALB', 'Albania', 'Albania', 'Albanien');
 INSERT INTO CountryCodes (code, name_en, name_fi, name_sv) VALUES ('ARM', 'Armenia', 'Armenia', 'Armenien');
@@ -154,6 +215,9 @@ INSERT INTO CountryCodes (code, name_en, name_fi, name_sv) VALUES ('CHE', 'Switz
 INSERT INTO CountryCodes (code, name_en, name_fi, name_sv) VALUES ('UKR', 'Ukraine', 'Ukraina', 'Ukraina');
 INSERT INTO CountryCodes (code, name_en, name_fi, name_sv) VALUES ('GBR', 'United Kingdom', 'Englanti', 'Storbritannien');
 
+
+-- TODO: Clean this next year. Its now here just to get the show running
+INSERT INTO Contest (year, finals_date) VALUES (2025, '2025-05-16');
 -- =============================================================================
 -- Views (Optional - Not Created Here Based on Documentation Decision)
 -- =============================================================================

src/lib/db.py

@@ -6,6 +6,7 @@ from dotenv import load_dotenv
 import os
 
 from lib.helpers import hash_password
+from lib.logger import logger
 
 load_dotenv()
 
@@ -61,6 +62,9 @@ def seed_db() -> None:
     # Seed Admin users
     admin_username = os.getenv("ADMIN_USERNAME")
     hashed_admin_password = hash_password(os.getenv("ADMIN_PASSWORD", "password"))
+    logger.debug(
+        f"Admin user: {admin_username}, hashed password: {hashed_admin_password}"
+    )
     with get_connection() as conn:
         conn.execute(
             'INSERT INTO "User" (username, hashed_password, team_id, is_active, is_admin) VALUES (?, ?, ?, ?, ?)',
@@ -75,8 +79,12 @@ def seed_db() -> None:
 
 
 def init_db():
+    logger.info("Initializing database...")
     if Path(DB_PATH).exists():
         return
+    logger.info("Database does not exist, creating...")
+    if not Path(DB_PATH).parent.exists():
+        Path(DB_PATH).parent.mkdir(parents=True, exist_ok=True)
     with open(SQL_PATH, "r") as f:
         sql = f.read()
     with get_connection() as conn:

src/lib/logger.py

@@ -1,16 +1,26 @@
 from loguru import logger
 from pathlib import Path
 import sys
+from dotenv import load_dotenv
+import os
 
-LOG_PATH = Path("./data/logs/logs.log").absolute()
+load_dotenv()
-ERROR_PATH = Path("./data/logs/errors.log").absolute()
+
+LOG_PATH = Path(os.getenv("LOG_PATH", "./data/logs/logs.log")).absolute()
+ERROR_PATH = Path(os.getenv("ERROR_PATH", "./data/logs/errors.log")).absolute()
 
 logger.remove()
-logger.add(LOG_PATH, rotation="10 MB", compression="gz", level="INFO")
+logger.add(
-logger.add(sys.stdout, level="INFO")
+    LOG_PATH, rotation="10 MB", compression="gz", level=os.getenv("LOG_LEVEL", "INFO")
+)
+logger.add(sys.stdout, level=os.getenv("LOG_LEVEL", "INFO"))
 
-logger.add(ERROR_PATH, rotation="10 MB", compression="gz", level="ERROR")
+logger.add(
-logger.add(sys.stderr, level="ERROR")
+    ERROR_PATH,
-logger.add(sys.stdout, level="DEBUG")
+    rotation="10 MB",
+    compression="gz",
+    level=os.getenv("LOG_LEVEL_ERROR", "ERROR"),
+)
+logger.add(sys.stderr, level=os.getenv("LOG_LEVEL_ERROR", "ERROR"))
 
 logger = logger

src/models/contest.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from datetime import date, datetime
+
+
+class Contest(BaseModel):
+    id: int
+    year: int = Field(
+        default_factory=lambda: datetime.now().year,
+        description="The year of the contest",
+        examples=[2025],
+    )
+    is_active: bool = Field(
+        default=True, description="Is this the active contest?", examples=[True, False]
+    )
+    finals_date: date = Field(
+        description="The date of the finals", examples=["2025-05-15"]
+    )
+    created_at: datetime = Field(
+        description="The date and time when the contest was created",
+        examples=["2025-05-15T17:40:42.000Z"],
+    )
+    updated_at: datetime = Field(
+        description="The date and time when the contest was last updated",
+        examples=["2025-05-15T17:40:42.000Z"],
+    )

src/models/msg.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+
+class Message(BaseModel):
+    type: str | None = None
+    message: str
+    timestamp: datetime = Field(default_factory=datetime.now)

src/models/result.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel, Field
+
+
+class Result(BaseModel):
+    song_id: int = Field(description="ID of the song", examples=[1])
+    country_fi: str = Field(
+        description="Country of the song in Finnish", examples=["Suomi"]
+    )
+    country_sv: str = Field(
+        description="Country of the song in Swedish", examples=["Sverige"]
+    )
+    artist: str = Field(description="Artist of the song", examples=["Käärijä"])
+    title: str = Field(description="Title of the song", examples=["Cha cha cha"])
+    total_reviews: int = Field(0, description="Total number of reviews", examples=[10])
+    avg_score_song: float = Field(
+        description="Average score for song quality", examples=[85.5]
+    )
+    avg_score_show: float = Field(
+        description="Average score for stage show", examples=[82.3]
+    )
+    avg_score_costume: float = Field(
+        description="Average score for wardrobe/costumes", examples=[88.1]
+    )
+    avg_total_score: float = Field(description="Average total score", examples=[85.5])
+
+
+class TeamResult(Result):
+    team_id: int = Field(description="ID of the team", examples=[1])

src/routes/contest.py

@@ -0,0 +1,39 @@
+from fastapi import APIRouter, HTTPException
+
+from lib.db import get_connection
+from lib.logger import logger
+from models.contest import Contest
+from models.msg import Message
+
+router = APIRouter(prefix="/contest", tags=["contest"])
+
+
+@router.get("/", response_model=list[Contest])
+async def list_contests():
+    with get_connection() as conn:
+        logger.debug("Listing all contests")
+        df = conn.execute("SELECT * FROM Contest").fetchdf()
+        logger.debug(f"Contests: {df}")
+        contests = [Contest(**row) for row in df.to_dict(orient="records")]
+    return contests
+
+
+@router.get("/{year}", response_model=Contest)
+async def get_contest(year: int):
+    with get_connection() as conn:
+        df = conn.execute("SELECT * FROM Contest WHERE year = ?", (year,)).fetchdf()
+        if df.empty:
+            raise HTTPException(status_code=404, detail="Contest not found")
+        contest = Contest(**df.to_dict(orient="records")[0])
+    return contest
+
+
+@router.put("/", response_model=Message)
+async def update_contest(year: int, is_active: bool):
+    with get_connection() as conn:
+        logger.debug(f"Updating contest {year} to active: {is_active}")
+        conn.execute(
+            "UPDATE Contest SET is_active = ? WHERE year = ?",
+            (is_active, year),
+        )
+    return Message(message="Contest updated successfully")

src/routes/results.py

@@ -1,3 +1,28 @@
 from fastapi import APIRouter
 
+from models.result import Result, TeamResult
+from lib.db import get_connection
+
 router = APIRouter(prefix="/results", tags=["results"])
+
+
+@router.get("/", response_model=list[Result])
+async def list_results():
+    with get_connection() as conn:
+        df = conn.execute("SELECT * FROM ReviewSummaryGlobal").fetchdf()
+        if df.empty:
+            return []
+        results = [Result(**row) for row in df.to_dict(orient="records")]
+    return results
+
+
+@router.get("/team/{team_id}", response_model=list[TeamResult])
+async def list_team_results(team_id: int):
+    with get_connection() as conn:
+        df = conn.execute(
+            "SELECT * FROM ReviewSummaryByTeam WHERE team_id = ?", (team_id,)
+        ).fetchdf()
+        if df.empty:
+            return []
+        results = [TeamResult(**row) for row in df.to_dict(orient="records")]
+    return results

src/routes/reviews.py

@@ -1,7 +1,9 @@
 from fastapi import APIRouter, HTTPException
 
-from models.review import ReviewOut, ReviewSearch, ReviewIn
+from models.review import ReviewOut, ReviewIn
+from models.msg import Message
 from lib.db import get_connection
+from lib.logger import logger
 
 router = APIRouter(prefix="/reviews", tags=["reviews"])
 
@@ -11,57 +13,139 @@ async def list_reviews():
     with get_connection() as conn:
         reviews = conn.execute("SELECT * FROM Review").fetchdf()
     if reviews.empty:
-        raise HTTPException(status_code=404, detail="Reviews not found")
+        return []
     return reviews.to_dict(orient="records")
 
 
 @router.get("/", response_model=ReviewOut)
-async def get_review(review_id: ReviewSearch):
+async def get_review(song_id: int, user_id: int):
     with get_connection() as conn:
         review = conn.execute(
             "SELECT * FROM Review WHERE song_id = ? AND user_id = ?",
-            (review_id.song_id, review_id.user_id),
+            (song_id, user_id),
         ).fetchdf()
     if review.empty:
-        raise HTTPException(status_code=404, detail="Review not found")
+        return []
     return review.to_dict(orient="records")[0]
 
 
-@router.post("/", response_model=ReviewOut)
+@router.post("/", response_model=Message)
 async def create_review(review: ReviewIn):
-    with get_connection() as conn:
+    logger.debug(f"Received create review request with data: {review.dict()}")
-        review = conn.execute(
+    try:
-            "INSERT INTO Review (user_id, song_id, score_song, score_show, score_costume, text_review) VALUES (?, ?, ?, ?, ?, ?)",
+        with get_connection() as conn:
-            (
+            # Log the SQL query and parameters
-                review.user_id,
+            logger.debug(
-                review.song_id,
+                f"Executing INSERT INTO Review (user_id, song_id, score_song, score_show, score_costume, text_review) "
-                review.score_song,
+                f"VALUES ({review.user_id}, {review.song_id}, {review.score_song}, "
-                review.score_show,
+                f"{review.score_show}, {review.score_costume}, '{review.text_review}')"
-                review.score_costume,
+            )
-                review.text_review,
+
-            ),
+            # Insert the review
-        ).fetchdf()
+            conn.execute(
-    if review.empty:
+                "INSERT INTO Review (user_id, song_id, score_song, score_show, score_costume, text_review) VALUES (?, ?, ?, ?, ?, ?)",
-        raise HTTPException(status_code=404, detail="Review not found")
+                (
-    return review.to_dict(orient="records")[0]
+                    review.user_id,
+                    review.song_id,
+                    review.score_song,
+                    review.score_show,
+                    review.score_costume,
+                    review.text_review,
+                ),
+            )
+
+            # Fetch the newly created review
+            logger.debug(
+                f"Checking if review was created for song_id={review.song_id}, user_id={review.user_id}"
+            )
+            result = conn.execute(
+                "SELECT * FROM Review WHERE song_id = ? AND user_id = ?",
+                (review.song_id, review.user_id),
+            ).fetchdf()
+            logger.debug(f"Database result for newly created review: {result}")
+
+        if result.empty:
+            logger.warning(
+                f"Review not found after insert attempt: song_id={review.song_id}, user_id={review.user_id}"
+            )
+            raise HTTPException(status_code=404, detail="Review not found")
+
+        logger.info(
+            f"Review created successfully for song_id={review.song_id}, user_id={review.user_id}"
+        )
+        return Message(type="success", message="Review created successfully")
+    except Exception as e:
+        logger.error(f"Error creating review: {str(e)}")
+        raise
 
 
-@router.put("/", response_model=ReviewOut)
+@router.put("/", response_model=Message)
 async def update_review(review: ReviewIn):
-    with get_connection() as conn:
+    print("update_review")
-        review = conn.execute(
+    logger.debug(f"Received update review request with data: {review.dict()}")
-            "UPDATE Review SET user_id = ?, song_id = ?, score_song = ?, score_show = ?, score_costume = ?, text_review = ? WHERE song_id = ? AND user_id = ?",
+    try:
-            (
+        with get_connection() as conn:
-                review.user_id,
+            # Log the SQL query and parameters
-                review.song_id,
+            logger.debug(
-                review.score_song,
+                f"Executing UPDATE Review SET score_song = {review.score_song}, "
-                review.score_show,
+                f"score_show = {review.score_show}, score_costume = {review.score_costume}, "
-                review.score_costume,
+                f"text_review = '{review.text_review}' WHERE song_id = {review.song_id} "
-                review.text_review,
+                f"AND user_id = {review.user_id}"
-                review.song_id,
+            )
-                review.user_id,
+
-            ),
+            # Check if the review exists
-        ).fetchdf()
+            review_df = conn.execute(
-    if review.empty:
+                "SELECT * FROM Review WHERE song_id = ? AND user_id = ?",
-        raise HTTPException(status_code=404, detail="Review not found")
+                (review.song_id, review.user_id),
-    return review.to_dict(orient="records")[0]
+            ).fetchdf()
+
+            if not review_df.empty:
+                # Update the review
+                conn.execute(
+                    "UPDATE Review SET score_song = ?, score_show = ?, score_costume = ?, text_review = ? WHERE song_id = ? AND user_id = ?",
+                    (
+                        review.score_song,
+                        review.score_show,
+                        review.score_costume,
+                        review.text_review,
+                        review.song_id,
+                        review.user_id,
+                    ),
+                )
+            else:
+                # Insert the review
+                conn.execute(
+                    "INSERT INTO Review (user_id, song_id, score_song, score_show, score_costume, text_review) VALUES (?, ?, ?, ?, ?, ?)",
+                    (
+                        review.user_id,
+                        review.song_id,
+                        review.score_song,
+                        review.score_show,
+                        review.score_costume,
+                        review.text_review,
+                    ),
+                )
+
+            # Fetch the updated review
+            logger.debug(
+                f"Checking if review was updated for song_id={review.song_id}, user_id={review.user_id}"
+            )
+            result = conn.execute(
+                "SELECT * FROM Review WHERE song_id = ? AND user_id = ?",
+                (review.song_id, review.user_id),
+            ).fetchdf()
+            logger.debug(f"Database result: {result}")
+
+        if result.empty:
+            logger.warning(
+                f"Review not found after update attempt: song_id={review.song_id}, user_id={review.user_id}"
+            )
+            raise HTTPException(status_code=404, detail="Review not found")
+
+        logger.info(
+            f"Review updated successfully for song_id={review.song_id}, user_id={review.user_id}"
+        )
+        return Message(type="success", message="Review updated successfully")
+    except Exception as e:
+        logger.error(f"Error updating review: {str(e)}")
+        raise

uv.lock

@@ -131,7 +131,7 @@ wheels = [
 
 [[package]]
 name = "eurovision-25-backend"
-version = "0.1.0"
+version = "1.0rc2"
 source = { virtual = "." }
 dependencies = [
     { name = "aiofiles" },