commit c0bfdb58d2f45c886159f5dd87eedfc3af322c2d Author: sheila-mb28 Date: Fri Nov 20 17:56:23 2026 +0100 Primer commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..079c533 --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +# Compilados de Java +*.class +bin/ + +# Compilados de Maven +target/ + +# Configuración de Eclipse +.project +.classpath +.settings/ \ No newline at end of file diff --git a/config/application.properties b/config/application.properties new file mode 100644 index 0000000..f5ceae2 --- /dev/null +++ b/config/application.properties @@ -0,0 +1,6 @@ +sgdb.conexion.url=jdbc:postgresql://localhost:5432/ +bbdd.nombre=formacion_fp +bbdd.usuario=alumno +bbdd.clave=alumno1234 +xml.ruta.html=https://web.decieloytierra.es/aadd/catalogo_formacion.xml +json.ruta.html=https://web.decieloytierra.es/aadd/familias_pro.json \ 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/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..5b27234 --- /dev/null +++ b/pom.xml @@ -0,0 +1,56 @@ + + 4.0.0 + Conectores_04 + Conectores_04 + 0.0.1-SNAPSHOT + + + + com.mysql + mysql-connector-j + 26.10.0 + compile + + + + + org.postgresql + postgresql + 42.7.14 + + + + + com.fasterxml.jackson.core + jackson-databind + 2.18.2 + + + + + com.fasterxml.jackson.dataformat + jackson-dataformat-xml + 2.18.2 + + + + src + + + config + + **/*.java + + + + + + maven-compiler-plugin + 3.13.0 + + 21 + + + + + \ No newline at end of file diff --git a/src/org/palomafp/aadd/smmb/AplicacionPrincipal.java b/src/org/palomafp/aadd/smmb/AplicacionPrincipal.java new file mode 100644 index 0000000..1ac185c --- /dev/null +++ b/src/org/palomafp/aadd/smmb/AplicacionPrincipal.java @@ -0,0 +1,94 @@ +package org.palomafp.aadd.smmb; + +import java.io.IOException; +import java.util.Scanner; + +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.ficheros.ProcesadorFicheroJSON; +import org.palomafp.aadd.smmb.ficheros.ProcesadorFicheroXML; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; +import org.palomafp.aadd.smmb.service.CicloFormativoService; +import org.palomafp.aadd.smmb.service.FamiliaProfesionalService; +import org.palomafp.aadd.smmb.service.TipoFormacionService; + +public class AplicacionPrincipal { + + Scanner sc = new Scanner(System.in); + + private final FamiliaProfesionalService familiaService; + private final TipoFormacionService tipoService; + private final CicloFormativoService cicloService; + private final ProcesadorFicheroJSON proJSON; + private final ProcesadorFicheroXML proXML; + + public AplicacionPrincipal(GestorConfiguracion configuracion) { + + this.familiaService = new FamiliaProfesionalService(configuracion); + this.tipoService = new TipoFormacionService(configuracion); + this.cicloService = new CicloFormativoService(configuracion); + this.proJSON = new ProcesadorFicheroJSON(configuracion, familiaService); + this.proXML = new ProcesadorFicheroXML(configuracion, familiaService, tipoService, cicloService); + } + + public static void main(String[] args) { + + GestorConfiguracion configuracion; + + try { + + configuracion = new GestorConfiguracion("application.properties"); + AplicacionPrincipal app = new AplicacionPrincipal(configuracion); + + int opcion = app.menu(); + app.operaciones(opcion); + app.sc.close(); + + } catch (IOException | FormacionException e) { + e.printStackTrace(); + } + } + + private int menu() { + + System.out.println("Introduce la operación a realizar: "); + System.out.println("1. Tratar el JSON de familias profesionales"); + System.out.println("2. Tratar el XML de ciclos formativos"); + + int opcion = sc.nextInt(); + + while (!(opcion == 1 || opcion == 2)) { + System.out.println("Tienes que elegir entre 1 y 2"); + System.out.println("Introduce la operación a realizar:"); + + opcion = sc.nextInt(); + } + + return opcion; + } + + private void operaciones(int opcion) throws FormacionException { + + switch (opcion) { + + case 1: { + + System.out.println("Realizando tratamiento JSON de familias profesionales"); + proJSON.realizarTratamientoFamiliasProfesionales(); + + break; + } + + case 2: { + + System.out.println("Realizando tratamiento XML de ciclos formativos"); + proXML.realizarTratamientoCiclosFormativos(); + + break; + } + + default: + System.out.println("Opción no válida"); + break; + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/smmb/dao/ICiclosFormativosDAO.java b/src/org/palomafp/aadd/smmb/dao/ICiclosFormativosDAO.java new file mode 100644 index 0000000..a071344 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/ICiclosFormativosDAO.java @@ -0,0 +1,10 @@ +package org.palomafp.aadd.smmb.dao; + +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.model.CicloFormativo; + +public interface ICiclosFormativosDAO { + + void insertarCicloFormativo(CicloFormativo ciclo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/smmb/dao/IFamiliaProfesionalDAO.java b/src/org/palomafp/aadd/smmb/dao/IFamiliaProfesionalDAO.java new file mode 100644 index 0000000..f6baba7 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/IFamiliaProfesionalDAO.java @@ -0,0 +1,12 @@ +package org.palomafp.aadd.smmb.dao; + +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.model.FamiliaProfesional; + +public interface IFamiliaProfesionalDAO { + + boolean existeFamiliaProfesionalPorCodigo(String cod) throws FormacionException; + void insertarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException; + void actualizarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/smmb/dao/ITipoFormacionDAO.java b/src/org/palomafp/aadd/smmb/dao/ITipoFormacionDAO.java new file mode 100644 index 0000000..c1b9f1f --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/ITipoFormacionDAO.java @@ -0,0 +1,9 @@ +package org.palomafp.aadd.smmb.dao; + +import org.palomafp.aadd.smmb.exception.FormacionException; + +public interface ITipoFormacionDAO { + + boolean existeTipoFormacionPorCodigo(String codigo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/smmb/dao/impl/CicloFormativoDaoJDBC.java b/src/org/palomafp/aadd/smmb/dao/impl/CicloFormativoDaoJDBC.java new file mode 100644 index 0000000..cf1aac6 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/impl/CicloFormativoDaoJDBC.java @@ -0,0 +1,49 @@ +package org.palomafp.aadd.smmb.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; + +import org.palomafp.aadd.smmb.dao.ICiclosFormativosDAO; +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.model.CicloFormativo; + +public class CicloFormativoDaoJDBC implements ICiclosFormativosDAO { + + private final Connection conexion; + + public CicloFormativoDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public void insertarCicloFormativo(CicloFormativo ciclo) throws FormacionException { + + String codigo = ciclo.getCodigoFormacion(); + String nombreCorto = ciclo.getNombreCorto(); + String nombreLargo = ciclo.getNombreLargo(); + int horas = ciclo.getHorasDuracion(); + String codFamilia = ciclo.getFamiliaProfesional().getCodigoFamilia(); + String codTipo = ciclo.getTipoFormacion().getCodigoTipoEstudio(); + + + String sql = "INSERT INTO T_CICLO_FORMATIVO (codigo, nombre_corto, nombre_largo, horas_duracion, codigo_familia, codigo_tipo_formacion) VALUES (?, ?, ?, ?, ?, ?)"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + + ps.setString(1, codigo); + ps.setString(2, nombreCorto); + ps.setString(3, nombreLargo); + ps.setInt(4, horas); + ps.setString(5, codFamilia); + ps.setString(6, codTipo); + + ps.executeUpdate(); + + } catch (SQLException e) { + throw new FormacionException("No se pudo insertar el ciclo formativo " + ciclo.getCodigoFormacion(), e); + } + + } + +} diff --git a/src/org/palomafp/aadd/smmb/dao/impl/FamiliaProfesionalDaoMySql.java b/src/org/palomafp/aadd/smmb/dao/impl/FamiliaProfesionalDaoMySql.java new file mode 100644 index 0000000..4db32ee --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/impl/FamiliaProfesionalDaoMySql.java @@ -0,0 +1,98 @@ +package org.palomafp.aadd.smmb.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.smmb.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.model.FamiliaProfesional; + +public class FamiliaProfesionalDaoMySql implements IFamiliaProfesionalDAO { + + private final Connection conexion; + + public FamiliaProfesionalDaoMySql(Connection conexion) { + this.conexion = conexion; + } + + + @Override + public boolean existeFamiliaProfesionalPorCodigo(String cod) throws FormacionException { + + String sql = "SELECT EXISTS(SELECT 1 FROM T_FAMILIA_PROFESIONAL WHERE codigo = ?) AS existe_fp"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + + ps.setString(1, cod); + + try (ResultSet rs = ps.executeQuery()) { + + if (rs.next()) { + return rs.getBoolean("existe_fp"); + } + } + + + } catch (SQLException e) { + throw new FormacionException("No se pudo obtener la familia profesional con el código: " + cod, e); + } + + + return false; + } + + + @Override + public void insertarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException { + + String codigo = familia.getCodigoFamilia(); + String nombre = familia.getNombre(); + + String sql = "INSERT INTO T_FAMILIA_PROFESIONAL (codigo, nombre) VALUES (?, ?)"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + + ps.setString(1, codigo); + ps.setString(2, nombre); + + ps.executeUpdate(); + + } catch (SQLException e) { + throw new FormacionException("No se pudo insertar la familia profesional " + codigo, e); + } + } + + + @Override + public void actualizarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException { + + String codigo = familia.getCodigoFamilia(); + String nombre = familia.getNombre(); + + String sql = "UPDATE T_FAMILIA_PROFESIONAL SET nombre = ? WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + + ps.setString(1, nombre); + ps.setString(2, codigo); + + ps.executeUpdate(); + + } catch (SQLException e) { + throw new FormacionException("No se pudo actualizar la familia profesional " + codigo, e); + } + + } + + /**private FamiliaProfesional construirFamilia(ResultSet rs) throws SQLException { + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigoFamilia(rs.getString("codigo")); + familia.setNombre(rs.getString("nombre")); + + return familia; + }**/ + +} diff --git a/src/org/palomafp/aadd/smmb/dao/impl/TipoFormacionDaoMySql.java b/src/org/palomafp/aadd/smmb/dao/impl/TipoFormacionDaoMySql.java new file mode 100644 index 0000000..64d90a3 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/impl/TipoFormacionDaoMySql.java @@ -0,0 +1,52 @@ +package org.palomafp.aadd.smmb.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.palomafp.aadd.smmb.dao.ITipoFormacionDAO; +import org.palomafp.aadd.smmb.exception.FormacionException; + +public class TipoFormacionDaoMySql implements ITipoFormacionDAO { + +private final Connection conexion; + + public TipoFormacionDaoMySql(Connection conexion) { + this.conexion = conexion; + } + + @Override + public boolean existeTipoFormacionPorCodigo(String codigo) throws FormacionException { + + String sql = "SELECT EXISTS(SELECT 1 FROM T_TIPO_FORMACION WHERE codigo = ?) AS existe_tf"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + + ps.setString(1, codigo); + + try (ResultSet rs = ps.executeQuery()) { + + if (rs.next()) { + return rs.getBoolean("existe_tf"); + } + } + + } catch (SQLException e) { + throw new FormacionException("Error al validar si existe un tipo de formación por código.", e); + } + + return false; + } + + /**private TipoFormacion construirTipoFormacion(ResultSet rs) throws SQLException { + + TipoFormacion tp = new TipoFormacion(); + tp.setNombreCorto(rs.getString("nombre_corto")); + tp.setNombreLargo(rs.getString("nombre_largo")); + tp.setCodigoTipoEstudio(rs.getString("codigo")); + + return tp; + }**/ + +} diff --git a/src/org/palomafp/aadd/smmb/exception/FormacionException.java b/src/org/palomafp/aadd/smmb/exception/FormacionException.java new file mode 100644 index 0000000..db12d27 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/exception/FormacionException.java @@ -0,0 +1,15 @@ +package org.palomafp.aadd.smmb.exception; + +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/smmb/ficheros/ProcesadorFicheroJSON.java b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroJSON.java new file mode 100644 index 0000000..a7370c4 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroJSON.java @@ -0,0 +1,81 @@ +package org.palomafp.aadd.smmb.ficheros; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URI; +import java.net.URL; + +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; +import org.palomafp.aadd.smmb.model.FamiliaProfesional; +import org.palomafp.aadd.smmb.service.FamiliaProfesionalService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +public class ProcesadorFicheroJSON { + + private final String rutaUrl; + private final FamiliaProfesionalService familiaService; + + public ProcesadorFicheroJSON(GestorConfiguracion configuracion, FamiliaProfesionalService familiaService) { + this.rutaUrl = configuracion.getRutaJson(); + this.familiaService = familiaService; + } + + + public void realizarTratamientoFamiliasProfesionales() throws FormacionException { + + JsonNode raiz = cargarDocumento(rutaUrl); + + for (JsonNode nodo : raiz) { + + String codigo = obtenerTexto(nodo, "cod_tipo_fam"); + String nombre = obtenerTexto(nodo, "nombre_tf"); + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigoFamilia(codigo); + familia.setNombre(nombre); + + boolean existe = familiaService.existeFamiliaProfesionalPorClave(codigo); + + if (existe) { + System.out.println("Actualizando familia profesional: " + familia); + familiaService.actualizarFamiliaProfesional(familia); + } else { + System.out.println("Insertando la familia profesional: " + familia); + familiaService.insertarFamiliaProfesional(familia); + } + } + } + + + + private String obtenerTexto(JsonNode nodo, String campo) { + return nodo.path(campo).asText().trim(); + } + + + private JsonNode cargarDocumento(String ruta) throws FormacionException { + + try (InputStream flujo = abrirConexion(ruta)) { + + ObjectMapper mapeador = new ObjectMapper(); + JsonNode raiz = mapeador.readTree(flujo); + + return raiz; + + } catch (IOException | IllegalArgumentException e) { + throw new FormacionException("No se pudo leer el JSON de la URL: " + ruta, e); + } + } + + private InputStream abrirConexion(String ruta) throws IOException { + + URI uri = URI.create(ruta); + URL url = uri.toURL(); + + return url.openStream(); + } + +} diff --git a/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroXML.java b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroXML.java new file mode 100644 index 0000000..2feaabb --- /dev/null +++ b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroXML.java @@ -0,0 +1,111 @@ +package org.palomafp.aadd.smmb.ficheros; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URI; +import java.net.URL; + +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; +import org.palomafp.aadd.smmb.model.CicloFormativo; +import org.palomafp.aadd.smmb.model.FamiliaProfesional; +import org.palomafp.aadd.smmb.model.TipoFormacion; +import org.palomafp.aadd.smmb.service.CicloFormativoService; +import org.palomafp.aadd.smmb.service.FamiliaProfesionalService; +import org.palomafp.aadd.smmb.service.TipoFormacionService; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.dataformat.xml.XmlMapper; + +public class ProcesadorFicheroXML { + + private final String rutaUrl; + private final FamiliaProfesionalService familiaService; + private final TipoFormacionService tipoService; + private final CicloFormativoService cicloService; + + public ProcesadorFicheroXML(GestorConfiguracion configuracion, FamiliaProfesionalService familiaService, + TipoFormacionService tipoService, CicloFormativoService cicloService) { + this.rutaUrl = configuracion.getRutaXml(); + this.familiaService = familiaService; + this.tipoService = tipoService; + this.cicloService = cicloService; + } + + public void realizarTratamientoCiclosFormativos() throws FormacionException { + + JsonNode raiz = cargarDocumento(rutaUrl); + JsonNode ciclos = raiz.path("informacion_adicional").path("ciclos_formativos").path("ciclo"); + + try { + + for (JsonNode elemento : ciclos) { + + String codigo = obtenerTexto(elemento, "cod_cf"); + String nombreCorto = obtenerTexto(elemento, "nomb_corto"); + String nombreLargo = obtenerTexto(elemento, "nombrelargo"); + String horasTexto = obtenerTexto(elemento, "num_horas_duracion"); + String codFamilia = obtenerTexto(elemento, "codigo_familia"); + String codTipo = obtenerTexto(elemento, "codigo_tipoestudio"); + + boolean existeFamilia = familiaService.existeFamiliaProfesionalPorClave(codFamilia); + boolean existeTipo = tipoService.existeTipoFormacionPorClave(codTipo); + + if (existeFamilia && existeTipo) { + + int horas = Integer.parseInt(horasTexto); + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigoFamilia(codFamilia); + + TipoFormacion tipo = new TipoFormacion(); + tipo.setCodigoTipoEstudio(codTipo); + + CicloFormativo ciclo = new CicloFormativo(); + ciclo.setCodigoFormacion(codigo); + ciclo.setNombreCorto(nombreCorto); + ciclo.setNombreLargo(nombreLargo); + ciclo.setHorasDuracion(horas); + ciclo.setFamiliaProfesional(familia); + ciclo.setTipoFormacion(tipo); + + System.out.println("Insertando el ciclo formativo: " + ciclo); + cicloService.insertarCicloFormativo(ciclo); + + } else { + System.out.println( + "El ciclo " + codigo + " no se inserta: su familia o su tipo no están registrados"); + } + } + + } catch (NumberFormatException e) { + throw new FormacionException("Número de horas no válido en " + rutaUrl, e); + } + } + + private String obtenerTexto(JsonNode nodo, String campo) { + return nodo.path(campo).asText().trim(); + } + + private JsonNode cargarDocumento(String ruta) throws FormacionException { + + try (InputStream flujo = abrirConexion(ruta)) { + + XmlMapper mapeador = new XmlMapper(); + JsonNode raiz = mapeador.readTree(flujo); + + return raiz; + + } catch (IOException | IllegalArgumentException e) { + throw new FormacionException("No se pudo leer el XML de la URL: " + ruta, e); + } + } + + private InputStream abrirConexion(String ruta) throws IOException { + + URI uri = URI.create(ruta); + URL url = uri.toURL(); + + return url.openStream(); + } +} diff --git a/src/org/palomafp/aadd/smmb/gestores/GestorConexionesBBDD.java b/src/org/palomafp/aadd/smmb/gestores/GestorConexionesBBDD.java new file mode 100644 index 0000000..52d653e --- /dev/null +++ b/src/org/palomafp/aadd/smmb/gestores/GestorConexionesBBDD.java @@ -0,0 +1,28 @@ +package org.palomafp.aadd.smmb.gestores; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +public class GestorConexionesBBDD { + + private final String url; + private final String bbdd; + private final String usuario; + private final String clave; + + public GestorConexionesBBDD(GestorConfiguracion gestor) { + this.url = gestor.getUrl(); + this.bbdd = gestor.getBaseDatos(); + this.usuario = gestor.getUsuario(); + this.clave = gestor.getClave(); + } + + public Connection obtenerConexion() throws SQLException { + + Connection conexion = DriverManager.getConnection(url + bbdd, usuario, clave); + + return conexion; + } + +} diff --git a/src/org/palomafp/aadd/smmb/gestores/GestorConfiguracion.java b/src/org/palomafp/aadd/smmb/gestores/GestorConfiguracion.java new file mode 100644 index 0000000..365de50 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/gestores/GestorConfiguracion.java @@ -0,0 +1,47 @@ +package org.palomafp.aadd.smmb.gestores; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; + +public class GestorConfiguracion { + + private final Properties propiedades = new Properties(); + + public GestorConfiguracion(String rutaFicheroConfig) throws IOException { + + try (InputStream is = GestorConfiguracion.class.getClassLoader().getResourceAsStream(rutaFicheroConfig)) { + + if (is == null) { + throw new IOException("No se ha encontrado el fichero de configuración: " + rutaFicheroConfig); + } + + propiedades.load(is); + } + } + + public String getRutaJson() { + return propiedades.getProperty("json.ruta.html"); + } + + public String getRutaXml() { + return propiedades.getProperty("xml.ruta.html"); + } + + public String getUrl() { + return propiedades.getProperty("sgdb.conexion.url"); + } + + public String getBaseDatos() { + return propiedades.getProperty("bbdd.nombre"); + } + + public String getUsuario() { + return propiedades.getProperty("bbdd.usuario"); + } + + public String getClave() { + return propiedades.getProperty("bbdd.clave"); + } + +} diff --git a/src/org/palomafp/aadd/smmb/model/CicloFormativo.java b/src/org/palomafp/aadd/smmb/model/CicloFormativo.java new file mode 100644 index 0000000..6a648a6 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/model/CicloFormativo.java @@ -0,0 +1,64 @@ +package org.palomafp.aadd.smmb.model; + +import java.io.Serializable; + +public class CicloFormativo implements Serializable { + + private static final long serialVersionUID = 1L; + private String codigoFormacion; + private String nombreCorto; + private String nombreLargo; + private int horasDuracion; + private FamiliaProfesional familiaProfesional; + private TipoFormacion tipoFormacion; + + + + public String getCodigoFormacion() { + return codigoFormacion; + } + public void setCodigoFormacion(String codigoFormacion) { + this.codigoFormacion = codigoFormacion; + } + public String getNombreCorto() { + return nombreCorto; + } + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + public String getNombreLargo() { + return nombreLargo; + } + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } + public int getHorasDuracion() { + return horasDuracion; + } + public void setHorasDuracion(int horasDuracion) { + this.horasDuracion = horasDuracion; + } + public FamiliaProfesional getFamiliaProfesional() { + return familiaProfesional; + } + public void setFamiliaProfesional(FamiliaProfesional familiaProfesional) { + this.familiaProfesional = familiaProfesional; + } + public TipoFormacion getTipoFormacion() { + return tipoFormacion; + } + public void setTipoFormacion(TipoFormacion tipoFormacion) { + this.tipoFormacion = tipoFormacion; + } + + + @Override + public String toString() { + return "CicloFormativo [codigoFormacion=" + codigoFormacion + ", nombreCorto=" + nombreCorto + ", nombreLargo=" + + nombreLargo + ", horasDuracion=" + horasDuracion + ", familiaProfesional=" + familiaProfesional + + ", tipoFormacion=" + tipoFormacion + "]"; + } + + + +} diff --git a/src/org/palomafp/aadd/smmb/model/FamiliaProfesional.java b/src/org/palomafp/aadd/smmb/model/FamiliaProfesional.java new file mode 100644 index 0000000..19a1dd7 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/model/FamiliaProfesional.java @@ -0,0 +1,31 @@ +package org.palomafp.aadd.smmb.model; + +import java.io.Serializable; + +public class FamiliaProfesional implements Serializable{ + + private static final long serialVersionUID = 1L; + private String codigoFamilia; + private String nombre; + + + public String getCodigoFamilia() { + return codigoFamilia; + } + public void setCodigoFamilia(String codigoFamilia) { + this.codigoFamilia = codigoFamilia; + } + public String getNombre() { + return nombre; + } + public void setNombre(String nombre) { + this.nombre = nombre; + } + + + @Override + public String toString() { + return "FamiliaProfesional [codigoFamilia=" + codigoFamilia + ", nombre=" + nombre + "]"; + } + +} diff --git a/src/org/palomafp/aadd/smmb/model/TipoFormacion.java b/src/org/palomafp/aadd/smmb/model/TipoFormacion.java new file mode 100644 index 0000000..6101feb --- /dev/null +++ b/src/org/palomafp/aadd/smmb/model/TipoFormacion.java @@ -0,0 +1,39 @@ +package org.palomafp.aadd.smmb.model; + +import java.io.Serializable; + +public class TipoFormacion implements Serializable{ + + private static final long serialVersionUID = 1L; + private String codigoTipoEstudio; + private String nombreCorto; + private String nombreLargo; + + + public String getCodigoTipoEstudio() { + return codigoTipoEstudio; + } + public void setCodigoTipoEstudio(String codigoTipoEstudio) { + this.codigoTipoEstudio = codigoTipoEstudio; + } + 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 [codigoTipoEstudio=" + codigoTipoEstudio + ", nombreCorto=" + nombreCorto + + ", nombreLargo=" + nombreLargo + "]"; + } + +} diff --git a/src/org/palomafp/aadd/smmb/service/CicloFormativoService.java b/src/org/palomafp/aadd/smmb/service/CicloFormativoService.java new file mode 100644 index 0000000..daad8b2 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/service/CicloFormativoService.java @@ -0,0 +1,34 @@ +package org.palomafp.aadd.smmb.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.smmb.dao.ICiclosFormativosDAO; +import org.palomafp.aadd.smmb.dao.impl.CicloFormativoDaoJDBC; +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.gestores.GestorConexionesBBDD; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; +import org.palomafp.aadd.smmb.model.CicloFormativo; + +public class CicloFormativoService { + + private final GestorConexionesBBDD gestorConexiones; + + public CicloFormativoService(GestorConfiguracion configuracion) { + this.gestorConexiones = new GestorConexionesBBDD(configuracion); + } + + + public void insertarCicloFormativo(CicloFormativo ciclo) throws FormacionException { + + try (Connection conexion = gestorConexiones.obtenerConexion()) { + + ICiclosFormativosDAO cicloDao = new CicloFormativoDaoJDBC(conexion); + cicloDao.insertarCicloFormativo(ciclo); + + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } + +} diff --git a/src/org/palomafp/aadd/smmb/service/FamiliaProfesionalService.java b/src/org/palomafp/aadd/smmb/service/FamiliaProfesionalService.java new file mode 100644 index 0000000..5d5e241 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/service/FamiliaProfesionalService.java @@ -0,0 +1,59 @@ +package org.palomafp.aadd.smmb.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.smmb.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.smmb.dao.impl.FamiliaProfesionalDaoMySql; +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.gestores.GestorConexionesBBDD; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; +import org.palomafp.aadd.smmb.model.FamiliaProfesional; + +public class FamiliaProfesionalService { + + private final GestorConexionesBBDD gestorConexiones; + + public FamiliaProfesionalService(GestorConfiguracion configuracion) { + this.gestorConexiones = new GestorConexionesBBDD(configuracion); + } + + public boolean existeFamiliaProfesionalPorClave(String codFamiliaProfesional) throws FormacionException { + + try (Connection conexion = gestorConexiones.obtenerConexion()) { + + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoMySql(conexion); + boolean existe = familiaDao.existeFamiliaProfesionalPorCodigo(codFamiliaProfesional); + + return existe; + + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } + + public void insertarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException { + + try (Connection conexion = gestorConexiones.obtenerConexion()) { + + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoMySql(conexion); + familiaDao.insertarFamiliaProfesional(familia); + + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } + + public void actualizarFamiliaProfesional(FamiliaProfesional familia) throws FormacionException { + + try (Connection conexion = gestorConexiones.obtenerConexion()) { + + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoMySql(conexion); + familiaDao.actualizarFamiliaProfesional(familia); + + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } + +} diff --git a/src/org/palomafp/aadd/smmb/service/TipoFormacionService.java b/src/org/palomafp/aadd/smmb/service/TipoFormacionService.java new file mode 100644 index 0000000..6f87865 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/service/TipoFormacionService.java @@ -0,0 +1,33 @@ +package org.palomafp.aadd.smmb.service; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.palomafp.aadd.smmb.dao.ITipoFormacionDAO; +import org.palomafp.aadd.smmb.dao.impl.TipoFormacionDaoMySql; +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.gestores.GestorConexionesBBDD; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; + +public class TipoFormacionService { + + private final GestorConexionesBBDD gestorConexiones; + + public TipoFormacionService(GestorConfiguracion configuracion) { + this.gestorConexiones = new GestorConexionesBBDD(configuracion); + } + + public boolean existeTipoFormacionPorClave(String codTipo) throws FormacionException { + + try (Connection conexion = gestorConexiones.obtenerConexion()) { + + ITipoFormacionDAO tipoDao = new TipoFormacionDaoMySql(conexion); + boolean existe = tipoDao.existeTipoFormacionPorCodigo(codTipo); + + return existe; + + } catch (SQLException e) { + throw new FormacionException("Error al obtener la conexión", e); + } + } +} \ No newline at end of file