Download modules/database/sql_db.py from AIdeaText/v5Prod: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/spaces/AIdeaText/v5Prod/resolve/183d66a55bc5f4e59cd467fbe679c0aaf7dda3c5/modules/database/sql_db.py
- Command line
-
hf download hf://spaces/AIdeaText/v5Prod@183d66a55bc5f4e59cd467fbe679c0aaf7dda3c5/modules/database/sql_db.py
-
curl -L -o sql_db.py https://huggingface.co/spaces/AIdeaText/v5Prod/resolve/183d66a55bc5f4e59cd467fbe679c0aaf7dda3c5/modules/database/sql_db.py
12.2 kB
| # modules/database/sql_db.py | |
| from .database_init import get_container | |
| from datetime import datetime, timezone | |
| import logging | |
| import bcrypt | |
| import uuid | |
| from bson import json_util # ← CORREGIDO: así se importa correctamente | |
| import json # ← Necesario para json.loads() | |
| logger = logging.getLogger(__name__) | |
| ######################################### | |
| def get_user(username, role=None): | |
| container = get_container("users") | |
| try: | |
| 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)}") | |
| return 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") | |
| if not container: | |
| logger.error("No se pudo obtener el contenedor de usuarios") | |
| return False | |
| try: | |
| user_data = { | |
| 'id': username, | |
| 'password': password, | |
| 'role': role, | |
| 'timestamp': datetime.now(timezone.utc), # ← Se mantiene como datetime | |
| 'additional_info': additional_info or {}, | |
| 'partitionKey': username | |
| } | |
| # Convertir usando json_util antes de enviar a Cosmos DB | |
| user_data_json = json.loads(json_util.dumps(user_data)) | |
| # Crear item con los datos convertidos | |
| container.create_item(body=user_data_json) | |
| 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) | |
| ######################################### | |
| 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), # ← Se mantiene como datetime | |
| "additional_info": {}, | |
| "partitionKey": username | |
| } | |
| # Convertir usando json_util | |
| session_json = json.loads(json_util.dumps(session_doc)) | |
| result = container.create_item(body=session_json) | |
| 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 | |
| )) | |
| 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(), | |
| "sessionDuration": duration, | |
| "partitionKey": username | |
| }) | |
| 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: | |
| 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}], | |
| enable_cross_partition_query=True # Agregar este parámetro | |
| )) | |
| 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}] | |
| )) | |
| 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): | |
| container = get_container("users") | |
| try: | |
| user = get_student_user(username) | |
| if user: | |
| 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: | |
| 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 | |
| ######################################### | |
| def delete_student_user(username): | |
| container = get_container("users") | |
| try: | |
| user = get_student_user(username) | |
| if user: | |
| # 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: | |
| 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 | |
| ######################################### | |
| def store_application_request(name, lastname, email, institution, current_role, desired_role, reason): | |
| """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, | |
| "lastname": lastname, | |
| "email": email, | |
| "institution": institution, | |
| "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 | |
| } | |
| # 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): | |
| """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, # Campo regular | |
| "name": name, | |
| "email": email, | |
| "feedback": feedback, | |
| "role": "Estudiante", | |
| "timestamp": datetime.now(timezone.utc).isoformat(), | |
| "partitionKey": username # Campo de partición | |
| } | |
| # 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}") | |
| logger.error(f"Detalles del error: {str(e)}") | |
| return False |