Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -8,6 +8,8 @@ import uuid
 
 logger = logging.getLogger(__name__)
 
+###########################################
+
 def get_user(username, role=None):
     container = get_container("users")
     try:
@@ -15,14 +17,16 @@ def get_user(username, role=None):
         if role:
             query += f" AND c.role = '{role}'"
         items = list(container.query_items(
-            query=query,
-            enable_cross_partition_query=True
+            query=query  # Removido enable_cross_partition_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')
 
@@ -32,34 +36,26 @@ def get_student_user(username):
 def get_teacher_user(username):
     return get_user(username, role='Profesor')
 
-#################################################################################
-#El error ocurre porque el parámetro `partition_key` 
-#no es soportado en la versión actual del SDK. 
-#Modifiquemos la función `create_user()` para incluir la partición en el cuerpo del documento:
-
 def create_user(username, password, role, additional_info=None):
+    """Crea un nuevo usuario"""
     container = get_container("users")
     if not container:
         logger.error("No se pudo obtener el contenedor de usuarios")
         return False
         
     try:
-        # Generar salt y hash de la contraseña
-        salt = bcrypt.gensalt()
-        hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
-        
         user_data = {
             'id': username,
-            'password': hashed.decode('utf-8'),
-            'salt': salt.decode('utf-8'),
+            'password': password,
             'role': role,
             'timestamp': datetime.now(timezone.utc).isoformat(),
-            'additional_info': additional_info or {},
-            # La partición va dentro del documento
-            'partitionKey': username
+            'additional_info': additional_info or {}
         }
         
-        container.create_item(body=user_data)
+        container.create_item(
+            body=user_data,
+            partition_key=username
+        )
         logger.info(f"Usuario {role} creado: {username}")
         return True
         
@@ -67,7 +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)
 
@@ -96,14 +91,11 @@ 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
+            body=session_doc  # Solo el body
         )
         logger.info(f"Sesión {session_id} registrada para {username}")
         return session_id
@@ -111,7 +103,6 @@ def record_login(username):
         logger.error(f"Error registrando login: {str(e)}")
         return None
 
-
 ###########################################################
 
 def record_logout(username, session_id):
@@ -122,7 +113,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},
@@ -131,8 +121,7 @@ def record_logout(username, session_id):
         
         items = list(container.query_items(
             query=query,
-            parameters=params,
-            enable_cross_partition_query=True
+            parameters=params  # Removido enable_cross_partition_query
         ))
 
         if not items:
@@ -146,12 +135,12 @@ def record_logout(username, session_id):
 
         session.update({
             "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration
+            "sessionDuration": duration,
+            "partitionKey": username  # Asegurar que partitionKey esté presente
         })
 
-        # Actualizar el documento
         container.upsert_item(
-            body=session
+            body=session  # Solo el body
         )
         logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
         return True
@@ -180,11 +169,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}]  # Removido enable_cross_partition_query
         ))
 
-        # Validar y limpiar los datos
         clean_sessions = []
         for session in sessions:
             try:
@@ -224,8 +211,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}]  # Removido enable_cross_partition_query
         ))
 
         return result[0] if result and result[0] is not None else 0
@@ -251,6 +237,7 @@ def update_student_user(username, new_info):
         return False
 
 
+#########################################################
 def delete_student_user(username):
     user_container, _, _ = get_sql_containers()
     try:
@@ -266,9 +253,21 @@ 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,
@@ -278,30 +277,56 @@ 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