more functional frontend

Author: jbcarras

api/database/idb_queue.py

@@ -10,6 +10,10 @@ def __init__(self):
     def enqueue_student(self, student):
         raise NotImplementedError()
 
+    @abstractmethod
+    def enqueue_student_front(self, student):
+        raise NotImplementedError()
+
     @abstractmethod
     def dequeue_student(self):
         raise NotImplementedError()
@@ -19,5 +23,9 @@ def get_queue(self):
         raise NotImplementedError()
 
     @abstractmethod
-    def remove_student(self, student, reason):
-        raise NotImplementedError()
+    def remove_student(self, student):
+        raise NotImplementedError()
+
+    @abstractmethod
+    def clear_queue(self):
+        raise NotImplementedError()

api/database/idb_visits.py

@@ -22,10 +22,11 @@ def create_visit(self, student, ta, enqueue_time) -> int:
         raise NotImplementedError()
 
     @abstractmethod
-    def end_visit(self, visit_id):
+    def end_visit(self, visit_id, reason):
         """Mark in the database that the specified visit
         has ended.
 
         :param visit_id: The numeric ID representing the specific visit
+        :param reason:   The resolution of the visit
         """
         raise NotImplementedError()

api/database/relational_db/relational_db.py

@@ -24,7 +24,7 @@ def initialize(self):
                 (
                     user_id INTEGER PRIMARY KEY,
                     preferred_name VARCHAR(64),
-                    last_name VARCHAR (64),
+                    last_name VARCHAR(64),
                     ubit VARCHAR(16) UNIQUE,
                     person_num INTEGER UNIQUE,
                     course_role VARCHAR(16)
@@ -37,7 +37,8 @@ def initialize(self):
                 CREATE TABLE IF NOT EXISTS queue
                 (
                     user_id INTEGER UNIQUE,
-                    joined TEXT DEFAULT (datetime('now', 'localtime'))
+                    joined TEXT DEFAULT (datetime('now', 'localtime')),
+                    priority INTEGER
                 );
                 """
             )
@@ -63,6 +64,7 @@ def initialize(self):
                     ta_id INTEGER,
                     session_start TEXT DEFAULT (datetime('now','localtime')),
                     session_end TEXT,
+                    session_end_reason TEXT,
                     enqueue_time TEXT
                     );
                 """

api/database/relational_db/relational_db_queue.py

@@ -7,11 +7,27 @@ def enqueue_student(self, student):
         with self.cursor() as cursor:
             cursor.execute(
                 """
-                INSERT OR IGNORE INTO queue (user_id) VALUES (?)
+                INSERT OR IGNORE INTO queue (user_id, priority) VALUES (?, 0)
             """,
                 (student,),
             )
 
+    def enqueue_student_front(self, student):
+        with self.cursor() as cursor:
+            priority = cursor.execute("SELECT MAX(priority) FROM queue").fetchone()[0]
+            if priority is None:
+                priority = 0
+            else:
+                priority += 1
+
+            cursor.execute(
+                """
+                INSERT OR IGNORE INTO queue (user_id, priority)
+                VALUES (?, ?)
+                """,
+                (student, priority),
+            )
+
     def dequeue_student(self):
         with self.cursor() as cursor:
             rows = cursor.execute("SELECT COUNT(*) from queue").fetchone()[0]
@@ -20,10 +36,10 @@ def dequeue_student(self):
 
             user = cursor.execute(
                 """
-                SELECT users.user_id, preferred_name, ubit, person_num 
+                SELECT users.user_id, preferred_name, ubit, person_num, joined 
                 FROM queue 
                 INNER JOIN users ON queue.user_id = users.user_id 
-                ORDER BY joined
+                ORDER BY priority DESC, joined
             """
             ).fetchone()
             cursor.execute("DELETE FROM queue WHERE user_id = ?", (user[0],))
@@ -33,6 +49,31 @@ def dequeue_student(self):
             "preferred_name": user[1],
             "ubit": user[2],
             "person_num": str(user[3]),
+            "enqueue_time": user[4]
+        }
+
+    def dequeue_specified_student(self, student_id):
+        with self.cursor() as cursor:
+            user = cursor.execute(
+                """
+                SELECT users.user_id, preferred_name, ubit, person_num, joined 
+                FROM queue 
+                INNER JOIN users ON queue.user_id = users.user_id 
+                WHERE users.user_id = ?
+            """, (student_id,)
+            ).fetchone()
+
+            if user is None:
+                return None
+
+            cursor.execute("DELETE FROM queue WHERE user_id = ?", (user[0],))
+
+        return {
+            "user_id": user[0],
+            "preferred_name": user[1],
+            "ubit": user[2],
+            "person_num": str(user[3]),
+            "enqueue_time": user[4]
         }
 
     def get_queue(self):
@@ -55,5 +96,16 @@ def get_queue(self):
 
         return users_l
 
-    def remove_student(self, student, reason):
-        pass
+    def clear_queue(self):
+        with self.cursor() as cursor:
+            cursor.execute(
+                "DELETE FROM queue"
+            )
+
+    def remove_student(self, student):
+        with self.cursor() as cursor:
+            queue_info = cursor.execute("SELECT * FROM queue WHERE user_id = ?", (student, )).fetchone()
+
+            cursor.execute("DELETE FROM queue WHERE user_id = ?", (student, ))
+
+            return {"user_id": queue_info[0], "joined": queue_info[1]}

api/database/relational_db/relational_db_visits.py

@@ -20,14 +20,14 @@ def create_visit(self, student, ta, enqueue_time) -> int:
 
 
 
-    def end_visit(self, visit_id):
+    def end_visit(self, visit_id, reason):
         # YYYY-MM-DD HH:MM:SS
         now = str(datetime.datetime.now().isoformat(' ', timespec="seconds"))
 
         with self.cursor() as cursor:
             cursor.execute("""
                 UPDATE visits
-                SET session_end = ?
+                SET session_end = ?, session_end_reason = ?
                 WHERE visit_id = ? AND session_end is null
-            """)
+            """, (now, reason, visit_id))
 

api/queue/controller.py

@@ -17,14 +17,27 @@ def add_to_queue_by_card_swipe(swipe_data):
     return False
 
 
-def add_to_queue_by_ta_override(identifier):
+def add_to_queue_by_ta_override(identifier, front=False):
     student = db.lookup_identifier(identifier)
     if student is not None:
-        add_to_queue(student)
+        if front:
+            add_to_front_of_queue(student)
+        else:
+            add_to_queue(student)
         return True
     return False
 
 
 def add_to_queue(user_account):
     user_id = user_account["user_id"]
     db.enqueue_student(user_id)
+
+def add_to_front_of_queue(user_account):
+    user_id = user_account["user_id"]
+    db.enqueue_student_front(user_id)
+
+def remove_from_queue_without_visit(student, reason):
+    queue_info = db.remove_student(student)
+    visit = db.create_visit(student, None, queue_info["joined"])
+    db.end_visit(visit, reason)
+

api/queue/routes.py

@@ -3,6 +3,7 @@
 from flask import Blueprint, request
 
 import api.queue.controller as controller
+from api.queue.controller import remove_from_queue_without_visit
 from api.roster.controller import min_level
 from api.database.db import db
 
@@ -86,10 +87,18 @@ def dequeue():
     """
     role: TA
 
-    Remove the first student from the queue and create a Visit in the DB
+    Remove the specified student from the queue and create a Visit in the DB
 
     Not allowed if TA is already in a visit
 
+    Args:
+        body.id: The ID of the account to dequeue
+
+    Body:
+        {
+            "id": <string>
+        }
+
     Returns:
         200 OK - Student was dequeued
         {
@@ -99,23 +108,34 @@ def dequeue():
             "preferred_name: <string>
         }
 
-        400 Bad Request - The queue is empty
+        400 Bad Request - The queue is empty or user is not in the queue
         403 Unauthorized - Requester does not have TA permissions
         {
             "message": <string>
         }
     """
 
-    student = db.dequeue_student()
+    body = request.get_json()
+
+    if not (auth_token := request.cookies.get("auth_token")):
+        return {"message": "You are not logged in!"}, 403
+
+    user = db.get_authenticated_user(auth_token)
+    user_id = user["user_id"]
+
+    student = db.dequeue_specified_student(body["id"])
 
     if student is None:
         return {"message": "The queue is empty"}, 400
 
+    visit = db.create_visit(body["id"], user_id, student["enqueue_time"])
+
     return {
         "id": int(student["user_id"]),
         "username": student["ubit"],
         "pn": str(student["person_num"]),
         "preferred_name": student["preferred_name"],
+        "visitID": visit
     }
 
 
@@ -215,7 +235,23 @@ def remove_self():
             "message": <string>
         }
     """
-    return f"{request.path} hit 😎, remove method is used."
+
+    if not (auth_token := request.cookies.get("auth_token")):
+        return {"message": "You are not logged in!"}, 403
+
+    user = db.get_authenticated_user(auth_token)
+
+    if not user:
+        return {"message": "You are not logged in!"}, 403
+
+    user_id = user["user_id"]
+    body = request.get_json()
+
+    remove_from_queue_without_visit(user_id, f"[SELF-REMOVE]: {body["reason"]}")
+
+
+
+    return {"message":"Removed self from queue."}
 
 
 @blueprint.route("/remove-from-queue", methods=["POST"])
@@ -245,7 +281,59 @@ def remove(user_id):
     """
     return f"{request.path} hit 😎, remove method is used."
 
+@blueprint.route("/clear-queue", methods=["DELETE"])
+@min_level('ta')
+def clear_queue():
+    db.clear_queue()
+    return {"message": "Successfully cleared the queue."}
+
+
+@blueprint.route("/enqueue-override-front")
+@min_level('ta')
+def enqueue_override_front():
+    """ Exact same behavior as /enqueue-ta-override, except it sends the student to the front.
+
+    Args:
+        body.identifier: A unique identifier for the student This can either be their UBIT, pn, or the id of their account
+
+    Body:
+        {
+            "identifier": <string>
+        }
+
+    Returns:
+        200 OK - Student was added to the queue
+        403 Unauthorized - Requester does not have TA permissions
+        404 Not Found - No student matching provided identifier
+        {
+            "message": <string>,
+        }
+    """
+    body = request.get_json()
+    identifier = body["identifier"]
+
+    if controller.add_to_queue_by_ta_override(identifier, True):
+        return {"message": "Student was added to the front of the queue"}
+
+    return {"message": "No student matching provided identifier"}, 404
+
+@blueprint.route("/end-visit", methods=["POST"])
+@min_level('ta')
+def end_visit():
+    body = request.get_json()
+
+    visit = body.get("id")
+    reason = body.get("reason")
+
+    if visit is None or reason is None:
+        return {"message": "Malformed request"}, 400
+
+    db.end_visit(visit, reason)
+
+    return {"message": "Ended the visit"}
+
+
 
 # TODO: move to end of queue (Called by TAs to add the students they just saw back to the end of the queue)
 
-# TODO: Clear the queue
+