commit 3f198221b834884a7137eab9479226de4f643129 Author: sheila-mb28 Date: Sat Nov 7 20:42:36 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..3899d48 --- /dev/null +++ b/config/application.properties @@ -0,0 +1,7 @@ +sgdb.conexion.url=jdbc:mysql://localhost:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=root +bbdd.clave=root1234 +familias.ruta.fichero=ficheros/familias_profesionales.csv +familias.csv.separador=| +catalogo.ruta.fichero=ficheros/catalogo_formacion.xml \ No newline at end of file diff --git a/ficheros/catalogo_formacion.xml b/ficheros/catalogo_formacion.xml new file mode 100644 index 0000000..63195a4 --- /dev/null +++ b/ficheros/catalogo_formacion.xml @@ -0,0 +1,170 @@ + + + + + + Ministerio de Educación + 2026-11-01 + 1.0 + + Catálogo informativo de enseñanzas de Formación Profesional. + + + + + + + + 2026-01-15 + Registro de administración. + Servicios Administrativos + Título Profesional Básico en Servicios Administrativos + 2000 + ADG + CFBA + + + + 2026-02-10 + Formación de grado medio. + Gestión Administrativa + Técnico en Gestión Administrativa + 2000 + ADG + CFGM + + + + 2026-02-15 + Estudios superiores de administración. + Administración y Finanzas + Técnico Superior en Administración y Finanzas + 2000 + ADG + CFGS + + + + + + + 2026-01-20 + Formación inicial en informática. + Informática y Comunicaciones + Título Profesional Básico en Informática y Comunicaciones + 2000 + IFE + CFGB + + + + 2026-01-25 + Redes y sistemas informáticos. + Sistemas Microinformáticos y Redes + Técnico en Sistemas Microinformáticos y Redes + 2000 + IFC + CFGM + + + + 2026-02-01 + Programación de aplicaciones multiplataforma. + Desarrollo de Aplicaciones Multiplataforma + Técnico Superior en Desarrollo de Aplicaciones Multiplataforma + 2000 + IFC + CFGS + + + + 2026-02-05 + Desarrollo de aplicaciones web. + Desarrollo de Aplicaciones Web + Técnico Superior en Desarrollo de Aplicaciones Web + 2000 + IFC + CFGS + + + + 2026-03-01 + Especialización tecnológica. + Inteligencia Artificial y Big Data + Curso de Especialización en Inteligencia Artificial y Big Data + 600 + IFC + CFE + + + + + + + 2026-01-18 + Formación básica en mantenimiento. + Mantenimiento de Vehículos + Título Profesional Básico en Mantenimiento de Vehículos + 2000 + TMV + CFGB + + + + 2026-02-12 + Especialidad en electromecánica. + Electromecánica de Vehículos Automóviles + Técnico en Electromecánica de Vehículos Automóviles + 2000 + TMV + CFGM + + + + 2026-02-20 + Formación superior en automoción. + Automoción + Técnico Superior en Automoción + 2000 + TMV + CFGS + + + + 2026-03-05 + Especialización en aeronaves no tripuladas. + Inspección Técnica y Peritación + Curso de Especialización en Aeronaves pilotadas de forma remota-Drones + 600 + TMV + CE + + + + + + + 2026-02-08 + Formación sanitaria de grado medio. + Farmacia y Parafarmacia + Técnico en Farmacia y Parafarmacia + 2000 + SAN + CFME + + + + 2026-02-18 + Formación sanitaria de grado superior. + Laboratorio Clínico y Biomédico + Técnico Superior en Laboratorio Clínico y Biomédico + 2000 + SAN + CFGS + + + + + + + diff --git a/ficheros/familias_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..d0e6ef5 --- /dev/null +++ b/pom.xml @@ -0,0 +1,35 @@ + + 4.0.0 + Conectores_04 + Conectores_04 + 0.0.1-SNAPSHOT + + + + com.mysql + mysql-connector-j + 26.10.0 + compile + + + + 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..304b189 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/AplicacionPrincipal.java @@ -0,0 +1,34 @@ +package org.palomafp.aadd.smmb; + +import java.io.IOException; + +import org.palomafp.aadd.smmb.exception.FormacionException; +import org.palomafp.aadd.smmb.ficheros.ProcesadorFicheroCSV; +import org.palomafp.aadd.smmb.ficheros.ProcesadorFicheroXML; +import org.palomafp.aadd.smmb.gestores.GestorConfiguracion; + +public class AplicacionPrincipal { + + public static void main(String[] args) { + + try { + + GestorConfiguracion configuracion = new GestorConfiguracion("application.properties"); + + ProcesadorFicheroCSV procesadorCSV = new ProcesadorFicheroCSV(configuracion); + procesadorCSV.realizarTratamientoFamiliasProfesionales(); + + ProcesadorFicheroXML procesadorXML = new ProcesadorFicheroXML(configuracion); + procesadorXML.realizarTratamientoCiclosFormativos(); + + } catch (IOException e) { + System.out.println("Error de configuración: " + e.getMessage()); + } 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/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/CiclosFormativosDaoMySql.java b/src/org/palomafp/aadd/smmb/dao/impl/CiclosFormativosDaoMySql.java new file mode 100644 index 0000000..358a6e7 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/dao/impl/CiclosFormativosDaoMySql.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 CiclosFormativosDaoMySql implements ICiclosFormativosDAO { + + private final Connection conexion; + + public CiclosFormativosDaoMySql(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/ProcesadorFicheroCSV.java b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroCSV.java new file mode 100644 index 0000000..ba74e4b --- /dev/null +++ b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroCSV.java @@ -0,0 +1,99 @@ +package org.palomafp.aadd.smmb.ficheros; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.util.regex.Pattern; + +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; + +public class ProcesadorFicheroCSV { + + private static final int NUM_CAMPOS = 4; + private static final int POS_CLAVE = 2; + private final FamiliaProfesionalService familiaService; + + private final String rutaFichero; + private final String separador; + + public ProcesadorFicheroCSV(GestorConfiguracion configuracion) { + + this.rutaFichero = configuracion.getRutaFamilias(); + this.separador = configuracion.getSeparadorFamilias(); + this.familiaService = new FamiliaProfesionalService(configuracion); + } + + public void realizarTratamientoFamiliasProfesionales() throws FormacionException { + + + + try (BufferedReader br = new BufferedReader(new FileReader(rutaFichero))) { + + // Saltamos la cabecera + br.readLine(); + + String linea; + + while ((linea = br.readLine()) != null) { + + // Miramos que no sea una linea vacia y no es comentario + if (esLineaValida(linea)) { + + FamiliaProfesional familia = parsearLinea(linea); + boolean existe = familiaService.existeFamiliaProfesionalPorClave(familia.getCodigoFamilia()); + + if (existe) { + System.out.println("Actualizando familia profesional: " + familia); + familiaService.actualizarFamiliaProfesional(familia); + } else { + System.out.println("Insertando la familia profesional: " + familia); + familiaService.insertarFamiliaProfesional(familia); + } + + } + } + + } catch (IOException e) { + throw new FormacionException("Error leyendo " + rutaFichero, e); + } + + } + + private FamiliaProfesional parsearLinea(String linea) throws FormacionException { + + String[] campos = linea.split(Pattern.quote(separador), -1); + + if (campos.length < NUM_CAMPOS) { + throw new FormacionException("Línea no válida: " + linea); + } + + String codigo = limpiar(campos[POS_CLAVE]); + String nom = limpiar(campos[3]); + + FamiliaProfesional familia = new FamiliaProfesional(); + + + familia.setCodigoFamilia(codigo); + familia.setNombre(nom); + + return familia; + } + + private String limpiar(String campo) { + String limpio = campo.trim().replace("\"", ""); + return limpio; + } + + private boolean esLineaValida(String linea) { + String limpia = linea.trim(); + + boolean vacia = limpia.isEmpty(); + boolean comentario = limpia.startsWith("#"); + + return !vacia && !comentario; + } + +} 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..f47439c --- /dev/null +++ b/src/org/palomafp/aadd/smmb/ficheros/ProcesadorFicheroXML.java @@ -0,0 +1,110 @@ +package org.palomafp.aadd.smmb.ficheros; + +import java.io.File; +import java.io.IOException; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; + +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.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; +import org.xml.sax.SAXException; + +public class ProcesadorFicheroXML { + + private final String rutaFichero; + private final CicloFormativoService cicloService; + + public ProcesadorFicheroXML(GestorConfiguracion configuracion) { + + this.rutaFichero = configuracion.getRutaCatalogo(); + this.cicloService = new CicloFormativoService(configuracion); + } + + public void realizarTratamientoCiclosFormativos() throws FormacionException { + + + try { + + Document documento = cargarDocumento(rutaFichero); + NodeList ciclos = documento.getElementsByTagName("ciclo"); + + for (int i = 0; i < ciclos.getLength(); i++) { + + Element elemento = (Element) ciclos.item(i); + + String codigo = elemento.getAttribute("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"); + + 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(ciclo); + cicloService.insertarCicloFormativo(ciclo); + + + } + + } catch (ParserConfigurationException | SAXException | IOException e) { + throw new FormacionException("Error leyendo " + rutaFichero, e); + } catch (NumberFormatException e) { + throw new FormacionException("Número de horas no válido en " + rutaFichero, e); + } + + } + + + + + private String obtenerTexto(Element padre, String etiqueta) { + + NodeList lista = padre.getElementsByTagName(etiqueta); + + if (lista.getLength() == 0) { + return ""; + } + + Node nodo = lista.item(0); + String texto = nodo.getTextContent().trim(); + + return texto; + } + + private Document cargarDocumento(String rutaXml) throws ParserConfigurationException, SAXException, IOException { + + DocumentBuilderFactory fabrica = DocumentBuilderFactory.newInstance(); + DocumentBuilder constructor = fabrica.newDocumentBuilder(); + Document documento = constructor.parse(new File(rutaXml)); + + documento.getDocumentElement().normalize(); + + return documento; + } + +} 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..e959457 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/gestores/GestorConfiguracion.java @@ -0,0 +1,51 @@ +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 getRutaFamilias() { + return propiedades.getProperty("familias.ruta.fichero"); + } + + public String getSeparadorFamilias() { + return propiedades.getProperty("familias.csv.separador"); + } + + public String getRutaCatalogo() { + return propiedades.getProperty("catalogo.ruta.fichero"); + } + + 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..2521378 --- /dev/null +++ b/src/org/palomafp/aadd/smmb/service/CicloFormativoService.java @@ -0,0 +1,49 @@ +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.IFamiliaProfesionalDAO; +import org.palomafp.aadd.smmb.dao.ITipoFormacionDAO; +import org.palomafp.aadd.smmb.dao.impl.CiclosFormativosDaoMySql; +import org.palomafp.aadd.smmb.dao.impl.FamiliaProfesionalDaoMySql; +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; +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()) { + + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoMySql(conexion); + ITipoFormacionDAO tipoDao = new TipoFormacionDaoMySql(conexion); + ICiclosFormativosDAO cicloDao = new CiclosFormativosDaoMySql(conexion); + + String codFamilia = ciclo.getFamiliaProfesional().getCodigoFamilia(); + String codTipo = ciclo.getTipoFormacion().getCodigoTipoEstudio(); + + boolean existeFamilia = familiaDao.existeFamiliaProfesionalPorCodigo(codFamilia); + boolean existeTipo = tipoDao.existeTipoFormacionPorCodigo(codTipo); + + if (existeFamilia && existeTipo) { + 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); + } + } + +}