Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -1,5 +1,4 @@
 #modules/database/sql_db.py
-
 from .database_init import get_container
 from datetime import datetime, timezone
 import logging
@@ -8,26 +7,25 @@ import uuid
 
 logger = logging.getLogger(__name__)
 
-###########################################
-
 def get_user(username, role=None):
     container = get_container("users")
     try:
-        query = f"SELECT * FROM c WHERE c.id = '{username}'"
-        if role:
-            query += f" AND c.role = '{role}'"
+        # Consulta básica por ID que es el partition key
         items = list(container.query_items(
-            query=query,
-            enable_cross_partition_query=True  # Añadimos esta línea
+            query=f"SELECT * FROM c WHERE c.id = @username",
+            parameters=[{"name": "@username", "value": username}],
+            partition_key=username
         ))
+        
+        # Si se especifica rol, filtrar por rol
+        if role and items:
+            items = [item for item in items if item['role'] == role]
+            
         return items[0] if items else None
     except Exception as e:
         logger.error(f"Error al obtener usuario {username}: {str(e)}")
         return None
 
-###########################################
-
-
 def get_admin_user(username):
     return get_user(username, role='Administrador')
 
@@ -37,10 +35,6 @@ def get_student_user(username):
 def get_teacher_user(username):
     return get_user(username, role='Profesor')
 
-
-
-###################################################
-
 def create_user(username, password, role, additional_info=None):
     """Crea un nuevo usuario"""
     container = get_container("users")
@@ -50,17 +44,17 @@ def create_user(username, password, role, additional_info=None):
         
     try:
         user_data = {
-            'id': username,
+            'id': username,  # Este campo es el partition key
             'password': password,
             'role': role,
             'timestamp': datetime.now(timezone.utc).isoformat(),
-            'additional_info': additional_info or {},
-            'partitionKey': username  # Añadimos esta línea
+            'additional_info': additional_info or {}
         }
         
+        # Usar el id como partition key
         container.create_item(
             body=user_data,
-            enable_cross_partition_query=True  # Añadimos esta línea
+            partition_key=username
         )
         logger.info(f"Usuario {role} creado: {username}")
         return True
@@ -69,8 +63,6 @@ def create_user(username, password, role, additional_info=None):
         logger.error(f"Error al crear usuario {role}: {str(e)}")
         return False
 
-
-#######################################################
 def create_student_user(username, password, additional_info=None):
     return create_user(username, password, 'Estudiante', additional_info)
 
@@ -80,10 +72,6 @@ def create_teacher_user(username, password, additional_info=None):
 def create_admin_user(username, password, additional_info=None):
     return create_user(username, password, 'Administrador', additional_info)
 
-############-- Funciones de control del tiempo de sesión ##################
-
-###########################################################
-
 def record_login(username):
     """Registra el inicio de sesión de un usuario"""
     try:
@@ -98,12 +86,12 @@ def record_login(username):
             "type": "session",
             "username": username,
             "loginTime": datetime.now(timezone.utc).isoformat(),
-            "additional_info": {},
-            "partitionKey": username
+            "additional_info": {}
         }
 
         result = container.create_item(
-            body=session_doc  # Solo el body
+            body=session_doc,
+            enable_cross_partition_query=True
         )
         logger.info(f"Sesión {session_id} registrada para {username}")
         return session_id
@@ -111,8 +99,6 @@ def record_login(username):
         logger.error(f"Error registrando login: {str(e)}")
         return None
 
-###########################################################
-
 def record_logout(username, session_id):
     """Registra el cierre de sesión y calcula la duración"""
     try:
@@ -121,15 +107,13 @@ def record_logout(username, session_id):
             logger.error("No se pudo obtener el contenedor users_sessions")
             return False
 
-        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
-        params = [
-            {"name": "@id", "value": session_id},
-            {"name": "@username", "value": username}
-        ]
-        
         items = list(container.query_items(
-            query=query,
-            parameters=params  # Removido enable_cross_partition_query
+            query="SELECT * FROM c WHERE c.id = @id AND c.username = @username",
+            parameters=[
+                {"name": "@id", "value": session_id},
+                {"name": "@username", "value": username}
+            ],
+            enable_cross_partition_query=True
         ))
 
         if not items:
@@ -143,12 +127,12 @@ def record_logout(username, session_id):
 
         session.update({
             "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration,
-            "partitionKey": username  # Asegurar que partitionKey esté presente
+            "sessionDuration": duration
         })
 
         container.upsert_item(
-            body=session  # Solo el body
+            body=session,
+            enable_cross_partition_query=True
         )
         logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
         return True
@@ -156,9 +140,6 @@ def record_logout(username, session_id):
         logger.error(f"Error registrando logout: {str(e)}")
         return False
 
-
-###########################################################
-
 def get_recent_sessions(limit=10):
     """Obtiene las sesiones más recientes"""
     try:
@@ -167,17 +148,16 @@ def get_recent_sessions(limit=10):
             logger.error("No se pudo obtener el contenedor users_sessions")
             return []
 
-        query = """
-        SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
-        FROM c
-        WHERE c.type = 'session'
-        ORDER BY c.loginTime DESC
-        OFFSET 0 LIMIT @limit
-        """
-        
         sessions = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@limit", "value": limit}]  # Removido enable_cross_partition_query
+            query="""
+            SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
+            FROM c
+            WHERE c.type = 'session'
+            ORDER BY c.loginTime DESC
+            OFFSET 0 LIMIT @limit
+            """,
+            parameters=[{"name": "@limit", "value": limit}],
+            enable_cross_partition_query=True
         ))
 
         clean_sessions = []
@@ -198,10 +178,6 @@ def get_recent_sessions(limit=10):
         logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
         return []
 
-
-
-###########################################################
-
 def get_user_total_time(username):
     """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
     try:
@@ -209,132 +185,19 @@ def get_user_total_time(username):
         if not container:
             return None
 
-        query = """
-        SELECT VALUE SUM(c.sessionDuration)
-        FROM c
-        WHERE c.type = 'session'
-        AND c.username = @username
-        AND IS_DEFINED(c.sessionDuration)
-        """
-        
         result = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@username", "value": username}]  # Removido enable_cross_partition_query
+            query="""
+            SELECT VALUE SUM(c.sessionDuration)
+            FROM c
+            WHERE c.type = 'session'
+            AND c.username = @username
+            AND IS_DEFINED(c.sessionDuration)
+            """,
+            parameters=[{"name": "@username", "value": username}],
+            enable_cross_partition_query=True
         ))
 
         return result[0] if result and result[0] is not None else 0
     except Exception as e:
         logger.error(f"Error obteniendo tiempo total: {str(e)}")
         return 0
-
-###########################################################
-def update_student_user(username, new_info):
-    user_container, _, _ = get_sql_containers()
-    try:
-        user = get_student_user(username)
-        if user:
-            user['additional_info'].update(new_info)
-            user_container.upsert_item(body=user)
-            logger.info(f"Información del estudiante actualizada: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
-        return False
-
-
-#########################################################
-def delete_student_user(username):
-    user_container, _, _ = get_sql_containers()
-    try:
-        user = get_student_user(username)
-        if user:
-            user_container.delete_item(item=user['id'], partition_key=username)
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
-        return False
-
-
-
-#########################################################
-
-def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
-    """Almacena una solicitud de aplicación"""
-    try:
-        # Obtener el contenedor usando get_container() que sí funciona
-        container = get_container("application_requests")
-        if not container:
-            logger.error("No se pudo obtener el contenedor de solicitudes")
-            return False
-
-        # Crear documento con la solicitud
-        # Nótese que incluimos email como partition key en el cuerpo del documento
-        application_request = {
-            "id": str(uuid.uuid4()),
-            "name": name,
-            "lastname": lastname,
-            "email": email,
-            "institution": institution,
-            "current_role": current_role,
-            "desired_role": desired_role,
-            "reason": reason,
-            "requestDate": datetime.utcnow().isoformat(),
-            # El campo para partition key debe estar en el documento
-            "partitionKey": email
-        }
-        
-        # Crear el item en el contenedor - sin el parámetro enable_cross_partition_query
-        container.create_item(
-            body=application_request  # Solo pasamos el body
-        )
-        logger.info(f"Solicitud de aplicación almacenada para: {email}")
-        return True
-        
-    except Exception as e:
-        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
-        logger.error(f"Detalles del error: {str(e)}")
-        return False
-
-############################################################
-def store_student_feedback(username, name, email, feedback):
-    """Almacena el feedback de un estudiante"""
-    try:
-        # Obtener el contenedor - verificar disponibilidad
-        logger.info(f"Intentando obtener contenedor user_feedback para usuario: {username}")
-        container = get_container("user_feedback")
-        if not container:
-            logger.error("No se pudo obtener el contenedor user_feedback")
-            return False
-
-        # Crear documento de feedback - asegurar que el username esté como partition key
-        feedback_item = {
-            "id": str(uuid.uuid4()),
-            "username": username,  # Campo regular
-            "name": name,
-            "email": email,
-            "feedback": feedback,
-            "role": "Estudiante",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "partitionKey": username  # Campo de partición
-        }
-
-        # Crear el item - sin el parámetro enable_cross_partition_query
-        logger.info(f"Intentando almacenar feedback para usuario: {username}")
-        result = container.create_item(
-            body=feedback_item  # Solo el body, no parámetros adicionales
-        )
-        
-        logger.info(f"Feedback almacenado exitosamente para el usuario: {username}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Error al almacenar el feedback del estudiante {username}")
-        logger.error(f"Detalles del error: {str(e)}")
-        return False