From ab10673a67e42a10ed6cc625c2b4891d6cb653a2 Mon Sep 17 00:00:00 2001
From: white <122345776@umail.ucc.ie>
Date: Thu, 23 Jan 2025 20:51:09 +0000
Subject: [PATCH] updated the methods in chat.py, still need to make it
 interact with frontend

---
 web_server/blueprints/chat.py  | 79 ++++++++++++++++++++++++++--------
 web_server/database/schema.sql |  8 ++--
 2 files changed, 65 insertions(+), 22 deletions(-)

diff --git a/web_server/blueprints/chat.py b/web_server/blueprints/chat.py
index 7029c16..9ea19ca 100644
--- a/web_server/blueprints/chat.py
+++ b/web_server/blueprints/chat.py
@@ -1,48 +1,89 @@
-from flask import Blueprint
+from flask import Blueprint, request, jsonify
 from blueprints.utils import login_required
 from database.database import Database
 
 chat_bp = Blueprint("chat", __name__)
 
+@chat_bp.route("/send_chat", methods=["POST"])
 @login_required
-def chat():
+def send_chat():
     """
     Works with react, takes the chat entered by a logged in user and stores in database
     """
+
+    # Take the message information from frontend
+    data = request.get_json()
+    chatter_id = data.get("chatter_id")
+    stream_id = data.get("stream_id")
+    message = data.get("message")
+
+    # Input validation - chatter is logged in, message is not empty, stream exists
+    if not all(chatter_id, message, stream_id):
+        return {"chat_sent": False}
     
+    # Save chat information to database so other users can see
+    db = Database()
+    cursor = db.create_connection()
+    cursor.execute("""
+                    INSERT INTO chat (chatter_id, stream_id, message)
+                    VALUES (?, ?, ?);""", (chatter_id, stream_id, message))
+    db.commit_data()
 
-    return {}
+    return {"chat_sent": True}
 
 
-def get_all_chat():
+# <---------------------- ROUTE NEEDS TO BE CHANGED TO VIDEO OR DELETED AS DEEMED APPROPRIATE ---------------------->
+@chat_bp.route("/chat/<int:stream_id>", methods=["GET"])
+def get_past_chat(stream_id):
     """
-    Returns a dictionary to be passed to the server.
+    Returns a JSON object to be passed to the server.
     
-    Output structure in the following format: `{(chatter, message), ...}` for all chats.
+    Output structure in the following format: `{chatter_id: message}` for all chats.
 
-    Rans once when a user first logs into a stream
+    Ran once when a user first logs into a stream to get the most recent 50 chat messages.
     """
 
     # Connect to the database
     db = Database()
     cursor = db.create_connection()
     
-    # Returns list of tuples: (chatter_id, message)
-    all_chats = cursor.execute("""SELECT ?, ? FROM chat
-                                  ORDER BY ?;""", ("chatter_id", "message", "time_sent")).fetchall()
+    # fetched in format: [(chatter_id, message, time_sent)]
+    all_chats = cursor.execute("""
+                               SELECT *
+                               FROM (
+                                SELECT chatter_id, message, time_sent
+                                FROM chat
+                                WHERE stream_id = ?
+                                ORDER BY time_sent DESC
+                                LIMIT 50
+                               )
+                               ORDER BY time_sent ASC;""", (stream_id,)).fetchall()
+    db.close_connection()
     
     # Create JSON output of chat_history to pass through NGINX proxy
-    chat_history = {}
-    for chat in all_chats:
-        chat_history[chat[0]] = chat[1]
+    chat_history = [{"chatter_id": chat[0], "message": chat[1], "time_sent": chat[2]} for chat in all_chats]
 
     # Pass the chat history to the proxy
-    return chat_history
+    return jsonify(chat_history)
 
-def get_recent_chat():
+def get_recent_chat(stream_id):
     """
-    Run periodically to return new chat messages on a stream a user has already loaded in to.
-    
-    
+    Fetch new chat messages on a stream a user has already loaded in to.
     """
-    return {}
\ No newline at end of file
+    # Get the last received chat to avoid repeating old chats
+    last_received = request.args.get("last_received")   # last_received is a time stamp
+
+    # Get the most recent chats from the database
+    db = Database()
+    cursor = db.create_connection()
+
+    # fetched in format: [(chatter_id, message, time_sent)]
+    new_chats = cursor.execute("""
+                        SELECT chatter_id, message, time_sent
+                        FROM chat
+                        WHERE stream_id = ?
+                        AND time_sent > ?;""", (stream_id, last_received)).fetchall()
+    db.close_connection()
+
+    # Send the new chats to frontend
+    return jsonify(new_chats)
\ No newline at end of file
diff --git a/web_server/database/schema.sql b/web_server/database/schema.sql
index 728cd07..7c0d85b 100644
--- a/web_server/database/schema.sql
+++ b/web_server/database/schema.sql
@@ -43,9 +43,11 @@ CREATE TABLE chat
     message_id INT AUTOINCREMENT,
     chatter_id VARCHAR(50) NOT NULL,
     stream_id INT NOT NULL,
-    message TEXT NOT NULL,
-    time_sent DATETIME NOT NULL,
+    message VARCHAR(256) NOT NULL,
+    time_sent DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (message_id),
     FOREIGN KEY (chatter_id) REFERENCES users(username),
     FOREIGN KEY (stream_id) REFERENCES streams(stream_id) ON DELETE CASCADE
-);
\ No newline at end of file
+);
+
+CREATE INDEX chatter_index ON chat(chatter_id);
\ No newline at end of file