new user tracking

tools.py

@@ -5,7 +5,6 @@ MCP Tools for Session Management and Quiz
 import json
 import uuid
 import random
-from datetime import datetime
 from mcp.server.fastmcp import FastMCP
 from pydantic import Field
 from typing import Dict, List, Optional
@@ -41,15 +40,10 @@ def register_tools(mcp: FastMCP, db_getter):
             if session_doc.exists:
                 session_data = session_doc.to_dict()
             
-            # Add the new player with enhanced tracking
+            # Add the new player to the players list  
             new_player = {
                 'pseudo': player_pseudo,
-                'score': 0,  # Initialize score to 0
-                'answered_questions': [],  # Track which questions this user has answered
-                'answer_history': [],  # Detailed history of all answers
-                'current_question_index': 0,  # Individual progress tracking
-                'session_start_time': {'$timestamp': 'server'},
-                'last_activity': {'$timestamp': 'server'}
+                'score': 0  # Initialize score to 0
             }
             
             # Check if player already exists in this session
@@ -185,41 +179,13 @@ def register_tools(mcp: FastMCP, db_getter):
             correct_answer = current_question.get('correct')
             is_correct = answer_index == correct_answer
             
-            # Find and update player with enhanced tracking
+            # Find and update player score
             player_found = False
             new_score = 0
             for player in players:
                 if player.get('pseudo') == player_pseudo:
-                    # Create detailed answer record
-                    answer_record = {
-                        'question_id': current_question.get('id'),
-                        'question_index': current_question_index,
-                        'submitted_answer': answer_index,
-                        'correct_answer': correct_answer,
-                        'is_correct': is_correct,
-                        'timestamp': {'$timestamp': 'server'},
-                        'response_time': None  # Could be calculated if we track question start time
-                    }
-                    
-                    # Update player data
                     if is_correct:
                         player['score'] = player.get('score', 0) + 1
-                    
-                    # Add to answer history
-                    answer_history = player.get('answer_history', [])
-                    answer_history.append(answer_record)
-                    player['answer_history'] = answer_history
-                    
-                    # Add question ID to answered questions if not already there
-                    answered_questions = player.get('answered_questions', [])
-                    question_id = current_question.get('id')
-                    if question_id not in answered_questions:
-                        answered_questions.append(question_id)
-                        player['answered_questions'] = answered_questions
-                    
-                    # Update activity timestamp
-                    player['last_activity'] = {'$timestamp': 'server'}
-                    
                     new_score = player.get('score', 0)
                     player_found = True
                     break
@@ -288,234 +254,4 @@ def register_tools(mcp: FastMCP, db_getter):
             return json.dumps(result, indent=2)
             
         except Exception as e:
-            return f"Error getting scores: {str(e)}"
-
-    @mcp.tool(
-        title="Get User Progress",
-        description="Get detailed progress information for a specific user including answer history",
-    )
-    async def get_user_progress(
-        session_id: str = Field(description="The ID of the quiz session"),
-        player_pseudo: str = Field(description="The pseudo/username of the player")
-    ) -> str:
-        """Get detailed user progress and answer history"""
-        try:
-            # Get database client lazily
-            db = db_getter()
-            session_ref = db.collection('quiz_sessions').document(session_id)
-            session_doc = session_ref.get()
-            
-            if not session_doc.exists:
-                return f"Session '{session_id}' not found"
-            
-            session_data = session_doc.to_dict()
-            players = session_data.get('players', [])
-            
-            # Find the specific player
-            player = next((p for p in players if p.get('pseudo') == player_pseudo), None)
-            if not player:
-                return f"Player '{player_pseudo}' not found in session '{session_id}'"
-            
-            # Get session questions for context
-            questions = session_data.get('questions', [])
-            total_questions = len(questions)
-            
-            result = {
-                "player_pseudo": player_pseudo,
-                "session_id": session_id,
-                "current_score": player.get('score', 0),
-                "answered_questions": player.get('answered_questions', []),
-                "answer_history": player.get('answer_history', []),
-                "current_question_index": player.get('current_question_index', 0),
-                "total_questions": total_questions,
-                "questions_remaining": total_questions - len(player.get('answered_questions', [])),
-                "session_start_time": player.get('session_start_time'),
-                "last_activity": player.get('last_activity'),
-                "completion_percentage": (len(player.get('answered_questions', [])) / total_questions * 100) if total_questions > 0 else 0
-            }
-            
-            return json.dumps(result, indent=2)
-            
-        except Exception as e:
-            return f"Error getting user progress: {str(e)}"
-
-    @mcp.tool(
-        title="Get Next Question for User",
-        description="Get the next question specifically for a user based on their individual progress",
-    )
-    async def get_next_question_for_user(
-        session_id: str = Field(description="The ID of the quiz session"),
-        player_pseudo: str = Field(description="The pseudo/username of the player")
-    ) -> str:
-        """Get the next unanswered question for a specific user"""
-        try:
-            # Get database client lazily
-            db = db_getter()
-            session_ref = db.collection('quiz_sessions').document(session_id)
-            session_doc = session_ref.get()
-            
-            if not session_doc.exists:
-                return f"Session '{session_id}' not found"
-            
-            session_data = session_doc.to_dict()
-            questions = session_data.get('questions', [])
-            players = session_data.get('players', [])
-            
-            if not questions:
-                return json.dumps({
-                    "error": "No questions available",
-                    "message": "This session has no questions configured."
-                }, indent=2)
-            
-            # Find the specific player
-            player = next((p for p in players if p.get('pseudo') == player_pseudo), None)
-            if not player:
-                return f"Player '{player_pseudo}' not found in session '{session_id}'"
-            
-            # Get questions this user has already answered
-            answered_question_ids = player.get('answered_questions', [])
-            
-            # Find next unanswered question
-            next_question = None
-            next_question_index = None
-            
-            for i, question in enumerate(questions):
-                question_id = question.get('id')
-                if question_id not in answered_question_ids:
-                    next_question = question
-                    next_question_index = i
-                    break
-            
-            if next_question is None:
-                return json.dumps({
-                    "finished": True,
-                    "message": f"Player '{player_pseudo}' has completed all questions",
-                    "total_questions": len(questions),
-                    "answered_questions": len(answered_question_ids)
-                }, indent=2)
-            
-            # Format the response (without the correct answer)
-            question_data = {
-                "question_id": next_question.get('id'),
-                "question_text": next_question.get('question'),
-                "options": next_question.get('options', []),
-                "question_number": next_question_index + 1,
-                "total_questions": len(questions),
-                "player_progress": {
-                    "answered": len(answered_question_ids),
-                    "remaining": len(questions) - len(answered_question_ids),
-                    "completion_percentage": (len(answered_question_ids) / len(questions) * 100)
-                }
-            }
-            
-            return json.dumps(question_data, indent=2)
-            
-        except Exception as e:
-            return f"Error getting next question for user: {str(e)}"
-
-    @mcp.tool(
-        title="Update User Question Index",
-        description="Update a user's current question index for manual progression control",
-    )
-    async def update_user_question_index(
-        session_id: str = Field(description="The ID of the quiz session"),
-        player_pseudo: str = Field(description="The pseudo/username of the player"),
-        question_index: int = Field(description="The new question index for the user")
-    ) -> str:
-        """Update user's current question index"""
-        try:
-            # Get database client lazily
-            db = db_getter()
-            session_ref = db.collection('quiz_sessions').document(session_id)
-            session_doc = session_ref.get()
-            
-            if not session_doc.exists:
-                return f"Session '{session_id}' not found"
-            
-            session_data = session_doc.to_dict()
-            players = session_data.get('players', [])
-            questions = session_data.get('questions', [])
-            
-            # Validate question index
-            if question_index < 0 or question_index >= len(questions):
-                return f"Invalid question index. Must be between 0 and {len(questions) - 1}"
-            
-            # Find and update the specific player
-            player_found = False
-            for player in players:
-                if player.get('pseudo') == player_pseudo:
-                    player['current_question_index'] = question_index
-                    player['last_activity'] = {'$timestamp': 'server'}
-                    player_found = True
-                    break
-            
-            if not player_found:
-                return f"Player '{player_pseudo}' not found in session '{session_id}'"
-            
-            # Update session document
-            session_data['players'] = players
-            session_ref.set(session_data, merge=True)
-            
-            result = {
-                "player_pseudo": player_pseudo,
-                "session_id": session_id,
-                "new_question_index": question_index,
-                "question_title": questions[question_index].get('question', 'N/A')[:50] + "...",
-                "message": f"Successfully updated question index for '{player_pseudo}'"
-            }
-            
-            return json.dumps(result, indent=2)
-            
-        except Exception as e:
-            return f"Error updating user question index: {str(e)}"
-
-    @mcp.tool(
-        title="Reset User Progress",
-        description="Reset a user's progress including answer history and scores",
-    )
-    async def reset_user_progress(
-        session_id: str = Field(description="The ID of the quiz session"),
-        player_pseudo: str = Field(description="The pseudo/username of the player")
-    ) -> str:
-        """Reset user's progress to start over"""
-        try:
-            # Get database client lazily
-            db = db_getter()
-            session_ref = db.collection('quiz_sessions').document(session_id)
-            session_doc = session_ref.get()
-            
-            if not session_doc.exists:
-                return f"Session '{session_id}' not found"
-            
-            session_data = session_doc.to_dict()
-            players = session_data.get('players', [])
-            
-            # Find and reset the specific player
-            player_found = False
-            for player in players:
-                if player.get('pseudo') == player_pseudo:
-                    player['score'] = 0
-                    player['answered_questions'] = []
-                    player['answer_history'] = []
-                    player['current_question_index'] = 0
-                    player['last_activity'] = {'$timestamp': 'server'}
-                    player_found = True
-                    break
-            
-            if not player_found:
-                return f"Player '{player_pseudo}' not found in session '{session_id}'"
-            
-            # Update session document
-            session_data['players'] = players
-            session_ref.set(session_data, merge=True)
-            
-            result = {
-                "player_pseudo": player_pseudo,
-                "session_id": session_id,
-                "message": f"Successfully reset progress for '{player_pseudo}'"
-            }
-            
-            return json.dumps(result, indent=2)
-            
-        except Exception as e:
-            return f"Error resetting user progress: {str(e)}"
+            return f"Error getting scores: {str(e)}"