From d91e4a8675e1337eb3fad2736c88e4500b433720 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Isidoro=20Nevares=20Mart=C3=ADn?= Date: Wed, 17 Dec 2025 19:18:51 +0100 Subject: [PATCH] commit inicial --- .classpath | 41 ++++ .gitignore | 3 + .project | 23 ++ .settings/org.eclipse.core.resources.prefs | 2 + .settings/org.eclipse.jdt.core.prefs | 13 + .settings/org.eclipse.m2e.core.prefs | 4 + pom.xml | 23 ++ .../java/org/lapaloma/aadd/cine/AppCine.java | 225 ++++++++++++++++++ .../org/lapaloma/aadd/cine/dao/IActorDAO.java | 9 + .../aadd/cine/dao/IContinenteDAO.java | 7 + .../lapaloma/aadd/cine/dao/IDirectorDAO.java | 9 + .../aadd/cine/dao/IOperacionesDAOEntidad.java | 21 ++ .../org/lapaloma/aadd/cine/dao/IPaisDAO.java | 8 + .../lapaloma/aadd/cine/dao/IPeliculaDAO.java | 11 + .../lapaloma/aadd/cine/dao/IRepartoDAO.java | 9 + .../aadd/cine/dao/hbnt/ActorDaoHibernate.java | 144 +++++++++++ .../cine/dao/hbnt/ContinenteDaoHibernate.java | 121 ++++++++++ .../cine/dao/hbnt/DirectorDaoHibernate.java | 144 +++++++++++ .../aadd/cine/dao/hbnt/PaisDaoHibernate.java | 132 ++++++++++ .../cine/dao/hbnt/PeliculaDaoHibernate.java | 168 +++++++++++++ .../cine/dao/hbnt/RepartoDaoHibernate.java | 82 +++++++ .../gestores/GestorSesionesHibernate.java | 46 ++++ .../aadd/cine/servicio/ActorService.java | 40 ++++ .../aadd/cine/servicio/ContinenteService.java | 66 +++++ .../aadd/cine/servicio/DirectorService.java | 46 ++++ .../aadd/cine/servicio/PaisService.java | 61 +++++ .../aadd/cine/servicio/PeliculaService.java | 40 ++++ .../java/org/lapaloma/aadd/cine/vo/Actor.java | 56 +++++ .../org/lapaloma/aadd/cine/vo/Continente.java | 39 +++ .../org/lapaloma/aadd/cine/vo/Director.java | 58 +++++ .../java/org/lapaloma/aadd/cine/vo/Pais.java | 60 +++++ .../org/lapaloma/aadd/cine/vo/Pelicula.java | 108 +++++++++ .../org/lapaloma/aadd/cine/vo/Reparto.java | 60 +++++ .../org/lapaloma/aadd/cine/vo/RepartoId.java | 60 +++++ src/main/resources/hibernate.cfg.xml | 30 +++ 35 files changed, 1969 insertions(+) create mode 100644 .classpath create mode 100644 .gitignore create mode 100644 .project create mode 100644 .settings/org.eclipse.core.resources.prefs create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.eclipse.m2e.core.prefs create mode 100644 pom.xml create mode 100644 src/main/java/org/lapaloma/aadd/cine/AppCine.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IActorDAO.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IContinenteDAO.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IDirectorDAO.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IOperacionesDAOEntidad.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IPaisDAO.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IPeliculaDAO.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/IRepartoDAO.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ActorDaoHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ContinenteDaoHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/hbnt/DirectorDaoHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PaisDaoHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PeliculaDaoHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/dao/hbnt/RepartoDaoHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/gestores/GestorSesionesHibernate.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/servicio/ActorService.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/servicio/ContinenteService.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/servicio/DirectorService.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/servicio/PaisService.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/servicio/PeliculaService.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/Actor.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/Continente.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/Director.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/Pais.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/Pelicula.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/Reparto.java create mode 100644 src/main/java/org/lapaloma/aadd/cine/vo/RepartoId.java create mode 100644 src/main/resources/hibernate.cfg.xml diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..d863192 --- /dev/null +++ b/.classpath @@ -0,0 +1,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..93e00af --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/bin/ +*.class +/target/ diff --git a/.project b/.project new file mode 100644 index 0000000..9ed3c4e --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ + + + aadd_act3_6 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..99f26c0 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..bfac099 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,13 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate +org.eclipse.jdt.core.compiler.codegen.targetPlatform=24 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=24 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=24 diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000..f897a7f --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..7ac1631 --- /dev/null +++ b/pom.xml @@ -0,0 +1,23 @@ + + 4.0.0 + org.lapaloma.aadd.cine + aadd_act3_2 + 0.0.1-SNAPSHOT + + + + + com.mysql + mysql-connector-j + 9.5.0 + + + + + org.hibernate.orm + hibernate-core + 7.1.11.Final + + + + \ No newline at end of file diff --git a/src/main/java/org/lapaloma/aadd/cine/AppCine.java b/src/main/java/org/lapaloma/aadd/cine/AppCine.java new file mode 100644 index 0000000..35ba7e0 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/AppCine.java @@ -0,0 +1,225 @@ +package org.lapaloma.aadd.cine; + +import java.time.LocalDate; +import java.util.List; + +import org.lapaloma.aadd.cine.dao.IOperacionesDAOEntidad; +import org.lapaloma.aadd.cine.dao.hbnt.ActorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.ContinenteDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.DirectorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PaisDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PeliculaDaoHibernate; +import org.lapaloma.aadd.cine.servicio.ActorService; +import org.lapaloma.aadd.cine.servicio.ContinenteService; +import org.lapaloma.aadd.cine.servicio.DirectorService; +import org.lapaloma.aadd.cine.servicio.PaisService; +import org.lapaloma.aadd.cine.servicio.PeliculaService; +import org.lapaloma.aadd.cine.vo.Actor; +import org.lapaloma.aadd.cine.vo.Continente; +import org.lapaloma.aadd.cine.vo.Director; +import org.lapaloma.aadd.cine.vo.Pais; +import org.lapaloma.aadd.cine.vo.Pelicula; + +/** + * + * AppMapaMundi: Clase que realiza .... + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 5 dic 2025 + * + * + */ + +public class AppCine { + + public static void main(String[] args) { + AppCine app = new AppCine(); + + app.probarOperacionesContinente(); + + app.probarOperacionesPais(); + + app.probarOperacionesDirector(); + + app.probarOperacionesPelicula(); + + app.probarOperacionesActor(); + } + + private void probarOperacionesContinente() { + IOperacionesDAOEntidad iDaoContinente = new ContinenteDaoHibernate(); + + // Lista de Continentes + List listaCcontinentes = iDaoContinente.obtenerListaTodasEntidades(); + System.out.println("obtenerListaTodasEntidades: " + listaCcontinentes); + + // Continente por ID + Continente continente = iDaoContinente.obtenerEntidadPorClave("02"); + System.out.println("obtenerEntidadPorID: " + continente); + + // Insertar continente + Continente continente2 = new Continente(); + continente2.setCodigo("06"); + continente2.setNombre("Antartida"); + iDaoContinente.crearEntidad(continente2); + System.out.println("crearEntidad: " + continente2); + + // Actualizar continente + continente.setNombre("América del norte y del sur"); + iDaoContinente.actualizarEntidad(continente); + System.out.println("actualizarEntidad: " + continente); + + // Borrar continente + String codigoContinente="02"; + ContinenteService servicioContinente = new ContinenteService(); + servicioContinente.borrarContinenteYReferencias(codigoContinente); + System.out.println("borrarEntidadPorClave: Continente - " + codigoContinente); + } + + private void probarOperacionesPais() { + IOperacionesDAOEntidad iDaoPais = new PaisDaoHibernate(); + + // Lista de Paises + List listaPaises = iDaoPais.obtenerListaTodasEntidades(); + System.out.println("obtenerListaTodasEntidades: " + listaPaises); + + // Pais por ID + Pais pais = iDaoPais.obtenerEntidadPorClave(152); + System.out.println("obtenerEntidadPorID: " + pais); + + // Insertar Pais + Pais pais2 = new Pais(); + Continente continente = new Continente(); + continente.setCodigo("04"); + pais2.setIdentificador(200); + pais2.setNombrePais("El país de la Maravillas"); + pais2.setCapital("Wonderland"); + pais2.setContinente(continente); + iDaoPais.crearEntidad(pais2); + System.out.println("crearEntidad: " + pais2); + + // Actualizar Pais + pais.setCapital("Magerit"); + iDaoPais.actualizarEntidad(pais); + System.out.println("actualizarEntidad: " + pais); + + // Borrar Pais + int idPais=71; + PaisService servicioPais = new PaisService(); + servicioPais.borrarPaisYReferencias(idPais); + System.out.println("borrarEntidadPorClave: Pais - " + idPais); + } + + private void probarOperacionesDirector() { + IOperacionesDAOEntidad iDaoDirector = new DirectorDaoHibernate(); + + // Lista de Directores + List listaDirectores = iDaoDirector.obtenerListaTodasEntidades(); + System.out.println("obtenerListaTodasEntidades: " + listaDirectores); + + // Director por ID + Director director = iDaoDirector.obtenerEntidadPorClave(1); + System.out.println("obtenerEntidadPorID: " + director); + + // Insertar Director + // Pais por ID + IOperacionesDAOEntidad iDaoPais = new PaisDaoHibernate(); + Pais pais = iDaoPais.obtenerEntidadPorClave(152); + + Director director2 = new Director(); + LocalDate fechaNacimiento = LocalDate.of(1973, 5, 9); + director2.setFechaNacimiento(fechaNacimiento); + director2.setNombre("Rodrigo Cortés"); + director2.setPais(pais); + iDaoDirector.crearEntidad(director2); + System.out.println("crearEntidad: " + director2); + + // Actualizar Director + director.setNombre("Woody Aaallen"); + iDaoDirector.actualizarEntidad(director); + System.out.println("actualizarEntidad: " + director); + + // Borrar Director + int idDirector =3; + DirectorService directorService = new DirectorService(); + directorService.borrarDirectorYReferencias(idDirector); + System.out.println("borrarEntidadPorClave: Director - " + idDirector); + } + + private void probarOperacionesPelicula() { + IOperacionesDAOEntidad iDaoPelicula = new PeliculaDaoHibernate(); + + // Lista de Peliculas + List listaPeliculas = iDaoPelicula.obtenerListaTodasEntidades(); + System.out.println("obtenerListaTodasEntidades: " + listaPeliculas); + + // Pelicula por ID + Pelicula pelicula = iDaoPelicula.obtenerEntidadPorClave(3); + System.out.println("obtenerEntidadPorID: " + pelicula); + + // Insertar Director + // Director por ID + IOperacionesDAOEntidad iDaoDirector = new DirectorDaoHibernate(); + Director director = iDaoDirector.obtenerEntidadPorClave(1); + // Pais por ID + IOperacionesDAOEntidad iDaoPais = new PaisDaoHibernate(); + Pais paisLocalizacion = iDaoPais.obtenerEntidadPorClave(152); + + Pelicula pelicula2 = new Pelicula(); + pelicula2.setTitulo("Midnight in Paris"); + pelicula2.setPaisLocalizacion(paisLocalizacion); + pelicula2.setDirector(director); + pelicula2.setAnyo(2011); + pelicula2.setColor(true); + pelicula2.setIdioma("Inglés"); + pelicula2.setObservacion("No relevantes"); + iDaoPelicula.crearEntidad(pelicula2); + System.out.println("crearEntidad: " + pelicula2); + + // Actualizar Película + pelicula2.setObservacion("Hay breves escenas ambientadas en Versalles"); + iDaoPelicula.actualizarEntidad(pelicula2); + System.out.println("actualizarEntidad: " + director); + + // Borrar Película + int idPelicula=3; + PeliculaService peliculaService = new PeliculaService(); + peliculaService.borrarPeliculaYReferencias(idPelicula); + System.out.println("borrarEntidadPorClave: Película - " + idPelicula); + } + + private void probarOperacionesActor() { + IOperacionesDAOEntidad iDaoActor = new ActorDaoHibernate(); + + // Lista de Actores + List listaActores = iDaoActor.obtenerListaTodasEntidades(); + System.out.println("obtenerListaTodasEntidades: " + listaActores); + + // Actor por ID + Actor actor = iDaoActor.obtenerEntidadPorClave(3); + System.out.println("obtenerEntidadPorID: " + actor); + + // Insertar Actor + // Pais por ID + IOperacionesDAOEntidad iDaoPais = new PaisDaoHibernate(); + Pais paisNacimiento = iDaoPais.obtenerEntidadPorClave(152); + + Actor actor2 = new Actor(); + actor2.setNombre("Ryan Reynold"); + actor2.setPais(paisNacimiento); + iDaoActor.crearEntidad(actor2); + System.out.println("crearEntidad: " + actor2); + + // Actualizar Actor + actor2.setNombre("Ryan Reynolds"); + iDaoActor.actualizarEntidad(actor2); + System.out.println("actualizarEntidad: " + actor2); + + // Borrar Actor + int idActor=4; + ActorService actorService = new ActorService(); + actorService.borrarActorYReferencias(idActor); + System.out.println("borrarEntidadPorClave: Actor - " + idActor); + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IActorDAO.java b/src/main/java/org/lapaloma/aadd/cine/dao/IActorDAO.java new file mode 100644 index 0000000..cd9f02a --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IActorDAO.java @@ -0,0 +1,9 @@ +package org.lapaloma.aadd.cine.dao; + +import org.lapaloma.aadd.cine.vo.Actor; + +public interface IActorDAO extends IOperacionesDAOEntidad { + void borrarActor(Integer identificador) throws Exception; + void borrarActoresReferenciasPais(Integer idPais) throws Exception; + void borrarActoresReferenciasContinente(String codigoContinente) throws Exception; +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IContinenteDAO.java b/src/main/java/org/lapaloma/aadd/cine/dao/IContinenteDAO.java new file mode 100644 index 0000000..edc9466 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IContinenteDAO.java @@ -0,0 +1,7 @@ +package org.lapaloma.aadd.cine.dao; + +import org.lapaloma.aadd.cine.vo.Continente; + +public interface IContinenteDAO extends IOperacionesDAOEntidad { + void borrarContinente(String codigo) throws Exception; +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IDirectorDAO.java b/src/main/java/org/lapaloma/aadd/cine/dao/IDirectorDAO.java new file mode 100644 index 0000000..a7f0efe --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IDirectorDAO.java @@ -0,0 +1,9 @@ +package org.lapaloma.aadd.cine.dao; + +import org.lapaloma.aadd.cine.vo.Director; + +public interface IDirectorDAO extends IOperacionesDAOEntidad { + void borrarDirector(Integer identificador) throws Exception; + void borrarDirectoresReferenciasPais(Integer idPais) throws Exception; + void borrarDirectoresReferenciasContinente(String codigoContinente) throws Exception; +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IOperacionesDAOEntidad.java b/src/main/java/org/lapaloma/aadd/cine/dao/IOperacionesDAOEntidad.java new file mode 100644 index 0000000..ef7c8d9 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IOperacionesDAOEntidad.java @@ -0,0 +1,21 @@ +package org.lapaloma.aadd.cine.dao; + +import java.util.List; + +/** + * + * IOperacionesBasicas: Clase que realiza .... + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 14 dic 2025 + * + * + */ + +public interface IOperacionesDAOEntidad { + T obtenerEntidadPorClave(ID clave); + List obtenerListaTodasEntidades(); + void crearEntidad(T entidad); + void actualizarEntidad(T entidad); + void borrarEntidadPorClave(ID clave); +} + diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IPaisDAO.java b/src/main/java/org/lapaloma/aadd/cine/dao/IPaisDAO.java new file mode 100644 index 0000000..a418cb0 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IPaisDAO.java @@ -0,0 +1,8 @@ +package org.lapaloma.aadd.cine.dao; + +import org.lapaloma.aadd.cine.vo.Pais; + +public interface IPaisDAO extends IOperacionesDAOEntidad { + void borrarPais(Integer identificador) throws Exception; + void borrarPaisesContinente(String codigoContinente) throws Exception; +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IPeliculaDAO.java b/src/main/java/org/lapaloma/aadd/cine/dao/IPeliculaDAO.java new file mode 100644 index 0000000..5fa0e12 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IPeliculaDAO.java @@ -0,0 +1,11 @@ +package org.lapaloma.aadd.cine.dao; + +import org.lapaloma.aadd.cine.vo.Pelicula; + +public interface IPeliculaDAO extends IOperacionesDAOEntidad { + void borrarPelicula(Integer identificador) throws Exception; + void borrarPeliculasDirector(Integer idDirector) throws Exception; + void borrarPeliculasReferenciasPais(Integer idPais) throws Exception; + void borrarPeliculasReferenciasContinente(String codigoContinente) throws Exception; + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/IRepartoDAO.java b/src/main/java/org/lapaloma/aadd/cine/dao/IRepartoDAO.java new file mode 100644 index 0000000..2c14249 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/IRepartoDAO.java @@ -0,0 +1,9 @@ +package org.lapaloma.aadd.cine.dao; + +public interface IRepartoDAO { + void borrarRepartoActor(Integer idActor) throws Exception; + void borrarRepartoPelicula(Integer idPelicula) throws Exception; + void borrarRepartoPeliculasDirector(Integer idDirector) throws Exception; + void borrarRepartoReferenciasPais(Integer idPais) throws Exception; + void borrarRepartoReferenciasContinente(String codigoContinente) throws Exception; +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ActorDaoHibernate.java b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ActorDaoHibernate.java new file mode 100644 index 0000000..e64879c --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ActorDaoHibernate.java @@ -0,0 +1,144 @@ +package org.lapaloma.aadd.cine.dao.hbnt; + +import java.util.List; + +import org.hibernate.HibernateException; +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.hibernate.query.MutationQuery; +import org.hibernate.query.SelectionQuery; +import org.lapaloma.aadd.cine.dao.IActorDAO; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; +import org.lapaloma.aadd.cine.vo.Actor; + +/** + * + * ActorDaoHibernate: Clase que implementa las operaciones del interfaz + * IOperacionesDAOEntidad de Actor para Hibernate. + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 14 dic 2025 + * + * + */ + +public class ActorDaoHibernate implements IActorDAO { + + @Override + public Actor obtenerEntidadPorClave(Integer clave) { + Actor actor = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + actor = sesion.find(Actor.class, clave); + } catch (Exception e) { + e.printStackTrace(); + } + return actor; + } + + @Override + public List obtenerListaTodasEntidades() { + List listaActores = null; + String sentenciaHQL = "SELECT a FROM Actor a"; + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + + SelectionQuery sentenciaConsulta = sesion.createSelectionQuery(sentenciaHQL, Actor.class); + listaActores = sentenciaConsulta.getResultList(); + + } catch (Exception e) { + e.printStackTrace(); + } + return listaActores; + } + + @Override + public void crearEntidad(Actor entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Connection, Statement + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + sesion.persist(entidad); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void actualizarEntidad(Actor entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + if (!sesion.contains(entidad)) + sesion.merge(entidad); + + transaccion.commit(); + } catch (Exception e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarEntidadPorClave(Integer clave) { + Transaction transaccion = null; + + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + // Borrado de Actor + Actor actor = sesion.find(Actor.class, clave); + sesion.remove(actor); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarActor(Integer identificador) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de Actor + String sentenciaBorradoActorHQL = "DELETE FROM Actor a WHERE a.identificador = :identificador"; + MutationQuery senteciaBorradoActor = sesion.createMutationQuery(sentenciaBorradoActorHQL); + senteciaBorradoActor.setParameter("identificador", identificador); + senteciaBorradoActor.executeUpdate(); + } + + @Override + public void borrarActoresReferenciasPais(Integer idPais) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de los actores cuyo país de nacimiento es en el país a borrar + String sentenciaBorradoActorPaisHQL = "DELETE FROM Actor a WHERE a.pais.identificador = :identificador"; + MutationQuery senteciaBorradoActoresPais = sesion.createMutationQuery(sentenciaBorradoActorPaisHQL); + senteciaBorradoActoresPais.setParameter("identificador", idPais); + senteciaBorradoActoresPais.executeUpdate(); + + } + + @Override + public void borrarActoresReferenciasContinente(String codigoContinente) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de los actores cuyo país de nacimiento es en un país del continente a borrar + String sentenciaBorradoActorPaisHQL = "DELETE FROM Actor a WHERE a.pais.continente.codigo = :codigo"; + MutationQuery senteciaBorradoActoresPais = sesion.createMutationQuery(sentenciaBorradoActorPaisHQL); + senteciaBorradoActoresPais.setParameter("codigo", codigoContinente); + senteciaBorradoActoresPais.executeUpdate(); + + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ContinenteDaoHibernate.java b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ContinenteDaoHibernate.java new file mode 100644 index 0000000..dbf4f61 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ContinenteDaoHibernate.java @@ -0,0 +1,121 @@ +package org.lapaloma.aadd.cine.dao.hbnt; + +import java.util.List; + +import org.hibernate.HibernateException; +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.hibernate.query.MutationQuery; +import org.hibernate.query.SelectionQuery; +import org.lapaloma.aadd.cine.dao.IContinenteDAO; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; +import org.lapaloma.aadd.cine.vo.Continente; + +/** + * + * ContinenteDaoHibernate: Clase que implementa las operaciones del interfaz IOperacionesDAOEntidad + * de Continente para Hibernate. + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 14 dic 2025 + * + * + */ + +public class ContinenteDaoHibernate implements IContinenteDAO { + + @Override + public Continente obtenerEntidadPorClave(String clave) { + Continente continente = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + continente = sesion.find(Continente.class, clave); + } catch (Exception e) { + e.printStackTrace(); + } + return continente; + } + + @Override + public List obtenerListaTodasEntidades() { + List listaContinentes = null; + String sentenciaHQL = "SELECT c FROM Continente c"; + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + + SelectionQuery sentenciaConsulta = sesion.createSelectionQuery(sentenciaHQL, Continente.class); + listaContinentes = sentenciaConsulta.getResultList(); + + } catch (Exception e) { + e.printStackTrace(); + } + return listaContinentes; + } + + @Override + public void crearEntidad(Continente entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Connection, Statement + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + sesion.persist(entidad); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void actualizarEntidad(Continente entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + if (!sesion.contains(entidad)) + sesion.merge(entidad); + + transaccion.commit(); + } catch (Exception e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarEntidadPorClave(String clave) { + Transaction transaccion = null; + + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + Continente continente = sesion.find(Continente.class, clave); + sesion.remove(continente); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + + } + } + + + @Override + public void borrarContinente(String codigo) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + String sentenciaBorradoContinenteHQL = "DELETE FROM Continente WHERE codigo= :codigo"; + MutationQuery sentenciaBorradoContinente = sesion.createMutationQuery(sentenciaBorradoContinenteHQL); + sentenciaBorradoContinente.setParameter("codigo", codigo); + sentenciaBorradoContinente.executeUpdate(); + + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/DirectorDaoHibernate.java b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/DirectorDaoHibernate.java new file mode 100644 index 0000000..9ce5c21 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/DirectorDaoHibernate.java @@ -0,0 +1,144 @@ +package org.lapaloma.aadd.cine.dao.hbnt; + +import java.util.List; + +import org.hibernate.HibernateException; +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.hibernate.query.MutationQuery; +import org.hibernate.query.SelectionQuery; +import org.lapaloma.aadd.cine.dao.IDirectorDAO; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; +import org.lapaloma.aadd.cine.vo.Director; + +/** + * + * DirectorDAO: Clase que implementa las operaciones del interfaz + * IOperacionesDAOEntidad de Director para Hibernate. + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 14 dic 2025 + * + * + */ + +public class DirectorDaoHibernate implements IDirectorDAO { + + @Override + public Director obtenerEntidadPorClave(Integer clave) { + Director director = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + director = sesion.find(Director.class, clave); + } catch (Exception e) { + e.printStackTrace(); + } + return director; + } + + @Override + public List obtenerListaTodasEntidades() { + List listaDirectores = null; + String sentenciaHQL = "SELECT d FROM Director d"; + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + + SelectionQuery sentenciaConsulta = sesion.createSelectionQuery(sentenciaHQL, Director.class); + listaDirectores = sentenciaConsulta.getResultList(); + + } catch (Exception e) { + e.printStackTrace(); + } + return listaDirectores; + } + + @Override + public void crearEntidad(Director entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Connection, Statement + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + sesion.persist(entidad); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void actualizarEntidad(Director entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + if (!sesion.contains(entidad)) + sesion.merge(entidad); + + transaccion.commit(); + } catch (Exception e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarEntidadPorClave(Integer clave) { + Transaction transaccion = null; + + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + Director director = sesion.find(Director.class, clave); + sesion.remove(director); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarDirector(Integer identificador) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + String sentenciaBorradoDirectoresHQL = "DELETE FROM Director d WHERE d.identificador = :identificador"; + MutationQuery senteciaBorradoDirectores = sesion.createMutationQuery(sentenciaBorradoDirectoresHQL); + senteciaBorradoDirectores.setParameter("identificador", identificador); + senteciaBorradoDirectores.executeUpdate(); + } + + @Override + public void borrarDirectoresReferenciasPais(Integer idPais) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de los directores cuyo país de nacimiento es en un país del + // continente a borrar + String sentenciaBorradoDirectoresPaisHQL = "DELETE FROM Director d WHERE d.pais.identificador = :identificador"; + MutationQuery senteciaBorradoDirectoresPais = sesion.createMutationQuery(sentenciaBorradoDirectoresPaisHQL); + senteciaBorradoDirectoresPais.setParameter("identificador", idPais); + senteciaBorradoDirectoresPais.executeUpdate(); + + } + + @Override + public void borrarDirectoresReferenciasContinente(String codigoContinente) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de los directores cuyo país de nacimiento es en un país del + // continente a borrar + String sentenciaBorradoDirectoresPaisHQL = "DELETE FROM Director d WHERE d.pais.continente.codigo = :codigo"; + MutationQuery senteciaBorradoDirectoresPais = sesion.createMutationQuery(sentenciaBorradoDirectoresPaisHQL); + senteciaBorradoDirectoresPais.setParameter("codigo", codigoContinente); + senteciaBorradoDirectoresPais.executeUpdate(); + + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PaisDaoHibernate.java b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PaisDaoHibernate.java new file mode 100644 index 0000000..08fb5bf --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PaisDaoHibernate.java @@ -0,0 +1,132 @@ +package org.lapaloma.aadd.cine.dao.hbnt; + +import java.util.List; + +import org.hibernate.HibernateException; +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.hibernate.query.MutationQuery; +import org.hibernate.query.SelectionQuery; +import org.lapaloma.aadd.cine.dao.IPaisDAO; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; +import org.lapaloma.aadd.cine.vo.Pais; + +/** + * + * PaisDaoHibernate: Clase que implementa las operaciones del interfaz + * IOperacionesDAOEntidad de Pais para Hibernate. + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 14 dic 2025 + * + * + */ + +public class PaisDaoHibernate implements IPaisDAO { + + @Override + public Pais obtenerEntidadPorClave(Integer clave) { + Pais pais = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + pais = sesion.find(Pais.class, clave); + } catch (Exception e) { + e.printStackTrace(); + } + return pais; + } + + @Override + public List obtenerListaTodasEntidades() { + List listaPaises = null; + String sentenciaHQL = "SELECT p FROM Pais p"; + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + + SelectionQuery sentenciaConsulta = sesion.createSelectionQuery(sentenciaHQL, Pais.class); + listaPaises = sentenciaConsulta.getResultList(); + + } catch (Exception e) { + e.printStackTrace(); + } + return listaPaises; + + } + + @Override + public void crearEntidad(Pais entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Connection, Statement + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + sesion.persist(entidad); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void actualizarEntidad(Pais entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + if (!sesion.contains(entidad)) + sesion.merge(entidad); + + transaccion.commit(); + } catch (Exception e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarEntidadPorClave(Integer clave) { + Transaction transaccion = null; + + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + Pais pais = sesion.find(Pais.class, clave); + sesion.remove(pais); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarPais(Integer identificador) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de los países del continente a borrar + String sentenciaBorradoPaiseesHQL = "DELETE FROM Pais p WHERE p.identificador = :identificador"; + MutationQuery senteciaBorradoPaises = sesion.createMutationQuery(sentenciaBorradoPaiseesHQL); + senteciaBorradoPaises.setParameter("identificador", identificador); + senteciaBorradoPaises.executeUpdate(); + + } + + @Override + public void borrarPaisesContinente(String codigoContinente) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de los países del continente a borrar + String sentenciaBorradoPaiseesHQL = "DELETE FROM Pais p WHERE p.continente.codigo = :codigo"; + MutationQuery senteciaBorradoPaises = sesion.createMutationQuery(sentenciaBorradoPaiseesHQL); + senteciaBorradoPaises.setParameter("codigo", codigoContinente); + senteciaBorradoPaises.executeUpdate(); + + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PeliculaDaoHibernate.java b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PeliculaDaoHibernate.java new file mode 100644 index 0000000..cc638d3 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PeliculaDaoHibernate.java @@ -0,0 +1,168 @@ +package org.lapaloma.aadd.cine.dao.hbnt; + +import java.util.List; + +import org.hibernate.HibernateException; +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.hibernate.query.MutationQuery; +import org.hibernate.query.SelectionQuery; +import org.lapaloma.aadd.cine.dao.IPeliculaDAO; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; +import org.lapaloma.aadd.cine.vo.Actor; +import org.lapaloma.aadd.cine.vo.Pelicula; + +/** + * + * PeliculaDAO: Clase que implementa las operaciones del interfaz + * IOperacionesDAOEntidad de Pelicula para Hibernate. + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 14 dic 2025 + * + * + */ + +public class PeliculaDaoHibernate implements IPeliculaDAO { + + @Override + public Pelicula obtenerEntidadPorClave(Integer clave) { + Pelicula pelicula = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + pelicula = sesion.find(Pelicula.class, clave); + } catch (Exception e) { + e.printStackTrace(); + } + return pelicula; + } + + @Override + public List obtenerListaTodasEntidades() { + List listaPeliculas = null; + String sentenciaHQL = "SELECT d FROM Pelicula d"; + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + + SelectionQuery sentenciaConsulta = sesion.createSelectionQuery(sentenciaHQL, Pelicula.class); + listaPeliculas = sentenciaConsulta.getResultList(); + + } catch (Exception e) { + e.printStackTrace(); + } + return listaPeliculas; + } + + @Override + public void crearEntidad(Pelicula entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Connection, Statement + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + sesion.persist(entidad); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void actualizarEntidad(Pelicula entidad) { + Transaction transaccion = null; + + // try con recursos "cerrables": Session + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + if (!sesion.contains(entidad)) + sesion.merge(entidad); + + transaccion.commit(); + } catch (Exception e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarEntidadPorClave(Integer clave) { + Transaction transaccion = null; + + try (Session sesion = GestorSesionesHibernate.getSession();) { + transaccion = sesion.beginTransaction(); + + // Borrado de Actor + Actor actor = sesion.find(Actor.class, clave); + sesion.remove(actor); + + transaccion.commit(); + } catch (HibernateException e) { + transaccion.rollback(); + e.printStackTrace(); + } + } + + @Override + public void borrarPelicula(Integer identificador) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de Películas de una Película + String sentenciaBorradoPeliculasHQL = "DELETE FROM Pelicula p WHERE identificador = :identificador"; + MutationQuery senteciaBorradoPeliculas = sesion.createMutationQuery(sentenciaBorradoPeliculasHQL); + senteciaBorradoPeliculas.setParameter("identificador", identificador); + senteciaBorradoPeliculas.executeUpdate(); + } + + @Override + public void borrarPeliculasDirector(Integer idDirector) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de Películas de un director + String sentenciaBorradoPeliculasHQL = "DELETE FROM Pelicula p WHERE p.director.identificador = :identificador"; + MutationQuery senteciaBorradoPeliculas = sesion.createMutationQuery(sentenciaBorradoPeliculasHQL); + senteciaBorradoPeliculas.setParameter("identificador", idDirector); + senteciaBorradoPeliculas.executeUpdate(); + } + + @Override + public void borrarPeliculasReferenciasPais(Integer idPais) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de las películas cuyo país de Loclaización nacimiento es en un país + // del continente + // a borrar + String sentenciaBorradoPeliculasPaisHQL = """ + DELETE FROM Pelicula p + WHERE (p.paisLocalizacion.identificador = :identificador + OR p.director.pais.identificador = :identificador) + """; + MutationQuery senteciaBorradoRepartosPeliculasPais = sesion + .createMutationQuery(sentenciaBorradoPeliculasPaisHQL); + senteciaBorradoRepartosPeliculasPais.setParameter("identificador", idPais); + senteciaBorradoRepartosPeliculasPais.executeUpdate(); + + } + + @Override + public void borrarPeliculasReferenciasContinente(String codigoContinente) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de las Películas cuyo país de nacimiento es en un país del continente + // a borrar + String sentenciaBorradoPeliculasPaisHQL = """ + DELETE FROM Pelicula p WHERE (p.paisLocalizacion.continente.codigo = :codigo + OR p.director.pais.continente.codigo = :codigo) + """; + MutationQuery senteciaBorradoRepartosPeliculasPais = sesion + .createMutationQuery(sentenciaBorradoPeliculasPaisHQL); + senteciaBorradoRepartosPeliculasPais.setParameter("codigo", codigoContinente); + senteciaBorradoRepartosPeliculasPais.executeUpdate(); + + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/RepartoDaoHibernate.java b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/RepartoDaoHibernate.java new file mode 100644 index 0000000..1b7045b --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/dao/hbnt/RepartoDaoHibernate.java @@ -0,0 +1,82 @@ +package org.lapaloma.aadd.cine.dao.hbnt; + +import org.hibernate.Session; +import org.hibernate.query.MutationQuery; +import org.lapaloma.aadd.cine.dao.IRepartoDAO; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; + +public class RepartoDaoHibernate implements IRepartoDAO { + + @Override + public void borrarRepartoActor(Integer idActor) throws Exception{ + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de Repartos de un Actor + String sentenciaBorradoRepartosHQL = "DELETE FROM Reparto r WHERE r.actor.identificador = :identificador"; + MutationQuery senteciaBorradoRepartos = sesion.createMutationQuery(sentenciaBorradoRepartosHQL); + senteciaBorradoRepartos.setParameter("identificador", idActor); + senteciaBorradoRepartos.executeUpdate(); + } + + @Override + public void borrarRepartoPelicula(Integer idPelicula) throws Exception{ + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de Repartos de una Película + String sentenciaBorradoRepartosHQL = "DELETE FROM Reparto r WHERE r.pelicula.identificador = :identificador"; + MutationQuery senteciaBorradoRepartos = sesion.createMutationQuery(sentenciaBorradoRepartosHQL); + senteciaBorradoRepartos.setParameter("identificador", idPelicula); + senteciaBorradoRepartos.executeUpdate(); + } + + @Override + public void borrarRepartoPeliculasDirector(Integer idDirector) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + //Borrado de Repartos de películas un director + String sentenciaBorradoRepartosHQL = "DELETE FROM Reparto r WHERE r.pelicula.director.identificador = :identificador"; + MutationQuery senteciaBorradoRepartos = sesion.createMutationQuery(sentenciaBorradoRepartosHQL); + senteciaBorradoRepartos.setParameter("identificador", idDirector); + senteciaBorradoRepartos.executeUpdate(); + + } + + @Override + public void borrarRepartoReferenciasPais(Integer idPais) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de repartos en los que la localización de la película es en el país a borrar + // Borrado de repartos en los que el país de nacimiento del actor es en el país a borrar + // Borrado de repartos en los que el país de nacimiento del director de la película es en el país a borrar + String sentenciaBorradoRepartosPaisHQL = """ + DELETE FROM Reparto r + WHERE (r.pelicula.paisLocalizacion.identificador = :identificador + OR r.actor.pais.identificador = :identificador + OR r.pelicula.director.pais.identificador = :identificador) + """; + MutationQuery senteciaBorradoRepartosPais = sesion.createMutationQuery(sentenciaBorradoRepartosPaisHQL); + senteciaBorradoRepartosPais.setParameter("identificador", idPais); + senteciaBorradoRepartosPais.executeUpdate(); + + } + + @Override + public void borrarRepartoReferenciasContinente(String codigoContinente) throws Exception { + Session sesion = GestorSesionesHibernate.getCurrentSession(); + + // Borrado de repartos en los que la localización de la película es en un país del continente a borrar + // Borrado de repartos en los que el país de nacimiento del actor es en un país del continente a borrar + // Borrado de repartos en los que el país de nacimiento del director de la película es en un país del continente a borrar + String sentenciaBorradoRepartosPaisHQL = """ + DELETE FROM Reparto r + WHERE (r.pelicula.paisLocalizacion.continente.codigo = :codigo + OR r.actor.pais.continente.codigo = :codigo + OR r.pelicula.director.pais.continente.codigo = :codigo) + """; + MutationQuery senteciaBorradoRepartosPais = sesion.createMutationQuery(sentenciaBorradoRepartosPaisHQL); + senteciaBorradoRepartosPais.setParameter("codigo", codigoContinente); + senteciaBorradoRepartosPais.executeUpdate(); + + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/gestores/GestorSesionesHibernate.java b/src/main/java/org/lapaloma/aadd/cine/gestores/GestorSesionesHibernate.java new file mode 100644 index 0000000..23b8a9b --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/gestores/GestorSesionesHibernate.java @@ -0,0 +1,46 @@ +package org.lapaloma.aadd.cine.gestores; + +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.cfg.Configuration; + +/** + * + * GestorSesionesHibernate: Clase que realiza .... + * + * @author Isidoro Nevares Martín - IES Virgen de la Paloma + * @date 4 dic 2025 + * + * + */ + +public class GestorSesionesHibernate { + private static SessionFactory sessionFactory = null; + + private GestorSesionesHibernate() {// Constructor privado para evitar instanciación + } + + // Carga la configuración desde hibernate.cfg.xml + static { + try { + sessionFactory = new Configuration().configure().buildSessionFactory(); + } catch (Throwable ex) { + System.err.println("Error en SessionFactory: " + ex); + throw new ExceptionInInitializerError(ex); + } + } + + public static Session getSession() { + return sessionFactory.openSession(); + } + + public static Session getCurrentSession() { + return sessionFactory.getCurrentSession(); + } + + public static void cerrarFactoria() { + if (sessionFactory != null) { + sessionFactory.close(); + } + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/servicio/ActorService.java b/src/main/java/org/lapaloma/aadd/cine/servicio/ActorService.java new file mode 100644 index 0000000..fcefbba --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/servicio/ActorService.java @@ -0,0 +1,40 @@ +package org.lapaloma.aadd.cine.servicio; + +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.lapaloma.aadd.cine.dao.IActorDAO; +import org.lapaloma.aadd.cine.dao.IRepartoDAO; +import org.lapaloma.aadd.cine.dao.hbnt.ActorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.RepartoDaoHibernate; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; + +public class ActorService { + public void borrarActorYReferencias(Integer idActor) { + Transaction transaccion = null; + Session sesion = null; + + try { + sesion = GestorSesionesHibernate.getCurrentSession(); + transaccion = sesion.beginTransaction(); + + // Borrado de Repartos de un Actor + IRepartoDAO iRepartoDAO = new RepartoDaoHibernate(); + iRepartoDAO.borrarRepartoActor(idActor); + + // Borrado de Actor + IActorDAO iActorDAO = new ActorDaoHibernate(); + iActorDAO.borrarActor(idActor); + + transaccion.commit(); + } catch (Exception e) { + if (transaccion != null && transaccion.isActive()) { + transaccion.rollback(); + } + e.printStackTrace(); + } finally { + if (sesion != null) { + sesion.close(); + } + } + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/servicio/ContinenteService.java b/src/main/java/org/lapaloma/aadd/cine/servicio/ContinenteService.java new file mode 100644 index 0000000..5837bda --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/servicio/ContinenteService.java @@ -0,0 +1,66 @@ +package org.lapaloma.aadd.cine.servicio; + +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.lapaloma.aadd.cine.dao.IActorDAO; +import org.lapaloma.aadd.cine.dao.IContinenteDAO; +import org.lapaloma.aadd.cine.dao.IDirectorDAO; +import org.lapaloma.aadd.cine.dao.IPaisDAO; +import org.lapaloma.aadd.cine.dao.IPeliculaDAO; +import org.lapaloma.aadd.cine.dao.IRepartoDAO; +import org.lapaloma.aadd.cine.dao.hbnt.ActorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.ContinenteDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.DirectorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PaisDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PeliculaDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.RepartoDaoHibernate; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; + +public class ContinenteService { + public void borrarContinenteYReferencias(String codigoContinente) { + Transaction transaccion = null; + Session sesion = null; + try { + sesion = GestorSesionesHibernate.getCurrentSession(); + transaccion = sesion.beginTransaction(); + + // Borrado de Repartos en que haya relaciones con un Continente (Actor, Película + // o Director de la película) + IRepartoDAO iRepartoDAO = new RepartoDaoHibernate(); + iRepartoDAO.borrarRepartoReferenciasContinente(codigoContinente); + + // Borrado de Actores que nacieron en un país del continente a borrar + IActorDAO iActorDAO = new ActorDaoHibernate(); + iActorDAO.borrarActoresReferenciasContinente(codigoContinente); + + // Borrado de Películas en que haya relaciones con un país (Localización + // Película o Director de la película) + IPeliculaDAO iPeliculaDAO = new PeliculaDaoHibernate(); + iPeliculaDAO.borrarPeliculasReferenciasContinente(codigoContinente); + + // Borrado de los directores cuyo país de nacimiento es en un país del + // continente a borrar + IDirectorDAO iDirectorDAO = new DirectorDaoHibernate(); + iDirectorDAO.borrarDirectoresReferenciasContinente(codigoContinente); + + // Borrado de los paises del continente + IPaisDAO iPaisDAO = new PaisDaoHibernate(); + iPaisDAO.borrarPaisesContinente(codigoContinente); + + // Borrado del continente + IContinenteDAO iContinenteDAO = new ContinenteDaoHibernate(); + iContinenteDAO.borrarContinente(codigoContinente); + + transaccion.commit(); + } catch (Exception e) { + if (transaccion != null && transaccion.isActive()) { + transaccion.rollback(); + } + e.printStackTrace(); + } finally { + if (sesion != null) { + sesion.close(); + } + } + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/servicio/DirectorService.java b/src/main/java/org/lapaloma/aadd/cine/servicio/DirectorService.java new file mode 100644 index 0000000..4f8ecfd --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/servicio/DirectorService.java @@ -0,0 +1,46 @@ +package org.lapaloma.aadd.cine.servicio; + +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.lapaloma.aadd.cine.dao.IDirectorDAO; +import org.lapaloma.aadd.cine.dao.IPeliculaDAO; +import org.lapaloma.aadd.cine.dao.IRepartoDAO; +import org.lapaloma.aadd.cine.dao.hbnt.DirectorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PeliculaDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.RepartoDaoHibernate; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; + +public class DirectorService { + public void borrarDirectorYReferencias(Integer idDirector) { + Transaction transaccion = null; + Session sesion = null; + + try { + sesion = GestorSesionesHibernate.getCurrentSession(); + transaccion = sesion.beginTransaction(); + + // Borrado de Repartos de un Actor + IRepartoDAO iRepartoDAO = new RepartoDaoHibernate(); + iRepartoDAO.borrarRepartoPeliculasDirector(idDirector); + + // Borrado de Películas de un Director + IPeliculaDAO iPeliculaDAO = new PeliculaDaoHibernate(); + iPeliculaDAO.borrarPeliculasDirector(idDirector); + + // Borrado del director + IDirectorDAO iDirectorDAO = new DirectorDaoHibernate(); + iDirectorDAO.borrarDirector(idDirector); + + transaccion.commit(); + } catch (Exception e) { + if (transaccion != null && transaccion.isActive()) { + transaccion.rollback(); + } + e.printStackTrace(); + } finally { + if (sesion != null) { + sesion.close(); + } + } + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/servicio/PaisService.java b/src/main/java/org/lapaloma/aadd/cine/servicio/PaisService.java new file mode 100644 index 0000000..4bfd13d --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/servicio/PaisService.java @@ -0,0 +1,61 @@ +package org.lapaloma.aadd.cine.servicio; + +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.lapaloma.aadd.cine.dao.IActorDAO; +import org.lapaloma.aadd.cine.dao.IDirectorDAO; +import org.lapaloma.aadd.cine.dao.IPaisDAO; +import org.lapaloma.aadd.cine.dao.IPeliculaDAO; +import org.lapaloma.aadd.cine.dao.IRepartoDAO; +import org.lapaloma.aadd.cine.dao.hbnt.ActorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.DirectorDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PaisDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.PeliculaDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.RepartoDaoHibernate; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; + +public class PaisService { + public void borrarPaisYReferencias(Integer idPais) { + Transaction transaccion = null; + Session sesion = null; + + try { + sesion = GestorSesionesHibernate.getCurrentSession(); + transaccion = sesion.beginTransaction(); + + // Borrado de Repartos en que haya relaciones con un país (Actor, Película o + // Director de la película) + IRepartoDAO iRepartoDAO = new RepartoDaoHibernate(); + iRepartoDAO.borrarRepartoReferenciasPais(idPais); + + // Borrado de Actores que nacieron en un país + IActorDAO iActorDAO = new ActorDaoHibernate(); + iActorDAO.borrarActoresReferenciasPais(idPais); + + // Borrado de Películas en que haya relaciones con un país (Localización + // Película o Director de la película) + IPeliculaDAO iPeliculaDAO = new PeliculaDaoHibernate(); + iPeliculaDAO.borrarPeliculasReferenciasPais(idPais); + + // Borrado de los directores cuyo país de nacimiento es en un país del + // continente a borrar + IDirectorDAO iDirectorDAO = new DirectorDaoHibernate(); + iDirectorDAO.borrarDirectoresReferenciasPais(idPais); + + // Borrado de los paises + IPaisDAO iPaisDAO = new PaisDaoHibernate(); + iPaisDAO.borrarPais(idPais); + + transaccion.commit(); + } catch (Exception e) { + if (transaccion != null && transaccion.isActive()) { + transaccion.rollback(); + } + e.printStackTrace(); + } finally { + if (sesion != null) { + sesion.close(); + } + } + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/servicio/PeliculaService.java b/src/main/java/org/lapaloma/aadd/cine/servicio/PeliculaService.java new file mode 100644 index 0000000..972c865 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/servicio/PeliculaService.java @@ -0,0 +1,40 @@ +package org.lapaloma.aadd.cine.servicio; + +import org.hibernate.Session; +import org.hibernate.Transaction; +import org.lapaloma.aadd.cine.dao.IPeliculaDAO; +import org.lapaloma.aadd.cine.dao.IRepartoDAO; +import org.lapaloma.aadd.cine.dao.hbnt.PeliculaDaoHibernate; +import org.lapaloma.aadd.cine.dao.hbnt.RepartoDaoHibernate; +import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate; + +public class PeliculaService { + public void borrarPeliculaYReferencias(Integer idPelicula) { + Transaction transaccion = null; + Session sesion = null; + + try { + sesion = GestorSesionesHibernate.getCurrentSession(); + transaccion = sesion.beginTransaction(); + + // Borrado de Repartos de una Película + IRepartoDAO iRepartoDAO = new RepartoDaoHibernate(); + iRepartoDAO.borrarRepartoPelicula(idPelicula); + + // Borrado de Actor + IPeliculaDAO iPeliculaDAO = new PeliculaDaoHibernate(); + iPeliculaDAO.borrarPelicula(idPelicula); + + transaccion.commit(); + } catch (Exception e) { + if (transaccion != null && transaccion.isActive()) { + transaccion.rollback(); + } + e.printStackTrace(); + } finally { + if (sesion != null) { + sesion.close(); + } + } + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/Actor.java b/src/main/java/org/lapaloma/aadd/cine/vo/Actor.java new file mode 100644 index 0000000..a1ccac1 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/Actor.java @@ -0,0 +1,56 @@ +package org.lapaloma.aadd.cine.vo; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; + +@Entity +@Table(name = "actor") +public class Actor { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="identificador") + private Integer identificador; + + @Column(name="nombre", length = 50) + private String nombre; + + @ManyToOne(fetch = FetchType.EAGER) + @JoinColumn(name = "id_pais") + private Pais pais; + + public Integer getIdentificador() { + return identificador; + } + + public void setIdentificador(Integer identificador) { + this.identificador = identificador; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + public Pais getPais() { + return pais; + } + + public void setPais(Pais pais) { + this.pais = pais; + } + + @Override + public String toString() { + return "Actor [identificador=" + identificador + ", nombre=" + nombre + ", pais=" + pais + "]"; + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/Continente.java b/src/main/java/org/lapaloma/aadd/cine/vo/Continente.java new file mode 100644 index 0000000..ef06615 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/Continente.java @@ -0,0 +1,39 @@ +package org.lapaloma.aadd.cine.vo; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.Table; + +@Entity +@Table(name = "continente") +public class Continente { + @Id + @Column(name = "codigo", columnDefinition = "char(2)") + private String codigo; + + @Column(name = "nombre_continente ", length = 50) + private String nombre; + + public String getCodigo() { + return codigo; + } + + public void setCodigo(String codigo) { + this.codigo = codigo; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public String toString() { + return "Continente [codigo=" + codigo + ", nombre=" + nombre + "]\n"; + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/Director.java b/src/main/java/org/lapaloma/aadd/cine/vo/Director.java new file mode 100644 index 0000000..f493e14 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/Director.java @@ -0,0 +1,58 @@ +package org.lapaloma.aadd.cine.vo; + +import jakarta.persistence.*; +import java.time.LocalDate; + +@Entity +@Table(name = "director") +public class Director { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="identificador") + private Integer identificador; + + @Column(name="nombre", length = 50) + private String nombre; + + @ManyToOne(fetch = FetchType.EAGER) + @JoinColumn(name = "id_pais") + private Pais pais; + + @Column(name="fecha_nacimiento") + private LocalDate fechaNacimiento; + + public Integer getIdentificador() { + return identificador; + } + + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + public Pais getPais() { + return pais; + } + + public void setPais(Pais pais) { + this.pais = pais; + } + + public LocalDate getFechaNacimiento() { + return fechaNacimiento; + } + + public void setFechaNacimiento(LocalDate fechaNacimiento) { + this.fechaNacimiento = fechaNacimiento; + } + + @Override + public String toString() { + return "Director [identificador=" + identificador + ", nombre=" + nombre + ", pais=" + pais + + ", fechaNacimiento=" + fechaNacimiento + "]\n"; + } +} diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/Pais.java b/src/main/java/org/lapaloma/aadd/cine/vo/Pais.java new file mode 100644 index 0000000..a6cadba --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/Pais.java @@ -0,0 +1,60 @@ +package org.lapaloma.aadd.cine.vo; + +import jakarta.persistence.*; + +@Entity +@Table(name = "pais") +public class Pais { + @Id + @Column(name = "identificador") + private Integer identificador; + + @Column(name = "nombre_pais" , length = 50) + private String nombrePais; + + @Column(name = "capital" , length = 20) + private String capital; + + @ManyToOne(fetch = FetchType.EAGER) + @JoinColumn(name = "cod_continente") + private Continente continente; + + public Integer getIdentificador() { + return identificador; + } + + public void setIdentificador(Integer identificador) { + this.identificador = identificador; + } + + public String getNombrePais() { + return nombrePais; + } + + public void setNombrePais(String nombrePais) { + this.nombrePais = nombrePais; + } + + public String getCapital() { + return capital; + } + + public void setCapital(String capital) { + this.capital = capital; + } + + public Continente getContinente() { + return continente; + } + + public void setContinente(Continente continente) { + this.continente = continente; + } + + @Override + public String toString() { + return "Pais [identificador=" + identificador + ", nombrePais=" + nombrePais + ", capital=" + capital + + ", continente=" + continente + "]\n"; + } + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/Pelicula.java b/src/main/java/org/lapaloma/aadd/cine/vo/Pelicula.java new file mode 100644 index 0000000..78bbb0f --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/Pelicula.java @@ -0,0 +1,108 @@ +package org.lapaloma.aadd.cine.vo; + +import jakarta.persistence.*; + +@Entity +@Table(name = "pelicula") +public class Pelicula { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name="identificador") + private Integer identificador; + + @Column(name="titulo") + private String titulo; + + @Column(name="anyo", nullable = false) + private Integer anyo; + + @Column(name="idioma", length = 50) + private String idioma; + + @Column(name="color", columnDefinition = "boolean") + private Boolean color; + + @Column(name="observ") + private String observacion; + + @ManyToOne(fetch = FetchType.EAGER) + @JoinColumn(name = "id_pais") + private Pais paisLocalizacion; + + @ManyToOne(fetch = FetchType.EAGER) + @JoinColumn(name = "id_director", nullable = false) + private Director director; + + public Integer getIdentificador() { + return identificador; + } + + public void setIdentificador(Integer identificador) { + this.identificador = identificador; + } + + public String getTitulo() { + return titulo; + } + + public void setTitulo(String titulo) { + this.titulo = titulo; + } + + public Integer getAnyo() { + return anyo; + } + + public void setAnyo(Integer anyo) { + this.anyo = anyo; + } + + public String getIdioma() { + return idioma; + } + + public void setIdioma(String idioma) { + this.idioma = idioma; + } + + public Boolean getColor() { + return color; + } + + public void setColor(Boolean color) { + this.color = color; + } + + public String getObservacion() { + return observacion; + } + + public void setObservacion(String observacion) { + this.observacion = observacion; + } + + public Pais getPaisLocalizacion() { + return paisLocalizacion; + } + + public void setPaisLocalizacion(Pais paisLocalizacion) { + this.paisLocalizacion = paisLocalizacion; + } + + public Director getDirector() { + return director; + } + + public void setDirector(Director director) { + this.director = director; + } + + @Override + public String toString() { + return "Pelicula [identificador=" + identificador + ", titulo=" + titulo + ", anyo=" + anyo + ", idioma=" + + idioma + ", color=" + color + ", observacion=" + observacion + ", paisLocalizacion=" + + paisLocalizacion + ", director=" + director + "]\n"; + } + + +} diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/Reparto.java b/src/main/java/org/lapaloma/aadd/cine/vo/Reparto.java new file mode 100644 index 0000000..2185fe8 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/Reparto.java @@ -0,0 +1,60 @@ +package org.lapaloma.aadd.cine.vo; + +import jakarta.persistence.*; + +@Entity +@Table(name = "reparto") +public class Reparto { + + @EmbeddedId + private RepartoId idReparto; + + @ManyToOne(fetch = FetchType.EAGER) + @MapsId("idActor") // Esto mapea a idActor en RepartoId + @JoinColumn(name = "id_actor") + private Actor actor; + + @ManyToOne(fetch = FetchType.EAGER) + @MapsId("idPelicula") // Esto mapea a idPelicula en RepartoId + @JoinColumn(name = "id_pelicula") + private Pelicula pelicula; + + @Column(name = "personaje", length = 50, nullable = false) + private String personaje; + + public Actor getActor() { + return actor; + } + + public void setActor(Actor actor) { + this.actor = actor; + } + + public Pelicula getPelicula() { + return pelicula; + } + + public void setPelicula(Pelicula pelicula) { + this.pelicula = pelicula; + } + + public String getPersonaje() { + return personaje; + } + + public void setPersonaje(String personaje) { + this.personaje = personaje; + } + public RepartoId getIdReparto() { + return idReparto; + } + + public void setIdReparto(RepartoId idReparto) { + this.idReparto = idReparto; + } + + @Override + public String toString() { + return "Reparto [actor=" + actor + ", pelicula=" + pelicula + ", personaje=" + personaje + "]\n"; + } + } diff --git a/src/main/java/org/lapaloma/aadd/cine/vo/RepartoId.java b/src/main/java/org/lapaloma/aadd/cine/vo/RepartoId.java new file mode 100644 index 0000000..5fedd79 --- /dev/null +++ b/src/main/java/org/lapaloma/aadd/cine/vo/RepartoId.java @@ -0,0 +1,60 @@ +package org.lapaloma.aadd.cine.vo; + +import java.io.Serializable; +import java.util.Objects; + +import jakarta.persistence.Column; +import jakarta.persistence.Embeddable; + + +@Embeddable +public class RepartoId implements Serializable { + private static final long serialVersionUID = 6142631595518522640L; + + @Column(name = "id_actor") + private Integer idActor; + + @Column(name = "id_pelicula") + private Integer idPelicula; + + public RepartoId() { + } + + public RepartoId(Integer idActor, Integer idPelicula) { + this.idActor = idActor; + this.idPelicula = idPelicula; + } + + @Override + public boolean equals(Object o) { + RepartoId idReparto= (RepartoId) o; + return Objects.equals(idActor, idReparto.idActor) && Objects.equals(idPelicula, idReparto.idPelicula); + } + + @Override + public int hashCode() { + return Objects.hash(idActor, idPelicula); + } + + public Integer getIdActor() { + return idActor; + } + + public void setIdActor(Integer idActor) { + this.idActor = idActor; + } + + public Integer getIdPelicula() { + return idPelicula; + } + + public void setIdPelicula(Integer idPelicula) { + this.idPelicula = idPelicula; + } + + @Override + public String toString() { + return "RepartoId [idActor=" + idActor + ", idPelicula=" + idPelicula + "]"; + } + +} diff --git a/src/main/resources/hibernate.cfg.xml b/src/main/resources/hibernate.cfg.xml new file mode 100644 index 0000000..65532ea --- /dev/null +++ b/src/main/resources/hibernate.cfg.xml @@ -0,0 +1,30 @@ + + + + + jdbc:mysql://172.16.0.176:3306/Cine + com.mysql.cj.jdbc.Driver + + org.hibernate.dialect.MySQLDialect + + root + mysql_123 + + + none + false + flase + + + thread + + + + + + + + + \ No newline at end of file