From bb31745c5da1ce720e1bf45acad8fa6e39379c81 Mon Sep 17 00:00:00 2001
From: verdoso <Verdoso@users.noreply.github.com>
Date: Tue, 21 Dec 2021 19:44:27 +0100
Subject: [PATCH] =?UTF-8?q?Implementaci=C3=B3n=20de=20libros=20descartados?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Se añade un atributo y la funcionalidad para actualizarlo, de forma que
si marcamos un libro como descartado, cuando ocultemos los libros que
tenemos también se oculten los descartados.
---
 src/main/frontend/src/vue/biblioteca.vue      |  70 +++-
 .../controller/PreferencesAPIController.java  |  18 +-
 .../greeneyed/epl/librarian/model/Libro.java  | 333 +++++++++---------
 .../librarian/services/BibliotecaService.java |  61 +++-
 .../services/PreferencesService.java          |  42 +++
 .../services/model/BusquedaLibro.java         | 154 ++++----
 6 files changed, 409 insertions(+), 269 deletions(-)

diff --git a/src/main/frontend/src/vue/biblioteca.vue b/src/main/frontend/src/vue/biblioteca.vue
index 0d599ce..ca8e7a9 100644
--- a/src/main/frontend/src/vue/biblioteca.vue
+++ b/src/main/frontend/src/vue/biblioteca.vue
@@ -36,7 +36,7 @@
             v-model="soloNoEnPropiedad"
             @input="cambioSoloNoEnPropiedad()"
             v-if="integracioncalibre"
-          >Ocultar los que ya tengo</b-switch>
+          >Ocultar los que tengo/descartados</b-switch>
         </p>
       </b-field>
     </div>
@@ -160,6 +160,28 @@
           :icon="props.row.inCalibre ? 'check' : 'times'"
         ></b-icon>
       </b-table-column>
+      <b-table-column
+        field="descartado"
+        label="Descarte"
+        :visible="integracioncalibre"
+        width="5%"
+        v-slot="props"
+      >
+        <b-tooltip
+          :type="!props.row.descartado ? 'is-danger' : 'is-success'"
+          :label="props.row.descartado ? 'Mostrar' : 'Descartar'"
+          >
+          <b-button
+            size="is-small"
+            outlined
+            rounded
+            icon-pack="fa"
+            :type="props.row.descartado ? 'is-danger' : 'is-success'"
+            :icon-right="props.row.descartado ? 'eye-slash' : 'eye'"
+            @click="descartar(props.row)"
+            />
+        </b-tooltip>
+      </b-table-column>
       <template #detail="props">
         <article class="media">
           <figure class="media-left">
@@ -285,13 +307,17 @@ export default {
           data.results.forEach(item => {
             this.data.push(item);
           });
-          this.loading = false;
+          this.$nextTick(() => {
+            this.loading = false;
+          });
         })
         .catch(error => {
-          this.data = [];
-          this.total = 0;
-          throw error;
-          this.loading = false;
+          this.$nextTick(() => {
+            this.data = [];
+            this.total = 0;
+            throw error;
+            this.loading = false;
+          });
         });
     },
     /*
@@ -372,6 +398,36 @@ export default {
     cambioSoloNoEnPropiedad() {
       this.loadAsyncData();
     },
+    descartar(libro) {
+      var formData = new FormData();
+      formData.append("id", libro.id);
+      formData.append("descartado", !libro.descartado);
+      axios
+        .post("/librarian/preferences/descarte", formData, {
+          headers: { "Content-Type": "multipart/form-data" }
+        })
+        .then(response => {
+          libro.descartado = !libro.descartado;
+          this.$buefy.notification.open({
+            type: "is-info",
+            duration: 2000,
+            message: `${libro.titulo} ${libro.descartado? 'descartado' : 'mostrado'}`,
+            hasIcon: true
+          });
+          if (libro.descartado && this.soloNoEnPropiedad) {
+            this.loadAsyncData();
+          }
+        })
+        .catch(error => {
+          this.$buefy.notification.open({
+            type: "is-danger",
+            duration: 2000,
+            message: "Error descartando libro: " + error,
+            hasIcon: true
+          });
+          throw error;
+        });
+    },
     guardarFechaBase() {
       if (this.fechaBase) {
         var formData = new FormData();
@@ -397,7 +453,7 @@ export default {
             this.$buefy.notification.open({
               type: "is-danger",
               duration: 5000,
-              message: "Error almacenando fecha base: " + e,
+              message: "Error almacenando fecha base: " + error,
               hasIcon: true
             });
             throw error;
diff --git a/src/main/java/org/greeneyed/epl/librarian/controller/PreferencesAPIController.java b/src/main/java/org/greeneyed/epl/librarian/controller/PreferencesAPIController.java
index 5437856..c95d498 100644
--- a/src/main/java/org/greeneyed/epl/librarian/controller/PreferencesAPIController.java
+++ b/src/main/java/org/greeneyed/epl/librarian/controller/PreferencesAPIController.java
@@ -38,23 +38,31 @@ public ResponseEntity<Long> fechaBase() {
                 .orElseGet(OK_BUILDER::build);
     }
 
-    @PostMapping(value = "/fecha_base", produces = MediaType.TEXT_HTML_VALUE )
+    @PostMapping(value = "/fecha_base", produces = MediaType.TEXT_HTML_VALUE)
     public ResponseEntity<String> guardarFechaBase(@RequestParam(name = "fechaBase") long fechaBaseLong) {
         preferencesService
                 .setFechaBase(Instant.ofEpochMilli(fechaBaseLong).atZone(ZoneId.systemDefault()).toLocalDate());
         return OK_BUILDER.build();
     }
 
-    @PostMapping(value = "/autoresFavoritos", produces = MediaType.TEXT_HTML_VALUE )
+    @PostMapping(value = "/descarte", produces = MediaType.TEXT_HTML_VALUE)
+    public ResponseEntity<String> descartarLibro(@RequestParam(name = "id") Integer libroId,
+            @RequestParam(name = "descartado") boolean descartado) {
+        preferencesService.setDescarte(libroId, descartado);
+        bibliotecaService.setDescarte(libroId, descartado);
+        return OK_BUILDER.build();
+    }
+
+    @PostMapping(value = "/autoresFavoritos", produces = MediaType.TEXT_HTML_VALUE)
     public ResponseEntity<String> guardarAutoresFavoritos(
             @RequestParam(name = "autoresFavoritos") Set<String> autoresFavoritos,
             @RequestParam(name = "autoresNoFavoritos") Set<String> autoresNoFavoritos) {
         preferencesService.actualizarAutoresPreferidos(autoresFavoritos, autoresNoFavoritos);
-        bibliotecaService.actualizaAutoresFavoritos(preferencesService.getAutoresPreferidos());
+        bibliotecaService.actualizaAutoresPreferidos(preferencesService.getAutoresPreferidos());
         return OK_BUILDER.body("OK");
     }
 
-    @PostMapping(value = "/idiomasFavoritos", produces = MediaType.TEXT_HTML_VALUE )
+    @PostMapping(value = "/idiomasFavoritos", produces = MediaType.TEXT_HTML_VALUE)
     public ResponseEntity<String> guardarIdiomasFavoritos(
             @RequestParam(name = "idiomasFavoritos") Set<String> idiomasFavoritos,
             @RequestParam(name = "idiomasNoFavoritos") Set<String> idiomasNoFavoritos) {
@@ -63,7 +71,7 @@ public ResponseEntity<String> guardarIdiomasFavoritos(
         return OK_BUILDER.body("OK");
     }
 
-    @PostMapping(value = "/generosFavoritos", produces = MediaType.TEXT_HTML_VALUE )
+    @PostMapping(value = "/generosFavoritos", produces = MediaType.TEXT_HTML_VALUE)
     public ResponseEntity<String> guardarGenerosFavoritos(
             @RequestParam(name = "generosFavoritos") Set<String> generosFavoritos,
             @RequestParam(name = "generosNoFavoritos") Set<String> generosNoFavoritos) {
diff --git a/src/main/java/org/greeneyed/epl/librarian/model/Libro.java b/src/main/java/org/greeneyed/epl/librarian/model/Libro.java
index 3aabec2..e8eb569 100644
--- a/src/main/java/org/greeneyed/epl/librarian/model/Libro.java
+++ b/src/main/java/org/greeneyed/epl/librarian/model/Libro.java
@@ -26,169 +26,174 @@
 @EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Libro {
 
-	private static final String LIBRO_ID_PARAM = "libroID";
-	private static final String LIBRO_TITULO_PARAM = "libroTITULO";
-	private static final String LIBRO_AUTOR_PARAM = "libroAUTOR";
-	private static final String LIBRO_AUTOR_FAVORITO_PARAM = "libroAUTOR_FAVORITO";
-	private static final String LIBRO_COLECCION_PARAM = "libroCOLECCION";
-	private static final String LIBRO_GENERO_PARAM = "libroGENERO";
-	private static final String LIBRO_GENERO_FAVORITO_PARAM = "libroGENERO_FAVORITO";
-	private static final String LIBRO_IDIOMA_PARAM = "libroIDIOMA";
-	private static final String LIBRO_IDIOMA_FAVORITO_PARAM = "libroIDIOMA_FAVORITO";
-	private static final String LIBRO_VOLUMEN_PARAM = "libroVOLUMEN";
-	private static final String LIBRO_PUBLICADO_PARAM = "libroPUBLICADO";
-	private static final String LIBRO_EN_CALIBRE_PARAM = "libroEN_CALIBRE";
-
-	public static final SimpleAttribute<Libro, Integer> LIBRO_ID = attribute(Libro.class, Integer.class, LIBRO_ID_PARAM,
-			Libro::getId);
-	public static final SimpleAttribute<Libro, String> LIBRO_TITULO = attribute(Libro.class, String.class,
-			LIBRO_TITULO_PARAM, Libro::getTituloNormalizado);
-	public static final SimpleAttribute<Libro, String> LIBRO_AUTOR = attribute(Libro.class, String.class,
-			LIBRO_AUTOR_PARAM, Libro::getAutorNormalizado);
-	public static final SimpleAttribute<Libro, Boolean> LIBRO_AUTOR_FAVORITO = attribute(Libro.class, Boolean.class,
-			LIBRO_AUTOR_FAVORITO_PARAM, Libro::getAutorFavorito);
-	public static final SimpleAttribute<Libro, String> LIBRO_IDIOMA = attribute(Libro.class, String.class,
-			LIBRO_IDIOMA_PARAM, Libro::getIdiomaNormalizado);
-	public static final SimpleAttribute<Libro, Boolean> LIBRO_IDIOMA_FAVORITO = attribute(Libro.class, Boolean.class,
-			LIBRO_IDIOMA_FAVORITO_PARAM, Libro::getIdiomaFavorito);
-	public static final SimpleAttribute<Libro, Boolean> LIBRO_EN_CALIBRE = attribute(Libro.class, Boolean.class,
-			LIBRO_EN_CALIBRE_PARAM, Libro::getInCalibre);
-	public static final SimpleNullableAttribute<Libro, ChronoLocalDate> LIBRO_PUBLICADO = nullableAttribute(Libro.class,
-			ChronoLocalDate.class, LIBRO_PUBLICADO_PARAM, Libro::getFechaPublicacion);
-	public static final SimpleNullableAttribute<Libro, String> LIBRO_COLECCION = nullableAttribute(Libro.class,
-			String.class, LIBRO_COLECCION_PARAM, Libro::getColeccionNormalizada);
-	public static final SimpleNullableAttribute<Libro, BigDecimal> LIBRO_VOLUMEN = nullableAttribute(Libro.class,
-			BigDecimal.class, LIBRO_VOLUMEN_PARAM, Libro::getVolumen);
-	public static final SimpleNullableAttribute<Libro, String> LIBRO_GENERO = nullableAttribute(Libro.class,
-			String.class, LIBRO_GENERO_PARAM, Libro::getGeneroNormalizado);
-	public static final SimpleAttribute<Libro, Boolean> LIBRO_GENERO_FAVORITO = attribute(Libro.class, Boolean.class,
-			LIBRO_GENERO_FAVORITO_PARAM, Libro::getGeneroFavorito);
-
-	@EqualsAndHashCode.Include
-	private int id;
-
-	private String titulo;
-
-	private String autor;
-
-	private String generos;
-
-	private String coleccion;
-
-	private BigDecimal volumen;
-
-	// private int anyoPublicacion;
-
-	private String sinopsis;
-
-	private Integer paginas;
-
-	private BigDecimal revision;
-
-	private String idioma;
-
-	private String publicado;
-
-	private LocalDate fechaPublicacion;
-
-	private String estado;
-
-	// private BigDecimal valoracion;
-
-	// private Integer votos;
-
-	private String magnetId;
-
-	private String portada;
-
-	private Boolean inCalibre = Boolean.FALSE;
-
-	private Boolean autorFavorito = Boolean.FALSE;
-
-	private Boolean generoFavorito = Boolean.FALSE;
-
-	private Boolean idiomaFavorito = Boolean.FALSE;
-
-	@JsonIgnore
-	public List<String> getListaAutores() {
-		if (autor != null) {
-			return Arrays.asList(autor.split(" & "));
-		} else {
-			return Collections.emptyList();
-		}
-	}
-
-	@JsonIgnore
-	public List<String> getListaGeneros() {
-		if (generos != null) {
-			return Arrays.asList(generos.split(","));
-		} else {
-			return Collections.emptyList();
-		}
-	}
-
-	@JsonProperty("magnet_ids")
-	public List<String> getListaMagnetIds() {
-		if (magnetId != null) {
-			return Arrays.asList(magnetId.split(", "));
-		} else {
-			return Collections.emptyList();
-		}
-	}
-
-	public String getColeccionCompleta() {
-		String completa = null;
-		if (coleccion != null) {
-			if (volumen != null) {
-				completa = coleccion + " [" + volumen + "]";
-			} else {
-				completa = coleccion;
-			}
-		}
-		return completa;
-	}
-
-	@JsonIgnore
-	public String getTituloNormalizado() {
-		return flattenToAscii(titulo);
-	}
-
-	@JsonIgnore
-	public String getAutorNormalizado() {
-		return flattenToAscii(autor);
-	}
-
-	@JsonIgnore
-	public String getIdiomaNormalizado() {
-		return flattenToAscii(idioma);
-	}
+    private static final String LIBRO_ID_PARAM = "libroID";
+    private static final String LIBRO_TITULO_PARAM = "libroTITULO";
+    private static final String LIBRO_AUTOR_PARAM = "libroAUTOR";
+    private static final String LIBRO_AUTOR_FAVORITO_PARAM = "libroAUTOR_FAVORITO";
+    private static final String LIBRO_COLECCION_PARAM = "libroCOLECCION";
+    private static final String LIBRO_GENERO_PARAM = "libroGENERO";
+    private static final String LIBRO_GENERO_FAVORITO_PARAM = "libroGENERO_FAVORITO";
+    private static final String LIBRO_IDIOMA_PARAM = "libroIDIOMA";
+    private static final String LIBRO_IDIOMA_FAVORITO_PARAM = "libroIDIOMA_FAVORITO";
+    private static final String LIBRO_VOLUMEN_PARAM = "libroVOLUMEN";
+    private static final String LIBRO_PUBLICADO_PARAM = "libroPUBLICADO";
+    private static final String LIBRO_EN_CALIBRE_PARAM = "libroEN_CALIBRE";
+    private static final String LIBRO_DESCARTADO_PARAM = "libroDESCARTADO";
+
+    public static final SimpleAttribute<Libro, Integer> LIBRO_ID = attribute(Libro.class, Integer.class, LIBRO_ID_PARAM,
+            Libro::getId);
+    public static final SimpleAttribute<Libro, String> LIBRO_TITULO = attribute(Libro.class, String.class,
+            LIBRO_TITULO_PARAM, Libro::getTituloNormalizado);
+    public static final SimpleAttribute<Libro, String> LIBRO_AUTOR = attribute(Libro.class, String.class,
+            LIBRO_AUTOR_PARAM, Libro::getAutorNormalizado);
+    public static final SimpleAttribute<Libro, Boolean> LIBRO_AUTOR_FAVORITO = attribute(Libro.class, Boolean.class,
+            LIBRO_AUTOR_FAVORITO_PARAM, Libro::getAutorFavorito);
+    public static final SimpleAttribute<Libro, String> LIBRO_IDIOMA = attribute(Libro.class, String.class,
+            LIBRO_IDIOMA_PARAM, Libro::getIdiomaNormalizado);
+    public static final SimpleAttribute<Libro, Boolean> LIBRO_IDIOMA_FAVORITO = attribute(Libro.class, Boolean.class,
+            LIBRO_IDIOMA_FAVORITO_PARAM, Libro::getIdiomaFavorito);
+    public static final SimpleAttribute<Libro, Boolean> LIBRO_EN_CALIBRE = attribute(Libro.class, Boolean.class,
+            LIBRO_EN_CALIBRE_PARAM, Libro::getInCalibre);
+    public static final SimpleAttribute<Libro, Boolean> LIBRO_DESCARTADO = attribute(Libro.class, Boolean.class,
+            LIBRO_DESCARTADO_PARAM, Libro::getDescartado);
+    public static final SimpleNullableAttribute<Libro, ChronoLocalDate> LIBRO_PUBLICADO = nullableAttribute(Libro.class,
+            ChronoLocalDate.class, LIBRO_PUBLICADO_PARAM, Libro::getFechaPublicacion);
+    public static final SimpleNullableAttribute<Libro, String> LIBRO_COLECCION = nullableAttribute(Libro.class,
+            String.class, LIBRO_COLECCION_PARAM, Libro::getColeccionNormalizada);
+    public static final SimpleNullableAttribute<Libro, BigDecimal> LIBRO_VOLUMEN = nullableAttribute(Libro.class,
+            BigDecimal.class, LIBRO_VOLUMEN_PARAM, Libro::getVolumen);
+    public static final SimpleNullableAttribute<Libro, String> LIBRO_GENERO = nullableAttribute(Libro.class,
+            String.class, LIBRO_GENERO_PARAM, Libro::getGeneroNormalizado);
+    public static final SimpleAttribute<Libro, Boolean> LIBRO_GENERO_FAVORITO = attribute(Libro.class, Boolean.class,
+            LIBRO_GENERO_FAVORITO_PARAM, Libro::getGeneroFavorito);
+
+    @EqualsAndHashCode.Include
+    private int id;
+
+    private String titulo;
+
+    private String autor;
+
+    private String generos;
+
+    private String coleccion;
+
+    private BigDecimal volumen;
+
+    // private int anyoPublicacion;
+
+    private String sinopsis;
+
+    private Integer paginas;
+
+    private BigDecimal revision;
+
+    private String idioma;
+
+    private String publicado;
+
+    private LocalDate fechaPublicacion;
+
+    private String estado;
+
+    // private BigDecimal valoracion;
+
+    // private Integer votos;
+
+    private String magnetId;
+
+    private String portada;
+
+    private Boolean inCalibre = Boolean.FALSE;
+
+    private Boolean descartado = Boolean.FALSE;
+
+    private Boolean autorFavorito = Boolean.FALSE;
+
+    private Boolean generoFavorito = Boolean.FALSE;
+
+    private Boolean idiomaFavorito = Boolean.FALSE;
+
+    @JsonIgnore
+    public List<String> getListaAutores() {
+        if (autor != null) {
+            return Arrays.asList(autor.split(" & "));
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    @JsonIgnore
+    public List<String> getListaGeneros() {
+        if (generos != null) {
+            return Arrays.asList(generos.split(","));
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    @JsonProperty("magnet_ids")
+    public List<String> getListaMagnetIds() {
+        if (magnetId != null) {
+            return Arrays.asList(magnetId.split(", "));
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    public String getColeccionCompleta() {
+        String completa = null;
+        if (coleccion != null) {
+            if (volumen != null) {
+                completa = coleccion + " [" + volumen + "]";
+            } else {
+                completa = coleccion;
+            }
+        }
+        return completa;
+    }
+
+    @JsonIgnore
+    public String getTituloNormalizado() {
+        return flattenToAscii(titulo);
+    }
+
+    @JsonIgnore
+    public String getAutorNormalizado() {
+        return flattenToAscii(autor);
+    }
 
-	@JsonIgnore
-	public String getColeccionNormalizada() {
-		return flattenToAscii(coleccion);
-	}
-
-	@JsonIgnore
-	public String getGeneroNormalizado() {
-		if (generos != null) {
-			return flattenToAscii(generos).replace(",", "");
-		} else {
-			return null;
-		}
-	}
-
-	public static String flattenToAscii(String string) {
-		if (string != null) {
-			StringBuilder sb = new StringBuilder(string.length());
-			string = Normalizer.normalize(string.toLowerCase(), Normalizer.Form.NFD);
-			for (char c : string.toCharArray()) {
-				if (c <= '\u007F') {
-					sb.append(c);
-				}
-			}
-			return sb.toString();
-		} else {
-			return null;
-		}
-	}
+    @JsonIgnore
+    public String getIdiomaNormalizado() {
+        return flattenToAscii(idioma);
+    }
+
+    @JsonIgnore
+    public String getColeccionNormalizada() {
+        return flattenToAscii(coleccion);
+    }
+
+    @JsonIgnore
+    public String getGeneroNormalizado() {
+        if (generos != null) {
+            return flattenToAscii(generos).replace(",", "");
+        } else {
+            return null;
+        }
+    }
+
+    public static String flattenToAscii(String string) {
+        if (string != null) {
+            StringBuilder sb = new StringBuilder(string.length());
+            string = Normalizer.normalize(string.toLowerCase(), Normalizer.Form.NFD);
+            for (char c : string.toCharArray()) {
+                if (c <= '\u007F') {
+                    sb.append(c);
+                }
+            }
+            return sb.toString();
+        } else {
+            return null;
+        }
+    }
 }
diff --git a/src/main/java/org/greeneyed/epl/librarian/services/BibliotecaService.java b/src/main/java/org/greeneyed/epl/librarian/services/BibliotecaService.java
index d3fb2ca..048324f 100644
--- a/src/main/java/org/greeneyed/epl/librarian/services/BibliotecaService.java
+++ b/src/main/java/org/greeneyed/epl/librarian/services/BibliotecaService.java
@@ -198,7 +198,8 @@ public void update(UpdateSpec updateSpec) {
             log.info("Libros a\u00f1adidos.");
             // Actualizamos segun los datos que tenemos
             calibreService.updateLibros(SEARCH_AND_UDPATE_BOOK);
-            actualizaAutoresFavoritos(preferencesService.getAutoresPreferidos());
+            actualizaAutoresPreferidos(preferencesService.getAutoresPreferidos());
+            actualizaLibrosDescartados(preferencesService.getLibrosDescartados());
             actualizaIdiomasFavoritos(preferencesService.getIdiomasPreferidos());
             actualizaGenerosFavoritos(preferencesService.getGenerosPreferidos());
             //
@@ -321,23 +322,53 @@ private <O extends PuedeSerFavorito> Pagina<O> paginaElementos(IndexedCollection
         return pagina;
     }
 
-    public void actualizaAutoresFavoritos(Set<String> autores) {
+    public void setDescarte(Integer libroId, boolean descartado) {
+        log.info("Actualizando libros descarte...");
+        writeLock.lock();
+        try {
+            try (final ResultSet<Libro> queryResult = libreria.retrieve(in(Libro.LIBRO_ID, libroId))) {
+                queryResult.stream().forEach(libro -> {
+                    libreria.remove(libro);
+                    libro.setDescartado(descartado);
+                    libreria.add(libro);
+                });
+            }
+        } finally {
+            writeLock.unlock();
+        }
+        log.info("...actualizado");
+    }
+
+    public void actualizaLibrosDescartados(Set<Integer> libros) {
+        log.info("Actualizando libros descartados...");
+        writeLock.lock();
+        try {
+            List<Libro> all = libreria.stream()
+                    .peek(libro -> libro.setDescartado(libros.contains(libro.getId())))
+                    .collect(Collectors.toList());
+            libreria.clear();
+            libreria.addAll(all);
+        } finally {
+            writeLock.unlock();
+        }
+        log.info("...actualizados");
+    }
+
+    public void actualizaAutoresPreferidos(Set<String> autores) {
         log.info("Actualizando autores preferidos...");
         writeLock.lock();
         try {
             libreria.stream().forEach(libro -> libro.setAutorFavorito(false));
             Set<String> normalisedAutors = autores.stream().map(Libro::flattenToAscii).collect(Collectors.toSet());
-            try (final ResultSet<Libro> queryResult = libreria
-                    .retrieve(in(Libro.LIBRO_AUTOR, normalisedAutors))) {
+            try (final ResultSet<Libro> queryResult = libreria.retrieve(in(Libro.LIBRO_AUTOR, normalisedAutors))) {
                 queryResult.stream().forEach(libro -> {
-                        libro.setAutorFavorito(true);
+                    libro.setAutorFavorito(true);
                 });
             }
             List<Libro> all = libreria.stream().collect(Collectors.toList());
             libreria.clear();
             libreria.addAll(all);
-        }
-        finally {
+        } finally {
             writeLock.unlock();
         }
         log.info("...actualizados");
@@ -349,17 +380,15 @@ public void actualizaIdiomasFavoritos(Set<String> idiomas) {
         try {
             libreria.stream().forEach(libro -> libro.setIdiomaFavorito(false));
             Set<String> normalisedIdiomas = idiomas.stream().map(Libro::flattenToAscii).collect(Collectors.toSet());
-            try (final ResultSet<Libro> queryResult = libreria
-                    .retrieve(in(Libro.LIBRO_IDIOMA, normalisedIdiomas))) {
+            try (final ResultSet<Libro> queryResult = libreria.retrieve(in(Libro.LIBRO_IDIOMA, normalisedIdiomas))) {
                 queryResult.stream().forEach(libro -> {
-                        libro.setIdiomaFavorito(true);
+                    libro.setIdiomaFavorito(true);
                 });
             }
             List<Libro> all = libreria.stream().collect(Collectors.toList());
             libreria.clear();
             libreria.addAll(all);
-        }
-        finally {
+        } finally {
             writeLock.unlock();
         }
         log.info("...actualizados");
@@ -371,17 +400,15 @@ public void actualizaGenerosFavoritos(Set<String> generos) {
         try {
             libreria.stream().forEach(libro -> libro.setGeneroFavorito(false));
             Set<String> normalisedGeneros = generos.stream().map(Libro::flattenToAscii).collect(Collectors.toSet());
-            try (final ResultSet<Libro> queryResult = libreria
-                    .retrieve(in(Libro.LIBRO_GENERO, normalisedGeneros))) {
+            try (final ResultSet<Libro> queryResult = libreria.retrieve(in(Libro.LIBRO_GENERO, normalisedGeneros))) {
                 queryResult.stream().forEach(libro -> {
-                        libro.setGeneroFavorito(true);
+                    libro.setGeneroFavorito(true);
                 });
             }
             List<Libro> all = libreria.stream().collect(Collectors.toList());
             libreria.clear();
             libreria.addAll(all);
-        }
-        finally {
+        } finally {
             writeLock.unlock();
         }
         log.info("...actualizados");
diff --git a/src/main/java/org/greeneyed/epl/librarian/services/PreferencesService.java b/src/main/java/org/greeneyed/epl/librarian/services/PreferencesService.java
index dcf75c1..37a3a14 100644
--- a/src/main/java/org/greeneyed/epl/librarian/services/PreferencesService.java
+++ b/src/main/java/org/greeneyed/epl/librarian/services/PreferencesService.java
@@ -38,6 +38,7 @@ public class PreferencesService {
     private boolean superPortable;
 
     private static final String IDIOMAS_PREFERIDOS_KEY = "idiomas_preferidos";
+    private static final String LIBROS_DESCARTADOS_KEY = "libros_descartados";
     private static final String AUTORES_PREFERIDOS_KEY = "autores_preferidos";
     private static final String GENEROS_PREFERIDOS_KEY = "generos_preferidos";
 
@@ -56,6 +57,7 @@ public class PreferencesService {
     private final Set<String> idiomasPreferidos = new HashSet<>();
     private final Set<String> autoresPreferidos = new HashSet<>();
     private final Set<String> generosPreferidos = new HashSet<>();
+    private final Set<Integer> librosDescartados = new HashSet<>();
 
     @PostConstruct
     public void postConstruct() {
@@ -77,6 +79,7 @@ private void cargarPreferencias() {
                 InputStreamReader theISW = new InputStreamReader(theFIS)) {
             preferences.load(theISW);
             idiomasPreferidos.addAll(leerIdiomasPreferidos(preferences));
+            librosDescartados.addAll(leerLibrosDescartados(preferences));
             autoresPreferidos.addAll(leerAutoresPreferidos(preferences));
             generosPreferidos.addAll(leerGenerosPreferidos(preferences));
         } catch (Exception e) {
@@ -105,6 +108,25 @@ private Set<String> leerIdiomasPreferidos(Properties preferences) {
         return result;
     }
 
+    private Set<Integer> leerLibrosDescartados(Properties preferences) {
+        readLock.lock();
+        Set<Integer> result = Collections.emptySet();
+        try {
+            if (preferences.containsKey(LIBROS_DESCARTADOS_KEY)) {
+                result = new HashSet<>(Stream.of(preferences.getProperty(LIBROS_DESCARTADOS_KEY).split(","))
+                        .filter(StringUtils::isNotBlank)
+                        .map(Integer::parseInt)
+                        .collect(Collectors.toList()));
+            }
+        } catch (Exception e) {
+            log.error("Error parseando libros descartados: {}", e.getMessage());
+            log.trace("Error detallado", e);
+        } finally {
+            readLock.unlock();
+        }
+        return result;
+    }
+
     private Set<String> leerAutoresPreferidos(Properties preferences) {
         readLock.lock();
         Set<String> result = Collections.emptySet();
@@ -168,6 +190,26 @@ public Optional<File> getBDDCalibre() {
         return Optional.ofNullable(calibre);
     }
 
+
+    public void setDescarte(Integer libroId, boolean descartado) {
+        writeLock.lock();
+        try {
+            if(descartado) {
+                this.librosDescartados.add(libroId);
+            } else {
+                this.librosDescartados.remove(libroId);
+            }
+            preferences.setProperty(LIBROS_DESCARTADOS_KEY,
+                    this.librosDescartados.stream().map(i -> Integer.toString(i)).collect(Collectors.joining(",")));
+            guardarPreferencias();
+        } catch (Exception e) {
+            log.error("Error parseando libros descartados: {}", e.getMessage());
+            log.trace("Error detallado", e);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
     public void actualizarAutoresPreferidos(Set<String> autoresPreferidosToAdd, Set<String> autoresPreferidosToRemove) {
         writeLock.lock();
         try {
diff --git a/src/main/java/org/greeneyed/epl/librarian/services/model/BusquedaLibro.java b/src/main/java/org/greeneyed/epl/librarian/services/model/BusquedaLibro.java
index 2a6f433..4c5552a 100644
--- a/src/main/java/org/greeneyed/epl/librarian/services/model/BusquedaLibro.java
+++ b/src/main/java/org/greeneyed/epl/librarian/services/model/BusquedaLibro.java
@@ -28,88 +28,90 @@
 @Slf4j
 @Data
 public class BusquedaLibro {
-	private final int numeroPagina;
-	private final int porPagina;
-	private final BOOK_ORDERING ordering;
-	private final boolean reversed;
-	private final String filtroTitulo;
-	private final String filtroColeccion;
-	private final String filtroAutor;
-	private final String filtroGenero;
-	private final String filtroIdioma;
-	private final LocalDate filtroFecha;
-	private final boolean soloAutoresFavoritos;
-	private final boolean soloIdiomasFavoritos;
-	private final boolean soloGenerosFavoritos;
-	private final Boolean soloNoEnPropiedad;
+    private final int numeroPagina;
+    private final int porPagina;
+    private final BOOK_ORDERING ordering;
+    private final boolean reversed;
+    private final String filtroTitulo;
+    private final String filtroColeccion;
+    private final String filtroAutor;
+    private final String filtroGenero;
+    private final String filtroIdioma;
+    private final LocalDate filtroFecha;
+    private final boolean soloAutoresFavoritos;
+    private final boolean soloIdiomasFavoritos;
+    private final boolean soloGenerosFavoritos;
+    private final Boolean soloNoEnPropiedad;
 
-	public QueryOptions getQueryOptions() {
-		return reversed ? ordering.getQueryOptionsDescending() : ordering.getQueryOptionsAscending();
-	}
+    public QueryOptions getQueryOptions() {
+        return reversed ? ordering.getQueryOptionsDescending() : ordering.getQueryOptionsAscending();
+    }
 
-	public Query<Libro> getQuery(PreferencesService preferencesService) {
-		Query<Libro> query;
-		List<Query<Libro>> partialQueries = Arrays.asList(getPartialQuery(getFiltroTitulo(), Libro.LIBRO_TITULO),
-				getPartialQuery(getFiltroAutor(), Libro.LIBRO_AUTOR),
-				getPartialQuery(getFiltroIdioma(), Libro.LIBRO_IDIOMA),
-				getPartialQuery(getFiltroColeccion(), Libro.LIBRO_COLECCION),
-				getPartialQuery(getFiltroGenero(), Libro.LIBRO_GENERO), getEnCalibreQuery(),
-				getAutoresFavoritosQuery(preferencesService), getIdiomasFavoritosQuery(preferencesService),
-				getGenerosFavoritosQuery(preferencesService), getFechaQuery(getFiltroFecha(), Libro.LIBRO_PUBLICADO))
-				.stream()
-				.filter(Objects::nonNull)
-				.collect(Collectors.toList());
-		if (partialQueries.isEmpty()) {
-			query = all(Libro.class);
-		} else {
-			query = partialQueries.get(0);
-			for (int i = 1; i < partialQueries.size(); i++) {
-				query = and(query, partialQueries.get(i));
-			}
-		}
-		log.debug("Query: {}", query);
-		return query;
-	}
+    public Query<Libro> getQuery(PreferencesService preferencesService) {
+        Query<Libro> query;
+        List<Query<Libro>> partialQueries = Arrays.asList(getPartialQuery(getFiltroTitulo(), Libro.LIBRO_TITULO),
+                getPartialQuery(getFiltroAutor(), Libro.LIBRO_AUTOR),
+                getPartialQuery(getFiltroIdioma(), Libro.LIBRO_IDIOMA),
+                getPartialQuery(getFiltroColeccion(), Libro.LIBRO_COLECCION),
+                getPartialQuery(getFiltroGenero(), Libro.LIBRO_GENERO),
+                //
+                getEnCalibreNoDescartadosQuery(),
+                getAutoresFavoritosQuery(preferencesService), getIdiomasFavoritosQuery(preferencesService),
+                getGenerosFavoritosQuery(preferencesService), getFechaQuery(getFiltroFecha(), Libro.LIBRO_PUBLICADO))
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        if (partialQueries.isEmpty()) {
+            query = all(Libro.class);
+        } else {
+            query = partialQueries.get(0);
+            for (int i = 1; i < partialQueries.size(); i++) {
+                query = and(query, partialQueries.get(i));
+            }
+        }
+        log.debug("Query: {}", query);
+        return query;
+    }
 
-	private static Query<Libro> getFechaQuery(final LocalDate criterio, final Attribute<Libro, ChronoLocalDate> campo) {
-		if (criterio != null) {
-			return greaterThanOrEqualTo(campo, criterio);
-		} else
-			return null;
-	}
+    private static Query<Libro> getFechaQuery(final LocalDate criterio, final Attribute<Libro, ChronoLocalDate> campo) {
+        if (criterio != null) {
+            return greaterThanOrEqualTo(campo, criterio);
+        } else
+            return null;
+    }
 
-	public Query<Libro> getEnCalibreQuery() {
-		if (Boolean.TRUE.equals(soloNoEnPropiedad)) {
-			return equal(Libro.LIBRO_EN_CALIBRE, Boolean.FALSE);
-		} else
-			return null;
-	}
+    public Query<Libro> getEnCalibreNoDescartadosQuery() {
+        if (Boolean.TRUE.equals(soloNoEnPropiedad)) {
+            return and(equal(Libro.LIBRO_EN_CALIBRE, Boolean.FALSE), equal(Libro.LIBRO_DESCARTADO, Boolean.FALSE));
+        } else
+            return null;
+    }
 
-	public Query<Libro> getAutoresFavoritosQuery(PreferencesService preferencesService) {
-		if (preferencesService.canAplyAutoresFavoritos() && Boolean.TRUE.equals(soloAutoresFavoritos)) {
-			return equal(Libro.LIBRO_AUTOR_FAVORITO, Boolean.TRUE);
-		} else
-			return null;
-	}
+    public Query<Libro> getAutoresFavoritosQuery(PreferencesService preferencesService) {
+        if (preferencesService.canAplyAutoresFavoritos() && Boolean.TRUE.equals(soloAutoresFavoritos)) {
+            return equal(Libro.LIBRO_AUTOR_FAVORITO, Boolean.TRUE);
+        } else
+            return null;
+    }
 
-	public Query<Libro> getIdiomasFavoritosQuery(PreferencesService preferencesService) {
-		if (preferencesService.canAplyIdiomasFavoritos() && Boolean.TRUE.equals(soloIdiomasFavoritos)) {
-			return equal(Libro.LIBRO_IDIOMA_FAVORITO, Boolean.TRUE);
-		} else
-			return null;
-	}
+    public Query<Libro> getIdiomasFavoritosQuery(PreferencesService preferencesService) {
+        if (preferencesService.canAplyIdiomasFavoritos() && Boolean.TRUE.equals(soloIdiomasFavoritos)) {
+            return equal(Libro.LIBRO_IDIOMA_FAVORITO, Boolean.TRUE);
+        } else
+            return null;
+    }
 
-	public Query<Libro> getGenerosFavoritosQuery(PreferencesService preferencesService) {
-		if (preferencesService.canAplyGenerosFavoritos() && Boolean.TRUE.equals(soloGenerosFavoritos)) {
-			return equal(Libro.LIBRO_GENERO_FAVORITO, Boolean.TRUE);
-		} else
-			return null;
-	}
+    public Query<Libro> getGenerosFavoritosQuery(PreferencesService preferencesService) {
+        if (preferencesService.canAplyGenerosFavoritos() && Boolean.TRUE.equals(soloGenerosFavoritos)) {
+            return equal(Libro.LIBRO_GENERO_FAVORITO, Boolean.TRUE);
+        } else
+            return null;
+    }
 
-	public static Query<Libro> getPartialQuery(final String criterio, final Attribute<Libro, String> campo) {
-		if (StringUtils.isNotBlank(criterio)) {
-			return contains(campo, Libro.flattenToAscii(criterio));
-		} else
-			return null;
-	}
+    public static Query<Libro> getPartialQuery(final String criterio, final Attribute<Libro, String> campo) {
+        if (StringUtils.isNotBlank(criterio)) {
+            return contains(campo, Libro.flattenToAscii(criterio));
+        } else
+            return null;
+    }
 }
\ No newline at end of file