FEATURE: Ticketing & API improvements

.gitignore

@@ -1,6 +1,8 @@
 /.idea/
 .env
 /src/db/postgres-data/
+.gitignore
+.vscode/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -157,3 +159,5 @@ dmypy.json
 cython_debug/
 
 /.obsidian/
+src/bot/cogs/moderation/admin_detect_spam_message.py
+.gitignore

src/api/api.py

@@ -10,6 +10,7 @@
 from routes.settings import settings
 from routes.points import points
 from routes.roles import role
+from routes.tickets import tickets
 
 from core.db_helper import DB
 
@@ -28,6 +29,7 @@
 app.register_blueprint(settings)
 app.register_blueprint(points)
 app.register_blueprint(role)
+app.register_blueprint(tickets)
 
 # Error handlers
 @app.errorhandler(Exception)

src/api/core/db_helper.py

@@ -51,7 +51,9 @@ def get_log_settings(self):
         try:
             self.cursor.execute("SELECT * FROM logging") # case sensitive
             result = self.cursor.fetchall()
-            return {"status": "ok", "logging": result}
+            response = {"status": "ok", "logging": result}
+            logger.debug(f"DB Response:\n{response}")
+            return response
         except OperationalError as err:
             logger.error(f"Error fetching logging: {err}")
             return {"status": "error", "message": str(err)}
@@ -61,7 +63,9 @@ def get_logging(self):
         try:
             self.cursor.execute("SELECT * FROM logging")
             result = self.cursor.fetchall()
-            return {"status": "ok", "logging": result}
+            response = {"status": "ok", "logging": result}
+            logger.debug(f"DB Response:\n{response}")
+            return response
         except OperationalError as err:
             logger.error(f"Error fetching logging: {err}")
             return {"status": "error", "message": str(err)}
@@ -96,14 +100,15 @@ def delete_log_setting(self, log_id):
     ##################
     ##   Settings   ##
     ##################
+
     def get_setting(self, setting_id):
         logger.debug("API attempting to contact DB for get_setting...")
         try:
             self.cursor.execute("SELECT * FROM serversettings where id = %s", (setting_id,))
             result = self.cursor.fetchone()
             return {"status": "ok", "setting": result}
         except OperationalError as err:
-            logger.error(f"Error fetching logging: {err}")
+            logger.error(f"Error fetching setting: {err}")
             return {"status": "error", "message": str(err)}
 
     def get_settings(self):
@@ -113,7 +118,7 @@ def get_settings(self):
             result = self.cursor.fetchall()
             return {"status": "ok", "setting": result}
         except OperationalError as err:
-            logger.error(f"Error fetching setting: {err}")
+            logger.error(f"Error fetching settings: {err}")
             return {"status": "error", "message": str(err)}
 
 
@@ -148,6 +153,7 @@ def delete_setting(self, log_id):
     ##################
     ##   roles   ##
     ##################
+
     def get_role(self, role_id):
         logger.debug("API attempting to contact DB for get_role...")
         try:
@@ -189,10 +195,10 @@ def add_role(self, name, value):
     def delete_role(self, role_id):
         logger.debug(f"API attempting to contact DB for delete_role with role_ID:{role_id}")
         try:
-            self.cursor.execute("DELETE FROM roles WHERE id = %s", (role_id,))
+            self.cursor.execute("DELETE FROM roles WHERE id = %s", (role_id,))            
             return {"status": "ok", "message": f"role with ID {role_id} deleted successfully"}
         except OperationalError as err:
-            logger.error(f"Error deleting role: {err}")
+            logger.error(f"Error deleting role: {err}")            
             return {"status": "error", "message": str(err)}
 
     ##################
@@ -212,12 +218,10 @@ def get_points_for_user(self, user_id):
 
     def update_points(self, user_id, value):
         try:
-            self.cursor.execute("UPDATE users SET points = points + %s WHERE discord_id = %s", (value, user_id))
-            self.conn.commit()
+            self.cursor.execute("UPDATE users SET points = points + %s WHERE discord_id = %s", (value, user_id))            
             return {"status": "ok", "message": "points updated successfully"}
         except OperationalError as err:
             logger.error(f"Error updating points: {err}")
-            self.conn.rollback()
             return {"status": "error", "message": str(err)}
 
     def add_user_to_points(self, user_id):
@@ -226,25 +230,25 @@ def add_user_to_points(self, user_id):
                 "INSERT INTO users (discord_id, points) VALUES (%s, 0) ON CONFLICT (discord_id) DO NOTHING;"
                 , (user_id,)
             )
-            # self.conn.commit()
+            # 
             return {"status": "ok", "message": "New user added to 'points' successfully"}
         except OperationalError as err:
             logger.error(f"Error adding new user: {err}")
-            # self.conn.rollback()
+            # 
             return {"status": "error", "message": str(err)}
 
     def remove_user_from_points(self, user_id):
         try:
             self.cursor.execute("DELETE FROM users WHERE discord_id = %s", (user_id,))
             affected_rows = self.cursor.rowcount
             if affected_rows > 0:
-                self.conn.commit()
+
                 return {"status": "ok", "message": f"User with ID: {user_id} deleted successfully"}
             else:
                 return {"status": "not_found", "message": f"No user found with ID: {user_id}"}
         except OperationalError as err:
             logger.error(f"Error deleting user: {err}")
-            self.conn.rollback()
+
             return {"status": "error", "message": str(err)}
 
     def get_top_10(self):
@@ -254,5 +258,121 @@ def get_top_10(self):
             return {"status": "ok", "message": result}
         except OperationalError as err:
             logger.error(f"Error deleting user: {err}")
-            self.conn.rollback()
-            return {"status": "error", "message": str(err)}
+
+            return {"status": "error", "message": str(err)}
+
+
+    ##################
+    ##    Ticket    ##
+    ##################
+
+    def get_ticket(self, thread_id: int):
+        """Fetches a specific ticket from the database by its thread ID."""
+
+        logger.debug("API attempting to contact DB for get_ticket...")
+        try:
+            self.cursor.execute("SELECT * FROM tickets where thread_id = %s", (thread_id,))
+            result = self.cursor.fetchone()
+            return {"status": "ok", "ticket": result}
+        except OperationalError as err:
+            logger.error(f"Error fetching ticket: {err}")
+            return {"status": "error", "message": str(err)}
+
+    def get_tickets(self):
+        """Fetches all tickets from the database."""
+
+        logger.debug("API attempting to contact DB for get_tickets...")
+        try:
+            self.cursor.execute("SELECT * FROM tickets")
+            result = self.cursor.fetchall()
+            return {"status": "ok", "tickets": result}
+        except OperationalError as err:
+            logger.error(f"Error fetching tickets: {err}")
+            return {"status": "error", "message": str(err)}
+
+    def add_ticket(self, thread_id: int, creator_id: int, channel_id: int, status: str = 'open'):
+        """
+        Add a new ticket to the database.
+        Args:
+            - thread_id: The unique ID of the ticket (e.g., thread ID).
+            - creator_id: The Discord ID of the user who created the ticket.
+            - channel_id: The Discord ID of the channel associated with the ticket.
+            - status: The current status of the ticket (e.g., 'open', 'closed')
+
+        """
+
+        logger.debug(f"API attempting to contact DB for add_ticket with thread_id:{thread_id} - creator_id:{creator_id} - channel_id:{channel_id} - status:{status}")
+        try:
+            self.cursor.execute(
+                """
+                INSERT INTO tickets (
+                    thread_id, 
+                    creator_id, 
+                    channel_id, 
+                    status
+                ) 
+                VALUES (%s, %s, %s, %s)""", 
+                (
+                    thread_id, 
+                    creator_id, 
+                    channel_id, 
+                    status
+                )
+            )
+
+
+            return {"status": "ok", "message": "New ticket added successfully"}
+        except OperationalError as err:
+            logger.error(f"Error adding new ticket: {err}")
+
+            return {"status": "error", "message": str(err)}
+
+    def close_ticket(self, thread_id: int):
+        """
+        Close a specific ticket in the database by updating its status to 'closed'.
+        Args:
+            - thread_id: The unique ID of the ticket (e.g., thread ID) to be closed.
+        """
+
+        logger.debug(f"API attempting to contact DB for close_ticket with thread_id:{thread_id}")
+        try:
+            self.cursor.execute("UPDATE tickets SET status = 'closed' WHERE thread_id = %s", (thread_id,))
+
+            return {"status": "ok", "message": f"Ticket with thread ID {thread_id} closed successfully"}
+        except OperationalError as err:
+            logger.error(f"Error closing ticket: {err}")
+
+            return {"status": "error", "message": str(err)}
+
+    def update_ticket_status(self, thread_id: int, status: str):
+        logger.debug(f"API attempting to contact DB for update_ticket_status with thread_id:{thread_id} - status:{status}")
+        try:
+            self.cursor.execute("UPDATE tickets SET status = %s WHERE thread_id = %s", (status, thread_id))
+
+            return {"status": "ok", "message": "Ticket status updated successfully"}
+        except OperationalError as err:
+            logger.error(f"Error updating ticket status: {err}")
+
+            return {"status": "error", "message": str(err)}
+
+    def delete_ticket(self, thread_id: int):
+        logger.debug(f"API attempting to contact DB for delete_ticket with thread_id:{thread_id}")
+        try:
+            self.cursor.execute("DELETE FROM tickets WHERE thread_id = %s", (thread_id,))
+
+            return {"status": "ok", "message": f"Ticket with thread ID {thread_id} deleted successfully"}
+        except OperationalError as err:
+            logger.error(f"Error deleting ticket: {err}")
+
+            return {"status": "error", "message": str(err)}
+
+    def get_open_tickets(self):
+        logger.debug("API attempting to contact DB for get_open_tickets...")
+        try:
+            self.cursor.execute("SELECT * FROM tickets WHERE status = 'open'")
+            result = self.cursor.fetchall()
+            return {"status": "ok", "tickets": result}
+        except OperationalError as err:
+            logger.error(f"Error fetching open tickets: {err}")
+            return {"status": "error", "message": str(err)}
+

src/api/routes/healthchecks.py

@@ -19,7 +19,7 @@ def api_health_check():
     if request.method == 'GET':
         return jsonify({'status': 'ok'}, 200)
 
-    return jsonify({'message': 'improper request method'}, 405)
+    return jsonify({'message': 'improper request method'}), 405
 
 
 @health_checks.route('/hc_db', methods=['GET'])
@@ -30,9 +30,9 @@ def database_health_check():
     if request.method == 'GET':
         try:
             hc = eos.db.database_health_check()
-            return jsonify(hc, 200)
+            return jsonify(hc), 200
 
         except TypeError as ded:
-            return jsonify({"status": "unhealthy", "error": "DB unreachable"}, 404)
+            return jsonify({"status": "unhealthy", "error": "DB unreachable"}), 404
 
-    return jsonify({'message': 'improper request method'}, 404)
+    return jsonify({'message': 'improper request method'}), 404

src/api/routes/logging.py

@@ -25,7 +25,7 @@ def get_log_setting(log_id=None):
         # Retrieve a single setting
         result = eos.db.get_log_setting(log_id)
 
-    return jsonify(result, 200)
+    return jsonify(result), 200
 
 # @settings.route('/log_settings', methods=['GET'])
 # def get_log_settings():
@@ -36,7 +36,7 @@ def get_log_setting(log_id=None):
 #     """
 #     result = eos.db.get_log_settings()
 #
-#     return jsonify(result, 200)
+#     return jsonify(result), 200
 
 @logs.route('/logging/<log_id>', methods=['PUT'])
 def update_log_setting(log_id):
@@ -46,9 +46,9 @@ def update_log_setting(log_id):
     if request.method == 'PUT':
         data = request.json
         result = eos.db.update_logging(int(log_id), data['value'])
-        return jsonify(result, 200)
+        return jsonify(result), 200
 
-    return jsonify({'message': 'improper request method'}, 405)
+    return jsonify({'message': 'improper request method'}), 405
 
 @logs.route('/logging', methods=['POST'])
 def add_log_setting():
@@ -58,9 +58,9 @@ def add_log_setting():
     if request.method == 'POST':
         data = request.json
         result = eos.db.add_log_setting(data['name'], data['value'])
-        return jsonify(result, 201)
+        return jsonify(result), 201
 
-    return jsonify({'message': 'improper request method'}, 405)
+    return jsonify({'message': 'improper request method'}), 405
 
 @logs.route('/logging/<int:log_id>', methods=['DELETE'])
 def delete_log_setting(log_id):
@@ -69,6 +69,6 @@ def delete_log_setting(log_id):
     """
     if request.method == 'DELETE':
         result = eos.db.delete_log_setting(log_id)
-        return jsonify(result, 200)
+        return jsonify(result), 200
 
-    return jsonify({'message': 'improper request method'}, 405)
+    return jsonify({'message': 'improper request method'}), 405

src/api/routes/roles.py

@@ -25,7 +25,7 @@ def get_role(role_id=None):
         # Retrieve a single role
         result = eos.db.get_role(role_id)
 
-    return jsonify(result, 200)
+    return jsonify(result), 200
 
 @role.route('/role/<role_id>', methods=['PUT'])
 def update_role(role_id):
@@ -35,9 +35,9 @@ def update_role(role_id):
     if request.method == 'PUT':
         data = request.json
         result = eos.db.update_role(int(role_id), data['value'])
-        return jsonify(result, 200)
+        return jsonify(result), 200
 
-    return jsonify({'message': 'improper request method'}, 405)
+    return jsonify({'message': 'improper request method'}), 405
 
 @role.route('/role', methods=['POST'])
 def add_role():
@@ -47,9 +47,9 @@ def add_role():
     if request.method == 'POST':
         data = request.json
         result = eos.db.add_role(data['name'], data['value'])
-        return jsonify(result, 201)
+        return jsonify(result), 201
 
-    return jsonify({'message': 'improper request method'}, 405)
+    return jsonify({'message': 'improper request method'}), 405
 
 @role.route('/role/<int:role_id>', methods=['DELETE'])
 def delete_role(role_id):
@@ -58,6 +58,7 @@ def delete_role(role_id):
     """
     if request.method == 'DELETE':
         result = eos.db.delete_role(role_id)
-        return jsonify(result, 200)
+        return jsonify(result), 200
+
+    return jsonify({'message': 'improper request method'}), 405
 
-    return jsonify({'message': 'improper request method'}, 405)