import firebase_admin from datetime import datetime from firebase_admin import auth from firebase_admin import firestore from firebase_admin import credentials firebase_cred = credentials.Certificate('config.json') firebase_admin.initialize_app(firebase_cred) db = firestore.client(database_id='nowme') #dato es el dato que traes como el nombre del user. #info es la info de ese dato que estás buscando, como token. def obtenDato(coleccion, dato, info): #Future: Tentativamente ésta parte podría solo hacerse una vez y vivir en la app para ser reutilizado. #Primero debemos definir la referencia al documento, o sea a la hoja de usuario. doc_ref = db.collection(coleccion).document(dato) #Éste es el documento que tiene los datos de ella. documento = doc_ref.get() #Recuerda la conversión a diccionario. documento = doc_ref.get() diccionario = documento.to_dict() return diccionario.get(info) def editaDato(coleccion, dato, info, contenido): #Primero debemos definir la referencia al documento, o sea a la hoja de usuario. doc_ref = db.collection(coleccion).document(dato) doc_ref.update({ # 'quote': quote, info: contenido, }) def creaDato(coleccion, dato, info, contenido): #Primero debemos definir la referencia al documento, o sea a la hoja de usuario. doc_ref = db.collection(coleccion).document(dato) doc_ref.set({ info: contenido, }) def registraLog(servidor_val, prompt_val, modelo_val, seed_val): """ Agrega un nuevo documento a la colección 'logs'. El ID del documento es la fecha y hora actual en formato string. Los campos del documento son 'servidor', 'prompt', 'modelo' y 'seed'. Args: servidor_val (str): El nombre o ID del servidor. prompt_val (str): El valor del campo 'prompt'. modelo_val (str): El valor del campo 'modelo'. seed_val (int): El valor del campo 'seed'. """ try: # 1. Generar el ID del documento (fecha y hora actual formateada) # Es importante usar una zona horaria si tus logs vienen de diferentes lugares # o si quieres que el timestamp refleje una hora local específica. # Por defecto, datetime.now() usa la hora local de tu sistema. # Si prefieres UTC (recomendado para consistencia global), puedes usar datetime.now(pytz.utc). # Obtenemos la hora actual del sistema now = datetime.now() # Formateamos la hora para que sea el ID del documento document_id_fecha_hora = now.strftime("%Y-%m-%d %H:%M:%S") nombre_final = servidor_val + " - " + document_id_fecha_hora # 2. Definir la referencia al documento específico con el ID de fecha y hora doc_ref = db.collection('logs').document(nombre_final) # 3. Definir los datos del log datos_log = { 'servidor': servidor_val, 'prompt': prompt_val, 'modelo': modelo_val, 'seed': seed_val, # Opcional: También puedes guardar el timestamp como un campo Timestamp # esto facilita consultas de rango si la fecha/hora del ID no es perfecta # o si necesitas ordenar por milisegundos. 'timestamp_creacion': firestore.SERVER_TIMESTAMP } # 4. Guardar los datos en el documento # Usamos .set(). Si un log ya existe para ese EXACTO segundo, se sobrescribirá. # Si esto es una preocupación (dos logs en el mismo segundo), podríamos añadir # milisegundos al ID o usar un ID automático y un campo de timestamp. doc_ref.set(datos_log) print(f"✔️ Log agregado exitosamente en 'logs/{document_id_fecha_hora}'.") print(f" Datos: Servidor='{servidor_val}', Prompt='{prompt_val}'...") except Exception as e: print(f"❌ Error al agregar log a Firestore: {e}") # Considera registrar el error o manejarlo de forma más robusta. def buscar_log_por_prompt(valor_prompt): """ Busca documentos en la colección 'logs' donde el campo 'prompt' coincide con el valor_prompt especificado. Args: valor_prompt (str): El valor exacto del prompt a buscar. Returns: list: Una lista de diccionarios, donde cada diccionario representa un documento que coincide con la búsqueda. Incluye el ID del documento. """ print(f"\n--- Buscando logs con prompt: '{valor_prompt}' ---") # --- CAMBIO AQUÍ: Usando firestore.FieldFilter en lugar de .where() directamente --- query_results = db.collection('logs').where( filter=firestore.FieldFilter('prompt', '==', valor_prompt) ).get() logs_encontrados = [] if not query_results: print(f"No se encontraron documentos con el prompt '{valor_prompt}'.") return [] for doc in query_results: log_data = doc.to_dict() log_data['id'] = doc.id # Añade el ID del documento al diccionario de datos logs_encontrados.append(log_data) return logs_encontrados def incrementar_campo_numerico(collection_name, document_id, field_name, amount=1): """ Incrementa un campo numérico en un documento de Firestore de forma atómica. Si el documento no existe, lo crea e inicializa el campo con el 'amount'. Si el campo no existe en un documento existente, lo inicializa y aplica el incremento. Args: collection_name (str): El nombre de la colección. document_id (str): El ID del documento. field_name (str): El nombre del campo numérico a incrementar. amount (int/float): La cantidad por la cual incrementar (puede ser negativo para decrementar). """ doc_ref = db.collection(collection_name).document(document_id) try: # Usamos .set() con merge=True para comportamiento de "upsert". # Si el documento no existe, lo crea. # Si el campo no existe, lo crea e inicializa con 'amount'. # Si el campo ya existe, lo incrementa con 'amount'. doc_ref.set( {field_name: firestore.Increment(amount)}, merge=True # Esta es la clave para que se cree si no existe y no sobrescriba otros campos ) print(f"✔️ Campo '{field_name}' en el documento '{document_id}' actualizado/creado e incrementado en {amount}.") except Exception as e: print(f"❌ Error al operar en el campo '{field_name}' del documento '{document_id}': {e}")