Spaces:

noodledom
/

focusflow

Sleeping

Complete per-user data isolation, bug fixes, and Admin wipe trigger

dca819c 8 months ago

12.2 kB

"""
Student Profile Manager - Handles persistent storage of student learning data
Supports both local JSON files and cloud Supabase storage.
"""
import json
import os
import shutil
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional
import threading
import logging

logger = logging.getLogger(__name__)

class StudentProfileManager:
    """Manages student profile data with JSON file or Supabase persistence"""
    
    def __init__(self, student_id: Optional[str] = None):
        # 1. Generate unique student ID per user session
        if student_id:
            self.student_id = student_id
        else:
            import uuid
            self.student_id = f"student_{uuid.uuid4().hex[:12]}"

        logger.info(f"StudentProfileManager initialized for {self.student_id}")

        # 2. Auto-detect Supabase (don't strictly require USE_SUPABASE to be true)
        try:
            from backend.supabase_storage import SupabaseStorage
            self.supabase = SupabaseStorage()
            if self.supabase.is_available():
                logger.info("Using Supabase for persistent storage")
                self.use_supabase = True
                self.storage_mode = "supabase"
            else:
                logger.warning("Supabase no available, falling back to local storage")
                self.use_supabase = False
                self.storage_mode = "local"
        except Exception as e:
            logger.error(f"Failed to initialize Supabase: {e}")
            self.use_supabase = False
            self.storage_mode = "local"
        
        # 3. Local storage setup (always available as fallback)
        self.profile_dir = Path.home() / ".focusflow"
        
        # FIX: Include student_id in profile filenames to prevent users overwriting each other in local mode
        safe_id = "".join(c if c.isalnum() else "_" for c in self.student_id)[:40]
        self.profile_file = self.profile_dir / f"profile_{safe_id}.json"
        self.backup_file = self.profile_dir / f"profile_{safe_id}.backup.json"
        
        self.lock = threading.Lock()
        
        if not self.use_supabase:
            self._ensure_profile_exists()
    
    def _ensure_profile_exists(self):
        """Create profile directory and file if not exists"""
        self.profile_dir.mkdir(exist_ok=True)
        
        if not self.profile_file.exists():
            # Create new profile with default structure
            default_profile = {
                "student_id": f"student_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
                "created_at": datetime.now().isoformat(),
                "study_plan": {
                    "plan_id": None,
                    "topics": [],
                    "num_days": 0
                },
                "current_study_day": 1,
                "last_access_date": datetime.now().strftime("%Y-%m-%d"),
                "quiz_history": [],
                "mastery_tracker": {},
                "time_tracking": {
                    "total_study_time_minutes": 0,
                    "topics_time": {}
                },
                "incomplete_tasks": []
            }
            self._save_to_file(default_profile)
    
    def _save_to_file(self, profile: dict):
        """Atomic write to file with backup"""
        try:
            # Create backup of existing file
            if self.profile_file.exists():
                shutil.copy2(self.profile_file, self.backup_file)
            
            # Write to temporary file first
            temp_file = self.profile_file.with_suffix('.tmp')
            with open(temp_file, 'w') as f:
                json.dump(profile, f, indent=2)
            
            # Atomic rename
            temp_file.replace(self.profile_file)
            
        except Exception as e:
            # Error saving profile, attempt to restore from backup
            if self.backup_file.exists():
                shutil.copy2(self.backup_file, self.profile_file)
            raise
    
    def load_profile(self) -> dict:
        """Load student profile from Supabase or local disk"""
        with self.lock:
            if self.use_supabase:
                try:
                    profile = self.supabase.load_profile(self.student_id)
                    if profile:
                        return profile
                    else:
                        # Create default profile for new user
                        default_profile = self._get_default_profile()
                        self.supabase.save_profile(self.student_id, default_profile)
                        return default_profile
                except Exception as e:
                    logger.error(f"Error loading from Supabase: {e}")
                    return self._get_default_profile()
            else:
                # Local JSON storage
                try:
                    with open(self.profile_file, 'r') as f:
                        profile = json.load(f)
                    
                    # Update last active
                    profile["last_active"] = datetime.now().isoformat()
                    self._save_to_file(profile)
                    
                    return profile
                except Exception as e:
                    logger.error(f"Error loading from file: {e}")
                    # Return default profile
                    self._ensure_profile_exists()
                    return self.load_profile()
    
    
    def save_profile(self, profile: dict):
        """Save student profile to Supabase or local disk"""
        with self.lock:
            profile["last_active"] = datetime.now().isoformat()
            
            if self.use_supabase:
                try:
                    success = self.supabase.save_profile(self.student_id, profile)
                    if not success:
                        logger.warning("Failed to save to Supabase")
                except Exception as e:
                    logger.error(f"Error saving to Supabase: {e}")
            else:
                # Local JSON storage
                self._save_to_file(profile)
    
    def _get_default_profile(self) -> dict:
        """Get default profile structure"""
        return {
            "student_id": self.student_id,
            "created_at": datetime.now().isoformat(),
            "study_plan": {
                "plan_id": None,
                "topics": [],
                "num_days": 0
            },
            "current_study_day": 1,
            "last_access_date": datetime.now().strftime("%Y-%m-%d"),
            "quiz_history": [],
            "mastery_tracker": {},
            "time_tracking": {
                "total_study_time_minutes": 0,
                "topics_time": {}
            },
            "incomplete_tasks": []
        }
    
    def update_current_state(self, current_day: int, current_topic_id: Optional[int], plan_id: Optional[str]):
        """Update current position in study plan"""
        profile = self.load_profile()
        profile["current_state"] = {
            "current_day": current_day,
            "current_topic_id": current_topic_id,
            "active_plan_id": plan_id
        }
        self.save_profile(profile)
    
    def save_study_plan(self, topics: List[dict], num_days: int):
        """Save study plan"""
        profile = self.load_profile()
        plan_id = f"plan_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        
        profile["study_plan"] = {
            "plan_id": plan_id,
            "created_at": datetime.now().isoformat(),
            "num_days": num_days,
            "topics": topics
        }
        
        # Ensure current_state exists
        if "current_state" not in profile:
            profile["current_state"] = {}
        profile["current_state"]["active_plan_id"] = plan_id
        
        self.save_profile(profile)
        return plan_id
    
    def update_quiz_score(self, topic_id: int, topic_title: str, subject: str, score: int, total: int, time_taken: int = 0):
        """Record quiz performance"""
        profile = self.load_profile()
        
        percentage = (score / total * 100) if total > 0 else 0
        
        # Add to quiz history
        quiz_record = {
            "topic_id": topic_id,
            "topic_title": topic_title,
            "subject": subject,
            "timestamp": datetime.now().isoformat(),
            "score": score,
            "total": total,
            "percentage": percentage,
            "time_taken_seconds": time_taken
        }
        profile["quiz_history"].append(quiz_record)
        
        # Update mastery tracker
        self._update_mastery(profile, subject, percentage)
        
        self.save_profile(profile)
    
    def _update_mastery(self, profile: dict, subject: str, score_percentage: float):
        """Update subject mastery level"""
        if subject not in profile["mastery_tracker"]:
            profile["mastery_tracker"][subject] = {
                "avg_score": 0,
                "topics_completed": 0,
                "total_topics": 0,
                "mastery_level": "medium",
                "scores": []
            }
        
        mastery = profile["mastery_tracker"][subject]
        mastery["scores"].append(score_percentage)
        mastery["topics_completed"] += 1
        
        # Calculate average
        mastery["avg_score"] = sum(mastery["scores"]) / len(mastery["scores"])
        
        # Determine mastery level
        avg = mastery["avg_score"]
        if avg >= 75:
            mastery["mastery_level"] = "high"
        elif avg >= 50:
            mastery["mastery_level"] = "medium"
        else:
            mastery["mastery_level"] = "low"
    
    def mark_topic_complete(self, topic_id: int, completed_at: Optional[str] = None):
        """Mark a topic as completed"""
        profile = self.load_profile()
        
        if not completed_at:
            completed_at = datetime.now().isoformat()
        
        # Update topic in study plan
        for topic in profile["study_plan"]["topics"]:
            if topic["id"] == topic_id:
                topic["status"] = "completed"
                topic["completed_at"] = completed_at
                break
        
        # Remove from incomplete tasks if present
        profile["incomplete_tasks"] = [
            t for t in profile["incomplete_tasks"] if t["topic_id"] != topic_id
        ]
        
        self.save_profile(profile)
    
    def add_incomplete_task(self, topic_id: int, from_day: int, reason: str = "not_completed"):
        """Mark a task as incomplete"""
        profile = self.load_profile()
        
        # Check if already in incomplete list
        if not any(t["topic_id"] == topic_id for t in profile["incomplete_tasks"]):
            profile["incomplete_tasks"].append({
                "topic_id": topic_id,
                "from_day": from_day,
                "reason": reason,
                "added_at": datetime.now().isoformat()
            })
        
        self.save_profile(profile)
    
    def get_incomplete_tasks(self, current_day: int) -> List[dict]:
        """Get tasks not completed from previous days"""
        profile = self.load_profile()
        
        # Get incomplete tasks from previous days
        return [
            t for t in profile["incomplete_tasks"] 
            if t["from_day"] < current_day
        ]
    
    def get_mastery_data(self) -> Dict[str, dict]:
        """Get mastery tracker data"""
        profile = self.load_profile()
        return profile.get("mastery_tracker", {})
    
    def record_study_time(self, topic_id: int, minutes: int):
        """Record time spent on a topic"""
        profile = self.load_profile()
        
        profile["time_tracking"]["total_study_time_minutes"] += minutes
        
        topic_id_str = str(topic_id)
        if topic_id_str not in profile["time_tracking"]["topics_time"]:
            profile["time_tracking"]["topics_time"][topic_id_str] = 0
        
        profile["time_tracking"]["topics_time"][topic_id_str] += minutes
        
        self.save_profile(profile)

	"""
	Student Profile Manager - Handles persistent storage of student learning data
	Supports both local JSON files and cloud Supabase storage.
	"""
	import json
	import os
	import shutil
	from datetime import datetime
	from pathlib import Path
	from typing import Dict, List, Optional
	import threading
	import logging

	logger = logging.getLogger(__name__)

	class StudentProfileManager:
	"""Manages student profile data with JSON file or Supabase persistence"""

	def __init__(self, student_id: Optional[str] = None):
	# 1. Generate unique student ID per user session
	if student_id:
	self.student_id = student_id
	else:
	import uuid
	self.student_id = f"student_{uuid.uuid4().hex[:12]}"

	logger.info(f"StudentProfileManager initialized for {self.student_id}")

	# 2. Auto-detect Supabase (don't strictly require USE_SUPABASE to be true)
	try:
	from backend.supabase_storage import SupabaseStorage
	self.supabase = SupabaseStorage()
	if self.supabase.is_available():
	logger.info("Using Supabase for persistent storage")
	self.use_supabase = True
	self.storage_mode = "supabase"
	else:
	logger.warning("Supabase no available, falling back to local storage")
	self.use_supabase = False
	self.storage_mode = "local"
	except Exception as e:
	logger.error(f"Failed to initialize Supabase: {e}")
	self.use_supabase = False
	self.storage_mode = "local"

	# 3. Local storage setup (always available as fallback)
	self.profile_dir = Path.home() / ".focusflow"

	# FIX: Include student_id in profile filenames to prevent users overwriting each other in local mode
	safe_id = "".join(c if c.isalnum() else "_" for c in self.student_id)[:40]
	self.profile_file = self.profile_dir / f"profile_{safe_id}.json"
	self.backup_file = self.profile_dir / f"profile_{safe_id}.backup.json"

	self.lock = threading.Lock()

	if not self.use_supabase:
	self._ensure_profile_exists()

	def _ensure_profile_exists(self):
	"""Create profile directory and file if not exists"""
	self.profile_dir.mkdir(exist_ok=True)

	if not self.profile_file.exists():
	# Create new profile with default structure
	default_profile = {
	"student_id": f"student_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
	"created_at": datetime.now().isoformat(),
	"study_plan": {
	"plan_id": None,
	"topics": [],
	"num_days": 0
	},
	"current_study_day": 1,
	"last_access_date": datetime.now().strftime("%Y-%m-%d"),
	"quiz_history": [],
	"mastery_tracker": {},
	"time_tracking": {
	"total_study_time_minutes": 0,
	"topics_time": {}
	},
	"incomplete_tasks": []
	}
	self._save_to_file(default_profile)

	def _save_to_file(self, profile: dict):
	"""Atomic write to file with backup"""
	try:
	# Create backup of existing file
	if self.profile_file.exists():
	shutil.copy2(self.profile_file, self.backup_file)

	# Write to temporary file first
	temp_file = self.profile_file.with_suffix('.tmp')
	with open(temp_file, 'w') as f:
	json.dump(profile, f, indent=2)

	# Atomic rename
	temp_file.replace(self.profile_file)

	except Exception as e:
	# Error saving profile, attempt to restore from backup
	if self.backup_file.exists():
	shutil.copy2(self.backup_file, self.profile_file)
	raise

	def load_profile(self) -> dict:
	"""Load student profile from Supabase or local disk"""
	with self.lock:
	if self.use_supabase:
	try:
	profile = self.supabase.load_profile(self.student_id)
	if profile:
	return profile
	else:
	# Create default profile for new user
	default_profile = self._get_default_profile()
	self.supabase.save_profile(self.student_id, default_profile)
	return default_profile
	except Exception as e:
	logger.error(f"Error loading from Supabase: {e}")
	return self._get_default_profile()
	else:
	# Local JSON storage
	try:
	with open(self.profile_file, 'r') as f:
	profile = json.load(f)

	# Update last active
	profile["last_active"] = datetime.now().isoformat()
	self._save_to_file(profile)

	return profile
	except Exception as e:
	logger.error(f"Error loading from file: {e}")
	# Return default profile
	self._ensure_profile_exists()
	return self.load_profile()


	def save_profile(self, profile: dict):
	"""Save student profile to Supabase or local disk"""
	with self.lock:
	profile["last_active"] = datetime.now().isoformat()

	if self.use_supabase:
	try:
	success = self.supabase.save_profile(self.student_id, profile)
	if not success:
	logger.warning("Failed to save to Supabase")
	except Exception as e:
	logger.error(f"Error saving to Supabase: {e}")
	else:
	# Local JSON storage
	self._save_to_file(profile)

	def _get_default_profile(self) -> dict:
	"""Get default profile structure"""
	return {
	"student_id": self.student_id,
	"created_at": datetime.now().isoformat(),
	"study_plan": {
	"plan_id": None,
	"topics": [],
	"num_days": 0
	},
	"current_study_day": 1,
	"last_access_date": datetime.now().strftime("%Y-%m-%d"),
	"quiz_history": [],
	"mastery_tracker": {},
	"time_tracking": {
	"total_study_time_minutes": 0,
	"topics_time": {}
	},
	"incomplete_tasks": []
	}

	def update_current_state(self, current_day: int, current_topic_id: Optional[int], plan_id: Optional[str]):
	"""Update current position in study plan"""
	profile = self.load_profile()
	profile["current_state"] = {
	"current_day": current_day,
	"current_topic_id": current_topic_id,
	"active_plan_id": plan_id
	}
	self.save_profile(profile)

	def save_study_plan(self, topics: List[dict], num_days: int):
	"""Save study plan"""
	profile = self.load_profile()
	plan_id = f"plan_{datetime.now().strftime('%Y%m%d_%H%M%S')}"

	profile["study_plan"] = {
	"plan_id": plan_id,
	"created_at": datetime.now().isoformat(),
	"num_days": num_days,
	"topics": topics
	}

	# Ensure current_state exists
	if "current_state" not in profile:
	profile["current_state"] = {}
	profile["current_state"]["active_plan_id"] = plan_id

	self.save_profile(profile)
	return plan_id

	def update_quiz_score(self, topic_id: int, topic_title: str, subject: str, score: int, total: int, time_taken: int = 0):
	"""Record quiz performance"""
	profile = self.load_profile()

	percentage = (score / total * 100) if total > 0 else 0

	# Add to quiz history
	quiz_record = {
	"topic_id": topic_id,
	"topic_title": topic_title,
	"subject": subject,
	"timestamp": datetime.now().isoformat(),
	"score": score,
	"total": total,
	"percentage": percentage,
	"time_taken_seconds": time_taken
	}
	profile["quiz_history"].append(quiz_record)

	# Update mastery tracker
	self._update_mastery(profile, subject, percentage)

	self.save_profile(profile)

	def _update_mastery(self, profile: dict, subject: str, score_percentage: float):
	"""Update subject mastery level"""
	if subject not in profile["mastery_tracker"]:
	profile["mastery_tracker"][subject] = {
	"avg_score": 0,
	"topics_completed": 0,
	"total_topics": 0,
	"mastery_level": "medium",
	"scores": []
	}

	mastery = profile["mastery_tracker"][subject]
	mastery["scores"].append(score_percentage)
	mastery["topics_completed"] += 1

	# Calculate average
	mastery["avg_score"] = sum(mastery["scores"]) / len(mastery["scores"])

	# Determine mastery level
	avg = mastery["avg_score"]
	if avg >= 75:
	mastery["mastery_level"] = "high"
	elif avg >= 50:
	mastery["mastery_level"] = "medium"
	else:
	mastery["mastery_level"] = "low"

	def mark_topic_complete(self, topic_id: int, completed_at: Optional[str] = None):
	"""Mark a topic as completed"""
	profile = self.load_profile()

	if not completed_at:
	completed_at = datetime.now().isoformat()

	# Update topic in study plan
	for topic in profile["study_plan"]["topics"]:
	if topic["id"] == topic_id:
	topic["status"] = "completed"
	topic["completed_at"] = completed_at
	break

	# Remove from incomplete tasks if present
	profile["incomplete_tasks"] = [
	t for t in profile["incomplete_tasks"] if t["topic_id"] != topic_id
	]

	self.save_profile(profile)

	def add_incomplete_task(self, topic_id: int, from_day: int, reason: str = "not_completed"):
	"""Mark a task as incomplete"""
	profile = self.load_profile()

	# Check if already in incomplete list
	if not any(t["topic_id"] == topic_id for t in profile["incomplete_tasks"]):
	profile["incomplete_tasks"].append({
	"topic_id": topic_id,
	"from_day": from_day,
	"reason": reason,
	"added_at": datetime.now().isoformat()
	})

	self.save_profile(profile)

	def get_incomplete_tasks(self, current_day: int) -> List[dict]:
	"""Get tasks not completed from previous days"""
	profile = self.load_profile()

	# Get incomplete tasks from previous days
	return [
	t for t in profile["incomplete_tasks"]
	if t["from_day"] < current_day
	]

	def get_mastery_data(self) -> Dict[str, dict]:
	"""Get mastery tracker data"""
	profile = self.load_profile()
	return profile.get("mastery_tracker", {})

	def record_study_time(self, topic_id: int, minutes: int):
	"""Record time spent on a topic"""
	profile = self.load_profile()

	profile["time_tracking"]["total_study_time_minutes"] += minutes

	topic_id_str = str(topic_id)
	if topic_id_str not in profile["time_tracking"]["topics_time"]:
	profile["time_tracking"]["topics_time"][topic_id_str] = 0

	profile["time_tracking"]["topics_time"][topic_id_str] += minutes

	self.save_profile(profile)