From dc2295e002a4f5849dcd8417255b0e2aed69878d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Isidoro=20Nevares=20Mart=C3=ADn?= Date: Mon, 10 Nov 2025 12:14:55 +0100 Subject: [PATCH] primer commit --- .classpath | 22 ++ .gitignore | 2 + .project | 23 ++ .settings/org.eclipse.jdt.core.prefs | 12 ++ .settings/org.eclipse.m2e.core.prefs | 4 + config/conf.properties | 9 + pom.xml | 32 +++ recursos/Formacion.sql | 59 ++++++ src/es/palomafp/aadd/inm/GestorFormacion.java | 87 ++++++++ src/es/palomafp/aadd/inm/dao/ICicloDAO.java | 23 ++ .../aadd/inm/dao/IFamiliaProfesionalDAO.java | 24 +++ src/es/palomafp/aadd/inm/dao/IGradoDAO.java | 19 ++ .../aadd/inm/dao/impl/CicloDaoJDBC.java | 179 ++++++++++++++++ .../aadd/inm/dao/impl/CicloDaoTXT.java | 99 +++++++++ .../dao/impl/FamiliaProfesionalDaoCSV.java | 197 ++++++++++++++++++ .../dao/impl/FamiliaProfesionalDaoJDBC.java | 130 ++++++++++++ .../aadd/inm/dao/impl/GradoDaoCSV.java | 75 +++++++ .../aadd/inm/dao/impl/GradoDaoJDBC.java | 81 +++++++ .../aadd/inm/gestor/GestorConexionJDBC.java | 39 ++++ .../gestor/GestorFicheroConfiguracion.java | 44 ++++ .../ProcesadorCicloGradoXML.java | 127 +++++++++++ src/es/palomafp/aadd/inm/vo/Ciclo.java | 66 ++++++ .../aadd/inm/vo/FamiliaProfesional.java | 47 +++++ src/es/palomafp/aadd/inm/vo/Grado.java | 38 ++++ 24 files changed, 1438 insertions(+) create mode 100644 .classpath create mode 100644 .gitignore create mode 100644 .project create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.eclipse.m2e.core.prefs create mode 100644 config/conf.properties create mode 100644 pom.xml create mode 100644 recursos/Formacion.sql create mode 100644 src/es/palomafp/aadd/inm/GestorFormacion.java create mode 100644 src/es/palomafp/aadd/inm/dao/ICicloDAO.java create mode 100644 src/es/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java create mode 100644 src/es/palomafp/aadd/inm/dao/IGradoDAO.java create mode 100644 src/es/palomafp/aadd/inm/dao/impl/CicloDaoJDBC.java create mode 100644 src/es/palomafp/aadd/inm/dao/impl/CicloDaoTXT.java create mode 100644 src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoCSV.java create mode 100644 src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java create mode 100644 src/es/palomafp/aadd/inm/dao/impl/GradoDaoCSV.java create mode 100644 src/es/palomafp/aadd/inm/dao/impl/GradoDaoJDBC.java create mode 100644 src/es/palomafp/aadd/inm/gestor/GestorConexionJDBC.java create mode 100644 src/es/palomafp/aadd/inm/gestor/GestorFicheroConfiguracion.java create mode 100644 src/es/palomafp/aadd/inm/procesamiento/ProcesadorCicloGradoXML.java create mode 100644 src/es/palomafp/aadd/inm/vo/Ciclo.java create mode 100644 src/es/palomafp/aadd/inm/vo/FamiliaProfesional.java create mode 100644 src/es/palomafp/aadd/inm/vo/Grado.java diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..7b55102 --- /dev/null +++ b/.classpath @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9f1d3ca --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/target/ +*.class \ No newline at end of file diff --git a/.project b/.project new file mode 100644 index 0000000..55dadc5 --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ + + + aadd_act2_5 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..a1bee5a --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=24 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=24 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=24 diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000..f897a7f --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/config/conf.properties b/config/conf.properties new file mode 100644 index 0000000..8c402a3 --- /dev/null +++ b/config/conf.properties @@ -0,0 +1,9 @@ +# Informaci髇 sobre fichero XML ciclo-grado.xml +ciclogrado.fichero.ruta=C:\\Users\\ineva\\INM\\tmp\\dam2\\aadd\\act25\\ciclo_grado.xml + +# Par醡etros de conexi髇 a la base de datos 'formacion' en SGDB MySQL (tabla de familias profesionales) +jdbc.driver = com.mysql.cj.jdbc.Driver +jdbc.url = jdbc:mysql://192.168.1.36:3306/formacion +jdbc.usuario = root +jdbc.password = mysql_123 + diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..1ff8236 --- /dev/null +++ b/pom.xml @@ -0,0 +1,32 @@ + + 4.0.0 + aadd_act2_4 + aadd_act2_4 + 0.0.1-SNAPSHOT + + + + com.mysql + mysql-connector-j + 9.5.0 + + + + tools.jackson.dataformat + jackson-dataformat-xml + 3.0.1 + + + + src + + + maven-compiler-plugin + 3.13.0 + + 24 + + + + + \ No newline at end of file diff --git a/recursos/Formacion.sql b/recursos/Formacion.sql new file mode 100644 index 0000000..d39e1b8 --- /dev/null +++ b/recursos/Formacion.sql @@ -0,0 +1,59 @@ +CREATE DATABASE formacion; +USE formacion; + +-- Tabla: T_FAMILIA_PROFESIONAL +CREATE TABLE T_FAMILIA_PROFESIONAL ( + codigo CHAR(5) PRIMARY KEY, + nombre VARCHAR(255) NOT NULL, + url_img_logo VARCHAR(255) DEFAULT NULL +); + +-- Tabla: T_GRADO +create table T_GRADO( + codigo CHAR(5) PRIMARY KEY, + nombre VARCHAR(255) NOT NULL, + categoria CHAR(1) NOT NULL +); + +-- Tabla: T_CICLO +CREATE TABLE T_CICLO( + codigo CHAR(5) PRIMARY KEY, + descripcion VARCHAR(255) NOT NULL, + numero_horas INT NOT NULL, + cod_grado CHAR(5) NOT NULL, + cod_familia_profesional CHAR(5) NOT NULL, + CONSTRAINT FK_CICLO_FAMILIAPROFESIONAL + FOREIGN KEY (cod_familia_profesional) REFERENCES T_FAMILIA_PROFESIONAL(codigo), + CONSTRAINT FK_CICLO_GRADO + FOREIGN KEY (cod_grado) REFERENCES T_GRADO(codigo) +); + +INSERT INTO T_FAMILIA_PROFESIONAL (codigo, nombre, url_img_logo) VALUES + ('ADG', 'Administraci贸n y Gesti贸n', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/adg/jcr:content/adg.png.png'), + ('AFD', 'Actividades F铆sicas y Deportivas', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/afd/jcr:content/afd.png.png'), + ('AGA', 'Agraria', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/aga/jcr:content/aga.png.png'), + ('ARG', 'Artes Gr谩ficas', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/arg/jcr:content/arg.png.png'), + ('ART', 'Artes y Artesan铆as', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/art/jcr:content/art.png.png'), + ('COM', 'Comercio y Marketing', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/com/jcr:content/com.png.png'), + ('EOC', 'Edificaci贸n y Obra Civil', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/eoc/jcr:content/eoc.png.png'), + ('ELE', 'Electricidad y Electr贸nica', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ele/jcr:content/ele.png.png'), + ('ENA', 'Energ铆a y Agua', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ena/jcr:content/ena.png.png'), + ('FME', 'Fabricaci贸n Mec谩nica', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/fme/jcr:content/fme.png.png'), + ('HOT', 'Hosteler铆a y Turismo', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/hot/jcr:content/hot.png.png'), + ('IMP', 'Imagen Personal', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/imp/jcr:content/imp.png.png'), + ('IMS', 'Imagen y Sonido', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ims/jcr:content/ims.png.png'), + ('INA', 'Industrias Alimentarias', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ina/jcr:content/ina.png.png'), + ('IEX', 'Industrias Extractivas', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/iex/jcr:content/iex.png.png'), + ('IFC', 'Inform谩tica y Comunicaciones', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ifc/jcr:content/ifc.png.png'), + ('IMA', 'Instalaci贸n y Mantenimiento', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ima/jcr:content/ima.png.png'), + ('MAM', 'Madera, Mueble y Corcho', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/mam/jcr:content/mam.png.png'), + ('MAP', 'Mar铆timo-Pesquera', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/map/jcr:content/map.png.png'), + ('QUI', 'Qu铆mica', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/qui/jcr:content/qui.png.png'), + ('SAN', 'Sanidad', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/san/jcr:content/san.png.png'), + ('SEA', 'Seguridad y Medio Ambiente', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/sea/jcr:content/sea.png.png'), + ('SSC', 'Servicios Socioculturales y a la Comunidad', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/ssc/jcr:content/ssc.png.png'), + ('TCP', 'Textil, Confecci贸n y Piel', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/tcp/jcr:content/tcp.png.png'), + ('TMV', 'Transporte y Mantenimiento de Veh铆culos', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/tmv/jcr:content/tmv.png.png'), + ('VIC', 'Vidrio y Cer谩mica', 'https://www.todofp.es/.imaging/mte/todofp-theme/contenido-cgi-pqm/dam/todofp/comunes/familias-new/verticales-nombre/vic/jcr:content/vic.png.png'); + + diff --git a/src/es/palomafp/aadd/inm/GestorFormacion.java b/src/es/palomafp/aadd/inm/GestorFormacion.java new file mode 100644 index 0000000..d4caf41 --- /dev/null +++ b/src/es/palomafp/aadd/inm/GestorFormacion.java @@ -0,0 +1,87 @@ +package es.palomafp.aadd.inm; + +import java.util.List; + +import es.palomafp.aadd.inm.dao.ICicloDAO; +import es.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import es.palomafp.aadd.inm.dao.impl.CicloDaoJDBC; +import es.palomafp.aadd.inm.dao.impl.FamiliaProfesionalDaoJDBC; +import es.palomafp.aadd.inm.procesamiento.ProcesadorCicloGradoXML; +import es.palomafp.aadd.inm.vo.Ciclo; +import es.palomafp.aadd.inm.vo.FamiliaProfesional; + +/** + * + * GestorFormacion: Clase que se encarga de gestionar Formaci贸n (Familias, + * Grados y Ciclos) + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 2 oct 2025 + */ +public class GestorFormacion { + public static void main(String[] args) { + // Se procesa el fichero XML ciclo_grado.xml + ProcesadorCicloGradoXML procesadorCicloGradoXML = new ProcesadorCicloGradoXML(); + procesadorCicloGradoXML.procesarFicheroXML(); + + String operacion = args[0]; // L: Listar, C: Consultar, I: Insertar, B: Borrar, M: Modificar + String parametro1 = args[1]; + String parametro2 = args[2]; + + // Se declaran las variables como Interfaces y se construyen como + // implementaciones. + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(); + + + switch (operacion) { + case "L": + List listaFamilias = iFamiliaProfesionalDAO.obtenerListaFamiliasProfesionales(); + System.out.println(listaFamilias); + + break; + case "C": { + FamiliaProfesional familiaProfesional = iFamiliaProfesionalDAO.obtenerFamiliaProfesionalPorCodigo(parametro1); + System.out.println(familiaProfesional); + + break; + } + case "I": { + FamiliaProfesional familiaProfesional = iFamiliaProfesionalDAO.obtenerFamiliaProfesionalPorCodigo(parametro1); + // Si el c贸digo existe en el fichero se lanza mensaje + if (familiaProfesional != null) { + System.out.println("El c贸digo de familia profesional ya existe."); + } else { // Inserci贸n + familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(parametro1); + familiaProfesional.setNombre(parametro2); + iFamiliaProfesionalDAO.insertarFamiliaProfesional(familiaProfesional); + } + + break; + } + case "B": { + iFamiliaProfesionalDAO.eliminarFamiliaProfesional(parametro1); + break; + } + case "M": { + FamiliaProfesional familiaProfesional = iFamiliaProfesionalDAO.obtenerFamiliaProfesionalPorCodigo(parametro1); + familiaProfesional.setCodigo(parametro1); + familiaProfesional.setNombre(parametro2); + iFamiliaProfesionalDAO.actualizarFamiliaProfesional(familiaProfesional); + break; + } + case "1": { + ICicloDAO iCicloDAO = new CicloDaoJDBC(); + List listaCiclos = iCicloDAO.obtenerListaCiclosPorFamiliaGrado(parametro1, parametro2); + for (Ciclo ciclo : listaCiclos) { + String textoImprimir = "El ciclo %s incluido en la familia de %s es un %s de la categor铆a %s"; + textoImprimir = String.format(textoImprimir, ciclo.getDescripcion(), ciclo.getFamilia().getNombre(), + ciclo.getGrado().getNombre(), ciclo.getGrado().getCategoria()); + System.out.println(textoImprimir); + } + break; + } + } + + } +} diff --git a/src/es/palomafp/aadd/inm/dao/ICicloDAO.java b/src/es/palomafp/aadd/inm/dao/ICicloDAO.java new file mode 100644 index 0000000..6a1c2c8 --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/ICicloDAO.java @@ -0,0 +1,23 @@ +package es.palomafp.aadd.inm.dao; + +import java.util.List; + +import es.palomafp.aadd.inm.vo.Ciclo; + +/** + * + * ICicloDAO: Interfaz que contiene las operaciones a realizar sobre un Ciclo + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public interface ICicloDAO { + Ciclo obtenerCicloPorCodigo(String codigoCiclo); + List obtenerListaCiclosPorFamiliaGrado(String codigoFamilia, String codigoGrado); + void insertarCiclo(Ciclo ciclo); + void actualizarCiclo(Ciclo ciclo); +} + diff --git a/src/es/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java b/src/es/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java new file mode 100644 index 0000000..1ff345d --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/IFamiliaProfesionalDAO.java @@ -0,0 +1,24 @@ +package es.palomafp.aadd.inm.dao; + +import java.util.List; + +import es.palomafp.aadd.inm.vo.FamiliaProfesional; + +/** + * + * IFamiliaProfesionalDAO: Interfaz que contiene las operaciones a realizar + * sobre una Familia Profesional. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public interface IFamiliaProfesionalDAO { + FamiliaProfesional obtenerFamiliaProfesionalPorCodigo(String codigoFamilia); + List obtenerListaFamiliasProfesionales(); + void insertarFamiliaProfesional(FamiliaProfesional familiaProfesional); + void eliminarFamiliaProfesional(String codigoFamiliia); + void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional); +} diff --git a/src/es/palomafp/aadd/inm/dao/IGradoDAO.java b/src/es/palomafp/aadd/inm/dao/IGradoDAO.java new file mode 100644 index 0000000..c454a53 --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/IGradoDAO.java @@ -0,0 +1,19 @@ +package es.palomafp.aadd.inm.dao; + +import es.palomafp.aadd.inm.vo.Grado; + +/** + * + * IGradoDAO: Interfaz que contiene las operaciones a realizar sobre un Grado. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public interface IGradoDAO { + Grado obtenerGradoPorCodigo(String codigoGrado); + void actualizarGrado(Grado grado); + void insertarGrado(Grado grado); +} diff --git a/src/es/palomafp/aadd/inm/dao/impl/CicloDaoJDBC.java b/src/es/palomafp/aadd/inm/dao/impl/CicloDaoJDBC.java new file mode 100644 index 0000000..4739520 --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/impl/CicloDaoJDBC.java @@ -0,0 +1,179 @@ +package es.palomafp.aadd.inm.dao.impl; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.List; + +import es.palomafp.aadd.inm.dao.ICicloDAO; +import es.palomafp.aadd.inm.gestor.GestorConexionJDBC; +import es.palomafp.aadd.inm.vo.Ciclo; +import es.palomafp.aadd.inm.vo.FamiliaProfesional; +import es.palomafp.aadd.inm.vo.Grado; + +/** + * + * CicloDaoJDBC: Clase que implementa las operaciones del interfaz ICicloDAO + * para JDBC. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 10 nov 2025 + * + * + */ + +public class CicloDaoJDBC implements ICicloDAO { + + @Override + public Ciclo obtenerCicloPorCodigo(String codigoCiclo) { + Ciclo ciclo = null; + String sentenciaSQL = """ + SELECT c.codigo as codigo_ciclo, c.descripcion, c.numero_horas, + fp.codigo AS codigo_familia_profesional, fp.nombre AS nombre_familia_profesional, fp.url_img_logo, + g.codigo AS codigo_grado, g.nombre AS nombre_grado, g.categoria + FROM T_CICLO c join T_FAMILIA_PROFESIONAL fp + ON c.cod_familia_profesional = fp.codigo + join T_GRADO g + ON c.cod_grado = g.codigo + WHERE c.codigo = '%s' + """; + sentenciaSQL = String.format(sentenciaSQL, codigoCiclo); + + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement statement = conexion.createStatement(); + ResultSet resultado = statement.executeQuery(sentenciaSQL);) { + if (resultado.next()) { + // Informaci贸n del ciclo + String descripcion = resultado.getString("descripcion"); + String numeroHoras = resultado.getString("numero_horas"); + ciclo = new Ciclo(); + ciclo.setCodigo(codigoCiclo); + ciclo.setDescripcion(descripcion); + ciclo.setNumeroHoras(Integer.parseInt(numeroHoras)); + // Informaci贸n del Familia Profesional + String codFamilia = resultado.getString("codigo_familia_profesional"); + String nombreFamilia = resultado.getString("nombre_familia_profesional"); + String urlImgLogo = resultado.getString("url_img_logo"); + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codFamilia); + familiaProfesional.setNombre(nombreFamilia); + familiaProfesional.setUrlImageLogo(urlImgLogo); + ciclo.setFamilia(familiaProfesional); + + // Informaci贸n del grado + String codGrado = resultado.getString("codigo_grado"); + String nombreGrado = resultado.getString("nombre_grado"); + String categotia = resultado.getString("categoria"); + Grado grado = new Grado(); + grado.setCodigo(codGrado); + grado.setNombre(nombreGrado); + grado.setCategoria(categotia); + ciclo.setGrado(grado); + + } + } catch (SQLException e) { + e.printStackTrace(); + + } + return ciclo; + } + + @Override + public List obtenerListaCiclosPorFamiliaGrado(String codigoFamilia, String codigoGrado) { + List listaCiclos = null; + String sentenciaSQL = """ + SELECT c.codigo as codigo_ciclo, c.descripcion, c.numero_horas, + fp.codigo AS codigo_familia_profesional, fp.nombre AS nombre_familia_profesional, fp.url_img_logo, + g.codigo AS codigo_grado, g.nombre AS nombre_grado, g.categoria + FROM T_CICLO c join T_FAMILIA_PROFESIONAL fp + ON c.cod_familia_profesional = fp.codigo + join T_GRADO g + ON c.cod_grado = g.codigo + WHERE c.cod_grado = '%s' and cod_familia_profesional = '%s' + """; + sentenciaSQL = String.format(sentenciaSQL, codigoFamilia, codigoGrado); + // System.out.println(sentenciaSQL); + + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement statement = conexion.createStatement(); + ResultSet resultado = statement.executeQuery(sentenciaSQL);) { + listaCiclos = new java.util.ArrayList(); + while (resultado.next()) { + // Informaci贸n del ciclo + String codigoCiclo = resultado.getString("codigo_ciclo"); + String descripcion = resultado.getString("descripcion"); + String numeroHoras = resultado.getString("numero_horas"); + Ciclo ciclo = new Ciclo(); + ciclo.setCodigo(codigoCiclo); + ciclo.setDescripcion(descripcion); + ciclo.setNumeroHoras(Integer.parseInt(numeroHoras)); + + // Informaci贸n del Familia Profesional + String codFamilia = resultado.getString("codigo_familia_profesional"); + String nombreFamilia = resultado.getString("nombre_familia_profesional"); + String urlImgLogo = resultado.getString("url_img_logo"); + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codFamilia); + familiaProfesional.setNombre(nombreFamilia); + familiaProfesional.setUrlImageLogo(urlImgLogo); + ciclo.setFamilia(familiaProfesional); + + // Informaci贸n del grado + String codGrado = resultado.getString("codigo_grado"); + String nombreGrado = resultado.getString("nombre_grado"); + String categotia = resultado.getString("categoria"); + Grado grado = new Grado(); + grado.setCodigo(codGrado); + grado.setNombre(nombreGrado); + grado.setCategoria(categotia); + ciclo.setGrado(grado); + + // A帽adir ciclo a la lista + listaCiclos.add(ciclo); + + } + } catch (SQLException e) { + e.printStackTrace(); + + } + return listaCiclos; + } + + @Override + public void insertarCiclo(Ciclo ciclo) { + String sentenciaSQL = "INSERT INTO T_CICLO (codigo, descripcion, numero_horas, cod_grado, cod_familia_profesional) values ('%s', '%s', %d, '%s', '%s')"; + sentenciaSQL = String.format(sentenciaSQL, ciclo.getCodigo(), ciclo.getDescripcion(), ciclo.getNumeroHoras(), + ciclo.getGrado().getCodigo(), ciclo.getFamilia().getCodigo()); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public void actualizarCiclo(Ciclo ciclo) { + String sentenciaSQL = """ + UPDATE T_CICLO + set descripcion= '%s', numero_horas=%d, cod_grado='%s', cod_familia_profesional='%s' + WHERE codigo='%s' + """; + sentenciaSQL = String.format(sentenciaSQL, ciclo.getDescripcion(), ciclo.getNumeroHoras(), + ciclo.getGrado().getCodigo(), ciclo.getFamilia().getCodigo(), ciclo.getCodigo()); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + } + +} diff --git a/src/es/palomafp/aadd/inm/dao/impl/CicloDaoTXT.java b/src/es/palomafp/aadd/inm/dao/impl/CicloDaoTXT.java new file mode 100644 index 0000000..7d31a37 --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/impl/CicloDaoTXT.java @@ -0,0 +1,99 @@ +package es.palomafp.aadd.inm.dao.impl; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; + +import es.palomafp.aadd.inm.dao.ICicloDAO; +import es.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import es.palomafp.aadd.inm.dao.IGradoDAO; +import es.palomafp.aadd.inm.gestor.GestorFicheroConfiguracion; +import es.palomafp.aadd.inm.vo.Ciclo; +import es.palomafp.aadd.inm.vo.FamiliaProfesional; +import es.palomafp.aadd.inm.vo.Grado; + +/** + * + * Ciclo: Clase que implementa las operaciones del interfaz ICicloDAO. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public class CicloDaoTXT implements ICicloDAO { + private final static String RUTA_FICHERO_CICLOS = GestorFicheroConfiguracion.getValorfromClave("ciclo.fichero.ruta"); + private static final String DELIMITADOR = GestorFicheroConfiguracion.getValorfromClave("ciclo.fichero.separador");; + + private Path pathFichero = Paths.get(RUTA_FICHERO_CICLOS); + + @Override + public Ciclo obtenerCicloPorCodigo(String codigoCiclo) { + // TODO Auto-generated method stub + return null; + } + + @Override + public List obtenerListaCiclosPorFamiliaGrado(String codigoFamilia, String codigoGrado) { + List listaCiclos = null; + + List lineas; + try { + lineas = Files.readAllLines(pathFichero, StandardCharsets.UTF_8); + List lineasSinCabecera = lineas.subList(1, lineas.size()); + + if (!lineasSinCabecera.isEmpty()) { + listaCiclos = new ArrayList(); + IGradoDAO iGradoDAO = new GradoDaoCSV(); + IFamiliaProfesionalDAO iFamiliaProfesionalDAO = new FamiliaProfesionalDaoJDBC(); + for (String linea : lineasSinCabecera) { + // Procesar informaci贸n de Ciclo + String[] camposCiclo = linea.split(DELIMITADOR); + String codCiclo = camposCiclo[0].strip(); + String nombreCiclo = camposCiclo[1].strip(); + String numeroHoras = camposCiclo[2].strip(); + String codFamilia = camposCiclo[3].strip(); + String codGrado = camposCiclo[4].strip(); + + if ((codigoFamilia != null && codigoFamilia.equals(codFamilia)) + && (codigoGrado != null && codigoGrado.equals(codGrado))) { + Ciclo ciclo = new Ciclo(); + FamiliaProfesional familiaProfesional = iFamiliaProfesionalDAO + .obtenerFamiliaProfesionalPorCodigo(codigoFamilia); + Grado grado = iGradoDAO.obtenerGradoPorCodigo(codGrado); + ciclo.setCodigo(codCiclo); + ciclo.setDescripcion(nombreCiclo); + ciclo.setNumeroHoras(Integer.parseInt(numeroHoras)); + ciclo.setFamilia(familiaProfesional); + ciclo.setGrado(grado); + + listaCiclos.add(ciclo); + } + } + } + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + RUTA_FICHERO_CICLOS); + e.printStackTrace(); + } + + return listaCiclos; + } + + @Override + public void insertarCiclo(Ciclo ciclo) { + // TODO Auto-generated method stub + + } + + @Override + public void actualizarCiclo(Ciclo ciclo) { + // TODO Auto-generated method stub + + } + +} diff --git a/src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoCSV.java b/src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoCSV.java new file mode 100644 index 0000000..1a2cce3 --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoCSV.java @@ -0,0 +1,197 @@ +package es.palomafp.aadd.inm.dao.impl; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; +import java.nio.file.StandardOpenOption; +import java.util.ArrayList; +import java.util.List; + +import es.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import es.palomafp.aadd.inm.gestor.GestorFicheroConfiguracion; +import es.palomafp.aadd.inm.vo.FamiliaProfesional; + +/** + * + * FamiliaProfesionalDao: Clase que implementa las operaciones del interfaz + * IFamiliaProfesionalDAO. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public class FamiliaProfesionalDaoCSV implements IFamiliaProfesionalDAO { + private final static String RUTA_FICHERO_FAMILIAS_PROFESIONALES =GestorFicheroConfiguracion.getValorfromClave("familiaprofesional.fichero.ruta"); + private final static String RUTA_FICHERO_TMP_FAMILIAS_PROFESIONALES = GestorFicheroConfiguracion.getValorfromClave("familiaprofesional.ficherotmp.ruta"); + private static final String DELIMITADOR = GestorFicheroConfiguracion.getValorfromClave("familiaprofesional.fichero.separador");; + + private Path pathFichero = Paths.get(RUTA_FICHERO_FAMILIAS_PROFESIONALES); + private Path pathFicheroTMP = Paths.get(RUTA_FICHERO_TMP_FAMILIAS_PROFESIONALES); + + @Override + public FamiliaProfesional obtenerFamiliaProfesionalPorCodigo(String codigoFamilia) { + FamiliaProfesional familiaProfesional = null; + + List lineas; + try { + lineas = Files.readAllLines(pathFichero, StandardCharsets.UTF_8); + List lineasSinCabecera = lineas.subList(1, lineas.size()); + + for (String linea : lineasSinCabecera) { + // Procesar informaci贸n de la Familia Profesional + String[] camposFamilia = linea.split(DELIMITADOR); + String codFamilia = camposFamilia[0].trim(); + String nombreFamilia = camposFamilia[1].trim(); + + if (codigoFamilia != null && codigoFamilia.equals(codFamilia)) { + familiaProfesional = new FamiliaProfesional(); + + familiaProfesional.setCodigo(codFamilia); + familiaProfesional.setNombre(nombreFamilia); + + break; + } + } + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + RUTA_FICHERO_FAMILIAS_PROFESIONALES); + e.printStackTrace(); + } + + return familiaProfesional; + } + + @Override + public List obtenerListaFamiliasProfesionales() { + List listaFamilias = null; + + List lineas; + try { + lineas = Files.readAllLines(pathFichero, StandardCharsets.UTF_8); + List lineasSinCabecera = lineas.subList(1, lineas.size()); + if (!lineasSinCabecera.isEmpty()) { + listaFamilias = new ArrayList<>(); + for (String linea : lineasSinCabecera) { + // Procesar informaci贸n de la Familia Profesional + String[] camposFamilia = linea.split(DELIMITADOR); + String codFamilia = camposFamilia[0].trim(); + String nombreFamilia = camposFamilia[1].trim(); + + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + + familiaProfesional.setCodigo(codFamilia); + familiaProfesional.setNombre(nombreFamilia); +// System.out.println("familiaProfesional: " + familiaProfesional); + + + listaFamilias.add(familiaProfesional); + } + } + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + RUTA_FICHERO_FAMILIAS_PROFESIONALES); + e.printStackTrace(); + } + + return listaFamilias; + } + + /** + * Inserta una nueva familia profesional en el fichero CSV. + * + * @param familiaProfesional Familia profesional a insertar. + */ + public void insertarFamiliaProfesional(FamiliaProfesional familiaProfesional) { + String nuevaFamilia = String.format("%s%s%s\n", familiaProfesional.getCodigo(),DELIMITADOR, familiaProfesional.getNombre()); + + try { + Files.writeString(pathFichero, nuevaFamilia, StandardOpenOption.CREATE, StandardOpenOption.APPEND); + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + RUTA_FICHERO_FAMILIAS_PROFESIONALES); + e.printStackTrace(); + } + } + + /** + * Elimina una familia profesional del fichero CSV. + * + * @param codigoFamilia C贸digo de la familia profesional a eliminar. + */ + public void eliminarFamiliaProfesional(String codigoFamilia) { + List listaFamilias = obtenerListaFamiliasProfesionales(); + + if (listaFamilias != null) { + listaFamilias.removeIf(familiaProfesional -> familiaProfesional.getCodigo().equals(codigoFamilia)); + + insertarFamiliasProfesionalesFichero(listaFamilias); + } + } + + /** + * Actualiza el nombre de una familia profesional. + * + * @param familiaProfesional Familia profesional con el c贸digo y el nuevo + * nombre. + */ + public void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional) { + List listaFamilias = obtenerListaFamiliasProfesionales(); + + // Se cambia el valor del nombre de la familia. + for (FamiliaProfesional familiaProf : listaFamilias) { + if (familiaProf.getCodigo().equals(familiaProfesional.getCodigo())) { + familiaProf.setNombre(familiaProfesional.getNombre()); + } + } + + insertarFamiliasProfesionalesFichero(listaFamilias); + } + + /** + * Inserta la lista de familias profesionales en el fichero CSV. Para ello + * primero crea un fichero temporal y luego renombra el fichero temporal al + * original. + * + * @param listaFamilias Lista de familias profesionales a insertar. + */ + private void insertarFamiliasProfesionalesFichero(List listaFamilias) { + + try { + String cabecera = String.format("codigo_familia|nombre_familia\n"); + + Files.writeString(pathFicheroTMP, cabecera, StandardOpenOption.CREATE, StandardOpenOption.APPEND); + + for (FamiliaProfesional familiaProfesional : listaFamilias) { + String nuevaFamilia = String.format("%s%s%s\n", familiaProfesional.getCodigo(), DELIMITADOR, + familiaProfesional.getNombre()); + + Files.writeString(pathFicheroTMP, nuevaFamilia, StandardOpenOption.APPEND); + + } + // Se elimina el fichero original y se renombra el temporal + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + RUTA_FICHERO_TMP_FAMILIAS_PROFESIONALES); + e.printStackTrace(); + } + + // Se elimina el fichero original y se renombra el temporal + organizarFicheros(); + } + + private void organizarFicheros() { + try { + // Borrado del fichero original + Files.deleteIfExists(pathFichero); + + // Renombrado del fichero temporal + Files.move(pathFicheroTMP, pathFichero, StandardCopyOption.REPLACE_EXISTING); + } catch (IOException e) { + System.err.println("Error al renombrar el fichero: " + RUTA_FICHERO_TMP_FAMILIAS_PROFESIONALES); + e.printStackTrace(); + } + + } + +} diff --git a/src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java b/src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java new file mode 100644 index 0000000..c8e5694 --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/impl/FamiliaProfesionalDaoJDBC.java @@ -0,0 +1,130 @@ +package es.palomafp.aadd.inm.dao.impl; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.List; + +import es.palomafp.aadd.inm.dao.IFamiliaProfesionalDAO; +import es.palomafp.aadd.inm.gestor.GestorConexionJDBC; +import es.palomafp.aadd.inm.vo.FamiliaProfesional; + +/** + * + * FamiliaProfesionalDaoJDBC: Clase que implementa las operaciones del interfaz + * IFamiliaProfesionalDAO usando JDBC. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 7 nov 2025 + * + * + */ + +public class FamiliaProfesionalDaoJDBC implements IFamiliaProfesionalDAO { + + @Override + public FamiliaProfesional obtenerFamiliaProfesionalPorCodigo(String codigoFamilia) { + FamiliaProfesional familiaProfesional = null; + String sentenciaSQL = "SELECT * FROM T_FAMILIA_PROFESIONAL WHERE codigo = '%s'"; + sentenciaSQL = String.format(sentenciaSQL, codigoFamilia); + + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement statement = conexion.createStatement(); + ResultSet resultado = statement.executeQuery(sentenciaSQL);) { + if (resultado.next()) { + String codigo = resultado.getString("codigo"); + String nombre = resultado.getString("nombre"); + String urlImagenLogo = resultado.getString("url_img_logo"); + familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codigo); + familiaProfesional.setNombre(nombre); + familiaProfesional.setUrlImageLogo(urlImagenLogo); + } + } catch (SQLException e) { + e.printStackTrace(); + + } + return familiaProfesional; + } + + @Override + public List obtenerListaFamiliasProfesionales() { + List listaFamiliasProfesionales = null; + + String sentenciaSQL = "SELECT * FROM T_FAMILIA_PROFESIONAL"; + + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement statement = conexion.createStatement(); + ResultSet resultado = statement.executeQuery(sentenciaSQL);) { + listaFamiliasProfesionales = new java.util.ArrayList(); + while (resultado.next()) { + String codigo = resultado.getString("codigo"); + String nombre = resultado.getString("nombre"); + String urlImagenLogo = resultado.getString("url_img_logo"); + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codigo); + familiaProfesional.setNombre(nombre); + familiaProfesional.setUrlImageLogo(urlImagenLogo); + + listaFamiliasProfesionales.add(familiaProfesional); + } + } catch (SQLException e) { + e.printStackTrace(); + + } + + return listaFamiliasProfesionales; + } + + @Override + public void insertarFamiliaProfesional(FamiliaProfesional familiaProfesional) { + String sentenciaSQL = "INSERT INTO T_FAMILIA_PROFESIONAL values ('%s', '%s', %s)"; + String urlImageLogo = (familiaProfesional.getUrlImageLogo()!=null)?("'" + familiaProfesional.getUrlImageLogo() + "'"):"NULL"; + sentenciaSQL = String.format(sentenciaSQL, familiaProfesional.getCodigo(), familiaProfesional.getNombre(), urlImageLogo); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + + } + + @Override + public void eliminarFamiliaProfesional(String codigoFamilia) { + String sentenciaSQL = "DELETE FROM T_FAMILIA_PROFESIONAL WHERE codigo='%s'"; + sentenciaSQL = String.format(sentenciaSQL, codigoFamilia); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + + } + + @Override + public void actualizarFamiliaProfesional(FamiliaProfesional familiaProfesional) { + String sentenciaSQL = "UPDATE T_FAMILIA_PROFESIONAL set nombre= '%s', url_img_logo='%s' WHERE codigo='%s'"; + sentenciaSQL = String.format(sentenciaSQL, familiaProfesional.getNombre(), familiaProfesional.getUrlImageLogo(), + familiaProfesional.getCodigo()); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + + } + +} diff --git a/src/es/palomafp/aadd/inm/dao/impl/GradoDaoCSV.java b/src/es/palomafp/aadd/inm/dao/impl/GradoDaoCSV.java new file mode 100644 index 0000000..b3464cc --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/impl/GradoDaoCSV.java @@ -0,0 +1,75 @@ +package es.palomafp.aadd.inm.dao.impl; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; + +import es.palomafp.aadd.inm.dao.IGradoDAO; +import es.palomafp.aadd.inm.gestor.GestorFicheroConfiguracion; +import es.palomafp.aadd.inm.vo.Grado; + +/** + * + * GradoDao: Clase que implementa las operaciones del interfaz IGradoDAO. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public class GradoDaoCSV implements IGradoDAO { + private final static String RUTA_FICHERO_GRADOS = GestorFicheroConfiguracion.getValorfromClave("grado.fichero.ruta"); + private static final String DELIMITADOR = GestorFicheroConfiguracion.getValorfromClave("grado.fichero.separador");; + + private Path pathFichero = Paths.get(RUTA_FICHERO_GRADOS); + + @Override + public Grado obtenerGradoPorCodigo(String codigoGrado) { + Grado grado = null; + + List lineas; + try { + lineas = Files.readAllLines(pathFichero, StandardCharsets.UTF_8); + List lineasSinCabecera = lineas.subList(1, lineas.size()); + + for (String linea : lineasSinCabecera) { + // Procesar informaci贸n de un Grado + String[] camposGrado = linea.split(DELIMITADOR); + String codGrado = camposGrado[0].strip(); + String descripcionGrado = camposGrado[1].strip(); + String categoriaGrado = camposGrado[2].strip(); + + if (codigoGrado != null && codigoGrado.equals(codGrado)) { + grado = new Grado(); + + grado.setCodigo(codGrado); + grado.setNombre(descripcionGrado); + grado.setCategoria(categoriaGrado); + + break; + } + } + } catch (IOException e) { + System.err.println("Error al leer el fichero: " + RUTA_FICHERO_GRADOS); + e.printStackTrace(); + } + return grado; + } + + @Override + public void actualizarGrado(Grado grado) { + // TODO Auto-generated method stub + + } + + @Override + public void insertarGrado(Grado grado) { + // TODO Auto-generated method stub + + } + +} diff --git a/src/es/palomafp/aadd/inm/dao/impl/GradoDaoJDBC.java b/src/es/palomafp/aadd/inm/dao/impl/GradoDaoJDBC.java new file mode 100644 index 0000000..ab1da1c --- /dev/null +++ b/src/es/palomafp/aadd/inm/dao/impl/GradoDaoJDBC.java @@ -0,0 +1,81 @@ +package es.palomafp.aadd.inm.dao.impl; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; + +import es.palomafp.aadd.inm.dao.IGradoDAO; +import es.palomafp.aadd.inm.gestor.GestorConexionJDBC; +import es.palomafp.aadd.inm.vo.Grado; + +/** + * + * GradoDaoJDBC: Clase que implementa las operaciones del interfaz IGradoDAO + * para JDBC. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 10 nov 2025 + * + * + */ + +public class GradoDaoJDBC implements IGradoDAO { + + @Override + public Grado obtenerGradoPorCodigo(String codigoGrado) { + Grado grado = null; + String sentenciaSQL = "SELECT * FROM T_GRADO WHERE codigo = '%s'"; + sentenciaSQL = String.format(sentenciaSQL, codigoGrado); + + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement statement = conexion.createStatement(); + ResultSet resultado = statement.executeQuery(sentenciaSQL);) { + if (resultado.next()) { + String codigo = resultado.getString("codigo"); + String nombre = resultado.getString("nombre"); + String categoria = resultado.getString("categoria"); + grado = new Grado(); + grado.setCodigo(codigo); + grado.setNombre(nombre); + grado.setCategoria(categoria); + } + } catch (SQLException e) { + e.printStackTrace(); + + } + return grado; + } + + @Override + public void actualizarGrado(Grado grado) { + String sentenciaSQL = "UPDATE T_GRADO set nombre= '%s', categoria='%s' WHERE codigo='%s'"; + sentenciaSQL = String.format(sentenciaSQL, grado.getNombre(), grado.getCategoria(), grado.getCodigo()); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + + } + + @Override + public void insertarGrado(Grado grado) { + String sentenciaSQL = "INSERT INTO T_GRADO (codigo, nombre, categoria ) values ('%s', '%s', '%s')"; + sentenciaSQL = String.format(sentenciaSQL, grado.getCodigo(), grado.getNombre(), grado.getCategoria()); +// System.out.println(sentenciaSQL); + + // try con recursos "cerrables": Connection, Statement + try (Connection conexion = GestorConexionJDBC.obtenerConexionJDBC(); + Statement stm = conexion.createStatement();) { + stm.executeUpdate(sentenciaSQL); + } catch (SQLException e) { + e.printStackTrace(); + } + } + +} diff --git a/src/es/palomafp/aadd/inm/gestor/GestorConexionJDBC.java b/src/es/palomafp/aadd/inm/gestor/GestorConexionJDBC.java new file mode 100644 index 0000000..c79aefc --- /dev/null +++ b/src/es/palomafp/aadd/inm/gestor/GestorConexionJDBC.java @@ -0,0 +1,39 @@ +package es.palomafp.aadd.inm.gestor; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +/** + * + * GestorConexionJDBC: Clase que realiza la gesti贸n de la conexi贸n JDBC. + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 6 nov 2025 + * + * + */ + +public class GestorConexionJDBC { + + // Constructor privado para evitar instanciaci贸n + private GestorConexionJDBC() { + } + + public static Connection obtenerConexionJDBC() { + Connection conexion = null; + String driverJDBC= GestorFicheroConfiguracion.getValorfromClave("jdbc.driver"); + try { + Class.forName(driverJDBC); + + String urlJDBC= GestorFicheroConfiguracion.getValorfromClave("jdbc.url"); + String usuario= GestorFicheroConfiguracion.getValorfromClave("jdbc.usuario"); + String password= GestorFicheroConfiguracion.getValorfromClave("jdbc.password"); + + conexion=DriverManager.getConnection(urlJDBC, usuario, password); + } catch (ClassNotFoundException | SQLException e) { + e.printStackTrace(); + } + return conexion; + } +} + diff --git a/src/es/palomafp/aadd/inm/gestor/GestorFicheroConfiguracion.java b/src/es/palomafp/aadd/inm/gestor/GestorFicheroConfiguracion.java new file mode 100644 index 0000000..ac75730 --- /dev/null +++ b/src/es/palomafp/aadd/inm/gestor/GestorFicheroConfiguracion.java @@ -0,0 +1,44 @@ +package es.palomafp.aadd.inm.gestor; + +import java.io.IOException; +import java.util.Properties; + +/** + * + * GestorConfiguracion: Clase que se encarga de gestionar la configuraci贸n de + * los ficheros. + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 10 oct 2025 + * + * + */ + +public class GestorFicheroConfiguracion { + private final static String RUTA_FICHERO_CONFIGURACION = "conf.properties"; + private static Properties propiedades = null; + + private GestorFicheroConfiguracion() { + // Constructor privado para evitar instanciaci贸n + } + + // Bloque est谩tico que se ejecuta una 煤nica vez al cargar la clase + static { + cargarPropiedadesFichero(); + } + + private static void cargarPropiedadesFichero() { + propiedades = new Properties(); + try { + propiedades + .load(GestorFicheroConfiguracion.class.getClassLoader().getResourceAsStream(RUTA_FICHERO_CONFIGURACION)); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public static String getValorfromClave(String clave) { + return propiedades.getProperty(clave); + } +} diff --git a/src/es/palomafp/aadd/inm/procesamiento/ProcesadorCicloGradoXML.java b/src/es/palomafp/aadd/inm/procesamiento/ProcesadorCicloGradoXML.java new file mode 100644 index 0000000..84e837c --- /dev/null +++ b/src/es/palomafp/aadd/inm/procesamiento/ProcesadorCicloGradoXML.java @@ -0,0 +1,127 @@ +package es.palomafp.aadd.inm.procesamiento; + +import java.io.File; + +import es.palomafp.aadd.inm.dao.ICicloDAO; +import es.palomafp.aadd.inm.dao.IGradoDAO; +import es.palomafp.aadd.inm.dao.impl.CicloDaoJDBC; +import es.palomafp.aadd.inm.dao.impl.GradoDaoJDBC; +import es.palomafp.aadd.inm.gestor.GestorFicheroConfiguracion; +import es.palomafp.aadd.inm.vo.Ciclo; +import es.palomafp.aadd.inm.vo.FamiliaProfesional; +import es.palomafp.aadd.inm.vo.Grado; +import tools.jackson.databind.JsonNode; +import tools.jackson.databind.ObjectMapper; +import tools.jackson.databind.node.ArrayNode; +import tools.jackson.dataformat.xml.XmlMapper; + +/** + * + * Procesador_Ciclo_Grado_XML: Clase que realiza el procesamiento del fichero + * XML ciclo_grado.mxl + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 10 nov 2025 + * + * + */ + +public class ProcesadorCicloGradoXML { + private static String RUTA_FICHERO_XML = GestorFicheroConfiguracion.getValorfromClave("ciclogrado.fichero.ruta"); + + public void procesarFicheroXML() { + JsonNode nodoRaiz = obtenerJsonNodeDeFicheroXML(); + + // Obtener los nodos "grado" + ArrayNode grados = convertirJsonNodeEnArrayNode(nodoRaiz.path("grados").path("grado")); + for (JsonNode nodoGrado : grados) { + String codigoGrado = nodoGrado.path("codigo_nivel").asString(); + String nombreGrado = nodoGrado.path("nombre_nivel").asString(); + String categoria = nodoGrado.path("categoria").asString(); + + // Insertar el grado en BBDD si no existe, si existe actualizarlo + IGradoDAO gradoDAO = new GradoDaoJDBC(); + Grado gradoBBDD = gradoDAO.obtenerGradoPorCodigo(codigoGrado); + if (gradoBBDD == null) { + Grado nuevoGrado = new Grado(); + nuevoGrado.setCodigo(codigoGrado); + nuevoGrado.setNombre(nombreGrado); + nuevoGrado.setCategoria(categoria); + gradoDAO.insertarGrado(nuevoGrado); + System.out.println("Grado insertado en BBDD."); + } else { + System.out.println("El grado ya existe en BBDD."); + gradoBBDD.setNombre(nombreGrado); + gradoBBDD.setCategoria(categoria); + gradoDAO.actualizarGrado(gradoBBDD); + } + } + + // Obtener los nodos "ciclo" + ArrayNode ciclos = convertirJsonNodeEnArrayNode(nodoRaiz.path("ciclos").path("ciclo")); + for (JsonNode nodoCiclo : ciclos) { + String codigoCiclo= nodoCiclo.path("codigo_titulacion").asString(); + String descripionCiclo = nodoCiclo.path("nombre_titulacion").asString(); + String numeroHoras = nodoCiclo.path("numero_horas").asString(); + String codigoFamilia = nodoCiclo.path("codigo_familia").asString(); + String codigoGrado = nodoCiclo.path("codigo_nivel").asString(); + + // Insertar el ciclo en BBDD si no existe, si existe actualizarlo + ICicloDAO cicloDAO = new CicloDaoJDBC(); + Ciclo cicloBBDD = cicloDAO.obtenerCicloPorCodigo(codigoCiclo); + if(cicloBBDD == null) { + Ciclo nuevoCiclo = new Ciclo(); + nuevoCiclo.setCodigo(codigoCiclo); + nuevoCiclo.setDescripcion(descripionCiclo); + nuevoCiclo.setNumeroHoras(Integer.parseInt(numeroHoras)); + + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codigoFamilia); + nuevoCiclo.setFamilia(familiaProfesional); + + Grado grado = new Grado(); + grado.setCodigo(codigoGrado); + nuevoCiclo.setGrado(grado); + + cicloDAO.insertarCiclo(nuevoCiclo); + System.out.println("Ciclo insertado en BBDD."); + } else { + System.out.println("El ciclo ya existe en BBDD."); + cicloBBDD.setDescripcion(descripionCiclo); + cicloBBDD.setNumeroHoras(Integer.parseInt(numeroHoras)); + + FamiliaProfesional familiaProfesional = new FamiliaProfesional(); + familiaProfesional.setCodigo(codigoFamilia); + cicloBBDD.setFamilia(familiaProfesional); + + Grado grado = new Grado(); + grado.setCodigo(codigoGrado); + cicloBBDD.setGrado(grado); + + cicloDAO.actualizarCiclo(cicloBBDD); + } + } + + } + + private JsonNode obtenerJsonNodeDeFicheroXML() { + // Cargar el XML + XmlMapper xmlMapper = new XmlMapper(); + JsonNode root = xmlMapper.readTree(new File(RUTA_FICHERO_XML)); + + return root; + } + + private ArrayNode convertirJsonNodeEnArrayNode(JsonNode node) { + ObjectMapper mapper = new ObjectMapper(); + if (node.isArray()) { + return (ArrayNode) node; + } else { + ArrayNode arrayNode = mapper.createArrayNode(); + if (!node.isMissingNode()) { + arrayNode.add(node); + } + return arrayNode; + } + } +} diff --git a/src/es/palomafp/aadd/inm/vo/Ciclo.java b/src/es/palomafp/aadd/inm/vo/Ciclo.java new file mode 100644 index 0000000..d3ee10f --- /dev/null +++ b/src/es/palomafp/aadd/inm/vo/Ciclo.java @@ -0,0 +1,66 @@ +package es.palomafp.aadd.inm.vo; + +/** + * + * Ciclo: Clase que representa el contenido de un Ciclo Formativo + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public class Ciclo { + private String codigo; + private String descripcion; + private int numeroHoras; + private FamiliaProfesional familia; + private Grado grado; + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getDescripcion() { + return descripcion; + } + + public void setDescripcion(String descripcion) { + this.descripcion = descripcion; + } + + public int getNumeroHoras() { + return numeroHoras; + } + + public void setNumeroHoras(int numeroHoras) { + this.numeroHoras = numeroHoras; + } + + public FamiliaProfesional getFamilia() { + return familia; + } + + public void setFamilia(FamiliaProfesional familia) { + this.familia = familia; + } + + public Grado getGrado() { + return grado; + } + + public void setGrado(Grado grado) { + this.grado = grado; + } + + @Override + public String toString() { + return "Ciclo [codigo=" + codigo + ", descripcion=" + descripcion + ", numeroHoras=" + numeroHoras + + ", familia=" + familia + ", grado=" + grado + "]"; + } + +} diff --git a/src/es/palomafp/aadd/inm/vo/FamiliaProfesional.java b/src/es/palomafp/aadd/inm/vo/FamiliaProfesional.java new file mode 100644 index 0000000..fe17a89 --- /dev/null +++ b/src/es/palomafp/aadd/inm/vo/FamiliaProfesional.java @@ -0,0 +1,47 @@ +package es.palomafp.aadd.inm.vo; + +/** + * + * FamiliaProfesional: Clase que representa el contenido de una Familia + * Profesional + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 3 oct 2025 + * + * + */ + +public class FamiliaProfesional { + private String codigo; + private String nombre; + private String urlImageLogo; + + public String getUrlImageLogo() { + return urlImageLogo; + } + + public void setUrlImageLogo(String urlImageLogo) { + this.urlImageLogo = urlImageLogo; + } + + 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 + ", urlImageLogo=" + urlImageLogo + "]\n"; + } +} diff --git a/src/es/palomafp/aadd/inm/vo/Grado.java b/src/es/palomafp/aadd/inm/vo/Grado.java new file mode 100644 index 0000000..fc11c52 --- /dev/null +++ b/src/es/palomafp/aadd/inm/vo/Grado.java @@ -0,0 +1,38 @@ +package es.palomafp.aadd.inm.vo; + +/** + * + * Grado: Clase que representa el contenido de un Grado + * + * @author Isidoro Nevares Mart铆n - IES Virgen de la Paloma + * @date 2 oct 2025 + */ +public class Grado { + private String codigo; + private String nombre; + private String categoria; + + 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; + } + public String getCategoria() { + return categoria; + } + public void setCategoria(String categoria) { + this.categoria = categoria; + } + @Override + public String toString() { + return "Grado [codigo=" + codigo + ", nombre=" + nombre + ", categoria=" + categoria + "]"; + } + +}