Laboratorio 1 – REST

1. Controller

package com.scotia.usows.controller;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;

import com.scotia.usows.CustomErrorType;
import com.scotia.usows.model.User;
import com.scotia.usows.service.UserService;

@RestController
@RequestMapping("/api")
public class RestApiController {

public static final Logger logger =

LoggerFactory.getLogger(RestApiController.class);
@Autowired
UserService userService;

@RequestMapping(value="/user",method=RequestMethod.GET)
public ResponseEntity<List<User>> listAllUsers() {
logger.info("Mostrando todos los usuarios");
List<User> users = userService.consulta();
if(users.isEmpty()) {
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
return new ResponseEntity<List<User>>(users,HttpStatus.OK);

@RequestMapping(value="/user/{id}", method=RequestMethod.GET)
public ResponseEntity<?> getUser(@PathVariable("id") long id){
logger.info("Buscando usuario con id de entrada {}",id);
User user =userService.consultarPorId(id);
if(user == null) {
logger.error("usuario con id {} no existe",id);
return new ResponseEntity(new CustomErrorType("Usuario con id
"+id+" no encontrado"),
HttpStatus.NOT_FOUND);
}
return new ResponseEntity<User>(user,HttpStatus.OK);
}

@RequestMapping(value="/user", method=RequestMethod.POST)
public ResponseEntity<?> createUser(@RequestBody User
user,UriComponentsBuilder ucBuilder){

logger.info("Creando usuario en HR");

if(userService.siUsuarioExiste(user)) {
logger.error("Error en creacion: usuario con nombre {} ya
existe",user.getName());
return new ResponseEntity(new CustomErrorType("No se puede
crear usuario "+user.getName()+
" ya existe"),HttpStatus.CONFLICT);
}
userService.registro(user);

HttpHeaders headers = new HttpHeaders();

 headers.setLocation(ucBuilder.path("/api/user/{id}").buildAndExpand(u
ser.getId()).toUri());
return new ResponseEntity<String>(headers,HttpStatus.CREATED);
}

@RequestMapping(value="/user/{id}",method= RequestMethod.PUT)
public ResponseEntity<?> updateUser(@PathVariable("id") long
id,@RequestBody User user){

logger.info("Actualizando user {}",id);

User suser = userService.consultarPorId(id);

if(suser == null) {
logger.error("Error en actualizacion: usuario con id {} no
existe",id);
return new ResponseEntity(new CustomErrorType("No se puede
actualzar usuario "+user.getId()+
" ,no existe"),HttpStatus.NOT_FOUND);
}

suser.setAge(user.getAge());
suser.setName(user.getName());
suser.setSalary(user.getSalary());

userService.registro(suser);
return new ResponseEntity<User>(suser,HttpStatus.OK);
}

@RequestMapping(value="/user/{id}", method= RequestMethod.DELETE)

public ResponseEntity<?> deleteUser(@PathVariable("id") long id){
logger.info("eliminando user {}",id);

User user = userService.consultarPorId(id);

if(user == null) {
logger.error("Error en borrado: usuario con id {} no
existe",id);
return new ResponseEntity(new CustomErrorType("No se puede
eliminar usuario "+id+
" ,por que no existe"),HttpStatus.NOT_FOUND);
}
userService.borrarPorId(id);
return new ResponseEntity<User>(HttpStatus.NO_CONTENT);
}

@RequestMapping(value="/user", method= RequestMethod.DELETE)

public ResponseEntity<User> deleteAllUsers(){
logger.info("eliminando todos los usuarios");
userService.borrarTodos();
return new ResponseEntity<User>(HttpStatus.NO_CONTENT);

}
}

2. Entity

package com.nh.rest.ejmrest;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;
private String name;
private int age;
private double salary;

public long getId() {

return id;
}

public void setId(long id) {

this.id = id;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public int getAge() {

return age;
}
public void setAge(int age) {
this.age = age;
}

public double getSalary() {

return salary;
}

public void setSalary(double salary) {

this.salary = salary;
}

public User(String name, int age, double salary) {

super();
this.name = name;
this.age = age;
this.salary = salary;
}

public User() {
// TODO Auto-generated constructor stub
}

@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
if (this == obj)
return true;

if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (id != other.id)
return false;
return true;
}

@Override
public int hashCode() {
// TODO Auto-generated method stub
final int prime = 31;
int result = 1;
 result = prime * result + (int) (id ^ (id >>> 32));
return result;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return "User [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
}

--------------------------------------------------------------------------------
---------------------------------------------------------------------------

3. Interface CRUD

package com.nh.rest.ejmrest;

import org.springframework.data.repository.CrudRepository;

public interface UserRepository extends CrudRepository<User, Long> {

-----------------------------------------------------------------------------
4. Service

package com.nh.rest.ejmrest;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
@Autowired
UserRepository userRepository;

public List<User> consulta() {

return (List<User>) userRepository.findAll();
 }

public User consultaPorId(long id) {

return userRepository.findById(id).get();
}

public User registro(User b) {

return userRepository.save(b);
}

public void eliminar(User b) {

userRepository.delete(b);
}

public User consultaPorNombre(String name) {

List<User> users = consulta();
for (User user : users) {
if (user.getName().equalsIgnoreCase(name)) {
return user;
}
}
return null;
}
public void borrarPorId(long id) {
userRepository.deleteById(id);
}
public boolean isUsuarioExiste(User user) {
return consultaPorNombre(user.getName())!= null;
}
public void borrarTodos(){
userRepository.deleteAll();
}
}

5. ErrorType

package com.nh.rest.ejmrest;

public class CustomErrorType {

private String errorMessage;

public CustomErrorType(String errorMessage) {

this.errorMessage = errorMessage;
 }

public String getErrorMessage() {

return errorMessage;
}
}

---------------------------------------------------------------------------

6. Aplication

package com.nh.rest.ejmrest;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class EjmrestApplication {

public static void main(String[] args) {

SpringApplication.run(EjmrestApplication.class, args);
}

public CommandLineRunner setup(UserRepository br) {

return (args)->{
br.save(new User("Jorge Guerra", 50, 2000.00));
br.save(new User("Carlos Ruiz", 45, 1800.00));
br.save(new User("Tomas Tafur", 36, 2000.00));
br.save(new User("Maria Velasquez", 29, 3600.00));
br.save(new User("German Suarez", 65, 2600.00));
br.save(new User("Luis Avendaño", 38, 3100.00));
br.save(new User("Rossina Gonzales", 42, 4300.00));
br.save(new User("Martha Zegarra", 51, 2200.00));
};
}

Configuracion del Puerto del servidor:

En application.properties
server.port=8022

Ejecucion

http://localhost:8022/api/user.

En Postman
Consulta de un usuario especifico

http://localhost:8022/api/user/2

En postman
Uso de POST en Postman

Enviamos SEND – resultado

Comprobacion..

Probando DELETE en Postman

Al ejecutar SEND sale la siguiente respuesta:

Comprobando que se elimino