Delete modules/database.py

modules/database.py

@@ -1,388 +0,0 @@
-# database.py
-import logging
-import os
-from azure.cosmos import CosmosClient
-from azure.cosmos.exceptions import CosmosHttpResponseError
-from pymongo import MongoClient
-import certifi
-from datetime import datetime
-import io
-import base64
-import matplotlib.pyplot as plt
-from matplotlib.figure import Figure
-import bcrypt
-print(f"Bcrypt version: {bcrypt.__version__}")
-import uuid
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Variables globales para Cosmos DB SQL API
-application_requests_container = None
-cosmos_client = None
-user_database = None
-user_container = None
-
-# Variables globales para Cosmos DB MongoDB API
-mongo_client = None
-mongo_db = None
-analysis_collection = None
-chat_collection = None  # Nueva variable global
-
-
-#####################################################################################33
-def initialize_database_connections():
-    try:
-        print("Iniciando conexión a MongoDB")
-        mongodb_success = initialize_mongodb_connection()
-        print(f"Conexión a MongoDB: {'exitosa' if mongodb_success else 'fallida'}")
-    except Exception as e:
-        print(f"Error al conectar con MongoDB: {str(e)}")
-        mongodb_success = False
-
-    try:
-        print("Iniciando conexión a Cosmos DB SQL API")
-        sql_success = initialize_cosmos_sql_connection()
-        print(f"Conexión a Cosmos DB SQL API: {'exitosa' if sql_success else 'fallida'}")
-    except Exception as e:
-        print(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
-        sql_success = False
-
-    return {
-        "mongodb": mongodb_success,
-        "cosmos_sql": sql_success
-    }
-
-#####################################################################################33
-def initialize_cosmos_sql_connection():
-    global cosmos_client, user_database, user_container, application_requests_container
-    logger.info("Initializing Cosmos DB SQL API connection")
-    try:
-        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
-        cosmos_key = os.environ.get("COSMOS_KEY")
-        logger.info(f"Cosmos Endpoint: {cosmos_endpoint}")
-        logger.info(f"Cosmos Key: {'*' * len(cosmos_key) if cosmos_key else 'Not set'}")
-        
-        if not cosmos_endpoint or not cosmos_key:
-            logger.error("COSMOS_ENDPOINT or COSMOS_KEY environment variables are not set")
-            raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
-        
-        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
-        user_database = cosmos_client.get_database_client("user_database")
-        user_container = user_database.get_container_client("users")
-        application_requests_container = user_database.get_container_client("application_requests")
-        
-        logger.info(f"user_container initialized: {user_container is not None}")
-        logger.info(f"application_requests_container initialized: {application_requests_container is not None}")
-        
-        logger.info("Conexión a Cosmos DB SQL API exitosa")
-        return True
-    except Exception as e:
-        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}", exc_info=True)
-        return False
-
-############################################################################################3        
-def initialize_mongodb_connection():
-    global mongo_client, mongo_db, analysis_collection, chat_collection
-    try:
-        cosmos_mongodb_connection_string = os.getenv("MONGODB_CONNECTION_STRING")
-        if not cosmos_mongodb_connection_string:
-            logger.error("La variable de entorno MONGODB_CONNECTION_STRING no está configurada")
-            return False
-
-        mongo_client = MongoClient(cosmos_mongodb_connection_string,
-                                   tls=True,
-                                   tlsCAFile=certifi.where(),
-                                   retryWrites=False,
-                                   serverSelectionTimeoutMS=5000,
-                                   connectTimeoutMS=10000,
-                                   socketTimeoutMS=10000)
-
-        mongo_client.admin.command('ping')
-        
-        mongo_db = mongo_client['aideatext_db']
-        analysis_collection = mongo_db['text_analysis']
-        chat_collection = mongo_db['chat_history']  # Inicializar la nueva colección
-
-        # Verificar la conexión
-        mongo_client.admin.command('ping')
-        
-        logger.info("Conexión a Cosmos DB MongoDB API exitosa")
-        return True
-    except Exception as e:
-        logger.error(f"Error al conectar con Cosmos DB MongoDB API: {str(e)}", exc_info=True)
-        return False
-
-#######################################################################################################
-def create_user(username, password, role):
-    global user_container
-    try:
-        print(f"Attempting to create user: {username} with role: {role}")
-        if user_container is None:
-            print("Error: user_container is None. Attempting to reinitialize connection.")
-            if not initialize_cosmos_sql_connection():
-                raise Exception("Failed to initialize SQL connection")
-        
-        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
-        print(f"Password hashed successfully for user: {username}")
-        user_data = {
-            'id': username,
-            'password': hashed_password,
-            'role': role,
-            'created_at': datetime.utcnow().isoformat()
-        }
-        user_container.create_item(body=user_data)
-        print(f"Usuario {role} creado: {username}")  # Log para depuración
-        return True
-    except Exception as e:
-        print(f"Detailed error in create_user: {str(e)}")
-        return False
-
-#######################################################################################################
-def create_admin_user(username, password):
-    return create_user(username, password, 'Administrador')
-    
-#######################################################################################################
-def create_student_user(username, password):
-    return create_user(username, password, 'Estudiante')
-       
-#######################################################################################################
-# Funciones para Cosmos DB SQL API (manejo de usuarios)
-def get_user(username):
-    try:
-        query = f"SELECT * FROM c WHERE c.id = '{username}'"
-        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
-        user = items[0] if items else None
-        if user:
-            print(f"Usuario encontrado: {username}, Rol: {user.get('role')}")  # Log añadido
-        else:
-            print(f"Usuario no encontrado: {username}")  # Log añadido
-        return user
-    except Exception as e:
-        print(f"Error al obtener usuario {username}: {str(e)}")
-        return None
-
-#######################################################################################################
-def store_application_request(name, email, institution, role, reason):
-    global application_requests_container
-    logger.info("Entering store_application_request function")
-    try:
-        logger.info("Checking application_requests_container")
-        if application_requests_container is None:
-            logger.error("application_requests_container is not initialized")
-            return False
-
-        logger.info("Creating application request document")
-        application_request = {
-            "id": str(uuid.uuid4()),
-            "name": name,
-            "email": email,
-            "institution": institution,
-            "role": role,
-            "reason": reason,
-            "requestDate": datetime.utcnow().isoformat()
-        }
-
-        logger.info(f"Attempting to store document: {application_request}")
-        application_requests_container.create_item(body=application_request)
-        logger.info(f"Application request stored for email: {email}")
-        return True
-    except Exception as e:
-        logger.error(f"Error storing application request: {str(e)}")
-        return False
-        
-#######################################################################################################
-def store_morphosyntax_result(username, text, repeated_words, arc_diagrams):
-    if analysis_collection is None:
-        logger.error("La conexión a MongoDB no está inicializada")
-        return False
-
-    try:
-        word_count = {}
-        for word, color in repeated_words.items():
-            category = color  # Asumiendo que 'color' es la categoría gramatical
-            word_count[category] = word_count.get(category, 0) + 1
-
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.utcnow(),
-            'text': text,
-            'word_count': word_count,
-            'arc_diagrams': arc_diagrams,
-        }
-
-        result = analysis_collection.insert_one(analysis_document)
-
-        logger.info(f"Análisis guardado con ID: {result.inserted_id} para el usuario: {username}")
-        return True
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis para el usuario {username}: {str(e)}")
-        return False
-
-################################################################################################################
-def store_semantic_result(username, text, network_diagram):
-    try:
-        # Convertir la figura a una imagen base64
-        buf = io.BytesIO()
-        network_diagram.savefig(buf, format='png')
-        buf.seek(0)
-        img_str = base64.b64encode(buf.getvalue()).decode('utf-8')
-
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.utcnow(),
-            'text': text,
-            'network_diagram': img_str,  # Guardar la imagen como string base64
-            'analysis_type': 'semantic'
-        }
-
-        result = analysis_collection.insert_one(analysis_document)
-
-        logger.info(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
-        return True
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
-        return False
-
-###############################################################################################################
-
-def store_discourse_analysis_result(username, text1, text2, graph1, graph2):
-    try:
-        # Crear una nueva figura combinada
-        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
-
-        # Añadir la primera imagen con título
-        ax1.imshow(graph1.get_figure().canvas.renderer.buffer_rgba())
-        ax1.set_title("Documento Patrón: Relaciones semánticas relevantes")
-        ax1.axis('off')
-
-        # Añadir la segunda imagen con título
-        ax2.imshow(graph2.get_figure().canvas.renderer.buffer_rgba())
-        ax2.set_title("Documento Comparado con el documento patrón: Relaciones semánticas relevantes")
-        ax2.axis('off')
-
-        # Ajustar el diseño
-        plt.tight_layout()
-
-        # Convertir la figura combinada a una imagen base64
-        buf = io.BytesIO()
-        fig.savefig(buf, format='png')
-        buf.seek(0)
-        img_str = base64.b64encode(buf.getvalue()).decode('utf-8')
-
-        # Cerrar las figuras para liberar memoria
-        plt.close(fig)
-        plt.close(graph1.get_figure())
-        plt.close(graph2.get_figure())
-
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.utcnow(),
-            'text1': text1,
-            'text2': text2,
-            'combined_graph': img_str,
-            'analysis_type': 'discourse'
-        }
-
-        result = analysis_collection.insert_one(analysis_document)
-
-        logger.info(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
-        return True
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis discursivo para el usuario {username}: {str(e)}")
-        return False
-
-###############################################################################################################
-def store_chat_history(username, messages):
-    try:
-        logger.info(f"Attempting to save chat history for user: {username}")
-        logger.debug(f"Messages to save: {messages}")
-        
-        chat_document = {
-            'username': username,
-            'timestamp': datetime.utcnow(),
-            'messages': messages
-        }
-        result = chat_collection.insert_one(chat_document)
-        logger.info(f"Chat history saved with ID: {result.inserted_id} for user: {username}")
-        logger.debug(f"Chat content: {messages}")
-        return True
-    except Exception as e:
-        logger.error(f"Error saving chat history for user {username}: {str(e)}")
-        return False
-
-#######################################################################################################
-def get_student_data(username):
-    if analysis_collection is None or chat_collection is None:
-        logger.error("La conexión a MongoDB no está inicializada")
-        return None
-
-    formatted_data = {
-        "username": username,
-        "entries": [],
-        "entries_count": 0,
-        "word_count": {},
-        "semantic_analyses": [],
-        "discourse_analyses": [],
-        "chat_history": []
-    }
-
-    try:
-        logger.info(f"Buscando datos de análisis para el usuario: {username}")
-        cursor = analysis_collection.find({"username": username})
-        
-        for entry in cursor:
-            formatted_entry = {
-                "timestamp": entry.get("timestamp", datetime.utcnow()),
-                "text": entry.get("text", ""),
-                "analysis_type": entry.get("analysis_type", "morphosyntax")
-            }
-            
-            if formatted_entry["analysis_type"] == "morphosyntax":
-                formatted_entry.update({
-                    "word_count": entry.get("word_count", {}),
-                    "arc_diagrams": entry.get("arc_diagrams", [])
-                })
-                for category, count in formatted_entry["word_count"].items():
-                    formatted_data["word_count"][category] = formatted_data["word_count"].get(category, 0) + count
-            
-            elif formatted_entry["analysis_type"] == "semantic":
-                formatted_entry["network_diagram"] = entry.get("network_diagram", "")
-                formatted_data["semantic_analyses"].append(formatted_entry)
-            
-            elif formatted_entry["analysis_type"] == "discourse":
-                formatted_entry.update({
-                    "text1": entry.get("text1", ""),
-                    "text2": entry.get("text2", ""),
-                    "combined_graph": entry.get("combined_graph", "")
-                })
-                formatted_data["discourse_analyses"].append(formatted_entry)
-            
-            formatted_data["entries"].append(formatted_entry)
-        
-        formatted_data["entries_count"] = len(formatted_data["entries"])
-        formatted_data["entries"].sort(key=lambda x: x["timestamp"], reverse=True)
-        
-        for entry in formatted_data["entries"]:
-            entry["timestamp"] = entry["timestamp"].isoformat()
-    
-    except Exception as e:
-        logger.error(f"Error al obtener datos de análisis del estudiante {username}: {str(e)}")
-    
-    try:
-        logger.info(f"Buscando historial de chat para el usuario: {username}")
-        chat_cursor = chat_collection.find({"username": username})
-        for chat in chat_cursor:
-            formatted_chat = {
-                "timestamp": chat["timestamp"].isoformat(),
-                "messages": chat["messages"]
-            }
-            formatted_data["chat_history"].append(formatted_chat)
-        
-        formatted_data["chat_history"].sort(key=lambda x: x["timestamp"], reverse=True)
-    
-    except Exception as e:
-        logger.error(f"Error al obtener historial de chat del estudiante {username}: {str(e)}")
-
-    logger.info(f"Datos formateados para {username}: {formatted_data}")
-    return formatted_data