Bump version

.coveragerc

@@ -1,3 +0,0 @@
-[run]
-source = bookmarks
-omit = bookmarks/tests/*

.dockerignore

@@ -5,27 +5,13 @@
 /node_modules
 /tmp
 /docs
-/static
-/build
-/out
-/.git
 
 /.dockerignore
 /.gitignore
+/build-*.sh
 /Dockerfile
-/docker-compose.yml
-/*.sh
 /*.iml
-/*.patch
-/*.md
-/*.js
-/*.log
-/*.pid
-
-# Whitelist files needed in build or prod image
-!/rollup.config.js
-!/bootstrap.sh
-!/background-tasks-wrapper.sh
+/package*.json
 
 # Remove development settings
 /siteroot/settings/dev.py

.env.sample

@@ -5,7 +5,5 @@ LD_HOST_PORT=9090
 # Directory on the host system that should be mounted as data dir into the Docker container
 LD_HOST_DATA_DIR=./data
 
-# Option to disable background tasks
-LD_DISABLE_BACKGROUND_TASKS=False
 # Option to disable URL validation for bookmarks completely
-LD_DISABLE_URL_VALIDATION=False
+LD_DISABLE_URL_VALIDATION=False

.github/workflows/main.yaml

@@ -12,13 +12,7 @@ jobs:
         uses: actions/setup-python@v1
         with:
           python-version: 3.7
-      - name: Set up Node
-        uses: actions/setup-node@v2
-        with:
-          node-version: 14
-      - name: Install Python dependencies
+      - name: Install dependencies
         run: pip install -r requirements.txt
-      - name: Install Node dependencies
-        run: npm install
       - name: Run tests
         run: python manage.py test

.gitignore

@@ -3,14 +3,55 @@
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+cmake-build-release/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
 # File-based project format
 *.iws
 
 # IntelliJ
-.idea
-*.iml
 out/
 
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
 ### Python template
 # Byte-compiled / optimized / DLL files
 __pycache__/

.idea/compiler.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <wildcardResourcePatterns>
+      <entry name="!?*.java" />
+      <entry name="!?*.form" />
+      <entry name="!?*.class" />
+      <entry name="!?*.groovy" />
+      <entry name="!?*.scala" />
+      <entry name="!?*.flex" />
+      <entry name="!?*.kt" />
+      <entry name="!?*.clj" />
+    </wildcardResourcePatterns>
+  </component>
+</project>

.idea/dataSources.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
+    <data-source source="LOCAL" name="SQLite - db.sqlite3" uuid="c880bd6d-554c-484d-a5be-45581d9a9377">
+      <driver-ref>sqlite.xerial</driver-ref>
+      <synchronize>true</synchronize>
+      <jdbc-driver>org.sqlite.JDBC</jdbc-driver>
+      <jdbc-url>jdbc:sqlite:$PROJECT_DIR$/data/db.sqlite3</jdbc-url>
+    </data-source>
+  </component>
+</project>

.idea/encodings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" addBOMForNewFiles="with NO BOM" />
+</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,12 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="E402" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/misc.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="HaskellBuildOptions">
+    <ghcPath>/usr/local/bin/ghc</ghcPath>
+    <stackPath>/usr/local/bin/stack</stackPath>
+  </component>
+  <component name="JavaScriptSettings">
+    <option name="languageLevel" value="ES6" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" default="false" project-jdk-name="Python 3.7 (linkding)" project-jdk-type="Python SDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/linkdings.iml" filepath="$PROJECT_DIR$/linkdings.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.idea/watcherTasks.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectTasksOptions" suppressed-tasks="SCSS" />
+</project>

API.md

@@ -59,7 +59,7 @@ Example response:
 }
 ```
 
-**List Archived**
+**Archived**
 
 ```
 GET /api/bookmarks/archived/
@@ -121,22 +121,6 @@ Example payload:
 }
 ```
 
-**Archive**
-
-```
-POST /api/bookmarks/<id>/archive/
-```
-
-Archives a bookmark.
-
-**Unarchive**
-
-```
-POST /api/bookmarks/<id>/unarchive/
-```
-
-Unarchives a bookmark.
-
 **Delete**
 
 ```

CHANGELOG.md

@@ -1,148 +1,5 @@
 # Changelog
 
-## v1.8.8 (27/03/2022)
-- [**bug**] Prevent bookmark actions through get requests
-- [**bug**] Prevent external redirects
-
----
-
-## v1.8.7 (26/03/2022)
-- [**bug**] Increase request buffer size [#28](https://github.com/sissbruecker/linkding/issues/28)
-- [**enhancement**]  Allow specifying port through LINKDING_PORT environment variable [#156](https://github.com/sissbruecker/linkding/pull/156)
-- [**chore**] Bump NPM packages [#224](https://github.com/sissbruecker/linkding/pull/224)
----
-
-## v1.8.6 (25/03/2022)
-- [bug] fix bookmark access restrictions
-- [bug] prevent external redirects
-- [chore] bump dependencies
----
-
-## v1.8.5 (13/12/2021)
-- [**bug**] Ensure tag names do not contain spaces [#182](https://github.com/sissbruecker/linkding/issues/182)
-- [**bug**] Consider not copying whole GIT repository to Docker image [#174](https://github.com/sissbruecker/linkding/issues/174)
-- [**enhancement**] Make bookmarks count column in admin sortable [#183](https://github.com/sissbruecker/linkding/pull/183)
-
----
-
-## v1.8.4 (16/10/2021)
-- [**enhancement**] Allow non-admin users to change their password [#166](https://github.com/sissbruecker/linkding/issues/166)
-
----
-
-## v1.8.3 (03/10/2021)
-- [**enhancement**] Enhancement: let user configure to open links in same tab instead on a new window/tab [#27](https://github.com/sissbruecker/linkding/issues/27)
-
----
-
-## v1.8.2 (02/10/2021)
-- [**bug**] Fix jumping search box [#163](https://github.com/sissbruecker/linkding/pull/163)
----
-
-## v1.8.1 (01/10/2021)
-- [**enhancement**] Add global shortcut for search [#161](https://github.com/sissbruecker/linkding/pull/161)
-  - allows to press `s` to focus the search input
-
----
-
-## v1.8.0 (04/09/2021)
-- [**enhancement**] Wayback Machine Integration [#59](https://github.com/sissbruecker/linkding/issues/59)
-  - Automatically creates snapshots of bookmarked websites on [web archive](https://archive.org/web/)
-  - This is one of the largest changes yet and adds a task processor that runs as a separate process in the background. If you run into issues with this feature, it can be disabled using the [LD_DISABLE_BACKGROUND_TASKS](https://github.com/sissbruecker/linkding/blob/master/docs/Options.md#ld_disable_background_tasks) option
-
----
-
-## v1.7.2 (26/08/2021)
-- [**enhancement**] Add support for nanosecond resolution timestamps for bookmark import (e.g. Google Bookmarks) [#146](https://github.com/sissbruecker/linkding/issues/146)
-
----
-
-## v1.7.1 (25/08/2021)
-- [**bug**] umlaut/non-ascii characters broken when using bookmarklet (firefox) [#148](https://github.com/sissbruecker/linkding/issues/148)
-- [**bug**] Bookmark import accepts empty URL values [#124](https://github.com/sissbruecker/linkding/issues/124)
-- [**enhancement**] Show the version in the settings [#104](https://github.com/sissbruecker/linkding/issues/104)
-
----
-
-## v1.7.0 (17/08/2021)
-- Upgrade to Django 3
-- Bump other dependencies
-
----
-
-## v1.6.5 (15/08/2021)
-- [**enhancement**] query with multiple hashtags very slow [#112](https://github.com/sissbruecker/linkding/issues/112)
----
-
-## v1.6.4 (13/05/2021)
-- Update dependencies for security fixes
-
----
-
-## v1.6.3 (07/04/2021)
-- [**bug**] relative names use the wrong "today" after day change [#107](https://github.com/sissbruecker/linkding/issues/107)
-
----
-
-## v1.6.2 (04/04/2021)
-- [**enhancement**] Expose `date_added` in UI [#85](https://github.com/sissbruecker/linkding/issues/85)
-- [**closed**] Archived bookmarks - no result when searching for a word which is used only as tag [#83](https://github.com/sissbruecker/linkding/issues/83)
-- [**closed**] Add archive/unarchive button to edit bookmark page [#82](https://github.com/sissbruecker/linkding/issues/82)
-- [**enhancement**] Make scraped title and description editable [#80](https://github.com/sissbruecker/linkding/issues/80)
-
----
-
-## v1.6.1 (31/03/2021)
-- Expose date_added in UI [#85](https://github.com/sissbruecker/linkding/issues/85)
-
----
-
-## v1.6.0 (29/03/2021)
-- Bulk edit mode [#101](https://github.com/sissbruecker/linkding/pull/101)
----
-
-## v1.5.0 (28/03/2021)
-- [**closed**] Add a dark mode [#49](https://github.com/sissbruecker/linkding/issues/49)
----
-
-## v1.4.1 (20/03/2021)
-- Security patches
-- Documentation improvements
-
----
-
-## v1.4.0 (24/02/2021)
-- [**enhancement**] Improve admin utilization [#76](https://github.com/sissbruecker/linkding/issues/76)
-
----
-
-## v1.3.3 (18/02/2021)
-- [**closed**] Missing "description" request body parameter in API causes 500 [#78](https://github.com/sissbruecker/linkding/issues/78)
-
----
-
-## v1.3.2 (18/02/2021)
-- [**closed**] /archive and /unarchive API routes return 404 [#77](https://github.com/sissbruecker/linkding/issues/77)
-- [**closed**] API - /api/check_url?url= with token authetification [#55](https://github.com/sissbruecker/linkding/issues/55)
-
----
-
-## v1.3.1 (15/02/2021)
-[enhancement] Enhance delete links with inline confirmation
-
----
-
-## v1.3.0 (14/02/2021)
-- [**closed**] Novice help. [#71](https://github.com/sissbruecker/linkding/issues/71)
-- [**closed**] Option to create bookmarks public [#70](https://github.com/sissbruecker/linkding/issues/70)
-- [**enhancement**] Show URL if title is not available [#64](https://github.com/sissbruecker/linkding/issues/64)
-- [**bug**] minor ui nitpicks [#62](https://github.com/sissbruecker/linkding/issues/62)
-- [**enhancement**] add an archive function [#46](https://github.com/sissbruecker/linkding/issues/46)
-- [**closed**] remove non fqdn check and alert [#36](https://github.com/sissbruecker/linkding/issues/36)
-- [**closed**] Add Lotus Notes links [#22](https://github.com/sissbruecker/linkding/issues/22)
-
----
-
 ## v1.2.1 (12/01/2021)
 - [**bug**] Bug: Two equal tags with different capitalisation lead to 500 server errors [#65](https://github.com/sissbruecker/linkding/issues/65)
 - [**closed**] Enhancement: category and pagination [#11](https://github.com/sissbruecker/linkding/issues/11)

Dockerfile

@@ -1,54 +1,22 @@
-FROM node:current-alpine AS node-build
+FROM python:3.7-slim-stretch
+
+# Install packages required for uswgi
+RUN apt-get update
+RUN apt-get -y install build-essential
+RUN apt-get -y install mime-support
+
+# Install requirements and uwsgi server for running python web apps
 WORKDIR /etc/linkding
-# install build dependencies
-COPY package.json package-lock.json ./
-RUN npm install -g npm && \
-    npm install
-# compile JS components
-COPY . .
-RUN npm run build
-
-
-FROM python:3.9.6-slim-buster AS python-base
-RUN apt-get update && apt-get -y install build-essential
-WORKDIR /etc/linkding
-
-
-FROM python-base AS python-build
-# install build dependencies
-COPY requirements.txt requirements.txt
-RUN pip install -U pip && pip install -Ur requirements.txt
-# run Django part of the build
-COPY --from=node-build /etc/linkding .
-RUN python manage.py compilescss && \
-    python manage.py collectstatic --ignore=*.scss && \
-    python manage.py compilescss --delete-files
-
-
-FROM python-base AS prod-deps
 COPY requirements.prod.txt ./requirements.txt
-RUN mkdir /opt/venv && \
-    python -m venv --upgrade-deps --copies /opt/venv && \
-    /opt/venv/bin/pip install --upgrade pip wheel && \
-    /opt/venv/bin/pip install -Ur requirements.txt
+RUN pip install -U pip
+RUN pip install -Ur requirements.txt
 
-
-FROM python:3.9.6-slim-buster as final
-RUN apt-get update && apt-get -y install mime-support
-WORKDIR /etc/linkding
-# copy prod dependencies
-COPY --from=prod-deps /opt/venv /opt/venv
-# copy output from build stage
-COPY --from=python-build /etc/linkding/static static/
-# copy application code
+# Copy application
 COPY . .
+
 # Expose uwsgi server at port 9090
 EXPOSE 9090
-# Activate virtual env
-ENV VIRTUAL_ENV /opt/venv
-ENV PATH /opt/venv/bin:$PATH
-# Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
-RUN ["chmod", "g+w", "."]
+
 # Run bootstrap logic
 RUN ["chmod", "+x", "./bootstrap.sh"]
 CMD ["./bootstrap.sh"]

Options.md

@@ -0,0 +1,38 @@
+# Options
+
+This document lists the options that linkding can be configured with and explains how to use them in the individual install scenarios.
+
+## Using options
+
+### Docker
+
+Options are passed as environment variables to the Docker container by using the `-e` argument when using `docker run`. For example:
+
+```
+docker run --name linkding -p 9090:9090 -d -e LD_DISABLE_URL_VALIDATION=True sissbruecker/linkding:latest
+```
+
+For multiple options, use one `-e` argument per option.
+
+### Docker-compose
+
+For docker-compose options are configured using an `.env` file. 
+Follow the docker-compose setup in the README and copy `.env.sample` to `.env`. Then modify the options in `.env`.
+
+### Manual setup
+
+All options need to be defined as environment variables in the environment that linkding runs in.
+
+## List of options
+
+### `LD_DISABLE_URL_VALIDATION`
+
+Values: `True`, `False` | Default = `False`
+
+Completely disables URL validation for bookmarks. This can be useful if you intend to store non fully qualified domain name URLs, such as network paths, or you want to store URLs that use another protocol than `http` or `https`.
+
+### `LD_REQUEST_TIMEOUT`
+
+Values: `Integer` as seconds | Default = `60`
+
+Configures the request timeout in the uwsgi application server. This can be useful if you want to import a bookmark file with a high number of bookmarks and run into request timeouts.

README.md

@@ -1,28 +1,12 @@
 #  linkding
 
-*linkding* is a simple bookmark service that you can host yourself.
-It's designed be to be minimal, fast and easy to set up using Docker. 
+*linkding* is a simple bookmark service that you can host yourself. It supports managing bookmarks, categorizing them with tags and has a search function. It provides a bookmarklet for quickly adding new bookmarks while browsing the web. It also supports import / export of bookmarks in the Netscape HTML format. And that's basically it 🙂.
 
 The name comes from:
 - *link* which is often used as a synonym for URLs and bookmarks in common language
 - *Ding* which is german for *thing*
 - ...so basically some thing for managing your links
 
-**Feature Overview:**
-- Tags for organizing bookmarks
-- Search by text or tags
-- Bulk editing
-- Bookmark archive
-- Dark mode
-- Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
-- Automatically provides titles and descriptions of bookmarked websites 
-- Import and export bookmarks in Netscape HTML format
-- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), and a bookmarklet that should work in most browsers
-- REST API for developing 3rd party apps
-- Admin panel for user self-service and raw data access
-- Easy to set up using Docker, uses SQLite as database
-
-
 **Demo:** https://demo.linkding.link/ (configured with open registration)
 
 **Screenshot:**
@@ -31,7 +15,7 @@ The name comes from:
 
 ## Installation
 
-The easiest way to run linkding is to use [Docker](https://docs.docker.com/get-started/).  The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.
+The easiest way to run linkding is to use [Docker](https://docs.docker.com/get-started/).  The Docker image should be compatible with ARM platforms, so it can be run on a Raspberry Pi.
 
 There is also the option to set up the installation manually which I do not support, but can give some pointers on below.
 
@@ -65,7 +49,7 @@ docker-compose up -d
 
 ### User setup
 
-Finally you need to create a user so that you can access the application. Replace the credentials in the following command and run it:
+Finally you need to create a user so that you can access the frontend. Replace the credentials in the following command and run it:
 
 **Docker**
 ```shell
@@ -83,32 +67,28 @@ The command will prompt you for a secure password. After the command has complet
 
 If you can not or don't want to use Docker you can install the application manually on your server. To do so you can basically follow the steps from the *Development* section below while cross-referencing the `Dockerfile` and `bootstrap.sh` on how to make the application production-ready.
 
+### Options
+
+Check the [options document](Options.md) on how to configure your linkding installation.
+
 ### Hosting
 
-The application runs in a web-server called [uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/) that is production-ready and that you can expose to the web. If you don't know how to configure your server to expose the application to the web there are several more steps involved. I can not support the process here, but I can give some pointers on what to search for:
+The application runs in a web-server called [uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/) that is production-ready and that you can expose to the web. If you don't know how to configure your server to expose the application to the web there are several more steps involved. I can not support support the process here, but I can give some pointers on what to search for:
 - first get the app running (described in this document)
 - open the port that the application is running on in your servers firewall
 - depending on your network configuration, forward the opened port in your network router, so that the application can be addressed from the internet using your public IP address and the opened port
 
-## Options
+### Backups
 
-Check the [options document](docs/Options.md) on how to configure your linkding installation.
+For backups you have two options: manually or automatic.
 
-## Administration
+For manual backups you can export your bookmarks from the UI and store them on a backup device or online service.
 
-Check the [administration document](docs/Admin.md) on how to use the admin app that is bundled with linkding.
-
-## Backups
-
-Check the [backups document](docs/backup.md) for options on how to create backups.
-
-## How To
-
-Check the [how-to document](docs/how-to.md) for tips and tricks around using linkding.
+For automatic backups you want to backup the applications database. As described above, for production setups you should [mount](https://stackoverflow.com/questions/23439126/how-to-mount-a-host-directory-in-a-docker-container) the `/etc/linkding/data` directory from the Docker container to a directory on your host system. You can then use a backup tool of your choice to backup the contents of that directory.
 
 ## API
 
-The application provides a REST API that can be used by 3rd party applications to manage bookmarks. Check the [API docs](docs/API.md) for further information.
+The application provides a REST API that can be used by 3rd party applications to manage bookmarks. Check the [API docs](API.md) for further information.
 
 ## Troubleshooting
 
@@ -123,7 +103,7 @@ Note that any proxy servers that you are running in front of linkding may have t
 
 ## Development
 
-The application is open source, so you are free to modify or contribute. The application is built using the Django web framework. You can get started by checking out the excellent Django docs: https://docs.djangoproject.com/en/3.2/. The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.
+The application is open source, so you are free to modify or contribute. The application is built using the Django web framework. You can get started by checking out the excellent Django docs: https://docs.djangoproject.com/en/3.0/. The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.
 
 ### Prerequisites
 - Python 3
@@ -168,6 +148,4 @@ The frontend is now available under http://localhost:8000
 
 ## Community
 
-- [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
-- [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
-- [linkding-injector](https://github.com/Fivefold/linkding-injector) Injects search results from linkding into the sidebar of search pages like google and duckduckgo. Tested with Firefox and Chrome. By [Fivefold](https://github.com/Fivefold)
+- [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)

SECURITY.md

@@ -1,13 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 1.8.x   | :white_check_mark: |
-
-## Reporting a Vulnerability
-
-To report a vulnerability, please send a mail to: 588ex5zl8@mozmail.com
-
-I'll try to get back to you as soon as possible.

background-tasks-wrapper.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Wrapper script used by supervisord to first clear task locks before starting the background task processor
-
-python manage.py clean_tasks
-exec python manage.py process_tasks

bookmarks/admin.py

@@ -1,109 +1,17 @@
-from django.contrib import admin, messages
-from django.contrib.admin import AdminSite
-from django.contrib.auth.admin import UserAdmin
-from django.contrib.auth.models import User
-from django.db.models import Count, QuerySet
-from django.utils.translation import ngettext, gettext
-from rest_framework.authtoken.admin import TokenAdmin
-from rest_framework.authtoken.models import TokenProxy
-
-from bookmarks.models import Bookmark, Tag, UserProfile, Toast
-from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
-
-
-class LinkdingAdminSite(AdminSite):
-    site_header = 'linkding administration'
-    site_title = 'linkding Admin'
+from django.contrib import admin
 
+from bookmarks.models import Bookmark, Tag
 
+@admin.register(Bookmark)
 class AdminBookmark(admin.ModelAdmin):
-    list_display = ('resolved_title', 'url', 'is_archived', 'owner', 'date_added')
-    search_fields = ('title', 'description', 'website_title', 'website_description', 'url', 'tags__name')
-    list_filter = ('owner__username', 'is_archived', 'tags',)
-    ordering = ('-date_added',)
-    actions = ['archive_selected_bookmarks', 'unarchive_selected_bookmarks']
-
-    def archive_selected_bookmarks(self, request, queryset: QuerySet):
-        for bookmark in queryset:
-            archive_bookmark(bookmark)
-        bookmarks_count = queryset.count()
-        self.message_user(request, ngettext(
-            '%d bookmark was successfully archived.',
-            '%d bookmarks were successfully archived.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
-
-    def unarchive_selected_bookmarks(self, request, queryset: QuerySet):
-        for bookmark in queryset:
-            unarchive_bookmark(bookmark)
-        bookmarks_count = queryset.count()
-        self.message_user(request, ngettext(
-            '%d bookmark was successfully unarchived.',
-            '%d bookmarks were successfully unarchived.',
-            bookmarks_count,
-        ) % bookmarks_count, messages.SUCCESS)
-
+  list_display = ('title', 'url', 'date_added')
+  search_fields = ('title', 'url', 'tags__name')
+  list_filter = ('tags',)
+  ordering = ('-date_added', )
 
+@admin.register(Tag)
 class AdminTag(admin.ModelAdmin):
-    list_display = ('name', 'bookmarks_count', 'owner', 'date_added')
-    search_fields = ('name', 'owner__username')
-    list_filter = ('owner__username',)
-    ordering = ('-date_added',)
-    actions = ['delete_unused_tags']
-
-    def get_queryset(self, request):
-        queryset = super().get_queryset(request)
-        queryset = queryset.annotate(bookmarks_count=Count("bookmark"))
-        return queryset
-
-    def bookmarks_count(self, obj):
-        return obj.bookmarks_count
-
-    bookmarks_count.admin_order_field = 'bookmarks_count'
-
-    def delete_unused_tags(self, request, queryset: QuerySet):
-        unused_tags = queryset.filter(bookmark__isnull=True)
-        unused_tags_count = unused_tags.count()
-        for tag in unused_tags:
-            tag.delete()
-
-        if unused_tags_count > 0:
-            self.message_user(request, ngettext(
-                '%d unused tag was successfully deleted.',
-                '%d unused tags were successfully deleted.',
-                unused_tags_count,
-            ) % unused_tags_count, messages.SUCCESS)
-        else:
-            self.message_user(request, gettext(
-                'There were no unused tags in the selection',
-            ), messages.SUCCESS)
-
-
-class AdminUserProfileInline(admin.StackedInline):
-    model = UserProfile
-    can_delete = False
-    verbose_name_plural = 'Profile'
-    fk_name = 'user'
-
-
-class AdminCustomUser(UserAdmin):
-    inlines = (AdminUserProfileInline,)
-
-    def get_inline_instances(self, request, obj=None):
-        if not obj:
-            return list()
-        return super(AdminCustomUser, self).get_inline_instances(request, obj)
-
-
-class AdminToast(admin.ModelAdmin):
-    list_display = ('key', 'message', 'owner', 'acknowledged')
-    search_fields = ('key', 'message')
-    list_filter = ('owner__username',)
-
-
-linkding_admin_site = LinkdingAdminSite()
-linkding_admin_site.register(Bookmark, AdminBookmark)
-linkding_admin_site.register(Tag, AdminTag)
-linkding_admin_site.register(User, AdminCustomUser)
-linkding_admin_site.register(TokenProxy, TokenAdmin)
-linkding_admin_site.register(Toast, AdminToast)
+  list_display = ('name', 'date_added', 'owner')
+  search_fields = ('name', 'owner__username')
+  list_filter = ('owner__username', )
+  ordering = ('-date_added', )

bookmarks/api/routes.py

@@ -1,4 +1,3 @@
-from django.urls import reverse
 from rest_framework import viewsets, mixins, status
 from rest_framework.decorators import action
 from rest_framework.response import Response
@@ -7,8 +6,6 @@ from rest_framework.routers import DefaultRouter
 from bookmarks import queries
 from bookmarks.api.serializers import BookmarkSerializer, TagSerializer
 from bookmarks.models import Bookmark, Tag
-from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
-from bookmarks.services.website_loader import load_website_metadata
 
 
 class BookmarkViewSet(viewsets.GenericViewSet,
@@ -42,37 +39,6 @@ class BookmarkViewSet(viewsets.GenericViewSet,
         data = serializer(page, many=True).data
         return self.get_paginated_response(data)
 
-    @action(methods=['post'], detail=True)
-    def archive(self, request, pk):
-        bookmark = self.get_object()
-        archive_bookmark(bookmark)
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @action(methods=['post'], detail=True)
-    def unarchive(self, request, pk):
-        bookmark = self.get_object()
-        unarchive_bookmark(bookmark)
-        return Response(status=status.HTTP_204_NO_CONTENT)
-
-    @action(methods=['get'], detail=False)
-    def check(self, request):
-        url = request.GET.get('url')
-        bookmark = Bookmark.objects.filter(owner=request.user, url=url).first()
-        existing_bookmark_data = None
-
-        if bookmark is not None:
-            existing_bookmark_data = {
-                'id': bookmark.id,
-                'edit_url': reverse('bookmarks:edit', args=[bookmark.id])
-            }
-
-        metadata = load_website_metadata(url)
-
-        return Response({
-            'bookmark': existing_bookmark_data,
-            'metadata': metadata.to_dict()
-        }, status=status.HTTP_200_OK)
-
 
 class TagViewSet(viewsets.GenericViewSet,
                  mixins.ListModelMixin,

bookmarks/api/serializers.py

@@ -30,25 +30,22 @@ class BookmarkSerializer(serializers.ModelSerializer):
             'date_modified'
         ]
 
-    # Override optional char fields to provide default value
-    title = serializers.CharField(required=False, allow_blank=True, default='')
-    description = serializers.CharField(required=False, allow_blank=True, default='')
     # Override readonly tag_names property to allow passing a list of tag names to create/update
-    tag_names = TagListField(required=False, default=[])
+    tag_names = TagListField()
 
     def create(self, validated_data):
         bookmark = Bookmark()
         bookmark.url = validated_data['url']
         bookmark.title = validated_data['title']
         bookmark.description = validated_data['description']
-        tag_string = build_tag_string(validated_data['tag_names'])
+        tag_string = build_tag_string(validated_data['tag_names'], ' ')
         return create_bookmark(bookmark, tag_string, self.context['user'])
 
     def update(self, instance: Bookmark, validated_data):
         instance.url = validated_data['url']
         instance.title = validated_data['title']
         instance.description = validated_data['description']
-        tag_string = build_tag_string(validated_data['tag_names'])
+        tag_string = build_tag_string(validated_data['tag_names'], ' ')
         return update_bookmark(instance, tag_string, self.context['user'])
 
 

bookmarks/apps.py

@@ -3,7 +3,3 @@ from django.apps import AppConfig
 
 class BookmarksConfig(AppConfig):
     name = 'bookmarks'
-
-    def ready(self):
-        # Register signal handlers
-        import bookmarks.signals

bookmarks/components/SearchAutoComplete.svelte

@@ -264,4 +264,17 @@
         z-index: 2;
     }
 
+    /* TODO: Should be read from theme */
+    .menu-item.selected > a {
+        background: #f1f1fc;
+        color: #5755d9;
+    }
+
+    .group-item, .group-item:hover {
+        color: #999999;
+        text-transform: uppercase;
+        background: none;
+        font-size: 0.6rem;
+        font-weight: bold;
+    }
 </style>

bookmarks/components/TagAutocomplete.svelte

@@ -4,30 +4,15 @@
     export let id;
     export let name;
     export let value;
-    export let apiClient;
-    export let variant = 'default';
+    export let tags;
 
-    let tags = [];
     let isFocus = false;
     let isOpen = false;
     let input = null;
-    let suggestionList = null;
 
     let suggestions = [];
     let selectedIndex = 0;
 
-    init();
-
-    async function init() {
-        // For now we cache all tags on load as the template did before
-        try {
-            tags = await apiClient.getTags({limit: 1000, offset: 0});
-            tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
-        } catch (e) {
-            console.warn('TagAutocomplete: Error loading tag list');
-        }
-    }
-
     function handleFocus() {
         isFocus = true;
     }
@@ -42,9 +27,7 @@
 
         const word = getCurrentWord(input);
 
-        suggestions = word
-            ? tags.filter(tag => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0)
-            : [];
+        suggestions = word ? tags.filter(tag => tag.indexOf(word) === 0) : [];
 
         if (word && suggestions.length > 0) {
             open();
@@ -87,7 +70,7 @@
     function complete(suggestion) {
         const bounds = getCurrentWordBounds(input);
         const value = input.value;
-        input.value = value.substring(0, bounds.start) + suggestion.name + ' ' + value.substring(bounds.end);
+        input.value = value.substring(0, bounds.start) + suggestion + value.substring(bounds.end);
 
         close();
     }
@@ -101,39 +84,28 @@
         if (newIndex >= length) newIndex = 0;
 
         selectedIndex = newIndex;
-
-        // Scroll to selected list item
-        setTimeout(() => {
-            if (suggestionList) {
-                const selectedListItem = suggestionList.querySelector('li.selected');
-                if (selectedListItem) {
-                    selectedListItem.scrollIntoView({block: 'center'});
-                }
-            }
-        }, 0);
     }
 </script>
 
-<div class="form-autocomplete" class:small={variant === 'small'}>
+<div class="form-autocomplete">
     <!-- autocomplete input container -->
     <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
         <!-- autocomplete real input box -->
-        <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
+        <input id="{id}" name="{name}" value="{value ||''}"
                class="form-input" type="text" autocomplete="off"
                on:input={handleInput} on:keydown={handleKeyDown}
                on:focus={handleFocus} on:blur={handleBlur}>
     </div>
 
     <!-- autocomplete suggestion list -->
-    <ul class="menu" class:open={isOpen && suggestions.length > 0}
-        bind:this={suggestionList}>
+    <ul class="menu" class:open={isOpen && suggestions.length > 0}>
         <!-- menu list items -->
         {#each suggestions as tag,i}
             <li class="menu-item" class:selected={selectedIndex === i}>
                 <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
                     <div class="tile tile-centered">
                         <div class="tile-content">
-                            {tag.name}
+                            {tag}
                         </div>
                     </div>
                 </a>
@@ -153,16 +125,9 @@
         display: block;
     }
 
-    .form-autocomplete.small .form-autocomplete-input {
-        height: 1.4rem;
-        min-height: 1.4rem;
+    /* TODO: Should be read from theme */
+    .menu-item.selected > a {
+        background: #f1f1fc;
+        color: #5755d9;
     }
-    .form-autocomplete.small .form-autocomplete-input input {
-        margin: 0;
-        padding: 0;
-        font-size: 0.7rem;
-    }
-    .form-autocomplete.small .menu .menu-item {
-        font-size: 0.7rem;
-    }
-</style>
+</style>

bookmarks/components/api.js

@@ -5,7 +5,7 @@ export class ApiClient {
 
     getBookmarks(query, options = {limit: 100, offset: 0}) {
         const encodedQuery = encodeURIComponent(query)
-        const url = `${this.baseUrl}bookmarks/?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
+        const url = `${this.baseUrl}bookmarks?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
 
         return fetch(url)
             .then(response => response.json())
@@ -14,15 +14,7 @@ export class ApiClient {
 
     getArchivedBookmarks(query, options = {limit: 100, offset: 0}) {
         const encodedQuery = encodeURIComponent(query)
-        const url = `${this.baseUrl}bookmarks/archived/?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
-
-        return fetch(url)
-            .then(response => response.json())
-            .then(data => data.results)
-    }
-
-    getTags(options = {limit: 100, offset: 0}) {
-        const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`
+        const url = `${this.baseUrl}bookmarks/archived?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
 
         return fetch(url)
             .then(response => response.json())

bookmarks/context_processors.py

@@ -1,12 +0,0 @@
-from bookmarks.models import Toast
-
-
-def toasts(request):
-    user = request.user if hasattr(request, 'user') else None
-    toast_messages = Toast.objects.filter(owner=user, acknowledged=False) if user and user.is_authenticated else []
-    has_toasts = len(toast_messages) > 0
-
-    return {
-        'has_toasts': has_toasts,
-        'toast_messages': toast_messages,
-    }

bookmarks/management/commands/clean_tasks.py

@@ -1,15 +0,0 @@
-from background_task.models import Task, CompletedTask
-from django.core.management.base import BaseCommand
-
-
-class Command(BaseCommand):
-    help = "Remove task locks and clear completed task history"
-
-    def handle(self, *args, **options):
-        # Remove task locks
-        # If the background task processor exited while executing tasks, these tasks would still be marked as locked,
-        # even though no process is working on them, and would prevent the task processor from picking the next task in
-        # the queue
-        Task.objects.all().update(locked_by=None, locked_at=None)
-        # Clear task history to prevent them from bloating the DB
-        CompletedTask.objects.all().delete()

bookmarks/migrations/0007_userprofile.py

@@ -1,43 +0,0 @@
-# Generated by Django 2.2.18 on 2021-03-26 22:39
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-def forwards(apps, schema_editor):
-    User = apps.get_model('auth', 'User')
-    UserProfile = apps.get_model('bookmarks', 'UserProfile')
-    for user in User.objects.all():
-        try:
-            if user.profile:
-                continue
-        except UserProfile.DoesNotExist:
-            profile = UserProfile(user=user)
-            profile.save()
-
-
-def reverse(apps, schema_editor):
-    pass
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('bookmarks', '0006_bookmark_is_archived'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='UserProfile',
-            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('theme',
-                 models.CharField(choices=[('auto', 'Auto'), ('light', 'Light'), ('dark', 'Dark')], default='auto',
-                                  max_length=10)),
-                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile',
-                                              to=settings.AUTH_USER_MODEL)),
-            ],
-        ),
-        migrations.RunPython(forwards, reverse),
-    ]

bookmarks/migrations/0008_userprofile_bookmark_date_display.py

@@ -1,18 +0,0 @@
-# Generated by Django 2.2.18 on 2021-03-30 10:40
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('bookmarks', '0007_userprofile'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='userprofile',
-            name='bookmark_date_display',
-            field=models.CharField(choices=[('relative', 'Relative'), ('absolute', 'Absolute'), ('hidden', 'Hidden')], default='relative', max_length=10),
-        ),
-    ]

bookmarks/migrations/0009_bookmark_web_archive_snapshot_url.py

@@ -1,18 +0,0 @@
-# Generated by Django 2.2.20 on 2021-05-16 14:35
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('bookmarks', '0008_userprofile_bookmark_date_display'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='bookmark',
-            name='web_archive_snapshot_url',
-            field=models.CharField(blank=True, max_length=2048),
-        ),
-    ]

bookmarks/migrations/0010_userprofile_bookmark_link_target.py

@@ -1,18 +0,0 @@
-# Generated by Django 3.2.6 on 2021-10-03 06:35
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('bookmarks', '0009_bookmark_web_archive_snapshot_url'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='userprofile',
-            name='bookmark_link_target',
-            field=models.CharField(choices=[('_blank', 'New page'), ('_self', 'Same page')], default='_blank', max_length=10),
-        ),
-    ]

bookmarks/migrations/0011_userprofile_web_archive_integration.py

@@ -1,18 +0,0 @@
-# Generated by Django 3.2.6 on 2022-01-08 12:39
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('bookmarks', '0010_userprofile_bookmark_link_target'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='userprofile',
-            name='web_archive_integration',
-            field=models.CharField(choices=[('disabled', 'Disabled'), ('enabled', 'Enabled')], default='disabled', max_length=10),
-        ),
-    ]

bookmarks/migrations/0012_toast.py

@@ -1,26 +0,0 @@
-# Generated by Django 3.2.6 on 2022-01-08 19:24
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('bookmarks', '0011_userprofile_web_archive_integration'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='Toast',
-            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('key', models.CharField(max_length=50)),
-                ('message', models.TextField()),
-                ('acknowledged', models.BooleanField(default=False)),
-                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
-            ],
-        ),
-    ]

bookmarks/migrations/0013_web_archive_optin_toast.py

@@ -1,30 +0,0 @@
-# Generated by Django 3.2.6 on 2022-01-08 19:27
-
-from django.db import migrations
-from django.contrib.auth import get_user_model
-
-from bookmarks.models import Toast
-
-User = get_user_model()
-
-
-def forwards(apps, schema_editor):
-    for user in User.objects.all():
-        toast = Toast(key='web_archive_opt_in_hint',
-                      message='The Internet Archive Wayback Machine integration has been disabled by default. Check the Settings to re-enable it.',
-                      owner=user)
-        toast.save()
-
-
-def reverse(apps, schema_editor):
-    Toast.objects.filter(key='web_archive_opt_in_hint').delete()
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ('bookmarks', '0012_toast'),
-    ]
-
-    operations = [
-        migrations.RunPython(forwards, reverse),
-    ]

bookmarks/models.py

@@ -2,10 +2,7 @@ from typing import List
 
 from django import forms
 from django.contrib.auth import get_user_model
-from django.contrib.auth.models import User
 from django.db import models
-from django.db.models.signals import post_save
-from django.dispatch import receiver
 
 from bookmarks.utils import unique
 from bookmarks.validators import BookmarkURLValidator
@@ -20,19 +17,11 @@ class Tag(models.Model):
         return self.name
 
 
-def sanitize_tag_name(tag_name: str):
-    # strip leading/trailing spaces
-    # replace inner spaces with replacement char
-    return tag_name.strip().replace(' ', '-')
-
-
 def parse_tag_string(tag_string: str, delimiter: str = ','):
     if not tag_string:
         return []
     names = tag_string.strip().split(delimiter)
-    # remove empty names, sanitize remaining names
-    names = [sanitize_tag_name(name) for name in names if name]
-    # remove duplicates
+    names = [name.strip() for name in names if name]
     names = unique(names, str.lower)
     names.sort(key=str.lower)
 
@@ -49,7 +38,6 @@ class Bookmark(models.Model):
     description = models.TextField(blank=True)
     website_title = models.CharField(max_length=512, blank=True, null=True)
     website_description = models.TextField(blank=True, null=True)
-    web_archive_snapshot_url = models.CharField(max_length=2048, blank=True)
     unread = models.BooleanField(default=True)
     is_archived = models.BooleanField(default=False)
     date_added = models.DateTimeField()
@@ -99,70 +87,9 @@ class BookmarkForm(forms.ModelForm):
                                   widget=forms.Textarea())
     # Hidden field that determines whether to close window/tab after saving the bookmark
     auto_close = forms.CharField(required=False)
+    # Hidden field that determines where to redirect after saving the form
+    return_url = forms.CharField(required=False)
 
     class Meta:
         model = Bookmark
-        fields = ['url', 'tag_string', 'title', 'description', 'auto_close']
-
-
-class UserProfile(models.Model):
-    THEME_AUTO = 'auto'
-    THEME_LIGHT = 'light'
-    THEME_DARK = 'dark'
-    THEME_CHOICES = [
-        (THEME_AUTO, 'Auto'),
-        (THEME_LIGHT, 'Light'),
-        (THEME_DARK, 'Dark'),
-    ]
-    BOOKMARK_DATE_DISPLAY_RELATIVE = 'relative'
-    BOOKMARK_DATE_DISPLAY_ABSOLUTE = 'absolute'
-    BOOKMARK_DATE_DISPLAY_HIDDEN = 'hidden'
-    BOOKMARK_DATE_DISPLAY_CHOICES = [
-        (BOOKMARK_DATE_DISPLAY_RELATIVE, 'Relative'),
-        (BOOKMARK_DATE_DISPLAY_ABSOLUTE, 'Absolute'),
-        (BOOKMARK_DATE_DISPLAY_HIDDEN, 'Hidden'),
-    ]
-    BOOKMARK_LINK_TARGET_BLANK = '_blank'
-    BOOKMARK_LINK_TARGET_SELF = '_self'
-    BOOKMARK_LINK_TARGET_CHOICES = [
-        (BOOKMARK_LINK_TARGET_BLANK, 'New page'),
-        (BOOKMARK_LINK_TARGET_SELF, 'Same page'),
-    ]
-    WEB_ARCHIVE_INTEGRATION_DISABLED = 'disabled'
-    WEB_ARCHIVE_INTEGRATION_ENABLED = 'enabled'
-    WEB_ARCHIVE_INTEGRATION_CHOICES = [
-        (WEB_ARCHIVE_INTEGRATION_DISABLED, 'Disabled'),
-        (WEB_ARCHIVE_INTEGRATION_ENABLED, 'Enabled'),
-    ]
-    user = models.OneToOneField(get_user_model(), related_name='profile', on_delete=models.CASCADE)
-    theme = models.CharField(max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO)
-    bookmark_date_display = models.CharField(max_length=10, choices=BOOKMARK_DATE_DISPLAY_CHOICES, blank=False,
-                                             default=BOOKMARK_DATE_DISPLAY_RELATIVE)
-    bookmark_link_target = models.CharField(max_length=10, choices=BOOKMARK_LINK_TARGET_CHOICES, blank=False,
-                                            default=BOOKMARK_LINK_TARGET_BLANK)
-    web_archive_integration = models.CharField(max_length=10, choices=WEB_ARCHIVE_INTEGRATION_CHOICES, blank=False,
-                                               default=WEB_ARCHIVE_INTEGRATION_DISABLED)
-
-
-class UserProfileForm(forms.ModelForm):
-    class Meta:
-        model = UserProfile
-        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration']
-
-
-@receiver(post_save, sender=get_user_model())
-def create_user_profile(sender, instance, created, **kwargs):
-    if created:
-        UserProfile.objects.create(user=instance)
-
-
-@receiver(post_save, sender=get_user_model())
-def save_user_profile(sender, instance, **kwargs):
-    instance.profile.save()
-
-
-class Toast(models.Model):
-    key = models.CharField(max_length=50)
-    message = models.TextField()
-    acknowledged = models.BooleanField(default=False)
-    owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+        fields = ['url', 'tag_string', 'title', 'description', 'auto_close', 'return_url']

bookmarks/queries.py

@@ -55,24 +55,50 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
             tags__name__iexact=tag_name
         )
 
-    # Sort by date added
-    query_set = query_set.order_by('-date_added')
+    # Sort by modification date
+    query_set = query_set.order_by('-date_modified')
 
     return query_set
 
 
 def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    bookmarks_query = query_bookmarks(user, query_string)
-
-    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
-
-    return query_set.distinct()
+    return _base_bookmark_tags_query(user, query_string) \
+        .filter(bookmark__is_archived=False) \
+        .distinct()
 
 
 def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    bookmarks_query = query_archived_bookmarks(user, query_string)
+    return _base_bookmark_tags_query(user, query_string) \
+        .filter(bookmark__is_archived=True) \
+        .distinct()
 
-    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
+
+def _base_bookmark_tags_query(user: User, query_string: str) -> QuerySet:
+    query_set = Tag.objects
+
+    # Filter for user
+    query_set = query_set.filter(owner=user)
+
+    # Only show tags which have bookmarks
+    query_set = query_set.filter(bookmark__isnull=False)
+
+    # Split query into search terms and tags
+    query = _parse_query_string(query_string)
+
+    # Filter for search terms and tags
+    for term in query['search_terms']:
+        query_set = query_set.filter(
+            Q(bookmark__title__contains=term)
+            | Q(bookmark__description__contains=term)
+            | Q(bookmark__website_title__contains=term)
+            | Q(bookmark__website_description__contains=term)
+            | Q(bookmark__url__contains=term)
+        )
+
+    for tag_name in query['tag_names']:
+        query_set = query_set.filter(
+            bookmark__tags__name__iexact=tag_name
+        )
 
     return query_set.distinct()
 

bookmarks/services/bookmarks.py

@@ -1,12 +1,9 @@
-from typing import Union
-
 from django.contrib.auth.models import User
 from django.utils import timezone
 
 from bookmarks.models import Bookmark, parse_tag_string
 from bookmarks.services.tags import get_or_create_tags
 from bookmarks.services.website_loader import load_website_metadata
-from bookmarks.services import tasks
 
 
 def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
@@ -28,16 +25,10 @@ def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
     # Update tag list
     _update_bookmark_tags(bookmark, tag_string, current_user)
     bookmark.save()
-    # Create snapshot on web archive
-    tasks.create_web_archive_snapshot(current_user, bookmark, False)
-
     return bookmark
 
 
 def update_bookmark(bookmark: Bookmark, tag_string, current_user: User):
-    # Detect URL change
-    original_bookmark = Bookmark.objects.get(id=bookmark.id)
-    has_url_changed = original_bookmark.url != bookmark.url
     # Update website info
     _update_website_metadata(bookmark)
     # Update tag list
@@ -45,10 +36,6 @@ def update_bookmark(bookmark: Bookmark, tag_string, current_user: User):
     # Update dates
     bookmark.date_modified = timezone.now()
     bookmark.save()
-    # Update web archive snapshot, if URL changed
-    if has_url_changed:
-        tasks.create_web_archive_snapshot(current_user, bookmark, True)
-
     return bookmark
 
 
@@ -59,13 +46,6 @@ def archive_bookmark(bookmark: Bookmark):
     return bookmark
 
 
-def archive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
-    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-
-    bookmarks.update(is_archived=True, date_modified=timezone.now())
-
-
 def unarchive_bookmark(bookmark: Bookmark):
     bookmark.is_archived = False
     bookmark.date_modified = timezone.now()
@@ -73,46 +53,6 @@ def unarchive_bookmark(bookmark: Bookmark):
     return bookmark
 
 
-def unarchive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
-    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-
-    bookmarks.update(is_archived=False, date_modified=timezone.now())
-
-
-def delete_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
-    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-
-    bookmarks.delete()
-
-
-def tag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
-    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-    tag_names = parse_tag_string(tag_string)
-    tags = get_or_create_tags(tag_names, current_user)
-
-    for bookmark in bookmarks:
-        bookmark.tags.add(*tags)
-        bookmark.date_modified = timezone.now()
-
-    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
-
-
-def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
-    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
-    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
-    tag_names = parse_tag_string(tag_string)
-    tags = get_or_create_tags(tag_names, current_user)
-
-    for bookmark in bookmarks:
-        bookmark.tags.remove(*tags)
-        bookmark.date_modified = timezone.now()
-
-    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
-
-
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
     to_bookmark.title = from_bookmark.title
     to_bookmark.description = from_bookmark.description
@@ -125,11 +65,6 @@ def _update_website_metadata(bookmark: Bookmark):
 
 
 def _update_bookmark_tags(bookmark: Bookmark, tag_string: str, user: User):
-    tag_names = parse_tag_string(tag_string)
+    tag_names = parse_tag_string(tag_string, ' ')
     tags = get_or_create_tags(tag_names, user)
     bookmark.tags.set(tags)
-
-
-def _sanitize_id_list(bookmark_ids: [Union[int, str]]) -> [int]:
-    # Convert string ids to int if necessary
-    return [int(bm_id) if isinstance(bm_id, str) else bm_id for bm_id in bookmark_ids]

bookmarks/services/importer.py

@@ -1,14 +1,12 @@
 import logging
 from dataclasses import dataclass
+from datetime import datetime
 
 from django.contrib.auth.models import User
-from django.utils import timezone
 
 from bookmarks.models import Bookmark, parse_tag_string
-from bookmarks.services import tasks
 from bookmarks.services.parser import parse, NetscapeBookmark
 from bookmarks.services.tags import get_or_create_tags
-from bookmarks.utils import parse_timestamp
 
 logger = logging.getLogger(__name__)
 
@@ -39,9 +37,6 @@ def import_netscape_html(html: str, user: User):
             logging.exception('Error importing bookmark: ' + shortened_bookmark_tag_str)
             result.failed = result.failed + 1
 
-    # Create snapshots for newly imported bookmarks
-    tasks.schedule_bookmarks_without_snapshots(user)
-
     return result
 
 
@@ -50,10 +45,7 @@ def _import_bookmark_tag(netscape_bookmark: NetscapeBookmark, user: User):
     bookmark = _get_or_create_bookmark(netscape_bookmark.href, user)
 
     bookmark.url = netscape_bookmark.href
-    if netscape_bookmark.date_added:
-        bookmark.date_added = parse_timestamp(netscape_bookmark.date_added)
-    else:
-        bookmark.date_added = timezone.now()
+    bookmark.date_added = datetime.utcfromtimestamp(int(netscape_bookmark.date_added)).astimezone()
     bookmark.date_modified = bookmark.date_added
     bookmark.unread = False
     bookmark.title = netscape_bookmark.title
@@ -61,7 +53,6 @@ def _import_bookmark_tag(netscape_bookmark: NetscapeBookmark, user: User):
         bookmark.description = netscape_bookmark.description
     bookmark.owner = user
 
-    bookmark.full_clean()
     bookmark.save()
 
     # Set tags

bookmarks/services/parser.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import datetime
 
 import pyparsing as pp
 
@@ -8,7 +9,7 @@ class NetscapeBookmark:
     href: str
     title: str
     description: str
-    date_added: str
+    date_added: int
     tag_string: str
 
 
@@ -16,7 +17,8 @@ def extract_bookmark_link(tag):
     href = tag[0].href
     title = tag[0].text
     tag_string = tag[0].tags
-    date_added = tag[0].add_date
+    date_added_string = tag[0].add_date if tag[0].add_date else datetime.now().timestamp()
+    date_added = int(date_added_string)
 
     return {
         'href': href,

bookmarks/services/tasks.py

@@ -1,65 +0,0 @@
-import logging
-
-import waybackpy
-from background_task import background
-from django.conf import settings
-from django.contrib.auth import get_user_model
-from django.contrib.auth.models import User
-from waybackpy.exceptions import WaybackError
-
-from bookmarks.models import Bookmark, UserProfile
-
-logger = logging.getLogger(__name__)
-
-
-def is_web_archive_integration_active(user: User) -> bool:
-    background_tasks_enabled = not settings.LD_DISABLE_BACKGROUND_TASKS
-    web_archive_integration_enabled = \
-        user.profile.web_archive_integration == UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
-
-    return background_tasks_enabled and web_archive_integration_enabled
-
-
-def create_web_archive_snapshot(user: User, bookmark: Bookmark, force_update: bool):
-    if is_web_archive_integration_active(user):
-        _create_web_archive_snapshot_task(bookmark.id, force_update)
-
-
-@background()
-def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
-    try:
-        bookmark = Bookmark.objects.get(id=bookmark_id)
-    except Bookmark.DoesNotExist:
-        return
-
-    # Skip if snapshot exists and update is not explicitly requested
-    if bookmark.web_archive_snapshot_url and not force_update:
-        return
-
-    logger.debug(f'Create web archive link for bookmark: {bookmark}...')
-
-    wayback = waybackpy.Url(bookmark.url)
-
-    try:
-        archive = wayback.save()
-    except WaybackError as error:
-        logger.exception(f'Error creating web archive link for bookmark: {bookmark}...', exc_info=error)
-        raise
-
-    bookmark.web_archive_snapshot_url = archive.archive_url
-    bookmark.save()
-    logger.debug(f'Successfully created web archive link for bookmark: {bookmark}...')
-
-
-def schedule_bookmarks_without_snapshots(user: User):
-    if is_web_archive_integration_active(user):
-        _schedule_bookmarks_without_snapshots_task(user.id)
-
-
-@background()
-def _schedule_bookmarks_without_snapshots_task(user_id: int):
-    user = get_user_model().objects.get(id=user_id)
-    bookmarks_without_snapshots = Bookmark.objects.filter(web_archive_snapshot_url__exact='', owner=user)
-
-    for bookmark in bookmarks_without_snapshots:
-        _create_web_archive_snapshot_task(bookmark.id, False)

bookmarks/services/website_loader.py

@@ -2,7 +2,6 @@ from dataclasses import dataclass
 
 import requests
 from bs4 import BeautifulSoup
-from charset_normalizer import from_bytes
 
 
 @dataclass
@@ -34,11 +33,5 @@ def load_website_metadata(url: str):
 
 
 def load_page(url: str):
-    r = requests.get(url, timeout=10)
-
-    # Use charset_normalizer to determine encoding that best matches the response content
-    # Several sites seem to specify the response encoding incorrectly, so we ignore it and use custom logic instead
-    # This is different from Response.text which does respect the encoding specified in the response first,
-    # before trying to determine one
-    results = from_bytes(r.content)
-    return str(results.best())
+    r = requests.get(url)
+    return r.text

bookmarks/signals.py

@@ -1,8 +0,0 @@
-from django.contrib.auth import user_logged_in
-from django.dispatch import receiver
-from bookmarks.services import tasks
-
-
-@receiver(user_logged_in)
-def user_logged_in(sender, request, user, **kwargs):
-    tasks.schedule_bookmarks_without_snapshots(user)

bookmarks/static/bulk_edit.js

@@ -1,86 +0,0 @@
-(function () {
-    const bulkEditToggle = document.getElementById('bulk-edit-mode')
-    const bulkEditBar = document.querySelector('.bulk-edit-bar')
-    const singleToggles = document.querySelectorAll('.bulk-edit-toggle input')
-    const allToggle = document.querySelector('.bulk-edit-all-toggle input')
-
-    function isAllSelected() {
-        let result = true
-
-        singleToggles.forEach(function (toggle) {
-            result = result && toggle.checked
-        })
-
-        return result
-    }
-
-    function selectAll() {
-        singleToggles.forEach(function (toggle) {
-            toggle.checked = true
-        })
-    }
-
-    function deselectAll() {
-        singleToggles.forEach(function (toggle) {
-            toggle.checked = false
-        })
-    }
-
-    // Toggle all
-    allToggle.addEventListener('change', function (e) {
-        if (e.target.checked) {
-            selectAll()
-        } else {
-            deselectAll()
-        }
-    })
-
-    // Toggle single
-    singleToggles.forEach(function (toggle) {
-        toggle.addEventListener('change', function () {
-            allToggle.checked = isAllSelected()
-        })
-    })
-
-    // Allow overflow when bulk edit mode is active to be able to display tag auto complete menu
-    let bulkEditToggleTimeout
-    if (bulkEditToggle.checked) {
-        bulkEditBar.style.overflow = 'visible';
-    }
-    bulkEditToggle.addEventListener('change', function (e) {
-        if (bulkEditToggleTimeout) {
-            clearTimeout(bulkEditToggleTimeout);
-            bulkEditToggleTimeout = null;
-        }
-        if (e.target.checked) {
-            bulkEditToggleTimeout = setTimeout(function () {
-                bulkEditBar.style.overflow = 'visible';
-            }, 500);
-        } else {
-            bulkEditBar.style.overflow = 'hidden';
-        }
-    });
-
-    // Init tag auto-complete
-    function initTagAutoComplete() {
-        const wrapper = document.createElement('div');
-        const tagInput = document.getElementById('bulk-edit-tags-input');
-        const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || '';
-        const apiClient = new linkding.ApiClient(apiBaseUrl)
-
-        new linkding.TagAutoComplete({
-            target: wrapper,
-            props: {
-                id: 'bulk-edit-tags-input',
-                name: tagInput.name,
-                value: tagInput.value,
-                apiClient: apiClient,
-                variant: 'small'
-            }
-        });
-
-        tagInput.parentElement.replaceChild(wrapper, tagInput);
-    }
-
-    initTagAutoComplete();
-})()

bookmarks/static/shared.js

@@ -1,83 +0,0 @@
-(function () {
-
-    function initConfirmationButtons() {
-        const buttonEls = document.querySelectorAll('.btn-confirmation');
-
-        function showConfirmation(buttonEl) {
-            const cancelEl = document.createElement(buttonEl.nodeName);
-            cancelEl.innerText = 'Cancel';
-            cancelEl.className = 'btn btn-link btn-sm btn-confirmation-action mr-1';
-            cancelEl.addEventListener('click', function () {
-                container.remove();
-                buttonEl.style = '';
-            });
-
-            const confirmEl = document.createElement(buttonEl.nodeName);
-            confirmEl.innerText = 'Confirm';
-            confirmEl.className = 'btn btn-link btn-delete btn-sm btn-confirmation-action';
-
-            if (buttonEl.nodeName === 'BUTTON') {
-                confirmEl.type = buttonEl.type;
-                confirmEl.name = buttonEl.name;
-                confirmEl.value = buttonEl.value;
-            }
-            if (buttonEl.nodeName === 'A') {
-                confirmEl.href = buttonEl.href;
-            }
-
-            const container = document.createElement('span');
-            container.className = 'confirmation'
-            container.appendChild(cancelEl);
-            container.appendChild(confirmEl);
-            buttonEl.parentElement.insertBefore(container, buttonEl);
-            buttonEl.style = 'display: none';
-        }
-
-        buttonEls.forEach(function (linkEl) {
-            linkEl.addEventListener('click', function (e) {
-                e.preventDefault();
-                showConfirmation(linkEl);
-            });
-        });
-    }
-
-    function initGlobalShortcuts() {
-        // Focus search button
-        document.addEventListener('keydown', function (event) {
-            // Filter for shortcut key
-            if (event.key !== 's') return;
-            // Skip if event occurred within an input element
-            const targetNodeName = event.target.nodeName;
-            const isInputTarget = targetNodeName === 'INPUT'
-                || targetNodeName === 'SELECT'
-                || targetNodeName === 'TEXTAREA';
-
-            if (isInputTarget) return;
-
-            const searchInput = document.querySelector('input[type="search"]');
-
-            if (searchInput) {
-                searchInput.focus();
-                event.preventDefault();
-            }
-        });
-
-        // Add new bookmark
-        document.addEventListener('keydown', function(event) {
-            // Filter for new entry shortcut key
-            if (event.key !== 'n') return;
-            // Skip if event occurred within an input element
-            const targetNodeName = event.target.nodeName;
-            const isInputTarget = targetNodeName === 'INPUT'
-                || targetNodeName === 'SELECT'
-                || targetNodeName === 'TEXTAREA';
-
-            if (isInputTarget) return;
-
-            window.location.assign("/bookmarks/new");
-        });
-    }
-
-    initConfirmationButtons();
-    initGlobalShortcuts();
-})()

bookmarks/styles/base.scss

@@ -1,48 +1,29 @@
 body {
   margin: 20px 10px;
-
-  @media (min-width: $size-sm) {
-    // High horizontal padding accounts for checkboxes that show up in bulk edit mode
-    margin: 20px 24px;
-  }
 }
 
 header {
   margin-bottom: 40px;
 }
 
-header .toasts {
-  margin-bottom: 20px;
-
-  .toast {
-    margin-bottom: 0.4rem;
-  }
-
-  .toast a.btn-clear:visited {
-    color: currentColor;
-  }
-}
-
 .navbar {
 
   .navbar-brand {
 
-    display: flex;
-    align-items: center;
-
     .logo {
-      width: 28px;
-      height: 28px;
+      background-color: $primary-color;
+      color: $light-color;
+      padding: 14px;
     }
 
     h1 {
       text-transform: uppercase;
       display: inline-block;
-      margin: 0 0 0 8px;
     }
   }
 
   .dropdown-toggle {
+    padding: 0;
   }
 }
 
@@ -58,18 +39,9 @@ h2 {
   color: $gray-color-dark;
 }
 
-// Fix up visited styles
-a:visited {
-  color: $link-color;
-}
-a:visited:hover {
-  color: $link-color-dark;
-}
-.btn-link:visited:not(.btn-primary) {
-  color: $link-color;
-}
-.btn-link:visited:not(.btn-primary):hover {
-  color: $link-color-dark;
+// Button color should not change for anchor elements
+.btn:visited:not(.btn-primary) {
+  color: $primary-color;
 }
 
 // Increase spacing between columns
@@ -80,25 +52,4 @@ a:visited:hover {
 // Remove left padding from first pagination link
 .pagination .page-item:first-child a {
   padding-left: 0;
-}
-
-// Override border color for tab block
-.tab-block {
-  border-bottom: solid 1px $border-color;
-}
-
-// Form auto-complete menu
-.form-autocomplete .menu {
-  .menu-item.selected > a, .menu-item > a:hover {
-    background: $secondary-color;
-    color: $primary-color;
-  }
-
-  .group-item, .group-item:hover {
-    color: $gray-color;
-    text-transform: uppercase;
-    background: none;
-    font-size: 0.6rem;
-    font-weight: bold;
-  }
-}
+}

bookmarks/styles/bookmarks.scss

@@ -1,16 +1,14 @@
 .bookmarks-page .search {
-  $searchbox-width: 180px;
-  $searchbox-width-md: 300px;
   $searchbox-height: 1.8rem;
 
   // Regular input
   input[type='search'] {
-    width: $searchbox-width;
+    width: 180px;
     height: $searchbox-height;
     -webkit-appearance: none;
 
     @media (min-width: $control-width-md) {
-      width: $searchbox-width-md;
+      width: 300px;
     }
   }
 
@@ -20,29 +18,18 @@
     height: $searchbox-height;
 
     .form-autocomplete-input {
-      width: $searchbox-width;
       height: $searchbox-height;
+      width: 100%;
 
       input[type='search'] {
-        width: 100%;
         height: 100%;
         margin: 0;
         border: none;
       }
-
-      @media (min-width: $control-width-md) {
-        width: $searchbox-width-md;
-      }
     }
   }
 }
 
-.bookmarks-page .content-area-header {
-  span.btn {
-    margin-left: 8px;
-  }
-}
-
 ul.bookmark-list {
 
   list-style: none;
@@ -52,37 +39,23 @@ ul.bookmark-list {
   .description {
     color: $gray-color-dark;
 
-    a, a:visited:hover {
+    a {
       color: $alternative-color;
     }
   }
 
-  .actions > *:not(:last-child) {
-    margin-right: 0.1rem;
-  }
-
-  .actions .date-label a {
-    color: $gray-color;
-  }
-
   .actions .btn-link {
     color: $gray-color;
-    padding: 0;
-    height: auto;
-    vertical-align: unset;
-    border: none;
+    padding-left: 0;
+    padding-right: 0;
 
     &:focus,
     &:hover,
     &:active,
     &.active {
-      color: $gray-color-dark;
+      color: darken($gray-color, 10%);
     }
   }
-
-  .bulk-edit-toggle {
-    display: none;
-  }
 }
 
 .bookmark-pagination {
@@ -91,7 +64,7 @@ ul.bookmark-list {
 
 .tag-cloud {
 
-  a, a:visited:hover {
+  a {
     color: $alternative-color;
   }
 
@@ -108,41 +81,12 @@ ul.bookmark-list {
 
 .bookmarks-form {
 
-  .btn.form-icon {
-    padding: 0;
-    width: 20px;
-    height: 20px;
-    visibility: hidden;
-    color: $gray-color;
-
-    &:focus,
-    &:hover,
-    &:active,
-    &.active {
-      color: $gray-color-dark;
-    }
-
-    > svg {
-      width: 20px;
-      height: 20px;
-    }
-  }
-
-  .has-icon-right > input, .has-icon-right > textarea {
-    padding-right: 30px;
-  }
-
-  .has-icon-right > input:placeholder-shown ~ .btn.form-icon,
-  .has-icon-right > textarea:placeholder-shown ~ .btn.form-icon {
-    visibility: visible;
-  }
-
   .form-icon.loading {
     visibility: hidden;
   }
 
   .form-input-hint.bookmark-exists {
-    display: none;
+    visibility: hidden;
     color: $warning-color;
 
     a {
@@ -152,101 +96,3 @@ ul.bookmark-list {
     }
   }
 }
-
-/* Bookmark actions / bulk edit */
-$bulk-edit-toggle-width: 16px;
-$bulk-edit-toggle-offset: 8px;
-$bulk-edit-bar-offset: $bulk-edit-toggle-width + (2 * $bulk-edit-toggle-offset);
-$bulk-edit-transition-duration: 400ms;
-
-.bookmarks-page form.bookmark-actions {
-
-  .bulk-edit-bar {
-    margin-top: -17px;
-    margin-bottom: 16px;
-    margin-left: -$bulk-edit-bar-offset;
-    max-height: 0;
-    overflow: hidden;
-    transition: max-height $bulk-edit-transition-duration;
-  }
-
-  .bulk-edit-actions {
-    display: flex;
-    align-items: baseline;
-    padding: 4px 0;
-    border-top: solid 1px $border-color;
-
-    button:hover {
-      text-decoration: underline;
-    }
-
-    > label.form-checkbox {
-      min-height: 1rem;
-    }
-
-    > button {
-      padding: 0;
-      margin-left: 8px;
-    }
-
-    > span {
-      margin-left: 8px;
-    }
-
-    > input, .form-autocomplete {
-      width: auto;
-      margin-left: 4px;
-      max-width: 200px;
-      -webkit-appearance: none;
-    }
-
-    span.confirmation {
-      display: flex;
-    }
-
-    span.confirmation button {
-      padding: 0;
-    }
-  }
-
-  .bulk-edit-all-toggle {
-    width: $bulk-edit-toggle-width;
-    margin: 0 0 0 $bulk-edit-toggle-offset;
-    padding: 0;
-  }
-
-  ul.bookmark-list li {
-    position: relative;
-  }
-
-  ul.bookmark-list li .bulk-edit-toggle {
-    display: block;
-    position: absolute;
-    width: $bulk-edit-toggle-width;
-    left: -$bulk-edit-toggle-width - $bulk-edit-toggle-offset;
-    top: 0;
-    padding: 0;
-    margin: 0;
-    visibility: hidden;
-    opacity: 0;
-    transition: all $bulk-edit-transition-duration;
-
-    i {
-      top: 0.2rem;
-    }
-  }
-}
-
-#bulk-edit-mode {
-  display: none;
-}
-
-#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-toggle {
-  visibility: visible;
-  opacity: 1;
-}
-
-#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-bar {
-  max-height: 37px;
-  border-bottom: solid 1px $border-color;
-}

bookmarks/styles/dark.scss

@@ -1,32 +0,0 @@
-/* Dark theme overrides */
-
-/* Buttons */
-.btn.btn-primary {
-  background: $dt-primary-button-color;
-  border-color: darken($dt-primary-button-color, 5%);
-
-  &:hover, &:active, &:focus {
-    background: darken($dt-primary-button-color, 5%);
-    border-color: darken($dt-primary-button-color, 10%);
-  }
-}
-
-/* Focus ring*/
-a:focus, .btn:focus {
-  box-shadow: 0 0 0 .1rem rgba($primary-color, .5);
-}
-
-/* Forms */
-.has-error .form-input, .form-input.is-error, .has-error .form-select, .form-select.is-error {
-  background: darken($error-color, 40%);
-}
-
-.form-checkbox input:checked + .form-icon, .form-radio input:checked + .form-icon, .form-switch input:checked + .form-icon {
-  background: $dt-primary-button-color;
-  border-color: $dt-primary-button-color;
-}
-
-/* Pagination */
-.pagination .page-item.active a {
-  background: $dt-primary-button-color;
-}

bookmarks/styles/index.scss

@@ -0,0 +1,27 @@
+// Font sizes
+$html-font-size: 18px !default;
+
+//$alternative-color: #c84e00;
+//$alternative-color: #FF84E8;
+//$alternative-color: #98C1D9;
+//$alternative-color: #7B287D;
+$alternative-color: #05a6a3;
+$alternative-color-dark: darken($alternative-color, 5%);
+
+// Import Spectre CSS lib
+@import "../../node_modules/spectre.css/src/spectre";
+@import "../../node_modules/spectre.css/src/autocomplete";
+// Import Spectre icons
+@import "../../node_modules/spectre.css/src/icons/icons-core";
+@import "../../node_modules/spectre.css/src/icons/icons-navigation";
+@import "../../node_modules/spectre.css/src/icons/icons-action";
+@import "../../node_modules/spectre.css/src/icons/icons-object";
+
+
+// Import style modules
+@import "base";
+@import "util";
+@import "shared";
+@import "bookmarks";
+@import "settings";
+@import "auth";

bookmarks/styles/settings.scss

@@ -1,11 +1,6 @@
 .settings-page {
   section.content-area {
     margin-bottom: 2rem;
-
-    h2 {
-      font-size: 1.0rem;
-      margin-bottom: 0.8rem;
-    }
   }
 
   .input-group > input[type=submit] {

bookmarks/styles/shared.scss

@@ -1,4 +1,3 @@
-// Content area component
 section.content-area {
 
   .content-area-header {
@@ -12,11 +11,3 @@ section.content-area {
     }
   }
 }
-
-// Confirm button component
-.btn-confirmation-action {
-  color: $error-color !important;
-  &:hover {
-    text-decoration: underline;
-  }
-}

bookmarks/styles/theme-dark.scss

@@ -1,17 +0,0 @@
-// Import custom variables
-@import "variables-dark";
-
-// Import Spectre CSS lib
-@import "../../node_modules/spectre.css/src/spectre";
-@import "../../node_modules/spectre.css/src/autocomplete";
-
-// Import style modules
-@import "base";
-@import "util";
-@import "shared";
-@import "bookmarks";
-@import "settings";
-@import "auth";
-
-// Dark theme overrides
-@import "dark";

bookmarks/styles/theme-light.scss

@@ -1,14 +0,0 @@
-// Import custom variables
-@import "variables-light";
-
-// Import Spectre CSS lib
-@import "../../node_modules/spectre.css/src/spectre";
-@import "../../node_modules/spectre.css/src/autocomplete";
-
-// Import style modules
-@import "base";
-@import "util";
-@import "shared";
-@import "bookmarks";
-@import "settings";
-@import "auth";

bookmarks/styles/util.scss

@@ -7,11 +7,3 @@
   overflow: hidden;
   text-overflow: ellipsis;
 }
-
-.text-sm {
-  font-size: 0.7rem;
-}
-
-.text-gray-dark {
-  color: $gray-color-dark;
-}

bookmarks/styles/variables-dark.scss

@@ -1,28 +0,0 @@
-$html-font-size: 18px !default;
-
-$body-bg: #161822 !default;
-$bg-color: lighten($body-bg, 5%) !default;
-$bg-color-light: lighten($body-bg, 5%) !default;
-
-$border-color: #4C4E53 !default;
-$border-color-dark: $border-color !default;
-
-$body-font-color: #b5bec8 !default;
-$light-color: #fafafa !default;
-
-$gray-color: #7f879b !default;
-$gray-color-dark: lighten($gray-color, 20%) !default;
-
-$primary-color: #a8b1ff !default;
-$primary-color-dark: saturate($primary-color, 5%) !default;
-$secondary-color: lighten($body-bg, 10%) !default;
-
-$link-color: $primary-color !default;
-$link-color-dark: darken($link-color, 5%) !default;
-$link-color-light: $link-color !default;
-
-$alternative-color: #59bdb9;
-$alternative-color-dark: #73f1eb;
-
-/* Dark theme specific */
-$dt-primary-button-color: #5761cb !default;

bookmarks/styles/variables-light.scss

@@ -1,4 +0,0 @@
-$html-font-size: 18px !default;
-
-$alternative-color: #05a6a3;
-$alternative-color-dark: darken($alternative-color, 5%);

bookmarks/templates/bookmarks/archive.html

@@ -4,9 +4,6 @@
 {% load bookmarks %}
 
 {% block content %}
-
-    {% include 'bookmarks/bulk_edit/state.html' %}
-
     <div class="bookmarks-page columns">
 
         {# Bookmark list #}
@@ -15,20 +12,13 @@
                 <h2>Archived bookmarks</h2>
                 <div class="spacer"></div>
                 {% bookmark_search query tags mode='archive' %}
-                {% include 'bookmarks/bulk_edit/toggle.html' %}
             </div>
 
-            <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ return_url }}"
-                  method="post">
-                {% csrf_token %}
-                {% include 'bookmarks/bulk_edit/bar.html' with mode='archive' %}
-
-                {% if empty %}
-                    {% include 'bookmarks/empty_bookmarks.html' %}
-                {% else %}
-                    {% bookmark_list bookmarks return_url link_target %}
-                {% endif %}
-            </form>
+            {% if empty %}
+                {% include 'bookmarks/empty_bookmarks.html' %}
+            {% else %}
+                {% bookmark_list bookmarks return_url %}
+            {% endif %}
         </section>
 
         {# Tag list #}
@@ -41,6 +31,4 @@
     </div>
 
     <script src="{% static "bundle.js" %}"></script>
-    <script src="{% static "shared.js" %}"></script>
-    <script src="{% static "bulk_edit.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/bookmark_list.html

@@ -3,21 +3,17 @@
 
 <ul class="bookmark-list">
     {% for bookmark in bookmarks %}
-        <li data-is-bookmark-item>
-            <label class="form-checkbox bulk-edit-toggle">
-                <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
-                <i class="form-icon"></i>
-            </label>
+        <li>
             <div class="title truncate">
-                <a href="{{ bookmark.url }}" target="{{ link_target }}" rel="noopener">{{ bookmark.resolved_title }}</a>
+                <a href="{{ bookmark.url }}" target="_blank" rel="noopener">{{ bookmark.resolved_title }}</a>
             </div>
             <div class="description truncate">
                 {% if bookmark.tag_names %}
                     <span>
-                            {% for tag_name in bookmark.tag_names %}
-                                <a href="?{% append_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
-                            {% endfor %}
-                        </span>
+                        {% for tag_name in bookmark.tag_names %}
+                            <a href="?{% append_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
+                        {% endfor %}
+                    </span>
                 {% endif %}
                 {% if bookmark.tag_names and bookmark.resolved_description %} | {% endif %}
 
@@ -26,45 +22,18 @@
                 {% endif %}
             </div>
             <div class="actions">
-                {% if request.user.profile.bookmark_date_display == 'relative' %}
-                    <span class="date-label text-gray text-sm">
-                        {% if bookmark.web_archive_snapshot_url %}
-                        <a href="{{ bookmark.web_archive_snapshot_url }}"
-                           title="Show snapshot on the Internet Archive Wayback Machine" target="{{ link_target }}" rel="noopener">
-                        {% endif %}
-                        <span>{{ bookmark.date_added|humanize_relative_date }}</span>
-                        {% if bookmark.web_archive_snapshot_url %}
-                        <span>∞</span>
-                        </a>
-                        {% endif %}
-                    </span>
-                    <span class="text-gray text-sm">|</span>
-                {% endif %}
-                {% if request.user.profile.bookmark_date_display == 'absolute' %}
-                    <span class="date-label text-gray text-sm">
-                        {% if bookmark.web_archive_snapshot_url %}
-                        <a href="{{ bookmark.web_archive_snapshot_url }}"
-                           title="Show snapshot on the Internet Archive Wayback Machine" target="{{ link_target }}" rel="noopener">
-                        {% endif %}
-                        <span>{{ bookmark.date_added|humanize_absolute_date }}</span>
-                        {% if bookmark.web_archive_snapshot_url %}
-                        <span>∞</span>
-                        </a>
-                        {% endif %}
-                    </span>
-                    <span class="text-gray text-sm">|</span>
-                {% endif %}
                 <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}"
                    class="btn btn-link btn-sm">Edit</a>
                 {% if bookmark.is_archived %}
-                    <button type="submit" name="unarchive" value="{{ bookmark.id }}"
-                       class="btn btn-link btn-sm">Unarchive</button>
+                    <a href="{% url 'bookmarks:unarchive' bookmark.id %}?return_url={{ return_url }}"
+                       class="btn btn-link btn-sm">Unarchive</a>
                 {% else %}
-                    <button type="submit" name="archive" value="{{ bookmark.id }}"
-                       class="btn btn-link btn-sm">Archive</button>
+                    <a href="{% url 'bookmarks:archive' bookmark.id %}?return_url={{ return_url }}"
+                       class="btn btn-link btn-sm">Archive</a>
                 {% endif %}
-                <button type="submit" name="remove" value="{{ bookmark.id }}"
-                   class="btn btn-link btn-sm btn-confirmation">Remove</button>
+                <a href="{% url 'bookmarks:remove' bookmark.id %}?return_url={{ return_url }}"
+                   class="btn btn-link btn-sm"
+                   onclick="return confirm('Do you really want to delete this bookmark?')">Remove</a>
             </div>
         </li>
     {% endfor %}

bookmarks/templates/bookmarks/bulk_edit/bar.html

@@ -1,31 +0,0 @@
-<div class="bulk-edit-bar">
-    <div class="bulk-edit-actions bg-gray">
-        <label class="form-checkbox bulk-edit-all-toggle">
-            <input type="checkbox" style="display: none">
-            <i class="form-icon"></i>
-        </label>
-        {% if mode == 'archive' %}
-            <button type="submit" name="bulk_unarchive" class="btn btn-link btn-sm btn-confirmation"
-                    title="Unarchive selected bookmarks">Unarchive
-            </button>
-        {% else %}
-            <button type="submit" name="bulk_archive" class="btn btn-link btn-sm btn-confirmation"
-                    title="Archive selected bookmarks">Archive
-            </button>
-        {% endif %}
-        <span class="text-sm text-gray-dark">•</span>
-        <button type="submit" name="bulk_delete" class="btn btn-link btn-sm btn-confirmation"
-                title="Delete selected bookmarks">Delete
-        </button>
-        <span class="text-sm text-gray-dark">•</span>
-        <span class="text-sm text-gray-dark"><label for="bulk-edit-tags-input">Tags:</label></span>
-        <input id="bulk-edit-tags-input" name="bulk_tag_string" class="form-input input-sm"
-               placeholder="&nbsp;">
-        <button type="submit" name="bulk_tag" class="btn btn-link btn-sm"
-                title="Add tags to selected bookmarks">Add
-        </button>
-        <button type="submit" name="bulk_untag" class="btn btn-link btn-sm"
-                title="Remove tags from selected bookmarks">Remove
-        </button>
-    </div>
-</div>

bookmarks/templates/bookmarks/bulk_edit/state.html

@@ -1 +0,0 @@
-<input id="bulk-edit-mode" type="checkbox">

bookmarks/templates/bookmarks/bulk_edit/toggle.html

@@ -1,8 +0,0 @@
-<label for="bulk-edit-mode" class="hide-sm">
-    <span class="btn" title="Bulk edit">
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" width="20px"
-             height="20px">
-            <path d="M7 3a1 1 0 000 2h6a1 1 0 100-2H7zM4 7a1 1 0 011-1h10a1 1 0 110 2H5a1 1 0 01-1-1zM2 11a2 2 0 012-2h12a2 2 0 012 2v4a2 2 0 01-2 2H4a2 2 0 01-2-2v-4z"/>
-        </svg>
-    </span>
-</label>

bookmarks/templates/bookmarks/edit.html

@@ -7,8 +7,8 @@
             <div class="content-area-header">
                 <h2>Edit bookmark</h2>
             </div>
-            <form action="{% url 'bookmarks:edit' bookmark_id %}?return_url={{ return_url|urlencode }}" method="post" class="col-6 col-md-12" novalidate>
-                {% bookmark_form form return_url bookmark_id %}
+            <form action="{% url 'bookmarks:edit' bookmark_id %}" method="post" class="col-6 col-md-12" novalidate>
+                {% bookmark_form form all_tags return_url bookmark_id %}
             </form>
         </section>
     </div>

bookmarks/templates/bookmarks/empty_bookmarks.html

@@ -2,7 +2,7 @@
     <p class="empty-title h5">You have no bookmarks yet</p>
     <p class="empty-subtitle">
         You can get started by <a href="{% url 'bookmarks:new' %}">adding</a> bookmarks,
-        <a href="{% url 'bookmarks:settings.general' %}">importing</a> your existing bookmarks or configuring the
-        <a href="{% url 'bookmarks:settings.integrations' %}">browser extension</a> or the <a href="{% url 'bookmarks:settings.integrations' %}">bookmarklet</a>.
+        <a href="{% url 'bookmarks:settings.index' %}">importing</a> your existing bookmarks or configuring the
+        <a href="{% url 'bookmarks:settings.index' %}#bookmarklet">bookmarklet</a>.
     </p>
 </div>

bookmarks/templates/bookmarks/form.html

@@ -4,22 +4,22 @@
 <div class="bookmarks-form">
     {% csrf_token %}
     {{ form.auto_close|attr:"type:hidden" }}
+    {{ form.return_url|attr:"type:hidden" }}
     <div class="form-group {% if form.url.errors %}has-error{% endif %}">
         <label for="{{ form.url.id_for_label }}" class="form-label">URL</label>
-        {{ form.url|add_class:"form-input"|attr:"autofocus"|attr:"placeholder: " }}
+        {{ form.url|add_class:"form-input"|attr:"autofocus" }}
         {% if form.url.errors %}
             <div class="form-input-hint">
                 {{ form.url.errors }}
             </div>
         {% endif %}
         <div class="form-input-hint bookmark-exists">
-            This URL is already bookmarked. You can <a href="#">edit</a> it or you can overwrite the existing bookmark
-            by saving this form.
+            This URL is already bookmarked. You can <a href="#">edit</a> it or you can overwrite the existing bookmark by saving this form.
         </div>
     </div>
     <div class="form-group">
         <label for="{{ form.tag_string.id_for_label }}" class="form-label">Tags</label>
-        {{ form.tag_string|add_class:"form-input"|attr:"autocomplete:off" }}
+        {{ form.tag_string|add_class:"form-input" }}
         <div class="form-input-hint">
             Enter any number of tags separated by space and <strong>without</strong> the hash (#). If a tag does not
             exist it will be
@@ -30,16 +30,8 @@
     <div class="form-group has-icon-right">
         <label for="{{ form.title.id_for_label }}" class="form-label">Title</label>
         <div class="has-icon-right">
-            {{ form.title|add_class:"form-input"|attr:"autocomplete:off" }}
+            {{ form.title|add_class:"form-input" }}
             <i class="form-icon loading"></i>
-            <a class="btn btn-link form-icon" title="Edit title from website">
-                <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor">
-                    <path d="M17.414 2.586a2 2 0 00-2.828 0L7 10.172V13h2.828l7.586-7.586a2 2 0 000-2.828z"/>
-                    <path fill-rule="evenodd"
-                          d="M2 6a2 2 0 012-2h4a1 1 0 010 2H4v10h10v-4a1 1 0 112 0v4a2 2 0 01-2 2H4a2 2 0 01-2-2V6z"
-                          clip-rule="evenodd"/>
-                </svg>
-            </a>
         </div>
         <div class="form-input-hint">
             Optional, leave empty to use title from website.
@@ -51,14 +43,6 @@
         <div class="has-icon-right">
             {{ form.description|add_class:"form-input"|attr:"rows:4" }}
             <i class="form-icon loading"></i>
-            <a class="btn btn-link form-icon" title="Edit description from website">
-                <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor">
-                    <path d="M17.414 2.586a2 2 0 00-2.828 0L7 10.172V13h2.828l7.586-7.586a2 2 0 000-2.828z"/>
-                    <path fill-rule="evenodd"
-                          d="M2 6a2 2 0 012-2h4a1 1 0 010 2H4v10h10v-4a1 1 0 112 0v4a2 2 0 01-2 2H4a2 2 0 01-2-2V6z"
-                          clip-rule="evenodd"/>
-                </svg>
-            </a>
         </div>
         <div class="form-input-hint">
             Optional, leave empty to use description from website.
@@ -80,7 +64,8 @@
     <script type="application/javascript">
         const wrapper = document.createElement('div');
         const tagInput = document.getElementById('{{ form.tag_string.id_for_label }}');
-        const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')
+        const allTagsString = '{{ all_tags }}';
+        const allTags = allTagsString.split(' ');
 
         new linkding.TagAutoComplete({
             target: wrapper,
@@ -88,7 +73,7 @@
                 id: '{{ form.tag_string.id_for_label }}',
                 name: '{{ form.tag_string.name }}',
                 value: tagInput.value,
-                apiClient: apiClient
+                tags: allTags
             }
         });
 
@@ -98,72 +83,49 @@
         /**
          * - Pre-fill title and description placeholders with metadata from website as soon as URL changes
          * - Show hint if URL is already bookmarked
-         * - Setup buttons that allow editing of scraped website values
          */
         (function init() {
             const urlInput = document.getElementById('{{ form.url.id_for_label }}');
             const titleInput = document.getElementById('{{ form.title.id_for_label }}');
             const descriptionInput = document.getElementById('{{ form.description.id_for_label }}');
-            const editedBookmarkId = {{ bookmark_id }};
+            const editedBookmarkId = {{ bookmark_id }}
 
-            function toggleLoadingIcon(input, show) {
-                const icon = input.parentNode.querySelector('i.form-icon');
-                icon.style['visibility'] = show ? 'visible' : 'hidden';
-            }
-
-            function updatePlaceholder(input, value) {
-                if (value) {
-                    input.setAttribute('placeholder', value);
-                } else {
-                    input.removeAttribute('placeholder');
-                }
-            }
+            urlInput.addEventListener('input', checkUrl);
 
             function checkUrl() {
-                toggleLoadingIcon(titleInput, true);
-                toggleLoadingIcon(descriptionInput, true);
-                updatePlaceholder(titleInput, null);
-                updatePlaceholder(descriptionInput, null);
+                toggleIcon(titleInput, true);
+                toggleIcon(descriptionInput, true);
 
                 const websiteUrl = encodeURIComponent(urlInput.value);
-                const requestUrl = `{% url 'bookmarks:api-root' %}bookmarks/check?url=${websiteUrl}`;
+                const requestUrl = `{% url 'bookmarks:api.check_url' %}?url=${websiteUrl}`;
                 fetch(requestUrl)
                     .then(response => response.json())
                     .then(data => {
-                        const metadata = data.metadata;
-                        updatePlaceholder(titleInput, metadata.title);
-                        updatePlaceholder(descriptionInput, metadata.description);
-                        toggleLoadingIcon(titleInput, false);
-                        toggleLoadingIcon(descriptionInput, false);
+                        const metadata = data.metadata
+                        titleInput.setAttribute('placeholder', metadata.title || '');
+                        descriptionInput.setAttribute('placeholder', metadata.description || '');
+                        toggleIcon(titleInput, false);
+                        toggleIcon(descriptionInput, false);
 
                         // Display hint if URL is already bookmarked
-                        const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists');
-                        const editExistingBookmarkLink = bookmarkExistsHint.querySelector('a');
+                        const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists')
+                        const editExistingBookmarkLink = bookmarkExistsHint.querySelector('a')
 
-                        if (data.bookmark && data.bookmark.id !== editedBookmarkId) {
-                            bookmarkExistsHint.style['display'] = 'block';
-                            editExistingBookmarkLink.href = data.bookmark.edit_url;
+                        if(data.bookmark && data.bookmark.id !== editedBookmarkId) {
+                            bookmarkExistsHint.style['visibility'] = 'visible'
+                            editExistingBookmarkLink.href = data.bookmark.edit_url
                         } else {
-                            bookmarkExistsHint.style['display'] = 'none';
+                            bookmarkExistsHint.style['visibility'] = 'hidden'
                         }
                     });
             }
 
-            function setupEditAutoValueButton(input) {
-                const editAutoValueButton = input.parentNode.querySelector('.btn.form-icon');
-                if (!editAutoValueButton) return;
-                editAutoValueButton.addEventListener('click', function (event) {
-                    event.preventDefault();
-                    input.value = input.getAttribute('placeholder');
-                    input.focus();
-                    input.select();
-                });
+            function toggleIcon(input, show) {
+                const icon = input.parentNode.querySelector('i.form-icon');
+                icon.style['visibility'] = show ? 'visible' : 'hidden';
             }
 
             if (urlInput.value) checkUrl();
-            urlInput.addEventListener('input', checkUrl);
-            setupEditAutoValueButton(titleInput);
-            setupEditAutoValueButton(descriptionInput);
         })();
     </script>
 </div>

bookmarks/templates/bookmarks/index.html

@@ -4,9 +4,6 @@
 {% load bookmarks %}
 
 {% block content %}
-
-    {% include 'bookmarks/bulk_edit/state.html' %}
-
     <div class="bookmarks-page columns">
 
         {# Bookmark list #}
@@ -15,20 +12,13 @@
                 <h2>Bookmarks</h2>
                 <div class="spacer"></div>
                 {% bookmark_search query tags %}
-                {% include 'bookmarks/bulk_edit/toggle.html' %}
             </div>
 
-            <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ return_url }}"
-                  method="post">
-                {% csrf_token %}
-                {% include 'bookmarks/bulk_edit/bar.html' with mode='default' %}
-
-                {% if empty %}
-                    {% include 'bookmarks/empty_bookmarks.html' %}
-                {% else %}
-                    {% bookmark_list bookmarks return_url link_target %}
-                {% endif %}
-            </form>
+            {% if empty %}
+                {% include 'bookmarks/empty_bookmarks.html' %}
+            {% else %}
+                {% bookmark_list bookmarks return_url %}
+            {% endif %}
         </section>
 
         {# Tag list #}
@@ -41,6 +31,4 @@
     </div>
 
     <script src="{% static "bundle.js" %}"></script>
-    <script src="{% static "shared.js" %}"></script>
-    <script src="{% static "bulk_edit.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/layout.html

@@ -2,8 +2,7 @@
 {% load sass_tags %}
 
 <!DOCTYPE html>
-{# Use data attributes as storage for access in static scripts #}
-<html lang="en" data-api-base-url="{% url 'bookmarks:api-root' %}">
+<html lang="en">
 <head>
     <meta charset="UTF-8">
     <link rel="icon" href="{% static 'favicon.png' %}"/>
@@ -13,45 +12,23 @@
     <meta name="author" content="Sascha Ißbrücker">
     <title>linkding</title>
     {# Include SASS styles, files are resolved from bookmarks/styles #}
-    {# Include specific theme variant based on user profile setting #}
-    {% if request.user.profile.theme == 'light' %}
-        <link href="{% sass_src 'theme-light.scss' %}" rel="stylesheet" type="text/css"/>
-    {% elif request.user.profile.theme == 'dark' %}
-        <link href="{% sass_src 'theme-dark.scss' %}" rel="stylesheet" type="text/css"/>
-    {% else %}
-        {# Use auto theme as fallback #}
-        <link href="{% sass_src 'theme-dark.scss' %}" rel="stylesheet" type="text/css"
-              media="(prefers-color-scheme: dark)"/>
-        <link href="{% sass_src 'theme-light.scss' %}" rel="stylesheet" type="text/css"
-              media="(prefers-color-scheme: light)"/>
-    {% endif %}
+    <link href="{% sass_src 'index.scss' %}" rel="stylesheet" type="text/css"/>
 </head>
 <body>
-<header>
-    {% if has_toasts %}
-    <div class="toasts container grid-lg">
-        {% for toast in toast_messages %}
-            <div class="toast">
-                {{ toast.message }}
-                <a href="{% url 'bookmarks:toasts.acknowledge' toast.id %}?return_url={{ request.path | urlencode }}" class="btn btn-clear float-right"></a>
-            </div>
-        {% endfor %}
-    </div>
-    {% endif %}
-    <div class="navbar container grid-lg">
+<header class="navbar container grid-lg">
+    <section class="navbar-section">
+        <a href="/" class="navbar-brand text-bold">
+            <i class="logo icon icon-link s-circle"></i>
+
+            <h1>linkding</h1>
+        </a>
+    </section>
+    {# Only show nav items menu when logged in #}
+    {% if request.user.is_authenticated %}
         <section class="navbar-section">
-            <a href="/" class="navbar-brand text-bold">
-                <img class="logo" src="{% static 'logo.png' %}" alt="Application logo">
-                <h1>linkding</h1>
-            </a>
+            {% include 'bookmarks/nav_menu.html' %}
         </section>
-        {# Only show nav items menu when logged in #}
-        {% if request.user.is_authenticated %}
-            <section class="navbar-section">
-                {% include 'bookmarks/nav_menu.html' %}
-            </section>
-        {% endif %}
-    </div>
+    {% endif %}
 </header>
 <div class="content container grid-lg">
     {% block content %}

bookmarks/templates/bookmarks/nav_menu.html

@@ -7,16 +7,12 @@
 </div>
 {# Menu drop-down for smaller devices #}
 <div class="show-md">
-    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary">
-        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" style="width: 24px; height: 24px">
-            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6" />
-        </svg>
+    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">
+        <i class="icon icon-plus"></i>
     </a>
     <div class="dropdown dropdown-right">
         <a href="#" id="mobile-nav-menu-trigger" class="btn btn-link dropdown-toggle" tabindex="0">
-            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" style="width: 24px; height: 24px">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h16M4 18h16" />
-            </svg>
+            <i class="icon icon-menu icon-2x"></i>
         </a>
         <!-- menu component -->
         <ul class="menu">
@@ -50,4 +46,4 @@
     mobileNavMenuTrigger.addEventListener('blur', function () {
         document.removeEventListener('click', mobileNavMenuOutsideClickHandler);
     })
-</script>
+</script>

bookmarks/templates/bookmarks/new.html

@@ -8,7 +8,7 @@
                 <h2>New bookmark</h2>
             </div>
             <form action="{% url 'bookmarks:new' %}" method="post" class="col-6 col-md-12" novalidate>
-                {% bookmark_form form return_url auto_close=auto_close %}
+                {% bookmark_form form all_tags return_url auto_close=auto_close %}
             </form>
         </section>
     </div>

bookmarks/templates/bookmarks/tag_cloud.html

@@ -7,13 +7,13 @@
                 {# Highlight first char of first tag in group #}
                 {% if forloop.counter == 1 %}
                     <a href="?{% append_query_param q=tag.name|hash_tag %}"
-                       class="mr-2" data-is-tag-item>
+                       class="mr-2">
                         <span class="highlight-char">{{ tag.name|first_char }}</span><span>{{ tag.name|remaining_chars:1 }}</span>
                     </a>
                 {% else %}
                     {# Render remaining tags normally #}
                     <a href="?{% append_query_param q=tag.name|hash_tag %}"
-                       class="mr-2" data-is-tag-item>
+                       class="mr-2">
                         <span>{{ tag.name }}</span>
                     </a>
                 {% endif %}

bookmarks/templates/registration/login.html

@@ -20,11 +20,11 @@
                     {% endif %}
                     <div class="form-group">
                         <label class="form-label" for="{{ form.username.id_for_label }}">Username</label>
-                        {{ form.username|add_class:'form-input'|attr:"placeholder: " }}
+                        {{ form.username|add_class:'form-input' }}
                     </div>
                     <div class="form-group">
                         <label class="form-label" for="{{ form.password.id_for_label }}">Password</label>
-                        {{ form.password|add_class:'form-input'|attr:"placeholder: " }}
+                        {{ form.password|add_class:'form-input' }}
                     </div>
 
                     <br/>

bookmarks/templates/registration/password_change_done.html

@@ -1,21 +0,0 @@
-{% extends 'bookmarks/layout.html' %}
-{% load widget_tweaks %}
-
-{% block title %}Password changed{% endblock %}
-
-{% block content %}
-
-    <div class="auth-page">
-        <div class="columns">
-            <section class="content-area column col-5 col-md-12">
-                <div class="content-area-header">
-                    <h2>Password Changed</h2>
-                </div>
-                <p class="text-success">
-                    Your password was changed successfully.
-                </p>
-            </section>
-        </div>
-    </div>
-
-{% endblock %}

bookmarks/templates/registration/password_change_form.html

@@ -1,55 +0,0 @@
-{% extends 'bookmarks/layout.html' %}
-{% load widget_tweaks %}
-
-{% block title %}Change Password{% endblock %}
-
-{% block content %}
-
-    <div class="auth-page">
-        <div class="columns">
-            <section class="content-area column col-5 col-md-12">
-                <div class="content-area-header">
-                    <h2>Change Password</h2>
-                </div>
-                <form method="post" action="{% url 'change_password' %}">
-                    {% csrf_token %}
-                    <div class="form-group {% if form.old_password.errors %}has-error{% endif %}">
-                        <label class="form-label" for="{{ form.old_password.id_for_label }}">Old password</label>
-                        {{ form.old_password|add_class:'form-input'|attr:"placeholder: " }}
-                        {% if form.old_password.errors %}
-                            <div class="form-input-hint">
-                                {{ form.old_password.errors }}
-                            </div>
-                        {% endif %}
-                    </div>
-                    <div class="form-group {% if form.new_password1.errors %}has-error{% endif %}">
-                        <label class="form-label" for="{{ form.new_password1.id_for_label }}">New password</label>
-                        {{ form.new_password1|add_class:'form-input'|attr:"placeholder: " }}
-                        {% if form.new_password1.errors %}
-                            <div class="form-input-hint">
-                                {{ form.new_password1.errors }}
-                            </div>
-                        {% endif %}
-                    </div>
-                    <div class="form-group {% if form.new_password2.errors %}has-error{% endif %}">
-                        <label class="form-label" for="{{ form.new_password2.id_for_label }}">Confirm new password</label>
-                        {{ form.new_password2|add_class:'form-input'|attr:"placeholder: " }}
-                        {% if form.new_password2.errors %}
-                            <div class="form-input-hint">
-                                {{ form.new_password2.errors }}
-                            </div>
-                        {% endif %}
-                    </div>
-
-                    <br/>
-                    <div class="columns">
-                        <div class="column col-3">
-                            <input type="submit" value="Change Password" class="btn btn-primary">
-                        </div>
-                    </div>
-                </form>
-            </section>
-        </div>
-    </div>
-
-{% endblock %}

bookmarks/templates/settings/general.html

@@ -1,111 +0,0 @@
-{% extends "bookmarks/layout.html" %}
-{% load widget_tweaks %}
-
-{% block content %}
-    <div class="settings-page">
-
-        {% include 'settings/nav.html' %}
-
-        {# Profile section #}
-        <section class="content-area">
-            <h2>Profile</h2>
-            <p>
-                <a href="{% url 'change_password' %}">Change password</a>
-            </p>
-            <form action="{% url 'bookmarks:settings.general' %}" method="post" novalidate>
-                {% csrf_token %}
-                <div class="form-group">
-                    <label for="{{ form.theme.id_for_label }}" class="form-label">Theme</label>
-                    {{ form.theme|add_class:"form-select col-2 col-sm-12" }}
-                    <div class="form-input-hint">
-                      Whether to use a light or dark theme, or automatically adjust the theme based on your system's settings.
-                    </div>
-                </div>
-                <div class="form-group">
-                    <label for="{{ form.bookmark_date_display.id_for_label }}" class="form-label">Bookmark date format</label>
-                    {{ form.bookmark_date_display|add_class:"form-select col-2 col-sm-12" }}
-                    <div class="form-input-hint">
-                      Whether to show bookmark dates as relative (how long ago), or as absolute dates. Alternatively the date can be hidden.
-                    </div>
-                </div>
-                <div class="form-group">
-                    <label for="{{ form.bookmark_link_target.id_for_label }}" class="form-label">Open bookmarks in</label>
-                    {{ form.bookmark_link_target|add_class:"form-select col-2 col-sm-12" }}
-                    <div class="form-input-hint">
-                      Whether to open bookmarks a new page or in the same page.
-                    </div>
-                </div>
-                <div class="form-group">
-                    <label for="{{ form.web_archive_integration.id_for_label }}" class="form-label">Internet Archive
-                        integration</label>
-                    {{ form.web_archive_integration|add_class:"form-select col-2 col-sm-12" }}
-                    <div class="form-input-hint">
-                      Enabling this feature will automatically create snapshots of bookmarked websites on the <a
-                        href="https://web.archive.org/" target="_blank" rel="noopener">Internet Archive Wayback
-                      Machine</a>. This allows
-                      to preserve, and later access, the website as it was at the point in time it was bookmarked, in
-                      case it goes offline or its content is modified.
-                    </div>
-                </div>
-                <div class="form-group">
-                    <input type="submit" value="Save" class="btn btn-primary mt-2">
-                </div>
-            </form>
-        </section>
-
-        {# Import section #}
-        <section class="content-area">
-            <h2>Import</h2>
-            <p>Import bookmarks and tags in the Netscape HTML format. This will execute a sync where new bookmarks are
-                added and existing ones are updated.</p>
-            <form method="post" enctype="multipart/form-data" action="{% url 'bookmarks:settings.import' %}">
-                {% csrf_token %}
-                <div class="form-group">
-                    <div class="input-group col-8 col-md-12">
-                        <input class="form-input" type="file" name="import_file">
-                        <input type="submit" class="input-group-btn col-2 btn btn-primary" value="Upload">
-                    </div>
-                    {% if import_success_message %}
-                        <div class="has-success">
-                            <p class="form-input-hint">
-                                {{ import_success_message }}
-                            </p>
-                        </div>
-                    {% endif %}
-                    {% if import_errors_message %}
-                        <div class="has-error">
-                            <p class="form-input-hint">
-                                {{ import_errors_message }}
-                            </p>
-                        </div>
-                    {% endif %}
-                </div>
-            </form>
-        </section>
-
-        {# Export section #}
-        <section class="content-area">
-            <h2>Export</h2>
-            <p>Export all bookmarks in Netscape HTML format.</p>
-            <a class="btn btn-primary" href="{% url 'bookmarks:settings.export' %}">Download (.html)</a>
-            {% if export_error %}
-                <div class="has-error">
-                    <p class="form-input-hint">
-                        {{ export_error }}
-                    </p>
-                </div>
-            {% endif %}
-        </section>
-
-        {# About section #}
-        <section class="content-area">
-            <h2>About</h2>
-            <p>Version: {{ app_version }}</p>
-            <p>
-                Code: <a href="https://github.com/sissbruecker/linkding/"
-                    target="_blank">GitHub</a>
-            </p>
-        </section>
-    </div>
-
-{% endblock %}

bookmarks/templates/settings/index.html

@@ -0,0 +1,91 @@
+{% extends "bookmarks/layout.html" %}
+
+{% block content %}
+    <div class="settings-page">
+
+        {# Import section #}
+        <section class="content-area">
+            <div class="content-area-header">
+                <h2>Import</h2>
+            </div>
+            <p>Import bookmarks and tags in the Netscape HTML format. This will execute a sync where new bookmarks are
+                added and existing ones are updated.</p>
+            <form method="post" enctype="multipart/form-data" action="{% url 'bookmarks:settings.import' %}">
+                {% csrf_token %}
+                <div class="form-group">
+                    <div class="input-group col-8 col-md-12">
+                        <input class="form-input" type="file" name="import_file">
+                        <input type="submit" class="input-group-btn col-2 btn btn-primary" value="Upload">
+                    </div>
+                    {% if import_success_message %}
+                        <div class="has-success">
+                            <p class="form-input-hint">
+                                {{ import_success_message }}
+                            </p>
+                        </div>
+                    {% endif %}
+                    {% if import_errors_message %}
+                        <div class="has-error">
+                            <p class="form-input-hint">
+                                {{ import_errors_message }}
+                            </p>
+                        </div>
+                    {% endif %}
+                </div>
+            </form>
+        </section>
+
+        {# Export section #}
+        <section class="content-area">
+            <div class="content-area-header">
+                <h2>Export</h2>
+            </div>
+            <p>Export all bookmarks in Netscape HTML format.</p>
+            <a class="btn btn-primary" href="{% url 'bookmarks:settings.export' %}">Download (.html)</a>
+            {% if export_error %}
+                <div class="has-error">
+                    <p class="form-input-hint">
+                        {{ export_error }}
+                    </p>
+                </div>
+            {% endif %}
+        </section>
+
+        {# Integrations section #}
+        <section class="content-area">
+            <div class="content-area-header">
+                <a id="bookmarklet"><h2>Bookmarklet</h2></a>
+            </div>
+            <p>The bookmarklet is a quick way to add new bookmarks without opening the linkding application
+                first. Here's how it works:</p>
+            <ul>
+                <li>Drag the bookmarklet below into your browsers bookmark bar / toolbar</li>
+                <li>Open the website that you want to bookmark</li>
+                <li>Click the bookmarklet in your browsers toolbar</li>
+                <li>linkding opens in a new window  or tab and allows you to add a bookmark for the site</li>
+                <li>After saving the bookmark the linkding window closes and you are back on your website</li>
+            </ul>
+            <p>Drag the following bookmarklet to your browsers toolbar:</p>
+            <a href="javascript: {% include 'bookmarks/bookmarklet.js' %}"
+               class="btn btn-primary">📎 Add bookmark</a>
+        </section>
+
+        {# API token section #}
+        <section class="content-area">
+            <div class="content-area-header">
+                <h2>API Token</h2>
+            </div>
+            <p>The following token can be used to authenticate 3rd-party applications against the REST API:</p>
+            <div class="form-group">
+                <div class="columns">
+                    <div class="column col-6 col-md-12">
+                        <input class="form-input" value="{{ api_token }}" disabled>
+                    </div>
+                </div>
+            </div>
+            <p><strong>Please treat this token as you would any other credential.</strong> Any party with access to this token can access and manage all your bookmarks.</p>
+        </section>
+
+    </div>
+
+{% endblock %}

bookmarks/templates/settings/integrations.html

@@ -1,46 +0,0 @@
-{% extends "bookmarks/layout.html" %}
-
-{% block content %}
-    <div class="settings-page">
-
-        {% include 'settings/nav.html' %}
-
-        <section class="content-area">
-            <h2>Browser Extension</h2>
-            <p>The browser extension allows you to quickly add new bookmarks without leaving the page that you are on. The extension is available in the official extension stores for:</p>
-            <ul>
-                <li><a href="https://addons.mozilla.org/de/firefox/addon/linkding-extension/" target="_blank">Firefox</a></li>
-                <li><a href="https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe" target="_blank">Chrome</a></li>
-            </ul>
-            <p>The extension is <a href="https://github.com/sissbruecker/linkding-extension" target="_blank">open source</a> as well, which enables you to build and manually load it into any browser that supports Chrome extensions.</p>
-            <h2>Bookmarklet</h2>
-            <p>The bookmarklet is an alternative, cross-browser way to quickly add new bookmarks without opening the linkding application
-                first. Here's how it works:</p>
-            <ul>
-                <li>Drag the bookmarklet below into your browsers bookmark bar / toolbar</li>
-                <li>Open the website that you want to bookmark</li>
-                <li>Click the bookmarklet in your browsers toolbar</li>
-                <li>linkding opens in a new window or tab and allows you to add a bookmark for the site</li>
-                <li>After saving the bookmark the linkding window closes and you are back on your website</li>
-            </ul>
-            <p>Drag the following bookmarklet to your browsers toolbar:</p>
-            <a href="javascript: {% include 'bookmarks/bookmarklet.js' %}"
-               class="btn btn-primary">📎 Add bookmark</a>
-        </section>
-
-        <section class="content-area">
-            <h2>REST API</h2>
-            <p>The following token can be used to authenticate 3rd-party applications against the REST API:</p>
-            <div class="form-group">
-                <div class="columns">
-                    <div class="column col-6 col-md-12">
-                        <input class="form-input" value="{{ api_token }}" readonly>
-                    </div>
-                </div>
-            </div>
-            <p><strong>Please treat this token as you would any other credential.</strong> Any party with access to this
-                token can access and manage all your bookmarks.</p>
-            <p>If you think that a token was compromised you can revoke (delete) it in the <a href="{% url 'admin:authtoken_tokenproxy_changelist' %}">admin panel</a>. After deleting the token, a new one will be generated when you reload this settings page.</p>
-        </section>
-    </div>
-{% endblock %}

bookmarks/templates/settings/nav.html

@@ -1,22 +0,0 @@
-{% url 'bookmarks:settings.index' as index_url %}
-{% url 'bookmarks:settings.general' as general_url %}
-{% url 'bookmarks:settings.integrations' as integrations_url %}
-
-<ul class="tab tab-block">
-    <li class="tab-item {% if request.get_full_path == index_url or request.get_full_path == general_url%}active{% endif %}">
-        <a href="{% url 'bookmarks:settings.general' %}">General</a>
-    </li>
-    <li class="tab-item {% if request.get_full_path == integrations_url %}active{% endif %}">
-        <a href="{% url 'bookmarks:settings.integrations' %}">Integrations</a>
-    </li>
-    <li class="tab-item tooltip tooltip-bottom" data-tooltip="The admin panel provides additional features &#010; such as user management and bulk operations.">
-        <a href="{% url 'admin:index' %}" target="_blank">
-            <span>Admin</span>
-            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" class="ml-1" style="width: 1.2em; height: 1.2em; vertical-align: -0.2em;">
-                <path d="M11 3a1 1 0 100 2h2.586l-6.293 6.293a1 1 0 101.414 1.414L15 6.414V9a1 1 0 102 0V4a1 1 0 00-1-1h-5z" />
-                <path d="M5 5a2 2 0 00-2 2v8a2 2 0 002 2h8a2 2 0 002-2v-3a1 1 0 10-2 0v3H5V7h3a1 1 0 000-2H5z" />
-            </svg>
-        </a>
-    </li>
-</ul>
-<br>

bookmarks/templatetags/bookmarks.py

@@ -9,10 +9,15 @@ register = template.Library()
 
 
 @register.inclusion_tag('bookmarks/form.html', name='bookmark_form')
-def bookmark_form(form: BookmarkForm, cancel_url: str, bookmark_id: int = 0, auto_close: bool = False):
+def bookmark_form(form: BookmarkForm, all_tags: List[Tag], cancel_url: str, bookmark_id: int = 0, auto_close: bool = False):
+
+    all_tag_names = [tag.name for tag in all_tags]
+    all_tags_string = build_tag_string(all_tag_names, ' ')
+
     return {
         'form': form,
         'auto_close': auto_close,
+        'all_tags': all_tags_string,
         'bookmark_id': bookmark_id,
         'cancel_url': cancel_url
     }
@@ -51,12 +56,10 @@ def tag_cloud(context, tags: List[Tag]):
 
 
 @register.inclusion_tag('bookmarks/bookmark_list.html', name='bookmark_list', takes_context=True)
-def bookmark_list(context, bookmarks: Page, return_url: str, link_target: str = '_blank'):
+def bookmark_list(context, bookmarks: Page, return_url: str):
     return {
-        'request': context['request'],
         'bookmarks': bookmarks,
-        'return_url': return_url,
-        'link_target': link_target,
+        'return_url': return_url
     }
 
 

bookmarks/templatetags/shared.py

@@ -1,7 +1,5 @@
 from django import template
 
-from bookmarks import utils
-
 register = template.Library()
 
 
@@ -45,17 +43,3 @@ def first_char(text):
 @register.filter(name='remaining_chars')
 def remaining_chars(text, index):
     return text[index:]
-
-
-@register.filter(name='humanize_absolute_date')
-def humanize_absolute_date(value):
-    if value in (None, ''):
-        return ''
-    return utils.humanize_absolute_date(value)
-
-
-@register.filter(name='humanize_relative_date')
-def humanize_relative_date(value):
-    if value in (None, ''):
-        return ''
-    return utils.humanize_relative_date(value)

bookmarks/tests/helpers.py

@@ -1,133 +0,0 @@
-import random
-import logging
-
-from django.contrib.auth.models import User
-from django.utils import timezone
-from django.utils.crypto import get_random_string
-from rest_framework import status
-from rest_framework.test import APITestCase
-
-from bookmarks.models import Bookmark, Tag
-
-
-class BookmarkFactoryMixin:
-    user = None
-
-    def get_or_create_test_user(self):
-        if self.user is None:
-            self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
-
-        return self.user
-
-    def setup_bookmark(self,
-                       is_archived: bool = False,
-                       tags=None,
-                       user: User = None,
-                       url: str = '',
-                       title: str = '',
-                       description: str = '',
-                       website_title: str = '',
-                       website_description: str = '',
-                       web_archive_snapshot_url: str = '',
-                       ):
-        if tags is None:
-            tags = []
-        if user is None:
-            user = self.get_or_create_test_user()
-        if not url:
-            unique_id = get_random_string(length=32)
-            url = 'https://example.com/' + unique_id
-        bookmark = Bookmark(
-            url=url,
-            title=title,
-            description=description,
-            website_title=website_title,
-            website_description=website_description,
-            date_added=timezone.now(),
-            date_modified=timezone.now(),
-            owner=user,
-            is_archived=is_archived,
-            web_archive_snapshot_url=web_archive_snapshot_url,
-        )
-        bookmark.save()
-        for tag in tags:
-            bookmark.tags.add(tag)
-        bookmark.save()
-        return bookmark
-
-    def setup_tag(self, user: User = None, name: str = ''):
-        if user is None:
-            user = self.get_or_create_test_user()
-        if not name:
-            name = get_random_string(length=32)
-        tag = Tag(name=name, date_added=timezone.now(), owner=user)
-        tag.save()
-        return tag
-
-
-class LinkdingApiTestCase(APITestCase):
-    def get(self, url, expected_status_code=status.HTTP_200_OK):
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, expected_status_code)
-        return response
-
-    def post(self, url, data=None, expected_status_code=status.HTTP_200_OK):
-        response = self.client.post(url, data, format='json')
-        self.assertEqual(response.status_code, expected_status_code)
-        return response
-
-    def put(self, url, data=None, expected_status_code=status.HTTP_200_OK):
-        response = self.client.put(url, data, format='json')
-        self.assertEqual(response.status_code, expected_status_code)
-        return response
-
-    def delete(self, url, expected_status_code=status.HTTP_200_OK):
-        response = self.client.delete(url)
-        self.assertEqual(response.status_code, expected_status_code)
-        return response
-
-
-_words = [
-    'quasi',
-    'consequatur',
-    'necessitatibus',
-    'debitis',
-    'quod',
-    'vero',
-    'qui',
-    'commodi',
-    'quod',
-    'odio',
-    'aliquam',
-    'veniam',
-    'architecto',
-    'consequatur',
-    'autem',
-    'qui',
-    'iste',
-    'asperiores',
-    'soluta',
-    'et',
-]
-
-
-def random_sentence(num_words: int = None, including_word: str = ''):
-    if num_words is None:
-        num_words = random.randint(5, 10)
-    selected_words = random.choices(_words, k=num_words)
-    if including_word:
-        selected_words.append(including_word)
-    random.shuffle(selected_words)
-
-    return ' '.join(selected_words)
-
-
-def disable_logging(f):
-    def wrapper(*args):
-        logging.disable(logging.CRITICAL)
-        result = f(*args)
-        logging.disable(logging.NOTSET)
-
-        return result
-
-    return wrapper

bookmarks/tests/resources/simple_valid_import_file.html

@@ -1,20 +0,0 @@
-<!DOCTYPE NETSCAPE-Bookmark-file-1>
-
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
-
-<TITLE>Bookmarks</TITLE>
-
-<H1>Bookmarks</H1>
-
-<DL><p>
-
-    <DT><A HREF="https://example.com/1" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag1">test title 1</A>
-    <DD>test description 1
-
-    <DT><A HREF="https://example.com/2" ADD_DATE="1616337559000" PRIVATE="0" TOREAD="0" TAGS="tag2">test title 2</A>
-    <DD>test description 2
-
-    <DT><A HREF="https://example.com/3" ADD_DATE="1616337559000000" PRIVATE="0" TOREAD="0" TAGS="tag3">test title 3</A>
-    <DD>test description 3
-
-</DL><p>

bookmarks/tests/resources/simple_valid_import_file_with_one_invalid_bookmark.html

@@ -1,20 +0,0 @@
-<!DOCTYPE NETSCAPE-Bookmark-file-1>
-
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
-
-<TITLE>Bookmarks</TITLE>
-
-<H1>Bookmarks</H1>
-
-<DL><p>
-
-    <DT><A HREF="https://example.com/1" ADD_DATE="invaliddate" PRIVATE="0" TOREAD="0" TAGS="tag1">test title 1</A>
-    <DD>test description 1
-
-    <DT><A HREF="https://example.com/2" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag2">test title 2</A>
-    <DD>test description 2
-
-    <DT><A HREF="https://example.com/3" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">test title 3</A>
-    <DD>test description 3
-
-</DL><p>

bookmarks/tests/test_bookmark_action_view.py

@@ -1,322 +0,0 @@
-from django.contrib.auth.models import User
-from django.forms import model_to_dict
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.models import Bookmark
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkActionViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def assertBookmarksAreUnmodified(self, bookmarks: [Bookmark]):
-        self.assertEqual(len(bookmarks), Bookmark.objects.count())
-
-        for bookmark in bookmarks:
-            self.assertEqual(model_to_dict(bookmark), model_to_dict(Bookmark.objects.get(id=bookmark.id)))
-
-    def test_archive_should_archive_bookmark(self):
-        bookmark = self.setup_bookmark()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'archive': [bookmark.id],
-        })
-
-        bookmark.refresh_from_db()
-
-        self.assertTrue(bookmark.is_archived)
-
-    def test_can_only_archive_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark = self.setup_bookmark(user=other_user)
-
-        response = self.client.post(reverse('bookmarks:action'), {
-            'archive': [bookmark.id],
-        })
-
-        bookmark.refresh_from_db()
-
-        self.assertEqual(response.status_code, 404)
-        self.assertFalse(bookmark.is_archived)
-
-    def test_unarchive_should_unarchive_bookmark(self):
-        bookmark = self.setup_bookmark(is_archived=True)
-
-        self.client.post(reverse('bookmarks:action'), {
-            'unarchive': [bookmark.id],
-        })
-        bookmark.refresh_from_db()
-
-        self.assertFalse(bookmark.is_archived)
-
-    def test_unarchive_can_only_archive_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark = self.setup_bookmark(is_archived=True, user=other_user)
-
-        response = self.client.post(reverse('bookmarks:action'), {
-            'unarchive': [bookmark.id],
-        })
-        bookmark.refresh_from_db()
-
-        self.assertEqual(response.status_code, 404)
-        self.assertTrue(bookmark.is_archived)
-
-    def test_delete_should_delete_bookmark(self):
-        bookmark = self.setup_bookmark()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'remove': [bookmark.id],
-        })
-
-        self.assertEqual(Bookmark.objects.count(), 0)
-
-    def test_delete_can_only_delete_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark = self.setup_bookmark(user=other_user)
-
-        response = self.client.post(reverse('bookmarks:action'), {
-            'remove': [bookmark.id],
-        })
-        self.assertEqual(response.status_code, 404)
-        self.assertTrue(Bookmark.objects.filter(id=bookmark.id).exists())
-
-    def test_bulk_archive(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_archive': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_can_only_bulk_archive_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark(user=other_user)
-        bookmark2 = self.setup_bookmark(user=other_user)
-        bookmark3 = self.setup_bookmark(user=other_user)
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_archive': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_bulk_unarchive(self):
-        bookmark1 = self.setup_bookmark(is_archived=True)
-        bookmark2 = self.setup_bookmark(is_archived=True)
-        bookmark3 = self.setup_bookmark(is_archived=True)
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_unarchive': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_can_only_bulk_unarchive_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark(is_archived=True, user=other_user)
-        bookmark2 = self.setup_bookmark(is_archived=True, user=other_user)
-        bookmark3 = self.setup_bookmark(is_archived=True, user=other_user)
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_unarchive': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_bulk_delete(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_delete': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
-
-    def test_can_only_bulk_delete_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark(user=other_user)
-        bookmark2 = self.setup_bookmark(user=other_user)
-        bookmark3 = self.setup_bookmark(user=other_user)
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_delete': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark1.id).first())
-        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark2.id).first())
-        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark3.id).first())
-
-    def test_bulk_tag(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_tag': [''],
-            'bulk_tag_string': [f'{tag1.name} {tag2.name}'],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
-
-    def test_can_only_bulk_tag_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark(user=other_user)
-        bookmark2 = self.setup_bookmark(user=other_user)
-        bookmark3 = self.setup_bookmark(user=other_user)
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_tag': [''],
-            'bulk_tag_string': [f'{tag1.name} {tag2.name}'],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [])
-        self.assertCountEqual(bookmark2.tags.all(), [])
-        self.assertCountEqual(bookmark3.tags.all(), [])
-
-    def test_bulk_untag(self):
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_untag': [''],
-            'bulk_tag_string': [f'{tag1.name} {tag2.name}'],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [])
-        self.assertCountEqual(bookmark2.tags.all(), [])
-        self.assertCountEqual(bookmark3.tags.all(), [])
-
-    def test_can_only_bulk_untag_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark1 = self.setup_bookmark(tags=[tag1, tag2], user=other_user)
-        bookmark2 = self.setup_bookmark(tags=[tag1, tag2], user=other_user)
-        bookmark3 = self.setup_bookmark(tags=[tag1, tag2], user=other_user)
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bulk_untag': [''],
-            'bulk_tag_string': [f'{tag1.name} {tag2.name}'],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
-
-    def test_handles_empty_bookmark_id(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        response = self.client.post(reverse('bookmarks:action'), {
-            'bulk_archive': [''],
-        })
-        self.assertEqual(response.status_code, 302)
-
-        response = self.client.post(reverse('bookmarks:action'), {
-            'bulk_archive': [''],
-            'bookmark_id': [],
-        })
-        self.assertEqual(response.status_code, 302)
-
-        self.assertBookmarksAreUnmodified([bookmark1, bookmark2, bookmark3])
-
-    def test_empty_action_does_not_modify_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        self.client.post(reverse('bookmarks:action'), {
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertBookmarksAreUnmodified([bookmark1, bookmark2, bookmark3])
-
-    def test_should_redirect_to_return_url(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        url = reverse('bookmarks:action') + '?return_url=' + reverse('bookmarks:settings.index')
-        response = self.client.post(url, {
-            'bulk_archive': [''],
-            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-        })
-
-        self.assertRedirects(response, reverse('bookmarks:settings.index'))
-
-    def test_should_not_redirect_to_external_url(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        def post_with(return_url, follow=None):
-            url = reverse('bookmarks:action') + f'?return_url={return_url}'
-            return self.client.post(url, {
-                'bulk_archive': [''],
-                'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
-            }, follow=follow)
-
-        response = post_with('https://example.com')
-        self.assertRedirects(response, reverse('bookmarks:index'))
-        response = post_with('//example.com')
-        self.assertRedirects(response, reverse('bookmarks:index'))
-        response = post_with('://example.com')
-        self.assertRedirects(response, reverse('bookmarks:index'))
-
-        response = post_with('/foo//example.com', follow=True)
-        self.assertEqual(response.status_code, 404)

bookmarks/tests/test_bookmark_archived_view.py

@@ -1,158 +0,0 @@
-from django.contrib.auth.models import User
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.models import Bookmark, Tag, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
-        html = response.content.decode()
-        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
-
-        for bookmark in bookmarks:
-            self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
-                html
-            )
-
-    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
-        html = response.content.decode()
-
-        for bookmark in bookmarks:
-            self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
-                html,
-                count=0
-            )
-
-    def assertVisibleTags(self, response, tags: [Tag]):
-        self.assertContains(response, 'data-is-tag-item', count=len(tags))
-
-        for tag in tags:
-            self.assertContains(response, tag.name)
-
-    def assertInvisibleTags(self, response, tags: [Tag]):
-        for tag in tags:
-            self.assertNotContains(response, tag.name)
-
-    def test_should_list_archived_and_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        visible_bookmarks = [
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True)
-        ]
-        invisible_bookmarks = [
-            self.setup_bookmark(is_archived=False),
-            self.setup_bookmark(is_archived=True, user=other_user),
-        ]
-
-        response = self.client.get(reverse('bookmarks:archived'))
-
-        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
-        self.assertVisibleBookmarks(response, visible_bookmarks)
-        self.assertInvisibleBookmarks(response, invisible_bookmarks)
-
-    def test_should_list_bookmarks_matching_query(self):
-        visible_bookmarks = [
-            self.setup_bookmark(is_archived=True, title='searchvalue'),
-            self.setup_bookmark(is_archived=True, title='searchvalue'),
-            self.setup_bookmark(is_archived=True, title='searchvalue')
-        ]
-        invisible_bookmarks = [
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True)
-        ]
-
-        response = self.client.get(reverse('bookmarks:archived') + '?q=searchvalue')
-
-        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
-        self.assertVisibleBookmarks(response, visible_bookmarks)
-        self.assertInvisibleBookmarks(response, invisible_bookmarks)
-
-    def test_should_list_tags_for_archived_and_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        visible_tags = [
-            self.setup_tag(),
-            self.setup_tag(),
-            self.setup_tag(),
-        ]
-        invisible_tags = [
-            self.setup_tag(),  # unused tag
-            self.setup_tag(),  # used in archived bookmark
-            self.setup_tag(user=other_user),  # belongs to other user
-        ]
-
-        # Assign tags to some bookmarks with duplicates
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]])
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]])
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]])
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]])
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]])
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]])
-
-        self.setup_bookmark(is_archived=False, tags=[invisible_tags[1]])
-        self.setup_bookmark(is_archived=True, tags=[invisible_tags[2]], user=other_user)
-
-        response = self.client.get(reverse('bookmarks:archived'))
-
-        self.assertVisibleTags(response, visible_tags)
-        self.assertInvisibleTags(response, invisible_tags)
-
-    def test_should_list_tags_for_bookmarks_matching_query(self):
-        visible_tags = [
-            self.setup_tag(),
-            self.setup_tag(),
-            self.setup_tag(),
-        ]
-        invisible_tags = [
-            self.setup_tag(),
-            self.setup_tag(),
-            self.setup_tag(),
-        ]
-
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue'),
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]], title='searchvalue')
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]], title='searchvalue')
-        self.setup_bookmark(is_archived=True, tags=[invisible_tags[0]])
-        self.setup_bookmark(is_archived=True, tags=[invisible_tags[1]])
-        self.setup_bookmark(is_archived=True, tags=[invisible_tags[2]])
-
-        response = self.client.get(reverse('bookmarks:archived') + '?q=searchvalue')
-
-        self.assertVisibleTags(response, visible_tags)
-        self.assertInvisibleTags(response, invisible_tags)
-
-    def test_should_open_bookmarks_in_new_page_by_default(self):
-        visible_bookmarks = [
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True)
-        ]
-
-        response = self.client.get(reverse('bookmarks:archived'))
-
-        self.assertVisibleBookmarks(response, visible_bookmarks, '_blank')
-
-    def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
-        user = self.get_or_create_test_user()
-        user.profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
-        user.profile.save()
-
-        visible_bookmarks = [
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True)
-        ]
-
-        response = self.client.get(reverse('bookmarks:archived'))
-
-        self.assertVisibleBookmarks(response, visible_bookmarks, '_self')

bookmarks/tests/test_bookmark_edit_view.py

@@ -1,116 +0,0 @@
-from django.contrib.auth.models import User
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.models import build_tag_string
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def create_form_data(self, overrides=None):
-        if overrides is None:
-            overrides = {}
-        form_data = {
-            'url': 'http://example.com/edited',
-            'tag_string': 'editedtag1 editedtag2',
-            'title': 'edited title',
-            'description': 'edited description',
-        }
-        return {**form_data, **overrides}
-
-    def test_should_edit_bookmark(self):
-        bookmark = self.setup_bookmark()
-        form_data = self.create_form_data({'id': bookmark.id})
-
-        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
-
-        bookmark.refresh_from_db()
-
-        self.assertEqual(bookmark.owner, self.user)
-        self.assertEqual(bookmark.url, form_data['url'])
-        self.assertEqual(bookmark.title, form_data['title'])
-        self.assertEqual(bookmark.description, form_data['description'])
-        self.assertEqual(bookmark.tags.count(), 2)
-        self.assertEqual(bookmark.tags.all()[0].name, 'editedtag1')
-        self.assertEqual(bookmark.tags.all()[1].name, 'editedtag2')
-
-    def test_should_prefill_bookmark_form_fields(self):
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark = self.setup_bookmark(tags=[tag1, tag2], title='edited title', description='edited description')
-
-        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
-        html = response.content.decode()
-
-        self.assertInHTML('<input type="text" name="url" '
-                          'value="{0}" placeholder=" " '
-                          'autofocus class="form-input" required '
-                          'id="id_url">'.format(bookmark.url),
-                          html)
-
-        tag_string = build_tag_string(bookmark.tag_names, ' ')
-        self.assertInHTML('<input type="text" name="tag_string" '
-                          'value="{0}" autocomplete="off" '
-                          'class="form-input" '
-                          'id="id_tag_string">'.format(tag_string),
-                          html)
-
-        self.assertInHTML('<input type="text" name="title" maxlength="512" '
-                          'autocomplete="off" class="form-input" '
-                          'value="{0}" id="id_title">'.format(bookmark.title),
-                          html)
-
-        self.assertInHTML('<textarea name="description" cols="40" rows="4" class="form-input" id="id_description">{0}'
-                          '</textarea>'.format(bookmark.description),
-                          html)
-
-    def test_should_redirect_to_return_url(self):
-        bookmark = self.setup_bookmark()
-        form_data = self.create_form_data()
-
-        url = reverse('bookmarks:edit', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
-        response = self.client.post(url, form_data)
-
-        self.assertRedirects(response, reverse('bookmarks:close'))
-
-    def test_should_redirect_to_bookmark_index_by_default(self):
-        bookmark = self.setup_bookmark()
-        form_data = self.create_form_data()
-
-        response = self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
-
-        self.assertRedirects(response, reverse('bookmarks:index'))
-
-    def test_should_not_redirect_to_external_url(self):
-        bookmark = self.setup_bookmark()
-
-        def post_with(return_url, follow=None):
-            form_data = self.create_form_data()
-            url = reverse('bookmarks:edit', args=[bookmark.id]) + f'?return_url={return_url}'
-            return self.client.post(url, form_data, follow=follow)
-
-        response = post_with('https://example.com')
-        self.assertRedirects(response, reverse('bookmarks:index'))
-        response = post_with('//example.com')
-        self.assertRedirects(response, reverse('bookmarks:index'))
-        response = post_with('://example.com')
-        self.assertRedirects(response, reverse('bookmarks:index'))
-
-        response = post_with('/foo//example.com', follow=True)
-        self.assertEqual(response.status_code, 404)
-
-    def test_can_only_edit_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark = self.setup_bookmark(user=other_user)
-        form_data = self.create_form_data({'id': bookmark.id})
-
-        response = self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
-        bookmark.refresh_from_db()
-        self.assertNotEqual(bookmark.url, form_data['url'])
-        self.assertEqual(response.status_code, 404)
-

bookmarks/tests/test_bookmark_index_view.py

@@ -1,158 +0,0 @@
-from django.contrib.auth.models import User
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.models import Bookmark, Tag, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
-        html = response.content.decode()
-        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
-
-        for bookmark in bookmarks:
-            self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
-                html
-            )
-
-    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
-        html = response.content.decode()
-
-        for bookmark in bookmarks:
-            self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
-                html,
-                count=0
-            )
-
-    def assertVisibleTags(self, response, tags: [Tag]):
-        self.assertContains(response, 'data-is-tag-item', count=len(tags))
-
-        for tag in tags:
-            self.assertContains(response, tag.name)
-
-    def assertInvisibleTags(self, response, tags: [Tag]):
-        for tag in tags:
-            self.assertNotContains(response, tag.name)
-
-    def test_should_list_unarchived_and_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        visible_bookmarks = [
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-            self.setup_bookmark()
-        ]
-        invisible_bookmarks = [
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(user=other_user),
-        ]
-
-        response = self.client.get(reverse('bookmarks:index'))
-
-        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
-        self.assertVisibleBookmarks(response, visible_bookmarks)
-        self.assertInvisibleBookmarks(response, invisible_bookmarks)
-
-    def test_should_list_bookmarks_matching_query(self):
-        visible_bookmarks = [
-            self.setup_bookmark(title='searchvalue'),
-            self.setup_bookmark(title='searchvalue'),
-            self.setup_bookmark(title='searchvalue')
-        ]
-        invisible_bookmarks = [
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-            self.setup_bookmark()
-        ]
-
-        response = self.client.get(reverse('bookmarks:index') + '?q=searchvalue')
-
-        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
-        self.assertVisibleBookmarks(response, visible_bookmarks)
-        self.assertInvisibleBookmarks(response, invisible_bookmarks)
-
-    def test_should_list_tags_for_unarchived_and_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        visible_tags = [
-            self.setup_tag(),
-            self.setup_tag(),
-            self.setup_tag(),
-        ]
-        invisible_tags = [
-            self.setup_tag(),  # unused tag
-            self.setup_tag(),  # used in archived bookmark
-            self.setup_tag(user=other_user),  # belongs to other user
-        ]
-
-        # Assign tags to some bookmarks with duplicates
-        self.setup_bookmark(tags=[visible_tags[0]])
-        self.setup_bookmark(tags=[visible_tags[0]])
-        self.setup_bookmark(tags=[visible_tags[1]])
-        self.setup_bookmark(tags=[visible_tags[1]])
-        self.setup_bookmark(tags=[visible_tags[2]])
-        self.setup_bookmark(tags=[visible_tags[2]])
-
-        self.setup_bookmark(tags=[invisible_tags[1]], is_archived=True)
-        self.setup_bookmark(tags=[invisible_tags[2]], user=other_user)
-
-        response = self.client.get(reverse('bookmarks:index'))
-
-        self.assertVisibleTags(response, visible_tags)
-        self.assertInvisibleTags(response, invisible_tags)
-
-    def test_should_list_tags_for_bookmarks_matching_query(self):
-        visible_tags = [
-            self.setup_tag(),
-            self.setup_tag(),
-            self.setup_tag(),
-        ]
-        invisible_tags = [
-            self.setup_tag(),
-            self.setup_tag(),
-            self.setup_tag(),
-        ]
-
-        self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue'),
-        self.setup_bookmark(tags=[visible_tags[1]], title='searchvalue')
-        self.setup_bookmark(tags=[visible_tags[2]], title='searchvalue')
-        self.setup_bookmark(tags=[invisible_tags[0]])
-        self.setup_bookmark(tags=[invisible_tags[1]])
-        self.setup_bookmark(tags=[invisible_tags[2]])
-
-        response = self.client.get(reverse('bookmarks:index') + '?q=searchvalue')
-
-        self.assertVisibleTags(response, visible_tags)
-        self.assertInvisibleTags(response, invisible_tags)
-
-    def test_should_open_bookmarks_in_new_page_by_default(self):
-        visible_bookmarks = [
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-            self.setup_bookmark()
-        ]
-
-        response = self.client.get(reverse('bookmarks:index'))
-
-        self.assertVisibleBookmarks(response, visible_bookmarks, '_blank')
-
-    def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
-        user = self.get_or_create_test_user()
-        user.profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
-        user.profile.save()
-
-        visible_bookmarks = [
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-            self.setup_bookmark()
-        ]
-
-        response = self.client.get(reverse('bookmarks:index'))
-
-        self.assertVisibleBookmarks(response, visible_bookmarks, '_self')

bookmarks/tests/test_bookmark_new_view.py

@@ -1,88 +0,0 @@
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.models import Bookmark
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def create_form_data(self, overrides=None):
-        if overrides is None:
-            overrides = {}
-        form_data = {
-            'url': 'http://example.com',
-            'tag_string': 'tag1 tag2',
-            'title': 'test title',
-            'description': 'test description',
-            'auto_close': '',
-        }
-        return {**form_data, **overrides}
-
-    def test_should_create_new_bookmark(self):
-        form_data = self.create_form_data()
-
-        self.client.post(reverse('bookmarks:new'), form_data)
-
-        self.assertEqual(Bookmark.objects.count(), 1)
-
-        bookmark = Bookmark.objects.first()
-        self.assertEqual(bookmark.owner, self.user)
-        self.assertEqual(bookmark.url, form_data['url'])
-        self.assertEqual(bookmark.title, form_data['title'])
-        self.assertEqual(bookmark.description, form_data['description'])
-        self.assertEqual(bookmark.tags.count(), 2)
-        self.assertEqual(bookmark.tags.all()[0].name, 'tag1')
-        self.assertEqual(bookmark.tags.all()[1].name, 'tag2')
-
-    def test_should_prefill_url_from_url_parameter(self):
-        response = self.client.get(reverse('bookmarks:new') + '?url=http://example.com')
-        html = response.content.decode()
-
-        self.assertInHTML(
-            '<input type="text" name="url" value="http://example.com" '
-            'placeholder=" " autofocus class="form-input" required '
-            'id="id_url">',
-            html)
-
-    def test_should_enable_auto_close_when_specified_in_url_parameter(self):
-        response = self.client.get(
-            reverse('bookmarks:new') + '?auto_close')
-        html = response.content.decode()
-
-        self.assertInHTML(
-            '<input type="hidden" name="auto_close" value="true" '
-            'id="id_auto_close">',
-            html)
-
-    def test_should_not_enable_auto_close_when_not_specified_in_url_parameter(
-            self):
-        response = self.client.get(reverse('bookmarks:new'))
-        html = response.content.decode()
-
-        self.assertInHTML('<input type="hidden" name="auto_close" id="id_auto_close">',html)
-
-    def test_should_redirect_to_index_view(self):
-        form_data = self.create_form_data()
-
-        response = self.client.post(reverse('bookmarks:new'), form_data)
-
-        self.assertRedirects(response, reverse('bookmarks:index'))
-
-    def test_should_not_redirect_to_external_url(self):
-        form_data = self.create_form_data()
-
-        response = self.client.post(reverse('bookmarks:new') + '?return_url=https://example.com', form_data)
-
-        self.assertRedirects(response, reverse('bookmarks:index'))
-
-    def test_auto_close_should_redirect_to_close_view(self):
-        form_data = self.create_form_data({'auto_close': 'true'})
-
-        response = self.client.post(reverse('bookmarks:new'), form_data)
-
-        self.assertRedirects(response, reverse('bookmarks:close'))

bookmarks/tests/test_bookmark_validation.py

@@ -34,27 +34,6 @@ class BookmarkValidationTestCase(TestCase):
     def setUp(self) -> None:
         self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
 
-    def test_bookmark_model_should_not_allow_missing_url(self):
-        bookmark = Bookmark(
-            date_added=datetime.datetime.now(),
-            date_modified=datetime.datetime.now(),
-            owner=self.user
-        )
-
-        with self.assertRaises(ValidationError):
-            bookmark.full_clean()
-
-    def test_bookmark_model_should_not_allow_empty_url(self):
-        bookmark = Bookmark(
-            url='',
-            date_added=datetime.datetime.now(),
-            date_modified=datetime.datetime.now(),
-            owner=self.user
-        )
-
-        with self.assertRaises(ValidationError):
-            bookmark.full_clean()
-
     @override_settings(LD_DISABLE_URL_VALIDATION=False)
     def test_bookmark_model_should_validate_url_if_not_disabled_in_settings(self):
         self._run_bookmark_model_url_validity_checks(ENABLED_URL_VALIDATION_TEST_CASES)

bookmarks/tests/test_bookmarks_api.py

@@ -1,150 +0,0 @@
-from collections import OrderedDict
-
-from django.contrib.auth.models import User
-from django.urls import reverse
-from rest_framework import status
-from rest_framework.authtoken.models import Token
-
-from bookmarks.models import Bookmark
-from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
-
-
-class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        self.api_token = Token.objects.get_or_create(user=self.get_or_create_test_user())[0]
-        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.api_token.key)
-        self.tag1 = self.setup_tag()
-        self.tag2 = self.setup_tag()
-        self.bookmark1 = self.setup_bookmark(tags=[self.tag1, self.tag2])
-        self.bookmark2 = self.setup_bookmark()
-        self.bookmark3 = self.setup_bookmark(tags=[self.tag2])
-        self.archived_bookmark1 = self.setup_bookmark(is_archived=True, tags=[self.tag1, self.tag2])
-        self.archived_bookmark2 = self.setup_bookmark(is_archived=True)
-
-    def assertBookmarkListEqual(self, data_list, bookmarks):
-        expectations = []
-        for bookmark in bookmarks:
-            tag_names = [tag.name for tag in bookmark.tags.all()]
-            tag_names.sort(key=str.lower)
-            expectation = OrderedDict()
-            expectation['id'] = bookmark.id
-            expectation['url'] = bookmark.url
-            expectation['title'] = bookmark.title
-            expectation['description'] = bookmark.description
-            expectation['website_title'] = bookmark.website_title
-            expectation['website_description'] = bookmark.website_description
-            expectation['tag_names'] = tag_names
-            expectation['date_added'] = bookmark.date_added.isoformat().replace('+00:00', 'Z')
-            expectation['date_modified'] = bookmark.date_modified.isoformat().replace('+00:00', 'Z')
-            expectations.append(expectation)
-
-        for data in data_list:
-            data['tag_names'].sort(key=str.lower)
-
-        self.assertCountEqual(data_list, expectations)
-
-    def test_create_bookmark(self):
-        data = {
-            'url': 'https://example.com/',
-            'title': 'Test title',
-            'description': 'Test description',
-            'tag_names': ['tag1', 'tag2']
-        }
-        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
-        bookmark = Bookmark.objects.get(url=data['url'])
-        self.assertEqual(bookmark.url, data['url'])
-        self.assertEqual(bookmark.title, data['title'])
-        self.assertEqual(bookmark.description, data['description'])
-        self.assertEqual(bookmark.tags.count(), 2)
-        self.assertEqual(bookmark.tags.filter(name=data['tag_names'][0]).count(), 1)
-        self.assertEqual(bookmark.tags.filter(name=data['tag_names'][1]).count(), 1)
-
-    def test_create_bookmark_replaces_whitespace_in_tag_names(self):
-        data = {
-            'url': 'https://example.com/',
-            'title': 'Test title',
-            'description': 'Test description',
-            'tag_names': ['tag 1', 'tag 2']
-        }
-        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
-        bookmark = Bookmark.objects.get(url=data['url'])
-        tag_names = [tag.name for tag in bookmark.tags.all()]
-        self.assertListEqual(tag_names, ['tag-1', 'tag-2'])
-
-    def test_create_bookmark_minimal_payload(self):
-        data = {'url': 'https://example.com/'}
-        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
-
-    def test_list_bookmarks(self):
-        response = self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1, self.bookmark2, self.bookmark3])
-
-    def test_list_bookmarks_should_filter_by_query(self):
-        response = self.get(reverse('bookmarks:bookmark-list') + '?q=#' + self.tag1.name, expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1])
-
-    def test_list_archived_bookmarks_does_not_return_unarchived_bookmarks(self):
-        response = self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1, self.archived_bookmark2])
-
-    def test_list_archived_bookmarks_should_filter_by_query(self):
-        response = self.get(reverse('bookmarks:bookmark-archived') + '?q=#' + self.tag1.name, expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1])
-
-    def test_get_bookmark(self):
-        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
-        response = self.get(url, expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual([response.data], [self.bookmark1])
-
-    def test_update_bookmark(self):
-        data = {'url': 'https://example.com/'}
-        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
-        self.put(url, data, expected_status_code=status.HTTP_200_OK)
-        updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
-        self.assertEqual(updated_bookmark.url, data['url'])
-
-    def test_delete_bookmark(self):
-        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
-        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)
-        self.assertEqual(len(Bookmark.objects.filter(id=self.bookmark1.id)), 0)
-
-    def test_archive(self):
-        url = reverse('bookmarks:bookmark-archive', args=[self.bookmark1.id])
-        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
-        bookmark = Bookmark.objects.get(id=self.bookmark1.id)
-        self.assertTrue(bookmark.is_archived)
-
-    def test_unarchive(self):
-        url = reverse('bookmarks:bookmark-unarchive', args=[self.archived_bookmark1.id])
-        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
-        bookmark = Bookmark.objects.get(id=self.archived_bookmark1.id)
-        self.assertFalse(bookmark.is_archived)
-
-    def test_can_only_access_own_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        inaccessible_bookmark = self.setup_bookmark(user=other_user)
-        self.setup_bookmark(user=other_user, is_archived=True)
-
-        url = reverse('bookmarks:bookmark-list')
-        response = self.get(url, expected_status_code=status.HTTP_200_OK)
-        self.assertEqual(len(response.data['results']), 3)
-
-        url = reverse('bookmarks:bookmark-archived')
-        response = self.get(url, expected_status_code=status.HTTP_200_OK)
-        self.assertEqual(len(response.data['results']), 2)
-
-        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
-        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)
-
-        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
-        self.put(url, {url: 'https://example.com/'}, expected_status_code=status.HTTP_404_NOT_FOUND)
-
-        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
-        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)
-
-        url = reverse('bookmarks:bookmark-archive', args=[inaccessible_bookmark.id])
-        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
-
-        url = reverse('bookmarks:bookmark-unarchive', args=[inaccessible_bookmark.id])
-        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)

bookmarks/tests/test_bookmarks_list_tag.py

@@ -1,135 +0,0 @@
-from dateutil.relativedelta import relativedelta
-from django.core.paginator import Paginator
-from django.template import Template, RequestContext
-from django.test import TestCase, RequestFactory
-from django.utils import timezone, formats
-
-from bookmarks.models import Bookmark, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
-
-    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank'):
-        self.assertInHTML(
-            f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
-            html
-        )
-
-    def assertDateLabel(self, html: str, label_content: str):
-        self.assertInHTML(f'''
-        <span class="date-label text-gray text-sm">
-            <span>{label_content}</span>
-        </span>
-        <span class="text-gray text-sm">|</span>
-        ''', html)
-
-    def assertWebArchiveLink(self, html: str, label_content: str, url: str, link_target: str = '_blank'):
-        self.assertInHTML(f'''
-        <span class="date-label text-gray text-sm">
-            <a href="{url}"
-               title="Show snapshot on the Internet Archive Wayback Machine" target="{link_target}" rel="noopener">
-                <span>{label_content}</span>
-                <span>∞</span>
-            </a>
-        </span>
-        <span class="text-gray text-sm">|</span>
-        ''', html)
-
-    def render_template(self, bookmarks: [Bookmark], template: Template) -> str:
-        rf = RequestFactory()
-        request = rf.get('/test')
-        request.user = self.get_or_create_test_user()
-        paginator = Paginator(bookmarks, 10)
-        page = paginator.page(1)
-
-        context = RequestContext(request, {'bookmarks': page, 'return_url': '/test'})
-        return template.render(context)
-
-    def render_default_template(self, bookmarks: [Bookmark]) -> str:
-        template = Template(
-            '{% load bookmarks %}'
-            '{% bookmark_list bookmarks return_url %}'
-        )
-        return self.render_template(bookmarks, template)
-
-    def render_template_with_link_target(self, bookmarks: [Bookmark], link_target: str) -> str:
-        template = Template(
-            f'''
-            {{% load bookmarks %}}
-            {{% bookmark_list bookmarks return_url '{link_target}' %}}
-            '''
-        )
-        return self.render_template(bookmarks, template)
-
-    def setup_date_format_test(self, date_display_setting: str, web_archive_url: str = ''):
-        bookmark = self.setup_bookmark()
-        bookmark.date_added = timezone.now() - relativedelta(days=8)
-        bookmark.web_archive_snapshot_url = web_archive_url
-        bookmark.save()
-        user = self.get_or_create_test_user()
-        user.profile.bookmark_date_display = date_display_setting
-        user.profile.save()
-        return bookmark
-
-    def test_should_respect_absolute_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE)
-        html = self.render_default_template([bookmark])
-        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
-
-        self.assertDateLabel(html, formatted_date)
-
-    def test_should_render_web_archive_link_with_absolute_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE,
-                                               'https://web.archive.org/web/20210811214511/https://wanikani.com/')
-        html = self.render_default_template([bookmark])
-        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
-
-        self.assertWebArchiveLink(html, formatted_date, bookmark.web_archive_snapshot_url)
-
-    def test_should_respect_relative_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE)
-        html = self.render_default_template([bookmark])
-
-        self.assertDateLabel(html, '1 week ago')
-
-    def test_should_render_web_archive_link_with_relative_date_setting(self):
-        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE,
-                                               'https://web.archive.org/web/20210811214511/https://wanikani.com/')
-        html = self.render_default_template([bookmark])
-
-        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url)
-
-    def test_bookmark_link_target_should_be_blank_by_default(self):
-        bookmark = self.setup_bookmark()
-
-        html = self.render_default_template([bookmark])
-
-        self.assertBookmarksLink(html, bookmark, link_target='_blank')
-
-    def test_bookmark_link_target_should_respect_link_target_parameter(self):
-        bookmark = self.setup_bookmark()
-
-        html = self.render_template_with_link_target([bookmark], '_self')
-
-        self.assertBookmarksLink(html, bookmark, link_target='_self')
-
-    def test_web_archive_link_target_should_be_blank_by_default(self):
-        bookmark = self.setup_bookmark()
-        bookmark.date_added = timezone.now() - relativedelta(days=8)
-        bookmark.web_archive_snapshot_url = 'https://example.com'
-        bookmark.save()
-
-        html = self.render_default_template([bookmark])
-
-        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_blank')
-
-    def test_web_archive_link_target_respect_link_target_parameter(self):
-        bookmark = self.setup_bookmark()
-        bookmark.date_added = timezone.now() - relativedelta(days=8)
-        bookmark.web_archive_snapshot_url = 'https://example.com'
-        bookmark.save()
-
-        html = self.render_template_with_link_target([bookmark], '_self')
-
-        self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_self')

bookmarks/tests/test_bookmarks_service.py

@@ -1,47 +1,19 @@
-from unittest.mock import patch
-
 from django.contrib.auth import get_user_model
 from django.test import TestCase
 from django.utils import timezone
 
-from bookmarks.models import Bookmark, Tag
-from bookmarks.services.bookmarks import create_bookmark, update_bookmark, archive_bookmark, archive_bookmarks, \
-    unarchive_bookmark, unarchive_bookmarks, delete_bookmarks, tag_bookmarks, untag_bookmarks
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-from bookmarks.services import tasks
+from bookmarks.models import Bookmark
+from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
 
 User = get_user_model()
 
 
-class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkServiceTestCase(TestCase):
 
     def setUp(self) -> None:
-        self.get_or_create_test_user()
+        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
 
-    def test_create_should_create_web_archive_snapshot(self):
-        with patch.object(tasks, 'create_web_archive_snapshot') as mock_create_web_archive_snapshot:
-            bookmark_data = Bookmark(url='https://example.com')
-            bookmark = create_bookmark(bookmark_data, 'tag1,tag2', self.user)
-
-            mock_create_web_archive_snapshot.assert_called_once_with(self.user, bookmark, False)
-
-    def test_update_should_create_web_archive_snapshot_if_url_did_change(self):
-        with patch.object(tasks, 'create_web_archive_snapshot') as mock_create_web_archive_snapshot:
-            bookmark = self.setup_bookmark()
-            bookmark.url = 'https://example.com/updated'
-            update_bookmark(bookmark, 'tag1,tag2', self.user)
-
-            mock_create_web_archive_snapshot.assert_called_once_with(self.user, bookmark, True)
-
-    def test_update_should_not_create_web_archive_snapshot_if_url_did_not_change(self):
-        with patch.object(tasks, 'create_web_archive_snapshot') as mock_create_web_archive_snapshot:
-            bookmark = self.setup_bookmark()
-            bookmark.title = 'updated title'
-            update_bookmark(bookmark, 'tag1,tag2', self.user)
-
-            mock_create_web_archive_snapshot.assert_not_called()
-
-    def test_archive_bookmark(self):
+    def test_archive(self):
         bookmark = Bookmark(
             url='https://example.com',
             date_added=timezone.now(),
@@ -58,7 +30,7 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
 
         self.assertTrue(updated_bookmark.is_archived)
 
-    def test_unarchive_bookmark(self):
+    def test_unarchive(self):
         bookmark = Bookmark(
             url='https://example.com',
             date_added=timezone.now(),
@@ -73,297 +45,3 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
         updated_bookmark = Bookmark.objects.get(id=bookmark.id)
 
         self.assertFalse(updated_bookmark.is_archived)
-
-    def test_archive_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        archive_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_archive_bookmarks_should_only_archive_specified_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        archive_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_archive_bookmarks_should_only_archive_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        inaccessible_bookmark = self.setup_bookmark(user=other_user)
-
-        archive_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], self.get_or_create_test_user())
-
-        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=inaccessible_bookmark.id).is_archived)
-
-    def test_archive_bookmarks_should_accept_mix_of_int_and_string_ids(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        archive_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], self.get_or_create_test_user())
-
-        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_unarchive_bookmarks(self):
-        bookmark1 = self.setup_bookmark(is_archived=True)
-        bookmark2 = self.setup_bookmark(is_archived=True)
-        bookmark3 = self.setup_bookmark(is_archived=True)
-
-        unarchive_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_unarchive_bookmarks_should_only_unarchive_specified_bookmarks(self):
-        bookmark1 = self.setup_bookmark(is_archived=True)
-        bookmark2 = self.setup_bookmark(is_archived=True)
-        bookmark3 = self.setup_bookmark(is_archived=True)
-
-        unarchive_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_unarchive_bookmarks_should_only_unarchive_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark(is_archived=True)
-        bookmark2 = self.setup_bookmark(is_archived=True)
-        inaccessible_bookmark = self.setup_bookmark(is_archived=True, user=other_user)
-
-        unarchive_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], self.get_or_create_test_user())
-
-        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertTrue(Bookmark.objects.get(id=inaccessible_bookmark.id).is_archived)
-
-    def test_unarchive_bookmarks_should_accept_mix_of_int_and_string_ids(self):
-        bookmark1 = self.setup_bookmark(is_archived=True)
-        bookmark2 = self.setup_bookmark(is_archived=True)
-        bookmark3 = self.setup_bookmark(is_archived=True)
-
-        unarchive_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], self.get_or_create_test_user())
-
-        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
-        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
-
-    def test_delete_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        delete_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
-
-    def test_delete_bookmarks_should_only_delete_specified_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        delete_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
-        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark2.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
-
-    def test_delete_bookmarks_should_only_delete_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        inaccessible_bookmark = self.setup_bookmark(user=other_user)
-
-        delete_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], self.get_or_create_test_user())
-
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
-        self.assertIsNotNone(Bookmark.objects.filter(id=inaccessible_bookmark.id).first())
-
-    def test_delete_bookmarks_should_accept_mix_of_int_and_string_ids(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        delete_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
-
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
-        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
-
-    def test_tag_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-
-        tag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], f'{tag1.name},{tag2.name}',
-                      self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
-
-    def test_tag_bookmarks_should_create_tags(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-
-        tag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], 'tag1,tag2', self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertEqual(2, Tag.objects.count())
-
-        tag1 = Tag.objects.filter(name='tag1').first()
-        tag2 = Tag.objects.filter(name='tag2').first()
-
-        self.assertIsNotNone(tag1)
-        self.assertIsNotNone(tag2)
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
-
-    def test_tag_bookmarks_should_only_tag_specified_bookmarks(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-
-        tag_bookmarks([bookmark1.id, bookmark3.id], f'{tag1.name},{tag2.name}', self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [])
-        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
-
-    def test_tag_bookmarks_should_only_tag_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        inaccessible_bookmark = self.setup_bookmark(user=other_user)
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-
-        tag_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], f'{tag1.name},{tag2.name}',
-                      self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        inaccessible_bookmark.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(inaccessible_bookmark.tags.all(), [])
-
-    def test_tag_bookmarks_should_accept_mix_of_int_and_string_ids(self):
-        bookmark1 = self.setup_bookmark()
-        bookmark2 = self.setup_bookmark()
-        bookmark3 = self.setup_bookmark()
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-
-        tag_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], f'{tag1.name},{tag2.name}',
-                      self.get_or_create_test_user())
-
-        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
-
-    def test_untag_bookmarks(self):
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
-
-        untag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], f'{tag1.name},{tag2.name}',
-                        self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [])
-        self.assertCountEqual(bookmark2.tags.all(), [])
-        self.assertCountEqual(bookmark3.tags.all(), [])
-
-    def test_untag_bookmarks_should_only_tag_specified_bookmarks(self):
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
-
-        untag_bookmarks([bookmark1.id, bookmark3.id], f'{tag1.name},{tag2.name}', self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        bookmark3.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [])
-        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
-        self.assertCountEqual(bookmark3.tags.all(), [])
-
-    def test_untag_bookmarks_should_only_tag_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
-        inaccessible_bookmark = self.setup_bookmark(user=other_user, tags=[tag1, tag2])
-
-        untag_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], f'{tag1.name},{tag2.name}',
-                        self.get_or_create_test_user())
-
-        bookmark1.refresh_from_db()
-        bookmark2.refresh_from_db()
-        inaccessible_bookmark.refresh_from_db()
-
-        self.assertCountEqual(bookmark1.tags.all(), [])
-        self.assertCountEqual(bookmark2.tags.all(), [])
-        self.assertCountEqual(inaccessible_bookmark.tags.all(), [tag1, tag2])
-
-    def test_untag_bookmarks_should_accept_mix_of_int_and_string_ids(self):
-        tag1 = self.setup_tag()
-        tag2 = self.setup_tag()
-        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
-        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
-
-        untag_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], f'{tag1.name},{tag2.name}',
-                        self.get_or_create_test_user())
-
-        self.assertCountEqual(bookmark1.tags.all(), [])
-        self.assertCountEqual(bookmark2.tags.all(), [])
-        self.assertCountEqual(bookmark3.tags.all(), [])

bookmarks/tests/test_bookmarks_tasks.py

@@ -1,174 +0,0 @@
-from unittest.mock import patch
-
-import waybackpy
-from background_task.models import Task
-from django.contrib.auth.models import User
-from django.test import TestCase, override_settings
-
-from bookmarks.models import Bookmark, UserProfile
-from bookmarks.services import tasks
-from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
-
-
-class MockWaybackUrl:
-
-    def __init__(self, archive_url: str):
-        self.archive_url = archive_url
-
-    def save(self):
-        return self
-
-
-class MockWaybackUrlWithSaveError:
-    def save(self):
-        raise NotImplementedError
-
-
-class BookmarkTasksTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self):
-        user = self.get_or_create_test_user()
-        user.profile.web_archive_integration = UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
-        user.profile.save()
-
-    @disable_logging
-    def run_pending_task(self, task_function):
-        func = getattr(task_function, 'task_function', None)
-        task = Task.objects.all()[0]
-        args, kwargs = task.params()
-        func(*args, **kwargs)
-        task.delete()
-
-    @disable_logging
-    def run_all_pending_tasks(self, task_function):
-        func = getattr(task_function, 'task_function', None)
-        tasks = Task.objects.all()
-
-        for task in tasks:
-            args, kwargs = task.params()
-            func(*args, **kwargs)
-            task.delete()
-
-    def test_create_web_archive_snapshot_should_update_snapshot_url(self):
-        bookmark = self.setup_bookmark()
-
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://example.com')):
-            tasks.create_web_archive_snapshot(self.get_or_create_test_user(), bookmark, False)
-            self.run_pending_task(tasks._create_web_archive_snapshot_task)
-            bookmark.refresh_from_db()
-
-            self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com')
-
-    def test_create_web_archive_snapshot_should_handle_missing_bookmark_id(self):
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://example.com')) as mock_wayback_url:
-            tasks._create_web_archive_snapshot_task(123, False)
-            self.run_pending_task(tasks._create_web_archive_snapshot_task)
-
-            mock_wayback_url.assert_not_called()
-
-    def test_create_web_archive_snapshot_should_handle_wayback_save_error(self):
-        bookmark = self.setup_bookmark()
-
-        with patch.object(waybackpy, 'Url',
-                          return_value=MockWaybackUrlWithSaveError()):
-            with self.assertRaises(NotImplementedError):
-                tasks.create_web_archive_snapshot(self.get_or_create_test_user(), bookmark, False)
-                self.run_pending_task(tasks._create_web_archive_snapshot_task)
-
-    def test_create_web_archive_snapshot_should_skip_if_snapshot_exists(self):
-        bookmark = self.setup_bookmark(web_archive_snapshot_url='https://example.com')
-
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://other.com')):
-            tasks.create_web_archive_snapshot(self.get_or_create_test_user(), bookmark, False)
-            self.run_pending_task(tasks._create_web_archive_snapshot_task)
-            bookmark.refresh_from_db()
-
-            self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com')
-
-    def test_create_web_archive_snapshot_should_force_update_snapshot(self):
-        bookmark = self.setup_bookmark(web_archive_snapshot_url='https://example.com')
-
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://other.com')):
-            tasks.create_web_archive_snapshot(self.get_or_create_test_user(), bookmark, True)
-            self.run_pending_task(tasks._create_web_archive_snapshot_task)
-            bookmark.refresh_from_db()
-
-            self.assertEqual(bookmark.web_archive_snapshot_url, 'https://other.com')
-
-    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
-    def test_create_web_archive_snapshot_should_not_run_when_background_tasks_are_disabled(self):
-        bookmark = self.setup_bookmark()
-        tasks.create_web_archive_snapshot(self.get_or_create_test_user(), bookmark, False)
-
-        self.assertEqual(Task.objects.count(), 0)
-
-    def test_create_web_archive_snapshot_should_not_run_when_web_archive_integration_is_disabled(self):
-        self.user.profile.web_archive_integration = UserProfile.WEB_ARCHIVE_INTEGRATION_DISABLED
-        self.user.profile.save()
-
-        bookmark = self.setup_bookmark()
-        tasks.create_web_archive_snapshot(self.get_or_create_test_user(), bookmark, False)
-
-        self.assertEqual(Task.objects.count(), 0)
-
-    def test_schedule_bookmarks_without_snapshots_should_create_snapshot_task_for_all_bookmarks_without_snapshot(self):
-        user = self.get_or_create_test_user()
-        self.setup_bookmark()
-        self.setup_bookmark()
-        self.setup_bookmark()
-
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://example.com')):
-            tasks.schedule_bookmarks_without_snapshots(user)
-            self.run_pending_task(tasks._schedule_bookmarks_without_snapshots_task)
-            self.run_all_pending_tasks(tasks._create_web_archive_snapshot_task)
-
-            for bookmark in Bookmark.objects.all():
-                self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com')
-
-    def test_schedule_bookmarks_without_snapshots_should_not_update_bookmarks_with_existing_snapshot(self):
-        user = self.get_or_create_test_user()
-        self.setup_bookmark(web_archive_snapshot_url='https://example.com')
-        self.setup_bookmark(web_archive_snapshot_url='https://example.com')
-        self.setup_bookmark(web_archive_snapshot_url='https://example.com')
-
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://other.com')):
-            tasks.schedule_bookmarks_without_snapshots(user)
-            self.run_pending_task(tasks._schedule_bookmarks_without_snapshots_task)
-            self.run_all_pending_tasks(tasks._create_web_archive_snapshot_task)
-
-            for bookmark in Bookmark.objects.all():
-                self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com')
-
-    def test_schedule_bookmarks_without_snapshots_should_only_update_user_owned_bookmarks(self):
-        user = self.get_or_create_test_user()
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        self.setup_bookmark()
-        self.setup_bookmark()
-        self.setup_bookmark()
-        self.setup_bookmark(user=other_user)
-        self.setup_bookmark(user=other_user)
-        self.setup_bookmark(user=other_user)
-
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://example.com')):
-            tasks.schedule_bookmarks_without_snapshots(user)
-            self.run_pending_task(tasks._schedule_bookmarks_without_snapshots_task)
-            self.run_all_pending_tasks(tasks._create_web_archive_snapshot_task)
-
-            for bookmark in Bookmark.objects.all().filter(owner=user):
-                self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com')
-
-            for bookmark in Bookmark.objects.all().filter(owner=other_user):
-                self.assertEqual(bookmark.web_archive_snapshot_url, '')
-
-    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
-    def test_schedule_bookmarks_without_snapshots_should_not_run_when_background_tasks_are_disabled(self):
-        tasks.schedule_bookmarks_without_snapshots(self.user)
-
-        self.assertEqual(Task.objects.count(), 0)
-
-    def test_schedule_bookmarks_without_snapshots_should_not_run_when_web_archive_integration_is_disabled(self):
-        self.user.profile.web_archive_integration = UserProfile.WEB_ARCHIVE_INTEGRATION_DISABLED
-        self.user.profile.save()
-        tasks.schedule_bookmarks_without_snapshots(self.user)
-
-        self.assertEqual(Task.objects.count(), 0)

bookmarks/tests/test_importer.py

@@ -1,58 +0,0 @@
-from unittest.mock import patch
-
-from django.test import TestCase
-
-from bookmarks.models import Tag
-from bookmarks.services import tasks
-from bookmarks.services.importer import import_netscape_html
-from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
-
-
-class ImporterTestCase(TestCase, BookmarkFactoryMixin):
-
-    def create_import_html(self, bookmark_tags_string: str):
-        return f'''
-<!DOCTYPE NETSCAPE-Bookmark-file-1>
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
-<TITLE>Bookmarks</TITLE>
-<H1>Bookmarks</H1>
-<DL><p>
-{bookmark_tags_string}
-</DL><p>
-        '''
-
-    def test_replace_whitespace_in_tag_names(self):
-        test_html = self.create_import_html(f'''
-            <DT><A HREF="https://example.com" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag 1, tag 2, tag 3">Example.com</A>
-            <DD>Example.com
-        ''')
-        import_netscape_html(test_html, self.get_or_create_test_user())
-
-        tags = Tag.objects.all()
-        tag_names = [tag.name for tag in tags]
-
-        self.assertListEqual(tag_names, ['tag-1', 'tag-2', 'tag-3'])
-
-    @disable_logging
-    def test_validate_empty_or_missing_bookmark_url(self):
-        test_html = self.create_import_html(f'''
-            <!-- Empty URL -->
-            <DT><A HREF="" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">Empty URL</A>
-            <DD>Empty URL
-            <!-- Missing URL -->
-            <DT><A ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">Missing URL</A>
-            <DD>Missing URL
-        ''')
-
-        import_result = import_netscape_html(test_html, self.get_or_create_test_user())
-
-        self.assertEqual(import_result.success, 0)
-
-    def test_schedule_snapshot_creation(self):
-        user = self.get_or_create_test_user()
-        test_html = self.create_import_html('')
-
-        with patch.object(tasks, 'schedule_bookmarks_without_snapshots') as mock_schedule_bookmarks_without_snapshots:
-            import_netscape_html(test_html, user)
-
-            mock_schedule_bookmarks_without_snapshots.assert_called_once_with(user)

bookmarks/tests/test_pagination_tag.py

@@ -1,6 +1,6 @@
 from django.core.paginator import Paginator
-from django.template import Template, RequestContext
 from django.test import SimpleTestCase, RequestFactory
+from django.template import Template, RequestContext
 
 
 class PaginationTagTest(SimpleTestCase):

bookmarks/tests/test_password_change_view.py

@@ -1,55 +0,0 @@
-from django.contrib.auth.models import User
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class PasswordChangeViewTestCase(TestCase, BookmarkFactoryMixin):
-    def setUp(self) -> None:
-        self.user = User.objects.create_user('testuser', 'test@example.com', 'initial_password')
-        self.client.force_login(self.user)
-
-    def test_change_password(self):
-        form_data = {
-            'old_password': 'initial_password',
-            'new_password1': 'new_password',
-            'new_password2': 'new_password',
-        }
-
-        response = self.client.post(reverse('change_password'), form_data)
-
-        self.assertRedirects(response, reverse('password_change_done'))
-
-    def test_change_password_done(self):
-        form_data = {
-            'old_password': 'initial_password',
-            'new_password1': 'new_password',
-            'new_password2': 'new_password',
-        }
-
-        response = self.client.post(reverse('change_password'), form_data, follow=True)
-
-        self.assertContains(response, 'Your password was changed successfully')
-
-    def test_should_return_error_for_invalid_old_password(self):
-        form_data = {
-            'old_password': 'wrong_password',
-            'new_password1': 'new_password',
-            'new_password2': 'new_password',
-        }
-
-        response = self.client.post(reverse('change_password'), form_data)
-
-        self.assertIn('old_password', response.context_data['form'].errors)
-
-    def test_should_return_error_for_mismatching_new_password(self):
-        form_data = {
-            'old_password': 'initial_password',
-            'new_password1': 'new_password',
-            'new_password2': 'wrong_password',
-        }
-
-        response = self.client.post(reverse('change_password'), form_data)
-
-        self.assertIn('new_password2', response.context_data['form'].errors)

bookmarks/tests/test_queries.py

@@ -1,222 +1,38 @@
-import operator
-
 from django.contrib.auth import get_user_model
-from django.db.models import QuerySet
 from django.test import TestCase
-
+from django.utils import timezone
+from django.utils.crypto import get_random_string
+from bookmarks.models import Bookmark, Tag
 from bookmarks import queries
-from bookmarks.models import Bookmark
-from bookmarks.tests.helpers import BookmarkFactoryMixin, random_sentence
-from bookmarks.utils import unique
 
 User = get_user_model()
 
 
-class QueriesTestCase(TestCase, BookmarkFactoryMixin):
+class QueriesTestCase(TestCase):
 
-    def setup_bookmark_search_data(self) -> None:
-        tag1 = self.setup_tag(name='tag1')
-        tag2 = self.setup_tag(name='tag2')
-        self.setup_tag(name='unused_tag1')
+    def setUp(self) -> None:
+        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
 
-        self.other_bookmarks = [
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-        ]
-        self.term1_bookmarks = [
-            self.setup_bookmark(url='http://example.com/term1'),
-            self.setup_bookmark(title=random_sentence(including_word='term1')),
-            self.setup_bookmark(description=random_sentence(including_word='term1')),
-            self.setup_bookmark(website_title=random_sentence(including_word='term1')),
-            self.setup_bookmark(website_description=random_sentence(including_word='term1')),
-        ]
-        self.term1_term2_bookmarks = [
-            self.setup_bookmark(url='http://example.com/term1/term2'),
-            self.setup_bookmark(title=random_sentence(including_word='term1'),
-                                description=random_sentence(including_word='term2')),
-            self.setup_bookmark(description=random_sentence(including_word='term1'),
-                                title=random_sentence(including_word='term2')),
-            self.setup_bookmark(website_title=random_sentence(including_word='term1'),
-                                title=random_sentence(including_word='term2')),
-            self.setup_bookmark(website_description=random_sentence(including_word='term1'),
-                                title=random_sentence(including_word='term2')),
-        ]
-        self.tag1_bookmarks = [
-            self.setup_bookmark(tags=[tag1]),
-            self.setup_bookmark(title=random_sentence(), tags=[tag1]),
-            self.setup_bookmark(description=random_sentence(), tags=[tag1]),
-            self.setup_bookmark(website_title=random_sentence(), tags=[tag1]),
-            self.setup_bookmark(website_description=random_sentence(), tags=[tag1]),
-        ]
-        self.term1_tag1_bookmarks = [
-            self.setup_bookmark(url='http://example.com/term1', tags=[tag1]),
-            self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[tag1]),
-            self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[tag1]),
-            self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[tag1]),
-            self.setup_bookmark(website_description=random_sentence(including_word='term1'), tags=[tag1]),
-        ]
-        self.tag2_bookmarks = [
-            self.setup_bookmark(tags=[tag2]),
-        ]
-        self.tag1_tag2_bookmarks = [
-            self.setup_bookmark(tags=[tag1, tag2]),
-        ]
+    def setup_bookmark(self, is_archived: bool = False, tags: [Tag] = []):
+        unique_id = get_random_string(length=32)
+        bookmark = Bookmark(
+            url='https://example.com/' + unique_id,
+            date_added=timezone.now(),
+            date_modified=timezone.now(),
+            owner=self.user,
+            is_archived=is_archived
+        )
+        bookmark.save()
+        for tag in tags:
+            bookmark.tags.add(tag)
+        bookmark.save()
+        return bookmark
 
-    def setup_tag_search_data(self):
-        tag1 = self.setup_tag(name='tag1')
-        tag2 = self.setup_tag(name='tag2')
-        self.setup_tag(name='unused_tag1')
-
-        self.other_bookmarks = [
-            self.setup_bookmark(tags=[self.setup_tag()]),
-            self.setup_bookmark(tags=[self.setup_tag()]),
-            self.setup_bookmark(tags=[self.setup_tag()]),
-        ]
-        self.term1_bookmarks = [
-            self.setup_bookmark(url='http://example.com/term1', tags=[self.setup_tag()]),
-            self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
-            self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
-            self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
-            self.setup_bookmark(website_description=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
-        ]
-        self.term1_term2_bookmarks = [
-            self.setup_bookmark(url='http://example.com/term1/term2', tags=[self.setup_tag()]),
-            self.setup_bookmark(title=random_sentence(including_word='term1'),
-                                description=random_sentence(including_word='term2'),
-                                tags=[self.setup_tag()]),
-            self.setup_bookmark(description=random_sentence(including_word='term1'),
-                                title=random_sentence(including_word='term2'),
-                                tags=[self.setup_tag()]),
-            self.setup_bookmark(website_title=random_sentence(including_word='term1'),
-                                title=random_sentence(including_word='term2'),
-                                tags=[self.setup_tag()]),
-            self.setup_bookmark(website_description=random_sentence(including_word='term1'),
-                                title=random_sentence(including_word='term2'),
-                                tags=[self.setup_tag()]),
-        ]
-        self.tag1_bookmarks = [
-            self.setup_bookmark(tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(title=random_sentence(), tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(description=random_sentence(), tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(website_title=random_sentence(), tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(website_description=random_sentence(), tags=[tag1, self.setup_tag()]),
-        ]
-        self.term1_tag1_bookmarks = [
-            self.setup_bookmark(url='http://example.com/term1', tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
-            self.setup_bookmark(website_description=random_sentence(including_word='term1'),
-                                tags=[tag1, self.setup_tag()]),
-        ]
-        self.tag2_bookmarks = [
-            self.setup_bookmark(tags=[tag2, self.setup_tag()]),
-        ]
-        self.tag1_tag2_bookmarks = [
-            self.setup_bookmark(tags=[tag1, tag2, self.setup_tag()]),
-        ]
-
-    def get_tags_from_bookmarks(self, bookmarks: [Bookmark]):
-        all_tags = []
-        for bookmark in bookmarks:
-            all_tags = all_tags + list(bookmark.tags.all())
-        return all_tags
-
-    def assertQueryResult(self, query: QuerySet, item_lists: [[any]]):
-        expected_items = []
-        for item_list in item_lists:
-            expected_items = expected_items + item_list
-
-        expected_items = unique(expected_items, operator.attrgetter('id'))
-
-        self.assertCountEqual(list(query), expected_items)
-
-    def test_query_bookmarks_should_return_all_for_empty_query(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '')
-        self.assertQueryResult(query, [
-            self.other_bookmarks,
-            self.term1_bookmarks,
-            self.term1_term2_bookmarks,
-            self.tag1_bookmarks,
-            self.term1_tag1_bookmarks,
-            self.tag2_bookmarks,
-            self.tag1_tag2_bookmarks
-        ])
-
-    def test_query_bookmarks_should_search_single_term(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1')
-        self.assertQueryResult(query, [
-            self.term1_bookmarks,
-            self.term1_term2_bookmarks,
-            self.term1_tag1_bookmarks
-        ])
-
-    def test_query_bookmarks_should_search_multiple_terms(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term2 term1')
-
-        self.assertQueryResult(query, [self.term1_term2_bookmarks])
-
-    def test_query_bookmarks_should_search_single_tag(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1')
-
-        self.assertQueryResult(query, [self.tag1_bookmarks, self.tag1_tag2_bookmarks, self.term1_tag1_bookmarks])
-
-    def test_query_bookmarks_should_search_multiple_tags(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1 #tag2')
-
-        self.assertQueryResult(query, [self.tag1_tag2_bookmarks])
-
-    def test_query_bookmarks_should_search_multiple_tags_ignoring_casing(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#Tag1 #TAG2')
-
-        self.assertQueryResult(query, [self.tag1_tag2_bookmarks])
-
-    def test_query_bookmarks_should_search_terms_and_tags_combined(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #tag1')
-
-        self.assertQueryResult(query, [self.term1_tag1_bookmarks])
-
-    def test_query_bookmarks_should_return_no_matches(self):
-        self.setup_bookmark_search_data()
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term3')
-        self.assertQueryResult(query, [])
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 term3')
-        self.assertQueryResult(query, [])
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #tag2')
-        self.assertQueryResult(query, [])
-
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag3')
-        self.assertQueryResult(query, [])
-
-        # Unused tag
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#unused_tag1')
-        self.assertQueryResult(query, [])
-
-        # Unused tag combined with tag that is used
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1 #unused_tag1')
-        self.assertQueryResult(query, [])
-
-        # Unused tag combined with term that is used
-        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #unused_tag1')
-        self.assertQueryResult(query, [])
+    def setup_tag(self):
+        name = get_random_string(length=32)
+        tag = Tag(name=name, date_added=timezone.now(), owner=self.user)
+        tag.save()
+        return tag
 
     def test_query_bookmarks_should_not_return_archived_bookmarks(self):
         bookmark1 = self.setup_bookmark()
@@ -225,9 +41,9 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True)
         self.setup_bookmark(is_archived=True)
 
-        query = queries.query_bookmarks(self.get_or_create_test_user(), '')
+        query = queries.query_bookmarks(self.user, '')
 
-        self.assertQueryResult(query, [[bookmark1, bookmark2]])
+        self.assertCountEqual([bookmark1, bookmark2], list(query))
 
     def test_query_archived_bookmarks_should_not_return_unarchived_bookmarks(self):
         bookmark1 = self.setup_bookmark(is_archived=True)
@@ -236,158 +52,9 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark()
 
-        query = queries.query_archived_bookmarks(self.get_or_create_test_user(), '')
-
-        self.assertQueryResult(query, [[bookmark1, bookmark2]])
-
-    def test_query_bookmarks_should_only_return_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        owned_bookmarks = [
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-            self.setup_bookmark(),
-        ]
-        self.setup_bookmark(user=other_user)
-        self.setup_bookmark(user=other_user)
-        self.setup_bookmark(user=other_user)
-
-        query = queries.query_bookmarks(self.user, '')
-
-        self.assertQueryResult(query, [owned_bookmarks])
-
-    def test_query_archived_bookmarks_should_only_return_user_owned_bookmarks(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        owned_bookmarks = [
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True),
-            self.setup_bookmark(is_archived=True),
-        ]
-        self.setup_bookmark(is_archived=True, user=other_user)
-        self.setup_bookmark(is_archived=True, user=other_user)
-        self.setup_bookmark(is_archived=True, user=other_user)
-
         query = queries.query_archived_bookmarks(self.user, '')
 
-        self.assertQueryResult(query, [owned_bookmarks])
-
-    def test_query_bookmarks_should_use_tag_projection(self):
-        self.setup_bookmark_search_data()
-
-        # Test projection on bookmarks with tags
-        query = queries.query_bookmarks(self.user, '#tag1 #tag2')
-
-        for bookmark in query:
-            self.assertEqual(bookmark.tag_count, 2)
-            self.assertEqual(bookmark.tag_string, 'tag1,tag2')
-            self.assertTrue(bookmark.tag_projection)
-
-        # Test projection on bookmarks without tags
-        query = queries.query_bookmarks(self.user, 'term2')
-
-        for bookmark in query:
-            self.assertEqual(bookmark.tag_count, 0)
-            self.assertEqual(bookmark.tag_string, None)
-            self.assertTrue(bookmark.tag_projection)
-
-    def test_query_bookmark_tags_should_return_all_tags_for_empty_query(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, '')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.other_bookmarks),
-            self.get_tags_from_bookmarks(self.term1_bookmarks),
-            self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
-            self.get_tags_from_bookmarks(self.tag1_bookmarks),
-            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
-            self.get_tags_from_bookmarks(self.tag2_bookmarks),
-            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_search_single_term(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, 'term1')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.term1_bookmarks),
-            self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
-            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_search_multiple_terms(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, 'term2 term1')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_search_single_tag(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, '#tag1')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.tag1_bookmarks),
-            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
-            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_search_multiple_tags(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, '#tag1 #tag2')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_search_multiple_tags_ignoring_casing(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, '#Tag1 #TAG2')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_search_term_and_tag_combined(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.user, 'term1 #tag1')
-
-        self.assertQueryResult(query, [
-            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
-        ])
-
-    def test_query_bookmark_tags_should_return_no_matches(self):
-        self.setup_tag_search_data()
-
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term3')
-        self.assertQueryResult(query, [])
-
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 term3')
-        self.assertQueryResult(query, [])
-
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 #tag2')
-        self.assertQueryResult(query, [])
-
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#tag3')
-        self.assertQueryResult(query, [])
-
-        # Unused tag
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#unused_tag1')
-        self.assertQueryResult(query, [])
-
-        # Unused tag combined with tag that is used
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#tag1 #unused_tag1')
-        self.assertQueryResult(query, [])
-
-        # Unused tag combined with term that is used
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 #unused_tag1')
-        self.assertQueryResult(query, [])
+        self.assertCountEqual([bookmark1, bookmark2], list(query))
 
     def test_query_bookmark_tags_should_return_tags_for_unarchived_bookmarks_only(self):
         tag1 = self.setup_tag()
@@ -396,9 +63,9 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark(is_archived=True, tags=[tag2])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_bookmark_tags(self.user, '')
 
-        self.assertQueryResult(query, [[tag1]])
+        self.assertCountEqual([tag1], list(query))
 
     def test_query_bookmark_tags_should_return_distinct_tags(self):
         tag = self.setup_tag()
@@ -406,9 +73,9 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(tags=[tag])
         self.setup_bookmark(tags=[tag])
 
-        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_bookmark_tags(self.user, '')
 
-        self.assertQueryResult(query, [[tag]])
+        self.assertCountEqual([tag], list(query))
 
     def test_query_archived_bookmark_tags_should_return_tags_for_archived_bookmarks_only(self):
         tag1 = self.setup_tag()
@@ -417,9 +84,9 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark()
         self.setup_bookmark(is_archived=True, tags=[tag2])
 
-        query = queries.query_archived_bookmark_tags(self.get_or_create_test_user(), '')
+        query = queries.query_archived_bookmark_tags(self.user, '')
 
-        self.assertQueryResult(query, [[tag2]])
+        self.assertCountEqual([tag2], list(query))
 
     def test_query_archived_bookmark_tags_should_return_distinct_tags(self):
         tag = self.setup_tag()
@@ -427,36 +94,6 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         self.setup_bookmark(is_archived=True, tags=[tag])
         self.setup_bookmark(is_archived=True, tags=[tag])
 
-        query = queries.query_archived_bookmark_tags(self.get_or_create_test_user(), '')
-
-        self.assertQueryResult(query, [[tag]])
-
-    def test_query_bookmark_tags_should_only_return_user_owned_tags(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        owned_bookmarks = [
-            self.setup_bookmark(tags=[self.setup_tag()]),
-            self.setup_bookmark(tags=[self.setup_tag()]),
-            self.setup_bookmark(tags=[self.setup_tag()]),
-        ]
-        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
-        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
-        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
-
-        query = queries.query_bookmark_tags(self.user, '')
-
-        self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])
-
-    def test_query_archived_bookmark_tags_should_only_return_user_owned_tags(self):
-        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
-        owned_bookmarks = [
-            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
-            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
-            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
-        ]
-        self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
-        self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
-        self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
-
         query = queries.query_archived_bookmark_tags(self.user, '')
 
-        self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])
+        self.assertCountEqual([tag], list(query))

bookmarks/tests/test_settings_export_view.py

@@ -1,45 +0,0 @@
-from unittest.mock import patch
-
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-
-
-class SettingsExportViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def assertFormErrorHint(self, response, text: str):
-        self.assertContains(response, '<div class="has-error">')
-        self.assertContains(response, text)
-
-    def test_should_export_successfully(self):
-        self.setup_bookmark(tags=[self.setup_tag()])
-        self.setup_bookmark(tags=[self.setup_tag()])
-        self.setup_bookmark(tags=[self.setup_tag()])
-
-        response = self.client.get(
-            reverse('bookmarks:settings.export'),
-            follow=True
-        )
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response['content-type'], 'text/plain; charset=UTF-8')
-        self.assertEqual(response['Content-Disposition'], 'attachment; filename="bookmarks.html"')
-
-    def test_should_check_authentication(self):
-        self.client.logout()
-        response = self.client.get(reverse('bookmarks:settings.export'), follow=True)
-
-        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.export'))
-
-    def test_should_show_hint_when_export_raises_error(self):
-        with patch('bookmarks.services.exporter.export_netscape_html') as mock_export_netscape_html:
-            mock_export_netscape_html.side_effect = Exception('Nope')
-            response = self.client.get(reverse('bookmarks:settings.export'), follow=True)
-
-            self.assertTemplateUsed(response, 'settings/general.html')
-            self.assertFormErrorHint(response, 'An error occurred during bookmark export.')

bookmarks/tests/test_settings_general_view.py

@@ -1,40 +0,0 @@
-from django.test import TestCase
-from django.urls import reverse
-
-from bookmarks.tests.helpers import BookmarkFactoryMixin
-from bookmarks.models import UserProfile
-
-
-class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
-
-    def setUp(self) -> None:
-        user = self.get_or_create_test_user()
-        self.client.force_login(user)
-
-    def test_should_render_successfully(self):
-        response = self.client.get(reverse('bookmarks:settings.general'))
-
-        self.assertEqual(response.status_code, 200)
-
-    def test_should_check_authentication(self):
-        self.client.logout()
-        response = self.client.get(reverse('bookmarks:settings.general'), follow=True)
-
-        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.general'))
-
-    def test_should_save_profile(self):
-        form_data = {
-            'theme': UserProfile.THEME_DARK,
-            'bookmark_date_display': UserProfile.BOOKMARK_DATE_DISPLAY_HIDDEN,
-            'bookmark_link_target': UserProfile.BOOKMARK_LINK_TARGET_SELF,
-            'web_archive_integration': UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED,
-        }
-        response = self.client.post(reverse('bookmarks:settings.general'), form_data)
-
-        self.user.profile.refresh_from_db()
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(self.user.profile.theme, form_data['theme'])
-        self.assertEqual(self.user.profile.bookmark_date_display, form_data['bookmark_date_display'])
-        self.assertEqual(self.user.profile.bookmark_link_target, form_data['bookmark_link_target'])
-        self.assertEqual(self.user.profile.web_archive_integration, form_data['web_archive_integration'])