diff --git a/pom.xml b/pom.xml index ad485bc..cc64a73 100644 --- a/pom.xml +++ b/pom.xml @@ -54,6 +54,16 @@ spring-boot-starter-test test + + jakarta.persistence + jakarta.persistence-api + + + jakarta.validation + jakarta.validation-api + 3.0.0 + + diff --git a/src/main/java/com/example/project/management/DTO/PrioridadProyectoDTO.java b/src/main/java/com/example/project/management/DTO/PrioridadProyectoDTO.java new file mode 100644 index 0000000..e47c102 --- /dev/null +++ b/src/main/java/com/example/project/management/DTO/PrioridadProyectoDTO.java @@ -0,0 +1,15 @@ +package com.example.project.management.DTO; + +import com.example.project.management.model.PrioridadProyecto; +import lombok.Data; + +import java.time.LocalDateTime; + +@Data +public class PrioridadProyectoDTO { + + private Long id; + private String nombre; + private LocalDateTime fechaEliminacion; + +} diff --git a/src/main/java/com/example/project/management/controller/PrioridadProyectoController.java b/src/main/java/com/example/project/management/controller/PrioridadProyectoController.java new file mode 100644 index 0000000..c308a7f --- /dev/null +++ b/src/main/java/com/example/project/management/controller/PrioridadProyectoController.java @@ -0,0 +1,83 @@ +package com.example.project.management.controller; + +import com.example.project.management.DTO.PrioridadProyectoDTO; +import com.example.project.management.exception.BadRequestException; +import com.example.project.management.exception.ResponseService; +import com.example.project.management.mapper.PrioridadProyectoMapper; +import com.example.project.management.model.PrioridadProyecto; +import com.example.project.management.service.PrioridadProyectoService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/prioridad-proyecto") +@CrossOrigin (origins = "*") +public class PrioridadProyectoController { + @Autowired + private PrioridadProyectoService modelService; + + @Autowired + private ResponseService responseService; + + @GetMapping({"/"}) + public ResponseEntity getAll() { + List prioridades = modelService.findAllByFechaEliminacionIsNull(); + if (prioridades.isEmpty()) { + throw new BadRequestException("No hay roles creados"); + } + return responseService.successResponse(prioridades, "OK"); + } + + @GetMapping("/id/{id}") + public ResponseEntity getPorId(@PathVariable Long id){ + PrioridadProyecto model = modelService.findByIdAndFechaEliminacionIsNull(id); + PrioridadProyectoDTO modelDTO = PrioridadProyectoMapper.toDTO(model); + return responseService.successResponse(modelDTO, "OK"); + } + @GetMapping("/nombre/{nombre}") + public ResponseEntity getPorNombre(@PathVariable String nombre){ + PrioridadProyecto model = modelService.findByNombreAndFechaEliminacionIsNull(nombre); + PrioridadProyectoDTO modelDTO = PrioridadProyectoMapper.toDTO(model); + return responseService.successResponse(modelDTO, "OK"); + } + + + @PostMapping({"/"}) + public ResponseEntity crear(@RequestBody PrioridadProyectoDTO prioridadProyectoDTO) { + return responseService.successResponse(modelService.crear(prioridadProyectoDTO), "Prioridad creada"); + } + + + @DeleteMapping("/id/{id}") + public ResponseEntity deleteById(@PathVariable Long id) { + modelService.deleteById(id); + return responseService.successResponse(null, "Prioridad eliminada"); + } + + @DeleteMapping("/nombre/{nombre}") + public ResponseEntity deleteByNombre(@PathVariable String nombre) { + modelService.deleteByNombre(nombre); + return responseService.successResponse(null, "Prioridad eliminada"); + } + + @PostMapping("/recuperar/id/{id}") + public ResponseEntity recuperarPorId(@PathVariable Long id) { + modelService.recuperarPorId(id); + return responseService.successResponse(null, "Prioridad recuperada"); + } + + @PostMapping("/recuperar/nombre/{nombre}") + public ResponseEntity recuperarPorNombre(@PathVariable String nombre) { + modelService.recuperarPorNombre(nombre); + return responseService.successResponse(null, "Prioridad recuperada"); + } + + @PutMapping ("/") + public ResponseEntity update( @RequestBody PrioridadProyectoDTO prioridadProyectoDTO) { + return responseService.successResponse(modelService.update(prioridadProyectoDTO), "Prioridad actualizada"); + } + +} diff --git a/src/main/java/com/example/project/management/exception/ApiResponse.java b/src/main/java/com/example/project/management/exception/ApiResponse.java new file mode 100644 index 0000000..ab1ccc8 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/ApiResponse.java @@ -0,0 +1,16 @@ +package com.example.project.management.exception; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class ApiResponse { + private int status; // Código de estado HTTP + private String message; // Mensaje de estado (éxito o error) + private T data; // Datos relevantes que se devuelven + private String errors; // En caso de error, detalles del mismo +} + diff --git a/src/main/java/com/example/project/management/exception/BadRequestException.java b/src/main/java/com/example/project/management/exception/BadRequestException.java new file mode 100644 index 0000000..919c080 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/BadRequestException.java @@ -0,0 +1,16 @@ +package com.example.project.management.exception; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(value = HttpStatus.BAD_REQUEST) +public class BadRequestException extends RuntimeException { + public BadRequestException(String message) { + super(message); + } +} +/* +* El BadRequestException es una excepcion personalizada que se utiliza para manejar +* errores de validaciones de datos. +* Por ejemplo: Cuando un argumento tiene que tener un tipo de dato correcto. +* */ \ No newline at end of file diff --git a/src/main/java/com/example/project/management/exception/ConflictException.java b/src/main/java/com/example/project/management/exception/ConflictException.java new file mode 100644 index 0000000..921c8b0 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/ConflictException.java @@ -0,0 +1,11 @@ +package com.example.project.management.exception; + +public class ConflictException extends RuntimeException { + public ConflictException(String message) { + super(message); + } +} +/* +* ConflictException se usa para manejar errores de conflictos +* Por ejemplo: Cuando un recurso ya existe. +* */ \ No newline at end of file diff --git a/src/main/java/com/example/project/management/exception/ForbiddenException.java b/src/main/java/com/example/project/management/exception/ForbiddenException.java new file mode 100644 index 0000000..445030e --- /dev/null +++ b/src/main/java/com/example/project/management/exception/ForbiddenException.java @@ -0,0 +1,11 @@ +package com.example.project.management.exception; + +public class ForbiddenException extends RuntimeException { + public ForbiddenException(String message) { + super(message); + } +} +/* +* ForbiddenException sirve para manejar los errores de acceso denegado +* Por ejemplo: Cuando un usuario no tiene permiso para acceder a un recurso. +* */ \ No newline at end of file diff --git a/src/main/java/com/example/project/management/exception/GlobalExceptionHandler.java b/src/main/java/com/example/project/management/exception/GlobalExceptionHandler.java new file mode 100644 index 0000000..6591f62 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/GlobalExceptionHandler.java @@ -0,0 +1,93 @@ +package com.example.project.management.exception; + +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; +import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException; + +@RestControllerAdvice +public class GlobalExceptionHandler { + + // Manejo de BadRequestException (400) + @ExceptionHandler(BadRequestException.class) + public ResponseEntity handleBadRequest(BadRequestException ex) { + ApiResponse response = new ApiResponse<>( + 400, + "Error: Bad Request", + null, + ex.getMessage() + ); + return ResponseEntity.badRequest().body(response); + } + + // Manejo de NotFoundException (404) + @ExceptionHandler(NotFoundException.class) + public ResponseEntity handleNotFound(NotFoundException ex) { + ApiResponse response = new ApiResponse<>( + 404, + "Error: Not Found", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response); + } + @ExceptionHandler(ForbiddenException.class) + public ResponseEntity handleForbidden(ForbiddenException ex) { + ApiResponse response = new ApiResponse<>( + 403, + "Error: Forbidden", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.FORBIDDEN).body(response); + } + + @ExceptionHandler(UnauthorizedException.class) + public ResponseEntity handleUnauthorized(UnauthorizedException ex) { + ApiResponse response = new ApiResponse<>( + 401, + "Error: Unauthorized", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(response); + } + + @ExceptionHandler(ConflictException.class) + public ResponseEntity handleConflict(ConflictException ex) { + ApiResponse response = new ApiResponse<>( + 409, + "Error: Conflict", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.CONFLICT).body(response); + } + + @ExceptionHandler(MethodArgumentTypeMismatchException.class) + public ResponseEntity handleTypeMismatch(MethodArgumentTypeMismatchException ex) { + // Creamos una respuesta en formato JSON con el error + String error = String.format("El parametro enviado '%s' no es del tipo esperado.", ex.getName()); + ApiResponse response = new ApiResponse<>( + 400, + "Error de tipo de argumento", + null, + error + ); + return ResponseEntity.badRequest().body(response); + } + + // Manejo de cualquier otra excepción no controlada (500) + @ExceptionHandler(Exception.class) + public ResponseEntity handleGlobalException(Exception ex) { + ApiResponse response = new ApiResponse<>( + 500, + "Error: Internal Server Error", + null, + "Ocurrió un error inesperado." + ); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response); + } +} + diff --git a/src/main/java/com/example/project/management/exception/GlobalExceptionHandler.java~ b/src/main/java/com/example/project/management/exception/GlobalExceptionHandler.java~ new file mode 100644 index 0000000..e6e24c6 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/GlobalExceptionHandler.java~ @@ -0,0 +1,94 @@ +package com.example.project.management.exception; + +import com.tpi_pais.mega_store.utils.ApiResponse; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; +import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException; + +@RestControllerAdvice +public class GlobalExceptionHandler { + + // Manejo de BadRequestException (400) + @ExceptionHandler(BadRequestException.class) + public ResponseEntity handleBadRequest(BadRequestException ex) { + ApiResponse response = new ApiResponse<>( + 400, + "Error: Bad Request", + null, + ex.getMessage() + ); + return ResponseEntity.badRequest().body(response); + } + + // Manejo de NotFoundException (404) + @ExceptionHandler(NotFoundException.class) + public ResponseEntity handleNotFound(NotFoundException ex) { + ApiResponse response = new ApiResponse<>( + 404, + "Error: Not Found", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response); + } + @ExceptionHandler(ForbiddenException.class) + public ResponseEntity handleForbidden(ForbiddenException ex) { + ApiResponse response = new ApiResponse<>( + 403, + "Error: Forbidden", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.FORBIDDEN).body(response); + } + + @ExceptionHandler(UnauthorizedException.class) + public ResponseEntity handleUnauthorized(UnauthorizedException ex) { + ApiResponse response = new ApiResponse<>( + 401, + "Error: Unauthorized", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(response); + } + + @ExceptionHandler(ConflictException.class) + public ResponseEntity handleConflict(ConflictException ex) { + ApiResponse response = new ApiResponse<>( + 409, + "Error: Conflict", + null, + ex.getMessage() + ); + return ResponseEntity.status(HttpStatus.CONFLICT).body(response); + } + + @ExceptionHandler(MethodArgumentTypeMismatchException.class) + public ResponseEntity handleTypeMismatch(MethodArgumentTypeMismatchException ex) { + // Creamos una respuesta en formato JSON con el error + String error = String.format("El parametro enviado '%s' no es del tipo esperado.", ex.getName()); + ApiResponse response = new ApiResponse<>( + 400, + "Error de tipo de argumento", + null, + error + ); + return ResponseEntity.badRequest().body(response); + } + + // Manejo de cualquier otra excepción no controlada (500) + @ExceptionHandler(Exception.class) + public ResponseEntity handleGlobalException(Exception ex) { + ApiResponse response = new ApiResponse<>( + 500, + "Error: Internal Server Error", + null, + "Ocurrió un error inesperado." + ); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response); + } +} + diff --git a/src/main/java/com/example/project/management/exception/NotFoundException.java b/src/main/java/com/example/project/management/exception/NotFoundException.java new file mode 100644 index 0000000..692ddb5 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/NotFoundException.java @@ -0,0 +1,11 @@ +package com.example.project.management.exception; + +public class NotFoundException extends RuntimeException { + public NotFoundException(String message) { + super(message); + } +} +/* +* NotFoundException se usa para manejar errores de recursos no encontrados. +* Por ejemplo: Cuando el recurso solicitado no existe. +* */ diff --git a/src/main/java/com/example/project/management/exception/ResponseService.java b/src/main/java/com/example/project/management/exception/ResponseService.java new file mode 100644 index 0000000..06f819a --- /dev/null +++ b/src/main/java/com/example/project/management/exception/ResponseService.java @@ -0,0 +1,31 @@ +package com.example.project.management.exception; + +import com.tpi_pais.mega_store.utils.ApiResponse; +import org.springframework.http.ResponseEntity; +import org.springframework.stereotype.Service; + +@Service +public class ResponseService { + + // Método para respuestas exitosas con datos + public ResponseEntity> successResponse(Object data, String message) { + ApiResponse response = new ApiResponse<>( + 200, + message, + data, + null + ); + return ResponseEntity.ok(response); + } + + // Método para respuestas exitosas sin datos (como operaciones sin retorno) + public ResponseEntity> successResponse(String message) { + ApiResponse response = new ApiResponse<>( + 200, + message, + null, + null + ); + return ResponseEntity.ok(response); + } +} diff --git a/src/main/java/com/example/project/management/exception/UnauthorizedException.java b/src/main/java/com/example/project/management/exception/UnauthorizedException.java new file mode 100644 index 0000000..84a9fb6 --- /dev/null +++ b/src/main/java/com/example/project/management/exception/UnauthorizedException.java @@ -0,0 +1,12 @@ +package com.example.project.management.exception; + +public class UnauthorizedException extends RuntimeException { + public UnauthorizedException(String message) { + super(message); + } +} +/* +* UnauthorizedException es una excepcion personalizada que se utiliza para manejar +* errores de autorizaciones. +* Por ejemplo : Cuando el usuario no se ha autenticado y quiere acceder a un recurso. +* */ \ No newline at end of file diff --git a/src/main/java/com/example/project/management/mapper/PrioridadProyectoMapper.java b/src/main/java/com/example/project/management/mapper/PrioridadProyectoMapper.java new file mode 100644 index 0000000..26cac94 --- /dev/null +++ b/src/main/java/com/example/project/management/mapper/PrioridadProyectoMapper.java @@ -0,0 +1,21 @@ +package com.example.project.management.mapper; + +import com.example.project.management.DTO.PrioridadProyectoDTO; +import com.example.project.management.model.PrioridadProyecto; + +public class PrioridadProyectoMapper { + public static PrioridadProyectoDTO toDTO(PrioridadProyecto model) { + PrioridadProyectoDTO dto = new PrioridadProyectoDTO(); + dto.setId(model.getId()); + dto.setPrioridad(model.getPrioridad()); + dto.setFechaEliminacion(model.getFechaEliminacion()); + return dto; + } + + public static PrioridadProyecto toEntity(PrioridadProyectoDTO dto) { + PrioridadProyecto model = new PrioridadProyecto(dto.getPrioridad()); + model.setId(dto.getId()); + model.setFechaEliminacion(dto.getFechaEliminacion()); + return model; + } +} diff --git a/src/main/java/com/example/project/management/model/PrioridadProyecto.java b/src/main/java/com/example/project/management/model/PrioridadProyecto.java new file mode 100644 index 0000000..1b93b59 --- /dev/null +++ b/src/main/java/com/example/project/management/model/PrioridadProyecto.java @@ -0,0 +1,34 @@ +package com.example.project.management.model; + +import jakarta.persistence.*; +import lombok.Data; +import lombok.NonNull; + +import java.time.LocalDateTime; + +@Entity +@Table(name = "prioridad_proyecto") +@Data +public class PrioridadProyecto { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + @Column(name = "nombre" , nullable = false, unique = true) + @NonNull + private String nombre; + + @Column(name = "fecha_eliminacion") + private LocalDateTime fechaEliminacion; + + public void eliminar() { + this.fechaEliminacion = LocalDateTime.now(); + } + + public void recuperar() { + this.setFechaEliminacion(null); + } + + public boolean esEliminado() { return this.fechaEliminacion != null; } + +} diff --git a/src/main/java/com/example/project/management/repository/PrioridadProyectoRepository.java b/src/main/java/com/example/project/management/repository/PrioridadProyectoRepository.java new file mode 100644 index 0000000..63683fb --- /dev/null +++ b/src/main/java/com/example/project/management/repository/PrioridadProyectoRepository.java @@ -0,0 +1,33 @@ +package com.example.project.management.repository; + +import com.example.project.management.model.PrioridadProyecto; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; +import java.util.Optional; + +public interface PrioridadProyectoRepository extends JpaRepository { + + Optional findByNombre(String nombre); + + Optional findByNombreAndFechaEliminacionIsNull(String nombre); + + Optional findByNombreAndFechaEliminacionIsNotNull(String nombre); + + Optional findById(Long id); + + Optional findByIdAndFechaEliminacionIsNull(Long id); + + Optional findByIdAndFechaEliminacionIsNotNull(Long id); + + List findAllByFechaEliminacionIsNull(); + + List findAllByFechaEliminacionIsNotNull(); + + boolean existsByNombre(String nombre); + + boolean existsByNombreAndFechaEliminacionIsNull(String nombre); + + boolean existsByNombreAndFechaEliminacionIsNotNull(String nombre); + +} diff --git a/src/main/java/com/example/project/management/service/IPrioridadProyectoService.java b/src/main/java/com/example/project/management/service/IPrioridadProyectoService.java new file mode 100644 index 0000000..b5dcc76 --- /dev/null +++ b/src/main/java/com/example/project/management/service/IPrioridadProyectoService.java @@ -0,0 +1,38 @@ +package com.example.project.management.service; + +import com.example.project.management.DTO.PrioridadProyectoDTO; +import com.example.project.management.model.PrioridadProyecto; + +import java.util.List; + +public interface IPrioridadProyectoService { + + public List findAllByFechaEliminacionIsNull(); + + public List findAllByFechaEliminacionIsNotNull(); + + public PrioridadProyecto findById(Long id); + + public PrioridadProyecto findByIdAndFechaEliminacionIsNull(Long id); + + public PrioridadProyecto findByIdAndFechaEliminacionIsNotNull(Long id); + + public PrioridadProyecto findByNombre(String nombre); + + public PrioridadProyecto findByNombreAndFechaEliminacionIsNull(String nombre); + + public PrioridadProyecto findByNombreAndFechaEliminacionIsNotNull(String nombre); + + public PrioridadProyecto crear(PrioridadProyectoDTO prioridadProyectoDTO); + + public void deleteById(Long id); + + public void deleteByNombre(String nombre); + + public void recuperarPorId(Long id); + + public void recuperarPorNombre(String nombre); + + public PrioridadProyecto update(PrioridadProyectoDTO prioridadProyectoDTO); + +} diff --git a/src/main/java/com/example/project/management/service/PrioridadProyectoService.java b/src/main/java/com/example/project/management/service/PrioridadProyectoService.java new file mode 100644 index 0000000..8032cae --- /dev/null +++ b/src/main/java/com/example/project/management/service/PrioridadProyectoService.java @@ -0,0 +1,178 @@ +package com.example.project.management.service; + +import com.example.project.management.DTO.PrioridadProyectoDTO; +import com.example.project.management.exception.BadRequestException; +import com.example.project.management.exception.NotFoundException; +import com.example.project.management.mapper.PrioridadProyectoMapper; +import com.example.project.management.model.PrioridadProyecto; +import com.example.project.management.repository.PrioridadProyectoRepository; +import org.springframework.beans.factory.annotation.Autowired; + +import java.util.List; +import java.util.Optional; + +public class PrioridadProyectoService implements IPrioridadProyectoService { + + @Autowired + private PrioridadProyectoRepository prioridadProyectoRepository; + @Override + public List findAllByFechaEliminacionIsNull() { + List prioridades = prioridadProyectoRepository.findAllByFechaEliminacionIsNull(); + return prioridades.stream().map(PrioridadProyectoMapper::toDTO).toList(); + } + + @Override + public List findAllByFechaEliminacionIsNotNull() { + List prioridades = prioridadProyectoRepository.findAllByFechaEliminacionIsNotNull(); + return prioridades.stream().map(PrioridadProyectoMapper::toDTO).toList(); + } + + @Override + public PrioridadProyecto findById(Long id) { + Optional prioridadProyecto = prioridadProyectoRepository.findById(id); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad con id: " + id + "no encontrada"); + } + return prioridadProyecto.get(); + } + + @Override + public PrioridadProyecto findByIdAndFechaEliminacionIsNull(Long id) { + Optional prioridadProyecto = prioridadProyectoRepository.findByIdAndFechaEliminacionIsNull(id); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad con id: " + id + "no encontrada o eliminada"); + } + return prioridadProyecto.get(); + } + + @Override + public PrioridadProyecto findByIdAndFechaEliminacionIsNotNull(Long id) { + Optional prioridadProyecto = prioridadProyectoRepository.findByIdAndFechaEliminacionIsNotNull(id); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad con id: " + id + "no encontrada o no se encuentra eliminada"); + } + return prioridadProyecto.get(); + } + + @Override + public PrioridadProyecto findByNombre(String nombre) { + Optional prioridadProyecto = prioridadProyectoRepository.findByNombre(nombre); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad " + nombre + "no encontrada"); + } + return prioridadProyecto.get(); + } + + @Override + public PrioridadProyecto findByNombreAndFechaEliminacionIsNull(String nombre) { + Optional prioridadProyecto = prioridadProyectoRepository.findByNombreAndFechaEliminacionIsNull(nombre); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad " + nombre + "no encontrada o eliminada"); + } + return prioridadProyecto.get(); + } + + @Override + public PrioridadProyecto findByNombreAndFechaEliminacionIsNotNull(String nombre) { + Optional prioridadProyecto = prioridadProyectoRepository.findByNombreAndFechaEliminacionIsNotNull(nombre); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad " + nombre + "no encontrada o no se encuentra eliminada"); + } + return prioridadProyecto.get(); + } + + @Override + public PrioridadProyecto crear(PrioridadProyectoDTO prioridadProyectoDTO) { + this.tieneNombre(prioridadProyectoDTO); + this.nombreFormato(prioridadProyectoDTO); + this.longitudNombre(prioridadProyectoDTO); + if (prioridadExistente(prioridadProyectoDTO)){ + PrioridadProyecto prioridadProyectoRepetido = this.findByNombre(prioridadProyectoDTO.getNombre()); + if (prioridadProyectoRepetido.esEliminado()){ + prioridadProyectoRepetido.recuperar(); + return prioridadProyectoRepetido; + }else { + throw new BadRequestException("La prioridad ya existe"); + } + } else { + PrioridadProyecto prioridadProyecto = new PrioridadProyecto (prioridadProyectoDTO.getNombre()); + prioridadProyecto.setFechaEliminacion(null); + prioridadProyectoRepository.save(prioridadProyecto); + return prioridadProyecto; + } + } + + public void tieneNombre (PrioridadProyectoDTO prioridadProyectoDTO){ + if (prioridadProyectoDTO.getNombre() == null){ + throw new BadRequestException("Nombre no puede ser nulo"); + } + } + + public void nombreFormato (PrioridadProyectoDTO prioridadProyectoDTO){ + if (!prioridadProyectoDTO.getNombre().matches("[a-zA-Z]+")){ + throw new BadRequestException("El nombre no puede contener caracteres especiales"); + } + } + + public void longitudNombre (PrioridadProyectoDTO prioridadProyectoDTO){ + if (prioridadProyectoDTO.getNombre().length() > 100){ + throw new BadRequestException("Prioridad no puede superar los 100 caracteres"); + } + } + + public boolean prioridadExistente (PrioridadProyectoDTO prioridadProyectoDTO){ + return prioridadProyectoRepository.existsByNombre(prioridadProyectoDTO.getNombre()); + } + + @Override + public void deleteById(Long id) { + PrioridadProyecto prioridadProyecto = this.findByIdAndFechaEliminacionIsNull(id); + prioridadProyecto.eliminar(); + prioridadProyectoRepository.save(prioridadProyecto); + } + + @Override + public void deleteByNombre(String nombre) { + PrioridadProyecto prioridadProyecto = this.findByNombreAndFechaEliminacionIsNull(nombre); + prioridadProyecto.eliminar(); + prioridadProyectoRepository.save(prioridadProyecto); + } + + + @Override + public void recuperarPorId(Long id) { + PrioridadProyecto prioridadProyecto = this.findByIdAndFechaEliminacionIsNotNull(id); + prioridadProyecto.recuperar(); + prioridadProyectoRepository.save(prioridadProyecto); + } + + @Override + public void recuperarPorNombre (String prioridad) { + PrioridadProyecto prioridadProyecto = this.findByNombreAndFechaEliminacionIsNotNull(prioridad); + prioridadProyecto.recuperar(); + prioridadProyectoRepository.save(prioridadProyecto); + } + + @Override + public PrioridadProyecto update (PrioridadProyectoDTO prioridadProyectoDTO) { + Optional prioridadProyecto = prioridadProyectoRepository.findById(prioridadProyectoDTO.getId()); + if (prioridadProyecto.isEmpty()){ + throw new NotFoundException("Prioridad con id: " + prioridadProyectoDTO.getId() + "no encontrada"); + } + this.tieneNombre(prioridadProyectoDTO); + this.nombreFormato(prioridadProyectoDTO); + this.longitudNombre(prioridadProyectoDTO); + if (prioridadExistente(prioridadProyectoDTO)){ + PrioridadProyecto prioridadProyectoRepetido = this.findByNombre(prioridadProyectoDTO.getNombre()); + if (prioridadProyectoRepetido.esEliminado()){ + prioridadProyectoRepetido.recuperar(); + return prioridadProyectoRepetido; + }else { + throw new BadRequestException("La prioridad ya existe"); + } + } + prioridadProyecto.get().setNombre(prioridadProyectoDTO.getNombre()); + prioridadProyectoRepository.save(prioridadProyecto.get()); + return prioridadProyecto.get(); + } +}