Build in-session features

chatbot.py

@@ -0,0 +1,45 @@
+import streamlit as st
+import datetime
+from db import courses_collection2, faculty_collection, students_collection, vectors_collection, chat_history_collection
+from PIL import Image
+from dotenv import load_dotenv
+import os
+from datetime import datetime
+from bson import ObjectId
+from file_upload_vectorize import model
+
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+OPENAI_KEY = os.getenv('OPENAI_KEY')
+GEMINI_KEY = os.getenv('GEMINI_KEY')
+
+def insert_chat_message(user_id, session_id, role, content):
+    message = {
+        "role": role,
+        "content": content,
+        "timestamp": datetime.utcnow()
+    }
+    
+    chat_history_collection.update_one(
+        {"user_id": ObjectId(user_id), "session_id": session_id},
+        {"$push": {"messages": message}, "$set": {"timestamp": datetime.utcnow()}},
+        upsert=True
+    )
+
+
+def give_chat_response(user_id, session_id, question, context, prompt):
+    st.title("Chat with NOVA")
+    st.write("Ask any question and NOVA will provide an answer.")
+    
+    with st.form("chat_form"):
+        message = st.text_input("Message")
+        submit = st.form_submit_button("Send")
+        
+        if submit:
+            insert_chat_message(user_id, session_id, "user", message)
+            st.write(f"You: {message}")
+            
+            # Get response from NOVA
+            response = get_nova_response(question, context, prompt, message)
+            insert_chat_message(user_id, session_id, "nova", response)
+            st.write(f"NOVA: {response}")

db.py

@@ -532,4 +532,58 @@ vector_schema = {
 }
 # Creating the Vector Collection
 # db.create_collection("vectors", validator={"$jsonSchema": vector_schema})
-vectors_collection = db['vectors']
+vectors_collection = db['vectors']
+
+
+# Creating a Chat-History Collection
+# Creating a Chat-History Collection
+chat_history_schema = {
+    "bsonType": "object",
+    "required": ["user_id", "session_id", "messages", "timestamp"],
+    "properties": {
+        "user_id": {
+            "bsonType": "objectId",
+            "description": "Unique identifier for the user"
+        },
+        "session_id": {
+            "bsonType": "string",
+            "description": "Identifier for the session"
+        },
+        "timestamp": {
+            "bsonType": "date",
+            "description": "Timestamp when the chat session started"
+        },
+        "messages": {
+            "bsonType": "array",
+            "description": "List of chat messages",
+            "items": {
+                "bsonType": "object",
+                "properties": {
+                    "prompt": {
+                        "bsonType": "string",
+                        "description": "User's question or prompt"
+                    },
+                    "response": {
+                        "bsonType": "string",
+                        "description": "Assistant's response"
+                    },
+                    "timestamp": {
+                        "bsonType": "date",
+                        "description": "Timestamp of the message"
+                    }
+                }
+            }
+        }
+    }
+}
+
+# Create the collection with the schema
+# db.create_collection("chat_history", validator={"$jsonSchema": chat_history_schema})
+chat_history_collection = db['chat_history']
+
+# Create the collection with the schema
+# db.create_collection("chat_history", validator={"$jsonSchema": chat_history_schema})
+# chat_history_collection = db['chat_history']
+
+
+# database_setup for live polls

file_upload_vectorize.py

@@ -61,6 +61,30 @@ def upload_resource(course_id, session_id, file_name, file_content, material_typ
     resources_collection.insert_one(resource_data)
     return resource_id
 
+def assignment_submit(student_id, course_id, session_id, file_name, file_content, material_type):
+    # Extract text content from the file
+    text_content = extract_text_from_file(file_content)
+    
+    # Read the file content
+    file_content.seek(0)  # Reset the file pointer to the beginning
+    original_file_content = file_content.read()
+    
+    assignment_data = {
+        "student_id": student_id,
+        "course_id": course_id,
+        "session_id": session_id,
+        "file_name": file_name,
+        "file_type": file_content.type,
+        "text_content": text_content,
+        "file_content": original_file_content,  # Store the original file content
+        "material_type": material_type,
+        "uploaded_at": datetime.utcnow()
+    }
+    courses_collection2.update_one(
+        {"course_id": course_id, "sessions.session_id": session_id},
+        {"$push": {"sessions.$.post_class.assignments": assignment_data}}
+    )
+
 def extract_text_from_file(uploaded_file):
     text = ""
     file_type = uploaded_file.type

live_polls.py

@@ -0,0 +1,115 @@
+# live_poll_feature.py
+
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+from poll_db_operations import PollDatabase
+
+class LivePollFeature:
+    def __init__(self):
+        self.db = PollDatabase()
+    
+    def display_faculty_interface(self, session_id):
+        """Display the faculty interface for managing polls"""
+        st.subheader("Live Polls Management")
+        
+        # Create new poll
+        with st.expander("Create New Poll", expanded=False):
+            question = st.text_input("Poll Question")
+            
+            num_options = st.number_input("Number of Options", 
+                                        min_value=2, 
+                                        max_value=6, 
+                                        value=4)
+            
+            options = []
+            for i in range(num_options):
+                option = st.text_input(f"Option {i+1}", 
+                                     key=f"option_{i}")
+                if option:
+                    options.append(option)
+            
+            if st.button("Create Poll") and question and len(options) >= 2:
+                self.db.create_poll(
+                    st.session_state.selected_course,
+                    session_id,
+                    question,
+                    options,
+                    st.session_state.user_id
+                )
+                st.success("Poll created successfully!")
+                st.rerun()
+        
+        # Display active polls
+        active_polls = self.db.get_active_polls(session_id)
+        if active_polls:
+            st.subheader("Active Polls")
+            for poll in active_polls:
+                with st.expander(f"Poll: {poll['question']}", expanded=True):
+                    # Display results
+                    self._display_poll_results(poll)
+                    
+                    if st.button("Close Poll", 
+                               key=f"close_{str(poll['_id'])}"):
+                        self.db.close_poll(poll['_id'])
+                        st.success("Poll closed successfully!")
+                        st.rerun()
+    
+    def display_student_interface(self, session_id):
+        """Display the student interface for participating in polls"""
+        st.subheader("Live Polls")
+        
+        active_polls = self.db.get_active_polls(session_id)
+        if not active_polls:
+            st.info("No active polls at the moment.")
+            return
+        
+        for poll in active_polls:
+            with st.expander(f"Poll: {poll['question']}", expanded=True):
+                selected_option = st.radio(
+                    "Your response:",
+                    options=poll['options'],
+                    key=f"poll_{str(poll['_id'])}"
+                )
+                
+                if st.button("Submit Response", 
+                           key=f"submit_{str(poll['_id'])}"):
+                    success, message = self.db.submit_response(
+                        poll['_id'],
+                        st.session_state.user_id,
+                        selected_option
+                    )
+                    if success:
+                        st.success(message)
+                    else:
+                        st.warning(message)
+                    st.rerun()
+                
+                self._display_poll_results(poll)
+    
+    def _display_poll_results(self, poll):
+        """Helper method to display poll results"""
+        responses_df = pd.DataFrame(
+            list(poll['responses'].items()),
+            columns=['Option', 'Votes']
+        )
+        
+        total_votes = responses_df['Votes'].sum()
+        
+        # Calculate percentages
+        if total_votes > 0:
+            responses_df['Percentage'] = (
+                responses_df['Votes'] / total_votes * 100
+            ).round(1)
+        else:
+            responses_df['Percentage'] = 0
+        
+        # Display metrics
+        st.metric("Total Responses", total_votes)
+        
+        # Display charts
+        st.bar_chart(responses_df.set_index('Option')['Votes'])
+        
+        # Display detailed statistics
+        if st.session_state.user_type == 'faculty':
+            st.dataframe(responses_df)

main.py

@@ -11,6 +11,8 @@ def init_session_state():
     """Initialize session state variables"""
     if 'authenticated' not in st.session_state:
         st.session_state.authenticated = False
+    if 'user_id' not in st.session_state:
+        st.session_state.user_id = None
     if 'user_type' not in st.session_state:
         st.session_state.user_type = None
     if 'username' not in st.session_state:
@@ -26,6 +28,7 @@ def login_user(username, password, user_type):
         user = faculty_collection.find_one({"full_name": username})
     
     if user and check_password_hash(user['password'], password):
+        st.session_state.user_id = user['_id']
         st.session_state.authenticated = True
         st.session_state.user_type = user_type
         st.session_state.username = username
@@ -113,7 +116,7 @@ def main_dashboard():
 
     # Main content
     if 'selected_session' in st.session_state:
-        display_session_content(selected_course_id, st.session_state.selected_session, st.session_state.username)
+        display_session_content(st.session_state.user_id, selected_course_id, st.session_state.selected_session, st.session_state.username, st.session_state.user_type)
 
 
 def main():

poll_db_operations.py

@@ -0,0 +1,70 @@
+from pymongo import MongoClient
+from datetime import datetime
+from bson import ObjectId
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+class PollDatabase:
+    def __init__(self):
+        self.client = MongoClient(MONGO_URI)
+        self.db = self.client["novascholar_db"]
+    
+    def create_poll(self, course_id, session_id, question, options, faculty_id):
+        """Create a new poll"""
+        poll = {
+            "course_id": course_id,
+            "session_id": session_id,
+            "faculty_id": faculty_id,
+            "question": question,
+            "options": options,
+            "status": "active",
+            "created_at": datetime.now(),
+            "responses": {option: 0 for option in options}
+        }
+        return self.db.polls.insert_one(poll)
+    
+    def get_active_polls(self, session_id):
+        """Get all active polls for a session"""
+        return list(self.db.polls.find({
+            "session_id": session_id,
+            "status": "active"
+        }))
+    
+    def submit_response(self, poll_id, student_id, selected_option):
+        """Submit a student's response to a poll"""
+        try:
+            # Record individual response
+            response = {
+                "poll_id": poll_id,
+                "student_id": student_id,
+                "selected_option": selected_option,
+                "submitted_at": datetime.now()
+            }
+            self.db.poll_responses.insert_one(response)
+            
+            # Update aggregated results
+            self.db.polls.update_one(
+                {"_id": ObjectId(poll_id)},
+                {"$inc": {f"responses.{selected_option}": 1}}
+            )
+            return True, "Vote recorded successfully"
+            
+        except Exception as e:
+            if "duplicate key error" in str(e):
+                return False, "You have already voted in this poll"
+            return False, f"Error recording vote: {str(e)}"
+    
+    def close_poll(self, poll_id):
+        """Close a poll"""
+        return self.db.polls.update_one(
+            {"_id": ObjectId(poll_id)},
+            {"$set": {"status": "closed"}}
+        )
+    
+    def get_poll_analytics(self, poll_id):
+        """Get detailed analytics for a poll"""
+        poll = self.db.polls.find_one({"_id": ObjectId(poll_id)})
+        responses = self.db.poll_responses.find({"poll_id": ObjectId(poll_id)})
+        return poll, list(responses)

poll_db_setup.py

@@ -0,0 +1,35 @@
+from pymongo import MongoClient
+from datetime import datetime
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+def setup_mongodb():
+    """Initialize MongoDB connection and create collections with indexes"""
+    client = MongoClient(MONGO_URI)
+    db = client["novascholar_db"]
+    
+    # Create indexes for polls collection
+    db.polls.create_index([("session_id", 1), ("status", 1)])
+    db.polls.create_index([("course_id", 1)])
+    
+    # Create unique index for poll_responses to prevent duplicate votes
+    db.poll_responses.create_index(
+        [("poll_id", 1), ("student_id", 1)],
+        unique=True
+    )
+    
+    return "Database setup completed successfully"
+
+def print_all_polls():
+    """Print all polls in the database"""
+    client = MongoClient(MONGO_URI)
+    db = client["novascholar_db"]
+    
+    polls = db.polls.find()
+    for poll in polls:
+        print(poll)
+
+if __name__ == "__main__":
+    print(print_all_polls())

session_page.py

@@ -3,9 +3,18 @@ from datetime import datetime
 from utils.sample_data import SAMPLE_CHAT_HISTORY, SAMPLE_STUDENT_PROGRESS
 from utils.helpers import display_progress_bar, create_notification, format_datetime
 from utils.sample_data import SAMPLE_SESSIONS, SAMPLE_COURSES
-from file_upload_vectorize import upload_resource, extract_text_from_file, create_vector_store, resources_collection
-from db import courses_collection2
-def display_preclass_content(session, username):
+from file_upload_vectorize import upload_resource, extract_text_from_file, create_vector_store, resources_collection, model, assignment_submit
+from db import courses_collection2, chat_history_collection, students_collection, faculty_collection, vectors_collection
+from chatbot import insert_chat_message
+from bson import ObjectId
+from live_polls import LivePollFeature
+
+def get_current_user():
+    if 'current_user' not in st.session_state:
+        return None
+    return students_collection.find_one({"_id": st.session_state.user_id})
+
+def display_preclass_content(session, student_id):
     """Display pre-class materials for a session"""
     st.subheader("Pre-class Materials")
     
@@ -41,13 +50,12 @@ def display_preclass_content(session, username):
     #             create_notification("Notes saved successfully!", "success")
 
     # Display pre-class materials
+    print(f"student_id: {type(student_id)}")
+
     materials = resources_collection.find({"session_id": session['session_id']})
+    print(f"materials: {type(materials)}")
     for material in materials:
-        # with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
-        #     if material['material_type'] == 'pdf':
-        #         # st.markdown(f"📑 [Open PDF Document]({material['url']})")
-        #         if st.button("Mark PDF as Read", key=f"pdf_{material['file_name']}"):
-        #             create_notification("PDF marked as read!", "success")
+        print(f"material: {type(material)}")
         with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
             file_type = material.get('file_type', 'unknown')
             if file_type == 'application/pdf':
@@ -64,91 +72,218 @@ def display_preclass_content(session, username):
                 if st.button("Mark PDF as Read", key=f"pdf_{material['file_name']}"):
                     create_notification("PDF marked as read!", "success")
 
-def display_in_class_content(session):
-    """Display in-class activities and interactions"""
-    st.header("In-class Activities")
+    user = get_current_user()
+    print(f"user: {type(user)}")
+
+    user = get_current_user()
     
-    # Topics covered
-    with st.expander("Topics Covered", expanded=True):
-        for topic in session['in_class']['topics']:
-            st.markdown(f"- {topic}")
+    # Chat input
+    # Add a check, if materials are available, only then show the chat input
+    if(st.session_state.user_type == "student"):
+        if materials:
+            if prompt := st.chat_input("Ask a question about Pre-class Materials"):
+                if len(st.session_state.messages) >= 20:
+                    st.warning("Message limit (20) reached for this session.")
+                    return
+
+                st.session_state.messages.append({"role": "user", "content": prompt})
+                
+                # Display User Message
+                with st.chat_message("user"):
+                    st.markdown(prompt)
+
+                # Get document context
+                context = ""
+                materials = resources_collection.find({"session_id": session['session_id']})
+                context = ""
+                vector_data = None
+
+                context = ""
+                for material in materials:
+                    resource_id = material['_id']
+                    vector_data = vectors_collection.find_one({"resource_id": resource_id})
+                    if vector_data and 'text' in vector_data:
+                        context += vector_data['text'] + "\n"
+
+                if not vector_data:
+                    st.error("No Pre-class materials found for this session.")
+                    return
+                
+                try:
+                    # Generate response using Gemini
+                    context_prompt = f"""
+                    Based on the following context, answer the user's question:
+                    
+                    Context:
+                    {context}
+                    
+                    Question: {prompt}
+                    
+                    Please provide a clear and concise answer based only on the information provided in the context.
+                    """
+
+                    response = model.generate_content(context_prompt)
+                    if not response or not response.text:
+                        st.error("No response received from the model")
+                        return
+                    
+                    assistant_response = response.text
+                    # Display Assistant Response
+                    with st.chat_message("assistant"):
+                        st.markdown(assistant_response)
+                    
+                    # Build the message
+                    new_message = {
+                        "prompt": prompt,
+                        "response": assistant_response,
+                        "timestamp": datetime.utcnow()
+                    }
+                    st.session_state.messages.append(new_message)
+
+                    # Update database
+                    try:
+                        chat_history_collection.update_one(
+                            {
+                                "user_id": student_id,
+                                "session_id": session['session_id']
+                            },
+                            {
+                                "$push": {"messages": new_message},
+                                "$setOnInsert": {
+                                    "user_id": student_id,
+                                    "session_id": session['session_id'],
+                                    "timestamp": datetime.utcnow()
+                                }
+                            },
+                            upsert=True
+                        )
+                    except Exception as db_error:
+                        st.error(f"Error saving chat history: {str(db_error)}")
+                except Exception as e:
+                    st.error(f"Error generating response: {str(e)}")
     
-    # Live Quiz section
-    st.subheader("Session Quiz")
-    quiz = session['in_class']['quiz']
-    with st.expander(f"Quiz: {quiz['title']}"):
-        st.markdown(f"- Number of questions: {quiz['questions']}")
-        st.markdown(f"- Time allowed: {quiz['duration']} minutes")
-        if session['status'] == 'in_progress':
-            if st.button("Start Quiz"):
-                create_notification("Quiz will begin shortly!", "info")
+    st.subheader("Your Chat History")
+    # Initialize chat messages from database
+    if 'messages' not in st.session_state:
+        existing_chat = chat_history_collection.find_one({
+            "user_id": student_id,
+            "session_id": session['session_id']
+        })
+        if existing_chat and 'messages' in existing_chat:
+            st.session_state.messages = existing_chat['messages']
         else:
-            st.info("Quiz not available at this time")
+            st.session_state.messages = []
+
+    # Display existing chat history
+    try:
+        for message in st.session_state.messages:
+            if 'prompt' in message and 'response' in message:
+                with st.chat_message("user"):
+                    st.markdown(message["prompt"])
+                with st.chat_message("assistant"):
+                    st.markdown(message["response"])
+    except Exception as e:
+        st.error(f"Error displaying chat history: {str(e)}")
+        st.session_state.messages = []
+
+def display_in_class_content(session, user_type):
+    # """Display in-class activities and interactions"""
+    """Display in-class activities and interactions"""
+    st.header("In-class Activities")
     
-    # Live Polls
-    st.subheader("Interactive Polls")
-    for idx, poll in enumerate(session['in_class']['polls']):
-        with st.expander(f"Poll {idx + 1}: {poll['question']}"):
-            selected_option = st.radio(
-                "Your response:",
-                options=poll['options'],
-                key=f"poll_{session['session_id']}_{idx}"
-            )
-            if st.button("Submit Response", key=f"submit_poll_{idx}"):
-                create_notification("Poll response recorded!", "success")
+    # Initialize Live Polls feature
+    live_polls = LivePollFeature()
     
-    # Chat Interface
-    st.subheader("Class Discussion")
-    chat_container = st.container()
-    with chat_container:
-        # Display existing messages
-        messages = SAMPLE_CHAT_HISTORY.get(session['session_id'], [])
-        for msg in messages:
-            with st.chat_message(msg['user']):
-                st.write(msg['message'])
-        
-        # New message input
-        if session['status'] == 'in_progress':
-            if prompt := st.chat_input("Ask a question..."):
-                if len(messages) < 20:
-                    with st.chat_message("user"):
-                        st.write(prompt)
-                    with st.chat_message("assistant"):
-                        st.write("This is a sample response to your question.")
-                else:
-                    create_notification("Message limit (20) reached for this session.", "warning")
+    # Display appropriate interface based on user role
+    if user_type == 'faculty':
+        live_polls.display_faculty_interface(session['session_id'])
+    else:
+        live_polls.display_student_interface(session['session_id'])
 
-def display_post_class_content(session):
+def display_post_class_content(session, student_id, course_id):
     """Display post-class assignments and submissions"""
     st.header("Post-class Work")
     
-    # Display assignments
-    for assignment in session['post_class']['assignments']:
-        with st.expander(f"Assignment: {assignment['title']}", expanded=True):
-            st.markdown(f"**Due Date:** {format_datetime(assignment['due_date'])}")
-            st.markdown(f"**Status:** {assignment['status'].replace('_', ' ').title()}")
-            
-            # Assignment details
-            st.markdown("### Instructions")
-            st.markdown("Complete the assignment according to the provided guidelines.")
-            
-            # File submission
-            st.markdown("### Submission")
-            uploaded_file = st.file_uploader(
-                "Upload your work",
-                type=['pdf', 'py', 'ipynb'],
-                key=f"upload_{assignment['id']}"
-            )
-            
-            if uploaded_file is not None:
-                st.success("File uploaded successfully!")
-                if st.button("Submit Assignment", key=f"submit_{assignment['id']}"):
-                    create_notification("Assignment submitted successfully!", "success")
+    if st.session_state.user_type == 'faculty':
+        st.subheader("Add Assignments")
+        # Add assignment form
+        with st.form("add_assignment_form"):
+            title = st.text_input("Assignment Title")
+            due_date = st.date_input("Due Date")
+            submit = st.form_submit_button("Add Assignment")
             
-            # Feedback section (if assignment is completed)
-            if assignment['status'] == 'completed':
-                st.markdown("### Feedback")
-                st.info("Feedback will be provided here once the assignment is graded.")
+            if submit:
+                due_date = datetime.combine(due_date, datetime.min.time())
+                # Save the assignment to the database
+                assignment = {
+                    "id": ObjectId(),
+                    "title": title,
+                    "due_date": due_date,
+                    "status": "pending",
+                    "submissions": []
+                }
+                courses_collection2.update_one(
+                    {"course_id": course_id, "sessions.session_id": session['session_id']},
+                    {"$push": {"sessions.$.post_class.assignments": assignment}}
+                )
+                st.success("Assignment added successfully!")
+    else:
+        # Display assignments
+        # assignments += courses_collection2.find_one(
+        #     {"course_id": course_id, "sessions.session_id": session['session_id']},
+        #     {"sessions.$.post_class.assignments": 1}
+        # )["sessions"][0]["post_class"]["assignments"]
+        session_data = courses_collection2.find_one(
+            {"course_id": course_id, "sessions.session_id": session['session_id']},
+            {"sessions.$": 1}
+        )
+        assignments = session_data["sessions"][0]["post_class"]["assignments"]
+        print(assignments)
+        for assignment in assignments:
+            with st.expander(f"Assignment: {assignment['title']}", expanded=True):
+                st.markdown(f"**Due Date:** {assignment['due_date']}")
+                st.markdown(f"**Status:** {assignment['status'].replace('_', ' ').title()}")
+                
+                # Assignment details
+                st.markdown("### Instructions")
+                st.markdown("Complete the assignment according to the provided guidelines.")
+                
+                # File submission
+                st.markdown("### Submission")
+                uploaded_file = st.file_uploader(
+                    "Upload your work",
+                    type=['pdf', 'py', 'ipynb'],
+                    key=f"upload_{assignment['id']}"
+                )
+                
+                if uploaded_file is not None:
+                    st.success("File uploaded successfully!")
+
+                    if st.button("Submit Assignment", key=f"submit_{assignment['id']}"):
+                        # Save the file to a location and get the file URL
+                        assignment_submit(student_id, course_id, session['session_id'], uploaded_file.name, uploaded_file, uploaded_file.type)
+                
+                        # Display submitted assignments
+                        st.markdown(f"📑 [Click to view Submission]({uploaded_file['file_name']})")
+                        if st.button("View PDF", key=f"view_pdf_{uploaded_file['file_name']}"):
+                            st.text_area("PDF Content", uploaded_file['text_content'], height=300)
+                        if st.button("Download PDF", key=f"download_pdf_{uploaded_file['file_name']}"):
+                            st.download_button(
+                                label="Download PDF",
+                                data=uploaded_file['file_content'],
+                                file_name=uploaded_file['file_name'],
+                                mime='application/pdf'
+                        )
+
+                # Feedback section (if assignment is completed)
+                if assignment['status'] == 'completed':
+                    st.markdown("### Feedback")
+                    st.info("Feedback will be provided here once the assignment is graded.")
+                
+                
+
+
+
 
 def display_preclass_analytics(session):
     """Display pre-class analytics for faculty"""
@@ -185,10 +320,10 @@ def display_postclass_analytics(session):
     """Display post-class analytics for faculty"""
     st.subheader("Post-class Analytics")
     
-    # Display assignment completion rates
-    for assignment in session['post_class']['assignments']:
-        progress = SAMPLE_STUDENT_PROGRESS.get(assignment['id'], 0)
-        display_progress_bar(progress, 100, assignment['title'])
+    # # Display assignment completion rates
+    # for assignment in session['post_class']['assignments']:
+    #     progress = SAMPLE_STUDENT_PROGRESS.get(assignment['id'], 0)
+    #     display_progress_bar(progress, 100, assignment['title'])
 
 
 def upload_preclass_materials(session_id, course_id):
@@ -222,7 +357,7 @@ def upload_preclass_materials(session_id, course_id):
 
 
 
-def display_session_content(course_id, session, username):
+def display_session_content(student_id, course_id, session, username, user_type):
     st.title(f"Session {session['session_id']}: {session['title']}")
     st.markdown(f"**Date:** {format_datetime(session['date'])}")
     st.markdown(f"**Status:** {session['status'].replace('_', ' ').title()}")
@@ -250,18 +385,22 @@ def display_session_content(course_id, session, username):
     # Display pre-class materials
     if st.session_state.user_type == 'student':
         with pre_class_tab:
-            display_preclass_content(session, username)
+            display_preclass_content(session, student_id)
         
         with in_class_tab:
-            display_in_class_content(session)
+            display_in_class_content(session, st.session_state.user_type)
         
         # Post-class Content
         with post_class_tab:
-            display_post_class_content(session)
+            display_post_class_content(session, student_id, course_id)
 
     if st.session_state.user_type == 'faculty':
         with pre_class_work:
             upload_preclass_materials(session['session_id'], course_id)
+        with in_class_work:
+            display_in_class_content(session, st.session_state.user_type)
+        with post_class_work:
+            display_post_class_content(session, student_id, course_id)
         with preclass_analytics:
             display_preclass_analytics(session)
         with inclass_analytics: