commit 6e582b521c4f4c49b6eb3b7921801a0294ef5ecf Author: Laura Date: Thu Nov 19 14:13:30 2026 +0100 Actividad2.5 Tratamiento_Formación - Jackson diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5cd3bad --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +# Ignorar la carpeta de compilados +bin/ +*.class + +# Ignorar archivos de configuración de Eclipse +.settings/ +.project +.classpath +/target/ 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..c24a07b --- /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" + } +] diff --git a/ficheros/familias_profesionales.csv b/ficheros/familias_profesionales.csv new file mode 100644 index 0000000..c8d98aa --- /dev/null +++ b/ficheros/familias_profesionales.csv @@ -0,0 +1,5 @@ +id_registro|fecha_carga|cod_tipo_fam|nombre_tf +1|2026-01-15|ADG|Administración y Gestión +2|2026-01-15| IFC|Informática y Comunicaciones +3|2026-01-15|TMV |Transporte y Mantenimiento de Vehículos +4|2026-01-15|SAN|Sanidad \ No newline at end of file diff --git a/ficheros/formacion_fp.sql b/ficheros/formacion_fp.sql new file mode 100644 index 0000000..d45fc83 --- /dev/null +++ b/ficheros/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..82f83f9 --- /dev/null +++ b/pom.xml @@ -0,0 +1,53 @@ + + 4.0.0 + Conectores_5 + Conectores_5 + 0.0.1-SNAPSHOT + + + + + + com.mysql + mysql-connector-j + 26.10.0 + compile + + + + + com.fasterxml.jackson.core + jackson-databind + 2.18.2 + + + + + com.fasterxml.jackson.dataformat + jackson-dataformat-xml + 2.18.2 + + + + + + src + + + src + + **/*.java + + + + + + maven-compiler-plugin + 3.13.0 + + 26 + + + + + \ No newline at end of file diff --git a/src/application.properties b/src/application.properties new file mode 100644 index 0000000..5ff3e76 --- /dev/null +++ b/src/application.properties @@ -0,0 +1,11 @@ +# config/application.properties +ruta.json.familias=./ficheros/familias_pro.json + +ruta.xml.formaciones=./ficheros/catalogo_formacion.xml + +# conexion con la bbdd +sgdb.clase.driver=com.mysql.cj.jdbc.Driver +sgdb.conexion.url=jdbc:mysql://192.168.1.136:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=root +bbdd.clave=root \ No newline at end of file diff --git a/src/org/palomafp/aadd/ljl/AppPrincipal.java b/src/org/palomafp/aadd/ljl/AppPrincipal.java new file mode 100644 index 0000000..f54ad9f --- /dev/null +++ b/src/org/palomafp/aadd/ljl/AppPrincipal.java @@ -0,0 +1,25 @@ +package org.palomafp.aadd.ljl; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.lectoresYescritores.CicloFormativoProcesadorXml; +import org.palomafp.aadd.ljl.lectoresYescritores.FamiliaProfesionalProcesadorJson; + +public class AppPrincipal { + + public static void main(String[] args) { + + try { + // 1º parte -> FamiliaProfesional (JSON) + FamiliaProfesionalProcesadorJson procesadorJson = new FamiliaProfesionalProcesadorJson(); + procesadorJson.realizarTratamientoFamilias(); + + // 2º parte -> CicloFormativo (XML) + CicloFormativoProcesadorXml procesadorXml = new CicloFormativoProcesadorXml(); + procesadorXml.realizarTratamientoCiclos(); + + } catch (FormacionException e) { + System.err.println("Error: " + e.getMessage()); + } + } + +} diff --git a/src/org/palomafp/aadd/ljl/dao/ICicloFormativoDAO.java b/src/org/palomafp/aadd/ljl/dao/ICicloFormativoDAO.java new file mode 100644 index 0000000..cfb6681 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/dao/ICicloFormativoDAO.java @@ -0,0 +1,9 @@ +package org.palomafp.aadd.ljl.dao; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.model.CicloFormativo; + +public interface ICicloFormativoDAO { + + public void insertarCicloFormativo (CicloFormativo ciclo) throws FormacionException; +} diff --git a/src/org/palomafp/aadd/ljl/dao/IFamiliaProfesionalDAO.java b/src/org/palomafp/aadd/ljl/dao/IFamiliaProfesionalDAO.java new file mode 100644 index 0000000..96f013a --- /dev/null +++ b/src/org/palomafp/aadd/ljl/dao/IFamiliaProfesionalDAO.java @@ -0,0 +1,14 @@ +package org.palomafp.aadd.ljl.dao; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.model.FamiliaProfesional; + +public interface IFamiliaProfesionalDAO { + + public boolean existeFamiliaProfesionalPorCod (String codFamilia) throws FormacionException; + + public void insertarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException; + + public void actualizarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/ljl/dao/ITipoFormacionDAO.java b/src/org/palomafp/aadd/ljl/dao/ITipoFormacionDAO.java new file mode 100644 index 0000000..d065ab9 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/dao/ITipoFormacionDAO.java @@ -0,0 +1,8 @@ +package org.palomafp.aadd.ljl.dao; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; + +public interface ITipoFormacionDAO { + + public boolean existeTipoFormacionPorCod(String codTipo) throws FormacionException; +} diff --git a/src/org/palomafp/aadd/ljl/dao/impl/CicloFormativoDaoJDBC.java b/src/org/palomafp/aadd/ljl/dao/impl/CicloFormativoDaoJDBC.java new file mode 100644 index 0000000..7a0a9f1 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/dao/impl/CicloFormativoDaoJDBC.java @@ -0,0 +1,44 @@ +package org.palomafp.aadd.ljl.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; + +import org.palomafp.aadd.ljl.dao.ICicloFormativoDAO; +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.model.CicloFormativo; + +public class CicloFormativoDaoJDBC implements ICicloFormativoDAO { + + private final Connection conexion; + + public CicloFormativoDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public void insertarCicloFormativo(CicloFormativo ciclo) throws FormacionException { + String sentenciaSQL = """ + INSERT INTO T_CICLO_FORMATIVO (codigo, nombre_corto, nombre_largo, horas_duracion, codigo_familia, codigo_tipo_formacion) + VALUES (?, ?, ?, ?, ?, ?) + """; + + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL)) { + + sentenciaPreparada.setString(1, ciclo.getCodigoFormacion()); + sentenciaPreparada.setString(2, ciclo.getNombreCorto()); + sentenciaPreparada.setString(3, ciclo.getNombreLargo()); + sentenciaPreparada.setInt(4, ciclo.getHorasDuracion()); + + sentenciaPreparada.setString(5, ciclo.getFamiliaProfesional().getCodigoFamilia()); + sentenciaPreparada.setString(6, ciclo.getTipoFormacion().getCodigo()); + + sentenciaPreparada.executeUpdate(); + + } catch (SQLException e) { + throw new FormacionException("Error al insertar el ciclo " + ciclo.getCodigoFormacion() + ".", e); + } + + } + +} diff --git a/src/org/palomafp/aadd/ljl/dao/impl/FamiliaProfesionalDaoJDBC.java b/src/org/palomafp/aadd/ljl/dao/impl/FamiliaProfesionalDaoJDBC.java new file mode 100644 index 0000000..8c78e62 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/dao/impl/FamiliaProfesionalDaoJDBC.java @@ -0,0 +1,85 @@ +package org.palomafp.aadd.ljl.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.ljl.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.model.FamiliaProfesional; + +public class FamiliaProfesionalDaoJDBC implements IFamiliaProfesionalDAO{ + + private final Connection conexion; + + public FamiliaProfesionalDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public boolean existeFamiliaProfesionalPorCod(String codFamilia) throws FormacionException { + boolean existe = false; + + String sentenciaSQL = """ + SELECT EXISTS(SELECT 1 FROM T_FAMILIA_PROFESIONAL WHERE codigo = ?) AS existe_familia + """; + + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL)) { + + sentenciaPreparada.setString(1, codFamilia); + + try (ResultSet resultados = sentenciaPreparada.executeQuery()) { + + if (resultados.next()) { + existe = resultados.getBoolean("existe_familia"); + } + } + + } catch (SQLException e) { + throw new FormacionException("Error al comprobar si existe la familia " + codFamilia + ".", e); + } + return existe; + } + + @Override + public void insertarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException { + String sentenciaSQL = """ + INSERT INTO T_FAMILIA_PROFESIONAL (codigo, nombre) + VALUES (?, ?) + """; + + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL)) { + + sentenciaPreparada.setString(1, familia.getCodigoFamilia()); + sentenciaPreparada.setString(2, familia.getNombre()); + + sentenciaPreparada.executeUpdate(); + + } catch (SQLException e) { + throw new FormacionException("Error al insertar la familia " + familia.getCodigoFamilia() + ".", e); + } + } + + @Override + public void actualizarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException { + String sentenciaSQL = """ + UPDATE T_FAMILIA_PROFESIONAL + SET nombre = ? + WHERE codigo = ? + """; + + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL)) { + + sentenciaPreparada.setString(1, familia.getNombre()); + sentenciaPreparada.setString(2, familia.getCodigoFamilia()); + + sentenciaPreparada.executeUpdate(); + + } catch (SQLException e) { + throw new FormacionException("Error al actualizar la familia " + familia.getCodigoFamilia() + ".", e); + } + + } + +} diff --git a/src/org/palomafp/aadd/ljl/dao/impl/TipoFormacionDaoJDBC.java b/src/org/palomafp/aadd/ljl/dao/impl/TipoFormacionDaoJDBC.java new file mode 100644 index 0000000..e35298e --- /dev/null +++ b/src/org/palomafp/aadd/ljl/dao/impl/TipoFormacionDaoJDBC.java @@ -0,0 +1,42 @@ +package org.palomafp.aadd.ljl.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.ljl.dao.ITipoFormacionDAO; +import org.palomafp.aadd.ljl.exceptions.FormacionException; + +public class TipoFormacionDaoJDBC implements ITipoFormacionDAO { + + private final Connection conexion; + + public TipoFormacionDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public boolean existeTipoFormacionPorCod(String codTipo) throws FormacionException { + boolean existe = false; + + String sentenciaSQL = """ + SELECT EXISTS(SELECT 1 FROM T_TIPO_FORMACION WHERE codigo = ?) AS existe_tipo + """; + + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL)) { + + sentenciaPreparada.setString(1, codTipo); + + try (ResultSet resultados = sentenciaPreparada.executeQuery()) { + if (resultados.next()) { + existe = resultados.getBoolean("existe_tipo"); + } + } + + } catch (SQLException e) { + throw new FormacionException("Error al comprobar si existe el tipo de formación " + codTipo + ".", e); + } + return existe; + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/ljl/exceptions/FormacionException.java b/src/org/palomafp/aadd/ljl/exceptions/FormacionException.java new file mode 100644 index 0000000..da5d727 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/exceptions/FormacionException.java @@ -0,0 +1,12 @@ +package org.palomafp.aadd.ljl.exceptions; + +public class FormacionException extends Exception{ + + public FormacionException(String mensaje) { + super(mensaje); + } + + public FormacionException(String mensaje, Throwable causa) { + super(mensaje, causa); + } +} diff --git a/src/org/palomafp/aadd/ljl/gestores/GestorConexionBBDD.java b/src/org/palomafp/aadd/ljl/gestores/GestorConexionBBDD.java new file mode 100644 index 0000000..774b122 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/gestores/GestorConexionBBDD.java @@ -0,0 +1,38 @@ + +package org.palomafp.aadd.ljl.gestores; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; + + +public class GestorConexionBBDD { + + // Constructor privado: de esta manera conseguimos que esta clase no se puede instanciar. + private GestorConexionBBDD() { + } + + public static Connection obtenerConexion() throws FormacionException { + + Connection conexion = null; + + try { + // Con JDBC 4+ y el driver en el classpath (Maven) DriverManager lo registra solo; Class.forName es redundante. + // No es un error, pero puedo quitarlo, si hago eso -> el catch de ClassNotFoundException tambien lo quito + Class.forName(GestorConfiguracion.getClaseDriver()); + + String urlConexionCompleta = GestorConfiguracion.getConexionURL() + GestorConfiguracion.getNombreBBDD(); + String usuarioBBDD=GestorConfiguracion.getUsuarioBBDD(); + String claveBBDD=GestorConfiguracion.getClaveBBDD(); + + // crear una conexión con la base de datos + conexion = DriverManager.getConnection(urlConexionCompleta, usuarioBBDD, claveBBDD); + + } catch (ClassNotFoundException | SQLException e) { + throw new FormacionException("No se ha podido obtener una conexión con el SGDB", e); + } + return conexion; + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/ljl/gestores/GestorConfiguracion.java b/src/org/palomafp/aadd/ljl/gestores/GestorConfiguracion.java new file mode 100644 index 0000000..89b2a68 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/gestores/GestorConfiguracion.java @@ -0,0 +1,77 @@ +package org.palomafp.aadd.ljl.gestores; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; + +public class GestorConfiguracion { + + private static final String RUTA_FICHERO_CONFIGURACION = "application.properties"; + private static final Properties PROPIEDADES_CONFIGURACION = new Properties(); + private static boolean cargado = false; + + private GestorConfiguracion() { + + } + + // Un bloque static no puede lanzar excepciones checked, así que se carga al pedir + // la primera propiedad. Si ya se cargó antes (cargado = true) no se vuelve a cargar. + private static void cargarPropiedades() throws FormacionException { + if (!cargado) { + try (InputStream is = GestorConfiguracion.class.getClassLoader() + .getResourceAsStream(RUTA_FICHERO_CONFIGURACION)) { + if (is == null) { + throw new FormacionException( + "No se ha encontrado el fichero de configuración: " + RUTA_FICHERO_CONFIGURACION); + } + PROPIEDADES_CONFIGURACION.load(is); + cargado = true; + + } catch (IOException e) { + throw new FormacionException("No se ha podido cargar el fichero de configuración", e); + } + } + } + + + // lo que necesitamos para el JSON + public static String getRutaJsonFamilias() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("ruta.json.familias","./ficheros/familias_pro.json"); + } + + // lo que necesitamos para el XML + public static String getRutaXmlFormacion() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("ruta.xml.formaciones","./ficheros/catalogo_formacion.xml"); + } + + + // lo que necesitamos para el GestorConexionBBDD + public static String getClaseDriver() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("sgdb.clase.driver"); + } + + public static String getConexionURL() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("sgdb.conexion.url"); + } + + public static String getNombreBBDD() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("bbdd.nombre"); + } + + public static String getUsuarioBBDD() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("bbdd.usuario"); + } + + public static String getClaveBBDD() throws FormacionException { + cargarPropiedades(); + return PROPIEDADES_CONFIGURACION.getProperty("bbdd.clave"); + } +} diff --git a/src/org/palomafp/aadd/ljl/lectoresYescritores/CicloFormativoProcesadorXml.java b/src/org/palomafp/aadd/ljl/lectoresYescritores/CicloFormativoProcesadorXml.java new file mode 100644 index 0000000..2c4995a --- /dev/null +++ b/src/org/palomafp/aadd/ljl/lectoresYescritores/CicloFormativoProcesadorXml.java @@ -0,0 +1,109 @@ +package org.palomafp.aadd.ljl.lectoresYescritores; + +import java.io.File; +import java.io.IOException; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.gestores.GestorConfiguracion; +import org.palomafp.aadd.ljl.model.CicloFormativo; +import org.palomafp.aadd.ljl.model.FamiliaProfesional; +import org.palomafp.aadd.ljl.model.TipoFormacion; +import org.palomafp.aadd.ljl.service.CicloFormativoService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.dataformat.xml.XmlMapper; + +public class CicloFormativoProcesadorXml { + + private final String rutaFichero; + private final CicloFormativoService cicloService; + + public CicloFormativoProcesadorXml() throws FormacionException { + this.rutaFichero = GestorConfiguracion.getRutaXmlFormacion(); + this.cicloService = new CicloFormativoService(); + } + + // Solo se tratan los + public void realizarTratamientoCiclos() throws FormacionException { + + JsonNode raiz = cargarXml(); + + // findValues("ciclo") busca la etiqueta en cualquier nivel del árbol. + // Jackson devuelve un array si se repite, o un único nodo si solo hay uno. + for (JsonNode encontrado : raiz.findValues("ciclo")) { + + if (encontrado.isArray()) { + for (JsonNode nodoCiclo : encontrado) { + tratarCiclo(nodoCiclo); + } + } else { + tratarCiclo(encontrado); + } + } + } + + // ------------------ MÉTODOS AUXILIARES ------------------ + + private JsonNode cargarXml() throws FormacionException { + + try { + // XmlMapper lee todo el XML y lo convierte en un árbol de JsonNode + return new XmlMapper().readTree(new File(rutaFichero)); + + } catch (IOException e) { + throw new FormacionException("No se ha podido leer el fichero XML de ciclos " + rutaFichero, e); + } + } + + private void tratarCiclo(JsonNode nodoCiclo) { + + String codigo = textoHijo(nodoCiclo, "cod_cf"); + + try { + CicloFormativo ciclo = crearCiclo(nodoCiclo); + + cicloService.insertarCiclo(ciclo); + System.out.println("Ciclo " + codigo + ": insertado."); + + } catch (FormacionException e) { + // un error en un ciclo no debe impedir tratar el resto + System.err.println("Ciclo " + codigo + ": " + e.getMessage()); + } + } + + private CicloFormativo crearCiclo(JsonNode nodoCiclo) throws FormacionException { + + CicloFormativo ciclo = new CicloFormativo(); + // los atributos XML (cod_cf) aparecen en el árbol como un campo más + ciclo.setCodigoFormacion(textoHijo(nodoCiclo, "cod_cf")); + ciclo.setNombreCorto(textoHijo(nodoCiclo, "nomb_corto")); + ciclo.setNombreLargo(textoHijo(nodoCiclo, "nombrelargo")); + + try { + ciclo.setHorasDuracion(Integer.parseInt(textoHijo(nodoCiclo, "num_horas_duracion"))); + } catch (NumberFormatException e) { + throw new FormacionException("Horas de duración no válidas.", e); + } + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigoFamilia(textoHijo(nodoCiclo, "codigo_familia")); + ciclo.setFamiliaProfesional(familia); + + TipoFormacion formacion = new TipoFormacion(); + formacion.setCodigo(textoHijo(nodoCiclo, "codigo_tipoestudio")); + ciclo.setTipoFormacion(formacion); + + return ciclo; + } + + // devuelve el texto de un hijo (o atributo) sin espacios; "" si no existe o está vacío + private String textoHijo(JsonNode padre, String etiqueta) { + + JsonNode nodo = padre.path(etiqueta); + + if (nodo.isMissingNode() || nodo.isNull()) { + return ""; + } + return nodo.asText("").trim(); + } +} diff --git a/src/org/palomafp/aadd/ljl/lectoresYescritores/FamiliaProfesionalProcesadorJson.java b/src/org/palomafp/aadd/ljl/lectoresYescritores/FamiliaProfesionalProcesadorJson.java new file mode 100644 index 0000000..a01e8fe --- /dev/null +++ b/src/org/palomafp/aadd/ljl/lectoresYescritores/FamiliaProfesionalProcesadorJson.java @@ -0,0 +1,81 @@ +package org.palomafp.aadd.ljl.lectoresYescritores; + +import java.io.File; +import java.io.IOException; + +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.gestores.GestorConfiguracion; +import org.palomafp.aadd.ljl.model.FamiliaProfesional; +import org.palomafp.aadd.ljl.service.FamiliaProfesionalService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +public class FamiliaProfesionalProcesadorJson { + + private final String rutaFichero; + private final FamiliaProfesionalService familiaService; + + public FamiliaProfesionalProcesadorJson() throws FormacionException { + this.rutaFichero = GestorConfiguracion.getRutaJsonFamilias(); + this.familiaService = new FamiliaProfesionalService(); + } + + public void realizarTratamientoFamilias() throws FormacionException { + + JsonNode raiz = cargarJson(); + + // En cada vuelta, nodo es una familia: un { ... } con sus campos id_registro, fecha_carga, cod_tipo_fam y nombre_tf + for (JsonNode nodo : raiz) { + + try { + FamiliaProfesional familia = crearFamiliaProfesional(nodo); + + if (familiaService.existeFamiliaProfesionalPorClave(familia.getCodigoFamilia())) { + + familiaService.actualizarFamilia(familia); + System.out.println("Familia " + familia.getCodigoFamilia() + ": actualizada."); + + } else { + + familiaService.insertarFamilia(familia); + System.out.println("Familia " + familia.getCodigoFamilia() + ": insertada."); + } + + } catch (FormacionException e) { + // un error en una familia no debe impedir tratar el resto + System.err.println("Familia: " + e.getMessage()); + } + } + } + + // ------------------ MÉTODOS AUXILIARES ------------------ + + private JsonNode cargarJson() throws FormacionException { + + try { + // ObjectMapper lee todo el JSON y lo convierte en un árbol de JsonNode + return new ObjectMapper().readTree(new File(rutaFichero)); + + } catch (IOException e) { + throw new FormacionException("Error al leer el fichero JSON de familias " + rutaFichero, e); + } + } + + private FamiliaProfesional crearFamiliaProfesional(JsonNode nodo) throws FormacionException { + + // path no falla si la clave no existe (get devolvería null); el nombre debe ser el del fichero + String codigo = nodo.path("cod_tipo_fam").asText("").trim(); + String nombre = nodo.path("nombre_tf").asText("").trim(); + + if (codigo.isEmpty() || nombre.isEmpty()) { + throw new FormacionException("Familia no válida en el JSON: " + nodo); + } + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigoFamilia(codigo); + familia.setNombre(nombre); + + return familia; + } +} diff --git a/src/org/palomafp/aadd/ljl/model/CicloFormativo.java b/src/org/palomafp/aadd/ljl/model/CicloFormativo.java new file mode 100644 index 0000000..650215c --- /dev/null +++ b/src/org/palomafp/aadd/ljl/model/CicloFormativo.java @@ -0,0 +1,78 @@ +package org.palomafp.aadd.ljl.model; + +public class CicloFormativo { + + private String codigoFormacion; + private String nombreCorto; + private String nombreLargo; + private int horasDuracion; + private FamiliaProfesional familiaProfesional; + private TipoFormacion tipoFormacion; + + // Constructores + + public CicloFormativo(){ + + } + + public CicloFormativo(String codigoFormacion, String nombreCorto, String nombreLargo, int horasDuracion, + FamiliaProfesional familiaProfesional, TipoFormacion tipoFormacion) { + super(); + this.codigoFormacion = codigoFormacion; + this.nombreCorto = nombreCorto; + this.nombreLargo = nombreLargo; + this.horasDuracion = horasDuracion; + this.familiaProfesional = familiaProfesional; + this.tipoFormacion = tipoFormacion; + } + + + // getters y setters + public String getCodigoFormacion() { + return codigoFormacion; + } + public String getNombreCorto() { + return nombreCorto; + } + public String getNombreLargo() { + return nombreLargo; + } + public int getHorasDuracion() { + return horasDuracion; + } + public FamiliaProfesional getFamiliaProfesional() { + return familiaProfesional; + } + public TipoFormacion getTipoFormacion() { + return tipoFormacion; + } + + + public void setCodigoFormacion(String codigoFormacion) { + this.codigoFormacion = codigoFormacion; + } + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } + public void setHorasDuracion(int horasDuracion) { + this.horasDuracion = horasDuracion; + } + public void setFamiliaProfesional(FamiliaProfesional familiaProfesional) { + this.familiaProfesional = familiaProfesional; + } + public void setTipoFormacion(TipoFormacion tipoFormacion) { + this.tipoFormacion = tipoFormacion; + } + + + // sobrescribimos el método toString + @Override + public String toString() { + return "CicloFormativo [codigoFormacion=" + codigoFormacion + ", nombreCorto=" + nombreCorto + ", nombreLargo=" + + nombreLargo + ", horasDuracion=" + horasDuracion + ", familiaProfesional=" + familiaProfesional + + ", tipoFormacion=" + tipoFormacion + "]"; + } +} diff --git a/src/org/palomafp/aadd/ljl/model/FamiliaProfesional.java b/src/org/palomafp/aadd/ljl/model/FamiliaProfesional.java new file mode 100644 index 0000000..849b5d6 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/model/FamiliaProfesional.java @@ -0,0 +1,39 @@ +package org.palomafp.aadd.ljl.model; + +public class FamiliaProfesional { + + private String codigoFamilia; + private String nombre; + + // Constructores + public FamiliaProfesional() { + + } + + public FamiliaProfesional(String codigoFamilia, String nombre) { + super(); + this.codigoFamilia = codigoFamilia; + this.nombre = nombre; + } + + // Getters y setters + public String getCodigoFamilia() { + return codigoFamilia; + } + public String getNombre() { + return nombre; + } + + public void setCodigoFamilia(String codigoFamilia) { + this.codigoFamilia = codigoFamilia; + } + public void setNombre(String nombre) { + this.nombre = nombre; + } + + // sobrescribimos el método toString + @Override + public String toString() { + return "FamiliaProfesional [codigoFamilia=" + codigoFamilia + ", nombre=" + nombre + "]"; + } +} diff --git a/src/org/palomafp/aadd/ljl/model/TipoFormacion.java b/src/org/palomafp/aadd/ljl/model/TipoFormacion.java new file mode 100644 index 0000000..d465dfe --- /dev/null +++ b/src/org/palomafp/aadd/ljl/model/TipoFormacion.java @@ -0,0 +1,42 @@ +package org.palomafp.aadd.ljl.model; + +public class TipoFormacion { + + private String codigo; + private String nombreCorto; + private String nombreLargo; + + // constructores + public TipoFormacion() { + + } + + public TipoFormacion(String codigo, String nombreCorto, String nombreLargo) { + super(); + this.codigo = codigo; + this.nombreCorto = nombreCorto; + this.nombreLargo = nombreLargo; + } + + // getters y setters + public String getCodigo() { + return codigo; + } + public String getNombreCorto() { + return nombreCorto; + } + public String getNombreLargo() { + return nombreLargo; + } + + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } +} diff --git a/src/org/palomafp/aadd/ljl/service/CicloFormativoService.java b/src/org/palomafp/aadd/ljl/service/CicloFormativoService.java new file mode 100644 index 0000000..124b843 --- /dev/null +++ b/src/org/palomafp/aadd/ljl/service/CicloFormativoService.java @@ -0,0 +1,41 @@ +package org.palomafp.aadd.ljl.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.ljl.dao.ICicloFormativoDAO; +import org.palomafp.aadd.ljl.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.ljl.dao.ITipoFormacionDAO; +import org.palomafp.aadd.ljl.dao.impl.CicloFormativoDaoJDBC; +import org.palomafp.aadd.ljl.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.ljl.dao.impl.TipoFormacionDaoJDBC; +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.gestores.GestorConexionBBDD; +import org.palomafp.aadd.ljl.model.CicloFormativo; + + +public class CicloFormativoService { + + public void insertarCiclo(CicloFormativo ciclo) throws FormacionException { + + try (Connection conexion = GestorConexionBBDD.obtenerConexion()) { + + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoJDBC(conexion); + ICicloFormativoDAO cicloDao = new CicloFormativoDaoJDBC(conexion); + ITipoFormacionDAO tipoDao = new TipoFormacionDaoJDBC(conexion); + + if (!familiaDao.existeFamiliaProfesionalPorCod(ciclo.getFamiliaProfesional().getCodigoFamilia())) { + throw new FormacionException("Ese ciclo no tiene familia asociada"); + } + + if (!tipoDao.existeTipoFormacionPorCod(ciclo.getTipoFormacion().getCodigo())) { + throw new FormacionException("El ciclo no tiene Tipo de formación asociada"); + } + + cicloDao.insertarCicloFormativo(ciclo); + + } catch (SQLException e) { + throw new FormacionException("Error al cerrar la conexión.", e); + } + } +} diff --git a/src/org/palomafp/aadd/ljl/service/FamiliaProfesionalService.java b/src/org/palomafp/aadd/ljl/service/FamiliaProfesionalService.java new file mode 100644 index 0000000..5c21d1c --- /dev/null +++ b/src/org/palomafp/aadd/ljl/service/FamiliaProfesionalService.java @@ -0,0 +1,64 @@ +package org.palomafp.aadd.ljl.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.ljl.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.ljl.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.ljl.exceptions.FormacionException; +import org.palomafp.aadd.ljl.gestores.GestorConexionBBDD; +import org.palomafp.aadd.ljl.model.FamiliaProfesional; + +public class FamiliaProfesionalService { + + public boolean existeFamiliaProfesionalPorClave(String codFamiliaProfesional) throws FormacionException { + + boolean existe = false; + + try (Connection conexion = GestorConexionBBDD.obtenerConexion();) { + + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + + existe = iFamiliaProfesionalDAO.existeFamiliaProfesionalPorCod(codFamiliaProfesional); + + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + return existe; + } + + public void insertarFamilia(FamiliaProfesional familia) throws FormacionException { + + try (Connection conexion = GestorConexionBBDD.obtenerConexion()) { + + IFamiliaProfesionalDAO FamiliaDao = new FamiliaProfesionalDaoJDBC(conexion); + + if (FamiliaDao.existeFamiliaProfesionalPorCod(familia.getCodigoFamilia())) { + throw new FormacionException("La Familia " + familia.getCodigoFamilia() + " ya existe."); + } + + FamiliaDao.insertarFamiliaProfesional(familia); + + } catch (SQLException e) { + throw new FormacionException("Error al cerrar la conexión.", e); + } + } + + public void actualizarFamilia(FamiliaProfesional familia) throws FormacionException { + + try (Connection conexion = GestorConexionBBDD.obtenerConexion()) { + + IFamiliaProfesionalDAO FamiliaDao = new FamiliaProfesionalDaoJDBC(conexion); + + if (!FamiliaDao.existeFamiliaProfesionalPorCod(familia.getCodigoFamilia())) { + throw new FormacionException("La Familia " + familia.getCodigoFamilia() + " no existe."); + } + + FamiliaDao.actualizarFamiliaProfesional(familia); + + } catch (SQLException e) { + throw new FormacionException("Error al cerrar la conexión.", e); + } + } + +}