Update modules/database/sql_db.py

modules/database/sql_db.py

@@ -13,13 +13,11 @@ logger = logging.getLogger(__name__)
 def get_user(username, role=None):
     container = get_container("users")
     try:
-        # Para una búsqueda por id (que es el partition key), no necesitamos cross partition query
-        query = f"SELECT * FROM c WHERE c.id = '{username}'"
         if role:
             query += f" AND c.role = '{role}'"
         items = list(container.query_items(
-            query=query,
-            partition_key=username  # Especificamos el partition key
+            query=query  # Removido enable_cross_partition_query
+
         ))
         return items[0] if items else None
     except Exception as e:
@@ -32,14 +30,14 @@ def get_user(username, role=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")
@@ -48,95 +46,71 @@ def create_user(username, password, role, additional_info=None):
         return False
         
     try:
+
+
+
+
         user_data = {
-            'id': username,  # Este será usado como partition key
+            'id': username,
             'password': password,
+
             'role': role,
             'timestamp': datetime.now(timezone.utc).isoformat(),
             'additional_info': additional_info or {}
+
+
         }
         
         container.create_item(
             body=user_data,
-            partition_key=username  # Usamos el username (que es el id) como partition key
+            partition_key=username
         )
         logger.info(f"Usuario {role} creado: {username}")
         return True
         
-    except Exception as e:
         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:
-        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())
-        session_doc = {
-            "id": session_id,
-            "type": "session",
             "username": username,
             "loginTime": datetime.now(timezone.utc).isoformat(),
             "additional_info": {},
+
             "partitionKey": username
         }
 
+
         result = container.create_item(
             body=session_doc  # Solo el body
+
         )
         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:
-        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 AND c.username = @username"
         params = [
             {"name": "@id", "value": session_id},
-            {"name": "@username", "value": username}
-        ]
         
         items = list(container.query_items(
             query=query,
             parameters=params  # Removido enable_cross_partition_query
+
         ))
 
         if not items:
-            logger.warning(f"Sesión no encontrada: {session_id}")
-            return False
-
-        session = items[0]
-        login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
-        logout_time = datetime.now(timezone.utc)
-        duration = int((logout_time - login_time).total_seconds())
 
         session.update({
             "logoutTime": logout_time.isoformat(),
@@ -144,101 +118,31 @@ def record_logout(username, session_id):
             "partitionKey": username  # Asegurar que partitionKey esté presente
         })
 
+
         container.upsert_item(
             body=session  # Solo el body
         )
         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:
-        container = get_container("users_sessions")
-        if not container:
-            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=query,
             parameters=[{"name": "@limit", "value": limit}]  # Removido enable_cross_partition_query
+
         ))
 
+
         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 recientes: {str(e)}")
-        return []
-
-
-
-###########################################################
-
-def get_user_total_time(username):
-    """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
-    try:
-        container = get_container("users_sessions")
-        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=query,
             parameters=[{"name": "@username", "value": username}]  # Removido enable_cross_partition_query
+
         ))
 
         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 0
-
-###########################################################
-def update_student_user(username, new_info):
-    user_container, _, _ = get_sql_containers()
-    try:
-        user = get_student_user(username)
-        if user:
-            user['additional_info'].update(new_info)
-            user_container.upsert_item(body=user)
-            logger.info(f"Información del estudiante actualizada: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
         return False
 
 
@@ -246,15 +150,6 @@ def update_student_user(username, new_info):
 def delete_student_user(username):
     user_container, _, _ = get_sql_containers()
     try:
-        user = get_student_user(username)
-        if user:
-            user_container.delete_item(item=user['id'], partition_key=username)
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
-            return False
-    except Exception as e:
         logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
         return False
 
@@ -276,9 +171,6 @@ def store_application_request(name, lastname, email, institution, current_role,
         application_request = {
             "id": str(uuid.uuid4()),
             "name": name,
-            "lastname": lastname,
-            "email": email,
-            "institution": institution,
             "current_role": current_role,
             "desired_role": desired_role,
             "reason": reason,