Código Relevante para el Examen según la Clase de Repaso, Apuntes

Código Relevante para el Examen

Basándome en la clase de repaso, voy a extraer el código más relevante para el examen, organizándolo según las capas de arquitectura y los conceptos clave mencionados por Tomás.

Estructura de una Entidad JPA

Vacante Entity con Relaciones

java

@Entity
@Table(name = "vacantes")
public class Vacante {
@Id
@GeneratedValue(strategy = GenerationType. IDENTITY)
@Column(name = "id_vacante" )
private int idVacante;
private String nombre;
private String descripcion;
@Temporal(TemporalType. DATE)
private Date fecha;
private double salario;
@Column(nullable = false)
@Enumerated(EnumType. STRING)
private Estatus estatus;
// Relación ManyToOne con Categoria
@ManyToOne
@JoinColumn(name = "id_categoria", referencedColumnName =
"id_categoria", nullable = false)
private Categoria categoria;
// Relación ManyToOne con Empresa
@ManyToOne@JoinColumn(name = "id_empresa", referencedColumnName =
"id_empresa", nullable = false)
private Empresa empresa;
Constructor, getters y setters
}

Repository (Interfaz para Acceso a Datos)

Ejemplo Básico de VacanteRepository

java

@Repository
public interface VacanteRepository extends JpaRepository<Vacante,
Integer> {
}

Métodos Personalizados en VacanteRepository

Con métodos personalizados (derivados):

java

@Repository
public interface VacanteRepository extends JpaRepository<Vacante,
Integer> {
// Buscar vacantes por id de empresa
List<Vacante> findByEmpresaId(int idEmpresa);
// Buscar vacantes por empresa
List<Vacante> findByEmpresa(Empresa empresa);
}

Consulta @Query en VacanteRepository

Con consulta @Query:

java

@Repository
public interface VacanteRepository extends JpaRepository<Vacante,
Integer> {
@Query( "select v from Vacante v where v. empresa . id_empresa = ? 1")
List<Vacante> findByEmpresaId(int id_empresa);
}

Service (Interfaz)

Interfaz VacanteService

java

public interface VacanteService {
// Métodos CRUD básicos
Vacante alta(Vacante vacante);
Vacante modificar(Vacante vacante);
int eliminar(int id);
Vacante buscarUna(int id);
List<Vacante> buscarTodos();
// Método personalizado para el caso de uso específico
List<Vacante> vacantesPorEmpresa(int id_empresa);
}

ServiceImpl (Implementación)

Implementación de VacanteServiceImpl

java

@Service
public class VacanteServiceImpl implements VacanteService {
@Autowired
private VacanteRepository vacanteRepository;
@Override
public Vacante alta(Vacante vacante) {
try {
if (vacanteRepository . existsById(vacante. getIdVacante( )))
return null;
else
return vacanteRepository. save(vacante);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public Vacante modificar(Vacante vacante) {
try {if (vacanteRepository. existsById(vacante. getIdVacante( ) ))
return vacanteRepository. save(vacante);
else
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public int eliminar(int id) {
try {
if (vacanteRepository. existsById(id)) {
vacanteRepository.deleteById(id);
return 1;
}
return 0;
} catch (Exception e) {
e.printStackTrace();
return -1;
}
}
@Override
public Vacante buscarUna(int id) {
return vacanteRepository. findById(id) . orElse(null);
}
@Override
public List<Vacante> buscarTodos() {
return vacanteRepository. findAll( );
}
@Override
public List<Vacante> vacantesPorEmpresa(int id_empresa) {return vacanteRepository. findByEmpresaId(id_empresa);
}
}

DTO y Mapper

VacanteDto (Data Transfer Object)

java

public class VacanteDto {
private int idVacante;
private String nombre;
private String descripcion;
private Date fecha;
private double salario;
private Estatus estatus;
private Byte destacado;
private String imagen;
private String detalles;
private int id_categoria;
private int id_empresa;
// Constructor, getters y setters
}

VacanteMapper (Convertir entre Entity y DTO)

java

public class VacanteMapper {
// Convertir de Entity a DTO
public static VacanteDto toDto(Vacante vacante) {
return new VacanteDto(
vacante.getIdVacante(),
vacante.getNombre(),
vacante.getDescripcion(),
vacante.getFecha(),
vacante. getSalario(),
vacante. getEstatus(),
vacante.getDestacado(),vacante.getImagen(),
vacante.getDetalles(),
vacante.getCategoria( ).getId_categoria(),
vacante . getEmpresa( ).getId_empresa()
);
}
// Convertir de DTO a Entity
public static Vacante toEntity(VacanteDto dto, Categoria
categoria, Empresa empresa) {
if (dto == null) {
return null;
}
Vacante vacante = new Vacante(
dto. getIdVacante(),
dto.getNombre(),
dto. getDescripcion(),
dto. getFecha(),
dto. getSalario(),
dto. getEstatus(),
dto. getDestacado(),
dto.getImagen(),
dto.getDetalles(),
categoria,
empresa
);
return vacante;
}
}

RestController

VacanteController

java

@RestController
@RequestMapping( "/vacantes" )
public class VacanteController {@Autowired
VacanteService vacanteService;
@Autowired
EmpresaService empresaService;
@Autowired
CategoriaService categoriaService;
// Dar de alta una vacante
@PostMapping( "/alta")
public ResponseEntity<VacanteDto> alta(@RequestBody VacanteDto
vacanteDto, int id_categoria, int id_empresa) {
Empresa empresa = empresaService. buscarUna(id_empresa);
Categoria categoria =
categoriaService.buscarUna(id_categoria);
return ResponseEntity . ok(
VacanteMapper . toDto(
vacanteService. alta(
VacanteMapper. toEntity(vacanteDto, categoria,
empresa )
)
)
);
}
// Actualizar una vacante existente
@PutMapping( "/modificar")
public ResponseEntity<VacanteDto> modificar(@RequestBody
VacanteDto vacanteDto, int id_categoria, int id_empresa) {
Empresa empresa = empresaService. buscarUna(id_empresa);
Categoria categoria =
categoriaService. buscarUna(id_categoria);
return ResponseEntity. ok(
VacanteMapper. toDto(
vacanteService.modificar(VacanteMapper. toEntity(vacanteDto, categoria,
empresa)
)
)
);
}
// Eliminar una vacante
@DeleteMapping("/eliminar/ {idVacante} ")
public ResponseEntity<Integer> eliminar(@PathVariable int
idVacante) {
return ResponseEntity. ok(vacanteService. eliminar(idVacante ) );
}
// Buscar una vacante por id
@GetMapping("/uno/{idVacante}")
public ResponseEntity<VacanteDto> buscarUno(@PathVariable int
idVacante) {
return ResponseEntity. ok(
VacanteMapper . toDto(
vacanteService. buscarUna(idVacante)
)
);
}
// Listar todas las vacantes
@GetMapping( "/todos")
public ResponseEntity<List<VacanteDto>> buscarTodos() {
return ResponseEntity. ok(
vacanteService. buscarTodos()
. stream( )
. map (VacanteMapper : : toDto)
. collect (Collectors. toList( ))
);
}
// Buscar vacantes por empresa - EJEMPLOS DE POSIBLE EJERCICIO
PRÁCTICO@GetMapping("/empresa/{idEmpresa}")
public ResponseEntity<List<VacanteDto>>
buscarPorEmpresa(@PathVariable int idEmpresa) {
return ResponseEntity. ok(
vacanteService . vacantesPorEmpresa(idEmpresa)
. stream( )
. map (VacanteMapper : : toDto)
. collect (Collectors. toList( ))
);
}
}

Configuración de Seguridad

SecurityConfig (Mencionada como Importante)

java

@Configuration
@EnableWebSecurity
public class SecurityConfig {
// Configuración de usuarios desde la base de datos
@Bean
UserDetailsManager userDetailsManager(DataSource dataSource) {
JdbcUserDetailsManager users = new
JdbcUserDetailsManager(dataSource);
// Consulta SQL para obtener usuario (en este caso por email)
users. setUsersByUsernameQuery( "SELECT email, password, enabled
FROM usuarios WHERE email = ? ");
// Consulta SQL para obtener roles
users. setAuthoritiesByUsernameQuery( "SELECT email, rol FROM
usuarios WHERE email = ? ");
return users;
}
// Configuración de cifrado de contraseñas
@Bean
PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder( );
}// Configuración de rutas y permisos
@Bean
SecurityFilterChain securityFilterChain(HttpSecurity http) throws
Exception {
http.csrf(csrf -> csrf.disable()) // Deshabilitar CSRF para
API REST
. authorizeHttpRequests (auth -> auth
// Rutas públicas
.requestMatchers( "/auth/signup", "/swagger-
ui/ ** ", "/v3/api-docs/ ** ").permitAll()
// Rutas privadas
. requestMatchers( "/vacantes/ ** " ) . hasAnyAuthority( "CLIENTE", "ADMON",
" EMPRESA" )
. requestMatchers ( "/empresas/ ** " ) . hasAnyAuthority ( "EMPRESA", "ADMON" )
. requestMatchers( "/categorias/ ** " ) . hasAnyAuthority( "EMPRESA", "ADMON")
. requestMatchers( "/solicitudes/ ** " ) . hasAnyAuthority( "EMPRESA",
"ADMON", "CLIENTE")
// Cualquier otra requiere autenticación
. anyRequest( ) . authenticated( ))
. httpBasic(withDefaults( )) // Configurar autenticación
básica
. logout ( logout -> logout. permitAll( )); // Configurar
logout
return http.build();
}
}

Peticiones del Examen Práctico

Ejemplo 1: Consultar Solicitudes de un Usuario por Email

java

// En SolicitudRepository
@Repositorypublic interface SolicitudRepository extends JpaRepository<Solicitud,
Integer> {
List<Solicitud> findByUsuario(Usuario usuario);
}
// En SolicitudService
public interface SolicitudService {
// Otros métodos. ..
List<Solicitud> obtenerSolicitudesPorUsuario(String email);
}
// En SolicitudServiceImpl
@Service
public class SolicitudServiceImpl implements SolicitudService {
@Autowired
private SolicitudRepository solicitudRepository;
@Autowired
private UsuarioRepository usuarioRepository;
// Otros métodos. ..
@Override
public List<Solicitud> obtenerSolicitudesPorUsuario(String email)
{
Usuario usuario = usuarioRepository.findByEmail(email);
if (usuario == null) {
return new ArrayList<>();
}
return solicitudRepository. findByUsuario(usuario);
}
}
// En SolicitudController
@RestController
@RequestMapping( "/solicitudes" )
public class SolicitudController {@Autowired
private SolicitudService solicitudService;
// Otros métodos. ..
@GetMapping( "/usuario/{email} ")
public ResponseEntity<List<SolicitudDto>>
buscarPorUsuario(@PathVariable String email) {
List<Solicitud> solicitudes =
solicitudService. obtenerSolicitudesPorUsuario(email);
if (solicitudes. isEmpty()) {
return ResponseEntity. notFound( ). build( );
}
return ResponseEntity. ok(
solicitudes.stream()
. map(SolicitudMapper : : toDto)
. collect (Collectors. toList( ))
);
}
}

Ejemplo 2: Obtener Todas las Vacantes de una Empresa

java

// En VacanteRepository
@Repository
public interface VacanteRepository extends JpaRepository<Vacante,
Integer> {
List<Vacante> findByEmpresaId(int idEmpresa);
}
// En VacanteService
public interface VacanteService {
// Otros métodos ...
List<Vacante> vacantesPorEmpresa(int idEmpresa);
}
// En VacanteServiceImpl