Upload 216 files

app.py

@@ -0,0 +1,150 @@
+#app.py de v3
+#app.py
+import logging
+import streamlit as st
+import sys
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+
+def setup_logging():
+    log_dir = 'logs'
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+    current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_filename = f'{log_dir}/app_log_{current_time}.txt'
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        filename=log_filename,
+        filemode='w'
+    )
+    console = logging.StreamHandler()
+    console.setLevel(logging.INFO)
+    formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
+    console.setFormatter(formatter)
+    logging.getLogger('').addHandler(console)
+    logging.info(f"Logging iniciado. Archivo de log: {log_filename}")
+
+setup_logging()
+load_dotenv()
+
+st.set_page_config(page_title="AIdeaText", layout="wide", page_icon="random")
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+#########IMPORTACIONES LOCALES#######################################
+from translations import get_translations
+
+from session_state import initialize_session_state
+
+from modules.ui.ui import main as ui_main
+
+from modules.utils.spacy_utils import load_spacy_models
+
+from modules.morphosyntax.morphosyntax_interface import (
+    display_morphosyntax_interface
+)
+
+###Importaciones de la base de datos###
+from modules.database.database_init import (
+    initialize_database_connections
+)
+
+from modules.database.sql_db import (
+    create_student_user,
+    get_student_user,
+    update_student_user,
+    delete_student_user,
+    store_application_request,
+    store_student_feedback
+)
+
+
+from modules.database.mongo_db import (
+    get_collection,
+    insert_document,
+    find_documents,
+    update_document,
+    delete_document
+)
+
+from modules.database.morphosintax_mongo_db import (
+    store_student_morphosyntax_result,
+    get_student_morphosyntax_analysis
+)
+
+from modules.database.chat_db import (
+    store_chat_history,
+    get_chat_history
+)
+
+from modules.studentact.student_activities_v2 import (
+    display_student_progress
+)
+
+from modules.auth.auth import (
+    authenticate_student,
+    register_student,
+    update_student_info,
+    delete_student
+)
+
+from modules.admin.admin_ui import admin_page
+
+from modules.chatbot.chatbot import (
+    initialize_chatbot,
+    process_chat_input
+)
+
+print("Configurando página")
+st.cache_data.clear()
+st.cache_resource.clear()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@st.cache_resource
+def initialize_nlp_models():
+    logger.info("Cargando modelos de spaCy")
+    models = load_spacy_models()
+    logger.info("Modelos de spaCy cargados exitosamente")
+    return models
+
+def app_main():
+    try:
+        logger.info("Entrando en app_main()")
+
+        # Inicializar el estado de la sesión
+        initialize_session_state()
+
+        # Inicializar conexiones a bases de datos si no se ha hecho
+        if 'db_initialized' not in st.session_state:
+            st.session_state.db_initialized = initialize_database_connections()
+
+        # Cargar modelos NLP si no se ha hecho
+        if 'nlp_models' not in st.session_state:
+            logger.info("Inicializando modelos NLP en la sesión")
+            st.session_state.nlp_models = initialize_nlp_models()
+            logger.info("Modelos NLP inicializados y almacenados en la sesión")
+
+        # Configurar la página inicial si no está configurada
+        if 'page' not in st.session_state:
+            st.session_state.page = 'login'
+
+        logger.info(f"Página actual: {st.session_state.page}")
+        logger.info(f"Rol del usuario: {st.session_state.role}")
+
+        # Dirigir el flujo a la interfaz de usuario principal
+        logger.info(f"Llamando a ui_main() desde app_main()")
+        ui_main()
+
+    except Exception as e:
+        logger.error(f"Error en app_main: {str(e)}", exc_info=True)
+        st.error("Se ha producido un error en la aplicación. Por favor, inténtelo de nuevo más tarde.")
+        if st.button("Reiniciar aplicación"):
+            st.rerun()
+
+if __name__ == "__main__":
+    print("Llamando a app_main()")
+    app_main()

modules/23-7-2024_auth.py

@@ -0,0 +1,135 @@
+### auth.py
+import os
+from azure.cosmos import CosmosClient, exceptions
+import bcrypt
+import base64
+
+################################################################################################################
+def clean_and_validate_key(key):
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += '='
+    try:
+        base64.b64decode(key)
+        return key
+    except:
+        raise ValueError("La clave proporcionada no es válida")
+
+# Azure Cosmos DB configuration
+endpoint = os.environ.get("COSMOS_ENDPOINT")
+key = os.environ.get("COSMOS_KEY")
+
+if not endpoint or not key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+key = clean_and_validate_key(key)
+
+try:
+    client = CosmosClient(endpoint, key)
+    database = client.get_database_client("user_database")
+    container = database.get_container_client("users")
+    # Prueba de conexión
+    database_list = list(client.list_databases())
+    print(f"Conexión exitosa. Bases de datos encontradas: {len(database_list)}")
+except Exception as e:
+    print(f"Error al conectar con Cosmos DB: {str(e)}")
+    raise
+
+#############################################################################################################3
+def hash_password(password):
+    """Hash a password for storing."""
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+################################################################################################################
+def verify_password(stored_password, provided_password):
+    """Verify a stored password against one provided by user"""
+    return bcrypt.checkpw(provided_password.encode('utf-8'), stored_password.encode('utf-8'))
+    
+################################################################################################################
+def register_user(username, password, additional_info=None):
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        existing_user = list(container.query_items(query=query, enable_cross_partition_query=True))
+        
+        if existing_user:
+            return False  # User already exists
+        
+        new_user = {
+            'id': username,
+            'password': hash_password(password),
+            'role': 'Estudiante',
+            'additional_info': additional_info or {}
+        }
+        
+        new_user['partitionKey'] = username
+        
+        container.create_item(body=new_user)
+        return True
+    except exceptions.CosmosHttpResponseError as e:
+        print(f"Error al registrar usuario: {str(e)}")
+        return False
+
+        
+################################################################################################################
+def authenticate_user(username, password):
+    """Authenticate a user."""
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            stored_user = results[0]
+            if verify_password(stored_user['password'], password):
+                return True
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return False
+
+
+################################################################################################################
+def get_user_role(username):
+    """Get the role of a user."""
+    try:
+        query = f"SELECT c.role FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            return results[0]['role']
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return None
+
+################################################################################################################
+def update_user_info(username, new_info):
+    """Update user information."""
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            user = results[0]
+            user['additional_info'].update(new_info)
+            container.upsert_item(user, partition_key=username)
+            return True
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return False
+
+################################################################################################################
+def delete_user(username):
+    """Delete a user."""
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        results = list(container.query_items(query=query, partition_key=username))
+        
+        if results:
+            user = results[0]
+            container.delete_item(item=user['id'], partition_key=username)
+            return True
+    except exceptions.CosmosHttpResponseError:
+        pass
+    
+    return False

modules/23-7-2024_ui.py

@@ -0,0 +1,344 @@
+# modules/ui.py
+# Importaciones estandar de python
+import io
+import streamlit as st
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import squarify
+import pandas as pd
+from datetime import datetime
+import base64
+from spacy import displacy
+import re
+from .morpho_analysis import POS_COLORS, POS_TRANSLATIONS  # Asegúrate de que esta importación esté presente
+print("POS_COLORS:", POS_COLORS)
+print("POS_TRANSLATIONS:", POS_TRANSLATIONS)
+
+# Importaciones locales
+from .auth import authenticate_user, register_user, get_user_role
+from .database import get_student_data, store_analysis_result
+from .morpho_analysis import get_repeated_words_colors, highlight_repeated_words, POS_COLORS, POS_TRANSLATIONS
+from .syntax_analysis import visualize_syntax
+
+#########################################################################
+# Define colors for grammatical categories
+POS_COLORS = {
+    'ADJ': '#FFA07A',    # Light Salmon
+    'ADP': '#98FB98',    # Pale Green
+    'ADV': '#87CEFA',    # Light Sky Blue
+    'AUX': '#DDA0DD',    # Plum
+    'CCONJ': '#F0E68C',  # Khaki
+    'DET': '#FFB6C1',    # Light Pink
+    'INTJ': '#FF6347',   # Tomato
+    'NOUN': '#90EE90',   # Light Green
+    'NUM': '#FAFAD2',    # Light Goldenrod Yellow
+    'PART': '#D3D3D3',   # Light Gray
+    'PRON': '#FFA500',   # Orange
+    'PROPN': '#20B2AA',  # Light Sea Green
+    'SCONJ': '#DEB887',  # Burlywood
+    'SYM': '#7B68EE',    # Medium Slate Blue
+    'VERB': '#FF69B4',   # Hot Pink
+    'X': '#A9A9A9',      # Dark Gray
+}
+
+POS_TRANSLATIONS = {
+    'es': {
+        'ADJ': 'Adjetivo',
+        'ADP': 'Adposición',
+        'ADV': 'Adverbio',
+        'AUX': 'Auxiliar',
+        'CCONJ': 'Conjunción Coordinante',
+        'DET': 'Determinante',
+        'INTJ': 'Interjección',
+        'NOUN': 'Sustantivo',
+        'NUM': 'Número',
+        'PART': 'Partícula',
+        'PRON': 'Pronombre',
+        'PROPN': 'Nombre Propio',
+        'SCONJ': 'Conjunción Subordinante',
+        'SYM': 'Símbolo',
+        'VERB': 'Verbo',
+        'X': 'Otro',
+    },
+    'en': {
+        'ADJ': 'Adjective',
+        'ADP': 'Adposition',
+        'ADV': 'Adverb',
+        'AUX': 'Auxiliary',
+        'CCONJ': 'Coordinating Conjunction',
+        'DET': 'Determiner',
+        'INTJ': 'Interjection',
+        'NOUN': 'Noun',
+        'NUM': 'Number',
+        'PART': 'Particle',
+        'PRON': 'Pronoun',
+        'PROPN': 'Proper Noun',
+        'SCONJ': 'Subordinating Conjunction',
+        'SYM': 'Symbol',
+        'VERB': 'Verb',
+        'X': 'Other',
+    },
+    'fr': {
+        'ADJ': 'Adjectif',
+        'ADP': 'Adposition',
+        'ADV': 'Adverbe',
+        'AUX': 'Auxiliaire',
+        'CCONJ': 'Conjonction de Coordination',
+        'DET': 'Déterminant',
+        'INTJ': 'Interjection',
+        'NOUN': 'Nom',
+        'NUM': 'Nombre',
+        'PART': 'Particule',
+        'PRON': 'Pronom',
+        'PROPN': 'Nom Propre',
+        'SCONJ': 'Conjonction de Subordination',
+        'SYM': 'Symbole',
+        'VERB': 'Verbe',
+        'X': 'Autre',
+    }
+}
+
+##########################################################################
+def login_page():
+    st.title("Iniciar Sesión")
+    username = st.text_input("Usuario")
+    password = st.text_input("Contraseña", type='password')
+    if st.button("Iniciar Sesión"):
+        if authenticate_user(username, password):
+            st.success(f"Bienvenido, {username}!")
+            st.session_state.logged_in = True
+            st.session_state.username = username
+            st.session_state.role = get_user_role(username)
+            st.experimental_rerun()
+        else:
+            st.error("Usuario o contraseña incorrectos")
+
+##########################################################################
+def register_page():
+    st.title("Registrarse")
+    new_username = st.text_input("Nuevo Usuario")
+    new_password = st.text_input("Nueva Contraseña", type='password')
+    
+    additional_info = {}
+    additional_info['carrera'] = st.text_input("Carrera")
+
+    if st.button("Registrarse"):
+        if register_user(new_username, new_password, additional_info):
+            st.success("Registro exitoso. Por favor, inicia sesión.")
+        else:
+            st.error("El usuario ya existe o ocurrió un error durante el registro")
+
+##########################################################################
+def get_chatbot_response(input_text):
+    # Esta función debe ser implementada o importada de otro módulo
+    # Por ahora, retornamos un mensaje genérico
+    return "Lo siento, el chatbot no está disponible en este momento."
+
+##########################################################################
+def display_chat_interface():
+    st.markdown("### Chat con AIdeaText")
+
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    for i, (role, text) in enumerate(st.session_state.chat_history):
+        if role == "user":
+            st.text_area(f"Tú:", value=text, height=50, key=f"user_message_{i}", disabled=True)
+        else:
+            st.text_area(f"AIdeaText:", value=text, height=50, key=f"bot_message_{i}", disabled=True)
+
+    user_input = st.text_input("Escribe tu mensaje aquí:")
+
+    if st.button("Enviar"):
+        if user_input:
+            st.session_state.chat_history.append(("user", user_input))
+            response = get_chatbot_response(user_input)
+            st.session_state.chat_history.append(("bot", response))
+            st.experimental_rerun()
+
+##########################################################################
+
+def display_student_progress(username, lang_code='es'):
+    print("lang_code:", lang_code)
+    student_data = get_student_data(username)
+    
+    if student_data is None:
+        st.warning("No se encontraron datos para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+        return
+
+    st.title(f"Progreso de {username}")
+
+    if student_data['entries_count'] > 0:
+        if 'word_count' in student_data and student_data['word_count']:
+            st.subheader("Total de palabras por categoría gramatical")
+            
+            df = pd.DataFrame(list(student_data['word_count'].items()), columns=['category', 'count'])
+            df['label'] = df.apply(lambda x: f"{POS_TRANSLATIONS[lang_code].get(x['category'], x['category'])}", axis=1)
+            
+            # Ordenar el DataFrame por conteo de palabras, de mayor a menor
+            df = df.sort_values('count', ascending=False)
+            
+            fig, ax = plt.subplots(figsize=(12, 6))
+            bars = ax.bar(df['label'], df['count'], color=[POS_COLORS.get(cat, '#CCCCCC') for cat in df['category']])
+            
+            ax.set_xlabel('Categoría Gramatical')
+            ax.set_ylabel('Cantidad de Palabras')
+            ax.set_title('Total de palabras por categoría gramatical')
+            plt.xticks(rotation=45, ha='right')
+            
+            # Añadir etiquetas de valor en las barras
+            for bar in bars:
+                height = bar.get_height()
+                ax.text(bar.get_x() + bar.get_width()/2., height,
+                        f'{height}',
+                        ha='center', va='bottom')
+            
+            plt.tight_layout()
+            
+            buf = io.BytesIO()
+            fig.savefig(buf, format='png')
+            buf.seek(0)
+            st.image(buf, use_column_width=True)
+        else:
+            st.info("No hay datos de conteo de palabras disponibles.")    
+        
+        # Diagramas de Arco (consolidados)
+        st.header("Diagramas de Arco")
+        with st.expander("Ver todos los Diagramas de Arco"):
+            for i, entry in enumerate(student_data['entries']):
+                if 'arc_diagrams' in entry and entry['arc_diagrams']:
+                    st.subheader(f"Entrada {i+1} - {entry['timestamp']}")
+                    st.write(entry['arc_diagrams'][0], unsafe_allow_html=True)
+        
+        # Diagramas de Red (consolidados)
+        st.header("Diagramas de Red")
+        with st.expander("Ver todos los Diagramas de Red"):
+            for i, entry in enumerate(student_data['entries']):
+                if 'network_diagram' in entry and entry['network_diagram']:
+                    st.subheader(f"Entrada {i+1} - {entry['timestamp']}")
+                    try:
+                        # Decodificar la imagen base64
+                        image_bytes = base64.b64decode(entry['network_diagram'])
+                        st.image(image_bytes)
+                    except Exception as e:
+                        st.error(f"Error al mostrar el diagrama de red: {str(e)}")
+    else:
+        st.warning("No se encontraron entradas para este estudiante.")
+        st.info("Intenta realizar algunos análisis de texto primero.")
+
+##############################################################Mostrar entradas recientes######################################################################
+        #st.header("Entradas Recientes")
+        #for i, entry in enumerate(student_data['entries'][:5]):  # Mostrar las 5 entradas más recientes
+            #with st.expander(f"Entrada {i+1} - {entry['timestamp']}"):
+                #st.write(entry['text'])
+    #else:
+        #st.warning("No se encontraron entradas para este estudiante.")
+        #st.info("Intenta realizar algunos análisis de texto primero.")
+    
+##########################################################################
+def display_text_analysis_interface(nlp_models, lang_code):
+    translations = {
+        'es': {
+            'title': "AIdeaText - Análisis morfológico y sintáctico",
+            'input_label': "Ingrese un texto para analizar (máx. 5,000 palabras):",
+            'input_placeholder': "El objetivo de esta aplicación es que mejore sus habilidades de redacción. Para ello, después de ingresar su texto y presionar el botón obtendrá tres vistas horizontales. La primera, le indicará las palabras que se repiten por categoría gramátical; la segunda, un diagrama de arco le indicara las conexiones sintácticas en cada oración; y la tercera, es un grafo en el cual visualizara la configuración de su texto.",  
+            'analyze_button': "Analizar texto",
+            'repeated_words': "Palabras repetidas",
+            'legend': "Leyenda: Categorías gramaticales",
+            'arc_diagram': "Análisis sintáctico: Diagrama de arco",
+            'network_diagram': "Análisis sintáctico: Diagrama de red",
+            'sentence': "Oración"
+        },
+        'en': {
+            'title': "AIdeaText - Morphological and Syntactic Analysis",
+            'input_label': "Enter a text to analyze (max 5,000 words):",
+            'input_placeholder': "The goal of this app is for you to improve your writing skills. To do this, after entering your text and pressing the button you will get three horizontal views. The first will indicate the words that are repeated by grammatical category; second, an arc diagram will indicate the syntactic connections in each sentence; and the third is a graph in which you will visualize the configuration of your text.",
+            'analyze_button': "Analyze text",
+            'repeated_words': "Repeated words",
+            'legend': "Legend: Grammatical categories",
+            'arc_diagram': "Syntactic analysis: Arc diagram",
+            'network_diagram': "Syntactic analysis: Network diagram",
+            'sentence': "Sentence"
+        },
+        'fr': {
+            'title': "AIdeaText - Analyse morphologique et syntaxique",
+            'input_label': "Entrez un texte à analyser (max 5 000 mots) :",
+            'input_placeholder': "Le but de cette application est d'améliorer vos compétences en rédaction. Pour ce faire, après avoir saisi votre texte et appuyé sur le bouton vous obtiendrez trois vues horizontales. Le premier indiquera les mots répétés par catégorie grammaticale; deuxièmement, un diagramme en arcs indiquera les connexions syntaxiques dans chaque phrase; et le troisième est un graphique dans lequel vous visualiserez la configuration de votre texte.",
+            'analyze_button': "Analyser le texte",
+            'repeated_words': "Mots répétés",
+            'legend': "Légende : Catégories grammaticales",
+            'arc_diagram': "Analyse syntaxique : Diagramme en arc",
+            'network_diagram': "Analyse syntaxique : Diagramme de réseau",
+            'sentence': "Phrase"
+        }
+    }
+
+    t = translations[lang_code]
+
+    if 'input_text' not in st.session_state:
+        st.session_state.input_text = ""
+
+    # Añadimos una clave única basada en el idioma seleccionado
+    sentence_input = st.text_area(
+        t['input_label'],
+        height=150,
+        placeholder=t['input_placeholder'],
+        value=st.session_state.input_text,
+        key=f"text_input_{lang_code}"  # Clave única basada en el idioma
+    )
+    st.session_state.input_text = sentence_input
+
+#    sentence_input = st.text_area(t['input_label'], height=150, placeholder=t['input_placeholder'], value=st.session_state.input_text)
+#    st.session_state.input_text = sentence_input
+
+    if st.button(t['analyze_button'], key=f"analyze_button_{lang_code}"):
+        if sentence_input:
+            doc = nlp_models[lang_code](sentence_input)
+
+            with st.expander(t['repeated_words'], expanded=True):
+                word_colors = get_repeated_words_colors(doc)
+                highlighted_text = highlight_repeated_words(doc, word_colors)
+                st.markdown(highlighted_text, unsafe_allow_html=True)
+
+            st.markdown(f"##### {t['legend']}")
+            legend_html = "<div style='display: flex; flex-wrap: wrap;'>"
+            for pos, color in POS_COLORS.items():
+                if pos in POS_TRANSLATIONS:
+                    legend_html += f"<div style='margin-right: 10px;'><span style='background-color: {color}; padding: 2px 5px;'>{POS_TRANSLATIONS[pos]}</span></div>"
+            legend_html += "</div>"
+            st.markdown(legend_html, unsafe_allow_html=True)
+
+            with st.expander(t['arc_diagram'], expanded=True):
+                sentences = list(doc.sents)
+                arc_diagrams = []
+                for i, sent in enumerate(sentences):
+                    st.subheader(f"{t['sentence']} {i+1}")
+                    html = displacy.render(sent, style="dep", options={"distance": 100})
+                    html = html.replace('height="375"', 'height="200"')
+                    html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
+                    html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', lambda m: f'<g transform="translate({m.group(1)},50)"', html)
+                    st.write(html, unsafe_allow_html=True)
+                    arc_diagrams.append(html)
+
+            with st.expander(t['network_diagram'], expanded=True):
+                fig = visualize_syntax(sentence_input, nlp_models[lang_code], lang_code)
+                st.pyplot(fig)
+
+            if store_analysis_result(
+                st.session_state.username,
+                sentence_input,
+                word_colors,
+                arc_diagrams,
+                fig
+            ):
+                st.success("Análisis guardado correctamente.")
+            else:
+                st.error("Hubo un problema al guardar el análisis. Por favor, inténtelo de nuevo.")
+                st.error(f"Falló el guardado del análisis. Username: {st.session_state.username}")
+
+##########################################################################
+def display_teacher_interface():
+    st.write("Bienvenido, profesor. Aquí podrás ver el progreso de tus estudiantes.")
+    # Aquí puedes agregar la lógica para mostrar el progreso de los estudiantes

modules/__init__.py

@@ -0,0 +1,112 @@
+# modules/__init__.py
+
+def load_auth_functions():
+    from .auth.auth import authenticate_student, register_student, update_student_info, delete_student
+    return {
+        'authenticate_student': authenticate_student,
+        'register_student': register_student,
+        'update_student_info': update_student_info,
+        'delete_student': delete_student
+    }
+
+def load_database_functions():
+
+    from .database.database_init import (
+    initialize_database_connections
+    )
+
+    from .database.sql_db import (
+        create_student_user,
+        get_student_user,
+        update_student_user,
+        delete_student_user,
+        store_application_request,
+        store_student_feedback
+    )
+    from .database.mongo_db import (
+        get_collection,
+        insert_document,
+        find_documents,
+        update_document,
+        delete_document,
+    )
+    from .database.morphosintax_mongo_db import (
+        store_student_morphosyntax_result,
+        get_student_morphosyntax_analysis,
+        update_student_morphosyntax_analysis,
+        delete_student_morphosyntax_analysis,
+        get_student_morphosyntax_data
+    )
+    from .database.chat_db import store_chat_history, get_chat_history
+
+    return {
+        'initialize_database_connections': initialize_database_connections,
+        'create_student_user': create_student_user,
+        'get_student_user': get_student_user,
+        'update_student_user': update_student_user,
+        'delete_student_user': delete_student_user,
+        'store_application_request': store_application_request,
+        'store_student_feedback': store_student_feedback,
+        'get_collection': get_collection,
+        'insert_document': insert_document,
+        'find_documents': find_documents,
+        'update_document': update_document,
+        'delete_document': delete_document,
+        'store_student_morphosyntax_result': store_student_morphosyntax_result,
+        'get_student_morphosyntax_analysis': get_student_morphosyntax_analysis,
+        'update_student_morphosyntax_analysis': update_student_morphosyntax_analysis,
+        'delete_student_morphosyntax_analysis': delete_student_morphosyntax_analysis,
+        'get_student_morphosyntax_data': get_student_morphosyntax_data,
+        'store_chat_history': store_chat_history,
+        'get_chat_history': get_chat_history
+    }
+
+def load_ui_functions():
+    # No importamos nada de ui.py aquí
+    return {}  # Retornamos un diccionario vacío
+
+def load_student_activities_functions():
+    from .studentact.student_activities import display_student_progress
+    return {
+        'display_student_progress': display_student_progress
+    }
+
+def load_morphosyntax_functions():
+    from .morphosyntax.morphosyntax_interface import display_morphosyntax_interface
+    from .morphosyntax.morphosyntax_process import process_morphosyntactic_input
+    return {
+        'display_morphosyntax_interface': display_morphosyntax_interface,
+        'process_morphosyntactic_input': process_morphosyntactic_input
+    }
+
+def load_admin_functions():
+    from .admin.admin_ui import admin_page
+    return {
+        'admin_page': admin_page
+    }
+
+def load_utils_functions():
+    from .utils.spacy_utils import load_spacy_models
+    return {
+        'load_spacy_models': load_spacy_models
+    }
+
+def load_chatbot_functions():
+    from .chatbot.chatbot import initialize_chatbot, process_chat_input
+    return {
+        'initialize_chatbot': initialize_chatbot,
+        'process_chat_input': process_chat_input
+        }
+
+# Función para cargar todas las funciones
+def load_all_functions():
+    return {
+        **load_auth_functions(),
+        **load_database_functions(),
+        # **load_ui_functions(),
+        **load_admin_functions(),
+        **load_morphosyntax_functions(),
+        **load_utils_functions(),
+        **load_chatbot_functions(),
+        **load_student_activities_functions()
+    }

modules/__init__Old-V3.py

@@ -0,0 +1,180 @@
+# modules/__init__.py
+
+def load_auth_functions():
+    from .auth.auth import authenticate_user, register_user
+    return {
+        'authenticate_user': authenticate_user,
+        'register_user': register_user
+    }
+
+def load_database_function():
+    from .database.database_oldFromV2 import (
+        initialize_mongodb_connection,
+        initialize_database_connections,
+        create_admin_user,
+        create_student_user,
+        get_user,
+        get_student_data,
+        get_user_files,
+        delete_file,
+        store_application_request,
+        store_user_feedback,
+        store_morphosyntax_result,
+        store_semantic_result,
+        store_discourse_analysis_result,
+        store_chat_history,
+        export_analysis_and_chat,
+        manage_file_contents
+    )
+    return {
+        'initialize_mongodb_connection': initialize_mongodb_connection,
+        'initialize_database_connections': initialize_database_connections,
+        'create_admin_user': create_admin_user,
+        'create_student_user': create_student_user,
+        'get_user': get_user,
+        'get_student_data': get_student_data,
+        'get_user_files': get_user_files,
+        'delete_file': delete_file,
+        'store_application_request': store_application_request,
+        'store_user_feedback': store_user_feedback,
+        'store_morphosyntax_result': store_morphosyntax_result,
+        'store_semantic_result': store_semantic_result,
+        'store_discourse_analysis_result': store_discourse_analysis_result,
+        'store_chat_history': store_chat_history,
+        'export_analysis_and_chat': export_analysis_and_chat,
+        'manage_file_contents': manage_file_contents
+    }
+
+def load_ui_functions():
+    # No importamos nada de ui.py aquí
+    return {}  # Retornamos un diccionario vacío
+
+
+def load_student_activities_functions():
+    from .studentact.student_activities_v2 import display_student_progress
+    return {
+        'display_student_progress': display_student_progress
+    }
+
+def load_morphosyntax_functions():
+    from .morphosyntax.morphosyntax_interface import display_morphosyntax_interface
+    from .morphosyntax.morphosyntax_process import process_morphosyntactic_input
+    return {
+        'display_morphosyntax_interface': display_morphosyntax_interface,
+        'process_morphosyntactic_input': process_morphosyntactic_input
+    }
+
+def load_semantic_functions():
+    from .semantic.semantic_interface_68ok import display_semantic_interface
+    from .semantic.semantic_process import process_semantic_input
+    return {
+        'display_semantic_interface': display_semantic_interface,
+        'process_semantic_input': process_semantic_input
+    }
+
+def load_discourse_functions():
+    from .discourse.discourse_interface import display_discourse_interface
+    from .discourse.discourse_process import process_discourse_input
+    return {
+        'display_discourse_interface': display_discourse_interface,
+        'process_discourse_input': process_discourse_input
+    }
+
+def load_email_functions():
+    from .email.email import send_email_notification
+    return {
+        'send_email_notification': send_email_notification
+    }
+
+def load_admin_functions():
+    from .admin.admin_ui import admin_page
+    return {
+        'admin_page': admin_page
+    }
+
+def load_text_analysis_functions():
+    from .text_analysis.morpho_analysis import (
+        generate_arc_diagram,
+        perform_advanced_morphosyntactic_analysis,
+        perform_pos_analysis,
+        perform_morphological_analysis,
+        analyze_sentence_structure,
+        get_repeated_words_colors,
+        highlight_repeated_words,
+    )
+    from .text_analysis.semantic_analysis import (
+        perform_semantic_analysis,
+        generate_summary,
+        extract_entities,
+        analyze_sentiment,
+        create_topic_graph,
+        visualize_topic_graph,
+        ENTITY_LABELS
+    )
+    from .text_analysis.discourse_analysis import (
+        perform_discourse_analysis,
+        compare_semantic_analysis
+    )
+    return {
+        'generate_arc_diagram': generate_arc_diagram,
+        'perform_advanced_morphosyntactic_analysis': perform_advanced_morphosyntactic_analysis,
+        'perform_pos_analysis': perform_pos_analysis,
+        'perform_morphological_analysis': perform_morphological_analysis,
+        'analyze_sentence_structure': analyze_sentence_structure,
+        'get_repeated_words_colors': get_repeated_words_colors,
+        'highlight_repeated_words': highlight_repeated_words,
+        'perform_semantic_analysis': perform_semantic_analysis,
+        'generate_summary': generate_summary,
+        'extract_entities': extract_entities,
+        'analyze_sentiment': analyze_sentiment,
+        'create_topic_graph': create_topic_graph,
+        'visualize_topic_graph': visualize_topic_graph,
+        'ENTITY_LABELS': ENTITY_LABELS,
+        'perform_discourse_analysis': perform_discourse_analysis,
+        'compare_semantic_analysis': compare_semantic_analysis
+    }
+
+def load_utils_functions():
+    from .utils.spacy_utils import load_spacy_models
+    return {
+        'load_spacy_models': load_spacy_models
+    }
+
+def load_chatbot_functions():
+    from .chatbot.chatbot import (
+        ClaudeAPIChat,
+        initialize_chatbot,
+        process_chat_input,
+        get_connectors,
+        handle_semantic_commands,
+        generate_topics_visualization,
+        extract_topics,
+        get_semantic_chatbot_response
+    )
+    return {
+        'ClaudeAPIChat': ClaudeAPIChat,
+        'initialize_chatbot': initialize_chatbot,
+        'process_chat_input': process_chat_input,
+        'get_connectors': get_connectors,
+        'handle_semantic_commands': handle_semantic_commands,
+        'generate_topics_visualization': generate_topics_visualization,
+        'extract_topics': extract_topics,
+        'get_semantic_chatbot_response': get_semantic_chatbot_response
+    }
+
+# Función para cargar todas las funciones
+def load_all_functions():
+    return {
+        **load_auth_functions(),
+        **load_database_function(),
+        # **load_ui_functions(),
+        **load_admin_functions(),
+        **load_morphosyntax_functions(),
+        **load_semantic_functions(),
+        **load_discourse_functions(),
+        **load_text_analysis_functions(),
+        **load_utils_functions(),
+        **load_chatbot_functions(),
+        **load_email_functions()
+        **load_student_activities_functions()  # Añadimos las nuevas funciones de actividades del estudiante
+    }

modules/admin/admin_ui.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    get_admin_user,
+    get_teacher_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user
+)
+
+from ..database.morphosintax_mongo_db import get_student_morphosyntax_analysis
+
+def admin_page():
+    st.title("Panel de Administración")
+    st.write(f"Bienvenido, {st.session_state.username}")
+
+    # Sección para crear nuevos usuarios estudiantes
+    st.header("Crear Nuevo Usuario Estudiante")
+    new_username = st.text_input("Correo electrónico del nuevo usuario", key="admin_new_username")
+    new_password = st.text_input("Contraseña", type="password", key="admin_new_password")
+    if st.button("Crear Usuario", key="admin_create_user"):
+        if create_student_user(new_username, new_password):
+            st.success(f"Usuario estudiante {new_username} creado exitosamente")
+        else:
+            st.error("Error al crear el usuario estudiante")
+
+    # Sección para ver datos de estudiantes
+    st.header("Ver Datos de Estudiantes")
+    student_username = st.text_input("Nombre de usuario del estudiante", key="admin_view_student")
+    if st.button("Ver Datos", key="admin_view_student_data"):
+        student = get_student_user(student_username)
+        if student:
+            st.write(f"Información del estudiante {student_username}:")
+            st.json(student)
+
+            student_data = get_student_morphosyntax_analysis(student_username)
+            if student_data:
+                st.write("Datos de análisis del estudiante:")
+                st.json(student_data)
+            else:
+                st.info("No hay datos de análisis para este estudiante.")
+        else:
+            st.error("Estudiante no encontrado")
+
+    # Botón para cerrar sesión
+    if st.button("Cerrar Sesión", key="admin_logout"):
+        st.session_state.clear()
+        st.experimental_rerun()

modules/auth/auth.py

@@ -0,0 +1,119 @@
+import os
+from azure.cosmos import CosmosClient, exceptions
+from azure.cosmos.exceptions import CosmosHttpResponseError
+import bcrypt
+import base64
+from ..database.sql_db import (
+    get_user,
+    get_student_user,
+    get_admin_user,
+    get_teacher_user,
+    create_student_user,
+    update_student_user,
+    delete_student_user
+)
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# ... (código de inicialización)
+def clean_and_validate_key(key):
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += '='
+    try:
+        base64.b64decode(key)
+        return key
+    except:
+        raise ValueError("La clave proporcionada no es válida")
+
+# Verificar las variables de entorno
+endpoint = os.getenv("COSMOS_ENDPOINT")
+key = os.getenv("COSMOS_KEY")
+
+if not endpoint or not key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+key = clean_and_validate_key(key)
+####################################################
+
+
+def authenticate_user(username, password):
+    try:
+        user_item = get_user(username)
+        if user_item and verify_password(user_item['password'], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
+            return True, user_item['role']
+        logger.warning(f"Autenticación fallida para el usuario: {username}")
+        return False, None
+    except Exception as e:
+        logger.error(f"Error durante la autenticación del usuario: {str(e)}")
+        return False, None
+
+def authenticate_admin(username, password):
+    return authenticate_user(username, password)
+
+def authenticate_student(username, password):
+    return authenticate_user(username, password)
+
+def authenticate_teacher(username, password):
+    return authenticate_user(username, password)
+
+############################
+def register_student(username, password, additional_info=None):
+    try:
+        if get_student_user(username):
+            logger.warning(f"Intento de registro de estudiante existente: {username}")
+            return False  # El estudiante ya existe
+
+        success = create_student_user(username, password, additional_info)
+        if success:
+            logger.info(f"Nuevo estudiante registrado: {username}")
+            return True
+        else:
+            logger.error(f"Error al registrar nuevo estudiante: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al registrar estudiante: {str(e)}")
+        return False
+
+def update_student_info(username, new_info):
+    try:
+        success = update_student_user(username, new_info)
+        if success:
+            logger.info(f"Información del estudiante actualizada: {username}")
+            return True
+        else:
+            logger.error(f"Error al actualizar información del estudiante: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al actualizar información del estudiante: {str(e)}")
+        return False
+
+def delete_student(username):
+    try:
+        success = delete_student_user(username)
+        if success:
+            logger.info(f"Estudiante eliminado: {username}")
+            return True
+        else:
+            logger.error(f"Error al eliminar estudiante: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al eliminar estudiante: {str(e)}")
+        return False
+
+
+# ... (funciones de hash y verificación de contraseña)
+
+def hash_password(password):
+    """Hash a password for storing."""
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+##################################################################################33
+
+def verify_password(stored_password, provided_password):
+    """Verify a stored password against one provided by user"""
+    return bcrypt.checkpw(provided_password.encode('utf-8'), stored_password.encode('utf-8'))
+######################################################################################################

modules/chatbot/chatbot.py

@@ -0,0 +1,46 @@
+import streamlit as st
+from ..text_analysis.morpho_analysis import perform_advanced_morphosyntactic_analysis
+from ..text_analysis.semantic_analysis import perform_semantic_analysis
+from ..text_analysis.discourse_analysis import perform_discourse_analysis
+
+class AIdeaTextChatbot:
+    def __init__(self):
+        self.conversation_history = []
+
+    def handle_morphosyntactic_input(self, user_input, lang_code, nlp_models, t):
+        if user_input.startswith('/analisis_morfosintactico'):
+            text_to_analyze = user_input.split('[', 1)[1].rsplit(']', 1)[0]
+            result = perform_advanced_morphosyntactic_analysis(text_to_analyze, nlp_models[lang_code])
+            if result is None or 'arc_diagrams' not in result:
+                return t.get('morphosyntactic_analysis_error', 'Error en el análisis morfosintáctico'), None, None
+            return t.get('morphosyntactic_analysis_completed', 'Análisis morfosintáctico completado'), result['arc_diagrams'], result
+        else:
+            # Aquí puedes manejar otras interacciones relacionadas con el análisis morfosintáctico
+            return self.generate_response(user_input, lang_code), None, None
+
+
+    def handle_semantic_input(self, user_input, lang_code, nlp_models, t):
+        # Implementar lógica para análisis semántico
+        pass
+
+    def handle_discourse_input(self, user_input, lang_code, nlp_models, t):
+        # Implementar lógica para análisis de discurso
+        pass
+
+    def handle_generate_response(self, prompt, lang_code):
+        # Aquí iría la lógica para generar respuestas generales del chatbot
+        # Puedes usar la API de Claude aquí si lo deseas
+        pass
+
+def initialize_chatbot():
+    return AIdeaTextChatbot()
+
+def process_chat_input(user_input, lang_code, nlp_models, analysis_type, t, file_contents=None):
+    chatbot = st.session_state.get('aideatext_chatbot')
+    if not chatbot:
+        chatbot = initialize_chatbot()
+        st.session_state.aideatext_chatbot = chatbot
+
+    if analysis_type == 'morphosyntactic':
+        return chatbot.handle_morphosyntactic_input(user_input, lang_code, nlp_models, t)
+    # ... manejar otros tipos de análisis ...

modules/chatbot/chatbot_open_Source_Model-test.py

@@ -0,0 +1,124 @@
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+import torch
+from torch.optim import Adam
+from torch.utils.data import DataLoader, Dataset
+import json
+import tqdm
+
+tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
+model = GPT2LMHeadModel.from_pretrained("openai-community/gpt2")
+
+class MultilingualChatData(Dataset):
+    def __init__(self, file_path, tokenizer, max_length=512):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            self.data = json.load(f)
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        input_text = f"<startofstring> {item['input']} <bot>: {item['output']} <endofstring>"
+        encoding = self.tokenizer(input_text, truncation=True, padding='max_length', max_length=self.max_length, return_tensors="pt")
+        return encoding['input_ids'].squeeze(), encoding['attention_mask'].squeeze()
+
+class MultilingualChatbot:
+    def __init__(self):
+        self.models = {
+            'en': GPT2LMHeadModel.from_pretrained("microsoft/DialoGPT-medium"),
+            'es': GPT2LMHeadModel.from_pretrained("DeepESP/gpt2-spanish"),
+            'fr': GPT2LMHeadModel.from_pretrained("asi/gpt-fr-cased-small")
+        }
+        self.tokenizers = {
+            'en': GPT2Tokenizer.from_pretrained("microsoft/DialoGPT-medium"),
+            'es': GPT2Tokenizer.from_pretrained("DeepESP/gpt2-spanish"),
+            'fr': GPT2Tokenizer.from_pretrained("asi/gpt-fr-cased-small")
+        }
+        for tokenizer in self.tokenizers.values():
+            tokenizer.pad_token = tokenizer.eos_token
+            tokenizer.add_special_tokens({
+                "bos_token": "<startofstring>",
+                "eos_token": "<endofstring>"
+            })
+            tokenizer.add_tokens(["<bot>:"])
+        
+        for model in self.models.values():
+            model.resize_token_embeddings(len(self.tokenizers['en']))  # Assuming all tokenizers have the same vocabulary size
+        
+        self.device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+        for model in self.models.values():
+            model.to(self.device)
+
+    def train(self, lang, data_file, epochs=5, batch_size=32, learning_rate=1e-4):
+        model = self.models[lang]
+        tokenizer = self.tokenizers[lang]
+        
+        chat_data = MultilingualChatData(data_file, tokenizer)
+        data_loader = DataLoader(chat_data, batch_size=batch_size, shuffle=True)
+        
+        optimizer = Adam(model.parameters(), lr=learning_rate)
+        
+        model.train()
+        for epoch in range(epochs):
+            total_loss = 0
+            for batch in tqdm.tqdm(data_loader, desc=f"Epoch {epoch+1}/{epochs}"):
+                input_ids, attention_mask = [b.to(self.device) for b in batch]
+                
+                optimizer.zero_grad()
+                outputs = model(input_ids, attention_mask=attention_mask, labels=input_ids)
+                loss = outputs.loss
+                loss.backward()
+                optimizer.step()
+                
+                total_loss += loss.item()
+            
+            print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(data_loader):.4f}")
+        
+        torch.save(model.state_dict(), f"model_state_{lang}.pt")
+
+    def generate_response(self, prompt, src_lang):
+        model = self.models.get(src_lang, self.models['en'])
+        tokenizer = self.tokenizers.get(src_lang, self.tokenizers['en'])
+        
+        input_text = f"<startofstring> {prompt} <bot>: "
+        input_ids = tokenizer.encode(input_text, return_tensors='pt').to(self.device)
+        
+        attention_mask = torch.ones(input_ids.shape, dtype=torch.long, device=self.device)
+        
+        output = model.generate(
+            input_ids,
+            attention_mask=attention_mask,
+            max_length=1000,
+            pad_token_id=tokenizer.eos_token_id,
+            no_repeat_ngram_size=3,
+            do_sample=True,
+            top_k=50,
+            top_p=0.95,
+            temperature=0.7,
+            num_return_sequences=1,
+            length_penalty=1.0,
+            repetition_penalty=1.2
+        )
+        
+        decoded_output = tokenizer.decode(output[0], skip_special_tokens=True)
+        return decoded_output.split("<bot>:")[-1].strip()
+
+def initialize_chatbot():
+    return MultilingualChatbot()
+
+def get_chatbot_response(chatbot, prompt, src_lang):
+    return chatbot.generate_response(prompt, src_lang)
+
+# Ejemplo de uso
+if __name__ == "__main__":
+    chatbot = initialize_chatbot()
+    
+    # Entrenar el modelo en español (asumiendo que tienes un archivo de datos en español)
+    chatbot.train('es', './spanish_chat_data.json', epochs=3)
+    
+    # Generar respuestas
+    print(get_chatbot_response(chatbot, "Hola, ¿cómo estás?", 'es'))
+    print(get_chatbot_response(chatbot, "Hello, how are you?", 'en'))
+    print(get_chatbot_response(chatbot, "Bonjour, comment allez-vous?", 'fr'))

modules/database/backUp/database.py

@@ -0,0 +1,216 @@
+# database.py
+# Versión 3 actualizada para manejar chat_history_v3
+
+import streamlit as st
+import logging
+import os
+from pymongo import MongoClient
+import certifi
+from datetime import datetime, timezone
+import uuid
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+analysis_collection = None
+chat_collection_v3 = None  # Nueva variable global para chat_history_v3
+
+def initialize_mongodb_connection():
+    global mongo_client, mongo_db, analysis_collection, chat_collection_v3
+    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_v3 = mongo_db['chat_history_v3']  # Inicializar la nueva colección
+
+        # Crear índices para chat_history_v3
+        chat_collection_v3.create_index([("username", 1), ("timestamp", -1)])
+        chat_collection_v3.create_index([("username", 1), ("analysis_type", 1), ("timestamp", -1)])
+
+        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 store_chat_history_v3(username, messages, analysis_type):
+    try:
+        logger.info(f"Guardando historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
+        logger.debug(f"Mensajes a guardar: {messages}")
+
+        chat_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'analysis_type': analysis_type,
+            'messages': messages
+        }
+        result = chat_collection_v3.insert_one(chat_document)
+        logger.info(f"Historial de chat guardado con ID: {result.inserted_id} para el usuario: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al guardar el historial de chat para el usuario {username}: {str(e)}")
+        return False
+
+def get_chat_history_v3(username, analysis_type=None, limit=10):
+    try:
+        logger.info(f"Obteniendo historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
+
+        query = {"username": username}
+        if analysis_type:
+            query["analysis_type"] = analysis_type
+
+        cursor = chat_collection_v3.find(query).sort("timestamp", -1).limit(limit)
+
+        chat_history = []
+        for chat in cursor:
+            chat_history.append({
+                "timestamp": chat["timestamp"],
+                "analysis_type": chat["analysis_type"],
+                "messages": chat["messages"]
+            })
+
+        logger.info(f"Se obtuvieron {len(chat_history)} entradas de chat para el usuario: {username}")
+        return chat_history
+    except Exception as e:
+        logger.error(f"Error al obtener el historial de chat para el usuario {username}: {str(e)}")
+        return []
+
+def delete_chat_history_v3(username, analysis_type=None):
+    try:
+        logger.info(f"Eliminando historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
+
+        query = {"username": username}
+        if analysis_type:
+            query["analysis_type"] = analysis_type
+
+        result = chat_collection_v3.delete_many(query)
+
+        logger.info(f"Se eliminaron {result.deleted_count} entradas de chat para el usuario: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al eliminar el historial de chat para el usuario {username}: {str(e)}")
+        return False
+
+def export_chat_history_v3(username, analysis_type=None):
+    try:
+        logger.info(f"Exportando historial de chat para el usuario: {username}, tipo de análisis: {analysis_type}")
+
+        query = {"username": username}
+        if analysis_type:
+            query["analysis_type"] = analysis_type
+
+        cursor = chat_collection_v3.find(query).sort("timestamp", -1)
+
+        export_data = list(cursor)
+
+        logger.info(f"Se exportaron {len(export_data)} entradas de chat para el usuario: {username}")
+        return export_data
+    except Exception as e:
+        logger.error(f"Error al exportar el historial de chat para el usuario {username}: {str(e)}")
+        return []
+
+# Funciones específicas para cada tipo de análisis
+
+def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_analysis, morphological_analysis, sentence_structure):
+    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.now(timezone.utc).isoformat(),
+            'text': text,
+            'repeated_words': repeated_words,
+            'word_count': word_count,
+            'arc_diagrams': arc_diagrams,
+            'pos_analysis': pos_analysis,
+            'morphological_analysis': morphological_analysis,
+            'sentence_structure': sentence_structure,
+            'analysis_type': 'morphosyntax'
+        }
+
+        result = analysis_collection.insert_one(analysis_document)
+        logger.info(f"Análisis morfosintáctico 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 morfosintáctico para el usuario {username}: {str(e)}")
+        return False
+
+# Aquí puedes agregar funciones similares para análisis semántico y de discurso
+
+def get_student_data(username):
+    if analysis_collection is None or chat_collection_v3 is None:
+        logger.error("La conexión a MongoDB no está inicializada")
+        return None
+
+    formatted_data = {
+        "username": username,
+        "entries": [],
+        "entries_count": 0,
+        "word_count": {},
+        "chat_history": {
+            "morphosyntax": [],
+            "semantic": [],
+            "discourse": []
+        }
+    }
+
+    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"),
+                "analysis_type": entry.get("analysis_type", "morphosyntax")
+            }
+
+            if formatted_entry["analysis_type"] == "morphosyntax":
+                formatted_entry.update({
+                    "text": entry.get("text", ""),
+                    "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
+
+            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)
+
+        # Obtener historial de chat para cada tipo de análisis
+        for analysis_type in ["morphosyntax", "semantic", "discourse"]:
+            chat_history = get_chat_history_v3(username, analysis_type)
+            formatted_data["chat_history"][analysis_type] = chat_history
+
+    except Exception as e:
+        logger.error(f"Error al obtener datos del estudiante {username}: {str(e)}")
+
+    logger.info(f"Datos formateados para {username}: {formatted_data}")
+    return formatted_data
+
+# Puedes agregar más funciones según sea necesario para manejar otros tipos de datos o análisis

modules/database/backUp/databaseBackUp23-9-24.py

@@ -0,0 +1,581 @@
+# 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
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+import bcrypt
+print(f"Bcrypt version: {bcrypt.__version__}")
+import uuid
+import plotly.graph_objects as go  # Para manejar el diagrama de Sankey
+import numpy as np  # Puede ser necesario para algunas operaciones
+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
+user_feedback_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+analysis_collection = None
+chat_collection = None  # Nueva variable global
+
+
+##############################################################################--- INICIO DE LAS BASES DE DATOS --- ###############################
+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, user_feedback_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")
+        user_feedback_container = user_database.get_container_client("user_feedback")
+
+        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(f"user_feedback_container initialized: {user_feedback_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
+
+##############################################################################--- FIN DEL INICIO DE LAS BASES DE DATOS  --- ################################################################################################################################
+########################################################## -- INICIO DE GESTION DE USUARIOS ---##########################################################
+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
+
+########################################################## -- FIN DE GESTION DE USUARIOS ---##########################################################
+
+########################################################## -- INICIO GESTION DE ARCHIVOS ---##########################################################
+
+def store_file_contents(username, file_name, file_contents, analysis_type):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+    try:
+        document = {
+            'id': f"{username}_{analysis_type}_{file_name}",
+            'username': username,
+            'file_name': file_name,
+            'analysis_type': analysis_type,
+            'file_contents': file_contents,
+            'timestamp': datetime.utcnow().isoformat()
+        }
+        user_container.upsert_item(body=document)
+        logger.info(f"Contenido del archivo guardado para el usuario: {username}, tipo de análisis: {analysis_type}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al guardar el contenido del archivo para el usuario {username}: {str(e)}")
+        return False
+
+def retrieve_file_contents(username, file_name, analysis_type):
+    print(f"Attempting to retrieve file: {file_name} for user: {username}")
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return None
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}_{analysis_type}_{file_name}'"
+        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        if items:
+            return items[0]['file_contents']
+        else:
+            logger.info(f"No se encontró contenido de archivo para el usuario: {username}, tipo de análisis: {analysis_type}")
+            return None
+    except Exception as e:
+        logger.error(f"Error al recuperar el contenido del archivo para el usuario {username}: {str(e)}")
+        return None
+
+def get_user_files(username, analysis_type=None):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return []
+    try:
+        if analysis_type:
+            query = f"SELECT c.file_name, c.analysis_type, c.timestamp FROM c WHERE c.username = '{username}' AND c.analysis_type = '{analysis_type}'"
+        else:
+            query = f"SELECT c.file_name, c.analysis_type, c.timestamp FROM c WHERE c.username = '{username}'"
+
+        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        return items
+    except Exception as e:
+        logger.error(f"Error al obtener la lista de archivos del usuario {username}: {str(e)}")
+        return []
+
+def delete_file(username, file_name, analysis_type):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+    try:
+        user_container.delete_item(item=f"{username}_{analysis_type}_{file_name}", partition_key=username)
+        logger.info(f"Archivo eliminado para el usuario: {username}, tipo de análisis: {analysis_type}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al eliminar el archivo para el usuario {username}: {str(e)}")
+        return False
+
+########################################################## -- FIN GESTION DE ARCHIVOS ---##########################################################
+
+########################################################## -- INICIO GESTION DE FORMULARIOS ---##########################################################
+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_user_feedback(username, name, email, feedback):
+    global user_feedback_container
+    logger.info(f"Attempting to store user feedback for user: {username}")
+    try:
+        if user_feedback_container is None:
+            logger.error("user_feedback_container is not initialized")
+            return False
+
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+
+        result = user_feedback_container.create_item(body=feedback_item)
+        logger.info(f"User feedback stored with ID: {result['id']} for user: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error storing user feedback for user {username}: {str(e)}")
+        return False
+
+
+########################################################## -- FIN GESTION DE FORMULARIOS ---##########################################################
+
+########################################################## -- INICIO ALMACENAMIENTO ANÁLISIS MORFOSINTÁCTICO ---##########################################################
+
+def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_analysis, morphological_analysis, sentence_structure):
+    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,
+            'pos_analysis': pos_analysis,
+            'morphological_analysis': morphological_analysis,
+            'sentence_structure': sentence_structure
+        }
+
+        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
+
+########################################################## -- FIN ALMACENAMIENTO ANÁLISIS MORFOSINTÁCTICO ---##########################################################
+
+
+##########################################--- INICIO SECCIÓN DEL ANÁLISIS SEMÁNTICO ---###############################################
+
+def store_file_semantic_contents(username, file_name, file_contents):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+    try:
+        document = {
+            'id': f"{username}_semantic_{file_name}",
+            'username': username,
+            'file_name': file_name,
+            'file_contents': file_contents,
+            'analysis_type': 'semantic',
+            'timestamp': datetime.utcnow().isoformat()
+        }
+        user_container.upsert_item(body=document)
+        logger.info(f"Contenido del archivo semántico guardado para el usuario: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al guardar el contenido del archivo semántico para el usuario {username}: {str(e)}")
+        return False
+
+def store_semantic_result(username, text, analysis_result):
+    if analysis_collection is None:
+        print("La conexión a MongoDB no está inicializada")
+        return False
+    try:
+        # Convertir los conceptos clave a una lista de tuplas
+        key_concepts = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts']]
+
+        # Convertir los gráficos a imágenes base64
+        graphs = {}
+        for graph_name in ['relations_graph', 'entity_graph', 'topic_graph']:
+            if graph_name in analysis_result:
+                buf = BytesIO()
+                analysis_result[graph_name].savefig(buf, format='png')
+                buf.seek(0)
+                graphs[graph_name] = base64.b64encode(buf.getvalue()).decode('utf-8')
+
+        analysis_document = {
+            'username': username,
+            'timestamp': datetime.utcnow(),
+            'text': text,
+            'key_concepts': key_concepts,
+            'graphs': graphs,
+            'summary': analysis_result.get('summary', ''),
+            'entities': analysis_result.get('entities', {}),
+            'sentiment': analysis_result.get('sentiment', ''),
+            'topics': analysis_result.get('topics', []),
+            'analysis_type': 'semantic'
+        }
+
+        result = analysis_collection.insert_one(analysis_document)
+        print(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
+        return True
+    except Exception as e:
+        print(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
+        return False
+
+##########################################--- FIN DE LA SECCIÓN DEL ANÁLISIS SEMÁNTICO ---###############################################
+
+############################################--- INICIO DE LA SECCIÓN DEL ANÁLISIS DEL DISCURSO ###################################################################
+
+def store_discourse_analysis_result(username, text1, text2, analysis_result):
+    if analysis_collection is None:
+        print("La conexión a MongoDB no está inicializada")
+        return False
+
+    try:
+        # Convertir los grafos individuales a imágenes base64
+        buf1 = BytesIO()
+        analysis_result['graph1'].savefig(buf1, format='png')
+        buf1.seek(0)
+        img_str1 = base64.b64encode(buf1.getvalue()).decode('utf-8')
+
+        buf2 = BytesIO()
+        analysis_result['graph2'].savefig(buf2, format='png')
+        buf2.seek(0)
+        img_str2 = base64.b64encode(buf2.getvalue()).decode('utf-8')
+
+        # Crear una imagen combinada
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
+        ax1.imshow(plt.imread(BytesIO(base64.b64decode(img_str1))))
+        ax1.axis('off')
+        ax1.set_title("Documento 1: Relaciones Conceptuales")
+        ax2.imshow(plt.imread(BytesIO(base64.b64decode(img_str2))))
+        ax2.axis('off')
+        ax2.set_title("Documento 2: Relaciones Conceptuales")
+
+        buf_combined = BytesIO()
+        fig.savefig(buf_combined, format='png')
+        buf_combined.seek(0)
+        img_str_combined = base64.b64encode(buf_combined.getvalue()).decode('utf-8')
+        plt.close(fig)
+
+        # Convertir los conceptos clave a listas de tuplas
+        key_concepts1 = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts1']]
+        key_concepts2 = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts2']]
+
+        # Crear el documento para guardar
+        analysis_document = {
+            'username': username,
+            'timestamp': datetime.utcnow(),
+            #'text1': text1,
+            #'text2': text2,
+            'graph1': img_str1,
+            'graph2': img_str2,
+            'combined_graph': img_str_combined,
+            'key_concepts1': key_concepts1,
+            'key_concepts2': key_concepts2,
+            'analysis_type': 'discourse'
+        }
+
+        # Insertar el documento en la base de datos
+        result = analysis_collection.insert_one(analysis_document)
+        print(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
+        return True
+    except Exception as e:
+        print(f"Error al guardar el análisis discursivo para el usuario {username}: {str(e)}")
+        print(f"Tipo de excepción: {type(e).__name__}")
+        print(f"Detalles de la excepción: {e.args}")
+        return False
+
+############################################--- FIN DE LA SECCIÓN DEL ANÁLISIS DEL DISCURSO ###################################################################
+
+
+################################################-- INICIO DE LA SECCIÓN DEL CHATBOT --- ###############################################################
+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 export_analysis_and_chat(username, analysis_data, chat_data):
+    try:
+        export_data = {
+            "username": username,
+            "timestamp": datetime.utcnow(),
+            "analysis": analysis_data,
+            "chat": chat_data
+        }
+
+        # Aquí puedes decidir cómo quieres exportar los datos
+        # Por ejemplo, podrías guardarlos en una nueva colección en MongoDB
+        export_collection = mongo_db['exports']
+        result = export_collection.insert_one(export_data)
+
+        # También podrías generar un archivo JSON o CSV y guardarlo en Azure Blob Storage
+
+        return True
+    except Exception as e:
+        logger.error(f"Error al exportar análisis y chat para {username}: {str(e)}")
+        return False
+
+################################################-- FIN DE LA SECCIÓN DEL CHATBOT --- ###############################################################
+
+#######################################################################################################################################################
+
+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()),
+                "analysis_type": entry.get("analysis_type", "morphosyntax")
+            }
+
+            if formatted_entry["analysis_type"] == "morphosyntax":
+                formatted_entry.update({
+                    "text": entry.get("text", ""),
+                    "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.update({
+                    "key_concepts": entry.get("key_concepts", []),
+                    "graph": entry.get("graph", "")
+                })
+                formatted_data["semantic_analyses"].append(formatted_entry)
+
+            elif formatted_entry["analysis_type"] == "discourse":
+                formatted_entry.update({
+                    "text1": entry.get("text1", ""),
+                    "text2": entry.get("text2", ""),
+                    "key_concepts1": entry.get("key_concepts1", []),
+                    "key_concepts2": entry.get("key_concepts2", []),
+                    "graph1": entry.get("graph1", ""),
+                    "graph2": entry.get("graph2", ""),
+                    "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

modules/database/backUp/database_oldFromV2.py

@@ -0,0 +1,473 @@
+# database.py
+# database.py de la versión 3 al 26-9-2024
+import streamlit as st
+import logging
+import os
+import pandas as pd
+from azure.cosmos import CosmosClient
+from azure.cosmos.exceptions import CosmosHttpResponseError
+from pymongo import MongoClient
+import certifi
+from datetime import datetime, timezone
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+import bcrypt
+print(f"Bcrypt version: {bcrypt.__version__}")
+import uuid
+import plotly.graph_objects as go  # Para manejar el diagrama de Sankey
+import numpy as np  # Puede ser necesario para algunas operaciones
+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
+user_feedback_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+analysis_collection = None
+chat_collection = None  # Nueva variable global
+
+
+##############################################################################--- INICIO DE LAS BASES DE DATOS --- ###############################
+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, user_feedback_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")
+        user_feedback_container = user_database.get_container_client("user_feedback")
+
+        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(f"user_feedback_container initialized: {user_feedback_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']
+        # export = mongo_db['export']
+        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
+
+##############################################################################--- FIN DEL INICIO DE LAS BASES DE DATOS  --- ################################################################################################################################
+########################################################## -- INICIO DE GESTION DE USUARIOS ---##########################################################
+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,
+            'timestamp':datetime.now(timezone.utc).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
+
+########################################################## -- FIN DE GESTION DE USUARIOS ---##########################################################
+
+########################################################## -- INICIO GESTION DE ARCHIVOS ---##########################################################
+
+def manage_file_contents(username, file_name, analysis_type, file_contents=None):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return None
+
+    item_id = f"{analysis_type}_{file_name}"
+
+    try:
+        if file_contents is not None:
+            # Storing or updating file
+            document = {
+                'id': item_id,
+                'username': username,
+                'file_name': file_name,
+                'analysis_type': analysis_type,
+                'file_contents': file_contents,
+                'timestamp': datetime.now(timezone.utc).isoformat()
+            }
+            user_container.upsert_item(body=document, partition_key=username)
+            logger.info(f"Contenido del archivo guardado/actualizado para el usuario: {username}, tipo de análisis: {analysis_type}")
+            return True
+        else:
+            # Retrieving file
+            item = user_container.read_item(item=item_id, partition_key=username)
+            return item['file_contents']
+    except CosmosHttpResponseError as e:
+        if e.status_code == 404:
+            logger.info(f"No se encontró el archivo para el usuario: {username}, tipo de análisis: {analysis_type}")
+            return None
+        else:
+            logger.error(f"Error de Cosmos DB al manejar el archivo para el usuario {username}: {str(e)}")
+            return None
+    except Exception as e:
+        logger.error(f"Error al manejar el archivo para el usuario {username}: {str(e)}")
+        return None
+
+
+def get_user_files(username, analysis_type=None):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return []
+    try:
+        if analysis_type:
+            query = f"SELECT c.file_name, c.analysis_type, c.timestamp FROM c WHERE c.username = '{username}' AND c.analysis_type = '{analysis_type}'"
+        else:
+            query = f"SELECT c.file_name, c.analysis_type, c.timestamp FROM c WHERE c.username = '{username}'"
+
+        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        return items
+    except Exception as e:
+        logger.error(f"Error al obtener la lista de archivos del usuario {username}: {str(e)}")
+        return []
+
+
+
+def delete_file(username, file_name, analysis_type):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+
+    try:
+        item_id = f"{analysis_type}_{file_name}"
+        user_container.delete_item(item=item_id, partition_key=username)
+        logger.info(f"Archivo eliminado para el usuario: {username}, tipo de análisis: {analysis_type}, nombre: {file_name}")
+        return True
+
+        if success:
+            # Invalidar caché
+            cache_key = f"student_data_{username}"
+            if cache_key in st.session_state:
+                del st.session_state[cache_key]
+
+
+
+    except CosmosHttpResponseError as e:
+        logger.error(f"Cosmos DB error al eliminar el archivo para el usuario {username}: {str(e)}")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error al eliminar el archivo para el usuario {username}: {str(e)}")
+        return False
+
+########################################################## -- FIN GESTION DE ARCHIVOS ---##########################################################
+
+########################################################## -- INICIO GESTION DE FORMULARIOS ---##########################################################
+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_user_feedback(username, name, email, feedback):
+    global user_feedback_container
+    logger.info(f"Attempting to store user feedback for user: {username}")
+    try:
+        if user_feedback_container is None:
+            logger.error("user_feedback_container is not initialized")
+            return False
+
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+        }
+
+        result = user_feedback_container.create_item(body=feedback_item)
+        logger.info(f"User feedback stored with ID: {result['id']} for user: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error storing user feedback for user {username}: {str(e)}")
+        return False
+
+########################################################## -- FIN GESTION DE FORMULARIOS ---##########################################################
+
+########################################################## -- INICIO ALMACENAMIENTO ANÁLISIS MORFOSINTÁCTICO ---##########################################################
+
+def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_analysis, morphological_analysis, sentence_structure):
+    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.now(timezone.utc).isoformat(),
+            'text': text,
+            'repeated_words': repeated_words,
+            'word_count': word_count,
+            'arc_diagrams': arc_diagrams,
+            'pos_analysis': pos_analysis,
+            'morphological_analysis': morphological_analysis,
+            'sentence_structure': sentence_structure,
+            'analysis_type': 'morphosyntax'
+        }
+
+        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
+
+
+################################################-- INICIO DE LA SECCIÓN DEL CHATBOT --- ###############################################################
+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.now(timezone.utc).isoformat(),
+            '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 export_analysis_and_chat(username, analysis_data, chat_data):
+    try:
+        export_data = {
+            "username": username,
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+            "analysis": analysis_data,
+            "chat": chat_data
+        }
+
+        # Aquí puedes decidir cómo quieres exportar los datos
+        # Por ejemplo, podrías guardarlos en una nueva colección en MongoDB
+        export_collection = mongo_db['exports']
+        result = export_collection.insert_one(export_data)
+
+        # También podrías generar un archivo JSON o CSV y guardarlo en Azure Blob Storage
+
+        return True
+    except Exception as e:
+        logger.error(f"Error al exportar análisis y chat para {username}: {str(e)}")
+        return False
+
+################################################-- FIN DE LA SECCIÓN DEL CHATBOT --- ###############################################################
+########--- STUDENT DATA -------
+
+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':datetime.now(timezone.utc).isoformat(),
+                "analysis_type": entry.get("analysis_type", "morphosyntax")
+            }
+
+            if formatted_entry["analysis_type"] == "morphosyntax":
+                formatted_entry.update({
+                    "text": entry.get("text", ""),
+                    "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.update({
+                    "key_concepts": entry.get("key_concepts", []),
+                    "graph": entry.get("graph", "")
+                })
+                formatted_data["semantic_analyses"].append(formatted_entry)
+
+            elif formatted_entry["analysis_type"] == "discourse":
+                formatted_entry.update({
+                    "text1": entry.get("text1", ""),
+                    "text2": entry.get("text2", ""),
+                    "key_concepts1": entry.get("key_concepts1", []),
+                    "key_concepts2": entry.get("key_concepts2", []),
+                    "graph1": entry.get("graph1", ""),
+                    "graph2": entry.get("graph2", ""),
+                    "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

modules/database/backUp/database_v3-2ok.py

@@ -0,0 +1,629 @@
+# 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, timezone
+import io
+from io import BytesIO
+import base64
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+import bcrypt
+print(f"Bcrypt version: {bcrypt.__version__}")
+import uuid
+import plotly.graph_objects as go  # Para manejar el diagrama de Sankey
+import numpy as np  # Puede ser necesario para algunas operaciones
+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
+user_feedback_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+analysis_collection = None
+chat_collection = None  # Nueva variable global
+
+
+##############################################################################--- INICIO DE LAS BASES DE DATOS --- ###############################
+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, user_feedback_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")
+        user_feedback_container = user_database.get_container_client("user_feedback")
+
+        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(f"user_feedback_container initialized: {user_feedback_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
+
+##############################################################################--- FIN DEL INICIO DE LAS BASES DE DATOS  --- ################################################################################################################################
+########################################################## -- INICIO DE GESTION DE USUARIOS ---##########################################################
+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
+
+########################################################## -- FIN DE GESTION DE USUARIOS ---##########################################################
+
+########################################################## -- INICIO GESTION DE ARCHIVOS ---##########################################################
+
+def store_file_contents(username, file_name, file_contents, analysis_type):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+    try:
+        document = {
+            'id': f"{username}_{analysis_type}_{file_name}",
+            'username': username,
+            'file_name': file_name,
+            'analysis_type': analysis_type,
+            'file_contents': file_contents,
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+        }
+        user_container.upsert_item(body=document)
+        logger.info(f"Contenido del archivo guardado para el usuario: {username}, tipo de análisis: {analysis_type}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al guardar el contenido del archivo para el usuario {username}: {str(e)}")
+        return False
+
+def retrieve_file_contents(username, file_name, analysis_type):
+    print(f"Attempting to retrieve file: {file_name} for user: {username}")
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return None
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}_{analysis_type}_{file_name}'"
+        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        if items:
+            return items[0]['file_contents']
+        else:
+            logger.info(f"No se encontró contenido de archivo para el usuario: {username}, tipo de análisis: {analysis_type}")
+            return None
+    except Exception as e:
+        logger.error(f"Error al recuperar el contenido del archivo para el usuario {username}: {str(e)}")
+        return None
+
+def get_user_files(username, analysis_type=None):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return []
+    try:
+        if analysis_type:
+            query = f"SELECT c.file_name, c.analysis_type, c.timestamp FROM c WHERE c.username = '{username}' AND c.analysis_type = '{analysis_type}'"
+        else:
+            query = f"SELECT c.file_name, c.analysis_type, c.timestamp FROM c WHERE c.username = '{username}'"
+
+        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        return items
+    except Exception as e:
+        logger.error(f"Error al obtener la lista de archivos del usuario {username}: {str(e)}")
+        return []
+
+def delete_file(username, file_name, analysis_type):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+    try:
+        user_container.delete_item(item=f"{username}_{analysis_type}_{file_name}", partition_key=username)
+        logger.info(f"Archivo eliminado para el usuario: {username}, tipo de análisis: {analysis_type}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al eliminar el archivo para el usuario {username}: {str(e)}")
+        return False
+
+########################################################## -- FIN GESTION DE ARCHIVOS ---##########################################################
+
+########################################################## -- INICIO GESTION DE FORMULARIOS ---##########################################################
+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_user_feedback(username, name, email, feedback):
+    global user_feedback_container
+    logger.info(f"Attempting to store user feedback for user: {username}")
+    try:
+        if user_feedback_container is None:
+            logger.error("user_feedback_container is not initialized")
+            return False
+
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "timestamp":datetime.now(timezone.utc).isoformat(),
+        }
+
+        result = user_feedback_container.create_item(body=feedback_item)
+        logger.info(f"User feedback stored with ID: {result['id']} for user: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error storing user feedback for user {username}: {str(e)}")
+        return False
+
+
+########################################################## -- FIN GESTION DE FORMULARIOS ---##########################################################
+
+########################################################## -- INICIO ALMACENAMIENTO ANÁLISIS MORFOSINTÁCTICO ---##########################################################
+
+def store_morphosyntax_result(username, text, repeated_words, arc_diagrams, pos_analysis, morphological_analysis, sentence_structure):
+    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.now(timezone.utc).isoformat(),
+            'text': text,
+            'word_count': word_count,
+            'arc_diagrams': arc_diagrams,
+            'pos_analysis': pos_analysis,
+            'morphological_analysis': morphological_analysis,
+            'sentence_structure': sentence_structure
+        }
+
+        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
+
+########################################################## -- FIN ALMACENAMIENTO ANÁLISIS MORFOSINTÁCTICO ---##########################################################
+
+
+##########################################--- INICIO SECCIÓN DEL ANÁLISIS SEMÁNTICO ---###############################################
+
+def store_file_semantic_contents(username, file_name, file_contents):
+    if user_container is None:
+        logger.error("La conexión a Cosmos DB SQL API no está inicializada")
+        return False
+    try:
+        document = {
+            'id': f"{username}_semantic_{file_name}",
+            'username': username,
+            'file_name': file_name,
+            'file_contents': file_contents,
+            'analysis_type': 'semantic',
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+        }
+        user_container.upsert_item(body=document)
+        logger.info(f"Contenido del archivo semántico guardado para el usuario: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error al guardar el contenido del archivo semántico para el usuario {username}: {str(e)}")
+        return False
+
+def store_semantic_result(username, text, analysis_result):
+    if analysis_collection is None:
+        print("La conexión a MongoDB no está inicializada")
+        return False
+    try:
+        # Convertir los conceptos clave a una lista de tuplas
+        key_concepts = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts']]
+
+        # Convertir los gráficos a imágenes base64
+        graphs = {}
+        for graph_name in ['relations_graph', 'entity_graph', 'topic_graph']:
+            if graph_name in analysis_result:
+                buf = BytesIO()
+                analysis_result[graph_name].savefig(buf, format='png')
+                buf.seek(0)
+                graphs[graph_name] = base64.b64encode(buf.getvalue()).decode('utf-8')
+
+        analysis_document = {
+            'username': username,
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'key_concepts': key_concepts,
+            'graphs': graphs,
+            'summary': analysis_result.get('summary', ''),
+            'entities': analysis_result.get('entities', {}),
+            'sentiment': analysis_result.get('sentiment', ''),
+            'topics': analysis_result.get('topics', []),
+            'analysis_type': 'semantic'
+        }
+
+        result = analysis_collection.insert_one(analysis_document)
+        print(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
+        return True
+    except Exception as e:
+        print(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
+        return False
+
+##########################################--- FIN DE LA SECCIÓN DEL ANÁLISIS SEMÁNTICO ---###############################################
+
+############################################--- INICIO DE LA SECCIÓN DEL ANÁLISIS DEL DISCURSO ###################################################################
+
+def store_discourse_analysis_result(username, text1, text2, analysis_result):
+    if analysis_collection is None:
+        print("La conexión a MongoDB no está inicializada")
+        return False
+
+    try:
+        # Convertir los grafos individuales a imágenes base64
+        buf1 = BytesIO()
+        analysis_result['graph1'].savefig(buf1, format='png')
+        buf1.seek(0)
+        img_str1 = base64.b64encode(buf1.getvalue()).decode('utf-8')
+
+        buf2 = BytesIO()
+        analysis_result['graph2'].savefig(buf2, format='png')
+        buf2.seek(0)
+        img_str2 = base64.b64encode(buf2.getvalue()).decode('utf-8')
+
+        # Crear una imagen combinada
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10))
+        ax1.imshow(plt.imread(BytesIO(base64.b64decode(img_str1))))
+        ax1.axis('off')
+        ax1.set_title("Documento 1: Relaciones Conceptuales")
+        ax2.imshow(plt.imread(BytesIO(base64.b64decode(img_str2))))
+        ax2.axis('off')
+        ax2.set_title("Documento 2: Relaciones Conceptuales")
+
+        buf_combined = BytesIO()
+        fig.savefig(buf_combined, format='png')
+        buf_combined.seek(0)
+        img_str_combined = base64.b64encode(buf_combined.getvalue()).decode('utf-8')
+        plt.close(fig)
+
+        # Convertir los conceptos clave a listas de tuplas
+        key_concepts1 = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts1']]
+        key_concepts2 = [(concept, float(frequency)) for concept, frequency in analysis_result['key_concepts2']]
+
+        # Crear el documento para guardar
+        analysis_document = {
+            'username': username,
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+            #'text1': text1,
+            #'text2': text2,
+            'graph1': img_str1,
+            'graph2': img_str2,
+            'combined_graph': img_str_combined,
+            'key_concepts1': key_concepts1,
+            'key_concepts2': key_concepts2,
+            'analysis_type': 'discourse'
+        }
+
+        # Insertar el documento en la base de datos
+        result = analysis_collection.insert_one(analysis_document)
+        print(f"Análisis discursivo guardado con ID: {result.inserted_id} para el usuario: {username}")
+        return True
+    except Exception as e:
+        print(f"Error al guardar el análisis discursivo para el usuario {username}: {str(e)}")
+        print(f"Tipo de excepción: {type(e).__name__}")
+        print(f"Detalles de la excepción: {e.args}")
+        return False
+
+############################################--- FIN DE LA SECCIÓN DEL ANÁLISIS DEL DISCURSO ###################################################################
+
+
+################################################-- INICIO DE LA SECCIÓN DEL CHATBOT --- ###############################################################
+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.now(timezone.utc).isoformat(),
+            '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 export_analysis_and_chat(username, analysis_data, chat_data):
+    try:
+        export_data = {
+            "username": username,
+            'timestamp':datetime.now(timezone.utc).isoformat(),
+            "analysis": analysis_data,
+            "chat": chat_data
+        }
+
+        # Aquí puedes decidir cómo quieres exportar los datos
+        # Por ejemplo, podrías guardarlos en una nueva colección en MongoDB
+        export_collection = mongo_db['exports']
+        result = export_collection.insert_one(export_data)
+
+        # También podrías generar un archivo JSON o CSV y guardarlo en Azure Blob Storage
+
+        return True
+    except Exception as e:
+        logger.error(f"Error al exportar análisis y chat para {username}: {str(e)}")
+        return False
+
+################################################-- FIN DE LA SECCIÓN DEL CHATBOT --- ###############################################################
+
+#######################################################################################################################################################
+
+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.now(timezone.utc).isoformat()),
+                "analysis_type": entry.get("analysis_type", "morphosyntax")
+            }
+
+            if formatted_entry["analysis_type"] == "morphosyntax":
+                formatted_entry.update({
+                    "text": entry.get("text", ""),
+                    "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.update({
+                    "key_concepts": entry.get("key_concepts", []),
+                    "graph": entry.get("graph", "")
+                })
+                formatted_data["semantic_analyses"].append(formatted_entry)
+
+            elif formatted_entry["analysis_type"] == "discourse":
+                formatted_entry.update({
+                    "text1": entry.get("text1", ""),
+                    "text2": entry.get("text2", ""),
+                    "key_concepts1": entry.get("key_concepts1", []),
+                    "key_concepts2": entry.get("key_concepts2", []),
+                    "graph1": entry.get("graph1", ""),
+                    "graph2": entry.get("graph2", ""),
+                    "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
+
+################################################################
+def get_user_analysis_summary(username):
+    if analysis_collection is None:
+        logger.error("La conexión a MongoDB no está inicializada")
+        return []
+    try:
+        summary = analysis_collection.aggregate([
+            {"$match": {"username": username}},
+            {"$group": {
+                "_id": "$analysis_type",
+                "count": {"$sum": 1},
+                "last_analysis": {"$max": "$timestamp"}
+            }}
+        ])
+        return list(summary)
+    except Exception as e:
+        logger.error(f"Error al obtener el resumen de análisis para el usuario {username}: {str(e)}")
+        return []
+
+#######################################################################
+def get_user_recent_chats(username, limit=5):
+    if chat_collection is None:
+        logger.error("La conexión a MongoDB no está inicializada")
+        return []
+    try:
+        recent_chats = chat_collection.find(
+            {"username": username},
+            {"messages": {"$slice": -5}}
+        ).sort("timestamp", -1).limit(limit)
+        return list(recent_chats)
+    except Exception as e:
+        logger.error(f"Error al obtener chats recientes para el usuario {username}: {str(e)}")
+        return []
+
+#################################################
+def get_user_analysis_details(username, analysis_type, skip=0, limit=10):
+    if analysis_collection is None:
+        logger.error("La conexión a MongoDB no está inicializada")
+        return []
+    try:
+        details = analysis_collection.find(
+            {"username": username, "analysis_type": analysis_type}
+        ).sort("timestamp", -1).skip(skip).limit(limit)
+        return list(details)
+    except Exception as e:
+        logger.error(f"Error al obtener detalles de análisis para el usuario {username}: {str(e)}")
+        return []

modules/database/chat_db.py

@@ -0,0 +1,45 @@
+#/modules/database/chat_db.py
+from .mongo_db import insert_document, find_documents
+from datetime import datetime, timezone
+import logging
+from .database_init import get_mongodb  # Asegúrate de que esta importación esté al principio del archivo
+
+logger = logging.getLogger(__name__)
+
+COLLECTION_NAME = 'chat_history-v3'
+
+def store_chat_history(username, messages, analysis_type):
+    chat_document = {
+        'username': username,
+        'timestamp': datetime.now(timezone.utc).isoformat(),
+        'messages': messages,
+        'analysis_type': analysis_type
+    }
+
+    result = insert_document(COLLECTION_NAME, chat_document)
+    if result:
+        logger.info(f"Historial de chat guardado con ID: {result} para el usuario: {username}")
+        return True
+    return False
+
+def get_chat_history(username, analysis_type, limit=None):
+    query = {"username": username}
+    if analysis_type:
+        query["analysis_type"] = analysis_type
+
+    db = get_mongodb()
+    collection = db['chat_history-v3']
+    cursor = collection.find(query).sort("timestamp", -1)
+    if limit:
+        cursor = cursor.limit(limit)
+
+    return list(cursor)
+
+#def get_chat_history(username, analysis_type=None, limit=10):
+#    query = {"username": username}
+#    if analysis_type:
+#        query["analysis_type"] = analysis_type
+
+#    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
+
+# Agregar funciones para actualizar y eliminar chat si es necesario

modules/database/database_init.py

@@ -0,0 +1,80 @@
+import os
+import logging
+from azure.cosmos import CosmosClient
+from pymongo import MongoClient
+import certifi
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Variables globales para Cosmos DB SQL API
+cosmos_client = None
+user_database = None
+user_container = None
+application_requests_container = None
+user_feedback_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+
+def initialize_cosmos_sql_connection():
+    global cosmos_client, user_database, user_container, application_requests_container, user_feedback_container
+    try:
+        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
+        cosmos_key = os.environ.get("COSMOS_KEY")
+
+        if not cosmos_endpoint or not cosmos_key:
+            raise ValueError("COSMOS_ENDPOINT and COSMOS_KEY environment variables must be set")
+
+        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")
+        user_feedback_container = user_database.get_container_client("user_feedback")
+
+        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
+
+def initialize_mongodb_connection():
+    global mongo_client, mongo_db
+    try:
+        cosmos_mongodb_connection_string = os.getenv("MONGODB_CONNECTION_STRING")
+        if not cosmos_mongodb_connection_string:
+            raise ValueError("MONGODB_CONNECTION_STRING environment variable is not set")
+
+        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']
+
+        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 initialize_database_connections():
+    sql_success = initialize_cosmos_sql_connection()
+    mongodb_success = initialize_mongodb_connection()
+    return sql_success and mongodb_success
+
+def get_sql_containers():
+    if user_container is None or application_requests_container is None or user_feedback_container is None:
+        initialize_cosmos_sql_connection()
+    return user_container, application_requests_container, user_feedback_container
+
+def get_mongodb():
+    if mongo_db is None:
+        initialize_mongodb_connection()
+    return mongo_db

modules/database/mongo_db.py

@@ -0,0 +1,51 @@
+from .database_init import get_mongodb
+import logging
+
+logger = logging.getLogger(__name__)
+
+def get_collection(collection_name):
+    db = get_mongodb()
+    return db[collection_name]
+
+def insert_document(collection_name, document):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.insert_one(document)
+        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
+        return result.inserted_id
+    except Exception as e:
+        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
+        return None
+
+def find_documents(collection_name, query, sort=None, limit=None):
+    collection = get_collection(collection_name)
+    try:
+        cursor = collection.find(query)
+        if sort:
+            cursor = cursor.sort(sort)
+        if limit:
+            cursor = cursor.limit(limit)
+        return list(cursor)
+    except Exception as e:
+        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
+        return []
+
+def update_document(collection_name, query, update):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.update_one(query, update)
+        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
+        return result.modified_count
+    except Exception as e:
+        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
+        return 0
+
+def delete_document(collection_name, query):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.delete_one(query)
+        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
+        return result.deleted_count
+    except Exception as e:
+        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
+        return 0

modules/database/morphosintax_mongo_db.py

@@ -0,0 +1,49 @@
+#/modules/database/morphosintax_mongo_db.py
+from .mongo_db import insert_document, find_documents, update_document, delete_document
+from ..utils.svg_to_png_converter import process_and_save_svg_diagrams
+from datetime import datetime, timezone
+import logging
+
+logger = logging.getLogger(__name__)
+
+COLLECTION_NAME = 'student_morphosyntax_analysis'
+
+def store_student_morphosyntax_result(username, text, arc_diagrams):
+    analysis_document = {
+        'username': username,
+        'timestamp': datetime.now(timezone.utc).isoformat(),
+        'text': text,
+        'arc_diagrams': arc_diagrams,
+        'analysis_type': 'morphosyntax'
+    }
+
+    result = insert_document(COLLECTION_NAME, analysis_document)
+    if result:
+        # Procesar y guardar los diagramas SVG como PNG
+        png_ids = process_and_save_svg_diagrams(username, str(result), arc_diagrams)
+
+        # Actualizar el documento con los IDs de los PNGs
+        update_document(COLLECTION_NAME, {'_id': result}, {'$set': {'png_diagram_ids': png_ids}})
+
+        logger.info(f"Análisis morfosintáctico del estudiante guardado con ID: {result} para el usuario: {username}")
+        return True
+    return False
+
+def get_student_morphosyntax_analysis(username, limit=10):
+    query = {"username": username, "analysis_type": "morphosyntax"}
+    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
+
+def update_student_morphosyntax_analysis(analysis_id, update_data):
+    query = {"_id": analysis_id}
+    update = {"$set": update_data}
+    return update_document(COLLECTION_NAME, query, update)
+
+def delete_student_morphosyntax_analysis(analysis_id):
+    query = {"_id": analysis_id}
+    return delete_document(COLLECTION_NAME, query)
+
+def get_student_morphosyntax_data(username):
+    analyses = get_student_morphosyntax_analysis(username, limit=None)  # Obtener todos los análisis
+    return {
+        'entries': analyses
+    }

modules/database/morphosintaxis_export.py

@@ -0,0 +1,78 @@
+from io import BytesIO
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import cm
+from svglib.svglib import svg2rlg
+from reportlab.graphics import renderPM
+import base64
+import cairosvg
+from reportlab.graphics import renderPDF
+from reportlab.lib.utils import ImageReader
+
+#importaciones locales
+from .morphosintax_mongo_db import get_student_morphosyntax_data
+from .chat_db import get_chat_history
+
+# Placeholder para el logo
+LOGO_PATH = "assets\img\logo_92x92.png" # Reemplaza esto con la ruta real de tu logo
+
+# Definir el tamaño de página carta manualmente (612 x 792 puntos)
+LETTER_SIZE = (612, 792)
+
+def add_logo(canvas, doc):
+    logo = Image(LOGO_PATH, width=2*cm, height=2*cm)
+    logo.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin - 0.5*cm)
+
+def export_user_interactions(username, analysis_type):
+    # Obtener historial de chat (que ahora incluye los análisis morfosintácticos)
+    chat_history = get_chat_history(username, analysis_type)
+
+    # Crear un PDF
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=2*cm,
+        leftMargin=2*cm,
+        topMargin=2*cm,
+        bottomMargin=2*cm
+    )
+
+    story = []
+    styles = getSampleStyleSheet()
+
+    # Título
+    story.append(Paragraph(f"Interacciones de {username} - Análisis {analysis_type}", styles['Title']))
+    story.append(Spacer(1, 0.5*cm))
+
+    # Historial del chat y análisis
+    for entry in chat_history:
+        for message in entry['messages']:
+            role = message['role']
+            content = message['content']
+            story.append(Paragraph(f"<b>{role.capitalize()}:</b> {content}", styles['BodyText']))
+            story.append(Spacer(1, 0.25*cm))
+
+            # Si hay visualizaciones (diagramas SVG), convertirlas a imagen y añadirlas
+            if 'visualizations' in message and message['visualizations']:
+                for svg in message['visualizations']:
+                    drawing = svg2rlg(BytesIO(svg.encode('utf-8')))
+                    img_data = BytesIO()
+                    renderPM.drawToFile(drawing, img_data, fmt="PNG")
+                    img_data.seek(0)
+                    img = Image(img_data, width=15*cm, height=7.5*cm)
+                    story.append(img)
+                    story.append(Spacer(1, 0.5*cm))
+
+        story.append(PageBreak())
+
+    # Construir el PDF
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+# Uso en Streamlit:
+# pdf_buffer = export_user_interactions(username, 'morphosyntax')
+# st.download_button(label="Descargar PDF", data=pdf_buffer, file_name="interacciones.pdf", mime="application/pdf")

modules/database/morphosintaxis_export_v1.py

@@ -0,0 +1,97 @@
+# database_export.py
+
+import pandas as pd
+import matplotlib.pyplot as plt
+from io import BytesIO
+#importaciones locales
+from .morphosintax_mongo_db import get_student_morphosyntax_analysis
+from .chat_db import get_chat_history
+
+
+def export_user_interactions(username, analysis_type):
+    # Obtener historial de chat (que ahora incluye los análisis morfosintácticos)
+    chat_history = get_chat_history(username, analysis_type)
+
+    # Crear un PDF
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=2*cm,
+        leftMargin=2*cm,
+        topMargin=2*cm,
+        bottomMargin=2*cm
+    )
+
+    story = []
+    styles = getSampleStyleSheet()
+
+    # Título
+    story.append(Paragraph(f"Interacciones de {username} - Análisis {analysis_type}", styles['Title']))
+    story.append(Spacer(1, 0.5*cm))
+
+    # Historial del chat y análisis
+    for entry in chat_history:
+        for message in entry['messages']:
+            role = message['role']
+            content = message['content']
+            story.append(Paragraph(f"<b>{role.capitalize()}:</b> {content}", styles['BodyText']))
+            story.append(Spacer(1, 0.25*cm))
+
+            # Si hay visualizaciones (diagramas SVG), convertirlas a imagen y añadirlas
+            if 'visualizations' in message and message['visualizations']:
+                for svg in message['visualizations']:
+                    drawing = svg2rlg(BytesIO(svg.encode('utf-8')))
+                    img_data = BytesIO()
+                    renderPM.drawToFile(drawing, img_data, fmt="PNG")
+                    img_data.seek(0)
+                    img = Image(img_data, width=15*cm, height=7.5*cm)
+                    story.append(img)
+                    story.append(Spacer(1, 0.5*cm))
+
+        story.append(PageBreak())
+
+    # Construir el PDF
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+#def export_user_interactions(username, analysis_type):
+    # Obtener análisis morfosintáctico
+    #morphosyntax_data = get_student_morphosyntax_analysis(username)
+
+    # Obtener historial de chat
+    #chat_history = get_chat_history(username, analysis_type)
+
+    # Crear un DataFrame con los datos
+    #df = pd.DataFrame({
+    #    'Timestamp': [entry['timestamp'] for entry in chat_history],
+    #    'Role': [msg['role'] for entry in chat_history for msg in entry['messages']],
+    #    'Content': [msg['content'] for entry in chat_history for msg in entry['messages']]
+    #})
+
+    # Crear un PDF
+    #buffer = BytesIO()
+    #plt.figure(figsize=(12, 6))
+    #plt.axis('off')
+    #plt.text(0.5, 0.98, f"Interacciones de {username} - Análisis {analysis_type}", ha='center', va='top', fontsize=16)
+    #plt.text(0.5, 0.95, f"Total de interacciones: {len(df)}", ha='center', va='top', fontsize=12)
+
+    # Añadir tabla con las interacciones
+    #plt.table(cellText=df.values, colLabels=df.columns, cellLoc='center', loc='center')
+
+    # Añadir diagramas de arco si es análisis morfosintáctico
+    #if analysis_type == 'morphosyntax' and morphosyntax_data:
+    #    for i, analysis in enumerate(morphosyntax_data):
+    #        plt.figure(figsize=(12, 6))
+    #        plt.axis('off')
+    #        plt.text(0.5, 0.98, f"Diagrama de Arco {i+1}", ha='center', va='top', fontsize=16)
+    #        plt.imshow(analysis['arc_diagrams'][0])  # Asumiendo que arc_diagrams es una lista de imágenes
+
+    #plt.savefig(buffer, format='pdf', bbox_inches='tight')
+    #buffer.seek(0)
+    #return buffer
+
+# Uso:
+# pdf_buffer = export_user_interactions(username, 'morphosyntax')
+# st.download_button(label="Descargar PDF", data=pdf_buffer, file_name="interacciones.pdf", mime="application/pdf")

modules/database/sql_db.py

@@ -0,0 +1,129 @@
+from .database_init import get_sql_containers
+from datetime import datetime, timezone
+import logging
+import bcrypt
+import uuid
+
+logger = logging.getLogger(__name__)
+
+def get_user(username, role=None):
+    user_container, _, _ = get_sql_containers()
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        if role:
+            query += f" AND c.role = '{role}'"
+        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        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):
+    user_container, _, _ = get_sql_containers()
+    try:
+        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+        user_data = {
+            'id': username,
+            'password': hashed_password,
+            'role': role,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'additional_info': additional_info or {}
+        }
+        user_container.create_item(body=user_data)
+        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 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
+
+
+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
+
+def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
+    _, application_requests_container, _ = get_sql_containers()
+    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()
+        }
+        application_requests_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):
+    _, _, user_feedback_container = get_sql_containers()
+    try:
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "role": "Estudiante",
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+        }
+        result = user_feedback_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