Delete/Backup/Restore usuarios

backend/matefun/src/main/java/edu/proygrado/dto/BackupAlumnoDTO.java

+package edu.proygrado.dto;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import edu.proygrado.modelo.Alumno;
+import edu.proygrado.modelo.Archivo;
+import edu.proygrado.modelo.Grupo;
+
+public class BackupAlumnoDTO extends BackupUsuarioDTO{
+	
+	List<ArchivoDTO> archivos;
+	List<ArchivoDTO> archivosCompartidos;
+
+	List<GrupoDTO> grupos;
+
+	public BackupAlumnoDTO() {
+	}
+
+	public BackupAlumnoDTO(Alumno alumno, List<Grupo> grupos) {
+		super(alumno);
+		
+		this.archivos = new ArrayList<>();
+
+		for (Archivo archivo : alumno.getArchivos()) {
+			this.archivos.add(new ArchivoDTO(archivo));
+		}
+		this.archivosCompartidos = new ArrayList<>();
+
+		for (Archivo archivo : alumno.getArchivosCompartidos()) {
+			this.archivosCompartidos.add(new ArchivoDTO(archivo));
+		}
+
+		this.grupos = new ArrayList<>();
+		for (Grupo grupo : grupos) {
+			GrupoDTO grupoDTO = new GrupoDTO();
+			grupoDTO.setAnio(grupo.getGrupoPK().getAnio());
+			grupoDTO.setGrado(grupo.getGrupoPK().getGrado());
+			grupoDTO.setGrupo(grupo.getGrupoPK().getGrupo());
+			grupoDTO.setLiceoId(grupo.getGrupoPK().getLiceo().getLiceoId());
+			this.grupos.add(grupoDTO);
+		}
+	}
+
+	public List<ArchivoDTO> getArchivos() {
+		return archivos;
+	}
+
+	public void setArchivos(List<ArchivoDTO> archivos) {
+		this.archivos = archivos;
+	}
+
+	public List<ArchivoDTO> getArchivosCompartidos() {
+		return archivosCompartidos;
+	}
+
+	public void setArchivosCompartidos(List<ArchivoDTO> archivosCompartidos) {
+		this.archivosCompartidos = archivosCompartidos;
+	}
+
+	public List<GrupoDTO> getGrupos() {
+		return grupos;
+	}
+
+	public void setGrupos(List<GrupoDTO> grupos) {
+		this.grupos = grupos;
+	}
+	
+}

backend/matefun/src/main/java/edu/proygrado/dto/BackupDocenteDTO.java

+package edu.proygrado.dto;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import edu.proygrado.modelo.Archivo;
+import edu.proygrado.modelo.Docente;
+import edu.proygrado.modelo.Grupo;
+
+public class BackupDocenteDTO extends BackupUsuarioDTO{
+	
+	List<GrupoDTO> gruposAsignados;
+	List<ArchivoDTO> archivos;
+	
+	public BackupDocenteDTO(){}
+	
+	public BackupDocenteDTO(Docente docente){
+		super(docente);
+		
+		this.gruposAsignados = new ArrayList<>();
+		for(Grupo grupo: docente.getGruposAsignados()){
+			GrupoDTO grupoDTO = new GrupoDTO();
+			grupoDTO.setAnio(grupo.getGrupoPK().getAnio());
+			grupoDTO.setGrado(grupo.getGrupoPK().getGrado());
+			grupoDTO.setGrupo(grupo.getGrupoPK().getGrupo());
+			grupoDTO.setLiceoId(grupo.getGrupoPK().getLiceo().getLiceoId());
+			this.gruposAsignados.add(grupoDTO);			
+		}
+		this.archivos = new ArrayList<>();
+		for(Archivo archivo: docente.getArchivos()){
+			this.archivos.add(new ArchivoDTO(archivo));
+		}
+	}
+
+	public List<GrupoDTO> getGruposAsignados() {
+		return gruposAsignados;
+	}
+
+	public void setGruposAsignados(List<GrupoDTO> gruposAsignados) {
+		this.gruposAsignados = gruposAsignados;
+	}
+
+	public List<ArchivoDTO> getArchivos() {
+		return archivos;
+	}
+
+	public void setArchivos(List<ArchivoDTO> archivos) {
+		this.archivos = archivos;
+	}
+	
+}

backend/matefun/src/main/java/edu/proygrado/dto/BackupUsuarioDTO.java

+package edu.proygrado.dto;
+
+import edu.proygrado.modelo.Alumno;
+import edu.proygrado.modelo.Usuario;
+
+public class BackupUsuarioDTO {
+	String rol;
+	String cedula;
+	String nombre;
+	String apellido;
+	String password;
+	ConfiguracionDTO configuracion;
+	
+	public BackupUsuarioDTO(){}
+	
+	public BackupUsuarioDTO(Usuario usuario){
+		if (usuario instanceof Alumno) {
+			this.rol = "Alumno";
+		}else{
+			this.rol = "Docente";
+		}
+		this.cedula = usuario.getCedula();
+		this.nombre = usuario.getNombre();
+		this.apellido = usuario.getApellido();
+		this.password = usuario.getPassword();
+		this.configuracion = new ConfiguracionDTO(usuario.getConfiguracion());
+	}
+
+	public String getRol() {
+		return rol;
+	}
+
+	public void setRol(String rol) {
+		this.rol = rol;
+	}
+
+	public String getCedula() {
+		return cedula;
+	}
+
+	public void setCedula(String cedula) {
+		this.cedula = cedula;
+	}
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public String getApellido() {
+		return apellido;
+	}
+
+	public void setApellido(String apellido) {
+		this.apellido = apellido;
+	}
+
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	public ConfiguracionDTO getConfiguracion() {
+		return configuracion;
+	}
+
+	public void setConfiguracion(ConfiguracionDTO configuracion) {
+		this.configuracion = configuracion;
+	}
+	
+	
+}

backend/matefun/src/main/java/edu/proygrado/ejb/UsuarioEJB.java

 package edu.proygrado.ejb;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import javax.ejb.Stateless;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 
+import edu.proygrado.dto.ArchivoDTO;
+import edu.proygrado.dto.BackupAlumnoDTO;
+import edu.proygrado.dto.BackupDocenteDTO;
+import edu.proygrado.dto.BackupUsuarioDTO;
 import edu.proygrado.dto.ConfiguracionDTO;
+import edu.proygrado.dto.EvaluacionDTO;
+import edu.proygrado.dto.GrupoDTO;
+import edu.proygrado.matefun.MatefunException;
+import edu.proygrado.modelo.Alumno;
+import edu.proygrado.modelo.Archivo;
 import edu.proygrado.modelo.Configuracion;
+import edu.proygrado.modelo.Docente;
+import edu.proygrado.modelo.EstadoArchivo;
+import edu.proygrado.modelo.Evaluacion;
+import edu.proygrado.modelo.Grupo;
+import edu.proygrado.modelo.GrupoPK;
+import edu.proygrado.modelo.LiceoPK;
 import edu.proygrado.modelo.Usuario;
 
 @Stateless
@@ -53,5 +71,312 @@ public class UsuarioEJB {
         }
         
 	}
+	
+	public BackupUsuarioDTO respaldarUsuario(String cedula) throws MatefunException{
+		Usuario usuario = em.find(Usuario.class, cedula);
+		if(usuario == null){
+			throw new MatefunException("No existe el usuario con cedula "+cedula);
+		}
+		if(usuario instanceof Alumno){
+			List<Grupo> grupos = em.createQuery("select g from Grupo g where exists (select al from g.alumnos al where al.cedula =:cedula )", Grupo.class)
+					.setParameter("cedula", cedula)
+					.getResultList();
+			return new BackupAlumnoDTO((Alumno) usuario,grupos);
+		}else{
+			return new BackupDocenteDTO((Docente) usuario);
+		}
+	}
+	
+	public String restaurarAlumno(BackupAlumnoDTO backupAlumnoDTO) throws MatefunException {
+		Usuario usuario = em.find(Usuario.class, backupAlumnoDTO.getCedula());
+		if(usuario!=null){
+			throw new MatefunException("Ya existe el usuario de cedula "+backupAlumnoDTO.getCedula());
+		}
+		Alumno alumno = new Alumno();
+		alumno.setCedula(backupAlumnoDTO.getCedula());
+		alumno.setNombre(backupAlumnoDTO.getNombre());
+		alumno.setApellido(backupAlumnoDTO.getApellido());
+		alumno.setPassword(backupAlumnoDTO.getPassword());
+		alumno.setArchivos(new ArrayList<>());
+		alumno.setArchivosCompartidos(new ArrayList<>());
+		Configuracion config = new Configuracion(backupAlumnoDTO.getConfiguracion());
+		em.persist(config);
+		alumno.setConfiguracion(config);
+		if(backupAlumnoDTO.getGrupos()!=null){
+			for(GrupoDTO grupoDTO: backupAlumnoDTO.getGrupos()){
+				LiceoPK lpk = new LiceoPK(grupoDTO.getLiceoId());
+				GrupoPK gpk = new GrupoPK(grupoDTO.getAnio(), grupoDTO.getGrado(), grupoDTO.getGrupo(), lpk);
+				Grupo grupo = em.find(Grupo.class, gpk);
+				grupo.addAlumno(alumno);
+			}
+		}
+		if(backupAlumnoDTO.getArchivos()!=null){
+			Archivo root = null;
+			for(ArchivoDTO archivoDTO : backupAlumnoDTO.getArchivos()){
+				Archivo archivo = new Archivo();
+				archivo.setArchivoOrigen(null);
+				archivo.setContenido(archivoDTO.getContenido());
+				archivo.setDirectorio(archivoDTO.isDirectorio());
+				archivo.setEditable(archivoDTO.isEditable());
+				archivo.setEliminado(archivoDTO.isEliminado());
+				archivo.setEstado(EstadoArchivo.valueOf(archivoDTO.getEstado()));
+				archivo.setFechaCreacion(archivoDTO.getFechaCreacion());
+				archivo.setNombre(archivoDTO.getNombre());
+				archivo.setCreador(alumno);
+				if(archivoDTO.getEvaluacion()!=null){
+					EvaluacionDTO evalDTO = archivoDTO.getEvaluacion();
+					Docente docente = em.find(Docente.class, evalDTO.getCedulaDocente());
+					if(docente!=null){
+						Evaluacion eval = new Evaluacion();
+						eval.setDescripcion(evalDTO.getDescripcion());
+						eval.setFecha(evalDTO.getFecha());
+						eval.setNota(evalDTO.getNota());
+						eval.setDocente(docente);
+						archivo.setEvaluacion(eval);
+					}
+				}
+				if(archivoDTO.getPadreId() == -1){
+					root = archivo;
+					root.setPadre(null);
+				}
+				alumno.addArchivo(archivo);
+			}
+			for(Archivo archivo : alumno.getArchivos()){
+				if(archivo != root){
+					archivo.setPadre(root);
+				}
+				em.persist(archivo);
+			}
+		}
+		if(backupAlumnoDTO.getArchivosCompartidos()!=null){
+			for(ArchivoDTO archivoDTO : backupAlumnoDTO.getArchivosCompartidos()){
+				Archivo archivo = new Archivo();
+				Archivo origen = em.find(Archivo.class, archivoDTO.getId());
+				archivo.setArchivoOrigen(origen);
+				archivo.setContenido(archivoDTO.getContenido());
+				archivo.setDirectorio(archivoDTO.isDirectorio());
+				archivo.setEditable(archivoDTO.isEditable());
+				archivo.setEliminado(archivoDTO.isEliminado());
+				archivo.setEstado(EstadoArchivo.valueOf(archivoDTO.getEstado()));
+				archivo.setFechaCreacion(archivoDTO.getFechaCreacion());
+				archivo.setNombre(archivoDTO.getNombre());
+				if(origen!=null){
+					Docente creador = em.find(Docente.class, archivoDTO.getCedulaCreador());
+					if(creador!=null){
+						archivo.setCreador(creador);
+					}else{
+						archivo.setCreador(alumno);
+					}
+				}
+				if(archivoDTO.getEvaluacion()!=null){
+					EvaluacionDTO evalDTO = archivoDTO.getEvaluacion();
+					Docente docente = em.find(Docente.class, evalDTO.getCedulaDocente());
+					if(docente!=null){
+						Evaluacion eval = new Evaluacion();
+						eval.setDescripcion(evalDTO.getDescripcion());
+						eval.setFecha(evalDTO.getFecha());
+						eval.setNota(evalDTO.getNota());
+						eval.setDocente(docente);
+						archivo.setEvaluacion(eval);
+						em.persist(eval);
+					}
+				}
+				archivo.setPadre(null);
+				//Si esta definido el archivo origen lo agrego a los compartidos
+				//sino se agrega a la lista de archivos del usuario. 
+				if(origen!=null){
+					alumno.addArchivoCompartido(archivo);
+				}else{
+					alumno.addArchivo(archivo);
+				}
+				em.persist(archivo);
+			}
+			
+		}
+		em.persist(alumno);
+		return "Alumno ingresado. ";
+	}	
+	
+	public String restaurarDocente(BackupDocenteDTO backupDocenteDTO) throws MatefunException {
+		Usuario usuario = em.find(Usuario.class, backupDocenteDTO.getCedula());
+		if(usuario!=null){
+			throw new MatefunException("Ya existe el usuario de cedula "+backupDocenteDTO.getCedula());
+		}
+		Docente docente = new Docente();
+		docente.setCedula(backupDocenteDTO.getCedula());
+		docente.setNombre(backupDocenteDTO.getNombre());
+		docente.setApellido(backupDocenteDTO.getApellido());
+		docente.setPassword(backupDocenteDTO.getPassword());
+		docente.setArchivos(new ArrayList<>());
+		docente.setGruposAsignados(new ArrayList<>());
+		Configuracion config = new Configuracion(backupDocenteDTO.getConfiguracion());
+		em.persist(config);
+		docente.setConfiguracion(config);
+		if(backupDocenteDTO.getGruposAsignados()!=null){
+			for(GrupoDTO grupoDTO: backupDocenteDTO.getGruposAsignados()){
+				LiceoPK lpk = new LiceoPK(grupoDTO.getLiceoId());
+				GrupoPK gpk = new GrupoPK(grupoDTO.getAnio(), grupoDTO.getGrado(), grupoDTO.getGrupo(), lpk);
+				Grupo grupo = em.find(Grupo.class, gpk);
+				docente.addGrupoAsignado(grupo);
+			}
+		}
+		if(backupDocenteDTO.getArchivos()!=null){
+			Archivo root = null;
+			for(ArchivoDTO archivoDTO : backupDocenteDTO.getArchivos()){
+				Archivo archivo = new Archivo();
+				archivo.setArchivoOrigen(null);
+				archivo.setContenido(archivoDTO.getContenido());
+				archivo.setDirectorio(archivoDTO.isDirectorio());
+				archivo.setEditable(archivoDTO.isEditable());
+				archivo.setEliminado(archivoDTO.isEliminado());
+				archivo.setEstado(EstadoArchivo.valueOf(archivoDTO.getEstado()));
+				archivo.setFechaCreacion(archivoDTO.getFechaCreacion());
+				archivo.setNombre(archivoDTO.getNombre());
+				archivo.setCreador(docente);
+				//No se deberia dar el caso. Se deja por completitud
+				if(archivoDTO.getEvaluacion()!=null){
+					EvaluacionDTO evalDTO = archivoDTO.getEvaluacion();
+					Docente evaluador = em.find(Docente.class, evalDTO.getCedulaDocente());
+					if(evaluador!=null){
+						Evaluacion eval = new Evaluacion();
+						eval.setDescripcion(evalDTO.getDescripcion());
+						eval.setFecha(evalDTO.getFecha());
+						eval.setNota(evalDTO.getNota());
+						eval.setDocente(evaluador);
+						archivo.setEvaluacion(eval);
+						em.persist(eval);
+					}
+				}
+				if(archivoDTO.getPadreId() == -1){
+					root = archivo;
+					root.setPadre(null);
+				}
+				docente.addArchivo(archivo);
+				em.persist(archivo);
+			}
+			for(Archivo archivo : docente.getArchivos()){
+				if(archivo != root){
+					archivo.setPadre(root);
+				}
+			}
+		}
+		em.persist(docente);
+		return "Docente ingresado. ";
+	}
+	
+	public String eliminarUsuario(String cedula) throws MatefunException {
+		Usuario usuario = em.find(Usuario.class, cedula);
+		if(usuario == null){
+			throw new MatefunException("No existe el usuario con cedula "+cedula);
+		}
+		if(usuario instanceof Alumno){
+			Alumno alumno = (Alumno) usuario;
+			List<Grupo> grupos = em.createQuery("select g from Grupo g where exists (select al from g.alumnos al where al.cedula =:cedula )", Grupo.class)
+					.setParameter("cedula", cedula)
+					.getResultList();
+			for(Grupo grupo : grupos){
+				grupo.getAlumnos().remove(alumno);
+				grupo.getArchivos().removeAll(alumno.getArchivos());				
+			}
+			System.out.println("Alumno");
+			for(Archivo archivo: alumno.getArchivos()){
+				System.out.println(archivo.getId());
+				Evaluacion eval = archivo.getEvaluacion();
+				if(eval!=null){
+					eval.setDocente(null);
+					em.remove(eval);
+				}
+				archivo.setArchivoOrigen(null);
+				archivo.setCreador(null);
+				archivo.setEvaluacion(null);
+				archivo.setPadre(null);
+				em.remove(archivo);
+			}
+			alumno.setArchivos(null);
+			System.out.println("Compartidos");
+			for(Archivo archivo: alumno.getArchivosCompartidos()){
+				System.out.println(archivo.getId());
+				Evaluacion eval = archivo.getEvaluacion();
+				if(eval!=null){
+					eval.setDocente(null);
+					em.remove(eval);
+				}
+				archivo.setArchivoOrigen(null);
+				archivo.setCreador(null);
+				archivo.setEvaluacion(null);
+				archivo.setPadre(null);
+				em.remove(archivo);
+			}
+			alumno.setArchivosCompartidos(null);
+			//Codigo para corregir bug de archivos creados por el alumno pero no referenciados en su lista de archivos.
+			List<Archivo> archivosNoReferenciados = em.createQuery("select a from Archivo a where a.creador.cedula = :cedula",Archivo.class)
+					.setParameter("cedula", cedula)
+					.getResultList();
+			for(Archivo archivo: archivosNoReferenciados){
+				System.out.println(archivo.getId());
+				Evaluacion eval = archivo.getEvaluacion();
+				if(eval!=null){
+					eval.setDocente(null);
+					em.remove(eval);
+				}
+				archivo.setArchivoOrigen(null);
+				archivo.setCreador(null);
+				archivo.setEvaluacion(null);
+				archivo.setPadre(null);
+				em.remove(archivo);
+			}
+			
+			em.remove(alumno);
+		}else{
+			Docente docente = (Docente) usuario;
+			
+			for(Archivo archivo: docente.getArchivos()){
+				archivo.setPadre(null);
+				List<Grupo> grupos = em.createQuery("select g from Grupo g where exists (select a from g.archivos a where a.id=:id)",Grupo.class)
+						.setParameter("id", archivo.getId())
+						.getResultList();
+				for(Grupo g : grupos){
+					g.getArchivos().remove(archivo);
+				}
+				
+				System.out.println("Archivo docente "+archivo.getId());
+				Evaluacion eval = archivo.getEvaluacion();
+				if(eval!=null){
+					eval.setDocente(null);
+					em.remove(eval);
+				}
+				//Lista de archivos que son copia del compartido por el docente. 
+				List<Archivo> archivos = em.createQuery("select a from Archivo a where a.archivoOrigen.id = :id", Archivo.class )
+						.setParameter("id", archivo.getId())
+						.getResultList();
+				for(Archivo copiaAlumno : archivos){
+					System.out.println("copia archivo "+copiaAlumno.getId());
+					List<Alumno> alumnos = em.createQuery("select a from Alumno a where exists (select ac from a.archivosCompartidos ac where ac.id = :id)",Alumno.class)
+							.setParameter("id", copiaAlumno.getId())
+							.getResultList();
+					
+					//Los archivos compartidos que tiene el alumno se mueven a su lista de archivos personales. 
+					for(Alumno alumno : alumnos){
+						alumno.getArchivosCompartidos().remove(copiaAlumno);
+						Archivo root = em.createQuery("select a from Archivo a where a.padre = null and a.creador.cedula=:cedula",Archivo.class)
+								.setParameter("cedula", alumno.getCedula())
+								.getSingleResult();
+						copiaAlumno.setPadre(root);
+						copiaAlumno.setCreador(alumno);
+						copiaAlumno.setEstado(EstadoArchivo.Edicion);
+						copiaAlumno.setArchivoOrigen(null);
+						alumno.addArchivo(copiaAlumno);
+					}					
+				}
+			}
+			
+			for(Archivo archivo:docente.getArchivos()){
+				em.remove(archivo);
+			}
+			em.remove(docente);
+		}
+		
+		return "Usuario y recursos eliminados";
+	}
 
 }

backend/matefun/src/main/java/edu/proygrado/servicios/usuario/UsuarioRS.java

@@ -3,13 +3,21 @@ package edu.proygrado.servicios.usuario;
 import javax.ejb.EJB;
 import javax.ejb.Stateless;
 import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
 import javax.ws.rs.PUT;
 import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
 import javax.ws.rs.Produces;
 import javax.ws.rs.core.MediaType;
 
+import edu.proygrado.dto.BackupAlumnoDTO;
+import edu.proygrado.dto.BackupDocenteDTO;
+import edu.proygrado.dto.BackupUsuarioDTO;
 import edu.proygrado.dto.ConfiguracionDTO;
 import edu.proygrado.ejb.UsuarioEJB;
+import edu.proygrado.matefun.MatefunException;
 
 @Stateless
 @Path("/usuario")
@@ -21,11 +29,41 @@ public class UsuarioRS {
 	@Path("{cedula}/configuracion")
     @Produces(MediaType.APPLICATION_JSON)
     @Consumes(MediaType.APPLICATION_JSON)
-    public ConfiguracionDTO actualizarConfiguracion(@javax.ws.rs.PathParam("cedula") String cedula, ConfiguracionDTO configuracion) throws Exception {
+    public ConfiguracionDTO actualizarConfiguracion(@PathParam("cedula") String cedula, ConfiguracionDTO configuracion) throws Exception {
         if(cedula.toLowerCase().equals("invitado")){
         	return configuracion;
         }else{
         	return usuarioEJB.actualizarConfiguracion(cedula,configuracion);
         }
     }
+	
+	@GET
+	@Path("{cedula}/backup")
+	@Produces(MediaType.APPLICATION_JSON)
+	public BackupUsuarioDTO backupUsuario(@PathParam("cedula") String cedula) throws MatefunException{
+		return usuarioEJB.respaldarUsuario(cedula);
+	}
+	
+	@POST
+	@Path("alumno/restore")
+	@Consumes(MediaType.APPLICATION_JSON)
+	@Produces(MediaType.APPLICATION_JSON)
+	public String restaurarAlumno(BackupAlumnoDTO backupAlumnoDTO) throws MatefunException{
+		return usuarioEJB.restaurarAlumno(backupAlumnoDTO);
+	}
+	
+	@POST
+	@Path("docente/restore")
+	@Consumes(MediaType.APPLICATION_JSON)
+	@Produces(MediaType.APPLICATION_JSON)
+	public String restaurarDocente(BackupDocenteDTO backupDocenteDTO) throws MatefunException{
+		return usuarioEJB.restaurarDocente(backupDocenteDTO);
+	}
+	
+	@DELETE
+	@Path("{cedula}")
+	@Produces(MediaType.TEXT_PLAIN)
+	public String eliminarUsuario(@PathParam("cedula") String cedula) throws MatefunException {
+		return usuarioEJB.eliminarUsuario(cedula);
+	}
 }