commit f3c9aa32c0947b0de1b3c0e0a1ee6e0a9ecaa510 Author: dta Date: Thu Nov 5 10:21:45 2026 +0100 first commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..381fc2a --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +.settings/ +bin/ +target/ +.classpath +.project +*.class \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..1c59d84 --- /dev/null +++ b/README.md @@ -0,0 +1,252 @@ +# aadd_conect04: Procesamiento de ficheros CSV y XML con JDBC, patrón DAO y capa de servicios (MySQL) + +## Descripción + +Proyecto en Java que procesa dos ficheros (un CSV de familias profesionales y un XML de ciclos formativos) y vuelca su información en la base de datos `Formacion_FP`, administrada por MySQL. Se utiliza el API JDBC, el patrón DAO (solo para el acceso a la base de datos) y una capa de servicios. Todas las sentencias SQL se ejecutan con `PreparedStatement`. + +Es la evolución de `aadd_conect03` con cuatro novedades: + +- **Procesamiento de ficheros**: lectura de un CSV (familias profesionales) y de un XML con DOM (ciclos formativos). +- **Fichero de configuración ampliado**: además de los datos de conexión, contiene las rutas de los ficheros y el separador del CSV. +- **Modelo orientado a objetos**: `CicloFormativo` referencia a objetos `FamiliaProfesional` y `TipoFormacion`. +- **Excepción de aplicación** `FormacionException` (checked), única excepción que sale de las capas de acceso a datos, utilidades y servicios. + +Los datos de conexión y las rutas de los ficheros no están escritos en el código: se leen del fichero `application.properties` a través de la clase `GestorConfiguracion`. + +## Estructura del proyecto + +- `aadd_conect04/` + - `src/org/palomafp/aadd/dta/` + - `AppPrincipal.java`: clase principal que ejecuta los dos casos de uso a través del servicio + - `model/` + - `FamiliaProfesional.java`: clase del modelo (una familia profesional) + - `TipoFormacion.java`: clase del modelo (un tipo de formación) + - `CicloFormativo.java`: clase del modelo (un ciclo formativo, con su familia y su tipo) + - `dao/` + - `IFamiliaProfesionalDAO.java`: interfaz del DAO de familias profesionales + - `ITipoFormacionDAO.java`: interfaz del DAO de tipos de formación + - `ICicloFormativoDAO.java`: interfaz del DAO de ciclos formativos + - `impl/` + - `FamiliaProfesionalDaoJDBC.java`: implementación JDBC con `PreparedStatement` + - `TipoFormacionDaoJDBC.java`: implementación JDBC con `PreparedStatement` + - `CicloFormativoDaoJDBC.java`: implementación JDBC con `PreparedStatement` y `JOIN` + - `service/` + - `FormacionService.java`: casos de uso (procesar familias y procesar ciclos) + - `util/` + - `LectorFamiliasCsv.java`: lee el CSV de familias profesionales + - `LectorCiclosXml.java`: lee el XML de ciclos formativos + - `excepciones/` + - `FormacionException.java`: excepción de aplicación (checked) + - `gestores/` + - `GestorConfiguracion.java`: carga `application.properties` y expone sus valores + - `GestorConexionBBDD.java`: crea las conexiones a la base de datos + - `config/` + - `application.properties`: configuración (conexión a la BBDD y rutas de los ficheros) + - `ficheros/` + - `familias_profesionales.csv`: familias profesionales a procesar + - `catalogo_formacion.xml`: ciclos formativos a procesar + - `Formacion_FP.sql`: script de creación de la base de datos + - `pom.xml` + - `README.md` + +## Base de datos + +El script `Formacion_FP.sql` crea la base de datos `Formacion_FP` con tres tablas: + +| Tabla | Columnas | +|---|---| +| `T_FAMILIA_PROFESIONAL` | `codigo` (PK), `nombre` | +| `T_TIPO_FORMACION` | `codigo` (PK), `nombre_corto`, `nombre_largo` | +| `T_CICLO_FORMATIVO` | `codigo` (PK), `nombre_corto`, `nombre_largo`, `horas_duracion`, `codigo_familia` (FK a `T_FAMILIA_PROFESIONAL`), `codigo_tipo_formacion` (FK a `T_TIPO_FORMACION`) | + +Tras ejecutar el script, la base de datos contiene la familia `ADG` (con un nombre distinto al del CSV) y los cuatro tipos de formación: `CFGB`, `CFGM`, `CFGS` y `CE`. No contiene ciclos formativos. + +## Origen y destino de los datos + +| Información | Origen | Destino | +|---|---|---| +| Familias profesionales | Fichero CSV | `T_FAMILIA_PROFESIONAL` | +| Ciclos formativos | Fichero XML | `T_CICLO_FORMATIVO` | +| Tipos de formación | Base de datos (`T_TIPO_FORMACION`) | Solo se consulta | + +## Arquitectura en capas + +``` +AppPrincipal → Service → DAO → Base de datos + → Util → Ficheros (CSV y XML) +``` + +| Capa | Responsabilidad | +|---|---| +| `AppPrincipal` | Decide qué se ejecuta y qué se imprime. No conoce conexiones, SQL ni ficheros | +| Servicio | Representa los casos de uso. Lee los ficheros, abre y cierra la conexión y aplica las reglas de negocio | +| DAO | Ejecuta las sentencias SQL de una tabla. Recibe la conexión por constructor y no la cierra | +| Util | Lee los ficheros CSV y XML y los convierte en objetos del modelo. No usa el patrón DAO | +| Modelo | Clases que representan una fila de cada tabla | + +El patrón DAO se usa **únicamente para el acceso a la base de datos**. Los ficheros se leen con clases de utilidad. + +## Componentes principales + +- **`FamiliaProfesional`, `TipoFormacion` y `CicloFormativo`**: clases del modelo con sus atributos, getters y setters. `CicloFormativo` guarda un objeto `FamiliaProfesional` y un objeto `TipoFormacion`, no sus códigos. +- **`IFamiliaProfesionalDAO`, `ITipoFormacionDAO` e `ICicloFormativoDAO`**: interfaces con las operaciones de acceso a datos. Todos sus métodos declaran `throws FormacionException`. +- **`FamiliaProfesionalDaoJDBC`, `TipoFormacionDaoJDBC` y `CicloFormativoDaoJDBC`**: implementaciones JDBC. Reciben la `Connection` por constructor y la guardan en un atributo `private final`. Cada método crea un `PreparedStatement` con `try-with-resources`. Las `SQLException` se capturan y se relanzan envueltas en `FormacionException`, conservando la causa original. +- **`FormacionService`**: abre la conexión con `try-with-resources` (se cierra sola), crea los DAO pasándosela y aplica la lógica de cada caso de uso. Los fallos al cerrar la conexión también se convierten en `FormacionException`. +- **`LectorFamiliasCsv` y `LectorCiclosXml`**: clases de utilidad (constructor privado y método estático `leer()`). Obtienen la ruta y el separador de `GestorConfiguracion`. +- **`FormacionException`**: excepción checked con dos constructores (`mensaje` y `mensaje, causa`). Es la única que conocen las capas superiores. +- **`GestorConfiguracion`**: clase de utilidad (constructor privado) que carga `application.properties` en el método `cargar()` y ofrece un getter por propiedad. Si el fichero no existe o no se puede leer, lanza `FormacionException`. +- **`GestorConexionBBDD`**: clase de utilidad que monta la URL (`sgbd.conexion.url` + `bbdd.nombre`) y devuelve una `Connection` nueva. Quien la recibe es responsable de cerrarla. +- **`AppPrincipal`**: crea el `FormacionService` y ejecuta los dos casos de uso en orden. Captura `FormacionException` en un único punto. + +## Configuración + +Fichero `application.properties`: + +```properties +# Información relativa a la base de datos +sgbd.conexion.url=jdbc:mysql://192.168.1.62:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=myuser +bbdd.clave=mypass + +# Información relativa a familias profesionales +familiaprofesional.ruta.fichero=ficheros/familias_profesionales.csv +familiaprofesional.csv.separador=| + +# Información relativa a ciclos formativos +cicloformativo.ruta.fichero=ficheros/catalogo_formacion.xml +``` + +- La URL de conexión se forma concatenando `sgbd.conexion.url` y `bbdd.nombre`, es decir, `jdbc:mysql://192.168.1.62:3306/Formacion_FP`. Para ejecutar el proyecto en otro equipo hay que cambiar la IP (o usar `localhost`) y las credenciales. +- Las rutas son relativas al directorio de ejecución, por lo que el programa debe lanzarse desde la raíz del proyecto. + +## Ficheros de entrada + +### CSV de familias profesionales + +Fichero con cabecera y separador `|`: + +``` +id_registro|fecha_carga|cod_tipo_fam|nombre_tf +``` + +Solo interesan las columnas `cod_tipo_fam` (posición 2) y `nombre_tf` (posición 3). El fichero contiene datos con espacios sobrantes (`" IFC"` y `"TMV "`), que se eliminan con `trim()`. El separador se escapa con `Pattern.quote`, porque `|` es un carácter especial en las expresiones regulares de `String.split`. + +### XML de ciclos formativos + +Los elementos `ciclo` cuelgan de `ciclos_formativos`. Correspondencia con la tabla `T_CICLO_FORMATIVO`: + +| XML | Columna | +|---|---| +| atributo `cod_cf` | `codigo` | +| `nomb_corto` | `nombre_corto` | +| `nombrelargo` | `nombre_largo` | +| `num_horas_duracion` | `horas_duracion` | +| `codigo_familia` | `codigo_familia` | +| `codigo_tipoestudio` | `codigo_tipo_formacion` | + +## Métodos de los DAO + +Los tres DAO ofrecen los mismos cinco métodos: + +| Método | Sentencia SQL | Devuelve | +|---|---|---| +| `obtenerTodos()` | `SELECT` de todas las filas | `List` del modelo | +| `obtenerPorCodigo(String codigo)` | `SELECT ... WHERE codigo = ?` | El objeto, o `null` si no existe | +| `insertar(objeto)` | `INSERT` con todos los campos | nada | +| `actualizar(objeto)` | `UPDATE` de los campos no clave por código | nada | +| `borrar(String codigo)` | `DELETE ... WHERE codigo = ?` | nada | + +`CicloFormativoDaoJDBC` usa un `JOIN` con `T_FAMILIA_PROFESIONAL` y `T_TIPO_FORMACION` en `obtenerTodos()` y `obtenerPorCodigo()` para reconstruir los objetos referenciados. + +## Métodos del servicio + +| Método | Acción | +|---|---| +| `procesarFamilias()` | Lee el CSV y, por cada familia, la inserta si no existe en la BBDD o actualiza su nombre si ya existe. Devuelve el número de familias procesadas | +| `procesarCiclos()` | Lee el XML e inserta solo los ciclos cuya familia profesional y tipo de formación existen en la BBDD. Devuelve el número de ciclos insertados | + +### Reglas de `procesarCiclos()` + +1. El lector crea cada `CicloFormativo` con objetos `FamiliaProfesional` y `TipoFormacion` que solo tienen el código. +2. El servicio busca en la BBDD la familia y el tipo con `obtenerPorCodigo`. +3. Si alguno de los dos no existe, el ciclo se descarta. +4. Si existen ambos, el servicio sustituye los objetos incompletos por los de la BBDD e inserta el ciclo. + +## Métodos de `AppPrincipal` + +| Método | Acción | +|---|---| +| `main(String[] args)` | Crea el servicio, ejecuta `procesarFamilias()` y después `procesarCiclos()`, e imprime el número de registros procesados. Captura `FormacionException` en un único punto | + +**El orden es obligatorio**: las familias `IFC`, `TMV` y `SAN` solo existen en la BBDD después de procesar el CSV. Si se procesaran antes los ciclos, saldrían menos de 10. + +## Resultado del procesamiento + +### Familias profesionales + +| Código | Acción | Motivo | +|---|---|---| +| `ADG` | Actualizada | Ya existía en la BBDD: su nombre pasa a `Administración y Gestión` | +| `IFC` | Insertada | No existía | +| `TMV` | Insertada | No existía | +| `SAN` | Insertada | No existía | + +### Ciclos formativos + +El XML contiene 14 ciclos, de los que se insertan 10: + +| Ciclo | Familia | Tipo | ¿Se inserta? | +|---|---|---|---| +| `ADGB01` | `ADG` | `CFBA` | No: el tipo de formación no existe | +| `ADGM01` | `ADG` | `CFGM` | Sí | +| `ADGS01` | `ADG` | `CFGS` | Sí | +| `IFCB01` | `IFE` | `CFGB` | No: la familia profesional no existe | +| `IFCM01` | `IFC` | `CFGM` | Sí | +| `IFCS02` | `IFC` | `CFGS` | Sí | +| `IFCS03` | `IFC` | `CFGS` | Sí | +| `IFCES03` | `IFC` | `CFE` | No: el tipo de formación no existe | +| `TMVB01` | `TMV` | `CFGB` | Sí | +| `TMVM01` | `TMV` | `CFGM` | Sí | +| `TMVS01` | `TMV` | `CFGS` | Sí | +| `TMVES02` | `TMV` | `CE` | Sí | +| `SANM01` | `SAN` | `CFME` | No: el tipo de formación no existe | +| `SANS01` | `SAN` | `CFGS` | Sí | + +## Salida por consola + +Salida obtenida al ejecutar `AppPrincipal` con la base de datos recién creada: + +``` +Familias procesadas: 4 +Ciclos insertados: 10 +``` + +## Aspectos a tener en cuenta + +- Se asume que **no hay ciclos formativos** en la base de datos. Si se ejecuta `AppPrincipal` dos veces seguidas, la segunda fallará con un error de clave duplicada. Para repetir la prueba hay que volver a ejecutar `Formacion_FP.sql`. +- Las familias sí se pueden procesar varias veces: si ya existen, solo se actualiza el nombre. +- Los DAO no abren ni cierran la conexión; lo hace el servicio. `AppPrincipal` no conoce JDBC ni los ficheros. +- Se usa una conexión por caso de uso: la misma conexión sirve para los tres DAO. +- Los lectores no usan el patrón DAO, porque el enunciado lo limita al acceso a la base de datos. +- Hay una única excepción de aplicación, `FormacionException`, que se propaga desde los DAO y los lectores hasta `AppPrincipal`. +- La carpeta `config` está configurada como *source folder* en Eclipse, por lo que `application.properties` está en el classpath. + +## Ejecución + +1. Ejecutar `Formacion_FP.sql` en un cliente MySQL (por ejemplo DBeaver) para crear la base de datos. +2. Crear el usuario con permisos sobre la base de datos: + ```sql + CREATE USER 'myuser'@'%' IDENTIFIED BY 'mypass'; + GRANT ALL PRIVILEGES ON Formacion_FP.* TO 'myuser'@'%'; + FLUSH PRIVILEGES; + ``` +3. Ajustar `config/application.properties` a la IP y credenciales del servidor MySQL. +4. Comprobar que `ficheros/` contiene `familias_profesionales.csv` y `catalogo_formacion.xml`. +5. Ejecutar `AppPrincipal` como aplicación Java, desde la raíz del proyecto. +6. Comprobar en la consola la salida (`Familias procesadas: 4` y `Ciclos insertados: 10`). +7. Comprobar en la base de datos: + ```sql + SELECT * FROM T_FAMILIA_PROFESIONAL; -- ADG (nombre actualizado), IFC, SAN y TMV + SELECT COUNT(*) FROM T_CICLO_FORMATIVO; -- 10 + ``` \ No newline at end of file diff --git a/config/application.properties b/config/application.properties new file mode 100644 index 0000000..6ed86f9 --- /dev/null +++ b/config/application.properties @@ -0,0 +1,12 @@ +# Información relativa a la base de datos +sgbd.conexion.url=jdbc:mysql://192.168.1.62:3306/ +bbdd.nombre=Formacion_FP +bbdd.usuario=myuser +bbdd.clave=mypass + +# Información relativa a familias profesionales +familiaprofesional.ruta.fichero=ficheros/familias_profesionales.csv +familiaprofesional.csv.separador=| + +# Información relativa a ciclos formativos +cicloformativo.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/formacion_fp.sql b/formacion_fp.sql new file mode 100644 index 0000000..d45fc83 --- /dev/null +++ b/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..0b77c6c --- /dev/null +++ b/pom.xml @@ -0,0 +1,30 @@ + + 4.0.0 + aadd_conect04 + aadd_conect04 + 0.0.1-SNAPSHOT + + + + com.mysql + mysql-connector-j + 26.10.0 + compile + + + + src + + + maven-compiler-plugin + 3.13.0 + + 26 + + + + + \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/AppPrincipal.java b/src/org/palomafp/aadd/dta/AppPrincipal.java new file mode 100644 index 0000000..d44af4f --- /dev/null +++ b/src/org/palomafp/aadd/dta/AppPrincipal.java @@ -0,0 +1,23 @@ +package org.palomafp.aadd.dta; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.service.FormacionService; + +public class AppPrincipal { + + public static void main(String[] args) { + FormacionService servicio = new FormacionService(); + + try { + // Primero las familias: los ciclos dependen de ellas + int familias = servicio.procesarFamilias(); + System.out.println("Familias procesadas: " + familias); + + int ciclos = servicio.procesarCiclos(); + System.out.println("Ciclos insertados: " + ciclos); + + } catch (FormacionException e) { + System.err.println("Error: " + e.getMessage()); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/dao/ICicloFormativoDAO.java b/src/org/palomafp/aadd/dta/dao/ICicloFormativoDAO.java new file mode 100644 index 0000000..d91a33c --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/ICicloFormativoDAO.java @@ -0,0 +1,16 @@ +package org.palomafp.aadd.dta.dao; + +import java.util.List; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.CicloFormativo; + +public interface ICicloFormativoDAO { + + List obtenerTodos() throws FormacionException; + CicloFormativo obtenerPorCodigo(String codigo) throws FormacionException; + void insertar(CicloFormativo ciclo) throws FormacionException; + void actualizar(CicloFormativo ciclo) throws FormacionException; + void borrar(String codigo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/dta/dao/IFamiliaProfesionalDAO.java b/src/org/palomafp/aadd/dta/dao/IFamiliaProfesionalDAO.java new file mode 100644 index 0000000..39c6480 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/IFamiliaProfesionalDAO.java @@ -0,0 +1,16 @@ +package org.palomafp.aadd.dta.dao; + +import java.util.List; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.FamiliaProfesional; + +public interface IFamiliaProfesionalDAO { + + List obtenerTodos() throws FormacionException; + FamiliaProfesional obtenerPorCodigo(String codigo) throws FormacionException; + void insertar(FamiliaProfesional familia) throws FormacionException; + void actualizar(FamiliaProfesional familia) throws FormacionException; + void borrar(String codigo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/dta/dao/ITipoFormacionDAO.java b/src/org/palomafp/aadd/dta/dao/ITipoFormacionDAO.java new file mode 100644 index 0000000..779d747 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/ITipoFormacionDAO.java @@ -0,0 +1,16 @@ +package org.palomafp.aadd.dta.dao; + +import java.util.List; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.TipoFormacion; + +public interface ITipoFormacionDAO { + + List obtenerTodos() throws FormacionException; + TipoFormacion obtenerPorCodigo(String codigo) throws FormacionException; + void insertar(TipoFormacion tipo) throws FormacionException; + void actualizar(TipoFormacion tipo) throws FormacionException; + void borrar(String codigo) throws FormacionException; + +} diff --git a/src/org/palomafp/aadd/dta/dao/impl/CicloFormativoDaoJDBC.java b/src/org/palomafp/aadd/dta/dao/impl/CicloFormativoDaoJDBC.java new file mode 100644 index 0000000..eb068fc --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/impl/CicloFormativoDaoJDBC.java @@ -0,0 +1,145 @@ +package org.palomafp.aadd.dta.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import org.palomafp.aadd.dta.dao.ICicloFormativoDAO; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.CicloFormativo; +import org.palomafp.aadd.dta.model.FamiliaProfesional; +import org.palomafp.aadd.dta.model.TipoFormacion; + +public class CicloFormativoDaoJDBC implements ICicloFormativoDAO { + + private final Connection conexion; + + public CicloFormativoDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public List obtenerTodos() throws FormacionException { + List lista = new ArrayList<>(); + String sql = "SELECT c.codigo, c.nombre_corto, c.nombre_largo, c.horas_duracion, " + + "f.codigo AS fam_codigo, f.nombre AS fam_nombre, " + + "t.codigo AS tipo_codigo, t.nombre_corto AS tipo_corto, t.nombre_largo AS tipo_largo " + + "FROM T_CICLO_FORMATIVO c " + "JOIN T_FAMILIA_PROFESIONAL f ON c.codigo_familia = f.codigo " + + "JOIN T_TIPO_FORMACION t ON c.codigo_tipo_formacion = t.codigo"; + + try (PreparedStatement ps = conexion.prepareStatement(sql); ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigo(rs.getString("fam_codigo")); + familia.setNombre(rs.getString("fam_nombre")); + + TipoFormacion tipo = new TipoFormacion(); + tipo.setCodigo(rs.getString("tipo_codigo")); + tipo.setNombreCorto(rs.getString("tipo_corto")); + tipo.setNombreLargo(rs.getString("tipo_largo")); + + CicloFormativo ciclo = new CicloFormativo(); + ciclo.setCodigo(rs.getString("codigo")); + ciclo.setNombreCorto(rs.getString("nombre_corto")); + ciclo.setNombreLargo(rs.getString("nombre_largo")); + ciclo.setHorasDuracion(rs.getInt("horas_duracion")); + ciclo.setFamiliaProfesional(familia); + ciclo.setTipoFormacion(tipo); + lista.add(ciclo); + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener los ciclos formativos", e); + } + + return lista; + } + + @Override + public CicloFormativo obtenerPorCodigo(String codigo) throws FormacionException { + CicloFormativo ciclo = null; + String sql = "SELECT c.codigo, c.nombre_corto, c.nombre_largo, c.horas_duracion, " + + "f.codigo AS fam_codigo, f.nombre AS fam_nombre, " + + "t.codigo AS tipo_codigo, t.nombre_corto AS tipo_corto, t.nombre_largo AS tipo_largo " + + "FROM T_CICLO_FORMATIVO c " + "JOIN T_FAMILIA_PROFESIONAL f ON c.codigo_familia = f.codigo " + + "JOIN T_TIPO_FORMACION t ON c.codigo_tipo_formacion = t.codigo " + "WHERE c.codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, codigo); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) { + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigo(rs.getString("fam_codigo")); + familia.setNombre(rs.getString("fam_nombre")); + + TipoFormacion tipo = new TipoFormacion(); + tipo.setCodigo(rs.getString("tipo_codigo")); + tipo.setNombreCorto(rs.getString("tipo_corto")); + tipo.setNombreLargo(rs.getString("tipo_largo")); + + ciclo = new CicloFormativo(); + ciclo.setCodigo(rs.getString("codigo")); + ciclo.setNombreCorto(rs.getString("nombre_corto")); + ciclo.setNombreLargo(rs.getString("nombre_largo")); + ciclo.setHorasDuracion(rs.getInt("horas_duracion")); + ciclo.setFamiliaProfesional(familia); + ciclo.setTipoFormacion(tipo); + } + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener el ciclo formativo " + codigo, e); + } + + return ciclo; + } + + @Override + public void insertar(CicloFormativo ciclo) throws FormacionException { + 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, ciclo.getCodigo()); + ps.setString(2, ciclo.getNombreCorto()); + ps.setString(3, ciclo.getNombreLargo()); + ps.setInt(4, ciclo.getHorasDuracion()); + ps.setString(5, ciclo.getFamiliaProfesional().getCodigo()); + ps.setString(6, ciclo.getTipoFormacion().getCodigo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar el ciclo formativo " + ciclo.getCodigo(), e); + } + } + + @Override + public void actualizar(CicloFormativo ciclo) throws FormacionException { + String sql = "UPDATE T_CICLO_FORMATIVO SET nombre_corto = ?, nombre_largo = ?, " + + "horas_duracion = ?, codigo_familia = ?, codigo_tipo_formacion = ? WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, ciclo.getNombreCorto()); + ps.setString(2, ciclo.getNombreLargo()); + ps.setInt(3, ciclo.getHorasDuracion()); + ps.setString(4, ciclo.getFamiliaProfesional().getCodigo()); + ps.setString(5, ciclo.getTipoFormacion().getCodigo()); + ps.setString(6, ciclo.getCodigo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al actualizar el ciclo formativo " + ciclo.getCodigo(), e); + } + } + + @Override + public void borrar(String codigo) throws FormacionException { + String sql = "DELETE FROM T_CICLO_FORMATIVO WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, codigo); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al borrar el ciclo formativo " + codigo, e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/dao/impl/FamiliaProfesionalDaoJDBC.java b/src/org/palomafp/aadd/dta/dao/impl/FamiliaProfesionalDaoJDBC.java new file mode 100644 index 0000000..c271f84 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/impl/FamiliaProfesionalDaoJDBC.java @@ -0,0 +1,99 @@ +package org.palomafp.aadd.dta.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import org.palomafp.aadd.dta.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.FamiliaProfesional; + +public class FamiliaProfesionalDaoJDBC implements IFamiliaProfesionalDAO { + + private final Connection conexion; + + public FamiliaProfesionalDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public List obtenerTodos() throws FormacionException { + List lista = new ArrayList<>(); + String sql = "SELECT codigo, nombre FROM T_FAMILIA_PROFESIONAL"; + + try (PreparedStatement ps = conexion.prepareStatement(sql); ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigo(rs.getString("codigo")); + familia.setNombre(rs.getString("nombre")); + lista.add(familia); + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener las familias profesionales", e); + } + + return lista; + } + + @Override + public FamiliaProfesional obtenerPorCodigo(String codigo) throws FormacionException { + FamiliaProfesional familia = null; + String sql = "SELECT codigo, nombre FROM T_FAMILIA_PROFESIONAL WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, codigo); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) { + familia = new FamiliaProfesional(); + familia.setCodigo(rs.getString("codigo")); + familia.setNombre(rs.getString("nombre")); + } + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener la familia profesional " + codigo, e); + } + + return familia; + } + + @Override + public void insertar(FamiliaProfesional familia) throws FormacionException { + String sql = "INSERT INTO T_FAMILIA_PROFESIONAL (codigo, nombre) VALUES (?, ?)"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, familia.getCodigo()); + ps.setString(2, familia.getNombre()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar la familia profesional " + familia.getCodigo(), e); + } + } + + @Override + public void actualizar(FamiliaProfesional familia) throws FormacionException { + String sql = "UPDATE T_FAMILIA_PROFESIONAL SET nombre = ? WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, familia.getNombre()); + ps.setString(2, familia.getCodigo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al actualizar la familia profesional " + familia.getCodigo(), e); + } + } + + @Override + public void borrar(String codigo) throws FormacionException { + String sql = "DELETE FROM T_FAMILIA_PROFESIONAL WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, codigo); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al borrar la familia profesional " + codigo, e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/dao/impl/TipoFormacionDaoJDBC.java b/src/org/palomafp/aadd/dta/dao/impl/TipoFormacionDaoJDBC.java new file mode 100644 index 0000000..b323c30 --- /dev/null +++ b/src/org/palomafp/aadd/dta/dao/impl/TipoFormacionDaoJDBC.java @@ -0,0 +1,103 @@ +package org.palomafp.aadd.dta.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import org.palomafp.aadd.dta.dao.ITipoFormacionDAO; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.model.TipoFormacion; + +public class TipoFormacionDaoJDBC implements ITipoFormacionDAO { + + private final Connection conexion; + + public TipoFormacionDaoJDBC(Connection conexion) { + this.conexion = conexion; + } + + @Override + public List obtenerTodos() throws FormacionException { + List lista = new ArrayList<>(); + String sql = "SELECT codigo, nombre_corto, nombre_largo FROM T_TIPO_FORMACION"; + + try (PreparedStatement ps = conexion.prepareStatement(sql); ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + TipoFormacion tipo = new TipoFormacion(); + tipo.setCodigo(rs.getString("codigo")); + tipo.setNombreCorto(rs.getString("nombre_corto")); + tipo.setNombreLargo(rs.getString("nombre_largo")); + lista.add(tipo); + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener los tipos de formación", e); + } + + return lista; + } + + @Override + public TipoFormacion obtenerPorCodigo(String codigo) throws FormacionException { + TipoFormacion tipo = null; + String sql = "SELECT codigo, nombre_corto, nombre_largo FROM T_TIPO_FORMACION WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, codigo); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) { + tipo = new TipoFormacion(); + tipo.setCodigo(rs.getString("codigo")); + tipo.setNombreCorto(rs.getString("nombre_corto")); + tipo.setNombreLargo(rs.getString("nombre_largo")); + } + } + } catch (SQLException e) { + throw new FormacionException("Error al obtener el tipo de formación " + codigo, e); + } + + return tipo; + } + + @Override + public void insertar(TipoFormacion tipo) throws FormacionException { + String sql = "INSERT INTO T_TIPO_FORMACION (codigo, nombre_corto, nombre_largo) VALUES (?, ?, ?)"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, tipo.getCodigo()); + ps.setString(2, tipo.getNombreCorto()); + ps.setString(3, tipo.getNombreLargo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al insertar el tipo de formación " + tipo.getCodigo(), e); + } + } + + @Override + public void actualizar(TipoFormacion tipo) throws FormacionException { + String sql = "UPDATE T_TIPO_FORMACION SET nombre_corto = ?, nombre_largo = ? WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, tipo.getNombreCorto()); + ps.setString(2, tipo.getNombreLargo()); + ps.setString(3, tipo.getCodigo()); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al actualizar el tipo de formación " + tipo.getCodigo(), e); + } + } + + @Override + public void borrar(String codigo) throws FormacionException { + String sql = "DELETE FROM T_TIPO_FORMACION WHERE codigo = ?"; + + try (PreparedStatement ps = conexion.prepareStatement(sql)) { + ps.setString(1, codigo); + ps.executeUpdate(); + } catch (SQLException e) { + throw new FormacionException("Error al borrar el tipo de formación " + codigo, e); + } + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/excepciones/FormacionException.java b/src/org/palomafp/aadd/dta/excepciones/FormacionException.java new file mode 100644 index 0000000..11020b8 --- /dev/null +++ b/src/org/palomafp/aadd/dta/excepciones/FormacionException.java @@ -0,0 +1,15 @@ +package org.palomafp.aadd.dta.excepciones; + +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/dta/gestores/GestorConexionBBDD.java b/src/org/palomafp/aadd/dta/gestores/GestorConexionBBDD.java new file mode 100644 index 0000000..5f9b27d --- /dev/null +++ b/src/org/palomafp/aadd/dta/gestores/GestorConexionBBDD.java @@ -0,0 +1,27 @@ +package org.palomafp.aadd.dta.gestores; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +import org.palomafp.aadd.dta.excepciones.FormacionException; + +public class GestorConexionBBDD { + + private GestorConexionBBDD() { + + } + + public static Connection getConexion() throws FormacionException { + String url = GestorConfiguracion.getConexionUrl() + GestorConfiguracion.getNombreBBDD(); + String usuario = GestorConfiguracion.getUsuarioBBDD(); + String clave = GestorConfiguracion.getClaveBBDD(); + + try { + return DriverManager.getConnection(url, usuario, clave); + } catch (SQLException e) { + throw new FormacionException("No se pudo conectar con la base de datos " + url, e); + } + } + +} diff --git a/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java b/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java new file mode 100644 index 0000000..ec1323c --- /dev/null +++ b/src/org/palomafp/aadd/dta/gestores/GestorConfiguracion.java @@ -0,0 +1,78 @@ +package org.palomafp.aadd.dta.gestores; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.Properties; + +import org.palomafp.aadd.dta.excepciones.FormacionException; + +public class GestorConfiguracion { + + private static final String CONFIG = "application.properties"; + private static final Properties PROPS = new Properties(); + private static boolean cargado = false; + + private GestorConfiguracion() { + + } + + public static void cargar() throws FormacionException { + + if (cargado) { + return; + } + + try (var is = GestorConfiguracion.class.getClassLoader().getResourceAsStream(CONFIG)){ + if (is == null) { + throw new FormacionException("No se encuentra el fichero " + CONFIG + " en el classpath."); + } + PROPS.load(is); + cargado = true; + } catch (IOException e) { + throw new FormacionException("No se pudo leer el fichero de configuración " + CONFIG, e); + } + + } + + // Base de datos + + public static String getConexionUrl() throws FormacionException { + cargar(); + return PROPS.getProperty("sgbd.conexion.url"); + } + + public static String getNombreBBDD() throws FormacionException { + cargar(); + return PROPS.getProperty("bbdd.nombre"); + } + + public static String getUsuarioBBDD() throws FormacionException { + cargar(); + return PROPS.getProperty("bbdd.usuario"); + } + + public static String getClaveBBDD() throws FormacionException { + cargar(); + return PROPS.getProperty("bbdd.clave"); + } + + // Familias profesionales (CSV) + + public static Path getRutaFicheroFamilias() throws FormacionException { + cargar(); + return Path.of(PROPS.getProperty("familiaprofesional.ruta.fichero")); + } + + public static String getSeparadorCsvFamilias() throws FormacionException { + cargar(); + return PROPS.getProperty("familiaprofesional.csv.separador"); + } + + // Ciclos formativos (XML) + + public static Path getRutaFicheroCiclos() throws FormacionException { + cargar(); + return Path.of(PROPS.getProperty("cicloformativo.ruta.fichero")); + } + +} diff --git a/src/org/palomafp/aadd/dta/model/CicloFormativo.java b/src/org/palomafp/aadd/dta/model/CicloFormativo.java new file mode 100644 index 0000000..1189d0b --- /dev/null +++ b/src/org/palomafp/aadd/dta/model/CicloFormativo.java @@ -0,0 +1,82 @@ +package org.palomafp.aadd.dta.model; + +public class CicloFormativo { + + private String codigo; + private String nombreCorto; + private String nombreLargo; + private int horasDuracion; + + private FamiliaProfesional familiaProfesional; + private TipoFormacion tipoFormacion; + + public CicloFormativo() { + + } + + public CicloFormativo(String codigo, String nombreCorto, String nombreLargo, int horasDuracion, + FamiliaProfesional familiaProfesional, TipoFormacion tipoFormacion) { + this.codigo = codigo; + this.nombreCorto = nombreCorto; + this.nombreLargo = nombreLargo; + this.horasDuracion = horasDuracion; + this.familiaProfesional = familiaProfesional; + this.tipoFormacion = tipoFormacion; + } + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombreCorto() { + return nombreCorto; + } + + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + + public String getNombreLargo() { + return nombreLargo; + } + + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } + + public int 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 [codigo=" + codigo + ", nombreCorto=" + nombreCorto + ", nombreLargo=" + nombreLargo + + ", horasDuracion=" + horasDuracion + ", familiaProfesional=" + familiaProfesional + ", tipoFormacion=" + + tipoFormacion + "]"; + } + +} diff --git a/src/org/palomafp/aadd/dta/model/FamiliaProfesional.java b/src/org/palomafp/aadd/dta/model/FamiliaProfesional.java new file mode 100644 index 0000000..1a5632b --- /dev/null +++ b/src/org/palomafp/aadd/dta/model/FamiliaProfesional.java @@ -0,0 +1,38 @@ +package org.palomafp.aadd.dta.model; + +public class FamiliaProfesional { + + private String codigo; + private String nombre; + + public FamiliaProfesional() { + + } + + public FamiliaProfesional(String codigo, String nombre) { + this.codigo = codigo; + this.nombre = nombre; + } + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public String toString() { + return "FamiliaProfesional [codigo=" + codigo + ", nombre=" + nombre + "]"; + } + +} diff --git a/src/org/palomafp/aadd/dta/model/TipoFormacion.java b/src/org/palomafp/aadd/dta/model/TipoFormacion.java new file mode 100644 index 0000000..ee57f46 --- /dev/null +++ b/src/org/palomafp/aadd/dta/model/TipoFormacion.java @@ -0,0 +1,49 @@ +package org.palomafp.aadd.dta.model; + +public class TipoFormacion { + + private String codigo; + private String nombreCorto; + private String nombreLargo; + + public TipoFormacion() { + + } + + public TipoFormacion(String codigo, String nombreCorto, String nombreLargo) { + this.codigo = codigo; + this.nombreCorto = nombreCorto; + this.nombreLargo = nombreLargo; + } + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombreCorto() { + return nombreCorto; + } + + public void setNombreCorto(String nombreCorto) { + this.nombreCorto = nombreCorto; + } + + public String getNombreLargo() { + return nombreLargo; + } + + public void setNombreLargo(String nombreLargo) { + this.nombreLargo = nombreLargo; + } + + @Override + public String toString() { + return "TipoFormacion [codigo=" + codigo + ", nombreCorto=" + nombreCorto + ", nombreLargo=" + nombreLargo + + "]"; + } + +} diff --git a/src/org/palomafp/aadd/dta/service/FormacionService.java b/src/org/palomafp/aadd/dta/service/FormacionService.java new file mode 100644 index 0000000..5702ff9 --- /dev/null +++ b/src/org/palomafp/aadd/dta/service/FormacionService.java @@ -0,0 +1,73 @@ +package org.palomafp.aadd.dta.service; + +import java.sql.Connection; +import java.sql.SQLException; +import java.util.List; + +import org.palomafp.aadd.dta.dao.ICicloFormativoDAO; +import org.palomafp.aadd.dta.dao.IFamiliaProfesionalDAO; +import org.palomafp.aadd.dta.dao.ITipoFormacionDAO; +import org.palomafp.aadd.dta.dao.impl.CicloFormativoDaoJDBC; +import org.palomafp.aadd.dta.dao.impl.FamiliaProfesionalDaoJDBC; +import org.palomafp.aadd.dta.dao.impl.TipoFormacionDaoJDBC; +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConexionBBDD; +import org.palomafp.aadd.dta.model.CicloFormativo; +import org.palomafp.aadd.dta.model.FamiliaProfesional; +import org.palomafp.aadd.dta.model.TipoFormacion; +import org.palomafp.aadd.dta.util.LectorCiclosXml; +import org.palomafp.aadd.dta.util.LectorFamiliasCsv; + +public class FormacionService { + + public int procesarFamilias() throws FormacionException { + List familias = LectorFamiliasCsv.leer(); + int procesadas = 0; + + try (Connection conexion = GestorConexionBBDD.getConexion()) { + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoJDBC(conexion); + + for (FamiliaProfesional familia : familias) { + if (familiaDao.obtenerPorCodigo(familia.getCodigo()) == null) { + familiaDao.insertar(familia); + } else { + familiaDao.actualizar(familia); + } + procesadas++; + } + } catch (SQLException e) { + throw new FormacionException("Error de conexión al procesar las familias profesionales", e); + } + + return procesadas; + } + + public int procesarCiclos() throws FormacionException { + List ciclos = LectorCiclosXml.leer(); + int insertados = 0; + + try (Connection conexion = GestorConexionBBDD.getConexion()) { + IFamiliaProfesionalDAO familiaDao = new FamiliaProfesionalDaoJDBC(conexion); + ITipoFormacionDAO tipoDao = new TipoFormacionDaoJDBC(conexion); + ICicloFormativoDAO cicloDao = new CicloFormativoDaoJDBC(conexion); + + for (CicloFormativo ciclo : ciclos) { + FamiliaProfesional familia = familiaDao.obtenerPorCodigo(ciclo.getFamiliaProfesional().getCodigo()); + TipoFormacion tipo = tipoDao.obtenerPorCodigo(ciclo.getTipoFormacion().getCodigo()); + + if (familia == null || tipo == null) { + continue; // ciclo no consistente: se descarta + } + + ciclo.setFamiliaProfesional(familia); + ciclo.setTipoFormacion(tipo); + cicloDao.insertar(ciclo); + insertados++; + } + } catch (SQLException e) { + throw new FormacionException("Error de conexión al procesar los ciclos formativos", e); + } + + return insertados; + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/util/LectorCiclosXml.java b/src/org/palomafp/aadd/dta/util/LectorCiclosXml.java new file mode 100644 index 0000000..2464aec --- /dev/null +++ b/src/org/palomafp/aadd/dta/util/LectorCiclosXml.java @@ -0,0 +1,71 @@ +package org.palomafp.aadd.dta.util; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConfiguracion; +import org.palomafp.aadd.dta.model.CicloFormativo; +import org.palomafp.aadd.dta.model.FamiliaProfesional; +import org.palomafp.aadd.dta.model.TipoFormacion; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.NodeList; +import org.xml.sax.SAXException; + +public class LectorCiclosXml { + + private LectorCiclosXml() { + } + + public static List leer() throws FormacionException { + Path ruta = GestorConfiguracion.getRutaFicheroCiclos(); + List ciclos = new ArrayList<>(); + + try { + DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); + Document documento = builder.parse(ruta.toFile()); + + NodeList nodos = documento.getElementsByTagName("ciclo"); + for (int i = 0; i < nodos.getLength(); i++) { + Element elemento = (Element) nodos.item(i); + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigo(getTexto(elemento, "codigo_familia")); + + TipoFormacion tipo = new TipoFormacion(); + tipo.setCodigo(getTexto(elemento, "codigo_tipoestudio")); + + CicloFormativo ciclo = new CicloFormativo(); + ciclo.setCodigo(elemento.getAttribute("cod_cf").trim()); + ciclo.setNombreCorto(getTexto(elemento, "nomb_corto")); + ciclo.setNombreLargo(getTexto(elemento, "nombrelargo")); + ciclo.setHorasDuracion(Integer.parseInt(getTexto(elemento, "num_horas_duracion"))); + ciclo.setFamiliaProfesional(familia); + ciclo.setTipoFormacion(tipo); + ciclos.add(ciclo); + } + } catch (ParserConfigurationException | SAXException | IOException e) { + throw new FormacionException("No se pudo leer el fichero XML " + ruta, e); + } catch (NumberFormatException e) { + throw new FormacionException("Valor no numérico en las horas de duración del XML " + ruta, e); + } + + return ciclos; + } + + private static String getTexto(Element padre, String etiqueta) throws FormacionException { + NodeList nodos = padre.getElementsByTagName(etiqueta); + if (nodos.getLength() == 0) { + throw new FormacionException("Falta la etiqueta <" + etiqueta + "> en el ciclo " + + padre.getAttribute("cod_cf")); + } + return nodos.item(0).getTextContent().trim(); + } +} \ No newline at end of file diff --git a/src/org/palomafp/aadd/dta/util/LectorFamiliasCsv.java b/src/org/palomafp/aadd/dta/util/LectorFamiliasCsv.java new file mode 100644 index 0000000..59282ea --- /dev/null +++ b/src/org/palomafp/aadd/dta/util/LectorFamiliasCsv.java @@ -0,0 +1,53 @@ +package org.palomafp.aadd.dta.util; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Pattern; + +import org.palomafp.aadd.dta.excepciones.FormacionException; +import org.palomafp.aadd.dta.gestores.GestorConfiguracion; +import org.palomafp.aadd.dta.model.FamiliaProfesional; + +public class LectorFamiliasCsv { + + // Columnas: id_registro|fecha_carga|cod_tipo_fam|nombre_tf + private static final int COL_CODIGO = 2; + private static final int COL_NOMBRE = 3; + + private LectorFamiliasCsv() { + } + + public static List leer() throws FormacionException { + Path ruta = GestorConfiguracion.getRutaFicheroFamilias(); + String separador = Pattern.quote(GestorConfiguracion.getSeparadorCsvFamilias()); + List familias = new ArrayList<>(); + + try { + List lineas = Files.readAllLines(ruta); + + for (int i = 1; i < lineas.size(); i++) { + String linea = lineas.get(i).trim(); + if (linea.isEmpty()) { + continue; + } + + String[] campos = linea.split(separador); + if (campos.length <= COL_NOMBRE) { + throw new FormacionException("Línea " + (i + 1) + " incorrecta en " + ruta + ": " + linea); + } + + FamiliaProfesional familia = new FamiliaProfesional(); + familia.setCodigo(campos[COL_CODIGO].trim()); + familia.setNombre(campos[COL_NOMBRE].trim()); + familias.add(familia); + } + } catch (IOException e) { + throw new FormacionException("No se pudo leer el fichero CSV " + ruta, e); + } + + return familias; + } +} \ No newline at end of file