package videoclub.server;
import java.util.ArrayList;
import java.util.List;
import javax.jdo.Query;
import javax.jdo.PersistenceManager;
import modelo.Clasificacion;
import modelo.Pelicula;
import modelo.Persona;
import modelo.Productora;
import videoclub.server.PMF;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.google.appengine.api.datastore.Key;
import videoclub.client.MyUserService;
import videoclub.client.dto.ClasificacionDTO;
import videoclub.client.dto.PeliculaDTO;
import videoclub.client.dto.PersonaDTO;
import videoclub.client.dto.ProductoraDTO;
@SuppressWarnings("serial")
public class MyUserServiceImpl extends RemoteServiceServlet implements
MyUserService {
private List<ClasificacionDTO> dtoClasList = new ArrayList<ClasificacionDTO>();
private List<Clasificacion> resultsClas = new ArrayList<Clasificacion>();
private List<ProductoraDTO> dtoProdList = new ArrayList<ProductoraDTO>();
private List<Productora> resultsProd = new ArrayList<Productora>();
private List<PersonaDTO> dtoPersList = new ArrayList<PersonaDTO>();
private List<Persona> resultsPers = new ArrayList<Persona>();
private List<PeliculaDTO> dtoPelList = new ArrayList<PeliculaDTO>();
private List<Pelicula> resultsPel = new ArrayList<Pelicula>();
private String escapeHtml(String html) {
if (html == null) {
return null;
}
return html.replaceAll("&", "&").replaceAll("<", "<")
.replaceAll(">", ">");
}
//---------------------------------CLASIFICACION---------------------------------------
public String agregarClasificacion(String input) {
input = escapeHtml(input);
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Clasificacion.class);
q.declareParameters("String detalleParam");
q.setFilter("detalle == detalleParam");
try {
List<Clasificacion> results = (List<Clasificacion>) q.execute(input);
if (results.isEmpty()) {
Clasificacion clas = new Clasificacion(input);
try {
pm.makePersistent(clas);
} finally {
pm.close();
}
return "La Clasificacion <b>" + input + "</b> se ha agregado correctamente.";
}else{
System.out.println("Lapidus");
return "No se ha podido agregar la clasificacion <b>" + input + "</b>. <br />Ya se encuentre en la base de datos.";
}
} finally {
q.closeAll();
}
}
public List<ClasificacionDTO> getClasList() {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Clasificacion.class);
q.setOrdering("detalle asc");
resultsClas.clear();
try {
List<Clasificacion> results = (List<Clasificacion>) q.execute();
if (!results.isEmpty()) {
for (Clasificacion e : results) {
resultsClas.add(e);
}
}
} finally {
q.closeAll();
}
dtoClasList.clear();
for (Clasificacion e : resultsClas) {
ClasificacionDTO clasDTO = new ClasificacionDTO(e.getDetalle());
dtoClasList.add(clasDTO);
}
return dtoClasList;
}
private Clasificacion getClasList(String input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Clasificacion.class);
q.declareParameters("String detalleParam");
q.setFilter("detalle == detalleParam");
try {
List<Clasificacion> results = (List<Clasificacion>) q.execute(input);
if (!results.isEmpty()) {
for (Clasificacion e : results) {
return e;
}
}
} finally {
pm.close();
}
return new Clasificacion();
}
public String deleteClasificacion(String input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Clasificacion.class);
q.declareParameters("String detalleParam");
q.setFilter("detalle == detalleParam");
try {
List<Clasificacion> results = (List<Clasificacion>) q.execute(input);
if (!results.isEmpty()) {
for (Clasificacion e : results) {
pm.deletePersistent(e);
}
return "La clasificaci�n <b>" + input + "</b> se ha eliminado correctamente.";
}
else{
return "No se ha podido eliminar a la clasificaci�n <b>" + input + "</b>. <br />Puede que no se encuentre en la base de datos.";
}
} finally {
q.closeAll();
}
}
public String updateClasificacion(String input, String input2) {
input2 = escapeHtml(input2);
input = escapeHtml(input);
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Clasificacion.class);
q.declareParameters("String detalleParam");
q.setFilter("detalle == detalleParam");
Query q2 = pm.newQuery(Clasificacion.class);
q2.declareParameters("String detalleParam");
q2.setFilter("detalle == detalleParam");
try {
List<Clasificacion> results = (List<Clasificacion>) q.execute(input2);
if (results.isEmpty()) {
try {
List<Clasificacion> results2 = (List<Clasificacion>) q2.execute(input);
if (!results2.isEmpty()) {
for (Clasificacion e : results2) {
try {
Clasificacion clas = pm.getObjectById(Clasificacion.class, e.getKey());
clas.setDetalle(input2);
} finally {
pm.close();
}
return "La clasificaci�n <b>" + input + "</b> se ha modificado por <b>" + input2 + "</b> correctamente.";
}
}
} finally {
q2.closeAll();
}
return "No se ha podido modificar la clasificaci�n <b>" + input + "</b>.";
}
} finally {
q.closeAll();
}
return "No se ha podido modificar la clasificaci�n <b>" + input + "</b> por <b>" + input2 + "</b>. <br />Debido a que ya hab�a una clasificacion llamada <b>" + input2 + "</b>.";
}
//--------------------------------- FIN CLASIFICACION---------------------------------------
//---------------------------------PRODUCTORA---------------------------------------
public String agregarProductora(ProductoraDTO input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Productora.class);
q.declareParameters("String nombreParam");
q.setFilter("nombre == nombreParam");
try {
List<Productora> results = (List<Productora>) q.execute(input.getNombre());
if (results.isEmpty()) {
Productora prod = new Productora(input.getNombre(), input.getPais(), input.getDireccion(), input.getTelefono(), input.getDesde());
try {
pm.makePersistent(prod);
} finally {
pm.close();
}
return "La productora <b>" + input.getNombre() + "</b> se ha agregado correctamente.";
}else{
System.out.println("Lapidus");
return "No se ha podido agregar la productora <b>" + input.getNombre() + "</b>. <br />Ya se encuentre en la base de datos.";
}
} finally {
q.closeAll();
}
}
public List<ProductoraDTO> getProdList() {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Productora.class);
q.setOrdering("nombre asc");
resultsProd.clear();
try {
List<Productora> results = (List<Productora>) q.execute();
if (!results.isEmpty()) {
for (Productora e : results) {
resultsProd.add(e);
}
}
} finally {
q.closeAll();
}
dtoProdList.clear();
for (Productora e : resultsProd) {
ProductoraDTO prodDTO = new ProductoraDTO(e.getNombre(), e.getPais(), e.getDireccion(), e.getTelefono(), e.getDesde());
dtoProdList.add(prodDTO);
}
return dtoProdList;
}
private Productora getProdList(String input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Productora.class);
q.declareParameters("String nombreParam");
q.setFilter("nombre == nombreParam");
try {
List<Productora> results = (List<Productora>) q.execute(input);
if (!results.isEmpty()) {
for (Productora e : results) {
return e;
}
}
} finally {
pm.close();
}
return new Productora();
}
public String deleteProductora(String input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Productora.class);
q.declareParameters("String nombreParam");
q.setFilter("nombre == nombreParam");
try {
List<Productora> results = (List<Productora>) q.execute(input);
if (!results.isEmpty()) {
for (Productora e : results) {
pm.deletePersistent(e);
}
return "La productora <b>" + input + "</b> se ha eliminado correctamente.";
}
} finally {
q.closeAll();
}
return "No se ha podido eliminar a la productora <b>" + input + "</b>. <br />Puede que no se encuentre en la base de datos.";
}
public String updateProductora(String input, ProductoraDTO input2) {
input = escapeHtml(input);
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Productora.class);
q.declareParameters("String nombreParam");
q.setFilter("nombre == nombreParam");
Query q2 = pm.newQuery(Productora.class);
q2.declareParameters("String nombreParam");
q2.setFilter("nombre == nombreParam");
Boolean ok = true;
try {
if (input != input2.getNombre()){
System.out.println("Lapidus");
List<Productora> results = (List<Productora>) q.execute(input2.getNombre());
if (!results.isEmpty()){
ok = false;
}
}
if (ok) {
try {
List<Productora> results2 = (List<Productora>) q2.execute(input);
if (!results2.isEmpty()) {
for (Productora e : results2) {
try {
Productora prod = pm.getObjectById(Productora.class, e.getKey());
prod.setNombre(input2.getNombre());
prod.setPais(input2.getPais());
prod.setDireccion(input2.getDireccion());
prod.setTelefono(input2.getTelefono());
prod.setDesde(input2.getDesde());
} finally {
pm.close();
}
if (input == input2.getNombre())
return "La productora <b>" + input + "</b> se ha modificado correctamente.";
else
return "La productora <b>" + input + "</b> se ha modificado por <b>" + input2.getNombre() + "</b> correctamente.";
}
}
} finally {
q2.closeAll();
}
return "No se ha podido modificar la productora <b>" + input + "</b>.";
}
} finally {
q.closeAll();
}
return "No se ha podido modificar la productora <b>" + input + "</b> por <b>" + input2.getNombre() + "</b>. <br />Debido a que ya hab�a una productora llamada <b>" + input2.getNombre() + "</b>.";
}
//---------------------------------FIN PRODUCTORA---------------------------------------
//---------------------------------PERSONA---------------------------------------
public String agregarPersona(PersonaDTO input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Persona.class);
q.declareParameters("String apellidoParam, String nombreParam");
q.setFilter("apellido == apellidoParam && nombre == nombreParam");
try {
List<Persona> results = (List<Persona>) q.execute(input.getApellido(), input.getNombre());
if (results.isEmpty()) {
Persona pers = new Persona(input.getApellido(), input.getNombre(), input.getNacionalidad());
try {
pm.makePersistent(pers);
} finally {
pm.close();
}
return "La persona <b>" + input.getApellido() + ", " + input.getNombre() + "</b> se ha agregado correctamente.";
}else{
System.out.println("Lapidus");
return "No se ha podido agregar la persona <b>" + input.getApellido() + ", " + input.getNombre() + "</b>. <br />Puede que ya se encuentre en la base de datos.";
}
} finally {
q.closeAll();
}
}
public List<PersonaDTO> getPersList() {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Persona.class);
q.setOrdering("apellido asc");
resultsPers.clear();
try {
List<Persona> results = (List<Persona>) q.execute();
if (!results.isEmpty()) {
for (Persona e : results) {
resultsPers.add(e);
}
}
} finally {
q.closeAll();
}
dtoPersList.clear();
for (Persona e : resultsPers) {
PersonaDTO persDTO = new PersonaDTO(e.getApellido(), e.getNombre(), e.getNacionalidad());
dtoPersList.add(persDTO);
}
return dtoPersList;
}
public String deletePersona(String input, String input2) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Persona.class);
q.declareParameters("String apellidoParam, String nombreParam");
q.setFilter("apellido == apellidoParam && nombre == nombreParam");
Key key_persona;
Query q_peli_act = pm.newQuery(Pelicula.class);
q_peli_act.declareParameters("String personaParam");
q_peli_act.setFilter("actores.contains(personaParam)");
try {
List<Persona> results = (List<Persona>) q.execute(input, input2);
if (!results.isEmpty()) {
key_persona = results.get(0).getKey();
for (Persona e : results) {
pm.deletePersistent(e);
}
//Borro las referencias de esa persona en las pel�culas
List<Pelicula> pelis_results = (List<Pelicula>) q_peli_act.execute(key_persona);
if (!pelis_results.isEmpty()) {
for (Pelicula p : pelis_results) {
if (p.getActores().contains(key_persona)){
p.getActores().remove(key_persona);
}
}
}
return "La persona <b>" + input + ", " + input2 + "</b> se ha eliminado correctamente.";
}
} finally {
q.closeAll();
}
return "No se ha podido eliminar a la persona <b>" + input + ", " + input2 + "</b>. <br />Puede que no se encuentre en la base de datos.";
}
public String updatePersona(String input, String input2, PersonaDTO input3) {
input = escapeHtml(input);
input2 = escapeHtml(input2);
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Persona.class);
q.declareParameters("String apellidoParam, String nombreParam");
q.setFilter("apellido == apellidoParam && nombre == nombreParam");
Query q2 = pm.newQuery(Persona.class);
q2.declareParameters("String apellidoParam, String nombreParam");
q2.setFilter("apellido == apellidoParam && nombre == nombreParam");
Boolean ok = true;
try {
if ((input != input3.getApellido()) || (input2 != input3.getNombre())){
System.out.println("Lapidus");
List<Persona> results = (List<Persona>) q.execute(input3.getApellido(), input3.getNombre());
if (!results.isEmpty()){
ok = false;
}
}
if (ok) {
try {
List<Persona> results2 = (List<Persona>) q2.execute(input, input2);
if (!results2.isEmpty()) {
for (Persona e : results2) {
try {
Persona pers = pm.getObjectById(Persona.class, e.getKey());
pers.setApellido(input3.getApellido());
pers.setNombre(input3.getNombre());
pers.setNacionalidad(input3.getNacionalidad());
} finally {
pm.close();
}
if ((input+input2).equals(input3.getApellido()+input3.getNombre()))
return "La persona <b>" + input + ", " + input2 + "</b> se ha modificado correctamente.";
else
return "La persona <b>" + input + ", " + input2 + "</b> se ha modificado por <b>" + input3.getApellido() + ", " + input3.getNombre() + "</b> correctamente.";
}
}
} finally {
q2.closeAll();
}
return "No se ha podido modificar la persona <b>" + input + ", " + input2 + "</b>.";
}
} finally {
q.closeAll();
}
return "No se ha podido modificar la persona <b>" + input + ", " + input2 + "</b> por <b>" +input3.getApellido() + ", " + input3.getNombre() + "</b>. <br />Debido a que ya hab�a una persona llamada <b>" + input3.getApellido() + ", " + input3.getNombre() + "</b>.";
}
//---------------------------------FIN PERSONA---------------------------------------
//---------------------------------PELICULA---------------------------------------
public String agregarPelicula(PeliculaDTO input) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Pelicula.class);
q.declareParameters("String tituloParam, Integer anioParam");
q.setFilter("titulo == tituloParam && anio == anioParam");
Query qClas = pm.newQuery(Clasificacion.class);
qClas.declareParameters("String detalleParam");
qClas.setFilter("detalle == detalleParam");
Query qProd = pm.newQuery(Productora.class);
qProd.declareParameters("String nombreParam");
qProd.setFilter("nombre == nombreParam");
Query qPers = pm.newQuery(Persona.class);
try {
List<Pelicula> results = (List<Pelicula>) q.execute(input.getTitulo(), input.getAnio());
if (results.isEmpty()) {
Pelicula pel = new Pelicula(input.getTitulo(), input.getTitulo_esp(), input.getAnio());
try {
List<Key> actores = new ArrayList<Key>();
List<Persona> resultsPers = (List<Persona>) qPers.execute();
for (Persona e : resultsPers) {
if (input.getNombre_director().contains(e.getApellido()+", "+e.getNombre()))
pel.setDirector(e.getKey());
if (input.getActores().contains(e.getApellido()+", "+e.getNombre()))
actores.add(e.getKey());
}
pel.setActores(actores);
List<Productora> resultsProd = (List<Productora>) qProd.execute(input.getNombre_productora());
for (Productora e : resultsProd) {
//pel.setProductora1(e.getKey());
pel.setProductora(e);
e.agregarPelicula(pel);
}
List<Clasificacion> resultsClas = (List<Clasificacion>) qClas.execute(input.getDetalle_clasificacion());
for (Clasificacion e : resultsClas) {
//pel.setClasificacion(e.getKey());
pel.setClasificacion(e.getKey());
//e.getPeliculaSets().add(pel);
}
try {
pm.makePersistent(pel);
} finally {
}
return "La pel�cula <b>" + input.getTitulo() + " (" + input.getAnio() + ")" +"</b> se ha agregado correctamente.";
} finally {
pm.close();
}
}
else{
System.out.println("Lapidus");
return "No se ha podido agregar la pel�cula <b>" + input.getTitulo() + " (" + input.getAnio() + ")" +"</b>. <br />Ya se encuentra en la base de datos.";
}
} finally {
q.closeAll();
}
}
public List<PeliculaDTO> getPelList() {
//deletePeliculas();
//listAllData();
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Pelicula.class);
q.setOrdering("titulo asc");
resultsPel.clear();
try {
List<Pelicula> results = (List<Pelicula>) q.execute();
if (!results.isEmpty()) {
for (Pelicula e : results) {
resultsPel.add(e);
}
}
} finally {
q.closeAll();
}
dtoPelList.clear();
getPersList();
for (Pelicula e : resultsPel) {
String director ="";
String actores ="";
for (Persona c : resultsPers){
if(c.getKey().equals(e.getDirector()))
director = c.getApellido()+", "+c.getNombre();
if(e.getActores().contains(c.getKey()))
actores+= c.getApellido()+", "+c.getNombre()+ " - ";
}
getClasList();
String detalleClas ="";
for (Clasificacion c : resultsClas){
if(c.getKey().equals(e.getClasificacion()))
detalleClas = c.getDetalle();
}
/*getProdList();
String nombreProd ="";
for (Productora c : resultsProd){
if(c.getKey().equals(e.getProductora1()))
nombreProd = c.getNombre();
}*/
if (actores.length()!=0){
actores = actores.substring(0, (actores.length() - 3));
}
PeliculaDTO pelDTO = new PeliculaDTO(e.getTitulo(), e.getTitulo_espa�ol(), e.getAnio(), detalleClas,e.getProductora().getNombre(), director, actores);
dtoPelList.add(pelDTO);
}
return dtoPelList;
}
public String deletePelicula(String input, Integer input2) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Pelicula.class);
q.declareParameters("String tituloParam, Integer anioParam");
q.setFilter("titulo == tituloParam && anio == anioParam");
try {
List<Pelicula> results = (List<Pelicula>) q.execute(input, input2);
if (!results.isEmpty()) {
for (Pelicula e : results) {
pm.deletePersistent(e);
}
return "La pel�cula <b>" + input + " (" + input2 + ")" +"</b> se ha eliminado correctamente.";
}
} finally {
q.closeAll();
}
return "No se ha podido eliminar a la pel�cula <b>" + input + " (" + input2 + ")" +"</b>. <br />Puede que no se encuentre en la base de datos.";
}
public String updatePelicula(String input, Integer input2, PeliculaDTO pel_modificada) {
input = escapeHtml(input);
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Pelicula.class);
q.declareParameters("String tituloParam, Integer anioParam");
q.setFilter("titulo == tituloParam && anio == anioParam");
Query q2 = pm.newQuery(Pelicula.class);
q2.declareParameters("String tituloParam, Integer anioParam");
q2.setFilter("titulo == tituloParam && anio == anioParam");
Query qClas = pm.newQuery(Clasificacion.class);
qClas.declareParameters("String detalleParam");
qClas.setFilter("detalle == detalleParam");
Query qProd = pm.newQuery(Productora.class);
qProd.declareParameters("String nombreParam");
qProd.setFilter("nombre == nombreParam");
Query qPer = pm.newQuery(Persona.class);
Boolean ok = true;
try {
//Se fija si los valores viejos son distintos a los nuevos
if (!(input.equals(pel_modificada.getTitulo())) || !(input2.equals(pel_modificada.getAnio()))){
//Busca que no exista una pel�cula con el nuevo nombre/a�o
List<Pelicula> results = (List<Pelicula>) q.execute(pel_modificada.getTitulo(), pel_modificada.getAnio());
if (!results.isEmpty()) {
ok = false;
}
}
if (ok){
System.out.println("holanda!");
try {
//busca la pel�cula para actualizar los datos
List<Pelicula> results2 = (List<Pelicula>) q2.execute(input, input2);
if (!results2.isEmpty()) {
for (Pelicula e : results2) {
try {
Pelicula pel;
if (!e.getProductora().equals(pel_modificada.getNombre_productora())){
pel = new Pelicula();
e.getProductora().borrarPelicula(e);
System.out.println("they are taking the hobbits !!!!");
List<Productora> resultsProd = (List<Productora>) qProd.execute(pel_modificada.getNombre_productora());
for (Productora p : resultsProd) {
System.out.println(p.getNombre());
pel.setProductora(p);
p.agregarPelicula(pel);
}
pm.makePersistent(pel);
}else{
pel = pm.getObjectById(Pelicula.class, e.getKey());
}
pel.setTitulo(pel_modificada.getTitulo());
pel.setTitulo_espa�ol(pel_modificada.getTitulo_esp());
pel.setAnio(pel_modificada.getAnio());
if(pel_modificada.getDetalle_clasificacion().equals("")){
pel.deleteClasificacion();
}else{
List<Clasificacion> resultsClas = (List<Clasificacion>) qClas.execute(pel_modificada.getDetalle_clasificacion());
for (Clasificacion c : resultsClas) {
System.out.println("Lapidus");
pel.setClasificacion(c.getKey());
}
}
int coma;
List<Key> actores = new ArrayList<Key>();
coma = pel_modificada.getNombre_director().indexOf(",");
if(pel_modificada.getNombre_director().equals("")){
pel.deleteDirector();
}
if(pel_modificada.getActoresString().equals("")){
pel.deleteActores();
}
if(!(pel_modificada.getNombre_director().equals(""))&&!(pel_modificada.getActoresString().equals(""))){
List<Persona> resultsPer = (List<Persona>) qPer.execute();
for (Persona per : resultsPer) {
if ((pel_modificada.getNombre_director().substring(0, coma).equals(per.getApellido())) && (pel_modificada.getNombre_director().substring(coma+2).equals(per.getNombre()))){
pel.setDirector(per.getKey());
}
if ((pel_modificada.getActoresString().contains(per.getApellido()+ ", "+per.getNombre()))){
actores.add(per.getKey());
}
}
pel.setActores(actores);
}
} finally {
pm.close();
}
System.out.println(input == pel_modificada.getTitulo());
if (input == pel_modificada.getTitulo())
return "La pel�cula <b>" + input + "</b> se ha modificado correctamente.";
else
return "La pel�cula <b>" + input + "</b> se ha modificado por <b>" + pel_modificada.getTitulo() + "</b> correctamente.";
}
}
} finally {
q2.closeAll();
}
return "No se ha podido modificar la pel�cula <b>" + input + "</b>.";
}
} finally {
q.closeAll();
}
return "No se ha podido modificar la pel�cula <b>" + input + "</b> por <b>" + pel_modificada.getTitulo() + "</b>. <br />Debido a que ya hab�a una pel�cula llamada <b>" + pel_modificada.getTitulo() + "</b>.";
}
private void deletePeliculas() {
PersistenceManager pm = PMF.get().getPersistenceManager();
Query q = pm.newQuery(Pelicula.class);
try {
List<Pelicula> results = (List<Pelicula>) q.execute();
if (!results.isEmpty()) {
pm.deletePersistentAll(results);
}
} finally {
q.closeAll();
}
}
//---------------------------------FIN PELICULA---------------------------------------
private void listAllData(){
PersistenceManager pm = PMF.get().getPersistenceManager();
try {
List<Pelicula> a = (List<Pelicula>) pm.newQuery(Pelicula.class).execute();
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("PELICULAS");
for (Pelicula e : a) {
System.out.println("-----------------------------------------------------");
System.out.println("Key: "+e.getKey());
System.out.println("Titulo: "+e.getTitulo());
System.out.println("Titulo esp: "+e.getTitulo_espa�ol());
System.out.println("A�o: "+e.getAnio());
System.out.println("Actores: "+ e.getActores());
System.out.println("Director: " + e.getDirector());
System.out.println("Productora: " + e.getProductora().getKey());
System.out.println("Clasificaci�n: " + e.getClasificacion());
}
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("");
System.out.println("");
System.out.println("");
List<Clasificacion> b = (List<Clasificacion>) pm.newQuery(Clasificacion.class).execute();
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("CLASIFICACION");
for (Clasificacion e : b) {
System.out.println("-----------------------------------------------------");
System.out.println("Key: "+e.getKey());
System.out.println("Detalle: "+e.getDetalle());
}
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("");
System.out.println("");
System.out.println("");
List<Persona> r = (List<Persona>) pm.newQuery(Persona.class).execute();
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("PERSONA");
for (Persona e : r) {
System.out.println("-----------------------------------------------------");
System.out.println("Key: "+e.getKey());
System.out.println("Apellido: "+e.getApellido());
System.out.println("Nombre: "+e.getNombre());
System.out.println("Nacionalidad: "+e.getNacionalidad());
}
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("");
System.out.println("");
System.out.println("");
List<Productora> d = (List<Productora>) pm.newQuery(Productora.class).execute();
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("PRODUCTORA");
for (Productora e : d) {
System.out.println("-----------------------------------------------------");
System.out.println("Key: "+e.getKey());
System.out.println("Nombre: "+e.getNombre());
System.out.println("Pais: "+e.getPais());
System.out.println("Direccion: "+e.getDireccion());
System.out.println("Telefono: "+e.getTelefono());
System.out.println("Desde: "+e.getDesde());
}
System.out.println("-----------------------------------------------------");
System.out.println("-----------------------------------------------------");
System.out.println("");
System.out.println("-----------------------------------------------------");
System.out.println("------------------FIN------LISTADO-------------------");
System.out.println("-----------------------------------------------------");
}
finally {
pm.close();
}
}
}