Procesado con Transacción por película

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

src/main/java/org/lapaloma/aadd/cine/AppCine.java

@@ -9,7 +9,7 @@ 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.gestores.GestorFicheroConfiguracion;
+import org.lapaloma.aadd.cine.procesos.ProcesadorPeliculasJSON;
 import org.lapaloma.aadd.cine.servicio.ActorService;
 import org.lapaloma.aadd.cine.servicio.ContinenteService;
 import org.lapaloma.aadd.cine.servicio.DirectorService;
@@ -40,8 +40,20 @@ public class AppCine {
 	}
 
 	private void procesarFicheroJSON() {
-		org.lapaloma.aadd.cine.procesos.ProcesadorPeliculasJSON procesador = new org.lapaloma.aadd.cine.procesos.ProcesadorPeliculasJSON();
-		procesador.procesar();
+		ProcesadorPeliculasJSON procesador = new ProcesadorPeliculasJSON();
+		procesador.procesarFicheroInformacionFestival();
+		
+		/*
+		probarOperacionesContinente();
+		
+		probarOperacionesPais();
+		
+		probarOperacionesDirector();
+		
+		probarOperacionesPelicula();
+		
+		probarOperacionesActor();
+		*/
 	}
 
 	private void probarOperacionesContinente() {

src/main/java/org/lapaloma/aadd/cine/dao/IActorDAO.java

@@ -10,4 +10,9 @@ public interface IActorDAO extends IOperacionesDAOEntidad<Actor, Integer> {
 	void borrarActoresReferenciasContinente(String codigoContinente) throws Exception;
 
 	Actor obtenerActorPorNombre(String nombre);
+	
+	void actualizarActor(Actor actor) throws Exception;
+	
+	void insertarActor(Actor actor) throws Exception;
+	
 }

src/main/java/org/lapaloma/aadd/cine/dao/IDirectorDAO.java

@@ -10,4 +10,8 @@ public interface IDirectorDAO extends IOperacionesDAOEntidad<Director, Integer>
 	void borrarDirectoresReferenciasContinente(String codigoContinente) throws Exception;
 
 	Director obtenerDirectorPorNombre(String nombre);
+	
+	void actualizarDirector(Director director) throws Exception;
+	
+	void insertarDirector(Director director) throws Exception;
 }

src/main/java/org/lapaloma/aadd/cine/dao/IPeliculaDAO.java

@@ -11,5 +11,9 @@ public interface IPeliculaDAO extends IOperacionesDAOEntidad<Pelicula, Integer>
 
 	void borrarPeliculasReferenciasContinente(String codigoContinente) throws Exception;
 
-	Pelicula obtenerPeliculaPorTituloYAnyo(String titulo, Integer anyo);
+	Pelicula obtenerPeliculaPorTitulo(String titulo) throws Exception;
+	
+	void actualizarPelicula(Pelicula pelicula) throws Exception;
+	
+	void insertarPelicula(Pelicula pelicula) throws Exception;
 }

src/main/java/org/lapaloma/aadd/cine/dao/IRepartoDAO.java

@@ -13,4 +13,8 @@ public interface IRepartoDAO extends IOperacionesDAOEntidad<Reparto, RepartoId>
 	void borrarRepartoReferenciasPais(Integer idPais) throws Exception;
 
 	void borrarRepartoReferenciasContinente(String codigoContinente) throws Exception;
+	
+	void insertarReparto(Reparto reparto) throws Exception;
+	
+	void actualizarReparto(Reparto reparto) throws Exception;
 }

src/main/java/org/lapaloma/aadd/cine/dao/hbnt/ActorDaoHibernate.java

@@ -176,4 +176,16 @@ public class ActorDaoHibernate implements IActorDAO {
 		return actor;
 	}
 
+	@Override
+	public void actualizarActor(Actor actor) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.merge(actor);
+	}
+
+	@Override
+	public void insertarActor(Actor actor) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.persist(actor);
+	}
+
 }

src/main/java/org/lapaloma/aadd/cine/dao/hbnt/DirectorDaoHibernate.java

@@ -175,4 +175,16 @@ public class DirectorDaoHibernate implements IDirectorDAO {
 		return director;
 	}
 
+	@Override
+	public void actualizarDirector(Director director) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.merge(director);		
+	}
+
+	@Override
+	public void insertarDirector(Director director) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.persist(director);		
+	}
+
 }

src/main/java/org/lapaloma/aadd/cine/dao/hbnt/PeliculaDaoHibernate.java

@@ -186,13 +186,12 @@ public class PeliculaDaoHibernate implements IPeliculaDAO {
 	}
 
 	@Override
-	public Pelicula obtenerPeliculaPorTituloYAnyo(String titulo, Integer anyo) {
+	public Pelicula obtenerPeliculaPorTitulo(String titulo) {
 		Pelicula pelicula = null;
-		String sentenciaHQL = "SELECT p FROM Pelicula p WHERE p.titulo = :titulo AND p.anyo = :anyo";
+		String sentenciaHQL = "SELECT p FROM Pelicula p WHERE p.titulo = :titulo";
 		try (Session sesion = GestorSesionesHibernate.getSession();) {
 			SelectionQuery<Pelicula> sentenciaConsulta = sesion.createSelectionQuery(sentenciaHQL, Pelicula.class);
 			sentenciaConsulta.setParameter("titulo", titulo);
-			sentenciaConsulta.setParameter("anyo", anyo);
 			pelicula = sentenciaConsulta.getSingleResultOrNull();
 		} catch (Exception e) {
 			e.printStackTrace();
@@ -200,4 +199,16 @@ public class PeliculaDaoHibernate implements IPeliculaDAO {
 		return pelicula;
 	}
 
+	@Override
+	public void actualizarPelicula(Pelicula pelicula) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.merge(pelicula);			
+	}
+
+	@Override
+	public void insertarPelicula(Pelicula pelicula) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.persist(pelicula);			
+	}
+
 }

src/main/java/org/lapaloma/aadd/cine/dao/hbnt/RepartoDaoHibernate.java

@@ -182,4 +182,16 @@ public class RepartoDaoHibernate implements IRepartoDAO {
 
 	}
 
+	@Override
+	public void insertarReparto(Reparto reparto) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.persist(reparto);			
+	}
+
+	@Override
+	public void actualizarReparto(Reparto reparto) throws Exception {
+		Session sesion = GestorSesionesHibernate.getCurrentSession();
+		sesion.merge(reparto);				
+	}
+
 }

src/main/java/org/lapaloma/aadd/cine/procesos/ProcesadorPeliculasJSON.java

@@ -15,6 +15,7 @@ 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.GestorFicheroConfiguracion;
 import org.lapaloma.aadd.cine.gestores.GestorSesionesHibernate;
 import org.lapaloma.aadd.cine.vo.Actor;
 import org.lapaloma.aadd.cine.vo.Director;
@@ -34,89 +35,83 @@ public class ProcesadorPeliculasJSON {
 	private IPaisDAO paisDAO = new PaisDaoHibernate();
 	private IRepartoDAO repartoDAO = new RepartoDaoHibernate();
 
-	public void procesar() {
-		File fichero = new File("ficheros/peliculas-festival.json");
+	public void procesarFicheroInformacionFestival() {
+		String rutaFichero = GestorFicheroConfiguracion.getValorfromClave("festival.fichero.json.ruta");
+		File fichero = new File(rutaFichero);
+
+		// Se asume que la información de Paises es correcta y ya existe en la BD
 		ObjectMapper mapper = new ObjectMapper();
 		JsonNode root = mapper.readTree(fichero);
-		JsonNode peliculasNode = root.get("peliculas");
+		JsonNode nodoPeliculas = root.get("peliculas");
 
-		if (peliculasNode != null && peliculasNode.isArray()) {
-			for (JsonNode peliculaNode : peliculasNode) {
-				procesarPelicula(peliculaNode);
+		// Procesar cada película enviada por el festival
+		if (nodoPeliculas != null && nodoPeliculas.isArray()) {
+			for (JsonNode nodoPelicula : nodoPeliculas) {
+				procesarPelicula(nodoPelicula);
 			}
 		}
 	}
 
-	private void procesarPelicula(JsonNode node) {
+	private void procesarPelicula(JsonNode nodoPelicula) {
 		Transaction transaccion = null;
 		// Usamos getCurrentSession para que todos los DAO usen la misma sesión y
 		// transacción
-		try (Session sesion = GestorSesionesHibernate.getCurrentSession()) {
+		try (Session sesion = GestorSesionesHibernate.getSession()) {
+			// Iniciar transacción
 			transaccion = sesion.beginTransaction();
 
-			// 1. Obtener Pais de Localización
-			Integer idPais = node.get("pais").asInt();
+			// 1. Procesar Director Pelicula
+			JsonNode nodoDirector = nodoPelicula.get("director");
+			Director director = obtenerDirectorTrasProcesarlo(nodoDirector);
+
+			// 2. Procesar Película
+			String titulo = nodoPelicula.get("titulo").asString();
+			Pelicula pelicula = peliculaDAO.obtenerPeliculaPorTitulo(titulo);
+
+			String observacionJSON = nodoPelicula.get("observ").asString();
+
+			// Obtener Pais de Localización (se asume que existe)
+			Integer idPais = nodoPelicula.get("pais").asInt();
 			Pais paisLocalizacion = paisDAO.obtenerEntidadPorClave(idPais);
-			// Si no existe el país lo podríamos crear, pero el enunciado dice "En caso de
-			// que no exista alguna de las entidades involucradas... habrá que
-			// almacenarlas".
-			// Sin embargo, para un país sólo tenemos el ID en este punto. Supongamos que el
-			// país debe existir o se crea uno básico si no existe (aunque faltarían datos).
-			// Por ahora nos centramos en Director, Actor y Película que tienen más datos.
-			if (paisLocalizacion == null) {
-				paisLocalizacion = new Pais();
-				paisLocalizacion.setIdentificador(idPais);
-				paisLocalizacion.setNombrePais("País desconocido (" + idPais + ")");
-				// El continente es obligatorio? En el VO no parece marcarse como nullable=false
-				// pero es una buena práctica.
-				// Para simplificar, si no existe el país básico, lo persistimos si fuera
-				// necesario.
-				// sesion.persist(paisLocalizacion);
-			}
 
-			// 2. Procesar Director
-			JsonNode directorNode = node.get("director");
-			String nombreDirector = directorNode.get("nombre").asString();
-			Director director = directorDAO.obtenerDirectorPorNombre(nombreDirector);
-			if (director == null) {
-				director = new Director();
-				director.setNombre(nombreDirector);
-				fillDirectorInfo(director, directorNode);
-				sesion.persist(director);
-			} else {
-				fillDirectorInfo(director, directorNode);
-				sesion.merge(director);
-			}
-
-			// 3. Procesar Película
-			String titulo = node.get("titulo").asString();
-			Integer anyo = node.get("anyo").asInt();
-			Pelicula pelicula = peliculaDAO.obtenerPeliculaPorTituloYAnyo(titulo, anyo);
-			String observacionJSON = node.get("observ").asString();
+			String idioma = nodoPelicula.get("idioma").asString();
+			boolean color = nodoPelicula.get("color").asBoolean();
 
+			// Si la película no existe se crea nueva, si no se actualiza
 			if (pelicula == null) {
 				pelicula = new Pelicula();
 				pelicula.setTitulo(titulo);
-				pelicula.setAnyo(anyo);
-				fillPeliculaInfo(pelicula, node, paisLocalizacion, director);
+				pelicula.setPaisLocalizacion(paisLocalizacion);
+				pelicula.setDirector(director);
+				pelicula.setIdioma(idioma);
+				pelicula.setColor(color);
 				pelicula.setObservacion(observacionJSON);
-				sesion.persist(pelicula);
+
+				peliculaDAO.insertarPelicula(pelicula);
 			} else {
+				pelicula.setTitulo(titulo);
+				pelicula.setPaisLocalizacion(paisLocalizacion);
+				pelicula.setDirector(director);
+				pelicula.setIdioma(idioma);
+				pelicula.setColor(color);
 				String obsActual = pelicula.getObservacion();
-				pelicula.setObservacion((obsActual != null ? obsActual : "") + observacionJSON);
-				fillPeliculaInfo(pelicula, node, paisLocalizacion, director);
-				sesion.merge(pelicula);
-			}
-
-			// 4. Procesar Reparto y Actores
-			JsonNode repartoNode = node.get("reparto");
-			if (repartoNode != null && repartoNode.isArray()) {
-				for (JsonNode actorNode : repartoNode) {
-					procesarActorYReparto(sesion, actorNode, pelicula);
+				if (obsActual!=null && !obsActual.contains(observacionJSON)) {
+					obsActual += obsActual + " | " + observacionJSON;
+				}else {
+					obsActual = observacionJSON;
 				} 
+				pelicula.setObservacion(obsActual.substring(0, 50)); // Limitar a 50 caracteres (de la BBDD)
+
+				peliculaDAO.actualizarPelicula(pelicula);
 			}
 
+			// 3. Procesar Reparto (y sus actores)
+			JsonNode nodoReparto = nodoPelicula.get("reparto");
+			procesarActoresYReparto(nodoReparto, pelicula);
+
+			// Confirmar transacción
 			transaccion.commit();
+			
 			System.out.println("Procesada con éxito la película: " + titulo);
 		} catch (Exception e) {
 			if (transaccion != null && transaccion.isActive()) {
@@ -127,64 +122,89 @@ public class ProcesadorPeliculasJSON {
 		}
 	}
 
-	private void fillDirectorInfo(Director director, JsonNode node) {
-		if (node.has("fechaNacimiento")) {
-			director.setFechaNacimiento(LocalDate.parse(node.get("fechaNacimiento").asString()));
+	private Director obtenerDirectorTrasProcesarlo(JsonNode nodoDirector) throws Exception {
+		String nombreDirector = nodoDirector.get("nombre").asString();
+		Director director = null;
+
+		LocalDate fechaNacimiento = null;
+		Pais paisNacimiento = null;
+		if (nodoDirector.has("fechaNacimiento")) {
+			fechaNacimiento = LocalDate.parse(nodoDirector.get("fechaNacimiento").asString());
 		}
-		if (node.has("pais")) {
-			Integer idPais = node.get("pais").asInt();
-			Pais p = paisDAO.obtenerEntidadPorClave(idPais);
-			if (p != null) {
-				director.setPais(p);
+		if (nodoDirector.has("pais")) {
+			Integer idPais = nodoDirector.get("pais").asInt();
+			paisNacimiento = paisDAO.obtenerEntidadPorClave(idPais);
+		}
+		director = directorDAO.obtenerDirectorPorNombre(nombreDirector);
+		// Si no existe, crear nuevo Director
+		if (director == null) {
+			director = new Director();
+			director.setNombre(nombreDirector);
+			director.setFechaNacimiento(fechaNacimiento);
+			director.setPais(paisNacimiento);
+
+			directorDAO.insertarDirector(director);
+		} else {
+			director.setNombre(nombreDirector);
+			if (fechaNacimiento != null)
+				director.setFechaNacimiento(fechaNacimiento);
+			if (paisNacimiento != null)
+				director.setPais(paisNacimiento);
+
+			directorDAO.actualizarDirector(director);
+		}
+		return director;
+	}
+
+	private void procesarActoresYReparto(JsonNode nodoReparto, Pelicula pelicula) throws Exception {
+		if (nodoReparto != null && nodoReparto.isArray()) {
+			for (JsonNode nodoActorPeli : nodoReparto) {
+				// Procesar Actor
+				Actor actor = obtenerActorTrasProcesarlo(nodoActorPeli);
+
+				// Procesar Reparto
+				String personaje = nodoActorPeli.get("personaje").asString();
+				RepartoId idReparto = new RepartoId(actor.getIdentificador(), pelicula.getIdentificador());
+				Reparto reparto = repartoDAO.obtenerEntidadPorClave(idReparto);
+
+				if (reparto == null) {
+					reparto = new Reparto();
+					reparto.setIdReparto(idReparto);
+					reparto.setActor(actor);
+					reparto.setPelicula(pelicula);
+					reparto.setPersonaje(personaje);
+					
+					repartoDAO.insertarReparto(reparto);
+				} else {
+					reparto.setPersonaje(personaje);
+					repartoDAO.actualizarReparto(reparto);
+				}
 			}
 		}
+
 	}
 
-	private void fillPeliculaInfo(Pelicula pelicula, JsonNode node, Pais pais, Director director) {
-		pelicula.setIdioma(node.get("idioma").asString());
-		pelicula.setColor(node.get("color").asBoolean());
-		pelicula.setPaisLocalizacion(pais);
-		pelicula.setDirector(director);
-	}
+	private Actor obtenerActorTrasProcesarlo(JsonNode nodoActor) throws Exception {
+		Actor actor = null;
 
-	private void procesarActorYReparto(Session sesion, JsonNode node, Pelicula pelicula) {
-		String nombreActor = node.get("nombre").asString();
-		Actor actor = actorDAO.obtenerActorPorNombre(nombreActor);
+		String nombreActor = nodoActor.get("nombre").asString();
+		actor = actorDAO.obtenerActorPorNombre(nombreActor);
 
+		Integer idPais = nodoActor.get("pais").asInt();
+		Pais paisActor = paisDAO.obtenerEntidadPorClave(idPais);
+
+		// Si no existe, crear nuevo Actor en caso contrario actualizar país
 		if (actor == null) {
 			actor = new Actor();
 			actor.setNombre(nombreActor);
-			fillActorInfo(actor, node);
-			sesion.persist(actor);
-		} else {
-			fillActorInfo(actor, node);
-			sesion.merge(actor);
-		}
+			actor.setPais(paisActor);
 			
-		String personaje = node.get("personaje").asString();
-		RepartoId idReparto = new RepartoId(actor.getIdentificador(), pelicula.getIdentificador());
-		Reparto reparto = sesion.find(Reparto.class, idReparto);
-
-		if (reparto == null) {
-			reparto = new Reparto();
-			reparto.setIdReparto(idReparto);
-			reparto.setActor(actor);
-			reparto.setPelicula(pelicula);
-			reparto.setPersonaje(personaje);
-			sesion.persist(reparto);
+			actorDAO.insertarActor(actor);
 		} else {
-			reparto.setPersonaje(personaje);
-			sesion.merge(reparto);
+			actor.setPais(paisActor);
+			actorDAO.actualizarActor(actor);
 		}
+		return actor;
 	}
 
-	private void fillActorInfo(Actor actor, JsonNode node) {
-		if (node.has("pais")) {
-			Integer idPais = node.get("pais").asInt();
-			Pais p = paisDAO.obtenerEntidadPorClave(idPais);
-			if (p != null) {
-				actor.setPais(p);
-			}
-		}
-	}
 }

src/main/resources/conf.properties

@@ -1,4 +1,4 @@
-# Información sobre fichero JSON
-cine.fichero.json.ruta=ficheros/peliculas-festival.json
+# Información sobre fichero JSON
+festival.fichero.json.ruta=ficheros/peliculas-festival.json