commit 4e52b78c69f4fbdfa9621586a9c87d2dbe3ca2e3 Author: dta Date: Wed Nov 18 14:12:56 2026 +0100 first commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..381fc2a --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +.settings/ +bin/ +target/ +.classpath +.project +*.class \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..993d15f --- /dev/null +++ b/README.md @@ -0,0 +1,297 @@ +# aadd_conect05: Procesamiento de ficheros JSON y XML con Jackson, JDBC, patrón DAO y Service Layer (MySQL) + +## Descripción + +Proyecto en Java que procesa dos ficheros (un JSON de familias profesionales y un XML de ciclos formativos) y vuelca su información en la base de datos `Formacion_FP`, administrada por MySQL. Se utiliza el API JDBC, el patrón DAO (solo para el acceso a la base de datos) y el patrón Service Layer. Todas las sentencias SQL se ejecutan con `PreparedStatement` y están declaradas como constantes `private static final`. + +Es la evolución de `aadd_conect04` con tres novedades: + +- **Procesamiento con Jackson**: el fichero de familias profesionales pasa de CSV a **JSON** (`ObjectMapper`) y el de ciclos formativos se lee con **Jackson XML** (`XmlMapper`) en lugar del paquete DOM de Java. En ambos casos se recorre el contenido con la clase `JsonNode`. +- **Una clase de servicio por entidad**: `FamiliaProfesionalService` y `CicloFormativoService`, que aplican las reglas de negocio y gestionan la conexión. +- **Procesadores de ficheros**: `ProcesadorFicheroJSON` y `ProcesadorFicheroXML` leen los ficheros y llaman a los servicios. + +Los datos de conexión y las rutas de los ficheros no están escritos en el código: se leen del fichero `application.properties` a través de la clase `GestorConfiguracion`. + +## Estructura del proyecto + +- `aadd_conect05/` + - `src/org/palomafp/aadd/dta/` + - `AppPrincipal.java`: clase principal que lanza el tratamiento de los dos ficheros + - `model/` + - `FamiliaProfesional.java`: clase del modelo (una familia profesional) + - `TipoFormacion.java`: clase del modelo (un tipo de formación) + - `CicloFormativo.java`: clase del modelo (un ciclo formativo, con su familia y su tipo) + - `dao/` + - `IFamiliaProfesionalDAO.java`: interfaz del DAO de familias profesionales + - `ITipoFormacionDAO.java`: interfaz del DAO de tipos de formación + - `ICicloFormativoDAO.java`: interfaz del DAO de ciclos formativos + - `impl/` + - `FamiliaProfesionalDaoJDBC.java`: implementación JDBC con `PreparedStatement` + - `TipoFormacionDaoJDBC.java`: implementación JDBC con `PreparedStatement` + - `CicloFormativoDaoJDBC.java`: implementación JDBC con `PreparedStatement` + - `service/` + - `FamiliaProfesionalService.java`: casos de uso de familias profesionales + - `CicloFormativoService.java`: casos de uso de ciclos formativos + - `util/` + - `ProcesadorFicheroJSON.java`: lee el JSON de familias con Jackson y llama al servicio + - `ProcesadorFicheroXML.java`: lee el XML de ciclos con Jackson y llama al servicio + - `excepciones/` + - `FormacionException.java`: excepción de aplicación (checked) + - `gestores/` + - `GestorConfiguracion.java`: carga `application.properties` y expone sus valores + - `GestorConexionBBDD.java`: crea las conexiones a la base de datos + - `config/` + - `application.properties`: configuración (conexión a la BBDD y rutas de los ficheros) + - `ficheros/` + - `familias_pro.json`: familias profesionales a procesar + - `catalogo_formacion.xml`: ciclos formativos a procesar + - `Formacion_FP.sql`: script de creación de la base de datos + - `pom.xml` + - `README.md` + +## Dependencias (Maven) + +| Dependencia | Uso | +|---|---| +| `mysql-connector-j` | Driver JDBC de MySQL | +| `jackson-databind` | `ObjectMapper` y `JsonNode` (lectura del JSON) | +| `jackson-dataformat-xml` | `XmlMapper` (lectura del XML) | + +## Base de datos + +El script `Formacion_FP.sql` crea la base de datos `Formacion_FP` con tres tablas: + +| Tabla | Columnas | +|---|---| +| `T_FAMILIA_PROFESIONAL` | `codigo` (PK), `nombre` | +| `T_TIPO_FORMACION` | `codigo` (PK), `nombre_corto`, `nombre_largo` | +| `T_CICLO_FORMATIVO` | `codigo` (PK), `nombre_corto`, `nombre_largo`, `horas_duracion`, `codigo_familia` (FK a `T_FAMILIA_PROFESIONAL`), `codigo_tipo_formacion` (FK a `T_TIPO_FORMACION`) | + +Tras ejecutar el script, la base de datos contiene la familia `ADG` (con un nombre distinto al del JSON) y los cuatro tipos de formación: `CFGB`, `CFGM`, `CFGS` y `CE`. No contiene ciclos formativos. + +## Origen y destino de los datos + +| Información | Origen | Destino | +|---|---|---| +| Familias profesionales | Fichero JSON | `T_FAMILIA_PROFESIONAL` | +| Ciclos formativos | Fichero XML | `T_CICLO_FORMATIVO` | +| Tipos de formación | Base de datos (`T_TIPO_FORMACION`) | Solo se consulta | + +## Arquitectura en capas + +``` +AppPrincipal → Procesador (util) → Service → DAO → Base de datos + ↓ + Ficheros (JSON y XML) con Jackson +``` + +| Capa | Responsabilidad | +|---|---| +| `AppPrincipal` | Decide qué se ejecuta y captura la excepción de aplicación. No conoce conexiones, SQL ni ficheros | +| Procesador | Lee el fichero con Jackson, convierte cada nodo en un objeto del modelo y llama al servicio | +| Servicio | Representa los casos de uso. Abre y cierra la conexión y aplica las reglas de negocio | +| DAO | Ejecuta las sentencias SQL de una tabla. Recibe la conexión por constructor y no la cierra | +| Modelo | Clases que representan una fila de cada tabla | + +El patrón DAO se usa **únicamente para el acceso a la base de datos**. Los ficheros se leen con las clases procesadoras. + +## Componentes principales + +- **`FamiliaProfesional`, `TipoFormacion` y `CicloFormativo`**: clases del modelo con sus atributos, constructores, getters, setters y `toString()`. `CicloFormativo` guarda un objeto `FamiliaProfesional` y un objeto `TipoFormacion`, no sus códigos. +- **`IFamiliaProfesionalDAO`, `ITipoFormacionDAO` e `ICicloFormativoDAO`**: interfaces con las operaciones de acceso a datos. Todos sus métodos declaran `throws FormacionException`. +- **`FamiliaProfesionalDaoJDBC`, `TipoFormacionDaoJDBC` y `CicloFormativoDaoJDBC`**: implementaciones JDBC. Reciben la `Connection` por constructor y la guardan en un atributo `private final`. Cada método crea un `PreparedStatement` con `try-with-resources`. Las `SQLException` se capturan y se relanzan envueltas en `FormacionException`, conservando la causa original. +- **`FamiliaProfesionalService` y `CicloFormativoService`**: abren la conexión con `try-with-resources` (se cierra sola), crean los DAO pasándosela y aplican la lógica de cada caso de uso. Los fallos al obtener o cerrar la conexión se convierten en `FormacionException`. +- **`ProcesadorFicheroJSON` y `ProcesadorFicheroXML`**: leen el fichero con `ObjectMapper` y `XmlMapper` respectivamente, recorren los nodos `JsonNode` y construyen los objetos del modelo. Obtienen la ruta de `GestorConfiguracion`. +- **`FormacionException`**: excepción checked con dos constructores (`mensaje` y `mensaje, causa`). Es la excepción de aplicación que conocen las capas superiores. +- **`GestorConfiguracion`**: clase de utilidad (constructor privado) que carga `application.properties` desde el classpath en un bloque `static` y ofrece un getter por propiedad. Las rutas de los ficheros se devuelven como `Path`. +- **`GestorConexionBBDD`**: clase de utilidad que monta la URL (`sgbd.conexion.url` + `bbdd.nombre`) y devuelve una `Connection` nueva. Quien la recibe es responsable de cerrarla. +- **`AppPrincipal`**: crea los dos procesadores y los ejecuta en orden. Captura `FormacionException` en un único punto. + +## Configuración + +Fichero `application.properties`: + +```properties +# Información relativa a la base de datos +sgbd.conexion.url=jdbc:mysql://192.168.1.62:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=myuser +bbdd.clave=mypass + +# Información relativa a familias profesionales +familiaprofesional.ruta.fichero=ficheros/familias_pro.json + +# Información relativa a ciclos formativos +cicloformativo.ruta.fichero=ficheros/catalogo_formacion.xml +``` + +- La URL de conexión se forma concatenando `sgbd.conexion.url` y `bbdd.nombre`, es decir, `jdbc:mysql://192.168.1.62:3306/Formacion_FP`. Para ejecutar el proyecto en otro equipo hay que cambiar la IP (o usar `localhost`) y las credenciales. +- Las rutas de los ficheros son relativas al directorio de ejecución, por lo que el programa debe lanzarse desde la raíz del proyecto. + +## Ficheros de entrada + +### JSON de familias profesionales + +Fichero cuya raíz es un array de objetos: + +```json +[ + { + "id_registro": 1, + "fecha_carga": "2026-01-15", + "cod_tipo_fam": "ADG", + "nombre_tf": "Administración y Gestión" + } +] +``` + +Solo interesan los campos `cod_tipo_fam` y `nombre_tf`. Los demás se ignoran. Los valores se leen con `path(...).asText().trim()`. + +| JSON | Columna | +|---|---| +| `cod_tipo_fam` | `codigo` | +| `nombre_tf` | `nombre` | + +### XML de ciclos formativos + +Los elementos `ciclo` cuelgan de `catalogo_formacion/informacion_adicional/ciclos_formativos`. Jackson descarta el elemento raíz, por lo que se navega con `path("informacion_adicional").path("ciclos_formativos").path("ciclo")`. El atributo `cod_cf` aparece como un campo más del nodo. Los elementos `fecha_actualizacion` y `observaciones` se ignoran. Correspondencia con la tabla `T_CICLO_FORMATIVO`: + +| XML | Columna | +|---|---| +| atributo `cod_cf` | `codigo` | +| `nomb_corto` | `nombre_corto` | +| `nombrelargo` | `nombre_largo` | +| `num_horas_duracion` | `horas_duracion` | +| `codigo_familia` | `codigo_familia` | +| `codigo_tipoestudio` | `codigo_tipo_formacion` | + +## Métodos de los DAO + +| DAO | Método | Sentencia SQL | Devuelve | +|---|---|---|---| +| `IFamiliaProfesionalDAO` | `existe(String codigo)` | `SELECT 1 ... WHERE codigo = ?` | `true` si existe | +| `IFamiliaProfesionalDAO` | `insertar(familia)` | `INSERT` con todos los campos | nada | +| `IFamiliaProfesionalDAO` | `actualizar(familia)` | `UPDATE` del nombre por código | nada | +| `ITipoFormacionDAO` | `existe(String codigo)` | `SELECT 1 ... WHERE codigo = ?` | `true` si existe | +| `ICicloFormativoDAO` | `insertar(ciclo)` | `INSERT` con todos los campos | nada | + +## Métodos de los servicios + +| Servicio | Método | Acción | +|---|---|---| +| `FamiliaProfesionalService` | `existeFamiliaProfesional(codigo)` | Comprueba si la familia existe en la BBDD | +| `FamiliaProfesionalService` | `insertarFamiliaProfesional(familia)` | Inserta la familia | +| `FamiliaProfesionalService` | `actualizarFamiliaProfesional(familia)` | Actualiza el nombre de la familia | +| `CicloFormativoService` | `insertarCicloFormativo(ciclo)` | Inserta el ciclo solo si existen su familia profesional y su tipo de formación; si no, lanza `FormacionException` | + +### Reglas del tratamiento + +**Familias (`ProcesadorFicheroJSON`)** + +1. Lee el JSON y recorre el array de nodos. +2. Por cada familia, el servicio comprueba si existe en la BBDD. +3. Si existe, actualiza su nombre; si no, la inserta. +4. Cualquier error (fichero no encontrado, JSON mal formado, fallo SQL) se propaga hasta `AppPrincipal`. + +**Ciclos (`ProcesadorFicheroXML`)** + +1. Lee el XML y recorre los nodos `ciclo`. +2. Por cada ciclo crea un `CicloFormativo` con objetos `FamiliaProfesional` y `TipoFormacion` que solo tienen el código. +3. `CicloFormativoService` comprueba que existen la familia y el tipo en la BBDD. +4. Si alguno no existe, lanza `FormacionException` con un mensaje descriptivo. El procesador lo captura **ciclo a ciclo**, informa del error y continúa con el siguiente, de modo que un ciclo erróneo no detiene el tratamiento de los demás. +5. Si existen ambos, inserta el ciclo. + +## Métodos de `AppPrincipal` + +| Método | Acción | +|---|---| +| `main(String[] args)` | Crea y ejecuta `ProcesadorFicheroJSON` (familias) y después `ProcesadorFicheroXML` (ciclos). Captura `FormacionException` en un único punto | + +**El orden es obligatorio**: las familias `IFC`, `TMV` y `SAN` solo existen en la BBDD después de procesar el JSON. Si se procesaran antes los ciclos, saldrían menos de 10. + +## Resultado del procesamiento + +### Familias profesionales + +| Código | Acción | Motivo | +|---|---|---| +| `ADG` | Actualizada | Ya existía en la BBDD: su nombre pasa a `Administración y Gestión` | +| `IFC` | Insertada | No existía | +| `TMV` | Insertada | No existía | +| `SAN` | Insertada | No existía | + +### Ciclos formativos + +El XML contiene 14 ciclos, de los que se insertan 10: + +| Ciclo | Familia | Tipo | ¿Se inserta? | +|---|---|---|---| +| `ADGB01` | `ADG` | `CFBA` | No: el tipo de formación no existe | +| `ADGM01` | `ADG` | `CFGM` | Sí | +| `ADGS01` | `ADG` | `CFGS` | Sí | +| `IFCB01` | `IFE` | `CFGB` | No: la familia profesional no existe | +| `IFCM01` | `IFC` | `CFGM` | Sí | +| `IFCS02` | `IFC` | `CFGS` | Sí | +| `IFCS03` | `IFC` | `CFGS` | Sí | +| `IFCES03` | `IFC` | `CFE` | No: el tipo de formación no existe | +| `TMVB01` | `TMV` | `CFGB` | Sí | +| `TMVM01` | `TMV` | `CFGM` | Sí | +| `TMVS01` | `TMV` | `CFGS` | Sí | +| `TMVES02` | `TMV` | `CE` | Sí | +| `SANM01` | `SAN` | `CFME` | No: el tipo de formación no existe | +| `SANS01` | `SAN` | `CFGS` | Sí | + +## Salida por consola + +Salida obtenida al ejecutar `AppPrincipal` con la base de datos recién creada: + +``` +Familia profesional actualizada: ADG +Familia profesional insertada: IFC +Familia profesional insertada: TMV +Familia profesional insertada: SAN +ERROR en el ciclo ADGB01: No existe el tipo de formación CFBA del ciclo ADGB01 +Ciclo formativo insertado: ADGM01 +Ciclo formativo insertado: ADGS01 +ERROR en el ciclo IFCB01: No existe la familia profesional IFE del ciclo IFCB01 +Ciclo formativo insertado: IFCM01 +Ciclo formativo insertado: IFCS02 +Ciclo formativo insertado: IFCS03 +ERROR en el ciclo IFCES03: No existe el tipo de formación CFE del ciclo IFCES03 +Ciclo formativo insertado: TMVB01 +Ciclo formativo insertado: TMVM01 +Ciclo formativo insertado: TMVS01 +Ciclo formativo insertado: TMVES02 +ERROR en el ciclo SANM01: No existe el tipo de formación CFME del ciclo SANM01 +Ciclo formativo insertado: SANS01 +Ciclos formativos insertados: 10 de 14 +``` + +## Aspectos a tener en cuenta + +- Se asume que **no hay ciclos formativos** en la base de datos. Si se ejecuta `AppPrincipal` dos veces seguidas, los ciclos ya insertados darán error de clave duplicada. Para repetir la prueba hay que volver a ejecutar `Formacion_FP.sql`. +- Las familias sí se pueden procesar varias veces: si ya existen, solo se actualiza el nombre. +- Los DAO no abren ni cierran la conexión; lo hacen los servicios. `AppPrincipal` no conoce JDBC ni los ficheros. +- Cada método de servicio abre y cierra su propia conexión; no hay transacción compartida entre operaciones. +- Hay una única excepción de aplicación, `FormacionException`, que se propaga desde los DAO, los servicios y los procesadores hasta `AppPrincipal`. +- La carpeta `config` está configurada como source folder en Eclipse, por lo que el properties está en el classpath. + +## Ejecución + +1. Ejecutar `Formacion_FP.sql` en un cliente MySQL (por ejemplo DBeaver) para crear la base de datos. +2. Crear el usuario con permisos sobre la base de datos: + ```sql + CREATE USER 'myuser'@'%' IDENTIFIED BY 'mypass'; + GRANT ALL PRIVILEGES ON Formacion_FP.* TO 'myuser'@'%'; + FLUSH PRIVILEGES; + ``` +3. Ajustar `config/application.properties` a la IP y credenciales del servidor MySQL. +4. Comprobar que `ficheros/` contiene `familias_pro.json` y `catalogo_formacion.xml`. +5. Actualizar las dependencias Maven (*Maven → Update Project* en Eclipse). +6. Ejecutar `AppPrincipal` como aplicación Java, desde la raíz del proyecto. +7. Comprobar en la consola la salida (`Ciclos formativos insertados: 10 de 14`). +8. Comprobar en la base de datos: + ```sql + SELECT * FROM T_FAMILIA_PROFESIONAL; -- ADG (nombre actualizado), IFC, SAN y TMV + SELECT COUNT(*) FROM T_CICLO_FORMATIVO; -- 10 + ``` \ No newline at end of file diff --git a/config/application.properties b/config/application.properties new file mode 100644 index 0000000..ab0aa62 --- /dev/null +++ b/config/application.properties @@ -0,0 +1,12 @@ +# Información relativa a la base de datos +sgbd.conexion.url=jdbc:mysql://192.168.1.62:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=myuser +bbdd.clave=mypass + +# Información relativa a familias profesionales +familiaprofesional.ruta.fichero=ficheros/familias_pro.json +familiaprofesional.csv.separador=| + +# Información relativa a ciclos formativos +cicloformativo.ruta.fichero=ficheros/catalogo_formacion.xml \ No newline at end of file diff --git a/ficheros/catalogo_formacion.xml b/ficheros/catalogo_formacion.xml new file mode 100644 index 0000000..63195a4 --- /dev/null +++ b/ficheros/catalogo_formacion.xml @@ -0,0 +1,170 @@ + + + + + + Ministerio de Educación + 2026-11-01 + 1.0 + + Catálogo informativo de enseñanzas de Formación Profesional. + + + + + + + + 2026-01-15 + Registro de administración. + Servicios Administrativos + Título Profesional Básico en Servicios Administrativos + 2000 + ADG + CFBA + + + + 2026-02-10 + Formación de grado medio. + Gestión Administrativa + Técnico en Gestión Administrativa + 2000 + ADG + CFGM + + + + 2026-02-15 + Estudios superiores de administración. + Administración y Finanzas + Técnico Superior en Administración y Finanzas + 2000 + ADG + CFGS + + + + + + + 2026-01-20 + Formación inicial en informática. + Informática y Comunicaciones + Título Profesional Básico en Informática y Comunicaciones + 2000 + IFE + CFGB + + + + 2026-01-25 + Redes y sistemas informáticos. + Sistemas Microinformáticos y Redes + Técnico en Sistemas Microinformáticos y Redes + 2000 + IFC + CFGM + + + + 2026-02-01 + Programación de aplicaciones multiplataforma. + Desarrollo de Aplicaciones Multiplataforma + Técnico Superior en Desarrollo de Aplicaciones Multiplataforma + 2000 + IFC + CFGS + + + + 2026-02-05 + Desarrollo de aplicaciones web. + Desarrollo de Aplicaciones Web + Técnico Superior en Desarrollo de Aplicaciones Web + 2000 + IFC + CFGS + + + + 2026-03-01 + Especialización tecnológica. + Inteligencia Artificial y Big Data + Curso de Especialización en Inteligencia Artificial y Big Data + 600 + IFC + CFE + + + + + + + 2026-01-18 + Formación básica en mantenimiento. + Mantenimiento de Vehículos + Título Profesional Básico en Mantenimiento de Vehículos + 2000 + TMV + CFGB + + + + 2026-02-12 + Especialidad en electromecánica. + Electromecánica de Vehículos Automóviles + Técnico en Electromecánica de Vehículos Automóviles + 2000 + TMV + CFGM + + + + 2026-02-20 + Formación superior en automoción. + Automoción + Técnico Superior en Automoción + 2000 + TMV + CFGS + + + + 2026-03-05 + Especialización en aeronaves no tripuladas. + Inspección Técnica y Peritación + Curso de Especialización en Aeronaves pilotadas de forma remota-Drones + 600 + TMV + CE + + + + + + + 2026-02-08 + Formación sanitaria de grado medio. + Farmacia y Parafarmacia + Técnico en Farmacia y Parafarmacia + 2000 + SAN + CFME + + + + 2026-02-18 + Formación sanitaria de grado superior. + Laboratorio Clínico y Biomédico + Técnico Superior en Laboratorio Clínico y Biomédico + 2000 + SAN + CFGS + + + + + + + diff --git a/ficheros/familias_pro.json b/ficheros/familias_pro.json new file mode 100644 index 0000000..48c3ac1 --- /dev/null +++ b/ficheros/familias_pro.json @@ -0,0 +1,26 @@ +[ + { + "id_registro": 1, + "fecha_carga": "2026-01-15", + "cod_tipo_fam": "ADG", + "nombre_tf": "Administración y Gestión" + }, + { + "id_registro": 2, + "fecha_carga": "2026-01-15", + "cod_tipo_fam": "IFC", + "nombre_tf": "Informática y Comunicaciones" + }, + { + "id_registro": 3, + "fecha_carga": "2026-01-15", + "cod_tipo_fam": "TMV", + "nombre_tf": "Transporte y Mantenimiento de Vehículos" + }, + { + "id_registro": 4, + "fecha_carga": "2026-01-15", + "cod_tipo_fam": "SAN", + "nombre_tf": "Sanidad" + } +] \ No newline at end of file diff --git a/formacion_fp.sql b/formacion_fp.sql new file mode 100644 index 0000000..d45fc83 --- /dev/null +++ b/formacion_fp.sql @@ -0,0 +1,62 @@ +CREATE DATABASE IF NOT EXISTS Formacion_FP; +USE Formacion_FP; + +-- Eliminación de la estructura de datos. +DROP TABLE IF EXISTS T_CICLO_FORMATIVO; +DROP TABLE IF EXISTS T_TIPO_FORMACION; +DROP TABLE IF EXISTS T_FAMILIA_PROFESIONAL; + +-- ========================================= +-- TABLA: T_FAMILIA_PROFESIONAL +-- ========================================= +CREATE TABLE IF NOT EXISTS T_FAMILIA_PROFESIONAL ( + codigo CHAR(3) PRIMARY KEY, + nombre VARCHAR(100) NOT NULL +); + + +-- ========================================= +-- TABLA: T_TIPO_FORMACION +-- ========================================= +CREATE TABLE IF NOT EXISTS T_TIPO_FORMACION ( + codigo VARCHAR(4) PRIMARY KEY, + nombre_corto VARCHAR(50) NOT NULL, + nombre_largo VARCHAR(100) NOT NULL +); + + +-- ========================================= +-- TABLA: T_CICLO_FORMATIVO +-- ========================================= +CREATE TABLE IF NOT EXISTS T_CICLO_FORMATIVO ( + codigo VARCHAR(7) PRIMARY KEY, + nombre_corto VARCHAR(150) NOT NULL, + nombre_largo VARCHAR(200) NOT NULL, + horas_duracion INTEGER, + codigo_familia CHAR(3) NOT NULL, + codigo_tipo_formacion VARCHAR(4) NOT NULL, + + CONSTRAINT FK_CICLO_FAMILIA + FOREIGN KEY (codigo_familia) + REFERENCES T_FAMILIA_PROFESIONAL (codigo), + + CONSTRAINT FK_CICLO_TIPO + FOREIGN KEY (codigo_tipo_formacion) + REFERENCES T_TIPO_FORMACION (codigo) +); + +-- Tipos de familias profesionales + +INSERT INTO T_FAMILIA_PROFESIONAL +VALUES +('ADG', 'Gestión y Administración de Empresas '); + + +-- Tipos de formación (ejemplos de la notaciones) + +INSERT INTO T_TIPO_FORMACION +VALUES +('CFGB', 'Grado Básico', 'Grado Básico'), +('CFGM', 'Grado Medio', 'Grado Medio'), +('CFGS', 'Grado Superior', 'Grado Superior'), +('CE', 'Curso Especialización', 'Curso Especialización'); diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..56a3603 --- /dev/null +++ b/pom.xml @@ -0,0 +1,46 @@ + + 4.0.0 + aadd_conect05 + aadd_conect05 + 0.0.1-SNAPSHOT + + + + com.mysql + mysql-connector-j + 26.10.0 + compile + + + + com.fasterxml.jackson.core + jackson-databind + 2.23.0 + compile + + + + com.fasterxml.jackson.dataformat + jackson-dataformat-xml + 2.23.0 + compile + + + + src + + + maven-compiler-plugin + 3.13.0 + + 26 + + + + + \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/AppPrincipal.java b/src/org/palomafp/aadd/dta/AppPrincipal.java new file mode 100644 index 0000000..f4a89cc --- /dev/null +++ b/src/org/palomafp/aadd/dta/AppPrincipal.java @@ -0,0 +1,24 @@ +package org.palomafp.aadd.dta; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.util.ProcesadorFicheroJSON; +import org.palomafp.aadd.dta.util.ProcesadorFicheroXML; + +public class AppPrincipal { + + public static void main(String[] args) { + try { + // Realizar el tratamiento de familias profesionales desde el fichero JSON + ProcesadorFicheroJSON procesadorJSON = new ProcesadorFicheroJSON(); + procesadorJSON.realizarTratamientoFamiliasProfesionales(); + + // Realizar el tratamiento de ciclos formativos desde el fichero XML + ProcesadorFicheroXML procesadorXML = new ProcesadorFicheroXML(); + procesadorXML.realizarTratamientoCiclosFormativos(); + + } catch (FormacionException e) { + System.out.println("Error al realizar el tratamiento de Formación: " + e.getMessage()); + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/dao/ICicloFormativoDAO.java b/src/org/palomafp/aadd/dta/dao/ICicloFormativoDAO.java new file mode 100644 index 0000000..6142c75 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/ICicloFormativoDAO.java @@ -0,0 +1,10 @@ +package org.palomafp.aadd.dta.dao; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.CicloFormativo; + +public interface ICicloFormativoDAO { + + void insertar(CicloFormativo ciclo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/dta/dao/IFamiliaProfesionalDAO.java b/src/org/palomafp/aadd/dta/dao/IFamiliaProfesionalDAO.java new file mode 100644 index 0000000..b24e6c0 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/IFamiliaProfesionalDAO.java @@ -0,0 +1,12 @@ +package org.palomafp.aadd.dta.dao; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.FamiliaProfesional; + +public interface IFamiliaProfesionalDAO { + + boolean existe(String codigo) throws FormacionException; + void insertar(FamiliaProfesional familia) throws FormacionException; + void actualizar(FamiliaProfesional familia) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/dta/dao/ITipoFormacionDAO.java b/src/org/palomafp/aadd/dta/dao/ITipoFormacionDAO.java new file mode 100644 index 0000000..76c4639 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/ITipoFormacionDAO.java @@ -0,0 +1,9 @@ +package org.palomafp.aadd.dta.dao; + +import org.palomafp.aadd.dta.excepciones.FormacionException; + +public interface ITipoFormacionDAO { + + boolean existe(String codigo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/dta/dao/impl/CicloFormativoDaoJDBC.java b/src/org/palomafp/aadd/dta/dao/impl/CicloFormativoDaoJDBC.java new file mode 100644 index 0000000..d7804f9 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/impl/CicloFormativoDaoJDBC.java @@ -0,0 +1,36 @@ +package org.palomafp.aadd.dta.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.dao.ICicloFormativoDAO; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.CicloFormativo; + +public class CicloFormativoDaoJDBC implements ICicloFormativoDAO { + + private static final String SQL_INSERT = "INSERT INTO T_CICLO_FORMATIVO (codigo, nombre_corto, nombre_largo, " + + "horas_duracion, codigo_familia, codigo_tipo_formacion) VALUES (?, ?, ?, ?, ?, ?)"; + + private final Connection conexion; + + public CicloFormativoDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public void insertar(CicloFormativo ciclo) throws FormacionException { + try (PreparedStatement ps = conexion.prepareStatement(SQL_INSERT)) { + ps.setString(1, ciclo.getCodigo()); + ps.setString(2, ciclo.getNombreCorto()); + ps.setString(3, ciclo.getNombreLargo()); + ps.setInt(4, ciclo.getHorasDuracion()); + ps.setString(5, ciclo.getFamiliaProfesional().getCodigo()); + ps.setString(6, ciclo.getTipoFormacion().getCodigo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar el ciclo formativo " + ciclo.getCodigo(), e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/dao/impl/FamiliaProfesionalDaoJDBC.java b/src/org/palomafp/aadd/dta/dao/impl/FamiliaProfesionalDaoJDBC.java new file mode 100644 index 0000000..7ab037e --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/impl/FamiliaProfesionalDaoJDBC.java @@ -0,0 +1,59 @@ +package org.palomafp.aadd.dta.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.FamiliaProfesional; + +public class FamiliaProfesionalDaoJDBC implements IFamiliaProfesionalDAO { + + private static final String SQL_EXISTE = "SELECT 1 FROM T_FAMILIA_PROFESIONAL WHERE codigo = ?"; + + private static final String SQL_INSERT = "INSERT INTO T_FAMILIA_PROFESIONAL (codigo, nombre) VALUES (?, ?)"; + + private static final String SQL_UPDATE = "UPDATE T_FAMILIA_PROFESIONAL SET nombre = ? WHERE codigo = ?"; + + private final Connection conexion; + + public FamiliaProfesionalDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public boolean existe(String codigo) throws FormacionException { + try (PreparedStatement ps = conexion.prepareStatement(SQL_EXISTE)) { + ps.setString(1, codigo); + try (ResultSet rs = ps.executeQuery()) { + return rs.next(); + } + } catch (SQLException e) { + throw new FormacionException("Error al comprobar si existe la familia profesional " + codigo, e); + } + } + + @Override + public void insertar(FamiliaProfesional familia) throws FormacionException { + try (PreparedStatement ps = conexion.prepareStatement(SQL_INSERT)) { + ps.setString(1, familia.getCodigo()); + ps.setString(2, familia.getNombre()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar la familia profesional " + familia.getCodigo(), e); + } + } + + @Override + public void actualizar(FamiliaProfesional familia) throws FormacionException { + try (PreparedStatement ps = conexion.prepareStatement(SQL_UPDATE)) { + ps.setString(1, familia.getNombre()); + ps.setString(2, familia.getCodigo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al actualizar la familia profesional " + familia.getCodigo(), e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/dao/impl/TipoFormacionDaoJDBC.java b/src/org/palomafp/aadd/dta/dao/impl/TipoFormacionDaoJDBC.java new file mode 100644 index 0000000..7cfd57c --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/impl/TipoFormacionDaoJDBC.java @@ -0,0 +1,32 @@ +package org.palomafp.aadd.dta.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.dao.ITipoFormacionDAO; +import org.palomafp.aadd.dta.excepciones.FormacionException; + +public class TipoFormacionDaoJDBC implements ITipoFormacionDAO { + + private static final String SQL_EXISTE = "SELECT 1 FROM T_TIPO_FORMACION WHERE codigo = ?"; + + private final Connection conexion; + + public TipoFormacionDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public boolean existe(String codigo) throws FormacionException { + try (PreparedStatement ps = conexion.prepareStatement(SQL_EXISTE)) { + ps.setString(1, codigo); + try (ResultSet rs = ps.executeQuery()) { + return rs.next(); + } + } catch (SQLException e) { + throw new FormacionException("Error al comprobar si existe el tipo de formación " + codigo, e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/excepciones/FormacionException.java b/src/org/palomafp/aadd/dta/excepciones/FormacionException.java new file mode 100644 index 0000000..11020b8 --- /dev/null +++ b/src/org/palomafp/aadd/dta/excepciones/FormacionException.java @@ -0,0 +1,15 @@ +package org.palomafp.aadd.dta.excepciones; + +public class FormacionException extends Exception { + + private static final long serialVersionUID = 1L; + + public FormacionException(String mensaje) { + super(mensaje); + } + + public FormacionException(String mensaje, Throwable causa) { + super(mensaje, causa); + } + +} diff --git a/src/org/palomafp/aadd/dta/gestores/GestorConexionBBDD.java b/src/org/palomafp/aadd/dta/gestores/GestorConexionBBDD.java new file mode 100644 index 0000000..5f9b27d --- /dev/null +++ b/src/org/palomafp/aadd/dta/gestores/GestorConexionBBDD.java @@ -0,0 +1,27 @@ +package org.palomafp.aadd.dta.gestores; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.excepciones.FormacionException; + +public class GestorConexionBBDD { + + private GestorConexionBBDD() { + + } + + public static Connection getConexion() throws FormacionException { + String url = GestorConfiguracion.getConexionUrl() + GestorConfiguracion.getNombreBBDD(); + String usuario = GestorConfiguracion.getUsuarioBBDD(); + String clave = GestorConfiguracion.getClaveBBDD(); + + try { + return DriverManager.getConnection(url, usuario, clave); + } catch (SQLException e) { + throw new FormacionException("No se pudo conectar con la base de datos " + url, e); + } + } + +} 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..32fa396 --- /dev/null +++ b/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java @@ -0,0 +1,55 @@ +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 CONFIG = "application.properties"; + private static final Properties PROPS = new Properties(); + + static { + try (var is = GestorConfiguracion.class.getClassLoader().getResourceAsStream(CONFIG)) { + if (is == null) { + throw new IOException("No se encuentra " + CONFIG + " en el classpath."); + } + PROPS.load(is); + } catch (IOException e) { + throw new RuntimeException("No se ha podido cargar el fichero de configuración " + CONFIG, e); + } + } + + private GestorConfiguracion() { + } + + // Base de datos + + public static String getConexionUrl() { + return PROPS.getProperty("sgbd.conexion.url"); + } + + public static String getNombreBBDD() { + return PROPS.getProperty("bbdd.nombre"); + } + + public static String getUsuarioBBDD() { + return PROPS.getProperty("bbdd.usuario"); + } + + public static String getClaveBBDD() { + return PROPS.getProperty("bbdd.clave"); + } + + // Familias profesionales (JSON) + + public static Path getRutaFicheroFamiliasProfesionales() { + return Path.of(PROPS.getProperty("familiaprofesional.ruta.fichero")); + } + + // Ciclos formativos (XML) + + public static Path getRutaFicheroCiclosFormativos() { + return Path.of(PROPS.getProperty("cicloformativo.ruta.fichero")); + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/model/CicloFormativo.java b/src/org/palomafp/aadd/dta/model/CicloFormativo.java new file mode 100644 index 0000000..1189d0b --- /dev/null +++ b/src/org/palomafp/aadd/dta/model/CicloFormativo.java @@ -0,0 +1,82 @@ +package org.palomafp.aadd.dta.model; + +public class CicloFormativo { + + private String codigo; + private String nombreCorto; + private String nombreLargo; + private int horasDuracion; + + private FamiliaProfesional familiaProfesional; + private TipoFormacion tipoFormacion; + + public CicloFormativo() { + + } + + public CicloFormativo(String codigo, String nombreCorto, String nombreLargo, int horasDuracion, + FamiliaProfesional familiaProfesional, TipoFormacion tipoFormacion) { + this.codigo = codigo; + this.nombreCorto = nombreCorto; + this.nombreLargo = nombreLargo; + this.horasDuracion = horasDuracion; + this.familiaProfesional = familiaProfesional; + this.tipoFormacion = tipoFormacion; + } + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombreCorto() { + return nombreCorto; + } + + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + + public String getNombreLargo() { + return nombreLargo; + } + + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } + + public int getHorasDuracion() { + return horasDuracion; + } + + public void setHorasDuracion(int horasDuracion) { + this.horasDuracion = horasDuracion; + } + + public FamiliaProfesional getFamiliaProfesional() { + return familiaProfesional; + } + + public void setFamiliaProfesional(FamiliaProfesional familiaProfesional) { + this.familiaProfesional = familiaProfesional; + } + + public TipoFormacion getTipoFormacion() { + return tipoFormacion; + } + + public void setTipoFormacion(TipoFormacion tipoFormacion) { + this.tipoFormacion = tipoFormacion; + } + + @Override + public String toString() { + return "CicloFormativo [codigo=" + codigo + ", nombreCorto=" + nombreCorto + ", nombreLargo=" + nombreLargo + + ", horasDuracion=" + horasDuracion + ", familiaProfesional=" + familiaProfesional + ", tipoFormacion=" + + tipoFormacion + "]"; + } + +} diff --git a/src/org/palomafp/aadd/dta/model/FamiliaProfesional.java b/src/org/palomafp/aadd/dta/model/FamiliaProfesional.java new file mode 100644 index 0000000..1a5632b --- /dev/null +++ b/src/org/palomafp/aadd/dta/model/FamiliaProfesional.java @@ -0,0 +1,38 @@ +package org.palomafp.aadd.dta.model; + +public class FamiliaProfesional { + + private String codigo; + private String nombre; + + public FamiliaProfesional() { + + } + + public FamiliaProfesional(String codigo, String nombre) { + this.codigo = codigo; + this.nombre = nombre; + } + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public String toString() { + return "FamiliaProfesional [codigo=" + codigo + ", nombre=" + nombre + "]"; + } + +} diff --git a/src/org/palomafp/aadd/dta/model/TipoFormacion.java b/src/org/palomafp/aadd/dta/model/TipoFormacion.java new file mode 100644 index 0000000..ee57f46 --- /dev/null +++ b/src/org/palomafp/aadd/dta/model/TipoFormacion.java @@ -0,0 +1,49 @@ +package org.palomafp.aadd.dta.model; + +public class TipoFormacion { + + private String codigo; + private String nombreCorto; + private String nombreLargo; + + public TipoFormacion() { + + } + + public TipoFormacion(String codigo, String nombreCorto, String nombreLargo) { + this.codigo = codigo; + this.nombreCorto = nombreCorto; + this.nombreLargo = nombreLargo; + } + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombreCorto() { + return nombreCorto; + } + + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + + public String getNombreLargo() { + return nombreLargo; + } + + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } + + @Override + public String toString() { + return "TipoFormacion [codigo=" + codigo + ", nombreCorto=" + nombreCorto + ", nombreLargo=" + nombreLargo + + "]"; + } + +} diff --git a/src/org/palomafp/aadd/dta/service/CicloFormativoService.java b/src/org/palomafp/aadd/dta/service/CicloFormativoService.java new file mode 100644 index 0000000..dc90361 --- /dev/null +++ b/src/org/palomafp/aadd/dta/service/CicloFormativoService.java @@ -0,0 +1,46 @@ +package org.palomafp.aadd.dta.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.dao.ICicloFormativoDAO; +import org.palomafp.aadd.dta.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.dta.dao.ITipoFormacionDAO; +import org.palomafp.aadd.dta.dao.impl.CicloFormativoDaoJDBC; +import org.palomafp.aadd.dta.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.dta.dao.impl.TipoFormacionDaoJDBC; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConexionBBDD; +import org.palomafp.aadd.dta.model.CicloFormativo; + +public class CicloFormativoService { + + public void insertarCicloFormativo(CicloFormativo cicloFormativo) throws FormacionException { + try (Connection conexion = GestorConexionBBDD.getConexion()) { + // Comprobar que existe la familia profesional + IFamiliaProfesionalDAO familiaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + boolean existeFamiliaProfesional = familiaProfesionalDAO + .existe(cicloFormativo.getFamiliaProfesional().getCodigo()); + + // Comprobar que existe el tipo de formación + ITipoFormacionDAO tipoFormacionDAO = new TipoFormacionDaoJDBC(conexion); + boolean existeTipoFormacion = tipoFormacionDAO.existe(cicloFormativo.getTipoFormacion().getCodigo()); + + // Insertar el ciclo si existen la familia profesional y el tipo de formación + if (!existeFamiliaProfesional) { + throw new FormacionException( + "No existe la familia profesional " + cicloFormativo.getFamiliaProfesional().getCodigo() + + " del ciclo " + cicloFormativo.getCodigo()); + } + if (!existeTipoFormacion) { + throw new FormacionException("No existe el tipo de formación " + + cicloFormativo.getTipoFormacion().getCodigo() + " del ciclo " + cicloFormativo.getCodigo()); + } + + ICicloFormativoDAO cicloFormativoDAO = new CicloFormativoDaoJDBC(conexion); + cicloFormativoDAO.insertar(cicloFormativo); + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/service/FamiliaProfesionalService.java b/src/org/palomafp/aadd/dta/service/FamiliaProfesionalService.java new file mode 100644 index 0000000..30f8f55 --- /dev/null +++ b/src/org/palomafp/aadd/dta/service/FamiliaProfesionalService.java @@ -0,0 +1,43 @@ +package org.palomafp.aadd.dta.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.dta.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConexionBBDD; +import org.palomafp.aadd.dta.model.FamiliaProfesional; + +public class FamiliaProfesionalService { + + public boolean existeFamiliaProfesional(String codFamiliaProfesional) throws FormacionException { + boolean existeFP = false; + + try (Connection conexion = GestorConexionBBDD.getConexion()) { + IFamiliaProfesionalDAO familiaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + existeFP = familiaProfesionalDAO.existe(codFamiliaProfesional); + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + return existeFP; + } + + public void insertarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException { + try (Connection conexion = GestorConexionBBDD.getConexion()) { + IFamiliaProfesionalDAO familiaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + familiaProfesionalDAO.insertar(familiaProfesional); + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } + + public void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException { + try (Connection conexion = GestorConexionBBDD.getConexion()) { + IFamiliaProfesionalDAO familiaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + familiaProfesionalDAO.actualizar(familiaProfesional); + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/util/ProcesadorFicheroJSON.java b/src/org/palomafp/aadd/dta/util/ProcesadorFicheroJSON.java new file mode 100644 index 0000000..90808f4 --- /dev/null +++ b/src/org/palomafp/aadd/dta/util/ProcesadorFicheroJSON.java @@ -0,0 +1,41 @@ +package org.palomafp.aadd.dta.util; + +import java.io.IOException; +import java.nio.file.Path; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConfiguracion; +import org.palomafp.aadd.dta.model.FamiliaProfesional; +import org.palomafp.aadd.dta.service.FamiliaProfesionalService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +public class ProcesadorFicheroJSON { + + public void realizarTratamientoFamiliasProfesionales() throws FormacionException { + Path ruta = GestorConfiguracion.getRutaFicheroFamiliasProfesionales(); + FamiliaProfesionalService familiaProfesionalService = new FamiliaProfesionalService(); + + try { + // La raíz del JSON es un array de familias + JsonNode raiz = new ObjectMapper().readTree(ruta.toFile()); + + for (JsonNode nodo : raiz) { + String codigo = nodo.path("cod_tipo_fam").asText().trim(); + String nombre = nodo.path("nombre_tf").asText().trim(); + FamiliaProfesional familiaProfesional = new FamiliaProfesional(codigo, nombre); + + if (familiaProfesionalService.existeFamiliaProfesional(codigo)) { + familiaProfesionalService.actualizarFamiliaProfesional(familiaProfesional); + System.out.println("Familia profesional actualizada: " + codigo); + } else { + familiaProfesionalService.insertarFamiliaProfesional(familiaProfesional); + System.out.println("Familia profesional insertada: " + codigo); + } + } + } catch (IOException e) { + throw new FormacionException("Error al leer el fichero JSON " + ruta, e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/util/ProcesadorFicheroXML.java b/src/org/palomafp/aadd/dta/util/ProcesadorFicheroXML.java new file mode 100644 index 0000000..1406ba8 --- /dev/null +++ b/src/org/palomafp/aadd/dta/util/ProcesadorFicheroXML.java @@ -0,0 +1,63 @@ +package org.palomafp.aadd.dta.util; + +import java.io.IOException; +import java.nio.file.Path; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConfiguracion; +import org.palomafp.aadd.dta.model.CicloFormativo; +import org.palomafp.aadd.dta.model.FamiliaProfesional; +import org.palomafp.aadd.dta.model.TipoFormacion; +import org.palomafp.aadd.dta.service.CicloFormativoService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.dataformat.xml.XmlMapper; + +public class ProcesadorFicheroXML { + + public void realizarTratamientoCiclosFormativos() throws FormacionException { + Path ruta = GestorConfiguracion.getRutaFicheroCiclosFormativos(); + CicloFormativoService cicloFormativoService = new CicloFormativoService(); + + try { + // XmlMapper descarta el elemento raíz () + JsonNode nodoCiclos = new XmlMapper().readTree(ruta.toFile()).path("informacion_adicional") + .path("ciclos_formativos").path("ciclo"); + + int total = 0; + int insertados = 0; + + for (JsonNode nodo : nodoCiclos) { + total++; + CicloFormativo cicloFormativo = convertirACicloFormativo(nodo); + + // Un ciclo erróneo no detiene el tratamiento de los demás + try { + cicloFormativoService.insertarCicloFormativo(cicloFormativo); + insertados++; + System.out.println("Ciclo formativo insertado: " + cicloFormativo.getCodigo()); + } catch (FormacionException e) { + System.out.println("ERROR en el ciclo " + cicloFormativo.getCodigo() + ": " + e.getMessage()); + } + } + System.out.println("Ciclos formativos insertados: " + insertados + " de " + total); + + } catch (IOException e) { + throw new FormacionException("Error al leer el fichero XML " + ruta, e); + } + } + + private CicloFormativo convertirACicloFormativo(JsonNode nodo) { + // El atributo cod_cf aparece como un campo más del nodo + String codigo = nodo.path("cod_cf").asText().trim(); + String nombreCorto = nodo.path("nomb_corto").asText().trim(); + String nombreLargo = nodo.path("nombrelargo").asText().trim(); + int horasDuracion = nodo.path("num_horas_duracion").asInt(); + + FamiliaProfesional familiaProfesional = new FamiliaProfesional(nodo.path("codigo_familia").asText().trim(), + null); + TipoFormacion tipoFormacion = new TipoFormacion(nodo.path("codigo_tipoestudio").asText().trim(), null, null); + + return new CicloFormativo(codigo, nombreCorto, nombreLargo, horasDuracion, familiaProfesional, tipoFormacion); + } +} \ No newline at end of file