Upload 4 files

mongodb_adapter.py

@@ -0,0 +1,882 @@
+"""
+MongoDB Adapter - Replaces SQLAlchemy ORM with MongoDB operations
+Provides compatibility layer for existing codebase
+"""
+
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+try:
+    from bson.objectid import ObjectId
+except ImportError:
+    # Fallback if standalone bson package conflicts
+    from pymongo.bson.objectid import ObjectId
+from mongodb_config import mongodb, get_db, serialize_document
+import bcrypt
+import logging
+
+logger = logging.getLogger(__name__)
+
+class MongoDBAdapter:
+    """Adapter to replace SQLAlchemy operations with MongoDB"""
+    
+    def __init__(self):
+        self.db = get_db()
+    
+    # ==================== Admin Operations ====================
+    
+    def create_admin(self, username: str, password: str, role: str = "admin") -> Optional[str]:
+        """Create a new admin user with role
+        
+        Roles:
+        - 'admin': Can upload syllabus only
+        - 'school_admin': Can enroll students only
+        """
+        try:
+            password_hash = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+            
+            admin_doc = {
+                "username": username,
+                "password_hash": password_hash,
+                "role": role,  # 'admin' or 'school_admin'
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.admins.insert_one(admin_doc)
+            logger.info(f"✅ Admin created: {username} with role: {role}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating admin: {e}")
+            return None
+    
+    def get_admin_by_username(self, username: str) -> Optional[Dict]:
+        """Get admin by username"""
+        admin = self.db.admins.find_one({"username": username})
+        return serialize_document(admin) if admin else None
+    
+    def get_admin_role(self, username: str) -> Optional[str]:
+        """Get admin role by username"""
+        admin = self.db.admins.find_one({"username": username}, {"role": 1})
+        return admin.get("role", "admin") if admin else None
+    
+    def verify_admin_password(self, username: str, password: str) -> bool:
+        """Verify admin password"""
+        admin = self.db.admins.find_one({"username": username})
+        if not admin:
+            return False
+        return bcrypt.checkpw(password.encode('utf-8'), admin["password_hash"].encode('utf-8'))
+    
+    def update_admin_password(self, username: str, new_password: str, role: Optional[str] = None) -> bool:
+        """Update admin password and optionally role"""
+        try:
+            password_hash = bcrypt.hashpw(new_password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+            update_data = {"password_hash": password_hash, "updated_at": datetime.utcnow()}
+            if role:
+                update_data["role"] = role
+            result = self.db.admins.update_one(
+                {"username": username},
+                {"$set": update_data}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating admin password: {e}")
+            return False
+    
+    def create_school_admin(self, username: str, password: str, school_id: str, name: str) -> Optional[str]:
+        """Create a new school_admin user with school_id association (max 50 school_admins)"""
+        try:
+            # Check if we've reached the limit of 50 school_admins
+            school_admin_count = self.db.admins.count_documents({"role": "school_admin"})
+            if school_admin_count >= 50:
+                logger.error(f"Maximum limit of 50 school_admins reached")
+                return None
+            
+            password_hash = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+            
+            admin_doc = {
+                "username": username,
+                "password_hash": password_hash,
+                "role": "school_admin",
+                "school_id": school_id,
+                "name": name,
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.admins.insert_one(admin_doc)
+            logger.info(f"✅ School admin created: {username} for school_id: {school_id}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating school admin: {e}")
+            return None
+    
+    def get_school_admins(self, school_id: Optional[str] = None) -> List[Dict]:
+        """Get all school_admins, optionally filtered by school_id"""
+        query = {"role": "school_admin"}
+        if school_id:
+            query["school_id"] = school_id
+        admins = self.db.admins.find(query).sort("created_at", -1)
+        return [serialize_document(a) for a in admins]
+    
+    def get_admin_school_id(self, username: str) -> Optional[str]:
+        """Get school_id for a school_admin"""
+        admin = self.db.admins.find_one({"username": username}, {"school_id": 1})
+        return admin.get("school_id") if admin else None
+    
+    # ==================== School Operations ====================
+    
+    def create_school(self, name: str) -> Optional[str]:
+        """Create a new school"""
+        try:
+            # Check if school with same name already exists
+            existing = self.db.schools.find_one({"name": name})
+            if existing:
+                logger.warning(f"School with name '{name}' already exists")
+                return str(existing.get("_id"))
+            
+            school_doc = {
+                "name": name,
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.schools.insert_one(school_doc)
+            logger.info(f"✅ School created: {name}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating school: {e}")
+            return None
+    
+    def get_school_by_id(self, school_id: str) -> Optional[Dict]:
+        """Get school by ID"""
+        try:
+            school = self.db.schools.find_one({"_id": ObjectId(school_id)})
+            return serialize_document(school) if school else None
+        except:
+            return None
+    
+    def get_school_by_name(self, name: str) -> Optional[Dict]:
+        """Get school by name"""
+        school = self.db.schools.find_one({"name": name})
+        return serialize_document(school) if school else None
+    
+    def get_all_schools(self) -> List[Dict]:
+        """Get all schools"""
+        schools = self.db.schools.find().sort("created_at", -1)
+        return [serialize_document(s) for s in schools]
+    
+    def update_school(self, school_id: str, name: str) -> bool:
+        """Update school information"""
+        try:
+            result = self.db.schools.update_one(
+                {"_id": ObjectId(school_id)},
+                {"$set": {"name": name, "updated_at": datetime.utcnow()}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating school: {e}")
+            return False
+    
+    def delete_school(self, school_id: str) -> bool:
+        """Delete a school (only if no students or admins are associated)"""
+        try:
+            # Check if any students are associated with this school
+            student_count = self.db.students.count_documents({"school_id": school_id})
+            if student_count > 0:
+                logger.warning(f"Cannot delete school {school_id}: {student_count} students are associated")
+                return False
+            
+            # Check if any school_admins are associated with this school
+            admin_count = self.db.admins.count_documents({"school_id": school_id, "role": "school_admin"})
+            if admin_count > 0:
+                logger.warning(f"Cannot delete school {school_id}: {admin_count} school_admins are associated")
+                return False
+            
+            result = self.db.schools.delete_one({"_id": ObjectId(school_id)})
+            return result.deleted_count > 0
+        except Exception as e:
+            logger.error(f"Error deleting school: {e}")
+            return False
+    
+    # ==================== Student Operations ====================
+    
+    def create_student(self, student_data: Dict) -> Optional[str]:
+        """Create a new student"""
+        try:
+            password_hash = bcrypt.hashpw(student_data["password"].encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+            
+            student_doc = {
+                "student_id": student_data["student_id"],
+                "username": student_data.get("username", student_data["student_id"]),
+                "email": student_data["email"],
+                "password_hash": password_hash,
+                "first_name": student_data["first_name"],
+                "last_name": student_data["last_name"],
+                "grade": student_data.get("grade", 0),
+                "school_id": student_data.get("school_id"),  # Add school_id
+                "school_name": student_data.get("school_name", ""),  # Keep for backward compatibility
+                "weak_topics": student_data.get("weak_topics", []),
+                "google_form_results": student_data.get("google_form_results", {}),
+                "learning_path": student_data.get("learning_path", {}),
+                "progress": student_data.get("progress", 0.0),
+                "created_at": datetime.utcnow(),
+                "is_active": student_data.get("is_active", True)
+            }
+            
+            result = self.db.students.insert_one(student_doc)
+            logger.info(f"✅ Student created: {student_data['student_id']}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating student: {e}")
+            return None
+    
+    def get_student_by_student_id(self, student_id: str) -> Optional[Dict]:
+        """Get student by student_id"""
+        student = self.db.students.find_one({"student_id": student_id})
+        return serialize_document(student) if student else None
+    
+    def get_student_by_id(self, id: str) -> Optional[Dict]:
+        """Get student by MongoDB _id"""
+        try:
+            student = self.db.students.find_one({"_id": ObjectId(id)})
+            return serialize_document(student) if student else None
+        except:
+            return None
+    
+    def get_student_by_username(self, username: str) -> Optional[Dict]:
+        """Get student by username"""
+        student = self.db.students.find_one({"username": username})
+        return serialize_document(student) if student else None
+    
+    def get_student_by_email(self, email: str) -> Optional[Dict]:
+        """Get student by email"""
+        student = self.db.students.find_one({"email": email})
+        return serialize_document(student) if student else None
+    
+    def get_all_students(self, skip: int = 0, limit: int = 100, school_id: Optional[str] = None) -> List[Dict]:
+        """Get all students with pagination, optionally filtered by school_id"""
+        query = {}
+        if school_id:
+            query["school_id"] = school_id
+        students = self.db.students.find(query).skip(skip).limit(limit).sort("created_at", -1)
+        return [serialize_document(s) for s in students]
+    
+    def update_student(self, student_id: str, update_data: Dict) -> bool:
+        """Update student information"""
+        try:
+            result = self.db.students.update_one(
+                {"student_id": student_id},
+                {"$set": {**update_data, "updated_at": datetime.utcnow()}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating student: {e}")
+            return False
+    
+    def update_student_by_id(self, student_mongo_id: str, update_data: Dict) -> bool:
+        """Update student by MongoDB _id"""
+        try:
+            result = self.db.students.update_one(
+                {"_id": ObjectId(student_mongo_id)},
+                {"$set": {**update_data, "updated_at": datetime.utcnow()}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating student by ID: {e}")
+            return False
+    
+    def update_student_password(self, student_id: str, new_password: str) -> bool:
+        """Update student password"""
+        try:
+            password_hash = bcrypt.hashpw(new_password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+            return self.update_student(student_id, {"password_hash": password_hash})
+        except Exception as e:
+            logger.error(f"Error updating student password: {e}")
+            return False
+    
+    def delete_student(self, student_id: str) -> bool:
+        """Delete a student and all related data"""
+        try:
+            # Get student first to find by student_id or MongoDB _id
+            student = self.get_student_by_student_id(student_id)
+            if not student:
+                # Try by MongoDB _id
+                try:
+                    student = self.get_student_by_id(student_id)
+                except:
+                    pass
+            
+            if not student:
+                return False
+            
+            mongo_id = student.get("_id") or student_id
+            
+            # Delete related data
+            # Delete chat messages
+            self.db.chat_messages.delete_many({"student_id": student.get("student_id")})
+            
+            # Delete assessments
+            assessments = self.db.assessments.find({"student_id": student.get("student_id")})
+            assessment_ids = [str(a["_id"]) for a in assessments]
+            
+            # Delete student answers
+            self.db.student_answers.delete_many({"assessment_id": {"$in": assessment_ids}})
+            
+            # Delete questions
+            self.db.questions.delete_many({"assessment_id": {"$in": assessment_ids}})
+            
+            # Delete assessments
+            self.db.assessments.delete_many({"student_id": student.get("student_id")})
+            
+            # Remove student from syllabus assigned_students lists
+            self.db.syllabi.update_many(
+                {"assigned_students": student.get("student_id")},
+                {"$pull": {"assigned_students": student.get("student_id")}}
+            )
+            
+            # Delete the student
+            result = self.db.students.delete_one({"_id": ObjectId(mongo_id) if isinstance(mongo_id, str) else mongo_id})
+            return result.deleted_count > 0
+        except Exception as e:
+            logger.error(f"Error deleting student: {e}")
+            return False
+    
+    def get_students_by_grade(self, grade: int, school_id: Optional[str] = None) -> List[Dict]:
+        """Get students filtered by grade, optionally filtered by school_id"""
+        query = {"grade": grade}
+        if school_id:
+            query["school_id"] = school_id
+        students = self.db.students.find(query).sort("created_at", -1)
+        return [serialize_document(s) for s in students]
+    
+    def update_student_learning_path(self, student_id: str, learning_path: Dict) -> bool:
+        """Update student's learning path"""
+        return self.update_student(student_id, {"learning_path": learning_path})
+    
+    def update_student_progress(self, student_id: str, progress: float) -> bool:
+        """Update student's progress"""
+        return self.update_student(student_id, {"progress": progress})
+    
+    def verify_student_password(self, username: str, password: str) -> bool:
+        """Verify student password"""
+        student = self.db.students.find_one({"username": username})
+        if not student:
+            return False
+        return bcrypt.checkpw(password.encode('utf-8'), student["password_hash"].encode('utf-8'))
+    
+    # ==================== Syllabus Operations ====================
+    
+    def create_syllabus(self, title: str, content: Dict, assigned_students: List[str] = None) -> Optional[str]:
+        """Create a new syllabus"""
+        try:
+            syllabus_doc = {
+                "title": title,
+                "content": content,
+                "assigned_students": assigned_students or [],
+                "uploaded_at": datetime.utcnow()
+            }
+            
+            result = self.db.syllabi.insert_one(syllabus_doc)
+            logger.info(f"✅ Syllabus created: {title}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating syllabus: {e}")
+            return None
+    
+    def get_syllabus_by_id(self, id: str) -> Optional[Dict]:
+        """Get syllabus by ID"""
+        try:
+            syllabus = self.db.syllabi.find_one({"_id": ObjectId(id)})
+            return serialize_document(syllabus) if syllabus else None
+        except:
+            return None
+    
+    def get_all_syllabi(self) -> List[Dict]:
+        """Get all syllabi"""
+        syllabi = self.db.syllabi.find().sort("uploaded_at", -1)
+        return [serialize_document(s) for s in syllabi]
+    
+    def get_student_syllabi(self, student_id: str) -> List[Dict]:
+        """Get syllabi assigned to a student - checks both student_id field and MongoDB _id"""
+        try:
+            # Try exact match first
+            syllabi = list(self.db.syllabi.find({"assigned_students": student_id}))
+            
+            # If not found, try with ObjectId conversion (in case student_id is MongoDB _id)
+            if not syllabi:
+                try:
+                    from mongodb_config import ObjectId
+                    if ObjectId and len(student_id) == 24:  # ObjectId is 24 hex characters
+                        syllabi = list(self.db.syllabi.find({"assigned_students": ObjectId(student_id)}))
+                except:
+                    pass
+            
+            # Also try string comparison (in case stored as string but we're searching with different format)
+            if not syllabi:
+                # Get all syllabi and filter in Python (less efficient but more reliable)
+                all_syllabi = list(self.db.syllabi.find({}))
+                syllabi = []
+                for s in all_syllabi:
+                    assigned = s.get("assigned_students", [])
+                    assigned_str = [str(sid) for sid in assigned]
+                    if str(student_id) in assigned_str:
+                        syllabi.append(s)
+            
+            return [serialize_document(s) for s in syllabi]
+        except Exception as e:
+            logger.error(f"Error getting student syllabi for {student_id}: {e}")
+            return []
+    
+    def assign_syllabus_to_students(self, syllabus_id: str, student_ids: List[str]) -> bool:
+        """Assign syllabus to multiple students"""
+        try:
+            result = self.db.syllabi.update_one(
+                {"_id": ObjectId(syllabus_id)},
+                {"$addToSet": {"assigned_students": {"$each": student_ids}}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error assigning syllabus: {e}")
+            return False
+    
+    def update_syllabus(self, syllabus_id: str, update_data: Dict) -> bool:
+        """Update syllabus information"""
+        try:
+            result = self.db.syllabi.update_one(
+                {"_id": ObjectId(syllabus_id)},
+                {"$set": {**update_data, "updated_at": datetime.utcnow()}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating syllabus: {e}")
+            return False
+    
+    def delete_syllabus(self, syllabus_id: str) -> bool:
+        """Delete a syllabus"""
+        try:
+            result = self.db.syllabi.delete_one({"_id": ObjectId(syllabus_id)})
+            return result.deleted_count > 0
+        except Exception as e:
+            logger.error(f"Error deleting syllabus: {e}")
+            return False
+    
+    def get_syllabi_by_grade(self, grade: int) -> List[Dict]:
+        """Get syllabi filtered by grade (extracted from title)"""
+        all_syllabi = self.get_all_syllabi()
+        matching = []
+        for s in all_syllabi:
+            title_lower = (s.get("title") or "").lower()
+            if f"grade {grade}" in title_lower or f"grade{grade}" in title_lower or title_lower.endswith(f"grade {grade}"):
+                matching.append(s)
+        return matching
+    
+    def remove_student_from_syllabus(self, syllabus_id: str, student_id: str) -> bool:
+        """Remove a student from syllabus assigned_students list"""
+        try:
+            result = self.db.syllabi.update_one(
+                {"_id": ObjectId(syllabus_id)},
+                {"$pull": {"assigned_students": student_id}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error removing student from syllabus: {e}")
+            return False
+    
+    # ==================== Assessment Operations ====================
+    
+    def create_assessment(self, assessment_data: Dict) -> Optional[str]:
+        """Create a new assessment"""
+        try:
+            assessment_doc = {
+                "student_id": assessment_data["student_id"],
+                "syllabus_id": assessment_data.get("syllabus_id"),
+                "attempt_number": assessment_data.get("attempt_number", 1),
+                "session_id": assessment_data.get("session_id", ""),
+                "total_questions": assessment_data.get("total_questions", 0),
+                "questions_asked": assessment_data.get("questions_asked", 0),
+                "correct_answers": assessment_data.get("correct_answers", 0),
+                "score_percentage": assessment_data.get("score_percentage", 0.0),
+                "weak_topics": assessment_data.get("weak_topics", []),
+                "created_at": datetime.utcnow(),
+                "completed_at": assessment_data.get("completed_at")
+            }
+            
+            result = self.db.assessments.insert_one(assessment_doc)
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating assessment: {e}")
+            return None
+    
+    def get_assessment_by_id(self, id: str) -> Optional[Dict]:
+        """Get assessment by ID"""
+        try:
+            assessment = self.db.assessments.find_one({"_id": ObjectId(id)})
+            return serialize_document(assessment) if assessment else None
+        except:
+            return None
+    
+    def get_student_assessments(self, student_id: str) -> List[Dict]:
+        """Get all assessments for a student"""
+        assessments = self.db.assessments.find({"student_id": student_id}).sort("created_at", -1)
+        return [serialize_document(a) for a in assessments]
+    
+    def update_assessment(self, assessment_id: str, update_data: Dict) -> bool:
+        """Update assessment"""
+        try:
+            result = self.db.assessments.update_one(
+                {"_id": ObjectId(assessment_id)},
+                {"$set": update_data}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating assessment: {e}")
+            return False
+    
+    # ==================== Question Operations ====================
+    
+    def create_question(self, question_data: Dict) -> Optional[str]:
+        """Create a new question"""
+        try:
+            question_doc = {
+                "assessment_id": question_data["assessment_id"],
+                "question_text": question_data["question_text"],
+                "option_a": question_data["option_a"],
+                "option_b": question_data["option_b"],
+                "option_c": question_data["option_c"],
+                "option_d": question_data["option_d"],
+                "correct_answer": question_data["correct_answer"],
+                "topic": question_data["topic"],
+                "difficulty": question_data.get("difficulty", "medium"),
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.questions.insert_one(question_doc)
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating question: {e}")
+            return None
+    
+    def get_questions_by_assessment(self, assessment_id: str) -> List[Dict]:
+        """Get all questions for an assessment"""
+        questions = self.db.questions.find({"assessment_id": assessment_id})
+        return [serialize_document(q) for q in questions]
+    
+    # ==================== Student Answer Operations ====================
+    
+    def save_student_answer(self, answer_data: Dict) -> Optional[str]:
+        """Save student's answer"""
+        try:
+            answer_doc = {
+                "assessment_id": answer_data["assessment_id"],
+                "question_id": answer_data["question_id"],
+                "student_id": answer_data["student_id"],
+                "selected_answer": answer_data["selected_answer"],
+                "is_correct": answer_data["is_correct"],
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.student_answers.insert_one(answer_doc)
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error saving answer: {e}")
+            return None
+    
+    def get_student_answers(self, assessment_id: str, student_id: str) -> List[Dict]:
+        """Get all answers for a student's assessment"""
+        answers = self.db.student_answers.find({
+            "assessment_id": assessment_id,
+            "student_id": student_id
+        })
+        return [serialize_document(a) for a in answers]
+    
+    # ==================== Chat Operations ====================
+    
+    def save_chat_message(self, message_data: Dict) -> Optional[str]:
+        """Save a chat message"""
+        try:
+            message_doc = {
+                "student_id": message_data["student_id"],
+                "session_id": message_data["session_id"],
+                "role": message_data["role"],
+                "content": message_data["content"],
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.chat_messages.insert_one(message_doc)
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error saving chat message: {e}")
+            return None
+    
+    def get_chat_history(self, student_id: str, session_id: str, limit: int = 50) -> List[Dict]:
+        """Get chat history for a session"""
+        messages = self.db.chat_messages.find({
+            "student_id": student_id,
+            "session_id": session_id
+        }).sort("created_at", 1).limit(limit)
+        return [serialize_document(m) for m in messages]
+    
+    # ==================== Learning Path Progress Operations ====================
+    
+    def save_learning_progress(self, progress_data: Dict) -> Optional[str]:
+        """Save learning progress"""
+        try:
+            progress_doc = {
+                "student_id": progress_data["student_id"],
+                "module_id": progress_data.get("module_id"),
+                "lesson_id": progress_data.get("lesson_id"),
+                "practice_id": progress_data.get("practice_id"),
+                "quiz_id": progress_data.get("quiz_id"),
+                "item_type": progress_data["item_type"],
+                "is_completed": progress_data.get("is_completed", False),
+                "score": progress_data.get("score"),
+                "completed_at": progress_data.get("completed_at"),
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.learning_path_progress.insert_one(progress_doc)
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error saving learning progress: {e}")
+            return None
+    
+    def get_student_progress(self, student_id: str) -> List[Dict]:
+        """Get all progress for a student"""
+        progress = self.db.learning_path_progress.find({"student_id": student_id})
+        return [serialize_document(p) for p in progress]
+    
+    def update_progress_item(self, student_id: str, item_id: int, item_type: str, 
+                           is_completed: bool, score: float = None) -> bool:
+        """Update a specific progress item"""
+        try:
+            query = {"student_id": student_id, "item_type": item_type}
+            
+            if item_type == "lesson":
+                query["lesson_id"] = item_id
+            elif item_type == "practice":
+                query["practice_id"] = item_id
+            elif item_type in ["mini_quiz", "module_quiz"]:
+                query["quiz_id"] = item_id
+            
+            update_data = {
+                "is_completed": is_completed,
+                "completed_at": datetime.utcnow() if is_completed else None
+            }
+            
+            if score is not None:
+                update_data["score"] = score
+            
+            result = self.db.learning_path_progress.update_one(query, {"$set": update_data}, upsert=True)
+            return result.modified_count > 0 or result.upserted_id is not None
+        except Exception as e:
+            logger.error(f"Error updating progress: {e}")
+            return False
+    
+    # ==================== Practice Assessment Operations ====================
+    
+    def create_practice_assessment(self, practice_data: Dict) -> Optional[str]:
+        """Create practice assessment"""
+        try:
+            practice_doc = {
+                "student_id": practice_data["student_id"],
+                "topic": practice_data["topic"],
+                "questions": practice_data["questions"],
+                "answers": practice_data.get("answers"),
+                "score": practice_data.get("score"),
+                "completed_at": practice_data.get("completed_at"),
+                "created_at": datetime.utcnow()
+            }
+            
+            result = self.db.practice_assessments.insert_one(practice_doc)
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating practice assessment: {e}")
+            return None
+    
+    def get_practice_assessment(self, practice_id: str) -> Optional[Dict]:
+        """Get practice assessment by ID"""
+        try:
+            practice = self.db.practice_assessments.find_one({"_id": ObjectId(practice_id)})
+            return serialize_document(practice) if practice else None
+        except:
+            return None
+    
+    def update_practice_assessment(self, practice_id: str, update_data: Dict) -> bool:
+        """Update practice assessment"""
+        try:
+            result = self.db.practice_assessments.update_one(
+                {"_id": ObjectId(practice_id)},
+                {"$set": update_data}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating practice assessment: {e}")
+            return False
+    
+    # ==================== Microsoft Forms Operations ====================
+    
+    def create_microsoft_form(self, form_data: Dict) -> Optional[str]:
+        """Create a new Microsoft Form"""
+        try:
+            form_doc = {
+                "title": form_data["title"],
+                "description": form_data.get("description", ""),
+                "form_url": form_data["form_url"],
+                "form_id": form_data.get("form_id"),
+                "subject": form_data["subject"],
+                "grade": form_data["grade"],
+                "school_id": form_data.get("school_id"),
+                "is_active": form_data.get("is_active", True),
+                "created_by": form_data["created_by"],
+                "created_at": datetime.utcnow(),
+                "due_date": form_data.get("due_date")
+            }
+            
+            result = self.db.microsoft_forms.insert_one(form_doc)
+            logger.info(f"✅ Microsoft Form created: {form_data['title']}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating Microsoft Form: {e}")
+            return None
+    
+    def get_microsoft_form_by_id(self, form_id: str) -> Optional[Dict]:
+        """Get Microsoft Form by ID"""
+        try:
+            # Try ObjectId first
+            form = self.db.microsoft_forms.find_one({"_id": ObjectId(form_id)})
+            if form:
+                return serialize_document(form)
+            # If not found, try as string ID
+            form = self.db.microsoft_forms.find_one({"id": form_id})
+            return serialize_document(form) if form else None
+        except Exception as e:
+            logger.warning(f"Error getting Microsoft Form by ID {form_id}: {e}")
+            return None
+    
+    def get_microsoft_forms(self, subject: Optional[str] = None, grade: Optional[int] = None) -> List[Dict]:
+        """Get all Microsoft Forms, optionally filtered"""
+        query = {"is_active": True}
+        if subject:
+            query["subject"] = subject
+        if grade:
+            query["grade"] = grade
+        
+        forms = self.db.microsoft_forms.find(query).sort("created_at", -1)
+        return [serialize_document(f) for f in forms]
+    
+    def create_microsoft_form_submission(self, submission_data: Dict) -> Optional[str]:
+        """Create a new Microsoft Form submission"""
+        try:
+            submission_doc = {
+                "student_id": str(submission_data.get("student_id", "")),  # Store as string for consistency
+                "form_id": str(submission_data.get("form_id", "")),  # Store as string for consistency
+                "submission_url": submission_data.get("submission_url", ""),
+                "responses": submission_data.get("responses", {}),
+                "subject": submission_data["subject"],
+                "score": submission_data.get("score"),
+                "weak_points": submission_data.get("weak_points", []),
+                "submitted_at": datetime.utcnow(),
+                "processed": submission_data.get("processed", False)
+            }
+            
+            result = self.db.microsoft_form_submissions.insert_one(submission_doc)
+            logger.info(f"✅ Microsoft Form submission created: {result.inserted_id}")
+            return str(result.inserted_id)
+        except Exception as e:
+            logger.error(f"Error creating Microsoft Form submission: {e}", exc_info=True)
+            return None
+    
+    def get_microsoft_form_submission(self, submission_id: str) -> Optional[Dict]:
+        """Get Microsoft Form submission by ID"""
+        try:
+            submission = self.db.microsoft_form_submissions.find_one({"_id": ObjectId(submission_id)})
+            return serialize_document(submission) if submission else None
+        except Exception as e:
+            logger.warning(f"Error getting Microsoft Form submission {submission_id}: {e}")
+            return None
+    
+    def get_student_microsoft_form_submissions(self, student_id: str) -> List[Dict]:
+        """Get all Microsoft Form submissions for a student"""
+        # Try to find by student_id (string) or by integer ID
+        try:
+            submissions = self.db.microsoft_form_submissions.find({
+                "$or": [
+                    {"student_id": student_id},
+                    {"student_id": int(student_id) if student_id.isdigit() else None}
+                ]
+            }).sort("submitted_at", -1)
+            return [serialize_document(s) for s in submissions]
+        except:
+            # Fallback: just search by string
+            submissions = self.db.microsoft_form_submissions.find({"student_id": str(student_id)}).sort("submitted_at", -1)
+            return [serialize_document(s) for s in submissions]
+    
+    def get_form_submissions(self, form_id: str) -> List[Dict]:
+        """Get all submissions for a form"""
+        # Try to find by form_id (string) or by ObjectId
+        try:
+            submissions = self.db.microsoft_form_submissions.find({
+                "$or": [
+                    {"form_id": form_id},
+                    {"form_id": ObjectId(form_id)}
+                ]
+            }).sort("submitted_at", -1)
+            return [serialize_document(s) for s in submissions]
+        except:
+            # Fallback: just search by string
+            submissions = self.db.microsoft_form_submissions.find({"form_id": str(form_id)}).sort("submitted_at", -1)
+            return [serialize_document(s) for s in submissions]
+    
+    def update_microsoft_form_submission(self, submission_id: str, update_data: Dict) -> bool:
+        """Update Microsoft Form submission"""
+        try:
+            result = self.db.microsoft_form_submissions.update_one(
+                {"_id": ObjectId(submission_id)},
+                {"$set": update_data}
+            )
+            if result.modified_count > 0:
+                logger.info(f"✅ Updated Microsoft Form submission {submission_id}")
+            return result.modified_count > 0
+        except Exception as e:
+            logger.error(f"Error updating Microsoft Form submission {submission_id}: {e}", exc_info=True)
+            return False
+    
+    def delete_microsoft_form(self, form_id: str) -> bool:
+        """Delete a Microsoft Form and all related submissions"""
+        try:
+            # First, try to find the form
+            form = self.get_microsoft_form_by_id(form_id)
+            if not form:
+                logger.warning(f"Microsoft Form {form_id} not found for deletion")
+                return False
+            
+            # Delete all submissions for this form
+            form_id_str = str(form.get("_id") or form.get("id", form_id))
+            try:
+                submissions_deleted = self.db.microsoft_form_submissions.delete_many({
+                    "$or": [
+                        {"form_id": form_id_str},
+                        {"form_id": ObjectId(form_id_str)}
+                    ]
+                })
+                logger.info(f"Deleted {submissions_deleted.deleted_count} submissions for form {form_id_str}")
+            except Exception as e:
+                logger.warning(f"Error deleting submissions for form {form_id_str}: {e}")
+            
+            # Delete the form itself
+            try:
+                result = self.db.microsoft_forms.delete_one({"_id": ObjectId(form_id_str)})
+                if result.deleted_count > 0:
+                    logger.info(f"✅ Deleted Microsoft Form {form_id_str}")
+                    return True
+                else:
+                    # Try by form_id field if ObjectId didn't work
+                    result = self.db.microsoft_forms.delete_one({"form_id": form_id_str})
+                    return result.deleted_count > 0
+            except Exception as e:
+                # If ObjectId conversion fails, try as string
+                result = self.db.microsoft_forms.delete_one({"id": form_id_str})
+                return result.deleted_count > 0
+        except Exception as e:
+            logger.error(f"Error deleting Microsoft Form {form_id}: {e}", exc_info=True)
+            return False
+
+# Global adapter instance
+db_adapter = MongoDBAdapter()

mongodb_config.py

@@ -0,0 +1,197 @@
+"""
+MongoDB Configuration and Connection Manager
+Replaces SQLite with MongoDB for the Adaptive Learning Platform
+"""
+
+import sys
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# Check for bson import conflict before importing pymongo
+try:
+    import bson
+    # Check if this is the standalone bson package (which doesn't have SON)
+    if not hasattr(bson, 'SON') and not hasattr(bson, 'objectid'):
+        logger.error("""
+        ⚠️  BSON Import Conflict Detected!
+        
+        A standalone 'bson' package is installed that conflicts with pymongo.
+        This will cause import errors.
+        
+        To fix this, run:
+            pip uninstall bson
+            pip install --upgrade pymongo
+        
+        Or see: BSON_CONFLICT_FIX.md for detailed instructions.
+        """)
+        # Don't exit - let pymongo fail with a clearer error
+except ImportError:
+    pass  # bson not installed, which is fine
+
+from pymongo import MongoClient, ASCENDING, DESCENDING
+from pymongo.errors import ConnectionFailure, OperationFailure
+try:
+    from bson.objectid import ObjectId
+except ImportError:
+    # Fallback if standalone bson package conflicts
+    try:
+        from pymongo.bson.objectid import ObjectId
+    except ImportError:
+        # Last resort - try direct import
+        import pymongo
+        ObjectId = pymongo.bson.objectid.ObjectId
+
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+
+# MongoDB Configuration
+MONGODB_CONNECTION_STRING = "mongodb+srv://raziullah0316_db_user:8GXp76aJwsg2i6Rn@learning.tlwwzix.mongodb.net/"
+MONGODB_DATABASE_NAME = "learning"
+
+class MongoDBManager:
+    """MongoDB Connection and Operations Manager"""
+    
+    def __init__(self):
+        self.client: Optional[MongoClient] = None
+        self.db = None
+        self._connected = False
+    
+    def connect(self) -> bool:
+        """Connect to MongoDB"""
+        try:
+            self.client = MongoClient(
+                MONGODB_CONNECTION_STRING,
+                serverSelectionTimeoutMS=5000,
+                connectTimeoutMS=10000,
+                retryWrites=True,
+                w='majority'
+            )
+            
+            # Test connection
+            self.client.admin.command('ping')
+            self.db = self.client[MONGODB_DATABASE_NAME]
+            self._connected = True
+            
+            logger.info(f"✅ Connected to MongoDB: {MONGODB_DATABASE_NAME}")
+            self._create_indexes()
+            return True
+            
+        except ConnectionFailure as e:
+            logger.error(f"❌ Failed to connect to MongoDB: {e}")
+            self._connected = False
+            return False
+        except Exception as e:
+            logger.error(f"❌ Unexpected error connecting to MongoDB: {e}")
+            self._connected = False
+            return False
+    
+    def _create_indexes(self):
+        """Create indexes for better performance"""
+        try:
+            # Admins collection
+            self.db.admins.create_index([("username", ASCENDING)], unique=True)
+            
+            # Students collection
+            self.db.students.create_index([("student_id", ASCENDING)], unique=True)
+            self.db.students.create_index([("email", ASCENDING)])
+            
+            # Syllabi collection
+            self.db.syllabi.create_index([("title", ASCENDING)])
+            self.db.syllabi.create_index([("uploaded_at", DESCENDING)])
+            
+            # Assessments collection
+            self.db.assessments.create_index([("student_id", ASCENDING)])
+            self.db.assessments.create_index([("syllabus_id", ASCENDING)])
+            self.db.assessments.create_index([("created_at", DESCENDING)])
+            
+            # MCQ Questions collection
+            self.db.mcq_questions.create_index([("syllabus_id", ASCENDING)])
+            self.db.mcq_questions.create_index([("topic", ASCENDING)])
+            
+            # Student Answers collection
+            self.db.student_answers.create_index([("student_id", ASCENDING), ("assessment_id", ASCENDING)])
+            
+            # Learning Paths collection
+            self.db.learning_paths.create_index([("student_id", ASCENDING)])
+            self.db.learning_paths.create_index([("status", ASCENDING)])
+            
+            # Chat Sessions collection
+            self.db.chat_sessions.create_index([("student_id", ASCENDING)])
+            self.db.chat_sessions.create_index([("created_at", DESCENDING)])
+            
+            # Learning Progress collection
+            self.db.learning_progress.create_index([("student_id", ASCENDING)])
+            self.db.learning_progress.create_index([("learning_path_id", ASCENDING)])
+            
+            # Microsoft Forms collection
+            self.db.microsoft_forms.create_index([("subject", ASCENDING)])
+            self.db.microsoft_forms.create_index([("grade", ASCENDING)])
+            self.db.microsoft_forms.create_index([("is_active", ASCENDING)])
+            self.db.microsoft_forms.create_index([("created_at", DESCENDING)])
+            
+            # Microsoft Form Submissions collection
+            self.db.microsoft_form_submissions.create_index([("student_id", ASCENDING)])
+            self.db.microsoft_form_submissions.create_index([("form_id", ASCENDING)])
+            self.db.microsoft_form_submissions.create_index([("subject", ASCENDING)])
+            self.db.microsoft_form_submissions.create_index([("submitted_at", DESCENDING)])
+            
+            logger.info("✅ MongoDB indexes created successfully")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to create some indexes: {e}")
+    
+    def is_connected(self) -> bool:
+        """Check if connected to MongoDB"""
+        return self._connected and self.client is not None
+    
+    def close(self):
+        """Close MongoDB connection"""
+        if self.client:
+            self.client.close()
+            self._connected = False
+            logger.info("MongoDB connection closed")
+    
+    def serialize_doc(self, doc: Optional[Dict]) -> Optional[Dict]:
+        """Convert MongoDB document to JSON-serializable format"""
+        if doc is None:
+            return None
+        
+        doc = dict(doc)  # Make a copy
+        
+        if "_id" in doc:
+            doc["id"] = str(doc["_id"])
+            del doc["_id"]
+        
+        for key, value in doc.items():
+            if isinstance(value, ObjectId):
+                doc[key] = str(value)
+            elif isinstance(value, datetime):
+                doc[key] = value.isoformat()
+            elif isinstance(value, dict):
+                doc[key] = self.serialize_doc(value)
+            elif isinstance(value, list):
+                doc[key] = [self.serialize_doc(item) if isinstance(item, dict) else item for item in value]
+        
+        return doc
+    
+    def get_object_id(self, id_str: str) -> ObjectId:
+        """Convert string to ObjectId"""
+        try:
+            return ObjectId(id_str)
+        except:
+            return None
+
+# Global MongoDB instance
+mongodb = MongoDBManager()
+
+# Helper functions for backward compatibility with SQLite code
+def get_db():
+    """Get MongoDB database instance (replaces SQLAlchemy session)"""
+    if not mongodb.is_connected():
+        mongodb.connect()
+    return mongodb.db
+
+def serialize_document(doc: Dict) -> Dict:
+    """Serialize MongoDB document"""
+    return mongodb.serialize_doc(doc)