From 85b05ade5168606e0b24bbe7a528f58e46501c55 Mon Sep 17 00:00:00 2001 From: dta Date: Tue, 27 Oct 2026 10:33:17 +0100 Subject: [PATCH] first commit --- .gitignore | 7 + README.md | 106 +++++ config/application.properties | 2 + info_IES.xml | 4 + informacion-IES_v2.xml | 369 ++++++++++++++++++ informe_ciclos_IES.txt | 38 ++ modulos1_ciclo_DAM.xml | 27 ++ resumen_ciclos_IES.xml | 11 + src/org/palomafp/aadd/dta/AppPrincipal.java | 302 ++++++++++++++ .../dta/gestores/GestorConfiguracion.java | 40 ++ 10 files changed, 906 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 config/application.properties create mode 100644 info_IES.xml create mode 100644 informacion-IES_v2.xml create mode 100644 informe_ciclos_IES.txt create mode 100644 modulos1_ciclo_DAM.xml create mode 100644 resumen_ciclos_IES.xml create mode 100644 src/org/palomafp/aadd/dta/AppPrincipal.java create mode 100644 src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..065c529 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +.settings/ +bin/ +.classpath +.project +*.class + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..b992e57 --- /dev/null +++ b/README.md @@ -0,0 +1,106 @@ +# aadd_fic12: Tratamiento de ficheros XML con DOM (lectura/escritura) + +## Descripción + +Proyecto en Java que lee el fichero `informacion-IES_v2.xml` con el API DOM (`org.w3c.dom`) y, a través de un menú por consola (clase `Scanner`), genera cuatro ficheros de salida: tres en formato XML construidos con DOM y un informe de texto con los comentarios de cada ciclo formativo. + +La ruta del fichero de entrada no está escrita en el código: se lee del fichero `application.properties` a través de la clase `GestorConfiguracion`. No se utiliza el patrón DAO. + +## Estructura del proyecto + +- `Ficheros_12/` + - `src/org/palomafp/aadd/dta/` + - `AppPrincipal.java`: clase principal con el menú y el tratamiento del XML + - `gestores/` + - `GestorConfiguracion.java`: carga `application.properties` y expone la ruta del XML + - `config/` + - `application.properties`: configuración (ruta del fichero de entrada) + - `informacion-IES_v2.xml`: fichero de entrada + - `README.md` + +Ficheros generados al ejecutar el programa: + +- `info_IES.xml` +- `resumen_ciclos_IES.xml` +- `modulos1_ciclo_DAM.xml` +- `informe_ciclos_IES.txt` + +## Componentes principales + +- **`AppPrincipal`**: carga el XML en un `Document` y muestra el menú. Cada opción llama a un método que crea su fichero de salida. +- **`GestorConfiguracion`**: clase de utilidad (constructor privado) que carga `application.properties` en un bloque `static` y devuelve la ruta del XML como `Path`. + +## Configuración + +Fichero `application.properties`: + +```properties +ies.ruta.fichero=informacion-IES_v2.xml +``` + +Si falta la propiedad, `getRutaFicheroIes()` lanza una `IllegalStateException` con un mensaje descriptivo. + +## Métodos de `GestorConfiguracion` + +| Método | Acción | +|---|---| +| bloque `static` | Carga `application.properties` desde el classpath. Si no existe o no se puede leer, lanza una `RuntimeException` | +| `getRutaFicheroIes()` | Devuelve como `Path` el valor de `ies.ruta.fichero` | + +## Métodos de `AppPrincipal` + +| Método | Acción | +|---|---| +| `main(String[] args)` | Obtiene la ruta, carga el XML y repite el menú hasta que se elige `0`. Los errores de una opción se capturan dentro del bucle y no cierran el programa; los de arranque terminan la ejecución | +| `mostrarMenu()` | Imprime las opciones del menú | +| `cargarXml(Path ruta)` | Parsea el fichero con `DocumentBuilder` y devuelve el `Document` normalizado. No ignora comentarios, porque la opción 4 los necesita | +| `guardarXml(Document doc, Path destino)` | Vuelca un `Document` a fichero con `Transformer` (UTF-8, indentado a 4 espacios, sin `standalone="no"`) | +| `obtenerNombreIes(Document doc)` | Devuelve el texto del `` que es hijo directo de la raíz ``, evitando los `` de los ciclos | +| `crearFicheroInformacionInstituto(Document doc)` | Opción 1. Crea `info_IES.xml` | +| `crearFicheroResumenCiclos(Document doc)` | Opción 2. Crea `resumen_ciclos_IES.xml` | +| `crearFicheroModulosDam(Document doc)` | Opción 3. Crea `modulos1_ciclo_DAM.xml` | +| `crearFicheroInformeCiclos(Document doc)` | Opción 4. Crea `informe_ciclos_IES.txt` | + +## Opciones del menú + +| Opción | Fichero generado | Contenido | +|---|---|---| +| 1 | `info_IES.xml` | Raíz `` con el `` del instituto | +| 2 | `resumen_ciclos_IES.xml` | Raíz `` con el instituto (atributo `tipo`) y un `` por cada ciclo con su nombre corto | +| 3 | `modulos1_ciclo_DAM.xml` | Raíz `` (atributos `nombre` y `tipo`) con el ciclo DAM y los módulos de su primer curso | +| 4 | `informe_ciclos_IES.txt` | Informe con código, nombre corto y observaciones de cada ciclo | +| 0 | — | Salir | + +### Detalle de la opción 3 + +El formato de salida cambia respecto al original: + +| Original | Salida | +|---|---| +| Raíz `` con `` | Raíz `` con atributo `nombre` | +| `` | `` | +| `` (elemento) | atributo `numero_horas` del `` | +| `` con `familia` y `numero_horas` | `` solo con `codigo` y `nivel` | + +Los módulos se leen buscando por nombre de etiqueta (no por posición), porque el orden de `` y `` cambia entre módulos. Se aplica `trim()` a los textos para eliminar espacios sobrantes. + +### Detalle de la opción 4 + +- Solo se recogen los nodos `Node.COMMENT_NODE` que son **hijos directos** de cada ``, mediante `getChildNodes()`. Los comentarios de `` o los externos al ciclo no se incluyen. +- Se muestran todos los ciclos, aunque alguno no tenga observaciones. +- El informe se construye en un `StringBuilder` y se escribe con `Files.writeString` (UTF-8). + +## Aspectos a tener en cuenta del XML de entrada + +- Hay elementos `` en dos sitios: como hijos de `` (aulas) y dentro de `` (asignaturas). Por eso se busca siempre dentro del `` correspondiente. +- Hay dos tipos de ``: el del instituto (texto) y el de cada ciclo (con `nombre_corto` y `nombre_largo`). +- Algunos ids de módulo están repetidos (por ejemplo `14` en DAM). Es un dato del fichero y se copian tal cual. +- En DAM hay un comentario entre `` y `` cuyo texto dice no ser hijo directo del ciclo, pero estructuralmente sí lo es, por lo que aparece en el informe. +- El orden de los atributos en los ficheros generados lo decide el `Transformer`; no tiene significado en XML. + +## Ejecución + +1. Colocar `informacion-IES_v2.xml` en la raíz del proyecto y comprobar que `application.properties` está en el classpath. +2. Ejecutar `AppPrincipal`. +3. Elegir una opción del menú (1-4) o `0` para salir. +4. Los ficheros se generan en el directorio de trabajo del proyecto. \ No newline at end of file diff --git a/config/application.properties b/config/application.properties new file mode 100644 index 0000000..518b391 --- /dev/null +++ b/config/application.properties @@ -0,0 +1,2 @@ +# información de IES +ies.ruta.fichero=informacion-IES_v2.xml \ No newline at end of file diff --git a/info_IES.xml b/info_IES.xml new file mode 100644 index 0000000..ba9401d --- /dev/null +++ b/info_IES.xml @@ -0,0 +1,4 @@ + + + IES Virgen de la Paloma + diff --git a/informacion-IES_v2.xml b/informacion-IES_v2.xml new file mode 100644 index 0000000..f36101d --- /dev/null +++ b/informacion-IES_v2.xml @@ -0,0 +1,369 @@ + + + + + IES Virgen de la Paloma + + + + Laboratorio de informática + 30 + + + + + Taller de Fundamentos de Hardware + 25 + + + + Taller de Automoción + 25 + + + + + + + + + DAM + Técnico Superior en Desarrollo de Aplicaciones Multiplataforma + + + + + + + + + Bases de datos + 205 + + + 90 + Entornos de desarrollo + + + 90 + Formación y orientación laboral + + + 140 + Lenguaje de marcas y sistemas de gestión de información + + + 270 + Programación + + + 205 + Sistemas informáticos + + + + + + Acceso a Datos + 120 + + + 120 + Diseño de interfaces + + + 65 + Empresa e iniciativa emprendedora + + + 80 + Programación de servicios y procesos + + + 80 + Programación multimedia y dispositivos móviles + + + 40 + Inglés técnico para grado superior + + + + + + + + + + + + DAW + Técnico Superior en Desarrollo de Aplicaciones Web + + + + + + + + Bases de datos + 205 + + + 90 + Entornos de desarrollo + + + 90 + Formación y orientación laboral + + + 140 + Lenguaje de marcas y sistemas de gestión de información + + + 270 + Programación + + + 205 + Sistemas informáticos + + + + + + + + Desarrollo web en entorno cliente + 115 + + + 180 + Desarrollo web en entorno servidor + + + 85 + Despliegue de aplicaciones web + + + 115 + Diseño de interfaces web + + + 30 + Proyecto de desarrollo de aplicaciones web + + + 40 + Inglés técnico para grado superior + + + 65 + Empresa e iniciativa emprendedora + + + + + + + + + + ASIR + Técnico Superior en Administración de Sistemas Informáticos en Red + + + + + + + Implantación de sistemas operativos + 231 + + + Planificación y administración de redes + 231 + + + Fundamentos de hardware + 165 + + + Gestión de bases de datos + 198 + + + Lenguajes de marcas y sistemas de gestión de información + 132 + + + Formación y orientación laboral + 99 + + + + + + Administración de sistemas operativos + 105 + + + Servicios de red e Internet + 126 + + + Implantación de aplicaciones web + 84 + + + Administración de sistemas gestores de bases de datos + 84 + + + Seguridad y alta disponibilidad + 126 + + + Empresa e iniciativa emprendedora + 66 + + + Formación en centros de trabajo + 370 + + + Proyecto de Administración de Sistemas Informáticos en Red + 40 + + + + + + + + + + + + SMR + Técnico en Sistemas Microinformáticos y Redes + + + + + + + Montaje y mantenimiento de equipos + 198 + + + Sistemas operativos monopuesto + 198 + + + Aplicaciones ofimáticas + 231 + + + Redes locales + 198 + + + Formación y orientación laboral + 99 + + + + + + Sistemas operativos en red + 168 + + + Seguridad informática + 105 + + + Servicios en red + 168 + + + Aplicaciones web + 105 + + + Empresa e iniciativa emprendedora + 66 + + + Formación en centros de trabajo + 370 + + + + + + + + + + + + + + INFOBAS + Título Profesional Básico en Informática de Oficina + + + + + Aplicaciones básicas de ofimática + 160 + + + Montaje y mantenimiento de sistemas y componentes informáticos + 160 + + + Ciencias aplicadas I + 160 + + + Comunicación y sociedad I + 160 + + + Tutorización y orientación + 80 + + + + + + + + Tratamiento de textos y presentación de información + 160 + + + Operaciones auxiliares de mantenimiento de sistemas informáticos + 160 + + + Ciencias aplicadas II + 160 + + + Comunicación y sociedad II + 160 + + + Formación en centros de trabajo + 260 + + + + + + \ No newline at end of file diff --git a/informe_ciclos_IES.txt b/informe_ciclos_IES.txt new file mode 100644 index 0000000..437079a --- /dev/null +++ b/informe_ciclos_IES.txt @@ -0,0 +1,38 @@ +INFORME DE CICLOS FORMATIVOS +IES Virgen de la Paloma +======================================== + +Código: IFC05 +Nombre corto: DAM +Observaciones: +- Observación: revisar la distribución horaria de los módulos +- Este comentario está dentro de un ciclo, pero no es hijo directo del mismo + +---------------------------------------- +Código: IFC06 +Nombre corto: DAW +Observaciones: +- Observación: reforzar las actividades prácticas de desarrollo backend +- Observación: comprobar la disponibilidad de empresas para la FFE + +---------------------------------------- +Código: IFC03 +Nombre corto: ASIR +Observaciones: +- Observación: revisar los recursos disponibles para prácticas de redes + +---------------------------------------- +Código: IFC02 +Nombre corto: SMR +Observaciones: +- Observación: actualizar el inventario de equipos informáticos + +---------------------------------------- +Código: FB01 +Nombre corto: INFOBAS +Observaciones: +- Este ciclo requiere especial atención a las necesidades del alumnado +- Observación: coordinar las actividades prácticas con los tutores + +======================================== +Fin del informe diff --git a/modulos1_ciclo_DAM.xml b/modulos1_ciclo_DAM.xml new file mode 100644 index 0000000..d86c564 --- /dev/null +++ b/modulos1_ciclo_DAM.xml @@ -0,0 +1,27 @@ + + + + DAM + Técnico Superior en Desarrollo de Aplicaciones Multiplataforma + + + Bases de datos + + + Entornos de desarrollo + + + Formación y orientación laboral + + + Lenguaje de marcas y sistemas de gestión de información + + + Programación + + + Sistemas informáticos + + + + diff --git a/resumen_ciclos_IES.xml b/resumen_ciclos_IES.xml new file mode 100644 index 0000000..15f638c --- /dev/null +++ b/resumen_ciclos_IES.xml @@ -0,0 +1,11 @@ + + + IES Virgen de la Paloma + + DAM + DAW + ASIR + SMR + INFOBAS + + diff --git a/src/org/palomafp/aadd/dta/AppPrincipal.java b/src/org/palomafp/aadd/dta/AppPrincipal.java new file mode 100644 index 0000000..64b2f90 --- /dev/null +++ b/src/org/palomafp/aadd/dta/AppPrincipal.java @@ -0,0 +1,302 @@ +package org.palomafp.aadd.dta; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Scanner; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.transform.OutputKeys; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; + +import org.palomafp.aadd.dta.gestores.GestorConfiguracion; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +public class AppPrincipal { + + public static void main(String[] args) { + + try (Scanner sc = new Scanner(System.in)) { + + // Obtener la ruta del fichero desde application.properties a un objeto de la interfaz Path + Path ruta = GestorConfiguracion.getRutaFicheroIes(); + + // Cargar el fichero XML con DOM y recogerlo en un Document + Document doc = cargarXml(ruta); + + int opcion; + + do { + + mostrarMenu(); + + try { + opcion = Integer.parseInt(sc.nextLine().trim()); + } catch (NumberFormatException e) { + opcion = -1; + } + + try { + switch (opcion) { + case 1 -> crearFicheroInformacionInstituto(doc); + case 2 -> crearFicheroResumenCiclos(doc); + case 3 -> crearFicheroModulosDam(doc); + case 4 -> crearFicheroInformeCiclos(doc); + case 0 -> System.out.println("Saliendo del programa..."); + default -> System.out.println("Opción inválida: (0-4)"); + } + } catch (Exception e) { + System.err.println("Error en la opción " + opcion + ": " + e); + } + + } while (opcion != 0); + + + } catch (Exception e) { + System.err.println("Error al iniciar el programa: " + e); + } + } + + private static void crearFicheroInformacionInstituto(Document doc) throws Exception { + + // 1. Buscar el que es hijo directo de + String nombreIes = obtenerNombreIes(doc); + + // 2. Crear un documento nuevo + Document nuevo = DocumentBuilderFactory.newInstance() + .newDocumentBuilder().newDocument(); + + // 3. Construir el árbol + Element instituto = nuevo.createElement("instituto"); + nuevo.appendChild(instituto); + + Element nombre = nuevo.createElement("nombre"); + nombre.setTextContent(nombreIes); + instituto.appendChild(nombre); + + // 4. Guardar + guardarXml(nuevo, Path.of("info_IES.xml")); + System.out.println("Fichero info_IES.xml creado correctamente."); + } + + private static void crearFicheroResumenCiclos(Document doc) throws Exception { + + // 1. Datos del instituto: atributo tipo y nombre (hijo directo de la raíz) + String nombreIes = obtenerNombreIes(doc); + String tipo = doc.getDocumentElement().getAttribute("tipo"); + + // 2. Crear documento nuevo + Document nuevo = DocumentBuilderFactory.newInstance() + .newDocumentBuilder().newDocument(); + + Element resumen = nuevo.createElement("resumen"); + nuevo.appendChild(resumen); + + Element instituto = nuevo.createElement("instituto"); + instituto.setAttribute("tipo", tipo); + instituto.setTextContent(nombreIes); + resumen.appendChild(instituto); + + Element ciclos = nuevo.createElement("ciclos"); + resumen.appendChild(ciclos); + + // 3. Recorrer los ciclos del original + NodeList ciclosOrigen = doc.getElementsByTagName("ciclo"); + for (int i = 0; i < ciclosOrigen.getLength(); i++) { + Element cicloOrigen = (Element) ciclosOrigen.item(i); + + String codigo = cicloOrigen.getAttribute("codigo"); + String nombreCorto = cicloOrigen.getElementsByTagName("nombre_corto") + .item(0).getTextContent().trim(); + + Element ciclo = nuevo.createElement("ciclo"); + ciclo.setAttribute("codigo", codigo); + ciclo.setTextContent(nombreCorto); + ciclos.appendChild(ciclo); + } + + // 4. Guardar + guardarXml(nuevo, Path.of("resumen_ciclos_IES.xml")); + System.out.println("Fichero resumen_ciclos_IES.xml creado correctamente."); + } + + private static void crearFicheroModulosDam(Document doc) throws Exception { + + // 1. Nombre del IES (hijo directo de la raíz) + String nombreIes = obtenerNombreIes(doc); + + // 2. Localizar el ciclo DAM + Element cicloDam = null; + NodeList ciclosOrigen = doc.getElementsByTagName("ciclo"); + for (int i = 0; i < ciclosOrigen.getLength(); i++) { + Element c = (Element) ciclosOrigen.item(i); + String corto = c.getElementsByTagName("nombre_corto").item(0).getTextContent().trim(); + if (corto.equals("DAM")) { + cicloDam = c; + break; + } + } + if (cicloDam == null) { + System.out.println("No se ha encontrado el ciclo DAM."); + return; + } + + // 3. Documento nuevo + Document nuevo = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); + + Element ies = nuevo.createElement("ies"); + ies.setAttribute("nombre", nombreIes); + ies.setAttribute("tipo", doc.getDocumentElement().getAttribute("tipo")); + nuevo.appendChild(ies); + + Element ciclo = nuevo.createElement("ciclo"); + ciclo.setAttribute("codigo", cicloDam.getAttribute("codigo")); + ciclo.setAttribute("nivel", cicloDam.getAttribute("nivel")); + ies.appendChild(ciclo); + + Element nombreCorto = nuevo.createElement("nombre_corto"); + nombreCorto.setTextContent(cicloDam.getElementsByTagName("nombre_corto").item(0).getTextContent().trim()); + ciclo.appendChild(nombreCorto); + + Element nombreLargo = nuevo.createElement("nombre_largo"); + nombreLargo.setTextContent(cicloDam.getElementsByTagName("nombre_largo").item(0).getTextContent().trim()); + ciclo.appendChild(nombreLargo); + + // 4. Curso 1 y sus módulos + NodeList cursosOrigen = cicloDam.getElementsByTagName("curso"); + for (int i = 0; i < cursosOrigen.getLength(); i++) { + Element cursoOrigen = (Element) cursosOrigen.item(i); + if (!cursoOrigen.getAttribute("numero").equals("1")) { + continue; + } + + Element curso = nuevo.createElement("curso"); + curso.setAttribute("num", "1"); + ciclo.appendChild(curso); + + NodeList modulosOrigen = cursoOrigen.getElementsByTagName("modulo"); + for (int j = 0; j < modulosOrigen.getLength(); j++) { + Element moduloOrigen = (Element) modulosOrigen.item(j); + + Element modulo = nuevo.createElement("modulo"); + modulo.setAttribute("id", moduloOrigen.getAttribute("id")); + modulo.setAttribute("ref", moduloOrigen.getAttribute("ref")); + modulo.setAttribute("numero_horas", + moduloOrigen.getElementsByTagName("numerohoras").item(0).getTextContent().trim()); + + Element titulo = nuevo.createElement("titulo"); + titulo.setTextContent( + moduloOrigen.getElementsByTagName("titulo").item(0).getTextContent().trim()); + modulo.appendChild(titulo); + + curso.appendChild(modulo); + } + break; + } + + // 5. Guardar + guardarXml(nuevo, Path.of("modulos1_ciclo_DAM.xml")); + System.out.println("Fichero modulos1_ciclo_DAM.xml creado correctamente."); + } + + private static void crearFicheroInformeCiclos(Document doc) throws Exception { + + // 1. Nombre del IES (hijo directo de la raíz) + String nombreIes = obtenerNombreIes(doc); + + String igual = "=".repeat(40); + String guiones = "-".repeat(40); + String salto = System.lineSeparator(); + + StringBuilder sb = new StringBuilder(); + + // 2. Cabecera + sb.append("INFORME DE CICLOS FORMATIVOS").append(salto); + sb.append(nombreIes).append(salto); + sb.append(igual).append(salto); + + // 3. Ciclos + NodeList ciclos = doc.getElementsByTagName("ciclo"); + for (int i = 0; i < ciclos.getLength(); i++) { + Element ciclo = (Element) ciclos.item(i); + + if (i > 0) { + sb.append(guiones).append(salto); + } else { + sb.append(salto); + } + + sb.append("Código: ").append(ciclo.getAttribute("codigo")).append(salto); + sb.append("Nombre corto: ") + .append(ciclo.getElementsByTagName("nombre_corto").item(0).getTextContent().trim()) + .append(salto); + sb.append("Observaciones:").append(salto); + + // Solo comentarios hijos directos del ciclo + NodeList hijos = ciclo.getChildNodes(); + for (int j = 0; j < hijos.getLength(); j++) { + Node h = hijos.item(j); + if (h.getNodeType() == Node.COMMENT_NODE) { + sb.append("- ").append(h.getNodeValue().trim()).append(salto); + } + } + sb.append(salto); + } + + // 4. Pie + sb.append(igual).append(salto); + sb.append("Fin del informe").append(salto); + + // 5. Guardar (UTF-8 por defecto en writeString) + Files.writeString(Path.of("informe_ciclos_IES.txt"), sb.toString()); + + System.out.println("Fichero informe_ciclos_IES.txt creado correctamente."); + } + + private static void mostrarMenu() { + System.out.println("---- MENÚ ----"); + System.out.println("1. Crear fichero 'info_IES.xml'"); + System.out.println("2. Crear fichero 'resumen_ciclos_IES.xml'"); + System.out.println("3. Crear fichero 'modulos1_ciclo_DAM.xml'"); + System.out.println("4. Crear fichero 'informe_ciclos_IES.txt'"); + System.out.println("0. Salir"); + System.out.print("Opción: "); + } + + private static Document cargarXml(Path ruta) throws Exception { + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + DocumentBuilder builder = factory.newDocumentBuilder(); + Document doc = builder.parse(ruta.toFile()); + doc.getDocumentElement().normalize(); + return doc; + } + + private static void guardarXml(Document doc, Path destino) throws Exception { + doc.setXmlStandalone(true); // quita standalone="no" + + Transformer t = TransformerFactory.newInstance().newTransformer(); + t.setOutputProperty(OutputKeys.INDENT, "yes"); + t.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); + t.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); + t.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, "yes"); + t.transform(new DOMSource(doc), new StreamResult(destino.toFile())); + } + + private static String obtenerNombreIes(Document doc) { + NodeList hijosRaiz = doc.getDocumentElement().getChildNodes(); + for (int i = 0; i < hijosRaiz.getLength(); i++) { + Node n = hijosRaiz.item(i); + if (n.getNodeType() == Node.ELEMENT_NODE && n.getNodeName().equals("nombre")) { + return n.getTextContent().trim(); + } + } + return ""; + } + +} diff --git a/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java b/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java new file mode 100644 index 0000000..254f857 --- /dev/null +++ b/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java @@ -0,0 +1,40 @@ +package org.palomafp.aadd.dta.gestores; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.Properties; + +public class GestorConfiguracion { + + private static final String RUTA_FICHERO_CONFIGURACION = "application.properties"; + private static final Properties PROPIEDADES_CONFIGURACION = new Properties(); + + private GestorConfiguracion() {} + + static { + try (var in = GestorConfiguracion.class.getClassLoader() + .getResourceAsStream(RUTA_FICHERO_CONFIGURACION)) { + + if (in == null) { + throw new IOException("No se ha encontrado el fichero " + RUTA_FICHERO_CONFIGURACION); + } + + PROPIEDADES_CONFIGURACION.load(in); + + } catch (IOException e) { + throw new RuntimeException("No se ha podido cargar el fichero de configuración", e); + } + } + + public static Path getRutaFicheroIes() { + + String rutaStr = PROPIEDADES_CONFIGURACION.getProperty("ies.ruta.fichero"); + + if (rutaStr == null) { + throw new IllegalStateException("Falta la propiedad 'ies.ruta.fichero' en " + RUTA_FICHERO_CONFIGURACION); + } + + return Path.of(rutaStr); + } + +}