The great endpoint refactor

src/crud/courseprogress.py

@@ -3,7 +3,7 @@ from fastapi import HTTPException
 
 from src.enums import CourseEnum
 from src.models import CourseProgress, User
-from src.schemas.courseprogress import CourseProgressBase
+from src.schemas.courseprogress import CourseProgressBase, CourseProgressParent
 
 
 def get_course_progress(db: Session, user: User, course: CourseEnum):
@@ -26,7 +26,7 @@ def get_course_progress(db: Session, user: User, course: CourseEnum):
 
         if course_progress:
             result.append(
-                CourseProgressBase(
+                CourseProgressParent(
                     progress_value=course_progress.progress_value, course=course
                 )
             )
@@ -35,7 +35,7 @@ def get_course_progress(db: Session, user: User, course: CourseEnum):
                 CourseProgress(progress_value=0.0, course=course, owner_id=user.user_id)
             )
             db.commit()
-            result.append(CourseProgressBase(progress_value=0.0, course=course))
+            result.append(CourseProgressParent(progress_value=0.0, course=course))
 
     return result
 
@@ -50,18 +50,18 @@ def initialize_user(db: Session, user: User):
             db.commit()
 
 
-def patch_course_progress(db: Session, user: User, course_progress: CourseProgressBase):
+def patch_course_progress(db: Session, user: User, course: CourseEnum, course_progress: CourseProgressBase):
     """Change the progress value for a given course"""
     if course_progress.progress_value > 1 or course_progress.progress_value < 0:
         raise HTTPException(status_code=400, detail="Invalid progress value")
 
     db_course_progress_list = []
-    if course_progress.course != CourseEnum.All:
+    if course != CourseEnum.All:
         db_course_progress_list = (
             db.query(CourseProgress)
             .filter(
                 CourseProgress.owner_id == user.user_id,
-                CourseProgress.course == course_progress.course,
+                CourseProgress.course == course,
             )
             .all()
         )
@@ -71,12 +71,12 @@ def patch_course_progress(db: Session, user: User, course_progress: CourseProgre
             .filter(CourseProgress.owner_id == user.user_id)
             .all()
         )
-    print(f"LENGTH OF LIST OF {course_progress.course}: {len(db_course_progress_list)}")
+
     for db_course_progress in db_course_progress_list:
         db_course_progress.progress_value = course_progress.progress_value
         db.commit()
 
     return [
-        CourseProgressBase(course=db_cp.course, progress_value=db_cp.progress_value)
+        CourseProgressParent(course=db_cp.course, progress_value=db_cp.progress_value)
         for db_cp in db_course_progress_list
     ]

src/crud/highscores.py

@@ -42,14 +42,14 @@ def get_high_scores(db: Session, minigame: MinigameEnum, nr_highest: int):
     return user_high_scores
 
 
-def create_high_score(db: Session, user: User, high_score: HighScoreBase):
+def create_high_score(db: Session, user: User, minigame: MinigameEnum, high_score: HighScoreBase):
     """Create a new high score for a given minigame"""
 
     def add_to_db():
         """Helper function that adds new score to database; prevents code duplication"""
         db_high_score = HighScore(
             score_value=high_score.score_value,
-            minigame=high_score.minigame,
+            minigame=minigame,
             owner_id=user.user_id,
         )
         db.add(db_high_score)
@@ -61,7 +61,7 @@ def create_high_score(db: Session, user: User, high_score: HighScoreBase):
         db.query(HighScore)
         .filter(
             HighScore.owner_id == user.user_id,
-            HighScore.minigame == high_score.minigame,
+            HighScore.minigame == minigame,
         )
         .first()
     )

src/main.py

@@ -63,25 +63,26 @@ async def login(user: users.UserCreate, db: Session = Depends(get_db)):
 
 @app.get("/highscores/{minigame}", response_model=List[users.UserHighScore])
 async def get_high_scores(
-    minigame: Optional[MinigameEnum] = None,
+    minigame: MinigameEnum,
     nr_highest: Optional[int] = None,
     db: Session = Depends(get_db),
 ):
     return crud_highscores.get_high_scores(db, minigame, nr_highest)
 
 
-@app.post("/highscores", response_model=highscores.HighScore)
+@app.post("/highscores/{minigame}", response_model=highscores.HighScore)
 async def create_high_score(
+    minigame: MinigameEnum,
     high_score: highscores.HighScoreBase,
     current_user_name=Depends(crud_authentication.get_current_user_name),
     db: Session = Depends(get_db),
 ):
     current_user = crud_users.get_user_by_username(db, current_user_name)
-    return crud_highscores.create_high_score(db, current_user, high_score)
+    return crud_highscores.create_high_score(db, current_user, minigame, high_score)
 
 
 @app.get(
-    "/courseprogress/{course}", response_model=List[courseprogress.CourseProgressBase]
+    "/courseprogress/{course}", response_model=List[courseprogress.CourseProgressParent]
 )
 async def get_course_progress(
     course: Optional[CourseEnum] = CourseEnum.All,
@@ -92,14 +93,15 @@ async def get_course_progress(
     return crud_courseprogress.get_course_progress(db, current_user, course)
 
 
-@app.patch("/courseprogress", response_model=List[courseprogress.CourseProgressBase])
+@app.patch("/courseprogress/{course}", response_model=List[courseprogress.CourseProgressParent])
 async def patch_course_progress(
+    course: CourseEnum,
     course_progress: courseprogress.CourseProgressBase,
     current_user_name: str = Depends(crud_authentication.get_current_user_name),
     db: Session = Depends(get_db),
 ):
     current_user = crud_users.get_user_by_username(db, current_user_name)
-    return crud_courseprogress.patch_course_progress(db, current_user, course_progress)
+    return crud_courseprogress.patch_course_progress(db, current_user, course, course_progress)
 
 
 #### TESTING!! DELETE LATER

src/schemas/courseprogress.py

@@ -5,10 +5,13 @@ from src.enums import CourseEnum
 
 class CourseProgressBase(BaseModel):
     progress_value: float
+
+
+class CourseProgressParent(CourseProgressBase):
     course: CourseEnum
 
 
-class CourseProgress(CourseProgressBase):
+class CourseProgress(CourseProgressParent):
     course_progress_id: int
     owner_id: int
 

src/schemas/highscores.py

@@ -5,12 +5,12 @@ from src.enums import MinigameEnum
 
 class HighScoreBase(BaseModel):
     score_value: float
-    minigame: MinigameEnum
 
 
 class HighScore(HighScoreBase):
     high_score_id: int
     owner_id: int
+    minigame: MinigameEnum
 
     class Config:
         orm_mode = True