Adds many to many related items to notifications

.github/workflows/pylint.yml

@@ -21,7 +21,8 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         pip install -r requirements.txt
+        pip install pylint
     - name: Analysing the code with pylint
       run: |
-        pylint bookwyrm/
+        pylint bookwyrm/ --ignore=migrations --disable=E1101,E1135,E1136,R0903,R0901,R0902,W0707,W0511,W0406,R0401,R0801
 

.pylintrc

@@ -1,6 +0,0 @@
-[MAIN]
-ignore=migrations
-load-plugins=pylint.extensions.no_self_use
-
-[MESSAGES CONTROL]
-disable=E1101,E1135,E1136,R0903,R0901,R0902,W0707,W0511,W0406,R0401,R0801,C3001

Dockerfile

@@ -6,7 +6,6 @@ RUN mkdir /app /app/static /app/images
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y gettext libgettextpo-dev tidy && apt-get clean
-
 COPY requirements.txt /app/
 RUN pip install -r requirements.txt --no-cache-dir
+RUN apt-get update && apt-get install -y gettext libgettextpo-dev tidy && apt-get clean

README.md

@@ -16,7 +16,7 @@ If you'd like to join an instance, you can check out the [instances](https://joi
 
 
 ## Contributing
-See [contributing](https://docs.joinbookwyrm.com/contributing.html) for code, translation or monetary contributions.
+See [contributing](https://docs.joinbookwyrm.com/how-to-contribute.html) for code, translation or monetary contributions.
 
 ## About BookWyrm
 ### What it is and isn't
@@ -76,4 +76,4 @@ Deployment
 
 
 ## Set up BookWyrm
-The [documentation website](https://docs.joinbookwyrm.com/) has instruction on how to set up BookWyrm in a [developer environment](https://docs.joinbookwyrm.com/install-dev.html) or [production](https://docs.joinbookwyrm.com/install-prod.html).
+The [documentation website](https://docs.joinbookwyrm.com/) has instruction on how to set up BookWyrm in a [developer environment](https://docs.joinbookwyrm.com/developer-environment.html) or [production](https://docs.joinbookwyrm.com/installing-in-production.html).

bookwyrm/activitypub/base_activity.py

@@ -1,7 +1,6 @@
 """ basics for an activitypub serializer """
 from dataclasses import dataclass, fields, MISSING
 from json import JSONEncoder
-import logging
 
 from django.apps import apps
 from django.db import IntegrityError, transaction
@@ -9,8 +8,6 @@ from django.db import IntegrityError, transaction
 from bookwyrm.connectors import ConnectorException, get_data
 from bookwyrm.tasks import app
 
-logger = logging.getLogger(__name__)
-
 
 class ActivitySerializerError(ValueError):
     """routine problems serializing activitypub json"""
@@ -42,12 +39,12 @@ def naive_parse(activity_objects, activity_json, serializer=None):
             activity_json["type"] = "PublicKey"
 
         activity_type = activity_json.get("type")
-        if activity_type in ["Question", "Article"]:
-            return None
         try:
             serializer = activity_objects[activity_type]
         except KeyError as err:
             # we know this exists and that we can't handle it
+            if activity_type in ["Question"]:
+                return None
             raise ActivitySerializerError(err)
 
     return serializer(activity_objects=activity_objects, **activity_json)
@@ -68,7 +65,7 @@ class ActivityObject:
             try:
                 value = kwargs[field.name]
                 if value in (None, MISSING, {}):
-                    raise KeyError("Missing required field", field.name)
+                    raise KeyError()
                 try:
                     is_subclass = issubclass(field.type, ActivityObject)
                 except TypeError:
@@ -271,9 +268,9 @@ def resolve_remote_id(
     try:
         data = get_data(remote_id)
     except ConnectorException:
-        logger.exception("Could not connect to host for remote_id: %s", remote_id)
-        return None
-
+        raise ActivitySerializerError(
+            f"Could not connect to host for remote_id: {remote_id}"
+        )
     # determine the model implicitly, if not provided
     # or if it's a model with subclasses like Status, check again
     if not model or hasattr(model.objects, "select_subclasses"):

bookwyrm/activitystreams.py

@@ -298,9 +298,8 @@ def add_status_on_create_command(sender, instance, created):
     priority = HIGH
     # check if this is an old status, de-prioritize if so
     # (this will happen if federation is very slow, or, more expectedly, on csv import)
-    if instance.published_date < timezone.now() - timedelta(
-        days=1
-    ) or instance.created_date < instance.published_date - timedelta(days=1):
+    one_day = 60 * 60 * 24
+    if (instance.created_date - instance.published_date).seconds > one_day:
         priority = LOW
 
     add_status_task.apply_async(

bookwyrm/book_search.py

@@ -148,8 +148,8 @@ class SearchResult:
 
     def __repr__(self):
         # pylint: disable=consider-using-f-string
-        return "<SearchResult key={!r} title={!r} author={!r} confidence={!r}>".format(
-            self.key, self.title, self.author, self.confidence
+        return "<SearchResult key={!r} title={!r} author={!r}>".format(
+            self.key, self.title, self.author
         )
 
     def json(self):

bookwyrm/connectors/abstract_connector.py

@@ -1,8 +1,9 @@
 """ functionality outline for a book data connector """
 from abc import ABC, abstractmethod
 import imghdr
+import ipaddress
 import logging
-import re
+from urllib.parse import urlparse
 
 from django.core.files.base import ContentFile
 from django.db import transaction
@@ -10,7 +11,7 @@ import requests
 from requests.exceptions import RequestException
 
 from bookwyrm import activitypub, models, settings
-from .connector_manager import load_more_data, ConnectorException, raise_not_valid_url
+from .connector_manager import load_more_data, ConnectorException
 from .format_mappings import format_mappings
 
 
@@ -38,34 +39,62 @@ class AbstractMinimalConnector(ABC):
         for field in self_fields:
             setattr(self, field, getattr(info, field))
 
-    def get_search_url(self, query):
-        """format the query url"""
-        # Check if the query resembles an ISBN
-        if maybe_isbn(query) and self.isbn_search_url and self.isbn_search_url != "":
-            return f"{self.isbn_search_url}{query}"
+    def search(self, query, min_confidence=None, timeout=settings.QUERY_TIMEOUT):
+        """free text search"""
+        params = {}
+        if min_confidence:
+            params["min_confidence"] = min_confidence
 
-        # NOTE: previously, we tried searching isbn and if that produces no results,
-        # searched as free text. This, instead, only searches isbn if it's isbn-y
-        return f"{self.search_url}{query}"
+        data = self.get_search_data(
+            f"{self.search_url}{query}",
+            params=params,
+            timeout=timeout,
+        )
+        results = []
 
-    def process_search_response(self, query, data, min_confidence):
-        """Format the search results based on the formt of the query"""
-        if maybe_isbn(query):
-            return list(self.parse_isbn_search_data(data))[:10]
-        return list(self.parse_search_data(data, min_confidence))[:10]
+        for doc in self.parse_search_data(data)[:10]:
+            results.append(self.format_search_result(doc))
+        return results
+
+    def isbn_search(self, query, timeout=settings.QUERY_TIMEOUT):
+        """isbn search"""
+        params = {}
+        data = self.get_search_data(
+            f"{self.isbn_search_url}{query}",
+            params=params,
+            timeout=timeout,
+        )
+        results = []
+
+        # this shouldn't be returning mutliple results, but just in case
+        for doc in self.parse_isbn_search_data(data)[:10]:
+            results.append(self.format_isbn_search_result(doc))
+        return results
+
+    def get_search_data(self, remote_id, **kwargs):  # pylint: disable=no-self-use
+        """this allows connectors to override the default behavior"""
+        return get_data(remote_id, **kwargs)
 
     @abstractmethod
     def get_or_create_book(self, remote_id):
         """pull up a book record by whatever means possible"""
 
     @abstractmethod
-    def parse_search_data(self, data, min_confidence):
+    def parse_search_data(self, data):
         """turn the result json from a search into a list"""
 
+    @abstractmethod
+    def format_search_result(self, search_result):
+        """create a SearchResult obj from json"""
+
     @abstractmethod
     def parse_isbn_search_data(self, data):
         """turn the result json from a search into a list"""
 
+    @abstractmethod
+    def format_isbn_search_result(self, search_result):
+        """create a SearchResult obj from json"""
+
 
 class AbstractConnector(AbstractMinimalConnector):
     """generic book data connector"""
@@ -225,6 +254,9 @@ def get_data(url, params=None, timeout=10):
     # check if the url is blocked
     raise_not_valid_url(url)
 
+    if models.FederatedServer.is_blocked(url):
+        raise ConnectorException(f"Attempting to load data from blocked url: {url}")
+
     try:
         resp = requests.get(
             url,
@@ -279,6 +311,20 @@ def get_image(url, timeout=10):
     return image_content, extension
 
 
+def raise_not_valid_url(url):
+    """do some basic reality checks on the url"""
+    parsed = urlparse(url)
+    if not parsed.scheme in ["http", "https"]:
+        raise ConnectorException("Invalid scheme: ", url)
+
+    try:
+        ipaddress.ip_address(parsed.netloc)
+        raise ConnectorException("Provided url is an IP address: ", url)
+    except ValueError:
+        # it's not an IP address, which is good
+        pass
+
+
 class Mapping:
     """associate a local database field with a field in an external dataset"""
 
@@ -320,9 +366,3 @@ def unique_physical_format(format_text):
         # try a direct match, so saving this would be redundant
         return None
     return format_text
-
-
-def maybe_isbn(query):
-    """check if a query looks like an isbn"""
-    isbn = re.sub(r"[\W_]", "", query)  # removes filler characters
-    return len(isbn) in [10, 13]  # ISBN10 or ISBN13

bookwyrm/connectors/bookwyrm_connector.py

@@ -10,12 +10,15 @@ class Connector(AbstractMinimalConnector):
     def get_or_create_book(self, remote_id):
         return activitypub.resolve_remote_id(remote_id, model=models.Edition)
 
-    def parse_search_data(self, data, min_confidence):
-        for search_result in data:
+    def parse_search_data(self, data):
+        return data
+
+    def format_search_result(self, search_result):
         search_result["connector"] = self
-            yield SearchResult(**search_result)
+        return SearchResult(**search_result)
 
     def parse_isbn_search_data(self, data):
-        for search_result in data:
-            search_result["connector"] = self
-            yield SearchResult(**search_result)
+        return data
+
+    def format_isbn_search_result(self, search_result):
+        return self.format_search_result(search_result)

bookwyrm/connectors/connector_manager.py

@@ -1,18 +1,17 @@
 """ interface with whatever connectors the app has """
-import asyncio
+from datetime import datetime
 import importlib
-import ipaddress
 import logging
+import re
 from urllib.parse import urlparse
 
-import aiohttp
 from django.dispatch import receiver
 from django.db.models import signals
 
 from requests import HTTPError
 
 from bookwyrm import book_search, models
-from bookwyrm.settings import SEARCH_TIMEOUT, USER_AGENT
+from bookwyrm.settings import SEARCH_TIMEOUT
 from bookwyrm.tasks import app
 
 logger = logging.getLogger(__name__)
@@ -22,85 +21,53 @@ class ConnectorException(HTTPError):
     """when the connector can't do what was asked"""
 
 
-async def get_results(session, url, min_confidence, query, connector):
-    """try this specific connector"""
-    # pylint: disable=line-too-long
-    headers = {
-        "Accept": (
-            'application/json, application/activity+json, application/ld+json; profile="https://www.w3.org/ns/activitystreams"; charset=utf-8'
-        ),
-        "User-Agent": USER_AGENT,
-    }
-    params = {"min_confidence": min_confidence}
-    try:
-        async with session.get(url, headers=headers, params=params) as response:
-            if not response.ok:
-                logger.info("Unable to connect to %s: %s", url, response.reason)
-                return
-
-            try:
-                raw_data = await response.json()
-            except aiohttp.client_exceptions.ContentTypeError as err:
-                logger.exception(err)
-                return
-
-            return {
-                "connector": connector,
-                "results": connector.process_search_response(
-                    query, raw_data, min_confidence
-                ),
-            }
-    except asyncio.TimeoutError:
-        logger.info("Connection timed out for url: %s", url)
-    except aiohttp.ClientError as err:
-        logger.exception(err)
-
-
-async def async_connector_search(query, items, min_confidence):
-    """Try a number of requests simultaneously"""
-    timeout = aiohttp.ClientTimeout(total=SEARCH_TIMEOUT)
-    async with aiohttp.ClientSession(timeout=timeout) as session:
-        tasks = []
-        for url, connector in items:
-            tasks.append(
-                asyncio.ensure_future(
-                    get_results(session, url, min_confidence, query, connector)
-                )
-            )
-
-        results = await asyncio.gather(*tasks)
-        return results
-
-
 def search(query, min_confidence=0.1, return_first=False):
     """find books based on arbitary keywords"""
     if not query:
         return []
     results = []
 
-    items = []
-    for connector in get_connectors():
-        # get the search url from the connector before sending
-        url = connector.get_search_url(query)
-        try:
-            raise_not_valid_url(url)
-        except ConnectorException:
-            # if this URL is invalid we should skip it and move on
-            logger.info("Request denied to blocked domain: %s", url)
-            continue
-        items.append((url, connector))
+    # Have we got a ISBN ?
+    isbn = re.sub(r"[\W_]", "", query)
+    maybe_isbn = len(isbn) in [10, 13]  # ISBN10 or ISBN13
 
-    # load as many results as we can
-    results = asyncio.run(async_connector_search(query, items, min_confidence))
-    results = [r for r in results if r]
+    start_time = datetime.now()
+    for connector in get_connectors():
+        result_set = None
+        if maybe_isbn and connector.isbn_search_url and connector.isbn_search_url != "":
+            # Search on ISBN
+            try:
+                result_set = connector.isbn_search(isbn)
+            except Exception as err:  # pylint: disable=broad-except
+                logger.info(err)
+                # if this fails, we can still try regular search
+
+        # if no isbn search results, we fallback to generic search
+        if not result_set:
+            try:
+                result_set = connector.search(query, min_confidence=min_confidence)
+            except Exception as err:  # pylint: disable=broad-except
+                # we don't want *any* error to crash the whole search page
+                logger.info(err)
+                continue
+
+        if return_first and result_set:
+            # if we found anything, return it
+            return result_set[0]
+
+        if result_set:
+            results.append(
+                {
+                    "connector": connector,
+                    "results": result_set,
+                }
+            )
+        if (datetime.now() - start_time).seconds >= SEARCH_TIMEOUT:
+            break
 
     if return_first:
-        # find the best result from all the responses and return that
-        all_results = [r for con in results for r in con["results"]]
-        all_results = sorted(all_results, key=lambda r: r.confidence, reverse=True)
-        return all_results[0] if all_results else None
+        return None
 
-    # failed requests will return None, so filter those out
     return results
 
 
@@ -166,20 +133,3 @@ def create_connector(sender, instance, created, *args, **kwargs):
     """create a connector to an external bookwyrm server"""
     if instance.application_type == "bookwyrm":
         get_or_create_connector(f"https://{instance.server_name}")
-
-
-def raise_not_valid_url(url):
-    """do some basic reality checks on the url"""
-    parsed = urlparse(url)
-    if not parsed.scheme in ["http", "https"]:
-        raise ConnectorException("Invalid scheme: ", url)
-
-    try:
-        ipaddress.ip_address(parsed.netloc)
-        raise ConnectorException("Provided url is an IP address: ", url)
-    except ValueError:
-        # it's not an IP address, which is good
-        pass
-
-    if models.FederatedServer.is_blocked(url):
-        raise ConnectorException(f"Attempting to load data from blocked url: {url}")

bookwyrm/connectors/inventaire.py

@@ -77,16 +77,24 @@ class Connector(AbstractConnector):
             **{k: data.get(k) for k in ["uri", "image", "labels", "sitelinks", "type"]},
         }
 
-    def parse_search_data(self, data, min_confidence):
-        for search_result in data.get("results", []):
+    def search(self, query, min_confidence=None):  # pylint: disable=arguments-differ
+        """overrides default search function with confidence ranking"""
+        results = super().search(query)
+        if min_confidence:
+            # filter the search results after the fact
+            return [r for r in results if r.confidence >= min_confidence]
+        return results
+
+    def parse_search_data(self, data):
+        return data.get("results")
+
+    def format_search_result(self, search_result):
         images = search_result.get("image")
         cover = f"{self.covers_url}/img/entities/{images[0]}" if images else None
         # a deeply messy translation of inventaire's scores
         confidence = float(search_result.get("_score", 0.1))
         confidence = 0.1 if confidence < 150 else 0.999
-            if confidence < min_confidence:
-                continue
-            yield SearchResult(
+        return SearchResult(
             title=search_result.get("label"),
             key=self.get_remote_id(search_result.get("uri")),
             author=search_result.get("description"),
@@ -100,12 +108,15 @@ class Connector(AbstractConnector):
         """got some daaaata"""
         results = data.get("entities")
         if not results:
-            return
-        for search_result in list(results.values()):
+            return []
+        return list(results.values())
+
+    def format_isbn_search_result(self, search_result):
+        """totally different format than a regular search result"""
         title = search_result.get("claims", {}).get("wdt:P1476", [])
         if not title:
-                continue
-            yield SearchResult(
+            return None
+        return SearchResult(
             title=title[0],
             key=self.get_remote_id(search_result.get("uri")),
             author=search_result.get("description"),

bookwyrm/connectors/openlibrary.py

@@ -152,35 +152,33 @@ class Connector(AbstractConnector):
         image_name = f"{cover_id}-{size}.jpg"
         return f"{self.covers_url}/b/id/{image_name}"
 
-    def parse_search_data(self, data, min_confidence):
-        for idx, search_result in enumerate(data.get("docs")):
+    def parse_search_data(self, data):
+        return data.get("docs")
+
+    def format_search_result(self, search_result):
         # build the remote id from the openlibrary key
         key = self.books_url + search_result["key"]
         author = search_result.get("author_name") or ["Unknown"]
         cover_blob = search_result.get("cover_i")
         cover = self.get_cover_url([cover_blob], size="M") if cover_blob else None
-
-            # OL doesn't provide confidence, but it does sort by an internal ranking, so
-            # this confidence value is relative to the list position
-            confidence = 1 / (idx + 1)
-
-            yield SearchResult(
+        return SearchResult(
             title=search_result.get("title"),
             key=key,
             author=", ".join(author),
             connector=self,
             year=search_result.get("first_publish_year"),
             cover=cover,
-                confidence=confidence,
         )
 
     def parse_isbn_search_data(self, data):
-        for search_result in list(data.values()):
+        return list(data.values())
+
+    def format_isbn_search_result(self, search_result):
         # build the remote id from the openlibrary key
         key = self.books_url + search_result["key"]
         authors = search_result.get("authors") or [{"name": "Unknown"}]
         author_names = [author.get("name") for author in authors]
-            yield SearchResult(
+        return SearchResult(
             title=search_result.get("title"),
             key=key,
             author=", ".join(author_names),

bookwyrm/forms/forms.py

@@ -53,12 +53,7 @@ class ReadThroughForm(CustomForm):
             self.add_error(
                 "finish_date", _("Reading finish date cannot be before start date.")
             )
-        stopped_date = cleaned_data.get("stopped_date")
-        if start_date and stopped_date and start_date > stopped_date:
-            self.add_error(
-                "stopped_date", _("Reading stopped date cannot be before start date.")
-            )
 
     class Meta:
         model = models.ReadThrough
-        fields = ["user", "book", "start_date", "finish_date", "stopped_date"]
+        fields = ["user", "book", "start_date", "finish_date"]

bookwyrm/importers/__init__.py

@@ -1,7 +1,6 @@
 """ import classes """
 
 from .importer import Importer
-from .calibre_import import CalibreImporter
 from .goodreads_import import GoodreadsImporter
 from .librarything_import import LibrarythingImporter
 from .openlibrary_import import OpenLibraryImporter

bookwyrm/importers/calibre_import.py

@@ -1,28 +0,0 @@
-""" handle reading a csv from calibre """
-from bookwyrm.models import Shelf
-
-from . import Importer
-
-
-class CalibreImporter(Importer):
-    """csv downloads from Calibre"""
-
-    service = "Calibre"
-
-    def __init__(self, *args, **kwargs):
-        # Add timestamp to row_mappings_guesses for date_added to avoid
-        # integrity error
-        row_mappings_guesses = []
-
-        for field, mapping in self.row_mappings_guesses:
-            if field in ("date_added",):
-                row_mappings_guesses.append((field, mapping + ["timestamp"]))
-            else:
-                row_mappings_guesses.append((field, mapping))
-
-        self.row_mappings_guesses = row_mappings_guesses
-        super().__init__(*args, **kwargs)
-
-    def get_shelf(self, normalized_row):
-        # Calibre export does not indicate which shelf to use. Go with a default one for now
-        return Shelf.TO_READ

bookwyrm/importers/librarything_import.py

@@ -1,8 +1,5 @@
 """ handle reading a tsv from librarything """
 import re
-
-from bookwyrm.models import Shelf
-
 from . import Importer
 
 
@@ -24,7 +21,7 @@ class LibrarythingImporter(Importer):
 
     def get_shelf(self, normalized_row):
         if normalized_row["date_finished"]:
-            return Shelf.READ_FINISHED
+            return "read"
         if normalized_row["date_started"]:
-            return Shelf.READING
-        return Shelf.TO_READ
+            return "reading"
+        return "to-read"

bookwyrm/management/commands/generate_preview_images.py

@@ -56,17 +56,12 @@ class Command(BaseCommand):
             self.stdout.write(" OK 🖼")
 
             # Books
-            book_ids = (
-                models.Book.objects.select_subclasses()
-                .filter()
-                .values_list("id", flat=True)
-            )
-
+            books = models.Book.objects.select_subclasses().filter()
             self.stdout.write(
-                "   → Book preview images ({}): ".format(len(book_ids)), ending=""
+                "   → Book preview images ({}): ".format(len(books)), ending=""
             )
-            for book_id in book_ids:
-                preview_images.generate_edition_preview_image_task.delay(book_id)
+            for book in books:
+                preview_images.generate_edition_preview_image_task.delay(book.id)
                 self.stdout.write(".", ending="")
             self.stdout.write(" OK 🖼")
 

bookwyrm/management/commands/initdb.py

@@ -89,7 +89,7 @@ def init_connectors():
         covers_url="https://inventaire.io",
         search_url="https://inventaire.io/api/search?types=works&types=works&search=",
         isbn_search_url="https://inventaire.io/api/entities?action=by-uris&uris=isbn%3A",
-        priority=1,
+        priority=3,
     )
 
     models.Connector.objects.create(
@@ -101,7 +101,7 @@ def init_connectors():
         covers_url="https://covers.openlibrary.org",
         search_url="https://openlibrary.org/search?q=",
         isbn_search_url="https://openlibrary.org/api/books?jscmd=data&format=json&bibkeys=ISBN:",
-        priority=1,
+        priority=3,
     )
 
 

bookwyrm/migrations/0146_auto_20220316_2320.py

@@ -1,80 +0,0 @@
-# Generated by Django 3.2.12 on 2022-03-16 23:20
-
-import bookwyrm.models.fields
-from django.db import migrations
-from bookwyrm.models import Shelf
-
-
-def add_shelves(apps, schema_editor):
-    """add any superusers to the "admin" group"""
-
-    db_alias = schema_editor.connection.alias
-    shelf_model = apps.get_model("bookwyrm", "Shelf")
-
-    users = apps.get_model("bookwyrm", "User")
-    local_users = users.objects.using(db_alias).filter(local=True)
-    for user in local_users:
-        remote_id = f"{user.remote_id}/books/stopped"
-        shelf_model.objects.using(db_alias).create(
-            name="Stopped reading",
-            identifier=Shelf.STOPPED_READING,
-            user=user,
-            editable=False,
-            remote_id=remote_id,
-        )
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("bookwyrm", "0145_sitesettings_version"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="comment",
-            name="reading_status",
-            field=bookwyrm.models.fields.CharField(
-                blank=True,
-                choices=[
-                    ("to-read", "To-Read"),
-                    ("reading", "Reading"),
-                    ("read", "Read"),
-                    ("stopped-reading", "Stopped-Reading"),
-                ],
-                max_length=255,
-                null=True,
-            ),
-        ),
-        migrations.AlterField(
-            model_name="quotation",
-            name="reading_status",
-            field=bookwyrm.models.fields.CharField(
-                blank=True,
-                choices=[
-                    ("to-read", "To-Read"),
-                    ("reading", "Reading"),
-                    ("read", "Read"),
-                    ("stopped-reading", "Stopped-Reading"),
-                ],
-                max_length=255,
-                null=True,
-            ),
-        ),
-        migrations.AlterField(
-            model_name="review",
-            name="reading_status",
-            field=bookwyrm.models.fields.CharField(
-                blank=True,
-                choices=[
-                    ("to-read", "To-Read"),
-                    ("reading", "Reading"),
-                    ("read", "Read"),
-                    ("stopped-reading", "Stopped-Reading"),
-                ],
-                max_length=255,
-                null=True,
-            ),
-        ),
-        migrations.RunPython(add_shelves, reverse_code=migrations.RunPython.noop),
-    ]

bookwyrm/migrations/0148_merge_20220326_2006.py

@@ -1,13 +0,0 @@
-# Generated by Django 3.2.12 on 2022-03-26 20:06
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("bookwyrm", "0146_auto_20220316_2320"),
-        ("bookwyrm", "0147_alter_user_preferred_language"),
-    ]
-
-    operations = []

bookwyrm/migrations/0149_merge_20220526_1716.py

@@ -1,13 +0,0 @@
-# Generated by Django 3.2.13 on 2022-05-26 17:16
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("bookwyrm", "0148_alter_user_preferred_language"),
-        ("bookwyrm", "0148_merge_20220326_2006"),
-    ]
-
-    operations = []

bookwyrm/migrations/0149_remove_notification_related_book.py

@@ -0,0 +1,17 @@
+# Generated by Django 3.2.12 on 2022-04-08 22:20
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0148_alter_user_preferred_language"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="notification",
+            name="related_book",
+        ),
+    ]

bookwyrm/migrations/0150_auto_20220408_2236.py

@@ -0,0 +1,128 @@
+# Generated by Django 3.2.12 on 2022-04-08 22:36
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("bookwyrm", "0149_remove_notification_related_book"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="notification",
+            name="related_groups",
+            field=models.ManyToManyField(
+                related_name="notifications", to="bookwyrm.Group"
+            ),
+        ),
+        migrations.AddField(
+            model_name="notification",
+            name="related_list_items",
+            field=models.ManyToManyField(
+                related_name="notifications", to="bookwyrm.ListItem"
+            ),
+        ),
+        migrations.AddField(
+            model_name="notification",
+            name="related_reports",
+            field=models.ManyToManyField(to="bookwyrm.Report"),
+        ),
+        migrations.AddField(
+            model_name="notification",
+            name="related_statuses",
+            field=models.ManyToManyField(
+                related_name="notifications", to="bookwyrm.Status"
+            ),
+        ),
+        migrations.AddField(
+            model_name="notification",
+            name="related_users",
+            field=models.ManyToManyField(
+                related_name="notifications", to=settings.AUTH_USER_MODEL
+            ),
+        ),
+        migrations.AlterField(
+            model_name="notification",
+            name="related_group",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="notifications_temp",
+                to="bookwyrm.group",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="notification",
+            name="related_list_item",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="notifications_tmp",
+                to="bookwyrm.listitem",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="notification",
+            name="related_report",
+            field=models.ForeignKey(
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="notifications_tmp",
+                to="bookwyrm.report",
+            ),
+        ),
+        migrations.RunSQL(
+            sql="""
+            INSERT INTO bookwyrm_notification_related_statuses (notification_id, status_id)
+            SELECT id, related_status_id
+            FROM bookwyrm_notification
+                WHERE bookwyrm_notification.related_status_id IS NOT NULL;
+
+            INSERT INTO bookwyrm_notification_related_users (notification_id, user_id)
+            SELECT id, related_user_id
+            FROM bookwyrm_notification
+                WHERE bookwyrm_notification.related_user_id IS NOT NULL;
+
+            INSERT INTO bookwyrm_notification_related_groups (notification_id, group_id)
+            SELECT id, related_group_id
+            FROM bookwyrm_notification
+                WHERE bookwyrm_notification.related_group_id IS NOT NULL;
+
+            INSERT INTO bookwyrm_notification_related_list_items (notification_id, listitem_id)
+            SELECT id, related_list_item_id
+            FROM bookwyrm_notification
+                WHERE bookwyrm_notification.related_list_item_id IS NOT NULL;
+
+            INSERT INTO bookwyrm_notification_related_reports (notification_id, report_id)
+            SELECT id, related_report_id
+            FROM bookwyrm_notification
+                WHERE bookwyrm_notification.related_report_id IS NOT NULL;
+
+            """,
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+        migrations.RemoveField(
+            model_name="notification",
+            name="related_group",
+        ),
+        migrations.RemoveField(
+            model_name="notification",
+            name="related_list_item",
+        ),
+        migrations.RemoveField(
+            model_name="notification",
+            name="related_report",
+        ),
+        migrations.RemoveField(
+            model_name="notification",
+            name="related_status",
+        ),
+        migrations.RemoveField(
+            model_name="notification",
+            name="related_user",
+        ),
+    ]

bookwyrm/migrations/0150_readthrough_stopped_date.py

@@ -1,18 +0,0 @@
-# Generated by Django 3.2.13 on 2022-05-26 18:33
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("bookwyrm", "0149_merge_20220526_1716"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="readthrough",
-            name="stopped_date",
-            field=models.DateTimeField(blank=True, null=True),
-        ),
-    ]

bookwyrm/models/base_model.py

@@ -8,7 +8,6 @@ from django.db.models import Q
 from django.dispatch import receiver
 from django.http import Http404
 from django.utils.translation import gettext_lazy as _
-from django.utils.text import slugify
 
 from bookwyrm.settings import DOMAIN
 from .fields import RemoteIdField
@@ -36,11 +35,10 @@ class BookWyrmModel(models.Model):
     remote_id = RemoteIdField(null=True, activitypub_field="id")
 
     def get_remote_id(self):
-        """generate the url that resolves to the local object, without a slug"""
+        """generate a url that resolves to the local object"""
         base_path = f"https://{DOMAIN}"
         if hasattr(self, "user"):
             base_path = f"{base_path}{self.user.local_path}"
-
         model_name = type(self).__name__.lower()
         return f"{base_path}/{model_name}/{self.id}"
 
@@ -51,20 +49,8 @@ class BookWyrmModel(models.Model):
 
     @property
     def local_path(self):
-        """how to link to this object in the local app, with a slug"""
-        local = self.get_remote_id().replace(f"https://{DOMAIN}", "")
-
-        name = None
-        if hasattr(self, "name_field"):
-            name = getattr(self, self.name_field)
-        elif hasattr(self, "name"):
-            name = self.name
-
-        if name:
-            slug = slugify(name)
-            local = f"{local}/s/{slug}"
-
-        return local
+        """how to link to this object in the local app"""
+        return self.get_remote_id().replace(f"https://{DOMAIN}", "")
 
     def raise_visible_to_user(self, viewer):
         """is a user authorized to view an object?"""

bookwyrm/models/book.py

@@ -176,8 +176,8 @@ class Book(BookDataModel):
         """properties of this edition, as a string"""
         items = [
             self.physical_format if hasattr(self, "physical_format") else None,
-            f"{self.languages[0]} language"
-            if self.languages and self.languages[0] and self.languages[0] != "English"
+            self.languages[0] + " language"
+            if self.languages and self.languages[0] != "English"
             else None,
             str(self.published_date.year) if self.published_date else None,
             ", ".join(self.publishers) if hasattr(self, "publishers") else None,

bookwyrm/models/import_job.py

@@ -175,15 +175,9 @@ class ImportItem(models.Model):
     def date_added(self):
         """when the book was added to this dataset"""
         if self.normalized_data.get("date_added"):
-            parsed_date_added = dateutil.parser.parse(
-                self.normalized_data.get("date_added")
+            return timezone.make_aware(
+                dateutil.parser.parse(self.normalized_data.get("date_added"))
             )
-
-            if timezone.is_aware(parsed_date_added):
-                # Keep timezone if import already had one
-                return parsed_date_added
-
-            return timezone.make_aware(parsed_date_added)
         return None
 
     @property

bookwyrm/models/notification.py

@@ -15,40 +15,25 @@ class Notification(BookWyrmModel):
     """you've been tagged, liked, followed, etc"""
 
     user = models.ForeignKey("User", on_delete=models.CASCADE)
-    related_book = models.ForeignKey("Edition", on_delete=models.CASCADE, null=True)
-    related_user = models.ForeignKey(
-        "User", on_delete=models.CASCADE, null=True, related_name="related_user"
-    )
-    related_group = models.ForeignKey(
-        "Group", on_delete=models.CASCADE, null=True, related_name="notifications"
-    )
-    related_status = models.ForeignKey("Status", on_delete=models.CASCADE, null=True)
-    related_import = models.ForeignKey("ImportJob", on_delete=models.CASCADE, null=True)
-    related_list_item = models.ForeignKey(
-        "ListItem", on_delete=models.CASCADE, null=True
-    )
-    related_report = models.ForeignKey("Report", on_delete=models.CASCADE, null=True)
     read = models.BooleanField(default=False)
     notification_type = models.CharField(
         max_length=255, choices=NotificationType.choices
     )
 
-    def save(self, *args, **kwargs):
-        """save, but don't make dupes"""
-        # there's probably a better way to do this
-        if self.__class__.objects.filter(
-            user=self.user,
-            related_book=self.related_book,
-            related_user=self.related_user,
-            related_group=self.related_group,
-            related_status=self.related_status,
-            related_import=self.related_import,
-            related_list_item=self.related_list_item,
-            related_report=self.related_report,
-            notification_type=self.notification_type,
-        ).exists():
-            return
-        super().save(*args, **kwargs)
+    related_users = models.ManyToManyField(
+        "User", symmetrical=False, related_name="notifications"
+    )
+    related_groups = models.ManyToManyField(
+        "Group", symmetrical=False, related_name="notifications"
+    )
+    related_statuses = models.ManyToManyField(
+        "Status", symmetrical=False, related_name="notifications"
+    )
+    related_import = models.ForeignKey("ImportJob", on_delete=models.CASCADE, null=True)
+    related_list_items = models.ManyToManyField(
+        "ListItem", symmetrical=False, related_name="notifications"
+    )
+    related_reports = models.ManyToManyField("Report", symmetrical=False)
 
     class Meta:
         """checks if notifcation is in enum list for valid types"""

bookwyrm/models/readthrough.py

@@ -27,7 +27,6 @@ class ReadThrough(BookWyrmModel):
     )
     start_date = models.DateTimeField(blank=True, null=True)
     finish_date = models.DateTimeField(blank=True, null=True)
-    stopped_date = models.DateTimeField(blank=True, null=True)
     is_active = models.BooleanField(default=True)
 
     def save(self, *args, **kwargs):
@@ -35,7 +34,7 @@ class ReadThrough(BookWyrmModel):
         cache.delete(f"latest_read_through-{self.user.id}-{self.book.id}")
         self.user.update_active_date()
         # an active readthrough must have an unset finish date
-        if self.finish_date or self.stopped_date:
+        if self.finish_date:
             self.is_active = False
         super().save(*args, **kwargs)
 

bookwyrm/models/shelf.py

@@ -6,7 +6,6 @@ from django.db import models
 from django.utils import timezone
 
 from bookwyrm import activitypub
-from bookwyrm.settings import DOMAIN
 from .activitypub_mixin import CollectionItemMixin, OrderedCollectionMixin
 from .base_model import BookWyrmModel
 from . import fields
@@ -18,9 +17,8 @@ class Shelf(OrderedCollectionMixin, BookWyrmModel):
     TO_READ = "to-read"
     READING = "reading"
     READ_FINISHED = "read"
-    STOPPED_READING = "stopped-reading"
 
-    READ_STATUS_IDENTIFIERS = (TO_READ, READING, READ_FINISHED, STOPPED_READING)
+    READ_STATUS_IDENTIFIERS = (TO_READ, READING, READ_FINISHED)
 
     name = fields.CharField(max_length=100)
     identifier = models.CharField(max_length=100)
@@ -67,11 +65,6 @@ class Shelf(OrderedCollectionMixin, BookWyrmModel):
         identifier = self.identifier or self.get_identifier()
         return f"{base_path}/books/{identifier}"
 
-    @property
-    def local_path(self):
-        """No slugs"""
-        return self.get_remote_id().replace(f"https://{DOMAIN}", "")
-
     def raise_not_deletable(self, viewer):
         """don't let anyone delete a default shelf"""
         super().raise_not_deletable(viewer)

bookwyrm/models/status.py

@@ -116,8 +116,11 @@ class Status(OrderedCollectionPageMixin, BookWyrmModel):
     def ignore_activity(cls, activity):  # pylint: disable=too-many-return-statements
         """keep notes if they are replies to existing statuses"""
         if activity.type == "Announce":
-            boosted = activitypub.resolve_remote_id(activity.object, get_activity=True)
-            if not boosted:
+            try:
+                boosted = activitypub.resolve_remote_id(
+                    activity.object, get_activity=True
+                )
+            except activitypub.ActivitySerializerError:
                 # if we can't load the status, definitely ignore it
                 return True
             # keep the boost if we would keep the status
@@ -262,7 +265,7 @@ class GeneratedNote(Status):
 
 
 ReadingStatusChoices = models.TextChoices(
-    "ReadingStatusChoices", ["to-read", "reading", "read", "stopped-reading"]
+    "ReadingStatusChoices", ["to-read", "reading", "read"]
 )
 
 
@@ -303,17 +306,10 @@ class Comment(BookStatus):
     @property
     def pure_content(self):
         """indicate the book in question for mastodon (or w/e) users"""
-        if self.progress_mode == "PG" and self.progress and (self.progress > 0):
-            return_value = (
-                f'{self.content}<p>(comment on <a href="{self.book.remote_id}">'
-                f'"{self.book.title}"</a>, page {self.progress})</p>'
-            )
-        else:
-            return_value = (
+        return (
             f'{self.content}<p>(comment on <a href="{self.book.remote_id}">'
             f'"{self.book.title}"</a>)</p>'
         )
-        return return_value
 
     activity_serializer = activitypub.Comment
 
@@ -339,17 +335,10 @@ class Quotation(BookStatus):
         """indicate the book in question for mastodon (or w/e) users"""
         quote = re.sub(r"^<p>", '<p>"', self.quote)
         quote = re.sub(r"</p>$", '"</p>', quote)
-        if self.position_mode == "PG" and self.position and (self.position > 0):
-            return_value = (
-                f'{quote} <p>-- <a href="{self.book.remote_id}">'
-                f'"{self.book.title}"</a>, page {self.position}</p>{self.content}'
-            )
-        else:
-            return_value = (
+        return (
             f'{quote} <p>-- <a href="{self.book.remote_id}">'
             f'"{self.book.title}"</a></p>{self.content}'
         )
-        return return_value
 
     activity_serializer = activitypub.Quotation
 
@@ -388,7 +377,7 @@ class Review(BookStatus):
     def save(self, *args, **kwargs):
         """clear rating caches"""
         if self.book.parent_work:
-            cache.delete(f"book-rating-{self.book.parent_work.id}")
+            cache.delete(f"book-rating-{self.book.parent_work.id}-*")
         super().save(*args, **kwargs)
 
 

bookwyrm/models/user.py

@@ -374,10 +374,6 @@ class User(OrderedCollectionPageMixin, AbstractUser):
                 "name": "Read",
                 "identifier": "read",
             },
-            {
-                "name": "Stopped Reading",
-                "identifier": "stopped-reading",
-            },
         ]
 
         for shelf in shelves:

bookwyrm/settings.py

@@ -11,7 +11,7 @@ from django.utils.translation import gettext_lazy as _
 env = Env()
 env.read_env()
 DOMAIN = env("DOMAIN")
-VERSION = "0.4.0"
+VERSION = "0.3.4"
 
 RELEASE_API = env(
     "RELEASE_API",
@@ -21,7 +21,7 @@ RELEASE_API = env(
 PAGE_LENGTH = env("PAGE_LENGTH", 15)
 DEFAULT_LANGUAGE = env("DEFAULT_LANGUAGE", "English")
 
-JS_CACHE = "e678183b"
+JS_CACHE = "bc93172a"
 
 # email
 EMAIL_BACKEND = env("EMAIL_BACKEND", "django.core.mail.backends.smtp.EmailBackend")
@@ -212,7 +212,7 @@ STREAMS = [
 
 # Search configuration
 # total time in seconds that the instance will spend searching connectors
-SEARCH_TIMEOUT = int(env("SEARCH_TIMEOUT", 8))
+SEARCH_TIMEOUT = int(env("SEARCH_TIMEOUT", 15))
 # timeout for a query to an individual connector
 QUERY_TIMEOUT = int(env("QUERY_TIMEOUT", 5))
 

bookwyrm/static/css/bookwyrm/utilities/_colors.scss

@@ -23,8 +23,3 @@
 .has-background-tertiary {
     background-color: $background-tertiary !important;
 }
-
-/* Workaround for dark theme as .has-text-black doesn't give desired effect. */
-.has-text-default {
-    color: $text !important;
-}

bookwyrm/static/css/themes/bookwyrm-dark.scss

@@ -53,7 +53,6 @@ $link-hover: $white-bis;
 $link-hover-border: #51595d;
 $link-focus: $white-bis;
 $link-active: $white-bis;
-$link-light: #0d1c26;
 
 /* bulma overrides */
 $background: $background-secondary;
@@ -84,13 +83,6 @@ $progress-value-background-color: $border-light;
 $family-primary: $family-sans-serif;
 $family-secondary: $family-sans-serif;
 
-.has-text-muted {
-    color: $grey-lighter !important;
-}
-
-.has-text-more-muted {
-    color: $grey-light !important;
-}
 
 @import "../bookwyrm.scss";
 @import "../vendor/icons.css";

bookwyrm/static/css/themes/bookwyrm-light.scss

@@ -57,13 +57,5 @@ $invisible-overlay-background-color: rgba($scheme-invert, 0.66);
 $family-primary: $family-sans-serif;
 $family-secondary: $family-sans-serif;
 
-.has-text-muted {
-    color: $grey-dark !important;
-}
-
-.has-text-more-muted {
-    color: $grey !important;
-}
-
 @import "../bookwyrm.scss";
 @import "../vendor/icons.css";

bookwyrm/static/js/status_cache.js

@@ -203,8 +203,6 @@ let StatusCache = new (class {
             .forEach((item) => (item.disabled = false));
 
         next_identifier = next_identifier == "complete" ? "read" : next_identifier;
-        next_identifier =
-            next_identifier == "stopped-reading-complete" ? "stopped-reading" : next_identifier;
 
         // Disable the current state
         button.querySelector(

bookwyrm/templates/about/layout.html

@@ -50,7 +50,7 @@
         </ul>
     </nav>
 
-    <div class="column is-clipped">
+    <div class="column">
         {% block about_content %}{% endblock %}
     </div>
 </div>

bookwyrm/templates/author/edit_author.html

@@ -24,7 +24,7 @@
 </div>
 {% endif %}
 
-<form class="block" name="edit-author" action="{% url 'edit-author' author.id %}" method="post">
+<form class="block" name="edit-author" action="{{ author.local_path }}/edit" method="post">
     {% csrf_token %}
     <input type="hidden" name="last_edited_by" value="{{ request.user.id }}">
 

bookwyrm/templates/book/book.html

@@ -284,7 +284,7 @@
                 {% if user_statuses.review_count or user_statuses.comment_count or user_statuses.quotation_count %}
                 <nav class="tabs">
                     <ul>
-                        {% url 'book' book.id book.name|slugify as tab_url %}
+                        {% url 'book' book.id as tab_url %}
                         <li {% if tab_url == request.path %}class="is-active"{% endif %}>
                             <a href="{{ tab_url }}#reviews">{% trans "Reviews" %} ({{ review_count }})</a>
                         </li>

bookwyrm/templates/book/edit/edit_book.html

@@ -41,18 +41,10 @@
     class="block"
     {% if book.id %}
         name="edit-book"
-        {% if confirm_mode %}
-        action="{% url 'edit-book-confirm' book.id %}"
-        {% else %}
-        action="{% url 'edit-book' book.id %}"
-        {% endif %}
+        action="{{ book.local_path }}/{% if confirm_mode %}confirm{% else %}edit{% endif %}"
     {% else %}
         name="create-book"
-        {% if confirm_mode %}
-        action="{% url 'create-book-confirm' %}"
-        {% else %}
-        action="{% url 'create-book' %}"
-        {% endif %}
+        action="/create-book{% if confirm_mode %}/confirm{% endif %}"
     {% endif %}
     method="post"
     enctype="multipart/form-data"

bookwyrm/templates/book/editions/editions.html

@@ -21,7 +21,7 @@
 
         <div class="column my-3-mobile ml-3-tablet mr-auto">
             <h2 class="title is-5 mb-1">
-                <a href="{{ book.local_path }}" class="has-text-default">
+                <a href="{{ book.local_path }}" class="has-text-black">
                     {{ book|book_title }}
                 </a>
             </h2>

bookwyrm/templates/book/file_links/edit_links.html

@@ -15,7 +15,7 @@
 
     <nav class="breadcrumb subtitle" aria-label="breadcrumbs">
         <ul>
-            <li><a href="{% url 'book' book.id book.name|slugify %}">{{ book|book_title }}</a></li>
+            <li><a href="{% url 'book' book.id %}">{{ book|book_title }}</a></li>
             <li class="is-active">
                 <a href="#" aria-current="page">
                     {% trans "Edit links" %}

bookwyrm/templates/get_started/book_preview.html

@@ -10,7 +10,6 @@
                 {% if shelf.identifier == 'to-read' %}{% trans "To Read" %}
                 {% elif shelf.identifier == 'reading' %}{% trans "Currently Reading" %}
                 {% elif shelf.identifier == 'read' %}{% trans "Read" %}
-                {% elif shelf.identifier == 'stopped-reading' %}{% trans "Stopped Reading" %}
                 {% else %}{{ shelf.name }}{% endif %}
             </option>
             {% endfor %}

bookwyrm/templates/groups/members.html

@@ -38,7 +38,7 @@
     {% for membership in group.memberships.all %}
     {% with member=membership.user %}
     <div class="box has-text-centered is-shadowless has-background-tertiary my-2 mx-2 member_{{ member.id }}">
-        <a href="{{ member.local_path }}" class="has-text-default">
+        <a href="{{ member.local_path }}" class="has-text-black">
             {% include 'snippets/avatar.html' with user=member large=True %}
             <span title="{{ member.display_name }}" class="is-block is-6 has-text-weight-bold">{{ member.display_name|truncatechars:10 }}</span>
             <span title="@{{ member|username }}" class="is-block pb-3">@{{ member|username|truncatechars:8 }}</span>

bookwyrm/templates/groups/suggested_users.html

@@ -9,7 +9,7 @@
     <div class="column is-flex is-flex-grow-0">
         {% for user in suggested_users %}
         <div class="box has-text-centered is-shadowless has-background-tertiary m-2">
-            <a href="{{ user.local_path }}" class="has-text-default">
+            <a href="{{ user.local_path }}" class="has-text-black">
                 {% include 'snippets/avatar.html' with user=user large=True %}
                 <span title="{{ user.display_name }}" class="is-block is-6 has-text-weight-bold">{{ user.display_name|truncatechars:10 }}</span>
                 <span title="@{{ user|username }}" class="is-block pb-3">@{{ user|username|truncatechars:8 }}</span>

bookwyrm/templates/import/import.html

@@ -32,9 +32,6 @@
                         <option value="OpenLibrary" {% if current == 'OpenLibrary' %}selected{% endif %}>
                             OpenLibrary (CSV)
                         </option>
-                        <option value="Calibre" {% if current == 'Calibre' %}selected{% endif %}>
-                            Calibre (CSV)
-                        </option>
                     </select>
                 </div>
 

bookwyrm/templates/lists/curate.html

@@ -6,7 +6,7 @@
 <nav class="breadcrumb subtitle" aria-label="breadcrumbs">
     <ul>
         <li><a href="{% url 'lists' %}">{% trans "Lists" %}</a></li>
-        <li><a href="{% url 'list' list_id=list.id slug=list.name|slugify %}">{{ list.name|truncatechars:30 }}</a></li>
+        <li><a href="{% url 'list' list.id %}">{{ list.name|truncatechars:30 }}</a></li>
         <li class="is-active">
             <a href="#" aria-current="page">
                 {% trans "Curate" %}

bookwyrm/templates/lists/list.html

@@ -180,7 +180,7 @@
         <h2 class="title is-5">
             {% trans "Sort List" %}
         </h2>
-        <form name="sort" action="{% url 'list' list_id=list.id slug=list.name|slugify %}" method="GET" class="block">
+        <form name="sort" action="{% url 'list' list.id %}" method="GET" class="block">
             <div class="field">
                 <label class="label" for="id_sort_by">{% trans "Sort By" %}</label>
                 <div class="select is-fullwidth">
@@ -207,7 +207,7 @@
                 {% trans "Suggest Books" %}
             {% endif %}
         </h2>
-        <form name="search" action="{% url 'list' list_id=list.id slug=list.name|slugify %}" method="GET" class="block">
+        <form name="search" action="{% url 'list' list.id %}" method="GET" class="block">
             <div class="field has-addons">
                 <div class="control">
                     <input aria-label="{% trans 'Search for a book' %}" class="input" type="text" name="q" placeholder="{% trans 'Search for a book' %}" value="{{ query }}">
@@ -221,7 +221,7 @@
                 </div>
             </div>
             {% if query %}
-            <p class="help"><a href="{% url 'list' list_id=list.id slug=list.name|slugify %}">{% trans "Clear search" %}</a></p>
+            <p class="help"><a href="{% url 'list' list.id %}">{% trans "Clear search" %}</a></p>
             {% endif %}
         </form>
         {% if not suggested_books %}

bookwyrm/templates/notifications/items/boost.html

@@ -47,12 +47,12 @@
 
 
 {% block preview %}
-<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-muted{% endif %}">
+<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-grey-dark{% endif %}">
     <div class="columns">
         <div class="column is-clipped">
             {% include 'snippets/status_preview.html' with status=related_status %}
         </div>
-        <div class="column is-narrow has-text-muted">
+        <div class="column is-narrow has-grey-dark">
             {{ related_status.published_date|timesince }}
             {% include 'snippets/privacy-icons.html' with item=related_status %}
         </div>

bookwyrm/templates/notifications/items/fav.html

@@ -47,12 +47,12 @@
 
 
 {% block preview %}
-<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-muted{% endif %}">
+<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-grey-dark{% endif %}">
     <div class="columns">
         <div class="column is-clipped">
             {% include 'snippets/status_preview.html' with status=related_status %}
         </div>
-        <div class="column is-narrow has-text-muted">
+        <div class="column is-narrow has-grey-dark">
             {{ related_status.published_date|timesince }}
             {% include 'snippets/privacy-icons.html' with item=related_status %}
         </div>

bookwyrm/templates/notifications/items/layout.html

@@ -1,7 +1,7 @@
 {% load notification_page_tags %}
 {% related_status notification as related_status %}
 <div class="notification {% if notification.id in unread %}has-background-primary{% endif %}">
-    <div class="columns is-mobile {% if notification.id in unread %}has-text-white{% else %}has-text-more-muted{% endif %}">
+    <div class="columns is-mobile {% if notification.id in unread %}has-text-white{% else %}has-text-grey{% endif %}">
         <div class="column is-narrow is-size-3">
             <a class="icon" href="{% block primary_link %}{% endblock %}">
                 {% block icon %}{% endblock %}

bookwyrm/templates/notifications/items/mention.html

@@ -48,12 +48,12 @@
 
 
 {% block preview %}
-<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-default{% endif %}">
+<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-black{% endif %}">
     <div class="columns">
         <div class="column is-clipped">
             {% include 'snippets/status_preview.html' with status=related_status %}
         </div>
-        <div class="column is-narrow has-text-default">
+        <div class="column is-narrow has-text-black">
             {{ related_status.published_date|timesince }}
             {% include 'snippets/privacy-icons.html' with item=related_status %}
         </div>

bookwyrm/templates/notifications/items/reply.html

@@ -51,12 +51,12 @@
 
 
 {% block preview %}
-<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-default{% endif %}">
+<div class="notification py-2 {% if notification.id in unread %}is-primary is-light{% else %}has-background-body has-text-black{% endif %}">
     <div class="columns">
         <div class="column is-clipped">
             {% include 'snippets/status_preview.html' with status=related_status %}
         </div>
-        <div class="column is-narrow has-text-default">
+        <div class="column is-narrow has-text-black">
             {{ related_status.published_date|timesince }}
             {% include 'snippets/privacy-icons.html' with item=related_status %}
         </div>

bookwyrm/templates/reading_progress/stop.html

@@ -1,14 +0,0 @@
-{% extends 'layout.html' %}
-{% load i18n %}
-
-{% block title %}
-{% blocktrans trimmed with book_title=book.title %}
-Stop Reading "{{ book_title }}"
-{% endblocktrans %}
-{% endblock %}
-
-{% block content %}
-
-{% include "snippets/reading_modals/stop_reading_modal.html" with book=book active=True static=True %}
-
-{% endblock %}

bookwyrm/templates/readthrough/readthrough_form.html

@@ -19,7 +19,6 @@
 </label>
 {% include "snippets/progress_field.html" with id=field_id %}
 {% endif %}
-
 <div class="field">
     <label class="label" for="id_finish_date_{{ readthrough.id }}">
         {% trans "Finished reading" %}

bookwyrm/templates/readthrough/readthrough_list.html

@@ -8,12 +8,10 @@
             <div class="column">
                 {% trans "Progress Updates:" %}
                 <ul>
-                    {% if readthrough.finish_date or readthrough.stopped_date or readthrough.progress %}
+                    {% if readthrough.finish_date or readthrough.progress %}
                     <li>
                         {% if readthrough.finish_date %}
                             {{ readthrough.finish_date | localtime | naturalday }}: {% trans "finished" %}
-                        {% elif readthrough.stopped_date %}
-                            {{ readthrough.stopped_date | localtime | naturalday }}: {% trans "stopped" %}
                         {% else %}
 
                             {% if readthrough.progress_mode == 'PG' %}

bookwyrm/templates/search/book.html

@@ -36,7 +36,7 @@
     {% if result_set.results %}
     <section class="mb-5">
         {% if not result_set.connector.local %}
-        <details class="details-panel box" open>
+        <details class="details-panel box" {% if forloop.first %}open{% endif %}>
         {% endif %}
             {% if not result_set.connector.local %}
             <summary class="is-flex is-align-items-center is-flex-wrap-wrap is-gap-2">

bookwyrm/templates/shelf/shelf.html

@@ -86,7 +86,6 @@
                 {% if shelf.identifier == 'to-read' %}{% trans "To Read" %}
                 {% elif shelf.identifier == 'reading' %}{% trans "Currently Reading" %}
                 {% elif shelf.identifier == 'read' %}{% trans "Read" %}
-                {% elif shelf.identifier == 'stopped-reading' %}{% trans "Stopped Reading" %}
                 {% else %}{{ shelf.name }}{% endif %}
                 <span class="subtitle">
                     {% include 'snippets/privacy-icons.html' with item=shelf %}
@@ -151,7 +150,7 @@
                         {% if is_self %}
                     <th>{% trans "Shelved"  as text %}{% include 'snippets/table-sort-header.html' with field="shelved_date" sort=sort text=text %}</th>
                     <th>{% trans "Started"  as text %}{% include 'snippets/table-sort-header.html' with field="start_date" sort=sort text=text %}</th>
-                    <th>{% if shelf.identifier == 'read' %}{% trans "Finished"  as text %}{% else %}{% trans "Until"  as text %}{% endif %}{% include 'snippets/table-sort-header.html' with field="finish_date" sort=sort text=text %}</th>
+                    <th>{% trans "Finished"  as text %}{% include 'snippets/table-sort-header.html' with field="finish_date" sort=sort text=text %}</th>
                         {% endif %}
                     <th>{% trans "Rating" as text %}{% include 'snippets/table-sort-header.html' with field="rating" sort=sort text=text %}</th>
                     {% endif %}
@@ -181,7 +180,7 @@
                     <td data-title="{% trans "Started" %}">
                         {{ book.start_date|naturalday|default_if_none:""}}
                     </td>
-                    <td data-title="{% if shelf.identifier == 'read' %}{% trans "Finished"  as text %}{% else %}{% trans "Until" as text %}{% endif %}">
+                    <td data-title="{% trans "Finished" %}">
                         {{ book.finish_date|naturalday|default_if_none:""}}
                     </td>
                         {% endif %}

bookwyrm/templates/snippets/reading_modals/stop_reading_modal.html

@@ -1,42 +0,0 @@
-{% extends 'snippets/reading_modals/layout.html' %}
-{% load i18n %}
-{% load utilities %}
-
-{% block modal-title %}
-{% blocktrans trimmed with book_title=book|book_title %}
-Stop Reading "<em>{{ book_title }}</em>"
-{% endblocktrans %}
-{% endblock %}
-
-{% block modal-form-open %}
-<form name="stop-reading-{{ uuid }}" action="{% url 'reading-status' 'stop' book.id %}" method="post" {% if not refresh %}class="submit-status"{% endif %}>
-{% csrf_token %}
-<input type="hidden" name="id" value="{{ readthrough.id }}">
-<input type="hidden" name="reading_status" value="stopped-reading">
-<input type="hidden" name="shelf" value="{{ move_from }}">
-{% endblock %}
-
-{% block reading-dates %}
-<div class="columns">
-    <div class="column is-half">
-        <div class="field">
-            <label class="label" for="stop_id_start_date_{{ uuid }}">
-                {% trans "Started reading" %}
-            </label>
-            <input type="date" name="start_date" class="input" id="stop_id_start_date_{{ uuid }}" value="{{ readthrough.start_date | date:"Y-m-d" }}">
-        </div>
-    </div>
-    <div class="column is-half">
-        <div class="field">
-            <label class="label" for="id_read_until_date_{{ uuid }}">
-                {% trans "Stopped reading" %}
-            </label>
-            <input type="date" name="stopped_date" class="input" id="id_read_until_date_{{ uuid }}" value="{% now "Y-m-d" %}">
-        </div>
-    </div>
-</div>
-{% endblock %}
-
-{% block form %}
-{% include "snippets/reading_modals/form.html" with optional=True type="stop_modal" %}
-{% endblock %}

bookwyrm/templates/snippets/shelf_selector.html

@@ -49,13 +49,6 @@
 {% join "finish_reading" uuid as modal_id %}
 {% include 'snippets/shelve_button/modal_button.html' with class=button_class fallback_url=fallback_url %}
 
-{% elif shelf.identifier == 'stopped-reading' %}
-
-{% trans "Stopped reading" as button_text %}
-{% url 'reading-status' 'stop' book.id as fallback_url %}
-{% join "stop_reading" uuid as modal_id %}
-{% include 'snippets/shelve_button/modal_button.html' with class=button_class fallback_url=fallback_url %}
-
 {% elif shelf.identifier == 'to-read' %}
 
 {% trans "Want to read" as button_text %}
@@ -106,8 +99,5 @@
 {% join "finish_reading" uuid as modal_id %}
 {% include 'snippets/reading_modals/finish_reading_modal.html' with book=active_shelf.book id=modal_id move_from=current.id readthrough=readthrough refresh=True class="" %}
 
-{% join "stop_reading" uuid as modal_id %}
-{% include 'snippets/reading_modals/stop_reading_modal.html' with book=active_shelf.book id=modal_id move_from=current.id readthrough=readthrough refresh=True class="" %}
-
 {% endwith %}
 {% endblock %}

bookwyrm/templates/snippets/shelve_button/shelve_button.html

@@ -29,9 +29,6 @@
 {% join "finish_reading" uuid as modal_id %}
 {% include 'snippets/reading_modals/finish_reading_modal.html' with book=active_shelf_book id=modal_id readthrough=readthrough class="" %}
 
-{% join "stop_reading" uuid as modal_id %}
-{% include 'snippets/reading_modals/stop_reading_modal.html' with book=active_shelf_book id=modal_id readthrough=readthrough class="" %}
-
 {% join "progress_update" uuid as modal_id %}
 {% include 'snippets/reading_modals/progress_update_modal.html' with book=active_shelf_book id=modal_id readthrough=readthrough class="" %}
 

bookwyrm/templates/snippets/shelve_button/shelve_button_dropdown_options.html

@@ -8,7 +8,7 @@
 {% comparison_bool shelf.identifier active_shelf.shelf.identifier as is_current %}
     <li role="menuitem" class="dropdown-item p-0">
         <div
-            class="{% if is_current or next_shelf_identifier == shelf.identifier %}is-hidden{% elif shelf.identifier == 'stopped-reading' and active_shelf.shelf.identifier != "reading" %}is-hidden{% endif %}"
+            class="{% if next_shelf_identifier == shelf.identifier %}is-hidden{% endif %}"
             data-shelf-dropdown-identifier="{{ shelf.identifier }}"
             data-shelf-next="{{ shelf.identifier|next_shelf }}"
         >
@@ -26,13 +26,6 @@
             {% join "finish_reading" button_uuid as modal_id %}
             {% include 'snippets/shelve_button/modal_button.html' with class=class fallback_url=fallback_url %}
 
-        {% elif shelf.identifier == 'stopped-reading' %}
-
-            {% trans "Stop reading" as button_text %}
-            {% url 'reading-status' 'stop' book.id as fallback_url %}
-            {% join "stop_reading" button_uuid as modal_id %}
-            {% include 'snippets/shelve_button/modal_button.html' with class=class fallback_url=fallback_url %}
-
         {% elif shelf.identifier == 'to-read' %}
 
             {% trans "Want to read" as button_text %}

bookwyrm/templates/snippets/shelve_button/shelve_button_options.html

@@ -13,15 +13,6 @@
     </button>
 </div>
 
-<div
-    class="{% if next_shelf_identifier != 'stopped-reading-complete' %}is-hidden{% endif %}"
-    data-shelf-identifier="stopped-reading-complete"
->
-    <button type="button" class="button {{ class }}" disabled>
-        <span>{% trans "Stopped reading" %}</span>
-    </button>
-</div>
-
 {% for shelf in shelves %}
     <div
         class="{% if next_shelf_identifier != shelf.identifier %}is-hidden{% endif %}"
@@ -42,14 +33,6 @@
             {% join "finish_reading" button_uuid as modal_id %}
             {% include 'snippets/shelve_button/modal_button.html' with class=class fallback_url=fallback_url %}
 
-
-    {% elif shelf.identifier == 'stopped-reading' %}
-
-            {% trans "Stop reading" as button_text %}
-            {% url 'reading-status' 'finish' book.id as fallback_url %}
-            {% join "stop_reading" button_uuid as modal_id %}
-            {% include 'snippets/shelve_button/modal_button.html' with class=class fallback_url=fallback_url %}
-
     {% elif shelf.identifier == 'to-read' %}
 
             {% trans "Want to read" as button_text %}

bookwyrm/templates/snippets/status/content_status.html

@@ -112,9 +112,6 @@
                     {% with full=status.content|safe no_trim=status.content_warning itemprop="reviewBody" %}
                         {% include 'snippets/trimmed_text.html' %}
                     {% endwith %}
-                    {% if status.progress %}
-                    <div class="is-small is-italic has-text-right mr-3">{% trans "page" %} {{ status.progress }}</div>
-                    {% endif %}
                 {% endif %}
 
                 {% if status.attachments.exists %}

bookwyrm/templates/snippets/status/headers/stopped_reading.html

@@ -1,23 +0,0 @@
-{% spaceless %}
-{% load i18n %}
-{% load utilities %}
-{% load status_display %}
-
-{% load_book status as book %}
-{% if book.authors.exists %}
-
-{% with author=book.authors.first %}
-{% blocktrans trimmed with book_path=book.local_path book=book|book_title author_name=author.name author_path=author.local_path %}
-stopped reading <a href="{{ book_path }}">{{ book }}</a> by <a href="{{ author_path }}">{{ author_name }}</a>
-{% endblocktrans %}
-{% endwith %}
-
-{% else %}
-
-{% blocktrans trimmed with book_path=book.local_path book=book|book_title %}
-stopped reading <a href="{{ book_path }}">{{ book }}</a>
-{% endblocktrans %}
-
-{% endif %}
-{% endspaceless %}
-

bookwyrm/templates/snippets/suggested_users.html

@@ -5,7 +5,7 @@
     {% for user in suggested_users %}
     <div class="column is-flex is-flex-grow-0">
         <div class="box has-text-centered is-shadowless has-background-tertiary m-0">
-            <a href="{{ user.local_path }}" class="has-text-default">
+            <a href="{{ user.local_path }}" class="has-text-black">
                 {% include 'snippets/avatar.html' with user=user large=True %}
                 <span title="{{ user.display_name }}" class="is-block is-6 has-text-weight-bold">{{ user.display_name|truncatechars:10 }}</span>
                 <span title="@{{ user|username }}" class="is-block pb-3">@{{ user|username|truncatechars:8 }}</span>

bookwyrm/templates/user/user.html

@@ -33,9 +33,8 @@
                 {% if shelf.name == 'To Read' %}{% trans "To Read" %}
                 {% elif shelf.name == 'Currently Reading' %}{% trans "Currently Reading" %}
                 {% elif shelf.name == 'Read' %}{% trans "Read" %}
-                {% elif shelf.name == 'Stopped Reading' %}{% trans "Stopped Reading" %}
                 {% else %}{{ shelf.name }}{% endif %}
-                {% if shelf.size > 4 %}<small>(<a href="{{ shelf.local_path }}">{% blocktrans with size=shelf.size %}View all {{ size }}{% endblocktrans %}</a>)</small>{% endif %}
+                {% if shelf.size > 3 %}<small>(<a href="{{ shelf.local_path }}">{% blocktrans with size=shelf.size %}View all {{ size }}{% endblocktrans %}</a>)</small>{% endif %}
             </h3>
             <div class="is-mobile field is-grouped">
             {% for book in shelf.books %}

bookwyrm/templates/user_menu.html

@@ -21,7 +21,7 @@
             role="menu"
         >
             <li role="menuitem">
-                <a href="{% url 'user-feed' request.user.localname %}" class="navbar-item">
+                <a href="{% url 'user-feed' user|username %}" class="navbar-item">
                     {% trans "Profile" %}
                 </a>
             </li>

bookwyrm/templatetags/rating_tags.py

@@ -13,10 +13,10 @@ register = template.Library()
 def get_rating(book, user):
     """get the overall rating of a book"""
     return cache.get_or_set(
-        f"book-rating-{book.parent_work.id}",
-        lambda u, b: models.Review.objects.filter(
-            book__parent_work__editions=b, rating__gt=0
-        ).aggregate(Avg("rating"))["rating__avg"]
+        f"book-rating-{book.parent_work.id}-{user.id}",
+        lambda u, b: models.Review.privacy_filter(u)
+        .filter(book__parent_work__editions=b, rating__gt=0)
+        .aggregate(Avg("rating"))["rating__avg"]
         or 0,
         user,
         book,

bookwyrm/templatetags/shelf_tags.py

@@ -30,8 +30,6 @@ def get_next_shelf(current_shelf):
         return "read"
     if current_shelf == "read":
         return "complete"
-    if current_shelf == "stopped-reading":
-        return "stopped-reading-complete"
     return "to-read"
 
 

bookwyrm/tests/activitystreams/test_signals.py

@@ -1,10 +1,6 @@
 """ testing activitystreams """
-from datetime import datetime, timedelta
 from unittest.mock import patch
-
 from django.test import TestCase
-from django.utils import timezone
-
 from bookwyrm import activitystreams, models
 
 
@@ -66,39 +62,6 @@ class ActivitystreamsSignals(TestCase):
         self.assertEqual(args["args"][0], status.id)
         self.assertEqual(args["queue"], "high_priority")
 
-    def test_add_status_on_create_created_low_priority(self, *_):
-        """a new statuses has entered"""
-        # created later than publication
-        status = models.Status.objects.create(
-            user=self.remote_user,
-            content="hi",
-            privacy="public",
-            created_date=datetime(2022, 5, 16, tzinfo=timezone.utc),
-            published_date=datetime(2022, 5, 14, tzinfo=timezone.utc),
-        )
-        with patch("bookwyrm.activitystreams.add_status_task.apply_async") as mock:
-            activitystreams.add_status_on_create_command(models.Status, status, False)
-
-        self.assertEqual(mock.call_count, 1)
-        args = mock.call_args[1]
-        self.assertEqual(args["args"][0], status.id)
-        self.assertEqual(args["queue"], "low_priority")
-
-        # published later than yesterday
-        status = models.Status.objects.create(
-            user=self.remote_user,
-            content="hi",
-            privacy="public",
-            published_date=timezone.now() - timedelta(days=1),
-        )
-        with patch("bookwyrm.activitystreams.add_status_task.apply_async") as mock:
-            activitystreams.add_status_on_create_command(models.Status, status, False)
-
-        self.assertEqual(mock.call_count, 1)
-        args = mock.call_args[1]
-        self.assertEqual(args["args"][0], status.id)
-        self.assertEqual(args["queue"], "low_priority")
-
     def test_populate_streams_on_account_create_command(self, *_):
         """create streams for a user"""
         with patch("bookwyrm.activitystreams.populate_stream_task.delay") as mock:

bookwyrm/tests/connectors/test_abstract_connector.py

@@ -42,9 +42,15 @@ class AbstractConnector(TestCase):
 
             generated_remote_link_field = "openlibrary_link"
 
-            def parse_search_data(self, data, min_confidence):
+            def format_search_result(self, search_result):
+                return search_result
+
+            def parse_search_data(self, data):
                 return data
 
+            def format_isbn_search_result(self, search_result):
+                return search_result
+
             def parse_isbn_search_data(self, data):
                 return data
 
@@ -95,7 +101,6 @@ class AbstractConnector(TestCase):
         result = self.connector.get_or_create_book(
             f"https://{DOMAIN}/book/{self.book.id}"
         )
-
         self.assertEqual(models.Book.objects.count(), 1)
         self.assertEqual(result, self.book)
 

bookwyrm/tests/connectors/test_abstract_minimal_connector.py

@@ -1,5 +1,6 @@
 """ testing book data connectors """
 from django.test import TestCase
+import responses
 
 from bookwyrm import models
 from bookwyrm.connectors import abstract_connector
@@ -24,12 +25,18 @@ class AbstractConnector(TestCase):
         class TestConnector(abstract_connector.AbstractMinimalConnector):
             """nothing added here"""
 
+            def format_search_result(self, search_result):
+                return search_result
+
             def get_or_create_book(self, remote_id):
                 pass
 
-            def parse_search_data(self, data, min_confidence):
+            def parse_search_data(self, data):
                 return data
 
+            def format_isbn_search_result(self, search_result):
+                return search_result
+
             def parse_isbn_search_data(self, data):
                 return data
 
@@ -47,6 +54,45 @@ class AbstractConnector(TestCase):
         self.assertIsNone(connector.name)
         self.assertEqual(connector.identifier, "example.com")
 
+    @responses.activate
+    def test_search(self):
+        """makes an http request to the outside service"""
+        responses.add(
+            responses.GET,
+            "https://example.com/search?q=a%20book%20title",
+            json=["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+            status=200,
+        )
+        results = self.test_connector.search("a book title")
+        self.assertEqual(len(results), 10)
+        self.assertEqual(results[0], "a")
+        self.assertEqual(results[1], "b")
+        self.assertEqual(results[2], "c")
+
+    @responses.activate
+    def test_search_min_confidence(self):
+        """makes an http request to the outside service"""
+        responses.add(
+            responses.GET,
+            "https://example.com/search?q=a%20book%20title&min_confidence=1",
+            json=["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+            status=200,
+        )
+        results = self.test_connector.search("a book title", min_confidence=1)
+        self.assertEqual(len(results), 10)
+
+    @responses.activate
+    def test_isbn_search(self):
+        """makes an http request to the outside service"""
+        responses.add(
+            responses.GET,
+            "https://example.com/isbn?q=123456",
+            json=["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+            status=200,
+        )
+        results = self.test_connector.isbn_search("123456")
+        self.assertEqual(len(results), 10)
+
     def test_create_mapping(self):
         """maps remote fields for book data to bookwyrm activitypub fields"""
         mapping = Mapping("isbn")

bookwyrm/tests/connectors/test_bookwyrm_connector.py

@@ -30,11 +30,14 @@ class BookWyrmConnector(TestCase):
         result = self.connector.get_or_create_book(book.remote_id)
         self.assertEqual(book, result)
 
-    def test_parse_search_data(self):
+    def test_format_search_result(self):
         """create a SearchResult object from search response json"""
         datafile = pathlib.Path(__file__).parent.joinpath("../data/bw_search.json")
         search_data = json.loads(datafile.read_bytes())
-        result = list(self.connector.parse_search_data(search_data, 0))[0]
+        results = self.connector.parse_search_data(search_data)
+        self.assertIsInstance(results, list)
+
+        result = self.connector.format_search_result(results[0])
         self.assertIsInstance(result, SearchResult)
         self.assertEqual(result.title, "Jonathan Strange and Mr Norrell")
         self.assertEqual(result.key, "https://example.com/book/122")
@@ -42,9 +45,10 @@ class BookWyrmConnector(TestCase):
         self.assertEqual(result.year, 2017)
         self.assertEqual(result.connector, self.connector)
 
-    def test_parse_isbn_search_data(self):
+    def test_format_isbn_search_result(self):
         """just gotta attach the connector"""
         datafile = pathlib.Path(__file__).parent.joinpath("../data/bw_search.json")
         search_data = json.loads(datafile.read_bytes())
-        result = list(self.connector.parse_isbn_search_data(search_data))[0]
+        results = self.connector.parse_isbn_search_data(search_data)
+        result = self.connector.format_isbn_search_result(results[0])
         self.assertEqual(result.connector, self.connector)

bookwyrm/tests/connectors/test_connector_manager.py

@@ -49,11 +49,39 @@ class ConnectorManager(TestCase):
         self.assertEqual(len(connectors), 1)
         self.assertIsInstance(connectors[0], BookWyrmConnector)
 
+    @responses.activate
+    def test_search_plaintext(self):
+        """search all connectors"""
+        responses.add(
+            responses.GET,
+            "http://fake.ciom/search/Example?min_confidence=0.1",
+            json=[{"title": "Hello", "key": "https://www.example.com/search/1"}],
+        )
+        results = connector_manager.search("Example")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(len(results[0]["results"]), 1)
+        self.assertEqual(results[0]["connector"].identifier, "test_connector_remote")
+        self.assertEqual(results[0]["results"][0].title, "Hello")
+
     def test_search_empty_query(self):
         """don't panic on empty queries"""
         results = connector_manager.search("")
         self.assertEqual(results, [])
 
+    @responses.activate
+    def test_search_isbn(self):
+        """special handling if a query resembles an isbn"""
+        responses.add(
+            responses.GET,
+            "http://fake.ciom/isbn/0000000000",
+            json=[{"title": "Hello", "key": "https://www.example.com/search/1"}],
+        )
+        results = connector_manager.search("0000000000")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(len(results[0]["results"]), 1)
+        self.assertEqual(results[0]["connector"].identifier, "test_connector_remote")
+        self.assertEqual(results[0]["results"][0].title, "Hello")
+
     def test_first_search_result(self):
         """only get one search result"""
         result = connector_manager.first_search_result("Example")

bookwyrm/tests/connectors/test_inventaire_connector.py

@@ -66,14 +66,38 @@ class Inventaire(TestCase):
         with self.assertRaises(ConnectorException):
             self.connector.get_book_data("https://test.url/ok")
 
-    def test_parse_search_data(self):
+    @responses.activate
+    def test_search(self):
+        """min confidence filtering"""
+        responses.add(
+            responses.GET,
+            "https://inventaire.io/search?q=hi",
+            json={
+                "results": [
+                    {
+                        "_score": 200,
+                        "label": "hello",
+                    },
+                    {
+                        "_score": 100,
+                        "label": "hi",
+                    },
+                ],
+            },
+        )
+        results = self.connector.search("hi", min_confidence=0.5)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].title, "hello")
+
+    def test_format_search_result(self):
         """json to search result objs"""
         search_file = pathlib.Path(__file__).parent.joinpath(
             "../data/inventaire_search.json"
         )
         search_results = json.loads(search_file.read_bytes())
 
-        formatted = list(self.connector.parse_search_data(search_results, 0))[0]
+        results = self.connector.parse_search_data(search_results)
+        formatted = self.connector.format_search_result(results[0])
 
         self.assertEqual(formatted.title, "The Stories of Vladimir Nabokov")
         self.assertEqual(
@@ -154,14 +178,15 @@ class Inventaire(TestCase):
         result = self.connector.resolve_keys(keys)
         self.assertEqual(result, ["epistolary novel", "crime novel"])
 
-    def test_pase_isbn_search_data(self):
+    def test_isbn_search(self):
         """another search type"""
         search_file = pathlib.Path(__file__).parent.joinpath(
             "../data/inventaire_isbn_search.json"
         )
         search_results = json.loads(search_file.read_bytes())
 
-        formatted = list(self.connector.parse_isbn_search_data(search_results))[0]
+        results = self.connector.parse_isbn_search_data(search_results)
+        formatted = self.connector.format_isbn_search_result(results[0])
 
         self.assertEqual(formatted.title, "L'homme aux cercles bleus")
         self.assertEqual(
@@ -173,12 +198,25 @@ class Inventaire(TestCase):
             "https://covers.inventaire.io/img/entities/12345",
         )
 
-    def test_parse_isbn_search_data_empty(self):
+    def test_isbn_search_empty(self):
         """another search type"""
         search_results = {}
-        results = list(self.connector.parse_isbn_search_data(search_results))
+        results = self.connector.parse_isbn_search_data(search_results)
         self.assertEqual(results, [])
 
+    def test_isbn_search_no_title(self):
+        """another search type"""
+        search_file = pathlib.Path(__file__).parent.joinpath(
+            "../data/inventaire_isbn_search.json"
+        )
+        search_results = json.loads(search_file.read_bytes())
+        search_results["entities"]["isbn:9782290349229"]["claims"]["wdt:P1476"] = None
+
+        result = self.connector.format_isbn_search_result(
+            search_results.get("entities")
+        )
+        self.assertIsNone(result)
+
     def test_is_work_data(self):
         """is it a work"""
         work_file = pathlib.Path(__file__).parent.joinpath(

bookwyrm/tests/connectors/test_openlibrary_connector.py

@@ -122,11 +122,21 @@ class Openlibrary(TestCase):
         self.assertEqual(result, "https://covers.openlibrary.org/b/id/image-L.jpg")
 
     def test_parse_search_result(self):
+        """extract the results from the search json response"""
+        datafile = pathlib.Path(__file__).parent.joinpath("../data/ol_search.json")
+        search_data = json.loads(datafile.read_bytes())
+        result = self.connector.parse_search_data(search_data)
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 2)
+
+    def test_format_search_result(self):
         """translate json from openlibrary into SearchResult"""
         datafile = pathlib.Path(__file__).parent.joinpath("../data/ol_search.json")
         search_data = json.loads(datafile.read_bytes())
-        result = list(self.connector.parse_search_data(search_data, 0))[0]
+        results = self.connector.parse_search_data(search_data)
+        self.assertIsInstance(results, list)
 
+        result = self.connector.format_search_result(results[0])
         self.assertIsInstance(result, SearchResult)
         self.assertEqual(result.title, "This Is How You Lose the Time War")
         self.assertEqual(result.key, "https://openlibrary.org/works/OL20639540W")
@@ -138,10 +148,18 @@ class Openlibrary(TestCase):
         """extract the results from the search json response"""
         datafile = pathlib.Path(__file__).parent.joinpath("../data/ol_isbn_search.json")
         search_data = json.loads(datafile.read_bytes())
-        result = list(self.connector.parse_isbn_search_data(search_data))
+        result = self.connector.parse_isbn_search_data(search_data)
+        self.assertIsInstance(result, list)
         self.assertEqual(len(result), 1)
 
-        result = result[0]
+    def test_format_isbn_search_result(self):
+        """translate json from openlibrary into SearchResult"""
+        datafile = pathlib.Path(__file__).parent.joinpath("../data/ol_isbn_search.json")
+        search_data = json.loads(datafile.read_bytes())
+        results = self.connector.parse_isbn_search_data(search_data)
+        self.assertIsInstance(results, list)
+
+        result = self.connector.format_isbn_search_result(results[0])
         self.assertIsInstance(result, SearchResult)
         self.assertEqual(result.title, "Les ombres errantes")
         self.assertEqual(result.key, "https://openlibrary.org/books/OL16262504M")
@@ -211,7 +229,7 @@ class Openlibrary(TestCase):
             status=200,
         )
         with patch(
-            "bookwyrm.connectors.openlibrary.Connector.get_authors_from_data"
+            "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
         ) as mock:
             mock.return_value = []
             result = self.connector.create_edition_from_data(work, self.edition_data)

bookwyrm/tests/data/calibre.csv

@@ -1,2 +0,0 @@
-authors,author_sort,rating,library_name,timestamp,formats,size,isbn,identifiers,comments,tags,series,series_index,languages,title,cover,title_sort,publisher,pubdate,id,uuid
-"Seanan McGuire","McGuire, Seanan","5","Bücher","2021-01-19T22:41:16+01:00","epub, original_epub","1433809","9780756411800","goodreads:39077187,isbn:9780756411800","REPLACED COMMENTS (BOOK DESCRIPTION) BECAUSE IT IS REALLY LONG.","Cryptids, Fantasy, Romance, Magic","InCryptid","8.0","eng","That Ain't Witchcraft","/home/tastytea/Bücher/Seanan McGuire/That Ain't Witchcraft (864)/cover.jpg","That Ain't Witchcraft","Daw Books","2019-03-05T01:00:00+01:00","864","3051ed45-8943-4900-a22a-d2704e3583df"

bookwyrm/tests/importers/test_calibre_import.py

@@ -1,71 +0,0 @@
-""" testing import """
-import pathlib
-from unittest.mock import patch
-
-from django.test import TestCase
-
-from bookwyrm import models
-from bookwyrm.importers import CalibreImporter
-from bookwyrm.importers.importer import handle_imported_book
-
-
-# pylint: disable=consider-using-with
-@patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
-@patch("bookwyrm.activitystreams.populate_stream_task.delay")
-@patch("bookwyrm.activitystreams.add_book_statuses_task.delay")
-class CalibreImport(TestCase):
-    """importing from Calibre csv"""
-
-    def setUp(self):
-        """use a test csv"""
-        self.importer = CalibreImporter()
-        datafile = pathlib.Path(__file__).parent.joinpath("../data/calibre.csv")
-        self.csv = open(datafile, "r", encoding=self.importer.encoding)
-        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch(
-            "bookwyrm.activitystreams.populate_stream_task.delay"
-        ), patch("bookwyrm.lists_stream.populate_lists_task.delay"):
-            self.local_user = models.User.objects.create_user(
-                "mouse", "mouse@mouse.mouse", "password", local=True
-            )
-
-        work = models.Work.objects.create(title="Test Work")
-        self.book = models.Edition.objects.create(
-            title="Example Edition",
-            remote_id="https://example.com/book/1",
-            parent_work=work,
-        )
-
-    def test_create_job(self, *_):
-        """creates the import job entry and checks csv"""
-        import_job = self.importer.create_job(
-            self.local_user, self.csv, False, "public"
-        )
-
-        import_items = (
-            models.ImportItem.objects.filter(job=import_job).order_by("index").all()
-        )
-        self.assertEqual(len(import_items), 1)
-        self.assertEqual(import_items[0].index, 0)
-        self.assertEqual(
-            import_items[0].normalized_data["title"], "That Ain't Witchcraft"
-        )
-
-    def test_handle_imported_book(self, *_):
-        """calibre import added a book, this adds related connections"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.TO_READ
-        ).first()
-        self.assertIsNone(shelf.books.first())
-
-        import_job = self.importer.create_job(
-            self.local_user, self.csv, False, "public"
-        )
-        import_item = import_job.items.first()
-        import_item.book = self.book
-        import_item.save()
-
-        with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"):
-            handle_imported_book(import_item)
-
-        shelf.refresh_from_db()
-        self.assertEqual(shelf.books.first(), self.book)

bookwyrm/tests/importers/test_goodreads_import.py

@@ -84,9 +84,7 @@ class GoodreadsImport(TestCase):
 
     def test_handle_imported_book(self, *_):
         """goodreads import added a book, this adds related connections"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.READ_FINISHED
-        ).first()
+        shelf = self.local_user.shelf_set.filter(identifier="read").first()
         self.assertIsNone(shelf.books.first())
 
         import_job = self.importer.create_job(

bookwyrm/tests/importers/test_importer.py

@@ -174,9 +174,7 @@ class GenericImporter(TestCase):
 
     def test_handle_imported_book(self, *_):
         """import added a book, this adds related connections"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.READ_FINISHED
-        ).first()
+        shelf = self.local_user.shelf_set.filter(identifier="read").first()
         self.assertIsNone(shelf.books.first())
 
         import_job = self.importer.create_job(
@@ -195,9 +193,7 @@ class GenericImporter(TestCase):
     def test_handle_imported_book_already_shelved(self, *_):
         """import added a book, this adds related connections"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"):
-            shelf = self.local_user.shelf_set.filter(
-                identifier=models.Shelf.TO_READ
-            ).first()
+            shelf = self.local_user.shelf_set.filter(identifier="to-read").first()
             models.ShelfBook.objects.create(
                 shelf=shelf,
                 user=self.local_user,
@@ -221,16 +217,12 @@ class GenericImporter(TestCase):
             shelf.shelfbook_set.first().shelved_date, make_date(2020, 2, 2)
         )
         self.assertIsNone(
-            self.local_user.shelf_set.get(
-                identifier=models.Shelf.READ_FINISHED
-            ).books.first()
+            self.local_user.shelf_set.get(identifier="read").books.first()
         )
 
     def test_handle_import_twice(self, *_):
         """re-importing books"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.READ_FINISHED
-        ).first()
+        shelf = self.local_user.shelf_set.filter(identifier="read").first()
         import_job = self.importer.create_job(
             self.local_user, self.csv, False, "public"
         )

bookwyrm/tests/importers/test_librarything_import.py

@@ -93,9 +93,7 @@ class LibrarythingImport(TestCase):
 
     def test_handle_imported_book(self, *_):
         """librarything import added a book, this adds related connections"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.READ_FINISHED
-        ).first()
+        shelf = self.local_user.shelf_set.filter(identifier="read").first()
         self.assertIsNone(shelf.books.first())
 
         import_job = self.importer.create_job(
@@ -119,9 +117,7 @@ class LibrarythingImport(TestCase):
     def test_handle_imported_book_already_shelved(self, *_):
         """librarything import added a book, this adds related connections"""
         with patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async"):
-            shelf = self.local_user.shelf_set.filter(
-                identifier=models.Shelf.TO_READ
-            ).first()
+            shelf = self.local_user.shelf_set.filter(identifier="to-read").first()
             models.ShelfBook.objects.create(
                 shelf=shelf, user=self.local_user, book=self.book
             )
@@ -139,9 +135,7 @@ class LibrarythingImport(TestCase):
         shelf.refresh_from_db()
         self.assertEqual(shelf.books.first(), self.book)
         self.assertIsNone(
-            self.local_user.shelf_set.get(
-                identifier=models.Shelf.READ_FINISHED
-            ).books.first()
+            self.local_user.shelf_set.get(identifier="read").books.first()
         )
 
         readthrough = models.ReadThrough.objects.get(user=self.local_user)

bookwyrm/tests/importers/test_openlibrary_import.py

@@ -70,9 +70,7 @@ class OpenLibraryImport(TestCase):
 
     def test_handle_imported_book(self, *_):
         """openlibrary import added a book, this adds related connections"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.READING
-        ).first()
+        shelf = self.local_user.shelf_set.filter(identifier="reading").first()
         self.assertIsNone(shelf.books.first())
 
         import_job = self.importer.create_job(

bookwyrm/tests/importers/test_storygraph_import.py

@@ -62,9 +62,7 @@ class StorygraphImport(TestCase):
 
     def test_handle_imported_book(self, *_):
         """storygraph import added a book, this adds related connections"""
-        shelf = self.local_user.shelf_set.filter(
-            identifier=models.Shelf.TO_READ
-        ).first()
+        shelf = self.local_user.shelf_set.filter(identifier="to-read").first()
         self.assertIsNone(shelf.books.first())
 
         import_job = self.importer.create_job(

bookwyrm/tests/models/test_import_model.py

@@ -195,7 +195,7 @@ class ImportJob(TestCase):
             ) as search:
                 search.return_value = result
                 with patch(
-                    "bookwyrm.connectors.openlibrary.Connector.get_authors_from_data"
+                    "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
                 ):
                     book = item.get_book_from_identifier()
 

bookwyrm/tests/models/test_status_model.py

@@ -462,8 +462,6 @@ class Status(TestCase):
     @responses.activate
     def test_ignore_activity_boost(self, *_):
         """don't bother with most remote statuses"""
-        responses.add(responses.GET, "http://fish.com/nothing")
-
         activity = activitypub.Announce(
             id="http://www.faraway.com/boost/12",
             actor=self.remote_user.remote_id,

bookwyrm/tests/models/test_user_model.py

@@ -53,17 +53,15 @@ class User(TestCase):
 
     def test_user_shelves(self):
         shelves = models.Shelf.objects.filter(user=self.user).all()
-        self.assertEqual(len(shelves), 4)
+        self.assertEqual(len(shelves), 3)
         names = [s.name for s in shelves]
         self.assertTrue("To Read" in names)
         self.assertTrue("Currently Reading" in names)
         self.assertTrue("Read" in names)
-        self.assertTrue("Stopped Reading" in names)
         ids = [s.identifier for s in shelves]
         self.assertTrue("to-read" in ids)
         self.assertTrue("reading" in ids)
         self.assertTrue("read" in ids)
-        self.assertTrue("stopped-reading" in ids)
 
     def test_activitypub_serialize(self):
         activity = self.user.to_activity()

bookwyrm/tests/templatetags/test_rating_tags.py

@@ -40,8 +40,7 @@ class RatingTags(TestCase):
 
     @patch("bookwyrm.models.activitypub_mixin.broadcast_task.apply_async")
     def test_get_rating(self, *_):
-        """privacy filtered rating. Commented versions are how it ought to work with
-        subjective ratings, which are currenly not used for performance reasons."""
+        """privacy filtered rating"""
         # follows-only: not included
         models.ReviewRating.objects.create(
             user=self.remote_user,
@@ -49,8 +48,7 @@ class RatingTags(TestCase):
             book=self.book,
             privacy="followers",
         )
-        # self.assertEqual(rating_tags.get_rating(self.book, self.local_user), 0)
-        self.assertEqual(rating_tags.get_rating(self.book, self.local_user), 5)
+        self.assertEqual(rating_tags.get_rating(self.book, self.local_user), 0)
 
         # public: included
         models.ReviewRating.objects.create(

bookwyrm/tests/test_book_search.py

@@ -102,12 +102,18 @@ class BookSearch(TestCase):
         class TestConnector(AbstractMinimalConnector):
             """nothing added here"""
 
+            def format_search_result(self, search_result):
+                return search_result
+
             def get_or_create_book(self, remote_id):
                 pass
 
-            def parse_search_data(self, data, min_confidence):
+            def parse_search_data(self, data):
                 return data
 
+            def format_isbn_search_result(self, search_result):
+                return search_result
+
             def parse_isbn_search_data(self, data):
                 return data
 

bookwyrm/tests/views/books/test_edit_book.py

@@ -9,7 +9,6 @@ from django.test import TestCase
 from django.test.client import RequestFactory
 
 from bookwyrm import forms, models, views
-from bookwyrm.views.books.edit_book import add_authors
 from bookwyrm.tests.validate_html import validate_html
 from bookwyrm.tests.views.books.test_book import _setup_cover_url
 
@@ -215,22 +214,3 @@ class EditBookViews(TestCase):
 
         self.book.refresh_from_db()
         self.assertTrue(self.book.cover)
-
-    def test_add_authors_helper(self):
-        """converts form input into author matches"""
-        form = forms.EditionForm(instance=self.book)
-        form.data["title"] = "New Title"
-        form.data["last_edited_by"] = self.local_user.id
-        form.data["add_author"] = ["Sappho", "Some Guy"]
-        request = self.factory.post("", form.data)
-        request.user = self.local_user
-
-        with patch("bookwyrm.utils.isni.find_authors_by_name") as mock:
-            mock.return_value = []
-            result = add_authors(request, form.data)
-
-        self.assertTrue(result["confirm_mode"])
-        self.assertEqual(result["add_author"], ["Sappho", "Some Guy"])
-        self.assertEqual(len(result["author_matches"]), 2)
-        self.assertEqual(result["author_matches"][0]["name"], "Sappho")
-        self.assertEqual(result["author_matches"][1]["name"], "Some Guy")

bookwyrm/tests/views/inbox/test_inbox_create.py

@@ -208,42 +208,14 @@ class InboxCreate(TestCase):
         self.assertEqual(book_list.description, "summary text")
         self.assertEqual(book_list.remote_id, "https://example.com/list/22")
 
-    def test_create_unsupported_type_question(self, *_):
+    def test_create_unsupported_type(self, *_):
         """ignore activities we know we can't handle"""
         activity = self.create_json
         activity["object"] = {
             "id": "https://example.com/status/887",
             "type": "Question",
         }
-        # just observe how it doesn't throw an error
-        views.inbox.activity_task(activity)
-
-    def test_create_unsupported_type_article(self, *_):
-        """special case in unsupported type because we do know what it is"""
-        activity = self.create_json
-        activity["object"] = {
-            "id": "https://example.com/status/887",
-            "type": "Article",
-            "name": "hello",
-            "published": "2021-04-29T21:27:30.014235+00:00",
-            "attributedTo": "https://example.com/user/mouse",
-            "to": ["https://www.w3.org/ns/activitystreams#Public"],
-            "cc": ["https://example.com/user/mouse/followers"],
-            "sensitive": False,
-            "@context": "https://www.w3.org/ns/activitystreams",
-        }
-        # just observe how it doesn't throw an error
-        views.inbox.activity_task(activity)
-
-    def test_create_unsupported_type_unknown(self, *_):
-        """Something truly unexpected should throw an error"""
-        activity = self.create_json
-        activity["object"] = {
-            "id": "https://example.com/status/887",
-            "type": "Blaaaah",
-        }
-        # error this time
-        with self.assertRaises(ActivitySerializerError):
+        # just observer how it doesn't throw an error
         views.inbox.activity_task(activity)
 
     def test_create_unknown_type(self, *_):

bookwyrm/tests/views/test_search.py

@@ -1,5 +1,6 @@
 """ test for app action functionality """
 import json
+import pathlib
 from unittest.mock import patch
 
 from django.contrib.auth.models import AnonymousUser
@@ -7,9 +8,9 @@ from django.http import JsonResponse
 from django.template.response import TemplateResponse
 from django.test import TestCase
 from django.test.client import RequestFactory
+import responses
 
 from bookwyrm import models, views
-from bookwyrm.book_search import SearchResult
 from bookwyrm.settings import DOMAIN
 from bookwyrm.tests.validate_html import validate_html
 
@@ -64,11 +65,12 @@ class Views(TestCase):
         self.assertIsInstance(response, TemplateResponse)
         validate_html(response.render())
 
+    @responses.activate
     def test_search_books(self):
         """searches remote connectors"""
         view = views.Search.as_view()
 
-        connector = models.Connector.objects.create(
+        models.Connector.objects.create(
             identifier="example.com",
             connector_file="openlibrary",
             base_url="https://example.com",
@@ -76,24 +78,26 @@ class Views(TestCase):
             covers_url="https://example.com/covers",
             search_url="https://example.com/search?q=",
         )
-        mock_result = SearchResult(title="Mock Book", connector=connector, key="hello")
+        datafile = pathlib.Path(__file__).parent.joinpath("../data/ol_search.json")
+        search_data = json.loads(datafile.read_bytes())
+        responses.add(
+            responses.GET, "https://example.com/search?q=Test%20Book", json=search_data
+        )
 
         request = self.factory.get("", {"q": "Test Book", "remote": True})
         request.user = self.local_user
         with patch("bookwyrm.views.search.is_api_request") as is_api:
             is_api.return_value = False
-            with patch("bookwyrm.connectors.connector_manager.search") as remote_search:
-                remote_search.return_value = [
-                    {"results": [mock_result], "connector": connector}
-                ]
             response = view(request)
-
         self.assertIsInstance(response, TemplateResponse)
         validate_html(response.render())
         connector_results = response.context_data["results"]
         self.assertEqual(len(connector_results), 2)
         self.assertEqual(connector_results[0]["results"][0].title, "Test Book")
-        self.assertEqual(connector_results[1]["results"][0].title, "Mock Book")
+        self.assertEqual(
+            connector_results[1]["results"][0].title,
+            "This Is How You Lose the Time War",
+        )
 
         # don't search remote
         request = self.factory.get("", {"q": "Test Book", "remote": True})
@@ -102,10 +106,6 @@ class Views(TestCase):
         request.user = anonymous_user
         with patch("bookwyrm.views.search.is_api_request") as is_api:
             is_api.return_value = False
-            with patch("bookwyrm.connectors.connector_manager.search") as remote_search:
-                remote_search.return_value = [
-                    {"results": [mock_result], "connector": connector}
-                ]
             response = view(request)
         self.assertIsInstance(response, TemplateResponse)
         validate_html(response.render())

bookwyrm/tests/views/test_status.py

@@ -281,7 +281,7 @@ http://www.fish.com/"""
         result = views.status.to_markdown(text)
         self.assertEqual(
             result,
-            '<p><em>hi</em> and <a href="http://fish.com">fish.com</a> is rad</p>',
+            '<p><em>hi</em> and <a href="http://fish.com">fish.com</a> ' "is rad</p>",
         )
 
     def test_to_markdown_detect_url(self, *_):
@@ -297,7 +297,7 @@ http://www.fish.com/"""
         """this is mostly handled in other places, but nonetheless"""
         text = "[hi](http://fish.com) is <marquee>rad</marquee>"
         result = views.status.to_markdown(text)
-        self.assertEqual(result, '<p><a href="http://fish.com">hi</a> is rad</p>')
+        self.assertEqual(result, '<p><a href="http://fish.com">hi</a> ' "is rad</p>")
 
     def test_delete_status(self, mock, *_):
         """marks a status as deleted"""

bookwyrm/urls.py

@@ -391,9 +391,6 @@ urlpatterns = [
     re_path(
         r"^group/(?P<group_id>\d+)(.json)?/?$", views.Group.as_view(), name="group"
     ),
-    re_path(
-        rf"^group/(?P<group_id>\d+){regex.SLUG}/?$", views.Group.as_view(), name="group"
-    ),
     re_path(
         r"^group/delete/(?P<group_id>\d+)/?$", views.delete_group, name="delete-group"
     ),
@@ -420,10 +417,7 @@ urlpatterns = [
     re_path(rf"{USER_PATH}/lists/?$", views.UserLists.as_view(), name="user-lists"),
     re_path(r"^list/?$", views.Lists.as_view(), name="lists"),
     re_path(r"^list/saved/?$", views.SavedLists.as_view(), name="saved-lists"),
-    re_path(r"^list/(?P<list_id>\d+)(\.json)?/?$", views.List.as_view(), name="list"),
-    re_path(
-        rf"^list/(?P<list_id>\d+){regex.SLUG}/?$", views.List.as_view(), name="list"
-    ),
+    re_path(r"^list/(?P<list_id>\d+)(.json)?/?$", views.List.as_view(), name="list"),
     re_path(
         r"^list/(?P<list_id>\d+)/item/(?P<list_item>\d+)/?$",
         views.ListItem.as_view(),
@@ -493,7 +487,6 @@ urlpatterns = [
     re_path(r"^unblock/(?P<user_id>\d+)/?$", views.unblock),
     # statuses
     re_path(rf"{STATUS_PATH}(.json)?/?$", views.Status.as_view(), name="status"),
-    re_path(rf"{STATUS_PATH}{regex.SLUG}/?$", views.Status.as_view(), name="status"),
     re_path(rf"{STATUS_PATH}/activity/?$", views.Status.as_view(), name="status"),
     re_path(
         rf"{STATUS_PATH}/replies(.json)?/?$", views.Replies.as_view(), name="replies"
@@ -530,27 +523,18 @@ urlpatterns = [
     re_path(r"^unboost/(?P<status_id>\d+)/?$", views.Unboost.as_view()),
     # books
     re_path(rf"{BOOK_PATH}(.json)?/?$", views.Book.as_view(), name="book"),
-    re_path(rf"{BOOK_PATH}{regex.SLUG}/?$", views.Book.as_view(), name="book"),
     re_path(
         rf"{BOOK_PATH}/(?P<user_statuses>review|comment|quote)/?$",
         views.Book.as_view(),
         name="book-user-statuses",
     ),
     re_path(rf"{BOOK_PATH}/edit/?$", views.EditBook.as_view(), name="edit-book"),
-    re_path(
-        rf"{BOOK_PATH}/confirm/?$",
-        views.ConfirmEditBook.as_view(),
-        name="edit-book-confirm",
-    ),
+    re_path(rf"{BOOK_PATH}/confirm/?$", views.ConfirmEditBook.as_view()),
     re_path(
         r"^create-book/data/?$", views.create_book_from_data, name="create-book-data"
     ),
     re_path(r"^create-book/?$", views.CreateBook.as_view(), name="create-book"),
-    re_path(
-        r"^create-book/confirm/?$",
-        views.ConfirmEditBook.as_view(),
-        name="create-book-confirm",
-    ),
+    re_path(r"^create-book/confirm/?$", views.ConfirmEditBook.as_view()),
     re_path(rf"{BOOK_PATH}/editions(.json)?/?$", views.Editions.as_view()),
     re_path(
         r"^upload-cover/(?P<book_id>\d+)/?$", views.upload_cover, name="upload-cover"
@@ -596,11 +580,6 @@ urlpatterns = [
     re_path(
         r"^author/(?P<author_id>\d+)(.json)?/?$", views.Author.as_view(), name="author"
     ),
-    re_path(
-        rf"^author/(?P<author_id>\d+){regex.SLUG}/?$",
-        views.Author.as_view(),
-        name="author",
-    ),
     re_path(
         r"^author/(?P<author_id>\d+)/edit/?$",
         views.EditAuthor.as_view(),
@@ -622,7 +601,7 @@ urlpatterns = [
         name="reading-status-update",
     ),
     re_path(
-        r"^reading-status/(?P<status>want|start|finish|stop)/(?P<book_id>\d+)/?$",
+        r"^reading-status/(?P<status>want|start|finish)/(?P<book_id>\d+)/?$",
         views.ReadingStatus.as_view(),
         name="reading-status",
     ),

bookwyrm/utils/regex.py

@@ -6,6 +6,5 @@ STRICT_LOCALNAME = r"@[a-zA-Z_\-\.0-9]+"
 USERNAME = rf"{LOCALNAME}(@{DOMAIN})?"
 STRICT_USERNAME = rf"\B{STRICT_LOCALNAME}(@{DOMAIN})?\b"
 FULL_USERNAME = rf"{LOCALNAME}@{DOMAIN}\b"
-SLUG = r"/s/(?P<slug>[-_a-z0-9]*)"
 # should match (BookWyrm/1.0.0; or (BookWyrm/99.1.2;
 BOOKWYRM_USER_AGENT = r"\(BookWyrm/[0-9]+\.[0-9]+\.[0-9]+;"

bookwyrm/views/admin/dashboard.py

@@ -103,7 +103,7 @@ class Dashboard(View):
                 status="pending"
             ).count(),
             "invite_requests": models.InviteRequest.objects.filter(
-                ignored=False, invite__isnull=True
+                ignored=False, invite_sent=False
             ).count(),
             "user_stats": user_chart.get_chart(start, end, interval),
             "status_stats": status_chart.get_chart(start, end, interval),

bookwyrm/views/author.py

@@ -11,24 +11,20 @@ from bookwyrm import forms, models
 from bookwyrm.activitypub import ActivitypubResponse
 from bookwyrm.connectors import connector_manager
 from bookwyrm.settings import PAGE_LENGTH
-from bookwyrm.views.helpers import is_api_request, maybe_redirect_local_path
+from bookwyrm.views.helpers import is_api_request
 
 
 # pylint: disable= no-self-use
 class Author(View):
     """this person wrote a book"""
 
-    # pylint: disable=unused-argument
-    def get(self, request, author_id, slug=None):
+    def get(self, request, author_id):
         """landing page for an author"""
         author = get_object_or_404(models.Author, id=author_id)
 
         if is_api_request(request):
             return ActivitypubResponse(author.to_activity())
 
-        if redirect_local_path := maybe_redirect_local_path(request, author):
-            return redirect_local_path
-
         books = (
             models.Work.objects.filter(editions__authors=author)
             .order_by("created_date")

bookwyrm/views/books/books.py

@@ -15,14 +15,14 @@ from bookwyrm.activitypub import ActivitypubResponse
 from bookwyrm.connectors import connector_manager, ConnectorException
 from bookwyrm.connectors.abstract_connector import get_image
 from bookwyrm.settings import PAGE_LENGTH
-from bookwyrm.views.helpers import is_api_request, maybe_redirect_local_path
+from bookwyrm.views.helpers import is_api_request
 
 
 # pylint: disable=no-self-use
 class Book(View):
     """a book! this is the stuff"""
 
-    def get(self, request, book_id, **kwargs):
+    def get(self, request, book_id, user_statuses=False, update_error=False):
         """info about a book"""
         if is_api_request(request):
             book = get_object_or_404(
@@ -30,11 +30,7 @@ class Book(View):
             )
             return ActivitypubResponse(book.to_activity())
 
-        user_statuses = (
-            kwargs.get("user_statuses", False)
-            if request.user.is_authenticated
-            else False
-        )
+        user_statuses = user_statuses if request.user.is_authenticated else False
 
         # it's safe to use this OR because edition and work and subclasses of the same
         # table, so they never have clashing IDs
@@ -50,11 +46,6 @@ class Book(View):
         if not book or not book.parent_work:
             raise Http404()
 
-        if redirect_local_path := not user_statuses and maybe_redirect_local_path(
-            request, book
-        ):
-            return redirect_local_path
-
         # all reviews for all editions of the book
         reviews = models.Review.privacy_filter(request.user).filter(
             book__parent_work__editions=book
@@ -89,7 +80,7 @@ class Book(View):
             else None,
             "rating": reviews.aggregate(Avg("rating"))["rating__avg"],
             "lists": lists,
-            "update_error": kwargs.get("update_error", False),
+            "update_error": update_error,
         }
 
         if request.user.is_authenticated:

bookwyrm/views/books/edit_book.py

@@ -115,7 +115,6 @@ class CreateBook(View):
 
         # go to confirm mode
         if not parent_work_id or data.get("add_author"):
-            data["confirm_mode"] = True
             return TemplateResponse(request, "book/edit/edit_book.html", data)
 
         with transaction.atomic():