Ya estoy inscrito ¿Todavía no tienes acceso? Nuestros Planes
Ya estoy inscrito ¿Todavía no tienes acceso? Nuestros Planes
2
respuestas

error en el filtro a generar nueva consulta

cuando intento crear una nueva cita me aparece este error, Error en el filtro: Request processing failed: org.springframework.dao.InvalidDataAccessApiUsageException: The given id must not be null, pongo en codigo del filtro la entidad usuario y el repositorio package med.voll.api.models;

import jakarta.persistence.; import lombok.; import med.voll.api.dto.UsuarioRegistroDto; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection; import java.util.List;

@Entity(name = "usuarios") @Table(name = "usuario") @NoArgsConstructor @AllArgsConstructor @EqualsAndHashCode(of = "id") @Getter @Setter public class Usuario implements UserDetails { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String username; private String clave;

public Usuario(UsuarioRegistroDto usuarioRegistroDto) {
    this.username = usuarioRegistroDto.username();
    this.clave = usuarioRegistroDto.clave();
}

@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
    return List.of(new SimpleGrantedAuthority("ROLE_USER"));
}

@Override
public String getPassword() {
    return this.clave;
}

@Override
public boolean isAccountNonExpired() {
    return UserDetails.super.isAccountNonExpired();
}

@Override
public boolean isAccountNonLocked() {
    return UserDetails.super.isAccountNonLocked();
}

@Override
public boolean isCredentialsNonExpired() {
    return UserDetails.super.isCredentialsNonExpired();
}

@Override
public boolean isEnabled() {
    return UserDetails.super.isEnabled();
}

}

package med.voll.api.repository;

import med.voll.api.models.Usuario; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.security.core.userdetails.UserDetails;

public interface IUsuarioReposiroty extends JpaRepository<Usuario, Long> {

UserDetails findByUsername(String username);

}

package med.voll.api.filters;

import jakarta.servlet.FilterChain; import jakarta.servlet.ServletException; import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; import lombok.RequiredArgsConstructor; import med.voll.api.auth.TokenService; import med.voll.api.repository.IUsuarioReposiroty; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Component; import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@Component @RequiredArgsConstructor public class FilterSecurity extends OncePerRequestFilter {

private final TokenService tokenService;
private final IUsuarioReposiroty usuarioReposiroty;

@Override
protected void doFilterInternal(
        HttpServletRequest request,
        HttpServletResponse response,
        FilterChain filterChain) throws ServletException, IOException {

    var auth = request.getHeader("Authorization");

    try {
        if (auth != null) {
            var token = auth.replace("Bearer ", "");
            var subject = this.tokenService.getSunject(token);
            if (subject != null) {
                var usuario = this.usuarioReposiroty.findByUsername(subject);
                System.out.println("usuario = " + usuario.toString());
                if (usuario != null) {
                    var authUser = new UsernamePasswordAuthenticationToken(usuario, null,
                            usuario.getAuthorities());
                    SecurityContextHolder.getContext().setAuthentication(authUser);
                } else {
                    System.out.println("Usuario no encontrado");
                }
            } else {
                System.out.println("Token inválido");
            }
        }
        filterChain.doFilter(request, response);
    } catch (Exception e) {
        System.out.println("Error en el filtro: " + e.getMessage());
    }
}

}

2 respuestas

¡Hola Oscar, espero que estés bien!

Entiendo que estás teniendo un error al intentar crear una nueva cita en tu API. El error que estás viendo, "The given id must not be null", sugiere que estás pasando un ID nulo al intentar crear la cita.

Revisando tu código, parece que estás utilizando el ID de usuario para la creación de la cita, y es posible que no esté siendo pasado correctamente o esté llegando como nulo.

Dado que estás utilizando Spring Boot, es importante asegurarse de que el ID del usuario se esté pasando correctamente al crear la cita.

Podrías revisar el código donde se realiza la creación de la cita y asegurarte de que el ID del usuario se esté pasando de manera adecuada.

Además, es importante verificar que el usuario que estás intentando utilizar para crear la cita exista en la base de datos. Puedes imprimir el usuario obtenido del repositorio antes de crear la cita para asegurarte de que esté siendo recuperado correctamente.

Espero que estas sugerencias te ayuden a resolver el problema. ¡Buena suerte con tu proyecto!

Espero haber ayudado y buenos estudios!

Buenos dias te paso mi dto servicio repositorio y controller

package med.voll.api.dto;

import java.time.LocalDateTime;

public record DatosReservaConsulta(

    Long idMedico,
    @NotNull
    Long idPaciente,
    @NotNull
    @Future
    @JsonFormat(pattern = "dd/MM/yyyy HH:mm")
    LocalDateTime fecha,
    EspecialidadMedico especialidad

) { }

package med.voll.api.repository;

import med.voll.api.models.Consulta; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query;

import java.time.LocalDateTime;

public interface IConsultaReposiroty extends JpaRepository<Consulta, Long> {

boolean existsByPacienteIdAndFechaBetween(Long id, LocalDateTime inico, LocalDateTime fin);

boolean existsByMedicoIdAndFecha(Long aLong, LocalDateTime fecha);

}

package med.voll.api.services;

import java.util.List;

@Service @RequiredArgsConstructor public class ConsultaService { private final IConsultaReposiroty consultaReposiroty; private final IMedicoRepository medicoRepository; private final IPacienteRepository pacienteRepository;

private final List<IValidadorDeConsultas> validadores;

Pageable pageable = PageRequest.of(0, 1);

public void crearReserva(DatosReservaConsulta datos) {
    if (!this.pacienteRepository.existsById(datos.idPaciente())) {
        throw new ValidacionExecpcion("Paciente no Encontrado.");
    }
    if (datos.idMedico() != null && !this.medicoRepository.existsById(datos.idPaciente())) {
        throw new ValidacionExecpcion("Medico no Encontrado.");
    }

    validadores.forEach(v -> v.validar(datos));

    var medico = elegirMedico(datos);
    var paciente = this.pacienteRepository.findById(datos.idPaciente()).get();

    var consulta = new Consulta(null, datos.fecha(), medico, paciente, null);
    this.consultaReposiroty.save(consulta);
}

private Medico elegirMedico(DatosReservaConsulta datos) {
    if (datos.idMedico() != null) {
        return this.medicoRepository.getReferenceById(datos.idMedico());
    }
    if (datos.especialidad() == null) {
        throw new ValidacionExecpcion("No se Ingreso una Especialidad, Ingrese Una.");
    }
    List<Medico> medicos = this.medicoRepository.elegirMedicoAleatorio(datos.especialidad(), datos.fecha(), pageable);

    // Validar si se obtuvo un médico
    if (medicos.isEmpty()) {
        throw new ValidacionExecpcion("No se encontró ningún médico disponible para la especialidad y" +
                " fecha indicadas.");
    }

    return medicos.get(0);
}

public void cancelar(DatosCancelacion datosCancelacion) {
    if (!consultaReposiroty.existsById(datosCancelacion.idConsulta())) {
        throw new ValidacionExecpcion("Id de la consulta informado no existe!");
    }
    var consulta = consultaReposiroty.getReferenceById(datosCancelacion.idConsulta());
    consulta.cancelar(datosCancelacion.motivo());
}

}

package med.voll.api.controllers;

@RestController @RequestMapping("/consulta") @RequiredArgsConstructor public class ConsultaController {

private final ConsultaService consultaService;

@PostMapping
public ResponseEntity crearConsulta(DatosReservaConsulta datos){
    this.consultaService.crearReserva(datos);
    return ResponseEntity.ok().build();
}

@DeleteMapping
public ResponseEntity cancelarConsulta(DatosCancelacion datosCancelacion){
    this.consultaService.cancelar(datosCancelacion);
    return  ResponseEntity.noContent().build();
}

}

@Entity(name = "Consulta") @Table(name = "consulta") @NoArgsConstructor @Getter @Setter @AllArgsConstructor @EqualsAndHashCode(of = "id") public class Consulta { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;

private LocalDateTime fecha;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "medico_id")
private Medico medico;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "paciente_id")
private Paciente paciente;

@Column(name = "motivo_cancelamiento")
@Enumerated(EnumType.STRING)
private MotivoCancelamiento motivoCancelamiento;

public void cancelar(@NotNull MotivoCancelamiento motivo) {
    this.motivoCancelamiento = motivo;
}

} muchas gracias