File size: 8,128 Bytes
50415aa
7807ad5
50415aa
0c9d53d
 
 
50415aa
 
 
0c9d53d
 
50415aa
0c9d53d
50415aa
 
0c9d53d
 
 
 
 
 
50415aa
0c9d53d
50415aa
 
5dc0420
0c9d53d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5dc0420
50415aa
0c9d53d
50415aa
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0c9d53d
 
50415aa
 
 
 
 
 
 
5dc0420
0c9d53d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7c7d4fd
0c9d53d
7c7d4fd
50415aa
 
 
 
 
 
7c7d4fd
 
 
 
 
 
 
 
 
 
 
50415aa
fb5f4d5
50415aa
cba69cb
 
 
 
 
 
 
 
 
5dc0420
 
 
 
 
cba69cb
50415aa
fb5f4d5
cba69cb
50415aa
 
 
 
cba69cb
7c7d4fd
 
 
 
 
 
 
 
cba69cb
 
50415aa
 
 
cba69cb
7c7d4fd
50415aa
bcf68d2
0c9d53d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
bcf68d2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
# database.py
# database.py
import logging
import os
from azure.cosmos import CosmosClient
from azure.cosmos.exceptions import CosmosHttpResponseError
from pymongo import MongoClient
import certifi
from datetime import datetime
import io
import base64

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

# Variables globales para Cosmos DB MongoDB API
mongo_client = None
mongo_db = None
analysis_collection = None

#####################################################################################33
def initialize_cosmos_sql_connection():
    global cosmos_client, user_database, user_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("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")
        
        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)}")
        return False

############################################################################################3        
def initialize_mongodb_connection():
    global mongo_client, mongo_db, analysis_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']
        
        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

#######################################################################################################
# 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))
        return items[0] if items else None
    except Exception as e:
        logger.error(f"Error al obtener usuario {username}: {str(e)}")
        return None

def create_user(user_data):
    try:
        user_container.create_item(body=user_data)
        return True
    except Exception as e:
        logger.error(f"Error al crear usuario: {str(e)}")
        return False

################################################################################
# Funciones para Cosmos DB MongoDB API (análisis de texto)

def get_student_data(username):
    if analysis_collection is None:
        logger.error("La conexión a MongoDB no está inicializada")
        return None

    try:
        logger.info(f"Buscando datos para el usuario: {username}")
        # Obtener todos los documentos para el usuario sin ordenar
        cursor = analysis_collection.find({"username": username})
        
        # Contar documentos
        count = analysis_collection.count_documents({"username": username})
        logger.info(f"Número de documentos encontrados para {username}: {count}")

        if count == 0:
            logger.info(f"No se encontraron datos para el usuario {username}")
            return None
        
        # Formatear los datos
        formatted_data = {
            "username": username,
            "entries": [],
            "entries_count": count,
            "word_count": {}
        }
        
        for entry in cursor:
            formatted_entry = {
                "timestamp": entry["timestamp"],
                "text": entry["text"],
                "word_count": entry.get("word_count", {}),
                "arc_diagrams": entry.get("arc_diagrams", []),
                "network_diagram": entry.get("network_diagram", "")
            }
            formatted_data["entries"].append(formatted_entry)
            
            # Agregar conteo de palabras
            for category, count in formatted_entry["word_count"].items():
                if category in formatted_data["word_count"]:
                    formatted_data["word_count"][category] += count
                else:
                    formatted_data["word_count"][category] = count

        # Ordenar las entradas por timestamp después de obtenerlas
        formatted_data["entries"].sort(key=lambda x: x["timestamp"], reverse=True)
        
        # Convertir los timestamps a formato ISO después de ordenar
        for entry in formatted_data["entries"]:
            entry["timestamp"] = entry["timestamp"].isoformat()
        
        logger.info(f"Datos formateados para {username}: {formatted_data}")
        return formatted_data

    except Exception as e:
        logger.error(f"Error al obtener datos del estudiante {username}: {str(e)}")
        return None
        
#######################################################################################################

def store_morphosyntax_result(username, text, repeated_words, arc_diagrams):
    if analysis_collection is None:
        logger.error("La conexión a MongoDB no está inicializada")
        return False

    try:
        buffer = io.BytesIO()
        network_diagram.savefig(buffer, format='png')
        buffer.seek(0)
        network_diagram_base64 = base64.b64encode(buffer.getvalue()).decode()

        word_count = {}
        for word, color in repeated_words.items():
            category = color  # Asumiendo que 'color' es la categoría gramatical
            word_count[category] = word_count.get(category, 0) + 1

        analysis_document = {
            'username': username,
            'timestamp': datetime.utcnow(),
            'text': text,
            'word_count': word_count,
            'arc_diagrams': arc_diagrams,
        }

        result = analysis_collection.insert_one(analysis_document)

        logger.info(f"Análisis guardado con ID: {result.inserted_id} para el usuario: {username}")
        return True
    except Exception as e:
        logger.error(f"Error al guardar el análisis para el usuario {username}: {str(e)}")
        return False

################################################################################################################
def store_semantic_result(username, text, network_diagram):
    try:
        analysis_document = {
            'username': username,
            'timestamp': datetime.utcnow(),
            'text': text,
            'network_diagram': network_diagram,
            'analysis_type': 'semantic'
        }

        result = analysis_collection.insert_one(analysis_document)

        logger.info(f"Análisis semántico guardado con ID: {result.inserted_id} para el usuario: {username}")
        return True
    except Exception as e:
        logger.error(f"Error al guardar el análisis semántico para el usuario {username}: {str(e)}")
        return False

###############################################################################################################
def store_discourse_semantic_result(username, text, discourse_analysis):
    # Implementación similar a las anteriores
    pass