Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -70,12 +70,14 @@ def create_admin_user(username, password, additional_info=None):
 
 ############-- Funciones de control del tiempo de sesión ##################
 
+###########################################################
 
 def record_login(username):
-    """Registra el inicio de sesión"""
+    """Registra el inicio de sesión de un usuario"""
     try:
         container = get_container("users_sessions")
         if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
             return None
 
         session_id = str(uuid.uuid4())
@@ -84,38 +86,48 @@ def record_login(username):
             "type": "session",
             "username": username,
             "loginTime": datetime.now(timezone.utc).isoformat(),
-            "additional_info": {}  # Mantener consistencia con la estructura existente
+            "additional_info": {},
+            # El campo para partition key debe estar en el documento
+            "partitionKey": username
         }
 
-        container.create_item(
+        # Crear el documento usando options
+        result = container.create_item(
             body=session_doc,
-            partition_key=username
+            enable_cross_partition_query=True
         )
-        logger.info(f"Login registrado: {username}")
+        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"""
+    """Registra el cierre de sesión y calcula la duración"""
     try:
         container = get_container("users_sessions")
         if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
             return False
 
-        query = "SELECT * FROM c WHERE c.id = @id"
-        params = [{"name": "@id", "value": session_id}]
+        # Obtener la sesión actual
+        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,
-            partition_key=username
+            enable_cross_partition_query=True
         ))
 
         if not items:
+            logger.warning(f"Sesión no encontrada: {session_id}")
             return False
 
         session = items[0]
@@ -128,21 +140,25 @@ def record_logout(username, session_id):
             "sessionDuration": duration
         })
 
+        # Actualizar el documento
         container.upsert_item(
-            body=session,
-            partition_key=username
+            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 sesiones recientes"""
+    """Obtiene las sesiones más recientes"""
     try:
         container = get_container("users_sessions")
         if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
             return []
 
         query = """
@@ -153,15 +169,35 @@ def get_recent_sessions(limit=10):
         OFFSET 0 LIMIT @limit
         """
         
-        return list(container.query_items(
+        sessions = list(container.query_items(
             query=query,
             parameters=[{"name": "@limit", "value": limit}],
             enable_cross_partition_query=True
         ))
+
+        # Validar y limpiar los datos
+        clean_sessions = []
+        for session in sessions:
+            try:
+                clean_sessions.append({
+                    "username": session["username"],
+                    "loginTime": session["loginTime"],
+                    "logoutTime": session.get("logoutTime", "Activo"),
+                    "sessionDuration": session.get("sessionDuration", 0)
+                })
+            except KeyError as e:
+                logger.warning(f"Sesión con datos incompletos: {e}")
+                continue
+
+        return clean_sessions
     except Exception as e:
-        logger.error(f"Error obteniendo sesiones: {str(e)}")
+        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:
@@ -174,19 +210,19 @@ def get_user_total_time(username):
         FROM c
         WHERE c.type = 'session'
         AND c.username = @username
-        AND c.logoutTime != null
+        AND IS_DEFINED(c.sessionDuration)
         """
         
         result = list(container.query_items(
             query=query,
             parameters=[{"name": "@username", "value": username}],
-            partition_key=username
+            enable_cross_partition_query=True
         ))
 
-        return result[0] if result else 0
+        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 None
+        return 0
 
 ###########################################################
 def update_student_user(username, new_info):