Skip to content

Instantly share code, notes, and snippets.

@MartinAngeloni

MartinAngeloni/ABM.java

Last active September 8, 2021 20:52
Show Gist options
  • Save MartinAngeloni/43d71f9dd23ea71f9b8e6fefaa2061eb to your computer and use it in GitHub Desktop.
Save MartinAngeloni/43d71f9dd23ea71f9b8e6fefaa2061eb to your computer and use it in GitHub Desktop.
Download ZIP
Simulando Sistema de Gestión de alumnos de una universidad en Java utilizando Spring Boot
Raw
ABM.java
import static com.sysacad.repositorios.CarreraRepositorio.repositorioCarrera;
import static com.sysacad.repositorios.MateriaRepositorio.repositorioMateria;
import static com.sysacad.repositorios.PersonaRepositorio.repositorioPersona;
/**
* Created by martin on 8/7/2017.
*/
public class ABM {
//a partir de aqui: ALUMNO
//alta de alumno
public static void altaAlumno(Alumno alumnoNuevo){
repositorioPersona.add(alumnoNuevo);
}
//actualiza un alumno en repositorio
public static void modificarAlumno(Alumno alumnoEliminar, Alumno alumnoNuevo){
alumnoNuevo.setLegajo(alumnoEliminar.getLegajo());//conservamos el mismo legajo
repositorioPersona.remove(alumnoEliminar);//eliminamos alumno encontrado
repositorioPersona.add(alumnoNuevo); //aniadimos el alumno simulando actualizacion
}
//baja de alumno
public static void bajaAlumno(Alumno alumnoEliminar){
repositorioPersona.remove(alumnoEliminar);//eliminamos alumno
}
//a partir de aqui: CARRERA
//alta de carrera
public static void altaCarrera(Carrera carrera){
repositorioCarrera.add(carrera);
}
//modificacion carrera
public static void modificarCarrera(Carrera carreraEliminar, Carrera carreraNueva){
carreraNueva.setId(carreraEliminar.getId());//conservamos el mismo id
repositorioCarrera.remove(carreraEliminar);//eliminamos carrera
repositorioCarrera.add(carreraNueva); //aniadimos carrera simulando actualizacion
}
//baja carrera
public static void bajaCarrera(Carrera carrera){
repositorioCarrera.remove(carrera);//eliminamos carrera
}
//a partir de aqui: MATERIAS
public static void altaMateria(Materia materia){
repositorioMateria.add(materia);
}
//actualizamos Materia
public static void modificarMateria(Materia materiaEliminar, Materia materiaNueva){
materiaNueva.setId(materiaEliminar.getId());//conservamos el mismo id
repositorioMateria.remove(materiaEliminar);//eliminamos materia
repositorioMateria.add(materiaNueva); //aniadimos materia simulando actualizacion
}
//baja materia
public static void bajaMateria(Materia materia){
repositorioMateria.remove(materia);//eliminamos materia
}
}
Raw
Administrador.java
public class Administrador extends Persona {
public Administrador(){
}
public Administrador(int legajo, String contrasenia){
this.legajo = legajo;
this.contrasenia = contrasenia;
}
@Override
public boolean equals(Object o){
if(o instanceof Administrador && this.getLegajo() == ((Administrador) o).getLegajo()){
return true;
}
return false;
}
}
Raw
Alumno.java
import java.util.HashMap;
import java.util.Map;
public class Alumno extends Persona {
private Carrera carrera;
private Estado estado;
private Map<Integer, Materia> listaMateriasCursando;
private Map<Integer, Materia> listaMateriasRegular;
private Map<Integer, Materia> listaMateriasAprobadas;
private Map<Integer, Materia> listaMateriasRendirFinal;
public Alumno(){
this.listaMateriasAprobadas = new HashMap<>();
this.listaMateriasCursando = new HashMap<>();
this.listaMateriasRegular = new HashMap<>();
this.listaMateriasRendirFinal = new HashMap<>();
this.estado = Estado.regular; //por defecto
}
public Alumno(String nombre, String apellido, int legajo, String contrasenia){
this.nombre = nombre;
this.apellido = apellido;
this.legajo = legajo;
this.contrasenia = contrasenia;
this.listaMateriasAprobadas = new HashMap<>();
this.listaMateriasCursando = new HashMap<>();
this.listaMateriasRegular = new HashMap<>();
this.listaMateriasRendirFinal = new HashMap<>();
}
public Carrera getCarrera() {
return carrera;
}
public void setCarrera(Carrera carrera) {
this.carrera = carrera;
}
public Estado getEstado() {
return estado;
}
public void setEstado(Estado estado) {
this.estado = estado;
}
public Map<Integer, Materia> getListaMateriasCursando() {
return listaMateriasCursando;
}
public void setListaMateriasCursando(Map<Integer, Materia> listaMateriasCursando) {
this.listaMateriasCursando = listaMateriasCursando;
}
public Map<Integer, Materia> getListaMateriasRegular() {
return listaMateriasRegular;
}
public void setListaMateriasRegular(Map<Integer, Materia> listaMateriasRegular) {
this.listaMateriasRegular = listaMateriasRegular;
}
public Map<Integer, Materia> getListaMateriasAprobadas() {
return listaMateriasAprobadas;
}
public void setListaMateriasAprobadas(Map<Integer, Materia> listaMateriasAprobadas) {
this.listaMateriasAprobadas = listaMateriasAprobadas;
}
public Map<Integer, Materia> getListaMateriasRendirFinal() {
return listaMateriasRendirFinal;
}
public void setListaMateriasRendirFinal(Map<Integer, Materia> listaMateriasRendirFinal) {
this.listaMateriasRendirFinal = listaMateriasRendirFinal;
}
@Override
public boolean equals(Object o){
if(o instanceof Alumno && ((Alumno) o).getLegajo() == this.legajo){
return true;
}
return false;
}
}
Raw
AlumnoController.java
import com.sysacad.model.*;
import com.sysacad.service.*;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.persistence.EntityNotFoundException;
import java.util.List;
import java.util.Map;
import static com.sysacad.repositorios.PersonaRepositorio.repositorioPersona;
/**
* Created by martin on 20/4/2017.
*/
@RestController
public class AlumnoController {
@PostMapping("/alumno")
ResponseEntity<Alumno> crearAlumno(@RequestBody Alumno alumno,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
repositorioPersona.add(alumno);
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(alumno);
}
@GetMapping("/alumno/{legajo}")
ResponseEntity<Alumno> obtenerAlumno(@PathVariable int legajo,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Alumno alumnoEncontrado = null;
try {
if (Login.validarUsuario(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajo);
if(alumnoEncontrado != null){
return ResponseEntity.ok(alumnoEncontrado);
}else throw new EntityNotFoundException();
} else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@PutMapping("/alumno/{legajo}")
ResponseEntity<Alumno> actualizarAlumno(@RequestBody Alumno alumno,
@PathVariable int legajo,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajo); //buscamos alumno en repositorio
if (alumnoEncontrado != null) {
ABM.modificarAlumno(alumnoEncontrado, alumno);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
return ResponseEntity.ok().body(alumno);
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/alumno/{legajo}")
ResponseEntity<Persona> eliminarAlumno(@PathVariable int legajo,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Alumno alumnoEliminar = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEliminar = Busqueda.encontrarAlumno(legajo);
if (alumnoEliminar != null) {
ABM.bajaAlumno(alumnoEliminar);
return ResponseEntity.ok().body(alumnoEliminar);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@GetMapping("/alumno/listado")
ResponseEntity<List<Alumno>> listarAlumnos(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
List<Alumno> listaAlumnos;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
listaAlumnos = Busqueda.listaAlumnos();
if (listaAlumnos != null) {
return ResponseEntity.ok(listaAlumnos);
} else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@PutMapping("/alumno/{legajoAlumno}/asignar/regularidad") //admin asigna una materia regular al alumno
ResponseEntity<Materia> asignarMateriaRegular(@PathVariable int legajoAlumno,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Materia materiaAsignar = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaAsignar = Busqueda.materiaCursando(alumnoEncontrado, idMateria);
if (materiaAsignar != null && alumnoEncontrado != null) {
alumnoEncontrado.getListaMateriasCursando().remove(idMateria); //quitamos el cursado de la materia
alumnoEncontrado.getListaMateriasRegular().put(idMateria, materiaAsignar); //ahora la tiene ne regular
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new EntityNotFoundException();
}
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaAsignar);
}
//obtener lista de materias regular del alumno
@GetMapping("/alumno/listado/materias/regular")
ResponseEntity<Map<Integer, Materia>> listarMateriasRegular(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
try {
if (Login.validarAlumno(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.listaMateriasRegular(legajoUsuario));
} else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/alumno/{legajoAlumno}/eliminar/regular") //admin asigna una materia aprobada al alumno
ResponseEntity<Materia> eliminarMateriaRegular(@PathVariable int legajoAlumno,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Materia materiaEliminar = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaEliminar = Busqueda.materiaRegular(alumnoEncontrado, idMateria);
if (materiaEliminar != null && alumnoEncontrado != null) {
alumnoEncontrado.getListaMateriasRegular().remove(idMateria); //quitamos el cursado de la materia
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaEliminar);
}
@PutMapping("/alumno/{legajoAlumno}/asignar/aprobada") //admin asigna una materia aprobada al alumno
ResponseEntity<Materia> asignarMateriaAprobada(@PathVariable int legajoAlumno,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Materia materiaAsignar = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaAsignar = Busqueda.materiaRegular(alumnoEncontrado, idMateria);
if (materiaAsignar != null && alumnoEncontrado != null) {
alumnoEncontrado.getListaMateriasRegular().remove(idMateria); //quitamos el cursado de la materia
alumnoEncontrado.getListaMateriasAprobadas().put(idMateria, materiaAsignar); //ahora la tiene ne regular
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new EntityNotFoundException();
}
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaAsignar);
}
//obtener lista de materias aprobadas del alumno
@GetMapping("/alumno/listado/materias/aprobadas")
ResponseEntity<Map<Integer, Materia>> listarMateriasAprobadas(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
try {
if (Login.validarAlumno(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.listaMateriasAprobadas(legajoUsuario));
} else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/alumno/{legajoAlumno}/eliminar/aprobada") //admin asigna una materia aprobada al alumno
ResponseEntity<Materia> eliminarMateriaAprobada(@PathVariable int legajoAlumno,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Materia materiaEliminar = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaEliminar = Busqueda.materiaAprobada(alumnoEncontrado, idMateria);
if (materiaEliminar != null && alumnoEncontrado != null) {
alumnoEncontrado.getListaMateriasAprobadas().remove(idMateria); //quitamos el cursado de la materia
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new Exception();
}else throw new Exception();
}catch (Exception e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaEliminar);
}
@PutMapping("/alumno/inscribirse/cursado/{idMateria}")
ResponseEntity<Materia> inscribirseACursado(@PathVariable int idMateria,
@RequestHeader int legajoAlumno,
@RequestHeader String contrasenia) throws Exception{
Carrera carreraDeAlumno = null;
Materia materiaInscribirse = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAlumno(legajoAlumno, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
carreraDeAlumno = alumnoEncontrado.getCarrera();
if (carreraDeAlumno.getListaMaterias() != null && carreraDeAlumno.getListaMaterias().containsKey(idMateria)) {
materiaInscribirse = carreraDeAlumno.getListaMaterias().get(idMateria);
}
if (materiaInscribirse != null) {
if (Inscripcion.cursado(alumnoEncontrado, materiaInscribirse)) {
alumnoEncontrado.getListaMateriasCursando().put(materiaInscribirse.getId(), materiaInscribirse); //asignamos a su lista de regulares
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new Exception(); //para capturar un badrequest
} else throw new EntityNotFoundException(); //arrojamos una excepcion para json
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build(); //capturamos y mandamos un not found a json
}
catch (Exception e){
return ResponseEntity.badRequest().build(); //para informar que no es posible inscribir
}
return ResponseEntity.ok(materiaInscribirse);
}
//obtener lista de materias cursando del alumno
@GetMapping("/alumno/listado/materias/cursando")
ResponseEntity<Map<Integer, Materia>> listarMateriasCursando(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
try {
if (Login.validarAlumno(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.listaMateriasCursando(legajoUsuario));
} else throw new Exception();
}catch (Exception e){
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/alumno/eliminar/cursando/{legajoAlumno}") //admin asigna una materia aprobada al alumno
ResponseEntity<Materia> eliminarMateriaCursando(@PathVariable int legajoAlumno,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Materia materiaEliminar = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaEliminar = Busqueda.materiaCursando(alumnoEncontrado, idMateria);
if (materiaEliminar != null && alumnoEncontrado != null) {
alumnoEncontrado.getListaMateriasCursando().remove(idMateria); //quitamos el cursado de la materia
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new Exception();
}else throw new Exception();
}catch (Exception e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaEliminar);
}
@PutMapping("/alumno/inscribirse/final/{idMateria}")
ResponseEntity<Materia> inscribirseAFinal(@PathVariable int idMateria,
@RequestHeader int legajoAlumno,
@RequestHeader String contrasenia) throws Exception{
Materia materiaInscribirse = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAlumno(legajoAlumno, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaInscribirse = Busqueda.materiaRegular(alumnoEncontrado, idMateria);
if (materiaInscribirse != null) {
if (Inscripcion.inscribirseFinal(alumnoEncontrado, materiaInscribirse)) {
alumnoEncontrado.getListaMateriasRendirFinal().put(materiaInscribirse.getId(), materiaInscribirse); //asignamos a su lista de regulares
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new Exception(); //para capturar un badrequest
} else throw new EntityNotFoundException(); //arrojamos una excepcion para json
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build(); //capturamos y mandamos un not found a json
}
catch (Exception e){
return ResponseEntity.badRequest().build(); //para informar que no es posible inscribir
}
return ResponseEntity.ok(materiaInscribirse);
}
//obtener lista de materias cursando del alumno
@GetMapping("/alumno/listado/materias/final")
ResponseEntity<Map<Integer, Materia>> listarMateriasARendirFinal(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Alumno alumno = null;
try {
if (Login.validarAlumno(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.listaMateriasFinal(legajoUsuario));
} else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/alumno/eliminar/final/{legajoAlumno}") //admin asigna una materia aprobada al alumno
ResponseEntity<Materia> eliminarMateriaFinal(@PathVariable int legajoAlumno,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
Materia materiaEliminar = null;
Alumno alumnoEncontrado = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaEliminar = Busqueda.materiaFinal(alumnoEncontrado, idMateria);
if (materiaEliminar != null && alumnoEncontrado != null) {
alumnoEncontrado.getListaMateriasRendirFinal().remove(idMateria); //borramos la materia
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaEliminar);
}
//insertamos un examen con su nota en la materia del alumno
@PutMapping("alumno/{legajoAlumno}/asignar/examen/parcial")
ResponseEntity<Examen> asignarExamenParcial (@PathVariable int legajoAlumno,
@RequestBody Examen examen,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
Alumno alumnoEncontrado = null;
Materia materiaCursando = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaCursando = Busqueda.materiaCursando(alumnoEncontrado, idMateria);
if (alumnoEncontrado != null && materiaCursando != null) {
if(Verificacion.examenParcial(examen)){
alumnoEncontrado.getListaMateriasCursando().get(idMateria).getListaExamenes().add(examen);
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new Exception();
} else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
catch (Exception e){
return ResponseEntity.badRequest().build();//si el examen no coincide con el estado de la materia
}
return ResponseEntity.ok(examen);
}
@PutMapping("alumno/asignar/examen/final/{legajoAlumno}")
ResponseEntity<Examen> asignarExamenFinal(@PathVariable int legajoAlumno,
@RequestBody Examen examen,
@RequestHeader int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
Alumno alumnoEncontrado = null;
Materia materiaAprobada = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
materiaAprobada = Busqueda.materiaAprobada(alumnoEncontrado, idMateria);
if (alumnoEncontrado != null && materiaAprobada != null) {
System.out.println("ni el alumno ni la materia son nulos");
if(Verificacion.examenFinal(examen)){
System.out.println("el examen es correcto");
alumnoEncontrado.getListaMateriasAprobadas().get(idMateria).getListaExamenes().add(examen);
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
}else throw new Exception();
} else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
catch (Exception e){
return ResponseEntity.badRequest().build(); //si el examen no coincide con el estado de la materia
}
return ResponseEntity.ok(examen);
}
}
Raw
Busqueda.java
import com.sysacad.model.Alumno;
import com.sysacad.model.Carrera;
import com.sysacad.model.Materia;
import com.sysacad.model.Persona;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.sysacad.repositorios.CarreraRepositorio.repositorioCarrera;
import static com.sysacad.repositorios.MateriaRepositorio.repositorioMateria;
import static com.sysacad.repositorios.PersonaRepositorio.repositorioPersona;
/**
* Created by martin on 8/7/2017.
*/
public class Busqueda {
public static Alumno encontrarAlumno(int legajoAlumno){
Alumno alumno = null;
for(Persona p: repositorioPersona){
if(p.getLegajo() == legajoAlumno && p instanceof Alumno){
return (Alumno) p;
}
}
return alumno;
}
public static List<Alumno> listaAlumnos(){
List<Alumno> lista = new ArrayList<>();
for(Persona p: repositorioPersona){
if(p instanceof Alumno){
lista.add((Alumno) p);
}
}
return lista;
}
//buscamos una materia cursando del alumno
public static Materia materiaCursando(Alumno alumno, Integer idMateria){
Materia materiaCursando = null;
if(alumno != null && alumno.getListaMateriasCursando().containsKey(idMateria)){
materiaCursando = alumno.getListaMateriasCursando().get(idMateria);
}
return materiaCursando;
}
//lista de materias cursando del alumno
public static Map<Integer, Materia> listaMateriasCursando(int legajoAlumno){
Map<Integer, Materia> listaMateriasCursando = new HashMap<>();
for(Persona p: repositorioPersona){
if( p.getLegajo() == legajoAlumno && p instanceof Alumno){
listaMateriasCursando = ((Alumno) p).getListaMateriasCursando();
}
}
return listaMateriasCursando;
}
//lista de materias regular del alumno
public static Map<Integer, Materia> listaMateriasRegular(int legajoAlumno){
Map<Integer, Materia> listaMateriasRegular = new HashMap<>();
for(Persona p: repositorioPersona){
if( p.getLegajo() == legajoAlumno && p instanceof Alumno){
listaMateriasRegular = ((Alumno) p).getListaMateriasRegular();
}
}
return listaMateriasRegular;
}
//buscamos una materia regular del alumno
public static Materia materiaRegular(Alumno alumno, Integer idMateria){
Materia materiaRegular = null;
if(alumno != null && alumno.getListaMateriasRegular().containsKey(idMateria)){
materiaRegular = alumno.getListaMateriasRegular().get(idMateria);
}
return materiaRegular;
}
//lista de materias aprobadas del alumno
public static Map<Integer, Materia> listaMateriasAprobadas(int legajoAlumno){
Map<Integer, Materia> listaMateriasAprobadas = new HashMap<>();
for(Persona p: repositorioPersona){
if( p.getLegajo() == legajoAlumno && p instanceof Alumno){
listaMateriasAprobadas = ((Alumno) p).getListaMateriasAprobadas();
}
}
return listaMateriasAprobadas;
}
//buscamos una materia aprobada del alumno
public static Materia materiaAprobada(Alumno alumno, Integer idMateria){
Materia materiaAprobada = null;
if(alumno != null && alumno.getListaMateriasAprobadas().containsKey(idMateria)){
materiaAprobada = alumno.getListaMateriasAprobadas().get(idMateria);
}
return materiaAprobada;
}
//lista de materias por rendir final del alumno
public static Map<Integer, Materia> listaMateriasFinal(int legajoAlumno){
Map<Integer, Materia> listaMateriasFinal = new HashMap<>();
for(Persona p: repositorioPersona){
if( p.getLegajo() == legajoAlumno && p instanceof Alumno){
listaMateriasFinal = ((Alumno) p).getListaMateriasRendirFinal();
}
}
return listaMateriasFinal;
}
//buscamos una materia por rendir final del alumno
public static Materia materiaFinal(Alumno alumno, Integer idMateria){
Materia materiaFinal = null;
if(alumno != null && alumno.getListaMateriasRendirFinal().containsKey(idMateria)){
materiaFinal = alumno.getListaMateriasRendirFinal().get(idMateria);
}
return materiaFinal;
}
//a partir de aqui: Carrera
//alta carrera
public static Carrera encontrarCarrera(int idCarrera){
Carrera carrera = null;
for(Carrera c: repositorioCarrera){
if(c.getId() == idCarrera){
carrera = c;
}
}
return carrera;
}
public static Map<Integer, Materia> carreraListaMaterias(int idCarrera){
Map<Integer, Materia> listaMaterias = new HashMap<>();
for(Carrera c: repositorioCarrera){
if(c.getId() == idCarrera){
listaMaterias = c.getListaMaterias();
}
}
return listaMaterias;
}
public static Map<Integer, Alumno> carreraListaAlumnos(int idCarrera){
Map<Integer, Alumno> listaAlumnos = new HashMap<>();
for(Carrera c: repositorioCarrera){
if(c.getId() == idCarrera){
if(!c.getListaAlumnos().isEmpty()) {
listaAlumnos = c.getListaAlumnos();
}
}
}
return listaAlumnos;
}
public static List<Carrera> listaCarreras(){
List<Carrera> listaCarreras = new ArrayList<>();
for(Carrera c: repositorioCarrera){
listaCarreras.add(c);
}
return listaCarreras;
}
//a partir de aqui: MATERIA
public static Materia encontrarMateria(int idMateria){
Materia materia = null;
for(Materia m: repositorioMateria){
if(m.getId() == idMateria){
materia = m;
}
}
return materia;
}
public static ArrayList<Materia> listaMaterias(){
ArrayList<Materia> listaMaterias = new ArrayList<>();
for(Materia m: repositorioMateria){
listaMaterias.add(m);
}
return listaMaterias;
}
}
Raw
Carrera.java
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.HashMap;
import java.util.Map;
public class Carrera {
private static int id_increment = 1;
private int id;
private String nombre;
private Map<Integer, Materia> listaMaterias;
@JsonIgnore
private Map<Integer, Alumno> listaAlumnos;
public Carrera(){
this.listaMaterias = new HashMap<>();
this.listaAlumnos = new HashMap<>();
id = id_increment;
id_increment++;
}
public Carrera(String nombre, int id){
this.nombre = nombre;
this.listaMaterias = new HashMap<>();
this.listaAlumnos = new HashMap<>();
this.id = id;
}
public Map<Integer, Materia> getListaMaterias() {
return listaMaterias;
}
public void setListaMaterias(Map<Integer, Materia> listaMaterias) {
this.listaMaterias = listaMaterias;
}
public Map<Integer, Alumno> getListaAlumnos() {
return listaAlumnos;
}
public void setListaAlumnos(Map<Integer, Alumno> listaAlumnos) {
this.listaAlumnos = listaAlumnos;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
@Override
public boolean equals(Object o){
if(o instanceof Carrera && this.getId() == ((Carrera) o).getId()){
return true;
}
return false;
}
}
Raw
CarreraController.java
import com.sysacad.model.*;
import com.sysacad.service.ABM;
import com.sysacad.service.Busqueda;
import com.sysacad.service.Login;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.persistence.EntityNotFoundException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by martin on 26/4/2017.
*/
@RestController
public class CarreraController {
@PostMapping("/carrera")
ResponseEntity<Carrera> crearCarrera(@RequestBody Carrera carrera,
@RequestHeader int legajo,
@RequestHeader String contrasenia) throws Exception{
System.out.println("entro en crear");
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
ABM.altaCarrera(carrera);
} else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(carrera);
}
@GetMapping("/carrera/{id}")
ResponseEntity<Carrera> obtenerCarrera(@PathVariable int id,
@RequestHeader int legajo,
@RequestHeader String contrasenia)throws Exception{
Carrera carreraEncontrada = null;
try {
if (Login.validarUsuario(legajo, contrasenia)) {
carreraEncontrada = Busqueda.encontrarCarrera(id);
}else throw new EntityNotFoundException();
if (carreraEncontrada == null) {
throw new EntityNotFoundException();
}
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok().body(carreraEncontrada);
}
@PutMapping("/carrera/{id}")
ResponseEntity<Carrera> actualizarCarrera(@PathVariable int id,
@RequestBody Carrera carrera,
@RequestHeader int legajo,
@RequestHeader String contrasenia)throws Exception{
Carrera carreraEncontrada = null;
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
carreraEncontrada = Busqueda.encontrarCarrera(id);
if (carreraEncontrada != null) {
ABM.modificarCarrera(carreraEncontrada, carrera);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok().body(carrera);
}
@DeleteMapping("/carrera/{id}")
ResponseEntity<Carrera> eliminarCarrera(@PathVariable int id,
@RequestHeader int legajo,
@RequestHeader String contrasenia) throws Exception{
Carrera carreraEliminar = null;
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
carreraEliminar = Busqueda.encontrarCarrera(id);
if (carreraEliminar != null) {
ABM.bajaCarrera(carreraEliminar);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok().body(carreraEliminar);
}
@PutMapping("/carrera/asignar/materia/{idCarrera}")
ResponseEntity<Materia> asignarMateria(@PathVariable int idCarrera,
@RequestHeader int idMateria,
@RequestHeader int legajo,
@RequestHeader String contrasenia)throws Exception{
Materia materiaAsignar = null;
Carrera carreraEncontrada = null;
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
materiaAsignar = Busqueda.encontrarMateria(idMateria);
carreraEncontrada = Busqueda.encontrarCarrera(idCarrera);
if (materiaAsignar != null && carreraEncontrada != null) {
carreraEncontrada.getListaMaterias().put(idMateria, materiaAsignar);
ABM.modificarCarrera(carreraEncontrada, carreraEncontrada);
} else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaAsignar);
}
@GetMapping("/carrera/obtener/materias/{idCarrera}")
ResponseEntity<Map<Integer, Materia>> obtenerListaMaterias(@PathVariable int idCarrera,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
Map<Integer, Materia> listaMaterias = new HashMap<>();
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
listaMaterias = Busqueda.carreraListaMaterias(idCarrera);
if(!listaMaterias.isEmpty()) {
return ResponseEntity.ok(listaMaterias);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/carrera/eliminar/materia/{idCarrera}")
ResponseEntity<Materia> eliminarMateriaAsignada (@PathVariable int idCarrera,
@RequestHeader int idMateria,
@RequestHeader int legajo,
@RequestHeader String contrasenia) throws Exception{
Materia materiaEliminar = null;
Carrera carreraEncontrada = null;
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
materiaEliminar = Busqueda.encontrarMateria(idMateria);
carreraEncontrada = Busqueda.encontrarCarrera(idCarrera);
if (materiaEliminar != null && carreraEncontrada != null) {
carreraEncontrada.getListaMaterias().remove(idMateria);
ABM.modificarCarrera(carreraEncontrada, carreraEncontrada);
} else throw new EntityNotFoundException();
}
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materiaEliminar);
}
@PutMapping("/carrera/{idCarrera}/asignar/alumno")
ResponseEntity<Alumno> asignarAlumno(@PathVariable int idCarrera,
@RequestHeader int legajoAlumno,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
Alumno alumnoEncontrado = null;
Carrera carreraEncontrada = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEncontrado = Busqueda.encontrarAlumno(legajoAlumno);
carreraEncontrada = Busqueda.encontrarCarrera(idCarrera);
if (alumnoEncontrado != null && carreraEncontrada != null) {
carreraEncontrada.getListaAlumnos().put(legajoAlumno, alumnoEncontrado);
alumnoEncontrado.setCarrera(carreraEncontrada); //le asignamos al alumno la carrera
ABM.modificarCarrera(carreraEncontrada, carreraEncontrada);
ABM.modificarAlumno(alumnoEncontrado, alumnoEncontrado);
} else throw new EntityNotFoundException();
}
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok().build();
}
@GetMapping("/carrera/obtener/alumnos/{idCarrera}")
ResponseEntity<Map<Integer, Alumno>> obtenerListaAlumnos(@PathVariable int idCarrera,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.carreraListaAlumnos(idCarrera));
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
//elimina alumno de carrera y carrera del alumno
@DeleteMapping("/carrera/eliminar/alumno/{idCarrera}")
ResponseEntity<Alumno> eliminarAlumnoEnCarrera(@PathVariable int idCarrera,
@RequestHeader int legajoAlumno,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
Alumno alumnoEliminar = null;
Carrera carreraEncontrada = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
alumnoEliminar = Busqueda.encontrarAlumno(legajoAlumno);
carreraEncontrada = Busqueda.encontrarCarrera(idCarrera);
if (alumnoEliminar != null && carreraEncontrada != null) {
carreraEncontrada.getListaAlumnos().remove(legajoAlumno);
alumnoEliminar.setCarrera(null);
ABM.modificarCarrera(carreraEncontrada, carreraEncontrada);
ABM.modificarAlumno(alumnoEliminar, alumnoEliminar); //el alumno no tendra mas carrera
} else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(alumnoEliminar);
}
@GetMapping("/carrera/listado")
ResponseEntity<List<Carrera>> listarCarreras(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.listaCarreras());
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
}
Raw
CarreraRepositorio.java
import java.util.ArrayList;
import java.util.List;
public class CarreraRepositorio {
public static final List<Carrera> repositorioCarrera = new ArrayList<>();
}
Raw
Dia.java
public enum Dia {
lunes,
martes,
miercoles,
jueves,
viernes,
sabado
}
Raw
Dictado.java
public enum Dictado {
primerCuatrimestre,
segundoCuatrimestre,
anual
}
Raw
Estado.java
public enum Estado {
regular,
libre
}
Raw
Examen.java
public class Examen {
private String descripcion;
private int nota;
private TipoExamen tipoExamen; //enumeracion
public Examen(){
}
public Examen(String descripcion, int nota, TipoExamen tipoExamen){
this.descripcion = descripcion;
this.nota = nota;
this.tipoExamen = tipoExamen;
}
public String getDescripcion() {
return descripcion;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
public int getNota() {
return nota;
}
public void setNota(int nota) {
this.nota = nota;
}
public TipoExamen getTipoExamen() {
return tipoExamen;
}
public void setTipoExamen(TipoExamen tipoExamen) {
this.tipoExamen = tipoExamen;
}
}
Raw
Facultad.java
import java.util.ArrayList;
import java.util.List;
public class Facultad {
private List<Carrera> listaCarreras;
public Facultad(){
this.listaCarreras = new ArrayList<>();
}
public List<Carrera> getListaCarreras() {
return listaCarreras;
}
public void setListaCarreras(List<Carrera> listaCarreras) {
this.listaCarreras = listaCarreras;
}
}
Raw
Horario.java
/**
* Created by martin on 9/5/2017.
*/
public class Horario {
private Dia dia;
private int horaInicio;
private int minutosInicio;
private int horaFin;
private int minutosFin;
public Horario(){
}
public Horario(Dia dia, int horaInicio, int minutosInicio, int horaFin, int minutosFin){
this.dia = dia;
this. horaInicio = horaInicio;
this.minutosInicio = minutosInicio;
this.horaFin = horaFin;
this.minutosFin = minutosFin;
}
public Dia getDia() {
return dia;
}
public void setDia(Dia dia) {
this.dia = dia;
}
public int getHoraInicio() {
return horaInicio;
}
public void setHoraInicio(int horaInicio) {
this.horaInicio = horaInicio;
}
public int getMinutosInicio() {
return minutosInicio;
}
public void setMinutosInicio(int minutosInicio) {
this.minutosInicio = minutosInicio;
}
public int getHoraFin() {
return horaFin;
}
public void setHoraFin(int horaFin) {
this.horaFin = horaFin;
}
public int getMinutosFin() {
return minutosFin;
}
public void setMinutosFin(int minutosFin) {
this.minutosFin = minutosFin;
}
}
Raw
Inscripcion.java
import com.sysacad.model.Alumno;
import com.sysacad.model.Carrera;
import com.sysacad.model.Materia;
import java.util.Map;
/**
* Created by martin on 15/5/2017.
*/
public class Inscripcion {
public static boolean cursado(Alumno alumno, Materia materiaInscribir){ //funciona
Integer id = materiaInscribir.getId();
Carrera carrera = alumno.getCarrera();
if(carrera.getListaMaterias().containsKey(id)) {
if (materiaInscribir.getListaMateriaRequerida().isEmpty()) {
//alumno.getListaMateriasCursando().put(id, materiaInscribir);
return true;
} else {
for (Map.Entry<Integer, Materia> entry : materiaInscribir.getListaMateriaRequerida().entrySet()) {
//System.out.println(entry.getKey() + "/" + entry.getValue());
if (!alumno.getListaMateriasRegular().containsKey(entry.getKey())) {
return false;
}
}
}
//verifico que ya no este inscripto
if (!alumno.getListaMateriasCursando().containsKey(id)) {
//alumno.getListaMateriasCursando().put(id, materiaInscribir);
return true;
}
}
return false;
}
public static boolean inscribirseFinal (Alumno alumno, Materia materiaInscribir){
Integer id = materiaInscribir.getId();
Carrera carrera = alumno.getCarrera();
if(carrera.getListaMaterias().containsKey(id)) {
if (materiaInscribir.getListaMateriaRequerida().isEmpty() && alumno.getListaMateriasRegular().containsKey(id)) {
//alumno.getListaMateriasRendirFinal().put(id, materiaInscribir);
return true;
} else {
for (Map.Entry<Integer, Materia> entry : materiaInscribir.getListaMateriaRequerida().entrySet()) {
if (!alumno.getListaMateriasAprobadas().containsKey(entry.getKey())) {
return false;
}
}
}
return true;
}
return false;
}
}
Raw
Login.java
import com.sysacad.model.Administrador;
import com.sysacad.model.Alumno;
import com.sysacad.model.Persona;
import static com.sysacad.repositorios.PersonaRepositorio.repositorioPersona;
/**
* Created by martin on 20/4/2017.
*/
public class Login {
//verifica un logeo de cualquier usuario
public static boolean validarUsuario(int legajoUsuario, String contrasenia){
for(Persona a: repositorioPersona){
if(a.getLegajo() == legajoUsuario){
if(a.getContrasenia().equals(contrasenia)){
return true;
}
}
}
return false;
}
//para verificar que sea administrador
public static boolean validarAdministrador(int legajoUsuario, String contrasenia){
for(Persona p: repositorioPersona){
if(p.getLegajo() == legajoUsuario){
if(p.getContrasenia().equals(contrasenia)){
if(p instanceof Administrador){
return true;
}
}
}
}
return false;
}
//para verificar que sea alumno
public static boolean validarAlumno(int legajoUsuario, String contrasenia){
for(Persona p: repositorioPersona){
if(p.getLegajo() == legajoUsuario){
if(p.getContrasenia().equals(contrasenia)){
if(p instanceof Alumno){
return true;
}
}
}
}
return false;
}
}
Raw
Materia.java
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Materia {
private static int id_increment = 1;
private int id;
private String nombre;
private Dictado dictado;
private boolean seCursa;
private boolean seRinde;
private List<Horario> listaHorarios;
private List<Examen> listaExamenes;
private Map<Integer, Materia> listaMateriaRequerida;
@JsonIgnore
private Map<Integer, Alumno> listaAlumnos;
public Materia(){
this.listaHorarios = new ArrayList<>();
this.listaExamenes = new ArrayList<>();
this.listaMateriaRequerida = new HashMap<>();
this.listaAlumnos = new HashMap<>();
this.id = id_increment;
id_increment++;
}
public Materia(String nombre, int id){
this.nombre = nombre;
this.id = id;
this.listaHorarios = new ArrayList<>();
this.listaExamenes = new ArrayList<>();
this.listaMateriaRequerida = new HashMap<>();
this.listaAlumnos = new HashMap<>();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public Dictado getDictado() {
return dictado;
}
public void setDictado(Dictado dictado) {
this.dictado = dictado;
}
public boolean isSeCursa() {
return seCursa;
}
public void setSeCursa(boolean seCursa) {
this.seCursa = seCursa;
}
public boolean isSeRinde() {
return seRinde;
}
public void setSeRinde(boolean seRinde) {
this.seRinde = seRinde;
}
public List<Horario> getListaHorarios() {
return listaHorarios;
}
public void setListaHorarios(List<Horario> listaHorarios) {
this.listaHorarios = listaHorarios;
}
public List<Examen> getListaExamenes() {
return listaExamenes;
}
public void setListaExamenes(List<Examen> listaExamenes) {
this.listaExamenes = listaExamenes;
}
public Map<Integer, Materia> getListaMateriaRequerida() {
return listaMateriaRequerida;
}
public void setListaMateriaRequerida(Map<Integer, Materia> listaMateriaRequerida) {
this.listaMateriaRequerida = listaMateriaRequerida;
}
public Map<Integer, Alumno> getListaAlumnos() {
return listaAlumnos;
}
public void setListaAlumnos(Map<Integer, Alumno> listaAlumnos) {
this.listaAlumnos = listaAlumnos;
}
@Override
public boolean equals(Object o){
if(o instanceof Materia && ((Materia) o).getId() == this.id){
return true;
}
return false;
}
}
Raw
MateriaController.java
import com.sysacad.model.*;
import com.sysacad.service.ABM;
import com.sysacad.service.Busqueda;
import com.sysacad.service.Login;
import com.sysacad.service.Verificacion;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.persistence.EntityNotFoundException;
import java.util.List;
/**
* Created by martin on 21/4/2017.
*/
@RestController
public class MateriaController {
@PostMapping("/materia")
ResponseEntity<Materia> crearMateria(@RequestBody Materia materia,
@RequestHeader int legajo,
@RequestHeader String contrasenia) throws Exception {
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
ABM.altaMateria(materia);
} else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(materia);
}
@GetMapping("/materia/{id}")
ResponseEntity<Materia> obtenerMateria(@PathVariable int id,
@RequestHeader int legajo,
@RequestHeader String contrasenia) throws Exception {
Materia materiaEncontrada = null;
try {
if (Login.validarUsuario(legajo, contrasenia)) {
materiaEncontrada = Busqueda.encontrarMateria(id);
if(materiaEncontrada != null){
return ResponseEntity.ok(materiaEncontrada);
}else throw new EntityNotFoundException();
} else throw new EntityNotFoundException();
}catch(EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@PutMapping("/materia/{id}")
ResponseEntity<Materia> actualizarMateria(@PathVariable int id,
@RequestHeader int legajo,
@RequestHeader String contrasenia,
@RequestBody Materia materia) throws Exception{
Materia materiaEliminar = null;
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
materiaEliminar = Busqueda.encontrarMateria(id);
if (materiaEliminar != null) {
ABM.modificarMateria(materiaEliminar, materia);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok().body(materia);
}
@DeleteMapping("/materia/{id}")
ResponseEntity<Materia> eliminarMateria(@PathVariable int id,
@RequestHeader int legajo,
@RequestHeader String contrasenia) throws Exception{
Materia materiaEliminar = null;
try {
if (Login.validarAdministrador(legajo, contrasenia)) {
materiaEliminar = Busqueda.encontrarMateria(id);
if (materiaEliminar != null) {
ABM.bajaMateria(materiaEliminar);
}else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok().body(materiaEliminar);
}
@PutMapping("/materia/agregar/requerida/{idMateria}")
ResponseEntity<Materia> agregarMateriaRequerida(@PathVariable int idMateria,
@RequestHeader int idRequerida,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia)throws Exception{
Materia materiaTratar = null;
Materia materiaRequerida = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
materiaTratar = Busqueda.encontrarMateria(idMateria);
materiaRequerida = Busqueda.encontrarMateria(idRequerida);
if (materiaRequerida != null && materiaTratar != null) {
if (Verificacion.asignarMateriaRequerida(materiaRequerida, materiaTratar)) { //que la materia no se requiera a si misma
materiaTratar.getListaMateriaRequerida().put(idRequerida, materiaRequerida);
ABM.modificarMateria(materiaTratar, materiaTratar);
} else throw new Exception();
} else throw new EntityNotFoundException();
}
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}catch (Exception e){
return ResponseEntity.badRequest().build();
}
return ResponseEntity.ok(materiaRequerida);
}
//devuelve lista de materias del repositorio
@GetMapping("materia/listado")
ResponseEntity<List<Materia>> listarMaterias(@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia) throws Exception{
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
return ResponseEntity.ok(Busqueda.listaMaterias());
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}
}
@PutMapping("materia/horarios/{idMateria}")
ResponseEntity<Horario> asignarHorario(@PathVariable int idMateria,
@RequestHeader int legajoUsuario,
@RequestHeader String contrasenia,
@RequestBody Horario horario)throws Exception{
Materia materiaEncontrada = null;
try {
if (Login.validarAdministrador(legajoUsuario, contrasenia)) {
materiaEncontrada = Busqueda.encontrarMateria(idMateria);
if (materiaEncontrada != null) {
if(Verificacion.validarHorario(horario)) {
materiaEncontrada.getListaHorarios().add(horario);
ABM.modificarMateria(materiaEncontrada, materiaEncontrada);
}else throw new Exception();
} else throw new EntityNotFoundException();
}else throw new EntityNotFoundException();
}catch (EntityNotFoundException e){
return ResponseEntity.notFound().build();
}catch (Exception e){
return ResponseEntity.badRequest().build();
}
return ResponseEntity.ok(horario);
}
}
Raw
MateriaRepositorio.java
import java.util.ArrayList;
import java.util.List;
public class MateriaRepositorio {
public static final List<Materia> repositorioMateria = new ArrayList<>();
}
Raw
Persona.java
public abstract class Persona implements Comparable<Persona>{
protected static int legajo_Increment = 1;
protected int legajo;
protected String nombre;
protected String apellido;
protected String contrasenia;
public Persona () {
legajo = legajo_Increment;
legajo_Increment++;
}
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 int getLegajo() {
return legajo;
}
public void setLegajo(int legajo) {
this.legajo = legajo;
}
public String getContrasenia() {
return contrasenia;
}
public void setContrasenia(String contrasenia) {
this.contrasenia = contrasenia;
}
@Override
public boolean equals(Object o){
if(o instanceof Persona && this.legajo == ((Persona) o).getLegajo()){
return true;
}
return false;
}
@Override
public int compareTo(Persona p){
if(this.getLegajo() > p.getLegajo()) return 1;
if(this.getLegajo() < p.getLegajo()) return -1;
return 0;
}
}
Raw
PersonaRepositorio.java
import java.util.ArrayList;
import java.util.List;
public class PersonaRepositorio {
public static final List<Persona> repositorioPersona = new ArrayList<>();
}
Raw
SysacadutnApplicationTests.java
import com.sysacad.controller.AlumnoController;
import com.sysacad.controller.MateriaController;
import com.sysacad.model.Administrador;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import static com.sysacad.repositorios.PersonaRepositorio.repositorioPersona;
@SpringBootApplication
@ComponentScan(basePackageClasses = MateriaController.class)
@ComponentScan(basePackageClasses = AlumnoController.class)
public class SysacadUTNApplication implements CommandLineRunner {
public static void main(String[] args) {
SpringApplication.run(SysacadUTNApplication.class, args);
}
@Override
public void run(String... strings) throws Exception {
Administrador administradorUnico = new Administrador();
administradorUnico.setContrasenia("admin26");
repositorioPersona.add(administradorUnico);
}
}
Raw
Test.java
import com.sysacad.model.Administrador;
import com.sysacad.model.Alumno;
import com.sysacad.model.Carrera;
import com.sysacad.model.Dia;
import com.sysacad.model.Examen;
import com.sysacad.model.Horario;
import com.sysacad.model.Materia;
import com.sysacad.model.TipoExamen;
import com.sysacad.repositorios.CarreraRepositorio;
import com.sysacad.repositorios.MateriaRepositorio;
import com.sysacad.repositorios.PersonaRepositorio;
import com.sysacad.service.Busqueda;
import com.sysacad.service.Inscripcion;
import com.sysacad.service.Login;
import com.sysacad.service.Verificacion;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class SysacadutnApplicationTests {
public SysacadutnApplicationTests() {
}
@Before
public void setUp() throws Exception {
new Examen();
Administrador administradorUnico = new Administrador(1, "admin26");
PersonaRepositorio.repositorioPersona.add(administradorUnico);
Alumno alumno = new Alumno("Martin", "Angeloni", 22100, "jack24");
Materia materia2 = new Materia("ProgramacionI", 1);
alumno.getListaMateriasCursando().put(Integer.valueOf(1), materia2);
alumno.getListaMateriasRegular().put(Integer.valueOf(1), materia2);
alumno.getListaMateriasAprobadas().put(Integer.valueOf(1), materia2);
alumno.getListaMateriasRendirFinal().put(Integer.valueOf(1), materia2);
Carrera carrera2 = new Carrera("TSP", 2);
carrera2.getListaMaterias().put(Integer.valueOf(1), materia2);
alumno.setCarrera(carrera2);
PersonaRepositorio.repositorioPersona.add(alumno);
Carrera carrera = new Carrera("Tecnico Superior en Programacion", 1);
Materia materia = new Materia("ProgramacionI", 1);
MateriaRepositorio.repositorioMateria.add(materia);
carrera.getListaMaterias().put(Integer.valueOf(1), materia);
carrera.getListaAlumnos().put(Integer.valueOf(22100), alumno);
CarreraRepositorio.repositorioCarrera.add(carrera);
}
@Test
public void loginValido() {
Boolean resultado = Boolean.valueOf(Login.validarUsuario(1, "admin26"));
Boolean esperado = Boolean.valueOf(true);
TestCase.assertTrue(esperado == resultado);
}
@Test
public void loginInvalido() {
Boolean resultado = Boolean.valueOf(Login.validarUsuario(2, "asd"));
Boolean esperado = Boolean.valueOf(false);
TestCase.assertTrue(esperado == resultado);
}
@Test
public void loginAdministradorValido() {
boolean resultado = Login.validarAdministrador(1, "admin26");
boolean esperado = true;
TestCase.assertTrue(esperado == resultado);
}
@Test
public void loginAdministradorInvalido() {
boolean resultado = Login.validarAdministrador(2, "asd");
boolean esperado = false;
TestCase.assertTrue(esperado == resultado);
}
@Test
public void loginAlumnoValido() {
boolean resultado = Login.validarAlumno(22100, "jack24");
boolean esperado = true;
TestCase.assertTrue(esperado == resultado);
}
@Test
public void loginAlumnoInvalido() {
boolean resultado = Login.validarAlumno(1, "admin26");
boolean esperado = false;
TestCase.assertTrue(esperado == resultado);
}
@Test
public void encontrarAlumno() {
Alumno alumno = new Alumno("Martin", "Angeloni", 22100, "jack24");
Alumno alumnoPrueba = Busqueda.encontrarAlumno(22100);
TestCase.assertEquals(alumnoPrueba, alumno);
}
@Test
public void listarAlumnos() {
new ArrayList();
List<Alumno> listaAlumnos = Busqueda.listaAlumnos();
TestCase.assertEquals(1, listaAlumnos.size());
}
@Test
public void encontrarCarrera() {
Carrera carrera = (Carrera)CarreraRepositorio.repositorioCarrera.get(0);
Carrera carreraPrueba = Busqueda.encontrarCarrera(1);
TestCase.assertEquals(carreraPrueba, carrera);
}
@Test
public void carreraListaMaterias() {
new HashMap();
Map<Integer, Materia> listaMaterias = Busqueda.carreraListaMaterias(1);
TestCase.assertEquals(1, listaMaterias.size());
}
@Test
public void carreraListaAlumnos() {
new HashMap();
Map<Integer, Alumno> listaAlumnos = Busqueda.carreraListaAlumnos(1);
TestCase.assertEquals(1, listaAlumnos.size());
}
@Test
public void listaCarreras() {
new ArrayList();
List<Carrera> listaCarrera = Busqueda.listaCarreras();
TestCase.assertEquals(1, listaCarrera.size());
}
@Test
public void encontrarMateria() {
Materia materia = (Materia)MateriaRepositorio.repositorioMateria.get(0);
Materia materiaResultado = Busqueda.encontrarMateria(1);
TestCase.assertEquals(materiaResultado, materia);
}
@Test
public void listaMaterias() {
new ArrayList();
List<Materia> listaMateria = Busqueda.listaMaterias();
TestCase.assertEquals(1, listaMateria.size());
}
@Test
public void alumnoMateriaCursando() {
Materia materiaEsperada = (Materia)MateriaRepositorio.repositorioMateria.get(0);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Materia materiaResultado = Busqueda.materiaCursando(alumno, Integer.valueOf(1));
TestCase.assertEquals(materiaResultado, materiaEsperada);
}
@Test
public void alumnoMateriaCursandoOpuesto() {
Materia materiaEsperada = new Materia("LABII", 2);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Materia materiaResultado = Busqueda.materiaCursando(alumno, Integer.valueOf(1));
TestCase.assertFalse(materiaEsperada.equals(materiaResultado));
}
@Test
public void alumnoListaMateriasCursando() {
new HashMap();
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Map<Integer, Materia> listaMateriasCursando = Busqueda.listaMateriasCursando(22100);
TestCase.assertEquals(1, listaMateriasCursando.size());
}
@Test
public void alumnoMateriaRegular() {
Materia materia2 = new Materia("ProgramacionI", 1);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Materia materiaRegular = Busqueda.materiaRegular(alumno, Integer.valueOf(1));
TestCase.assertEquals(materia2, materiaRegular);
}
@Test
public void alumnoListaMateriasRegular() {
new HashMap();
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Map<Integer, Materia> listaMateriasRegular = Busqueda.listaMateriasRegular(22100);
TestCase.assertEquals(1, listaMateriasRegular.size());
}
@Test
public void alumnoListaMateriasAprobadas() {
new HashMap();
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Map<Integer, Materia> listaMateriasAprobadas = Busqueda.listaMateriasAprobadas(22100);
TestCase.assertEquals(1, listaMateriasAprobadas.size());
}
@Test
public void alumnoMateriaAprobada() {
Materia materia2 = new Materia("ProgramacionI", 1);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Materia materiaAprobada = Busqueda.materiaAprobada(alumno, Integer.valueOf(1));
TestCase.assertEquals(materia2, materiaAprobada);
}
@Test
public void alumnoListaMateriasFinal() {
new HashMap();
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Map<Integer, Materia> listaMateriasFinal = Busqueda.listaMateriasFinal(22100);
TestCase.assertEquals(1, listaMateriasFinal.size());
}
@Test
public void alumnoMateriaFinal() {
Materia materia2 = new Materia("ProgramacionI", 1);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
Materia materiaFinal = Busqueda.materiaAprobada(alumno, Integer.valueOf(1));
TestCase.assertEquals(materia2, materiaFinal);
}
@Test
public void inscripcionCursado() {
Materia materia2 = new Materia("ProgramacionI", 1);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
boolean permiso = Inscripcion.cursado(alumno, materia2);
TestCase.assertTrue(permiso);
}
@Test
public void inscripcionFinal() {
Materia materia2 = new Materia("ProgramacionI", 1);
Alumno alumno = (Alumno)PersonaRepositorio.repositorioPersona.get(1);
boolean permiso = Inscripcion.inscribirseFinal(alumno, materia2);
TestCase.assertTrue(permiso);
}
@Test
public void verificarExamenParcial() {
Examen examen = new Examen("perimerExamen", 10, TipoExamen.parcial);
boolean permisoExamen = Verificacion.examenParcial(examen);
TestCase.assertTrue(permisoExamen);
}
@Test
public void verificarExamenParcialRecuperatorio() {
Examen examen = new Examen("perimerExamen", 10, TipoExamen.recuperatorio);
boolean permisoExamen = Verificacion.examenParcial(examen);
TestCase.assertTrue(permisoExamen);
}
@Test
public void verificarExamenFinal() {
Examen examen = new Examen("perimerExamen", 10, TipoExamen.mesaFinal);
boolean permisoExamen = Verificacion.examenFinal(examen);
TestCase.assertTrue(permisoExamen);
}
@Test
public void verificarHorario() {
Horario horario = new Horario(Dia.jueves, 6, 45, 23, 0);
boolean horarioCorrecto = Verificacion.validarHorario(horario);
TestCase.assertTrue(horarioCorrecto);
}
@Test
public void verificarHorarioIncorrecto() {
Horario horario = new Horario(Dia.jueves, 18, 45, 17, 0);
boolean horarioCorrecto = Verificacion.validarHorario(horario);
TestCase.assertTrue(!horarioCorrecto);
}
@Test
public void verificarHorarioIncorrecto2() {
Horario horario = new Horario(Dia.jueves, 18, 70, 23, 0);
boolean horarioCorrecto = Verificacion.validarHorario(horario);
TestCase.assertTrue(!horarioCorrecto);
}
@Test
public void verificarHorarioIncorrecto3() {
Horario horario = new Horario(Dia.jueves, 18, 5, 23, 60);
boolean horarioCorrecto = Verificacion.validarHorario(horario);
TestCase.assertTrue(!horarioCorrecto);
}
@Test
public void verificarHorarioIncorrecto4() {
Horario horario = new Horario(Dia.jueves, 25, 45, 17, 0);
boolean horarioCorrecto = Verificacion.validarHorario(horario);
TestCase.assertTrue(!horarioCorrecto);
}
@Test
public void verificarHorarioIncorrecto5() {
Horario horario = new Horario(Dia.jueves, 17, 45, 25, 0);
boolean horarioCorrecto = Verificacion.validarHorario(horario);
TestCase.assertTrue(!horarioCorrecto);
}
@After
public void after() {
PersonaRepositorio.repositorioPersona.clear();
CarreraRepositorio.repositorioCarrera.clear();
MateriaRepositorio.repositorioMateria.clear();
}
}
Raw
TipoExamen.java
public enum TipoExamen {
parcial,
recuperatorio,
mesaFinal
}
Raw
Verificacion.java
import com.sysacad.model.Examen;
import com.sysacad.model.Horario;
import com.sysacad.model.Materia;
import com.sysacad.model.TipoExamen;
/**
* Created by martin on 8/7/2017.
*/
public class Verificacion {
public static boolean examenParcial (Examen examen){
if(examen.getNota()>=1 && examen.getNota() <=10){
if(examen.getTipoExamen() == TipoExamen.parcial || examen.getTipoExamen() == TipoExamen.recuperatorio){
return true;
}
}
return false;
}
public static boolean examenFinal (Examen examen){
if(examen.getNota()>=1 && examen.getNota() <=10){
if(examen.getTipoExamen() == TipoExamen.mesaFinal){
return true;
}
}
return false;
}
//a partir de aqui: Horario
public static boolean validarHorario(Horario horario){
if(horario.getHoraInicio() >= 6 && horario.getHoraInicio() <=22){
if(horario.getHoraFin()>= 7 && horario.getHoraFin() <= 23){
if((horario.getHoraInicio() < horario.getHoraFin()) &&
(horario.getHoraInicio() != horario.getHoraFin())){
if(horario.getMinutosInicio()>= 0 && horario.getMinutosInicio() <= 59){
if(horario.getMinutosFin()>= 0 && horario.getMinutosFin() <= 59){
return true;
}
}
}
}
}
return false;
}
//asignar materia requerida a otra materia
public static boolean asignarMateriaRequerida(Materia materiaRequerida, Materia matetriaTratar){
if(!materiaRequerida.equals(matetriaTratar)){
return true;
}
return false;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment