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

Haga lo que aprendimos en aula en el aula:

Serie.java
package com.aluracursos.screenmatch.model;

import jakarta.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "series")
public class Serie {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String titulo;

@Enumerated(EnumType.STRING)
private Categoria genero;

private Integer totalTemporadas;
private Double evaluacion;

@OneToMany(mappedBy = "serie", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Episodio> episodios = new ArrayList<>();

public Serie() {}

public Serie(DatosSerie datos) {
    this.titulo = datos.titulo();
    this.genero = Categoria.fromString(datos.genero());
    this.totalTemporadas = datos.totalTemporadas();
    this.evaluacion = datos.evaluacion();
}

public void addEpisodio(Episodio episodio) {
    episodios.add(episodio);
    episodio.setSerie(this);
}

// getters
public String getTitulo() { return titulo; }
public Categoria getGenero() { return genero; }
public Integer getTotalTemporadas() { return totalTemporadas; }
public Double getEvaluacion() { return evaluacion; }

@Override
public String toString() {
    return titulo + " | " + genero + " | " + evaluacion;
}

}

Episodio.java
package com.aluracursos.screenmatch.model;

import jakarta.persistence.*;
import java.time.LocalDate;
import java.time.format.DateTimeParseException;

@Entity
@Table(name = "episodios")
public class Episodio {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private Integer temporada;
private String titulo;
private Integer numeroEpisodio;
private Double evaluacion;
private LocalDate fechaDeLanzamiento;

@ManyToOne
@JoinColumn(name = "serie_id")
private Serie serie;

public Episodio() {}

public Episodio(Integer temporada, DatosEpisodio d) {
    this.temporada = temporada;
    this.titulo = d.titulo();
    this.numeroEpisodio = d.numeroEpisodio();

    try {
        this.evaluacion = Double.valueOf(d.evaluacion());
    } catch (NumberFormatException e) {
        this.evaluacion = 0.0;
    }

    try {
        this.fechaDeLanzamiento = LocalDate.parse(d.fechaDeLanzamiento());
    } catch (DateTimeParseException e) {
        this.fechaDeLanzamiento = null;
    }
}

public void setSerie(Serie serie) {
    this.serie = serie;
}

}

3️⃣ Categoria.java
package com.aluracursos.screenmatch.model;

public enum Categoria {

ACCION,
DRAMA,
COMEDIA,
ROMANCE,
CRIMEN;

public static Categoria fromEspanol(String texto) {
    return Categoria.valueOf(texto.toUpperCase());
}

public static Categoria fromString(String texto) {
    return Categoria.valueOf(texto.split(",")[0].toUpperCase());
}

}

4️⃣ SerieRepository.java
package com.aluracursos.screenmatch.repository;

import com.aluracursos.screenmatch.model.Categoria;
import com.aluracursos.screenmatch.model.Serie;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;
import java.util.Optional;

public interface SerieRepository extends JpaRepository<Serie, Long> {

Optional<Serie> findByTituloContainingIgnoreCase(String titulo);

List<Serie> findTop5ByOrderByEvaluacionDesc();

List<Serie> findByGenero(Categoria categoria);

List<Serie> findByTotalTemporadasLessThanEqualAndEvaluacionGreaterThanEqual(
        int totalTemporadas,
        double evaluacion
);

}

2 respuestas

public class Principal {

private Scanner teclado = new Scanner(System.in);
private SerieRepository repository;

public Principal(SerieRepository repository) {
    this.repository = repository;
}

public void muestraElMenu() {
    int opcion = -1;

    while (opcion != 0) {
        System.out.println("""
            4 - Buscar serie por título
            5 - Top 5 series
            6 - Buscar series por categoría
            7 - Filtrar series
            0 - Salir
            """);

        opcion = teclado.nextInt();
        teclado.nextLine();
        switch (opcion) {
            case 4 -> buscarSeriePorTitulo();
            case 5 -> buscarTop5Series();
            case 6 -> buscarSeriesPorCategoria();
            case 7 -> filtrarSeriesPorTemporadaYEvaluacion();
            case 0 -> System.out.println("Cerrando aplicación...");
            default -> System.out.println("Opción inválida");
        }
    }
}



    Optional<Serie> serie = repository.findByTituloContainingIgnoreCase(nombre);
    serie.ifPresentOrElse(
            System.out::println,
            () -> System.out.println("Serie no encontrada")
    );
}

private void buscarTop5Series() {
    List<Serie> top = repository.findTop5ByOrderByEvaluacionDesc();
    top.forEach(s ->
            System.out.println(s.getTitulo() + " ⭐ " + s.getEvaluacion())
    );
}

private void buscarSeriesPorCategoria() {
    System.out.println("Categoría:");
    var genero = teclado.nextLine();
    Categoria categoria = Categoria.fromEspanol(genero);

    repository.findByGenero(categoria)
            .forEach(System.out::println);
}

private void filtrarSeriesPorTemporadaYEvaluacion() {
    System.out.println("Máximo de temporadas:");
    int temporadas = teclado.nextInt();

    System.out.println("Evaluación mínima:");
    double evaluacion = teclado.nextDouble();
    teclado.nextLine();

    repository
        .findByTotalTemporadasLessThanEqualAndEvaluacionGreaterThanEqual(
                temporadas, evaluacion)
        .forEach(s ->
            System.out.println(s.getTitulo() + " - " + s.getEvaluacion())
        );
}

}

Hola Alexis, espero que estés bien

Parece que estás trabajando en un desafío para filtrar series por varios criterios usando Spring Data JPA. Según el contexto, necesitas crear una consulta que busque series con un número máximo de temporadas y una evaluación mínima.

Basándome en el código que compartiste, ya tienes un método en tu SerieRepository que parece cumplir con estos requisitos:

List<Serie> findByTotalTemporadasLessThanEqualAndEvaluacionGreaterThanEqual(
        int totalTemporadas,
        double evaluacion
);

Este método derivado debería permitirte buscar series que tengan un número de temporadas menor o igual al especificado y una evaluación mayor o igual a la que indiques. Por ejemplo, podrías usarlo de la siguiente manera:

List<Serie> seriesFiltradas = serieRepository.findByTotalTemporadasLessThanEqualAndEvaluacionGreaterThanEqual(5, 8.0);

Este ejemplo buscaría todas las series con un máximo de 5 temporadas y una evaluación de al menos 8.0.

Espero que esta explicación te sea de ayuda y te permita avanzar con tu desafío. ¡Bons estudios!