Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -32,34 +32,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 +59,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)
 
@@ -266,20 +257,9 @@ 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):
-    """Almacena una solicitud de aplicación"""
+    _, application_requests_container, _ = get_sql_containers()
     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,
@@ -289,57 +269,30 @@ def store_application_request(name, lastname, email, institution, current_role,
             "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
+            "requestDate": datetime.utcnow().isoformat()
         }
-        
-        # 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}")
+        application_requests_container.create_item(body=application_request)
+        logger.info(f"Solicitud de aplicación almacenada para el email: {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"""
+    _, _, user_feedback_container = get_sql_containers()
     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
+            "username": username,
             "name": name,
             "email": email,
             "feedback": feedback,
             "role": "Estudiante",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "partitionKey": username  # Campo de partición
+            'timestamp': datetime.now(timezone.utc).isoformat(),
         }
-
-        # 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}")
+        result = user_feedback_container.create_item(body=feedback_item)
+        logger.info(f"Feedback de estudiante almacenado con ID: {result['id']} 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
+        logger.error(f"Error al almacenar el feedback del estudiante {username}: {str(e)}")
+        return False