Diagramas UML en Enterprise Architect (por COM)
Archivos en esta carpeta (junto a este SKILL.md; funciona con cualquier agente que lea skills en formato SKILL.md y pueda ejecutar PowerShell):
GUIA_TECNICA.md: cómo automatizar EA 15, funciones, recetas por tipo de diagrama, trampas, patrones de diseño (con Chain of Responsibility). Léela completa antes de construir.scripts\:ea_lib.ps1(biblioteca),nuevo_eapx.ps1,inspeccionar_eapx.ps1,guardar_enlaces_de_diagramas.ps1,ejemplo_generico.ps1,ejemplo_tipos_adicionales.ps1,ejemplo_patrones_detalle.ps1,ejemplo_navegacion_prototipos_requisitos.ps1yejemplos_de_otro_proyecto\(solo para ver técnicas).FORMATO_DISENO_DETALLE_PROCEDIMENTAL.md: cómo se entrega un "diseño de detalle procedimental con patrones" (diagrama genérico del patrón + diagrama específico del caso de uso dentro de la arquitectura), con la notación y el método para ampliar casos de uso.ejemplo_resultado_png\: lo que producen los ejemplos.
Cuándo usarla y cuándo no
- Sí: pedir los diagramas de un proyecto en EA, ampliar o corregir un
.eapx, agregar un patrón de diseño a diagramas ya hechos, reproducir el estilo de un.eapxde referencia. - No: diagramas sueltos en Mermaid o PlantUML, o imágenes sin repositorio de EA. Tampoco generes XMI salvo que lo pidan.
Principios (no negociables)
- Pedido genérico. No asumas ICONIX, Scrum, PUDS u otra metodología, ni una lista fija de diagramas. La metodología, el tipo y la cantidad de diagramas salen de la documentación, de las instrucciones del usuario y de las necesidades del proyecto.
- No inventes requisitos, historias de usuario, casos de uso, componentes, estados ni relaciones para completar un diagrama. Si faltan datos indispensables o hay contradicciones importantes, pregunta. Las suposiciones menores se documentan (cuáles y por qué). Lo que sea propuesta, rotúlalo como propuesto.
- Resultado real: un
.eapxauténtico con elementos y conectores editables; nunca un PDF, imagen o HTML presentado como repositorio. Si EA o su interfaz COM no están disponibles, explica la limitación y detente. - No destruyas nada. Trabaja sobre una copia. Si el archivo de salida ya existe, no lo sobrescribas ni lo borres sin preguntar. Conserva intactos la documentación, el código y los archivos de referencia (no modifiques el
.eapxde referencia). - Verifica antes de afirmar. Nada "funciona" o "se ve bien" si no lo comprobaste; lo que no pudiste comprobar, dilo.
Flujo de trabajo
1. Entorno. Comprueba que EA y su COM están disponibles:
powershell -NoProfile -Command "$r = New-Object -ComObject EA.Repository; 'EA COM disponible'; $r.Exit()".
Los scripts se corren con Windows PowerShell 5.1 y EA debe estar cerrado sobre el archivo que se toca. Detalles y límite de tiempo en la guía (sección 3).
2. Análisis inicial. Identifica el proyecto, su documentación y su código, y cualquier .eapx disponible. Revisa los documentos para determinar: objetivo y alcance; metodología mencionada; actores, requisitos, casos de uso, historias de usuario, procesos y componentes; los diagramas pedidos explícitamente y los adicionales necesarios. Si hay código, úsalo para contrastar entidades, servicios, componentes y arquitectura (con herramientas: AST, grep, esquema de la base; no de memoria). Si hay varios proyectos o documentos y no está claro cuáles usar, pregunta antes de empezar.
3. Plan de diagramas. Antes de construir, prepara una lista con: los diagramas pedidos explícitamente; los adicionales que recomiendas y por qué; el alcance de cada uno (global, por módulo, proceso, caso de uso o historia); sus elementos principales; y la fuente documental o de código que lo respalda (usa la ficha de la guía, sección 5). Si lo pedido está claro, sigue sin esperar confirmación. Si hay varias interpretaciones, o quieres añadir diagramas que cambian mucho el alcance, muestra el plan y pregunta cuáles incluir.
4. .eapx de referencia (si hay). Inspecciónalo con scripts\inspeccionar_eapx.ps1 (organización, tipos de diagrama, notación, estereotipos, conectores, estilo). Sigue sus convenciones cuando apliquen; no copies requisitos ni elementos de otro proyecto como si fueran de este; no lo modifiques. Sin referencia, usa las convenciones de UML, BPMN, ICONIX o modelado de datos que correspondan.
4b. Diseño que hay que respetar. Si el usuario tiene diagramas con un diseño impuesto (zonas de color, orden, estilo del docente) y pide "lo mismo pero con X" (otro patrón, otro caso de uso), duplica el diseño, no lo redibujes: Clonar-Paquete (copia profunda con zonas, colores y conectores) y agrega encima lo nuevo; mira scripts\ejemplos_de_otro_proyecto\ejemplo_replicar_diseno_y_agregar_patron.ps1 y la guía, sección 10. Nunca modifiques el archivo del usuario: trabaja en una copia y entrégala aparte.
5. Crear o abrir. Archivo nuevo: scripts\nuevo_eapx.ps1 -Archivo "ruta\proyecto.eapx" (se niega a sobrescribir). Archivo existente: trabaja en una copia.
6. Organizar el modelo en paquetes claros según los diagramas y el alcance (por ejemplo: visión general, requisitos, casos de uso, procesos y actividades, dominio y clases, interacciones, arquitectura, datos, otros); adapta nombres y carpetas a lo que el proyecto necesite. No crees paquetes vacíos. Si hay un diagrama por caso de uso, proceso, módulo o historia, organízalos para que se encuentren fácil.
6b. Estructura por flujos de trabajo (Proceso Unificado / PUDS). Si la metodología es Proceso Unificado, o el docente pide el modelo "por análisis, diseño e implementación", organiza el proyecto así (un paquete por actividad; dentro, un subpaquete y un diagrama por caso de uso o por paquete cuando corresponda):
| Flujo | Paquete (actividad) | Diagramas |
|---|---|---|
| Análisis | Identificar Actores / Actores | Actores (con nota de descripción) |
| Estructurar Casos de Uso | Casos de uso global | |
Detallar Casos de Uso / CUxx ... | Un diagrama de casos de uso por CU (y su actividad o prototipo si se piden) | |
Analizar Casos de Uso / CUxx ... | Comunicación de análisis por CU (antes "colaboración"), con el mismo nombre del CU: boundary, control y entity con mensajes numerados 1, 1.1, 1.2... Si la metodología es ICONIX, robustez sin mensajes | |
| Identificar Paquetes | Paquetes de análisis | |
Relación de Paquete y Casos de Uso / Relación Paquete X | Paquete → sus CU con «trace» | |
Encapsulamiento / Encapsulamiento de Paquete X | Paquete con sus CU y los actores que los usan | |
| Análisis de Paquetes | Paquetes con dependencias «import» | |
| Modelo de Dominio | Clases del negocio (+ atributo, id, sin FK ni tipos) | |
| Diseño | Diseño de Clases | Clases de diseño (tipos y métodos, sin FK) |
| Diseño de BD | Dos diagramas: Modelo de Datos - Lógico (sin FK ni tipos) y Modelo de Datos - Físico (PK, FK y tipos) | |
Diseño de Casos de Uso / Diseño CUxx ... | Secuencia de diseño (cajitas) por CU | |
| Diseño de Paquetes | Paquetes de diseño o módulos | |
| Diseño de Arquitectura | Despliegue: Node para la nube, el router y cada servicio externo; Device para el celular o la PC; dentro de cada uno, los componentes que corren ahí (cluster de BD > motor; plataforma > API y front; SO > app), y enlaces Association con http/https | |
| Implementación | Arquitectura del Sistema | Paquetes con «import», subsistemas «subsystem» (Frontend/Móvil, Backend), servicios externos «service» en verde con su interfaz provista, y la BD; Dependency del Backend a cada paquete |
Arquitectura de Subsistemas / Subsistema X | Un diagrama de componentes por paquete, en tres bloques anidados: Usuario (páginas) → Servidor (controller, interfaz del service, DTO, «entity») → Base de datos («table»), unidos con Dependency |
Añade navegación web, prototipos y requisitos donde el docente los pida (normalmente en Análisis o Diseño). Relaciones entre diagramas (trazabilidad):
- Cada elemento se crea UNA vez, en el paquete de la actividad donde nace (actores en Actores, CU en Estructurar Casos de Uso, paquetes en Identificar Paquetes, clases del negocio en Modelo de Dominio), y los demás diagramas lo colocan de nuevo con
Place(EA lo muestra con "(from )"). Nunca crees un segundo actor o CU con el mismo nombre. - Los conectores pertenecen al modelo, no al diagrama: al colocar un actor y un CU ya conectados, la relación aparece sola. Conéctalos una vez (Actor → CU con tipo
UseCase). - Entre fases: paquete de análisis → CU con
Abstraction+ estereotipotrace; paquete → paquete conDependency+import; clase de diseño → clase de dominio contrace; paqueteDiseño CUxx→ su CU contrace; subsistema (componente) → paquete que implementa conDependency(así lo usa el.eapxde referencia del taller). - Ejemplo completo y probado:
scripts\ejemplo_estructura_puds.ps1.
7. Construir con scripts\ea_lib.ps1: un script por grupo de diagramas, un try/catch y un registro por diagrama, elementos reutilizados con Find-Elem en vez de copias incoherentes, y Exporta al final de cada diagrama (guarda también las líneas del diagrama en el archivo). Empieza por ejemplo_generico.ps1 y ejemplo_tipos_adicionales.ps1 como plantillas.
8. Reglas por tipo (aplica solo las de los tipos del plan; recetas y código en la guía). Cada diagrama sigue las normas de su propio tipo: no mezcles la notación de uno con la de otro (por ejemplo, nada de mensajes numerados en robustez, ni tipos de dato en el modelo conceptual). Si el .eapx de referencia o el docente usan otra convención, sigue la de ellos y dilo.
- Casos de uso: actores, casos de uso y relaciones justificadas;
include/extendsolo cuando corresponda; vistas globales o individuales según los requisitos. - Actividades y procesos: actividades, decisiones, inicio, fin y responsables (calles); UML o BPMN según lo pedido; flujos coherentes con la documentación.
- Clases de diseño: clases con atributos (con visibilidad y tipo) y operaciones reales, relaciones justificadas, multiplicidades, herencias y dependencias. Sin claves foráneas como atributo: la asociación entre clases (o un atributo que es el objeto,
- cliente: Cliente) ya representa la relación. Guarda y verifica cada atributo y operación individualmente tras reabrir. - Secuencia: hay dos variantes; si no está claro cuál piden, pregunta o haz las dos, y no mezcles sus notaciones en un mismo diagrama:
- Secuencia de análisis (ICONIX): sale del diagrama de robustez. Participantes con estereotipo
boundary,controlyentity(EA los dibuja como círculos); mensajes en lenguaje del negocio (Obtener sugerencia()). EnBuild-Sequence,t = 'boundary' | 'control' | 'entity'. - Secuencia de diseño: la que se pide para implementación (por ejemplo en taller de grado). Participantes como cajitas (rectángulos) con nombre de objeto
:Clasetomado del diagrama de clases de diseño o del código real (:PedidoView,:PedidoController,:PedidoService,:PedidoRepository,:Pedido); el actor puede ir al inicio. Mensajes = métodos reales con parámetros (crear(PedidoDTO),guardar(pedido)), retornos punteados con el valor devuelto, autollamadas para validaciones,new Clase(...)para crear objetos y fragmentosalt/opt/loopcon su condición. EnBuild-Sequence,t = ''(sin estereotipo). Cada mensaje debe existir como operación en la clase que lo recibe. Modelo típico pedido en taller de grado: Actor → página o vista (usuarioPage) → controlador (responsableLugarController) → base de datos (Postgres), con autollamadas en la vista (seleccionarLugar()), llamadas con datos (crearResponsabilidad(data)), retornos punteados (success(),ok()) y el último mensaje de vuelta al actor (mostrarListaResponsables()). Los participantes se nombran como en el código; el prefijo:es opcional. - En las dos: verifica explícitamente el orden (
SequenceNo) y que persista al cerrar y volver a abrir. Las condiciones de los fragmentos se escriben sin corchetes (EA los agrega).
- Secuencia de análisis (ICONIX): sale del diagrama de robustez. Participantes con estereotipo
- Comunicación (en UML 1.x se llamaba colaboración; en EA es el tipo
Collaboration): participantes enlazados y mensajes numerados, coherentes con la secuencia de la misma funcionalidad. Comunicación de análisis (Proceso Unificado, "Analizar caso de uso"): actor + objetosboundary,controlyentityunidos por asociaciones (mismas reglas de conexión que la robustez), y encima de cada enlace sus mensajes con numeración anidada: cada acción del actor es un grupo (1,2,3...) y sus llamadas internas1.1,1.2...; parámetros entre paréntesis (registrarUser(usuario)). EA colorea cada grupo solo. UsaAdd-MsgComyBuild-Comunicaciondeea_lib.ps1. Limitación probada: la flechita de dirección junto a cada mensaje no aparece si el mensaje se crea por script (el número, el color y los parámetros sí); el orden lo dan los números. - Modelo de dominio / mapeo conceptual: solo las clases del negocio con sus relaciones y multiplicidades. Cada clase lleva sus atributos con visibilidad
+y su identificador (clave primaria, por ejemplo+ id_campana). No pongas claves foráneas (la relación con la otra clase ya las representa), ni tipos de dato (int,varchar,String,Date...), ni operaciones. Los tipos, las claves foráneas y los métodos van en el diagrama de clases de diseño y en el modelo de datos. - Robustez ICONIX: solo si está pedida o la metodología/documentos la justifican; actores y objetos boundary, control y entity; si el
.eapxde referencia usaCollaborationconObjecty estereotipos, sigue esa convención; comprueba que los estereotipos se guarden y se vean. Reglas de conexión: Actor ↔ Boundary; Boundary ↔ Control; Control ↔ Entity; Control ↔ Control. Nunca Actor ↔ Control, Actor ↔ Entity, Boundary ↔ Entity ni Entity ↔ Entity. Una entidad no inicia una consulta hacia un control: el control es quien usa la entidad. Usa asociaciones simples, sin mensajes numerados ni flechas de llamada; el orden de los mensajes (por ejemplo, los pasos y las compensaciones de una SAGA) va en el diagrama de secuencia. Cada control representa una acción o responsabilidad del caso de uso; no lo dejes en un único control que lo haga todo. - Navegación web (WAE / Conallen), uno por actor: es el diagrama más completo para sistemas web y se pide un diagrama por actor (
Diagrama de Navegacion - <Actor>), con todas las pantallas, formularios, páginas servidor y tablas a las que llega ese actor. DiagramaLogical(de clases) conHideQuals=0. Elementos (todosClass):- Página cliente (estereotipo
Client Page, EA dibuja el icono de página): cada pantalla (Login, Dashboard, Lista X, Perfil). Atributos = datos que muestra; operaciones = acciones del usuario (abrirCrear(),buscar(),navigateTo()). - Formulario (estereotipo
Formulario): cada formulario o modal (Registrar X, Editar X). Atributos = campos; operaciones =guardar(),cerrarForm(),listarX()para cargar combos. - Página servidor (estereotipo
Server Page, icono de engranaje), con nombreps <Acción>(ps Listar X, ps Registrar X, ps Actualizar X, ps Eliminar X, ps Toggle X). Atributos = parámetros que recibe; operación = método del controlador (index(),store(),update(),destroy()). - Tabla: elemento
Artifact(noClass) con estereotipodatabasey nombreBD: <tabla>(oBD: tabla1 / tabla2si se usan juntas); EA la pinta verde con icono de documento. Atributos = columnas que se usan. - Todos los elementos salvo el actor y las tablas son
Class. - Atributos: privados (
-), sin tipo y como colección (IsCollection+AllowDuplicates→ EA muestra{bag}). Operaciones: públicas (+), sin parámetros; el nombre se guarda sin(). - Conectores
Associationcuyo nombre es<tipo> <acción>: Actor → Loginlink usa el sistema; página cliente → página clientelink <destino>; página cliente → formulariolink abrirCrear()/link abrirEditar(); formulario o página cliente → página servidorsubmit guardar()/submit toggle/submit eliminar; página servidor → página clientebuild page load(carga datos) obuild redirect back(vuelve tras guardar); página servidor → tablaaccess SELECT|INSERT|UPDATE|DELETE. Nunca conectes una página cliente o un formulario directamente con una tabla. - Variantes de
buildsegún cómo responde el servidor:build page load,build redirect,build redirect back,build redirect login,build JSON(respuesta a una petición asíncrona) o el método real del framework (por ejemplobuild Inertia::render). Las desubmitllevan el método o la acción real (submit guardar(),submit eliminar,submit cambiarPassword()); si la acción tiene una condición de rol, va entre paréntesis (submit eliminar (propietario/director)). - Cada operación CRUD tiene su propia página servidor (
ps Listar X,ps Registrar X,ps Actualizar X,ps Eliminar X,ps Toggle X), cada una con suaccessa las tablas que toca. El perfil del actor (ver, editar datos, cambiar contraseña) y el login van en todos los diagramas. - Tamaño de referencia (proyecto académico con 5 actores): el actor con más funciones tenía 11 páginas cliente, 15 formularios, 35 páginas servidor y 8 tablas; el más simple, 5, 4, 7 y 4. Si un actor sale con muchos menos, probablemente faltan acciones del código.
- Para que tu compañero o el usuario puedan reimportar, exporta también cada diagrama a XMI (
Diagrama de Navegacion - <Actor>.xml) además del PNG. No probado por COM (GetProjectInterface().ExportPackageXMI); pruébalo antes en una copia, y si falla, se exporta a mano desde EA (Publicar → Exportar XML). - Saca pantallas, formularios, rutas y tablas del código real (rutas/controladores, componentes de la interfaz, esquema de BD) y no los inventes. Ejemplo:
ejemplo_navegacion_prototipos_requisitos.ps1, diagrama 1.
- Página cliente (estereotipo
- Prototipos de interfaz: uno por pantalla principal. Diagrama
Custom; la pantalla es un elementoScreeny cada control es unGUIElementcon estereotipo (label,text,combobox,button,list,checkbox...) yParentID= pantalla. Los campos deben coincidir con los del formulario del diagrama de navegación y de la descripción del caso de uso. - Requisitos: diagrama
Custom; cada requisito es unRequirementcon su código (RF01 ...,RNF01 ...); la trazabilidad esRealisationdel caso de uso al requisito que cumple. Todo RF debe quedar cubierto por algún caso de uso. - Componentes, paquetes y despliegue: módulos, servicios, nodos, dispositivos, bases de datos según la arquitectura documentada o implementada; distingue lo existente de lo propuesto.
- Estados: estados, transiciones y eventos de las entidades o procesos que lo requieran; no inventes ni estados ni transiciones.
- Modelo de datos: genera siempre los dos diagramas, sobre las mismas tablas del esquema real, para que el usuario use en su documentación el que le pida su docente (dilo en la entrega):
Modelo de Datos - Lógico(estilo diagrama de clases): una clase por tabla con+ atributo, suid, sin tipos de dato y sin columnas de clave foránea; cada FK se representa con la línea de la relación y su cardinalidad (1..1,0..*). Revisa que no quede ninguna columna*_idque sea FK escrita como atributo.Modelo de Datos - Físico(relacional): las mismas tablas con todas las columnas, tipos (INT,VARCHAR(100),NUMERIC(14,2),DATE...),PK, una columnaFKpor cada relación (en el lado "muchos" de una 1:N; en las N:M, una tabla intermedia con las dos FK) y restricciones.- Las relaciones y cardinalidades tienen que ser idénticas en los dos. No modifiques la base de datos.
- Resumen de claves foráneas y tipos: modelo conceptual / de dominio → sin FK, sin tipos; diagrama de clases de diseño → sin FK (la asociación las representa), con tipos; modelo de datos lógico → sin FK, sin tipos; modelo de datos físico → con FK y con tipos. Si el docente o el
.eapxde referencia piden otra cosa, sigue eso y dilo. - Otros: usa el tipo, los elementos y la notación apropiados; si EA no soporta exactamente la notación pedida, dilo y pregunta antes de reemplazarla.
- Patrones de diseño: guía, secciones 10 y 11, y
FORMATO_DISENO_DETALLE_PROCEDIMENTAL.md. Crear diagramas "con patrón" que reutilizan las mismas clases; confirmar en el código que el patrón existe; por cada caso de uso, diagrama genérico del patrón (con cita) + diagrama específico dentro de la arquitectura real.
9. Coherencia y presentación. Mismos nombres e identificadores en todo el repositorio; elementos reutilizados entre diagramas; diagramas relacionados que no se contradigan; conectores con dirección, tipo y etiqueta correctos; cada diagrama legible, sin solapamientos ni elementos de relleno.
10. Verificación final (antes de decir que está terminado): guarda, cierra y reabre el .eapx (inspeccionar_eapx.ps1); cuenta diagramas por tipo y compara con el plan; comprueba que hay elementos y conectores reales (con= mayor que 0 en los diagramas que no son de secuencia); verifica nombres, relaciones, estereotipos, atributos, operaciones y orden de mensajes; compara con la documentación; exporta los PNG y míralos (muestra representativa como mínimo); indica lo que no pudiste comprobar.
11. Entrega. Informa: ruta absoluta del .eapx; lista de diagramas por tipo y cantidad; documentos y archivos de código usados como fuente; metodología identificada (si está documentada); cómo se creó y qué comprobaciones se hicieron; si se revisó visualmente en EA o solo por COM/PNG; suposiciones, discrepancias, omisiones, limitaciones, errores y trabajo pendiente.
Qué está probado (EA 15, por COM)
| Tipo | Estado | Dónde verlo |
|---|---|---|
Casos de uso, clases, paquetes, secuencia (con alt, opt, loop...), actividad con calles | Probado | ejemplo_generico.ps1 |
| Patrón Chain of Responsibility (clases, secuencia, actividad) | Probado | ejemplo_generico.ps1, guía sección 11 |
| Comunicación, objetos, estados, robustez ICONIX (2 variantes) | Probado | ejemplo_tipos_adicionales.ps1 |
| Strategy y Template Method (genérico + específico), Singleton, abstractas/estáticas/protegidas, interfaz, notas, colores | Probado | ejemplo_patrones_detalle.ps1 |
| Despliegue, componentes, modelo de datos, secuencias largas | Probado (otro sistema) | ejemplos_de_otro_proyecto\ |
| Navegación web por actor (página cliente, formulario, página servidor, tabla), prototipo de interfaz, requisitos | Probado | ejemplo_navegacion_prototipos_requisitos.ps1 |
Modelo organizado en Análisis / Diseño / Implementación con elementos reutilizados y relaciones «trace», «import», Realisation; secuencia de diseño con cajitas | Probado | ejemplo_estructura_puds.ps1 |
Crear .eapx nuevo | Probado | nuevo_eapx.ps1 |
| Duplicar un diseño existente (paquete completo con zonas de color) y agregarle un patrón | Probado | ejemplos_de_otro_proyecto\ejemplo_replicar_diseno_y_agregar_patron.ps1 |
| BPMN 2.0, ocurrencias de colaboración, duplicar diagramas, fragmentos anidados, interfaces "piruleta" | No probado | probar primero en una copia y mirar el PNG |
Trampas que más cuestan (el resto, en la guía, sección 9)
- Sin abrir y guardar el diagrama, sus líneas no quedan en el archivo (el PNG de la misma sesión se ve bien; al abrir el
.eapxlos elementos aparecen sueltos).Exportaya lo hace; en secuencias no se debe. - Una consulta SQL a una columna inexistente cuelga EA: usa límite de tiempo y
taskkill /F /IM EA.exesi pasa. - Los
.ps1con acentos deben ir en UTF-8 con BOM. - Correr un script de construcción dos veces sobre el mismo archivo duplica los elementos: copia nueva cada vez.
- Los autoenvíos dentro o en el borde de un fragmento de secuencia desalinean el marco.
- Mira siempre el PNG: los conteos no dicen si un diagrama se lee bien.
Corregir un diagrama que el usuario ya acomodó
- Respaldo con fecha y hora antes de escribir (
archivo.eapx.backup_AAAAMMDD_HHMMSS). - Cierra EA por completo antes de editar (
Get-Process EAdebe salir vacío): con EA abierto el archivo queda bloqueado o se pisan los cambios. - Solo agrega. No borres, reemplaces, renombres ni muevas elementos o conectores que ya existen; respeta los tamaños y el acomodo que dejó el usuario. Coloca lo nuevo en espacio libre, sin solaparlo con lo existente.
- Antes de agregar, busca si el elemento ya existe en el paquete (
Find-Elem) para no duplicarlo. - Toca solo el diagrama pedido; anota el estado de los demás (sobre todo los que el usuario ya dio por buenos) y comprueba al final que no cambiaron.
- Guarda, cierra, reabre y verifica que lo agregado persistió y lo anterior sigue igual. Informa los IDs de lo agregado y la ruta del respaldo.