Harshal Vhatkar
Merge branch 'main' of https://huggingface.co/spaces/SPJIMR-Internship/SPJIMR_FlipClassroom_RCopilot_ResearchInternship
7e06d5a
| import re | |
| from pymongo import MongoClient | |
| import streamlit as st | |
| from datetime import datetime, date, time, timedelta | |
| from pathlib import Path | |
| from utils.sample_data import SAMPLE_COURSES, SAMPLE_SESSIONS | |
| # from session_page_alt import display_session_content | |
| from session_page import display_session_content | |
| from db import ( | |
| courses_collection2, | |
| faculty_collection, | |
| students_collection, | |
| research_assistants_collection, | |
| analysts_collection, | |
| ) | |
| from werkzeug.security import generate_password_hash, check_password_hash | |
| import os | |
| from openai import OpenAI | |
| from dotenv import load_dotenv | |
| 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")) | |
| from dotenv import load_dotenv | |
| from code_playground import display_code_playground | |
| load_dotenv() | |
| # PERPLEXITY_API_KEY = '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' | |
| def get_research_papers(query): | |
| """Get research paper recommendations based on query""" | |
| try: | |
| response = client.chat.completions.create( | |
| model="gpt-3.5-turbo", | |
| messages=[ | |
| { | |
| "role": "system", | |
| "content": "You are a helpful research assistant. Provide 10 relevant research papers with titles, authors, brief descriptions, and DOI/URL links. Format each paper as: \n\n1. **Title**\nAuthors: [names]\nLink: [DOI/URL]\nDescription: [brief summary]", | |
| }, | |
| { | |
| "role": "user", | |
| "content": f"Give me 10 research papers about: {query}. Include valid DOI links or URLs to the papers where available.", | |
| }, | |
| ], | |
| ) | |
| return response.choices[0].message.content | |
| except Exception as e: | |
| return f"Error getting recommendations: {str(e)}" | |
| def analyze_research_gaps(papers): | |
| """Analyze gaps in research based on recommended papers""" | |
| try: | |
| response = client.chat.completions.create( | |
| model="gpt-3.5-turbo", | |
| messages=[ | |
| { | |
| "role": "system", | |
| "content": "You are a research analysis expert. Based on the provided papers, identify potential research gaps and future research directions.", | |
| }, | |
| { | |
| "role": "user", | |
| "content": f"Based on these papers, what are the key areas that need more research?\n\nPapers:\n{papers}", | |
| }, | |
| ], | |
| ) | |
| return response.choices[0].message.content | |
| except Exception as e: | |
| return f"Error analyzing research gaps: {str(e)}" | |
| 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: | |
| st.session_state.username = None | |
| if "selected_course" not in st.session_state: | |
| st.session_state.selected_course = None | |
| if "show_create_course_form" not in st.session_state: | |
| st.session_state.show_create_course_form = False | |
| if "show_create_session_form" not in st.session_state: | |
| st.session_state.show_create_session_form = False | |
| if "show_enroll_course_page" not in st.session_state: | |
| st.session_state.show_enroll_course_page = False | |
| if "course_to_enroll" not in st.session_state: | |
| st.session_state.course_to_enroll = None | |
| def login_user(username, password, user_type): | |
| """Login user based on credentials""" | |
| if user_type == "student": | |
| # user = students_collection.find_one({"full_name": username}) or students_collection.find_one({"username": username}) | |
| user = students_collection.find_one({"$or": [{"full_name": username}, {"username": username}]}) | |
| elif user_type == "faculty": | |
| user = faculty_collection.find_one({"$or": [{"full_name": username}, {"username": username}]}) | |
| elif user_type == "research_assistant": | |
| user = research_assistants_collection.find_one({"full_name": username}) | |
| elif user_type == "analyst": | |
| user = analysts_collection.find_one({"full_name": username}) | |
| if user and check_password_hash(user["password"], password): | |
| st.session_state.user_id = user["_id"] | |
| print(st.session_state.user_id) | |
| st.session_state.authenticated = True | |
| st.session_state.user_type = user_type | |
| st.session_state.username = username | |
| return True | |
| return False | |
| # def login_form(): | |
| # """Display login form""" | |
| # st.title("Welcome to NOVAScholar") | |
| # with st.form("login_form"): | |
| # user_type = st.selectbox( | |
| # "Please select your Role", ["student", "faculty", "research_assistant", "analyst"] | |
| # ) | |
| # username = st.text_input("Username") | |
| # password = st.text_input("Password", type="password") | |
| # submit = st.form_submit_button("Login") | |
| # if submit: | |
| # if login_user(username, password, user_type): | |
| # st.success("Login successful!") | |
| # st.rerun() | |
| # else: | |
| # st.error("Invalid credentials!") | |
| def login_form(): | |
| """Display enhanced login form""" | |
| st.title("Welcome to NOVAScholar") | |
| with st.form("login_form"): | |
| # Role selection at the top | |
| user_type = st.selectbox( | |
| "Please select your Role", | |
| ["Student", "Faculty", "Research Assistant", "Analyst"] | |
| ) | |
| user_type = user_type.lower().replace(" ", "_") | |
| # Username/email and password stacked vertically | |
| username = st.text_input("Username or Email") | |
| password = st.text_input("Password", type="password") | |
| # Login button | |
| submit = st.form_submit_button("Login") | |
| if submit: | |
| # Handle both username and email login | |
| if '@' in username: | |
| username = extract_username(username) | |
| if login_user(username, password, user_type): | |
| st.success("Login successful!") | |
| st.rerun() | |
| else: | |
| st.error("Invalid credentials!") | |
| def get_courses(username, user_type): | |
| if user_type == "student": | |
| student = students_collection.find_one({"$or": [{"full_name": username}, {"username": username}]}) | |
| if student: | |
| enrolled_course_ids = [ | |
| course["course_id"] for course in student.get("enrolled_courses", []) | |
| ] | |
| courses = courses_collection.find( | |
| {"course_id": {"$in": enrolled_course_ids}} | |
| ) | |
| # courses += courses_collection2.find( | |
| # {"course_id": {"$in": enrolled_course_ids}} | |
| # ) | |
| # # course_titles = [course['title'] for course in courses] | |
| # return list(courses) | |
| # courses_cursor1 = courses_collection.find( | |
| # {"course_id": {"$in": enrolled_course_ids}} | |
| # ) | |
| # courses_cursor2 = courses_collection2.find( | |
| # {"course_id": {"$in": enrolled_course_ids}} | |
| # ) | |
| # courses = list(courses_cursor1) + list(courses_cursor2) | |
| return list(courses) | |
| elif user_type == "faculty": | |
| faculty = faculty_collection.find_one({"$or": [{"full_name": username}, {"username": username}]}) | |
| if faculty: | |
| course_ids = [ | |
| course["course_id"] for course in faculty.get("courses_taught", []) | |
| ] | |
| # courses_1 = list(courses_collection2.find({"course_id": {"$in": course_ids}})) | |
| courses_2 = list(courses_collection.find({"course_id": {"$in": course_ids}})) | |
| return courses_2 | |
| elif user_type == "research_assistant": | |
| research_assistant = research_assistants_collection.find_one( | |
| {"full_name": username} | |
| ) | |
| if research_assistant: | |
| course_ids = [ | |
| course["course_id"] | |
| for course in research_assistant.get("courses_assisted", []) | |
| ] | |
| courses = courses_collection2.find({"course_id": {"$in": course_ids}}) | |
| return list(courses) | |
| else: | |
| return [] | |
| def get_course_ids(): | |
| """Get course IDs for sample courses""" | |
| return [course["course_id"] for course in SAMPLE_COURSES] | |
| def get_sessions(course_id, course_title): | |
| """Get sessions for a given course ID""" | |
| course = courses_collection.find_one({"course_id": course_id, "title": course_title}) | |
| if course: | |
| return course.get("sessions", []) | |
| return [] | |
| def create_session(new_session, course_id): | |
| """Create a new session for a given course ID""" | |
| course = courses_collection2.find_one({"course_id": course_id}) | courses_collection.find_one({"course_id": course_id}) | |
| if course: | |
| last_session_id = max((session["session_id"] for session in course["sessions"])) | |
| last_session_id = int(last_session_id[1:]) | |
| new_session_id = last_session_id + 1 | |
| new_session["session_id"] = "S" + str(new_session_id) | |
| courses_collection.update_one( | |
| {"course_id": new_session["course_id"]}, | |
| {"$push": {"sessions": new_session}}, | |
| ) | |
| return True | |
| 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: | |
| 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 | |
| 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") | |
| 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 | |
| # 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"]) | |
| new_session_id = last_session_id + 1 | |
| else: | |
| new_session_id = 1 | |
| # Submit session | |
| if st.form_submit_button("Create Session"): | |
| 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": []}, | |
| "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}}) | |
| 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 | |
| # # Generate new session ID | |
| # course = courses_collection2.find_one({"course_id": course_id}) | |
| # if course and 'sessions' in course and course['sessions']: | |
| # last_session_id = max((session['session_id'] for session in course['sessions'])) | |
| # last_session_id = int(last_session_id[1:]) | |
| # new_session_id = last_session_id + 1 | |
| # else: | |
| # new_session_id = 1 | |
| # new_session = { | |
| # "session_id": 'S' + new_session_id, | |
| # "title": session_title, | |
| # "date": datetime.datetime.combine(session_date, session_time).isoformat(), | |
| # "status": "upcoming", | |
| # "created_at": datetime.datetime.utcnow().isoformat(), | |
| # "pre_class": { | |
| # "resources": [], | |
| # "completetion_required": True, | |
| # }, | |
| # "in_class": { | |
| # "topics": [], | |
| # "quiz": | |
| # { | |
| # "title": '', | |
| # "questions": 0, | |
| # "duration": 0 | |
| # }, | |
| # "polls": [] | |
| # }, | |
| # "post_class": { | |
| # "assignments": [], | |
| # } | |
| # } | |
| # courses_collection2.update_one( | |
| # {"course_id": course_id}, | |
| # {"$push": {"sessions": new_session}} | |
| # ) | |
| # creation_success = True | |
| # st.form_submit_button("Create Session") | |
| # if creation_success == True: | |
| # st.success("Session created successfully!") | |
| # else: | |
| load_dotenv() | |
| MONGO_URI = os.getenv('MONGO_URI') | |
| client = MongoClient(MONGO_URI) | |
| db = client["novascholar_db"] | |
| subjective_tests_collection = db["subjective_tests"] | |
| resources_collection = db['resources'] | |
| quizzes_collection = db['quizzes'] | |
| chat_history_collection = db['chat_history'] | |
| polls_collection = db['polls'] | |
| def delete_session(course_id: str, session_id: str) -> bool: | |
| """Delete a session and all its associated data""" | |
| try: | |
| # Delete all resources for this session | |
| resources_collection.delete_many({ | |
| "course_id": course_id, | |
| "session_id": session_id | |
| }) | |
| # Delete all quizzes for this session | |
| quizzes_collection.delete_many({ | |
| "course_id": course_id, | |
| "session_id": session_id | |
| }) | |
| # Delete all subjective tests | |
| subjective_tests_collection.delete_many({ | |
| "course_id": course_id, | |
| "session_id": session_id | |
| }) | |
| # Delete chat history | |
| chat_history_collection.delete_many({ | |
| "course_id": course_id, | |
| "session_id": session_id | |
| }) | |
| # Delete session polls | |
| polls_collection.delete_many({ | |
| "course_id": course_id, | |
| "session_id": session_id | |
| }) | |
| # Finally remove session from course | |
| result = courses_collection.update_one( | |
| {"course_id": course_id}, | |
| {"$pull": {"sessions": {"session_id": session_id}}} | |
| ) | |
| return result.modified_count > 0 | |
| except Exception as e: | |
| print(f"Error deleting session: {e}") | |
| return False | |
| def get_new_student_id(): | |
| """Generate a new student ID by incrementing the last student ID""" | |
| last_student = students_collection.find_one(sort=[("SID", -1)]) | |
| if last_student: | |
| last_student_id = int(last_student["SID"][1:]) | |
| new_student_id = f"S{last_student_id + 1}" | |
| else: | |
| new_student_id = "S101" | |
| return new_student_id | |
| def get_new_faculty_id(): | |
| """Generate a new faculty ID by incrementing the last faculty ID""" | |
| last_faculty = faculty_collection.find_one(sort=[("TID", -1)]) | |
| if last_faculty: | |
| last_faculty_id = int(last_faculty["TID"][1:]) | |
| new_faculty_id = f"T{last_faculty_id + 1}" | |
| else: | |
| new_faculty_id = "T101" | |
| return new_faculty_id | |
| def get_new_course_id(): | |
| """Generate a new course ID by incrementing the last course ID""" | |
| last_course = courses_collection2.find_one(sort=[("course_id", -1)]) | |
| if last_course: | |
| last_course_id = int(last_course["course_id"][2:]) | |
| new_course_id = f"CS{last_course_id + 1}" | |
| else: | |
| new_course_id = "CS101" | |
| return new_course_id | |
| # def register_page(): | |
| # st.title("Register") | |
| # if "user_type" not in st.session_state: | |
| # st.session_state.user_type = "student" | |
| # # Select user type | |
| # st.session_state.user_type = st.selectbox( | |
| # "Select User Type", ["student", "faculty", "research_assistant"] | |
| # ) | |
| # user_type = st.session_state.user_type | |
| # print(user_type) | |
| # with st.form("register_form"): | |
| # # user_type = st.selectbox("Select User Type", ["student", "faculty", "research_assistant"]) | |
| # # print(user_type) | |
| # full_name = st.text_input("Full Name") | |
| # password = st.text_input("Password", type="password") | |
| # confirm_password = st.text_input("Confirm Password", type="password") | |
| # if user_type == "student": | |
| # # Fetch courses for students to select from | |
| # courses = list(courses_collection2.find({}, {"course_id": 1, "title": 1})) | |
| # course_options = [ | |
| # f"{course['title']} ({course['course_id']})" for course in courses | |
| # ] | |
| # selected_courses = st.multiselect("Available Courses", course_options) | |
| # submit = st.form_submit_button("Register") | |
| # if submit: | |
| # if password == confirm_password: | |
| # hashed_password = generate_password_hash(password) | |
| # if user_type == "student": | |
| # new_student_id = get_new_student_id() | |
| # enrolled_courses = [ | |
| # { | |
| # "course_id": course.split("(")[-1][:-1], | |
| # "title": course.split(" (")[0], | |
| # } | |
| # for course in selected_courses | |
| # ] | |
| # students_collection.insert_one( | |
| # { | |
| # "SID": new_student_id, | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "enrolled_courses": enrolled_courses, | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success( | |
| # f"Student registered successfully with ID: {new_student_id}" | |
| # ) | |
| # elif user_type == "faculty": | |
| # new_faculty_id = get_new_faculty_id() | |
| # faculty_collection.insert_one( | |
| # { | |
| # "TID": new_faculty_id, | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "courses_taught": [], | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success( | |
| # f"Faculty registered successfully with ID: {new_faculty_id}" | |
| # ) | |
| # elif user_type == "research_assistant": | |
| # research_assistants_collection.insert_one( | |
| # { | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success("Research Assistant registered successfully!") | |
| # else: | |
| # st.error("Passwords do not match") | |
| def get_new_analyst_id(): | |
| """Generate a new analyst ID by incrementing the last analyst ID""" | |
| last_analyst = analysts_collection.find_one(sort=[("AID", -1)]) | |
| if last_analyst: | |
| last_id = int(last_analyst["AID"][1:]) | |
| new_id = f"A{last_id + 1}" | |
| else: | |
| new_id = "A1" | |
| return new_id | |
| # def register_page(): | |
| # st.title("Register") | |
| # if "user_type" not in st.session_state: | |
| # st.session_state.user_type = "student" | |
| # # Select user type | |
| # st.session_state.user_type = st.selectbox( | |
| # "Please select your Role", ["student", "faculty", "research_assistant", "analyst"] | |
| # ) | |
| # user_type = st.session_state.user_type | |
| # print(user_type) | |
| # with st.form("register_form"): | |
| # full_name = st.text_input("Full Name") | |
| # password = st.text_input("Password", type="password") | |
| # confirm_password = st.text_input("Confirm Password", type="password") | |
| # if user_type == "student": | |
| # # Fetch courses for students to select from | |
| # courses = list(courses_collection.find({}, {"course_id": 1, "title": 1})) | |
| # course_options = [ | |
| # f"{course['title']} ({course['course_id']})" for course in courses | |
| # ] | |
| # selected_courses = st.multiselect("Available Courses", course_options) | |
| # submit = st.form_submit_button("Register") | |
| # if submit: | |
| # if password == confirm_password: | |
| # hashed_password = generate_password_hash(password) | |
| # if user_type == "student": | |
| # new_student_id = get_new_student_id() | |
| # enrolled_courses = [ | |
| # { | |
| # "course_id": course.split("(")[-1][:-1], | |
| # "title": course.split(" (")[0], | |
| # } | |
| # for course in selected_courses | |
| # ] | |
| # students_collection.insert_one( | |
| # { | |
| # "SID": new_student_id, | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "enrolled_courses": enrolled_courses, | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success( | |
| # f"Student registered successfully with ID: {new_student_id}" | |
| # ) | |
| # elif user_type == "faculty": | |
| # new_faculty_id = get_new_faculty_id() | |
| # faculty_collection.insert_one( | |
| # { | |
| # "TID": new_faculty_id, | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "courses_taught": [], | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success( | |
| # f"Faculty registered successfully with ID: {new_faculty_id}" | |
| # ) | |
| # elif user_type == "research_assistant": | |
| # research_assistants_collection.insert_one( | |
| # { | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success("Research Assistant registered successfully!") | |
| # elif user_type == "analyst": | |
| # # new_analyst_id = get_new_analyst_id() | |
| # analysts_collection.insert_one( | |
| # { | |
| # # "AID": new_analyst_id, | |
| # "full_name": full_name, | |
| # "password": hashed_password, | |
| # "created_at": datetime.utcnow(), | |
| # } | |
| # ) | |
| # st.success("Analyst registered successfully!") | |
| # else: | |
| # st.error("Passwords do not match") | |
| def register_page(): | |
| st.title("Register for NOVAScholar") | |
| if "user_type" not in st.session_state: | |
| st.session_state.user_type = "student" | |
| # Select user type | |
| st.session_state.user_type = st.selectbox( | |
| "Please select your Role", | |
| ["Student", "Faculty", "Research Assistant", "Analyst"] | |
| ) | |
| user_type = st.session_state.user_type.lower().replace(" ", "_") | |
| with st.form("register_form"): | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| full_name = st.text_input("Full Name") | |
| email = st.text_input("Institutional Email") | |
| phone = st.text_input("Phone Number") | |
| with col2: | |
| password = st.text_input("Password", type="password") | |
| confirm_password = st.text_input("Confirm Password", type="password") | |
| if user_type == "student": | |
| courses = list(courses_collection.find({}, {"course_id": 1, "title": 1})) | |
| course_options = [f"{course['title']} ({course['course_id']})" for course in courses] | |
| selected_courses = st.multiselect("Available Courses", course_options) | |
| submit = st.form_submit_button("Register") | |
| if submit: | |
| # Validate email | |
| email_valid, email_msg = validate_email(email) | |
| if not email_valid: | |
| st.error(email_msg) | |
| return | |
| # Validate phone | |
| phone_valid, phone_msg = validate_phone(phone) | |
| if not phone_valid: | |
| st.error(phone_msg) | |
| return | |
| # Validate password match | |
| if password != confirm_password: | |
| st.error("Passwords do not match") | |
| return | |
| # Extract username from email | |
| username = extract_username(email) | |
| # Check if username already exists | |
| if user_type == "student": | |
| existing_user = students_collection.find_one({"username": username}) | |
| elif user_type == "faculty": | |
| existing_user = faculty_collection.find_one({"username": username}) | |
| elif user_type == "research_assistant": | |
| existing_user = research_assistants_collection.find_one({"username": username}) | |
| elif user_type == "analyst": | |
| existing_user = analysts_collection.find_one({"username": username}) | |
| if existing_user: | |
| st.error("A user with this email already exists") | |
| return | |
| # Hash password and create user | |
| hashed_password = generate_password_hash(password) | |
| user_data = { | |
| "username": username, | |
| "full_name": full_name, | |
| "email": email, | |
| "phone": phone, | |
| "password": hashed_password, | |
| "created_at": datetime.utcnow() | |
| } | |
| if user_type == "student": | |
| new_student_id = get_new_student_id() | |
| enrolled_courses = [ | |
| { | |
| "course_id": course.split("(")[-1][:-1], | |
| "title": course.split(" (")[0], | |
| } | |
| for course in selected_courses | |
| ] | |
| user_data["SID"] = new_student_id | |
| user_data["enrolled_courses"] = enrolled_courses | |
| students_collection.insert_one(user_data) | |
| st.success(f"Student registered successfully! Your username is: {username}") | |
| elif user_type == "faculty": | |
| new_faculty_id = get_new_faculty_id() | |
| user_data["TID"] = new_faculty_id | |
| user_data["courses_taught"] = [] | |
| faculty_collection.insert_one(user_data) | |
| st.success(f"Faculty registered successfully! Your username is: {username}") | |
| elif user_type == "research_assistant": | |
| research_assistants_collection.insert_one(user_data) | |
| st.success(f"Research Assistant registered successfully! Your username is: {username}") | |
| elif user_type == "analyst": | |
| analysts_collection.insert_one(user_data) | |
| st.success(f"Analyst registered successfully! Your username is: {username}") | |
| # Create Course feature | |
| # def create_course_form2(faculty_name, faculty_id): | |
| # """Display enhanced form to create a new course with AI-generated content""" | |
| # st.title("Create New Course") | |
| # if 'course_plan' not in st.session_state: | |
| # st.session_state.course_plan = None | |
| # if 'edit_mode' not in st.session_state: | |
| # st.session_state.edit_mode = False | |
| # # Initial Course Creation Form | |
| # if not st.session_state.course_plan: | |
| # with st.form("initial_course_form"): | |
| # col1, col2 = st.columns(2) | |
| # with col1: | |
| # course_name = st.text_input("Course Name", placeholder="e.g., Introduction to Computer Science") | |
| # faculty_info = st.text_input("Faculty", value=faculty_name, disabled=True) | |
| # with col2: | |
| # duration_weeks = st.number_input("Duration (weeks)", min_value=1, max_value=16, value=12) | |
| # start_date = st.date_input("Start Date") | |
| # 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..."): | |
| # try: | |
| # course_plan = generate_perplexity_response(PERPLEXITY_API_KEY, course_name) | |
| # # print(course_plan) | |
| # st.session_state.course_plan = json.loads(course_plan) | |
| # st.session_state.start_date = start_date | |
| # st.session_state.duration_weeks = duration_weeks | |
| # 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']) | |
| # 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") | |
| # 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"Module {module_idx + 1} 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(f"### 📖 {sub_module['title']}") | |
| # # Create sessions for each topic | |
| # for topic_idx, topic in enumerate(sub_module['topics']): | |
| # session_key = f"session_{module_idx}_{sub_idx}_{topic_idx}" | |
| # with st.container(): | |
| # col1, col2, col3 = st.columns([3, 2, 1]) | |
| # with col1: | |
| # new_topic = st.text_input( | |
| # "Topic", | |
| # value=topic, | |
| # key=f"{session_key}_topic" | |
| # ) | |
| # 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 col3: | |
| # session_status = st.selectbox( | |
| # "Status", | |
| # options=["upcoming", "in-progress", "completed"], | |
| # key=f"{session_key}_status" | |
| # ) | |
| # # 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": [] | |
| # } | |
| # } | |
| # 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", | |
| # "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!") | |
| # # Update faculty collection | |
| # faculty_collection.update_one( | |
| # {"_id": st.session_state.user_id}, | |
| # { | |
| # "$push": { | |
| # "courses_taught": { | |
| # "course_id": new_course_id, | |
| # "title": course_title, | |
| # } | |
| # } | |
| # }, | |
| # ) | |
| # # Clear session state | |
| # st.session_state.course_plan = None | |
| # st.session_state.edit_mode = False | |
| # # 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}") | |
| def remove_json_backticks(json_string): | |
| """Remove backticks and 'json' from the JSON object string""" | |
| return json_string.replace("```json", "").replace("```", "").strip() | |
| def create_course_form(faculty_name, faculty_id): | |
| """Display enhanced form to create a new course with AI-generated content and resources""" | |
| st.title("Create New Course") | |
| if 'course_plan' not in st.session_state: | |
| st.session_state.course_plan = None | |
| if 'edit_mode' not in st.session_state: | |
| st.session_state.edit_mode = False | |
| if 'resources_map' not in st.session_state: | |
| st.session_state.resources_map = {} | |
| if 'start_date' not in st.session_state: | |
| st.session_state.start_date = None | |
| if 'duration_weeks' not in st.session_state: | |
| st.session_state.duration_weeks = None | |
| if 'sessions_per_week' not in st.session_state: | |
| st.session_state.sessions_per_week = None | |
| # Initial Course Creation Form | |
| if not st.session_state.course_plan: | |
| with st.form("initial_course_form"): | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| course_name = st.text_input("Course Name", placeholder="e.g., Introduction to Computer Science") | |
| faculty_info = st.text_input("Faculty", value=faculty_name, disabled=True) | |
| sessions_per_week = st.number_input("Sessions Per Week", min_value=1, max_value=5, value=2) | |
| 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: | |
| 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}") | |
| # # 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") | |
| # 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 | |
| # 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 | |
| # 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" | |
| # ) | |
| # # 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']}) | |
| # """) | |
| # # 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 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) | |
| # 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!") | |
| # # Update faculty collection | |
| # # 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 | |
| # except Exception as e: | |
| # st.error(f"Error saving course: {e}") | |
| from research_assistant_dashboard import display_research_assistant_dashboard | |
| from goals2 import display_analyst_dashboard | |
| def enroll_in_course(course_id, course_title, student): | |
| """Enroll a student in a course""" | |
| if student: | |
| courses = student.get("enrolled_courses", []) | |
| if course_id not in [course["course_id"] for course in courses]: | |
| course = courses_collection.find_one({"course_id": course_id}) | |
| if course: | |
| courses.append( | |
| { | |
| "course_id": course["course_id"], | |
| "title": course["title"], | |
| } | |
| ) | |
| students_collection.update_one( | |
| {"_id": st.session_state.user_id}, | |
| {"$set": {"enrolled_courses": courses}}, | |
| ) | |
| st.success(f"Enrolled in course {course_title}") | |
| # st.experimental_rerun() | |
| else: | |
| st.error("Course not found") | |
| else: | |
| st.warning("Already enrolled in this course") | |
| # def enroll_in_course_page(course_id): | |
| # """Enroll a student in a course""" | |
| # student = students_collection.find_one({"_id": st.session_state.user_id}) | |
| # course_title = courses_collection.find_one({"course_id": course_id})["title"] | |
| # course = courses_collection.find_one({"course_id": course_id}) | |
| # if course: | |
| # st.title(course["title"]) | |
| # st.subheader("Course Description:") | |
| # st.write(course["description"]) | |
| # st.write(f"Faculty: {course['faculty']}") | |
| # st.write(f"Duration: {course['duration']}") | |
| # st.title("Course Sessions") | |
| # for session in course["sessions"]: | |
| # st.write(f"Session: {session['title']}") | |
| # st.write(f"Date: {session['date']}") | |
| # st.write(f"Status: {session['status']}") | |
| # st.write("----") | |
| # else: | |
| # st.error("Course not found") | |
| # enroll_button = st.button("Enroll in Course", key="enroll_button", use_container_width=True) | |
| # if enroll_button: | |
| # enroll_in_course(course_id, course_title, student) | |
| def enroll_in_course_page(course_id): | |
| """Display an aesthetically pleasing course enrollment page""" | |
| student = students_collection.find_one({"_id": st.session_state.user_id}) | |
| course = courses_collection.find_one({"course_id": course_id}) | |
| if not course: | |
| st.error("Course not found") | |
| return | |
| # Create two columns for layout | |
| col1, col2 = st.columns([2, 1]) | |
| with col1: | |
| # Course header section | |
| st.title(course["title"]) | |
| st.markdown(f"*{course['description']}*") | |
| # Course details in an expander | |
| with st.expander("Course Details", expanded=True): | |
| st.markdown(f"👨🏫 **Faculty:** {course['faculty']}") | |
| st.markdown(f"⏱️ **Duration:** {course['duration']}") | |
| # Sessions in a clean card-like format | |
| st.subheader("📚 Course Sessions") | |
| for idx, session in enumerate(course["sessions"], 1): | |
| with st.container(): | |
| st.markdown(f""" | |
| --- | |
| ### Session {idx}: {session['title']} | |
| 🗓️ **Date:** {session['date']} | |
| 📌 **Status:** {session['status']} | |
| """) | |
| with col2: | |
| with st.container(): | |
| st.markdown("### Ready to Learn?") | |
| st.markdown("Click below to enroll in this course") | |
| # Check if already enrolled | |
| courses = student.get("enrolled_courses", []) | |
| is_enrolled = course_id in [c["course_id"] for c in courses] | |
| if is_enrolled: | |
| st.info("✅ You are already enrolled in this course") | |
| else: | |
| enroll_button = st.button( | |
| "🎓 Enroll Now", | |
| key="enroll_button", | |
| use_container_width=True | |
| ) | |
| if enroll_button: | |
| enroll_in_course(course_id, course["title"], student) | |
| def show_available_courses(username, user_type, user_id): | |
| """Display available courses for enrollment""" | |
| st.title("Available Courses") | |
| courses = list(courses_collection.find({}, {"course_id": 1, "title": 1})) | |
| course_options = [ | |
| f"{course['title']} ({course['course_id']})" for course in courses | |
| ] | |
| selected_course = st.selectbox("Select a Course to Enroll", course_options) | |
| # if selected_courses: | |
| # for course in selected_courses: | |
| # course_id = course.split("(")[-1][:-1] | |
| # course_title = course.split(" (")[0] | |
| # enroll_in_course(course_id, course_title, user_id) | |
| # st.success("Courses enrolled successfully!") | |
| if selected_course: | |
| course_id = selected_course.split("(")[-1][:-1] | |
| enroll_in_course_page(course_id) | |
| def validate_email(email): | |
| """Validate email format and domain""" | |
| # Basic email pattern | |
| pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' | |
| if not re.match(pattern, email): | |
| return False, "Invalid email format" | |
| # You can add additional institution-specific validation here | |
| # For example, checking if the domain is from your institution | |
| # allowed_domains = ["spit.ac.in"] # Add more domains as needed | |
| # domain = email.split('@')[1] | |
| # if domain not in allowed_domains: | |
| # return False, "Please use your institutional email address" | |
| return True, "Valid email" | |
| def validate_phone(phone): | |
| """Validate phone number format""" | |
| # Assuming Indian phone numbers | |
| pattern = r'^[6-9]\d{9}$' | |
| if not re.match(pattern, phone): | |
| return False, "Invalid phone number format. Please enter a 10-digit Indian mobile number" | |
| return True, "Valid phone number" | |
| def extract_username(email): | |
| """Extract username from email""" | |
| return email.split('@')[0] | |
| def main_dashboard(): | |
| if st.session_state.user_type == "research_assistant": | |
| display_research_assistant_dashboard() | |
| elif st.session_state.user_type == "analyst": | |
| display_analyst_dashboard() | |
| else: | |
| selected_course_id = None | |
| create_session = False | |
| with st.sidebar: | |
| st.title(f"Welcome, {st.session_state.username}") | |
| if st.session_state.user_type == "student": | |
| st.title("Enrolled Courses") | |
| else: | |
| st.title("Your Courses") | |
| # Course selection | |
| enrolled_courses = get_courses( | |
| st.session_state.username, st.session_state.user_type | |
| ) | |
| # Enroll in Courses | |
| if st.session_state.user_type == "student": | |
| if st.button( | |
| "Enroll in a New Course", key="enroll_course", use_container_width=True | |
| ): | |
| st.session_state.show_enroll_course_page = True | |
| # if st.session_state.show_enroll_course_form: | |
| # courses = list(courses_collection.find({}, {"course_id": 1, "title": 1})) | |
| # courses += list(courses_collection2.find({}, {"course_id": 1, "title": 1})) | |
| # course_options = [f"{course['title']} ({course['course_id']})" for course in courses] | |
| # course_to_enroll = st.selectbox("Available Courses", course_options) | |
| # st.session_state.course_to_enroll = course_to_enroll | |
| if st.session_state.user_type == "faculty": | |
| if st.button( | |
| "Create New Course", key="create_course", use_container_width=True | |
| ): | |
| st.session_state.show_create_course_form = True | |
| if not enrolled_courses: | |
| st.warning("No courses found") | |
| else: | |
| course_titles = [course["title"] for course in enrolled_courses] | |
| course_ids = [course["course_id"] for course in enrolled_courses] | |
| selected_course = st.selectbox("Select Course", course_titles) | |
| selected_course_id = course_ids[course_titles.index(selected_course)] | |
| print("Selected Course ID: ", selected_course_id) | |
| st.session_state.selected_course = selected_course | |
| st.session_state.selected_course_id = selected_course_id | |
| # Display course sessions | |
| sessions = get_sessions(selected_course_id, selected_course) | |
| st.title("Course Sessions") | |
| for i, session in enumerate(sessions, start=1): | |
| if st.button( | |
| f"Session {i}", key=f"session_{i}", use_container_width=True | |
| ): | |
| st.session_state.selected_session = session | |
| if st.session_state.user_type == "faculty": | |
| # Create new session | |
| # create_session = st.button("Create New Session Button", key="create_session", use_container_width=True) | |
| if st.button( | |
| "Create New Session", | |
| key="create_session", | |
| use_container_width=True, | |
| ): | |
| st.session_state.show_create_session_form = True | |
| if st.button("Delete a Session", key="delete_session", use_container_width=True): | |
| # session_id = st.text_input("Enter the Session ID to delete") | |
| st.session_state.show_delete_session_form = True | |
| if st.button("Logout", use_container_width=True): | |
| for key in st.session_state.keys(): | |
| del st.session_state[key] | |
| st.rerun() | |
| # if create_session: | |
| # create_session_form(selected_course_id) | |
| if st.session_state.get("show_create_course_form"): | |
| create_course_form(st.session_state.username, st.session_state.user_id) | |
| elif st.session_state.get("show_create_session_form"): | |
| create_session_form(selected_course_id) | |
| elif st.session_state.get("show_enroll_course_page"): | |
| show_available_courses(st.session_state.username, st.session_state.user_type, st.session_state.user_id) | |
| elif st.session_state.get("show_delete_session_form"): | |
| session_options = [f"{session['title']} (ID: {session['session_id']})" for session in sessions] | |
| session_id = st.selectbox("Select Session to Delete", session_options) | |
| session_id = session_id.split(" (ID: ")[-1][:-1] | |
| if st.button("Delete Session"): | |
| if delete_session(selected_course_id, session_id): | |
| st.success(f"Session {session_id} deleted successfully!") | |
| st.rerun() | |
| else: | |
| # Main content | |
| if "selected_session" in st.session_state: | |
| 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, | |
| ) | |
| else: | |
| st.info("Select a session to view details") | |
| # # Main content | |
| # if 'selected_session' in st.session_state: | |
| # 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) | |
| # if create_session: | |
| # create_session_form(selected_course_id) | |
| def main(): | |
| st.set_page_config(page_title="NOVAScholar", page_icon="📚", layout="wide") | |
| init_session_state() | |
| # modify_courses_collection_schema() | |
| if not st.session_state.authenticated: | |
| login_tab, register_tab = st.tabs(["Login", "Register"]) | |
| with register_tab: | |
| # register_page() | |
| st.info("Registrations are closed.") | |
| with login_tab: | |
| login_form() | |
| else: | |
| main_dashboard() | |
| if __name__ == "__main__": | |
| main() | |