commit 4ac95601d67e34bc99facbb0759b77f3fa6d2b47 Author: Isidoro Nevares Mart铆n Date: Mon Nov 16 22:23:12 2026 +0100 Primer commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cbaae6f --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +# Eclipse +.classpath +.project +.settings/ + +# Compilaci贸n Java +bin/ +target/ +*.class + +# Logs +*.log + +# Sistema operativo +.DS_Store +Thumbs.db \ No newline at end of file diff --git a/config/application.properties b/config/application.properties new file mode 100644 index 0000000..cc1b22a --- /dev/null +++ b/config/application.properties @@ -0,0 +1,14 @@ +# Elegir nombres de entradas que sean SIGNIFICATIVOS +# y que no se repitan con otras entradas de la misma aplicaci髇 + +# Informaci髇 relativa a la base de datos +sgdb.conexion.url=jdbc:mysql://192.168.1.36:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=root +bbdd.clave=mysql_123 + +# Informaci髇 relativa a las familias profesionales. +familiaprofesional.csv.ruta=ficheros/familias_pro.json + +# Informaci髇 relativa a los ciclos formativos. +catalogoformacion.xml.ruta=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/pom.xml b/pom.xml new file mode 100644 index 0000000..984e071 --- /dev/null +++ b/pom.xml @@ -0,0 +1,46 @@ + + 4.0.0 + Conectores_04 + Conectores_04 + 0.0.1-SNAPSHOT + + + + com.mysql + mysql-connector-j + 26.10.0 + compile + + + + com.fasterxml.jackson.core + jackson-databind + 2.20.1 + + + com.fasterxml.jackson.dataformat + jackson-dataformat-xml + 2.20.1 + + + + src + + + config + + **/*.java + + + + + + maven-compiler-plugin + 3.13.0 + + 24 + + + + + \ No newline at end of file diff --git a/src/org/palomafp/aadd/inm/AppPrincipalFormacion.java b/src/org/palomafp/aadd/inm/AppPrincipalFormacion.java new file mode 100644 index 0000000..8a76e02 --- /dev/null +++ b/src/org/palomafp/aadd/inm/AppPrincipalFormacion.java @@ -0,0 +1,37 @@ +package org.palomafp.aadd.inm; + +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.fichero.ProcesadorFicheroJSON; +import org.palomafp.aadd.inm.fichero.ProcesadorFicheroXML; + +/** + * + * AppPrincipal: Clase que realiza la gesti贸n de las principales operaciones + * asociadas a la aplicaci贸n de Formaci贸n. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 28 oct 2026 + * + * + */ + +public class AppPrincipalFormacion { + + public static void main(String[] args) { + + try { + // Realizar el tratamiento de familias profesionales desde el fichero CSV + ProcesadorFicheroJSON procesadorCSV = new ProcesadorFicheroJSON(); + procesadorCSV.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(); + } + } + +} diff --git a/src/org/palomafp/aadd/inm/dao/ICicloFormativoDAO.java b/src/org/palomafp/aadd/inm/dao/ICicloFormativoDAO.java new file mode 100644 index 0000000..503da32 --- /dev/null +++ b/src/org/palomafp/aadd/inm/dao/ICicloFormativoDAO.java @@ -0,0 +1,19 @@ +package org.palomafp.aadd.inm.dao; + +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.model.CicloFormativo; + +/** + * + * ICicloFormativoDAO: Interfaz que contiene los m茅todos para obtener informaci贸n de los ciclos formativos desde un origen de datos. + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 26 sept 2026 + * + * + */ + +public interface ICicloFormativoDAO { + void insertarCicloFormativo(CicloFormativo cicloFormativo) throws FormacionException; + +} + diff --git a/src/org/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java b/src/org/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java new file mode 100644 index 0000000..ec493e3 --- /dev/null +++ b/src/org/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java @@ -0,0 +1,23 @@ +package org.palomafp.aadd.inm.dao; + +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.model.FamiliaProfesional; + +/** + * + * IFamiliaProfesionalDAO: Interfaz que contiene los m茅todos para obtener + * informaci贸n de continentes desde un origen de datos. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 26 sept 2026 + * + * + */ + +public interface IFamiliaProfesionalDAO { + void insertarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException; + + void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException; + + boolean existeFamiliaProfesionalPorClave(String codFamiliaProfesional) throws FormacionException; +} diff --git a/src/org/palomafp/aadd/inm/dao/ITipoFormacionDAO.java b/src/org/palomafp/aadd/inm/dao/ITipoFormacionDAO.java new file mode 100644 index 0000000..efb5bdb --- /dev/null +++ b/src/org/palomafp/aadd/inm/dao/ITipoFormacionDAO.java @@ -0,0 +1,18 @@ +package org.palomafp.aadd.inm.dao; + +import org.palomafp.aadd.inm.excepcion.FormacionException; + +/** + * + * ICicloFormativoDAO: Interfaz que contiene los m茅todos para obtener informaci贸n los tipos de formaci贸n existentes. + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 26 sept 2026 + * + * + */ + +public interface ITipoFormacionDAO { + boolean existeTipoFormacionPorClave(String codigoTipoFormacion) throws FormacionException; + +} + diff --git a/src/org/palomafp/aadd/inm/dao/impl/CicloFormativoDaoJDBC.java b/src/org/palomafp/aadd/inm/dao/impl/CicloFormativoDaoJDBC.java new file mode 100644 index 0000000..8aac8e4 --- /dev/null +++ b/src/org/palomafp/aadd/inm/dao/impl/CicloFormativoDaoJDBC.java @@ -0,0 +1,51 @@ +package org.palomafp.aadd.inm.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; + +import org.palomafp.aadd.inm.dao.ICicloFormativoDAO; +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.model.CicloFormativo; + +/** + * + * CicloFormativoDaoJDBC: Clase que realiza la implementaci贸n de la interfaz + * ICicloFormativoDAO para obtener informaci贸n de los ciclos formativos mediante + * conector JDBC. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 26 sept 2026 + * + * + */ + +public class CicloFormativoDaoJDBC implements ICicloFormativoDAO { + private final Connection conexion; + + public CicloFormativoDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + @Override + public void insertarCicloFormativo(CicloFormativo cicloFormativo) throws FormacionException { + + String sentenciaSQL = """ + INSERT INTO T_CICLO_FORMATIVO (codigo, nombre_corto, nombre_largo, horas_duracion, codigo_familia, codigo_tipo_formacion) + VALUES (?, ?, ?, ?, ?, ?) + """; +// System.out.println(sentenciaSQL); + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL);) { + sentenciaPreparada.setString(1, cicloFormativo.getCodigo()); + sentenciaPreparada.setString(2, cicloFormativo.getNombreCorto()); + sentenciaPreparada.setString(3, cicloFormativo.getNombreLargo()); + sentenciaPreparada.setInt(4, cicloFormativo.getNumeroHorasDuracion()); + sentenciaPreparada.setString(5, cicloFormativo.getFamiliaProfesional().getCodigo()); + sentenciaPreparada.setString(6, cicloFormativo.getTipoFormacion().getCodigo()); + sentenciaPreparada.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar un ciclo formativo.", e); + } + + } + +} diff --git a/src/org/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java b/src/org/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java new file mode 100644 index 0000000..39c96ed --- /dev/null +++ b/src/org/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java @@ -0,0 +1,91 @@ +package org.palomafp.aadd.inm.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.model.FamiliaProfesional; + +/** + * + * FamiliaProfesionalDaoJDBC: Clase que realiza la implementaci贸n de la interfaz + * IFamiliaProfesionalDAO para obtener informaci贸n de las familias profesionales + * usando conector JDBC. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 26 sept 2026 + * + * + */ + +public class FamiliaProfesionalDaoJDBC implements IFamiliaProfesionalDAO { + private final Connection conexion; + + public FamiliaProfesionalDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public boolean existeFamiliaProfesionalPorClave(String codFamiliaProfesional) throws FormacionException { + boolean existeFamiliaProfesional = false; + + String sentenciaSQL = """ + SELECT EXISTS( + SELECT 1 + FROM T_FAMILIA_PROFESIONAL + WHERE codigo = ? + ) AS existe_fp + """; +// System.out.println(sentenciaSQL); + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL);) { + sentenciaPreparada.setString(1, codFamiliaProfesional); + ResultSet resultados = sentenciaPreparada.executeQuery(); + if (resultados.next()) { + existeFamiliaProfesional = resultados.getBoolean("existe_fp"); + } + + } catch (SQLException e) { + throw new FormacionException("Error al validar si existe una familia profesional por c贸digo.", e); + } + + return existeFamiliaProfesional; + } + + @Override + public void insertarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException { + String sentenciaSQL = """ + INSERT INTO T_FAMILIA_PROFESIONAL (codigo, nombre) + VALUES (?, ?) + """; +// System.out.println(sentenciaSQL); + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL);) { + sentenciaPreparada.setString(1, familiaProfesional.getCodigo()); + sentenciaPreparada.setString(2, familiaProfesional.getNombre()); + sentenciaPreparada.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar una familia profesional.", e); + } + + } + + @Override + public void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException { + String sentenciaSQL = """ + UPDATE T_FAMILIA_PROFESIONAL + SET nombre = ? + WHERE codigo= ? + """; +// System.out.println(sentenciaSQL); + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL);) { + sentenciaPreparada.setString(1, familiaProfesional.getNombre()); + sentenciaPreparada.setString(2, familiaProfesional.getCodigo()); + sentenciaPreparada.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al actualizar una familia profesional.", e); + } + } + +} diff --git a/src/org/palomafp/aadd/inm/dao/impl/TipoFormacionDaoJDBC.java b/src/org/palomafp/aadd/inm/dao/impl/TipoFormacionDaoJDBC.java new file mode 100644 index 0000000..26bc8a8 --- /dev/null +++ b/src/org/palomafp/aadd/inm/dao/impl/TipoFormacionDaoJDBC.java @@ -0,0 +1,54 @@ +package org.palomafp.aadd.inm.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.inm.dao.ITipoFormacionDAO; +import org.palomafp.aadd.inm.excepcion.FormacionException; + +/** + * + * TipoFormacionDaoJDBC: Clase que realiza la implementaci贸n de la interfaz + * ITipoFormacionDAO para obtener informaci贸n de tipos de formaci贸n usando conector JDBC. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 26 sept 2026 + * + * + */ + +public class TipoFormacionDaoJDBC implements ITipoFormacionDAO { + private final Connection conexion; + + public TipoFormacionDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + @Override + public boolean existeTipoFormacionPorClave(String codigoTipoFormacion) throws FormacionException { + boolean existeTipoFormacion = false; + + String sentenciaSQL = """ + SELECT EXISTS( + SELECT 1 + FROM T_TIPO_FORMACION + WHERE codigo = ? + ) AS existe_tf + """; +// System.out.println(sentenciaSQL); + try (PreparedStatement sentenciaPreparada = conexion.prepareStatement(sentenciaSQL);) { + sentenciaPreparada.setString(1, codigoTipoFormacion); + ResultSet resultados = sentenciaPreparada.executeQuery(); + if (resultados.next()) { + existeTipoFormacion = resultados.getBoolean("existe_tf"); + } + + } catch (SQLException e) { + throw new FormacionException("Error al validar si existe un tipo de formaci贸n por c贸digo.", e); + } + + return existeTipoFormacion; + } + +} diff --git a/src/org/palomafp/aadd/inm/excepcion/FormacionException.java b/src/org/palomafp/aadd/inm/excepcion/FormacionException.java new file mode 100644 index 0000000..2598731 --- /dev/null +++ b/src/org/palomafp/aadd/inm/excepcion/FormacionException.java @@ -0,0 +1,25 @@ +package org.palomafp.aadd.inm.excepcion; + + +/** + * + * FormacionException: Clase abstracta que representa la excepci贸n base del proyecto Formacion + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 15 oct 2026 + * + * + */ + +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/inm/fichero/ProcesadorFicheroJSON.java b/src/org/palomafp/aadd/inm/fichero/ProcesadorFicheroJSON.java new file mode 100644 index 0000000..724370a --- /dev/null +++ b/src/org/palomafp/aadd/inm/fichero/ProcesadorFicheroJSON.java @@ -0,0 +1,59 @@ +package org.palomafp.aadd.inm.fichero; + +import java.io.File; +import java.io.IOException; + +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.gestor.GestorConfiguracion; +import org.palomafp.aadd.inm.model.FamiliaProfesional; +import org.palomafp.aadd.inm.service.FamiliaProfesionalService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +/** + * + * ProcesadorFicheroCSV: Clase que realiza el procesamiento de un fichero CSV + * para obtener informaci贸n de familias profesionales y realizar la inserci贸n o + * actualizaci贸n en la base de datos. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 6 nov 2026 + * + * + */ + +public class ProcesadorFicheroJSON { + public void realizarTratamientoFamiliasProfesionales() throws FormacionException { + + File ficheroFamiliasProfesionales = new File(GestorConfiguracion.getRutaFicheroCSVFamiliaProfesional()); + ObjectMapper mapper = new ObjectMapper(); + + try { + JsonNode nodoFamilias = mapper.readTree(ficheroFamiliasProfesionales); + for (JsonNode nodoFamilia : nodoFamilias) { + String codFamiliaProfesional = nodoFamilia.get("cod_tipo_fam").asText(); + String nombreFamiliaProfesional = nodoFamilia.get("nombre_tf").asText(); + + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codFamiliaProfesional); + familiaProfesional.setNombre(nombreFamiliaProfesional); + + // Realizaci贸n de la inserci贸n o actualizaci贸n de la familia profesional en la + // base de datos + FamiliaProfesionalService familiaProfesionalService = new FamiliaProfesionalService(); + boolean existeFP = familiaProfesionalService.existeFamiliaProfesionalPorClave(codFamiliaProfesional); + if (existeFP) { + System.out.println("Actualizando familia profesional: " + familiaProfesional); + + familiaProfesionalService.actualizarFamiliaProfesional(familiaProfesional); + } else { + System.out.println("Insertando la familia profesional: " + familiaProfesional); + familiaProfesionalService.insertarFamiliaProfesional(familiaProfesional); + } + } + } catch (IOException e) { + throw new FormacionException("Error al leer el fichero CSV de familias profesionales.", e); + } + } +} diff --git a/src/org/palomafp/aadd/inm/fichero/ProcesadorFicheroXML.java b/src/org/palomafp/aadd/inm/fichero/ProcesadorFicheroXML.java new file mode 100644 index 0000000..e8ff49d --- /dev/null +++ b/src/org/palomafp/aadd/inm/fichero/ProcesadorFicheroXML.java @@ -0,0 +1,85 @@ +package org.palomafp.aadd.inm.fichero; + +import java.io.File; + +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.gestor.GestorConfiguracion; +import org.palomafp.aadd.inm.model.CicloFormativo; +import org.palomafp.aadd.inm.model.FamiliaProfesional; +import org.palomafp.aadd.inm.model.TipoFormacion; +import org.palomafp.aadd.inm.service.CicloFormativoService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.dataformat.xml.XmlMapper; + +/** + * + * ProcesadorFicheroXL: Clase que realiza el procesamiento de un fichero XML + * para obtener informaci贸n de ciclos formativos y realizar la inserci贸n en la + * base de datos. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 6 nov 2026 + * + * + */ + +public class ProcesadorFicheroXML { + public void realizarTratamientoCiclosFormativos() throws FormacionException { + + JsonNode arbolXMLCatalogoFormacion = cargarArbolXMLFichero(); + + CicloFormativoService cicloFormativoService = new CicloFormativoService(); + + JsonNode listaCiclos = arbolXMLCatalogoFormacion.path("informacion_adicional").path("ciclos_formativos") + .path("ciclo"); + + for (JsonNode elementoCiclo : listaCiclos) { + + // Tratamiento de atributo y contenido de etiquetas con JsonNode + String codCicloFormativo = elementoCiclo.path("cod_cf").asText(); + String nombreCortoCicloFormativo = elementoCiclo.path("nomb_corto").asText(); + String nombreLargoCicloFormativo = elementoCiclo.path("nombrelargo").asText(); + String numeroHorasCF = elementoCiclo.path("num_horas_duracion").asText(); + String codigoFamiliaProfesional = elementoCiclo.path("codigo_familia").asText(); + String codigoTipoFormacion = elementoCiclo.path("codigo_tipoestudio").asText(); + + CicloFormativo cicloFormativo = new CicloFormativo(); + cicloFormativo.setCodigo(codCicloFormativo); + cicloFormativo.setNombreCorto(nombreCortoCicloFormativo); + cicloFormativo.setNombreLargo(nombreLargoCicloFormativo); + cicloFormativo.setNumeroHorasDuracion(Integer.parseInt(numeroHorasCF)); + + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codigoFamiliaProfesional); + cicloFormativo.setFamiliaProfesional(familiaProfesional); + + TipoFormacion tipoFormacion = new TipoFormacion(); + tipoFormacion.setCodigo(codigoTipoFormacion); + cicloFormativo.setTipoFormacion(tipoFormacion); + + System.out.println(cicloFormativo); + + cicloFormativoService.insertarCicloFormativo(cicloFormativo); + } + } + + private JsonNode cargarArbolXMLFichero() { + + JsonNode nodoRaiz = null; + + try { + XmlMapper xmlMapper = new XmlMapper(); + + File fichero = new File(GestorConfiguracion.getRutaFicheroXMLCatalogoFormacion()); + + nodoRaiz = xmlMapper.readTree(fichero); + + } catch (Exception e) { + e.printStackTrace(); + } + + return nodoRaiz; + } + +} diff --git a/src/org/palomafp/aadd/inm/gestor/GestorConexionesBBDD.java b/src/org/palomafp/aadd/inm/gestor/GestorConexionesBBDD.java new file mode 100644 index 0000000..2245945 --- /dev/null +++ b/src/org/palomafp/aadd/inm/gestor/GestorConexionesBBDD.java @@ -0,0 +1,35 @@ +package org.palomafp.aadd.inm.gestor; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +/** + * + * GestorConfiguracion: Clase que carga la configuraci贸n de la aplicaci贸n desde + * un fichero de propiedades + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 8 oct 2026 + * + * + */ + +public class GestorConexionesBBDD { + + // Constructor privado: de esta manera conseguimos que esta clase no se puede + // instanciar. + private GestorConexionesBBDD() { + } + + public static Connection obtenerConexion() throws SQLException { + Connection conexion = null; + + String urlConexionCompleta = GestorConfiguracion.getConexionURL() + GestorConfiguracion.getNombreBBDD(); + String usuarioBBDD = GestorConfiguracion.getUsuarioBBDD(); + String claveBBDD = GestorConfiguracion.getClaveBBDD(); + conexion = DriverManager.getConnection(urlConexionCompleta, usuarioBBDD, claveBBDD); + + return conexion; + } +} diff --git a/src/org/palomafp/aadd/inm/gestor/GestorConfiguracion.java b/src/org/palomafp/aadd/inm/gestor/GestorConfiguracion.java new file mode 100644 index 0000000..cc0f917 --- /dev/null +++ b/src/org/palomafp/aadd/inm/gestor/GestorConfiguracion.java @@ -0,0 +1,72 @@ +package org.palomafp.aadd.inm.gestor; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; + +/** + * + * GestorConfiguracion: Clase que carga la configuraci贸n de la aplicaci贸n desde + * un fichero de propiedades + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 8 oct 2026 + * + * + */ + +public class GestorConfiguracion { + private static final String RUTA_FICHERO_CONFIGURACION = "application.properties"; + private static final Properties PROPIEDADES_CONFIGURACION = new Properties(); + + // Constructor privado: de esta manera conseguimos que esta clase no se puede + // instanciar. + private GestorConfiguracion() { + } + + // Este bloque se ejecuta una sola vez, cuando se carga la clase + // GestorConfiguracion + static { + try (InputStream inputStream = GestorConfiguracion.class.getClassLoader().getResourceAsStream(RUTA_FICHERO_CONFIGURACION);) + { + + if (inputStream == null) { + throw new IOException( + "No se encuentra "+ RUTA_FICHERO_CONFIGURACION + " en el classpath"); + } + PROPIEDADES_CONFIGURACION.load(inputStream); + // System.out.println(PROPIEDADES_CONFIGURACION); + } catch (IOException e) { + throw new RuntimeException("No se ha podido cargar el fichero de configuraci贸n", e); + } + } + + public static String getClaseDriver() { + return PROPIEDADES_CONFIGURACION.getProperty("sgdb.clase.driver"); + } + + public static String getConexionURL() { + return PROPIEDADES_CONFIGURACION.getProperty("sgdb.conexion.url"); + } + + public static String getNombreBBDD() { + return PROPIEDADES_CONFIGURACION.getProperty("bbdd.nombre"); + } + + public static String getUsuarioBBDD() { + return PROPIEDADES_CONFIGURACION.getProperty("bbdd.usuario"); + } + + public static String getClaveBBDD() { + return PROPIEDADES_CONFIGURACION.getProperty("bbdd.clave"); + } + + public static String getRutaFicheroCSVFamiliaProfesional() { + return PROPIEDADES_CONFIGURACION.getProperty("familiaprofesional.csv.ruta"); + } + + public static String getRutaFicheroXMLCatalogoFormacion() { + return PROPIEDADES_CONFIGURACION.getProperty("catalogoformacion.xml.ruta"); + } + +} diff --git a/src/org/palomafp/aadd/inm/model/CicloFormativo.java b/src/org/palomafp/aadd/inm/model/CicloFormativo.java new file mode 100644 index 0000000..c602558 --- /dev/null +++ b/src/org/palomafp/aadd/inm/model/CicloFormativo.java @@ -0,0 +1,64 @@ +package org.palomafp.aadd.inm.model; + +/** + * + * CicloFormativo Clase que se asocia a la informaci贸n de un ciclo formativo. + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 24 sept 2026 + * + * + */ + +public class CicloFormativo { + private String codigo; + private String nombreCorto; + private String nombreLargo; + private int numeroHorasDuracion; + private FamiliaProfesional familiaProfesional; + private 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 getNumeroHorasDuracion() { + return numeroHorasDuracion; + } + public void setNumeroHorasDuracion(int numeroHorasDuracion) { + this.numeroHorasDuracion = numeroHorasDuracion; + } + 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 + + ", numeroHorasDuracion=" + numeroHorasDuracion + ", familiaProfesional=" + familiaProfesional + + ", tipoFormacion=" + tipoFormacion + "]"; + } + +} + diff --git a/src/org/palomafp/aadd/inm/model/FamiliaProfesional.java b/src/org/palomafp/aadd/inm/model/FamiliaProfesional.java new file mode 100644 index 0000000..894d41d --- /dev/null +++ b/src/org/palomafp/aadd/inm/model/FamiliaProfesional.java @@ -0,0 +1,39 @@ +package org.palomafp.aadd.inm.model; + +/** + * + * FamiliaProfesional: Clase que se asocia a la informaci贸n de una familia + * profesional. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 24 sept 2026 + * + * + */ + +public class FamiliaProfesional { + private String codigo; + private String 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/inm/model/TipoFormacion.java b/src/org/palomafp/aadd/inm/model/TipoFormacion.java new file mode 100644 index 0000000..80e8085 --- /dev/null +++ b/src/org/palomafp/aadd/inm/model/TipoFormacion.java @@ -0,0 +1,41 @@ +package org.palomafp.aadd.inm.model; + +/** + * + * TipoFormacion: Clase que se asocia a la informaci贸n de un Tipo de Formacion. + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 24 sept 2026 + * + * + */ + +public class TipoFormacion { + private String codigo; + private String nombreCorto; + private String 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/inm/service/CicloFormativoService.java b/src/org/palomafp/aadd/inm/service/CicloFormativoService.java new file mode 100644 index 0000000..ebc0d1b --- /dev/null +++ b/src/org/palomafp/aadd/inm/service/CicloFormativoService.java @@ -0,0 +1,51 @@ +package org.palomafp.aadd.inm.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.inm.dao.ICicloFormativoDAO; +import org.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.inm.dao.ITipoFormacionDAO; +import org.palomafp.aadd.inm.dao.impl.CicloFormativoDaoJDBC; +import org.palomafp.aadd.inm.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.inm.dao.impl.TipoFormacionDaoJDBC; +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.gestor.GestorConexionesBBDD; +import org.palomafp.aadd.inm.model.CicloFormativo; + +/** + * + * CicloFormativoService: Clase que se encarga de las operaciones de servicio de un Ciclo Formativo + * (Casos de uso de CicloFormativo). + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 29 oct 2026 + * + * + */ + +public class CicloFormativoService { + public void insertarCicloFormativo(CicloFormativo cicloFormativo) throws FormacionException { + + try (Connection conexion = GestorConexionesBBDD.obtenerConexion();) { + // Comprobar que existe la familia profesional + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + boolean existeFamiliaProfesional = false; + existeFamiliaProfesional = iFamiliaProfesionalDAO.existeFamiliaProfesionalPorClave(cicloFormativo.getFamiliaProfesional().getCodigo()); + + // Comprobar que existe el tipo de formaci贸n + boolean existeTipoFormacion= false; + ITipoFormacionDAO iTipoFormacionDAO= new TipoFormacionDaoJDBC(conexion); + existeTipoFormacion= iTipoFormacionDAO.existeTipoFormacionPorClave(cicloFormativo.getTipoFormacion().getCodigo()); + + // Insertar el ciclo formativo si existen la familia profesional y el tipo de formaci贸n + ICicloFormativoDAO iCicloFormativoDAO = new CicloFormativoDaoJDBC(conexion); + if(existeFamiliaProfesional && existeTipoFormacion) { + iCicloFormativoDAO.insertarCicloFormativo(cicloFormativo); + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexi贸n", e); + } + } + +} diff --git a/src/org/palomafp/aadd/inm/service/FamiliaProfesionalService.java b/src/org/palomafp/aadd/inm/service/FamiliaProfesionalService.java new file mode 100644 index 0000000..b46889f --- /dev/null +++ b/src/org/palomafp/aadd/inm/service/FamiliaProfesionalService.java @@ -0,0 +1,56 @@ +package org.palomafp.aadd.inm.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.inm.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.inm.excepcion.FormacionException; +import org.palomafp.aadd.inm.gestor.GestorConexionesBBDD; +import org.palomafp.aadd.inm.model.FamiliaProfesional; + +/** + * + * FamiliaProfesionalService: Clase que se encarga de las operaciones de + * servicio de una Familia Profesional. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 29 oct 2026 + * + * + */ + +public class FamiliaProfesionalService { + public boolean existeFamiliaProfesionalPorClave(String codFamiliaProfesional) throws FormacionException { + boolean existeFP = false; + + try (Connection conexion = GestorConexionesBBDD.obtenerConexion();) { + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + existeFP = iFamiliaProfesionalDAO.existeFamiliaProfesionalPorClave(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 = GestorConexionesBBDD.obtenerConexion();) { + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + iFamiliaProfesionalDAO.insertarFamiliaProfesional(familiaProfesional); + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexi贸n", e); + } + } + + public void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional) throws FormacionException { + + try (Connection conexion = GestorConexionesBBDD.obtenerConexion();) { + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(conexion); + iFamiliaProfesionalDAO.actualizarFamiliaProfesional(familiaProfesional); + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexi贸n", e); + } + } + +}