Creación de ControladorREST y ControladorRESTTEST, realizado con Álvaro Herrera

src/main/java/com/carpooling/carpoolingaoraha/rest/ControladorREST.java

+package com.carpooling.carpoolingaoraha.rest;
+
+import com.carpooling.carpoolingaoraha.entidades.*;
+import com.carpooling.carpoolingaoraha.excepciones.SolicitudYaExistente;
+import com.carpooling.carpoolingaoraha.excepciones.UsuarioNoRegistrado;
+import com.carpooling.carpoolingaoraha.excepciones.UsuarioYaRegistrado;
+import com.carpooling.carpoolingaoraha.rest.dto.DTOUsuario;
+import com.carpooling.carpoolingaoraha.services.ServicioCarPooling;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.ConstraintViolationException;
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/carpooling")
+public class ControladorREST {
+
+    @Autowired
+    ServicioCarPooling servicioCarPooling;
+
+    /**
+     * Manejo de violacion de restricciones
+     */
+    @ExceptionHandler(ConstraintViolationException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public ResponseEntity<String> handlerViolacionRestricciones(ConstraintViolationException ex){
+       return ResponseEntity.badRequest().body(ex.getMessage());
+    }
+
+    /**
+     * Manejo de excepcion usuario no registrado
+     */
+    @ExceptionHandler(UsuarioNoRegistrado.class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    public ResponseEntity<String> handlerUsuarioNoRegistrado(UsuarioNoRegistrado e){
+        return ResponseEntity.badRequest().body(e.getMessage());
+    }
+
+    @PostMapping("/usuarios")
+    ResponseEntity<DTOUsuario> altaUsuario(@RequestBody DTOUsuario usuario){
+        try {
+            SistemaCarPooling s;
+            servicioCarPooling.altaCliente(usuario.altaUsuario());
+            return ResponseEntity.status(HttpStatus.CREATED).build();
+        } catch (UsuarioYaRegistrado e) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).build();
+        }
+    }
+
+    /**
+     * Listar usuarios
+     */
+    @GetMapping("/usuarios/{dni}")
+    ResponseEntity<DTOUsuario> verUsuario(@PathVariable String DNI){
+        Optional<Usuario> usuario = servicioCarPooling.verUsuario(DNI);
+        return usuario.map(c -> ResponseEntity.ok(new DTOUsuario(c))).orElse(ResponseEntity.notFound().build());
+    }
+
+    /**
+     * Actualización de clientes
+     */
+    @PutMapping("/usuarios/modificar/{dni}")
+    ResponseEntity<DTOUsuario> actualizarCliente(@PathVariable String dni, @RequestBody Usuario clienteActualizado) {
+        Optional<Usuario> usuarioExistente = servicioCarPooling.verUsuario(dni);
+        return usuarioExistente.map(usuario -> {
+            // Actualizar los datos del cliente existente con los nuevos datos proporcionados
+            usuario.setNombre(clienteActualizado.getNombre());
+            usuario.setApellidos(clienteActualizado.getApellidos());
+            usuario.setFNac(clienteActualizado.getFNac());
+            usuario.setDNI(clienteActualizado.getDNI());
+            usuario.setRol(clienteActualizado.getRol());
+            usuario.setTelefono(clienteActualizado.getTelefono());
+            usuario.setClaveAcceso(clienteActualizado.getClaveAcceso());
+            usuario.setPuntuacion(clienteActualizado.getPuntuacion());
+            usuario.setViajesOfertados(clienteActualizado.getViajesOfertados());
+            usuario.setSolicitudesPendientes(clienteActualizado.getSolicitudesPendientes());
+            usuario.setHistoricoSolicitudes(clienteActualizado.getHistoricoSolicitudes());
+            usuario.setPuntuacionMedia(clienteActualizado.getPuntuacionMedia());
+            usuario.setSistemaCarPooling(clienteActualizado.getSistemaCarPooling());
+
+            servicioCarPooling.modificarDatosUsuario(usuario);
+            return ResponseEntity.ok(new DTOUsuario(usuario));
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+    /**
+     * Eliminación de clientes
+     */
+    @DeleteMapping("/usuarios/borrarUsuario/{dni}")
+    ResponseEntity<Object> eliminarUsuario(@PathVariable String dni) {
+        Optional<Usuario> usuarioExistente = servicioCarPooling.verUsuario(dni);
+        return usuarioExistente.map( usuario -> {
+            servicioCarPooling.darseDeBaja(dni);
+            return ResponseEntity.noContent().build();
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+    /**
+     * Crear viaje
+     */
+    @PostMapping("/viajes")
+    public ResponseEntity<Viaje> crearViaje(@RequestBody Viaje viaje) {
+        try {
+            servicioCarPooling.altaViaje(viaje);
+            return ResponseEntity.status(HttpStatus.CREATED).build();
+        } catch (UsuarioYaRegistrado e) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).build();
+        }
+    }
+
+    /**
+     * Mostrar un viaje
+     */
+    @GetMapping("/viajes/{id}")
+    public ResponseEntity<Viaje> verViajePorId(@PathVariable int id) {
+        Optional<Viaje> viaje = servicioCarPooling.verViaje(id);
+        return viaje.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
+    }
+
+    // Método para obtener todos los viajes
+    @GetMapping("/viajes/todosLosViajes")
+    public ResponseEntity<List<Viaje>> listarTodosLosViajes() {
+        List<Viaje> viajes = servicioCarPooling.listarViajes();
+        return ResponseEntity.ok(viajes);
+    }
+
+    //EliminarViaje
+    @DeleteMapping("/viajes/eliminarViaje/{id}")
+    ResponseEntity<Object> eliminarViaje(@PathVariable int id) {
+        Optional<Viaje> viajeExistente = servicioCarPooling.verViaje(id);
+        return viajeExistente.map( usuario -> {
+            servicioCarPooling.eliminarViaje(id);
+            return ResponseEntity.noContent().build();
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+    /**
+     * Modificar datos de un viaje
+     */
+    @PutMapping("/viajes/actualizarViaje/{id}")
+    public ResponseEntity<Viaje> actualizarViaje(@PathVariable int id, @RequestBody Viaje viajeActualizado) {
+        Optional<Viaje> viajeExistente = servicioCarPooling.verViaje(id);
+        return viajeExistente.map(viaje -> {
+            viaje.setOrigen(viajeActualizado.getOrigen());
+            viaje.setDestino(viajeActualizado.getDestino());
+            viaje.setFechaSalida(viajeActualizado.getFechaSalida());
+            viaje.setnAsientos(viajeActualizado.getnAsientos());
+            viaje.setPrecioAsiento(viajeActualizado.getPrecioAsiento());
+
+            Viaje viajeModificado = servicioCarPooling.modificarDatosViaje(viaje);
+            return ResponseEntity.ok(viajeModificado);
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+
+    @PostMapping("/reservas/crearReserva/{dni}")
+    public ResponseEntity<Reserva> crearReserva(@PathVariable String dni) {
+        try {
+            servicioCarPooling.crearReserva(dni);
+            return ResponseEntity.status(HttpStatus.CREATED).build();
+        } catch (UsuarioYaRegistrado e) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).build();
+        }
+    }
+
+    @GetMapping("/reservas/{id}")
+    public ResponseEntity<Reserva> verReservaPorId(@PathVariable int id) {
+        Optional<Reserva> reserva = servicioCarPooling.verReserva(id);
+        return reserva.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
+    }
+
+    @PutMapping("/reservas/actualizarReserva/{id}")
+    public ResponseEntity<Reserva> actualizarReserva(@PathVariable int id, @RequestBody Reserva reservaActualizada) {
+        Optional<Reserva> reservaExistente = servicioCarPooling.verReserva(id);
+        return reservaExistente.map(reserva -> {
+
+            reserva.setNumPasajeros(reservaActualizada.getNumPasajeros());
+            reserva.setPuntuacion(reservaActualizada.getPuntuacion());
+            reserva.setReservaConcluida(reservaActualizada.getReservaConcluida());
+            reserva.setPasajeros(reservaActualizada.getPasajeros());
+
+            Reserva reservaModificada = servicioCarPooling.modificarDatosReserva(reserva);
+            return ResponseEntity.ok(reservaModificada);
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/reservas/eliminarReserva/{id}")
+    public ResponseEntity<Void> eliminarReserva(@PathVariable int id) {
+        if (servicioCarPooling.eliminarReserva(id)) {
+            return ResponseEntity.noContent().build();
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+    @PostMapping("/solicitudes/crearSolicitud")
+    public ResponseEntity<Solicitud> crearSolicitud(@PathVariable String dni, @PathVariable int idReserva) {
+        try {
+            servicioCarPooling.crearSolicitud(dni, idReserva);
+            return ResponseEntity.status(HttpStatus.CREATED).build();
+        } catch (SolicitudYaExistente e) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).build();
+        }
+    }
+
+    @GetMapping("/solicitudes/{id}")
+    public ResponseEntity<Solicitud> verSolicitudPorId(@PathVariable Long id) {
+        Optional<Solicitud> solicitud = servicioCarPooling.verSolicitud(id);
+        return solicitud.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
+    }
+
+    @PutMapping("/solicitudes/actualizarSolicitud/{id}")
+    public ResponseEntity<Solicitud> actualizarSolicitud(@PathVariable Long id, @RequestBody Solicitud solicitudActualizada) {
+        Optional<Solicitud> solicitudExistente = servicioCarPooling.verSolicitud(id);
+        return solicitudExistente.map(solicitud -> {
+            solicitud.setReserva(solicitudActualizada.getReserva());
+            solicitud.setPasajero(solicitudActualizada.getPasajero());
+
+            Solicitud solicitudModificada = servicioCarPooling.modificarDatosSolicitud(solicitud);
+            return ResponseEntity.ok(solicitudModificada);
+        }).orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/solicitudes/eliminarSolicitud/{id}")
+    public ResponseEntity<Void> eliminarSolicitud(@PathVariable Long id) {
+        if (servicioCarPooling.cancelarSolicitud(id)) {
+            return ResponseEntity.noContent().build();
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+}

src/test/java/com/carpooling/carpoolingaoraha/ControladorRESTEST/ControladorRESTTEST.java

+package com.carpooling.carpoolingaoraha.ControladorRESTEST;
+
+import jakarta.annotation.PostConstruct;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+
+import java.util.List;
+
+
+@SpringBootTest(classes = com.carpooling.carpoolingaoraha.CarPoolingAorAhaApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+public class ControladorRESTTEST {
+    @LocalServerPort
+    int localPort;
+
+    @Autowired
+    MappingJackson2HttpMessageConverter springBoot;
+
+
+    TestRestTemplate restTemplate;
+
+    @PostConstruct
+    void crearRestTemplate() {
+        RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder()
+                .rootUri("http://localhost:" + localPort + "/carpooling")
+                .additionalMessageConverters(List.of(springBoot));
+
+        restTemplate = new TestRestTemplate(restTemplateBuilder);
+
+    }
+
+
+}