meerdere updates

backend/event_signups.py

@@ -0,0 +1,39 @@
+from database import execute, fetch_one
+
+
+def respond_to_event(event_id, user_id, status):
+
+    query = """
+    INSERT INTO event_signups
+    (event_id, user_id, status)
+    VALUES (?, ?, ?)
+
+    ON CONFLICT(event_id, user_id)
+    DO UPDATE SET status = excluded.status
+    """
+
+    return execute(
+        query,
+        (
+            event_id,
+            user_id,
+            status
+        )
+    )
+
+
+def count_confirmations(event_id):
+
+    query = """
+    SELECT COUNT(*) as amount
+    FROM event_signups
+    WHERE event_id = ?
+    AND status = 'going'
+    """
+
+    result = fetch_one(
+        query,
+        (event_id,)
+    )
+
+    return result["amount"]

backend/events.py

@@ -1,4 +1,21 @@
 from database import execute
+from database import fetch_all, fetch_one
+
+
+def get_user_events(user_id):
+
+    query = """
+    SELECT events.*
+    FROM events
+    JOIN room_members
+        ON events.room_id = room_members.room_id
+    WHERE room_members.user_id = ?
+    """
+
+    return fetch_all(
+        query,
+        (user_id,)
+    )
 
 def create_event(
     room_id,
@@ -66,4 +83,36 @@ def create_event(
 # )
 
 # print("Nieuw event ID:", event)
-    
+
+def check_event_threshold(event_id):
+
+    query = """
+    SELECT 
+        events.min_people,
+        COUNT(event_signups.user_id) AS going
+    FROM events
+
+    LEFT JOIN event_signups
+    ON events.id = event_signups.event_id
+    AND event_signups.status = 'going'
+
+    WHERE events.id = ?
+
+    GROUP BY events.id
+    """
+
+    event = fetch_one(
+        query,
+        (event_id,)
+    )
+
+    if event["going"] >= event["min_people"]:
+
+        execute(
+            """
+            UPDATE events
+            SET status = 'confirmed'
+            WHERE id = ?
+            """,
+            (event_id,)
+        )

backend/main.py

@@ -2,10 +2,15 @@ from fastapi import FastAPI, Depends
 from pydantic import BaseModel
 
 from database import fetch_all, fetch_one
-from events import create_event
+from events import create_event, get_user_events
 from auth import create_user, verify_user, create_token, get_current_user
 from rooms import create_room, search_room, accept_room
+from permissions import has_role
+from events import create_event, get_user_events, check_event_threshold
 
+from fastapi import HTTPException
+import sqlite3
+from typing import Literal
 
 class Login(BaseModel):
     username: str
@@ -118,6 +123,42 @@ def get_me(
 
 # rooms
 
+@app.delete("/room/{room_id}")
+def delete_room(
+    room_id: int,
+    user_id: int = Depends(get_current_user)
+):
+
+    if not has_role(
+        room_id,
+        user_id,
+        ["owner", "admin"]
+    ):
+        return {
+            "status": "denied",
+            "reason": "no_permission"
+    }
+    return {
+        "status": "deleted"
+    }
+
+
+# @app.post("/create-room")
+# def api_create_room(
+#     room: RoomCreate,
+#     user_id: int = Depends(get_current_user)
+# ):
+
+#     room_id = create_room(
+#         user_id,
+#         room.room_name,
+#         room.invite_code
+#     )
+
+#     return {
+#         "status": "created",
+#         **room_id
+#     }
 
 @app.post("/create-room")
 def api_create_room(
@@ -125,18 +166,24 @@ def api_create_room(
     user_id: int = Depends(get_current_user)
 ):
 
-    room_id = create_room(
-        room.room_name,
-        user_id,
-        room.invite_code
-    )
+    try:
+        room_id = create_room(
+            user_id,
+            room.room_name,
+            room.invite_code
+        )
+
+    except sqlite3.IntegrityError:
+        raise HTTPException(
+            status_code=409,
+            detail="invite_code already exists"
+        )
 
     return {
         "status": "created",
         "room_id": room_id
     }
 
-
 @app.post("/search-room")
 def api_search_room(
     room: RoomSearch
@@ -188,7 +235,6 @@ def api_create_event(
     user_id: int = Depends(get_current_user)
 ):
 
-    # check of gebruiker lid is
     member = fetch_one(
         """
         SELECT *
@@ -233,15 +279,29 @@ def get_events(
     user_id: int = Depends(get_current_user)
 ):
 
-    events = fetch_all(
-        """
-        SELECT *
-        FROM events
-        WHERE creator_id = ?
-        """,
-        (user_id,)
-    )
+    events = get_user_events(user_id)
 
     return {
         "events": [dict(event) for event in events]
+    }
+
+
+@app.post("/events/{event_id}/respond")
+def respond_event(
+    event_id: int,
+    status: Literal["going", "maybe", "declined"],
+    user_id: int = Depends(get_current_user)
+):
+
+    respond_to_event(
+        event_id,
+        user_id,
+        status
+    )
+
+    check_event_threshold(event_id)
+
+    return {
+        "status": "response_saved",
+        "going": count_confirmations(event_id)
     }

backend/permissions.py

@@ -0,0 +1,34 @@
+from database import fetch_one
+
+
+def get_room_role(room_id, user_id):
+    member = fetch_one(
+        """
+        SELECT role
+        FROM room_members
+        WHERE room_id = ?
+        AND user_id = ?
+        """,
+        (
+            room_id,
+            user_id
+        )
+    )
+
+    if member is None:
+        return None
+
+    return member["role"]
+
+
+def has_role(room_id, user_id, allowed_roles):
+
+    role = get_room_role(
+        room_id,
+        user_id
+    )
+
+    if role is None:
+        return False
+
+    return role in allowed_roles

backend/rooms.py

@@ -5,8 +5,8 @@ from database import execute, fetch_one
 DEFAULT_ROLE = "member"
 
 def create_room(
+    user_id,
     room_name,
-    creator_id,
     invite_code
 ):
     query = """
@@ -18,7 +18,7 @@ def create_room(
         query,
         (
             room_name,
-            creator_id,
+            user_id,
             invite_code
         )
     )
@@ -48,10 +48,10 @@ def create_room(
 
     member_id = execute(
         query3,
-        (
+        (   
+            user_id,
             room_id,
-            creator_id,
-            role
+            "owner"
         )
     )
 
@@ -99,10 +99,9 @@ def accept_room(user_id, invite_code):
 
     room_id = room["id"]
 
-    # check dubbele join
     existing = fetch_one(
         """
-        SELECT id
+        SELECT *
         FROM room_members
         WHERE room_id = ?
         AND user_id = ?