Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -1,4 +1,5 @@
-#modules/database/sql_db.py
+# modules/database/sql_db.py
+
 from .database_init import get_container
 from datetime import datetime, timezone
 import logging
@@ -10,17 +11,10 @@ logger = logging.getLogger(__name__)
 def get_user(username, role=None):
     container = get_container("users")
     try:
-        # Consulta básica por ID que es el partition key
-        items = list(container.query_items(
-            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]
-            
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        if role:
+            query += f" AND c.role = '{role}'"
+        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)}")
@@ -44,18 +38,16 @@ def create_user(username, password, role, additional_info=None):
         
     try:
         user_data = {
-            'id': username,  # Este campo es el partition key
+            'id': username,
             '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
         }
         
-        # Usar el id como 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
         
@@ -86,13 +78,11 @@ def record_login(username):
             "type": "session",
             "username": username,
             "loginTime": datetime.now(timezone.utc).isoformat(),
-            "additional_info": {}
+            "additional_info": {},
+            "partitionKey": username
         }
 
-        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:
@@ -107,13 +97,15 @@ 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="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
+            query=query,
+            parameters=params
         ))
 
         if not items:
@@ -127,13 +119,11 @@ def record_logout(username, session_id):
 
         session.update({
             "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration
+            "sessionDuration": duration,
+            "partitionKey": username
         })
 
-        container.upsert_item(
-            body=session,
-            enable_cross_partition_query=True
-        )
+        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:
@@ -148,16 +138,17 @@ 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="""
-            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
+            query=query,
+            parameters=[{"name": "@limit", "value": limit}]
         ))
 
         clean_sessions = []
@@ -185,16 +176,17 @@ 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="""
-            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
+            query=query,
+            parameters=[{"name": "@username", "value": username}]
         ))
 
         return result[0] if result and result[0] is not None else 0
@@ -202,27 +194,14 @@ def get_user_total_time(username):
         logger.error(f"Error obteniendo tiempo total: {str(e)}")
         return 0
 
-
-# Agregar estas funciones en sql_db.py
-
 def update_student_user(username, new_info):
-    """Actualiza la información de un estudiante"""
-    container = get_container("users")
+    container = get_container("users") 
     try:
-        # Primero obtener el usuario existente
         user = get_student_user(username)
         if user:
-            # Actualizar la información
-            if 'additional_info' in user:
-                user['additional_info'].update(new_info)
-            else:
-                user['additional_info'] = new_info
-                
-            # Actualizar el documento usando el partition key correcto
-            container.upsert_item(
-                body=user,
-                partition_key=username
-            )
+            user['additional_info'].update(new_info)
+            user['partitionKey'] = username
+            container.upsert_item(body=user)
             logger.info(f"Información del estudiante actualizada: {username}")
             return True
         else:
@@ -233,17 +212,12 @@ def update_student_user(username, new_info):
         return False
 
 def delete_student_user(username):
-    """Elimina un estudiante"""
     container = get_container("users")
     try:
-        # Verificar que el usuario existe y es un estudiante
         user = get_student_user(username)
         if user:
-            # Eliminar usando el partition key correcto
-            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:
@@ -253,19 +227,44 @@ def delete_student_user(username):
         logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
         return False
 
-__all__ = [
-    'get_user',
-    'get_admin_user',
-    'get_student_user',
-    'get_teacher_user',
-    'create_user',
-    'create_student_user',
-    'create_teacher_user',
-    'create_admin_user',
-    'update_student_user',  # Agregada
-    'delete_student_user',  # Agregada
-    'record_login',
-    'record_logout',
-    'get_recent_sessions',
-    'get_user_total_time'
-]
+def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
+    container = get_container("application_requests")
+    try:
+        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(),
+            "partitionKey": email  # Usar email como partition key
+        }
+        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)}")
+        return False
+
+def store_student_feedback(username, name, email, feedback):
+    container = get_container("user_feedback")
+    try:
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "role": "Estudiante",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "partitionKey": username  # Usar username como partition key
+        }
+        result = 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}: {str(e)}")
+        return False