Merge pull request #35 from Cruzadera/develop

Release 1.5

Author: Cruzadera

README.md

@@ -269,6 +269,55 @@ Returns frontend settings, feature flags, destination shelves, and available ind
 
 Persists frontend-managed settings.
 
+The settings payload accepts a new optional field to control indexer prioritization:
+
+```json
+{
+  "filters": {
+    "preferredFormat": "epub",
+    "indexers": ["Indexer A", "Indexer B"],
+    "indexerPriority": ["Indexer B", "Indexer A"]
+  }
+}
+```
+
+`filters.indexerPriority` is an ordered array of indexer names (strings). When present, Bookseerr will give a bonus to search results that originate from earlier indexers in the list.
+
+### Scoring & Indexer priority
+
+Bookseerr now uses a scoring-based ranking for search results to provide more consistent and relevant "best" selections. Factors included in the score:
+
+- Preferred format: large bonus when the result matches `filters.preferredFormat`.
+- Format bias: EPUB/azw3/mobi receive positive weight; PDF receives a negative penalty by default.
+- Seeders: added as points (capped) so healthier torrents rank higher.
+- File size: smaller files are preferred with a small bonus (to avoid unnecessarily large downloads).
+- Language match: bonus when the result language matches `filters.language`.
+- Indexer priority: optional ordered bonus via `filters.indexerPriority` (earlier indexers get a larger bonus).
+
+The `/api/search` response includes a numeric `score` on each result so you can inspect why a result was chosen. The search pipeline still applies filters (excluded formats, min seeds, max size, indexer selection) and falls back through relaxed stages if no result matches strictly.
+
+### How to test locally
+
+1. Open the UI and go to Settings → Prowlarr indexers. Use the new "Indexer priority" panel to add and order indexers.
+2. Save settings (this issues `POST /api/settings`).
+3. Run a search and inspect the returned results with `curl`:
+
+```bash
+curl "http://localhost:3000/api/search?query=your+book" | jq .
+```
+
+Look at the `score`, `format`, `seeders`, `sizeMB`, and `indexer` fields to verify ranking behaviour. Adjust `indexerPriority` or format preferences and save again to retune.
+
+Example `POST /api/settings` body including priority (useful for testing via `curl`):
+
+```bash
+curl -X POST http://localhost:3000/api/settings \
+  -H "Content-Type: application/json" \
+  -d '{"filters":{"preferredFormat":"epub","indexers":["MyIdx"],"indexerPriority":["MyIdx"]}}'
+```
+
+This feature is intended to make "best result" selection more deterministic and customizable for multi-indexer setups. If you want different weighting (e.g., reduce format bias or change size/seed influence), we can expose weight settings in the UI or tune defaults in `src/services/prowlarr.service.js`.
+
 ### `GET /api/jobs`
 
 Returns tracked jobs.

frontend/src/App.jsx

@@ -4,6 +4,7 @@ import SearchView from "./components/SearchView";
 import SettingsView from "./components/SettingsView";
 import Sidebar from "./components/Sidebar";
 import JobsView from "./components/JobsView";
+import FavoritesView from "./components/FavoritesView";
 import { useI18n } from "./hooks/useI18n";
 import {
   cloneSettings,
@@ -147,6 +148,8 @@ export default function App() {
   const [downloadingKey, setDownloadingKey] = useState("");
   const [jobs, setJobs] = useState([]);
   const [jobActionId, setJobActionId] = useState("");
+  const [favorites, setFavorites] = useState([]);
+  const [favoriteActionKey, setFavoriteActionKey] = useState("");
   const [destinationShelfEnabled, setDestinationShelfEnabled] = useState(false);
   const [destinationShelves, setDestinationShelves] = useState([]);
   const [selectedDestinationId, setSelectedDestinationId] = useState("");
@@ -213,6 +216,27 @@ export default function App() {
     };
   }, []);
 
+  useEffect(() => {
+    let cancelled = false;
+
+    async function loadFavorites() {
+      try {
+        const response = await fetch("/api/favorites");
+        const data = await handleJsonResponse(response);
+
+        if (!cancelled) {
+          setFavorites(Array.isArray(data.favorites) ? data.favorites : []);
+        }
+      } catch {}
+    }
+
+    loadFavorites();
+
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
   useEffect(() => {
     let cancelled = false;
 
@@ -329,6 +353,97 @@ export default function App() {
     setJobs(Array.isArray(data.jobs) ? data.jobs : []);
   }
 
+  async function refreshFavorites() {
+    const response = await fetch("/api/favorites");
+    const data = await handleJsonResponse(response);
+    setFavorites(Array.isArray(data.favorites) ? data.favorites : []);
+  }
+
+  function getResultKey(item) {
+    return `${item.title}::${item.downloadUrl}`;
+  }
+
+  function getFavoriteForResult(item) {
+    return favorites.find((favorite) => favorite.downloadUrl === item.downloadUrl) || null;
+  }
+
+  async function addFavorite(item) {
+    const resultKey = getResultKey(item);
+    setFavoriteActionKey(resultKey);
+
+    try {
+      const response = await fetch("/api/favorites", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          title: item.title,
+          author: item.author,
+          downloadUrl: item.downloadUrl,
+          protocol: item.protocol || "torrent",
+          format: item.format,
+          sizeMB: item.sizeMB,
+          seeders: item.seeders,
+          publishDate: item.publishDate,
+          indexer: item.indexer,
+          language: item.language,
+          coverUrl: item.coverUrl,
+        }),
+      });
+
+      await handleJsonResponse(response);
+      await refreshFavorites();
+      setHomeStatus({ message: t("ui.favorites.added"), error: false });
+    } catch (error) {
+      setHomeStatus({ message: error.message, error: true });
+    } finally {
+      setFavoriteActionKey("");
+    }
+  }
+
+  async function removeFavoriteById(favoriteId, statusMessage = "") {
+    try {
+      const response = await fetch(`/api/favorites/${favoriteId}`, {
+        method: "DELETE",
+      });
+
+      if (!response.ok && response.status !== 404) {
+        await handleJsonResponse(response);
+      }
+
+      await refreshFavorites();
+      if (statusMessage) {
+        setHomeStatus({ message: statusMessage, error: false });
+      }
+    } catch (error) {
+      setHomeStatus({ message: error.message, error: true });
+    }
+  }
+
+  async function toggleFavorite(item) {
+    const existing = getFavoriteForResult(item);
+
+    if (existing?.id) {
+      setFavoriteActionKey(getResultKey(item));
+      await removeFavoriteById(existing.id, t("ui.favorites.removed"));
+      setFavoriteActionKey("");
+      return;
+    }
+
+    await addFavorite(item);
+  }
+
+  async function removeFavoriteFromList(item) {
+    if (!item?.id) {
+      return;
+    }
+
+    setFavoriteActionKey(item.id);
+    await removeFavoriteById(item.id, t("ui.favorites.removed"));
+    setFavoriteActionKey("");
+  }
+
   async function downloadBook(item) {
     const startedAt = Date.now();
     const resultKey = `${item.title}::${item.downloadUrl}`;
@@ -395,6 +510,53 @@ export default function App() {
     await downloadBook(best);
   }
 
+  // Local mirror of server-side filter enforcement to ensure auto-download
+  // only triggers when a result strictly matches the user's settings.
+  function matchesFiltersLocal(item, filters) {
+    if (!item || !item.downloadUrl) return false;
+
+    const excluded = Array.isArray(filters.excludedFormats) ? filters.excludedFormats : [];
+    if (excluded.includes((item.format || "").toLowerCase())) return false;
+
+    const minSeeds = Number(filters.minSeeds || 0);
+    if ((Number(item.seeders || 0)) < minSeeds) return false;
+
+    const maxSize = Number(filters.maxSizeMB || 0);
+    if (maxSize > 0 && Number(item.sizeMB || 0) > maxSize) return false;
+
+    if (filters.language && filters.language !== "any" && item.language && item.language !== "any") {
+      if (item.language !== filters.language) return false;
+    }
+
+    if (Array.isArray(filters.indexers) && filters.indexers.length) {
+      const normalized = `${item.indexer || ""}`.trim().toLowerCase();
+      const allowed = filters.indexers.map((i) => `${i || ""}`.trim().toLowerCase());
+      if (!allowed.includes(normalized)) return false;
+    }
+
+    return true;
+  }
+
+  async function maybeAutoDownload(nextResults) {
+    if (!settings.download.autoDownload || !nextResults.length) {
+      return;
+    }
+
+    const preferredFormat = settings.filters.preferredFormat || "any";
+    const mustMatchPreferred = Boolean(settings.download.onlyIfPreferredFormat) && preferredFormat !== "any";
+
+    // Find a result that strictly matches the user's settings
+    const candidate = nextResults.find((item) => {
+      if (!matchesFiltersLocal(item, settings.filters)) return false;
+      if (mustMatchPreferred && (item.format || "").toLowerCase() !== preferredFormat) return false;
+      return true;
+    });
+
+    if (!candidate) return;
+
+    await downloadBook(candidate);
+  }
+
   function saveRecentSearch(searchQuery) {
     const normalizedSearchQuery = normalizeRecentSearchEntry(searchQuery);
 
@@ -637,10 +799,24 @@ export default function App() {
               searchError={searchError}
               resultErrors={resultErrors}
               downloadingKey={downloadingKey}
+              favoriteActionKey={favoriteActionKey}
+              favoriteIdsByResultKey={favorites.reduce((acc, favorite) => {
+                acc[favorite.downloadUrl] = favorite.id;
+                return acc;
+              }, {})}
               isBusy={isBusy}
               onDownload={downloadBook}
+              onToggleFavorite={toggleFavorite}
               onRetryDownload={downloadBook}
             />
+          ) : activePage === "favorites" ? (
+            <FavoritesView
+              t={t}
+              favorites={favorites}
+              isBusy={isBusy || Boolean(favoriteActionKey)}
+              onDownload={downloadBook}
+              onRemove={removeFavoriteFromList}
+            />
           ) : activePage === "jobs" ? (
             <JobsView
               t={t}

frontend/src/components/FavoritesView.jsx

@@ -0,0 +1,119 @@
+function formatSize(sizeMB) {
+  const numeric = Number(sizeMB || 0);
+
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return "-";
+  }
+
+  return `${numeric >= 10 ? numeric.toFixed(0) : numeric.toFixed(1)} MB`;
+}
+
+function formatPublishYear(value) {
+  if (!value) {
+    return "";
+  }
+
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? "" : `${date.getFullYear()}`;
+}
+
+function EmptyFavorites({ t }) {
+  return (
+    <div className="state-panel state-panel--empty">
+      <div className="state-panel-copy">
+        <p className="state-panel-kicker">{t("ui.favorites.emptyKicker")}</p>
+        <h2>{t("ui.favorites.emptyTitle")}</h2>
+        <p>{t("ui.favorites.emptyDescription")}</p>
+      </div>
+    </div>
+  );
+}
+
+export default function FavoritesView({
+  t,
+  favorites,
+  isBusy,
+  onDownload,
+  onRemove,
+}) {
+  return (
+    <section className="page-view">
+      <section className="hero">
+        <h1 className="hero-title">Bookseerr</h1>
+        <p className="hero-subtitle">{t("ui.favorites.pageSubtitle")}</p>
+      </section>
+
+      <section className="panel">
+        {!favorites.length ? (
+          <EmptyFavorites t={t} />
+        ) : (
+          <div className="results favorites-results">
+            {favorites.map((item) => {
+              const year = formatPublishYear(item.publishDate);
+
+              return (
+                <article key={item.id} className="result-card">
+                  <div className="result-cover">
+                    {item.coverUrl ? (
+                      <img src={item.coverUrl} alt={item.title || "Book"} loading="lazy" />
+                    ) : (
+                      <span className="result-cover-fallback" aria-hidden="true">
+                        {(item.title?.charAt(0) || "?").toUpperCase()}
+                      </span>
+                    )}
+                    <span className="result-cover-format">
+                      {`${item.format || "unknown"}`.toUpperCase()}
+                    </span>
+                  </div>
+
+                  <div className="result-main">
+                    <div className="result-head">
+                      <div className="result-copy">
+                        <h2>{item.title || "Untitled"}</h2>
+                        <p className="result-author">{item.author || t("ui.unknownAuthor")}</p>
+                      </div>
+
+                      <div className="result-actions">
+                        <button type="button" disabled={isBusy} onClick={() => onDownload(item)}>
+                          {t("ui.favorites.downloadNow")}
+                        </button>
+                        <button
+                          type="button"
+                          className="secondary"
+                          disabled={isBusy}
+                          onClick={() => onRemove(item)}
+                        >
+                          {t("ui.favorites.remove")}
+                        </button>
+                      </div>
+                    </div>
+
+                    <div className="result-submeta">
+                      <span>{item.indexer || t("ui.indexer")}</span>
+                      {year ? <span>{year}</span> : null}
+                    </div>
+
+                    <dl className="meta meta-pills">
+                      <div>
+                        <dt>{t("ui.format")}</dt>
+                        <dd>{`${item.format || "unknown"}`.toUpperCase()}</dd>
+                      </div>
+                      <div>
+                        <dt>{t("ui.seeders")}</dt>
+                        <dd>{Number(item.seeders || 0)}</dd>
+                      </div>
+                      <div>
+                        <dt>{t("ui.size")}</dt>
+                        <dd>{formatSize(item.sizeMB)}</dd>
+                      </div>
+                    </dl>
+                  </div>
+                </article>
+              );
+            })}
+          </div>
+        )}
+      </section>
+    </section>
+  );
+}