El proceso combina extracción de metadatos SQL, generación automática de descripciones, manejo de archivos parciales y exportación final de scripts.

Modelo utilizado para la prueba - OpenFoundry

🔍 1. Extracción de Metadatos desde la Base de Datos

Primero, necesitamos obtener la estructura de las tablas y columnas de nuestra base de datos (en este caso MySQL) en un formato JSON uniforme, como este:

{
  "Tabla": "app_cloud_billing",
  "Campo": "tags",
  "TipoDeDato": "JSON",
  "Restricciones": "NULL",
  "Descripcion": ""
}

Consulta SQL para extraer metadata de la base de datos

Puedes obtener esta información directamente desde INFORMATION_SCHEMA.COLUMNS:

SELECT 
    TABLE_NAME AS 'Tabla',
    COLUMN_NAME AS 'Campo',
    COLUMN_TYPE AS 'TipoDeDato',
    IS_NULLABLE AS 'Restricciones',
    COLUMN_COMMENT AS 'Descripcion'
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = 'tu_base_de_datos'
ORDER BY TABLE_NAME, COLUMN_NAME;

Luego exportas el resultado en formato JSON (puedes hacerlo con una herramienta como DBeaver, MySQL Workbench o mediante un script Python).

🤖 2. Generación Automática de Descripciones con un Modelo de Lenguaje

Una vez tengas el archivo metadata_database.json, puedes usar un modelo como OpenFoundry, GPT u otro para generar descripciones automáticas.
El modelo recibirá algo como esto:

[
  {"Tabla": "app_cloud_billing", "Campo": "tags", "TipoDeDato": "JSON", "Restricciones": "NULL", "Descripcion": ""}
]

Y devolverá:

[
  {"Tabla": "app_cloud_billing", "Campo": "tags", "TipoDeDato": "JSON", "Restricciones": "NULL",
   "Descripcion": "Metadatos de facturación y atribución en formato JSON. Contiene etiquetas de clave/valor (ej. ambiente, proyecto, dueño) aplicadas al recurso"}
]

Para manejar grandes volúmenes de datos (más de 800 tokens), puedes dividir el archivo en bloques parciales y procesarlos por separado.

🧩 3. Guardar Resultados Parciales con Python

Usa este script para guardar los registros procesados en archivos parciales con timestamp:

import json
from datetime import datetime
import os

with open("campos.json", "r", encoding="utf-8") as f:
    campos = json.load(f)

campos_con_datos = [c for c in campos if c.get("Descripcion")]

os.makedirs("parciales", exist_ok=True)
timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M")
output_path = f"parciales/diccionario_con_datos_{timestamp}.json"

with open(output_path, "w", encoding="utf-8") as f:
    json.dump(campos_con_datos, f, ensure_ascii=False, indent=2)

print(f"Archivo parcial generado en: {output_path}")

💡 Esto facilita retomar el proceso si el modelo falla o se interrumpe.
Cada archivo parcial queda versionado por hora y minuto.

🧮 4. Unificar Archivos Parciales

Si has generado varios archivos parciales, puedes consolidarlos en un solo archivo ordenado por tabla y campo:

import json
import os

carpeta_parciales = "parciales"
archivos_json = [f for f in os.listdir(carpeta_parciales) if f.endswith(".json")]

datos_unificados = []

for archivo in archivos_json:
    with open(os.path.join(carpeta_parciales, archivo), "r", encoding="utf-8") as f:
        datos_unificados.extend(json.load(f))

# Eliminar duplicados y ordenar
diccionario_unificado = {(d["Tabla"], d["Campo"]): d for d in datos_unificados}
ordenado = sorted(diccionario_unificado.values(), key=lambda x: (x["Tabla"], x["Campo"]))

with open("resultado_final.json", "w", encoding="utf-8") as f:
    json.dump(ordenado, f, ensure_ascii=False, indent=2)

print(f"Archivo unificado generado: resultado_final.json")

🧱 5. Generar Scripts SQL con Comentarios

Por último, puedes crear automáticamente los comandos SQL ALTER TABLE que agregan comentarios descriptivos a tus columnas.

Este script genera tanto un archivo SQL completo como archivos parciales por tabla:

import json
import os
from datetime import datetime

with open("resultado_final.json", "r", encoding="utf-8") as f:
    datos = json.load(f)

sql_por_tabla = {}
for item in datos:
    tabla = item["Tabla"]
    campo = item["Campo"]
    tipo = item["TipoDeDato"]
    restr = item["Restricciones"]
    desc = item["Descripcion"].replace("'", "''")  # escapar comillas simples

    sentencia = f"MODIFY COLUMN {campo} {tipo} {restr} COMMENT '{desc}'"
    sql_por_tabla.setdefault(tabla, []).append(sentencia)

os.makedirs("parciales_sql", exist_ok=True)
timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M")

sql_total = ""

for tabla, sentencias in sql_por_tabla.items():
    bloque = f"ALTER TABLE {tabla}\n  " + ",\n  ".join(sentencias) + ";\n\n"
    sql_total += bloque

    with open(f"parciales_sql/{tabla}_{timestamp}.sql", "w", encoding="utf-8") as f:
        f.write(bloque)

with open(f"diccionario_sql_{timestamp}.sql", "w", encoding="utf-8") as f:
    f.write(sql_total)

print("✅ Archivos SQL generados en 'parciales_sql' y uno unificado.")

🧾 6. Ejemplo de Salida Final

Archivo diccionario_sql_2025-10-31-15-30.sql:

ALTER TABLE app_cloud_billing
  MODIFY COLUMN resourceName VARCHAR(512) NULL 
    COMMENT 'Nombre único y local del recurso de Azure',
  MODIFY COLUMN tags JSON NULL 
    COMMENT 'Metadatos de facturación y atribución en formato JSON. Contiene etiquetas de clave/valor (ej. ambiente, proyecto, dueño) aplicadas al recurso';

Archivos parciales (por tabla):

📁 parciales_sql/
 ┣ 📄 app_cloud_billing_2025-10-31-15-30.sql
 ┣ 📄 app_cloud_usage_2025-10-31-15-30.sql
 ┗ 📄 app_cloud_account_2025-10-31-15-30.sql

⚙️ 7. Requerimientos Python

Archivo requirements.txt mínimo:

openai
pandas

Si no usas OpenAI directamente, sustituye por el SDK del modelo que utilices (por ejemplo openfoundry).

🚀 Conclusión

Este proceso te permite:

• Documentar automáticamente la metadata de tu base de datos.

• Generar descripciones contextuales y consistentes usando IA.

• Mantener tus diccionarios actualizados con control de versiones.

• Aplicar los comentarios directamente en tu esquema SQL.

Es una solución práctica para equipos que manejan muchos modelos de datos y necesitan mantener la documentación sincronizada con el esquema técnico.

Como desarrollador, después de enfrentarme a este problema, descubrí que el conflicto suele estar en la interpretación que hace Namecheap de los valores del Host y en registros "fantasma" que vienen configurados por defecto.

Aquí te explico cómo solucionarlo paso a paso.

El Problema: La confusión con el Host y la IP fija

Netlify suele recomendar que apuntes tu dominio raíz (Apex domain) a su IP 75.2.60.5. Sin embargo, hay dos detalles que rompen esta configuración en Namecheap:

1. El valor del Host: La interfaz de Netlify a veces sugiere escribir el nombre de tu dominio (ej. misitio.com) en el campo Host. En Namecheap, esto puede causar que el DNS intente resolver misitio.com.misitio.com.

2. Registros AAAA: Muchos dominios nuevos en Namecheap traen registros IPv6 por defecto que entran en conflicto con la validación de Netlify.

La Solución Técnica

1. El uso del símbolo @

En el panel Advanced DNS de Namecheap, nunca escribas tu dominio completo en la columna de Host. Debes usar el símbolo @. Este símbolo es un estándar en DNS que representa la raíz del dominio (el Apex).

2. Optar por un Registro ALIAS (Mejor que el Registro A)

Aunque Netlify te da una IP, lo ideal para aprovechar su red CDN es usar un registro de tipo ALIAS.

• Host: @

• Value: tu-app.netlify.app (tu subdominio gratuito de Netlify).

Esto permite que Netlify gestione el tráfico de forma dinámica. Si tu proveedor no permite ALIAS, usa el registro A apuntando a 75.2.60.5, pero siempre con el Host en @.

3. Limpieza de registros IPv6 (AAAA)

Este es el paso que la mayoría olvida. Si haces un nslookup y ves direcciones largas con letras y números (IPv6), debes borrar todos los registros AAAA en Namecheap. Netlify necesita que el dominio raíz resuelva únicamente a su infraestructura para validar el SSL.

Resumen de la configuración ideal en Namecheap

Cómo verificar que el cambio funcionó (Modo Pro)

No esperes a que la interfaz de Netlify se actualice, ya que tiene caché. Abre tu terminal y usa este comando para consultar directamente a los servidores de Google:

Bash

nslookup -type=A tudominio.com 8.8.8.8
# Si la respuesta te devuelve la IP de Netlify (o el alias) y ya no aparecen direcciones IPv6,
# ve a tu panel de Netlify y presiona "Verify". La validación debería ser instantánea.

Conclusión

La documentación es una guía, pero cada registrador tiene sus reglas. En Namecheap, la clave es el @ y la limpieza de registros AAAA. ¡Espero que esto te ahorre las horas de frustración que a mí me costó descubrirlo!

Si usas Replace Tokens para inyectar secretos desde tu Library, el culpable no es tu código, sino un símbolo "rebelde".

El error que aparece es similar a lo siguiente:

2026-03-24T15:49:43.6432543Z ##[section]Starting: Apply ConfigMap
2026-03-24T15:49:43.6457385Z ==============================================================================
2026-03-24T15:49:43.6457745Z Task         : Deploy to Kubernetes
2026-03-24T15:49:43.6458241Z Description  : Use Kubernetes manifest files to deploy to clusters or even bake the manifest files to be used for deployments using Helm charts
2026-03-24T15:49:43.6458631Z Version      : 1.268.0
2026-03-24T15:49:43.6458882Z Author       : Microsoft Corporation
2026-03-24T15:49:43.6459148Z Help         : https://aka.ms/azpipes-k8s-manifest-tsg
2026-03-24T15:49:43.6459451Z ==============================================================================
2026-03-24T15:49:46.4423474Z 			Kubectl Client Version: v1.35.2
2026-03-24T15:49:46.4424129Z 			Kubectl Server Version: v1.33.7
2026-03-24T15:49:46.4424737Z ==============================================================================
2026-03-24T15:49:46.4694986Z ##[error]can not read a block mapping entry; a multiline key may not be an implicit key at line 19, column 48:
     ... M_COMERCIAL_SHAREPOINT_TENANT_ID: "22cfcf07-cbdf-458d-adc0-6e57ece ... 
                                         ^
2026-03-24T15:49:46.4789324Z ##[section]Finishing: Apply ConfigMap

El Problema: Caracteres con "superpoderes

En YAML, símbolos como !, @, #, :, | o > no son solo texto; son instrucciones técnicas.

• Ejemplo Real: Los IDs de SharePoint/Drive de Microsoft suelen empezar con b!.

• https://learn.microsoft.com/en-us/graph/api/drive-get?view=graph-rest-1.0&tabs=http#code-try-13?view=graph-rest-1.0&tabs=http

• El Caos: Al inyectar b!t18... directamente en el YAML, Kubernetes intenta interpretar el ! como un tag de datos y, al no entenderlo, rompe el despliegue.

La Herramienta de Diagnóstico: yamllint

Antes de lanzar el despliegue y esperar 5 minutos a que falle, añade un paso de validación en tu pipeline. yamllint es el juez estricto que necesitas:

- script: |
    pip install yamllint
    # Validamos el archivo procesado por el Replace Tokens
    yamllint qa/configmap.yml
displayName: 'QA: Validar sintaxis YAML'

Tip: Si es muy estricto con los espacios o largos de línea, usa un archivo .yamllint.conf para relajar las reglas y enfocarte solo en errores de sintaxis.

En el caso de que la librería encuentre algún error, te mostrara una salida similar a la siguiente:

/home/vsts/work/1/s/qa/configmap.yml
  1:1       warning  missing document start "---"  (document-start)
  14:81     error    line too long (84 > 80 characters)  (line-length)
  17:81     error    line too long (87 > 80 characters)  (line-length)
  18:51     error    syntax error: expected <block end>, but found '<scalar>' (syntax)
  19:81     error    line too long (87 > 80 characters)  (line-length)
  20:81     error    line too long (111 > 80 characters)  (line-length)
  21:81     error    line too long (105 > 80 characters)  (line-length)
  22:81     error    line too long (113 > 80 characters)  (line-length)
  26:81     error    line too long (86 > 80 characters)  (line-length)

La Solución Definitiva: El Bloque Literal (>-)

Si las comillas dobles o simples fallan, usa el "arma secreta" de YAML: el Folded Block Scalar (>-). Este operador le dice a Kubernetes: "Oye, todo lo que viene en la siguiente línea es texto puro. No intentes interpretarlo, no busques comandos, solo léelo como una cadena".

Así debe lucir tu ConfigMap:

data:
  # El >- limpia saltos de línea y protege el valor inyectado
  SHAREPOINT_DRIVE_ID: >-
    #{SHAREPOINT_DRIVE_ID}#

Valida temprano: Usa yamllint en el pipeline para ahorrar tiempo de debugging.

Usa >-: Es la forma más robusta de manejar IDs complejos y secretos con símbolos raros sin romper la estructura.

Prerrequisitos

Un agente de AI Foundry configurado y que funcione correctamente en el playground de Azure AI Foundry.

Las credenciales para la conexión con el endpoint del AI Foundry.

Crear un recurso Bot Service para gestionar el bot y la exportación hacía los diferentes canales.

Una aplicación Service Principal, que bien podrías reutilizar la aplicación generada automáticamente por el Bot Service, la cual puedes visualizarla en la pestaña Configuración del Bot Service.

La aplicación del Service Principal debe tener añadida como una URL de redirección, la URL que se conecte al Bot Service.

La aplicación no requiere permisos específicos para conectarse directamente al AI Foundry. En su lugar, debe registrarse en el recurso de AI Foundry con los roles adecuados: Cognitive Services Contributor y Azure AI User. Estos permisos garantizan que la aplicación pueda interactuar correctamente con el servicio sin necesidad de configuraciones adicionales a nivel de la propia aplicación.

Arquitectura del Proyecto

La arquitectura se compone de tres partes principales:

1. Agente AI Foundry: (Externo) Provee la lógica conversacional a través de una API.

2. Backend Python (Flask/FastAPI): Aloja el endpoint /api/messages, gestiona la comunicación con el Agente AI y da formato a las respuestas. Desplegado en Azure App Service.

3. Azure Bot Service: Actúa como el puente, autenticándose con el backend y canalizando las conversaciones (Web Chat, Teams, etc.).

Configuración del Backend Python y AI Foundry

1.1. Preparación del Entorno Python

Asegúrate de tener un entorno virtual activo y los paquetes necesarios instalados.

# Core requirements
flask>=2.0.0  # Version con soporte async
python-dotenv>=0.19.0

# Azure Bot Framework
botbuilder-core==4.17.0
botbuilder-integration-aiohttp==4.17.0
botbuilder-schema==4.17.0
botframework-connector==4.17.0
botframework-streaming==4.17.0

# Azure
azure-ai-agents==1.1.0
azure-core==1.36.0
azure-identity==1.25.1

# Async support
aiohttp==3.13.2
aiosignal==1.4.0
async-timeout==5.0.1
aiohappyeyeballs==2.6.1

# Utils
blinker==1.9.0
certifi==2025.11.12
cffi==2.0.0
charset-normalizer==3.4.4
click==8.1.8
colorama==0.4.6
cryptography==46.0.3
attrs==25.4.0
Flask==3.0.0
frozenlist==1.8.0
gunicorn==23.0.0
idna==3.11
importlib_metadata==8.7.0
isodate==0.7.2
itsdangerous==2.2.0
Jinja2==3.1.6
jsonpickle==1.4.2
MarkupSafe==3.0.3
msal==1.34.0
msal-extensions==1.3.1
msrest==0.7.1
multidict==6.7.0
oauthlib==3.3.1
packaging==25.0
propcache==0.4.1
pycparser==2.23
PyJWT==2.10.1
python-dotenv==1.2.1
requests==2.32.5
requests-oauthlib==2.0.0
typing_extensions==4.15.0
urllib3==2.5.0
Werkzeug==3.0.1
yarl==1.22.0
zipp==3.23.0

Configuración del archivo app.py

En el archivo app.py, hay que configurar lo siguiente:

Leer configuración del Bot Service

APP_ID = os.environ.get("MicrosoftAppId", "")
APP_PASSWORD = os.environ.get("MicrosoftAppPassword", "")
APP_TENANT_ID = os.environ.get("MicrosoftAppTenantId", "")
SETTINGS = BotFrameworkAdapterSettings(APP_ID, APP_PASSWORD, APP_TENANT_ID)
ADAPTER = BotFrameworkAdapter(SETTINGS)
BOT = FoundryAgentBot()

Inicializar la aplicación de Flask

app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False

Crear el endpoint de Health Check

Permite verificar al momento del despliegue si el servicio fue desplegado correctamente.

@app.route("/", methods=["GET"])
def health_check():
    """
    Endpoint de health check que devuelve el estado del servicio.
    """
    return Response("Bot Service is Running and Healthy", status=200, mimetype="text/plain")

Crear el endpoint que se comunica con el BotService

El estándar de la ruta es api/messages, recibe una petición HTTP de tipo JSON y que se autentica mediante un token de autorización Bearer.

@app.route("/api/messages", methods=["POST"])
def messages():
    if "application/json" not in request.headers.get("Content-Type", ""):
        return Response("Unsupported Media Type", status=415)

    try:
        # Obtener el body y el header de autorización
        body = request.json
        auth_header = request.headers.get("Authorization", "")
        # Deserializar la actividad
        activity = Activity.deserialize(body)

        # Procesar la actividad de forma asíncrona
        async def process():
            await ADAPTER.process_activity(
                activity, 
                auth_header, 
                lambda context: BOT.on_turn(context)
            )

        # Ejecutar la función async (asyncio.run crea un nuevo event loop)
        asyncio.run(process())
        return Response(status=200)

    except Exception as e:
        logging.error(f"Error procesando la actividad: {e}")
        return Response(str(e), status=500, mimetype="text/plain")

Iniciar la aplicación Flask

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 5000))
    host = os.environ.get("HOST", "0.0.0.0")
    app.run(host=host, port=port, debug=True)

Configuración del archivo foundry.py

Leer las configuraciones del AI Foundry

PROJECT_ENDPOINT = os.environ.get("AZURE_AI_FOUNDRY_PROJECT_ENDPOINT")
AGENT_ID = os.environ.get("AZURE_AI_FOUNDRY_AGENT_ID")

Inicializar la clase que gestiona la conexión al Foundry

class FoundryAgentBot(ActivityHandler):
    def __init__(self):
        # Autenticación: DefaultAzureCredential busca credenciales en el entorno
        self.credential = DefaultAzureCredential()
        # Cliente para interactuar con los servicios de Agentes de Foundry
        self.agent_client = AgentsClient(endpoint=PROJECT_ENDPOINT, credential=self.credential)
        # Diccionario para almacenar el Thread ID de Foundry por usuario/conversación
        self.user_threads = {}

Añadir el método para gestionar la actividad de los mensajes

Primero hay que definir la función junto con los parámetros que requiere.

async def on_message_activity(self, turn_context: TurnContext):
    """Maneja el mensaje de entrada del usuario."""

Obtener el contexto de Foundry y crear un hilo de conversación

# Obtener el ID de la conversación
conversation_id = turn_context.activity.conversation.id
# Generar un identificador para el hilo de la conversación
thread_id = self.user_threads.get(conversation_id)

# Crear un nuevo hilo en caso no exista uno
if not thread_id:
    new_thread = self.agent_client.threads.create()
    thread_id = new_thread.id
    self.user_threads[conversation_id] = thread_id
    await turn_context.send_activity(
        "¡Hola! Soy un agente impulsado por Azure AI Foundry. ¿En qué puedo ayudarte?"
    )

# Enviar el mensaje del usuario como actividad al agente de Foundry
user_message = turn_context.activity.text
await turn_context.send_activity(f"Enviando el mensaje del usuario hacía AI Foundry...** '{user_message}'")

# Crear el cliente del agente con el contexto, el rol 'Usuario' y el identificador del Thread.
try:
    self.agent_client.messages.create(
        thread_id=thread_id,
        role="user",
        content=user_message
    )
except AttributeError as e:
    raise Exception(f"Error al crear mensaje: {e}. Revisar sintaxis de create_message.")

Implementar un bucle de polling para la conexión al momento de obtener los mensajes

 # Implementar el bucle de POLLING (Sondeo) manual
while run.status not in ["completed", "failed", "cancelled", "expired"]:
    # Esperar 1 segundo antes de verificar el estado nuevamente
    await asyncio.sleep(1) 

    # Obtener el estado actualizado del run usando el método 'get' del objeto 'runs'
    run = self.agent_client.runs.get(
        thread_id=thread_id,
        run_id=run.id
    )

Obtener la respuesta del agente

if run.status == "completed":
    messages_result = self.agent_client.messages.list( 
        thread_id=thread_id, 
        order="desc", 
        limit=1
    )
    messages_list = list(messages_result) 
    # Obtener el contenido del mensaje
    if messages_list and messages_list[0] and messages_list[0].content:
        result_message = messages_list[0].content[0]
        result_response = result_message['text']['value']
        agent_response = result_response
    else:
        agent_response = "No se recibió respuesta del agente."
else:
    agent_response = f"El agente no pudo completar la tarea. Estado: {run.status}. Error: {run.last_error}"

Responder al usuario con el mensaje que retorna el agente de AI Foundry

await turn_context.send_activity(agent_response)

Una vez desplegado el proyecto en un APP Service, se debe configurar las variables de entorno, una configuración similar a la siguiente.

Y finalmente en el Bot Service accediendo al apartado de Canales, se puede probar utilizando el canal web que es la forma más rápida.

Bonus

El siguiente código permite manejar el evento cuando el Bot se despliegue en un entorno como Microsoft Teams mediante los canales del Bot Service.

async def on_members_added_activity(self, members_added: list[ChannelAccount], turn_context: TurnContext):
    "Maneja cuando el bot es añadido a una conversación (útil en Teams)."
    for member in members_added:
        if member.id != turn_context.activity.recipient.id:
            await turn_context.send_activity(
                Activity(
                    type=ActivityTypes.message, 
                    text="¡Hola! Soy un bot que usa un Agente de Azure AI Foundry. Puedes empezar a chatear conmigo."
                )
            )

Además si necesitas probar generando tu propio token puedes hacerlo mediante este pequeño script de Python.

# Importar librerias
from azure.identity import DefaultAzureCredential
from datetime import datetime

# Inicializar credencial, utilizará los valores dependiendo del entorno que tengas, sea proporcionando
# credenciales de Service Principal o de una identidad gestionada del sistema
credential = DefaultAzureCredential()

# Scope para Microsoft Graph (puedes cambiarlo según tu necesidad)
scope = "https://graph.microsoft.com/.default"

# Obtener token
token = credential.get_token(scope)
expires_readable = datetime.utcfromtimestamp(token.expires_on).strftime('%Y-%m-%d %H:%M:%S')
print("Access Token:", token.token)
print("Expires On:", token.expires_on)
print("Expires On expires_readable:", expires_readable)

Por último si deseas probar el chat mediante un endpoint HTTP, puedes hacerlo mediante el siguiente código que añade una ruta que la puedes probar desde un cliente como Postman, Insomnia o un Frontend.

@app.route("/api/chat", methods=["POST"])
def chat():
    """
    Endpoint HTTP simple para probar el bot con peticiones REST estándar.
    Acepta un JSON con un campo 'message' y devuelve la respuesta del bot.
    """
    if not request.is_json:
        return jsonify({"error": "Content type must be application/json"}), 415

    try:
        data = request.get_json()
        user_message = data.get('message', '')

        if not user_message:
            return jsonify({"error": "Field 'message' is required"}), 400

        # Crear una actividad de mensaje simple con todos los campos requeridos
        from botbuilder.schema import ConversationAccount
        from botbuilder.core import TurnContext, BotAdapter

        # Crear la actividad con los campos mínimos requeridos
        activity = Activity(
            type="message",
            text=user_message,
            channel_id="http",
            from_property={"id": "http-user", "name": "HTTP User", "role": "user"},
            recipient={"id": "bot", "role": "bot"},
            conversation=ConversationAccount(
                id="http-conversation-123",  # ID de conversación fijo para pruebas
                name="Test Conversation"
            ),
            service_url="http://localhost:5000", # Reemplazar con la URL del servicio si es necesario cuando se use en producción
            channel_data={},
            reply_to_id=""
        )

        # Variable para almacenar la respuesta
        response_text = "No se recibió respuesta del bot"

        # Crear un adaptador simple para el contexto
        class SimpleAdapter(BotAdapter):
            def __init__(self):
                super().__init__()
                self.sent_messages = []

            async def send_activities(self, context, activities):
                responses = []
                for activity in activities:
                    self.sent_messages.append(activity)
                    responses.append({'id': '123'})
                return responses

            async def delete_activity(self, context, reference):
                """Delete an existing activity."""
                # Implementación básica para cumplir con la interfaz
                return

            async def update_activity(self, context, activity):
                """Update an existing activity."""
                # Implementación básica para cumplir con la interfaz
                return {'id': '123'}

        # Crear el contexto de turno
        adapter = SimpleAdapter()
        context = TurnContext(adapter, activity)
        context.turn_state['BotCallbackHandler'] = None

        # Procesar la actividad de forma síncrona
        import asyncio

        async def process():
            await BOT.on_turn(context)

            # Obtener la respuesta del bot
            if hasattr(adapter, 'sent_messages') and adapter.sent_messages:
                last_message = adapter.sent_messages[-1]
                if hasattr(last_message, 'text'):
                    return last_message.text
                elif isinstance(last_message, dict) and 'text' in last_message:
                    return last_message['text']
                return str(last_message)
            return "No se recibió respuesta del bot"

        # Ejecutar la corutina y esperar el resultado
        response_text = asyncio.run(process())

        # Devolver la respuesta en formato JSON
        return jsonify({"response": response_text})

    except Exception as e:
        logging.error(f"Error en /api/chat: {str(e)}", exc_info=True)
        return jsonify({"error": str(e)}), 500

Recientemente me enfrenté a este proceso y quiero compartir los puntos clave que debes considerar para que tu migración sea lo más fluida posible.

1. Adiós a java.util.Date, Hola a LocalDate

El primer y más evidente cambio es dejar atrás Date. Si bien java.util.Date funcionaba, era una clase con problemas conocidos de mutabilidad y manejo de zonas horarias. La nueva API java.time ofrece tipos específicos para cada necesidad:

• LocalDate: Para fechas (2023-11-03).

• LocalTime: Para horas (15:30:00).

• LocalDateTime: Para fecha y hora (2023-11-03T15:30:00).

El reto aquí no es solo cambiar el tipo en tu código, sino también la forma en que los datos se manejan en el backend y el frontend.

2. La Serialización: Del Timestamp al Array

Aquí es donde surge la principal fricción con las aplicaciones existentes. Por defecto, cuando Jackson (la biblioteca de serialización de Spring) encuentra un campo java.util.Date, lo convierte a un timestamp (un número largo). Sin embargo, con LocalDate, el comportamiento por defecto es serializarlo como un array JSON ([2023, 11, 3]).

Si tu frontend espera un timestamp, esto causará errores. La solución es configurar la serialización de Jackson en el backend para que LocalDate se convierta a un timestamp. Esto se puede lograr fácilmente con la anotación @JsonFormat directamente en el campo de tu entidad:

import com.fasterxml.jackson.annotation.JsonFormat;
// ...
@JsonFormat(shape = JsonFormat.Shape.NUMBER_INT)
private LocalDate fechaDePublicacion;

3. Actualizaciones en la Configuración de JPA y Hibernate

La validación de esquemas en Spring Boot 3 es mucho más estricta. Ya no puedes confiar en que Hibernate "adivine" el tipo de dato correcto. Si tienes columnas con tipos específicos, ahora debes definirlas explícitamente:

• Decimales: Olvídate de @Column(columnDefinition = "decimal", precision = 10, scale = 2). Ahora debes usar el formato estándar de SQL: @Column(columnDefinition = "DECIMAL(10, 2)").

• Tipos de Columna: Si usabas @Type para especificar el tipo de una columna, ahora la mejor práctica es usar la anotación @Column directamente.

4. Cambios en el Manejo de Fechas en el Código

Al migrar tu lógica de negocio, tus métodos que antes usaban Date ahora deben ser reescritos para usar LocalDate. Por ejemplo, para sumar días, el método plusDays() de LocalDate es mucho más claro y sencillo que la manipulación de milisegundos que se hacía con Date.

Antes:

public static Date generateFixedDate(Date dateWithOffset, int offset) {
    long epochMilli = dateWithOffset.toInstant().toEpochMilli() + ...;
    return new Date(epochMilli);
}

Ahora

public static LocalDate generateFixedDate(LocalDate dateWithOffset, int offset) {
    return dateWithOffset.plusDays(offset);
}

Cuando migras una aplicación de Spring Boot 2 a 3, uno de los desafíos más grandes es lidiar con los cambios en las dependencias y la configuración. Aquí está el ítem número 5 para tu blog, enfocado en cómo manejar el cambio de javax a jakarta.

5. El gran cambio de javax a jakarta: Tu nueva lista de tareas

Si hay una única tarea que debes priorizar al migrar a Spring Boot 3, es la de actualizar tus paquetes de javax a jakarta. Este cambio no es una simple cuestión de estilo; es una modificación fundamental en la API de Java EE (ahora conocida como Jakarta EE). El equipo de Spring Boot adoptó por completo el nuevo ecosistema, y tus proyectos deben hacer lo mismo. Ignorar este paso resultará en errores de compilación y de tiempo de ejecución.

¿Qué paquetes son los más afectados?

• JPA (Java Persistence API): Si tu aplicación usa Hibernate, la mayoría de tus entidades, como @Entity, @Table, y @Id, deben cambiar su importación de javax.persistence a jakarta.persistence. Sin esta actualización, tu EntityManagerFactory no se inicializará y el proyecto no se ejecutará.

• Servlets: Las clases relacionadas con el manejo de peticiones web, como HttpServletRequest y HttpServletResponse, deben cambiar de javax.servlet a jakarta.servlet.

• Validación: Las anotaciones de validación como @Valid o @Size también migran de javax.validation a jakarta.validation.

• JAXB y JTA: Los paquetes para la serialización de XML y la gestión de transacciones distribuidas (javax.xml.bind y javax.transaction) también se mueven a jakarta.xml.bind y jakarta.transaction, respectivamente.

¿Cómo hacerlo de forma eficiente?

En lugar de ir archivo por archivo, utiliza las herramientas de tu IDE. La mayoría de los entornos de desarrollo como IntelliJ IDEA tienen una función de búsqueda y reemplazo a nivel de proyecto. Simplemente busca javax. y reemplázalo por jakarta.. Ten cuidado de no reemplazar los paquetes que no migraron, como javax.crypto que es parte del JDK estándar.

Al hacer este cambio, estarás alineado con la última versión de la plataforma Java, lo que te permitirá aprovechar las nuevas características y mejoras de rendimiento de Spring Boot 3 y sus dependencias.

Conclusión

La migración a Spring Boot 3 es un paso inevitable hacia adelante. Aunque la transición de Date a LocalDate presenta desafíos en la serialización y validación, la inversión de tiempo vale la pena. Ganas en claridad del código, seguridad de tipos y te alineas con los estándares modernos de Java.

Es un proceso que requiere paciencia y atención a los detalles, pero al final, tu aplicación será más robusta y fácil de mantener.

El inconveniente inicial

El proyecto SaaS que manejaba estaba implementado en Kubernetes en Azure, usando cookies seguras para el manejo de sesión. Mientras todos los portales vivían bajo el mismo dominio raíz, no tuvimos inconvenientes.

Ejemplo:

• Frontend: portal_bi.miempresa.com

• Backend: api_bi.miempresa.com

Aquí las cookies funcionaban bien porque compartían el mismo dominio (.miempresa.com).

Sin embargo, cuando un nuevo cliente necesitó su propio dominio:

• Frontend: portalcliente_bi.dominioexterno.com

• Backend: api_bi.miempresa.dominioexterno.com

El inicio de sesión comenzó a fallar en ciertos casos:

• En modo incógnito el inicio de sesión no funcionaba.

• A algunos usuarios corporativos, con navegadores más estrictos, también les fallaba.

La causa: el navegador detectaba que las cookies venían de un dominio distinto y las bloqueaba por política de seguridad.

Por ejemplo:

• En Brave, el portal funcionaba tanto en el modo incognito y en las ventanas normales, a pesar de que en la consola de desarrollo no se listaban las cookies seguras.

• En Edge, Chrome y Firefox, en la ventana normal si aparecían las cookies seguras mientras que en el modo incognito no aparecían y se cerraba la sesión.

Primera hipótesis

Pensamos que tal vez el error estaba ligado únicamente a configuraciones de cookies, así que hicimos pruebas replicando el escenario en un subdominio de pruebas:

• clientepruebas.dominio-test.com

Al probar login en ventana normal e incógnito, vimos que en incógnito también se bloqueaban las cookies si el backend estaba en un dominio distinto. Confirmamos que el problema no era de configuración de cookies, sino de cross-domain.

Solución planteada

La solución que adoptamos fue dejar de usar una URL estática de backend y, en su lugar, hacer que el frontend siempre invoque a la API relativa al mismo dominio donde está desplegado el cliente.

Antes:

// Llamada "quemada"
fetch("https://miportal.com/api/v2/endpoint")

Después:

// Llamada relativa al dominio actual
fetch("/api/v2/endpoint")

De esta manera, si el cliente está en:

• portalcliente.com, la llamada va a portalcliente.com/api/v2.

• clientepruebas.dominio-test.com, la llamada va a clientepruebas.dominio-test.com/api/v2.

Y en Kubernetes configuramos el Ingress para que todas las llamadas a /api/v2 se redirijan internamente al servicio backend.

Ventajas de este enfoque

1. Misma política de dominio: al hacer las llamadas desde el mismo dominio donde está montado el frontend, las cookies seguras se comportan como first-party, no third-party.

2. Evita bloqueos de navegadores: ya no dependemos de excepciones de Chrome, Edge, Safari o configuraciones corporativas.

3. Escalable para múltiples clientes: cada dominio de cliente puede usar /api/v2 sin necesidad de cambiar la configuración del backend.

4. Más limpio en Kubernetes: el Ingress enruta todas las peticiones /api/v2 al servicio backend sin importar desde qué dominio se accede.

Conclusión

Si estás desarrollando un SaaS multi-tenant y manejas sesiones con cookies seguras, debes considerar que los navegadores no permiten compartir cookies entre dominios distintos. Esto puede romper el inicio de sesión en incógnito o en entornos corporativos.

Para resolverlo, una estrategia eficaz es:

• Evitar URLs absolutas en el frontend.

• Usar rutas relativas (/api/...).

• Configurar el Ingress de Kubernetes para enrutar esas rutas al backend.

De esta manera, cada cliente accede a tu SaaS con su propio dominio y las cookies seguras funcionan sin restricciones.

¿Te pasó algo parecido en tu proyecto SaaS? 🚀 Déjame tus comentarios y qué soluciones aplicaste para manejar cookies y sesiones en entornos multi-dominio.

Hay que añadir algunas variables de configuración de JMX para que cuando se ejecute la aplicación, permita el acceso sin necesidad de aplicar SSH, sin solicitar autenticación con la siguiente configuración en docker.

Dockerfile

```dockerfile

CMD ["java", "-Dcom.sun.management.jmxremote.port=9090", "-Dcom.sun.management.jmxremote.rmi.port=9090", "-Dcom.sun.management.jmxremote.authenticate=false", "-Dcom.sun.management.jmxremote.ssl=false", "-Djava.rmi.server.hostname=localhost", "-jar", "/opt/handytec-portal/handytec-portal-backend-1.0.0.jar"]
```
- Puerto 9090 lo usará JMC para conectarse a la app en docker.
- hostname localhost para que utilize la red local una vez docker expone el puerto local de nuestra PC
- ssl=false para desactivar que necesitemos ssl al conectarnos
- authenticate=false para no necesitar credenciales al loguearnos

Ejecutar contenedor

Para ejecutar el contenedor debemos ejecutar el siguiente comando:

```bash
docker run -it --rm --env-file=./.env -p 8080:8080 -p 9090:9090 --name <containerName> <imageName>

```

- -it: Habilita el modo interactivo al ejecutar la imagen

- --rm: Eliminar el contenedor al terminar de utilizarlo

- --env-file=./.env: Cargar las variables de entorno al contenedor en base a un archivo .env

- -p 8080:8080: Mapear puertos desde el host hacia el contenedor <host:contenedor>

- --name <containerName>: Nombre del contenedor

- <imageName>: Nombre de la imagen de la cual se va a crear un contenedor

En este ejemplo se habilita el puerto 8080 para que lo utiliza la aplicación de Java y el puerto 9090 para que acceda el JMX.

JDK Mission Control

Al añadir una nueva conexión en la aplicación de JDK Mission Control, se solicita los siguientes parámetros:
- host: localhost
- port: 9090

Con esto, se puede hacer clic en el botón "Probar conexión" y en el apartado de "Status" debe salir "Success". Opcionalmente, se puede añadir un nombre personalizado a la conexión.

Para llevarlo a cabo te comparto los aspectos a cubrir:

• El cierre de sesión se ejecuta luego de 10 minutos de inactividad (se puede cambiar en base a una variable).

• Para detectar la actividad del usuario, en este caso porque la aplicación lo requiere, se escucha los eventos del mouse [mousemove,click], si ninguno de estos sucede dentro de 10 minutos, se da por hecho que el usuario ha dejado de interactuar con la aplicación.

Para esto se implementa la función "resetInactiveUserOnApp" la cual es declarada dentro del archivo "authentication.service.ts", el cual contiene las funciones para realizar la autenticación vía firebase como el login, logout, refreshToken, etc.

//authentication.service.ts
const minutesToMilliseconds = (minutes: number) => minutes * 60000;
const AUTO_LOGOUT_INTERVAL_WAIT = minutesToMilliseconds(10);

private pauseInactiveListener = new BehaviourSubject<boolean>(false);
private resetTimerSubscription = new Subscription();

constructor(){
    // Inicializar función al crear el componente
    this.initializeInactiveListener();
}

login(){
    //Ejecutar lógica de login y al final llamar a la función para
    // inicializar el listener de inactive user. Esto debido a que
    // al ejecutar el logout se limpia la suscripción y se 
    // debe reinicializar la función
    this.initializeInactiveListener();
}

logout(){
    // Ejecutar lógica de cierre de sesión y al final 
    // limpiar suscripciones
    this.cleanComponentSubscriptions();
}

// Abre un modal con un contador de 60 segundos que permite al usuario
// elegir si desea o no continuar con la sesión abierta, si termina el
// contador y no se ha elegido alguna opción, se cierra la sesión
// automaticamente
openLogoutModal(){
    // Pausar la escucha de eventos cuando se abre el modal para validar
    // si el usuario desea continuar con la sesión abierta
    this.pauseInactiveListener.next(true);
    const dialogRef = this.dialog.open(LogoutCountdownComponent, {
      width: '350px',
      data: {},
      panelClass: 'dialog-draggable',
      hasBackdrop: true,
      disableClose: true
    });
    // Cuando se cierre la sesión, el modal devolvera un booleano 
    // que sera true o false dependiendo de si se desea o no
    // continuar con la sesión abierta
    dialogRef.afterClosed().subscribe(keepSession => {
      if (keepSession) {
        // Refrescar la sesión y luego habilita la escucha de eventos
        this.refreshSession().pipe(take(1)).subscribe(() => {
          this.pauseInactiveListener.next(false);
        })
      } else {
        // Ejecuta el logout
        this.logout().then(() => {
          this.router.navigate(['/login']);
        });
      }
    });
}

initializeInactiveListener(){
  //Escuchar los eventos del mouse que tomamos en cuenta
  // para determinar que el usuario esta interactuando con la página
  const mouseMove$ = fromEvent(document, 'mousemove');
  const click$ = fromEvent(document, 'click');
  // Pausar la escucha de los eventos cuando el observable de pausa esta
  // habilitado, esto se ejecuta al abrir el modal de log out.
  this.resetTimerSubscription = merge(mouseMove$, click$)
    .pipe(
      filter(() => !this.pauseInactiveListener.value),
      // Usando el switchmap se cancela el observable anterior si
      // todavía no se ejecuta, en este caso luego de 10min y 
      // se completa el observable si una nueva emisión es ejecutada
      switchMap(() => {
        return timer(AUTO_LOGOUT_INTERVAL_WAIT).pipe(
          takeUntil(merge(mouseMove$, click$))
        );
      })
    ).subscribe(() => {
      // Al obtener una emisión que cumple las validaciones antes
      // añadidas, se verifica la validez de la sesión y si no es
      // válida, se valida el observable de pausa, si esta desactivado
      // abre la ventana de logout de modal
      this.verifySessionIsValid().toPromise().then(credentials => {
        if (credentials) {
          if (!this.pauseInactiveListener.value) {
            this.openLogoutModal();
          }
        }
      });
    });
}

cleanComponentSubscriptions(){
    if (this.resetTimerSubscription) {
        this.resetTimerSubscription.unsubscribe();
    }
}
// Limpiar la suscripción del timer cuando el componente se destruye
ngOnDestroy(){
   this.cleanComponentSubscriptions();
}

📦 Paquetes necesarios

Primero lo que debemos hacer es importar los paquetes necesarios, entre los principales que se necesitarían son:

• FileSaver: para poder guardar archivos desde el navegador

• JSPDF: librería para generar PDF´s con JavaScript

• JSPDF Autotable: complemento de jspdf para habilitar la capacidad de generar tablas PDF ya sea analizando tablas HTML o utilizando datos JavaScript directamente

import { Injectable } from '@angular/core';
import * as FileSaver from 'file-saver';
import jsPDF from 'jspdf';
import 'jspdf-autotable';
import { reduceArrayByKeys } from 'src/app/shared/helpers/utils';
import { MessagesService } from './messages.service';

📝 Interfaz para cabeceras

Lo que necesitamos luego es crear una interfaz para mantener un tipado de los datos de entrada que tendremos al momento de exportar los datos.

interface IExportHeaders {
    header: string;
    dataKey: string;
}

🔍 Función para generar cabeceras por defecto

En caso de que no se provean las cabeceras de los datos, esta función permite obtenerlas a partir de las keys de los objetos.

const getDefaultHeaders = (json) => {
    const defaultHeaders = [];
    const keysObj = Object.keys(json);
    for (let value of keysObj) {
        const tempObj = {
            header: value, dataKey: value
        };
        defaultHeaders.push(tempObj)
    }
    return defaultHeaders;
}

⚙️ Configuración de PDF

Luego de eso se procede a escribir la configuración del objeto de JSPDF donde se puede configurar entre otras cosas la orientación del papel.

const PDFConfig = { putOnlyUsedFonts: true, orientation: 'landscape' };

Hecho eso ya podemos estructurar el servicio con su decorador tal cual como cualquier servicio normal de Angular, en el cual importamos un servicio para mostrar mensajes en el constructor del servicio.

@Injectable({ providedIn: 'root' })
export class ArchivosService {

    constructor(
        private messagesService: MessagesService
    ) { }

Luego si especificamos la función que hará el trabajo de crear el PDF y guardarlo en el dispositivo del usuario. En este caso recibimos 4 parámetros:

• data: lo especificamos con un array de cualquier tipo ya que va a ser utilizado por múltiples componentes en nuestra aplicación

• headers: se recibe las cabeceras que se mostrarán en las columnas de la tabla

• filename: el nombre del archivo a exportarse

• headerTitle: el título que aparecerá

exportPDF(
    data: any[],
    headers: IExportHeaders[] = [],
    filename = 'file',
    headerTitle = 'Documento eFact'
)

Luego verificamos si recibimos un array vacío, en ese caso retornamos un mensaje indicando que no existen datos disponibles para exportar.

if (data.length === 0) {
    return this.messagesService.info_notification(
        'No hay datos disponibles para exportar'
    );
}

También verificamos que si no se enviaron las cabeceras, las obtenemos usando la función que definimos anteriormente

if (!headers || headers.length === 0) {
    headers = getDefaultHeaders(data[0]);
}

Una vez que pasaron los datos las validaciones anteriores, se configura el documento jsPDF en el cual se configura el título del documento con tamaño de letra 18 y lo demás del documento con tamaño 8.

this.messagesService.info_notification('Generando su documento PDF...');
const doc = new jsPDF(PDFConfig);
doc.setFontSize(18);
doc.text(headerTitle, 14, 14);
doc.setFontSize(8);

const objColumns = {};
for (const header of headers) {
  objColumns[header.dataKey] = { columnWidth: 'auto' };
}

Luego de eso configuramos el método autoTable que se añade en el objeto jsPDF donde se establecen algunos parámetros como las columnas, el contenido de la tabla, la configuración de ancho de las columnas, el tema de la tabla entre otras configuraciones más.

doc.autoTable({
  columns: headers,
  body: data,
  startY: 20,
  columnStyles: objColumns,
  theme: 'striped',
  tableWidth: 'auto',
  cellWidth: 'wrap',
  showHead: 'firstPage',
  headStyles: { fillColor: [52, 152, 219] },
  styles: {
    overflow: 'linebreak',
    cellWidth: 'wrap',
    fontSize: 8,
    cellPadding: 2,
    overflowColumns: 'linebreak'
  }
});

Para obtener el numero de paginas, se usa el método getNumberOfPages que provee el método internal del documento y se procede a calcular el alto de la página.

const pageNumber = doc.internal.getNumberOfPages();
const pageSize = doc.internal.pageSize;
const pageHeight = pageSize.height || pageSize.getHeight();

Por último se ejecuta la función addFooters que se encarga de añadir el número de página en cada página del documento, el texto puede ser personalizado así como la ubicación del mismo. En el documento se establece el número de páginas y se ejecuta el método save del documento JSPDF.

function addFooters() {
  for (let i = 0; i < pageNumber; i++) {
    doc.text(`Página ${i + 1} de ${pageNumber}`, 14, pageHeight - 10);
  }
}

addFooters();
doc.setPage(pageNumber);
doc.save(`${filename}`);

Un ejemplo de como usar este servicio seria de esta manera, importándolo en el constructor de tu componente y llamando al método del servicio.

constructor(
    private _archivosService: ArchivosService 
){
}


print(){
    const headers = [
        {  header: 'Id', dataKey: 'id' },
        {  header: 'Nombre', dataKey: 'nombre'}
    ];
    const data = [
        { id: 1, nombre: 'Alexander Arnold' },
        { id: 2, nombre: 'Mariela Lopez' }
    ];
    this.exportPDF(data, headers, "usuarios.pdf", "Usuarios")
}

Listo, ya has escrito tu primer servicio que te permitirá exportar documentos PDF mandando un array de datos, el cual claramente lo puedes modificar para imprimir lo que consideres necesario.

Ejemplo:

📂 Estructura del ejemplo

• archivos.service.ts → Tu servicio para exportar a PDF (ya lo tienes).

• usuarios.component.ts → Componente que usa el servicio.

• usuarios.component.html → Vista con tabla y botón.

• usuarios.component.css → Estilos básicos.

usuarios.component.ts

import { Component } from '@angular/core';
import { ArchivosService } from '../services/archivos.service';

@Component({
  selector: 'app-usuarios',
  templateUrl: './usuarios.component.html',
  styleUrls: ['./usuarios.component.css']
})
export class UsuariosComponent {

  // Datos de ejemplo
  usuarios = [
    { id: 1, nombre: 'Alexander Arnold', email: 'alex@example.com' },
    { id: 2, nombre: 'Mariela Lopez', email: 'mariela@example.com' },
    { id: 3, nombre: 'Carlos Pérez', email: 'carlos@example.com' }
  ];

  constructor(private archivosService: ArchivosService) {}

  exportarPDF() {
    const headers = [
      { header: 'ID', dataKey: 'id' },
      { header: 'Nombre', dataKey: 'nombre' },
      { header: 'Email', dataKey: 'email' }
    ];

    this.archivosService.exportPDF(
      this.usuarios,
      headers,
      'usuarios.pdf',
      'Lista de Usuarios'
    );
  }
}

usuarios.component.html

<div class="container">
  <h2>Lista de Usuarios</h2>

  <table>
    <thead>
      <tr>
        <th>ID</th>
        <th>Nombre</th>
        <th>Email</th>
      </tr>
    </thead>
    <tbody>
      <tr *ngFor="let usuario of usuarios">
        <td>{{ usuario.id }}</td>
        <td>{{ usuario.nombre }}</td>
        <td>{{ usuario.email }}</td>
      </tr>
    </tbody>
  </table>

  <button (click)="exportarPDF()">📄 Exportar a PDF</button>
</div>

usuarios.component.css

.container {
  max-width: 600px;
  margin: auto;
  text-align: center;
  font-family: Arial, sans-serif;
}

h2 {
  margin-bottom: 20px;
}

table {
  width: 100%;
  border-collapse: collapse;
  margin-bottom: 15px;
}

table, th, td {
  border: 1px solid #ccc;
}

th {
  background-color: #3498db;
  color: white;
  padding: 8px;
}

td {
  padding: 8px;
}

button {
  background-color: #2ecc71;
  color: white;
  border: none;
  padding: 10px 15px;
  cursor: pointer;
  border-radius: 4px;
}

button:hover {
  background-color: #27ae60;
}

🔹 Cómo funciona

1. El usuario ve la tabla con los datos.

2. Al hacer clic en "Exportar a PDF", se llama al método exportarPDF() del componente.

3. Este método prepara las cabeceras y llama al servicio ArchivosService.

4. El servicio genera el PDF con jsPDF y autoTable y lo descarga automáticamente.

En el caso de Facebook en la documentación podemos encontrar lo siguiente:

Campo Email: Este campo no se devolverá si no hay una dirección de correo electrónico válida disponible para el usuario

Leyendo esto podemos deducir que cuando una dirección de correo electrónico no ha sido verificado o no existe, como en el caso de alguien que se registro por medio de su numero telefónico.

Fuentes Referenciadas:

• Facebook Api