made chat before and after

backend/blueprints/admin/__init__.py

@@ -141,43 +141,3 @@ def get_discussion_stats():
         return jsonify({'message': f'An error occurred: {str(e)}'}), 500
     
 
-public_summary = Blueprint('public', __name__)
-
-@public_summary.route('/stats/summary', methods=['GET'])
-def get_public_summary():
-    """
-    Public API to fetch total user count, authors, and total courses.
-    """
-    try:
-        # Total users
-        total_users = db.session.execute(
-            select(func.count()).select_from(User)
-        ).scalar()
-
-        # Authors (users who have created courses)
-        total_authors = db.session.execute(
-            select(func.count(func.distinct(Course.authorID)))
-            .select_from(Course)
-        ).scalar()
-
-        # Total courses
-        total_courses = db.session.execute(
-            select(func.count()).select_from(Course)
-        ).scalar()
-
-        # Simulated newsletter subscription count
-        subscribed_users = db.session.execute(
-            select(func.count(User.email)).select_from(User)
-        ).scalar()
-
-        return jsonify({
-            'stats': {
-                'totalUsers': total_users,
-                'totalAuthors': total_authors,
-                'totalCourses': total_courses,
-                'subscribedNewsletter': subscribed_users
-            }
-        }), 200
-
-    except Exception as e:
-        return jsonify({'message': f'An error occurred: {str(e)}'}), 500

backend/blueprints/chat/__init__.py

@@ -1,7 +1,7 @@
-from flask import Blueprint, request, jsonify, current_app, g
+from flask import Blueprint, request, jsonify, g
-from db.model import User, Course, Enrollment, Chat, db
+from db.model import User, Enrollment, Chat, db
 import uuid
-from sqlalchemy import select, and_
+from sqlalchemy import select, and_, desc
 from datetime import datetime
 
 chat = Blueprint('chat', __name__)
@@ -9,11 +9,19 @@ chat = Blueprint('chat', __name__)
 @chat.route('/<uuid:course_id>/messages', methods=['GET'])
 def get_course_messages(course_id: uuid.UUID):
     """
-    Fetch chat messages for a specific course.
+    Fetch chat messages for a specific course with optional pagination.
     Only enrolled users can access the messages.
+
+    Query Parameters:
+    - before: UUID of the message to get older entries
+    - after: UUID of the message to get newer entries
+    - limit: Number of messages to return (default: 10)
     """
     try:
         current_user: User = g.current_user
+        limit = int(request.args.get('limit', 10))
+        before_id = request.args.get('before')
+        after_id = request.args.get('after')
         
         # Verify user's enrollment
         enrollment = db.session.execute(
@@ -28,12 +36,47 @@ def get_course_messages(course_id: uuid.UUID):
         if not enrollment:
             return jsonify({'message': 'You are not enrolled in this course'}), 401
         
-        # Get chat messages for the course
+        # Base query
-        messages = db.session.execute(
+        query = select(Chat).where(Chat.courseID == course_id)
-            select(Chat)
+        
-            .where(Chat.courseID == course_id)
+        # Handle pagination
-            .order_by(Chat.chatDate.desc())
+        if before_id:
-        ).scalars()
+            try:
+                reference_message = db.session.execute(
+                    select(Chat).where(Chat.id == uuid.UUID(before_id))
+                ).scalar()
+                
+                if not reference_message:
+                    return jsonify({'message': 'Reference message not found'}), 404
+                
+                query = query.where(Chat.chatDate < reference_message.chatDate)
+            except ValueError:
+                return jsonify({'message': 'Invalid message ID format'}), 400
+        elif after_id:
+            try:
+                reference_message = db.session.execute(
+                    select(Chat).where(Chat.id == uuid.UUID(after_id))
+                ).scalar()
+                
+                if not reference_message:
+                    return jsonify({'message': 'Reference message not found'}), 404
+                
+                query = query.where(Chat.chatDate > reference_message.chatDate)
+                # For after queries, reverse the order later
+                query = query.order_by(Chat.chatDate)
+            except ValueError:
+                return jsonify({'message': 'Invalid message ID format'}), 400
+        else:
+            # Default ordering
+            query = query.order_by(desc(Chat.chatDate))
+        
+        # Apply limit and execute query
+        query = query.limit(limit)
+        messages = list(db.session.execute(query).scalars())
+        
+        # Reverse the order for 'after' queries to maintain consistency
+        if after_id:
+            messages.reverse()
         
         # Format messages
         chat_messages = [{
@@ -44,7 +87,11 @@ def get_course_messages(course_id: uuid.UUID):
             'timestamp': msg.chatDate.isoformat()
         } for msg in messages]
         
-        return jsonify({'messages': chat_messages}), 200
+        return jsonify({
+            'messages': chat_messages,
+            'count': len(chat_messages),
+            'hasMore': len(chat_messages) == limit
+        }), 200
         
     except Exception as e:
         return jsonify({'message': f'An error occurred: {str(e)}'}), 500
@@ -99,44 +146,3 @@ def send_message(course_id: uuid.UUID):
     except Exception as e:
         db.session.rollback()
         return jsonify({'message': f'An error occurred: {str(e)}'}), 500
-
-@chat.route('/<uuid:course_id>/participants', methods=['GET'])
-def get_chat_participants(course_id: uuid.UUID):
-    """
-    Get list of active participants in a course chat.
-    Returns only enrolled users with recent activity.
-    """
-    try:
-        current_user: User = g.current_user
-        
-        # Verify requesting user's enrollment
-        user_enrollment = db.session.execute(
-            select(Enrollment).where(
-                and_(
-                    Enrollment.courseID == course_id,
-                    Enrollment.userID == current_user.id
-                )
-            )
-        ).scalar()
-        
-        if not user_enrollment:
-            return jsonify({'message': 'You are not enrolled in this course'}), 401
-            
-        # Get enrolled users
-        enrollments = db.session.execute(
-            select(Enrollment)
-            .where(Enrollment.courseID == course_id)
-            .join(User)
-        ).scalars()
-        
-        # Return participant information
-        participants = [{
-            'id': str(enrollment.userID),
-            'username': enrollment.user.username,
-            'lastActivity': enrollment.lastActivity.isoformat()
-        } for enrollment in enrollments]
-        
-        return jsonify({'participants': participants}), 200
-        
-    except Exception as e:
-        return jsonify({'message': f'An error occurred: {str(e)}'}), 500

backend/blueprints/public/__init__.py

@@ -0,0 +1,71 @@
+from flask import Blueprint, jsonify
+from db.model import User, Course, db
+from sqlalchemy import select, func
+
+public_summary = Blueprint('public', __name__)
+
+@public_summary.route('/stats/total-users', methods=['GET'])
+def get_total_users():
+    """
+    Fetch total user count.
+    """
+    try:
+        total_users = db.session.execute(
+            select(func.count()).select_from(User)
+        ).scalar()
+
+        return jsonify({'totalUsers': total_users}), 200
+
+    except Exception as e:
+        return jsonify({'message': f'An error occurred: {str(e)}'}), 500
+
+
+@public_summary.route('/stats/total-authors', methods=['GET'])
+def get_total_authors():
+    """
+    Fetch total authors (users who have created courses).
+    """
+    try:
+        total_authors = db.session.execute(
+            select(func.count(func.distinct(Course.authorID)))
+            .select_from(Course)
+        ).scalar()
+
+        return jsonify({'totalAuthors': total_authors}), 200
+
+    except Exception as e:
+        return jsonify({'message': f'An error occurred: {str(e)}'}), 500
+
+
+@public_summary.route('/stats/total-courses', methods=['GET'])
+def get_total_courses():
+    """
+    Fetch total course count.
+    """
+    try:
+        total_courses = db.session.execute(
+            select(func.count()).select_from(Course)
+        ).scalar()
+
+        return jsonify({'totalCourses': total_courses}), 200
+
+    except Exception as e:
+        return jsonify({'message': f'An error occurred: {str(e)}'}), 500
+
+
+@public_summary.route('/stats/subscribed-users', methods=['GET'])
+def get_subscribed_users():
+    """
+    Fetch count of users subscribed to the newsletter and are activated.
+    """
+    try:
+        subscribed_users = db.session.execute(
+            select(func.count(User.email))
+            .select_from(User)
+            .where(User.isActivated == True)
+        ).scalar()
+
+        return jsonify({'subscribedNewsletter': subscribed_users}), 200
+
+    except Exception as e:
+        return jsonify({'message': f'An error occurred: {str(e)}'}), 500