Merge branch 'main' of https://huggingface.co/spaces/SPJIMR-Internship/SPJIMR_FlipClassroom_RCopilot_ResearchInternship

app.py

@@ -17,7 +17,7 @@ from werkzeug.security import generate_password_hash, check_password_hash
 import os
 from openai import OpenAI
 from dotenv import load_dotenv
-from create_course2 import create_course, courses_collection, generate_perplexity_response, generate_session_resources, PERPLEXITY_API_KEY, validate_course_plan
+from create_course import create_course, courses_collection, generate_perplexity_response #, generate_session_resources, PERPLEXITY_API_KEY, validate_course_plan
 import json
 from bson import ObjectId
 client = OpenAI(api_key=os.getenv("OPENAI_KEY"))
@@ -234,35 +234,110 @@ def create_session(new_session, course_id):
     return False
 
 
+# def create_session_form(course_id):
+#     """Display form to create a new session and perform the creation operation"""
+#     st.title("Create New Session")
+
+#     if 'session_time' not in st.session_state:
+#         st.session_state.session_time = datetime.now().time()
+#     if 'show_create_session_form' not in st.session_state:
+#         st.session_state.show_create_session_form = False
+
+#     with st.form("create_session_form"):
+#         session_title = st.text_input("Session Title")
+#         session_date = st.date_input("Session Date", date.today(), key="session_date")
+#         session_time = st.time_input(
+#             "Session Time", st.session_state.session_time, key="session_time"
+#         )
+
+#         new_session_id = None
+#         # Generate new session ID
+#         course = courses_collection.find_one({"course_id": course_id})
+#         if course and "sessions" in course and course["sessions"]:
+#             last_session_id = max(
+#                 int(session["session_id"][1:]) for session in course["sessions"]
+#             )
+#             new_session_id = last_session_id + 1
+#         else:
+#             new_session_id = 1
+
+#         if st.form_submit_button("Create Session"):
+#             clicked = True
+#             new_session = {
+#                 "session_id": f"S{new_session_id}",
+#                 "course_id": course_id,
+#                 "title": session_title,
+#                 "date": datetime.combine(session_date, session_time),
+#                 "status": "upcoming",
+#                 "created_at": datetime.utcnow(),
+#                 "pre_class": {
+#                     "resources": [],
+#                     "completetion_required": True,
+#                 },
+#                 "in_class": {
+#                     "topics": [],
+#                     "quiz": {"title": "", "questions": 0, "duration": 0},
+#                     "polls": [],
+#                 },
+#                 "post_class": {
+#                     "assignments": [],
+#                 },
+#             }
+#             courses_collection.update_one(
+#                 {"course_id": course_id}, {"$push": {"sessions": new_session}}
+#             )
+#             st.success("Session created successfully!")
+#             st.session_state.show_create_session_form = False
+
+
 def create_session_form(course_id):
     """Display form to create a new session and perform the creation operation"""
     st.title("Create New Session")
 
-    if 'session_time' not in st.session_state:
+    if "session_time" not in st.session_state:
         st.session_state.session_time = datetime.now().time()
-    if 'show_create_session_form' not in st.session_state:
+
+    if "show_create_session_form" not in st.session_state:
         st.session_state.show_create_session_form = False
 
+    if "outcomes" not in st.session_state:
+        st.session_state.outcomes = []  # List to store outcomes dynamically
+
     with st.form("create_session_form"):
         session_title = st.text_input("Session Title")
         session_date = st.date_input("Session Date", date.today(), key="session_date")
-        session_time = st.time_input(
-            "Session Time", st.session_state.session_time, key="session_time"
-        )
+        session_time = st.time_input("Session Time", st.session_state.session_time, key="session_time")
+
+        st.subheader("Session Learning Outcomes")
+        
+        # Display all outcomes dynamically
+        for idx, outcome in enumerate(st.session_state.outcomes):
+            st.text_input(f"Outcome {idx + 1} Description", key=f"outcome_desc_{idx}")
+            st.selectbox(
+                f"Bloom's Taxonomy Level {idx + 1}",
+                ["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"],
+                key=f"bloom_level_{idx}"
+            )
+
+        # Button to add new outcome fields
+        if st.form_submit_button("Add Outcome"):
+            new_index = len(st.session_state.outcomes)
+            st.session_state.outcomes.append(
+                {"outcome_number": new_index + 1, "outcome_description": "", "bloom_taxanomy_level": ""}
+            )
+            st.rerun()  # Refresh the form to display new fields
 
-        new_session_id = None
         # Generate new session ID
+        new_session_id = None
         course = courses_collection.find_one({"course_id": course_id})
         if course and "sessions" in course and course["sessions"]:
-            last_session_id = max(
-                int(session["session_id"][1:]) for session in course["sessions"]
-            )
+            last_session_id = max(int(session["session_id"][1:]) for session in course["sessions"])
             new_session_id = last_session_id + 1
         else:
             new_session_id = 1
 
+        # Submit session
         if st.form_submit_button("Create Session"):
-            clicked = True
             new_session = {
                 "session_id": f"S{new_session_id}",
                 "course_id": course_id,
@@ -270,24 +345,23 @@ def create_session_form(course_id):
                 "date": datetime.combine(session_date, session_time),
                 "status": "upcoming",
                 "created_at": datetime.utcnow(),
-                "pre_class": {
-                    "resources": [],
-                    "completetion_required": True,
-                },
-                "in_class": {
-                    "topics": [],
-                    "quiz": {"title": "", "questions": 0, "duration": 0},
-                    "polls": [],
-                },
-                "post_class": {
-                    "assignments": [],
-                },
+                "pre_class": {"resources": [], "completetion_required": True},
+                "in_class": {"topics": [], "quiz": {"title": "", "questions": 0, "duration": 0}, "polls": []},
+                "post_class": {"assignments": []},
+                "session_learning_outcomes": [
+                    {
+                        "outcome_number": idx + 1,
+                        "outcome_description": st.session_state[f"outcome_desc_{idx}"],
+                        "bloom_taxanomy_level": st.session_state[f"bloom_level_{idx}"]
+                    }
+                    for idx in range(len(st.session_state.outcomes))
+                ]
             }
-            courses_collection.update_one(
-                {"course_id": course_id}, {"$push": {"sessions": new_session}}
-            )
+            courses_collection.update_one({"course_id": course_id}, {"$push": {"sessions": new_session}})
             st.success("Session created successfully!")
+            st.session_state.outcomes = []  # Clear outcomes after submission
             st.session_state.show_create_session_form = False
+            st.rerun()
 
     #     new_session_id = None
     #     creation_success = False
@@ -924,282 +998,278 @@ def create_course_form(faculty_name, faculty_id):
             with col2:
                 duration_weeks = st.number_input("Duration (weeks)", min_value=1, max_value=16, value=12)
                 start_date = st.date_input("Start Date")
+                course_description = st.text_area("Course Description", placeholder="Enter a brief course description here")
+
             
             generate_button = st.form_submit_button("Generate Course Structure", use_container_width=True)
             
             if generate_button and course_name:
-                with st.spinner("Generating course structure and resources..."):
-                    try:
-                        # Generate course plan with resources
-                        course_plan = generate_perplexity_response(
-                            PERPLEXITY_API_KEY, 
-                            course_name, 
-                            duration_weeks,
-                            sessions_per_week
-                        )
-                        try:
-                            course_plan_json = json.loads(course_plan)
-                            validate_course_plan(course_plan_json)
-                            st.session_state.course_plan = course_plan_json
-                        except (json.JSONDecodeError, ValueError) as e:
-                            st.error(f"Error in course plan structure: {e}")
-                            return
-                        st.session_state.start_date = start_date
-                        st.session_state.duration_weeks = duration_weeks
-                        st.session_state.sessions_per_week = sessions_per_week
+                create_course(course_name, duration_weeks, faculty_name, sessions_per_week, start_date, course_description, faculty_id)
+
+                #update faculty list of courses
+                
+    #             with st.spinner("Generating course structure and resources..."):
+    #                 try:
+    #                     # Generate course plan with resources
+    #                     course_plan = generate_perplexity_response(
+    #                         PERPLEXITY_API_KEY, 
+    #                         course_name, 
+    #                         duration_weeks,
+    #                         sessions_per_week
+    #                     )
+    #                     try:
+    #                         course_plan_json = json.loads(course_plan)
+    #                         validate_course_plan(course_plan_json)
+    #                         st.session_state.course_plan = course_plan_json
+    #                     except (json.JSONDecodeError, ValueError) as e:
+    #                         st.error(f"Error in course plan structure: {e}")
+    #                         return
+    #                     st.session_state.start_date = start_date
+    #                     st.session_state.duration_weeks = duration_weeks
+    #                     st.session_state.sessions_per_week = sessions_per_week
                         
-                        # Generate resources for all sessions
-                        session_titles = []
-                        for module in st.session_state.course_plan['modules']:
-                            for sub_module in module['sub_modules']:
-                                for topic in sub_module['topics']:
-                                    # session_titles.append(topic['title'])
-                                    # session_titles.append(topic)
-                                    if isinstance(topic, dict):
-                                        session_titles.append(topic['title'])
-                                    else:
-                                        session_titles.append(topic)
-                        # In generate_session_resources function, add validation:
-                        if not session_titles:
-                            return json.dumps({"session_resources": []})
-                        resources_response = generate_session_resources(PERPLEXITY_API_KEY, session_titles)
-                        without_backticks = remove_json_backticks(resources_response)
-                        resources = json.loads(without_backticks)
-                        st.session_state.resources_map = {
-                            resource['session_title']: resource['resources']
-                            for resource in resources['session_resources']
-                        }
-                        # Add error handling for the resources map
-                        # if st.session_state.resources_map is None:
-                        #     st.session_state.resources_map = {}
-
-                        st.rerun()
-                    except Exception as e:
-                        st.error(f"Error generating course structure: {e}")
+    #                     # Generate resources for all sessions
+    #                     session_titles = []
+    #                     for module in st.session_state.course_plan['modules']:
+    #                         for sub_module in module['sub_modules']:
+    #                             for topic in sub_module['topics']:
+    #                                 # session_titles.append(topic['title'])
+    #                                 # session_titles.append(topic)
+    #                                 if isinstance(topic, dict):
+    #                                     session_titles.append(topic['title'])
+    #                                 else:
+    #                                     session_titles.append(topic)
+    #                     # In generate_session_resources function, add validation:
+    #                     if not session_titles:
+    #                         return json.dumps({"session_resources": []})
+    #                     resources_response = generate_session_resources(PERPLEXITY_API_KEY, session_titles)
+    #                     without_backticks = remove_json_backticks(resources_response)
+    #                     resources = json.loads(without_backticks)
+    #                     st.session_state.resources_map = {
+    #                         resource['session_title']: resource['resources']
+    #                         for resource in resources['session_resources']
+    #                     }
+    #                     # Add error handling for the resources map
+    #                     # if st.session_state.resources_map is None:
+    #                     #     st.session_state.resources_map = {}
+
+    #                     st.rerun()
+    #                 except Exception as e:
+    #                     st.error(f"Error generating course structure: {e}")
     
-    # Display and Edit Generated Course Content
-    if st.session_state.course_plan:
-        with st.expander("Course Overview", expanded=True):
-            if not st.session_state.edit_mode:
-                st.subheader(st.session_state.course_plan['course_title'])
-                st.write(st.session_state.course_plan['course_description'])
-                col1, col2, col3 = st.columns(3)
-                with col1:
-                    st.write(f"**Start Date:** {st.session_state.start_date}")
-                with col2:
-                    st.write(f"**Duration (weeks):** {st.session_state.duration_weeks}")
-                with col3:
-                    st.write(f"**Sessions Per Week:** {st.session_state.sessions_per_week}")
-
-                edit_button = st.button("Edit Course Details", use_container_width=True)
-                if edit_button:
-                    st.session_state.edit_mode = True
-                    st.rerun()
-            else:
-                with st.form("edit_course_details"):
-                    st.session_state.course_plan['course_title'] = st.text_input(
-                        "Course Title", 
-                        value=st.session_state.course_plan['course_title']
-                    )
-                    st.session_state.course_plan['course_description'] = st.text_area(
-                        "Course Description", 
-                        value=st.session_state.course_plan['course_description']
-                    )
-                    if st.form_submit_button("Save Course Details"):
-                        st.session_state.edit_mode = False
-                        st.rerun()
+    # # Display and Edit Generated Course Content
+    # if st.session_state.course_plan:
+    #     with st.expander("Course Overview", expanded=True):
+    #         if not st.session_state.edit_mode:
+    #             st.subheader(st.session_state.course_plan['course_title'])
+    #             st.write(st.session_state.course_plan['course_description'])
+    #             col1, col2, col3 = st.columns(3)
+    #             with col1:
+    #                 st.write(f"**Start Date:** {st.session_state.start_date}")
+    #             with col2:
+    #                 st.write(f"**Duration (weeks):** {st.session_state.duration_weeks}")
+    #             with col3:
+    #                 st.write(f"**Sessions Per Week:** {st.session_state.sessions_per_week}")
+
+    #             edit_button = st.button("Edit Course Details", use_container_width=True)
+    #             if edit_button:
+    #                 st.session_state.edit_mode = True
+    #                 st.rerun()
+    #         else:
+    #             with st.form("edit_course_details"):
+    #                 st.session_state.course_plan['course_title'] = st.text_input(
+    #                     "Course Title", 
+    #                     value=st.session_state.course_plan['course_title']
+    #                 )
+    #                 st.session_state.course_plan['course_description'] = st.text_area(
+    #                     "Course Description", 
+    #                     value=st.session_state.course_plan['course_description']
+    #                 )
+    #                 if st.form_submit_button("Save Course Details"):
+    #                     st.session_state.edit_mode = False
+    #                     st.rerun()
         
-        # Display Modules and Sessions
-        st.subheader("Course Modules and Sessions")
+    #     # Display Modules and Sessions
+    #     st.subheader("Course Modules and Sessions")
         
-        start_date = st.session_state.start_date
-        current_date = start_date
+    #     start_date = st.session_state.start_date
+    #     current_date = start_date
         
-        all_sessions = []
-        for module_idx, module in enumerate(st.session_state.course_plan['modules']):
-            with st.expander(f"📚 Module {module_idx + 1}: {module['module_title']}", expanded=True):
-                # Edit module title
-                new_module_title = st.text_input(
-                    f"Edit Module Title",
-                    value=module['module_title'],
-                    key=f"module_{module_idx}"
-                )
-                module['module_title'] = new_module_title
+    #     all_sessions = []
+    #     for module_idx, module in enumerate(st.session_state.course_plan['modules']):
+    #         with st.expander(f"📚 Module {module_idx + 1}: {module['module_title']}", expanded=True):
+    #             # Edit module title
+    #             new_module_title = st.text_input(
+    #                 f"Edit Module Title",
+    #                 value=module['module_title'],
+    #                 key=f"module_{module_idx}"
+    #             )
+    #             module['module_title'] = new_module_title
                 
-                for sub_idx, sub_module in enumerate(module['sub_modules']):
-                    st.markdown("<br>", unsafe_allow_html=True)  # Add gap between sessions
-                    # st.markdown(f"### 📖 {sub_module['title']}")
-                    st.markdown(f'<h3 style="font-size: 1.25rem;">📖 Chapter {sub_idx + 1}: {sub_module["title"]}</h3>', unsafe_allow_html=True)
-                    # Possible fix: 
-                    # Inside the loop where topics are being processed:
-
-                    for topic_idx, topic in enumerate(sub_module['topics']):
-                        st.markdown("<br>", unsafe_allow_html=True)  # Add gap between sessions
-                        session_key = f"session_{module_idx}_{sub_idx}_{topic_idx}"
+    #             for sub_idx, sub_module in enumerate(module['sub_modules']):
+    #                 st.markdown("<br>", unsafe_allow_html=True)  # Add gap between sessions
+    #                 # st.markdown(f"### 📖 {sub_module['title']}")
+    #                 st.markdown(f'<h3 style="font-size: 1.25rem;">📖 Chapter {sub_idx + 1}: {sub_module["title"]}</h3>', unsafe_allow_html=True)
+    #                 # Possible fix: 
+    #                 # Inside the loop where topics are being processed:
+
+    #                 for topic_idx, topic in enumerate(sub_module['topics']):
+    #                     st.markdown("<br>", unsafe_allow_html=True)  # Add gap between sessions
+    #                     session_key = f"session_{module_idx}_{sub_idx}_{topic_idx}"
                         
-                        # Get topic title based on type
-                        if isinstance(topic, dict):
-                            current_topic_title = topic.get('title', '')
-                            current_topic_display = current_topic_title
-                        else:
-                            current_topic_title = str(topic)
-                            current_topic_display = current_topic_title
-
-                        with st.container():
-                            # Session Details
-                            col1, col2, col3 = st.columns([3, 2, 1])
-                            with col1:
-                                new_topic = st.text_input(
-                                    f"Session {topic_idx + 1} Title",
-                                    value=current_topic_display,
-                                    key=f"{session_key}_topic"
-                                )
-                                # Update the topic in the data structure
-                                if isinstance(topic, dict):
-                                    topic['title'] = new_topic
-                                else:
-                                    sub_module['topics'][topic_idx] = new_topic
+    #                     # Get topic title based on type
+    #                     if isinstance(topic, dict):
+    #                         current_topic_title = topic.get('title', '')
+    #                         current_topic_display = current_topic_title
+    #                     else:
+    #                         current_topic_title = str(topic)
+    #                         current_topic_display = current_topic_title
+
+    #                     with st.container():
+    #                         # Session Details
+    #                         col1, col2, col3 = st.columns([3, 2, 1])
+    #                         with col1:
+    #                             new_topic = st.text_input(
+    #                                 f"Session {topic_idx + 1} Title",
+    #                                 value=current_topic_display,
+    #                                 key=f"{session_key}_topic"
+    #                             )
+    #                             # Update the topic in the data structure
+    #                             if isinstance(topic, dict):
+    #                                 topic['title'] = new_topic
+    #                             else:
+    #                                 sub_module['topics'][topic_idx] = new_topic
                             
-                            with col2:
-                                session_date = st.date_input(
-                                    "Session Date",
-                                    value=current_date,
-                                    key=f"{session_key}_date"
-                                )
+    #                         with col2:
+    #                             session_date = st.date_input(
+    #                                 "Session Date",
+    #                                 value=current_date,
+    #                                 key=f"{session_key}_date"
+    #                             )
                             
-                            with col3:
-                                session_status = st.selectbox(
-                                    "Status",
-                                    options=["upcoming", "in-progress", "completed"],
-                                    key=f"{session_key}_status"
-                                )
+    #                         with col3:
+    #                             session_status = st.selectbox(
+    #                                 "Status",
+    #                                 options=["upcoming", "in-progress", "completed"],
+    #                                 key=f"{session_key}_status"
+    #                             )
                             
-                            # Display Resources
-                            if st.session_state.resources_map:
-                                # Try both the full topic title and the display title
-                                resources = None
-                                if isinstance(topic, dict) and topic.get('title') in st.session_state.resources_map:
-                                    resources = st.session_state.resources_map[topic['title']]
-                                elif current_topic_title in st.session_state.resources_map:
-                                    resources = st.session_state.resources_map[current_topic_title]
+    #                         # Display Resources
+    #                         if st.session_state.resources_map:
+    #                             # Try both the full topic title and the display title
+    #                             resources = None
+    #                             if isinstance(topic, dict) and topic.get('title') in st.session_state.resources_map:
+    #                                 resources = st.session_state.resources_map[topic['title']]
+    #                             elif current_topic_title in st.session_state.resources_map:
+    #                                 resources = st.session_state.resources_map[current_topic_title]
                                 
-                                if resources:
-                                    with st.container():
-                                        # st.markdown("#### 📚 Session Resources")
-                                        st.markdown(f'<h4 style="font-size: 1.25rem;">📚 Session Resources</h4>', unsafe_allow_html=True)
-                                        # Readings Tab
-                                        if resources.get('readings'):
-                                            st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">📖 External Resources</h5>', unsafe_allow_html=True)
-                                            col1, col2 = st.columns(2)
-                                            for idx, reading in enumerate(resources['readings']):
-                                                with col1 if idx % 2 == 0 else col2:
-                                                    st.markdown(f"""
-                                                        - **{reading['title']}**
-                                                        - Type: {reading['type']}
-                                                        - Estimated reading time: {reading['estimated_read_time']}
-                                                        - [Access Resource]({reading['url']})
-                                                    """)
+    #                             if resources:
+    #                                 with st.container():
+    #                                     # st.markdown("#### 📚 Session Resources")
+    #                                     st.markdown(f'<h4 style="font-size: 1.25rem;">📚 Session Resources</h4>', unsafe_allow_html=True)
+    #                                     # Readings Tab
+    #                                     if resources.get('readings'):
+    #                                         st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">📖 External Resources</h5>', unsafe_allow_html=True)
+    #                                         col1, col2 = st.columns(2)
+    #                                         for idx, reading in enumerate(resources['readings']):
+    #                                             with col1 if idx % 2 == 0 else col2:
+    #                                                 st.markdown(f"""
+    #                                                     - **{reading['title']}**
+    #                                                     - Type: {reading['type']}
+    #                                                     - Estimated reading time: {reading['estimated_read_time']}
+    #                                                     - [Access Resource]({reading['url']})
+    #                                                 """)
                                         
-                                        # Books Tab and Additional Resources Tab side-by-side
-                                        col1, col2 = st.columns(2)
+    #                                     # Books Tab and Additional Resources Tab side-by-side
+    #                                     col1, col2 = st.columns(2)
                                         
-                                        with col1:
-                                            if resources.get('books'):
-                                                st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">📚 Reference Books</h5>', unsafe_allow_html=True)
-                                                for book in resources['books']:
-                                                    with st.container():
-                                                        st.markdown(f"""
-                                                            - **{book['title']}**
-                                                            - Author: {book['author']}
-                                                            - ISBN: {book['isbn']}
-                                                            - Chapters: {book['chapters']}
-                                                        """)
+    #                                     with col1:
+    #                                         if resources.get('books'):
+    #                                             st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">📚 Reference Books</h5>', unsafe_allow_html=True)
+    #                                             for book in resources['books']:
+    #                                                 with st.container():
+    #                                                     st.markdown(f"""
+    #                                                         - **{book['title']}**
+    #                                                         - Author: {book['author']}
+    #                                                         - ISBN: {book['isbn']}
+    #                                                         - Chapters: {book['chapters']}
+    #                                                     """)
                                         
-                                        with col2:
-                                            if resources.get('additional_resources'):
-                                                st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">🔗 Additional Study Resources</h5>', unsafe_allow_html=True)
-                                                for resource in resources['additional_resources']:
-                                                    with st.container():
-                                                        st.markdown(f"""
-                                                            - **{resource['title']}**
-                                                            - Type: {resource['type']}
-                                                            - Description: {resource['description']}
-                                                            - [Access Resource]({resource['url']})
-                                                        """)
+    #                                     with col2:
+    #                                         if resources.get('additional_resources'):
+    #                                             st.markdown(f'<h5 style="font-size: 1.1rem; margin-top: 1rem;">🔗 Additional Study Resources</h5>', unsafe_allow_html=True)
+    #                                             for resource in resources['additional_resources']:
+    #                                                 with st.container():
+    #                                                     st.markdown(f"""
+    #                                                         - **{resource['title']}**
+    #                                                         - Type: {resource['type']}
+    #                                                         - Description: {resource['description']}
+    #                                                         - [Access Resource]({resource['url']})
+    #                                                     """)
                             
-                            # Create session object
-                            session = {
-                                "session_id": str(ObjectId()),
-                                "title": new_topic,
-                                "date": datetime.combine(session_date, datetime.min.time()),
-                                "status": session_status,
-                                "module_name": module['module_title'],
-                                "created_at": datetime.utcnow(),
-                                "pre_class": {
-                                    "resources": [],
-                                    "completion_required": True
-                                },
-                                "in_class": {
-                                    "quiz": [],
-                                    "polls": []
-                                },
-                                "post_class": {
-                                    "assignments": []
-                                },
-                                "external_resources": st.session_state.resources_map.get(current_topic_title, {})
-                            }
-                            all_sessions.append(session)
-                            current_date = session_date + timedelta(days=7)
+    #                         # Create session object
+    #                         session = {
+    #                             "session_id": str(ObjectId()),
+    #                             "title": new_topic,
+    #                             "date": datetime.combine(session_date, datetime.min.time()),
+    #                             "status": session_status,
+    #                             "module_name": module['module_title'],
+    #                             "created_at": datetime.utcnow(),
+    #                             "pre_class": {
+    #                                 "resources": [],
+    #                                 "completion_required": True
+    #                             },
+    #                             "in_class": {
+    #                                 "quiz": [],
+    #                                 "polls": []
+    #                             },
+    #                             "post_class": {
+    #                                 "assignments": []
+    #                             },
+    #                             "external_resources": st.session_state.resources_map.get(current_topic_title, {})
+    #                         }
+    #                         all_sessions.append(session)
+    #                         current_date = session_date + timedelta(days=7)
                         
 
-        new_course_id = get_new_course_id()
-        course_title = st.session_state.course_plan['course_title']
-
-        # Final Save Button
-    if st.button("Save Course", type="primary", use_container_width=True):
-        try:
-            course_doc = {
-                "course_id": new_course_id,
-                "title": course_title,
-                "description": st.session_state.course_plan['course_description'],
-                "faculty": faculty_name,
-                "faculty_id": faculty_id,
-                "duration": f"{st.session_state.duration_weeks} weeks",
-                "sessions_per_week": st.session_state.sessions_per_week,
-                "start_date": datetime.combine(st.session_state.start_date, datetime.min.time()),
-                "created_at": datetime.utcnow(),
-                "sessions": all_sessions
-            }
+    #     new_course_id = get_new_course_id()
+    #     course_title = st.session_state.course_plan['course_title']
+
+    #     # Final Save Button
+    # if st.button("Save Course", type="primary", use_container_width=True):
+    #     try:
+    #         course_doc = {
+    #             "course_id": new_course_id,
+    #             "title": course_title,
+    #             "description": st.session_state.course_plan['course_description'],
+    #             "faculty": faculty_name,
+    #             "faculty_id": faculty_id,
+    #             "duration": f"{st.session_state.duration_weeks} weeks",
+    #             "sessions_per_week": st.session_state.sessions_per_week,
+    #             "start_date": datetime.combine(st.session_state.start_date, datetime.min.time()),
+    #             "created_at": datetime.utcnow(),
+    #             "sessions": all_sessions
+    #         }
             
-            # Insert into database
-            courses_collection.insert_one(course_doc)
-            st.success("Course successfully created!")
+    #         # Insert into database
+    #         courses_collection.insert_one(course_doc)
+    #         st.success("Course successfully created!")
 
-            # Update faculty collection
-            faculty_collection.update_one(
-                {"_id": st.session_state.user_id},
-                {
-                    "$push": {
-                        "courses_taught": {
-                            "course_id": new_course_id,
-                            "title": course_title,
-                        }
-                    }
-                }
-            )
+    #         # Update faculty collection
+            
 
-            # Clear session state
-            st.session_state.course_plan = None
-            st.session_state.edit_mode = False
-            st.session_state.resources_map = {}
+    #         # Clear session state
+    #         st.session_state.course_plan = None
+    #         st.session_state.edit_mode = False
+    #         st.session_state.resources_map = {}
             
-            # Optional: Add a button to view the created course
-            if st.button("View Course"):
-                # Add navigation logic here
-                pass
+    #         # Optional: Add a button to view the created course
+    #         if st.button("View Course"):
+    #             # Add navigation logic here
+    #             pass
             
-        except Exception as e:
-            st.error(f"Error saving course: {e}")
+    #     except Exception as e:
+    #         st.error(f"Error saving course: {e}")
 
 
 

create_course.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, date
 import os
 from typing import Dict, List, Any
 from pymongo import MongoClient
@@ -19,6 +19,7 @@ OPENAI_API_KEY = os.getenv("OPENAI_KEY")
 client = MongoClient(MONGODB_URI)
 db = client['novascholar_db']
 courses_collection = db['courses']
+faculty_collection = db['faculty']
 
 def generate_perplexity_response(api_key, course_name):
         headers = {
@@ -118,7 +119,7 @@ def get_new_course_id():
     return new_course_id
 
 
-def create_course(course_name, start_date, duration_weeks):
+def create_course_perplexity(course_name, start_date, duration_weeks):
         # Generate course overview
         # overview_prompt = f"""Generate an overview for the undergraduate course {course_name} 
         # Include all relevant concepts and key topics covered in a typical curriculum. 
@@ -246,6 +247,58 @@ def create_course(course_name, start_date, duration_weeks):
 
         # print(course_plan)
 
+
+def create_course(course_name, duration_weeks, faculty_name, sessions_per_week, start_date: date, course_description, faculty_id):
+    """
+    Create a course document in the desired JSON format and insert it into MongoDB.
+    """
+    try:
+        # Count sessions
+        # st.write("Number of sessions:", len(all_sessions)
+
+        # Generate a new course ID
+        course_id = get_new_course_id()
+
+        if isinstance(start_date, date):
+            start_date = datetime.combine(start_date, datetime.min.time())
+        
+        # Create the course document
+        course_doc = {
+            "_id": ObjectId(),
+            "course_id": course_id,  # Assumes there's a helper function in your code
+            "title": course_name,
+            "description": course_description,
+            "faculty": faculty_name,
+            "faculty_id": faculty_id,
+            "duration": f"{duration_weeks} weeks",
+            "sessions_per_week": sessions_per_week,
+            "start_date": start_date,
+            "created_at": datetime.utcnow(),
+        }
+        
+        # Insert into MongoDB
+        courses_collection.insert_one(course_doc)
+
+        faculty_collection.update_one(
+                {"_id": st.session_state.user_id},
+                    {
+                    "$push": {
+                        "courses_taught": {
+                            "course_id": course_id,
+                            "title": course_name,
+                                        }
+                            }
+                    }
+                )
+
+        st.success("Course created successfully!")
+        # st.json(course_doc)
+        return course_doc
+    except Exception as e:
+        st.error(f"Failed to insert course data into the database: {e}")
+        return None
+    
+
 def create_session(title: str, date: datetime, module_name: str):
         """Create a session document with pre-class, in-class, and post-class components."""
         return {

live_polls.py

@@ -9,7 +9,7 @@ class LivePollFeature:
     def __init__(self):
         self.db = PollDatabase()
     
-    def display_faculty_interface(self, session_id):
+    def display_faculty_interface(self, session_id, course_id):
         """Display the faculty interface for managing polls"""
         st.markdown("#### Live Polls Management")
         
@@ -31,6 +31,8 @@ class LivePollFeature:
             
             if st.button("Create Poll") and question and len(options) >= 2:
                 self.db.create_poll(
+                    course_id,
+                    # course_id,
                     st.session_state.selected_course,
                     session_id,
                     question,
@@ -41,7 +43,7 @@ class LivePollFeature:
                 st.rerun()
         
         # Display active polls
-        active_polls = self.db.get_active_polls(session_id)
+        active_polls = self.db.get_active_polls(session_id, course_id)
         if active_polls:
             st.subheader("Active Polls")
             for poll in active_polls:
@@ -55,11 +57,11 @@ class LivePollFeature:
                         st.success("Poll closed successfully!")
                         st.rerun()
     
-    def display_student_interface(self, session_id):
+    def display_student_interface(self, session_id, course_id):
         """Display the student interface for participating in polls"""
         st.subheader("Live Polls")
         
-        active_polls = self.db.get_active_polls(session_id)
+        active_polls = self.db.get_active_polls(session_id, course_id)
         if not active_polls:
             st.info("No active polls at the moment.")
             return

poll_db_operations.py

@@ -11,10 +11,11 @@ class PollDatabase:
         self.client = MongoClient(MONGO_URI)
         self.db = self.client["novascholar_db"]
     
-    def create_poll(self, course_id, session_id, question, options, faculty_id):
+    def create_poll(self, course_id, course_name, session_id, question, options, faculty_id):
         """Create a new poll"""
         poll = {
             "course_id": course_id,
+            "course_name": course_name,
             "session_id": session_id,
             "faculty_id": faculty_id,
             "question": question,
@@ -25,10 +26,11 @@ class PollDatabase:
         }
         return self.db.polls.insert_one(poll)
     
-    def get_active_polls(self, session_id):
+    def get_active_polls(self, session_id, course_id):
         """Get all active polls for a session"""
         return list(self.db.polls.find({
             "session_id": session_id,
+            "course_id": course_id,
             "status": "active"
         }))
     

session_page.py

@@ -155,7 +155,8 @@ def display_preclass_content(session, student_id, course_id):
     """Display pre-class materials for a session including external resources"""
     st.subheader("Pre-class Materials")
     print("Session ID is: ", session['session_id'])
-    
+    print(course_id)
+
     # Display uploaded materials
     materials = resources_collection.find({"session_id": session['session_id']})
     
@@ -725,6 +726,7 @@ def display_preclass_content(session, student_id, course_id):
             if not quiz:
                 st.info("No practice quizzes created.")
             else:
+                display_quiz_tab(student_id, course_id, session['session_id'])
                 with st.expander(f"📝 Practice Quiz", expanded=True):
                     existing_score = get_student_quiz_score(quiz['_id'], student_id)
                     
@@ -1359,7 +1361,7 @@ def upload_preclass_materials(session, session_id, course_id, student_id):
         # Display pre-class materials
         # Group resources by their types
         grouped_resources = defaultdict(list)
-        materials = resources_collection.find({"session_id": session_id})
+        materials = resources_collection.find({"session_id": session_id, "course_id": course_id})
         for material in materials:
             grouped_resources[material['material_type']].append(material)
 
@@ -2557,13 +2559,13 @@ def display_in_class_content(session, user_type, course_id, user_id):
     
     # Display appropriate interface based on user role
     if user_type == 'faculty':
-        live_polls.display_faculty_interface(session['session_id'])
+        live_polls.display_faculty_interface(session['session_id'], course_id)
     else:
-        live_polls.display_student_interface(session['session_id'])
+        live_polls.display_student_interface(session['session_id'], course_id)
     
     display_live_chat_interface(session, user_id, course_id=course_id)
 
-    # Live Presentation Feature
+    # Live Presentation Featurer
     display_live_presentation(session, user_type, course_id)
 
 def get_current_context(session):
@@ -3853,6 +3855,7 @@ def display_quiz_tab(student_id, course_id, session_id):
     #     "quiz_type": {"$ne": "pre_class"}
     # })
     quizzes = list(quizzes_collection.find({
+        "user_id": ObjectId(student_id),
         "course_id": course_id,
         "session_id": session_id,
         "status": "active",