Bump version

Bumps [django](https://github.com/django/django) from 4.1.9 to 4.1.10.
- [Commits](https://github.com/django/django/compare/4.1.9...4.1.10)

---
updated-dependencies:
- dependency-name: django
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.devcontainer/devcontainer.json

@@ -0,0 +1,29 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/python
+{
+	"name": "Python 3",
+	"image": "mcr.microsoft.com/devcontainers/python:0-3.10",
+	"features": {
+		"ghcr.io/devcontainers/features/node:1": {}
+	},
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	"forwardPorts": [8000],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "pip3 install --user -r requirements.txt && npm install && mkdir -p data && python3 manage.py migrate",
+
+	// Configure tool-specific properties.
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-python.python"
+			]
+		}
+	},
+
+	"remoteUser": "vscode"
+}

.dockerignore

@@ -6,12 +6,15 @@
 /tmp
 /docs
 /static
+/scripts
 /build
 /out
 /.git
+/.devcontainer
 
 /.dockerignore
 /.gitignore
+/.gitattributes
 /Dockerfile
 /docker-compose.yml
 /*.sh

.env.sample

@@ -5,7 +5,45 @@ 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
 
+# Can be used to run linkding under a context path, for example: linkding/
+# Must end with a slash `/`
+LD_CONTEXT_PATH=
+# Username of the initial superuser to create, leave empty to not create one
+LD_SUPERUSER_NAME=
+# Password for the initial superuser, leave empty to disable credentials authentication and rely on proxy authentication instead
+LD_SUPERUSER_PASSWORD=
 # Option to disable background tasks
 LD_DISABLE_BACKGROUND_TASKS=False
 # Option to disable URL validation for bookmarks completely
 LD_DISABLE_URL_VALIDATION=False
+# Enables support for authentication proxies such as Authelia
+LD_ENABLE_AUTH_PROXY=False
+# Name of the request header that the auth proxy passes to the application to identify the user
+# See docs/Options.md for more details
+LD_AUTH_PROXY_USERNAME_HEADER=
+# The URL that linkding should redirect to after a logout, when using an auth proxy
+# See docs/Options.md for more details
+LD_AUTH_PROXY_LOGOUT_URL=
+# List of trusted origins from which to accept POST requests
+# See docs/Options.md for more details
+LD_CSRF_TRUSTED_ORIGINS=
+
+# Database settings
+# These are currently only required for configuring PostreSQL.
+# By default, linkding uses SQLite for which you don't need to configure anything.
+
+# Database engine, can be sqlite (default) or postgres
+LD_DB_ENGINE=
+# Database name (default: linkding)
+LD_DB_DATABASE=
+# Username to connect to the database server  (default: linkding)
+LD_DB_USER=
+# Password to connect to the database server
+LD_DB_PASSWORD=
+# The hostname where the database is hosted (default: localhost)
+LD_DB_HOST=
+# Port use to connect to the database server
+# Should use the default port if not set
+LD_DB_PORT=
+# Any additional options to pass to the database (default: {})
+LD_DB_OPTIONS=

.gitattributes

@@ -0,0 +1,2 @@
+* text=auto
+*.sh text eol=lf

.github/workflows/main.yaml

@@ -3,22 +3,45 @@ name: linkding CI
 on: [push]
 
 jobs:
-  run_tests:
-    name: Run Django Tests
+  unit_tests:
+    name: Unit Tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v3
       - name: Set up Python
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: "3.10"
       - name: Set up Node
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
-          node-version: 14
-      - name: Install Python dependencies
-        run: pip install -r requirements.txt
+          node-version: 18
       - name: Install Node dependencies
         run: npm install
+      - name: Setup Python environment
+        run: pip install -r requirements.txt
       - name: Run tests
-        run: python manage.py test
+        run: python manage.py test bookmarks.tests
+  e2e_tests:
+    name: E2E Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: Set up Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install Node dependencies
+        run: npm install
+      - name: Setup Python environment
+        run: |
+          pip install -r requirements.txt
+          playwright install chromium
+          python manage.py compilescss
+          python manage.py collectstatic --ignore=*.scss
+      - name: Run tests
+        run: python manage.py test bookmarks.e2e --pattern="e2e_test_*.py"

.gitignore

@@ -182,7 +182,9 @@ typings/
 
 ### Custom
 # Rollup compilation output
-/build
+/bookmarks/static/bundle.js*
+# SASS compilation output
+/bookmarks/static/theme-*.css*
 # Collected static files for deployment
 /static
 # Build output, etc.

.grenrc.js

@@ -1,6 +0,0 @@
-module.exports = {
-    ignoreIssuesWith: [
-        "wontfix",
-        "duplicate"
-    ]
-}

CHANGELOG.md

@@ -1,125 +1,382 @@
 # Changelog
 
+## v1.19.0 (20/05/2023)
+
+### What's Changed
+* Add notes to bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/472
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.18.0...v1.19.0
+
+---
+
+## v1.18.0 (18/05/2023)
+
+### What's Changed
+* Make search case-insensitive on Postgres by @sissbruecker in https://github.com/sissbruecker/linkding/pull/432
+* Allow searching for tags without hash character by @sissbruecker in https://github.com/sissbruecker/linkding/pull/449
+* Prevent zoom-in after focusing an input on small viewports on iOS devices by @puresick in https://github.com/sissbruecker/linkding/pull/440
+* Add database options by @plockaby in https://github.com/sissbruecker/linkding/pull/406
+* Allow to log real client ip in logs when using a reverse proxy by @fmenabe in https://github.com/sissbruecker/linkding/pull/398
+* Add option to display URL below title by @bah0 in https://github.com/sissbruecker/linkding/pull/365
+* Add LinkThing iOS app to community section by @amoscardino in https://github.com/sissbruecker/linkding/pull/446
+* Bump django from 4.1.7 to 4.1.9 by @dependabot in https://github.com/sissbruecker/linkding/pull/466
+* Bump sqlparse from 0.4.2 to 0.4.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/455
+
+### New Contributors
+* @amoscardino made their first contribution in https://github.com/sissbruecker/linkding/pull/446
+* @puresick made their first contribution in https://github.com/sissbruecker/linkding/pull/440
+* @plockaby made their first contribution in https://github.com/sissbruecker/linkding/pull/406
+* @fmenabe made their first contribution in https://github.com/sissbruecker/linkding/pull/398
+* @bah0 made their first contribution in https://github.com/sissbruecker/linkding/pull/365
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.2...v1.18.0
+
+---
+
+## v1.17.2 (18/02/2023)
+
+### What's Changed
+* Escape texts in exported HTML by @sissbruecker in https://github.com/sissbruecker/linkding/pull/429
+* Bump django from 4.1.2 to 4.1.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/427
+* Make health check in Dockerfile honor context path setting by @mrex in https://github.com/sissbruecker/linkding/pull/407
+* Disable autocapitalization for tag input form by @joshdick in https://github.com/sissbruecker/linkding/pull/395
+
+### New Contributors
+* @mrex made their first contribution in https://github.com/sissbruecker/linkding/pull/407
+* @joshdick made their first contribution in https://github.com/sissbruecker/linkding/pull/395
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.1...v1.17.2
+
+---
+
+## v1.17.1 (22/01/2023)
+
+### What's Changed
+* Fix favicon being cleared by web archive snapshot task by @sissbruecker in https://github.com/sissbruecker/linkding/pull/405
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.17.0...v1.17.1
+
+---
+
+## v1.17.0 (21/01/2023)
+
+### What's Changed
+* Add Health Check endpoint  by @mckennajones in https://github.com/sissbruecker/linkding/pull/392
+* Cache website metadata to avoid duplicate scraping by @sissbruecker in https://github.com/sissbruecker/linkding/pull/401
+* Prefill form if URL is already bookmarked by @sissbruecker in https://github.com/sissbruecker/linkding/pull/402
+* Add option for showing bookmark favicons by @sissbruecker in https://github.com/sissbruecker/linkding/pull/390
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.16.1...v1.17.0
+
+---
+
+## v1.16.1 (20/01/2023)
+
+### What's Changed
+* Fix bookmark website metadata not being updated when URL changes by @sissbruecker in https://github.com/sissbruecker/linkding/pull/400
+* Bump django from 4.1 to 4.1.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/391
+* Bump certifi from 2022.6.15 to 2022.12.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/374
+* Bump minimatch from 3.0.4 to 3.1.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/366
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.16.0...v1.16.1
+
+---
+
+## v1.16.0 (12/01/2023)
+
+### What's Changed
+* Add postgres as database engine by @tomamplius in https://github.com/sissbruecker/linkding/pull/388
+* Gracefully stop docker container when it receives SIGTERM by @mckennajones in https://github.com/sissbruecker/linkding/pull/368
+* Limit document size for website scraper by @sissbruecker in https://github.com/sissbruecker/linkding/pull/354
+* Add error handling for checking latest version by @sissbruecker in https://github.com/sissbruecker/linkding/pull/360
+* Trim website metadata title and description by @luca1197 in https://github.com/sissbruecker/linkding/pull/383
+* Only show admin link for superusers by @AlexanderS in https://github.com/sissbruecker/linkding/pull/384
+* Add apache reverse proxy documentation. by @jhauris in https://github.com/sissbruecker/linkding/pull/371
+* Correct LD_ENABLE_AUTH_PROXY documentation by @jhauris in https://github.com/sissbruecker/linkding/pull/379
+* Android HTTP shortcuts v3 by @kzshantonu in https://github.com/sissbruecker/linkding/pull/387
+
+### New Contributors
+* @jhauris made their first contribution in https://github.com/sissbruecker/linkding/pull/371
+* @AlexanderS made their first contribution in https://github.com/sissbruecker/linkding/pull/384
+* @mckennajones made their first contribution in https://github.com/sissbruecker/linkding/pull/368
+* @tomamplius made their first contribution in https://github.com/sissbruecker/linkding/pull/388
+* @luca1197 made their first contribution in https://github.com/sissbruecker/linkding/pull/383
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.15.1...v1.16.0
+
+---
+
+## v1.15.1 (05/10/2022)
+
+### What's Changed
+* Fix static file dir warning by @sissbruecker in https://github.com/sissbruecker/linkding/pull/350
+* Add setting and documentation for fixing CSRF errors by @sissbruecker in https://github.com/sissbruecker/linkding/pull/349
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.15.0...v1.15.1
+
+---
+
+## v1.15.0 (11/09/2022)
+
+### What's Changed
+* Bump Django and other dependencies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/331
+* Add option to create initial superuser by @sissbruecker in https://github.com/sissbruecker/linkding/pull/323
+* Improved Android HTTP Shortcuts doc by @kzshantonu in https://github.com/sissbruecker/linkding/pull/330
+* Minify bookmark list HTML by @sissbruecker in https://github.com/sissbruecker/linkding/pull/332
+* Bump python version to 3.10 by @sissbruecker in https://github.com/sissbruecker/linkding/pull/333
+* Fix error when deleting all bookmarks in admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/336
+* Improve bookmark query performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/334
+* Prevent rate limit errors in wayback machine API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/339
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.14.0...v1.15.0
+
+---
+
+## v1.14.0 (14/08/2022)
+
+### What's Changed
+* Add support for context path by @s2marine in https://github.com/sissbruecker/linkding/pull/313
+* Add support for authentication proxies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/321
+* Add bookmark list keyboard navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/320
+* Skip updating website metadata on edit unless URL has changed by @sissbruecker in https://github.com/sissbruecker/linkding/pull/318
+* Add simple docs of the new `shared` API parameter by @bachya in https://github.com/sissbruecker/linkding/pull/312
+* Add project linka to community section in README by @cmsax in https://github.com/sissbruecker/linkding/pull/319
+* Order tags in test_should_create_new_bookmark by @RoGryza in https://github.com/sissbruecker/linkding/pull/310
+* Bump django from 3.2.14 to 3.2.15 by @dependabot in https://github.com/sissbruecker/linkding/pull/316
+
+### New Contributors
+* @s2marine made their first contribution in https://github.com/sissbruecker/linkding/pull/313
+* @RoGryza made their first contribution in https://github.com/sissbruecker/linkding/pull/310
+* @cmsax made their first contribution in https://github.com/sissbruecker/linkding/pull/319
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.13.0...v1.14.0
+
+---
+
+## v1.13.0 (04/08/2022)
+
+### What's Changed
+* Add bookmark sharing by @sissbruecker in https://github.com/sissbruecker/linkding/pull/311
+* Display selected tags in tag cloud by @sissbruecker and @jhauris in https://github.com/sissbruecker/linkding/pull/307
+* Update unread flag when saving duplicate URL by @sissbruecker in https://github.com/sissbruecker/linkding/pull/306
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.12.0...v1.13.0
+
+---
+
+## v1.12.0 (23/07/2022)
+
+### What's Changed
+* Add read it later functionality by @sissbruecker in https://github.com/sissbruecker/linkding/pull/304
+* Add RSS feeds by @sissbruecker in https://github.com/sissbruecker/linkding/pull/305
+* Add bookmarklet to community by @ukcuddlyguy in https://github.com/sissbruecker/linkding/pull/293
+* Shorten and simplify example bookmarklet in documentation by @FunctionDJ in https://github.com/sissbruecker/linkding/pull/297
+* Fix typo by @kianmeng in https://github.com/sissbruecker/linkding/pull/295
+* Bump django from 3.2.13 to 3.2.14 by @dependabot in https://github.com/sissbruecker/linkding/pull/294
+* Bump svelte from 3.46.4 to 3.49.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/299
+* Bump terser from 5.5.1 to 5.14.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/302
+
+### New Contributors
+* @ukcuddlyguy made their first contribution in https://github.com/sissbruecker/linkding/pull/293
+* @FunctionDJ made their first contribution in https://github.com/sissbruecker/linkding/pull/297
+* @kianmeng made their first contribution in https://github.com/sissbruecker/linkding/pull/295
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.11.1...v1.12.0
+
+---
+
+## v1.11.1 (03/07/2022)
+
+### What's Changed
+* Fix duplicate tags on import by @wahlm in https://github.com/sissbruecker/linkding/pull/289
+* Add apple-touch-icon by @daveonkels in https://github.com/sissbruecker/linkding/pull/282
+* Bump waybackpy to 3.0.6 by @dustinblackman in https://github.com/sissbruecker/linkding/pull/281
+
+### New Contributors
+* @wahlm made their first contribution in https://github.com/sissbruecker/linkding/pull/289
+* @daveonkels made their first contribution in https://github.com/sissbruecker/linkding/pull/282
+* @dustinblackman made their first contribution in https://github.com/sissbruecker/linkding/pull/281
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.11.0...v1.11.1
+
+---
+
+## v1.11.0 (26/05/2022)
+
+### What's Changed
+* Add background tasks to admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/264
+* Improve about section by @sissbruecker in https://github.com/sissbruecker/linkding/pull/265
+* Allow creating archived bookmark through REST API by @kencx in https://github.com/sissbruecker/linkding/pull/268
+* Add PATCH support to bookmarks endpoint by @sissbruecker in https://github.com/sissbruecker/linkding/pull/269
+* Add community reference to linkding-cli by @bachya in https://github.com/sissbruecker/linkding/pull/270
+
+### New Contributors
+* @kencx made their first contribution in https://github.com/sissbruecker/linkding/pull/268
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.10.1...v1.11.0
+
+---
+
+## v1.10.1 (21/05/2022)
+
+### What's Changed
+* Fake request headers to reduce bot detection by @sissbruecker in https://github.com/sissbruecker/linkding/pull/263
+
+
+**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.10.0...v1.10.1
+
+---
+
 ## v1.10.0 (21/05/2022)
-### What's Changed
-* Add to managed hosting options by @m3nu in https://github.com/sissbruecker/linkding/pull/253
-* Add community reference to aiolinkding by @bachya in https://github.com/sissbruecker/linkding/pull/259
-* Improve import performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/261
-* Update how-to.md to fix unclear/paraphrased Safari action in IOS Shortcuts by @feoh in https://github.com/sissbruecker/linkding/pull/260
-* Allow searching for untagged bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/226
-
-### New Contributors
-* @m3nu made their first contribution in https://github.com/sissbruecker/linkding/pull/253
-* @bachya made their first contribution in https://github.com/sissbruecker/linkding/pull/259
-* @feoh made their first contribution in https://github.com/sissbruecker/linkding/pull/260
 
+### What's Changed
+* Add to managed hosting options by @m3nu in https://github.com/sissbruecker/linkding/pull/253
+* Add community reference to aiolinkding by @bachya in https://github.com/sissbruecker/linkding/pull/259
+* Improve import performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/261
+* Update how-to.md to fix unclear/paraphrased Safari action in IOS Shortcuts by @feoh in https://github.com/sissbruecker/linkding/pull/260
+* Allow searching for untagged bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/226
+
+### New Contributors
+* @m3nu made their first contribution in https://github.com/sissbruecker/linkding/pull/253
+* @bachya made their first contribution in https://github.com/sissbruecker/linkding/pull/259
+* @feoh made their first contribution in https://github.com/sissbruecker/linkding/pull/260
+
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.9.0...v1.10.0
 
 ---
 
 ## v1.9.0 (14/05/2022)
-### What's Changed
-* Scroll menu items into view when using keyboard by @sissbruecker in https://github.com/sissbruecker/linkding/pull/248
-* Add whitespace after auto-completed tag by @sissbruecker in https://github.com/sissbruecker/linkding/pull/249
-* Bump django from 3.2.12 to 3.2.13 by @dependabot in https://github.com/sissbruecker/linkding/pull/244
-* Add community helm chart reference to readme by @pascaliske in https://github.com/sissbruecker/linkding/pull/242
-* Feature: Shortcut key for new bookmark by @rithask in https://github.com/sissbruecker/linkding/pull/241
-* Clarify archive.org feature by @clach04 in https://github.com/sissbruecker/linkding/pull/229
-* Make Internet Archive integration opt-in by @sissbruecker in https://github.com/sissbruecker/linkding/pull/250
-
-### New Contributors
-* @pascaliske made their first contribution in https://github.com/sissbruecker/linkding/pull/242
-* @rithask made their first contribution in https://github.com/sissbruecker/linkding/pull/241
-* @clach04 made their first contribution in https://github.com/sissbruecker/linkding/pull/229
 
+### What's Changed
+* Scroll menu items into view when using keyboard by @sissbruecker in https://github.com/sissbruecker/linkding/pull/248
+* Add whitespace after auto-completed tag by @sissbruecker in https://github.com/sissbruecker/linkding/pull/249
+* Bump django from 3.2.12 to 3.2.13 by @dependabot in https://github.com/sissbruecker/linkding/pull/244
+* Add community helm chart reference to readme by @pascaliske in https://github.com/sissbruecker/linkding/pull/242
+* Feature: Shortcut key for new bookmark by @rithask in https://github.com/sissbruecker/linkding/pull/241
+* Clarify archive.org feature by @clach04 in https://github.com/sissbruecker/linkding/pull/229
+* Make Internet Archive integration opt-in by @sissbruecker in https://github.com/sissbruecker/linkding/pull/250
+
+### New Contributors
+* @pascaliske made their first contribution in https://github.com/sissbruecker/linkding/pull/242
+* @rithask made their first contribution in https://github.com/sissbruecker/linkding/pull/241
+* @clach04 made their first contribution in https://github.com/sissbruecker/linkding/pull/229
+
 **Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.8.8...v1.9.0
+
 ---
 
 ## v1.8.8 (27/03/2022)
-- [**bug**] Prevent bookmark actions through get requests
+
+- [**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)
+
+- [**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
+
+- [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)
+## v1.8.5 (12/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)
+
+- [**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/)
+
+- [**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)
+
+- [**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
+
+- 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)
+## v1.6.3 (06/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)
@@ -128,46 +385,57 @@
 ---
 
 ## 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)
+## v1.6.0 (28/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
+
+- 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)
@@ -179,16 +447,40 @@
 ---
 
 ## 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)
 
 ---
 
 ## v1.2.0 (09/01/2021)
+
 - [**closed**] Add Favicon [#58](https://github.com/sissbruecker/linkding/issues/58)
 - [**closed**] Make tags case-insensitive [#45](https://github.com/sissbruecker/linkding/issues/45)
 
 ---
 
 ## v1.1.1 (01/01/2021)
-- [**enhancement**] Add docker-compose support [#54](https://github.com/sissbruecker/linkding/pull/54)
+
+- [**enhancement**] Add docker-compose support [#54](https://github.com/sissbruecker/linkding/pull/54)
+
+---
+
+## v1.1.0 (31/12/2020)
+
+- [**enhancement**] Search autocomplete [#52](https://github.com/sissbruecker/linkding/issues/52)
+- [**enhancement**] Improve Netscape bookmarks file parsing [#50](https://github.com/sissbruecker/linkding/issues/50)
+
+---
+
+## v1.0.0 (31/12/2020)
+
+- [**bug**] Import does not import bookmark descriptions [#47](https://github.com/sissbruecker/linkding/issues/47)
+- [**enhancement**] Enhancement: return to same page we were on after editing a bookmark [#26](https://github.com/sissbruecker/linkding/issues/26)
+- [**bug**] Increase limit on bookmark URL length [#25](https://github.com/sissbruecker/linkding/issues/25)
+- [**enhancement**] API for app development [#24](https://github.com/sissbruecker/linkding/issues/24)
+- [**enhancement**] Enhancement: detect duplicates at entry time [#23](https://github.com/sissbruecker/linkding/issues/23)
+- [**bug**] Error importing bookmarks [#18](https://github.com/sissbruecker/linkding/issues/18)
+- [**enhancement**] Enhancement: better administration page [#4](https://github.com/sissbruecker/linkding/issues/4)
+- [**enhancement**] Bug: Navigation bar active link stays on add bookmark [#3](https://github.com/sissbruecker/linkding/issues/3)
+- [**bug**] CSS Stylesheet presented as text/plain [#2](https://github.com/sissbruecker/linkding/issues/2)

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:current-alpine AS node-build
+FROM node:18.13.0-alpine AS node-build
 WORKDIR /etc/linkding
 # install build dependencies
 COPY package.json package-lock.json ./
@@ -9,8 +9,8 @@ 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
+FROM python:3.10.6-slim-buster AS python-base
+RUN apt-get update && apt-get -y install build-essential libpq-dev
 WORKDIR /etc/linkding
 
 
@@ -33,8 +33,8 @@ RUN mkdir /opt/venv && \
     /opt/venv/bin/pip install -Ur requirements.txt
 
 
-FROM python:3.9.6-slim-buster as final
-RUN apt-get update && apt-get -y install mime-support
+FROM python:3.10.6-slim-buster as final
+RUN apt-get update && apt-get -y install mime-support libpq-dev curl
 WORKDIR /etc/linkding
 # copy prod dependencies
 COPY --from=prod-deps /opt/venv /opt/venv
@@ -51,4 +51,8 @@ ENV PATH /opt/venv/bin:$PATH
 RUN ["chmod", "g+w", "."]
 # Run bootstrap logic
 RUN ["chmod", "+x", "./bootstrap.sh"]
+
+HEALTHCHECK --interval=30s --retries=3 --timeout=1s \
+CMD curl -f http://localhost:${LD_SERVER_PORT:-9090}/${LD_CONTEXT_PATH}health || exit 1
+
 CMD ["./bootstrap.sh"]

README.md

@@ -12,15 +12,17 @@
     - [Using Docker](#using-docker)
     - [Using Docker Compose](#using-docker-compose)
     - [User Setup](#user-setup)
+    - [Reverse Proxy Setup](#reverse-proxy-setup)
     - [Managed Hosting Options](#managed-hosting-options)
 - [Documentation](#documentation)
 - [Browser Extension](#browser-extension)
 - [Community](#community)
+- [Acknowledgements](#acknowledgements)
 - [Development](#development)
 
 ##  Introduction
 
-linkding is a simple bookmark service that you can host yourself.
+linkding is a bookmark manager that you can host yourself.
 It's designed be to be minimal, fast, and easy to set up using Docker.
 
 The name comes from:
@@ -29,21 +31,23 @@ The name comes from:
 - ...so basically something for managing your links
 
 **Feature Overview:**
-- Tags for organizing bookmarks
-- Search by text or tags
+- Clean UI optimized for readability
+- Organize bookmarks with tags
+- Add notes using Markdown
+- Read it later functionality
+- Share bookmarks with other users
 - Bulk editing
-- Bookmark archive
-- Dark mode
+- Automatically provides titles, descriptions and icons of bookmarked websites
 - 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
+- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
+- Light and dark themes
 - 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
+- Easy setup using Docker and a SQLite database, with PostgreSQL as an option
 
 
-**Demo:** https://demo.linkding.link/ (configured with open registration)
+**Demo:** https://demo.linkding.link/ ([see here](https://github.com/sissbruecker/linkding/issues/408) if you have trouble accessing it)
 
 **Screenshot:**
 
@@ -51,21 +55,23 @@ The name comes from:
 
 ## Installation
 
-linkding is designed to be run with container solutions like [Docker](https://docs.docker.com/get-started/).  The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.
+linkding is designed to be run with container solutions like [Docker](https://docs.docker.com/get-started/).
+The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.
+
+By default, linkding uses SQLite as a database.
+Alternatively linkding supports PostgreSQL, see the [database options](docs/Options.md#LD_DB_ENGINE) for more information.
 
 ###  Using Docker
 
 To install linkding using Docker you can just run the [latest image](https://hub.docker.com/repository/docker/sissbruecker/linkding) from Docker Hub:
 ```shell
-docker run --name linkding -p 9090:9090 -d sissbruecker/linkding:latest
-```
-By default, the application runs on port `9090`, you can map it to a different host port by modifying the port mapping in the command above. If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090, provided you did not change the port mapping.
-
-Note that the command above will store the linkding SQLite database in the container, which means that deleting the container, for example when upgrading the installation, will also remove the database. For hosting an actual installation you usually want to store the database on the host system, rather than in the container. To do so, run the following command, and replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database:
-```shell
 docker run --name linkding -p 9090:9090 -v {host-data-folder}:/etc/linkding/data -d sissbruecker/linkding:latest
 ```
 
+In the command above, replace the `{host-data-folder}` placeholder with an absolute path to a folder on your host system where you want to store the linkding database.
+
+If everything completed successfully, the application should now be running and can be accessed at http://localhost:9090.
+
 To upgrade the installation to a new version, remove the existing container, pull the latest version of the linkding Docker image, and then start a new container using the same command that you used above. There is a [shell script](https://github.com/sissbruecker/linkding/blob/master/install-linkding.sh) available to automate these steps. The script can be configured using environment variables, or you can just modify it.
 
 To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.
@@ -95,9 +101,66 @@ docker-compose exec linkding python manage.py createsuperuser --username=joe --e
 
 The command will prompt you for a secure password. After the command has completed you can start using the application by logging into the UI with your credentials.
 
+Alternatively you can automatically create an initial superuser on startup using the [`LD_SUPERUSER_NAME` option](docs/Options.md#LD_SUPERUSER_NAME). 
+
+### Reverse Proxy Setup
+
+When using a reverse proxy, such as Nginx or Apache, you may need to configure your proxy to correctly forward the `Host` header to linkding, otherwise certain requests, such as login, might fail.
+
+<details>
+<summary>Apache</summary>
+
+Apache2 does not change the headers by default, and should not
+need additional configuration.
+
+An example virtual host that proxies to linkding might look like:
+```
+<VirtualHost *:9100>
+    <Proxy *>
+        Order deny,allow
+        Allow from all
+    </Proxy>
+
+    ProxyPass / http://linkding:9090/
+    ProxyPassReverse / http://linkding:9090/
+</VirtualHost>
+```
+
+For a full example, see the docker-compose configuration in [jhauris/apache2-reverse-proxy](https://github.com/jhauris/linkding/tree/apache2-reverse-proxy)
+
+If you still run into CSRF issues, please check out the [`LD_CSRF_TRUSTED_ORIGINS` option](docs/Options.md#LD_CSRF_TRUSTED_ORIGINS).
+
+</details>
+
+<details>
+<summary>Caddy 2</summary>
+
+Caddy does not change the headers by default, and should not need any further configuration.
+
+If you still run into CSRF issues, please check out the [`LD_CSRF_TRUSTED_ORIGINS` option](docs/Options.md#LD_CSRF_TRUSTED_ORIGINS).
+
+</details>
+
+<details>
+<summary>Nginx</summary>
+
+Nginx by default rewrites the `Host` header to whatever URL is used in the `proxy_pass` directive.
+To forward the correct headers to linkding, add the following directives to the location block of your Nginx config:
+```
+location /linkding {
+    ...
+    proxy_set_header Host $host;
+    proxy_set_header X-Forwarded-Proto $scheme;
+}
+```
+
+</details>
+
+Instead of configuring header forwarding in your proxy, you can also configure the URL from which you want to access your linkding instance with the  [`LD_CSRF_TRUSTED_ORIGINS` option](docs/Options.md#LD_CSRF_TRUSTED_ORIGINS).
+
 ### Managed Hosting Options
 
-Self-hosting web applications on your own hardware (unfortunately) still requires a lot of technical know-how, and commitment to maintenance, with regard to keeping everything up-to-date and secure. This can be a huge entry barrier for people who are interested in self-hosting linkding, but lack the technical knowledge to do so. This section is intended to provide alternatives in form of managed hosting solutions. Note that these options are usually commercial offerings, that require paying a (usually monthly) fee for the convenience of being managed by another party. The technical knowledge required to make use of individual options is going to vary, and no guarantees can be made that every option is accessible for everyone. That being said, I hope this section helps in making the application accessible to a wider audience.
+Self-hosting web applications still requires a lot of technical know-how, and commitment to maintenance, with regard to keeping everything up-to-date and secure. This can be a huge entry barrier for people who are interested in self-hosting, but lack the technical knowledge to do so. This section is intended to provide alternatives in form of managed hosting solutions. Note that these options are usually commercial offerings, that require paying a fee for the convenience of being managed by another party. The technical knowledge required to make use of individual options is going to vary, and no guarantees can be made that every option is accessible for everyone. That being said, I hope this section helps in making the application accessible to a wider audience.
 
 - [linkding on fly.io](https://github.com/fspoettel/linkding-on-fly) - Guide for hosting a linkding installation on [fly.io](https://fly.io). By [fspoettel](https://github.com/fspoettel)
 - [PikaPods.com](https://www.pikapods.com/) - Managed hosting for linkding, EU and US regions available. [1-click setup link](https://www.pikapods.com/pods?run=linkding)
@@ -110,6 +173,7 @@ Self-hosting web applications on your own hardware (unfortunately) still require
 | [Backups](https://github.com/sissbruecker/linkding/blob/master/docs/backup.md)                  | How to backup the linkding database                      |
 | [Troubleshooting](https://github.com/sissbruecker/linkding/blob/master/docs/troubleshooting.md) | Advice for troubleshooting common problems               |
 | [How To](https://github.com/sissbruecker/linkding/blob/master/docs/how-to.md)                   | Tips and tricks around using linking                     |
+| [Keyboard shortcuts](https://github.com/sissbruecker/linkding/blob/master/docs/shortcuts.md)    | List of available keyboard shortcuts                     |
 | [Admin documentation](https://github.com/sissbruecker/linkding/blob/master/docs/Admin.md)       | User documentation for the Admin UI                      |
 | [API documentation](https://github.com/sissbruecker/linkding/blob/master/docs/API.md)           | Documentation for the REST API                           |
 
@@ -125,17 +189,26 @@ The extension is open-source as well, and can be found [here](https://github.com
 
 This section lists community projects around using linkding, in alphabetical order. If you have a project that you want to share with the linkding community, feel free to submit a PR to add your project to this section.
 
+- [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
 - [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
+- [Linka!](https://github.com/cmsax/linka) Web app (also a PWA) for quickly searching & opening bookmarks in linkding, support multi keywords, exclude mode and other advance options. By [cmsax](https://github.com/cmsax)
+- [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
 - [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)
-- [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
+- [LinkThing](https://apps.apple.com/us/app/linkthing/id1666031776) An iOS client for linkding. By [amoscardino](https://github.com/amoscardino)
+- [Open all links bookmarklet](https://gist.github.com/ukcuddlyguy/336dd7339e6d35fc64a75ccfc9323c66) A browser bookmarklet to open all links on the current Linkding page in new tabs. By [ukcuddlyguy](https://github.com/ukcuddlyguy)
+- [Postman collection](https://gist.github.com/gingerbeardman/f0b42502f3bc9344e92ce63afd4360d3) a group of saved request templates for API testing. By [gingerbeardman](https://github.com/gingerbeardman)
+
+## Acknowledgements
+
+JetBrains provides an open-source license of [IntelliJ IDEA](https://www.jetbrains.com/idea/) for the development of linkding.
 
 ## 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/4.1/). 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
+- Python 3.10
 - Node.js
 
 ### Setup
@@ -174,3 +247,23 @@ Start the Django development server with:
 python3 manage.py runserver
 ```
 The frontend is now available under http://localhost:8000
+
+### DevContainers
+
+This repository also supports DevContainers: [![Open in Remote - Containers](https://img.shields.io/static/v1?label=Remote%20-%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=git@github.com:sissbruecker/linkding.git)
+
+Once checked out, only the following commands are required to get started:
+
+Create a user for the frontend:
+```
+python3 manage.py createsuperuser --username=joe --email=joe@example.com
+```
+Start the Node.js development server (used for compiling JavaScript components like tag auto-completion) with:
+```
+npm run dev
+```
+Start the Django development server with:
+```
+python3 manage.py runserver
+```
+The frontend is now available under http://localhost:8000

bookmarks/admin.py

@@ -1,3 +1,5 @@
+from background_task.admin import TaskAdmin, CompletedTaskAdmin
+from background_task.models import Task, CompletedTask
 from django.contrib import admin, messages
 from django.contrib.admin import AdminSite
 from django.contrib.auth.admin import UserAdmin
@@ -7,7 +9,7 @@ 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.models import Bookmark, Tag, UserProfile, Toast, FeedToken
 from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
 
 
@@ -19,9 +21,27 @@ class LinkdingAdminSite(AdminSite):
 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',)
+    list_filter = ('owner__username', 'is_archived', 'unread', 'tags',)
     ordering = ('-date_added',)
-    actions = ['archive_selected_bookmarks', 'unarchive_selected_bookmarks']
+    actions = ['delete_selected_bookmarks', 'archive_selected_bookmarks', 'unarchive_selected_bookmarks', 'mark_as_read', 'mark_as_unread']
+
+    def get_actions(self, request):
+        actions = super().get_actions(request)
+        # Remove default delete action, which gets replaced by delete_selected_bookmarks below
+        # The default action shows a confirmation page which can fail in production when selecting all bookmarks and the
+        # number of objects to delete exceeds the value in DATA_UPLOAD_MAX_NUMBER_FIELDS (1000 by default)
+        del actions['delete_selected']
+        return actions
+
+    def delete_selected_bookmarks(self, request, queryset: QuerySet):
+        bookmarks_count = queryset.count()
+        for bookmark in queryset:
+            bookmark.delete()
+        self.message_user(request, ngettext(
+            '%d bookmark was successfully deleted.',
+            '%d bookmarks were successfully deleted.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
 
     def archive_selected_bookmarks(self, request, queryset: QuerySet):
         for bookmark in queryset:
@@ -43,6 +63,24 @@ class AdminBookmark(admin.ModelAdmin):
             bookmarks_count,
         ) % bookmarks_count, messages.SUCCESS)
 
+    def mark_as_read(self, request, queryset: QuerySet):
+        bookmarks_count = queryset.count()
+        queryset.update(unread=False)
+        self.message_user(request, ngettext(
+            '%d bookmark marked as read.',
+            '%d bookmarks marked as read.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
+
+    def mark_as_unread(self, request, queryset: QuerySet):
+        bookmarks_count = queryset.count()
+        queryset.update(unread=True)
+        self.message_user(request, ngettext(
+            '%d bookmark marked as unread.',
+            '%d bookmarks marked as unread.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
+
 
 class AdminTag(admin.ModelAdmin):
     list_display = ('name', 'bookmarks_count', 'owner', 'date_added')
@@ -101,9 +139,18 @@ class AdminToast(admin.ModelAdmin):
     list_filter = ('owner__username',)
 
 
+class AdminFeedToken(admin.ModelAdmin):
+    list_display = ('key', 'user')
+    search_fields = ['key']
+    list_filter = ('user__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)
+linkding_admin_site.register(FeedToken, AdminFeedToken)
+linkding_admin_site.register(Task, TaskAdmin)
+linkding_admin_site.register(CompletedTask, CompletedTaskAdmin)

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
@@ -6,9 +5,9 @@ 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
+from bookmarks.models import Bookmark, BookmarkFilters, Tag, User
+from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark, website_loader
+from bookmarks.services.website_loader import WebsiteMetadata
 
 
 class BookmarkViewSet(viewsets.GenericViewSet,
@@ -24,7 +23,7 @@ class BookmarkViewSet(viewsets.GenericViewSet,
         # For list action, use query set that applies search and tag projections
         if self.action == 'list':
             query_string = self.request.GET.get('q')
-            return queries.query_bookmarks(user, query_string)
+            return queries.query_bookmarks(user, user.profile, query_string)
 
         # For single entity actions use default query set without projections
         return Bookmark.objects.all().filter(owner=user)
@@ -36,7 +35,17 @@ class BookmarkViewSet(viewsets.GenericViewSet,
     def archived(self, request):
         user = request.user
         query_string = request.GET.get('q')
-        query_set = queries.query_archived_bookmarks(user, query_string)
+        query_set = queries.query_archived_bookmarks(user, user.profile, query_string)
+        page = self.paginate_queryset(query_set)
+        serializer = self.get_serializer_class()
+        data = serializer(page, many=True).data
+        return self.get_paginated_response(data)
+
+    @action(methods=['get'], detail=False)
+    def shared(self, request):
+        filters = BookmarkFilters(request)
+        user = User.objects.filter(username=filters.user).first()
+        query_set = queries.query_shared_bookmarks(user, request.user.profile, filters.query)
         page = self.paginate_queryset(query_set)
         serializer = self.get_serializer_class()
         data = serializer(page, many=True).data
@@ -58,15 +67,13 @@ class BookmarkViewSet(viewsets.GenericViewSet,
     def check(self, request):
         url = request.GET.get('url')
         bookmark = Bookmark.objects.filter(owner=request.user, url=url).first()
-        existing_bookmark_data = None
+        existing_bookmark_data = self.get_serializer(bookmark).data if bookmark else 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)
+        # Either return metadata from existing bookmark, or scrape from URL
+        if bookmark:
+            metadata = WebsiteMetadata(url, bookmark.website_title, bookmark.website_description)
+        else:
+            metadata = website_loader.load_website_metadata(url)
 
         return Response({
             'bookmark': existing_bookmark_data,

bookmarks/api/serializers.py

@@ -1,4 +1,6 @@
+from django.db.models import prefetch_related_objects
 from rest_framework import serializers
+from rest_framework.serializers import ListSerializer
 
 from bookmarks.models import Bookmark, Tag, build_tag_string
 from bookmarks.services.bookmarks import create_bookmark, update_bookmark
@@ -9,6 +11,14 @@ class TagListField(serializers.ListField):
     child = serializers.CharField()
 
 
+class BookmarkListSerializer(ListSerializer):
+    def to_representation(self, data):
+        # Prefetch nested relations to avoid n+1 queries
+        prefetch_related_objects(data, 'tags')
+
+        return super().to_representation(data)
+
+
 class BookmarkSerializer(serializers.ModelSerializer):
     class Meta:
         model = Bookmark
@@ -17,8 +27,12 @@ class BookmarkSerializer(serializers.ModelSerializer):
             'url',
             'title',
             'description',
+            'notes',
             'website_title',
             'website_description',
+            'is_archived',
+            'unread',
+            'shared',
             'tag_names',
             'date_added',
             'date_modified'
@@ -29,10 +43,15 @@ class BookmarkSerializer(serializers.ModelSerializer):
             'date_added',
             'date_modified'
         ]
+        list_serializer_class = BookmarkListSerializer
 
     # 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='')
+    notes = serializers.CharField(required=False, allow_blank=True, default='')
+    is_archived = serializers.BooleanField(required=False, default=False)
+    unread = serializers.BooleanField(required=False, default=False)
+    shared = serializers.BooleanField(required=False, default=False)
     # Override readonly tag_names property to allow passing a list of tag names to create/update
     tag_names = TagListField(required=False, default=[])
 
@@ -41,14 +60,24 @@ class BookmarkSerializer(serializers.ModelSerializer):
         bookmark.url = validated_data['url']
         bookmark.title = validated_data['title']
         bookmark.description = validated_data['description']
+        bookmark.notes = validated_data['notes']
+        bookmark.is_archived = validated_data['is_archived']
+        bookmark.unread = validated_data['unread']
+        bookmark.shared = validated_data['shared']
         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'])
+        # Update fields if they were provided in the payload
+        for key in ['url', 'title', 'description', 'notes', 'unread', 'shared']:
+            if key in validated_data:
+                setattr(instance, key, validated_data[key])
+
+        # Use tag string from payload, or use bookmark's current tags as fallback
+        tag_string = build_tag_string(instance.tag_names)
+        if 'tag_names' in validated_data:
+            tag_string = build_tag_string(validated_data['tag_names'])
+
         return update_bookmark(instance, tag_string, self.context['user'])
 
 

bookmarks/components/SearchAutoComplete.svelte

@@ -8,8 +8,9 @@
     export let placeholder;
     export let value;
     export let tags;
-    export let mode = 'default';
+    export let mode = '';
     export let apiClient;
+    export let filters;
 
     let isFocus = false;
     let isOpen = false;
@@ -112,9 +113,12 @@
         let bookmarks = []
 
         if (value && value.length >= 3) {
-            const fetchedBookmarks = mode === 'archive'
-                ? await apiClient.getArchivedBookmarks(value, {limit: 5, offset: 0})
-                : await apiClient.getBookmarks(value, {limit: 5, offset: 0})
+            const path = mode ? `/${mode}` : ''
+            const suggestionFilters = {
+                ...filters,
+                q: value
+            }
+            const fetchedBookmarks = await apiClient.listBookmarks(suggestionFilters, {limit: 5, offset: 0, path})
             bookmarks = fetchedBookmarks.map(bookmark => {
                 const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
                 const label = clampText(fullLabel, 60)

bookmarks/components/TagAutocomplete.svelte

@@ -119,7 +119,7 @@
     <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
         <!-- autocomplete real input box -->
         <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
-               class="form-input" type="text" autocomplete="off"
+               class="form-input" type="text" autocomplete="off" autocapitalize="off"
                on:input={handleInput} on:keydown={handleKeyDown}
                on:focus={handleFocus} on:blur={handleBlur}>
     </div>

bookmarks/components/api.js

@@ -3,18 +3,19 @@ export class ApiClient {
         this.baseUrl = baseUrl
     }
 
-    getBookmarks(query, options = {limit: 100, offset: 0}) {
-        const encodedQuery = encodeURIComponent(query)
-        const url = `${this.baseUrl}bookmarks/?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
-
-        return fetch(url)
-            .then(response => response.json())
-            .then(data => data.results)
-    }
-
-    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}`
+    listBookmarks(filters, options = {limit: 100, offset: 0, path: ''}) {
+        const query = [
+          `limit=${options.limit}`,
+          `offset=${options.offset}`,
+        ]
+        Object.keys(filters).forEach(key => {
+            const value = filters[key]
+            if (value) {
+                query.push(`${key}=${encodeURIComponent(value)}`)
+            }
+        })
+        const queryString = query.join('&')
+        const url = `${this.baseUrl}bookmarks${options.path}/?${queryString}`
 
         return fetch(url)
             .then(response => response.json())

bookmarks/e2e/e2e_test_bookmark_form.py

@@ -0,0 +1,67 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
+    def test_create_should_check_for_existing_bookmark(self):
+        existing_bookmark = self.setup_bookmark(title='Existing title',
+                                                description='Existing description',
+                                                notes='Existing notes',
+                                                tags=[self.setup_tag(name='tag1'), self.setup_tag(name='tag2')],
+                                                website_title='Existing website title',
+                                                website_description='Existing website description',
+                                                unread=True)
+        tag_names = ' '.join(existing_bookmark.tag_names)
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:new'))
+
+            # Enter bookmarked URL
+            page.get_by_label('URL').fill(existing_bookmark.url)
+            # Already bookmarked hint should be visible
+            page.get_by_text('This URL is already bookmarked.').wait_for(timeout=2000)
+            # Form should be pre-filled with data from existing bookmark
+            self.assertEqual(existing_bookmark.title, page.get_by_label('Title').input_value())
+            self.assertEqual(existing_bookmark.description, page.get_by_label('Description').input_value())
+            self.assertEqual(existing_bookmark.notes, page.get_by_label('Notes').input_value())
+            self.assertEqual(existing_bookmark.website_title, page.get_by_label('Title').get_attribute('placeholder'))
+            self.assertEqual(existing_bookmark.website_description,
+                             page.get_by_label('Description').get_attribute('placeholder'))
+            self.assertEqual(tag_names, page.get_by_label('Tags').input_value())
+            self.assertTrue(tag_names, page.get_by_label('Mark as unread').is_checked())
+
+            # Enter non-bookmarked URL
+            page.get_by_label('URL').fill('https://example.com/unknown')
+            # Already bookmarked hint should be hidden
+            page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden', timeout=2000)
+
+            browser.close()
+
+    def test_edit_should_not_check_for_existing_bookmark(self):
+        bookmark = self.setup_bookmark()
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:edit', args=[bookmark.id]))
+
+            page.wait_for_timeout(timeout=1000)
+            page.get_by_text('This URL is already bookmarked.').wait_for(state='hidden')
+
+    def test_enter_url_of_existing_bookmark_should_show_notes(self):
+        bookmark = self.setup_bookmark(notes='Existing notes', description='Existing description')
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:new'))
+
+            details = page.locator('details.notes')
+            expect(details).not_to_have_attribute('open', value='')
+
+            page.get_by_label('URL').fill(bookmark.url)
+            expect(details).to_have_attribute('open', value='')

bookmarks/e2e/e2e_test_bookmark_list.py

@@ -0,0 +1,27 @@
+from unittest import skip
+
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+@skip("Fails in CI, needs investigation")
+class BookmarkListE2ETestCase(LinkdingE2ETestCase):
+    def test_toggle_notes_should_show_hide_notes(self):
+        self.setup_bookmark(notes='Test notes')
+
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:index'))
+
+            notes = page.locator('li .notes')
+            expect(notes).to_be_hidden()
+
+            toggle_notes = page.locator('li button.toggle-notes')
+            toggle_notes.click()
+            expect(notes).to_be_visible()
+
+            toggle_notes.click()
+            expect(notes).to_be_hidden()

bookmarks/e2e/e2e_test_global_shortcuts.py

@@ -0,0 +1,30 @@
+from django.urls import reverse
+from playwright.sync_api import sync_playwright, expect
+
+from bookmarks.e2e.helpers import LinkdingE2ETestCase
+
+
+class GlobalShortcutsE2ETestCase(LinkdingE2ETestCase):
+    def test_focus_search(self):
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:index'))
+
+            page.press('body', 's')
+
+            expect(page.get_by_placeholder('Search for words or #tags')).to_be_focused()
+
+            browser.close()
+
+    def test_add_bookmark(self):
+        with sync_playwright() as p:
+            browser = self.setup_browser(p)
+            page = browser.new_page()
+            page.goto(self.live_server_url + reverse('bookmarks:index'))
+
+            page.press('body', 'n')
+
+            expect(page).to_have_url(self.live_server_url + reverse('bookmarks:new'))
+
+            browser.close()

bookmarks/e2e/helpers.py

@@ -0,0 +1,21 @@
+from django.contrib.staticfiles.testing import LiveServerTestCase
+from playwright.sync_api import BrowserContext
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class LinkdingE2ETestCase(LiveServerTestCase, BookmarkFactoryMixin):
+    def setUp(self) -> None:
+        self.client.force_login(self.get_or_create_test_user())
+        self.cookie = self.client.cookies['sessionid']
+
+    def setup_browser(self, playwright) -> BrowserContext:
+        browser = playwright.chromium.launch(headless=True)
+        context = browser.new_context()
+        context.add_cookies([{
+            'name': 'sessionid',
+            'value': self.cookie.value,
+            'domain': self.live_server_url.replace('http:', ''),
+            'path': '/'
+        }])
+        return context

bookmarks/feeds.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+
+from django.contrib.syndication.views import Feed
+from django.db.models import QuerySet
+from django.urls import reverse
+
+from bookmarks.models import Bookmark, FeedToken
+from bookmarks import queries
+
+
+@dataclass
+class FeedContext:
+    feed_token: FeedToken
+    query_set: QuerySet[Bookmark]
+
+
+class BaseBookmarksFeed(Feed):
+    def get_object(self, request, feed_key: str):
+        feed_token = FeedToken.objects.get(key__exact=feed_key)
+        query_string = request.GET.get('q')
+        query_set = queries.query_bookmarks(feed_token.user, feed_token.user.profile, query_string)
+        return FeedContext(feed_token, query_set)
+
+    def item_title(self, item: Bookmark):
+        return item.resolved_title
+
+    def item_description(self, item: Bookmark):
+        return item.resolved_description
+
+    def item_link(self, item: Bookmark):
+        return item.url
+
+    def item_pubdate(self, item: Bookmark):
+        return item.date_added
+
+
+class AllBookmarksFeed(BaseBookmarksFeed):
+    title = 'All bookmarks'
+    description = 'All bookmarks'
+
+    def link(self, context: FeedContext):
+        return reverse('bookmarks:feeds.all', args=[context.feed_token.key])
+
+    def items(self, context: FeedContext):
+        return context.query_set
+
+
+class UnreadBookmarksFeed(BaseBookmarksFeed):
+    title = 'Unread bookmarks'
+    description = 'All unread bookmarks'
+
+    def link(self, context: FeedContext):
+        return reverse('bookmarks:feeds.unread', args=[context.feed_token.key])
+
+    def items(self, context: FeedContext):
+        return context.query_set.filter(unread=True)

bookmarks/management/commands/create_initial_superuser.py

@@ -0,0 +1,37 @@
+import os
+import logging
+
+from django.core.management.base import BaseCommand
+from django.contrib.auth import get_user_model
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Creates an initial superuser for a deployment using env variables"
+
+    def handle(self, *args, **options):
+        User = get_user_model()
+        superuser_name = os.getenv('LD_SUPERUSER_NAME', None)
+        superuser_password = os.getenv('LD_SUPERUSER_PASSWORD', None)
+
+        # Skip if option is undefined
+        if not superuser_name:
+            logger.info('Skip creating initial superuser, LD_SUPERUSER_NAME option is not defined')
+            return
+
+        # Skip if user already exists
+        user_exists = User.objects.filter(username=superuser_name).exists()
+        if user_exists:
+            logger.info('Skip creating initial superuser, user already exists')
+            return
+
+        user = User(username=superuser_name, is_superuser=True, is_staff=True)
+
+        if superuser_password:
+            user.set_password(superuser_password)
+        else:
+            user.set_unusable_password()
+
+        user.save()
+        logger.info('Created initial superuser')

bookmarks/management/commands/enable_wal.py

@@ -0,0 +1,24 @@
+import logging
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.db import connections
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Enable WAL journal mode when using an SQLite database"
+
+    def handle(self, *args, **options):
+        if settings.DATABASES['default']['ENGINE'] != 'django.db.backends.sqlite3':
+            return
+
+        connection = connections['default']
+        with connection.cursor() as cursor:
+            cursor.execute("PRAGMA journal_mode")
+            current_mode = cursor.fetchone()[0]
+            logger.info(f'Current journal mode: {current_mode}')
+            if current_mode != 'wal':
+                cursor.execute("PRAGMA journal_mode=wal;")
+                logger.info('Switched to WAL journal mode')

bookmarks/middlewares.py

@@ -0,0 +1,6 @@
+from django.conf import settings
+from django.contrib.auth.middleware import RemoteUserMiddleware
+
+
+class CustomRemoteUserMiddleware(RemoteUserMiddleware):
+    header = settings.LD_AUTH_PROXY_USERNAME_HEADER

bookmarks/migrations/0014_alter_bookmark_unread.py

@@ -0,0 +1,27 @@
+# Generated by Django 3.2.13 on 2022-07-23 12:30
+
+from django.db import migrations, models
+
+
+def forwards(apps, schema_editor):
+    Bookmark = apps.get_model('bookmarks', 'Bookmark')
+    Bookmark.objects.update(unread=False)
+
+
+def reverse(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('bookmarks', '0013_web_archive_optin_toast'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='bookmark',
+            name='unread',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.RunPython(forwards, reverse),
+    ]

bookmarks/migrations/0015_feedtoken.py

@@ -0,0 +1,24 @@
+# Generated by Django 3.2.13 on 2022-07-23 20:35
+
+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', '0014_alter_bookmark_unread'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='FeedToken',
+            fields=[
+                ('key', models.CharField(max_length=40, primary_key=True, serialize=False)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='feed_token', to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+    ]

bookmarks/migrations/0016_bookmark_shared.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.2.14 on 2022-08-02 18:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0015_feedtoken'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='bookmark',
+            name='shared',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/migrations/0017_userprofile_enable_sharing.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.2.14 on 2022-08-04 09:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0016_bookmark_shared'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='enable_sharing',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/migrations/0018_bookmark_favicon_file.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1 on 2023-01-07 23:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0017_userprofile_enable_sharing'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='bookmark',
+            name='favicon_file',
+            field=models.CharField(blank=True, max_length=512),
+        ),
+    ]

bookmarks/migrations/0019_userprofile_enable_favicons.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1 on 2023-01-09 21:16
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0018_bookmark_favicon_file'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='enable_favicons',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/migrations/0020_userprofile_tag_search.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.7 on 2023-04-10 01:55
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0019_userprofile_enable_favicons'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='tag_search',
+            field=models.CharField(choices=[('strict', 'Strict'), ('lax', 'Lax')], default='strict', max_length=10),
+        ),
+    ]

bookmarks/migrations/0021_userprofile_display_url.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.7 on 2023-05-18 07:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0020_userprofile_tag_search'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='display_url',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/migrations/0022_bookmark_notes.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.7 on 2023-05-19 10:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0021_userprofile_display_url'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='bookmark',
+            name='notes',
+            field=models.TextField(blank=True),
+        ),
+    ]

bookmarks/migrations/0023_userprofile_permanent_notes.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.9 on 2023-05-20 08:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0022_bookmark_notes'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='permanent_notes',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/models.py

@@ -1,8 +1,11 @@
+import binascii
+import os
 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.core.handlers.wsgi import WSGIRequest
 from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -47,22 +50,20 @@ class Bookmark(models.Model):
     url = models.CharField(max_length=2048, validators=[BookmarkURLValidator()])
     title = models.CharField(max_length=512, blank=True)
     description = models.TextField(blank=True)
+    notes = 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)
+    favicon_file = models.CharField(max_length=512, blank=True)
+    unread = models.BooleanField(default=False)
     is_archived = models.BooleanField(default=False)
+    shared = models.BooleanField(default=False)
     date_added = models.DateTimeField()
     date_modified = models.DateTimeField()
     date_accessed = models.DateTimeField(blank=True, null=True)
     owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
     tags = models.ManyToManyField(Tag)
 
-    # Attributes might be calculated in query
-    tag_count = 0  # Projection for number of associated tags
-    tag_string = ''  # Projection for list of tag names, comma-separated
-    tag_projection = False  # Tracks if the above projections were loaded
-
     @property
     def resolved_title(self):
         if self.title:
@@ -78,11 +79,7 @@ class Bookmark(models.Model):
 
     @property
     def tag_names(self):
-        # If tag projections were loaded then avoid querying all tags (=executing further selects)
-        if self.tag_projection:
-            return parse_tag_string(self.tag_string)
-        else:
-            return [tag.name for tag in self.tags.all()]
+        return [tag.name for tag in self.tags.all()]
 
     def __str__(self):
         return self.resolved_title + ' (' + self.url[:30] + '...)'
@@ -97,12 +94,40 @@ class BookmarkForm(forms.ModelForm):
                             required=False)
     description = forms.CharField(required=False,
                                   widget=forms.Textarea())
+    # Include website title and description as hidden field as they only provide info when editing bookmarks
+    website_title = forms.CharField(max_length=512,
+                                    required=False, widget=forms.HiddenInput())
+    website_description = forms.CharField(required=False,
+                                          widget=forms.HiddenInput())
+    unread = forms.BooleanField(required=False)
+    shared = forms.BooleanField(required=False)
     # Hidden field that determines whether to close window/tab after saving the bookmark
     auto_close = forms.CharField(required=False)
 
     class Meta:
         model = Bookmark
-        fields = ['url', 'tag_string', 'title', 'description', 'auto_close']
+        fields = [
+            'url',
+            'tag_string',
+            'title',
+            'description',
+            'notes',
+            'website_title',
+            'website_description',
+            'unread',
+            'shared',
+            'auto_close',
+        ]
+
+    @property
+    def has_notes(self):
+        return self.instance and self.instance.notes
+
+
+class BookmarkFilters:
+    def __init__(self, request: WSGIRequest):
+        self.query = request.GET.get('q') or ''
+        self.user = request.GET.get('user') or ''
 
 
 class UserProfile(models.Model):
@@ -134,6 +159,12 @@ class UserProfile(models.Model):
         (WEB_ARCHIVE_INTEGRATION_DISABLED, 'Disabled'),
         (WEB_ARCHIVE_INTEGRATION_ENABLED, 'Enabled'),
     ]
+    TAG_SEARCH_STRICT = 'strict'
+    TAG_SEARCH_LAX = 'lax'
+    TAG_SEARCH_CHOICES = [
+        (TAG_SEARCH_STRICT, 'Strict'),
+        (TAG_SEARCH_LAX, 'Lax'),
+    ]
     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,
@@ -142,12 +173,19 @@ class UserProfile(models.Model):
                                             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)
+    tag_search = models.CharField(max_length=10, choices=TAG_SEARCH_CHOICES, blank=False,
+                                  default=TAG_SEARCH_STRICT)
+    enable_sharing = models.BooleanField(default=False, null=False)
+    enable_favicons = models.BooleanField(default=False, null=False)
+    display_url = models.BooleanField(default=False, null=False)
+    permanent_notes = models.BooleanField(default=False, null=False)
 
 
 class UserProfileForm(forms.ModelForm):
     class Meta:
         model = UserProfile
-        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration']
+        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration', 'tag_search',
+                  'enable_sharing', 'enable_favicons', 'display_url', 'permanent_notes']
 
 
 @receiver(post_save, sender=get_user_model())
@@ -166,3 +204,27 @@ class Toast(models.Model):
     message = models.TextField()
     acknowledged = models.BooleanField(default=False)
     owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+
+
+class FeedToken(models.Model):
+    """
+    Adapted from authtoken.models.Token
+    """
+    key = models.CharField(max_length=40, primary_key=True)
+    user = models.OneToOneField(get_user_model(),
+                                related_name='feed_token',
+                                on_delete=models.CASCADE,
+                                )
+    created = models.DateTimeField(auto_now_add=True)
+
+    def save(self, *args, **kwargs):
+        if not self.key:
+            self.key = self.generate_key()
+        return super().save(*args, **kwargs)
+
+    @classmethod
+    def generate_key(cls):
+        return binascii.hexlify(os.urandom(20)).decode()
+
+    def __str__(self):
+        return self.key

bookmarks/queries.py

@@ -1,54 +1,51 @@
-from django.contrib.auth.models import User
-from django.db.models import Q, Count, Aggregate, CharField, Value, BooleanField, QuerySet
+from typing import Optional
 
-from bookmarks.models import Bookmark, Tag
+from django.contrib.auth.models import User
+from django.db.models import Q, QuerySet, Exists, OuterRef
+
+from bookmarks.models import Bookmark, Tag, UserProfile
 from bookmarks.utils import unique
 
 
-class Concat(Aggregate):
-    function = 'GROUP_CONCAT'
-    template = '%(function)s(%(distinct)s%(expressions)s)'
-
-    def __init__(self, expression, distinct=False, **extra):
-        super(Concat, self).__init__(
-            expression,
-            distinct='DISTINCT ' if distinct else '',
-            output_field=CharField(),
-            **extra)
-
-
-def query_bookmarks(user: User, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+def query_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, profile, query_string) \
         .filter(is_archived=False)
 
 
-def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+def query_archived_bookmarks(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, profile, query_string) \
         .filter(is_archived=True)
 
 
-def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
-    # Add aggregated tag info to bookmark instances
-    query_set = Bookmark.objects \
-        .annotate(tag_count=Count('tags'),
-                  tag_string=Concat('tags__name'),
-                  tag_projection=Value(True, BooleanField()))
+def query_shared_bookmarks(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, profile, query_string) \
+        .filter(shared=True) \
+        .filter(owner__profile__enable_sharing=True)
+
+
+def _base_bookmarks_query(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
+    query_set = Bookmark.objects
 
     # Filter for user
-    query_set = query_set.filter(owner=user)
+    if user:
+        query_set = query_set.filter(owner=user)
 
     # Split query into search terms and tags
-    query = _parse_query_string(query_string)
+    query = parse_query_string(query_string)
 
     # Filter for search terms and tags
     for term in query['search_terms']:
-        query_set = query_set.filter(
-            Q(title__contains=term)
-            | Q(description__contains=term)
-            | Q(website_title__contains=term)
-            | Q(website_description__contains=term)
-            | Q(url__contains=term)
-        )
+        conditions = Q(title__icontains=term) \
+                     | Q(description__icontains=term) \
+                     | Q(notes__icontains=term) \
+                     | Q(website_title__icontains=term) \
+                     | Q(website_description__icontains=term) \
+                     | Q(url__icontains=term)
+
+        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
+            conditions = conditions | Exists(Bookmark.objects.filter(id=OuterRef('id'), tags__name__iexact=term))
+
+        query_set = query_set.filter(conditions)
 
     for tag_name in query['tag_names']:
         query_set = query_set.filter(
@@ -60,6 +57,11 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
         query_set = query_set.filter(
             tags=None
         )
+    # Unread bookmarks
+    if query['unread']:
+        query_set = query_set.filter(
+            unread=True
+        )
 
     # Sort by date added
     query_set = query_set.order_by('-date_added')
@@ -67,27 +69,43 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
     return query_set
 
 
-def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    bookmarks_query = query_bookmarks(user, query_string)
+def query_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    bookmarks_query = query_bookmarks(user, profile, query_string)
 
     query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
 
     return query_set.distinct()
 
 
-def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    bookmarks_query = query_archived_bookmarks(user, query_string)
+def query_archived_bookmark_tags(user: User, profile: UserProfile, query_string: str) -> QuerySet:
+    bookmarks_query = query_archived_bookmarks(user, profile, query_string)
 
     query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
 
     return query_set.distinct()
 
 
+def query_shared_bookmark_tags(user: Optional[User], profile: UserProfile, query_string: str) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(user, profile, query_string)
+
+    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
+
+    return query_set.distinct()
+
+
+def query_shared_bookmark_users(profile: UserProfile, query_string: str) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(None, profile, query_string)
+
+    query_set = User.objects.filter(bookmark__in=bookmarks_query)
+
+    return query_set.distinct()
+
+
 def get_user_tags(user: User):
     return Tag.objects.filter(owner=user).all()
 
 
-def _parse_query_string(query_string):
+def parse_query_string(query_string):
     # Sanitize query params
     if not query_string:
         query_string = ''
@@ -102,9 +120,11 @@ def _parse_query_string(query_string):
 
     # Special search commands
     untagged = '!untagged' in keywords
+    unread = '!unread' in keywords
 
     return {
         'search_terms': search_terms,
         'tag_names': tag_names,
         'untagged': untagged,
+        'unread': unread,
     }

bookmarks/services/bookmarks.py

@@ -5,7 +5,7 @@ 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 website_loader
 from bookmarks.services import tasks
 
 
@@ -30,6 +30,8 @@ def create_bookmark(bookmark: Bookmark, tag_string: str, current_user: User):
     bookmark.save()
     # Create snapshot on web archive
     tasks.create_web_archive_snapshot(current_user, bookmark, False)
+    # Load favicon
+    tasks.load_favicon(current_user, bookmark)
 
     return bookmark
 
@@ -38,16 +40,20 @@ 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
     _update_bookmark_tags(bookmark, tag_string, current_user)
     # Update dates
     bookmark.date_modified = timezone.now()
     bookmark.save()
-    # Update web archive snapshot, if URL changed
+    # Update favicon
+    tasks.load_favicon(current_user, bookmark)
+
     if has_url_changed:
+        # Update web archive snapshot, if URL changed
         tasks.create_web_archive_snapshot(current_user, bookmark, True)
+        # Only update website metadata if URL changed
+        _update_website_metadata(bookmark)
+        bookmark.save()
 
     return bookmark
 
@@ -116,10 +122,13 @@ def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_us
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
     to_bookmark.title = from_bookmark.title
     to_bookmark.description = from_bookmark.description
+    to_bookmark.notes = from_bookmark.notes
+    to_bookmark.unread = from_bookmark.unread
+    to_bookmark.shared = from_bookmark.shared
 
 
 def _update_website_metadata(bookmark: Bookmark):
-    metadata = load_website_metadata(bookmark.url)
+    metadata = website_loader.load_website_metadata(bookmark.url)
     bookmark.website_title = metadata.title
     bookmark.website_description = metadata.description
 

bookmarks/services/exporter.py

@@ -1,3 +1,4 @@
+import html
 from typing import List
 
 from bookmarks.models import Bookmark
@@ -28,8 +29,8 @@ def append_list_start(doc: BookmarkDocument):
 
 def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
     url = bookmark.url
-    title = bookmark.resolved_title
-    desc = bookmark.resolved_description
+    title = html.escape(bookmark.resolved_title or '')
+    desc = html.escape(bookmark.resolved_description or '')
     tags = ','.join(bookmark.tag_names)
     toread = '1' if bookmark.unread else '0'
     added = int(bookmark.date_added.timestamp())

bookmarks/services/favicon_loader.py

@@ -0,0 +1,57 @@
+import os.path
+import re
+import shutil
+import time
+from pathlib import Path
+from urllib.parse import urlparse
+
+import requests
+from django.conf import settings
+
+max_file_age = 60 * 60 * 24  # 1 day
+
+
+def _ensure_favicon_folder():
+    Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)
+
+
+def _url_to_filename(url: str) -> str:
+    name = re.sub(r'\W+', '_', url)
+    return f'{name}.png'
+
+
+def _get_base_url(url: str) -> str:
+    parsed_uri = urlparse(url)
+    return f'{parsed_uri.scheme}://{parsed_uri.hostname}'
+
+
+def _get_favicon_path(favicon_file: str) -> Path:
+    return Path(os.path.join(settings.LD_FAVICON_FOLDER, favicon_file))
+
+
+def _is_stale(path: Path) -> bool:
+    stat = path.stat()
+    file_age = time.time() - stat.st_mtime
+    return file_age >= max_file_age
+
+
+def load_favicon(url: str) -> str:
+    # Get base URL so that we can reuse favicons for multiple bookmarks with the same host
+    base_url = _get_base_url(url)
+    favicon_name = _url_to_filename(base_url)
+    favicon_path = _get_favicon_path(favicon_name)
+
+    # Load icon if it doesn't exist yet or has become stale
+    if not favicon_path.exists() or _is_stale(favicon_path):
+        # Create favicon folder if not exists
+        _ensure_favicon_folder()
+        # Load favicon from provider, save to file
+        favicon_url = settings.LD_FAVICON_PROVIDER.format(url=base_url)
+        response = requests.get(favicon_url, stream=True)
+
+        with open(favicon_path, 'wb') as file:
+            shutil.copyfileobj(response.raw, file)
+
+        del response
+
+    return favicon_name

bookmarks/services/importer.py

@@ -74,6 +74,8 @@ def import_netscape_html(html: str, user: User):
 
     # Create snapshots for newly imported bookmarks
     tasks.schedule_bookmarks_without_snapshots(user)
+    # Load favicons for newly imported bookmarks
+    tasks.schedule_bookmarks_without_favicons(user)
 
     end = timezone.now()
     logger.debug(f'Import duration: {end - import_start}')
@@ -93,6 +95,7 @@ def _create_missing_tags(netscape_bookmarks: List[NetscapeBookmark], user: User)
                 tag = Tag(name=tag_name, owner=user)
                 tag.date_added = timezone.now()
                 tags_to_create.append(tag)
+                tag_cache.put(tag)
 
     Tag.objects.bulk_create(tags_to_create)
 
@@ -172,6 +175,7 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
             shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + '...'
             logging.warning(
                 f'Failed to assign tags to the bookmark: {shortened_bookmark_tag_str}. Could not find bookmark by URL.')
+            continue
 
         # Get tag models by string, schedule inserts for bookmark -> tag associations
         tag_names = parse_tag_string(netscape_bookmark.tag_string)
@@ -190,7 +194,7 @@ def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark)
     else:
         bookmark.date_added = timezone.now()
     bookmark.date_modified = bookmark.date_added
-    bookmark.unread = False
+    bookmark.unread = netscape_bookmark.to_read
     if netscape_bookmark.title:
         bookmark.title = netscape_bookmark.title
     if netscape_bookmark.description:

bookmarks/services/parser.py

@@ -10,6 +10,7 @@ class NetscapeBookmark:
     description: str
     date_added: str
     tag_string: str
+    to_read: bool
 
 
 class BookmarkParser(HTMLParser):
@@ -24,6 +25,7 @@ class BookmarkParser(HTMLParser):
         self.tags = ''
         self.title = ''
         self.description = ''
+        self.toread = ''
 
     def handle_starttag(self, tag: str, attrs: list):
         name = 'handle_start_' + tag.lower()
@@ -56,6 +58,7 @@ class BookmarkParser(HTMLParser):
             description='',
             date_added=self.add_date,
             tag_string=self.tags,
+            to_read=self.toread == '1'
         )
 
     def handle_a_data(self, data):
@@ -75,6 +78,7 @@ class BookmarkParser(HTMLParser):
         self.tags = ''
         self.title = ''
         self.description = ''
+        self.toread = ''
 
 
 def parse(html: str) -> List[NetscapeBookmark]:

bookmarks/services/tasks.py

@@ -2,12 +2,16 @@ import logging
 
 import waybackpy
 from background_task import background
+from background_task.models import Task
 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 waybackpy.exceptions import WaybackError, TooManyRequestsError, NoCDXRecordFound
 
+import bookmarks.services.wayback
 from bookmarks.models import Bookmark, UserProfile
+from bookmarks.services import favicon_loader
+from bookmarks.services.website_loader import DEFAULT_USER_AGENT
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +29,32 @@ def create_web_archive_snapshot(user: User, bookmark: Bookmark, force_update: bo
         _create_web_archive_snapshot_task(bookmark.id, force_update)
 
 
+def _load_newest_snapshot(bookmark: Bookmark):
+    try:
+        logger.info(f'Load existing snapshot for bookmark. url={bookmark.url}')
+        cdx_api = bookmarks.services.wayback.CustomWaybackMachineCDXServerAPI(bookmark.url)
+        existing_snapshot = cdx_api.newest()
+
+        if existing_snapshot:
+            bookmark.web_archive_snapshot_url = existing_snapshot.archive_url
+            bookmark.save(update_fields=['web_archive_snapshot_url'])
+            logger.info(f'Using newest snapshot. url={bookmark.url} from={existing_snapshot.datetime_timestamp}')
+
+    except NoCDXRecordFound:
+        logger.info(f'Could not find any snapshots for bookmark. url={bookmark.url}')
+    except WaybackError as error:
+        logger.error(f'Failed to load existing snapshot. url={bookmark.url}', exc_info=error)
+
+
+def _create_snapshot(bookmark: Bookmark):
+    logger.info(f'Create new snapshot for bookmark. url={bookmark.url}...')
+    archive = waybackpy.WaybackMachineSaveAPI(bookmark.url, DEFAULT_USER_AGENT, max_tries=1)
+    archive.save()
+    bookmark.web_archive_snapshot_url = archive.archive_url
+    bookmark.save(update_fields=['web_archive_snapshot_url'])
+    logger.info(f'Successfully created new snapshot for bookmark:. url={bookmark.url}')
+
+
 @background()
 def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
     try:
@@ -36,19 +66,32 @@ def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
     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)
-
+    # Create new snapshot
     try:
-        archive = wayback.save()
+        _create_snapshot(bookmark)
+        return
+    except TooManyRequestsError:
+        logger.error(
+            f'Failed to create snapshot due to rate limiting, trying to load newest snapshot as fallback. url={bookmark.url}')
     except WaybackError as error:
-        logger.exception(f'Error creating web archive link for bookmark: {bookmark}...', exc_info=error)
-        raise
+        logger.error(f'Failed to create snapshot, trying to load newest snapshot as fallback. url={bookmark.url}',
+                     exc_info=error)
 
-    bookmark.web_archive_snapshot_url = archive.archive_url
-    bookmark.save()
-    logger.debug(f'Successfully created web archive link for bookmark: {bookmark}...')
+    # Load the newest snapshot as fallback
+    _load_newest_snapshot(bookmark)
+
+
+@background()
+def _load_web_archive_snapshot_task(bookmark_id: int):
+    try:
+        bookmark = Bookmark.objects.get(id=bookmark_id)
+    except Bookmark.DoesNotExist:
+        return
+    # Skip if snapshot exists
+    if bookmark.web_archive_snapshot_url:
+        return
+    # Load the newest snapshot
+    _load_newest_snapshot(bookmark)
 
 
 def schedule_bookmarks_without_snapshots(user: User):
@@ -62,4 +105,70 @@ def _schedule_bookmarks_without_snapshots_task(user_id: int):
     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)
+        # To prevent rate limit errors from the Wayback API only try to load the latest snapshots instead of creating
+        # new ones when processing bookmarks in bulk
+        _load_web_archive_snapshot_task(bookmark.id)
+
+
+def is_favicon_feature_active(user: User) -> bool:
+    background_tasks_enabled = not settings.LD_DISABLE_BACKGROUND_TASKS
+
+    return background_tasks_enabled and user.profile.enable_favicons
+
+
+def load_favicon(user: User, bookmark: Bookmark):
+    if is_favicon_feature_active(user):
+        _load_favicon_task(bookmark.id)
+
+
+@background()
+def _load_favicon_task(bookmark_id: int):
+    try:
+        bookmark = Bookmark.objects.get(id=bookmark_id)
+    except Bookmark.DoesNotExist:
+        return
+
+    logger.info(f'Load favicon for bookmark. url={bookmark.url}')
+
+    new_favicon = favicon_loader.load_favicon(bookmark.url)
+
+    if new_favicon != bookmark.favicon_file:
+        bookmark.favicon_file = new_favicon
+        bookmark.save(update_fields=['favicon_file'])
+        logger.info(f'Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon}')
+
+
+def schedule_bookmarks_without_favicons(user: User):
+    if is_favicon_feature_active(user):
+        _schedule_bookmarks_without_favicons_task(user.id)
+
+
+@background()
+def _schedule_bookmarks_without_favicons_task(user_id: int):
+    user = get_user_model().objects.get(id=user_id)
+    bookmarks = Bookmark.objects.filter(favicon_file__exact='', owner=user)
+    tasks = []
+
+    for bookmark in bookmarks:
+        task = Task.objects.new_task(task_name='bookmarks.services.tasks._load_favicon_task', args=(bookmark.id,))
+        tasks.append(task)
+
+    Task.objects.bulk_create(tasks)
+
+
+def schedule_refresh_favicons(user: User):
+    if is_favicon_feature_active(user) and settings.LD_ENABLE_REFRESH_FAVICONS:
+        _schedule_refresh_favicons_task(user.id)
+
+
+@background()
+def _schedule_refresh_favicons_task(user_id: int):
+    user = get_user_model().objects.get(id=user_id)
+    bookmarks = Bookmark.objects.filter(owner=user)
+    tasks = []
+
+    for bookmark in bookmarks:
+        task = Task.objects.new_task(task_name='bookmarks.services.tasks._load_favicon_task', args=(bookmark.id,))
+        tasks.append(task)
+
+    Task.objects.bulk_create(tasks)

bookmarks/services/wayback.py

@@ -0,0 +1,40 @@
+import time
+from typing import Dict
+
+import waybackpy
+import waybackpy.utils
+from waybackpy.exceptions import NoCDXRecordFound
+
+
+class CustomWaybackMachineCDXServerAPI(waybackpy.WaybackMachineCDXServerAPI):
+    """
+    Customized WaybackMachineCDXServerAPI to work around some issues with retrieving the newest snapshot.
+    See https://github.com/akamhy/waybackpy/issues/176
+    """
+
+    def newest(self):
+        unix_timestamp = int(time.time())
+        self.closest = waybackpy.utils.unix_timestamp_to_wayback_timestamp(unix_timestamp)
+        self.sort = 'closest'
+        self.limit = -5
+
+        newest_snapshot = None
+        for snapshot in self.snapshots():
+            newest_snapshot = snapshot
+            break
+
+        if not newest_snapshot:
+            raise NoCDXRecordFound(
+                "Wayback Machine's CDX server did not return any records "
+                + "for the query. The URL may not have any archives "
+                + " on the Wayback Machine or the URL may have been recently "
+                + "archived and is still not available on the CDX server."
+            )
+
+        return newest_snapshot
+
+    def add_payload(self, payload: Dict[str, str]) -> None:
+        super().add_payload(payload)
+        # Set fastLatest query param, as we are only using this API to get the latest snapshot and using fastLatest
+        # makes searching for latest snapshots faster
+        payload['fastLatest'] = 'true'

bookmarks/services/website_loader.py

@@ -1,8 +1,13 @@
+import logging
 from dataclasses import dataclass
+from functools import lru_cache
 
 import requests
 from bs4 import BeautifulSoup
 from charset_normalizer import from_bytes
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -19,37 +24,81 @@ class WebsiteMetadata:
         }
 
 
+# Caching metadata avoids scraping again when saving bookmarks, in case the
+# metadata was already scraped to show preview values in the bookmark form
+@lru_cache(maxsize=10)
 def load_website_metadata(url: str):
     title = None
     description = None
     try:
+        start = timezone.now()
         page_text = load_page(url)
+        end = timezone.now()
+        logger.debug(f'Load duration: {end - start}')
+
+        start = timezone.now()
         soup = BeautifulSoup(page_text, 'html.parser')
 
-        title = soup.title.string if soup.title is not None else None
+        title = soup.title.string.strip() if soup.title is not None else None
         description_tag = soup.find('meta', attrs={'name': 'description'})
-        description = description_tag['content'] if description_tag is not None else None
+        description = description = description_tag['content'].strip() if description_tag and description_tag[
+            'content'] else None
+        end = timezone.now()
+        logger.debug(f'Parsing duration: {end - start}')
     finally:
         return WebsiteMetadata(url=url, title=title, description=description)
 
 
+CHUNK_SIZE = 50 * 1024
+MAX_CONTENT_LIMIT = 5000 * 1024
+
+
 def load_page(url: str):
     headers = fake_request_headers()
-    r = requests.get(url, timeout=10, headers=headers)
+    size = 0
+    content = None
+    iteration = 0
+    # Use with to ensure request gets closed even if it's only read partially
+    with requests.get(url, timeout=10, headers=headers, stream=True) as r:
+        for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
+            size += len(chunk)
+            iteration = iteration + 1
+            if content is None:
+                content = chunk
+            else:
+                content = content + chunk
+
+            logger.debug(f'Loaded chunk (iteration={iteration}, total={size / 1024})')
+
+            # Stop reading if we have parsed end of head tag
+            end_of_head = '</head>'.encode('utf-8')
+            if end_of_head in content:
+                logger.debug(f'Found closing head tag after {size} bytes')
+                content = content.split(end_of_head)[0] + end_of_head
+                break
+            # Stop reading if we exceed limit
+            if size > MAX_CONTENT_LIMIT:
+                logger.debug(f'Cancel reading document after {size} bytes')
+                break
+        if hasattr(r, '_content_consumed'):
+            logger.debug(f'Request consumed: {r._content_consumed}')
 
     # 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)
+    results = from_bytes(content or '')
     return str(results.best())
 
 
+DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36'
+
+
 def fake_request_headers():
     return {
         "Accept": "text/html,application/xhtml+xml,application/xml",
         "Accept-Encoding": "gzip, deflate",
         "Dnt": "1",
         "Upgrade-Insecure-Requests": "1",
-        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36",
+        "User-Agent": DEFAULT_USER_AGENT,
     }

bookmarks/static/bookmark_list.js

@@ -0,0 +1,171 @@
+(function () {
+  function allowBulkEdit() {
+    return !!document.getElementById('bulk-edit-mode');
+  }
+
+  function setupBulkEdit() {
+    if (!allowBulkEdit()) {
+      return;
+    }
+
+    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';
+      }
+    });
+  }
+
+  function setupBulkEditTagAutoComplete() {
+    if (!allowBulkEdit()) {
+      return;
+    }
+
+    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);
+  }
+
+  function setupListNavigation() {
+    // Add logic for navigating bookmarks with arrow keys
+    document.addEventListener('keydown', event => {
+      // Skip if event occurred within an input element
+      // or does not use arrow keys
+      const targetNodeName = event.target.nodeName;
+      const isInputTarget = targetNodeName === 'INPUT'
+        || targetNodeName === 'SELECT'
+        || targetNodeName === 'TEXTAREA';
+      const isArrowUp = event.key === 'ArrowUp';
+      const isArrowDown = event.key === 'ArrowDown';
+
+      if (isInputTarget || !(isArrowUp || isArrowDown)) {
+        return;
+      }
+      event.preventDefault();
+
+      // Detect current bookmark list item
+      const path = event.composedPath();
+      const currentItem = path.find(item => item.hasAttribute && item.hasAttribute('data-is-bookmark-item'));
+
+      // Find next item
+      let nextItem;
+      if (currentItem) {
+        nextItem = isArrowUp
+          ? currentItem.previousElementSibling
+          : currentItem.nextElementSibling;
+      } else {
+        // Select first item
+        nextItem = document.querySelector('li[data-is-bookmark-item]');
+      }
+      // Focus first link
+      if (nextItem) {
+        nextItem.querySelector('a').focus();
+      }
+    });
+  }
+
+  function setupNotes() {
+    // Shortcut for toggling all notes
+    document.addEventListener('keydown', function(event) {
+      // Filter for shortcut key
+      if (event.key !== 'e') 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 list = document.querySelector('.bookmark-list');
+      list.classList.toggle('show-notes');
+    });
+
+    // Toggle notes for single bookmark
+    const bookmarks = document.querySelectorAll('.bookmark-list li');
+    bookmarks.forEach(bookmark => {
+      const toggleButton = bookmark.querySelector('.toggle-notes');
+      if (toggleButton) {
+        toggleButton.addEventListener('click', event => {
+          event.preventDefault();
+          event.stopPropagation();
+          bookmark.classList.toggle('show-notes');
+        });
+      }
+    });
+  }
+
+  setupBulkEdit();
+  setupBulkEditTagAutoComplete();
+  setupListNavigation();
+  setupNotes();
+})()

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/styles/base.scss

@@ -72,6 +72,12 @@ a:visited:hover {
   color: $link-color-dark;
 }
 
+code {
+  color: $gray-color-dark;
+  background-color: $code-bg-color;
+  box-shadow: 1px 1px 0 $code-shadow-color;
+}
+
 // Increase spacing between columns
 .container > .columns > .column:not(:first-child) {
   padding-left: 2rem;
@@ -102,3 +108,12 @@ a:visited:hover {
     font-weight: bold;
   }
 }
+
+// Increase input font size on small viewports to prevent zooming on focus the input
+// on mobile devices. 430px relates to the "normalized" iPhone 14 Pro Max
+// viewport size
+@media screen and (max-width: 430px) {
+  .form-input {
+    font-size: 16px;
+  }
+}

bookmarks/styles/bookmarks.scss

@@ -43,11 +43,38 @@
   }
 }
 
+/* Bookmark list */
 ul.bookmark-list {
-
   list-style: none;
   margin: 0;
   padding: 0;
+}
+
+/* Bookmarks */
+ul.bookmark-list li {
+
+  .bulk-edit-toggle {
+    display: none;
+  }
+
+  .title a {
+    display: inline-block;
+    vertical-align: top;
+    width: 100%;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .title img {
+    width: 16px;
+    height: 16px;
+    vertical-align: text-top;
+  }
+
+  .url-display {
+    color: $secondary-link-color;
+  }
 
   .description {
     color: $gray-color-dark;
@@ -57,31 +84,44 @@ ul.bookmark-list {
     }
   }
 
-  .actions > *:not(:last-child) {
-    margin-right: 0.1rem;
+  .actions {
+    display: flex;
+    align-items: baseline;
+    flex-wrap: wrap;
   }
 
-  .actions .date-label a {
-    color: $gray-color;
-  }
-
-  .actions .btn-link {
-    color: $gray-color;
-    padding: 0;
-    height: auto;
-    vertical-align: unset;
-    border: none;
-
-    &:focus,
-    &:hover,
-    &:active,
-    &.active {
-      color: $gray-color-dark;
+  .actions {
+    > *:not(:last-child) {
+      margin-right: 0.4rem;
     }
-  }
 
-  .bulk-edit-toggle {
-    display: none;
+    a, button {
+      color: $gray-color;
+      padding: 0;
+      height: auto;
+      vertical-align: unset;
+      border: none;
+      transition: none;
+      text-decoration: none;
+
+      &:focus,
+      &:hover,
+      &:active,
+      &.active {
+        color: $gray-color-dark;
+      }
+    }
+
+    .separator {
+      align-self: flex-start;
+    }
+
+    .toggle-notes {
+      align-self: center;
+      display: flex;
+      align-items: center;
+      gap: 0.1rem;
+    }
   }
 }
 
@@ -91,8 +131,18 @@ ul.bookmark-list {
 
 .tag-cloud {
 
-  a, a:visited:hover {
-    color: $alternative-color;
+  .selected-tags {
+    margin-bottom: 0.8rem;
+
+    a, a:visited:hover {
+      color: $error-color;
+    }
+  }
+
+  .unselected-tags {
+    a, a:visited:hover {
+      color: $alternative-color;
+    }
   }
 
   .group {
@@ -151,6 +201,69 @@ ul.bookmark-list {
       font-weight: bold;
     }
   }
+
+  details.notes textarea {
+    box-sizing: border-box;
+  }
+}
+
+/* Bookmark notes */
+ul.bookmark-list {
+  .notes {
+    display: none;
+    max-height: 300px;
+    margin: 4px 0;
+    overflow: auto;
+  }
+
+  &.show-notes .notes,
+  li.show-notes .notes {
+    display: block;
+  }
+}
+
+/* Bookmark notes markdown styles */
+ul.bookmark-list .notes-content {
+  & {
+    padding: 0.4rem 0.6rem;
+  }
+
+  p, ul, ol, pre, blockquote {
+    margin: 0 0 0.4rem 0;
+  }
+
+  > *:first-child {
+    margin-top: 0;
+  }
+  > *:last-child {
+    margin-bottom: 0;
+  }
+
+  ul, ol {
+    margin-left: 0.8rem;
+  }
+
+  ul li, ol li {
+    margin-top: 0.2rem;
+  }
+
+  pre {
+    padding: 0.2rem 0.4rem;
+    background-color: $code-bg-color;
+    border-radius: 0.2rem;
+  }
+
+  pre code {
+    background: none;
+    box-shadow: none;
+    padding: 0;
+  }
+
+  > pre:first-child:last-child {
+    padding: 0;
+    background: none;
+    border-radius: 0;
+  }
 }
 
 /* Bookmark actions / bulk edit */

bookmarks/styles/settings.scss

@@ -11,4 +11,8 @@
   .input-group > input[type=submit] {
     height: auto;
   }
+
+  section.about table {
+    max-width: 500px;
+  }
 }

bookmarks/styles/variables-dark.scss

@@ -21,8 +21,13 @@ $link-color: $primary-color !default;
 $link-color-dark: darken($link-color, 5%) !default;
 $link-color-light: $link-color !default;
 
+$secondary-link-color: rgba(168, 177, 255, 0.73);
+
 $alternative-color: #59bdb9;
 $alternative-color-dark: #73f1eb;
 
+$code-bg-color: rgba(255, 255, 255, 0.1);
+$code-shadow-color: rgba(255, 255, 255, 0.2);
+
 /* Dark theme specific */
 $dt-primary-button-color: #5761cb !default;

bookmarks/styles/variables-light.scss

@@ -2,3 +2,8 @@ $html-font-size: 18px !default;
 
 $alternative-color: #05a6a3;
 $alternative-color-dark: darken($alternative-color, 5%);
+
+$secondary-link-color: rgba(87, 85, 217, 0.64);
+
+$code-bg-color: rgba(0, 0, 0, 0.05);
+$code-shadow-color: rgba(0, 0, 0, 0.15);

bookmarks/templates/bookmarks/archive.html

@@ -5,44 +5,42 @@
 
 {% block content %}
 
-    {% include 'bookmarks/bulk_edit/state.html' %}
+  {% include 'bookmarks/bulk_edit/state.html' %}
 
-    <div class="bookmarks-page columns">
+  <div class="bookmarks-page columns">
 
-        {# Bookmark list #}
-        <section class="content-area column col-8 col-md-12">
-            <div class="content-area-header">
-                <h2>Archived bookmarks</h2>
-                <div class="spacer"></div>
-                {% bookmark_search query tags mode='archive' %}
-                {% include 'bookmarks/bulk_edit/toggle.html' %}
-            </div>
+    {# Bookmark list #}
+    <section class="content-area column col-8 col-md-12">
+      <div class="content-area-header">
+        <h2>Archived bookmarks</h2>
+        <div class="spacer"></div>
+        {% bookmark_search filters tags mode='archived' %}
+        {% 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' %}
+      <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>
-        </section>
+        {% if empty %}
+          {% include 'bookmarks/empty_bookmarks.html' %}
+        {% else %}
+          {% bookmark_list bookmarks return_url link_target %}
+        {% endif %}
+      </form>
+    </section>
 
-        {# Tag list #}
-        <section class="content-area column col-4 hide-md">
-            <div class="content-area-header align-baseline">
-                <h2>Tags</h2>
-                <div class="spacer"></div>
-                <a href="?q=!untagged" class="text-gray text-sm">Show Untagged</a>
-            </div>
-            {% tag_cloud tags %}
-        </section>
-    </div>
+    {# Tag list #}
+    <section class="content-area column col-4 hide-md">
+      <div class="content-area-header">
+        <h2>Tags</h2>
+      </div>
+      {% tag_cloud tags selected_tags %}
+    </section>
+  </div>
 
-    <script src="{% static "bundle.js" %}"></script>
-    <script src="{% static "shared.js" %}"></script>
-    <script src="{% static "bulk_edit.js" %}"></script>
+  <script src="{% static "bundle.js" %}"></script>
+  <script src="{% static "shared.js" %}"></script>
+  <script src="{% static "bookmark_list.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/bookmark_list.html

@@ -1,75 +1,128 @@
+{% load static %}
 {% load shared %}
 {% load pagination %}
-
-<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>
-            <div class="title truncate">
-                <a href="{{ bookmark.url }}" target="{{ link_target }}" 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>
-                {% endif %}
-                {% if bookmark.tag_names and bookmark.resolved_description %} | {% endif %}
-
-                {% if bookmark.resolved_description %}
-                    <span>{{ bookmark.resolved_description }}</span>
-                {% 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>
-                {% else %}
-                    <button type="submit" name="archive" value="{{ bookmark.id }}"
-                       class="btn btn-link btn-sm">Archive</button>
-                {% endif %}
-                <button type="submit" name="remove" value="{{ bookmark.id }}"
-                   class="btn btn-link btn-sm btn-confirmation">Remove</button>
-            </div>
-        </li>
-    {% endfor %}
+<ul class="bookmark-list{% if  request.user.profile.permanent_notes %} show-notes{% endif %}">
+  {% 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>
+      <div class="title">
+        <a href="{{ bookmark.url }}" target="{{ link_target }}" rel="noopener"
+           class="{% if bookmark.unread %}text-italic{% endif %}">
+          {% if bookmark.favicon_file and request.user.profile.enable_favicons %}
+            <img src="{% static bookmark.favicon_file %}" alt="">
+          {% endif %}
+          {{ bookmark.resolved_title }}
+        </a>
+      </div>
+      {% if request.user.profile.display_url %}
+        <div class="url-path truncate">
+          <a href="{{ bookmark.url }}" target="{{ link_target }}" rel="noopener"
+             class="url-display text-sm">
+            {{ bookmark.url }}
+          </a>
+        </div>
+      {% endif %}
+      <div class="description truncate">
+        {% if bookmark.tag_names %}
+          <span>
+              {% for tag_name in bookmark.tag_names %}
+                <a href="?{% add_tag_to_query tag_name %}">{{ tag_name|hash_tag }}</a>
+              {% endfor %}
+            </span>
+        {% endif %}
+        {% if bookmark.tag_names and bookmark.resolved_description %} | {% endif %}
+        {% if bookmark.resolved_description %}
+          <span>{{ bookmark.resolved_description }}</span>
+        {% endif %}
+      </div>
+      {% if bookmark.notes %}
+        <div class="notes bg-gray text-gray-dark">
+          <div class="notes-content">
+            {% markdown bookmark.notes %}
+          </div>
+        </div>
+      {% endif %}
+      <div class="actions text-gray text-sm">
+        {% if request.user.profile.bookmark_date_display == 'relative' %}
+          <span>
+              {% 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 %}
+              ∞
+              </a>
+            {% endif %}
+            </span>
+          <span class="separator">|</span>
+        {% endif %}
+        {% if request.user.profile.bookmark_date_display == 'absolute' %}
+          <span>
+              {% 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 %}
+              ∞
+              </a>
+            {% endif %}
+            </span>
+          <span class="separator">|</span>
+        {% endif %}
+        {% if bookmark.owner == request.user %}
+          {# Bookmark owner actions #}
+          <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}">Edit</a>
+          {% if bookmark.is_archived %}
+            <button type="submit" name="unarchive" value="{{ bookmark.id }}"
+                    class="btn btn-link btn-sm">Unarchive
+            </button>
+          {% else %}
+            <button type="submit" name="archive" value="{{ bookmark.id }}"
+                    class="btn btn-link btn-sm">Archive
+            </button>
+          {% endif %}
+          <button type="submit" name="remove" value="{{ bookmark.id }}"
+                  class="btn btn-link btn-sm btn-confirmation">Remove
+          </button>
+          {% if bookmark.unread %}
+            <span class="separator">|</span>
+            <button type="submit" name="mark_as_read" value="{{ bookmark.id }}"
+                    class="btn btn-link btn-sm">Mark as read
+            </button>
+          {% endif %}
+        {% else %}
+          {# Shared bookmark actions #}
+          <span>Shared by
+              <a href="?{% replace_query_param user=bookmark.owner.username %}">{{ bookmark.owner.username }}</a>
+            </span>
+        {% endif %}
+        {% if bookmark.notes and not request.user.profile.permanent_notes %}
+          <span class="separator">|</span>
+          <button class="btn btn-link btn-sm toggle-notes" title="Toggle notes">
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-notes" width="16" height="16"
+                 viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round"
+                 stroke-linejoin="round">
+              <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+              <path d="M5 3m0 2a2 2 0 0 1 2 -2h10a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-10a2 2 0 0 1 -2 -2z"></path>
+              <path d="M9 7l6 0"></path>
+              <path d="M9 11l6 0"></path>
+              <path d="M9 15l4 0"></path>
+            </svg>
+            <span>Notes</span>
+          </button>
+        {% endif %}
+      </div>
+    </li>
+  {% endfor %}
 </ul>
 
 <div class="bookmark-pagination">
-    {% pagination bookmarks %}
+  {% pagination bookmarks %}
 </div>

bookmarks/templates/bookmarks/bookmarklet.js

@@ -1,9 +1,9 @@
-(function() {
-    var bookmarkUrl = window.location;
-    var applicationUrl = '{{ application_url }}';
+(function () {
+  var bookmarkUrl = window.location;
+  var applicationUrl = '{{ application_url }}';
 
-    applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl);
-    applicationUrl += '&auto_close';
+  applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl);
+  applicationUrl += '&auto_close';
 
-    window.open(applicationUrl);
+  window.open(applicationUrl);
 })();

bookmarks/templates/bookmarks/bulk_edit/bar.html

@@ -1,31 +1,34 @@
+{% load shared %}
+{% htmlmin %}
 <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 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>
+{% endhtmlmin %}

bookmarks/templates/bookmarks/bulk_edit/toggle.html

@@ -2,7 +2,8 @@
     <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"/>
+            <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/close.html

@@ -1,9 +1,9 @@
 {% extends "bookmarks/layout.html" %}
 
 {% block content %}
-    <script type="application/javascript">
-        window.close()
-    </script>
-    <p>You can now close this window.</p>
+  <script type="application/javascript">
+    window.close()
+  </script>
+  <p>You can now close this window.</p>
 {% endblock %}
 

bookmarks/templates/bookmarks/edit.html

@@ -2,14 +2,15 @@
 {% load bookmarks %}
 
 {% block content %}
-    <div class="columns">
-        <section class="content-area column col-12">
-            <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>
-        </section>
-    </div>
+  <div class="columns">
+    <section class="content-area column col-12">
+      <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>
+    </section>
+  </div>
 {% endblock %}

bookmarks/templates/bookmarks/empty_bookmarks.html

@@ -1,8 +1,9 @@
 <div class="empty">
-    <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>.
-    </p>
+  <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>.
+  </p>
 </div>

bookmarks/templates/bookmarks/form.html

@@ -2,168 +2,243 @@
 {% load static %}
 
 <div class="bookmarks-form">
-    {% csrf_token %}
-    {{ form.auto_close|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: " }}
-        {% 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.
-        </div>
+  {% csrf_token %}
+  {{ form.website_title }}
+  {{ form.website_description }}
+  {{ form.auto_close|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: " }}
+    {% 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.
+      The form has been pre-filled with the existing bookmark, and saving the form will update the existing bookmark.
     </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"|attr:"autocapitalize:off" }}
+    <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
+      automatically created.
+    </div>
+    {{ form.tag_string.errors }}
+  </div>
+  <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" }}
+      <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.
+    </div>
+    {{ form.title.errors }}
+  </div>
+  <div class="form-group">
+    <label for="{{ form.description.id_for_label }}" class="form-label">Description</label>
+    <div class="has-icon-right">
+      {{ form.description|add_class:"form-input"|attr:"rows:2" }}
+      <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.
+    </div>
+    {{ form.description.errors }}
+  </div>
+  <div class="form-group">
+    <details class="notes"{% if form.has_notes %} open{% endif %}>
+      <summary>
+        <span class="form-label d-inline-block">Notes</span>
+      </summary>
+      <label for="{{ form.notes.id_for_label }}" class="text-assistive">Notes</label>
+      {{ form.notes|add_class:"form-input"|attr:"rows:8" }}
+      <div class="form-input-hint">
+        Additional notes, supports Markdown.
+      </div>
+      {{ form.notes.errors }}
+    </details>
+  </div>
+  <div class="form-group">
+    <label for="{{ form.unread.id_for_label }}" class="form-checkbox">
+      {{ form.unread }}
+      <i class="form-icon"></i>
+      <span>Mark as unread</span>
+    </label>
+    <div class="form-input-hint">
+      Unread bookmarks can be filtered for, and marked as read after you had a chance to look at them.
+    </div>
+  </div>
+  {% if request.user.profile.enable_sharing %}
     <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" }}
-        <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
-            automatically created.
-        </div>
-        {{ form.tag_string.errors }}
-    </div>
-    <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" }}
-            <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.
-        </div>
-        {{ form.title.errors }}
-    </div>
-    <div class="form-group">
-        <label for="{{ form.description.id_for_label }}" class="form-label">Description</label>
-        <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.
-        </div>
-        {{ form.description.errors }}
-    </div>
-    <br/>
-    <div class="form-group">
-        {% if auto_close %}
-            <input type="submit" value="Save and close" class="btn btn-primary mr-2">
-        {% else %}
-            <input type="submit" value="Save" class="btn btn-primary mr-2">
-        {% endif %}
-        <a href="{{ cancel_url }}" class="btn">Nevermind</a>
+      <label for="{{ form.shared.id_for_label }}" class="form-checkbox">
+        {{ form.shared }}
+        <i class="form-icon"></i>
+        <span>Share</span>
+      </label>
+      <div class="form-input-hint">
+        Share this bookmark with other users.
+      </div>
     </div>
+  {% endif %}
+  <br/>
+  <div class="form-group">
+    {% if auto_close %}
+      <input type="submit" value="Save and close" class="btn btn-primary mr-2">
+    {% else %}
+      <input type="submit" value="Save" class="btn btn-primary mr-2">
+    {% endif %}
+    <a href="{{ cancel_url }}" class="btn">Nevermind</a>
+  </div>
 
-    {# Replace tag input with auto-complete component #}
-    <script src="{% static "bundle.js" %}"></script>
-    <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' %}')
+  {# Replace tag input with auto-complete component #}
+  <script src="{% static "bundle.js" %}"></script>
+  <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' %}')
 
-        new linkding.TagAutoComplete({
-            target: wrapper,
-            props: {
-                id: '{{ form.tag_string.id_for_label }}',
-                name: '{{ form.tag_string.name }}',
-                value: tagInput.value,
-                apiClient: apiClient
+    new linkding.TagAutoComplete({
+      target: wrapper,
+      props: {
+        id: '{{ form.tag_string.id_for_label }}',
+        name: '{{ form.tag_string.name }}',
+        value: tagInput.value,
+        apiClient: apiClient
+      }
+    });
+
+    tagInput.parentElement.replaceChild(wrapper, tagInput);
+  </script>
+  <script type="application/javascript">
+    /**
+     * - 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 notesDetails = document.querySelector('form details.notes');
+      const notesInput = document.getElementById('{{ form.notes.id_for_label }}');
+      const tagsInput = document.getElementById('{{ form.tag_string.id_for_label }}');
+      const unreadCheckbox = document.getElementById('{{ form.unread.id_for_label }}');
+      const sharedCheckbox = document.getElementById('{{ form.shared.id_for_label }}');
+      const websiteTitleInput = document.getElementById('{{ form.website_title.id_for_label }}');
+      const websiteDescriptionInput = document.getElementById('{{ form.website_description.id_for_label }}');
+      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');
+        }
+      }
+
+      function updateInput(input, value) {
+        if (!input) {
+          return;
+        }
+        input.value = value;
+      }
+
+      function updateCheckbox(input, value) {
+        if (!input) {
+          return;
+        }
+        input.checked = value;
+      }
+
+      function checkUrl() {
+        toggleLoadingIcon(titleInput, true);
+        toggleLoadingIcon(descriptionInput, true);
+        updatePlaceholder(titleInput, null);
+        updatePlaceholder(descriptionInput, null);
+
+        const websiteUrl = encodeURIComponent(urlInput.value);
+        const requestUrl = `{% url 'bookmarks:api-root' %}bookmarks/check?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);
+
+            // Prefill form and display hint if URL is already bookmarked
+            const existingBookmark = data.bookmark;
+            const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists');
+
+            if (existingBookmark && !editedBookmarkId) {
+              bookmarkExistsHint.style['display'] = 'block';
+              notesDetails.open = !!existingBookmark.notes;
+              updateInput(titleInput, existingBookmark.title);
+              updateInput(descriptionInput, existingBookmark.description);
+              updateInput(notesInput, existingBookmark.notes);
+              updateInput(tagsInput, existingBookmark.tag_names.join(" "));
+              updateCheckbox(unreadCheckbox, existingBookmark.unread);
+              updateCheckbox(sharedCheckbox, existingBookmark.shared);
+            } else {
+              bookmarkExistsHint.style['display'] = 'none';
             }
+          });
+      }
+
+      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();
         });
+      }
 
-        tagInput.parentElement.replaceChild(wrapper, tagInput);
-    </script>
-    <script type="application/javascript">
-        /**
-         * - 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 }};
+      setupEditAutoValueButton(titleInput);
+      setupEditAutoValueButton(descriptionInput);
 
-            function toggleLoadingIcon(input, show) {
-                const icon = input.parentNode.querySelector('i.form-icon');
-                icon.style['visibility'] = show ? 'visible' : 'hidden';
-            }
+      // Fetch initial website data if we have a URL, and we are not editing an existing bookmark
+      // For existing bookmarks we get the website metadata through hidden inputs
+      if (urlInput.value && !editedBookmarkId) {
+        checkUrl();
+      }
+      urlInput.addEventListener('input', checkUrl);
 
-            function updatePlaceholder(input, value) {
-                if (value) {
-                    input.setAttribute('placeholder', value);
-                } else {
-                    input.removeAttribute('placeholder');
-                }
-            }
-
-            function checkUrl() {
-                toggleLoadingIcon(titleInput, true);
-                toggleLoadingIcon(descriptionInput, true);
-                updatePlaceholder(titleInput, null);
-                updatePlaceholder(descriptionInput, null);
-
-                const websiteUrl = encodeURIComponent(urlInput.value);
-                const requestUrl = `{% url 'bookmarks:api-root' %}bookmarks/check?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);
-
-                        // Display hint if URL is already bookmarked
-                        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;
-                        } else {
-                            bookmarkExistsHint.style['display'] = 'none';
-                        }
-                    });
-            }
-
-            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();
-                });
-            }
-
-            if (urlInput.value) checkUrl();
-            urlInput.addEventListener('input', checkUrl);
-            setupEditAutoValueButton(titleInput);
-            setupEditAutoValueButton(descriptionInput);
-        })();
-    </script>
+      // Set initial website title and description for edited bookmarks
+      if (editedBookmarkId) {
+        updatePlaceholder(titleInput, websiteTitleInput.value);
+        updatePlaceholder(descriptionInput, websiteDescriptionInput.value);
+      }
+    })();
+  </script>
 </div>

bookmarks/templates/bookmarks/index.html

@@ -5,44 +5,42 @@
 
 {% block content %}
 
-    {% include 'bookmarks/bulk_edit/state.html' %}
+  {% include 'bookmarks/bulk_edit/state.html' %}
 
-    <div class="bookmarks-page columns">
+  <div class="bookmarks-page columns">
 
-        {# Bookmark list #}
-        <section class="content-area column col-8 col-md-12">
-            <div class="content-area-header">
-                <h2>Bookmarks</h2>
-                <div class="spacer"></div>
-                {% bookmark_search query tags %}
-                {% include 'bookmarks/bulk_edit/toggle.html' %}
-            </div>
+    {# Bookmark list #}
+    <section class="content-area column col-8 col-md-12">
+      <div class="content-area-header">
+        <h2>Bookmarks</h2>
+        <div class="spacer"></div>
+        {% bookmark_search filters 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' %}
+      <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>
-        </section>
+        {% if empty %}
+          {% include 'bookmarks/empty_bookmarks.html' %}
+        {% else %}
+          {% bookmark_list bookmarks return_url link_target %}
+        {% endif %}
+      </form>
+    </section>
 
-        {# Tag list #}
-        <section class="content-area column col-4 hide-md">
-            <div class="content-area-header align-baseline">
-                <h2>Tags</h2>
-                <div class="spacer"></div>
-                <a href="?q=!untagged" class="text-gray text-sm">Show Untagged</a>
-            </div>
-            {% tag_cloud tags %}
-        </section>
-    </div>
+    {# Tag list #}
+    <section class="content-area column col-4 hide-md">
+      <div class="content-area-header">
+        <h2>Tags</h2>
+      </div>
+      {% tag_cloud tags selected_tags %}
+    </section>
+  </div>
 
-    <script src="{% static "bundle.js" %}"></script>
-    <script src="{% static "shared.js" %}"></script>
-    <script src="{% static "bulk_edit.js" %}"></script>
+  <script src="{% static "bundle.js" %}"></script>
+  <script src="{% static "shared.js" %}"></script>
+  <script src="{% static "bookmark_list.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/layout.html

@@ -5,60 +5,63 @@
 {# Use data attributes as storage for access in static scripts #}
 <html lang="en" data-api-base-url="{% url 'bookmarks:api-root' %}">
 <head>
-    <meta charset="UTF-8">
-    <link rel="icon" href="{% static 'favicon.png' %}"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, minimal-ui">
-    <meta name="description" content="Self-hosted bookmark service">
-    <meta name="robots" content="index,follow">
-    <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 %}
+  <meta charset="UTF-8">
+  <link rel="icon" href="{% static 'favicon.png' %}"/>
+  <link rel="apple-touch-icon" href="{% static 'apple-touch-icon.png' %}">
+  <link rel="manifest" href="{% url 'bookmarks:manifest' %}">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, minimal-ui">
+  <meta name="description" content="Self-hosted bookmark service">
+  <meta name="robots" content="index,follow">
+  <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 %}
 </head>
 <body>
 <header>
-    {% if has_toasts %}
+  {% if has_toasts %}
     <div class="toasts container grid-lg">
       <form action="{% url 'bookmarks:toasts.acknowledge' %}?return_url={{ request.path | urlencode }}" method="post">
         {% csrf_token %}
         {% for toast in toast_messages %}
-            <div class="toast">
-                {{ toast.message }}
-                <button type="submit" name="toast" value="{{ toast.id }}" class="btn btn-clear float-right"></button>
-            </div>
+          <div class="toast">
+            {{ toast.message }}
+            <button type="submit" name="toast" value="{{ toast.id }}" class="btn btn-clear float-right"></button>
+          </div>
         {% endfor %}
       </form>
     </div>
+  {% endif %}
+  <div class="navbar container grid-lg">
+    <section class="navbar-section">
+      <a href="{% url 'bookmarks:index' %}" class="navbar-brand text-bold">
+        <img class="logo" src="{% static 'logo.png' %}" alt="Application logo">
+        <h1>linkding</h1>
+      </a>
+    </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 class="navbar container grid-lg">
-        <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>
-        </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>
+  </div>
 </header>
 <div class="content container grid-lg">
-    {% block content %}
-    {% endblock %}
+  {% block content %}
+  {% endblock %}
 </div>
 </body>
 </html>

bookmarks/templates/bookmarks/nav_menu.html

@@ -1,53 +1,101 @@
+{% load shared %}
+{% htmlmin %}
 {# Basic menu list #}
 <div class="hide-md">
-    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">Add bookmark</a>
-    <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archive</a>
-    <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
-    <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
+  <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">Add bookmark</a>
+  <div class="dropdown">
+    <a href="#" class="btn btn-link dropdown-toggle" tabindex="0" style="padding-right: 0.2rem">
+      Bookmarks
+      <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" viewBox="0 0 20 20" fill="currentColor"
+           style="height:1rem;width:1rem;vertical-align: text-bottom;">
+        <path fill-rule="evenodd"
+              d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z"
+              clip-rule="evenodd"/>
+      </svg>
+    </a>
+    <ul class="menu">
+      <li>
+        <a href="{% url 'bookmarks:index' %}" class="btn btn-link">Active</a>
+      </li>
+      <li>
+        <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archived</a>
+      </li>
+      {% if request.user.profile.enable_sharing %}
+        <li>
+          <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared</a>
+        </li>
+      {% endif %}
+      <li>
+        <a href="{% url 'bookmarks:index' %}?q=!unread" class="btn btn-link">Unread</a>
+      </li>
+      <li>
+        <a href="{% url 'bookmarks:index' %}?q=!untagged" class="btn btn-link">Untagged</a>
+      </li>
+    </ul>
+  </div>
+  <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
+  <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
 </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">
+    <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>
+  <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>
     </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>
-        </a>
-        <!-- menu component -->
-        <ul class="menu">
-            <li>
-                <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archive</a>
-            </li>
-            <li>
-                <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
-            </li>
-            <li>
-                <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
-            </li>
-        </ul>
-    </div>
+    <!-- menu component -->
+    <ul class="menu">
+      <li>
+        <a href="{% url 'bookmarks:index' %}" class="btn btn-link">Bookmarks</a>
+      </li>
+      <li style="padding-left: 1rem">
+        <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archived</a>
+      </li>
+      {% if request.user.profile.enable_sharing %}
+        <li style="padding-left: 1rem">
+          <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared</a>
+        </li>
+      {% endif %}
+      <li style="padding-left: 1rem">
+        <a href="{% url 'bookmarks:index' %}?q=!unread" class="btn btn-link">Unread</a>
+      </li>
+      <li style="padding-left: 1rem">
+        <a href="{% url 'bookmarks:index' %}?q=!untagged" class="btn btn-link">Untagged</a>
+      </li>
+      <li>
+        <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
+      </li>
+      <li>
+        <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
+      </li>
+    </ul>
+  </div>
 </div>
+{% endhtmlmin %}
 <script>
-    // Hide mobile menu on outside click
-    // The Spectre CSS component relies on focus changes to show/hide the dropdown, however mobile browsers like
-    // Safari will not trigger a blur event when clicking on a non-focusable element, so we have to simulate the
-    // behaviour through Javascript
-    const mobileNavMenuTrigger = document.getElementById('mobile-nav-menu-trigger');
+  // Hide mobile menu on outside click
+  // The Spectre CSS component relies on focus changes to show/hide the dropdown, however mobile browsers like
+  // Safari will not trigger a blur event when clicking on a non-focusable element, so we have to simulate the
+  // behaviour through Javascript
+  const mobileNavMenuTrigger = document.getElementById('mobile-nav-menu-trigger');
 
-    function mobileNavMenuOutsideClickHandler(clickEvent) {
-        if (mobileNavMenuTrigger.parentElement.contains(clickEvent.target)) return
-        mobileNavMenuTrigger.blur();
-    }
+  function mobileNavMenuOutsideClickHandler(clickEvent) {
+    if (mobileNavMenuTrigger.parentElement.contains(clickEvent.target)) return
+    mobileNavMenuTrigger.blur();
+  }
 
-    mobileNavMenuTrigger.addEventListener('focus', function () {
-        document.addEventListener('click', mobileNavMenuOutsideClickHandler);
-    })
-    mobileNavMenuTrigger.addEventListener('blur', function () {
-        document.removeEventListener('click', mobileNavMenuOutsideClickHandler);
-    })
+  mobileNavMenuTrigger.addEventListener('focus', function () {
+    document.addEventListener('click', mobileNavMenuOutsideClickHandler);
+  })
+  mobileNavMenuTrigger.addEventListener('blur', function () {
+    document.removeEventListener('click', mobileNavMenuOutsideClickHandler);
+  })
 </script>

bookmarks/templates/bookmarks/new.html

@@ -2,14 +2,14 @@
 {% load bookmarks %}
 
 {% block content %}
-    <div class="columns">
-        <section class="content-area column col-12">
-            <div class="content-area-header">
-                <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 %}
-            </form>
-        </section>
-    </div>
+  <div class="columns">
+    <section class="content-area column col-12">
+      <div class="content-area-header">
+        <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 %}
+      </form>
+    </section>
+  </div>
 {% endblock %}

bookmarks/templates/bookmarks/pagination.html

@@ -1,35 +1,35 @@
 {% load shared %}
 
 <ul class="pagination">
-    {% if page.has_previous %}
-        <li class="page-item">
-            <a href="?{% update_query_string page=page.previous_page_number %}" tabindex="-1">Previous</a>
-        </li>
-    {% else %}
-        <li class="page-item disabled">
-            <a href="#" tabindex="-1">Previous</a>
-        </li>
-    {% endif %}
+  {% if page.has_previous %}
+    <li class="page-item">
+      <a href="?{% update_query_string page=page.previous_page_number %}" tabindex="-1">Previous</a>
+    </li>
+  {% else %}
+    <li class="page-item disabled">
+      <a href="#" tabindex="-1">Previous</a>
+    </li>
+  {% endif %}
 
-    {% for page_number in visible_page_numbers %}
-        {% if page_number >= 0 %}
-            <li class="page-item {% if page.number == page_number %}active{% endif %}">
-                <a href="?{% update_query_string page=page_number %}">{{ page_number }}</a>
-            </li>
-        {% else %}
-            <li class="page-item">
-                <span>...</span>
-            </li>
-        {% endif %}
-    {% endfor %}
-
-    {% if page.has_next %}
-        <li class="page-item">
-            <a href="?{% update_query_string page=page.next_page_number %}" tabindex="-1">Next</a>
-        </li>
+  {% for page_number in visible_page_numbers %}
+    {% if page_number >= 0 %}
+      <li class="page-item {% if page.number == page_number %}active{% endif %}">
+        <a href="?{% update_query_string page=page_number %}">{{ page_number }}</a>
+      </li>
     {% else %}
-        <li class="page-item disabled">
-            <a href="#" tabindex="-1">Next</a>
-        </li>
+      <li class="page-item">
+        <span>...</span>
+      </li>
     {% endif %}
+  {% endfor %}
+
+  {% if page.has_next %}
+    <li class="page-item">
+      <a href="?{% update_query_string page=page.next_page_number %}" tabindex="-1">Next</a>
+    </li>
+  {% else %}
+    <li class="page-item disabled">
+      <a href="#" tabindex="-1">Next</a>
+    </li>
+  {% endif %}
 </ul>

bookmarks/templates/bookmarks/search.html

@@ -1,34 +1,43 @@
 <div class="search">
-    <form action="" method="get" role="search">
-        <div class="input-group">
+  <form action="" method="get" role="search">
+    <div class="input-group">
             <span id="search-input-wrap">
                 <input type="search" class="form-input" name="q" placeholder="Search for words or #tags"
-                       value="{{ query }}">
+                       value="{{ filters.query }}">
             </span>
-            <input type="submit" value="Search" class="btn input-group-btn">
-        </div>
-    </form>
+      <input type="submit" value="Search" class="btn input-group-btn">
+    </div>
+    {% if filters.user %}
+      <input type="hidden" name="user" value="{{ filters.user }}">
+    {% endif %}
+  </form>
 </div>
 
 {# Replace search input with auto-complete component #}
 <script type="application/javascript">
-    window.addEventListener("load", function() {
-        const currentTagsString = '{{ tags_string }}';
-        const currentTags = currentTagsString.split(' ');
-        const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')
-        const wrapper = document.getElementById('search-input-wrap')
-        const newWrapper = document.createElement('div')
-        new linkding.SearchAutoComplete({
-            target: newWrapper,
-            props: {
-                name: 'q',
-                placeholder: 'Search for words or #tags',
-                value: '{{ query }}',
-                tags: currentTags,
-                mode: '{{ mode }}',
-                apiClient
-            }
-        })
-        wrapper.parentElement.replaceChild(newWrapper, wrapper)
-    });
+  window.addEventListener("load", function () {
+    const currentTagsString = '{{ tags_string }}';
+    const currentTags = currentTagsString.split(' ');
+    const uniqueTags = [...new Set(currentTags)]
+    const filters = {
+      q: '{{ filters.query }}',
+      user: '{{ filters.user }}',
+    }
+    const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')
+    const wrapper = document.getElementById('search-input-wrap')
+    const newWrapper = document.createElement('div')
+    new linkding.SearchAutoComplete({
+      target: newWrapper,
+      props: {
+        name: 'q',
+        placeholder: 'Search for words or #tags',
+        value: '{{ filters.query }}',
+        tags: uniqueTags,
+        mode: '{{ mode }}',
+        apiClient,
+        filters,
+      }
+    })
+    wrapper.parentElement.replaceChild(newWrapper, wrapper)
+  });
 </script>

bookmarks/templates/bookmarks/shared.html

@@ -0,0 +1,49 @@
+{% extends "bookmarks/layout.html" %}
+{% load static %}
+{% load shared %}
+{% load bookmarks %}
+
+{% block content %}
+
+  <div class="bookmarks-page columns">
+
+    {# Bookmark list #}
+    <section class="content-area column col-8 col-md-12">
+      <div class="content-area-header">
+        <h2>Shared bookmarks</h2>
+        <div class="spacer"></div>
+        {% bookmark_search filters tags mode='shared' %}
+      </div>
+
+      <form class="bookmark-actions" action="{% url 'bookmarks:action' %}?return_url={{ return_url }}"
+            method="post">
+        {% csrf_token %}
+
+        {% if empty %}
+          {% include 'bookmarks/empty_bookmarks.html' %}
+        {% else %}
+          {% bookmark_list bookmarks return_url link_target %}
+        {% endif %}
+      </form>
+    </section>
+
+    {# Filters #}
+    <section class="content-area column col-4 hide-md">
+      <div class="content-area-header">
+        <h2>User</h2>
+      </div>
+      <div>
+        {% user_select filters users %}
+        <br>
+      </div>
+      <div class="content-area-header">
+        <h2>Tags</h2>
+      </div>
+      {% tag_cloud tags selected_tags %}
+    </section>
+  </div>
+
+  <script src="{% static "bundle.js" %}"></script>
+  <script src="{% static "shared.js" %}"></script>
+  <script src="{% static "bookmark_list.js" %}"></script>
+{% endblock %}

bookmarks/templates/bookmarks/tag_cloud.html

@@ -1,23 +1,37 @@
 {% load shared %}
-
-<div class="tag-cloud">
-    {% for group in groups %}
+{% htmlmin %}
+  <div class="tag-cloud">
+    {% if has_selected_tags %}
+      <p class="selected-tags">
+        {% for tag in selected_tags %}
+          <a href="?{% remove_tag_from_query tag.name %}"
+             class="text-bold mr-2">
+            <span>-{{ tag.name }}</span>
+          </a>
+        {% endfor %}
+      </p>
+    {% endif %}
+    <div class="unselected-tags">
+      {% for group in groups %}
         <p class="group">
-            {% for tag in group.tags %}
-                {# 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>
-                        <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>
-                        <span>{{ tag.name }}</span>
-                    </a>
-                {% endif %}
-            {% endfor %}
+          {% for tag in group.tags %}
+            {# Highlight first char of first tag in group #}
+            {% if forloop.counter == 1 %}
+              <a href="?{% add_tag_to_query tag.name %}"
+                 class="mr-2" data-is-tag-item>
+                <span
+                    class="highlight-char">{{ tag.name|first_char }}</span><span>{{ tag.name|remaining_chars:1 }}</span>
+              </a>
+            {% else %}
+              {# Render remaining tags normally #}
+              <a href="?{% add_tag_to_query tag.name %}"
+                 class="mr-2" data-is-tag-item>
+                <span>{{ tag.name }}</span>
+              </a>
+            {% endif %}
+          {% endfor %}
         </p>
-    {% endfor %}
-</div>
+      {% endfor %}
+    </div>
+  </div>
+{% endhtmlmin %}

bookmarks/templates/bookmarks/user_select.html

@@ -0,0 +1,29 @@
+<form id="user-select" action="" method="get">
+  {% if filters.query %}
+    <input type="hidden" name="q" value="{{ filters.query }}">
+  {% endif %}
+  <div class="form-group">
+    <div class="d-flex">
+      <select name="user" class="form-select">
+        <option value="">Everyone</option>
+        {% for user in users %}
+          <option value="{{ user.username }}"
+                  {% if user.username == filters.user %}selected{% endif %}
+                  data-is-user-option>
+            {{ user.username }}
+          </option>
+        {% endfor %}
+      </select>
+      <noscript>
+        <button type="submit" class="btn btn-link ml-2">Apply</button>
+      </noscript>
+    </div>
+  </div>
+</form>
+<script>
+  const form = document.getElementById('user-select');
+  const select = form.querySelector('select');
+  select.addEventListener('change', () => {
+    form.submit();
+  });
+</script>

bookmarks/templates/settings/general.html

@@ -2,110 +2,198 @@
 {% load widget_tweaks %}
 
 {% block content %}
-    <div class="settings-page">
+  <div class="settings-page">
 
-        {% include 'settings/nav.html' %}
+    {% 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>
+    {# 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.display_url.id_for_label }}" class="form-checkbox">
+            {{ form.display_url }}
+            <i class="form-icon"></i> Show bookmark URL
+          </label>
+          <div class="form-input-hint">
+            When enabled, this setting displays the bookmark URL below the title.
+          </div>
+        </div>
+        <div class="form-group">
+          <label for="{{ form.permanent_notes.id_for_label }}" class="form-checkbox">
+            {{ form.permanent_notes }}
+            <i class="form-icon"></i> Show notes permanently
+          </label>
+          <div class="form-input-hint">
+            Whether to show bookmark notes permanently, without having to toggle them individually.
+            Alternatively the keyboard shortcut <code>e</code> can be used to temporarily show all notes.
+          </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.tag_search.id_for_label }}" class="form-label">Tag search</label>
+          {{ form.tag_search|add_class:"form-select col-2 col-sm-12" }}
+          <div class="form-input-hint">
+            In strict mode, tags must be prefixed with a hash character (#).
+            In lax mode, tags can also be searched without the hash character.
+            Note that tags without the hash character are indistinguishable from search terms, which means the search result will also include bookmarks where a search term matches otherwise.
+          </div>
+        </div>
+        <div class="form-group">
+          <label for="{{ form.enable_favicons.id_for_label }}" class="form-checkbox">
+            {{ form.enable_favicons }}
+            <i class="form-icon"></i> Enable Favicons
+          </label>
+          <div class="form-input-hint">
+            Automatically loads favicons for bookmarked websites and displays them next to each bookmark.
+            By default, this feature uses a <b>Google service</b> to download favicons.
+            If you don't want to use this service, check the <a
+              href="https://github.com/sissbruecker/linkding/blob/master/docs/Options.md" target="_blank">options
+            documentation</a> on how to configure a custom favicon provider.
+            Icons are downloaded in the background, and it may take a while for them to show up.
+          </div>
+          {% if request.user.profile.enable_favicons and enable_refresh_favicons %}
+            <button class="btn mt-2" name="refresh_favicons">Refresh Favicons</button>
+          {% endif %}
+          {% if refresh_favicons_success_message %}
+            <div class="has-success">
+              <p class="form-input-hint">
+                {{ refresh_favicons_success_message }}
+              </p>
+            </div>
+          {% endif %}
+        </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.
+            Please consider donating to the <a href="https://archive.org/donate/index.php" target="_blank"
+                                               rel="noopener">Internet Archive</a> if you make use of this feature.
+          </div>
+        </div>
+        <div class="form-group">
+          <label for="{{ form.enable_sharing.id_for_label }}" class="form-checkbox">
+            {{ form.enable_sharing }}
+            <i class="form-icon"></i> Enable bookmark sharing
+          </label>
+          <div class="form-input-hint">
+            Allows to share bookmarks with other users, and to view shared bookmarks.
+            Disabling this feature will hide all previously shared bookmarks from other users.
+          </div>
+        </div>
+        <div class="form-group">
+          <input type="submit" name="update_profile" value="Save" class="btn btn-primary mt-2">
+          {% if update_profile_success_message %}
+            <div class="has-success">
+              <p class="form-input-hint">
+                {{ update_profile_success_message }}
+              </p>
+            </div>
+          {% endif %}
+        </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>
+    {# 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>
+    {# 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>
+    {# About section #}
+    <section class="content-area about">
+      <h2>About</h2>
+      <table class="table">
+        <tbody>
+        <tr>
+          <td>Version</td>
+          <td>{{ version_info }}</td>
+        </tr>
+        <tr>
+          <td rowspan="3" style="vertical-align: top">Links</td>
+          <td><a href="https://github.com/sissbruecker/linkding/"
+                 target="_blank">GitHub</a></td>
+        </tr>
+        <tr>
+          <td><a href="https://github.com/sissbruecker/linkding#documentation"
+                 target="_blank">Documentation</a></td>
+        </tr>
+        <tr>
+          <td><a href="https://github.com/sissbruecker/linkding/blob/master/CHANGELOG.md"
+                 target="_blank">Changelog</a></td>
+        </tr>
+        </tbody>
+      </table>
+    </section>
+  </div>
 
 {% endblock %}

bookmarks/templates/settings/integrations.html

@@ -38,9 +38,31 @@
                     </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>
+            <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.
+              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>
+
+        <section class="content-area">
+            <h2>RSS Feeds</h2>
+            <p>The following URLs provide RSS feeds for your bookmarks:</p>
+            <ul>
+              <li><a href="{{ all_feed_url }}">All bookmarks</a></li>
+              <li><a href="{{ unread_feed_url }}">Unread bookmarks</a></li>
+            </ul>
+            <p>
+              All URLs support appending a <code>q</code> URL parameter for specifying a search query.
+              You can get an example by doing a search in the bookmarks view and then copying the parameter from the URL.
+            </p>
+            <p>
+              <strong>Please note that these URLs include an authentication token that should be treated like any other credential.</strong>
+              Any party with access to these URLs can read all your bookmarks.
+              If you think that a URL was compromised you can delete the feed token for your user in the <a href="{% url 'admin:bookmarks_feedtoken_changelist' %}">admin panel</a>.
+              After deleting the feed token, new URLs will be generated when you reload this settings page.
+            </p>
         </section>
     </div>
 {% endblock %}

bookmarks/templates/settings/nav.html

@@ -9,6 +9,7 @@
     <li class="tab-item {% if request.get_full_path == integrations_url %}active{% endif %}">
         <a href="{% url 'bookmarks:settings.integrations' %}">Integrations</a>
     </li>
+    {% if request.user.is_superuser %}
     <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>
@@ -18,5 +19,6 @@
             </svg>
         </a>
     </li>
+    {% endif %}
 </ul>
 <br>

bookmarks/templatetags/bookmarks.py

@@ -1,16 +1,18 @@
-from typing import List
+from typing import List, Set
 
 from django import template
 from django.core.paginator import Page
 
-from bookmarks.models import BookmarkForm, Tag, build_tag_string
+from bookmarks.models import BookmarkForm, BookmarkFilters, Tag, build_tag_string, User
+from bookmarks.utils import unique
 
 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):
+@register.inclusion_tag('bookmarks/form.html', name='bookmark_form', takes_context=True)
+def bookmark_form(context, form: BookmarkForm, cancel_url: str, bookmark_id: int = 0, auto_close: bool = False):
     return {
+        'request': context['request'],
         'form': form,
         'auto_close': auto_close,
         'bookmark_id': bookmark_id,
@@ -24,7 +26,8 @@ class TagGroup:
         self.char = char
 
 
-def create_tag_groups(tags: List[Tag]):
+def create_tag_groups(tags: Set[Tag]):
+    # Ensure groups, as well as tags within groups, are ordered alphabetically
     sorted_tags = sorted(tags, key=lambda x: str.lower(x.name))
     group = None
     groups = []
@@ -43,10 +46,21 @@ def create_tag_groups(tags: List[Tag]):
 
 
 @register.inclusion_tag('bookmarks/tag_cloud.html', name='tag_cloud', takes_context=True)
-def tag_cloud(context, tags: List[Tag]):
-    groups = create_tag_groups(tags)
+def tag_cloud(context, tags: List[Tag], selected_tags: List[Tag]):
+    # Only display each tag name once, ignoring casing
+    # This covers cases where the tag cloud contains shared tags with duplicate names
+    # Also means that the cloud can not make assumptions that it will necessarily contain
+    # all tags of the current user
+    unique_tags = unique(tags, key=lambda x: str.lower(x.name))
+    unique_selected_tags = unique(selected_tags, key=lambda x: str.lower(x.name))
+
+    has_selected_tags = len(unique_selected_tags) > 0
+    unselected_tags = set(unique_tags).symmetric_difference(unique_selected_tags)
+    groups = create_tag_groups(unselected_tags)
     return {
         'groups': groups,
+        'selected_tags': unique_selected_tags,
+        'has_selected_tags': has_selected_tags,
     }
 
 
@@ -61,11 +75,20 @@ def bookmark_list(context, bookmarks: Page, return_url: str, link_target: str =
 
 
 @register.inclusion_tag('bookmarks/search.html', name='bookmark_search', takes_context=True)
-def bookmark_search(context, query: str, tags: [Tag], mode: str = 'default'):
+def bookmark_search(context, filters: BookmarkFilters, tags: [Tag], mode: str = ''):
     tag_names = [tag.name for tag in tags]
     tags_string = build_tag_string(tag_names, ' ')
     return {
-        'query': query,
+        'filters': filters,
         'tags_string': tags_string,
         'mode': mode,
     }
+
+
+@register.inclusion_tag('bookmarks/user_select.html', name='user_select', takes_context=True)
+def user_select(context, filters: BookmarkFilters, users: List[User]):
+    sorted_users = sorted(users, key=lambda x: str.lower(x.username))
+    return {
+        'filters': filters,
+        'users': sorted_users,
+    }

bookmarks/templatetags/shared.py

@@ -1,6 +1,13 @@
+import re
+
+import bleach
+import markdown
+from bleach_allowlist import markdown_tags, markdown_attrs
 from django import template
+from django.utils.safestring import mark_safe
 
 from bookmarks import utils
+from bookmarks.models import UserProfile
 
 register = template.Library()
 
@@ -17,16 +24,48 @@ def update_query_string(context, **kwargs):
 
 
 @register.simple_tag(takes_context=True)
-def append_query_param(context, **kwargs):
+def add_tag_to_query(context, tag_name: str):
+    params = context.request.GET.copy()
+
+    # Append to or create query string
+    if params.__contains__('q'):
+        query_string = params.__getitem__('q') + ' '
+    else:
+        query_string = ''
+    query_string = query_string + '#' + tag_name
+    params.__setitem__('q', query_string)
+
+    return params.urlencode()
+
+
+@register.simple_tag(takes_context=True)
+def remove_tag_from_query(context, tag_name: str):
+    params = context.request.GET.copy()
+    if params.__contains__('q'):
+        # Split query string into parts
+        query_string = params.__getitem__('q')
+        query_parts = query_string.split()
+        # Remove tag with hash
+        tag_name_with_hash = '#' + tag_name
+        query_parts = [part for part in query_parts if str.lower(part) != str.lower(tag_name_with_hash)]
+        # When using lax tag search, also remove tag without hash
+        profile = context.request.user.profile
+        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
+            query_parts = [part for part in query_parts if str.lower(part) != str.lower(tag_name)]
+        # Rebuild query string
+        query_string = ' '.join(query_parts)
+        params.__setitem__('q', query_string)
+
+    return params.urlencode()
+
+
+@register.simple_tag(takes_context=True)
+def replace_query_param(context, **kwargs):
     query = context.request.GET.copy()
 
-    # Append to or create query param
+    # Create query param or replace existing
     for key in kwargs:
-        if query.__contains__(key):
-            value = query.__getitem__(key) + ' '
-        else:
-            value = ''
-        value = value + kwargs[key]
+        value = kwargs[key]
         query.__setitem__(key, value)
 
     return query.urlencode()
@@ -59,3 +98,38 @@ def humanize_relative_date(value):
     if value in (None, ''):
         return ''
     return utils.humanize_relative_date(value)
+
+
+@register.tag
+def htmlmin(parser, token):
+    nodelist = parser.parse(('endhtmlmin',))
+    parser.delete_first_token()
+    return HtmlMinNode(nodelist)
+
+
+class HtmlMinNode(template.Node):
+    def __init__(self, nodelist):
+        self.nodelist = nodelist
+
+    def render(self, context):
+        output = self.nodelist.render(context)
+
+        output = re.sub(r'\s+', ' ', output)
+
+        return output
+
+
+@register.simple_tag(name="markdown", takes_context=True)
+def render_markdown(context, markdown_text):
+    # naive approach to reusing the renderer for a single request
+    # works for bookmark list for now
+    if not ('markdown_renderer' in context):
+        renderer = markdown.Markdown(extensions=['fenced_code', 'nl2br'])
+        context['markdown_renderer'] = renderer
+    else:
+        renderer = context['markdown_renderer']
+
+    as_html = renderer.convert(markdown_text)
+    sanitized_html = bleach.clean(as_html, markdown_tags, markdown_attrs)
+
+    return mark_safe(sanitized_html)

bookmarks/tests/helpers.py

@@ -1,8 +1,8 @@
 import random
 import logging
-from dataclasses import dataclass
-from typing import Optional, List
+from typing import List
 
+from bs4 import BeautifulSoup
 from django.contrib.auth.models import User
 from django.utils import timezone
 from django.utils.crypto import get_random_string
@@ -23,15 +23,21 @@ class BookmarkFactoryMixin:
 
     def setup_bookmark(self,
                        is_archived: bool = False,
+                       unread: bool = False,
+                       shared: bool = False,
                        tags=None,
                        user: User = None,
                        url: str = '',
                        title: str = '',
                        description: str = '',
+                       notes: str = '',
                        website_title: str = '',
                        website_description: str = '',
                        web_archive_snapshot_url: str = '',
+                       favicon_file: str = '',
                        ):
+        if not title:
+            title = get_random_string(length=32)
         if tags is None:
             tags = []
         if user is None:
@@ -43,13 +49,17 @@ class BookmarkFactoryMixin:
             url=url,
             title=title,
             description=description,
+            notes=notes,
             website_title=website_title,
             website_description=website_description,
             date_added=timezone.now(),
             date_modified=timezone.now(),
             owner=user,
             is_archived=is_archived,
+            unread=unread,
+            shared=shared,
             web_archive_snapshot_url=web_archive_snapshot_url,
+            favicon_file=favicon_file,
         )
         bookmark.save()
         for tag in tags:
@@ -66,6 +76,19 @@ class BookmarkFactoryMixin:
         tag.save()
         return tag
 
+    def setup_user(self, name: str = None, enable_sharing: bool = False):
+        if not name:
+            name = get_random_string(length=32)
+        user = User.objects.create_user(name, 'user@example.com', 'password123')
+        user.profile.enable_sharing = enable_sharing
+        user.profile.save()
+        return user
+
+
+class HtmlTestMixin:
+    def make_soup(self, html: str):
+        return BeautifulSoup(html, features="html.parser")
+
 
 class LinkdingApiTestCase(APITestCase):
     def get(self, url, expected_status_code=status.HTTP_200_OK):
@@ -83,6 +106,11 @@ class LinkdingApiTestCase(APITestCase):
         self.assertEqual(response.status_code, expected_status_code)
         return response
 
+    def patch(self, url, data=None, expected_status_code=status.HTTP_200_OK):
+        response = self.client.patch(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)
@@ -90,12 +118,19 @@ class LinkdingApiTestCase(APITestCase):
 
 
 class BookmarkHtmlTag:
-    def __init__(self, href: str = '', title: str = '', description: str = '', add_date: str = '', tags: str = ''):
+    def __init__(self,
+                 href: str = '',
+                 title: str = '',
+                 description: str = '',
+                 add_date: str = '',
+                 tags: str = '',
+                 to_read: bool = False):
         self.href = href
         self.title = title
         self.description = description
         self.add_date = add_date
         self.tags = tags
+        self.to_read = to_read
 
 
 class ImportTestMixin:
@@ -104,7 +139,8 @@ class ImportTestMixin:
         <DT>
         <A {f'HREF="{tag.href}"' if tag.href else ''}
            {f'ADD_DATE="{tag.add_date}"' if tag.add_date else ''}
-           {f'TAGS="{tag.tags}"' if tag.tags else ''}>
+           {f'TAGS="{tag.tags}"' if tag.tags else ''}
+           TOREAD="{1 if tag.to_read else 0}">
            {tag.title if tag.title else ''}
         </A>
         {f'<DD>{tag.description}' if tag.description else ''}

bookmarks/tests/test_app_options.py

@@ -0,0 +1,29 @@
+import importlib
+import os
+from unittest import mock
+
+from django.test import TestCase
+
+
+class AppOptionsTestCase(TestCase):
+    def setUp(self) -> None:
+        self.settings_module = importlib.import_module('siteroot.settings.base')
+
+    def test_empty_csrf_trusted_origins(self):
+        module = importlib.reload(self.settings_module)
+
+        self.assertFalse(hasattr(module, 'CSRF_TRUSTED_ORIGINS'))
+
+    @mock.patch.dict(os.environ, {'LD_CSRF_TRUSTED_ORIGINS': 'https://linkding.example.com'})
+    def test_single_csrf_trusted_origin(self):
+        module = importlib.reload(self.settings_module)
+
+        self.assertTrue(hasattr(module, 'CSRF_TRUSTED_ORIGINS'))
+        self.assertCountEqual(module.CSRF_TRUSTED_ORIGINS, ['https://linkding.example.com'])
+
+    @mock.patch.dict(os.environ, {'LD_CSRF_TRUSTED_ORIGINS': 'https://linkding.example.com,http://linkding.example.com'})
+    def test_multiple_csrf_trusted_origin(self):
+        module = importlib.reload(self.settings_module)
+
+        self.assertTrue(hasattr(module, 'CSRF_TRUSTED_ORIGINS'))
+        self.assertCountEqual(module.CSRF_TRUSTED_ORIGINS, ['https://linkding.example.com', 'http://linkding.example.com'])

bookmarks/tests/test_auth_proxy_support.py

@@ -0,0 +1,46 @@
+from unittest.mock import patch, PropertyMock
+
+from django.test import TestCase, modify_settings
+from django.urls import reverse
+from bookmarks.models import User
+from bookmarks.middlewares import CustomRemoteUserMiddleware
+
+
+class AuthProxySupportTest(TestCase):
+    # Reproducing configuration from the settings logic here
+    # ideally this test would just override the respective options
+    @modify_settings(
+        MIDDLEWARE={'append': 'bookmarks.middlewares.CustomRemoteUserMiddleware'},
+        AUTHENTICATION_BACKENDS={'prepend': 'django.contrib.auth.backends.RemoteUserBackend'}
+    )
+    def test_auth_proxy_authentication(self):
+        user = User.objects.create_user('auth_proxy_user', 'user@example.com', 'password123')
+
+        headers = {'REMOTE_USER': user.username}
+        response = self.client.get(reverse('bookmarks:index'), **headers)
+
+        self.assertEqual(response.status_code, 200)
+
+    # Reproducing configuration from the settings logic here
+    # ideally this test would just override the respective options
+    @modify_settings(
+        MIDDLEWARE={'append': 'bookmarks.middlewares.CustomRemoteUserMiddleware'},
+        AUTHENTICATION_BACKENDS={'prepend': 'django.contrib.auth.backends.RemoteUserBackend'}
+    )
+    def test_auth_proxy_with_custom_header(self):
+        with patch.object(CustomRemoteUserMiddleware, 'header', new_callable=PropertyMock) as mock:
+            mock.return_value = 'Custom-User'
+            user = User.objects.create_user('auth_proxy_user', 'user@example.com', 'password123')
+
+            headers = {'Custom-User': user.username}
+            response = self.client.get(reverse('bookmarks:index'), **headers)
+
+            self.assertEqual(response.status_code, 200)
+
+    def test_auth_proxy_is_disabled_by_default(self):
+        user = User.objects.create_user('auth_proxy_user', 'user@example.com', 'password123')
+
+        headers = {'REMOTE_USER': user.username}
+        response = self.client.get(reverse('bookmarks:index'), **headers, follow=True)
+
+        self.assertRedirects(response, '/login/?next=%2Fbookmarks')

bookmarks/tests/test_bookmark_action_view.py

@@ -84,6 +84,16 @@ class BookmarkActionViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(response.status_code, 404)
         self.assertTrue(Bookmark.objects.filter(id=bookmark.id).exists())
 
+    def test_mark_as_read(self):
+        bookmark = self.setup_bookmark(unread=True)
+
+        self.client.post(reverse('bookmarks:action'), {
+            'mark_as_read': [bookmark.id],
+        })
+        bookmark.refresh_from_db()
+
+        self.assertFalse(bookmark.unread)
+
     def test_bulk_archive(self):
         bookmark1 = self.setup_bookmark()
         bookmark2 = self.setup_bookmark()

bookmarks/tests/test_bookmark_archived_view.py

@@ -1,47 +1,60 @@
+from typing import List
+
 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
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
 
 
-class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
     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'):
+    def assertVisibleBookmarks(self, response, bookmarks: List[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>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html
             )
 
-    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+    def assertInvisibleBookmarks(self, response, bookmarks: List[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>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html,
                 count=0
             )
 
-    def assertVisibleTags(self, response, tags: [Tag]):
+    def assertVisibleTags(self, response, tags: List[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]):
+    def assertInvisibleTags(self, response, tags: List[Tag]):
         for tag in tags:
             self.assertNotContains(response, tag.name)
 
+    def assertSelectedTags(self, response, tags: List[Tag]):
+        soup = self.make_soup(response.content.decode())
+        selected_tags = soup.select('p.selected-tags')[0]
+        self.assertIsNotNone(selected_tags)
+
+        tag_list = selected_tags.select('a')
+        self.assertEqual(len(tag_list), len(tags))
+
+        for tag in tags:
+            self.assertTrue(tag.name in selected_tags.text, msg=f'Selected tags do not contain: {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 = [
@@ -119,7 +132,7 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
             self.setup_tag(),
         ]
 
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue'),
+        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]])
@@ -131,6 +144,51 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
 
+    def test_should_display_selected_tags_from_query(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(is_archived=True, tags=tags)
+
+        response = self.client.get(reverse('bookmarks:archived') + f'?q=%23{tags[0].name}+%23{tags[1].name}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
+    def test_should_not_display_search_terms_from_query_as_selected_tags_in_strict_mode(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(title=tags[0].name, tags=tags, is_archived=True)
+
+        response = self.client.get(reverse('bookmarks:archived') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[1]])
+
+    def test_should_display_search_terms_from_query_as_selected_tags_in_lax_mode(self):
+        self.user.profile.tag_search = UserProfile.TAG_SEARCH_LAX
+        self.user.profile.save()
+
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(tags=tags, is_archived=True)
+
+        response = self.client.get(reverse('bookmarks:archived') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
     def test_should_open_bookmarks_in_new_page_by_default(self):
         visible_bookmarks = [
             self.setup_bookmark(is_archived=True),

bookmarks/tests/test_bookmark_archived_view_performance.py

@@ -0,0 +1,42 @@
+from django.contrib.auth.models import User
+from django.test import TransactionTestCase
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkArchivedViewPerformanceTestCase(TransactionTestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_should_not_increase_number_of_queries_per_bookmark(self):
+        # create initial bookmarks
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(user=self.user, is_archived=True)
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            response = self.client.get(reverse('bookmarks:archived'))
+            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks)
+
+        number_of_queries = context.final_queries
+
+        # add more bookmarks
+        num_additional_bookmarks = 10
+        for index in range(num_additional_bookmarks):
+            self.setup_bookmark(user=self.user, is_archived=True)
+
+        # assert num queries doesn't increase
+        with self.assertNumQueries(number_of_queries):
+            response = self.client.get(reverse('bookmarks:archived'))
+            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks + num_additional_bookmarks)

bookmarks/tests/test_bookmark_edit_view.py

@@ -20,6 +20,9 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
             'tag_string': 'editedtag1 editedtag2',
             'title': 'edited title',
             'description': 'edited description',
+            'notes': 'edited notes',
+            'unread': False,
+            'shared': False,
         }
         return {**form_data, **overrides}
 
@@ -35,39 +38,87 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, form_data['url'])
         self.assertEqual(bookmark.title, form_data['title'])
         self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.notes, form_data['notes'])
+        self.assertEqual(bookmark.unread, form_data['unread'])
+        self.assertEqual(bookmark.shared, form_data['shared'])
         self.assertEqual(bookmark.tags.count(), 2)
-        self.assertEqual(bookmark.tags.all()[0].name, 'editedtag1')
-        self.assertEqual(bookmark.tags.all()[1].name, 'editedtag2')
+        tags = bookmark.tags.order_by('name').all()
+        self.assertEqual(tags[0].name, 'editedtag1')
+        self.assertEqual(tags[1].name, 'editedtag2')
+
+    def test_should_edit_unread_state(self):
+        bookmark = self.setup_bookmark()
+
+        form_data = self.create_form_data({'id': bookmark.id, 'unread': True})
+        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+        bookmark.refresh_from_db()
+        self.assertTrue(bookmark.unread)
+
+        form_data = self.create_form_data({'id': bookmark.id, 'unread': False})
+        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+        bookmark.refresh_from_db()
+        self.assertFalse(bookmark.unread)
+
+    def test_should_edit_shared_state(self):
+        bookmark = self.setup_bookmark()
+
+        form_data = self.create_form_data({'id': bookmark.id, 'shared': True})
+        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+        bookmark.refresh_from_db()
+        self.assertTrue(bookmark.shared)
+
+        form_data = self.create_form_data({'id': bookmark.id, 'shared': False})
+        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+        bookmark.refresh_from_db()
+        self.assertFalse(bookmark.shared)
 
     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')
+        bookmark = self.setup_bookmark(tags=[tag1, tag2], title='edited title', description='edited description',
+                                       notes='edited notes', website_title='website title',
+                                       website_description='website 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)
+        self.assertInHTML(f'''
+            <input type="text" name="url" value="{bookmark.url}" placeholder=" "
+                    autofocus class="form-input" required id="id_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(f'''
+            <input type="text" name="tag_string" value="{tag_string}" 
+                    autocomplete="off" autocapitalize="off" class="form-input" id="id_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(f'''
+            <input type="text" name="title" value="{bookmark.title}" maxlength="512" autocomplete="off" 
+                    class="form-input" id="id_title">
+        ''', html)
 
-        self.assertInHTML('<textarea name="description" cols="40" rows="4" class="form-input" id="id_description">{0}'
-                          '</textarea>'.format(bookmark.description),
-                          html)
+        self.assertInHTML(f'''
+            <textarea name="description" cols="40" rows="2" class="form-input" id="id_description">
+                {bookmark.description}
+            </textarea>
+        ''', html)
+
+        self.assertInHTML(f'''
+            <textarea name="notes" cols="40" rows="8" class="form-input" id="id_notes">
+                {bookmark.notes}
+            </textarea>
+        ''', html)
+
+        self.assertInHTML(f'''
+            <input type="hidden" name="website_title"  id="id_website_title"
+                    value="{bookmark.website_title}">
+        ''', html)
+
+        self.assertInHTML(f'''
+            <input type="hidden" name="website_description"  id="id_website_description"
+                    value="{bookmark.website_description}">
+        ''', html)
 
     def test_should_redirect_to_return_url(self):
         bookmark = self.setup_bookmark()
@@ -114,3 +165,43 @@ class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertNotEqual(bookmark.url, form_data['url'])
         self.assertEqual(response.status_code, 404)
 
+    def test_should_respect_share_profile_setting(self):
+        bookmark = self.setup_bookmark()
+
+        self.user.profile.enable_sharing = False
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+        html = response.content.decode()
+
+        self.assertInHTML('''
+            <label for="id_shared" class="form-checkbox">
+              <input type="checkbox" name="shared" id="id_shared">
+              <i class="form-icon"></i>
+              <span>Share</span>
+            </label>            
+        ''', html, count=0)
+
+        self.user.profile.enable_sharing = True
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+        html = response.content.decode()
+
+        self.assertInHTML('''
+            <label for="id_shared" class="form-checkbox">
+              <input type="checkbox" name="shared" id="id_shared">
+              <i class="form-icon"></i>
+              <span>Share</span>
+            </label>            
+        ''', html, count=1)
+
+    def test_should_hide_notes_if_there_are_no_notes(self):
+        bookmark = self.setup_bookmark()
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+
+        self.assertContains(response, '<details class="notes">', count=1)
+
+    def test_should_show_notes_if_there_are_notes(self):
+        bookmark = self.setup_bookmark(notes='test notes')
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+
+        self.assertContains(response, '<details class="notes" open>', count=1)

bookmarks/tests/test_bookmark_index_view.py

@@ -1,47 +1,61 @@
+from typing import List
+import urllib.parse
+
 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
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
 
 
-class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
     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'):
+    def assertVisibleBookmarks(self, response, bookmarks: List[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>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html
             )
 
-    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+    def assertInvisibleBookmarks(self, response, bookmarks: List[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>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html,
                 count=0
             )
 
-    def assertVisibleTags(self, response, tags: [Tag]):
+    def assertVisibleTags(self, response, tags: List[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]):
+    def assertInvisibleTags(self, response, tags: List[Tag]):
         for tag in tags:
             self.assertNotContains(response, tag.name)
 
+    def assertSelectedTags(self, response, tags: List[Tag]):
+        soup = self.make_soup(response.content.decode())
+        selected_tags = soup.select('p.selected-tags')[0]
+        self.assertIsNotNone(selected_tags)
+
+        tag_list = selected_tags.select('a')
+        self.assertEqual(len(tag_list), len(tags))
+
+        for tag in tags:
+            self.assertTrue(tag.name in selected_tags.text, msg=f'Selected tags do not contain: {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 = [
@@ -119,7 +133,7 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
             self.setup_tag(),
         ]
 
-        self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue'),
+        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]])
@@ -131,6 +145,51 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
 
+    def test_should_display_selected_tags_from_query(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(tags=tags)
+
+        response = self.client.get(reverse('bookmarks:index') + f'?q=%23{tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
+    def test_should_not_display_search_terms_from_query_as_selected_tags_in_strict_mode(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(title=tags[0].name, tags=tags)
+
+        response = self.client.get(reverse('bookmarks:index') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[1]])
+
+    def test_should_display_search_terms_from_query_as_selected_tags_in_lax_mode(self):
+        self.user.profile.tag_search = UserProfile.TAG_SEARCH_LAX
+        self.user.profile.save()
+
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(tags=tags)
+
+        response = self.client.get(reverse('bookmarks:index') + f'?q={tags[0].name}+%23{tags[1].name.upper()}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
     def test_should_open_bookmarks_in_new_page_by_default(self):
         visible_bookmarks = [
             self.setup_bookmark(),
@@ -157,7 +216,27 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
 
         self.assertVisibleBookmarks(response, visible_bookmarks, '_self')
 
-    def test_should_show_link_for_untagged_bookmarks(self):
-        response = self.client.get(reverse('bookmarks:index'))
+    def test_edit_link_return_url_should_contain_query_params(self):
+        bookmark = self.setup_bookmark(title='foo')
 
-        self.assertContains(response, '<a href="?q=!untagged" class="text-gray text-sm">Show Untagged</a>')
+        # without query params
+        url = reverse('bookmarks:index')
+        response = self.client.get(url)
+        html = response.content.decode()
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        return_url = urllib.parse.quote_plus(url)
+
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url={return_url}">Edit</a>        
+        ''', html)
+
+        # with query params
+        url = reverse('bookmarks:index') + '?q=foo&user=user'
+        response = self.client.get(url)
+        html = response.content.decode()
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        return_url = urllib.parse.quote_plus(url)
+
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url={return_url}">Edit</a>        
+        ''', html)

bookmarks/tests/test_bookmark_index_view_performance.py

@@ -0,0 +1,42 @@
+from django.contrib.auth.models import User
+from django.test import TransactionTestCase
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkIndexViewPerformanceTestCase(TransactionTestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_should_not_increase_number_of_queries_per_bookmark(self):
+        # create initial bookmarks
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(user=self.user)
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            response = self.client.get(reverse('bookmarks:index'))
+            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks)
+
+        number_of_queries = context.final_queries
+
+        # add more bookmarks
+        num_additional_bookmarks = 10
+        for index in range(num_additional_bookmarks):
+            self.setup_bookmark(user=self.user)
+
+        # assert num queries doesn't increase
+        with self.assertNumQueries(number_of_queries):
+            response = self.client.get(reverse('bookmarks:index'))
+            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks + num_additional_bookmarks)

bookmarks/tests/test_bookmark_new_view.py

@@ -19,6 +19,9 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
             'tag_string': 'tag1 tag2',
             'title': 'test title',
             'description': 'test description',
+            'notes': 'test notes',
+            'unread': False,
+            'shared': False,
             'auto_close': '',
         }
         return {**form_data, **overrides}
@@ -35,9 +38,33 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, form_data['url'])
         self.assertEqual(bookmark.title, form_data['title'])
         self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.notes, form_data['notes'])
+        self.assertEqual(bookmark.unread, form_data['unread'])
+        self.assertEqual(bookmark.shared, form_data['shared'])
         self.assertEqual(bookmark.tags.count(), 2)
-        self.assertEqual(bookmark.tags.all()[0].name, 'tag1')
-        self.assertEqual(bookmark.tags.all()[1].name, 'tag2')
+        tags = bookmark.tags.order_by('name').all()
+        self.assertEqual(tags[0].name, 'tag1')
+        self.assertEqual(tags[1].name, 'tag2')
+
+    def test_should_create_new_unread_bookmark(self):
+        form_data = self.create_form_data({'unread': True})
+
+        self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+
+        bookmark = Bookmark.objects.first()
+        self.assertTrue(bookmark.unread)
+
+    def test_should_create_new_shared_bookmark(self):
+        form_data = self.create_form_data({'shared': True})
+
+        self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+
+        bookmark = Bookmark.objects.first()
+        self.assertTrue(bookmark.shared)
 
     def test_should_prefill_url_from_url_parameter(self):
         response = self.client.get(reverse('bookmarks:new') + '?url=http://example.com')
@@ -48,6 +75,25 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
             'placeholder=" " autofocus class="form-input" required '
             'id="id_url">',
             html)
+    
+    def test_should_prefill_title_from_url_parameter(self):
+        response = self.client.get(reverse('bookmarks:new') + '?title=Example%20Title')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="text" name="title" value="Example Title" '
+            'class="form-input" maxlength="512" autocomplete="off" '
+            'id="id_title">',
+            html)
+        
+    def test_should_prefill_description_from_url_parameter(self):
+        response = self.client.get(reverse('bookmarks:new') + '?description=Example%20Site%20Description')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<textarea name="description" class="form-input" cols="40" '
+            'rows="2" id="id_description">Example Site Description</textarea>',
+            html)
 
     def test_should_enable_auto_close_when_specified_in_url_parameter(self):
         response = self.client.get(
@@ -64,7 +110,7 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         response = self.client.get(reverse('bookmarks:new'))
         html = response.content.decode()
 
-        self.assertInHTML('<input type="hidden" name="auto_close" id="id_auto_close">',html)
+        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()
@@ -86,3 +132,36 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         response = self.client.post(reverse('bookmarks:new'), form_data)
 
         self.assertRedirects(response, reverse('bookmarks:close'))
+
+    def test_should_respect_share_profile_setting(self):
+        self.user.profile.enable_sharing = False
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+
+        self.assertInHTML('''
+            <label for="id_shared" class="form-checkbox">
+              <input type="checkbox" name="shared" id="id_shared">
+              <i class="form-icon"></i>
+              <span>Share</span>
+            </label>            
+        ''', html, count=0)
+
+        self.user.profile.enable_sharing = True
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+
+        self.assertInHTML('''
+            <label for="id_shared" class="form-checkbox">
+              <input type="checkbox" name="shared" id="id_shared">
+              <i class="form-icon"></i>
+              <span>Share</span>
+            </label>            
+        ''', html, count=1)
+
+    def test_should_hide_notes_if_there_are_no_notes(self):
+        bookmark = self.setup_bookmark()
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+
+        self.assertContains(response, '<details class="notes">', count=1)

bookmarks/tests/test_bookmark_search_tag.py

@@ -0,0 +1,40 @@
+from django.db.models import QuerySet
+from django.template import Template, RequestContext
+from django.test import TestCase, RequestFactory
+
+from bookmarks.models import BookmarkFilters, Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkSearchTagTest(TestCase, BookmarkFactoryMixin):
+    def render_template(self, url: str, tags: QuerySet[Tag] = Tag.objects.all()):
+        rf = RequestFactory()
+        request = rf.get(url)
+        filters = BookmarkFilters(request)
+        context = RequestContext(request, {
+            'request': request,
+            'filters': filters,
+            'tags': tags,
+        })
+        template_to_render = Template(
+            '{% load bookmarks %}'
+            '{% bookmark_search filters tags %}'
+        )
+        return template_to_render.render(context)
+
+    def test_render_hidden_inputs_for_filter_params(self):
+        # Should render hidden inputs if query param exists
+        url = '/test?q=foo&user=john'
+        rendered_template = self.render_template(url)
+
+        self.assertInHTML('''
+            <input type="hidden" name="user" value="john">
+        ''', rendered_template)
+
+        # Should not render hidden inputs if query param does not exist
+        url = '/test?q=foo'
+        rendered_template = self.render_template(url)
+
+        self.assertInHTML('''
+            <input type="hidden" name="user" value="john">
+        ''', rendered_template, count=0)

bookmarks/tests/test_bookmark_shared_view.py

@@ -0,0 +1,255 @@
+from typing import List
+
+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 BookmarkSharedViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertBookmarkCount(self, html: str, bookmark: Bookmark, count: int, link_target: str = '_blank'):
+        self.assertInHTML(
+            f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
+            html, count=count
+        )
+
+    def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
+        html = response.content.decode()
+        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+
+        for bookmark in bookmarks:
+            self.assertBookmarkCount(html, bookmark, 1, link_target)
+
+    def assertInvisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
+        html = response.content.decode()
+
+        for bookmark in bookmarks:
+            self.assertBookmarkCount(html, bookmark, 0, link_target)
+
+    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 assertVisibleUserOptions(self, response, users: List[User]):
+        html = response.content.decode()
+        self.assertContains(response, 'data-is-user-option', count=len(users))
+
+        for user in users:
+            self.assertInHTML(f'''
+              <option value="{user.username}" data-is-user-option>
+                {user.username}
+              </option>        
+            ''', html)
+
+    def assertInvisibleUserOptions(self, response, users: List[User]):
+        html = response.content.decode()
+
+        for user in users:
+            self.assertInHTML(f'''
+              <option value="{user.username}" data-is-user-option>
+                {user.username}
+              </option>        
+            ''', html, count=0)
+
+    def test_should_list_shared_bookmarks_from_all_users_that_have_sharing_enabled(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        user4 = self.setup_user(enable_sharing=False)
+
+        visible_bookmarks = [
+            self.setup_bookmark(shared=True, user=user1),
+            self.setup_bookmark(shared=True, user=user2),
+            self.setup_bookmark(shared=True, user=user3),
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(shared=False, user=user1),
+            self.setup_bookmark(shared=False, user=user2),
+            self.setup_bookmark(shared=False, user=user3),
+            self.setup_bookmark(shared=True, user=user4),
+        ]
+
+        response = self.client.get(reverse('bookmarks:shared'))
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_shared_bookmarks_from_selected_user(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+
+        visible_bookmarks = [
+            self.setup_bookmark(shared=True, user=user1),
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(shared=True, user=user2),
+            self.setup_bookmark(shared=True, user=user3),
+        ]
+
+        url = reverse('bookmarks:shared') + '?user=' + user1.username
+        response = self.client.get(url)
+
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_bookmarks_matching_query(self):
+        user = self.setup_user(enable_sharing=True)
+        visible_bookmarks = [
+            self.setup_bookmark(shared=True, title='searchvalue', user=user),
+            self.setup_bookmark(shared=True, title='searchvalue', user=user),
+            self.setup_bookmark(shared=True, title='searchvalue', user=user)
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(shared=True, user=user),
+            self.setup_bookmark(shared=True, user=user),
+            self.setup_bookmark(shared=True, user=user)
+        ]
+
+        response = self.client.get(reverse('bookmarks:shared') + '?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_shared_bookmarks_from_all_users_that_have_sharing_enabled(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        user4 = self.setup_user(enable_sharing=False)
+        visible_tags = [
+            self.setup_tag(user=user1),
+            self.setup_tag(user=user2),
+            self.setup_tag(user=user3),
+        ]
+        invisible_tags = [
+            self.setup_tag(user=user1),
+            self.setup_tag(user=user2),
+            self.setup_tag(user=user3),
+            self.setup_tag(user=user4),
+        ]
+
+        self.setup_bookmark(shared=True, user=user1, tags=[visible_tags[0]])
+        self.setup_bookmark(shared=True, user=user2, tags=[visible_tags[1]])
+        self.setup_bookmark(shared=True, user=user3, tags=[visible_tags[2]])
+
+        self.setup_bookmark(shared=False, user=user1, tags=[invisible_tags[0]])
+        self.setup_bookmark(shared=False, user=user2, tags=[invisible_tags[1]])
+        self.setup_bookmark(shared=False, user=user3, tags=[invisible_tags[2]])
+        self.setup_bookmark(shared=True, user=user4, tags=[invisible_tags[3]])
+
+        response = self.client.get(reverse('bookmarks:shared'))
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_tags_for_shared_bookmarks_from_selected_user(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        visible_tags = [
+            self.setup_tag(user=user1),
+        ]
+        invisible_tags = [
+            self.setup_tag(user=user2),
+            self.setup_tag(user=user3),
+        ]
+
+        self.setup_bookmark(shared=True, user=user1, tags=[visible_tags[0]])
+        self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[0]])
+        self.setup_bookmark(shared=True, user=user3, tags=[invisible_tags[1]])
+
+        url = reverse('bookmarks:shared') + '?user=' + user1.username
+        response = self.client.get(url)
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_tags_for_bookmarks_matching_query(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        visible_tags = [
+            self.setup_tag(user=user1),
+            self.setup_tag(user=user2),
+            self.setup_tag(user=user3),
+        ]
+        invisible_tags = [
+            self.setup_tag(user=user1),
+            self.setup_tag(user=user2),
+            self.setup_tag(user=user3),
+        ]
+
+        self.setup_bookmark(shared=True, user=user1, title='searchvalue', tags=[visible_tags[0]])
+        self.setup_bookmark(shared=True, user=user2, title='searchvalue', tags=[visible_tags[1]])
+        self.setup_bookmark(shared=True, user=user3, title='searchvalue', tags=[visible_tags[2]])
+
+        self.setup_bookmark(shared=True, user=user1, tags=[invisible_tags[0]])
+        self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[1]])
+        self.setup_bookmark(shared=True, user=user3, tags=[invisible_tags[2]])
+
+        response = self.client.get(reverse('bookmarks:shared') + '?q=searchvalue')
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_users_with_shared_bookmarks_if_sharing_is_enabled(self):
+        expected_visible_users = [
+            self.setup_user(enable_sharing=True),
+            self.setup_user(enable_sharing=True),
+        ]
+        self.setup_bookmark(shared=True, user=expected_visible_users[0])
+        self.setup_bookmark(shared=True, user=expected_visible_users[1])
+
+        expected_invisible_users = [
+            self.setup_user(enable_sharing=True),
+            self.setup_user(enable_sharing=False),
+        ]
+        self.setup_bookmark(shared=False, user=expected_invisible_users[0])
+        self.setup_bookmark(shared=True, user=expected_invisible_users[1])
+
+        response = self.client.get(reverse('bookmarks:shared'))
+        self.assertVisibleUserOptions(response, expected_visible_users)
+        self.assertInvisibleUserOptions(response, expected_invisible_users)
+
+
+def test_should_open_bookmarks_in_new_page_by_default(self):
+    visible_bookmarks = [
+        self.setup_bookmark(shared=True),
+        self.setup_bookmark(shared=True),
+        self.setup_bookmark(shared=True)
+    ]
+
+    response = self.client.get(reverse('bookmarks:shared'))
+
+    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(shared=True),
+        self.setup_bookmark(shared=True),
+        self.setup_bookmark(shared=True)
+    ]
+
+    response = self.client.get(reverse('bookmarks:shared'))
+
+    self.assertVisibleBookmarks(response, visible_bookmarks, '_self')

bookmarks/tests/test_bookmark_shared_view_performance.py

@@ -0,0 +1,44 @@
+from django.contrib.auth.models import User
+from django.test import TransactionTestCase
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkSharedViewPerformanceTestCase(TransactionTestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_should_not_increase_number_of_queries_per_bookmark(self):
+        # create initial users and bookmarks
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            user = self.setup_user(enable_sharing=True)
+            self.setup_bookmark(user=user, shared=True)
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            response = self.client.get(reverse('bookmarks:shared'))
+            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks)
+
+        number_of_queries = context.final_queries
+
+        # add more users and bookmarks
+        num_additional_bookmarks = 10
+        for index in range(num_additional_bookmarks):
+            user = self.setup_user(enable_sharing=True)
+            self.setup_bookmark(user=user, shared=True)
+
+        # assert num queries doesn't increase
+        with self.assertNumQueries(number_of_queries):
+            response = self.client.get(reverse('bookmarks:shared'))
+            self.assertContains(response, 'data-is-bookmark-item', num_initial_bookmarks + num_additional_bookmarks)

bookmarks/tests/test_bookmarks_api.py

@@ -1,4 +1,6 @@
+import urllib.parse
 from collections import OrderedDict
+from unittest.mock import patch
 
 from django.contrib.auth.models import User
 from django.urls import reverse
@@ -6,6 +8,8 @@ from rest_framework import status
 from rest_framework.authtoken.models import Token
 
 from bookmarks.models import Bookmark
+from bookmarks.services import website_loader
+from bookmarks.services.website_loader import WebsiteMetadata
 from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
 
 
@@ -16,7 +20,7 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         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.bookmark1 = self.setup_bookmark(tags=[self.tag1, self.tag2], notes='Test notes')
         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])
@@ -32,8 +36,12 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
             expectation['url'] = bookmark.url
             expectation['title'] = bookmark.title
             expectation['description'] = bookmark.description
+            expectation['notes'] = bookmark.notes
             expectation['website_title'] = bookmark.website_title
             expectation['website_description'] = bookmark.website_description
+            expectation['is_archived'] = bookmark.is_archived
+            expectation['unread'] = bookmark.unread
+            expectation['shared'] = bookmark.shared
             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')
@@ -44,11 +52,93 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
 
         self.assertCountEqual(data_list, expectations)
 
+    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_list_shared_bookmarks(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        user4 = self.setup_user(enable_sharing=False)
+        shared_bookmarks = [
+            self.setup_bookmark(shared=True, user=user1),
+            self.setup_bookmark(shared=True, user=user2),
+            self.setup_bookmark(shared=True, user=user3),
+        ]
+        # Unshared bookmarks
+        self.setup_bookmark(shared=False, user=user1)
+        self.setup_bookmark(shared=False, user=user2)
+        self.setup_bookmark(shared=False, user=user3)
+        self.setup_bookmark(shared=True, user=user4)
+
+        response = self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], shared_bookmarks)
+
+    def test_list_shared_bookmarks_should_filter_by_query_and_user(self):
+        # Search by query
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        expected_bookmarks = [
+            self.setup_bookmark(title='searchvalue', shared=True, user=user1),
+            self.setup_bookmark(title='searchvalue', shared=True, user=user2),
+            self.setup_bookmark(title='searchvalue', shared=True, user=user3),
+        ]
+        self.setup_bookmark(shared=True, user=user1),
+        self.setup_bookmark(shared=True, user=user2),
+        self.setup_bookmark(shared=True, user=user3),
+
+        response = self.get(reverse('bookmarks:bookmark-shared') + '?q=searchvalue',
+                            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
+
+        # Search by user
+        user_search_user = self.setup_user(enable_sharing=True)
+        expected_bookmarks = [
+            self.setup_bookmark(shared=True, user=user_search_user),
+            self.setup_bookmark(shared=True, user=user_search_user),
+            self.setup_bookmark(shared=True, user=user_search_user),
+        ]
+        response = self.get(reverse('bookmarks:bookmark-shared') + '?user=' + user_search_user.username,
+                            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
+
+        # Search by query and user
+        combined_search_user = self.setup_user(enable_sharing=True)
+        expected_bookmarks = [
+            self.setup_bookmark(title='searchvalue', shared=True, user=combined_search_user),
+            self.setup_bookmark(title='searchvalue', shared=True, user=combined_search_user),
+            self.setup_bookmark(title='searchvalue', shared=True, user=combined_search_user),
+        ]
+        response = self.get(
+            reverse('bookmarks:bookmark-shared') + '?q=searchvalue&user=' + combined_search_user.username,
+            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
+
     def test_create_bookmark(self):
         data = {
             'url': 'https://example.com/',
             'title': 'Test title',
             'description': 'Test description',
+            'notes': 'Test notes',
+            'is_archived': False,
+            'unread': False,
+            'shared': False,
             'tag_names': ['tag1', 'tag2']
         }
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
@@ -56,6 +146,37 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, data['url'])
         self.assertEqual(bookmark.title, data['title'])
         self.assertEqual(bookmark.description, data['description'])
+        self.assertEqual(bookmark.notes, data['notes'])
+        self.assertFalse(bookmark.is_archived, data['is_archived'])
+        self.assertFalse(bookmark.unread, data['unread'])
+        self.assertFalse(bookmark.shared, data['shared'])
+        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_with_same_url_updates_existing_bookmark(self):
+        original_bookmark = self.setup_bookmark()
+        data = {
+            'url': original_bookmark.url,
+            'title': 'Updated title',
+            'description': 'Updated description',
+            'notes': 'Updated notes',
+            'unread': True,
+            'shared': True,
+            'is_archived': True,
+            '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.id, original_bookmark.id)
+        self.assertEqual(bookmark.url, data['url'])
+        self.assertEqual(bookmark.title, data['title'])
+        self.assertEqual(bookmark.description, data['description'])
+        self.assertEqual(bookmark.notes, data['notes'])
+        # Saving a duplicate bookmark should not modify archive flag - right?
+        self.assertFalse(bookmark.is_archived)
+        self.assertEqual(bookmark.unread, data['unread'])
+        self.assertEqual(bookmark.shared, data['shared'])
         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)
@@ -76,21 +197,53 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         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_create_archived_bookmark(self):
+        data = {
+            'url': 'https://example.com/',
+            'title': 'Test title',
+            'description': 'Test description',
+            'is_archived': True,
+            '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.assertTrue(bookmark.is_archived)
+        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_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_create_bookmark_is_not_archived_by_default(self):
+        data = {'url': 'https://example.com/'}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertFalse(bookmark.is_archived)
 
-    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_create_unread_bookmark(self):
+        data = {'url': 'https://example.com/', 'unread': True}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertTrue(bookmark.unread)
 
-    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_create_bookmark_is_not_unread_by_default(self):
+        data = {'url': 'https://example.com/'}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertFalse(bookmark.unread)
+
+    def test_create_shared_bookmark(self):
+        data = {'url': 'https://example.com/', 'shared': True}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertTrue(bookmark.shared)
+
+    def test_create_bookmark_is_not_shared_by_default(self):
+        data = {'url': 'https://example.com/'}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertFalse(bookmark.shared)
 
     def test_get_bookmark(self):
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
@@ -104,6 +257,101 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
         self.assertEqual(updated_bookmark.url, data['url'])
 
+    def test_update_bookmark_fails_without_required_fields(self):
+        data = {'title': 'https://example.com/'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.put(url, data, expected_status_code=status.HTTP_400_BAD_REQUEST)
+
+    def test_update_bookmark_with_minimal_payload_clears_all_fields(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'])
+        self.assertEqual(updated_bookmark.title, '')
+        self.assertEqual(updated_bookmark.description, '')
+        self.assertEqual(updated_bookmark.notes, '')
+        self.assertEqual(updated_bookmark.tag_names, [])
+
+    def test_update_bookmark_unread_flag(self):
+        data = {'url': 'https://example.com/', 'unread': True}
+        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.unread, True)
+
+    def test_update_bookmark_shared_flag(self):
+        data = {'url': 'https://example.com/', 'shared': True}
+        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.shared, True)
+
+    def test_patch_bookmark(self):
+        data = {'url': 'https://example.com'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertEqual(self.bookmark1.url, data['url'])
+
+        data = {'title': 'Updated title'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertEqual(self.bookmark1.title, data['title'])
+
+        data = {'description': 'Updated description'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertEqual(self.bookmark1.description, data['description'])
+
+        data = {'notes': 'Updated notes'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertEqual(self.bookmark1.notes, data['notes'])
+
+        data = {'unread': True}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertTrue(self.bookmark1.unread)
+
+        data = {'unread': False}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertFalse(self.bookmark1.unread)
+
+        data = {'shared': True}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertTrue(self.bookmark1.shared)
+
+        data = {'shared': False}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertFalse(self.bookmark1.shared)
+
+        data = {'tag_names': ['updated-tag-1', 'updated-tag-2']}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        tag_names = [tag.name for tag in self.bookmark1.tags.all()]
+        self.assertListEqual(tag_names, ['updated-tag-1', 'updated-tag-2'])
+
+    def test_patch_with_empty_payload_does_not_modify_bookmark(self):
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, {}, expected_status_code=status.HTTP_200_OK)
+        updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
+        self.assertEqual(updated_bookmark.url, self.bookmark1.url)
+        self.assertEqual(updated_bookmark.title, self.bookmark1.title)
+        self.assertEqual(updated_bookmark.description, self.bookmark1.description)
+        self.assertListEqual(updated_bookmark.tag_names, self.bookmark1.tag_names)
+
     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)
@@ -121,9 +369,70 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         bookmark = Bookmark.objects.get(id=self.archived_bookmark1.id)
         self.assertFalse(bookmark.is_archived)
 
+    def test_check_returns_no_bookmark_if_url_is_not_bookmarked(self):
+        url = reverse('bookmarks:bookmark-check')
+        check_url = urllib.parse.quote_plus('https://example.com')
+        response = self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)
+        bookmark_data = response.data['bookmark']
+
+        self.assertIsNone(bookmark_data)
+
+    def test_check_returns_scraped_metadata_if_url_is_not_bookmarked(self):
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            expected_metadata = WebsiteMetadata(
+                'https://example.com',
+                'Scraped metadata',
+                'Scraped description'
+            )
+            mock_load_website_metadata.return_value = expected_metadata
+
+            url = reverse('bookmarks:bookmark-check')
+            check_url = urllib.parse.quote_plus('https://example.com')
+            response = self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)
+            metadata = response.data['metadata']
+
+            self.assertIsNotNone(metadata)
+            self.assertIsNotNone(expected_metadata.url, metadata['url'])
+            self.assertIsNotNone(expected_metadata.title, metadata['title'])
+            self.assertIsNotNone(expected_metadata.description, metadata['description'])
+
+    def test_check_returns_bookmark_if_url_is_bookmarked(self):
+        bookmark = self.setup_bookmark(url='https://example.com',
+                                       title='Example title',
+                                       description='Example description')
+
+        url = reverse('bookmarks:bookmark-check')
+        check_url = urllib.parse.quote_plus('https://example.com')
+        response = self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)
+        bookmark_data = response.data['bookmark']
+
+        self.assertIsNotNone(bookmark_data)
+        self.assertEqual(bookmark.id, bookmark_data['id'])
+        self.assertEqual(bookmark.url, bookmark_data['url'])
+        self.assertEqual(bookmark.title, bookmark_data['title'])
+        self.assertEqual(bookmark.description, bookmark_data['description'])
+
+    def test_check_returns_existing_metadata_if_url_is_bookmarked(self):
+        bookmark = self.setup_bookmark(url='https://example.com',
+                                       website_title='Existing title',
+                                       website_description='Existing description')
+
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            url = reverse('bookmarks:bookmark-check')
+            check_url = urllib.parse.quote_plus('https://example.com')
+            response = self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)
+            metadata = response.data['metadata']
+
+            mock_load_website_metadata.assert_not_called()
+            self.assertIsNotNone(metadata)
+            self.assertIsNotNone(bookmark.url, metadata['url'])
+            self.assertIsNotNone(bookmark.website_title, metadata['title'])
+            self.assertIsNotNone(bookmark.website_description, metadata['description'])
+
     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)
+        inaccessible_shared_bookmark = self.setup_bookmark(user=other_user, shared=True)
         self.setup_bookmark(user=other_user, is_archived=True)
 
         url = reverse('bookmarks:bookmark-list')
@@ -137,14 +446,34 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         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_shared_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_shared_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-detail', args=[inaccessible_shared_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-archive', args=[inaccessible_shared_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)
+
+        url = reverse('bookmarks:bookmark-unarchive', args=[inaccessible_shared_bookmark.id])
+        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
+        url = reverse('bookmarks:bookmark-check')
+        check_url = urllib.parse.quote_plus(inaccessible_bookmark.url)
+        response = self.get(f'{url}?url={check_url}', expected_status_code=status.HTTP_200_OK)
+        self.assertIsNone(response.data['bookmark'])

bookmarks/tests/test_bookmarks_api_performance.py

@@ -0,0 +1,64 @@
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.authtoken.models import Token
+
+from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
+
+
+class BookmarksApiPerformanceTestCase(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)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_list_bookmarks_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)
+
+    def test_list_archived_bookmarks_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)
+
+    def test_list_shared_bookmarks_max_queries(self):
+        # set up some bookmarks with associated tags
+        share_user = self.setup_user(enable_sharing=True)
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(user=share_user, shared=True, tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)

bookmarks/tests/test_bookmarks_list_tag.py

@@ -2,43 +2,137 @@ 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.urls import reverse
 from django.utils import timezone, formats
 
-from bookmarks.models import Bookmark, UserProfile
+from bookmarks.models import Bookmark, UserProfile, User
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 
 class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
 
-    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank'):
+    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank', unread: bool = False):
         self.assertInHTML(
-            f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
+            f'''
+            <a href="{bookmark.url}" 
+                target="{link_target}" 
+                rel="noopener" 
+                class="{'text-italic' if unread else ''}">{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>
             <span>{label_content}</span>
         </span>
-        <span class="text-gray text-sm">|</span>
+        <span class="separator">|</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">
+        <span>
             <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>
+        <span class="separator">|</span>
         ''', html)
 
-    def render_template(self, bookmarks: [Bookmark], template: Template) -> str:
+    def assertBookmarkActions(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkActionsCount(html, bookmark, count=1)
+
+    def assertNoBookmarkActions(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkActionsCount(html, bookmark, count=0)
+
+    def assertBookmarkActionsCount(self, html: str, bookmark: Bookmark, count=1):
+        # Edit link
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url=/test">Edit</a>
+        ''', html, count=count)
+        # Archive link
+        self.assertInHTML(f'''
+            <button type="submit" name="archive" value="{bookmark.id}"
+               class="btn btn-link btn-sm">Archive</button>
+        ''', html, count=count)
+        # Delete link
+        self.assertInHTML(f'''
+            <button type="submit" name="remove" value="{bookmark.id}"
+               class="btn btn-link btn-sm btn-confirmation">Remove</button>
+        ''', html, count=count)
+
+    def assertShareInfo(self, html: str, bookmark: Bookmark):
+        self.assertShareInfoCount(html, bookmark, 1)
+
+    def assertNoShareInfo(self, html: str, bookmark: Bookmark):
+        self.assertShareInfoCount(html, bookmark, 0)
+
+    def assertShareInfoCount(self, html: str, bookmark: Bookmark, count=1):
+        self.assertInHTML(f'''
+            <span>Shared by 
+                <a href="?user={bookmark.owner.username}">{bookmark.owner.username}</a>
+            </span>
+        ''', html, count=count)
+
+    def assertFaviconVisible(self, html: str, bookmark: Bookmark):
+        self.assertFaviconCount(html, bookmark, 1)
+
+    def assertFaviconHidden(self, html: str, bookmark: Bookmark):
+        self.assertFaviconCount(html, bookmark, 0)
+
+    def assertFaviconCount(self, html: str, bookmark: Bookmark, count=1):
+        self.assertInHTML(f'''
+            <img src="/static/{bookmark.favicon_file}" alt="">
+            ''', html, count=count)
+
+    def assertBookmarkURLCount(self, html: str, bookmark: Bookmark, link_target: str = '_blank', count=0):
+        self.assertInHTML(f'''
+        <div class="url-path truncate">
+          <a href="{bookmark.url}" target="{link_target}" rel="noopener" 
+          class="url-display text-sm">
+            {bookmark.url}
+          </a>
+        </div>
+        ''', html, count)
+
+    def assertBookmarkURLVisible(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkURLCount(html, bookmark, count=1)
+
+    def assertBookmarkURLHidden(self, html: str, bookmark: Bookmark, link_target: str = '_blank'):
+        self.assertBookmarkURLCount(html, bookmark, count=0)
+
+    def assertNotes(self, html: str, notes_html: str, count=1):
+        self.assertInHTML(f'''
+        <div class="notes bg-gray text-gray-dark">
+          <div class="notes-content">
+            {notes_html}
+          </div>
+        </div>
+        ''', html, count=count)
+
+    def assertNotesToggle(self, html: str, count=1):
+        self.assertInHTML(f'''
+          <button class="btn btn-link btn-sm toggle-notes" title="Toggle notes">
+            <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-notes" width="16" height="16"
+                 viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round"
+                 stroke-linejoin="round">
+              <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
+              <path d="M5 3m0 2a2 2 0 0 1 2 -2h10a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-10a2 2 0 0 1 -2 -2z"></path>
+              <path d="M9 7l6 0"></path>
+              <path d="M9 11l6 0"></path>
+              <path d="M9 15l4 0"></path>
+            </svg>
+            <span>Notes</span>
+          </button>        
+          ''', html, count=count)
+
+    def render_template(self, bookmarks: [Bookmark], template: Template, url: str = '/test') -> str:
         rf = RequestFactory()
-        request = rf.get('/test')
+        request = rf.get(url)
         request.user = self.get_or_create_test_user()
         paginator = Paginator(bookmarks, 10)
         page = paginator.page(1)
@@ -46,12 +140,12 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
         context = RequestContext(request, {'bookmarks': page, 'return_url': '/test'})
         return template.render(context)
 
-    def render_default_template(self, bookmarks: [Bookmark]) -> str:
+    def render_default_template(self, bookmarks: [Bookmark], url: str = '/test') -> str:
         template = Template(
             '{% load bookmarks %}'
             '{% bookmark_list bookmarks return_url %}'
         )
-        return self.render_template(bookmarks, template)
+        return self.render_template(bookmarks, template, url)
 
     def render_template_with_link_target(self, bookmarks: [Bookmark], link_target: str) -> str:
         template = Template(
@@ -114,6 +208,15 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
 
         self.assertBookmarksLink(html, bookmark, link_target='_self')
 
+    def test_bookmark_link_target_should_respect_unread_flag(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_template_with_link_target([bookmark], '_self')
+        self.assertBookmarksLink(html, bookmark, link_target='_self', unread=False)
+
+        bookmark = self.setup_bookmark(unread=True)
+        html = self.render_template_with_link_target([bookmark], '_self')
+        self.assertBookmarksLink(html, bookmark, link_target='_self', unread=True)
+
     def test_web_archive_link_target_should_be_blank_by_default(self):
         bookmark = self.setup_bookmark()
         bookmark.date_added = timezone.now() - relativedelta(days=8)
@@ -133,3 +236,169 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
         html = self.render_template_with_link_target([bookmark], '_self')
 
         self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_self')
+
+    def test_show_bookmark_actions_for_owned_bookmarks(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_default_template([bookmark])
+
+        self.assertBookmarkActions(html, bookmark)
+        self.assertNoShareInfo(html, bookmark)
+
+    def test_show_share_info_for_non_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark = self.setup_bookmark(user=other_user)
+        html = self.render_default_template([bookmark])
+
+        self.assertNoBookmarkActions(html, bookmark)
+        self.assertShareInfo(html, bookmark)
+
+    def test_share_info_user_link_keeps_query_params(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark = self.setup_bookmark(user=other_user)
+        html = self.render_default_template([bookmark], url='/test?q=foo')
+
+        self.assertInHTML(f'''
+            <span>Shared by 
+                <a href="?q=foo&user={bookmark.owner.username}">{bookmark.owner.username}</a>
+            </span>
+        ''', html)
+
+    def test_favicon_should_be_visible_when_favicons_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_favicons = True
+        profile.save()
+
+        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
+        html = self.render_default_template([bookmark])
+
+        self.assertFaviconVisible(html, bookmark)
+
+    def test_favicon_should_be_hidden_when_there_is_no_icon(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_favicons = True
+        profile.save()
+
+        bookmark = self.setup_bookmark(favicon_file='')
+        html = self.render_default_template([bookmark])
+
+        self.assertFaviconHidden(html, bookmark)
+
+    def test_favicon_should_be_hidden_when_favicons_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.enable_favicons = False
+        profile.save()
+
+        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
+        html = self.render_default_template([bookmark])
+
+        self.assertFaviconHidden(html, bookmark)
+
+    def test_bookmark_url_should_be_hidden_by_default(self):
+        profile = self.get_or_create_test_user().profile
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_default_template([bookmark])
+
+        self.assertBookmarkURLHidden(html, bookmark)
+
+    def test_show_bookmark_url_when_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.display_url = True
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_default_template([bookmark])
+
+        self.assertBookmarkURLVisible(html, bookmark)
+
+    def test_hide_bookmark_url_when_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.display_url = False
+        profile.save()
+
+        bookmark = self.setup_bookmark()
+        html = self.render_default_template([bookmark])
+
+        self.assertBookmarkURLHidden(html, bookmark)
+
+    def test_without_notes(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_default_template([bookmark])
+
+        self.assertNotes(html, '', 0)
+        self.assertNotesToggle(html, 0)
+
+    def test_with_notes(self):
+        bookmark = self.setup_bookmark(notes='Test note')
+        html = self.render_default_template([bookmark])
+
+        note_html = '<p>Test note</p>'
+        self.assertNotes(html, note_html, 1)
+
+    def test_note_renders_markdown(self):
+        bookmark = self.setup_bookmark(notes='**Example:** `print("Hello world!")`')
+        html = self.render_default_template([bookmark])
+
+        note_html = '<p><strong>Example:</strong> <code>print("Hello world!")</code></p>'
+        self.assertNotes(html, note_html, 1)
+
+    def test_note_cleans_html(self):
+        bookmark = self.setup_bookmark(notes='<script>alert("test")</script>')
+        html = self.render_default_template([bookmark])
+
+        note_html = '&lt;script&gt;alert("test")&lt;/script&gt;'
+        self.assertNotes(html, note_html, 1)
+
+    def test_notes_are_hidden_initially_by_default(self):
+        html = self.render_default_template([])
+
+        self.assertInHTML("""
+        <ul class="bookmark-list"></ul>
+        """, html)
+
+    def test_notes_are_hidden_initially_with_permanent_notes_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = False
+        profile.save()
+        html = self.render_default_template([])
+
+        self.assertInHTML("""
+        <ul class="bookmark-list"></ul>
+        """, html)
+
+    def test_notes_are_visible_initially_with_permanent_notes_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = True
+        profile.save()
+        html = self.render_default_template([])
+
+        self.assertInHTML("""
+        <ul class="bookmark-list show-notes"></ul>
+        """, html)
+
+    def test_toggle_notes_is_visible_by_default(self):
+        bookmark = self.setup_bookmark(notes='Test note')
+        html = self.render_default_template([bookmark])
+
+        self.assertNotesToggle(html, 1)
+
+    def test_toggle_notes_is_visible_with_permanent_notes_disabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = False
+        profile.save()
+
+        bookmark = self.setup_bookmark(notes='Test note')
+        html = self.render_default_template([bookmark])
+
+        self.assertNotesToggle(html, 1)
+
+    def test_toggle_notes_is_hidden_with_permanent_notes_enabled(self):
+        profile = self.get_or_create_test_user().profile
+        profile.permanent_notes = True
+        profile.save()
+
+        bookmark = self.setup_bookmark(notes='Test note')
+        html = self.render_default_template([bookmark])
+
+        self.assertNotesToggle(html, 0)

bookmarks/tests/test_bookmarks_service.py

@@ -5,10 +5,12 @@ from django.test import TestCase
 from django.utils import timezone
 
 from bookmarks.models import Bookmark, Tag
+from bookmarks.services import tasks
+from bookmarks.services import website_loader
 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.services.website_loader import WebsiteMetadata
 from bookmarks.tests.helpers import BookmarkFactoryMixin
-from bookmarks.services import tasks
 
 User = get_user_model()
 
@@ -18,6 +20,48 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
     def setUp(self) -> None:
         self.get_or_create_test_user()
 
+    def test_create_should_update_website_metadata(self):
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            expected_metadata = WebsiteMetadata(
+                'https://example.com',
+                'Website title',
+                'Website description'
+            )
+            mock_load_website_metadata.return_value = expected_metadata
+
+            bookmark_data = Bookmark(url='https://example.com',
+                                     title='Updated Title',
+                                     description='Updated description',
+                                     unread=True,
+                                     shared=True,
+                                     is_archived=True)
+            created_bookmark = create_bookmark(bookmark_data, '', self.get_or_create_test_user())
+
+            created_bookmark.refresh_from_db()
+            self.assertEqual(expected_metadata.title, created_bookmark.website_title)
+            self.assertEqual(expected_metadata.description, created_bookmark.website_description)
+
+    def test_create_should_update_existing_bookmark_with_same_url(self):
+        original_bookmark = self.setup_bookmark(url='https://example.com', unread=False, shared=False)
+        bookmark_data = Bookmark(url='https://example.com',
+                                 title='Updated Title',
+                                 description='Updated description',
+                                 notes='Updated notes',
+                                 unread=True,
+                                 shared=True,
+                                 is_archived=True)
+        updated_bookmark = create_bookmark(bookmark_data, '', self.get_or_create_test_user())
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+        self.assertEqual(updated_bookmark.id, original_bookmark.id)
+        self.assertEqual(updated_bookmark.title, bookmark_data.title)
+        self.assertEqual(updated_bookmark.description, bookmark_data.description)
+        self.assertEqual(updated_bookmark.notes, bookmark_data.notes)
+        self.assertEqual(updated_bookmark.unread, bookmark_data.unread)
+        self.assertEqual(updated_bookmark.shared, bookmark_data.shared)
+        # Saving a duplicate bookmark should not modify archive flag - right?
+        self.assertFalse(updated_bookmark.is_archived)
+
     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')
@@ -25,6 +69,13 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
 
             mock_create_web_archive_snapshot.assert_called_once_with(self.user, bookmark, False)
 
+    def test_create_should_load_favicon(self):
+        with patch.object(tasks, 'load_favicon') as mock_load_favicon:
+            bookmark_data = Bookmark(url='https://example.com')
+            bookmark = create_bookmark(bookmark_data, 'tag1,tag2', self.user)
+
+            mock_load_favicon.assert_called_once_with(self.user, bookmark)
+
     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()
@@ -41,6 +92,40 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
 
             mock_create_web_archive_snapshot.assert_not_called()
 
+    def test_update_should_update_website_metadata_if_url_did_change(self):
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            expected_metadata = WebsiteMetadata(
+                'https://example.com/updated',
+                'Updated website title',
+                'Updated website description'
+            )
+            mock_load_website_metadata.return_value = expected_metadata
+
+            bookmark = self.setup_bookmark()
+            bookmark.url = 'https://example.com/updated'
+            update_bookmark(bookmark, 'tag1,tag2', self.user)
+
+            bookmark.refresh_from_db()
+            mock_load_website_metadata.assert_called_once()
+            self.assertEqual(expected_metadata.title, bookmark.website_title)
+            self.assertEqual(expected_metadata.description, bookmark.website_description)
+
+    def test_update_should_not_update_website_metadata_if_url_did_not_change(self):
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            bookmark = self.setup_bookmark()
+            bookmark.title = 'updated title'
+            update_bookmark(bookmark, 'tag1,tag2', self.user)
+
+            mock_load_website_metadata.assert_not_called()
+
+    def test_update_should_update_favicon(self):
+        with patch.object(tasks, 'load_favicon') as mock_load_favicon:
+            bookmark = self.setup_bookmark()
+            bookmark.title = 'updated title'
+            update_bookmark(bookmark, 'tag1,tag2', self.user)
+
+            mock_load_favicon.assert_called_once_with(self.user, bookmark)
+
     def test_archive_bookmark(self):
         bookmark = Bookmark(
             url='https://example.com',

bookmarks/tests/test_bookmarks_tasks.py

@@ -1,27 +1,49 @@
-from unittest.mock import patch
+import datetime
+from dataclasses import dataclass
+from typing import Any
+from unittest import mock
 
 import waybackpy
 from background_task.models import Task
 from django.contrib.auth.models import User
 from django.test import TestCase, override_settings
+from waybackpy.exceptions import WaybackError
 
-from bookmarks.models import Bookmark, UserProfile
+import bookmarks.services.favicon_loader
+import bookmarks.services.wayback
+from bookmarks.models import UserProfile
 from bookmarks.services import tasks
 from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
 
 
-class MockWaybackUrl:
+def create_wayback_machine_save_api_mock(archive_url: str = 'https://example.com/created_snapshot',
+                                         fail_on_save: bool = False):
+    mock_api = mock.Mock(archive_url=archive_url)
 
-    def __init__(self, archive_url: str):
-        self.archive_url = archive_url
+    if fail_on_save:
+        mock_api.save.side_effect = WaybackError
 
-    def save(self):
-        return self
+    return mock_api
 
 
-class MockWaybackUrlWithSaveError:
-    def save(self):
-        raise NotImplementedError
+@dataclass
+class MockCdxSnapshot:
+    archive_url: str
+    datetime_timestamp: datetime.datetime
+
+
+def create_cdx_server_api_mock(archive_url: str | None = 'https://example.com/newest_snapshot',
+                               fail_loading_snapshot=False):
+    mock_api = mock.Mock()
+
+    if fail_loading_snapshot:
+        mock_api.newest.side_effect = WaybackError
+    elif archive_url:
+        mock_api.newest.return_value = MockCdxSnapshot(archive_url, datetime.datetime.now())
+    else:
+        mock_api.newest.return_value = None
+
+    return mock_api
 
 
 class BookmarkTasksTestCase(TestCase, BookmarkFactoryMixin):
@@ -29,72 +51,212 @@ 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.enable_favicons = True
         user.profile.save()
 
     @disable_logging
-    def run_pending_task(self, task_function):
+    def run_pending_task(self, task_function: Any):
         func = getattr(task_function, 'task_function', None)
         task = Task.objects.all()[0]
+        self.assertEqual(task_function.name, task.task_name)
         args, kwargs = task.params()
         func(*args, **kwargs)
         task.delete()
 
     @disable_logging
-    def run_all_pending_tasks(self, task_function):
+    def run_all_pending_tasks(self, task_function: Any):
         func = getattr(task_function, 'task_function', None)
         tasks = Task.objects.all()
 
         for task in tasks:
+            self.assertEqual(task_function.name, task.task_name)
             args, kwargs = task.params()
             func(*args, **kwargs)
             task.delete()
 
     def test_create_web_archive_snapshot_should_update_snapshot_url(self):
         bookmark = self.setup_bookmark()
+        mock_save_api = create_wayback_machine_save_api_mock()
 
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://example.com')):
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
             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')
+            mock_save_api.save.assert_called_once()
+            self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com/created_snapshot')
 
     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:
+        mock_save_api = create_wayback_machine_save_api_mock()
+
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
             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)
+            mock_save_api.save.assert_not_called()
 
     def test_create_web_archive_snapshot_should_skip_if_snapshot_exists(self):
         bookmark = self.setup_bookmark(web_archive_snapshot_url='https://example.com')
+        mock_save_api = create_wayback_machine_save_api_mock()
 
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://other.com')):
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
             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')
+            mock_save_api.assert_not_called()
 
     def test_create_web_archive_snapshot_should_force_update_snapshot(self):
         bookmark = self.setup_bookmark(web_archive_snapshot_url='https://example.com')
+        mock_save_api = create_wayback_machine_save_api_mock(archive_url='https://other.com')
 
-        with patch.object(waybackpy, 'Url', return_value=MockWaybackUrl('https://other.com')):
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
             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')
 
+    def test_create_web_archive_snapshot_should_use_newest_snapshot_as_fallback(self):
+        bookmark = self.setup_bookmark()
+        mock_save_api = create_wayback_machine_save_api_mock(fail_on_save=True)
+        mock_cdx_api = create_cdx_server_api_mock()
+
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
+            with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                                   return_value=mock_cdx_api):
+                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()
+                mock_cdx_api.newest.assert_called_once()
+                self.assertEqual('https://example.com/newest_snapshot', bookmark.web_archive_snapshot_url)
+
+    def test_create_web_archive_snapshot_should_ignore_missing_newest_snapshot(self):
+        bookmark = self.setup_bookmark()
+        mock_save_api = create_wayback_machine_save_api_mock(fail_on_save=True)
+        mock_cdx_api = create_cdx_server_api_mock(archive_url=None)
+
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
+            with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                                   return_value=mock_cdx_api):
+                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)
+
+    def test_create_web_archive_snapshot_should_ignore_newest_snapshot_errors(self):
+        bookmark = self.setup_bookmark()
+        mock_save_api = create_wayback_machine_save_api_mock(fail_on_save=True)
+        mock_cdx_api = create_cdx_server_api_mock(fail_loading_snapshot=True)
+
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
+            with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                                   return_value=mock_cdx_api):
+                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)
+
+    def test_create_web_archive_snapshot_should_not_save_stale_bookmark_data(self):
+        bookmark = self.setup_bookmark()
+        mock_save_api = create_wayback_machine_save_api_mock()
+
+        # update bookmark during API call to check that saving
+        # the snapshot does not overwrite updated bookmark data
+        def mock_save_impl():
+            bookmark.title = 'Updated title'
+            bookmark.save()
+
+        mock_save_api.save.side_effect = mock_save_impl
+
+        with mock.patch.object(waybackpy, 'WaybackMachineSaveAPI', return_value=mock_save_api):
+            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.title, 'Updated title')
+            self.assertEqual('https://example.com/created_snapshot', bookmark.web_archive_snapshot_url)
+
+    def test_load_web_archive_snapshot_should_update_snapshot_url(self):
+        bookmark = self.setup_bookmark()
+        mock_cdx_api = create_cdx_server_api_mock()
+
+        with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                               return_value=mock_cdx_api):
+            tasks._load_web_archive_snapshot_task(bookmark.id)
+            self.run_pending_task(tasks._load_web_archive_snapshot_task)
+
+            bookmark.refresh_from_db()
+            mock_cdx_api.newest.assert_called_once()
+            self.assertEqual('https://example.com/newest_snapshot', bookmark.web_archive_snapshot_url)
+
+    def test_load_web_archive_snapshot_should_handle_missing_bookmark_id(self):
+        mock_cdx_api = create_cdx_server_api_mock()
+
+        with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                               return_value=mock_cdx_api):
+            tasks._load_web_archive_snapshot_task(123)
+            self.run_pending_task(tasks._load_web_archive_snapshot_task)
+
+            mock_cdx_api.newest.assert_not_called()
+
+    def test_load_web_archive_snapshot_should_skip_if_snapshot_exists(self):
+        bookmark = self.setup_bookmark(web_archive_snapshot_url='https://example.com')
+        mock_cdx_api = create_cdx_server_api_mock()
+
+        with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                               return_value=mock_cdx_api):
+            tasks._load_web_archive_snapshot_task(bookmark.id)
+            self.run_pending_task(tasks._load_web_archive_snapshot_task)
+
+            mock_cdx_api.newest.assert_not_called()
+
+    def test_load_web_archive_snapshot_should_handle_missing_snapshot(self):
+        bookmark = self.setup_bookmark()
+        mock_cdx_api = create_cdx_server_api_mock(archive_url=None)
+
+        with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                               return_value=mock_cdx_api):
+            tasks._load_web_archive_snapshot_task(bookmark.id)
+            self.run_pending_task(tasks._load_web_archive_snapshot_task)
+
+            self.assertEqual('', bookmark.web_archive_snapshot_url)
+
+    def test_load_web_archive_snapshot_should_handle_wayback_errors(self):
+        bookmark = self.setup_bookmark()
+        mock_cdx_api = create_cdx_server_api_mock(fail_loading_snapshot=True)
+
+        with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                               return_value=mock_cdx_api):
+            tasks._load_web_archive_snapshot_task(bookmark.id)
+            self.run_pending_task(tasks._load_web_archive_snapshot_task)
+
+            self.assertEqual('', bookmark.web_archive_snapshot_url)
+
+    def test_load_web_archive_snapshot_should_not_save_stale_bookmark_data(self):
+        bookmark = self.setup_bookmark()
+        mock_cdx_api = create_cdx_server_api_mock()
+
+        # update bookmark during API call to check that saving
+        # the snapshot does not overwrite updated bookmark data
+        def mock_newest_impl():
+            bookmark.title = 'Updated title'
+            bookmark.save()
+            return mock.DEFAULT
+
+        mock_cdx_api.newest.side_effect = mock_newest_impl
+
+        with mock.patch.object(bookmarks.services.wayback, 'CustomWaybackMachineCDXServerAPI',
+                               return_value=mock_cdx_api):
+            tasks._load_web_archive_snapshot_task(bookmark.id)
+            self.run_pending_task(tasks._load_web_archive_snapshot_task)
+            bookmark.refresh_from_db()
+
+            self.assertEqual('Updated title', bookmark.title)
+            self.assertEqual('https://example.com/newest_snapshot', bookmark.web_archive_snapshot_url)
+
     @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()
@@ -111,33 +273,23 @@ class BookmarkTasksTestCase(TestCase, BookmarkFactoryMixin):
 
         self.assertEqual(Task.objects.count(), 0)
 
-    def test_schedule_bookmarks_without_snapshots_should_create_snapshot_task_for_all_bookmarks_without_snapshot(self):
+    def test_schedule_bookmarks_without_snapshots_should_load_snapshot_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)
+        tasks.schedule_bookmarks_without_snapshots(user)
+        self.run_pending_task(tasks._schedule_bookmarks_without_snapshots_task)
 
-            for bookmark in Bookmark.objects.all():
-                self.assertEqual(bookmark.web_archive_snapshot_url, 'https://example.com')
+        task_list = Task.objects.all()
+        self.assertEqual(task_list.count(), 3)
+
+        for task in task_list:
+            self.assertEqual(task.task_name, 'bookmarks.services.tasks._load_web_archive_snapshot_task')
 
     def test_schedule_bookmarks_without_snapshots_should_only_update_user_owned_bookmarks(self):
         user = self.get_or_create_test_user()
@@ -149,16 +301,11 @@ class BookmarkTasksTestCase(TestCase, BookmarkFactoryMixin):
         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)
+        tasks.schedule_bookmarks_without_snapshots(user)
+        self.run_pending_task(tasks._schedule_bookmarks_without_snapshots_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, '')
+        task_list = Task.objects.all()
+        self.assertEqual(task_list.count(), 3)
 
     @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
     def test_schedule_bookmarks_without_snapshots_should_not_run_when_background_tasks_are_disabled(self):
@@ -172,3 +319,177 @@ class BookmarkTasksTestCase(TestCase, BookmarkFactoryMixin):
         tasks.schedule_bookmarks_without_snapshots(self.user)
 
         self.assertEqual(Task.objects.count(), 0)
+
+    def test_load_favicon_should_create_favicon_file(self):
+        bookmark = self.setup_bookmark()
+
+        with mock.patch('bookmarks.services.favicon_loader.load_favicon') as mock_load_favicon:
+            mock_load_favicon.return_value = 'https_example_com.png'
+
+            tasks.load_favicon(self.get_or_create_test_user(), bookmark)
+            self.run_pending_task(tasks._load_favicon_task)
+            bookmark.refresh_from_db()
+
+            self.assertEqual(bookmark.favicon_file, 'https_example_com.png')
+
+    def test_load_favicon_should_update_favicon_file(self):
+        bookmark = self.setup_bookmark(favicon_file='https_example_com.png')
+
+        with mock.patch('bookmarks.services.favicon_loader.load_favicon') as mock_load_favicon:
+            mock_load_favicon.return_value = 'https_example_updated_com.png'
+            tasks.load_favicon(self.get_or_create_test_user(), bookmark)
+            self.run_pending_task(tasks._load_favicon_task)
+
+            mock_load_favicon.assert_called()
+            bookmark.refresh_from_db()
+            self.assertEqual(bookmark.favicon_file, 'https_example_updated_com.png')
+
+    def test_load_favicon_should_handle_missing_bookmark(self):
+        with mock.patch('bookmarks.services.favicon_loader.load_favicon') as mock_load_favicon:
+            tasks._load_favicon_task(123)
+            self.run_pending_task(tasks._load_favicon_task)
+
+            mock_load_favicon.assert_not_called()
+
+    def test_load_favicon_should_not_save_stale_bookmark_data(self):
+        bookmark = self.setup_bookmark()
+
+        # update bookmark during API call to check that saving
+        # the favicon does not overwrite updated bookmark data
+        def mock_load_favicon_impl(url):
+            bookmark.title = 'Updated title'
+            bookmark.save()
+            return 'https_example_com.png'
+
+        with mock.patch('bookmarks.services.favicon_loader.load_favicon') as mock_load_favicon:
+            mock_load_favicon.side_effect = mock_load_favicon_impl
+
+            tasks.load_favicon(self.get_or_create_test_user(), bookmark)
+            self.run_pending_task(tasks._load_favicon_task)
+            bookmark.refresh_from_db()
+
+            self.assertEqual(bookmark.title, 'Updated title')
+            self.assertEqual(bookmark.favicon_file, 'https_example_com.png')
+
+    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
+    def test_load_favicon_should_not_run_when_background_tasks_are_disabled(self):
+        bookmark = self.setup_bookmark()
+        tasks.load_favicon(self.get_or_create_test_user(), bookmark)
+
+        self.assertEqual(Task.objects.count(), 0)
+
+    def test_load_favicon_should_not_run_when_favicon_feature_is_disabled(self):
+        self.user.profile.enable_favicons = False
+        self.user.profile.save()
+
+        bookmark = self.setup_bookmark()
+        tasks.load_favicon(self.get_or_create_test_user(), bookmark)
+
+        self.assertEqual(Task.objects.count(), 0)
+
+    def test_schedule_bookmarks_without_favicons_should_load_favicon_for_all_bookmarks_without_favicon(self):
+        user = self.get_or_create_test_user()
+        self.setup_bookmark()
+        self.setup_bookmark()
+        self.setup_bookmark()
+        self.setup_bookmark(favicon_file='https_example_com.png')
+        self.setup_bookmark(favicon_file='https_example_com.png')
+        self.setup_bookmark(favicon_file='https_example_com.png')
+
+        tasks.schedule_bookmarks_without_favicons(user)
+        self.run_pending_task(tasks._schedule_bookmarks_without_favicons_task)
+
+        task_list = Task.objects.all()
+        self.assertEqual(task_list.count(), 3)
+
+        for task in task_list:
+            self.assertEqual(task.task_name, 'bookmarks.services.tasks._load_favicon_task')
+
+    def test_schedule_bookmarks_without_favicons_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)
+
+        tasks.schedule_bookmarks_without_favicons(user)
+        self.run_pending_task(tasks._schedule_bookmarks_without_favicons_task)
+
+        task_list = Task.objects.all()
+        self.assertEqual(task_list.count(), 3)
+
+    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
+    def test_schedule_bookmarks_without_favicons_should_not_run_when_background_tasks_are_disabled(self):
+        bookmark = self.setup_bookmark()
+        tasks.schedule_bookmarks_without_favicons(self.get_or_create_test_user())
+
+        self.assertEqual(Task.objects.count(), 0)
+
+    def test_schedule_bookmarks_without_favicons_should_not_run_when_favicon_feature_is_disabled(self):
+        self.user.profile.enable_favicons = False
+        self.user.profile.save()
+
+        bookmark = self.setup_bookmark()
+        tasks.schedule_bookmarks_without_favicons(self.get_or_create_test_user())
+
+        self.assertEqual(Task.objects.count(), 0)
+
+    def test_schedule_refresh_favicons_should_update_favicon_for_all_bookmarks(self):
+        user = self.get_or_create_test_user()
+        self.setup_bookmark()
+        self.setup_bookmark()
+        self.setup_bookmark()
+        self.setup_bookmark(favicon_file='https_example_com.png')
+        self.setup_bookmark(favicon_file='https_example_com.png')
+        self.setup_bookmark(favicon_file='https_example_com.png')
+
+        tasks.schedule_refresh_favicons(user)
+        self.run_pending_task(tasks._schedule_refresh_favicons_task)
+
+        task_list = Task.objects.all()
+        self.assertEqual(task_list.count(), 6)
+
+        for task in task_list:
+            self.assertEqual(task.task_name, 'bookmarks.services.tasks._load_favicon_task')
+
+    def test_schedule_refresh_favicons_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)
+
+        tasks.schedule_refresh_favicons(user)
+        self.run_pending_task(tasks._schedule_refresh_favicons_task)
+
+        task_list = Task.objects.all()
+        self.assertEqual(task_list.count(), 3)
+
+    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
+    def test_schedule_refresh_favicons_should_not_run_when_background_tasks_are_disabled(self):
+        self.setup_bookmark()
+        tasks.schedule_refresh_favicons(self.get_or_create_test_user())
+
+        self.assertEqual(Task.objects.count(), 0)
+
+    @override_settings(LD_ENABLE_REFRESH_FAVICONS=False)
+    def test_schedule_refresh_favicons_should_not_run_when_refresh_is_disabled(self):
+        self.setup_bookmark()
+        tasks.schedule_refresh_favicons(self.get_or_create_test_user())
+
+        self.assertEqual(Task.objects.count(), 0)
+
+    def test_schedule_refresh_favicons_should_not_run_when_favicon_feature_is_disabled(self):
+        self.user.profile.enable_favicons = False
+        self.user.profile.save()
+
+        self.setup_bookmark()
+        tasks.schedule_refresh_favicons(self.get_or_create_test_user())
+
+        self.assertEqual(Task.objects.count(), 0)

bookmarks/tests/test_context_path.py

@@ -0,0 +1,53 @@
+import importlib
+
+from django.test import TestCase, override_settings
+from django.urls import reverse
+
+
+class MockUrlConf:
+    def __init__(self, module):
+        self.urlpatterns = module.urlpatterns
+
+
+class ContextPathTestCase(TestCase):
+
+    def setUp(self):
+        self.siteroot_urls = importlib.import_module('siteroot.urls')
+
+    @override_settings(LD_CONTEXT_PATH=None)
+    def tearDown(self):
+        importlib.reload(self.siteroot_urls)
+
+    @override_settings(LD_CONTEXT_PATH='linkding/')
+    def test_route_with_context_path(self):
+        module = importlib.reload(self.siteroot_urls)
+        # pass mock config instead of actual module to prevent caching the
+        # url config in django.urls.reverse
+        urlconf = MockUrlConf(module)
+        test_cases = [
+            ('bookmarks:index', '/linkding/bookmarks'),
+            ('bookmarks:bookmark-list', '/linkding/api/bookmarks/'),
+            ('login', '/linkding/login/'),
+            ('admin:bookmarks_bookmark_changelist', '/linkding/admin/bookmarks/bookmark/'),
+        ]
+
+        for url_name, expected_url in test_cases:
+            url = reverse(url_name, urlconf=urlconf)
+            self.assertEqual(expected_url, url)
+
+    @override_settings(LD_CONTEXT_PATH='')
+    def test_route_without_context_path(self):
+        module = importlib.reload(self.siteroot_urls)
+        # pass mock config instead of actual module to prevent caching the
+        # url config in django.urls.reverse
+        urlconf = MockUrlConf(module)
+        test_cases = [
+            ('bookmarks:index', '/bookmarks'),
+            ('bookmarks:bookmark-list', '/api/bookmarks/'),
+            ('login', '/login/'),
+            ('admin:bookmarks_bookmark_changelist', '/admin/bookmarks/bookmark/'),
+        ]
+
+        for url_name, expected_url in test_cases:
+            url = reverse(url_name, urlconf=urlconf)
+            self.assertEqual(expected_url, url)

bookmarks/tests/test_create_initial_superuser_command.py

@@ -0,0 +1,45 @@
+import os
+from unittest import mock
+
+from django.test import TestCase
+
+from bookmarks.models import User
+from bookmarks.management.commands.create_initial_superuser import Command
+
+
+class TestCreateInitialSuperuserCommand(TestCase):
+
+    @mock.patch.dict(os.environ, {'LD_SUPERUSER_NAME': 'john', 'LD_SUPERUSER_PASSWORD': 'password123'})
+    def test_create_with_password(self):
+        Command().handle()
+
+        self.assertEqual(1, User.objects.count())
+
+        user = User.objects.first()
+        self.assertEqual('john', user.username)
+        self.assertTrue(user.has_usable_password())
+        self.assertTrue(user.check_password('password123'))
+
+    @mock.patch.dict(os.environ, {'LD_SUPERUSER_NAME': 'john'})
+    def test_create_without_password(self):
+        Command().handle()
+
+        self.assertEqual(1, User.objects.count())
+
+        user = User.objects.first()
+        self.assertEqual('john', user.username)
+        self.assertFalse(user.has_usable_password())
+
+    def test_create_without_options(self):
+        Command().handle()
+
+        self.assertEqual(0, User.objects.count())
+
+    @mock.patch.dict(os.environ, {'LD_SUPERUSER_NAME': 'john', 'LD_SUPERUSER_PASSWORD': 'password123'})
+    def test_create_multiple_times(self):
+        Command().handle()
+        Command().handle()
+        Command().handle()
+
+        self.assertEqual(1, User.objects.count())
+

bookmarks/tests/test_exporter.py

@@ -0,0 +1,28 @@
+from django.test import TestCase
+
+from bookmarks.services import exporter
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class ExporterTestCase(TestCase, BookmarkFactoryMixin):
+    def test_escape_html_in_title_and_description(self):
+        bookmark = self.setup_bookmark(
+            title='<style>: The Style Information element',
+            description='The <style> HTML element contains style information for a document, or part of a document.'
+        )
+        html = exporter.export_netscape_html([bookmark])
+
+        self.assertIn('&lt;style&gt;: The Style Information element', html)
+        self.assertIn(
+            'The &lt;style&gt; HTML element contains style information for a document, or part of a document.',
+            html
+        )
+
+    def test_handle_empty_values(self):
+        bookmark = self.setup_bookmark()
+        bookmark.title = ''
+        bookmark.description = ''
+        bookmark.website_title = None
+        bookmark.website_description = None
+        bookmark.save()
+        exporter.export_netscape_html([bookmark])

bookmarks/tests/test_exporter_performance.py

@@ -0,0 +1,32 @@
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+from django.test import TestCase
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class ExporterPerformanceTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_export_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.client.get(reverse('bookmarks:settings.export'),follow=True)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)

bookmarks/tests/test_favicon_loader.py

@@ -0,0 +1,127 @@
+import io
+import os.path
+import time
+from pathlib import Path
+from unittest import mock
+
+from django.conf import settings
+from django.test import TestCase
+
+from bookmarks.services import favicon_loader
+
+mock_icon_data = b'mock_icon'
+
+
+class FaviconLoaderTestCase(TestCase):
+    def setUp(self) -> None:
+        self.ensure_favicon_folder()
+        self.clear_favicon_folder()
+
+    def create_mock_response(self, icon_data=mock_icon_data):
+        mock_response = mock.Mock()
+        mock_response.raw = io.BytesIO(icon_data)
+        return mock_response
+
+    def ensure_favicon_folder(self):
+        Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)
+
+    def clear_favicon_folder(self):
+        folder = Path(settings.LD_FAVICON_FOLDER)
+        for file in folder.iterdir():
+            file.unlink()
+
+    def get_icon_path(self, filename):
+        return Path(os.path.join(settings.LD_FAVICON_FOLDER, filename))
+
+    def icon_exists(self, filename):
+        return self.get_icon_path(filename).exists()
+
+    def get_icon_data(self, filename):
+        return self.get_icon_path(filename).read_bytes()
+
+    def count_icons(self):
+        files = os.listdir(settings.LD_FAVICON_FOLDER)
+        return len(files)
+
+    def test_load_favicon(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+            favicon_loader.load_favicon('https://example.com')
+
+            # should create icon file
+            self.assertTrue(self.icon_exists('https_example_com.png'))
+
+            # should store image data
+            self.assertEqual(mock_icon_data, self.get_icon_data('https_example_com.png'))
+
+    def test_load_favicon_creates_folder_if_not_exists(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+
+            folder = Path(settings.LD_FAVICON_FOLDER)
+            folder.rmdir()
+
+            self.assertFalse(folder.exists())
+
+            favicon_loader.load_favicon('https://example.com')
+
+            self.assertTrue(folder.exists())
+
+    def test_load_favicon_creates_single_icon_for_same_base_url(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+            favicon_loader.load_favicon('https://example.com')
+            favicon_loader.load_favicon('https://example.com?foo=bar')
+            favicon_loader.load_favicon('https://example.com/foo')
+
+            self.assertEqual(1, self.count_icons())
+            self.assertTrue(self.icon_exists('https_example_com.png'))
+
+    def test_load_favicon_creates_multiple_icons_for_different_base_url(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+            favicon_loader.load_favicon('https://example.com')
+            favicon_loader.load_favicon('https://sub.example.com')
+            favicon_loader.load_favicon('https://other-domain.com')
+
+            self.assertEqual(3, self.count_icons())
+            self.assertTrue(self.icon_exists('https_example_com.png'))
+            self.assertTrue(self.icon_exists('https_sub_example_com.png'))
+            self.assertTrue(self.icon_exists('https_other_domain_com.png'))
+
+    def test_load_favicon_caches_icons(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+
+            favicon_loader.load_favicon('https://example.com')
+            mock_get.assert_called()
+
+            mock_get.reset_mock()
+            favicon_loader.load_favicon('https://example.com')
+            mock_get.assert_not_called()
+
+    def test_load_favicon_updates_stale_icon(self):
+        with mock.patch('requests.get') as mock_get:
+            mock_get.return_value = self.create_mock_response()
+            favicon_loader.load_favicon('https://example.com')
+
+            icon_path = self.get_icon_path('https_example_com.png')
+
+            updated_mock_icon_data = b'updated_mock_icon'
+            mock_get.return_value = self.create_mock_response(icon_data=updated_mock_icon_data)
+            mock_get.reset_mock()
+
+            # change icon modification date so it is not stale yet
+            nearly_one_day_ago = time.time() - 60 * 60 * 23
+            os.utime(icon_path.absolute(), (nearly_one_day_ago, nearly_one_day_ago))
+
+            favicon_loader.load_favicon('https://example.com')
+            mock_get.assert_not_called()
+
+            # change icon modification date so it is considered stale
+            one_day_ago = time.time() - 60 * 60 * 24
+            os.utime(icon_path.absolute(), (one_day_ago, one_day_ago))
+
+            favicon_loader.load_favicon('https://example.com')
+            mock_get.assert_called()
+            self.assertEqual(updated_mock_icon_data, self.get_icon_data('https_example_com.png'))