Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -1,4 +1,4 @@
-#modules/database/sql_db.py
+# modules/database/sql_db.py
 
 from .database_init import get_container
 from datetime import datetime, timezone
@@ -8,30 +8,36 @@ 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}'"
-        items = list(container.query_items(
-            query=query,
-            enable_cross_partition_query=True
-        ))
+        items = list(container.query_items(query=query))
         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')
 
+
+#########################################
 def get_student_user(username):
     return get_user(username, role='Estudiante')
 
+
+#########################################
 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")
@@ -45,13 +51,12 @@ def create_user(username, password, role, additional_info=None):
             'password': password,
             'role': role,
             'timestamp': datetime.now(timezone.utc).isoformat(),
-            'additional_info': additional_info or {}
+            'additional_info': additional_info or {},
+            'partitionKey': username  # Agregar partition key
         }
         
-        container.create_item(
-            body=user_data,
-            partition_key=username
-        )
+        # Crear item sin especificar partition_key en el método
+        container.create_item(body=user_data)
         logger.info(f"Usuario {role} creado: {username}")
         return True
         
@@ -59,19 +64,19 @@ 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)
 
+#########################################
 def create_teacher_user(username, password, additional_info=None):
     return create_user(username, password, 'Profesor', additional_info)
 
+#########################################
 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:
@@ -87,24 +92,17 @@ def record_login(username):
             "username": username,
             "loginTime": datetime.now(timezone.utc).isoformat(),
             "additional_info": {},
-            # El campo para partition key debe estar en el documento
             "partitionKey": username
         }
 
-        # Crear el documento usando options
-        result = container.create_item(
-            body=session_doc,
-            enable_cross_partition_query=True
-        )
+        result = container.create_item(body=session_doc)
         logger.info(f"Sesión {session_id} registrada para {username}")
         return session_id
     except Exception as e:
         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:
@@ -113,7 +111,6 @@ def record_logout(username, session_id):
             logger.error("No se pudo obtener el contenedor users_sessions")
             return False
 
-        # Obtener la sesión actual
         query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
         params = [
             {"name": "@id", "value": session_id},
@@ -122,8 +119,7 @@ def record_logout(username, session_id):
         
         items = list(container.query_items(
             query=query,
-            parameters=params,
-            enable_cross_partition_query=True
+            parameters=params
         ))
 
         if not items:
@@ -137,22 +133,18 @@ def record_logout(username, session_id):
 
         session.update({
             "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration
+            "sessionDuration": duration,
+            "partitionKey": username
         })
 
-        # Actualizar el documento
-        container.upsert_item(
-            body=session
-        )
+        container.upsert_item(body=session)
         logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
         return True
     except Exception as e:
         logger.error(f"Error registrando logout: {str(e)}")
         return False
 
-
-###########################################################
-
+#########################################
 def get_recent_sessions(limit=10):
     """Obtiene las sesiones más recientes"""
     try:
@@ -171,11 +163,9 @@ def get_recent_sessions(limit=10):
         
         sessions = list(container.query_items(
             query=query,
-            parameters=[{"name": "@limit", "value": limit}],
-            enable_cross_partition_query=True
+            parameters=[{"name": "@limit", "value": limit}]
         ))
 
-        # Validar y limpiar los datos
         clean_sessions = []
         for session in sessions:
             try:
@@ -194,10 +184,7 @@ 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:
@@ -215,8 +202,7 @@ def get_user_total_time(username):
         
         result = list(container.query_items(
             query=query,
-            parameters=[{"name": "@username", "value": username}],
-            enable_cross_partition_query=True
+            parameters=[{"name": "@username", "value": username}]
         ))
 
         return result[0] if result and result[0] is not None else 0
@@ -224,14 +210,15 @@ def get_user_total_time(username):
         logger.error(f"Error obteniendo tiempo total: {str(e)}")
         return 0
 
-###########################################################
+#########################################
 def update_student_user(username, new_info):
-    user_container, _, _ = get_sql_containers()
+    container = get_container("users") 
     try:
         user = get_student_user(username)
         if user:
             user['additional_info'].update(new_info)
-            user_container.upsert_item(body=user)
+            user['partitionKey'] = username
+            container.upsert_item(body=user)
             logger.info(f"Información del estudiante actualizada: {username}")
             return True
         else:
@@ -241,13 +228,14 @@ def update_student_user(username, new_info):
         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()
+    container = get_container("users")
     try:
         user = get_student_user(username)
         if user:
-            user_container.delete_item(item=user['id'], partition_key=username)
+            # El ID es suficiente para eliminación ya que partitionKey está en el documento
+            container.delete_item(item=user['id'])
             logger.info(f"Estudiante eliminado: {username}")
             return True
         else:
@@ -257,9 +245,18 @@ def delete_student_user(username):
         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):
-    _, application_requests_container, _ = get_sql_containers()
+    """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,
@@ -269,30 +266,57 @@ def store_application_request(name, lastname, email, institution, current_role,
             "current_role": current_role,
             "desired_role": desired_role,
             "reason": reason,
-            "requestDate": datetime.utcnow().isoformat()
+            "requestDate": datetime.utcnow().isoformat(),
+            # El campo para partition key debe estar en el documento
+            "partitionKey": email
         }
-        application_requests_container.create_item(body=application_request)
-        logger.info(f"Solicitud de aplicación almacenada para el email: {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):
-    _, _, user_feedback_container = get_sql_containers()
+    """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,
+            "username": username,  # Campo regular
             "name": name,
             "email": email,
             "feedback": feedback,
             "role": "Estudiante",
-            'timestamp': datetime.now(timezone.utc).isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "partitionKey": username  # Campo de partición
         }
-        result = user_feedback_container.create_item(body=feedback_item)
-        logger.info(f"Feedback de estudiante almacenado con ID: {result['id']} para el usuario: {username}")
+
+        # 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}: {str(e)}")
+        logger.error(f"Error al almacenar el feedback del estudiante {username}")
+        logger.error(f"Detalles del error: {str(e)}")
         return False