Spaces:
Running
Running
| import globales | |
| import firebase_admin | |
| from firebase_admin import auth | |
| from firebase_admin import firestore | |
| from firebase_admin import credentials | |
| # Use the application default credentials. | |
| cred = credentials.Certificate('archivos/config.json') | |
| firebase_admin.initialize_app(cred) | |
| db = firestore.client() | |
| def obtenDatosUIDFirebase(uid): | |
| """ | |
| Verifica si un UID existe en Firebase Authentication. | |
| Esto con el fin de evitar que se cambié el id arbitrareamente desde localstorage. | |
| Args: | |
| uid (str): El User ID (UID) que se desea verificar. | |
| Returns: | |
| bool: True si el usuario con ese UID existe, False en caso contrario. | |
| """ | |
| try: | |
| user = auth.get_user(uid) #Obtengo el objeto con todos los datos. | |
| print("Ésto es el user obtenido de la comprobación: ", user) | |
| email = user.email | |
| displayName = user.display_name | |
| # Si la operación es exitosa, el usuario existe | |
| print(f"✔️ Usuario con UID '{uid}' encontrado en Firebase Auth: {user.email or 'sin email'}") | |
| return email, displayName | |
| except auth.UserNotFoundError: | |
| # Esta excepción se lanza específicamente si el UID no existe | |
| print(f"❌ Usuario con UID '{uid}' NO encontrado en Firebase Auth.") | |
| return None, None | |
| except Exception as e: | |
| # Captura cualquier otro error (ej. problemas de conexión, permisos) | |
| print(f"❌ Error al verificar usuario con UID '{uid}': {e}") | |
| return None, None | |
| def obtenDato(coleccion, dato, info): | |
| print(f"Estoy dentro de obtenDato y los valores que recibí son: {coleccion}, {dato}, {info}...") | |
| doc_ref = db.collection(coleccion).document(dato) | |
| documento = doc_ref.get() | |
| print("Esto es el documento obtenido: ", documento) | |
| #Quizá éste segmento que comenté era el que producia nuevos documentos sin deber. | |
| if documento.exists: | |
| print("El documento existe....") | |
| #Recuerda la conversión a diccionario. | |
| documento = doc_ref.get() | |
| diccionario = documento.to_dict() | |
| print("Esto es el diccionario: ", diccionario) | |
| resultado = diccionario.get(info) | |
| print("Éste es el resultado...", resultado) | |
| return resultado | |
| pass #El documento si existe. | |
| else: | |
| print("No existe el documento, es un nuevo usuario.") | |
| return None | |
| #No crees nada pero avisa que no existe. | |
| #creaDato(coleccion, dato, 'tokens', 5) #porque agregará 5 tokens. | |
| 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({ | |
| # 'quote': quote, | |
| info: contenido, | |
| }) | |
| def creaDatoMultiple(coleccion, dato, data_dict): | |
| """ | |
| Crea un nuevo documento o sobrescribe uno existente en Firestore | |
| con múltiples pares de campo-contenido. | |
| Args: | |
| coleccion (str): El nombre de la colección donde se creará/actualizará el documento. | |
| dato (str): El ID del documento que se va a crear o sobrescribir. | |
| data_dict (dict): Un diccionario donde las claves son los nombres de los campos | |
| y los valores son el contenido de esos campos. | |
| Ej: {'nombre': 'Juan', 'edad': 30, 'activo': True} | |
| """ | |
| # Primero definimos la referencia al documento | |
| doc_ref = db.collection(coleccion).document(dato) | |
| try: | |
| # Usamos .set() y le pasamos el diccionario completo. | |
| # Esto sobrescribirá el documento si ya existe con los nuevos datos. | |
| doc_ref.set(data_dict) | |
| print(f"✔️ Documento '{dato}' creado/sobrescrito en la colección '{coleccion}' con los siguientes datos:") | |
| for key, value in data_dict.items(): | |
| print(f" - {key}: {value}") | |
| except Exception as e: | |
| print(f"❌ Error al crear/sobrescribir documento '{dato}' en '{coleccion}': {e}") | |
| def verificar_token(id_token): | |
| """Verifica el token de ID de Firebase.""" | |
| try: | |
| # Verifica el token y decodifica la información del usuario | |
| decoded_token = auth.verify_id_token(id_token) | |
| uid = decoded_token['uid'] | |
| return uid # Retorna el UID del usuario si el token es válido | |
| except auth.InvalidIdTokenError as e: | |
| print(f"Token inválido: {e}") | |
| return None # Retorna None si el token es inválido | |
| def encontrar_documento_por_cus(valor_cus): | |
| """ | |
| Busca un documento en la colección 'usuario' donde el campo 'cus' | |
| coincide con el valor_cus especificado. | |
| Args: | |
| valor_cus (str): El valor exacto del campo 'cus' a buscar. | |
| Returns: | |
| tuple: Una tupla (document_id, document_data) si se encuentra, | |
| o (None, None) si no se encuentra o hay un error. | |
| Retorna solo el primer documento encontrado si hay múltiples coincidencias. | |
| """ | |
| print(f"\n--- Buscando documento en 'usuario' con cus: '{valor_cus}' ---") | |
| try: | |
| # Realizamos la consulta: filtra por documentos donde 'cus' sea igual a valor_cus | |
| query_results = db.collection('usuarios').where( | |
| filter=firestore.FieldFilter('cus', '==', valor_cus) | |
| ).limit(1).get() # Agregamos .limit(1) porque esperas un único documento | |
| if not query_results: | |
| print(f"❌ No se encontró ningún documento con 'cus' = '{valor_cus}'.") | |
| return None, None | |
| # Si se encuentra, query_results será una lista de instantáneas de documentos | |
| # Tomamos el primer resultado (ya que usamos limit(1)) | |
| doc_snapshot = query_results[0] | |
| doc_id = doc_snapshot.id | |
| doc_data = doc_snapshot.to_dict() | |
| print(f"✔️ Documento encontrado: ID='{doc_id}', Datos: {doc_data}") | |
| return doc_id | |
| except Exception as e: | |
| print(f"❌ Error al buscar documento por 'cus': {e}") | |
| return None, None | |
| 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}") |